qi-compute-api-client 0.56.0__py3-none-any.whl

compute_api_client/models/backend_type_patch.py

@@ -0,0 +1,205 @@
+# coding: utf-8
+
+"""
+    Quantum Inspire 2
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: 0.1.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictFloat, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+
+class BackendTypePatch(BaseModel):
+    """
+    BackendTypePatch
+    """ # noqa: E501
+    name: Optional[Annotated[str, Field(strict=True, max_length=32)]] = None
+    infrastructure: Optional[Annotated[str, Field(strict=True, max_length=32)]] = None
+    description: Optional[StrictStr] = None
+    image_id: Optional[Annotated[str, Field(strict=True, max_length=16)]] = None
+    is_hardware: Optional[StrictBool] = None
+    supports_raw_data: Optional[StrictBool] = None
+    features: Optional[List[StrictStr]] = None
+    default_compiler_config: Optional[Dict[str, Any]] = None
+    gateset: Optional[List[StrictStr]] = None
+    topology: Optional[List[List[StrictInt]]] = None
+    nqubits: Optional[StrictInt] = None
+    default_number_of_shots: Optional[StrictInt] = None
+    max_number_of_shots: Optional[StrictInt] = None
+    enabled: Optional[StrictBool] = None
+    identifier: Optional[Annotated[str, Field(strict=True, max_length=32)]] = None
+    protocol_version: Optional[StrictInt] = None
+    job_execution_time_limit: Optional[Union[StrictFloat, StrictInt]] = None
+    __properties: ClassVar[List[str]] = ["name", "infrastructure", "description", "image_id", "is_hardware", "supports_raw_data", "features", "default_compiler_config", "gateset", "topology", "nqubits", "default_number_of_shots", "max_number_of_shots", "enabled", "identifier", "protocol_version", "job_execution_time_limit"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of BackendTypePatch from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # set to None if name (nullable) is None
+        # and model_fields_set contains the field
+        if self.name is None and "name" in self.model_fields_set:
+            _dict['name'] = None
+
+        # set to None if infrastructure (nullable) is None
+        # and model_fields_set contains the field
+        if self.infrastructure is None and "infrastructure" in self.model_fields_set:
+            _dict['infrastructure'] = None
+
+        # set to None if description (nullable) is None
+        # and model_fields_set contains the field
+        if self.description is None and "description" in self.model_fields_set:
+            _dict['description'] = None
+
+        # set to None if image_id (nullable) is None
+        # and model_fields_set contains the field
+        if self.image_id is None and "image_id" in self.model_fields_set:
+            _dict['image_id'] = None
+
+        # set to None if is_hardware (nullable) is None
+        # and model_fields_set contains the field
+        if self.is_hardware is None and "is_hardware" in self.model_fields_set:
+            _dict['is_hardware'] = None
+
+        # set to None if supports_raw_data (nullable) is None
+        # and model_fields_set contains the field
+        if self.supports_raw_data is None and "supports_raw_data" in self.model_fields_set:
+            _dict['supports_raw_data'] = None
+
+        # set to None if features (nullable) is None
+        # and model_fields_set contains the field
+        if self.features is None and "features" in self.model_fields_set:
+            _dict['features'] = None
+
+        # set to None if default_compiler_config (nullable) is None
+        # and model_fields_set contains the field
+        if self.default_compiler_config is None and "default_compiler_config" in self.model_fields_set:
+            _dict['default_compiler_config'] = None
+
+        # set to None if gateset (nullable) is None
+        # and model_fields_set contains the field
+        if self.gateset is None and "gateset" in self.model_fields_set:
+            _dict['gateset'] = None
+
+        # set to None if topology (nullable) is None
+        # and model_fields_set contains the field
+        if self.topology is None and "topology" in self.model_fields_set:
+            _dict['topology'] = None
+
+        # set to None if nqubits (nullable) is None
+        # and model_fields_set contains the field
+        if self.nqubits is None and "nqubits" in self.model_fields_set:
+            _dict['nqubits'] = None
+
+        # set to None if default_number_of_shots (nullable) is None
+        # and model_fields_set contains the field
+        if self.default_number_of_shots is None and "default_number_of_shots" in self.model_fields_set:
+            _dict['default_number_of_shots'] = None
+
+        # set to None if max_number_of_shots (nullable) is None
+        # and model_fields_set contains the field
+        if self.max_number_of_shots is None and "max_number_of_shots" in self.model_fields_set:
+            _dict['max_number_of_shots'] = None
+
+        # set to None if enabled (nullable) is None
+        # and model_fields_set contains the field
+        if self.enabled is None and "enabled" in self.model_fields_set:
+            _dict['enabled'] = None
+
+        # set to None if identifier (nullable) is None
+        # and model_fields_set contains the field
+        if self.identifier is None and "identifier" in self.model_fields_set:
+            _dict['identifier'] = None
+
+        # set to None if protocol_version (nullable) is None
+        # and model_fields_set contains the field
+        if self.protocol_version is None and "protocol_version" in self.model_fields_set:
+            _dict['protocol_version'] = None
+
+        # set to None if job_execution_time_limit (nullable) is None
+        # and model_fields_set contains the field
+        if self.job_execution_time_limit is None and "job_execution_time_limit" in self.model_fields_set:
+            _dict['job_execution_time_limit'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of BackendTypePatch from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "name": obj.get("name"),
+            "infrastructure": obj.get("infrastructure"),
+            "description": obj.get("description"),
+            "image_id": obj.get("image_id"),
+            "is_hardware": obj.get("is_hardware"),
+            "supports_raw_data": obj.get("supports_raw_data"),
+            "features": obj.get("features"),
+            "default_compiler_config": obj.get("default_compiler_config"),
+            "gateset": obj.get("gateset"),
+            "topology": obj.get("topology"),
+            "nqubits": obj.get("nqubits"),
+            "default_number_of_shots": obj.get("default_number_of_shots"),
+            "max_number_of_shots": obj.get("max_number_of_shots"),
+            "enabled": obj.get("enabled"),
+            "identifier": obj.get("identifier"),
+            "protocol_version": obj.get("protocol_version"),
+            "job_execution_time_limit": obj.get("job_execution_time_limit")
+        })
+        return _obj
+
+

compute_api_client/models/backend_with_authentication.py

@@ -0,0 +1,108 @@
+# coding: utf-8
+
+"""
+    Quantum Inspire 2
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: 0.1.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from datetime import datetime
+from pydantic import BaseModel, ConfigDict, Field, StrictInt
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from compute_api_client.models.backend_message import BackendMessage
+from compute_api_client.models.backend_status import BackendStatus
+from typing import Optional, Set
+from typing_extensions import Self
+
+class BackendWithAuthentication(BaseModel):
+    """
+    BackendWithAuthentication
+    """ # noqa: E501
+    id: StrictInt = Field(description="The id of the backend")
+    name: Annotated[str, Field(strict=True, max_length=32)] = Field(description="The name of the backend")
+    location: Annotated[str, Field(strict=True, max_length=32)] = Field(description="The location of the backend")
+    backend_type_id: StrictInt = Field(description="The id of the backend type")
+    status: BackendStatus = Field(description="Status of the backend")
+    message: Optional[BackendMessage] = Field(default=None, description="The message obj for a backend")
+    last_heartbeat: datetime = Field(description="Time of last heartbeat")
+    authentication_hash: Annotated[str, Field(strict=True, max_length=32)] = Field(description="The authentication hash of the backend")
+    __properties: ClassVar[List[str]] = ["id", "name", "location", "backend_type_id", "status", "message", "last_heartbeat", "authentication_hash"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of BackendWithAuthentication from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of message
+        if self.message:
+            _dict['message'] = self.message.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of BackendWithAuthentication from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "id": obj.get("id"),
+            "name": obj.get("name"),
+            "location": obj.get("location"),
+            "backend_type_id": obj.get("backend_type_id"),
+            "status": obj.get("status"),
+            "message": BackendMessage.from_dict(obj["message"]) if obj.get("message") is not None else None,
+            "last_heartbeat": obj.get("last_heartbeat"),
+            "authentication_hash": obj.get("authentication_hash")
+        })
+        return _obj
+
+

