python: Replace OpenAPI generator http code with out own

python/svix/api/application.py

@@ -1,25 +1,15 @@
+# This file is @generated
 import typing as t
 from dataclasses import dataclass
 
-from .common import ApiBase, BaseOptions
 from ..internal.openapi_client import models
-
-
-from ..internal.openapi_client.api.application import (
-    v1_application_list,
-    v1_application_create,
-    v1_application_get,
-    v1_application_update,
-    v1_application_delete,
-    v1_application_patch,
-)
-
-from ..internal.openapi_client.models.list_response_application_out import (
-    ListResponseApplicationOut,
-)
 from ..internal.openapi_client.models.application_in import ApplicationIn
 from ..internal.openapi_client.models.application_out import ApplicationOut
 from ..internal.openapi_client.models.application_patch import ApplicationPatch
+from ..internal.openapi_client.models.list_response_application_out import (
+    ListResponseApplicationOut,
+)
+from .common import ApiBase, BaseOptions, sanitize_field
 
 
 @dataclass
@@ -31,124 +21,242 @@ class ApplicationListOptions(BaseOptions):
     # The sorting order of the returned items
     order: t.Optional[models.Ordering] = None
 
+    def _query_params(self) -> t.Optional[t.Dict[str, str]]:
+        d = {
+            "limit": self.limit,
+            "iterator": self.iterator,
+            "order": self.order,
+        }
+        return {
+            k: str(sanitize_field(v)).lower() for k, v in d.items() if v is not None
+        }
+
+    def _header_params(self) -> t.Optional[t.Dict[str, str]]:
+        return None
+
 
 @dataclass
 class ApplicationCreateOptions(BaseOptions):
     idempotency_key: t.Optional[str] = None
 
+    def _query_params(self) -> t.Optional[t.Dict[str, str]]:
+        return None
+
+    def _header_params(self) -> t.Optional[t.Dict[str, str]]:
+        d = {
+            "idempotency-key": self.idempotency_key,
+        }
+        return {k: v for k, v in d.items() if v is not None}
+
 
 @dataclass
 class ApplicationGetOrCreateOptions(BaseOptions):
     idempotency_key: t.Optional[str] = None
 
+    def _query_params(self) -> t.Optional[t.Dict[str, str]]:
+        return None
+
+    def _header_params(self) -> t.Optional[t.Dict[str, str]]:
+        d = {
+            "idempotency-key": self.idempotency_key,
+        }
+        return {k: v for k, v in d.items() if v is not None}
+
 
 class ApplicationAsync(ApiBase):
     async def list(
         self, options: ApplicationListOptions = ApplicationListOptions()
     ) -> ListResponseApplicationOut:
         """List of all the organization's applications."""
