qcs_api_client 0.27.3__py3-none-any.whl

qcs_api_client/models/health.py

@@ -0,0 +1,69 @@
+from __future__ import annotations
+
+from collections.abc import Callable, Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET
+from ..util.serialization import is_not_none
+
+T = TypeVar("T", bound="Health")
+
+
+@_attrs_define
+class Health:
+    """
+    Attributes:
+        status (str):  Example: PASS.
+    """
+
+    status: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self, pick_by_predicate: Callable[[str, Any], bool] | None = is_not_none) -> dict[str, Any]:
+        status = self.status
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "status": status,
+            }
+        )
+
+        if pick_by_predicate is not None:
+            field_dict = {k: v for k, v in field_dict.items() if pick_by_predicate(v)}
+        else:
+            field_dict = {k: v for k, v in field_dict.items() if v != UNSET}
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        status = d.pop("status")
+
+        health = cls(
+            status=status,
+        )
+
+        health.additional_properties = d
+        return health
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

qcs_api_client/models/instruction_set_architecture.py

@@ -0,0 +1,142 @@
+from __future__ import annotations
+
+from collections.abc import Callable, Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET
+from ..util.serialization import is_not_none
+
+if TYPE_CHECKING:
+    from ..models.architecture import Architecture
+    from ..models.operation import Operation
+
+
+T = TypeVar("T", bound="InstructionSetArchitecture")
+
+
+@_attrs_define
+class InstructionSetArchitecture:
+    """The native instruction set architecture of a quantum processor, annotated with characteristics.
+
+    The operations described by the `instructions` field are named by their QUIL instruction name,
+    while the operation described by the `benchmarks` field are named by their benchmark routine
+    and are a future extension point that will be populated in future iterations.
+
+    The characteristics that annotate both instructions and benchmarks assist the user to generate
+    the best native QUIL program for a desired task, and so are provided as part of the native ISA.
+
+        Attributes:
+            architecture (Architecture): Represents the logical underlying architecture of a quantum processor.
+
+                The architecture is defined in detail by the nodes and edges that constitute the quantum
+                processor. This defines the set of all nodes that could be operated upon, and indicates to
+                some approximation their physical layout. The main purpose of this is to support geometry
+                calculations that are independent of the available operations, and rendering ISA-based
+                information. Architecture layouts are defined by the `family`, as follows.
+
+                The "Aspen" family of quantum processor indicates a 2D planar grid layout of octagon unit
+                cells. The `node_id` in this architecture is computed as `100 p_y + 10 p_x + p_u` where
+                `p_y` is the zero-based Y position in the unit cell grid, `p_x` is the zero-based
+                X position in the unit cell grid, and `p_u` is the zero-based position in the octagon
+                unit cell and always ranges from 0 to 7. This scheme has a natural size limit of a 10x10
+                unit cell grid, which permits the architecture to scale up to 800 nodes.
+
+                Note that the operations that are actually available are defined entirely by `Operation`
+                instances. The presence of a node or edge in the `Architecture` model provides no guarantee
+                that any 1Q or 2Q operation will be available to users writing QUIL programs.
+            benchmarks (list[Operation]): The list of benchmarks that have characterized the quantum processor.
+            instructions (list[Operation]): The list of native QUIL instructions supported by the quantum processor.
+            name (str): The name of the quantum processor.
+    """
+
+    architecture: Architecture
+    benchmarks: list[Operation]
+    instructions: list[Operation]
+    name: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self, pick_by_predicate: Callable[[str, Any], bool] | None = is_not_none) -> dict[str, Any]:
+        architecture = self.architecture.to_dict()
+
+        benchmarks = []
+        for benchmarks_item_data in self.benchmarks:
+            benchmarks_item = benchmarks_item_data.to_dict()
+            benchmarks.append(benchmarks_item)
+
+        instructions = []
+        for instructions_item_data in self.instructions:
+            instructions_item = instructions_item_data.to_dict()
+            instructions.append(instructions_item)
+
+        name = self.name
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "architecture": architecture,
+                "benchmarks": benchmarks,
+                "instructions": instructions,
+                "name": name,
+            }
+        )
+
+        if pick_by_predicate is not None:
+            field_dict = {k: v for k, v in field_dict.items() if pick_by_predicate(v)}
+        else:
+            field_dict = {k: v for k, v in field_dict.items() if v != UNSET}
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.architecture import Architecture
+        from ..models.operation import Operation
+
+        d = dict(src_dict)
+        architecture = Architecture.from_dict(d.pop("architecture"))
+
+        benchmarks = []
+        _benchmarks = d.pop("benchmarks")
+        for benchmarks_item_data in _benchmarks:
+            benchmarks_item = Operation.from_dict(benchmarks_item_data)
+
+            benchmarks.append(benchmarks_item)
+
+        instructions = []
+        _instructions = d.pop("instructions")
+        for instructions_item_data in _instructions:
+            instructions_item = Operation.from_dict(instructions_item_data)
+
+            instructions.append(instructions_item)
+
+        name = d.pop("name")
+
+        instruction_set_architecture = cls(
+            architecture=architecture,
+            benchmarks=benchmarks,
+            instructions=instructions,
+            name=name,
+        )
+
+        instruction_set_architecture.additional_properties = d
+        return instruction_set_architecture
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