compute_api_client/models/batch_job.py

@@ -0,0 +1,130 @@
+# coding: utf-8
+
+"""
+    Quantum Inspire 2
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: 0.1.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from datetime import datetime
+from pydantic import BaseModel, ConfigDict, Field, StrictInt
+from typing import Any, ClassVar, Dict, List, Optional
+from compute_api_client.models.algorithm_type import AlgorithmType
+from compute_api_client.models.batch_job_status import BatchJobStatus
+from typing import Optional, Set
+from typing_extensions import Self
+
+class BatchJob(BaseModel):
+    """
+    BatchJob
+    """ # noqa: E501
+    id: StrictInt = Field(description="ID of the batch job")
+    created_on: datetime = Field(description="Time of batchjob creation")
+    status: BatchJobStatus = Field(description="Status of the batchjob")
+    user_id: StrictInt = Field(description="ID of the user to whom this job belongs")
+    backend_type_id: StrictInt = Field(description="ID of the backendtype")
+    backend_id: Optional[StrictInt]
+    queued_at: Optional[datetime]
+    reserved_at: Optional[datetime]
+    finished_at: Optional[datetime]
+    job_ids: List[StrictInt] = Field(description="Job ids in the batch job")
+    aggregated_algorithm_type: AlgorithmType = Field(description="Algorithm type submitted")
+    __properties: ClassVar[List[str]] = ["id", "created_on", "status", "user_id", "backend_type_id", "backend_id", "queued_at", "reserved_at", "finished_at", "job_ids", "aggregated_algorithm_type"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of BatchJob from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # set to None if backend_id (nullable) is None
+        # and model_fields_set contains the field
+        if self.backend_id is None and "backend_id" in self.model_fields_set:
+            _dict['backend_id'] = None
+
+        # set to None if queued_at (nullable) is None
+        # and model_fields_set contains the field
+        if self.queued_at is None and "queued_at" in self.model_fields_set:
+            _dict['queued_at'] = None
+
+        # set to None if reserved_at (nullable) is None
+        # and model_fields_set contains the field
+        if self.reserved_at is None and "reserved_at" in self.model_fields_set:
+            _dict['reserved_at'] = None
+
+        # set to None if finished_at (nullable) is None
+        # and model_fields_set contains the field
+        if self.finished_at is None and "finished_at" in self.model_fields_set:
+            _dict['finished_at'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of BatchJob from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "id": obj.get("id"),
+            "created_on": obj.get("created_on"),
+            "status": obj.get("status"),
+            "user_id": obj.get("user_id"),
+            "backend_type_id": obj.get("backend_type_id"),
+            "backend_id": obj.get("backend_id"),
+            "queued_at": obj.get("queued_at"),
+            "reserved_at": obj.get("reserved_at"),
+            "finished_at": obj.get("finished_at"),
+            "job_ids": obj.get("job_ids"),
+            "aggregated_algorithm_type": obj.get("aggregated_algorithm_type")
+        })
+        return _obj
+
+

compute_api_client/models/batch_job_in.py

@@ -0,0 +1,87 @@
+# coding: utf-8
+
+"""
+    Quantum Inspire 2
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: 0.1.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictInt
+from typing import Any, ClassVar, Dict, List
+from typing import Optional, Set
+from typing_extensions import Self
+
+class BatchJobIn(BaseModel):
+    """
+    BatchJobIn
+    """ # noqa: E501
+    backend_type_id: StrictInt = Field(description="ID of the batch job")
+    __properties: ClassVar[List[str]] = ["backend_type_id"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of BatchJobIn from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of BatchJobIn from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "backend_type_id": obj.get("backend_type_id")
+        })
+        return _obj
+
+

