crypticorn 2.17.0rc6__py3-none-any.whl → 2.18.0__py3-none-any.whl

crypticorn/common/errors.py

@@ -1,8 +1,9 @@
 """Comprehensive error handling system defining various API error types, HTTP exceptions, and error content structures."""
 
 from enum import Enum
-from fastapi import status
+
 from crypticorn.common.mixins import ApiErrorFallback
+from fastapi import status
 
 try:
     from enum import StrEnum
@@ -80,8 +81,6 @@ class ApiErrorIdentifier(StrEnum):
     LIQUIDATION_PRICE_VIOLATION = "order_violates_liquidation_price_constraints"
     MARGIN_MODE_CLASH = "margin_mode_clash"
     NAME_NOT_UNIQUE = "name_not_unique"
-    NO_API_KEY = "no_api_key"
-    NO_BEARER = "no_bearer"
     NO_CREDENTIALS = "no_credentials"
     NOW_API_DOWN = "now_api_down"
     OBJECT_ALREADY_EXISTS = "object_already_exists"
@@ -353,16 +352,6 @@ class ApiError(Enum, metaclass=ApiErrorFallback):
         ApiErrorType.USER_ERROR,
         ApiErrorLevel.ERROR,
     )
-    NO_API_KEY = (
-        ApiErrorIdentifier.NO_API_KEY,
-        ApiErrorType.USER_ERROR,
-        ApiErrorLevel.ERROR,
-    )
-    NO_BEARER = (
-        ApiErrorIdentifier.NO_BEARER,
-        ApiErrorType.USER_ERROR,
-        ApiErrorLevel.ERROR,
-    )
     NO_CREDENTIALS = (
         ApiErrorIdentifier.NO_CREDENTIALS,
         ApiErrorType.USER_ERROR,
@@ -565,6 +554,11 @@ class ApiError(Enum, metaclass=ApiErrorFallback):
         """WebSocket status code for the error."""
         return StatusCodeMapper.get_websocket_code(self)
 
+    @classmethod
+    def from_json(cls, data: dict) -> "ApiError":
+        """Load an ApiError from a dictionary. Must contain the identifier with the key 'code'."""
+        return next(error for error in cls if error.identifier == data["code"])
+
 
 class StatusCodeMapper:
     """Mapping of API errors to HTTP/Websocket status codes."""
@@ -595,14 +589,6 @@ class StatusCodeMapper:
             status.HTTP_401_UNAUTHORIZED,
             status.WS_1008_POLICY_VIOLATION,
         ),
