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

crypticorn/auth/client/configuration.py

@@ -195,7 +195,7 @@ class Configuration:
         debug: Optional[bool] = None,
     ) -> None:
         """Constructor"""
-        self._base_path = "https://api.crypticorn.dev/v1/auth" if host is None else host
+        self._base_path = "http://localhost/v1/auth" if host is None else host
         """Default Base url
         """
         self.server_index = 0 if server_index is None and host is None else server_index
@@ -528,7 +528,7 @@ class Configuration:
         """
         return [
             {
-                "url": "https://api.crypticorn.dev/v1/auth",
+                "url": "http://localhost/v1/auth",
                 "description": "No description provided",
             }
         ]

crypticorn/auth/client/models/create_api_key_request.py

@@ -50,6 +50,7 @@ class CreateApiKeyRequest(BaseModel):
             if i not in set(
                 [
                     "read:predictions",
+                    "read:dex:signals",
                     "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:dex:signals', '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:dex:signals",
                     "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:dex:signals', '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/cli/init.py

@@ -33,7 +33,7 @@ def copy_template(template_name: str, target_path: Path):
 
 def check_file_exists(path: Path, force: bool):
     if path.exists() and not force:
-        click.secho(f"File already exists, use --force / -f to overwrite", fg="red")
+        click.secho("File already exists, use --force / -f to overwrite", fg="red")
         return False
     return True
 

crypticorn/cli/templates/.env.docker.temp

@@ -0,0 +1,3 @@
+# Specifies which API environment to use in docker builds: "0" if the API_ENV should be used, "1" for the internal host.
+# Any database connections would have to be overridden as well.
+IS_DOCKER=1

crypticorn/cli/templates/.env.example.temp

@@ -0,0 +1,4 @@
+# Specifies which API environment to use: "local", "dev", "prod", or "docker".
+# When running inside Docker, this defaults to "docker" (internal network host),
+# unless IS_DOCKER is set to 0 in .env.docker.
+API_ENV=local

crypticorn/cli/templates/Dockerfile

@@ -19,14 +19,17 @@ WORKDIR /code
 # and to the workflow:
 # env:
 #     API_ENV: ${{ github.ref == 'refs/heads/main' && 'prod' || 'dev' }}
-ARG API_ENV
+# and in the docker build:
+#     build-args: |
+#       CACHEBUST=${{ github.run_id }} # invalidates dependency cache on every workflow run
 
-RUN pip install --no-cache-dir -r requirements.txt
+ARG API_ENV
 
 RUN if [ "$API_ENV" != "prod" ]; then \
     pip install --pre crypticorn; \
     fi
 
+RUN pip install --no-cache-dir -r requirements.txt
 
 COPY ./src /code/src
 

crypticorn/client.py

@@ -1,22 +1,30 @@
 from typing import TypeVar, Optional
+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 +32,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 +57,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 +163,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 +233,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

@@ -13,5 +13,6 @@ from crypticorn.common.ansi_colors import *
 from crypticorn.common.middleware import *
 from crypticorn.common.warnings import *
 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/auth.py

@@ -7,18 +7,19 @@ from crypticorn.common.exceptions import (
     ApiError,
     HTTPException,
     ExceptionContent,
-    WebSocketException,
 )
 from crypticorn.common.urls import BaseUrl, Service, ApiVersion
-from fastapi import Depends, Query
+from fastapi import Depends, Query, Request
 from fastapi.security import (
     HTTPAuthorizationCredentials,
     SecurityScopes,
     HTTPBearer,
     APIKeyHeader,
+    HTTPBasic,
 )
 from typing_extensions import Annotated
 from typing import Union
+from fastapi.security import HTTPBasicCredentials
 
 # Auth Schemes
 http_bearer = HTTPBearer(
@@ -33,6 +34,12 @@ apikey_header = APIKeyHeader(
     description="The API key to use for authentication.",
 )
 
+basic_auth = HTTPBasic(
+    scheme_name="Basic",
+    auto_error=False,
+    description="The username and password to use for authentication. Only used in /admin/metrics",
+)
+
 
 # Auth Handler
 class AuthHandler:
@@ -112,6 +119,7 @@ class AuthHandler:
             elif message == "jwt expired":
                 error = ApiError.EXPIRED_BEARER
             else:
+                message = "Invalid bearer token"
                 error = (
                     ApiError.INVALID_BEARER
                 )  # jwt malformed, jwt not active (https://www.npmjs.com/package/jsonwebtoken#errors--codes)
@@ -150,6 +158,7 @@ class AuthHandler:
                         error=ApiError.NO_API_KEY,
                         message="No credentials provided. API key is required",
                     ),
+                    headers={"WWW-Authenticate": "X-API-Key"},
                 )
             raise e
 
@@ -175,6 +184,7 @@ class AuthHandler:
                         error=ApiError.NO_BEARER,
                         message="No credentials provided. Bearer token is required",
                     ),
+                    headers={"WWW-Authenticate": "Bearer"},
                 )
             raise e
 
@@ -222,6 +232,7 @@ class AuthHandler:
                     error=ApiError.NO_CREDENTIALS,
                     message="No credentials provided. Either API key or bearer token is required.",
                 ),
+                headers={"WWW-Authenticate": "Bearer, X-API-Key"},
             )
 
     async def ws_api_key_auth(
@@ -234,10 +245,7 @@ class AuthHandler:
         Use this function if you only want to allow access via the API key.
         This function is used for WebSocket connections.
         """
-        try:
-            return await self.api_key_auth(api_key=api_key, sec=sec)
-        except HTTPException as e:
-            raise WebSocketException.from_http_exception(e)
+        return await self.api_key_auth(api_key=api_key, sec=sec)
 
     async def ws_bearer_auth(
         self,
@@ -249,10 +257,8 @@ class AuthHandler:
         Use this function if you only want to allow access via the bearer token.
         This function is used for WebSocket connections.
         """
-        try:
-            return await self.bearer_auth(bearer=bearer, sec=sec)
-        except HTTPException as e:
-            raise WebSocketException.from_http_exception(e)
+        credentials = HTTPAuthorizationCredentials(scheme="Bearer", credentials=bearer)
+        return await self.bearer_auth(bearer=credentials, sec=sec)
 
     async def ws_combined_auth(
         self,
@@ -270,9 +276,34 @@ class AuthHandler:
             if bearer
             else None
         )
+        return await self.combined_auth(bearer=credentials, api_key=api_key, sec=sec)
+
+    async def basic_auth(
+        self,
+        request: Request,
+        credentials: Annotated[Union[HTTPBasicCredentials, None], Depends(basic_auth)],
+    ):
+        """
+        Verifies the basic authentication credentials. This authentication method should just be used for special cases like /admin/metrics, where JWT and API key authentication are not desired or not possible.
+        """
+        if not credentials:
+            raise HTTPException(
+                content=ExceptionContent(
+                    error=ApiError.NO_CREDENTIALS,
+                    message="No credentials provided. Basic authentication credentials are required.",
+                ),
+            )
+
         try:
-            return await self.combined_auth(
-                bearer=credentials, api_key=api_key, sec=sec
+            await self.client.login.verify_basic_auth_without_preload_content(
+                credentials.username, credentials.password
             )
-        except HTTPException as e:
-            raise WebSocketException.from_http_exception(e)
+        except ApiException as e:
+            raise HTTPException(
+                content=ExceptionContent(
+                    error=ApiError.INVALID_BASIC_AUTH,
+                    message="Invalid basic authentication credentials",
+                ),
+                headers={"WWW-Authenticate": "Basic"},
+            )
+        return credentials.username