crypticorn 2.13.0__py3-none-any.whl → 2.13.2__py3-none-any.whl

crypticorn/auth/client/models/create_user_request.py

@@ -17,7 +17,7 @@ import pprint
 import re  # noqa: F401
 import json
 
-from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
 from typing import Any, ClassVar, Dict, List, Optional
 from typing_extensions import Annotated
 from typing import Optional, Set
@@ -29,12 +29,10 @@ class CreateUserRequest(BaseModel):
     CreateUserRequest
     """  # noqa: E501
 
-    email: Annotated[str, Field(min_length=1, strict=True)]
+    email: StrictStr
     password: Annotated[str, Field(min_length=8, strict=True)]
-    username: Optional[
-        Annotated[str, Field(min_length=3, strict=True, max_length=32)]
-    ] = None
-    name: Optional[Annotated[str, Field(min_length=1, strict=True)]] = None
+    username: Optional[StrictStr] = None
+    name: Optional[StrictStr] = None
     picture: Optional[StrictStr] = None
     __properties: ClassVar[List[str]] = [
         "email",
@@ -44,16 +42,6 @@ class CreateUserRequest(BaseModel):
         "picture",
     ]
 
-    @field_validator("username")
-    def username_validate_regular_expression(cls, value):
-        """Validates the regular expression"""
-        if value is None:
-            return value
-
-        if not re.match(r"^[a-zA-Z0-9_]+$", value):
-            raise ValueError(r"must validate the regular expression /^[a-zA-Z0-9_]+$/")
-        return value
-
     model_config = ConfigDict(
         populate_by_name=True,
         validate_assignment=True,

crypticorn/auth/main.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING, Optional
 from crypticorn.auth import (
     ApiClient,
     Configuration,
@@ -8,6 +10,9 @@ from crypticorn.auth import (
     AuthApi,
 )
 
+if TYPE_CHECKING:
+    from aiohttp import ClientSession
+
 
 class AuthClient:
     """
@@ -19,9 +24,12 @@ class AuthClient:
     def __init__(
         self,
         config: Configuration,
+        http_client: Optional[ClientSession] = None,
     ):
         self.config = config
         self.base_client = ApiClient(configuration=self.config)
+        if http_client is not None:
+            self.base_client.rest_client.pool_manager = http_client
         # Instantiate all the endpoint clients
         self.admin = AdminApi(self.base_client)
         self.service = ServiceApi(self.base_client)

crypticorn/client.py

@@ -1,4 +1,5 @@
-from typing import TypeVar
+from typing import TypeVar, Optional
+from aiohttp import ClientSession, ClientTimeout, TCPConnector
 from crypticorn.hive import HiveClient
 from crypticorn.klines import KlinesClient
 from crypticorn.pay import PayClient
@@ -6,6 +7,7 @@ from crypticorn.trade import TradeClient
 from crypticorn.metrics import MetricsClient
 from crypticorn.auth import AuthClient
 from crypticorn.common import BaseUrl, ApiVersion, Service, apikey_header as aph
+from importlib.metadata import version
 
 ConfigT = TypeVar("ConfigT")
 SubClient = TypeVar("SubClient")
@@ -14,14 +16,13 @@ SubClient = TypeVar("SubClient")
 class ApiClient:
     """
     The official Python client for interacting with the Crypticorn API.
-
     It is consisting of multiple microservices covering the whole stack of the Crypticorn project.
     """
 
     def __init__(
         self,
-        api_key: str = None,
-        jwt: str = None,
+        api_key: Optional[str] = None,
+        jwt: Optional[str] = None,
         base_url: BaseUrl = BaseUrl.PROD,
     ):
         self.base_url = base_url
@@ -30,6 +31,15 @@ class ApiClient:
         """The API key to use for authentication (recommended)."""
         self.jwt = jwt
         """The JWT to use for authentication (not recommended)."""
+        self.version = version("crypticorn")
+        """The version of the client."""
+
+        # self._http_client = ClientSession(
+        #     timeout=ClientTimeout(total=30.0),
+        #     connector=TCPConnector(limit=100, limit_per_host=20),
+        #     headers={"User-Agent": f"crypticorn/python/{self.version}"},
+        # )
+        self._http_client = None # temporary fix for the issue with the event loop
 
         self._service_classes: dict[Service, type[SubClient]] = {
             Service.HIVE: HiveClient,
@@ -39,9 +49,10 @@ class ApiClient:
             Service.METRICS: MetricsClient,
             Service.AUTH: AuthClient,
         }
-
         self._services: dict[Service, SubClient] = {
-            service: client_class(self._get_default_config(service))
+            service: client_class(
+                self._get_default_config(service), http_client=self._http_client
+            )
             for service, client_class in self._service_classes.items()
         }
 
@@ -88,17 +99,13 @@ class ApiClient:
         return self._services[Service.AUTH]
 
     async def close(self):
-        """Close all client sessions."""
         for service in self._services.values():
             if hasattr(service.base_client, "close"):
                 await service.base_client.close()
 
-    def _get_default_config(
-        self, service: Service, version: ApiVersion = ApiVersion.V1
-    ):
-        """
-        Get the default configuration for a given service.
-        """
+    def _get_default_config(self, service, version=None):
+        if version is None:
+            version = ApiVersion.V1
         config_class = self._service_classes[service].config_class
         return config_class(
             host=f"{self.base_url}/{version}/{service}",
@@ -106,11 +113,7 @@ class ApiClient:
             api_key={aph.scheme_name: self.api_key} if self.api_key else None,
         )
 