-        ApiError.NO_API_KEY: (
-            status.HTTP_401_UNAUTHORIZED,
-            status.WS_1008_POLICY_VIOLATION,
-        ),
-        ApiError.NO_BEARER: (
-            status.HTTP_401_UNAUTHORIZED,
-            status.WS_1008_POLICY_VIOLATION,
-        ),
         ApiError.INSUFFICIENT_SCOPES: (
             status.HTTP_403_FORBIDDEN,
             status.WS_1008_POLICY_VIOLATION,

crypticorn/common/exceptions.py

@@ -1,11 +1,19 @@
-from typing import Optional, Dict, Any
-from pydantic import BaseModel, Field
-from fastapi import HTTPException as FastAPIHTTPException, Request, FastAPI
+import json
+import logging
+from typing import Any, Optional
+
+from crypticorn.common.errors import (
+    ApiError,
+    ApiErrorIdentifier,
+    ApiErrorLevel,
+    ApiErrorType,
+)
+from fastapi import FastAPI
+from fastapi import HTTPException as FastAPIHTTPException
+from fastapi import Request
 from fastapi.exceptions import RequestValidationError, ResponseValidationError
 from fastapi.responses import JSONResponse
-from crypticorn.common import ApiError, ApiErrorIdentifier, ApiErrorType, ApiErrorLevel
-import logging
-import json
+from pydantic import BaseModel, Field
 
 try:
     from enum import StrEnum
@@ -66,7 +74,7 @@ class HTTPException(FastAPIHTTPException):
     def __init__(
         self,
         content: ExceptionContent,
-        headers: Optional[Dict[str, str]] = None,
+        headers: Optional[dict[str, str]] = None,
         _type: Optional[_ExceptionType] = _ExceptionType.HTTP,
     ):
         self.content = content
@@ -86,7 +94,7 @@ class WebSocketException(HTTPException):
     """
 
     def __init__(
-        self, content: ExceptionContent, headers: Optional[Dict[str, str]] = None
+        self, content: ExceptionContent, headers: Optional[dict[str, str]] = None
     ):
         super().__init__(content, headers, _type=_ExceptionType.WEBSOCKET)
 
@@ -102,11 +110,13 @@ class WebSocketException(HTTPException):
 async def general_handler(request: Request, exc: Exception) -> JSONResponse:
     """Default exception handler for all exceptions."""
     body = ExceptionContent(message=str(exc), error=ApiError.UNKNOWN_ERROR)
+    http_exc = HTTPException(content=body)
     res = JSONResponse(
-        status_code=body.enrich().status_code,
-        content=HTTPException(content=body).detail,
+        status_code=http_exc.status_code,
+        content=http_exc.detail,
+        headers=http_exc.headers,
     )
-    _logger.error(f"Response validation error: {json.loads(res.__dict__.get('body'))}")
+    _logger.error(f"General error: {json.loads(res.__dict__.get('body'))}")
     return res
 
 
@@ -115,11 +125,13 @@ async def request_validation_handler(
 ) -> JSONResponse:
     """Exception handler for all request validation errors."""
     body = ExceptionContent(message=str(exc), error=ApiError.INVALID_DATA_REQUEST)
+    http_exc = HTTPException(content=body)
     res = JSONResponse(
-        status_code=body.enrich().status_code,
-        content=HTTPException(content=body).detail,
+        status_code=http_exc.status_code,
+        content=http_exc.detail,
+        headers=http_exc.headers,
     )
-    _logger.error(f"Response validation error: {json.loads(res.__dict__.get('body'))}")
+    _logger.error(f"Request validation error: {json.loads(res.__dict__.get('body'))}")
     return res
 
 
@@ -128,9 +140,11 @@ async def response_validation_handler(
 ) -> JSONResponse:
     """Exception handler for all response validation errors."""
     body = ExceptionContent(message=str(exc), error=ApiError.INVALID_DATA_RESPONSE)
+    http_exc = HTTPException(content=body)
     res = JSONResponse(
-        status_code=body.enrich().status_code,
-        content=HTTPException(content=body).detail,
+        status_code=http_exc.status_code,
+        content=http_exc.detail,
+        headers=http_exc.headers,
     )
     _logger.error(f"Response validation error: {json.loads(res.__dict__.get('body'))}")
     return res
@@ -138,7 +152,9 @@ async def response_validation_handler(
 
 async def http_handler(request: Request, exc: HTTPException) -> JSONResponse:
     """Exception handler for HTTPExceptions. It unwraps the HTTPException and returns the detail in a flat JSON response."""
-    res = JSONResponse(status_code=exc.status_code, content=exc.detail)
+    res = JSONResponse(
+        status_code=exc.status_code, content=exc.detail, headers=exc.headers
+    )
     _logger.error(f"HTTP error: {json.loads(res.__dict__.get('body'))}")
     return res
 

crypticorn/common/logging.py

@@ -1,12 +1,13 @@
 from __future__ import annotations
 
 import logging
-from logging.handlers import RotatingFileHandler
+import os
 import sys
-from crypticorn.common.mixins import ValidateEnumMixin
-from crypticorn.common.ansi_colors import AnsiColors as C
 from datetime import datetime
-import os
+from logging.handlers import RotatingFileHandler
+
+from crypticorn.common.ansi_colors import AnsiColors as C
+from crypticorn.common.mixins import ValidateEnumMixin
 
 try:
     from enum import StrEnum

crypticorn/common/metrics.py

@@ -1,18 +1,30 @@
 # metrics/registry.py
-from prometheus_client import Counter, Histogram, CollectorRegistry
+from prometheus_client import CollectorRegistry, Counter, Histogram
 
 registry = CollectorRegistry()
 
-http_requests_total = Counter(
+HTTP_REQUESTS_COUNT = Counter(
     "http_requests_total",
     "Total HTTP requests",
-    ["method", "endpoint", "status_code"],
+    ["method", "endpoint", "status_code", "auth_type"],
     registry=registry,
 )
 
-http_request_duration_seconds = Histogram(
+HTTP_REQUEST_DURATION = Histogram(
     "http_request_duration_seconds",
     "HTTP request duration in seconds",
-    ["endpoint"],
+    ["endpoint", "method"],
+    registry=registry,
+)
+
+REQUEST_SIZE = Histogram(
+    "http_request_size_bytes", "Size of HTTP request bodies", ["method", "endpoint"]
+)
+
+
+RESPONSE_SIZE = Histogram(
+    "http_response_size_bytes",
+    "Size of HTTP responses",
+    ["method", "endpoint"],
     registry=registry,
 )

crypticorn/common/middleware.py

@@ -1,30 +1,79 @@
 import time
-from fastapi import FastAPI
+import warnings
+from contextlib import asynccontextmanager
+
+from crypticorn.common.logging import configure_logging
+from crypticorn.common.metrics import (
+    HTTP_REQUEST_DURATION,
+    HTTP_REQUESTS_COUNT,
+    REQUEST_SIZE,
+    RESPONSE_SIZE,
+)
+from crypticorn.common.warnings import CrypticornDeprecatedSince217
+from fastapi import FastAPI, Request
 from fastapi.middleware.cors import CORSMiddleware
 from starlette.middleware.base import BaseHTTPMiddleware
-from crypticorn.common.logging import configure_logging
-from contextlib import asynccontextmanager
 from typing_extensions import deprecated
-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):
+    async def dispatch(self, request: Request, call_next):
+
+        if "authorization" in request.headers:
+            auth_type = (
+                request.headers["authorization"].split()[0]
+                if " " in request.headers["authorization"]
+                else "none"
+            )
+        elif "x-api-key" in request.headers:
+            auth_type = "X-API-KEY"
+        else:
+            auth_type = "none"
+
+        try:
+            endpoint = request.get(
+                "route"
+            ).path  # use /time/{type} instead of dynamic route to avoid high cardinality
+        except Exception:
+            endpoint = request.url.path
+
         start = time.perf_counter()
         response = await call_next(request)
         duration = time.perf_counter() - start
 
-        http_requests_total.labels(
+        HTTP_REQUESTS_COUNT.labels(
             method=request.method,
-            endpoint=request.url.path,
+            endpoint=endpoint,
             status_code=response.status_code,
+            auth_type=auth_type,
         ).inc()
 
-        http_request_duration_seconds.labels(endpoint=request.url.path).observe(
-            duration
-        )
+        try:
+            body = await request.body()
+            size = len(body)
+        except Exception:
+            size = 0
+
+        REQUEST_SIZE.labels(
+            method=request.method,
+            endpoint=endpoint,
+        ).observe(size)
+
+        try:
+            body = await response.body()
+            size = len(body)
+        except Exception:
+            size = 0
+
+        RESPONSE_SIZE.labels(
+            method=request.method,
+            endpoint=endpoint,
+        ).observe(size)
+
+        HTTP_REQUEST_DURATION.labels(
+            endpoint=endpoint,
+            method=request.method,
+        ).observe(duration)
 
         return response
 

crypticorn/common/mixins.py

@@ -1,6 +1,7 @@
-from enum import EnumMeta
 import logging
 import warnings
+from enum import EnumMeta
+
 from crypticorn.common.warnings import CrypticornDeprecatedSince28
 
 _logger = logging.getLogger("crypticorn")

crypticorn/common/pagination.py

@@ -1,8 +1,9 @@
 """Utilities for handling paginated API responses, cursor-based pagination, filtering, sorting, etc."""
 
-from typing import Annotated, Any, Generic, Type, TypeVar, Optional, Literal
-from pydantic import BaseModel, Field, model_validator
 import math
+from typing import Annotated, Any, Generic, Literal, Optional, Type, TypeVar
+
+from pydantic import BaseModel, Field, model_validator
 
 T = TypeVar("T")
 

crypticorn/common/router/admin_router.py

@@ -2,19 +2,22 @@
 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])])
+>>> app.include_router(admin_router, dependencies=[Security(auth_handler.full_auth, scopes=[Scope.READ_ADMIN, Scope.WRITE_ADMIN])])
 """
 
-import os
 import importlib.metadata
+import logging
+import os
+import re
 import threading
 import time
-import psutil
-import re
-import logging
 from typing import Literal
-from fastapi import APIRouter, Query
+
+import psutil
 from crypticorn.common.logging import LogLevel
+from crypticorn.common.metrics import registry
+from fastapi import APIRouter, Query, Response
+from prometheus_client import CONTENT_TYPE_LATEST, generate_latest
 
 router = APIRouter(tags=["Admin"], prefix="/admin")
 
@@ -104,3 +107,11 @@ def list_installed_packages(
         or any(re.match(pattern, dist.metadata["Name"]) for pattern in include)
     }
     return dict(sorted(packages.items()))
+
+
+@router.get("/metrics", operation_id="getMetrics")
+def metrics():
+    """
+    Get Prometheus metrics for the application. Returns plain text.
+    """
+    return Response(generate_latest(registry), media_type=CONTENT_TYPE_LATEST)

crypticorn/common/router/status_router.py

@@ -10,28 +10,11 @@ Then include the router in the FastAPI app.
 """
 
 from datetime import datetime
-from fastapi import APIRouter, Request
-from typing import Annotated, Literal
-from fastapi import APIRouter, Response, Depends
-from prometheus_client import generate_latest, CONTENT_TYPE_LATEST
-from crypticorn.common.metrics import registry
-from crypticorn.common.auth import AuthHandler, basic_auth
-
-class EnhancedApiRouter(APIRouter):
-    def __init__(self, enable_metrics: bool = False, auth_handler: AuthHandler = None, *args, **kwargs):
-        """
-        Enhanced API Router that allows for metrics and authentication.
-        If enable_metrics is True, the router will include the metrics endpoint.
-        If auth_handler is provided, the router will use the auth handler to authenticate requests with
-        """
-        super().__init__(*args, **kwargs)
-        self.enable_metrics = enable_metrics
-        self.auth_handler = auth_handler
+from typing import Literal
 
-        if self.enable_metrics and not self.auth_handler:
-            raise ValueError("auth_handler must be provided if enable_metrics is True")
+from fastapi import APIRouter, Request
 
-router = EnhancedApiRouter(tags=["Status"], prefix="", enable_metrics=False, auth_handler=None)
+router = APIRouter(tags=["Status"], prefix="")
 
 
 @router.get("/", operation_id="ping")
@@ -51,12 +34,3 @@ async def time(type: Literal["iso", "unix"] = "iso") -> str:
         return datetime.now().isoformat()
     elif type == "unix":
         return str(int(datetime.now().timestamp()))
-
-
-@router.get("/metrics", operation_id="getMetrics", include_in_schema=router.enable_metrics)
-def metrics(username: Annotated[str, Depends(basic_auth)]):
-    """
-    Get Prometheus metrics for the application. Returns plain text.
-    """
-    return Response(generate_latest(registry), media_type=CONTENT_TYPE_LATEST)
-

crypticorn/common/utils.py

@@ -1,14 +1,14 @@
 """General utility functions and helper methods used across the codebase."""
 
-from datetime import datetime
-from typing import Any, Union
-from decimal import Decimal
-import string
 import random
-import typing_extensions
+import string
 import warnings
+from datetime import datetime
+from decimal import Decimal
+from typing import Any, Union
 
-from crypticorn.common.exceptions import ApiError, HTTPException, ExceptionContent
+import typing_extensions
+from crypticorn.common.exceptions import ApiError, ExceptionContent, HTTPException
 from crypticorn.common.warnings import CrypticornDeprecatedSince25
 
 

crypticorn/common/warnings.py

@@ -1,6 +1,7 @@
 """Crypticorn-specific warnings."""
 
 from __future__ import annotations
+
 from typing import Union
 
 

crypticorn/dex/client/api/admin_api.py

@@ -16,6 +16,9 @@ from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
 from typing import Any, Dict, List, Optional, Tuple, Union
 from typing_extensions import Annotated
 
+from pydantic import Field, StrictFloat, StrictInt, StrictStr, field_validator
+from typing import Any, Dict, List, Optional, Union
+from typing_extensions import Annotated
 from crypticorn.dex.client.models.log_level import LogLevel
 
 from crypticorn.dex.client.api_client import ApiClient, RequestSerialized

crypticorn/dex/client/api/signals_api.py

@@ -11,10 +11,14 @@ Generated by OpenAPI Generator (https://openapi-generator.tech)
 Do not edit the class manually.
 """  # noqa: E501
 
+import warnings
 from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
 from typing import Any, Dict, List, Optional, Tuple, Union
 from typing_extensions import Annotated
 
+from pydantic import Field, StrictInt, StrictStr, field_validator
+from typing import Optional
+from typing_extensions import Annotated
 from crypticorn.dex.client.models.paginated_response_signal_with_token import (
     PaginatedResponseSignalWithToken,
 )
@@ -176,7 +180,7 @@ class SignalsApi:
     ) -> SignalOverviewStats:
         """Get Stats
 
-        Get comprehensive statistics for all signals.
+        Retrieve comprehensive statistics and analytics for all trading signals.  Returns hourly-updated aggregated metrics including performance summaries and trading volumes.
 
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
@@ -236,7 +240,7 @@ class SignalsApi:
     ) -> ApiResponse[SignalOverviewStats]:
         """Get Stats
 
