crypticorn 2.17.0rc1__py3-none-any.whl → 2.17.0rc2__py3-none-any.whl

crypticorn/auth/client/models/create_api_key_request.py

@@ -50,6 +50,7 @@ class CreateApiKeyRequest(BaseModel):
             if i not in set(
                 [
                     "read:predictions",
+                    "read:dexsignals",
                     "read:hive:model",
                     "read:hive:data",
                     "write:hive:model",
@@ -84,7 +85,7 @@ class CreateApiKeyRequest(BaseModel):
                 ]
             ):
                 raise ValueError(
-                    "each list item must be one of ('read:predictions', 'read:hive:model', 'read:hive:data', 'write:hive:model', 'read:trade:bots', 'write:trade:bots', 'read:trade:exchangekeys', 'write:trade:exchangekeys', 'read:trade:orders', 'read:trade:actions', 'write:trade:actions', 'read:trade:exchanges', 'read:trade:futures', 'write:trade:futures', 'read:trade:notifications', 'write:trade:notifications', 'read:trade:strategies', 'write:trade:strategies', 'read:pay:payments', 'read:pay:products', 'write:pay:products', 'read:pay:now', 'write:pay:now', 'read:metrics:marketcap', 'read:metrics:indicators', 'read:metrics:exchanges', 'read:metrics:tokens', 'read:metrics:markets', 'read:sentiment', 'read:klines', 'read:admin', 'write:admin')"
+                    "each list item must be one of ('read:predictions', 'read:dexsignals', 'read:hive:model', 'read:hive:data', 'write:hive:model', 'read:trade:bots', 'write:trade:bots', 'read:trade:exchangekeys', 'write:trade:exchangekeys', 'read:trade:orders', 'read:trade:actions', 'write:trade:actions', 'read:trade:exchanges', 'read:trade:futures', 'write:trade:futures', 'read:trade:notifications', 'write:trade:notifications', 'read:trade:strategies', 'write:trade:strategies', 'read:pay:payments', 'read:pay:products', 'write:pay:products', 'read:pay:now', 'write:pay:now', 'read:metrics:marketcap', 'read:metrics:indicators', 'read:metrics:exchanges', 'read:metrics:tokens', 'read:metrics:markets', 'read:sentiment', 'read:klines', 'read:admin', 'write:admin')"
                 )
         return value
 

crypticorn/auth/client/models/get_api_keys200_response_inner.py

@@ -58,6 +58,7 @@ class GetApiKeys200ResponseInner(BaseModel):
             if i not in set(
                 [
                     "read:predictions",
+                    "read:dexsignals",
                     "read:hive:model",
                     "read:hive:data",
                     "write:hive:model",
@@ -92,7 +93,7 @@ class GetApiKeys200ResponseInner(BaseModel):
                 ]
             ):
                 raise ValueError(
-                    "each list item must be one of ('read:predictions', 'read:hive:model', 'read:hive:data', 'write:hive:model', 'read:trade:bots', 'write:trade:bots', 'read:trade:exchangekeys', 'write:trade:exchangekeys', 'read:trade:orders', 'read:trade:actions', 'write:trade:actions', 'read:trade:exchanges', 'read:trade:futures', 'write:trade:futures', 'read:trade:notifications', 'write:trade:notifications', 'read:trade:strategies', 'write:trade:strategies', 'read:pay:payments', 'read:pay:products', 'write:pay:products', 'read:pay:now', 'write:pay:now', 'read:metrics:marketcap', 'read:metrics:indicators', 'read:metrics:exchanges', 'read:metrics:tokens', 'read:metrics:markets', 'read:sentiment', 'read:klines', 'read:admin', 'write:admin')"
+                    "each list item must be one of ('read:predictions', 'read:dexsignals', 'read:hive:model', 'read:hive:data', 'write:hive:model', 'read:trade:bots', 'write:trade:bots', 'read:trade:exchangekeys', 'write:trade:exchangekeys', 'read:trade:orders', 'read:trade:actions', 'write:trade:actions', 'read:trade:exchanges', 'read:trade:futures', 'write:trade:futures', 'read:trade:notifications', 'write:trade:notifications', 'read:trade:strategies', 'write:trade:strategies', 'read:pay:payments', 'read:pay:products', 'write:pay:products', 'read:pay:now', 'write:pay:now', 'read:metrics:marketcap', 'read:metrics:indicators', 'read:metrics:exchanges', 'read:metrics:tokens', 'read:metrics:markets', 'read:sentiment', 'read:klines', 'read:admin', 'write:admin')"
                 )
         return value
 

