crypticorn 2.1.5__tar.gz → 2.2.0__tar.gz

crypticorn-2.2.0/PKG-INFO

@@ -0,0 +1,146 @@
+Metadata-Version: 2.4
+Name: crypticorn
+Version: 2.2.0
+Summary: Maximise Your Crypto Trading Profits with AI Predictions
+Author-email: Crypticorn <timon@crypticorn.com>
+Project-URL: Homepage, https://crypticorn.com
+Keywords: machine learning,data science,crypto,modelling
+Classifier: Topic :: Scientific/Engineering
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: fastapi
+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
+Requires-Dist: aiohttp-retry<3.0.0,>=2.8.3
+Requires-Dist: pydantic<3.0.0,>=2.0.0
+Requires-Dist: typing-extensions<5.0.0,>=4.7.1
+Requires-Dist: pandas<3.0.0,>=2.2.0
+Requires-Dist: requests<3.0.0,>=2.32.0
+Requires-Dist: tqdm<5.0.0,>=4.67.0
+Provides-Extra: dev
+Requires-Dist: streamlit; extra == "dev"
+Requires-Dist: httpx; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Requires-Dist: pyflakes; extra == "dev"
+Provides-Extra: test
+Requires-Dist: pytest==8.3.5; extra == "test"
+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"
+
+# What is Crypticorn?
+
+Crypticorn is at the forefront of cutting-edge artificial intelligence cryptocurrency trading.
+Crypticorn offers AI-based solutions for both active and passive investors, including:
+ - Prediction Dashboard with trading terminal,
+ - AI Agents with different strategies,
+ - DEX AI Signals for newly launched tokens,
+ - DEX AI Bots
+
+Use this API Client to contribute to the so-called Hive AI, a community driven AI Meta Model for predicting the
+cryptocurrency market.
+
+## Installation
+
+You can install the latest stable version from PyPi:
+```bash
+pip install crypticorn
+```
+
+If you want a specific version, run:
+```bash
+pip install crypticorn==2.0.0
+```
+
+If you want the latest version, which could be a pre release, run:
+```bash
+pip install --pre crypticorn
+```
+
+## 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:
+```python
+from crypticorn import ApiClient
+```
+
+## Usage
+
+### With Async Context Protocol
+```python
+async with ApiClient(base_url=BaseUrl.Prod, api_key="your-api-key") as client:
+        await client.pay.products.get_products()
+```
+
+### Without Async Context Protocol
+Without the context you need to close the session manually.
+```python
+client = ApiClient(base_url=BaseUrl.Prod, api_key="your-api-key")
+asyncio.run(client.pay.models.get_products())
+asyncio.run(client.close())
+```
+
+## Response Types
+
+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
+response = await client.pay.products.get_products()
+print(response)
+```
+The output would look like this:
+```python
+[ProductModel(id='67e8146e7bae32f3838fe36a', name='Awesome Product', price=5.0, scopes=None, duration=30, description='You need to buy this', is_active=True)]
+```
+
+### Serialized Response with HTTP Info
+```python
+await client.pay.products.get_products_with_http_info()
+print(res)
+```
+The output would look like this:
+```python
+status_code=200 headers={'Date': 'Wed, 09 Apr 2025 19:15:19 GMT', 'Content-Type': 'application/json', 'Transfer-Encoding': 'chunked', 'Connection': 'keep-alive', 'Alt-Svc': 'h3=":443"; ma=86400', 'Server': 'cloudflare', 'Cf-Cache-Status': 'DYNAMIC', 'Content-Encoding': 'gzip', 'CF-RAY': '92dc551a687bbe5e-ZRH'} data=[ProductModel(id='67e8146e7bae32f3838fe36a', name='Awesome Product', price=5.0, scopes=None, duration=30, description='You need to buy this', is_active=True)] raw_data=b'[{"id":"67e8146e7bae32f3838fe36a","name":"Awesome Product","price":5.0,"duration":30,"description":"You need to buy this","is_active":true}]'
+```
+You can then access the data of the response (as serialized output) with:
+```python
+print(res.data)
+```
+On top of that you get some information about the request:
+```python
+print(res.status_code)
+print(res.raw_data)
+print(res.headers)
+
+
+### JSON Response
+You can receive a classical JSON response by suffixing the function name with `_without_preload_content`
+```python
+response = await client.pay.products.get_products_without_preload_content()
+print(await response.json())
+```
+The output would look like this:
+```python
+[{'id': '67e8146e7bae32f3838fe36a', 'name': 'Awesome Product', 'price': 5.0, 'duration': 30, 'description': 'You need to buy this', 'is_active': True}]
+```
+
+## Advanced Usage
+
+You can override some configuration for specific sub clients. If just want to use the API as is you don't need to configure anything.
+This might be of use if you are testing a specific API locally.
+
+This will override the host for the Hive client to connect to http://localhost:8000 instead of the default caddy proxy:
+```python
+async with ApiClient(base_url=BaseUrl.DEV, jwt=jwt) as client:
+        client.configure(config=HiveConfig(host="http://localhost:8000"), sub_client=client.hive)
+```

