Use HTTPX

Author: Cyrus Nouroozi

README.md

@@ -17,10 +17,10 @@ from clerk import Client
 
 
 async def main():
-    async with Client("my-token") as client:
-        users = await client.users.list()
-        for user in users:
-            print(f"Got user {user.id} -> {user.first_name} {user.last_name}")
+    client = Client("my-token"):
+    users = await client.users.list()
+    for user in users:
+        print(f"Got user {user.id} -> {user.first_name} {user.last_name}")
 
 
 asyncio.run(main())

clerk/client.py

@@ -1,8 +1,8 @@
-from contextlib import asynccontextmanager
-from typing import Any, AsyncIterator, Mapping
+from typing import Any, Mapping
 import http
-import aiohttp
+
 from pydantic import BaseModel
+import httpx
 
 from clerk.errors import ClerkAPIException
 
@@ -15,18 +15,12 @@ class Client:
     def __init__(
         self, token: str, base_url: str = "https://api.clerk.dev/v1/", timeout_seconds: float = 30.0
     ) -> None:
-        self._session = aiohttp.ClientSession(
+        self._session = httpx.AsyncClient(
             headers={"Authorization": f"Bearer {token}", "Content-Type": "application/json"},
-            timeout=aiohttp.ClientTimeout(total=timeout_seconds),
+            timeout=httpx.Timeout(timeout_seconds),
         )
         self._base_url = base_url
 
-    async def __aenter__(self):
-        return self
-
-    async def __aexit__(self, exc_type, exc_val, exc_tb):
-        await self._session.close()
-
     @property
     def verification(self):
         from clerk.verification import VerificationService
@@ -57,46 +51,39 @@ def organizations(self):
 
         return OrganizationsService(self)
 
-    @asynccontextmanager
-    async def get(
-        self, endpoint: str, params: Mapping[str, str] | None = None
-    ) -> AsyncIterator[aiohttp.ClientResponse]:
-        async with self._session.get(self._make_url(endpoint), params=params) as r:
-            await self._check_response_err(r)
-            yield r
+    async def get(self, endpoint: str, params: Mapping[str, str] | None = None) -> httpx.Response:
+        r = await self._session.get(self._make_url(endpoint), params=params)
+        await self._check_response_err(r)
+        return r
 
-    @asynccontextmanager
     async def post(
         self, endpoint: str, request: BaseModel | None = None, json: Any = None
-    ) -> AsyncIterator[aiohttp.ClientResponse]:
-        async with self._session.post(
+    ) -> httpx.Response:
+        r = await self._session.post(
             self._make_url(endpoint),
-            data=request and request.model_dump_json(),
+            data=request.model_dump_json() if request else None,
             json=json,
-        ) as r:
-            await self._check_response_err(r)
-            yield r
+        )
+        await self._check_response_err(r)
+        return r
 
-    @asynccontextmanager
-    async def delete(self, endpoint: str) -> AsyncIterator[aiohttp.ClientResponse]:
-        async with self._session.delete(self._make_url(endpoint)) as r:
-            await self._check_response_err(r)
-            yield r
+    async def delete(self, endpoint: str) -> httpx.Response:
+        r = await self._session.delete(self._make_url(endpoint))
+        await self._check_response_err(r)
+        return r
 
-    @asynccontextmanager
     async def patch(
         self, endpoint: str, request: BaseModel | None = None, json: Any = None
-    ) -> AsyncIterator[aiohttp.ClientResponse]:
-        async with self._session.patch(
+    ) -> httpx.Response:
+        r = await self._session.patch(
             self._make_url(endpoint), data=request and request.model_dump_json(), json=json
-        ) as r:
-            await self._check_response_err(r)
-            yield r
-
-    async def _check_response_err(self, r: aiohttp.ClientResponse):
-        if http.HTTPStatus.OK <= r.status < http.HTTPStatus.BAD_REQUEST:
-            return  # no error
-        raise await ClerkAPIException.from_response(r)
+        )
+        await self._check_response_err(r)
+        return r
+
+    async def _check_response_err(self, r: httpx.Response):
+        if not http.HTTPStatus.OK <= r.status_code < http.HTTPStatus.BAD_REQUEST:
+            raise await ClerkAPIException.from_response(r)
 
     def _make_url(self, endpoint: str) -> str:
         return f"{self._base_url.rstrip('/')}/{endpoint.strip('/')}/"