crypticorn/auth/client/rest.py

@@ -77,6 +77,7 @@ class RESTClientObject:
 
         self.pool_manager: Optional[aiohttp.ClientSession] = None
         self.retry_client: Optional[aiohttp_retry.RetryClient] = None
+        self.is_sync: bool = False  # Track whether this is sync or async mode
 
     async def close(self) -> None:
         if self.pool_manager:
@@ -170,7 +171,9 @@ class RESTClientObject:
 
         pool_manager: Union[aiohttp.ClientSession, aiohttp_retry.RetryClient]
 
-        # https pool manager
+        # For sync operations, always use a fresh session
+        should_close_session = False
+
         if self.pool_manager is None:
             self.pool_manager = aiohttp.ClientSession(
                 connector=aiohttp.TCPConnector(
@@ -178,6 +181,9 @@ class RESTClientObject:
                 ),
                 trust_env=True,
             )
+            # Only close session automatically in sync mode
+            should_close_session = self.is_sync
+
         pool_manager = self.pool_manager
 
         if self.retries is not None and method in ALLOW_RETRY_METHODS:
@@ -193,6 +199,19 @@ class RESTClientObject:
                 )
             pool_manager = self.retry_client
 
-        r = await pool_manager.request(**args)
-
-        return RESTResponse(r)
+        try:
+            r = await pool_manager.request(**args)
+            # For sessions we're about to close, read the data immediately
+            if should_close_session:
+                response = RESTResponse(r)
+                await response.read()  # Read data before closing session
+                return response
+            else:
+                return RESTResponse(r)
+        finally:
+            if should_close_session:
+                if self.retry_client is not None:
+                    await self.retry_client.close()
+                    self.retry_client = None
+                await self.pool_manager.close()
+                self.pool_manager = None

crypticorn/auth/main.py

@@ -25,14 +25,17 @@ class AuthClient:
         self,
         config: Configuration,
         http_client: Optional[ClientSession] = None,
+        is_sync: bool = False,
     ):
         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
+        # Pass sync context to REST client for proper session management
+        self.base_client.rest_client.is_sync = is_sync
         # Instantiate all the endpoint clients
-        self.admin = AdminApi(self.base_client)
-        self.service = ServiceApi(self.base_client)
-        self.user = UserApi(self.base_client)
-        self.wallet = WalletApi(self.base_client)
-        self.login = AuthApi(self.base_client)
+        self.admin = AdminApi(self.base_client, is_sync=is_sync)
+        self.service = ServiceApi(self.base_client, is_sync=is_sync)
+        self.user = UserApi(self.base_client, is_sync=is_sync)
+        self.wallet = WalletApi(self.base_client, is_sync=is_sync)
+        self.login = AuthApi(self.base_client, is_sync=is_sync)

crypticorn/client.py

@@ -1,22 +1,31 @@
 from typing import TypeVar, Optional
+import asyncio
+import warnings
 from aiohttp import ClientSession, ClientTimeout, TCPConnector
 from crypticorn.hive import HiveClient
 from crypticorn.klines import KlinesClient
 from crypticorn.pay import PayClient
