fix: make it a class

Author: omercnet

.pre-commit-config.yaml

@@ -19,7 +19,7 @@ repos:
       - id: isort
         args: ["--profile", "black"]
   - repo: https://github.com/psf/black
-    rev: 25.1.0
+    rev: 24.10.0
     hooks:
       - id: black
         language_version: python3
@@ -29,19 +29,22 @@ repos:
       - id: pyupgrade
         args: [--py38-plus]
   - repo: https://github.com/pycqa/flake8
-    rev: 7.2.0
+    rev: 7.1.2
     hooks:
       - id: flake8
         additional_dependencies: [Flake8-pyproject]
   - repo: https://github.com/python-poetry/poetry
     rev: 2.1.3
     hooks:
-      - id: poetry-export
-        files: pyproject.toml
       - id: poetry-lock
         files: pyproject.toml
       - id: poetry-check
         files: pyproject.toml
+  - repo: https://github.com/python-poetry/poetry-plugin-export
+    rev: 1.9.0
+    hooks:
+      - id: poetry-export
+        files: pyproject.toml
   - repo: https://github.com/pre-commit/pre-commit
     rev: v4.2.0
     hooks:
@@ -62,11 +65,3 @@ repos:
         types: [python]
         entry: "print"
         language: pygrep
-      - id: liccheck
-        name: Run Python License Checker
-        description: Check license compliance of python requirements
-        entry: poetry
-        args: [run, liccheck, --level, paranoid]
-        language: system
-        files: ^(.*requirements.*\.txt|setup\.cfg|setup\.py|pyproject\.toml|liccheck\.ini)$
-        pass_filenames: false

ASYNC_IMPLEMENTATION.md

@@ -1,49 +1,22 @@
 """
-Monkey-patch async support for Descope SDK.
+Async support for Descope SDK.
 
-This mod    async_wrapper = _asyncify(original_method)
-    async_wrapper.__name__ = f"{method_name}_async"
-
-    # Try to set __qualname__ safely (may fail with mocks)
-    try:
-        if hasattr(original_method, "__qualname__"):
-            async_wrapper.__qualname__ = f"{original_method.__qualname__}_async"
-    except (AttributeError, TypeError):
-        # Skip if __qualname__ is not accessible (e.g., with mocks)
-        pass
-
-    # Try to set docstring safely
-    try:
-        if hasattr(original_method, "__doc__") and original_method.__doc__:
-            async_wrapper.__doc__ = (
-                f"Async version of {method_name}.\n\n{original_method.__doc__}"
-            )
-        else:
-            async_wrapper.__doc__ = f"Async version of {method_name}."
-    except (AttributeError, TypeError):
-        # Skip if __doc__ is not accessible
-        async_wrapper.__doc__ = f"Async version of {method_name}."
-
-    # Try to preserve the signature safely (skip for now due to asyncer limitations)
-    # try:
-    #     sig = inspect.signature(original_method)
-    #     if hasattr(async_wrapper, "__signature__"):
-    #         async_wrapper.__signature__ = sig
-    # except (ValueError, TypeError, AttributeError):
-    #     passcky but elegant way to add async methods to existing
-sync classes without code duplication. It dynamically discovers all public methods
-and creates async variants using asyncer.
+Provides a native AsyncDescopeClient class that mirrors DescopeClient structure
+but with async methods throughout.
 """
 
 from __future__ import annotations
 
-from typing import Any, Callable, Type, TypeVar
+from typing import Any, Callable, TypeVar
+
 from asyncer import asyncify as _asyncify
 
+from descope.common import DEFAULT_TIMEOUT_SECONDS
+
 T = TypeVar("T")
 
 
-def add_async_methods(cls: Type[T], method_suffix: str = "_async") -> Type[T]:
+def _add_async_methods(cls: type[T], method_suffix: str = "_async") -> type[T]:
     """
     Monkey patch a class to add async versions of all public methods.
 
@@ -106,18 +79,10 @@ async def async_wrapper(self, *args, **kwargs):
         # Skip if __doc__ is not accessible
         async_wrapper.__doc__ = f"Async version of {method_name}."
 
-    # Try to preserve the signature (skip for now due to asyncer limitations)
-    # try:
-    #     sig = inspect.signature(original_method)
-    #     if hasattr(async_wrapper, "__signature__"):
-    #         async_wrapper.__signature__ = sig
-    # except (ValueError, TypeError, AttributeError):
-    #     pass
-
     return async_wrapper
 
 
-def asyncify_client(client_instance: Any) -> Any:
+def _asyncify_client(client_instance: Any) -> Any:
     """
     Add async methods to an existing client instance.
 