crypticorn-2.2.0/README.md

@@ -0,0 +1,108 @@
+# What is Crypticorn?
+
+Crypticorn is at the forefront of cutting-edge artificial intelligence cryptocurrency trading.
+Crypticorn offers AI-based solutions for both active and passive investors, including:
+ - Prediction Dashboard with trading terminal,
+ - AI Agents with different strategies,
+ - DEX AI Signals for newly launched tokens,
+ - DEX AI Bots
+
+Use this API Client to contribute to the so-called Hive AI, a community driven AI Meta Model for predicting the
+cryptocurrency market.
+
+## Installation
+
+You can install the latest stable version from PyPi:
+```bash
+pip install crypticorn
+```
+
+If you want a specific version, run:
+```bash
+pip install crypticorn==2.0.0
+```
+
+If you want the latest version, which could be a pre release, run:
+```bash
+pip install --pre crypticorn
+```
+
+## 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:
+```python
+from crypticorn import ApiClient
+```
+
+## Usage
+
+### With Async Context Protocol
+```python
+async with ApiClient(base_url=BaseUrl.Prod, api_key="your-api-key") as client:
+        await client.pay.products.get_products()
+```
+
+### Without Async Context Protocol
+Without the context you need to close the session manually.
+```python
+client = ApiClient(base_url=BaseUrl.Prod, api_key="your-api-key")
+asyncio.run(client.pay.models.get_products())
+asyncio.run(client.close())
+```
+
+## Response Types
+
+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
+response = await client.pay.products.get_products()
+print(response)
+```
+The output would look like this:
+```python
+[ProductModel(id='67e8146e7bae32f3838fe36a', name='Awesome Product', price=5.0, scopes=None, duration=30, description='You need to buy this', is_active=True)]
+```
+
+### Serialized Response with HTTP Info
+```python
+await client.pay.products.get_products_with_http_info()
+print(res)
+```
+The output would look like this:
+```python
+status_code=200 headers={'Date': 'Wed, 09 Apr 2025 19:15:19 GMT', 'Content-Type': 'application/json', 'Transfer-Encoding': 'chunked', 'Connection': 'keep-alive', 'Alt-Svc': 'h3=":443"; ma=86400', 'Server': 'cloudflare', 'Cf-Cache-Status': 'DYNAMIC', 'Content-Encoding': 'gzip', 'CF-RAY': '92dc551a687bbe5e-ZRH'} data=[ProductModel(id='67e8146e7bae32f3838fe36a', name='Awesome Product', price=5.0, scopes=None, duration=30, description='You need to buy this', is_active=True)] raw_data=b'[{"id":"67e8146e7bae32f3838fe36a","name":"Awesome Product","price":5.0,"duration":30,"description":"You need to buy this","is_active":true}]'
+```
+You can then access the data of the response (as serialized output) with:
+```python
+print(res.data)
+```
+On top of that you get some information about the request:
+```python
+print(res.status_code)
+print(res.raw_data)
+print(res.headers)
+
+
+### JSON Response
+You can receive a classical JSON response by suffixing the function name with `_without_preload_content`
+```python
+response = await client.pay.products.get_products_without_preload_content()
+print(await response.json())
+```
+The output would look like this:
+```python
+[{'id': '67e8146e7bae32f3838fe36a', 'name': 'Awesome Product', 'price': 5.0, 'duration': 30, 'description': 'You need to buy this', 'is_active': True}]
+```
+
+## Advanced Usage
+
+You can override some configuration for specific sub clients. If just want to use the API as is you don't need to configure anything.
+This might be of use if you are testing a specific API locally.
+
+This will override the host for the Hive client to connect to http://localhost:8000 instead of the default caddy proxy:
+```python
+async with ApiClient(base_url=BaseUrl.DEV, jwt=jwt) as client:
+        client.configure(config=HiveConfig(host="http://localhost:8000"), sub_client=client.hive)
+```

