qca 0.0.1.dev1__py3-none-any.whl

qca/forward/_client.py

@@ -0,0 +1,142 @@
+from __future__ import annotations
+
+from functools import cached_property
+
+from qca.common._base_client import AsyncAPIClient, SyncAPIClient
+
+from .resources.batches.batches import AsyncBatches, Batches
+from .resources.channel_pairings import AsyncChannelPairings, ChannelPairings
+from .resources.channels.channels import AsyncChannels, Channels
+from .resources.environments import AsyncEnvironments, Environments
+from .resources.files import AsyncFiles, Files
+from .resources.identities.identities import AsyncIdentities, Identities
+from .resources.memory_stores.memory_stores import AsyncMemoryStores, MemoryStores
+from .resources.models import AsyncModels, Models
+from .resources.schedule_runs import AsyncScheduleRuns, ScheduleRuns
+from .resources.schedules import AsyncSchedules, Schedules
+from .resources.sessions.sessions import AsyncSessions, Sessions
+from .resources.skills.skills import AsyncSkills, Skills
+from .resources.templates import AsyncTemplates, Templates
+from .resources.vaults.vaults import AsyncVaults, Vaults
+
+
+class Forward(SyncAPIClient):
+    _default_base_url = "https://api.qoder.com/api/v1/forward/"
+    _base_url_env = "QODER_FORWARD_BASE_URL"
+
+    @cached_property
+    def templates(self) -> Templates:
+        return Templates(self)
+
+    @cached_property
+    def identities(self) -> Identities:
+        return Identities(self)
+
+    @cached_property
+    def sessions(self) -> Sessions:
+        return Sessions(self)
+
+    @cached_property
+    def schedules(self) -> Schedules:
+        return Schedules(self)
+
+    @cached_property
+    def schedule_runs(self) -> ScheduleRuns:
+        return ScheduleRuns(self)
+
+    @cached_property
+    def batches(self) -> Batches:
+        return Batches(self)
+
+    @cached_property
+    def channels(self) -> Channels:
+        return Channels(self)
+
+    @cached_property
+    def channel_pairings(self) -> ChannelPairings:
+        return ChannelPairings(self)
+
+    @cached_property
+    def environments(self) -> Environments:
+        return Environments(self)
+
+    @cached_property
+    def files(self) -> Files:
+        return Files(self)
+
+    @cached_property
+    def skills(self) -> Skills:
+        return Skills(self)
+
+    @cached_property
+    def vaults(self) -> Vaults:
+        return Vaults(self)
+
+    @cached_property
+    def memory_stores(self) -> MemoryStores:
+        return MemoryStores(self)
+
+    @cached_property
+    def models(self) -> Models:
+        return Models(self)
+
+
+class AsyncForward(AsyncAPIClient):
+    _default_base_url = "https://api.qoder.com/api/v1/forward/"
+    _base_url_env = "QODER_FORWARD_BASE_URL"
+
+    @cached_property
+    def templates(self) -> AsyncTemplates:
+        return AsyncTemplates(self)
+
+    @cached_property
+    def identities(self) -> AsyncIdentities:
+        return AsyncIdentities(self)
+
+    @cached_property
+    def sessions(self) -> AsyncSessions:
+        return AsyncSessions(self)
+
+    @cached_property
+    def schedules(self) -> AsyncSchedules:
+        return AsyncSchedules(self)
+
+    @cached_property
+    def schedule_runs(self) -> AsyncScheduleRuns:
+        return AsyncScheduleRuns(self)
+
+    @cached_property
+    def batches(self) -> AsyncBatches:
+        return AsyncBatches(self)
+
+    @cached_property
+    def channels(self) -> AsyncChannels:
+        return AsyncChannels(self)
+
+    @cached_property
+    def channel_pairings(self) -> AsyncChannelPairings:
+        return AsyncChannelPairings(self)
+
+    @cached_property
+    def environments(self) -> AsyncEnvironments:
+        return AsyncEnvironments(self)
+
+    @cached_property
+    def files(self) -> AsyncFiles:
+        return AsyncFiles(self)
+
+    @cached_property
+    def skills(self) -> AsyncSkills:
+        return AsyncSkills(self)
+
+    @cached_property
+    def vaults(self) -> AsyncVaults:
+        return AsyncVaults(self)
+
+    @cached_property
+    def memory_stores(self) -> AsyncMemoryStores:
+        return AsyncMemoryStores(self)
+
+    @cached_property
+    def models(self) -> AsyncModels:
+        return AsyncModels(self)