+
 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 crypticorn.common import (
+    BaseUrl,
+    ApiVersion,
+    Service,
+    apikey_header as aph,
+    CrypticornDeprecatedSince217,
+)
 from importlib.metadata import version
+from typing_extensions import deprecated
 
 ConfigT = TypeVar("ConfigT")
 SubClient = TypeVar("SubClient")
 
 
-class ApiClient:
+class BaseAsyncClient:
     """
-    The official Python client for interacting with the Crypticorn API.
-    It is consisting of multiple microservices covering the whole stack of the Crypticorn project.
+    Base class for Crypticorn API clients containing shared functionality.
     """
 
     def __init__(
@@ -24,20 +33,23 @@ class ApiClient:
         api_key: Optional[str] = None,
         jwt: Optional[str] = None,
         base_url: BaseUrl = BaseUrl.PROD,
-        *,
+        is_sync: bool = False,
         http_client: Optional[ClientSession] = None,
     ):
-        self.base_url = base_url
-        """The base URL the client will use to connect to the API."""
-        self.api_key = api_key
-        """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."""
-
+        """
+        :param api_key: The API key to use for authentication (recommended).
+        :param jwt: The JWT to use for authentication (not recommended).
+        :param base_url: The base URL the client will use to connect to the API.
+        :param is_sync: Whether this client should operate in synchronous mode.
+        :param http_client: Optional aiohttp ClientSession to use for HTTP requests.
+        """
+        self._base_url = base_url
+        self._api_key = api_key
+        self._jwt = jwt
+        self._is_sync = is_sync
         self._http_client = http_client
         self._owns_http_client = http_client is None  # whether we own the http client
+
         self._service_classes: dict[Service, type[SubClient]] = {
             Service.HIVE: HiveClient,
             Service.TRADE: TradeClient,
@@ -46,12 +58,69 @@ class ApiClient:
             Service.METRICS: MetricsClient,
             Service.AUTH: AuthClient,
         }
-        self._services: dict[Service, SubClient] = {
-            service: client_class(
-                self._get_default_config(service), http_client=self._http_client
-            )
-            for service, client_class in self._service_classes.items()
-        }
+
+        self._services: dict[Service, SubClient] = self._create_services()
+
+    def _create_services(self) -> dict[Service, SubClient]:
+        """Create services with the appropriate configuration based on sync/async mode."""
+        services = {}
+        for service, client_class in self._service_classes.items():
+            config = self._get_default_config(service)
+            # For sync clients, don't pass the persistent http_client
+            # Let each operation manage its own session
+            if self._is_sync:
+                services[service] = client_class(
+                    config, http_client=None, is_sync=self._is_sync
+                )
+            else:
+                services[service] = client_class(
+                    config, http_client=self._http_client, is_sync=self._is_sync
+                )
+        return services
+
+    @property
+    def base_url(self) -> BaseUrl:
+        """
+        The base URL the client will use to connect to the API.
+        """
+        return self._base_url
+
+    @property
+    def api_key(self) -> Optional[str]:
+        """
+        The API key the client will use to connect to the API.
+        This is the preferred way to authenticate.
+        """
+        return self._api_key
+
+    @property
+    def jwt(self) -> Optional[str]:
+        """
+        The JWT the client will use to connect to the API.
+        This is the not the preferred way to authenticate.
+        """
+        return self._jwt
+
+    @property
+    def version(self) -> str:
+        """
+        The version of the client.
+        """
+        return version("crypticorn")
+
+    @property
+    def is_sync(self) -> bool:
+        """
+        Whether this client operates in synchronous mode.
+        """
+        return self._is_sync
+
+    @property
+    def http_client(self) -> Optional[ClientSession]:
+        """
+        The HTTP client session being used, if any.
+        """
+        return self._http_client
 
     @property
     def hive(self) -> HiveClient:
