qtsurfer-api-client 0.98.0__py3-none-any.whl

qtsurfer/api/client/__init__.py

@@ -0,0 +1,38 @@
+"""qtsurfer-api-client — auto-generated Python client for the QTSurfer API.
+
+Low-level: one function per OpenAPI endpoint. For workflow orchestration
+(``backtest = compile + prepare + execute + poll``), use
+`qtsurfer-sdk <https://github.com/QTSurfer/sdk-python>`_ (coming soon).
+
+Public surface (re-exported from the generated package):
+
+* :class:`Client` — unauthenticated client (rarely useful in practice).
+* :class:`AuthenticatedClient` — Bearer-token client; pass to every
+  endpoint function as ``client=...``.
+* :mod:`qtsurfer.api.client.api` — endpoint modules grouped by tag.
+* :mod:`qtsurfer.api.client.models` — request/response dataclasses.
+
+Endpoint modules expose four entry points: ``sync``, ``sync_detailed``,
+``asyncio``, ``asyncio_detailed``. See the README for examples.
+"""
+
+from importlib.metadata import PackageNotFoundError, version
+
+# Re-export the generated public types.
+from qtsurfer.api.client._generated import api, errors, models, types
+from qtsurfer.api.client._generated.client import AuthenticatedClient, Client
+
+try:
+    __version__ = version("qtsurfer-api-client")
+except PackageNotFoundError:  # pragma: no cover - editable installs in dev
+    __version__ = "0.0.0+unknown"
+
+__all__ = [
+    "AuthenticatedClient",
+    "Client",
+    "__version__",
+    "api",
+    "errors",
+    "models",
+    "types",
+]

qtsurfer/api/client/_generated/__init__.py

@@ -0,0 +1,8 @@
+"""A client library for accessing QTSurfer API"""
+
+from .client import AuthenticatedClient, Client
+
+__all__ = (
+    "AuthenticatedClient",
+    "Client",
+)

qtsurfer/api/client/_generated/api/__init__.py

@@ -0,0 +1 @@
+"""Contains methods for accessing the API"""

qtsurfer/api/client/_generated/api/auth/__init__.py

@@ -0,0 +1 @@
+"""Contains endpoint functions for accessing the API"""

qtsurfer/api/client/_generated/api/auth/auth.py

@@ -0,0 +1,174 @@
+from http import HTTPStatus
+from typing import Any, cast
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.auth_token_error import AuthTokenError
+from ...models.auth_token_response import AuthTokenResponse
+from ...types import Response
+
+
+def _get_kwargs() -> dict[str, Any]:
+
+    _kwargs: dict[str, Any] = {
+        "method": "post",
+        "url": "/auth/token",
+    }
+
+    return _kwargs
+
+
+def _parse_response(
+    *, client: AuthenticatedClient | Client, response: httpx.Response
+) -> Any | AuthTokenError | AuthTokenResponse | None:
+    if response.status_code == 200:
+        response_200 = AuthTokenResponse.from_dict(response.json())
+
+        return response_200
+
+    if response.status_code == 401:
+        response_401 = AuthTokenError.from_dict(response.json())
+
+        return response_401
+
+    if response.status_code == 429:
+        response_429 = cast(Any, None)
+        return response_429
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(
+    *, client: AuthenticatedClient | Client, response: httpx.Response
+) -> Response[Any | AuthTokenError | AuthTokenResponse]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: AuthenticatedClient,
+) -> Response[Any | AuthTokenError | AuthTokenResponse]:
+    """Exchange API key for a short-lived JWT
+
+     Exchanges a long-lived API key for a short-lived JWT used by every other
+    endpoint. This is the only endpoint that accepts an API key directly —
+    callers should obtain a JWT here, then send it as `Authorization: Bearer
+    <token>` to all other operations.
+
+    The returned JWT carries the caller's subscription `tier` as a claim and
+    expires after `expires_in` seconds. Callers should refresh the token
+    before expiry (or on a `401` response) by calling this endpoint again.
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | AuthTokenError | AuthTokenResponse]
+    """
+
+    kwargs = _get_kwargs()
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    *,
+    client: AuthenticatedClient,
+) -> Any | AuthTokenError | AuthTokenResponse | None:
+    """Exchange API key for a short-lived JWT
+
+     Exchanges a long-lived API key for a short-lived JWT used by every other
+    endpoint. This is the only endpoint that accepts an API key directly —
+    callers should obtain a JWT here, then send it as `Authorization: Bearer
+    <token>` to all other operations.
+
+    The returned JWT carries the caller's subscription `tier` as a claim and
+    expires after `expires_in` seconds. Callers should refresh the token
+    before expiry (or on a `401` response) by calling this endpoint again.
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | AuthTokenError | AuthTokenResponse
+    """
+
+    return sync_detailed(
+        client=client,
+    ).parsed
+
+
+async def asyncio_detailed(
+    *,
+    client: AuthenticatedClient,
+) -> Response[Any | AuthTokenError | AuthTokenResponse]:
+    """Exchange API key for a short-lived JWT
+
+     Exchanges a long-lived API key for a short-lived JWT used by every other
+    endpoint. This is the only endpoint that accepts an API key directly —
+    callers should obtain a JWT here, then send it as `Authorization: Bearer
+    <token>` to all other operations.
+
+    The returned JWT carries the caller's subscription `tier` as a claim and
+    expires after `expires_in` seconds. Callers should refresh the token
+    before expiry (or on a `401` response) by calling this endpoint again.
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | AuthTokenError | AuthTokenResponse]
+    """
+
+    kwargs = _get_kwargs()
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    *,
+    client: AuthenticatedClient,
+) -> Any | AuthTokenError | AuthTokenResponse | None:
+    """Exchange API key for a short-lived JWT
+
+     Exchanges a long-lived API key for a short-lived JWT used by every other
+    endpoint. This is the only endpoint that accepts an API key directly —
+    callers should obtain a JWT here, then send it as `Authorization: Bearer
+    <token>` to all other operations.
+
+    The returned JWT carries the caller's subscription `tier` as a claim and
+    expires after `expires_in` seconds. Callers should refresh the token
+    before expiry (or on a `401` response) by calling this endpoint again.
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | AuthTokenError | AuthTokenResponse
+    """
+
+    return (
+        await asyncio_detailed(
+            client=client,
+        )
+    ).parsed