crypticorn-2.2.0/crypticorn/auth/main.py

@@ -0,0 +1,28 @@
+from crypticorn.auth import (
+    ApiClient,
+    Configuration,
+    AdminApi,
+    ServiceApi,
+    UserApi,
+    WalletApi,
+    AuthApi,
+)
+
+
+class AuthClient:
+    """
+    A client for interacting with the Crypticorn Auth API.
+    """
+
+    def __init__(
+        self,
+        config: Configuration,
+    ):
+        self.config = config
+        self.base_client = ApiClient(configuration=self.config)
+        # 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)

crypticorn-2.2.0/crypticorn/client.py

@@ -0,0 +1,107 @@
+from crypticorn.hive import HiveClient, Configuration
+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
+import warnings
+class ApiClient:
+    """
+    The official 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,
+        base_url: BaseUrl = BaseUrl.PROD,
+    ):
+        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.'''
+        self.jwt = jwt
+        '''The JWT to use for authentication.'''
+
+        self.hive = HiveClient(self._get_default_config(Service.HIVE))
+        self.trade = TradeClient(self._get_default_config(Service.TRADE))
+        self.klines = KlinesClient(self._get_default_config(Service.KLINES))
+        self.pay = PayClient(self._get_default_config(Service.PAY))
+        self.metrics = MetricsClient(self._get_default_config(Service.METRICS))
+        self.auth = AuthClient(self._get_default_config(Service.AUTH)) 
+
+    def __new__(cls, *args, **kwargs):
+        if kwargs.get("api_key") and not kwargs.get("jwt"):
+            # auth-service does not allow api_key
+            warnings.warn("The auth module does only accept JWT to be used to authenticate. If you use this module, you need to provide a JWT.")
+        return super().__new__(cls)
+    
+    async def close(self):
+        """Close all client sessions."""
+        clients = [
+            self.hive.base_client,
+            self.trade.base_client,
+            self.klines.base_client,
+            self.pay.base_client,
+            self.metrics.base_client,
+            self.auth.base_client,
+        ]
+
+        for client in clients:
+            if hasattr(client, "close"):
+                await client.close()
+
+    def _get_default_config(self, service: Service, version: ApiVersion = ApiVersion.V1):
+        """
+        Get the default configuration for a given service.
+        """
+        return Configuration(
+            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,
+            api_key_prefix=({aph.scheme_name: aph.model.name} if self.api_key else None),
+        )
+    
+    def configure(self, config: Configuration, sub_client: any):
+        """
+        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 sub_client: The sub-client to configure.
+
+        Example:
+        This will override the host for the Hive client to connect to http://localhost:8000 instead of the default proxy:
+        >>> async with ApiClient(base_url=BaseUrl.DEV, jwt=jwt) as client:
+        >>>     client.configure(config=HiveConfig(host="http://localhost:8000"), sub_client=client.hive)
+        """
+        new_config = sub_client.config
+        for attr in vars(config):
+            new_value = getattr(config, attr)
+            if new_value is not None:
+                setattr(new_config, attr, new_value)
+
+        if sub_client == self.hive:
+            self.hive = HiveClient(new_config)
+        elif sub_client == self.trade:
+            self.trade = TradeClient(new_config)
+        elif sub_client == self.klines:
+            self.klines = KlinesClient(new_config)
+        elif sub_client == self.pay:
+            self.pay = PayClient(new_config)
+        elif sub_client == self.metrics:
+            self.metrics = MetricsClient(new_config)
+        elif sub_client == self.auth:
+            self.auth = AuthClient(new_config)
+        else:
+            raise ValueError(f"Unknown sub-client: {sub_client}")
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self.close()
+

{crypticorn-2.1.5 → crypticorn-2.2.0}/crypticorn/common/__init__.py

@@ -1,5 +1,4 @@
 from crypticorn.common.errors import *
 from crypticorn.common.scopes import *
 from crypticorn.common.urls import *
-from crypticorn.common.auth import *
-from crypticorn.common.auth_client import *
+from crypticorn.common.auth import *

crypticorn-2.1.5/crypticorn/common/auth_client.py → crypticorn-2.2.0/crypticorn/common/auth.py

@@ -1,46 +1,51 @@
-from fastapi import Depends, HTTPException, Query, status
-from fastapi.security import HTTPAuthorizationCredentials, SecurityScopes
-from typing_extensions import Annotated, Doc
 import json
 
-from crypticorn.auth import AuthClient, Verify200Response
+from crypticorn.auth import Verify200Response, AuthClient, Configuration
 from crypticorn.auth.client.exceptions import ApiException
 from crypticorn.common import (
     ApiError,
-    Scope,
     ApiVersion,
-    BaseURL,
-    Domain,
-    apikey_header,
-    http_bearer,
+    BaseUrl,
+    Scope,
+    Service,
+)
+from fastapi import Depends, HTTPException, Query, status
+from fastapi.security import (
+    HTTPAuthorizationCredentials,
+    SecurityScopes,
+    HTTPBearer,
+    APIKeyHeader,
 )
+from typing_extensions import Annotated
 
+# Auth Schemes
+http_bearer = HTTPBearer(
+    bearerFormat="JWT",
+    auto_error=False,
+    description="The JWT to use for authentication.",
+)
+
+apikey_header = APIKeyHeader(
+    name="X-API-Key",
+    auto_error=False,
+    description="The API key to use for authentication.",
+)
 
+# Auth Handler
 class AuthHandler:
     """