@@ -95,17 +164,67 @@ class ApiClient:
         """
         return self._services[Service.AUTH]
 
+    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.
+
+        :param config: The new configuration to use for the sub-client.
+        :param service: The service to configure.
+
+        Example:
+        >>> # For async client
+        >>> async with AsyncClient() as client:
+        ...     client.configure(config=HiveConfig(host="http://localhost:8000"), service=Service.HIVE)
+        >>>
+        >>> # For sync client
+        >>> with SyncClient() as client:
+        ...     client.configure(config=HiveConfig(host="http://localhost:8000"), service=Service.HIVE)
+        """
+        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)
+
+        # Recreate service with new config and appropriate parameters
+        if self._is_sync:
+            self._services[service] = type(client)(
+                new_config, is_sync=self._is_sync, http_client=self._http_client
+            )
+        else:
+            self._services[service] = type(client)(
+                new_config, http_client=self._http_client
+            )
+
+    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}",
+            access_token=self.jwt,
+            api_key={aph.scheme_name: self.api_key} if self.api_key else None,
+        )
+
     async def close(self):
-        # close each in sync
+        """Close the client and clean up resources."""
+        # close each service
         for service in self._services.values():
-            if hasattr(service.base_client, "close") and self._owns_http_client:
+            if (
+                hasattr(service, "base_client")
+                and hasattr(service.base_client, "close")
+                and self._owns_http_client
+            ):
                 await service.base_client.close()
-        # close shared in async
+        # close shared http client if we own it
         if self._http_client and self._owns_http_client:
             await self._http_client.close()
             self._http_client = None
 
-    async def _ensure_session(self) -> None:
+    def _ensure_session(self) -> None:
         """
         Lazily create the shared HTTP client when first needed and pass it to all subclients.
         """
@@ -115,48 +234,97 @@ class ApiClient:
                 connector=TCPConnector(limit=100, limit_per_host=20),
                 headers={"User-Agent": f"crypticorn/python/{self.version}"},
             )
-            for service in self._services.values():
-                if hasattr(service, "base_client") and hasattr(
-                    service.base_client, "rest_client"
-                ):
-                    service.base_client.rest_client.pool_manager = self._http_client
+            # Update services to use the new session
+            self._services = self._create_services()
 
-    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}",
-            access_token=self.jwt,
-            api_key={aph.scheme_name: self.api_key} if self.api_key else None,
-        )
-
-    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.
 
-        :param config: The new configuration to use for the sub-client.
-        :param service: The service to configure.
+class AsyncClient(BaseAsyncClient):
+    """
+    The official async Python client for interacting with the Crypticorn API.
+    It is consisting of multiple microservices covering the whole stack of the Crypticorn project.
+    """
 
-        Example:
-        >>> async with ApiClient() as client:
-        ...     client.configure(config=HiveConfig(host="http://localhost:8000"), service=Service.HIVE)
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        jwt: Optional[str] = None,
+        base_url: BaseUrl = BaseUrl.PROD,
+        *,
+        http_client: Optional[ClientSession] = None,
+    ):
         """
-        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, http_client=self._http_client
-        )
+        :param api_key: The API key to use for authentication (recommended).
+        :param jwt: The JWT to use for authentication (not recommended).
+        :param base_url: The base URL the client will use to connect to the API.
+        :param http_client: The HTTP client to use for the client.
+        """
+        # Initialize as async client
+        super().__init__(api_key, jwt, base_url, is_sync=False, http_client=http_client)
+
+    async def close(self):
+        await super().close()
 
     async def __aenter__(self):
-        await self._ensure_session()
+        self._ensure_session()
         return self
 
     async def __aexit__(self, exc_type, exc_val, exc_tb):
         await self.close()