qcs_api_client/models/invite_user_request.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+
+from collections.abc import Callable, Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+from ..util.serialization import is_not_none
+
+T = TypeVar("T", bound="InviteUserRequest")
+
+
+@_attrs_define
+class InviteUserRequest:
+    """
+    Attributes:
+        email (str):
+        billing_organization_id (int | Unset):
+        group_name (str | Unset):
+    """
+
+    email: str
+    billing_organization_id: int | Unset = UNSET
+    group_name: str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self, pick_by_predicate: Callable[[str, Any], bool] | None = is_not_none) -> dict[str, Any]:
+        email = self.email
+
+        billing_organization_id = self.billing_organization_id
+
+        group_name = self.group_name
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "email": email,
+            }
+        )
+        if billing_organization_id is not UNSET:
+            field_dict["billingOrganizationId"] = billing_organization_id
+        if group_name is not UNSET:
+            field_dict["groupName"] = group_name
+
+        if pick_by_predicate is not None:
+            field_dict = {k: v for k, v in field_dict.items() if pick_by_predicate(v)}
+        else:
+            field_dict = {k: v for k, v in field_dict.items() if v != UNSET}
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        email = d.pop("email")
+
+        billing_organization_id = d.pop("billingOrganizationId", UNSET)
+
+        group_name = d.pop("groupName", UNSET)
+
+        invite_user_request = cls(
+            email=email,
+            billing_organization_id=billing_organization_id,
+            group_name=group_name,
+        )
+
+        invite_user_request.additional_properties = d
+        return invite_user_request
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

qcs_api_client/models/list_account_billing_invoice_lines_response.py

@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+from collections.abc import Callable, Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+from ..util.serialization import is_not_none
+
+if TYPE_CHECKING:
+    from ..models.billing_invoice_line import BillingInvoiceLine
+
+
+T = TypeVar("T", bound="ListAccountBillingInvoiceLinesResponse")
+
+
+@_attrs_define
+class ListAccountBillingInvoiceLinesResponse:
+    """
+    Attributes:
+        billing_invoice_lines (list[BillingInvoiceLine]):
+        next_page_token (str | Unset):
+    """
+
+    billing_invoice_lines: list[BillingInvoiceLine]
+    next_page_token: str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self, pick_by_predicate: Callable[[str, Any], bool] | None = is_not_none) -> dict[str, Any]:
+        billing_invoice_lines = []
+        for billing_invoice_lines_item_data in self.billing_invoice_lines:
+            billing_invoice_lines_item = billing_invoice_lines_item_data.to_dict()
+            billing_invoice_lines.append(billing_invoice_lines_item)
+
+        next_page_token = self.next_page_token
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "billingInvoiceLines": billing_invoice_lines,
+            }
+        )
+        if next_page_token is not UNSET:
+            field_dict["nextPageToken"] = next_page_token
+
+        if pick_by_predicate is not None:
+            field_dict = {k: v for k, v in field_dict.items() if pick_by_predicate(v)}
+        else:
+            field_dict = {k: v for k, v in field_dict.items() if v != UNSET}
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.billing_invoice_line import BillingInvoiceLine
+
+        d = dict(src_dict)
+        billing_invoice_lines = []
+        _billing_invoice_lines = d.pop("billingInvoiceLines")
+        for billing_invoice_lines_item_data in _billing_invoice_lines:
+            billing_invoice_lines_item = BillingInvoiceLine.from_dict(billing_invoice_lines_item_data)
+
+            billing_invoice_lines.append(billing_invoice_lines_item)
+
+        next_page_token = d.pop("nextPageToken", UNSET)
+
+        list_account_billing_invoice_lines_response = cls(
+            billing_invoice_lines=billing_invoice_lines,
+            next_page_token=next_page_token,
+        )
+
+        list_account_billing_invoice_lines_response.additional_properties = d
+        return list_account_billing_invoice_lines_response
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

qcs_api_client/models/list_account_billing_invoices_response.py