-        Get comprehensive statistics for all signals.
+        Retrieve comprehensive statistics and analytics for all trading signals.  Returns hourly-updated aggregated metrics including performance summaries and trading volumes.
 
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
@@ -295,7 +299,7 @@ class SignalsApi:
     ) -> RESTResponseType:
         """Get Stats
 
-        Get comprehensive statistics for all signals.
+        Retrieve comprehensive statistics and analytics for all trading signals.  Returns hourly-updated aggregated metrics including performance summaries and trading volumes.
 
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
@@ -465,7 +469,7 @@ class SignalsApi:
             Optional[StrictStr], Field(description="The field to filter by")
         ] = None,
         filter_value: Annotated[
-            Optional[Any], Field(description="The value to filter with")
+            Optional[StrictStr], Field(description="The value to filter with")
         ] = None,
         sort_order: Annotated[
             Optional[StrictStr], Field(description="The order to sort by")
@@ -532,7 +536,7 @@ class SignalsApi:
             Optional[StrictStr], Field(description="The field to filter by")
         ] = None,
         filter_value: Annotated[
-            Optional[Any], Field(description="The value to filter with")
+            Optional[StrictStr], Field(description="The value to filter with")
         ] = None,
         sort_order: Annotated[
             Optional[StrictStr], Field(description="The order to sort by")
@@ -599,7 +603,7 @@ class SignalsApi:
             Optional[StrictStr], Field(description="The field to filter by")
         ] = None,
         filter_value: Annotated[
-            Optional[Any], Field(description="The value to filter with")
+            Optional[StrictStr], Field(description="The value to filter with")
         ] = None,
         sort_order: Annotated[
             Optional[StrictStr], Field(description="The order to sort by")
@@ -667,7 +671,7 @@ class SignalsApi:
             Optional[StrictStr], Field(description="The field to filter by")
         ] = None,
         filter_value: Annotated[
-            Optional[Any], Field(description="The value to filter with")
+            Optional[StrictStr], Field(description="The value to filter with")
         ] = None,
         sort_order: Annotated[
             Optional[StrictStr], Field(description="The order to sort by")
@@ -698,12 +702,12 @@ class SignalsApi:
     ) -> PaginatedResponseSignalWithToken:
         """Get Signals
 