-    Middleware for verifying API requests. Verifies the validity of the authentication token, allowed scopes, etc.
+    Middleware for verifying API requests. Verifies the validity of the authentication token, scopes, etc.
+
+    @param base_url: The base URL of the API.
+    @param api_version: The version of the API.
     """
 
     def __init__(
         self,
-        base_url: Annotated[
-            BaseURL, Doc("The base URL for the auth service.")
-        ] = BaseURL.PROD,
-        api_version: Annotated[
-            ApiVersion, Doc("The API version of the auth service.")
-        ] = ApiVersion.V1,
-        whitelist: Annotated[
-            list[Domain],
-            Doc(
-                "The domains of which requests are allowed full access to the service."
-            ),
-        ] = [
-            Domain.PROD,
-            Domain.DEV,
-        ],  # TODO: decide whether this is needed, else omit
+        base_url: BaseUrl = BaseUrl.PROD,
     ):
-        self.whitelist = whitelist
-        self.auth_client = AuthClient(base_url=base_url, api_version=api_version)
+        self.url = f"{base_url}/{ApiVersion.V1}/{Service.AUTH}"
+        self.client = AuthClient(Configuration(host=self.url))
 
         self.no_credentials_exception = HTTPException(
             status_code=status.HTTP_401_UNAUTHORIZED,
@@ -51,7 +56,7 @@ class AuthHandler:
         """
         Verifies the API key.
         """
-        return await self.auth_client.login.verify_api_key(api_key)
+        return await self.client.login.verify_api_key(api_key)
 
     async def _verify_bearer(
         self, bearer: HTTPAuthorizationCredentials
@@ -59,8 +64,8 @@ class AuthHandler:
         """
         Verifies the bearer token.
         """
-        self.auth_client.config.access_token = bearer.credentials
-        return await self.auth_client.login.verify()
+        self.client.config.access_token = bearer.credentials
+        return await self.client.login.verify()
 
     async def _validate_scopes(
         self, api_scopes: list[Scope], user_scopes: list[Scope]

{crypticorn-2.1.5 → crypticorn-2.2.0}/crypticorn/common/scopes.py

@@ -1,7 +1,7 @@
-from enum import Enum
+from enum import StrEnum
 
 
-class Scope(str, Enum):
+class Scope(StrEnum):
     """
     The permission scopes for the API.
     """

crypticorn-2.2.0/crypticorn/common/urls.py

@@ -0,0 +1,37 @@
+from enum import StrEnum
+
+class ApiEnv(StrEnum):
+    PROD = "prod"
+    DEV = "dev"
+    LOCAL = "local"
+    DOCKER = "docker"
+
+class BaseUrl(StrEnum):
+    PROD = "https://api.crypticorn.com"
+    DEV = "https://api.crypticorn.dev"
+    LOCAL = "http://localhost"
+    DOCKER = "http://host.docker.internal"
+
+    @classmethod
+    def from_env(cls, env: ApiEnv) -> "BaseUrl":
+        if env == ApiEnv.PROD:
+            return cls.PROD
+        elif env == ApiEnv.DEV:
+            return cls.DEV
+        elif env == ApiEnv.LOCAL:
+            return cls.LOCAL
+        elif env == ApiEnv.DOCKER:
+            return cls.DOCKER
+
+
+class ApiVersion(StrEnum):
+    V1 = "v1"
+
+
+class Service(StrEnum):
+    HIVE = "hive"
+    KLINES = "klines"
+    PAY = "pay"
+    TRADE = "trade"
+    AUTH = "auth"
+    METRICS = "metrics"

crypticorn-2.2.0/crypticorn/hive/main.py

@@ -0,0 +1,26 @@
+from crypticorn.hive import (
+    ApiClient,
+    Configuration,
+    ModelsApi,
+    DataApi,
+    StatusApi,
+    Configuration,
+)
+from crypticorn.common import apikey_header as aph
+
+
+class HiveClient:
+    """
+    A client for interacting with the Crypticorn Hive API.
+    """
+
+    def __init__(
+        self,
+        config: Configuration,
+    ):
+        self.config = config
+        self.base_client = ApiClient(configuration=self.config)
+        # Instantiate all the endpoint clients
+        self.models = ModelsApi(self.base_client)
+        self.data = DataApi(self.base_client)
+        self.status = StatusApi(self.base_client)

{crypticorn-2.1.5 → crypticorn-2.2.0}/crypticorn/klines/client/configuration.py

@@ -191,7 +191,7 @@ class Configuration:
     ) -> None:
         """Constructor"""
         self._base_path = (
-            "https://api.crypticorn.dev/v1/klines" if host is None else host
+            "http://localhost/v1/klines" if host is None else host
         )
         """Default Base url
         """
@@ -516,7 +516,7 @@ class Configuration:
         """
         return [
             {
-                "url": "https://api.crypticorn.dev/v1/klines",
+                "url": "http://localhost/v1/klines",
                 "description": "No description provided",
             }
         ]