-    def configure(
-        self,
-        config: ConfigT,
-        service: Service,
-    ):
+    def configure(self, config: ConfigT, service: Service) -> None:
         """
         Update a sub-client's configuration by overriding with the values set in the new config.
         Useful for testing a specific service against a local server instead of the default proxy.
@@ -125,13 +128,13 @@ class ApiClient:
         assert Service.validate(service), f"Invalid service: {service}"
         client = self._services[service]
         new_config = client.config
-
         for attr in vars(config):
             new_value = getattr(config, attr)
             if new_value:
                 setattr(new_config, attr, new_value)
-
-        self._services[service] = type(client)(new_config)
+        self._services[service] = type(client)(
+            new_config, http_client=self._http_client
+        )
 
     async def __aenter__(self):
         return self

crypticorn/common/auth.py

@@ -70,7 +70,7 @@ class AuthHandler:
         self, api_scopes: list[Scope], user_scopes: list[Scope]
     ) -> bool:
         """
-        Checks if the user scopes are a subset of the API scopes.
+        Checks if the required scopes are a subset of the user scopes.
         """
         if not set(api_scopes).issubset(user_scopes):
             raise HTTPException(
@@ -137,10 +137,21 @@ class AuthHandler:
         sec: SecurityScopes = SecurityScopes(),
     ) -> Verify200Response:
         """
-        Verifies the API key and checks if the user scopes are a subset of the API scopes.
+        Verifies the API key and checks the scopes.
         Use this function if you only want to allow access via the API key.
+        This function is used for HTTP connections.
         """
-        return await self.combined_auth(bearer=None, api_key=api_key, sec=sec)
+        try:
+            return await self.combined_auth(bearer=None, api_key=api_key, sec=sec)
+        except HTTPException as e:
+            if e.detail.get("code") == ApiError.NO_CREDENTIALS.identifier:
+                raise HTTPException(
+                    content=ExceptionContent(
+                        error=ApiError.NO_API_KEY,
+                        message="No credentials provided. API key is required",
+                    ),
+                )
+            raise e
 
     async def bearer_auth(
         self,
@@ -151,10 +162,21 @@ class AuthHandler:
         sec: SecurityScopes = SecurityScopes(),
     ) -> Verify200Response:
         """
-        Verifies the bearer token and checks if the user scopes are a subset of the API scopes.
+        Verifies the bearer token and checks the scopes.
         Use this function if you only want to allow access via the bearer token.
+        This function is used for HTTP connections.
         """
-        return await self.combined_auth(bearer=bearer, api_key=None, sec=sec)
+        try:
+            return await self.combined_auth(bearer=bearer, api_key=None, sec=sec)
+        except HTTPException as e:
+            if e.detail.get("code") == ApiError.NO_CREDENTIALS.identifier:
+                raise HTTPException(
+                    content=ExceptionContent(
+                        error=ApiError.NO_BEARER,
+                        message="No credentials provided. Bearer token is required",
+                    ),
+                )
+            raise e
 
     async def combined_auth(
         self,
@@ -165,9 +187,10 @@ class AuthHandler:
         sec: SecurityScopes = SecurityScopes(),
     ) -> Verify200Response:
         """
-        Verifies the bearer token and/or API key and checks if the user scopes are a subset of the API scopes.
+        Verifies the bearer token and/or API key and checks the scopes.
         Returns early on the first successful verification, otherwise tries all available tokens.
         Use this function if you want to allow access via either the bearer token or the API key.
+        This function is used for HTTP connections.
         """
         tokens = [bearer, api_key]
 
@@ -197,7 +220,7 @@ class AuthHandler:
             raise HTTPException(
                 content=ExceptionContent(
                     error=ApiError.NO_CREDENTIALS,
-                    message="No credentials provided",
+                    message="No credentials provided. Either API key or bearer token is required.",
                 ),
             )
 
@@ -207,10 +230,14 @@ class AuthHandler:
         sec: SecurityScopes = SecurityScopes(),
     ) -> Verify200Response:
         """
-        Verifies the API key and checks if the user scopes are a subset of the API scopes.
+        Verifies the API key and checks the scopes.
         Use this function if you only want to allow access via the API key.
+        This function is used for WebSocket connections.
         """
-        return await self.ws_combined_auth(bearer=None, api_key=api_key, sec=sec)
+        try:
+            return await self.api_key_auth(api_key=api_key, sec=sec)
+        except HTTPException as e:
+            raise WebSocketException.from_http_exception(e)
 
     async def ws_bearer_auth(
         self,
@@ -218,10 +245,14 @@ class AuthHandler:
         sec: SecurityScopes = SecurityScopes(),
     ) -> Verify200Response:
         """
-        Verifies the bearer token and checks if the user scopes are a subset of the API scopes.
+        Verifies the bearer token and checks the scopes.
         Use this function if you only want to allow access via the bearer token.
+        This function is used for WebSocket connections.
         """
-        return await self.ws_combined_auth(bearer=bearer, api_key=None, sec=sec)
+        try:
+            return await self.bearer_auth(bearer=bearer, sec=sec)
+        except HTTPException as e:
+            raise WebSocketException.from_http_exception(e)
 
     async def ws_combined_auth(
         self,
@@ -230,8 +261,9 @@ class AuthHandler:
         sec: SecurityScopes = SecurityScopes(),
     ) -> Verify200Response:
         """
-        Verifies the bearer token and/or API key and checks if the user scopes are a subset of the API scopes.
+        Verifies the bearer token and/or API key and checks the scopes.
         Use this function if you want to allow access via either the bearer token or the API key.
+        This function is used for WebSocket connections.
         """
         credentials = (
             HTTPAuthorizationCredentials(scheme="Bearer", credentials=bearer)