-        return await v1_application_list.request_asyncio(
-            client=self._client, **options.to_dict()
+        # ruff: noqa: F841
+        response = await self._request_asyncio(
+            method="get",
+            path="/api/v1/app",
+            path_params={},
+            query_params=options._query_params(),
+            header_params=options._header_params(),
         )
+        return ListResponseApplicationOut.from_dict(response.json())
 
     async def create(
         self,
         application_in: ApplicationIn,
         options: ApplicationCreateOptions = ApplicationCreateOptions(),
     ) -> ApplicationOut:
         """Create a new application."""
-        return await v1_application_create.request_asyncio(
-            client=self._client, json_body=application_in, **options.to_dict()
+        # ruff: noqa: F841
+        response = await self._request_asyncio(
+            method="post",
+            path="/api/v1/app",
+            path_params={},
+            query_params=options._query_params(),
+            header_params=options._header_params(),
+            json_body=application_in.to_dict(),
         )
+        return ApplicationOut.from_dict(response.json())
 
     async def get(self, app_id: str) -> ApplicationOut:
         """Get an application."""
-        return await v1_application_get.request_asyncio(
-            client=self._client, app_id=app_id
+        # ruff: noqa: F841
+        response = await self._request_asyncio(
+            method="get",
+            path="/api/v1/app/{app_id}",
+            path_params={
+                "app_id": app_id,
+            },
         )
+        return ApplicationOut.from_dict(response.json())
 
     async def get_or_create(
         self,
         application_in: ApplicationIn,
         options: ApplicationGetOrCreateOptions = ApplicationGetOrCreateOptions(),
     ) -> ApplicationOut:
-        return await v1_application_create.request_asyncio(
-            client=self._client,
-            json_body=application_in,
-            get_if_exists=True,
-            **options.to_dict(),
+        response = await self._request_asyncio(
+            method="post",
+            path="/api/v1/app",
+            path_params={},
+            query_params={"get_if_exists": "true"},
+            header_params=options._header_params(),
+            json_body=application_in.to_dict(),
         )
+        return ApplicationOut.from_dict(response.json())
 
     async def update(
         self, app_id: str, application_in: ApplicationIn
     ) -> ApplicationOut:
         """Update an application."""
-        return await v1_application_update.request_asyncio(
-            client=self._client, app_id=app_id, json_body=application_in
+        # ruff: noqa: F841
+        response = await self._request_asyncio(
+            method="put",
+            path="/api/v1/app/{app_id}",
+            path_params={
+                "app_id": app_id,
+            },
+            json_body=application_in.to_dict(),
         )
+        return ApplicationOut.from_dict(response.json())
 
     async def delete(self, app_id: str) -> None:
         """Delete an application."""
-        return await v1_application_delete.request_asyncio(
-            client=self._client, app_id=app_id
+        # ruff: noqa: F841
+        response = await self._request_asyncio(
+            method="delete",
+            path="/api/v1/app/{app_id}",
+            path_params={
+                "app_id": app_id,
+            },
         )
 
     async def patch(
         self, app_id: str, application_patch: ApplicationPatch
     ) -> ApplicationOut:
         """Partially update an application."""
-        return await v1_application_patch.request_asyncio(
-            client=self._client, app_id=app_id, json_body=application_patch
+        # ruff: noqa: F841
+        response = await self._request_asyncio(
+            method="patch",
+            path="/api/v1/app/{app_id}",
+            path_params={
+                "app_id": app_id,
+            },
+            json_body=application_patch.to_dict(),
         )
+        return ApplicationOut.from_dict(response.json())
 
 
 class Application(ApiBase):
     def list(
         self, options: ApplicationListOptions = ApplicationListOptions()
     ) -> ListResponseApplicationOut:
         """List of all the organization's applications."""
-        return v1_application_list.request_sync(
-            client=self._client, **options.to_dict()
+        # ruff: noqa: F841
+        response = self._request_sync(
+            method="get",
+            path="/api/v1/app",
+            path_params={},
+            query_params=options._query_params(),
+            header_params=options._header_params(),
         )
+        return ListResponseApplicationOut.from_dict(response.json())
 
     def create(
         self,
         application_in: ApplicationIn,
         options: ApplicationCreateOptions = ApplicationCreateOptions(),
     ) -> ApplicationOut:
         """Create a new application."""
-        return v1_application_create.request_sync(
-            client=self._client, json_body=application_in, **options.to_dict()
+        # ruff: noqa: F841
+        response = self._request_sync(
+            method="post",
+            path="/api/v1/app",
+            path_params={},
+            query_params=options._query_params(),
+            header_params=options._header_params(),
+            json_body=application_in.to_dict(),
         )
+        return ApplicationOut.from_dict(response.json())
 
     def get(self, app_id: str) -> ApplicationOut:
         """Get an application."""
-        return v1_application_get.request_sync(client=self._client, app_id=app_id)
+        # ruff: noqa: F841
+        response = self._request_sync(
+            method="get",
+            path="/api/v1/app/{app_id}",
+            path_params={
+                "app_id": app_id,
+            },
+        )
+        return ApplicationOut.from_dict(response.json())
 
     def get_or_create(
         self,
         application_in: ApplicationIn,
         options: ApplicationGetOrCreateOptions = ApplicationGetOrCreateOptions(),
     ) -> ApplicationOut:
-        return v1_application_create.request_sync(
-            client=self._client,
-            json_body=application_in,
-            get_if_exists=True,
-            **options.to_dict(),
+        # ruff: noqa: F841
+        response = self._request_sync(
+            method="post",
+            path="/api/v1/app",
+            path_params={},
+            query_params={"get_if_exists": "true"},
+            header_params=options._header_params(),
+            json_body=application_in.to_dict(),
         )
+        return ApplicationOut.from_dict(response.json())
 
     def update(self, app_id: str, application_in: ApplicationIn) -> ApplicationOut:
         """Update an application."""
-        return v1_application_update.request_sync(
-            client=self._client, app_id=app_id, json_body=application_in
+        # ruff: noqa: F841
+        response = self._request_sync(
+            method="put",
+            path="/api/v1/app/{app_id}",
+            path_params={
+                "app_id": app_id,
+            },
+            json_body=application_in.to_dict(),
         )
+        return ApplicationOut.from_dict(response.json())
 
     def delete(self, app_id: str) -> None:
         """Delete an application."""
-        return v1_application_delete.request_sync(client=self._client, app_id=app_id)
+        # ruff: noqa: F841
+        response = self._request_sync(
+            method="delete",
+            path="/api/v1/app/{app_id}",
+            path_params={
+                "app_id": app_id,
+            },
+        )
 
     def patch(self, app_id: str, application_patch: ApplicationPatch) -> ApplicationOut:
         """Partially update an application."""
-        return v1_application_patch.request_sync(
-            client=self._client, app_id=app_id, json_body=application_patch
+        # ruff: noqa: F841
+        response = self._request_sync(
+            method="patch",
+            path="/api/v1/app/{app_id}",
+            path_params={
+                "app_id": app_id,
+            },
+            json_body=application_patch.to_dict(),
         )
+        return ApplicationOut.from_dict(response.json())

python/svix/api/authentication.py

@@ -26,12 +26,12 @@ class AuthenticationAppPortalAccessOptions(BaseOptions):
 
 
 @dataclass
-class AuthenticationDashboardAccessOptions(BaseOptions):
+class AuthenticationExpireAllOptions(BaseOptions):
     idempotency_key: t.Optional[str] = None
 
 
 @dataclass
-class AuthenticationExpireAllOptions(BaseOptions):
+class AuthenticationDashboardAccessOptions(BaseOptions):
     idempotency_key: t.Optional[str] = None
 
 
@@ -55,16 +55,6 @@ async def app_portal_access(
             **options.to_dict(),
         )
 
-    @deprecated
-    async def dashboard_access(
-        self,
-        app_id: str,
-        options: AuthenticationDashboardAccessOptions = AuthenticationDashboardAccessOptions(),
-    ) -> DashboardAccessOut:
-        return await v1_authentication_dashboard_access.request_asyncio(
-            client=self._client, app_id=app_id, **options.to_dict()
-        )
-
     async def expire_all(
         self,
         app_id: str,
@@ -79,6 +69,16 @@ async def expire_all(
             **options.to_dict(),
         )
 
+    @deprecated
+    async def dashboard_access(
+        self,
+        app_id: str,
+        options: AuthenticationDashboardAccessOptions = AuthenticationDashboardAccessOptions(),
+    ) -> DashboardAccessOut:
+        return await v1_authentication_dashboard_access.request_asyncio(
+            client=self._client, app_id=app_id, **options.to_dict()
+        )
+
     async def logout(
         self, options: AuthenticationLogoutOptions = AuthenticationLogoutOptions()
     ) -> None: