qcs_api_client 0.27.3__py3-none-any.whl

qcs_api_client/api/default/get_health.py

@@ -0,0 +1,123 @@
+from typing import Any
+
+import httpx
+from tenacity import retry
+
+from ...models.health import Health
+from ...types import Response
+from ...util.errors import QCSHTTPStatusError
+from ...util.retry import DEFAULT_RETRY_ARGUMENTS
+
+
+def _get_kwargs() -> dict[str, Any]:
+
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": "/",
+    }
+
+    return _kwargs
+
+
+def _parse_response(*, response: httpx.Response) -> Health | None:
+    if response.status_code == 200:
+        response_200 = Health.from_dict(response.json())
+
+        return response_200
+
+    raise QCSHTTPStatusError(
+        message=f"Unexpected response: status code {response.status_code}",
+        response=response,
+    )
+
+
+def _build_response(*, response: httpx.Response) -> Response[Health]:
+    """Construct the Response class from the raw ``httpx.Response``."""
+    return Response.build_from_httpx_response(response=response, parse_function=_parse_response)
+
+
+@retry(**DEFAULT_RETRY_ARGUMENTS)
+def sync(
+    *,
+    client: httpx.Client,
+    httpx_request_kwargs: dict[str, Any] | None = None,
+) -> Response[Health]:
+    """Retrieve the health status of the API
+
+    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[Health]
+    """
+
+    httpx_request_kwargs = httpx_request_kwargs or {}
+
+    kwargs = _get_kwargs()
+    kwargs.update(httpx_request_kwargs)
+    response = client.request(
+        **kwargs,
+    )
+
+    return _build_response(response=response)
+
+
+@retry(**DEFAULT_RETRY_ARGUMENTS)
+def sync_from_dict(
+    *,
+    client: httpx.Client,
+    httpx_request_kwargs: dict[str, Any] | None = None,
+) -> Response[Health]:
+    httpx_request_kwargs = httpx_request_kwargs or {}
+
+    kwargs = _get_kwargs(
+        client=client,
+    )
+    kwargs.update(httpx_request_kwargs)
+    response = client.request(
+        **kwargs,
+    )
+    return _build_response(response=response)
+
+
+@retry(**DEFAULT_RETRY_ARGUMENTS)
+async def asyncio(
+    *,
+    client: httpx.AsyncClient,
+    httpx_request_kwargs: dict[str, Any] | None = None,
+) -> Response[Health]:
+    """Retrieve the health status of the API
+
+    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[Health]
+    """
+
+    httpx_request_kwargs = httpx_request_kwargs or {}
+    kwargs = _get_kwargs()
+    kwargs.update(httpx_request_kwargs)
+    response = await client.request(**kwargs)
+    return _build_response(response=response)
+
+
+@retry(**DEFAULT_RETRY_ARGUMENTS)
+async def asyncio_from_dict(
+    *,
+    client: httpx.AsyncClient,
+    httpx_request_kwargs: dict[str, Any] | None = None,
+) -> Response[Health]:
+    httpx_request_kwargs = httpx_request_kwargs or {}
+
+    kwargs = _get_kwargs(
+        client=client,
+    )
+    kwargs.update(httpx_request_kwargs)
+    response = await client.request(
+        **kwargs,
+    )
+
+    return _build_response(response=response)

qcs_api_client/api/default/health_check.py

@@ -0,0 +1,124 @@
+from typing import Any
+
+import httpx
+from tenacity import retry
+
+from ...types import Response
+from ...util.errors import QCSHTTPStatusError
+from ...util.retry import DEFAULT_RETRY_ARGUMENTS
+
+
+def _get_kwargs() -> dict[str, Any]:
+
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": "/v1/healthcheck",
+    }
+
+    return _kwargs
+
+
+def _parse_response(*, response: httpx.Response) -> Any | None:
+    if response.status_code == 200:
+        return None
+
+    raise QCSHTTPStatusError(
+        message=f"Unexpected response: status code {response.status_code}",
+        response=response,
+    )
+
+
+def _build_response(*, response: httpx.Response) -> Response[Any]:
+    """Construct the Response class from the raw ``httpx.Response``."""
+    return Response.build_from_httpx_response(response=response, parse_function=_parse_response)
+
+
+@retry(**DEFAULT_RETRY_ARGUMENTS)
+def sync(
+    *,
+    client: httpx.Client,
+    httpx_request_kwargs: dict[str, Any] | None = None,
+) -> Response[Any]:
+    """Health Check
+
+     Check the health of the service.
+
+    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]
+    """
+
+    httpx_request_kwargs = httpx_request_kwargs or {}
+
+    kwargs = _get_kwargs()
+    kwargs.update(httpx_request_kwargs)
+    response = client.request(
+        **kwargs,
+    )
+
+    return _build_response(response=response)
+
+
+@retry(**DEFAULT_RETRY_ARGUMENTS)
+def sync_from_dict(
+    *,
+    client: httpx.Client,
+    httpx_request_kwargs: dict[str, Any] | None = None,
+) -> Response[Any]:
+    httpx_request_kwargs = httpx_request_kwargs or {}
+
+    kwargs = _get_kwargs(
+        client=client,
+    )
+    kwargs.update(httpx_request_kwargs)
+    response = client.request(
+        **kwargs,
+    )
+    return _build_response(response=response)
+
+
+@retry(**DEFAULT_RETRY_ARGUMENTS)
+async def asyncio(
+    *,
+    client: httpx.AsyncClient,
+    httpx_request_kwargs: dict[str, Any] | None = None,
+) -> Response[Any]:
+    """Health Check
+
+     Check the health of the service.
+
+    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]
+    """
+
+    httpx_request_kwargs = httpx_request_kwargs or {}
+    kwargs = _get_kwargs()
+    kwargs.update(httpx_request_kwargs)
+    response = await client.request(**kwargs)
+    return _build_response(response=response)
+
+
+@retry(**DEFAULT_RETRY_ARGUMENTS)
+async def asyncio_from_dict(
+    *,
+    client: httpx.AsyncClient,
+    httpx_request_kwargs: dict[str, Any] | None = None,
+) -> Response[Any]:
+    httpx_request_kwargs = httpx_request_kwargs or {}
+
+    kwargs = _get_kwargs(
+        client=client,
+    )
+    kwargs.update(httpx_request_kwargs)
+    response = await client.request(
+        **kwargs,
+    )
+
+    return _build_response(response=response)

qcs_api_client/api/default/health_check_deprecated.py

@@ -0,0 +1,126 @@
+from typing import Any
+
+import httpx
+from tenacity import retry
+
+from ...models.validation_error import ValidationError
+from ...types import Response
+from ...util.errors import QCSHTTPStatusError
+from ...util.retry import DEFAULT_RETRY_ARGUMENTS
+
+
+def _get_kwargs() -> dict[str, Any]:
+
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": "/v1/",
+    }
+
+    return _kwargs
+
+
+def _parse_response(*, response: httpx.Response) -> Any | ValidationError | None:
+    if response.status_code == 200:
+        response_200 = response.json()
+        return response_200
+
+    raise QCSHTTPStatusError(
+        message=f"Unexpected response: status code {response.status_code}",
+        response=response,
+    )
+
+
+def _build_response(*, response: httpx.Response) -> Response[Any | ValidationError]:
+    """Construct the Response class from the raw ``httpx.Response``."""
+    return Response.build_from_httpx_response(response=response, parse_function=_parse_response)
+
+
+@retry(**DEFAULT_RETRY_ARGUMENTS)
+def sync(
+    *,
+    client: httpx.Client,
+    httpx_request_kwargs: dict[str, Any] | None = None,
+) -> Response[Any | ValidationError]:
+    """Health Check
+
+     Endpoint to return a status 200 for load balancer health checks
+
+    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 | ValidationError]
+    """
+
+    httpx_request_kwargs = httpx_request_kwargs or {}
+
+    kwargs = _get_kwargs()
+    kwargs.update(httpx_request_kwargs)
+    response = client.request(
+        **kwargs,
+    )
+
+    return _build_response(response=response)
+
+
+@retry(**DEFAULT_RETRY_ARGUMENTS)
+def sync_from_dict(
+    *,
+    client: httpx.Client,
+    httpx_request_kwargs: dict[str, Any] | None = None,
+) -> Response[Any | ValidationError]:
+    httpx_request_kwargs = httpx_request_kwargs or {}
+
+    kwargs = _get_kwargs(
+        client=client,
+    )
+    kwargs.update(httpx_request_kwargs)
+    response = client.request(
+        **kwargs,
+    )
+    return _build_response(response=response)
+
+
+@retry(**DEFAULT_RETRY_ARGUMENTS)
+async def asyncio(
+    *,
+    client: httpx.AsyncClient,
+    httpx_request_kwargs: dict[str, Any] | None = None,
+) -> Response[Any | ValidationError]:
+    """Health Check
+
+     Endpoint to return a status 200 for load balancer health checks
+
+    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 | ValidationError]
+    """
+
+    httpx_request_kwargs = httpx_request_kwargs or {}
+    kwargs = _get_kwargs()
+    kwargs.update(httpx_request_kwargs)
+    response = await client.request(**kwargs)
+    return _build_response(response=response)
+
+
+@retry(**DEFAULT_RETRY_ARGUMENTS)
+async def asyncio_from_dict(
+    *,
+    client: httpx.AsyncClient,
+    httpx_request_kwargs: dict[str, Any] | None = None,
+) -> Response[Any | ValidationError]:
+    httpx_request_kwargs = httpx_request_kwargs or {}
+
+    kwargs = _get_kwargs(
+        client=client,
+    )
+    kwargs.update(httpx_request_kwargs)
+    response = await client.request(
+        **kwargs,
+    )
+
+    return _build_response(response=response)

qcs_api_client/api/endpoints/__init__.py

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

qcs_api_client/api/endpoints/create_endpoint.py

@@ -0,0 +1,157 @@
+from typing import Any
+
+import httpx
+from tenacity import retry
+
+from ...models.create_endpoint_parameters import CreateEndpointParameters
+from ...models.endpoint import Endpoint
+from ...models.error import Error
+from ...models.validation_error import ValidationError
+from ...types import Response
+from ...util.errors import QCSHTTPStatusError
+from ...util.retry import DEFAULT_RETRY_ARGUMENTS
+
+
+def _get_kwargs(
+    *,
+    body: CreateEndpointParameters,
+) -> dict[str, Any]:
+    headers: dict[str, Any] = {}
+
+    _kwargs: dict[str, Any] = {
+        "method": "post",
+        "url": "/v1/endpoints",
+    }
+
+    _kwargs["json"] = body.to_dict()
+
+    headers["Content-Type"] = "application/json"
+
+    _kwargs["headers"] = headers
+    return _kwargs
+
+
+def _parse_response(*, response: httpx.Response) -> Endpoint | Error | ValidationError | None:
+    if response.status_code == 201:
+        response_201 = Endpoint.from_dict(response.json())
+
+        return response_201
+
+    raise QCSHTTPStatusError(
+        message=f"Unexpected response: status code {response.status_code}",
+        response=response,
+    )
+
+
+def _build_response(*, response: httpx.Response) -> Response[Endpoint | Error | ValidationError]:
+    """Construct the Response class from the raw ``httpx.Response``."""
+    return Response.build_from_httpx_response(response=response, parse_function=_parse_response)
+
+
+@retry(**DEFAULT_RETRY_ARGUMENTS)
+def sync(
+    *,
+    client: httpx.Client,
+    body: CreateEndpointParameters,
+    httpx_request_kwargs: dict[str, Any] | None = None,
+) -> Response[Endpoint | Error | ValidationError]:
+    """Create Endpoint
+
+     Create an endpoint associated with your user account.
+
+    Args:
+        body (CreateEndpointParameters): A publicly available set of parameters for defining an
+            endpoint.
+
+    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[Endpoint | Error | ValidationError]
+    """
+
+    httpx_request_kwargs = httpx_request_kwargs or {}
+
+    kwargs = _get_kwargs(
+        body=body,
+    )
+    kwargs.update(httpx_request_kwargs)
+    response = client.request(
+        **kwargs,
+    )
+
+    return _build_response(response=response)
+
+
+@retry(**DEFAULT_RETRY_ARGUMENTS)
+def sync_from_dict(
+    *,
+    client: httpx.Client,
+    body: dict,
+    httpx_request_kwargs: dict[str, Any] | None = None,
+) -> Response[Endpoint | Error | ValidationError]:
+    httpx_request_kwargs = httpx_request_kwargs or {}
+
+    kwargs = _get_kwargs(
+        client=client,
+        body=body,
+    )
+    kwargs.update(httpx_request_kwargs)
+    response = client.request(
+        **kwargs,
+    )
+    return _build_response(response=response)
+
+
+@retry(**DEFAULT_RETRY_ARGUMENTS)
+async def asyncio(
+    *,
+    client: httpx.AsyncClient,
+    body: CreateEndpointParameters,
+    httpx_request_kwargs: dict[str, Any] | None = None,
+) -> Response[Endpoint | Error | ValidationError]:
+    """Create Endpoint
+
+     Create an endpoint associated with your user account.
+
+    Args:
+        body (CreateEndpointParameters): A publicly available set of parameters for defining an
+            endpoint.
+
+    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[Endpoint | Error | ValidationError]
+    """
+
+    httpx_request_kwargs = httpx_request_kwargs or {}
+    kwargs = _get_kwargs(
+        body=body,
+    )
+    kwargs.update(httpx_request_kwargs)
+    response = await client.request(**kwargs)
+    return _build_response(response=response)
+
+
+@retry(**DEFAULT_RETRY_ARGUMENTS)
+async def asyncio_from_dict(
+    *,
+    client: httpx.AsyncClient,
+    body: dict,
+    httpx_request_kwargs: dict[str, Any] | None = None,
+) -> Response[Endpoint | Error | ValidationError]:
+    httpx_request_kwargs = httpx_request_kwargs or {}
+
+    kwargs = _get_kwargs(
+        client=client,
+        body=body,
+    )
+    kwargs.update(httpx_request_kwargs)
+    response = await client.request(
+        **kwargs,
+    )
+
+    return _build_response(response=response)

qcs_api_client/api/endpoints/delete_endpoint.py

@@ -0,0 +1,148 @@
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+from tenacity import retry
+
+from ...models.error import Error
+from ...models.validation_error import ValidationError
+from ...types import Response
+from ...util.errors import QCSHTTPStatusError
+from ...util.retry import DEFAULT_RETRY_ARGUMENTS
+
+
+def _get_kwargs(
+    endpoint_id: str,
+) -> dict[str, Any]:
+
+    _kwargs: dict[str, Any] = {
+        "method": "delete",
+        "url": "/v1/endpoints/{endpoint_id}".format(
+            endpoint_id=quote(str(endpoint_id), safe=""),
+        ),
+    }
+
+    return _kwargs
+
+
+def _parse_response(*, response: httpx.Response) -> Any | Error | ValidationError | None:
+    if response.status_code == 204:
+        response_204 = cast(Any, None)
+        return response_204
+
+    raise QCSHTTPStatusError(
+        message=f"Unexpected response: status code {response.status_code}",
+        response=response,
+    )
+
+
+def _build_response(*, response: httpx.Response) -> Response[Any | Error | ValidationError]:
+    """Construct the Response class from the raw ``httpx.Response``."""
+    return Response.build_from_httpx_response(response=response, parse_function=_parse_response)
+
+
+@retry(**DEFAULT_RETRY_ARGUMENTS)
+def sync(
+    endpoint_id: str,
+    *,
+    client: httpx.Client,
+    httpx_request_kwargs: dict[str, Any] | None = None,
+) -> Response[Any | Error | ValidationError]:
+    """Delete Endpoint
+
+     Delete an endpoint, releasing its resources. This operation is not reversible.
+
+    Args:
+        endpoint_id (str):
+
+    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 | Error | ValidationError]
+    """
+
+    httpx_request_kwargs = httpx_request_kwargs or {}
+
+    kwargs = _get_kwargs(
+        endpoint_id=endpoint_id,
+    )
+    kwargs.update(httpx_request_kwargs)
+    response = client.request(
+        **kwargs,
+    )
+
+    return _build_response(response=response)
+
+
+@retry(**DEFAULT_RETRY_ARGUMENTS)
+def sync_from_dict(
+    endpoint_id: str,
+    *,
+    client: httpx.Client,
+    httpx_request_kwargs: dict[str, Any] | None = None,
+) -> Response[Any | Error | ValidationError]:
+    httpx_request_kwargs = httpx_request_kwargs or {}
+
+    kwargs = _get_kwargs(
+        endpoint_id=endpoint_id,
+        client=client,
+    )
+    kwargs.update(httpx_request_kwargs)
+    response = client.request(
+        **kwargs,
+    )
+    return _build_response(response=response)
+
+
+@retry(**DEFAULT_RETRY_ARGUMENTS)
+async def asyncio(
+    endpoint_id: str,
+    *,
+    client: httpx.AsyncClient,
+    httpx_request_kwargs: dict[str, Any] | None = None,
+) -> Response[Any | Error | ValidationError]:
+    """Delete Endpoint
+
+     Delete an endpoint, releasing its resources. This operation is not reversible.
+
+    Args:
+        endpoint_id (str):
+
+    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 | Error | ValidationError]
+    """
+
+    httpx_request_kwargs = httpx_request_kwargs or {}
+    kwargs = _get_kwargs(
+        endpoint_id=endpoint_id,
+    )
+    kwargs.update(httpx_request_kwargs)
+    response = await client.request(**kwargs)
+    return _build_response(response=response)
+
+
+@retry(**DEFAULT_RETRY_ARGUMENTS)
+async def asyncio_from_dict(
+    endpoint_id: str,
+    *,
+    client: httpx.AsyncClient,
+    httpx_request_kwargs: dict[str, Any] | None = None,
+) -> Response[Any | Error | ValidationError]:
+    httpx_request_kwargs = httpx_request_kwargs or {}
+
+    kwargs = _get_kwargs(
+        endpoint_id=endpoint_id,
+        client=client,
+    )
+    kwargs.update(httpx_request_kwargs)
+    response = await client.request(
+        **kwargs,
+    )
+
+    return _build_response(response=response)