compute_api_client/models/batch_job_status.py

@@ -0,0 +1,40 @@
+# coding: utf-8
+
+"""
+    Quantum Inspire 2
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: 0.1.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import json
+from enum import Enum
+from typing_extensions import Self
+
+
+class BatchJobStatus(str, Enum):
+    """
+    BatchJobStatus
+    """
+
+    """
+    allowed enum values
+    """
+    PLANNED = 'planned'
+    QUEUED = 'queued'
+    RESERVED = 'reserved'
+    RUNNING = 'running'
+    FINISHED = 'finished'
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Self:
+        """Create an instance of BatchJobStatus from a JSON string"""
+        return cls(json.loads(json_str))
+
+

compute_api_client/models/commit.py

@@ -0,0 +1,97 @@
+# coding: utf-8
+
+"""
+    Quantum Inspire 2
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: 0.1.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from datetime import datetime
+from pydantic import BaseModel, ConfigDict, Field, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+
+class Commit(BaseModel):
+    """
+    Commit
+    """ # noqa: E501
+    id: StrictInt = Field(description="ID of the commit")
+    created_on: datetime = Field(description="Time of creation of the commit")
+    hash: Annotated[str, Field(strict=True, max_length=32)] = Field(description="Unique hash assigned to the commit")
+    description: StrictStr = Field(description="Desriptive message of the commit")
+    algorithm_id: StrictInt = Field(description="ID of the algorithm")
+    __properties: ClassVar[List[str]] = ["id", "created_on", "hash", "description", "algorithm_id"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of Commit from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of Commit from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "id": obj.get("id"),
+            "created_on": obj.get("created_on"),
+            "hash": obj.get("hash"),
+            "description": obj.get("description"),
+            "algorithm_id": obj.get("algorithm_id")
+        })
+        return _obj
+
+