crypticorn 2.7.4__py3-none-any.whl → 2.8.0__py3-none-any.whl

crypticorn/__init__.py

@@ -1,8 +1,15 @@
 """
 .. include:: ../README.md
-.. include:: ../CHANGELOG.md
+
+## Versioning
+We adhere to [Semantic Versioning](https://semver.org/).
+You can find the full Changelog [below](#changelog).
 """
 
+from crypticorn.common.logging import configure_logging
+
+configure_logging()
+
 from crypticorn.client import ApiClient
 
 __all__ = ["ApiClient"]

crypticorn/auth/client/models/create_api_key_request.py

@@ -78,10 +78,12 @@ class CreateApiKeyRequest(BaseModel):
                     "read:metrics:tokens",
                     "read:metrics:markets",
                     "read:sentiment",
+                    "read:admin",
+                    "write:admin",
                 ]
             ):
                 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')"
+                    "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:admin', 'write:admin')"
                 )
         return value
 

crypticorn/auth/client/models/get_api_keys200_response_inner.py

@@ -86,10 +86,12 @@ class GetApiKeys200ResponseInner(BaseModel):
                     "read:metrics:tokens",
                     "read:metrics:markets",
                     "read:sentiment",
+                    "read:admin",
+                    "write:admin",
                 ]
             ):
                 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')"
+                    "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:admin', 'write:admin')"
                 )
         return value
 

crypticorn/client.py

@@ -13,7 +13,7 @@ SubClient = TypeVar("SubClient")
 
 class ApiClient:
     """
-    The official client for interacting with the Crypticorn API.
+    The official Python client for interacting with the Crypticorn API.
 
     It is consisting of multiple microservices covering the whole stack of the Crypticorn project.
     """
