crypticorn 2.15.0__py3-none-any.whl → 2.17.0__py3-none-any.whl

{crypticorn-2.15.0.dist-info → crypticorn-2.17.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: crypticorn
-Version: 2.15.0
+Version: 2.17.0
 Summary: Maximise Your Crypto Trading Profits with Machine Learning
 Author-email: Crypticorn <timon@crypticorn.com>
 License-Expression: MIT
@@ -25,6 +25,8 @@ Requires-Dist: click<9.0.0,>=8.0.0
 Requires-Dist: psutil<8.0.0,>=7.0.0
 Requires-Dist: setuptools<81.0.0,>=80.0.0
 Requires-Dist: strenum
+Requires-Dist: prometheus-client<1.0.0,>=0.22.0
+Requires-Dist: asgiref<4.0.0,>=3.6.0
 Requires-Dist: urllib3<3.0.0,>=1.25.3
 Requires-Dist: python_dateutil<3.0.0,>=2.8.2
 Requires-Dist: aiohttp<4.0.0,>=3.8.4
@@ -49,6 +51,7 @@ Requires-Dist: pytest-asyncio==0.26.0; extra == "test"
 Requires-Dist: pytest-cov==6.1.1; extra == "test"
 Requires-Dist: python-dotenv==1.0.1; extra == "test"
 Requires-Dist: PyJWT==2.10.0; extra == "test"
+Requires-Dist: httpx>=0.27.0; extra == "test"
 Provides-Extra: extra
 Requires-Dist: pandas<3.0.0,>=2.2.0; extra == "extra"
 Dynamic: license-file
@@ -78,11 +81,15 @@ You can install extra dependencies grouped in the extras `extra`, `dev` (develop
 
 ## Structure
 
-Our API is available as an asynchronous Python SDK. The main entry point you need is the `ApiClient` class, which you would import like this:
+Our API is available as both an asynchronous and synchronous Python SDK. The main entry points are:
+
+- `AsyncClient` - Asynchronous client for async/await usage
+- `SyncClient` - Synchronous client for traditional blocking calls
+
 ```python
-from crypticorn import ApiClient
+from crypticorn import AsyncClient, SyncClient
 ```
-The ApiClient serves as the central interface for API operations. It instantiates multiple API wrappers corresponding to our micro services. These are structured the following:
+Both clients serve as the central interface for API operations and instantiate multiple API wrappers corresponding to our micro services. These are structured the following:
 
 <img src="static/pip-structure.svg" alt="pip package structure" />
 
@@ -110,20 +117,22 @@ There are scopes which don't follow this structure. Those are either scopes that
 
 ## Basic Usage
 
-You can use the client with the async context protocol...
+### Asynchronous Client
+
+You can use the async client with the context manager protocol...
 ```python
-async with ApiClient(api_key="your-api-key") as client:
-        await client.pay.products.get_products()
+async with AsyncClient(api_key="your-api-key") as client:
+    await client.pay.products.get_products()
 ```
 ...or without it like this...
 ```python
-client = ApiClient(api_key="your-api-key")
-asyncio.run(client.pay.models.get_products())
+client = AsyncClient(api_key="your-api-key")
+asyncio.run(client.pay.products.get_products())
 asyncio.run(client.close())
 ```
 ...or this.
 ```python
-client = ApiClient(api_key="your-api-key")
+client = AsyncClient(api_key="your-api-key")
 
 async def main():
     await client.pay.products.get_products()
@@ -132,6 +141,29 @@ asyncio.run(main())
 asyncio.run(client.close())
 ```
 
+### Synchronous Client
+
+For traditional synchronous usage without async/await, use the `SyncClient`:
+
+```python
+from crypticorn import SyncClient
+
+# With context manager (recommended)
+with SyncClient(api_key="your-api-key") as client:
+    products = client.pay.products.get_products()
+    status = client.trade.status.ping()
+
+# Or without context manager
+client = SyncClient(api_key="your-api-key")
+try:
+    products = client.pay.products.get_products()
+    status = client.trade.status.ping()
+finally:
+    client.close()  # Manual cleanup required
+```
+
+The sync client provides the same API surface as the async client, but all methods return results directly instead of coroutines. Under the hood, it uses `asgiref.async_to_sync` to bridge async operations to synchronous calls, ensuring reliable operation without requiring async/await syntax.
+
 ## Response Types
 
 There are three different available output formats you can choose from:
@@ -139,7 +171,10 @@ There are three different available output formats you can choose from:
 ### Serialized Response
 You can get fully serialized responses as pydantic models. Using this, you get the full benefits of pydantic's type checking.
 ```python
+# Async client
 res = await client.pay.products.get_products()
+# Sync client  
+res = client.pay.products.get_products()
 print(res)
 ```
 The output would look like this:
@@ -149,7 +184,10 @@ The output would look like this:
 
 ### Serialized Response with HTTP Info
 ```python
+# Async client
 res = await client.pay.products.get_products_with_http_info()
+# Sync client
+res = client.pay.products.get_products_with_http_info()
 print(res)
 ```
 The output would look like this:
@@ -170,8 +208,12 @@ print(res.headers)
 ### JSON Response
 You can receive a classical JSON response by suffixing the function name with `_without_preload_content`
 ```python
+# Async client
 response = await client.pay.products.get_products_without_preload_content()
 print(await response.json())
+
+# Sync client - Note: use regular methods instead as response.json() returns a coroutine
+response = client.pay.products.get_products_without_preload_content()
 ```
 The output would look like this:
 ```python
@@ -201,33 +243,36 @@ To override e.g. the host for the Hive client to connect to localhost:8000 inste
 from crypticorn.hive import Configuration as HiveConfig
 from crypticorn.common import Service
 
-async with ApiClient() as client:
+# Async client
+async with AsyncClient() as client:
+    client.configure(config=HiveConfig(host="http://localhost:8000"), service=Service.HIVE)
+
+# Sync client
+with SyncClient() as client:
     client.configure(config=HiveConfig(host="http://localhost:8000"), service=Service.HIVE)
 ```
 
 ### Session Management
 
-By default, `ApiClient` manages a single shared `aiohttp.ClientSession` for all service wrappers.  
+By default, `AsyncClient` manages a single shared `aiohttp.ClientSession` for all service wrappers.  
 However, you can pass your own pre-configured `aiohttp.ClientSession` if you need advanced control — for example, to add retries, custom headers, logging, or mocking behavior.
 
 When you inject a custom session, you are responsible for managing its lifecycle, including closing when you're done.
 
 ```python
 import aiohttp
-from crypticorn import ApiClient
+from crypticorn import AsyncClient
 
 async def main():
     custom_session = aiohttp.ClientSession()
-    async with ApiClient(api_key="your-key", http_client=custom_session) as client:
+    async with AsyncClient(api_key="your-key", http_client=custom_session) as client:
         await client.trade.status.ping()
     await custom_session.close()
-    # or
-    custom_session = aiohttp.ClientSession()
-    client = ApiClient(api_key="your-key", http_client=custom_session)
-    await client.trade.status.ping()
-    await custom_session.close()
+
 ```
-If you don’t pass a session, `ApiClient` will create and manage one internally. In that case, it will be automatically closed when using `async with` or when calling `await client.close()` manually.
+If you don’t pass a session, `AsyncClient` will create and manage one internally. In that case, it will be automatically closed when using `async with` or when calling `await client.close()` manually.
+
+**Note on Sync Client**: The `SyncClient` uses per-operation sessions (creates and closes a session for each API call) to ensure reliable synchronous behavior. Custom sessions are accepted but not used. This approach prevents event loop conflicts at the cost of slightly higher overhead per operation.
 
 ### Disable Logging