chore: partial commit, more fixes

Author: o-santi

src/auth/src/supabase_auth/__init__.py

@@ -1,16 +1,16 @@
 from __future__ import annotations
 
-from ._async.gotrue_admin_api import AsyncGoTrueAdminAPI  # type: ignore # noqa: F401
-from ._async.gotrue_client import AsyncGoTrueClient  # type: ignore # noqa: F401
+from ._async.gotrue_admin_api import AsyncGoTrueAdminAPI
+from ._async.gotrue_client import AsyncGoTrueClient
 from ._async.storage import (
-    AsyncMemoryStorage,  # type: ignore # noqa: F401
-    AsyncSupportedStorage,  # type: ignore # noqa: F401
+    AsyncMemoryStorage,
+    AsyncSupportedStorage,
 )
-from ._sync.gotrue_admin_api import SyncGoTrueAdminAPI  # type: ignore # noqa: F401
-from ._sync.gotrue_client import SyncGoTrueClient  # type: ignore # noqa: F401
+from ._sync.gotrue_admin_api import SyncGoTrueAdminAPI
+from ._sync.gotrue_client import SyncGoTrueClient
 from ._sync.storage import (
-    SyncMemoryStorage,  # type: ignore # noqa: F401
-    SyncSupportedStorage,  # type: ignore # noqa: F401
+    SyncMemoryStorage,
+    SyncSupportedStorage,
 )
-from .types import *  # type: ignore # noqa: F401, F403
+from .types import *
 from .version import __version__

src/auth/src/supabase_auth/_async/gotrue_admin_api.py

@@ -1,7 +1,9 @@
 from __future__ import annotations
 