-        Get all signals. Returns the latest 10 signals by default. The default sort is `called_at` and the default order is `desc`.
+        Retrieve all trading signals with pagination, filtering, and sorting support.   Returns signals enriched with token metadata. Default sort is by call time (newest first).
 
         :param filter_by: The field to filter by
         :type filter_by: str
         :param filter_value: The value to filter with
-        :type filter_value: AnyOf
+        :type filter_value: str
         :param sort_order: The order to sort by
         :type sort_order: str
         :param sort_by: The field to sort by
@@ -766,7 +770,7 @@ class SignalsApi:
             Optional[StrictStr], Field(description="The field to filter by")
         ] = None,
         filter_value: Annotated[
-            Optional[Any], Field(description="The value to filter with")
+            Optional[StrictStr], Field(description="The value to filter with")
         ] = None,
         sort_order: Annotated[
             Optional[StrictStr], Field(description="The order to sort by")
@@ -797,12 +801,12 @@ class SignalsApi:
     ) -> ApiResponse[PaginatedResponseSignalWithToken]:
         """Get Signals
 
-        Get all signals. Returns the latest 10 signals by default. The default sort is `called_at` and the default order is `desc`.
+        Retrieve all trading signals with pagination, filtering, and sorting support.   Returns signals enriched with token metadata. Default sort is by call time (newest first).
 
         :param filter_by: The field to filter by
         :type filter_by: str
         :param filter_value: The value to filter with
-        :type filter_value: AnyOf
+        :type filter_value: str
         :param sort_order: The order to sort by
         :type sort_order: str
         :param sort_by: The field to sort by
@@ -864,7 +868,7 @@ class SignalsApi:
             Optional[StrictStr], Field(description="The field to filter by")
         ] = None,
         filter_value: Annotated[
-            Optional[Any], Field(description="The value to filter with")
+            Optional[StrictStr], Field(description="The value to filter with")
         ] = None,
         sort_order: Annotated[
             Optional[StrictStr], Field(description="The order to sort by")
@@ -895,12 +899,12 @@ class SignalsApi:
     ) -> RESTResponseType:
         """Get Signals
 
