fix: set prefix __ instead of _ for private methods

gotrue/_async/api.py

@@ -336,7 +336,7 @@ async def reset_password_for_email(
         response = await self.http_client.post(url, json=data, headers=headers)
         return parse_response(response, lambda _: None)
 
-    def _create_request_headers(self, *, jwt: str) -> dict[str, str]:
+    def __create_request_headers(self, *, jwt: str) -> dict[str, str]:
         """Create temporary object.
 
         Create a temporary object with all configured headers and adds the
@@ -365,7 +365,7 @@ async def sign_out(self, *, jwt: str) -> None:
         jwt : str
             A valid, logged-in JWT.
         """
-        headers = self._create_request_headers(jwt=jwt)
+        headers = self.__create_request_headers(jwt=jwt)
         url = f"{self.url}/logout"
         await self.http_client.post(url, headers=headers)
 
@@ -423,7 +423,7 @@ async def get_user(self, *, jwt: str) -> User:
         error : APIError
             If an error occurs
         """
-        headers = self._create_request_headers(jwt=jwt)
+        headers = self.__create_request_headers(jwt=jwt)
         url = f"{self.url}/user"
         response = await self.http_client.get(url, headers=headers)
         return parse_response(response, User.from_dict)
@@ -454,7 +454,7 @@ async def update_user(
         error : APIError
             If an error occurs
         """
-        headers = self._create_request_headers(jwt=jwt)
+        headers = self.__create_request_headers(jwt=jwt)
         data = attributes.to_dict()
         url = f"{self.url}/user"
         response = await self.http_client.put(url, json=data, headers=headers)
@@ -483,7 +483,7 @@ async def delete_user(self, *, uid: str, jwt: str) -> User:
         error : APIError
             If an error occurs
         """
-        headers = self._create_request_headers(jwt=jwt)
+        headers = self.__create_request_headers(jwt=jwt)
         url = f"{self.url}/admin/users/${uid}"
         response = await self.http_client.delete(url, headers=headers)
         return parse_response(response, User.from_dict)

gotrue/_async/client.py

@@ -80,8 +80,8 @@ async def close(self) -> None:
 
     async def init_recover(self) -> None:
         """Recover the current session from local storage."""
-        await self._recover_session()
-        await self._recover_and_refresh()
+        await self.__recover_session()
+        await self.__recover_and_refresh()
 
     async def sign_up(
         self,
@@ -118,7 +118,7 @@ async def sign_up(
         error : APIError
             If an error occurs
         """
-        await self._remove_session()
+        await self.__remove_session()
 
         if email and password:
             response = await self.api.sign_up_with_email(
@@ -139,8 +139,8 @@ async def sign_up(
         if isinstance(response, Session):
             # The user has confirmed their email or the underlying DB doesn't
             # require email confirmation.
-            await self._save_session(session=response)
-            self._notify_all_subscribers(event=AuthChangeEvent.SIGNED_IN)
+            await self.__save_session(session=response)
+            self.__notify_all_subscribers(event=AuthChangeEvent.SIGNED_IN)
         return response
 
     async def sign_in(
@@ -197,26 +197,26 @@ async def sign_in(
         error : APIError
             If an error occurs
         """
-        await self._remove_session()
+        await self.__remove_session()
         if email and not password:
             response = await self.api.send_magic_link_email(email=email)
         elif email and password:
-            response = await self._handle_email_sign_in(
+            response = await self.__handle_email_sign_in(
                 email=email,
                 password=password,
                 redirect_to=redirect_to,
             )
         elif phone and not password:
             response = await self.api.send_mobile_otp(phone=phone)
         elif phone and password:
-            response = await self._handle_phone_sign_in(phone=phone, password=password)
+            response = await self.__handle_phone_sign_in(phone=phone, password=password)
         elif refresh_token:
             # current_session and current_user will be updated to latest
             # on _call_refresh_token using the passed refresh_token
-            await self._call_refresh_token(refresh_token=refresh_token)
+            await self.__call_refresh_token(refresh_token=refresh_token)
             response = self.current_session
         elif provider:
-            response = await self._handle_provider_sign_in(
+            response = await self.__handle_provider_sign_in(
                 provider=provider,
                 redirect_to=redirect_to,
                 scopes=scopes,
@@ -257,15 +257,15 @@ async def verify_otp(
         error : APIError
             If an error occurs
         """
-        await self._remove_session()
+        await self.__remove_session()
         response = await self.api.verify_mobile_otp(
             phone=phone,
             token=token,
             redirect_to=redirect_to,
         )
         if isinstance(response, Session):
-            await self._save_session(session=response)
-            self._notify_all_subscribers(event=AuthChangeEvent.SIGNED_IN)
+            await self.__save_session(session=response)
+            self.__notify_all_subscribers(event=AuthChangeEvent.SIGNED_IN)
         return response
 
     def user(self) -> Optional[User]:
@@ -284,7 +284,7 @@ async def refresh_session(self) -> Session:
         """
         if not self.current_session:
             raise ValueError("Not logged in.")
-        response = await self._call_refresh_token()
+        response = await self.__call_refresh_token()
         return response
 
     async def update(self, *, attributes: UserAttributes) -> User:
@@ -312,8 +312,8 @@ async def update(self, *, attributes: UserAttributes) -> User:
             attributes=attributes,
         )
         self.current_session.user = response
-        await self._save_session(session=self.current_session)
-        self._notify_all_subscribers(event=AuthChangeEvent.USER_UPDATED)
+        await self.__save_session(session=self.current_session)
+        self.__notify_all_subscribers(event=AuthChangeEvent.USER_UPDATED)
         return response
 
     async def set_session(self, *, refresh_token: str) -> Session:
@@ -335,8 +335,8 @@ async def set_session(self, *, refresh_token: str) -> Session:
             If an error occurs
         """
         response = await self.api.refresh_access_token(refresh_token=refresh_token)
-        await self._save_session(session=response)
-        self._notify_all_subscribers(event=AuthChangeEvent.SIGNED_IN)
+        await self.__save_session(session=response)
+        self.__notify_all_subscribers(event=AuthChangeEvent.SIGNED_IN)
         return response
 
     async def set_auth(self, *, access_token: str) -> Session:
@@ -372,7 +372,7 @@ async def set_auth(self, *, access_token: str) -> Session:
             session.expires_at = self.current_session.expires_at
             session.refresh_token = self.current_session.refresh_token
             session.provider_token = self.current_session.provider_token
-        await self._save_session(session=session)
+        await self.__save_session(session=session)
         return session
 
     async def get_session_from_url(
@@ -430,23 +430,23 @@ async def get_session_from_url(
             provider_token=provider_token[0] if provider_token else None,
         )
         if store_session:
-            await self._save_session(session=session)
-            self._notify_all_subscribers(event=AuthChangeEvent.SIGNED_IN)
+            await self.__save_session(session=session)
+            self.__notify_all_subscribers(event=AuthChangeEvent.SIGNED_IN)
             if query.get("type") == "recovery":
-                self._notify_all_subscribers(event=AuthChangeEvent.PASSWORD_RECOVERY)
+                self.__notify_all_subscribers(event=AuthChangeEvent.PASSWORD_RECOVERY)
         return session
 
     async def sign_out(self) -> None:
         """Log the user out."""
         access_token: Optional[str] = None
         if self.current_session:
             access_token = self.current_session.access_token
-        await self._remove_session()
-        self._notify_all_subscribers(event=AuthChangeEvent.SIGNED_OUT)
+        await self.__remove_session()
+        self.__notify_all_subscribers(event=AuthChangeEvent.SIGNED_OUT)
         if access_token:
             await self.api.sign_out(jwt=access_token)
 
-    def _unsubscribe(self, *, id: str) -> None:
+    def __unsubscribe(self, *, id: str) -> None:
         """Unsubscribe from a subscription."""
         self.state_change_emitters.pop(id)
 
@@ -476,12 +476,12 @@ def on_auth_state_change(
         subscription = Subscription(
             id=unique_id,
             callback=callback,
-            unsubscribe=partial(self._unsubscribe, id=unique_id),
+            unsubscribe=partial(self.__unsubscribe, id=unique_id),
         )
         self.state_change_emitters[unique_id] = subscription
         return subscription
 
-    async def _handle_email_sign_in(
+    async def __handle_email_sign_in(
         self,
         *,
         email: str,
@@ -494,18 +494,18 @@ async def _handle_email_sign_in(
             password=password,
             redirect_to=redirect_to,
         )
-        await self._save_session(session=response)
-        self._notify_all_subscribers(event=AuthChangeEvent.SIGNED_IN)
+        await self.__save_session(session=response)
+        self.__notify_all_subscribers(event=AuthChangeEvent.SIGNED_IN)
         return response
 
-    async def _handle_phone_sign_in(self, *, phone: str, password: str) -> Session:
+    async def __handle_phone_sign_in(self, *, phone: str, password: str) -> Session:
         """Sign in with phone and password."""
         response = await self.api.sign_in_with_phone(phone=phone, password=password)
-        await self._save_session(session=response)
-        self._notify_all_subscribers(event=AuthChangeEvent.SIGNED_IN)
+        await self.__save_session(session=response)
+        self.__notify_all_subscribers(event=AuthChangeEvent.SIGNED_IN)
         return response
 
-    async def _handle_provider_sign_in(
+    async def __handle_provider_sign_in(
         self,
         *,
         provider: Provider,
@@ -520,7 +520,7 @@ async def _handle_provider_sign_in(
         )
         return response
 
-    async def _recover_session(self) -> None:
+    async def __recover_session(self) -> None:
         """Attempts to get the session from LocalStorage"""
         json = await self.local_storage.get_item(STORAGE_KEY)
         if not json:
@@ -538,10 +538,10 @@ async def _recover_session(self) -> None:
             session = Session.from_dict(session_raw)
             time_now = round(time())
             if expires_at >= time_now:
-                await self._save_session(session=session)
-                self._notify_all_subscribers(event=AuthChangeEvent.SIGNED_IN)
+                await self.__save_session(session=session)
+                self.__notify_all_subscribers(event=AuthChangeEvent.SIGNED_IN)
 
-    async def _recover_and_refresh(self) -> None:
+    async def __recover_and_refresh(self) -> None:
         """Recovers the session from LocalStorage and refreshes"""
         json = await self.local_storage.get_item(STORAGE_KEY)
         if not json:
@@ -561,20 +561,20 @@ async def _recover_and_refresh(self) -> None:
             if expires_at < time_now:
                 if self.auto_refresh_token and session.refresh_token:
                     try:
-                        await self._call_refresh_token(
+                        await self.__call_refresh_token(
                             refresh_token=session.refresh_token
                         )
                     except APIError:
-                        await self._remove_session()
+                        await self.__remove_session()
                 else:
-                    await self._remove_session()
+                    await self.__remove_session()
             elif not session or not session.user:
-                await self._remove_session()
+                await self.__remove_session()
             else:
-                await self._save_session(session=session)
-                self._notify_all_subscribers(event=AuthChangeEvent.SIGNED_IN)
+                await self.__save_session(session=session)
+                self.__notify_all_subscribers(event=AuthChangeEvent.SIGNED_IN)
 
-    async def _call_refresh_token(
+    async def __call_refresh_token(
         self, *, refresh_token: Optional[str] = None
     ) -> Session:
         if refresh_token is None:
@@ -585,45 +585,45 @@ async def _call_refresh_token(
         response = await self.api.refresh_access_token(
             refresh_token=cast(str, refresh_token)
         )
-        await self._save_session(session=response)
-        self._notify_all_subscribers(event=AuthChangeEvent.SIGNED_IN)
+        await self.__save_session(session=response)
+        self.__notify_all_subscribers(event=AuthChangeEvent.SIGNED_IN)
         return response
 
-    def _notify_all_subscribers(self, *, event: AuthChangeEvent) -> None:
+    def __notify_all_subscribers(self, *, event: AuthChangeEvent) -> None:
         """Notify all subscribers that auth event happened."""
         for value in self.state_change_emitters.values():
             value.callback(event, self.current_session)
 
-    async def _save_session(self, *, session: Session) -> None:
+    async def __save_session(self, *, session: Session) -> None:
         """Save session to client."""
         self.current_session = session
         self.current_user = session.user
         if session.expires_at:
             time_now = round(time())
             expire_in = session.expires_at - time_now
             refresh_duration_before_expires = 60 if expire_in > 60 else 0.5
-            self._start_auto_refresh_token(
+            self.__start_auto_refresh_token(
                 value=(expire_in - refresh_duration_before_expires) * 1000
             )
         if self.persist_session and session.expires_at:
-            await self._persist_session(session=session)
+            await self.__persist_session(session=session)
 
-    async def _persist_session(self, *, session: Session) -> None:
+    async def __persist_session(self, *, session: Session) -> None:
         data = {"session": session.to_dict(), "expires_at": session.expires_at}
         await self.local_storage.set_item(STORAGE_KEY, dumps(data))
 
-    async def _remove_session(self) -> None:
+    async def __remove_session(self) -> None:
         """Remove the session."""
         self.current_session = None
         self.current_user = None
         if self.refresh_token_timer:
             self.refresh_token_timer.cancel()
         await self.local_storage.remove_item(STORAGE_KEY)
 
-    def _start_auto_refresh_token(self, *, value: float) -> None:
+    def __start_auto_refresh_token(self, *, value: float) -> None:
         if self.refresh_token_timer:
             self.refresh_token_timer.cancel()
         if value <= 0 or not self.auto_refresh_token:
             return
-        self.refresh_token_timer = Timer(value, self._call_refresh_token)
+        self.refresh_token_timer = Timer(value, self.__call_refresh_token)
         self.refresh_token_timer.start()

gotrue/_sync/api.py

@@ -336,7 +336,7 @@ def reset_password_for_email(
         response = self.http_client.post(url, json=data, headers=headers)
         return parse_response(response, lambda _: None)
 
-    def _create_request_headers(self, *, jwt: str) -> dict[str, str]:
+    def __create_request_headers(self, *, jwt: str) -> dict[str, str]:
         """Create temporary object.
 
         Create a temporary object with all configured headers and adds the
@@ -365,7 +365,7 @@ def sign_out(self, *, jwt: str) -> None:
         jwt : str
             A valid, logged-in JWT.
         """
-        headers = self._create_request_headers(jwt=jwt)
+        headers = self.__create_request_headers(jwt=jwt)
         url = f"{self.url}/logout"
         self.http_client.post(url, headers=headers)
 
@@ -423,7 +423,7 @@ def get_user(self, *, jwt: str) -> User:
         error : APIError
             If an error occurs
         """
-        headers = self._create_request_headers(jwt=jwt)
+        headers = self.__create_request_headers(jwt=jwt)
         url = f"{self.url}/user"
         response = self.http_client.get(url, headers=headers)
         return parse_response(response, User.from_dict)
@@ -454,7 +454,7 @@ def update_user(
         error : APIError
             If an error occurs
         """
-        headers = self._create_request_headers(jwt=jwt)
+        headers = self.__create_request_headers(jwt=jwt)
         data = attributes.to_dict()
         url = f"{self.url}/user"
         response = self.http_client.put(url, json=data, headers=headers)
@@ -483,7 +483,7 @@ def delete_user(self, *, uid: str, jwt: str) -> User:
         error : APIError
             If an error occurs
         """
-        headers = self._create_request_headers(jwt=jwt)
+        headers = self.__create_request_headers(jwt=jwt)
         url = f"{self.url}/admin/users/${uid}"
         response = self.http_client.delete(url, headers=headers)
         return parse_response(response, User.from_dict)