qtsurfer/api/client/_generated/api/backtesting/__init__.py

@@ -0,0 +1 @@
+"""Contains endpoint functions for accessing the API"""

qtsurfer/api/client/_generated/api/backtesting/cancel_execution.py

@@ -0,0 +1,214 @@
+from http import HTTPStatus
+from typing import Any
+from urllib.parse import quote
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.cancel_execution_response_200 import CancelExecutionResponse200
+from ...models.data_source_type import DataSourceType
+from ...models.response_error import ResponseError
+from ...types import Response
+
+
+def _get_kwargs(
+    exchange_id: str,
+    type_: DataSourceType,
+    job_id: str,
+) -> dict[str, Any]:
+
+    _kwargs: dict[str, Any] = {
+        "method": "delete",
+        "url": "/backtest/{exchange_id}/{type_}/execute/{job_id}".format(
+            exchange_id=quote(str(exchange_id), safe=""),
+            type_=quote(str(type_), safe=""),
+            job_id=quote(str(job_id), safe=""),
+        ),
+    }
+
+    return _kwargs
+
+
+def _parse_response(
+    *, client: AuthenticatedClient | Client, response: httpx.Response
+) -> CancelExecutionResponse200 | ResponseError | None:
+    if response.status_code == 200:
+        response_200 = CancelExecutionResponse200.from_dict(response.json())
+
+        return response_200
+
+    if response.status_code == 404:
+        response_404 = ResponseError.from_dict(response.json())
+
+        return response_404
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(
+    *, client: AuthenticatedClient | Client, response: httpx.Response
+) -> Response[CancelExecutionResponse200 | ResponseError]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    exchange_id: str,
+    type_: DataSourceType,
+    job_id: str,
+    *,
+    client: AuthenticatedClient,
+) -> Response[CancelExecutionResponse200 | ResponseError]:
+    """Cancel a running backtest execution
+
+     Requests cancellation of the specified execution. The execution
+    status will transition to `Aborted` once the cancellation is
+    processed. Cancellation is asynchronous — poll the GET endpoint
+    to confirm the final status.
+
+    Args:
+        exchange_id (str):  Example: binance.
+        type_ (DataSourceType): Managed exchange data sources available for backtesting. Example:
+            ticker.
+        job_id (str):  Example: 13RBLGQlPnfDjO6wyKSX8i.
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[CancelExecutionResponse200 | ResponseError]
+    """
+
+    kwargs = _get_kwargs(
+        exchange_id=exchange_id,
+        type_=type_,
+        job_id=job_id,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    exchange_id: str,
+    type_: DataSourceType,
+    job_id: str,
+    *,
+    client: AuthenticatedClient,
+) -> CancelExecutionResponse200 | ResponseError | None:
+    """Cancel a running backtest execution
+
+     Requests cancellation of the specified execution. The execution
+    status will transition to `Aborted` once the cancellation is
+    processed. Cancellation is asynchronous — poll the GET endpoint
+    to confirm the final status.
+
+    Args:
+        exchange_id (str):  Example: binance.
+        type_ (DataSourceType): Managed exchange data sources available for backtesting. Example:
+            ticker.
+        job_id (str):  Example: 13RBLGQlPnfDjO6wyKSX8i.
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        CancelExecutionResponse200 | ResponseError
+    """
+
+    return sync_detailed(
+        exchange_id=exchange_id,
+        type_=type_,
+        job_id=job_id,
+        client=client,
+    ).parsed
+
+
+async def asyncio_detailed(
+    exchange_id: str,
+    type_: DataSourceType,
+    job_id: str,
+    *,
+    client: AuthenticatedClient,
+) -> Response[CancelExecutionResponse200 | ResponseError]:
+    """Cancel a running backtest execution
+
+     Requests cancellation of the specified execution. The execution
+    status will transition to `Aborted` once the cancellation is
+    processed. Cancellation is asynchronous — poll the GET endpoint
+    to confirm the final status.
+
+    Args:
+        exchange_id (str):  Example: binance.
+        type_ (DataSourceType): Managed exchange data sources available for backtesting. Example:
+            ticker.
+        job_id (str):  Example: 13RBLGQlPnfDjO6wyKSX8i.
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[CancelExecutionResponse200 | ResponseError]
+    """
+
+    kwargs = _get_kwargs(
+        exchange_id=exchange_id,
+        type_=type_,
+        job_id=job_id,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    exchange_id: str,
+    type_: DataSourceType,
+    job_id: str,
+    *,
+    client: AuthenticatedClient,
+) -> CancelExecutionResponse200 | ResponseError | None:
+    """Cancel a running backtest execution
+
+     Requests cancellation of the specified execution. The execution
+    status will transition to `Aborted` once the cancellation is
+    processed. Cancellation is asynchronous — poll the GET endpoint
+    to confirm the final status.
+
+    Args:
+        exchange_id (str):  Example: binance.
+        type_ (DataSourceType): Managed exchange data sources available for backtesting. Example:
+            ticker.
+        job_id (str):  Example: 13RBLGQlPnfDjO6wyKSX8i.
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        CancelExecutionResponse200 | ResponseError
+    """
+
+    return (
+        await asyncio_detailed(
+            exchange_id=exchange_id,
+            type_=type_,
+            job_id=job_id,
+            client=client,
+        )
+    ).parsed