-from functools import partial
-from typing import Dict, List, Optional
+from typing import Any, Dict, List, Optional
+
+from httpx import Response
+from pydantic import TypeAdapter
 
 from ..helpers import (
     is_valid_uuid,
@@ -26,6 +28,8 @@
 from .gotrue_admin_mfa_api import AsyncGoTrueAdminMFAAPI
 from .gotrue_base_api import AsyncGoTrueBaseAPI
 
+UserList = TypeAdapter(List[User])
+
 
 class AsyncGoTrueAdminAPI(AsyncGoTrueBaseAPI):
     def __init__(
@@ -45,15 +49,16 @@ def __init__(
             verify=verify,
             proxy=proxy,
         )
+        # TODO(@o-santi): why is is this done this way?
         self.mfa = AsyncGoTrueAdminMFAAPI()
-        self.mfa.list_factors = self._list_factors
-        self.mfa.delete_factor = self._delete_factor
+        self.mfa.list_factors = self._list_factors  # type: ignore
+        self.mfa.delete_factor = self._delete_factor  # type: ignore
 
     async def sign_out(self, jwt: str, scope: SignOutScope = "global") -> None:
         """
         Removes a logged-in session.
         """
-        return await self._request(
+        await self._request(
             "POST",
             "logout",
             query={"scope": scope},
@@ -69,19 +74,19 @@ async def invite_user_by_email(
         """
         Sends an invite link to an email address.
         """
-        return await self._request(
+        response = await self._request(
             "POST",
             "invite",
             body={"email": email, "data": options.get("data")},
             redirect_to=options.get("redirect_to"),
-            xform=parse_user_response,
         )
+        return parse_user_response(response)
 
     async def generate_link(self, params: GenerateLinkParams) -> GenerateLinkResponse:
         """
         Generates email links and OTPs to be sent via a custom email provider.
         """
-        return await self._request(
+        response = await self._request(
             "POST",
             "admin/generate_link",
             body={
@@ -92,8 +97,8 @@ async def generate_link(self, params: GenerateLinkParams) -> GenerateLinkRespons
                 "data": params.get("options", {}).get("data"),
             },
             redirect_to=params.get("options", {}).get("redirect_to"),
-            xform=parse_link_response,
         )
+        return parse_link_response(response)
 
     # User Admin API
 
@@ -104,30 +109,28 @@ async def create_user(self, attributes: AdminUserAttributes) -> UserResponse:
         This function should only be called on a server.
         Never expose your `service_role` key in the browser.
         """
-        return await self._request(
+        response = await self._request(
             "POST",
             "admin/users",
             body=attributes,
-            xform=parse_user_response,
         )
+        return parse_user_response(response)
 
-    async def list_users(self, page: int = None, per_page: int = None) -> List[User]:
+    async def list_users(
+        self, page: Optional[int] = None, per_page: Optional[int] = None
+    ) -> List[User]:
         """
         Get a list of users.
 
         This function should only be called on a server.
         Never expose your `service_role` key in the browser.
         """
-        return await self._request(
+        response = await self._request(
             "GET",
             "admin/users",
-            query={"page": page, "per_page": per_page},
-            xform=lambda data: (
-                [model_validate(User, user) for user in data["users"]]
-                if "users" in data
-                else []
-            ),
+            query={"page": str(page), "per_page": str(per_page)},
         )
+        return UserList.validate_json(response.content)
 
     async def get_user_by_id(self, uid: str) -> UserResponse:
         """
@@ -138,11 +141,11 @@ async def get_user_by_id(self, uid: str) -> UserResponse:
         """
         self._validate_uuid(uid)
 
-        return await self._request(
+        response = await self._request(
             "GET",
             f"admin/users/{uid}",
-            xform=parse_user_response,
         )
+        return parse_user_response(response)
 
     async def update_user_by_id(
         self,
@@ -156,12 +159,12 @@ async def update_user_by_id(
         Never expose your `service_role` key in the browser.
         """
         self._validate_uuid(uid)
-        return await self._request(
+        response = await self._request(
             "PUT",
             f"admin/users/{uid}",
             body=attributes,
-            xform=parse_user_response,
         )
+        return parse_user_response(response)
 
     async def delete_user(self, id: str, should_soft_delete: bool = False) -> None:
         """
@@ -172,31 +175,33 @@ async def delete_user(self, id: str, should_soft_delete: bool = False) -> None:
         """
         self._validate_uuid(id)
         body = {"should_soft_delete": should_soft_delete}
-        return await self._request("DELETE", f"admin/users/{id}", body=body)
+        await self._request("DELETE", f"admin/users/{id}", body=body)
 
     async def _list_factors(
         self,
         params: AuthMFAAdminListFactorsParams,
     ) -> AuthMFAAdminListFactorsResponse:
         self._validate_uuid(params.get("user_id"))
-        return await self._request(
+        response = await self._request(
             "GET",
             f"admin/users/{params.get('user_id')}/factors",
-            xform=partial(model_validate, AuthMFAAdminListFactorsResponse),
         )
+        return model_validate(AuthMFAAdminListFactorsResponse, response.content)
 
     async def _delete_factor(
         self,
         params: AuthMFAAdminDeleteFactorParams,
     ) -> AuthMFAAdminDeleteFactorResponse:
         self._validate_uuid(params.get("user_id"))
         self._validate_uuid(params.get("id"))
-        return await self._request(
+        response = await self._request(
             "DELETE",
             f"admin/users/{params.get('user_id')}/factors/{params.get('id')}",
-            xform=partial(model_validate, AuthMFAAdminDeleteFactorResponse),
         )
+        return model_validate(AuthMFAAdminDeleteFactorResponse, response.content)
 
-    def _validate_uuid(self, id: str) -> None:
+    def _validate_uuid(self, id: str | None) -> None:
+        if id is None:
+            raise ValueError("Invalid id, id cannot be none")
         if not is_valid_uuid(id):
             raise ValueError(f"Invalid id, '{id}' is not a valid uuid")

src/auth/src/supabase_auth/_async/gotrue_base_api.py

@@ -10,8 +10,6 @@
 from ..helpers import handle_exception, model_dump
 from ..http_clients import AsyncClient
 
-T = TypeVar("T")
-
 
 class AsyncGoTrueBaseAPI:
     def __init__(
@@ -41,50 +39,6 @@ async def __aexit__(self, exc_t, exc_v, exc_tb) -> None:
     async def close(self) -> None:
         await self._http_client.aclose()
 
-    @overload
-    async def _request(
-        self,
-        method: Literal["GET", "OPTIONS", "HEAD", "POST", "PUT", "PATCH", "DELETE"],
-        path: str,
-        *,
-        jwt: Optional[str] = None,
-        redirect_to: Optional[str] = None,
-        headers: Optional[Dict[str, str]] = None,
-        query: Optional[Dict[str, str]] = None,
-        body: Optional[Any] = None,
-        no_resolve_json: Literal[False] = False,
-        xform: Callable[[Any], T],
-    ) -> T: ...  # pragma: no cover
-
-    @overload
-    async def _request(
-        self,
-        method: Literal["GET", "OPTIONS", "HEAD", "POST", "PUT", "PATCH", "DELETE"],
-        path: str,
-        *,
-        jwt: Optional[str] = None,
-        redirect_to: Optional[str] = None,
-        headers: Optional[Dict[str, str]] = None,
-        query: Optional[Dict[str, str]] = None,
-        body: Optional[Any] = None,
-        no_resolve_json: Literal[True],
-        xform: Callable[[Response], T],
-    ) -> T: ...  # pragma: no cover
-
-    @overload
-    async def _request(
-        self,
-        method: Literal["GET", "OPTIONS", "HEAD", "POST", "PUT", "PATCH", "DELETE"],
-        path: str,
-        *,
-        jwt: Optional[str] = None,
-        redirect_to: Optional[str] = None,
-        headers: Optional[Dict[str, str]] = None,
-        query: Optional[Dict[str, str]] = None,
-        body: Optional[Any] = None,
-        no_resolve_json: bool = False,
-    ) -> None: ...  # pragma: no cover
-
     async def _request(
         self,
         method: Literal["GET", "OPTIONS", "HEAD", "POST", "PUT", "PATCH", "DELETE"],
@@ -93,11 +47,10 @@ async def _request(
         jwt: Optional[str] = None,
         redirect_to: Optional[str] = None,
         headers: Optional[Dict[str, str]] = None,
-        query: Optional[Dict[str, str]] = None,
+        query: Optional[Dict[str, str | None]] = None,
         body: Optional[Any] = None,
         no_resolve_json: bool = False,
-        xform: Optional[Callable[[Response], T]] = None,
-    ) -> Optional[T]:
+    ) -> Response:
         url = f"{self._url}/{path}"
         headers = {**self._headers, **(headers or {})}
         if API_VERSION_HEADER_NAME not in headers:
@@ -118,9 +71,6 @@ async def _request(
                 json=model_dump(body) if isinstance(body, BaseModel) else body,
             )
             response.raise_for_status()
-            result = response if no_resolve_json else response.json()
-            if xform:
-                return xform(result)
-            return None
+            return response
         except (HTTPStatusError, RuntimeError) as e:
             raise handle_exception(e)