+
+
+@deprecated("Use AsyncClient instead", category=None)
+class ApiClient(AsyncClient):
+    def __init__(self, *args, **kwargs):
+        warnings.warn(
+            "ApiClient is deprecated. Use AsyncClient instead.",
+            CrypticornDeprecatedSince217,
+        )
+        super().__init__(*args, **kwargs)
+
+
+class SyncClient(BaseAsyncClient):
+    """
+    The official synchronous Python client for interacting with the Crypticorn API.
+    """
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        jwt: Optional[str] = None,
+        base_url: BaseUrl = BaseUrl.PROD,
+        *,
+        http_client: Optional[ClientSession] = None,
+    ):
+        """
+        :param http_client: Optional aiohttp ClientSession to use for HTTP requests.
+                          Note: For sync client, session management is handled automatically.
+        """
+        super().__init__(api_key, jwt, base_url, is_sync=True, http_client=http_client)
+
+    def close(self):
+        """Close the client and clean up resources."""
+        # For sync client, don't maintain persistent sessions
+        # Each operation creates its own session within async_to_sync
+        self._http_client = None
+
+    def _ensure_session(self) -> None:
+        """
+        For sync client, don't create persistent sessions.
+        Let each async_to_sync call handle its own session.
+        """
+        # Don't create persistent sessions in sync mode
+        # Each API call will handle session creation/cleanup within async_to_sync
+        pass
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()
+
+    def __del__(self):
+        """Automatic cleanup when the object is garbage collected."""
+        try:
+            self.close()
+        except Exception:
+            pass

crypticorn/common/__init__.py

@@ -16,4 +16,3 @@ from crypticorn.common.openapi import *
 from crypticorn.common.metrics import *
 from crypticorn.common.router.status_router import router as status_router
 from crypticorn.common.router.admin_router import router as admin_router
-

crypticorn/common/metrics.py

@@ -1,7 +1,5 @@
 # metrics/registry.py
-from prometheus_client import (
-    Counter, Gauge, Histogram, Summary, CollectorRegistry
-)
+from prometheus_client import Counter, Gauge, Histogram, Summary, CollectorRegistry
 
 registry = CollectorRegistry()
 
@@ -9,12 +7,12 @@ http_requests_total = Counter(
     "http_requests_total",
     "Total HTTP requests",
     ["method", "endpoint", "status_code"],
-    registry=registry
+    registry=registry,
 )
 
 http_request_duration_seconds = Histogram(
     "http_request_duration_seconds",
     "HTTP request duration in seconds",
     ["endpoint"],
-    registry=registry
-)
+    registry=registry,
+)

crypticorn/common/middleware.py

@@ -10,6 +10,7 @@ import warnings
 from crypticorn.common.warnings import CrypticornDeprecatedSince217
 from crypticorn.common.metrics import http_requests_total, http_request_duration_seconds
 
+
 class PrometheusMiddleware(BaseHTTPMiddleware):
     async def dispatch(self, request, call_next):
         start = time.perf_counter()
@@ -19,19 +20,22 @@ class PrometheusMiddleware(BaseHTTPMiddleware):
         http_requests_total.labels(
             method=request.method,
             endpoint=request.url.path,
-            status_code=response.status_code
+            status_code=response.status_code,
         ).inc()
 
-        http_request_duration_seconds.labels(
-            endpoint=request.url.path
-        ).observe(duration)
+        http_request_duration_seconds.labels(endpoint=request.url.path).observe(
+            duration
+        )
 
         return response
 
 
 @deprecated("Use add_middleware instead", category=None)
 def add_cors_middleware(app: "FastAPI"):
-    warnings.warn("add_cors_middleware is deprecated. Use add_middleware instead.", CrypticornDeprecatedSince217)
+    warnings.warn(
+        "add_cors_middleware is deprecated. Use add_middleware instead.",
+        CrypticornDeprecatedSince217,
+    )
     app.add_middleware(
         CORSMiddleware,
         allow_origins=[
@@ -44,6 +48,7 @@ def add_cors_middleware(app: "FastAPI"):
         allow_headers=["*"],
     )
 
+
 def add_middleware(app: "FastAPI"):
     app.add_middleware(
         CORSMiddleware,