@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+from collections.abc import Callable, Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+from ..util.serialization import is_not_none
+
+if TYPE_CHECKING:
+    from ..models.billing_invoice import BillingInvoice
+
+
+T = TypeVar("T", bound="ListAccountBillingInvoicesResponse")
+
+
+@_attrs_define
+class ListAccountBillingInvoicesResponse:
+    """
+    Attributes:
+        billing_invoices (list[BillingInvoice]):
+        next_page_token (str | Unset):
+    """
+
+    billing_invoices: list[BillingInvoice]
+    next_page_token: str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self, pick_by_predicate: Callable[[str, Any], bool] | None = is_not_none) -> dict[str, Any]:
+        billing_invoices = []
+        for billing_invoices_item_data in self.billing_invoices:
+            billing_invoices_item = billing_invoices_item_data.to_dict()
+            billing_invoices.append(billing_invoices_item)
+
+        next_page_token = self.next_page_token
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "billingInvoices": billing_invoices,
+            }
+        )
+        if next_page_token is not UNSET:
+            field_dict["nextPageToken"] = next_page_token
+
+        if pick_by_predicate is not None:
+            field_dict = {k: v for k, v in field_dict.items() if pick_by_predicate(v)}
+        else:
+            field_dict = {k: v for k, v in field_dict.items() if v != UNSET}
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.billing_invoice import BillingInvoice
+
+        d = dict(src_dict)
+        billing_invoices = []
+        _billing_invoices = d.pop("billingInvoices")
+        for billing_invoices_item_data in _billing_invoices:
+            billing_invoices_item = BillingInvoice.from_dict(billing_invoices_item_data)
+
+            billing_invoices.append(billing_invoices_item)
+
+        next_page_token = d.pop("nextPageToken", UNSET)
+
+        list_account_billing_invoices_response = cls(
+            billing_invoices=billing_invoices,
+            next_page_token=next_page_token,
+        )
+
+        list_account_billing_invoices_response.additional_properties = d
+        return list_account_billing_invoices_response
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

qcs_api_client/models/list_client_applications_response.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+from collections.abc import Callable, Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET
+from ..util.serialization import is_not_none
+
+if TYPE_CHECKING:
+    from ..models.client_application import ClientApplication
+
+
+T = TypeVar("T", bound="ListClientApplicationsResponse")
+
+
+@_attrs_define
+class ListClientApplicationsResponse:
+    """
+    Attributes:
+        client_applications (list[ClientApplication]):
+    """
+
+    client_applications: list[ClientApplication]
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self, pick_by_predicate: Callable[[str, Any], bool] | None = is_not_none) -> dict[str, Any]:
+        client_applications = []
+        for client_applications_item_data in self.client_applications:
+            client_applications_item = client_applications_item_data.to_dict()
+            client_applications.append(client_applications_item)
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "clientApplications": client_applications,
+            }
+        )
+
+        if pick_by_predicate is not None:
+            field_dict = {k: v for k, v in field_dict.items() if pick_by_predicate(v)}
+        else:
+            field_dict = {k: v for k, v in field_dict.items() if v != UNSET}
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.client_application import ClientApplication
+
+        d = dict(src_dict)
+        client_applications = []
+        _client_applications = d.pop("clientApplications")
+        for client_applications_item_data in _client_applications:
+            client_applications_item = ClientApplication.from_dict(client_applications_item_data)
+
+            client_applications.append(client_applications_item)
+
+        list_client_applications_response = cls(
+            client_applications=client_applications,
+        )
+
+        list_client_applications_response.additional_properties = d
+        return list_client_applications_response
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

qcs_api_client/models/list_endpoints_response.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+from collections.abc import Callable, Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+from ..util.serialization import is_not_none
+
+if TYPE_CHECKING:
+    from ..models.endpoint import Endpoint
+
+
+T = TypeVar("T", bound="ListEndpointsResponse")
+
+
+@_attrs_define
+class ListEndpointsResponse:
+    """
+    Attributes:
+        endpoints (list[Endpoint]):
+        next_page_token (str | Unset): Opaque token indicating the start of the next page of results to return; do not
+            decode
+    """
+
+    endpoints: list[Endpoint]
+    next_page_token: str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self, pick_by_predicate: Callable[[str, Any], bool] | None = is_not_none) -> dict[str, Any]:
+        endpoints = []
+        for endpoints_item_data in self.endpoints:
+            endpoints_item = endpoints_item_data.to_dict()
+            endpoints.append(endpoints_item)
+
+        next_page_token = self.next_page_token
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "endpoints": endpoints,
+            }
+        )
+        if next_page_token is not UNSET:
+            field_dict["nextPageToken"] = next_page_token
+
+        if pick_by_predicate is not None:
+            field_dict = {k: v for k, v in field_dict.items() if pick_by_predicate(v)}
+        else:
+            field_dict = {k: v for k, v in field_dict.items() if v != UNSET}
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.endpoint import Endpoint
+
+        d = dict(src_dict)
+        endpoints = []
+        _endpoints = d.pop("endpoints")
+        for endpoints_item_data in _endpoints:
+            endpoints_item = Endpoint.from_dict(endpoints_item_data)
+
+            endpoints.append(endpoints_item)
+
+        next_page_token = d.pop("nextPageToken", UNSET)
+
+        list_endpoints_response = cls(
+            endpoints=endpoints,
+            next_page_token=next_page_token,
+        )
+
+        list_endpoints_response.additional_properties = d
+        return list_endpoints_response
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

qcs_api_client/models/list_group_reservations_show_deleted.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+class ListGroupReservationsShowDeleted(str, Enum):
+    FALSE = "false"
+    TRUE = "true"
+
+    def __str__(self) -> str:
+        return str(self.value)