qca/forward/resources/__init__.py

@@ -0,0 +1,14 @@
+from .channel_pairings import AsyncChannelPairings as AsyncChannelPairings
+from .channel_pairings import ChannelPairings as ChannelPairings
+from .environments import AsyncEnvironments as AsyncEnvironments
+from .environments import Environments as Environments
+from .files import AsyncFiles as AsyncFiles
+from .files import Files as Files
+from .models import AsyncModels as AsyncModels
+from .models import Models as Models
+from .schedule_runs import AsyncScheduleRuns as AsyncScheduleRuns
+from .schedule_runs import ScheduleRuns as ScheduleRuns
+from .schedules import AsyncSchedules as AsyncSchedules
+from .schedules import Schedules as Schedules
+from .templates import AsyncTemplates as AsyncTemplates
+from .templates import Templates as Templates

qca/forward/resources/batches/__init__.py

@@ -0,0 +1,4 @@
+from .batches import AsyncBatches as AsyncBatches
+from .batches import Batches as Batches
+from .tasks import AsyncTasks as AsyncTasks
+from .tasks import Tasks as Tasks

qca/forward/resources/batches/batches.py

@@ -0,0 +1,308 @@
+from __future__ import annotations
+
+from functools import cached_property
+from typing import Any, Dict, Union
+
+import httpx
+
+from qca.common._resource import AsyncAPIResource, SyncAPIResource
+from qca.common._types import NOT_GIVEN, NotGiven
+from qca.common._utils import make_request_options, path_template
+from qca.common.pagination import AsyncPaginator, SyncPage
+from qca.forward.resources.batches.tasks import AsyncTasks, Tasks
+from qca.forward.types.batch import Batch
+from qca.forward.types.batch_file import BatchFile
+
+__all__ = ["Batches", "AsyncBatches"]
+
+
+class Batches(SyncAPIResource):
+    @cached_property
+    def tasks(self) -> Tasks:
+        return Tasks(self._client)
+
+    def list(
+        self,
+        *,
+        status: Union[str, None, NotGiven] = NOT_GIVEN,
+        limit: Union[int, None, NotGiven] = NOT_GIVEN,
+        after_id: Union[str, None, NotGiven] = NOT_GIVEN,
+        before_id: Union[str, None, NotGiven] = NOT_GIVEN,
+        extra_headers: Dict[str, str] | None = None,
+        extra_query: Dict[str, Any] | None = None,
+        extra_body: Dict[str, Any] | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> SyncPage[Batch]:
+        """GET /batches."""
+        _path = path_template("/batches")
+        options = make_request_options(
+            body={},
+            query={"status": status, "limit": limit, "after_id": after_id, "before_id": before_id},
+            headers={},
+            extra_headers=extra_headers,
+            extra_query=extra_query,
+            extra_body=extra_body,
+            timeout=timeout,
+        )
+        return self._client.request("GET", _path, cast_to=Batch, options=options, page_style="Page")
+
+    def create(
+        self,
+        *,
+        input_file_id: str,
+        completion_window: str,
+        metadata: Union[Dict[str, Any], None, NotGiven] = NOT_GIVEN,
+        idempotency_key: Union[str, None, NotGiven] = NOT_GIVEN,
+        extra_headers: Dict[str, str] | None = None,
+        extra_query: Dict[str, Any] | None = None,
+        extra_body: Dict[str, Any] | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> Batch:
+        """POST /batches."""
+        _path = path_template("/batches")
+        options = make_request_options(
+            body={"input_file_id": input_file_id, "completion_window": completion_window, "metadata": metadata},
+            query={},
+            headers={"Idempotency-Key": idempotency_key},
+            extra_headers=extra_headers,
+            extra_query=extra_query,
+            extra_body=extra_body,
+            timeout=timeout,
+        )
+        return self._client.request("POST", _path, cast_to=Batch, options=options)
+
+    def retrieve(
+        self,
+        batch_id: str,
+        *,
+        extra_headers: Dict[str, str] | None = None,
+        extra_query: Dict[str, Any] | None = None,
+        extra_body: Dict[str, Any] | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> Batch:
+        """GET /batches/{batch_id}."""
+        _path = path_template("/batches/{batch_id}", batch_id=batch_id)
+        options = make_request_options(
+            body={},
+            query={},
+            headers={},
+            extra_headers=extra_headers,
+            extra_query=extra_query,
+            extra_body=extra_body,
+            timeout=timeout,
+        )
+        return self._client.request("GET", _path, cast_to=Batch, options=options)
+
+    def cancel(
+        self,
+        batch_id: str,
+        *,
+        idempotency_key: Union[str, None, NotGiven] = NOT_GIVEN,
+        extra_headers: Dict[str, str] | None = None,
+        extra_query: Dict[str, Any] | None = None,
+        extra_body: Dict[str, Any] | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> Batch:
+        """POST /batches/{batch_id}/cancel."""
+        _path = path_template("/batches/{batch_id}/cancel", batch_id=batch_id)
+        options = make_request_options(
+            body={},
+            query={},
+            headers={"Idempotency-Key": idempotency_key},
+            extra_headers=extra_headers,
+            extra_query=extra_query,
+            extra_body=extra_body,
+            timeout=timeout,
+        )
+        return self._client.request("POST", _path, cast_to=Batch, options=options)
+
+    def retrieve_error(
+        self,
+        batch_id: str,
+        *,
+        extra_headers: Dict[str, str] | None = None,
+        extra_query: Dict[str, Any] | None = None,
+        extra_body: Dict[str, Any] | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> BatchFile:
+        """GET /batches/{batch_id}/error."""
+        _path = path_template("/batches/{batch_id}/error", batch_id=batch_id)
+        options = make_request_options(
+            body={},
+            query={},
+            headers={},
+            extra_headers=extra_headers,
+            extra_query=extra_query,
+            extra_body=extra_body,
+            timeout=timeout,
+        )
+        return self._client.request("GET", _path, cast_to=BatchFile, options=options)
+
+    def retrieve_output(
+        self,
+        batch_id: str,
+        *,
+        extra_headers: Dict[str, str] | None = None,
+        extra_query: Dict[str, Any] | None = None,
+        extra_body: Dict[str, Any] | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> BatchFile:
+        """GET /batches/{batch_id}/output."""
+        _path = path_template("/batches/{batch_id}/output", batch_id=batch_id)
+        options = make_request_options(
+            body={},
+            query={},
+            headers={},
+            extra_headers=extra_headers,
+            extra_query=extra_query,
+            extra_body=extra_body,
+            timeout=timeout,
+        )
+        return self._client.request("GET", _path, cast_to=BatchFile, options=options)
+
+
+class AsyncBatches(AsyncAPIResource):
+    @cached_property
+    def tasks(self) -> AsyncTasks:
+        return AsyncTasks(self._client)
+
+    def list(
+        self,
+        *,
+        status: Union[str, None, NotGiven] = NOT_GIVEN,
+        limit: Union[int, None, NotGiven] = NOT_GIVEN,
+        after_id: Union[str, None, NotGiven] = NOT_GIVEN,
+        before_id: Union[str, None, NotGiven] = NOT_GIVEN,
+        extra_headers: Dict[str, str] | None = None,
+        extra_query: Dict[str, Any] | None = None,
+        extra_body: Dict[str, Any] | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> AsyncPaginator[Batch]:
+        """GET /batches."""
+        _path = path_template("/batches")
+        options = make_request_options(
+            body={},
+            query={"status": status, "limit": limit, "after_id": after_id, "before_id": before_id},
+            headers={},
+            extra_headers=extra_headers,
+            extra_query=extra_query,
+            extra_body=extra_body,
+            timeout=timeout,
+        )
+        return AsyncPaginator(
+            lambda: self._client.request("GET", _path, cast_to=Batch, options=options, page_style="Page")
+        )
+
+    async def create(
+        self,
+        *,
+        input_file_id: str,
+        completion_window: str,
+        metadata: Union[Dict[str, Any], None, NotGiven] = NOT_GIVEN,
+        idempotency_key: Union[str, None, NotGiven] = NOT_GIVEN,
+        extra_headers: Dict[str, str] | None = None,
+        extra_query: Dict[str, Any] | None = None,
+        extra_body: Dict[str, Any] | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> Batch:
+        """POST /batches."""
+        _path = path_template("/batches")
+        options = make_request_options(
+            body={"input_file_id": input_file_id, "completion_window": completion_window, "metadata": metadata},
+            query={},
+            headers={"Idempotency-Key": idempotency_key},
+            extra_headers=extra_headers,
+            extra_query=extra_query,
+            extra_body=extra_body,
+            timeout=timeout,
+        )
+        return await self._client.request("POST", _path, cast_to=Batch, options=options)
+
+    async def retrieve(
+        self,
+        batch_id: str,
+        *,
+        extra_headers: Dict[str, str] | None = None,
+        extra_query: Dict[str, Any] | None = None,
+        extra_body: Dict[str, Any] | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> Batch:
+        """GET /batches/{batch_id}."""
+        _path = path_template("/batches/{batch_id}", batch_id=batch_id)
+        options = make_request_options(
+            body={},
+            query={},
+            headers={},
+            extra_headers=extra_headers,
+            extra_query=extra_query,
+            extra_body=extra_body,
+            timeout=timeout,
+        )
+        return await self._client.request("GET", _path, cast_to=Batch, options=options)
+
+    async def cancel(
+        self,
+        batch_id: str,
+        *,
+        idempotency_key: Union[str, None, NotGiven] = NOT_GIVEN,
+        extra_headers: Dict[str, str] | None = None,
+        extra_query: Dict[str, Any] | None = None,
+        extra_body: Dict[str, Any] | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> Batch:
+        """POST /batches/{batch_id}/cancel."""
+        _path = path_template("/batches/{batch_id}/cancel", batch_id=batch_id)
+        options = make_request_options(
+            body={},
+            query={},
+            headers={"Idempotency-Key": idempotency_key},
+            extra_headers=extra_headers,
+            extra_query=extra_query,
+            extra_body=extra_body,
+            timeout=timeout,
+        )
+        return await self._client.request("POST", _path, cast_to=Batch, options=options)
+
+    async def retrieve_error(
+        self,
+        batch_id: str,
+        *,
+        extra_headers: Dict[str, str] | None = None,
+        extra_query: Dict[str, Any] | None = None,
+        extra_body: Dict[str, Any] | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> BatchFile:
+        """GET /batches/{batch_id}/error."""
+        _path = path_template("/batches/{batch_id}/error", batch_id=batch_id)
+        options = make_request_options(
+            body={},
+            query={},
+            headers={},
+            extra_headers=extra_headers,
+            extra_query=extra_query,
+            extra_body=extra_body,
+            timeout=timeout,
+        )
+        return await self._client.request("GET", _path, cast_to=BatchFile, options=options)
+
+    async def retrieve_output(
+        self,
+        batch_id: str,
+        *,
+        extra_headers: Dict[str, str] | None = None,
+        extra_query: Dict[str, Any] | None = None,
+        extra_body: Dict[str, Any] | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> BatchFile:
+        """GET /batches/{batch_id}/output."""
+        _path = path_template("/batches/{batch_id}/output", batch_id=batch_id)
+        options = make_request_options(
+            body={},
+            query={},
+            headers={},
+            extra_headers=extra_headers,
+            extra_query=extra_query,
+            extra_body=extra_body,
+            timeout=timeout,
+        )
+        return await self._client.request("GET", _path, cast_to=BatchFile, options=options)

qca/forward/resources/batches/tasks.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+from typing import Any, Dict, Union
+
+import httpx
+
+from qca.common._resource import AsyncAPIResource, SyncAPIResource
+from qca.common._types import NOT_GIVEN, NotGiven
+from qca.common._utils import make_request_options, path_template
+from qca.common.pagination import AsyncPaginator, SyncPage
+from qca.forward.types.batch_task import BatchTask
+
+__all__ = ["Tasks", "AsyncTasks"]
+
+
+class Tasks(SyncAPIResource):
+    def list(
+        self,
+        batch_id: str,
+        *,
+        status: Union[str, None, NotGiven] = NOT_GIVEN,
+        custom_id: Union[str, None, NotGiven] = NOT_GIVEN,
+        limit: Union[int, None, NotGiven] = NOT_GIVEN,
+        after_id: Union[str, None, NotGiven] = NOT_GIVEN,
+        extra_headers: Dict[str, str] | None = None,
+        extra_query: Dict[str, Any] | None = None,
+        extra_body: Dict[str, Any] | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> SyncPage[BatchTask]:
+        """GET /batches/{batch_id}/tasks."""
+        _path = path_template("/batches/{batch_id}/tasks", batch_id=batch_id)
+        options = make_request_options(
+            body={},
+            query={"status": status, "custom_id": custom_id, "limit": limit, "after_id": after_id},
+            headers={},
+            extra_headers=extra_headers,
+            extra_query=extra_query,
+            extra_body=extra_body,
+            timeout=timeout,
+        )
+        return self._client.request("GET", _path, cast_to=BatchTask, options=options, page_style="Page")
+
+
+class AsyncTasks(AsyncAPIResource):
+    def list(
+        self,
+        batch_id: str,
+        *,
+        status: Union[str, None, NotGiven] = NOT_GIVEN,
+        custom_id: Union[str, None, NotGiven] = NOT_GIVEN,
+        limit: Union[int, None, NotGiven] = NOT_GIVEN,
+        after_id: Union[str, None, NotGiven] = NOT_GIVEN,
+        extra_headers: Dict[str, str] | None = None,
+        extra_query: Dict[str, Any] | None = None,
+        extra_body: Dict[str, Any] | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> AsyncPaginator[BatchTask]:
+        """GET /batches/{batch_id}/tasks."""
+        _path = path_template("/batches/{batch_id}/tasks", batch_id=batch_id)
+        options = make_request_options(
+            body={},
+            query={"status": status, "custom_id": custom_id, "limit": limit, "after_id": after_id},
+            headers={},
+            extra_headers=extra_headers,
+            extra_query=extra_query,
+            extra_body=extra_body,
+            timeout=timeout,
+        )
+        return AsyncPaginator(
+            lambda: self._client.request("GET", _path, cast_to=BatchTask, options=options, page_style="Page")
+        )

qca/forward/resources/channel_pairings.py

@@ -0,0 +1,111 @@
+from __future__ import annotations
+
+from typing import Any, Dict, Union
+
+import httpx
+
+from qca.common._resource import AsyncAPIResource, SyncAPIResource
+from qca.common._types import NOT_GIVEN, NotGiven
+from qca.common._utils import make_request_options, path_template
+from qca.forward.types.channel_pairing import ChannelPairing
+from qca.forward.types.deleted_channel_pairing import DeletedChannelPairing
+
+__all__ = ["ChannelPairings", "AsyncChannelPairings"]
+
+
+class ChannelPairings(SyncAPIResource):
+    def create(
+        self,
+        *,
+        code: str,
+        identity_id: str,
+        template_id: str,
+        idempotency_key: Union[str, None, NotGiven] = NOT_GIVEN,
+        extra_headers: Dict[str, str] | None = None,
+        extra_query: Dict[str, Any] | None = None,
+        extra_body: Dict[str, Any] | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> ChannelPairing:
+        """POST /channel_pairings."""
+        _path = path_template("/channel_pairings")
+        options = make_request_options(
+            body={"code": code, "identity_id": identity_id, "template_id": template_id},
+            query={},
+            headers={"Idempotency-Key": idempotency_key},
+            extra_headers=extra_headers,
+            extra_query=extra_query,
+            extra_body=extra_body,
+            timeout=timeout,
+        )
+        return self._client.request("POST", _path, cast_to=ChannelPairing, options=options)
+
+    def delete(
+        self,
+        pairing_id: str,
+        *,
+        extra_headers: Dict[str, str] | None = None,
+        extra_query: Dict[str, Any] | None = None,
+        extra_body: Dict[str, Any] | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> DeletedChannelPairing:
+        """DELETE /channel_pairings/{pairing_id}."""
+        _path = path_template("/channel_pairings/{pairing_id}", pairing_id=pairing_id)
+        options = make_request_options(
+            body={},
+            query={},
+            headers={},
+            extra_headers=extra_headers,
+            extra_query=extra_query,
+            extra_body=extra_body,
+            timeout=timeout,
+        )
+        return self._client.request("DELETE", _path, cast_to=DeletedChannelPairing, options=options)
+
+
+class AsyncChannelPairings(AsyncAPIResource):
+    async def create(
+        self,
+        *,
+        code: str,
+        identity_id: str,
+        template_id: str,
+        idempotency_key: Union[str, None, NotGiven] = NOT_GIVEN,
+        extra_headers: Dict[str, str] | None = None,
+        extra_query: Dict[str, Any] | None = None,
+        extra_body: Dict[str, Any] | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> ChannelPairing:
+        """POST /channel_pairings."""
+        _path = path_template("/channel_pairings")
+        options = make_request_options(
+            body={"code": code, "identity_id": identity_id, "template_id": template_id},
+            query={},
+            headers={"Idempotency-Key": idempotency_key},
+            extra_headers=extra_headers,
+            extra_query=extra_query,
+            extra_body=extra_body,
+            timeout=timeout,
+        )
+        return await self._client.request("POST", _path, cast_to=ChannelPairing, options=options)
+
+    async def delete(
+        self,
+        pairing_id: str,
+        *,
+        extra_headers: Dict[str, str] | None = None,
+        extra_query: Dict[str, Any] | None = None,
+        extra_body: Dict[str, Any] | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> DeletedChannelPairing:
+        """DELETE /channel_pairings/{pairing_id}."""
+        _path = path_template("/channel_pairings/{pairing_id}", pairing_id=pairing_id)
+        options = make_request_options(
+            body={},
+            query={},
+            headers={},
+            extra_headers=extra_headers,
+            extra_query=extra_query,
+            extra_body=extra_body,
+            timeout=timeout,
+        )
+        return await self._client.request("DELETE", _path, cast_to=DeletedChannelPairing, options=options)

qca/forward/resources/channels/__init__.py

@@ -0,0 +1,4 @@
+from .channels import AsyncChannels as AsyncChannels
+from .channels import Channels as Channels
+from .qr_sessions import AsyncQrSessions as AsyncQrSessions
+from .qr_sessions import QrSessions as QrSessions