@@ -27,11 +27,11 @@ class ApiClient:
         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."""
+        """The API key to use for authentication (recommended)."""
         self.jwt = jwt
-        """The JWT to use for authentication."""
+        """The JWT to use for authentication (not recommended)."""
 
-        self.service_classes: dict[Service, type[SubClient]] = {
+        self._service_classes: dict[Service, type[SubClient]] = {
             Service.HIVE: HiveClient,
             Service.TRADE: TradeClient,
             Service.KLINES: KlinesClient,
@@ -40,38 +40,56 @@ class ApiClient:
             Service.AUTH: AuthClient,
         }
 
-        self.services: dict[Service, SubClient] = {
+        self._services: dict[Service, SubClient] = {
             service: client_class(self._get_default_config(service))
-            for service, client_class in self.service_classes.items()
+            for service, client_class in self._service_classes.items()
         }
 
     @property
     def hive(self) -> HiveClient:
-        return self.services[Service.HIVE]
+        """
+        Entry point for the Hive AI API ([Docs](https://docs.crypticorn.com/api/?api=hive-ai-api)).
+        """
+        return self._services[Service.HIVE]
 
     @property
     def trade(self) -> TradeClient:
-        return self.services[Service.TRADE]
+        """
+        Entry point for the Trading API ([Docs](https://docs.crypticorn.com/api/?api=trading-api)).
+        """
+        return self._services[Service.TRADE]
 
     @property
     def klines(self) -> KlinesClient:
-        return self.services[Service.KLINES]
+        """
+        Entry point for the Klines API ([Docs](https://docs.crypticorn.com/api/?api=klines-api)).
+        """
+        return self._services[Service.KLINES]
 
     @property
     def metrics(self) -> MetricsClient:
-        return self.services[Service.METRICS]
+        """
+        Entry point for the Metrics API ([Docs](https://docs.crypticorn.com/api/?api=metrics-api)).
+        """
+        return self._services[Service.METRICS]
 
     @property
     def pay(self) -> PayClient:
-        return self.services[Service.PAY]
+        """
+        Entry point for the Payment API ([Docs](https://docs.crypticorn.com/api/?api=payment-api)).
+        """
+        return self._services[Service.PAY]
 
     @property
     def auth(self) -> AuthClient:
-        return self.services[Service.AUTH]
+        """
+        Entry point for the Auth API ([Docs](https://docs.crypticorn.com/api/?api=auth-api)).
+        """
+        return self._services[Service.AUTH]
 
     async def close(self):
         """Close all client sessions."""
-        for service in self.services.values():
+        for service in self._services.values():
             if hasattr(service.base_client, "close"):
                 await service.base_client.close()
 
@@ -81,7 +99,7 @@ class ApiClient:
         """
         Get the default configuration for a given service.
         """
-        config_class = self.service_classes[service].config_class
+        config_class = self._service_classes[service].config_class
         return config_class(
             host=f"{self.base_url}/{version}/{service}",
             access_token=self.jwt,
@@ -105,7 +123,7 @@ class ApiClient:
         >>>     client.configure(config=HiveConfig(host="http://localhost:8000"), client=client.hive)
         """
         assert Service.validate(service), f"Invalid service: {service}"
-        client = self.services[service]
+        client = self._services[service]
         new_config = client.config
 
         for attr in vars(config):
@@ -113,7 +131,7 @@ class ApiClient:
             if new_value:
                 setattr(new_config, attr, new_value)
 
-        self.services[service] = type(client)(new_config)
+        self._services[service] = type(client)(new_config)
 
     async def __aenter__(self):
         return self

crypticorn/common/__init__.py

@@ -8,4 +8,8 @@ from crypticorn.common.enums import *
 from crypticorn.common.utils import *
 from crypticorn.common.exceptions import *
 from crypticorn.common.pagination import *
-from crypticorn.common.status_router import router as status_router
+from crypticorn.common.logging import *
+from crypticorn.common.ansi_colors import *
+from crypticorn.common.middleware 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/ansi_colors.py

@@ -0,0 +1,37 @@
+from enum import StrEnum
+from typing import TYPE_CHECKING
+
+
+class AnsiColors(StrEnum):
+    # Regular Text Colors
+    BLACK = "\033[30m"  # black
+    RED = "\033[31m"  # red
+    GREEN = "\033[32m"  # green
+    YELLOW = "\033[33m"  # yellow
+    BLUE = "\033[34m"  # blue
+    MAGENTA = "\033[35m"  # magenta
+    CYAN = "\033[36m"  # cyan
+    WHITE = "\033[37m"  # white
+
+    # Bright Text Colors
+    BLACK_BRIGHT = "\033[90m"  # black_bright
+    RED_BRIGHT = "\033[91m"  # red_bright
+    GREEN_BRIGHT = "\033[92m"  # green_bright
+    YELLOW_BRIGHT = "\033[93m"  # yellow_bright
+    BLUE_BRIGHT = "\033[94m"  # blue_bright
+    MAGENTA_BRIGHT = "\033[95m"  # magenta_bright
+    CYAN_BRIGHT = "\033[96m"  # cyan_bright
+    WHITE_BRIGHT = "\033[97m"  # white_bright
+
+    # Bold Text Colors
+    BLACK_BOLD = "\033[1;30m"  # black_bold
+    RED_BOLD = "\033[1;31m"  # red_bold
+    GREEN_BOLD = "\033[1;32m"  # green_bold
+    YELLOW_BOLD = "\033[1;33m"  # yellow_bold
+    BLUE_BOLD = "\033[1;34m"  # blue_bold
+    MAGENTA_BOLD = "\033[1;35m"  # magenta_bold
+    CYAN_BOLD = "\033[1;36m"  # cyan_bold
+    WHITE_BOLD = "\033[1;37m"  # white_bold
+
+    # Reset Color
+    RESET = "\033[0m"

crypticorn/common/auth.py

@@ -75,7 +75,9 @@ class AuthHandler:
             raise HTTPException(
                 content=ExceptionContent(
                     error=ApiError.INSUFFICIENT_SCOPES,
-                    message="Insufficient scopes to access this resource",
+                    message="Insufficient scopes to access this resource (required: "
+                    + ", ".join(api_scopes)
+                    + ")",
                 ),
             )
 

crypticorn/common/exceptions.py

@@ -5,6 +5,10 @@ from fastapi import HTTPException as FastAPIHTTPException, Request, FastAPI
 from fastapi.exceptions import RequestValidationError, ResponseValidationError
 from fastapi.responses import JSONResponse
 from crypticorn.common import ApiError, ApiErrorIdentifier, ApiErrorType, ApiErrorLevel
+import logging
+import json
+
+logger = logging.getLogger("crypticorn")
 
 
 class ExceptionType(StrEnum):
@@ -89,37 +93,51 @@ class WebSocketException(HTTPException):
         )
 
 
-async def general_handler(request: Request, exc: Exception):
+async def general_handler(request: Request, exc: Exception) -> JSONResponse:
     """This is the default exception handler for all exceptions."""
     body = ExceptionContent(message=str(exc), error=ApiError.UNKNOWN_ERROR)
-    return JSONResponse(
-        status_code=body.enrich().status_code, content=HTTPException(content=body).detail
+    res = JSONResponse(
+        status_code=body.enrich().status_code,
+        content=HTTPException(content=body).detail,
     )
+    logger.error(f"Response validation error: {json.loads(res.__dict__.get('body'))}")
+    return res
 
 
-async def request_validation_handler(request: Request, exc: RequestValidationError):
+async def request_validation_handler(
+    request: Request, exc: RequestValidationError
+) -> JSONResponse:
     """This is the exception handler for all request validation errors."""
     body = ExceptionContent(message=str(exc), error=ApiError.INVALID_DATA_REQUEST)
-    return JSONResponse(
-        status_code=body.enrich().status_code, content=HTTPException(content=body).detail
+    res = JSONResponse(
+        status_code=body.enrich().status_code,
+        content=HTTPException(content=body).detail,
     )
+    logger.error(f"Response validation error: {json.loads(res.__dict__.get('body'))}")
+    return res
 
 
-async def response_validation_handler(request: Request, exc: ResponseValidationError):
+async def response_validation_handler(
+    request: Request, exc: ResponseValidationError
+) -> JSONResponse:
     """This is the exception handler for all response validation errors."""
     body = ExceptionContent(message=str(exc), error=ApiError.INVALID_DATA_RESPONSE)
-    return JSONResponse(
-        status_code=body.enrich().status_code, content=HTTPException(content=body).detail
+    res = JSONResponse(
+        status_code=body.enrich().status_code,
+        content=HTTPException(content=body).detail,
     )
+    logger.error(f"Response validation error: {json.loads(res.__dict__.get('body'))}")
+    return res
 
 
-async def http_handler(request: Request, exc: HTTPException):
+async def http_handler(request: Request, exc: HTTPException) -> JSONResponse:
     """This is the exception handler for HTTPExceptions. It unwraps the HTTPException and returns the detail in a flat JSON response."""
+    logger.error(f"HTTP error: {exc.detail}")
     return JSONResponse(status_code=exc.status_code, content=exc.detail)
 
 
 def register_exception_handlers(app: FastAPI):
-    """Utility to register serveral exception handlers in one go. Catches Exception, HTTPException and Data Validation errors and responds with a unified json body."""
+    """Utility to register serveral exception handlers in one go. Catches Exception, HTTPException and Data Validation errors, logs them and responds with a unified json body."""
     app.add_exception_handler(Exception, general_handler)
     app.add_exception_handler(FastAPIHTTPException, http_handler)
     app.add_exception_handler(RequestValidationError, request_validation_handler)

crypticorn/common/logging.py

@@ -0,0 +1,126 @@
+from __future__ import annotations
+
+# shared_logger.py
+import logging
+import sys
+from contextvars import ContextVar
+from contextlib import asynccontextmanager
+import json
+from pydantic import BaseModel
+from enum import StrEnum
+from crypticorn.common.mixins import ValidateEnumMixin
+from crypticorn.common.ansi_colors import AnsiColors as C
+from datetime import datetime
+import os
+
+
+class LogLevel(ValidateEnumMixin, StrEnum):
+    DEBUG = "DEBUG"
+    INFO = "INFO"
+    WARNING = "WARNING"
+    ERROR = "ERROR"
+    CRITICAL = "CRITICAL"
+
+    @classmethod
+    def get_color(cls, level: str) -> str:
+        if level == cls.DEBUG:
+            return C.GREEN_BRIGHT
+        elif level == cls.INFO:
+            return C.BLUE_BRIGHT
+        elif level == cls.WARNING:
+            return C.YELLOW_BRIGHT
+        elif level == cls.ERROR:
+            return C.RED_BRIGHT
+        elif level == cls.CRITICAL:
+            return C.RED_BOLD
+        else:
+            return C.RESET
+
+    @staticmethod
+    def get_level(level: "LogLevel") -> int:
+        return logging._nameToLevel.get(level, logging.INFO)
+
+    @staticmethod
+    def get_name(level: int) -> "LogLevel":
+        return LogLevel(logging._levelToName.get(level, "INFO"))
+
+
+_LOGFORMAT = (
+    f"{C.CYAN_BOLD}%(asctime)s{C.RESET} - "
+    f"{C.GREEN_BOLD}%(name)s{C.RESET} - "
+    f"%(levelcolor)s%(levelname)s{C.RESET} - "
+    f"%(message)s"
+)
+_DATEFMT = "%Y-%m-%d %H:%M:%S.%f:"
+
+
+class CustomFormatter(logging.Formatter):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def format(self, record):
+        color = LogLevel.get_color(record.levelname)
+        record.levelcolor = color
+        return super().format(record)
+
+    def formatTime(self, record, datefmt=_DATEFMT):
+        dt = datetime.fromtimestamp(record.created)
+        s = dt.strftime(datefmt)
+        return s[:-3]  # Trim last 3 digits to get milliseconds
+
+
+def configure_logging(
+    name: str = None,
+    fmt: str = _LOGFORMAT,
+    datefmt: str = _DATEFMT,
+    stdout_level: int = logging.INFO,
+    file_level: int = logging.INFO,
+    log_file: str = None,
+    filters: list[logging.Filter] = [],
+) -> None:
+    """Configures the logging for the application.
+    Run this function as early as possible in the application (for example using the `lifespan` parameter in FastAPI).
+    Then use can use the default `logging.getLogger(__name__)` method to get the logger (or <name> if you set the name parameter).
+    :param name: The name of the logger. If not provided, the root logger will be used. Use a name if you use multiple loggers in the same application.
+    :param fmt: The format of the log message.
+    :param datefmt: The date format of the log message.
+    :param stdout_level: The level of the log message to be printed to the console.
+    :param file_level: The level of the log message to be written to the file. Only used if `log_file` is provided.
+    :param log_file: The file to write the log messages to.
+    :param filters: A list of filters to apply to the log handlers.
+    """
+    logger = logging.getLogger(name) if name else logging.getLogger()
+
+    if logger.handlers:  # clear existing handlers to avoid duplicates
+        logger.handlers.clear()
+
+    logger.setLevel(min(stdout_level, file_level))  # set to most verbose level
+
+    # Configure stdout handler
+    stdout_handler = logging.StreamHandler(sys.stdout)
+    stdout_handler.setLevel(stdout_level)
+    stdout_handler.setFormatter(CustomFormatter(fmt=fmt, datefmt=datefmt))
+    for filter in filters:
+        stdout_handler.addFilter(filter)
+    logger.addHandler(stdout_handler)
+
+    # Configure file handler
+    if log_file:
+        os.makedirs(os.path.dirname(log_file), exist_ok=True)
+        file_handler = logging.handlers.RotatingFileHandler(
+            log_file, maxBytes=10 * 1024 * 1024, backupCount=5
+        )
+        file_handler.setLevel(file_level)
+        file_handler.setFormatter(CustomFormatter(fmt=fmt, datefmt=datefmt))
+        for filter in filters:
+            file_handler.addFilter(filter)
+        logger.addHandler(file_handler)
+
+    if name:
+        logger.propagate = False
+
+
+def disable_logging():
+    """Disable logging for the crypticorn logger."""
+    logger = logging.getLogger("crypticorn")
+    logger.disabled = True

crypticorn/common/middleware.py

@@ -0,0 +1,27 @@
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from crypticorn.common.logging import configure_logging
+import logging
+
+
+def add_cors_middleware(app: "FastAPI"):
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=[
+            "http://localhost:5173",  # vite dev server
+            "http://localhost:4173",  # vite preview server
+        ],
+        allow_origin_regex="^https://([a-zA-Z0-9-]+.)*crypticorn.(dev|com)/?$",  # matches (multiple or no) subdomains of crypticorn.dev and crypticorn.com
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+
+
+async def default_lifespan(app: FastAPI):
+    """Default lifespan for the applications.
+    This is used to configure the logging for the application.
+    To override this, pass a different lifespan to the FastAPI constructor or call this lifespan within a custom lifespan.
+    """
+    configure_logging()
+    yield

crypticorn/common/mixins.py

@@ -33,13 +33,14 @@ class ValidateEnumMixin:
             return False
 
 
+# This Mixin will be removed in a future version. And has no effect from now on
 class ExcludeEnumMixin:
     """Mixin to exclude enum from OpenAPI schema. We use this to avoid duplicating enums when generating client code from the openapi spec."""
 
     @classmethod
     def __get_pydantic_json_schema__(cls, core_schema, handler):
         schema = handler(core_schema)
-        schema.pop("enum", None)
+        # schema.pop("enum", None)
         return schema
 
 

crypticorn/common/router/admin_router.py

@@ -0,0 +1,100 @@
+"""
+This module contains the admin router for the API.
+It provides endpoints for monitoring the server and getting information about the environment.
+ONLY ALLOW ACCESS TO THIS ROUTER WITH ADMIN SCOPES.
+>>> app.include_router(admin_router, dependencies=[Security(auth_handler.combined_auth, scopes=[Scope.READ_ADMIN, Scope.WRITE_ADMIN])])
+"""
+
+import os
+import pkg_resources
+import threading
+import time
+import psutil
+from fastapi import APIRouter, Query
+from typing import Literal, Union
+from crypticorn.common.logging import LogLevel
+import logging
+
+router = APIRouter(tags=["Admin"], prefix="/admin")
+
+START_TIME = time.time()
+
+
+@router.get("/log-level", status_code=200, operation_id="getLogLevel", deprecated=True)
+async def get_logging_level() -> LogLevel:
+    """
+    Get the log level of the server logger. Will be removed in a future release.
+    """
+    return LogLevel.get_name(logging.getLogger().level)
+
+
+@router.get("/uptime", operation_id="getUptime", status_code=200)
+def get_uptime(type: Literal["seconds", "human"] = "seconds") -> str:
+    """Return the server uptime in seconds or human-readable form."""
+    uptime_seconds = int(time.time() - START_TIME)
+    if type == "seconds":
+        return str(uptime_seconds)
+    elif type == "human":
+        return time.strftime("%H:%M:%S", time.gmtime(uptime_seconds))
+
+
+@router.get("/memory", operation_id="getMemoryUsage", status_code=200)
+def get_memory_usage() -> float:
+    """
+    Resident Set Size (RSS) in MB — the actual memory used by the process in RAM.
+    Represents the physical memory footprint. Important for monitoring real usage.
+    """
+    process = psutil.Process(os.getpid())
+    mem_info = process.memory_info()
+    return round(mem_info.rss / (1024 * 1024), 2)
+
+
+@router.get("/threads", operation_id="getThreads", status_code=200)
+def get_threads() -> dict:
+    """Return count and names of active threads."""
+    threads = threading.enumerate()
+    return {
+        "count": len(threads),
+        "threads": [t.name for t in threads],
+    }
+
+
+@router.get("/limits", operation_id="getContainerLimits", status_code=200)
+def get_container_limits() -> dict:
+    """Return container resource limits from cgroup."""
+    limits = {}
+    try:
+        with open("/sys/fs/cgroup/memory/memory.limit_in_bytes") as f:
+            limits["memory_limit_MB"] = int(f.read().strip()) / 1024 / 1024
+    except Exception:
+        limits["memory_limit_MB"] = "N/A"
+
+    try:
+        with open("/sys/fs/cgroup/cpu/cpu.cfs_quota_us") as f1, open(
+            "/sys/fs/cgroup/cpu/cpu.cfs_period_us"
+        ) as f2:
+            quota = int(f1.read().strip())
+            period = int(f2.read().strip())
+            limits["cpu_limit_cores"] = quota / period if quota > 0 else "N/A"
+    except Exception:
+        limits["cpu_limit_cores"] = "N/A"
+
+    return limits
+
+
+@router.get("/dependencies", operation_id="getDependencies", status_code=200)
+def list_installed_packages(
+    include: list[str] = Query(
+        default=None,
+        description="List of dependencies to include in the response. If not provided, all installed packages will be returned.",
+    )
+) -> list:
+    """Return a list of installed packages and versions."""
+    return sorted(
+        [
+            {dist.project_name: dist.version}
+            for dist in pkg_resources.working_set
+            if include is None or dist.project_name in include
+        ],
+        key=lambda x: next(iter(x)),
+    )

crypticorn/common/router/status_router.py

@@ -0,0 +1,24 @@
+from datetime import datetime
+from typing import Literal
+from fastapi import APIRouter, Request
+
+router = APIRouter(tags=["Status"], prefix="")
+
+
+@router.get("/", operation_id="ping")
+async def ping(request: Request) -> dict:
+    """
+    Returns 'OK' if the API is running.
+    """
+    return {"origin": request.headers.get("x-forwarded-for")}
+
+
+@router.get("/time", operation_id="getTime")
+async def time(type: Literal["iso", "unix"] = "iso") -> str:
+    """
+    Returns the current time in either ISO or Unix timestamp (seconds) format.
+    """
+    if type == "iso":
+        return datetime.now().isoformat()
+    elif type == "unix":
+        return str(int(datetime.now().timestamp()))

crypticorn/common/scopes.py

@@ -8,6 +8,9 @@ class Scope(StrEnum):
 
     # If you update anything here, also update the scopes in the auth-service repository
 
+    WRITE_ADMIN = "write:admin"
+    READ_ADMIN = "read:admin"
+
     # Scopes that can be purchased - these actually exist in the jwt token
     READ_PREDICTIONS = "read:predictions"
 
@@ -55,6 +58,8 @@ class Scope(StrEnum):
         return [
             cls.WRITE_TRADE_STRATEGIES,
             cls.WRITE_PAY_PRODUCTS,
+            cls.WRITE_ADMIN,
+            cls.READ_ADMIN,
         ]
 
     @classmethod

crypticorn/hive/client/__init__.py

@@ -17,6 +17,7 @@ Do not edit the class manually.
 __version__ = "1.0.0"
 
 # import apis into sdk package
+from crypticorn.hive.client.api.admin_api import AdminApi
 from crypticorn.hive.client.api.data_api import DataApi
 from crypticorn.hive.client.api.models_api import ModelsApi
 from crypticorn.hive.client.api.status_api import StatusApi
@@ -33,12 +34,13 @@ from crypticorn.hive.client.exceptions import ApiAttributeError
 from crypticorn.hive.client.exceptions import ApiException
 
 # import models into sdk package
+from crypticorn.hive.client.models.api_error_identifier import ApiErrorIdentifier
+from crypticorn.hive.client.models.api_error_level import ApiErrorLevel
+from crypticorn.hive.client.models.api_error_type import ApiErrorType
 from crypticorn.hive.client.models.coins import Coins
 from crypticorn.hive.client.models.data_download_response import DataDownloadResponse
 from crypticorn.hive.client.models.data_info import DataInfo
-from crypticorn.hive.client.models.data_value_value_value_inner import (
-    DataValueValueValueInner,
-)
+from crypticorn.hive.client.models.data_options import DataOptions
 from crypticorn.hive.client.models.data_version import DataVersion
 from crypticorn.hive.client.models.data_version_info import DataVersionInfo
 from crypticorn.hive.client.models.download_links import DownloadLinks
@@ -46,6 +48,7 @@ from crypticorn.hive.client.models.evaluation import Evaluation
 from crypticorn.hive.client.models.evaluation_response import EvaluationResponse
 from crypticorn.hive.client.models.exception_detail import ExceptionDetail
 from crypticorn.hive.client.models.feature_size import FeatureSize
+from crypticorn.hive.client.models.log_level import LogLevel
 from crypticorn.hive.client.models.model import Model
 from crypticorn.hive.client.models.model_create import ModelCreate
 from crypticorn.hive.client.models.model_status import ModelStatus

crypticorn/hive/client/api/__init__.py

@@ -1,6 +1,7 @@
 # flake8: noqa
 
 # import apis into api package
+from crypticorn.hive.client.api.admin_api import AdminApi
 from crypticorn.hive.client.api.data_api import DataApi
 from crypticorn.hive.client.api.models_api import ModelsApi
 from crypticorn.hive.client.api.status_api import StatusApi