@@ -128,7 +93,7 @@ def asyncify_client(client_instance: Any) -> Any:
         The same instance with async methods added
     """
     # Patch the instance's class
-    add_async_methods(client_instance.__class__)
+    _add_async_methods(client_instance.__class__)
 
     # Recursively patch all authentication method attributes
     # Use a safe list of known auth method attributes to avoid triggering properties
@@ -176,87 +141,62 @@ def asyncify_client(client_instance: Any) -> Any:
                     attr = getattr(client_instance, attr_name)
                     if hasattr(attr, "__class__") and hasattr(attr, "_auth"):
                         # This looks like an auth method class
-                        add_async_methods(attr.__class__)
+                        _add_async_methods(attr.__class__)
                 except Exception:
                     # Skip attributes that can't be accessed safely
                     continue
 
-    # Add specific async methods for client-level operations
-    _add_client_async_methods(client_instance)
-
     return client_instance
 
 
-def _add_client_async_methods(client_instance: Any) -> None:
-    """Add client-specific async methods like close_async."""
-
-    async def close_async(self):
-        """Async method to close the client and clean up resources."""
+class AsyncDescopeClient:
+    ALGORITHM_KEY = "alg"
+
+    def __init__(
+        self,
+        project_id: str,
+        public_key: dict | None = None,
+        skip_verify: bool = False,
+        management_key: str | None = None,
+        timeout_seconds: float = DEFAULT_TIMEOUT_SECONDS,
+        jwt_validation_leeway: int = 5,
+    ):
+        # Import here to avoid circular import
+        from .descope_client import DescopeClient
+
+        # Create a sync client instance
+        self._sync_client = DescopeClient(
+            project_id,
+            public_key,
+            skip_verify,
+            management_key,
+            timeout_seconds,
+            jwt_validation_leeway,
+        )
+
+        # Patch it with async methods
+        _asyncify_client(self._sync_client)
+
+    def __getattr__(self, name):
+        """Dynamically delegate all attribute access to the sync client."""
+        attr = getattr(self._sync_client, name)
+
+        # If it's a method and we have an async version, prefer the async version
+        if callable(attr) and hasattr(self._sync_client, f"{name}_async"):
+            return getattr(self._sync_client, f"{name}_async")
+
+        return attr
+
+    async def close(self):
+        """Close the client and clean up resources."""
         # For now, this is just a placeholder since the sync client doesn't have cleanup
         # In the future, this could close async HTTP connections
         pass
 
-    # Add context manager support
-    async def __aenter__(self):  # noqa: N807
+    async def __aenter__(self):
         """Async context manager entry."""
         return self
 
-    async def __aexit__(self, exc_type, exc_val, exc_tb):  # noqa: N807
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
         """Async context manager exit."""
-        await self.close_async()
-
-    # Add methods to the class rather than instance for proper protocol support
-    cls = client_instance.__class__
-
-    # Only add if not already present
-    if not hasattr(cls, "close_async"):
-        cls.close_async = close_async
-    if not hasattr(cls, "__aenter__"):
-        cls.__aenter__ = __aenter__
-    if not hasattr(cls, "__aexit__"):
-        cls.__aexit__ = __aexit__
-
-
-def create_async_client(client_class: Type[T], *args, **kwargs) -> T:
-    """
-    Create a client instance with async methods automatically added.
-
-    Args:
-        client_class: The client class to instantiate
-        *args: Arguments for client constructor
-        **kwargs: Keyword arguments for client constructor
-
-    Returns:
-        Client instance with async methods
-    """
-    # Create instance
-    instance = client_class(*args, **kwargs)
-
-    # Add async methods
-    return asyncify_client(instance)
-
-
-# Convenience function for DescopeClient
-def create_async_descope_client(*args, **kwargs):  # noqa: N802
-    """
-    Create a DescopeClient with async methods added.
-
-    Same signature as DescopeClient but with async methods available.
-    All methods get an _async suffix (e.g., sign_up_async, verify_async).
-
-    Example:
-        client = create_async_descope_client(project_id="P123")
-
-        # Use sync methods normally
-        result = client.otp.sign_up(DeliveryMethod.EMAIL, "[email protected]")
-
-        # Use async methods with _async suffix
-        result = await client.otp.sign_up_async(DeliveryMethod.EMAIL, "[email protected]")
-    """
-    from .descope_client import DescopeClient
-
-    return create_async_client(DescopeClient, *args, **kwargs)
-
-
-# Alias for convenience (ignore naming convention for this public API)
-AsyncDescopeClient = create_async_descope_client  # noqa: N816
+        await self.close()