{crypticorn-2.1.5 → crypticorn-2.2.0}/crypticorn/klines/main.py

@@ -8,7 +8,6 @@ from crypticorn.klines import (
     SymbolsApi,
     UDFApi,
 )
-from crypticorn.common import BaseURL, ApiVersion, Service, apikey_header as aph
 
 
 class FundingRatesApiWrapper(FundingRatesApi):
@@ -58,18 +57,9 @@ class KlinesClient:
 
     def __init__(
         self,
-        base_url: BaseURL,
-        api_version: ApiVersion,
-        api_key: str = None,
-        jwt: str = None,
+        config: Configuration,
     ):
-        self.host = f"{base_url.value}/{api_version.value}/{Service.KLINES.value}"
-        self.config = Configuration(
-            host=self.host,
-            access_token=jwt,
-            api_key={aph.scheme_name: api_key} if api_key else None,
-            api_key_prefix=({aph.scheme_name: aph.model.name} if api_key else None),
-        )
+        self.config = config
         self.base_client = ApiClient(configuration=self.config)
         # Instantiate all the endpoint clients
         self.funding = FundingRatesApiWrapper(self.base_client)

crypticorn-2.2.0/crypticorn/metrics/__init__.py

@@ -0,0 +1,4 @@
+from crypticorn.metrics.client import *
+from crypticorn.metrics.main import MetricsClient
+
+__all__ = ["MetricsClient", ]