-        Get all signals. Returns the latest 10 signals by default. The default sort is `called_at` and the default order is `desc`.
+        Retrieve all trading signals with pagination, filtering, and sorting support.   Returns signals enriched with token metadata. Default sort is by call time (newest first).
 
         :param filter_by: The field to filter by
         :type filter_by: str
         :param filter_value: The value to filter with
-        :type filter_value: AnyOf
+        :type filter_value: str
         :param sort_order: The order to sort by
         :type sort_order: str
         :param sort_by: The field to sort by
@@ -960,7 +964,7 @@ class SignalsApi:
             Optional[StrictStr], Field(description="The field to filter by")
         ] = None,
         filter_value: Annotated[
-            Optional[Any], Field(description="The value to filter with")
+            Optional[StrictStr], Field(description="The value to filter with")
         ] = None,
         sort_order: Annotated[
             Optional[StrictStr], Field(description="The order to sort by")
@@ -1011,7 +1015,7 @@ class SignalsApi:
             Optional[StrictStr], Field(description="The field to filter by")
         ] = None,
         filter_value: Annotated[
-            Optional[Any], Field(description="The value to filter with")
+            Optional[StrictStr], Field(description="The value to filter with")
         ] = None,
         sort_order: Annotated[
             Optional[StrictStr], Field(description="The order to sort by")
@@ -1062,7 +1066,7 @@ class SignalsApi:
             Optional[StrictStr], Field(description="The field to filter by")
         ] = None,
         filter_value: Annotated[
-            Optional[Any], Field(description="The value to filter with")
+            Optional[StrictStr], Field(description="The value to filter with")
         ] = None,
         sort_order: Annotated[
             Optional[StrictStr], Field(description="The order to sort by")
@@ -1170,7 +1174,7 @@ class SignalsApi:
             )
 
         # authentication setting