qtsurfer/api/client/_generated/api/backtesting/execute_backtesting.py

@@ -0,0 +1,251 @@
+from http import HTTPStatus
+from typing import Any
+from urllib.parse import quote
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.accepted_job import AcceptedJob
+from ...models.data_source_type import DataSourceType
+from ...models.execute_backtesting_body import ExecuteBacktestingBody
+from ...models.response_error import ResponseError
+from ...types import Response
+
+
+def _get_kwargs(
+    exchange_id: str,
+    type_: DataSourceType,
+    *,
+    body: ExecuteBacktestingBody,
+) -> dict[str, Any]:
+    headers: dict[str, Any] = {}
+
+    _kwargs: dict[str, Any] = {
+        "method": "post",
+        "url": "/backtest/{exchange_id}/{type_}/execute".format(
+            exchange_id=quote(str(exchange_id), safe=""),
+            type_=quote(str(type_), safe=""),
+        ),
+    }
+
+    _kwargs["json"] = body.to_dict()
+
+    headers["Content-Type"] = "application/json"
+
+    _kwargs["headers"] = headers
+    return _kwargs
+
+
+def _parse_response(
+    *, client: AuthenticatedClient | Client, response: httpx.Response
+) -> AcceptedJob | ResponseError | None:
+    if response.status_code == 202:
+        response_202 = AcceptedJob.from_dict(response.json())
+
+        return response_202
+
+    if response.status_code == 400:
+        response_400 = ResponseError.from_dict(response.json())
+
+        return response_400
+
+    if response.status_code == 404:
+        response_404 = ResponseError.from_dict(response.json())
+
+        return response_404
+
+    if response.status_code == 429:
+        response_429 = ResponseError.from_dict(response.json())
+
+        return response_429
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(
+    *, client: AuthenticatedClient | Client, response: httpx.Response
+) -> Response[AcceptedJob | ResponseError]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    exchange_id: str,
+    type_: DataSourceType,
+    *,
+    client: AuthenticatedClient,
+    body: ExecuteBacktestingBody,
+) -> Response[AcceptedJob | ResponseError]:
+    """Execute a compiled strategy against a prepared dataset
+
+     Enqueues an execute task that runs the strategy identified by `strategyId` over the data
+    prepared by the prepare job identified by `prepareJobId`. The instrument and date range are
+    recovered from the prepare job — they do not need to be sent again.
+
+    Returns immediately with a `jobId`; poll `GET /backtest/{exchangeId}/{type}/execute/{jobId}`
+    for the result.
+
+    The same params (same `prepareJobId`, `strategyId`, `storeSignals`) always return the same
+    `jobId` (idempotent).
+
+    Args:
+        exchange_id (str):  Example: binance.
+        type_ (DataSourceType): Managed exchange data sources available for backtesting. Example:
+            ticker.
+        body (ExecuteBacktestingBody):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[AcceptedJob | ResponseError]
+    """
+
+    kwargs = _get_kwargs(
+        exchange_id=exchange_id,
+        type_=type_,
+        body=body,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    exchange_id: str,
+    type_: DataSourceType,
+    *,
+    client: AuthenticatedClient,
+    body: ExecuteBacktestingBody,
+) -> AcceptedJob | ResponseError | None:
+    """Execute a compiled strategy against a prepared dataset
+
+     Enqueues an execute task that runs the strategy identified by `strategyId` over the data
+    prepared by the prepare job identified by `prepareJobId`. The instrument and date range are
+    recovered from the prepare job — they do not need to be sent again.
+
+    Returns immediately with a `jobId`; poll `GET /backtest/{exchangeId}/{type}/execute/{jobId}`
+    for the result.
+
+    The same params (same `prepareJobId`, `strategyId`, `storeSignals`) always return the same
+    `jobId` (idempotent).
+
+    Args:
+        exchange_id (str):  Example: binance.
+        type_ (DataSourceType): Managed exchange data sources available for backtesting. Example:
+            ticker.
+        body (ExecuteBacktestingBody):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        AcceptedJob | ResponseError
+    """
+
+    return sync_detailed(
+        exchange_id=exchange_id,
+        type_=type_,
+        client=client,
+        body=body,
+    ).parsed
+
+
+async def asyncio_detailed(
+    exchange_id: str,
+    type_: DataSourceType,
+    *,
+    client: AuthenticatedClient,
+    body: ExecuteBacktestingBody,
+) -> Response[AcceptedJob | ResponseError]:
+    """Execute a compiled strategy against a prepared dataset
+
+     Enqueues an execute task that runs the strategy identified by `strategyId` over the data
+    prepared by the prepare job identified by `prepareJobId`. The instrument and date range are
+    recovered from the prepare job — they do not need to be sent again.
+
+    Returns immediately with a `jobId`; poll `GET /backtest/{exchangeId}/{type}/execute/{jobId}`
+    for the result.
+
+    The same params (same `prepareJobId`, `strategyId`, `storeSignals`) always return the same
+    `jobId` (idempotent).
+
+    Args:
+        exchange_id (str):  Example: binance.
+        type_ (DataSourceType): Managed exchange data sources available for backtesting. Example:
+            ticker.
+        body (ExecuteBacktestingBody):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[AcceptedJob | ResponseError]
+    """
+
+    kwargs = _get_kwargs(
+        exchange_id=exchange_id,
+        type_=type_,
+        body=body,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    exchange_id: str,
+    type_: DataSourceType,
+    *,
+    client: AuthenticatedClient,
+    body: ExecuteBacktestingBody,
+) -> AcceptedJob | ResponseError | None:
+    """Execute a compiled strategy against a prepared dataset
+
+     Enqueues an execute task that runs the strategy identified by `strategyId` over the data
+    prepared by the prepare job identified by `prepareJobId`. The instrument and date range are
+    recovered from the prepare job — they do not need to be sent again.
+
+    Returns immediately with a `jobId`; poll `GET /backtest/{exchangeId}/{type}/execute/{jobId}`
+    for the result.
+
+    The same params (same `prepareJobId`, `strategyId`, `storeSignals`) always return the same
+    `jobId` (idempotent).
+
+    Args:
+        exchange_id (str):  Example: binance.
+        type_ (DataSourceType): Managed exchange data sources available for backtesting. Example:
+            ticker.
+        body (ExecuteBacktestingBody):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        AcceptedJob | ResponseError
+    """
+
+    return (
+        await asyncio_detailed(
+            exchange_id=exchange_id,
+            type_=type_,
+            client=client,
+            body=body,
+        )
+    ).parsed