clerk/clients.py

@@ -10,17 +10,17 @@ class ClientsService(Service):
 
     async def list(self) -> List[types.Client]:
         """Retrieve a list of all clients"""
-        async with self._client.get(self.endpoint) as r:
-            return [types.Client.model_validate(s) for s in await r.json()]
+        r = await self._client.get(self.endpoint)
+        return [types.Client.model_validate(s) for s in r.json()["data"]]
 
     async def get(self, client_id: str) -> types.Client:
         """Retrieve a client by its id"""
-        async with self._client.get(f"{self.endpoint}/{client_id}") as r:
-            return types.Client.model_validate(await r.json())
+        r = await self._client.get(f"{self.endpoint}/{client_id}")
+        return types.Client.model_validate_json(r.content)
 
     async def verify(self, token: str) -> types.Client:
         """Verify a token and return its associated client, if valid"""
         request = types.VerifyRequest(token=token)
 
-        async with self._client.post(self.verify_endpoint, request=request) as r:
-            return types.Client.model_validate(await r.json())
+        r = await self._client.post(self.verify_endpoint, request=request)
+        return types.Client.model_validate_json(r.content)

clerk/errors.py

@@ -1,29 +1,29 @@
-import aiohttp
+import httpx
 
 from clerk import types
 
 __all__ = ["ClerkAPIException", "NoActiveSessionException"]
 
 
 class ClerkAPIException(Exception):
-    def __init__(self, status: int, method: str, url: str, *api_errors: types.Error) -> None:
-        self.status = status
-        self.method = method
+    def __init__(self, status: int, data: str, url: str, *api_errors: types.Error) -> None:
+        self.status_code = status
+        self.data = data
         self.url = url
         self.api_errors = api_errors
-        super().__init__(f"{self.method} {self.url}: {self.status} {self.api_errors!r}")
+        super().__init__(f"{self.url}: {self.status_code} {self.api_errors!r}")
 
     @classmethod
-    async def from_response(cls, resp: aiohttp.ClientResponse) -> "ClerkAPIException":
+    async def from_response(cls, resp: httpx.Response) -> "ClerkAPIException":
         try:
-            data = await resp.json()
+            data = resp.json()
         except:  # noqa
             api_errors = []
         else:
             errors = data.get("errors", [])
             api_errors = [types.Error.model_validate(e) for e in errors]
 
-        return ClerkAPIException(resp.status, resp.method, str(resp.url), *api_errors)
+        return ClerkAPIException(resp.status_code, resp.content, str(resp.url), *api_errors)
 
 
 class NoActiveSessionException(Exception):

clerk/organizations.py

@@ -9,25 +9,25 @@ class OrganizationsService(Service):
 
     async def list(self) -> List[types.Organization]:
         """Retrieve a list of all organizations"""
-        async with self._client.get(self.endpoint) as r:
-            s = await r.json()
-            return [types.Organization.model_validate(s) for s in s.get("data")]
+        r = await self._client.get(self.endpoint)
+        return [types.Organization.model_validate(s) for s in r.json()["data"]]
 
     async def get(self, organization_id: str) -> types.Organization:
         """Retrieve an organization by their id"""
-        async with self._client.get(f"{self.endpoint}/{organization_id}") as r:
-            return types.Organization.model_validate(await r.json())
+        r = await self._client.get(f"{self.endpoint}/{organization_id}")
+        return types.Organization.model_validate_json(r.content)
 
     async def delete(self, organization_id: str) -> types.DeleteOrganizationResponse:
         """Delete an organization by their id"""