-        _auth_settings: List[str] = ["APIKeyHeader", "HTTPBearer"]
+        _auth_settings: List[str] = []
 
         return self.api_client.param_serialize(
             method="GET",
@@ -1385,7 +1389,7 @@ class SignalsApi:
     ) -> PaginatedResponseSignalWithToken:
         """Get Top Signals
 
-        Get the top performing signals from the last X hours.The default is from the last 24 hours.
+        Retrieve top-performing signals ranked by performance within a specified time window.  Returns the highest-performing signals from the last X hours (default: 24 hours).
 
         :param page: The current page number
         :type page: int
@@ -1469,7 +1473,7 @@ class SignalsApi:
     ) -> ApiResponse[PaginatedResponseSignalWithToken]:
         """Get Top Signals
 
-        Get the top performing signals from the last X hours.The default is from the last 24 hours.
+        Retrieve top-performing signals ranked by performance within a specified time window.  Returns the highest-performing signals from the last X hours (default: 24 hours).
 
         :param page: The current page number
         :type page: int
@@ -1552,7 +1556,7 @@ class SignalsApi:
     ) -> RESTResponseType:
         """Get Top Signals
 
-        Get the top performing signals from the last X hours.The default is from the last 24 hours.
+        Retrieve top-performing signals ranked by performance within a specified time window.  Returns the highest-performing signals from the last X hours (default: 24 hours).
 
         :param page: The current page number
         :type page: int
@@ -1776,7 +1780,7 @@ class SignalsApi:
             )
 
         # authentication setting
-        _auth_settings: List[str] = ["APIKeyHeader", "HTTPBearer"]
+        _auth_settings: List[str] = []
 
         return self.api_client.param_serialize(
             method="GET",