Update pytest* to latest, pydantic=2

Author: Cyrus Nouroozi

clerk/client.py

@@ -1,8 +1,8 @@
-import http
 from contextlib import asynccontextmanager
-from typing import Any, Mapping, Optional
-
+from typing import Any, AsyncIterator, Mapping
+import http
 import aiohttp
+from pydantic import BaseModel
 
 from clerk.errors import ClerkAPIException
 
@@ -59,31 +59,37 @@ def organizations(self):
 
     @asynccontextmanager
     async def get(
-        self, endpoint: str, params: Optional[Mapping[str, str]] = None
-    ) -> aiohttp.ClientResponse:
+        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
 
     @asynccontextmanager
     async def post(
-        self, endpoint: str, data: Any = None, json: Any = None
-    ) -> aiohttp.ClientResponse:
-        async with self._session.post(self._make_url(endpoint), data=data, json=json) as r:
+        self, endpoint: str, request: BaseModel | None = None, json: Any = None
+    ) -> AsyncIterator[aiohttp.ClientResponse]:
+        async with self._session.post(
+            self._make_url(endpoint),
+            data=request and request.model_dump_json(),
+            json=json,
+        ) as r:
             await self._check_response_err(r)
             yield r
 
     @asynccontextmanager
-    async def delete(self, endpoint: str) -> aiohttp.ClientResponse:
+    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
 
     @asynccontextmanager
     async def patch(
-        self, endpoint: str, data: Any = None, json: Any = None
-    ) -> aiohttp.ClientResponse:
-        async with self._session.patch(self._make_url(endpoint), data=data, json=json) as r:
+        self, endpoint: str, request: BaseModel | None = None, json: Any = None
+    ) -> AsyncIterator[aiohttp.ClientResponse]:
+        async with 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
 

clerk/clients.py

@@ -11,16 +11,16 @@ 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.parse_obj(s) for s in await r.json()]
+            return [types.Client.model_validate(s) for s in await r.json()]
 
     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.parse_obj(await r.json())
+            return types.Client.model_validate(await r.json())
 
     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, data=request.json()) as r:
-            return types.Client.parse_obj(await r.json())
+        async with self._client.post(self.verify_endpoint, request=request) as r:
+            return types.Client.model_validate(await r.json())

clerk/errors.py

@@ -21,7 +21,7 @@ async def from_response(cls, resp: aiohttp.ClientResponse) -> "ClerkAPIException
             api_errors = []
         else:
             errors = data.get("errors", [])
-            api_errors = [types.Error.parse_obj(e) for e in errors]
+            api_errors = [types.Error.model_validate(e) for e in errors]
 
         return ClerkAPIException(resp.status, resp.method, str(resp.url), *api_errors)
 

clerk/organizations.py

@@ -11,21 +11,23 @@ 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.parse_obj(s) for s in s.get("data")]
+            return [types.Organization.model_validate(s) for s in s.get("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.parse_obj(await r.json())
+            return types.Organization.model_validate(await r.json())
 
     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.parse_obj(await r.json())
+            return types.DeleteOrganizationResponse.model_validate(await r.json())
 
-    async def update(self, organization_id: str, request: types.UpdateOrganizationRequest) -> types.Organization:
+    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}", data=request.json(exclude_unset=True)
+            f"{self.endpoint}/{organization_id}", json=request.model_dump_json(exclude_unset=True)
         ) as r:
-            return types.Organization.parse_obj(await r.json())
+            return types.Organization.model_validate(await r.json())

clerk/sessions.py

@@ -10,23 +10,21 @@ 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.parse_obj(s) for s in await r.json()]
+            return [types.Session.model_validate(s) for s in await r.json()]
 
     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.parse_obj(await r.json())
+            return types.Session.model_validate(await r.json())
 
     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.parse_obj(await r.json())
+            return types.Session.model_validate(await r.json())
 
     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", data=request.json()
-        ) as r:
-            return types.Session.parse_obj(await r.json())
+        async with self._client.post(f"{self.endpoint}/{session_id}/verify", request=request) as r:
+            return types.Session.model_validate(await r.json())

clerk/users.py

@@ -10,21 +10,21 @@ 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.parse_obj(s) for s in await r.json()]
+            return [types.User.model_validate(s) for s in await r.json()]
 
     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.parse_obj(await r.json())
+            return types.User.model_validate(await r.json())
 
     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.parse_obj(await r.json())
+            return types.DeleteUserResponse.model_validate(await r.json())
 
     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}", data=request.json(exclude_unset=True)
+            f"{self.endpoint}/{user_id}", json=request.model_dump_json(exclude_unset=True)
         ) as r:
-            return types.User.parse_obj(await r.json())
+            return types.User.model_validate(await r.json())