-        async with self._client.delete(f"{self.endpoint}/{organization_id}") as r:
-            return types.DeleteOrganizationResponse.model_validate(await r.json())
+        r = await self._client.delete(f"{self.endpoint}/{organization_id}")
+        return types.DeleteOrganizationResponse.model_validate_json(r.content)
 
     async def update(
         self, organization_id: str, request: types.UpdateOrganizationRequest
     ) -> types.Organization:
         """Update an organization by their id"""
-        async with self._client.patch(
-            f"{self.endpoint}/{organization_id}", json=request.model_dump_json(exclude_unset=True)
-        ) as r:
-            return types.Organization.model_validate(await r.json())
+        r = await self._client.patch(
+            f"{self.endpoint}/{organization_id}",
+            json=request.model_dump_json(exclude_unset=True),
+        )
+        return types.Organization.model_validate_json(r.content)

clerk/sessions.py

@@ -9,22 +9,22 @@ class SessionsService(Service):
 
     async def list(self) -> List[types.Session]:
         """Retrieve a list of all sessions"""
-        async with self._client.get(self.endpoint) as r:
-            return [types.Session.model_validate(s) for s in await r.json()]
+        r = await self._client.get(self.endpoint)
+        return [types.Session.model_validate(s) for s in r.json()["data"]]
 
     async def get(self, session_id: str) -> types.Session:
         """Retrieve a session by its id"""
-        async with self._client.get(f"{self.endpoint}/{session_id}") as r:
-            return types.Session.model_validate(await r.json())
+        r = await self._client.get(f"{self.endpoint}/{session_id}")
+        return types.Session.model_validate_json(r.content)
 
     async def revoke(self, session_id: str) -> types.Session:
         """Revoke a session by its id"""
-        async with self._client.post(f"{self.endpoint}/{session_id}/revoke") as r:
-            return types.Session.model_validate(await r.json())
+        r = await self._client.post(f"{self.endpoint}/{session_id}/revoke")
+        return types.Session.model_validate_json(r.content)
 
     async def verify(self, session_id: str, token: str) -> types.Session:
         """Verify a session by its id and a given token"""
         request = types.VerifyRequest(token=token)
 
-        async with self._client.post(f"{self.endpoint}/{session_id}/verify", request=request) as r:
-            return types.Session.model_validate(await r.json())
+        r = await self._client.post(f"{self.endpoint}/{session_id}/verify", request=request)
+        return types.Session.model_validate_json(r.content)

clerk/users.py

@@ -9,22 +9,23 @@ class UsersService(Service):
 
     async def list(self) -> List[types.User]:
         """Retrieve a list of all users"""
-        async with self._client.get(self.endpoint) as r:
-            return [types.User.model_validate(s) for s in await r.json()]
+        r = await self._client.get(self.endpoint)
+        return [types.User.model_validate(s) for s in r.json()["data"]]
 
     async def get(self, user_id: str) -> types.User:
         """Retrieve a user by their id"""
-        async with self._client.get(f"{self.endpoint}/{user_id}") as r:
-            return types.User.model_validate(await r.json())
+        r = await self._client.get(f"{self.endpoint}/{user_id}")
+        return types.User.model_validate_json(r.content)
 
     async def delete(self, user_id: str) -> types.DeleteUserResponse:
         """Delete a user by their id"""
-        async with self._client.delete(f"{self.endpoint}/{user_id}") as r:
-            return types.DeleteUserResponse.model_validate(await r.json())
+        r = await self._client.delete(f"{self.endpoint}/{user_id}")
+        return types.DeleteUserResponse.model_validate_json(r.content)
 
     async def update(self, user_id: str, request: types.UpdateUserRequest) -> types.User:
         """Update a user by their id"""
-        async with self._client.patch(
-            f"{self.endpoint}/{user_id}", json=request.model_dump_json(exclude_unset=True)
-        ) as r:
-            return types.User.model_validate(await r.json())
+        r = await self._client.patch(
+            f"{self.endpoint}/{user_id}",
+            json=request.model_dump_json(exclude_unset=True),
+        )
+        return types.User.model_validate_json(r.content)