qi-compute-api-client 0.53.0__py3-none-any.whl → 0.54.1__py3-none-any.whl

compute_api_client/models/algorithm_in.py

@@ -17,33 +17,30 @@ import pprint
 import re  # noqa: F401
 import json
 
-
+from pydantic import BaseModel, ConfigDict, Field, StrictInt
 from typing import Any, ClassVar, Dict, List, Optional
-from pydantic import BaseModel, StrictInt
-from pydantic import Field
 from typing_extensions import Annotated
 from compute_api_client.models.algorithm_type import AlgorithmType
 from compute_api_client.models.share_type import ShareType
-try:
-    from typing import Self
-except ImportError:
-    from typing_extensions import Self
+from typing import Optional, Set
+from typing_extensions import Self
 
 class AlgorithmIn(BaseModel):
     """
     AlgorithmIn
     """ # noqa: E501
-    project_id: StrictInt
-    type: AlgorithmType
-    shared: ShareType
+    project_id: StrictInt = Field(description="ID of the project")
+    type: AlgorithmType = Field(description="The type of algorithm i.e. hybrid or quantum")
+    shared: ShareType = Field(description="The sharing scope of the algorithm")
     link: Optional[Annotated[str, Field(strict=True, max_length=255)]] = None
-    name: Annotated[str, Field(strict=True, max_length=255)]
+    name: Annotated[str, Field(strict=True, max_length=255)] = Field(description="The name of the algorithm")
     __properties: ClassVar[List[str]] = ["project_id", "type", "shared", "link", "name"]
 
-    model_config = {
-        "populate_by_name": True,
-        "validate_assignment": True
-    }
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
 
 
     def to_str(self) -> str:
@@ -56,7 +53,7 @@ class AlgorithmIn(BaseModel):
         return json.dumps(self.to_dict())
 
     @classmethod
-    def from_json(cls, json_str: str) -> Self:
+    def from_json(cls, json_str: str) -> Optional[Self]:
         """Create an instance of AlgorithmIn from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
@@ -70,10 +67,12 @@ class AlgorithmIn(BaseModel):
           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={
-            },
+            exclude=excluded_fields,
             exclude_none=True,
         )
         # set to None if link (nullable) is None
@@ -84,7 +83,7 @@ class AlgorithmIn(BaseModel):
         return _dict
 
     @classmethod
-    def from_dict(cls, obj: Dict) -> Self:
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
         """Create an instance of AlgorithmIn from a dict"""
         if obj is None:
             return None

compute_api_client/models/algorithm_type.py

@@ -14,16 +14,8 @@
 
 from __future__ import annotations
 import json
-import pprint
-import re  # noqa: F401
 from enum import Enum
-
-
-
-try:
-    from typing import Self
-except ImportError:
-    from typing_extensions import Self
+from typing_extensions import Self
 
 
 class AlgorithmType(str, Enum):

compute_api_client/models/auth_config.py

@@ -17,13 +17,10 @@ import pprint
 import re  # noqa: F401
 import json
 
-
+from pydantic import BaseModel, ConfigDict, StrictStr
 from typing import Any, ClassVar, Dict, List
-from pydantic import BaseModel, StrictStr
-try:
-    from typing import Self
-except ImportError:
-    from typing_extensions import Self
+from typing import Optional, Set
+from typing_extensions import Self
 
 class AuthConfig(BaseModel):
     """
@@ -34,10 +31,11 @@ class AuthConfig(BaseModel):
     well_known_endpoint: StrictStr
     __properties: ClassVar[List[str]] = ["client_id", "audience", "well_known_endpoint"]
 
-    model_config = {
-        "populate_by_name": True,
-        "validate_assignment": True
-    }
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
 
 
     def to_str(self) -> str:
@@ -50,7 +48,7 @@ class AuthConfig(BaseModel):
         return json.dumps(self.to_dict())
 
     @classmethod
-    def from_json(cls, json_str: str) -> Self:
+    def from_json(cls, json_str: str) -> Optional[Self]:
         """Create an instance of AuthConfig from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
@@ -64,16 +62,18 @@ class AuthConfig(BaseModel):
           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={
-            },
+            exclude=excluded_fields,
             exclude_none=True,
         )
         return _dict
 
     @classmethod
-    def from_dict(cls, obj: Dict) -> Self:
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
         """Create an instance of AuthConfig from a dict"""
         if obj is None:
             return None

compute_api_client/models/backend.py

@@ -18,32 +18,30 @@ import re  # noqa: F401
 import json
 
 from datetime import datetime
+from pydantic import BaseModel, ConfigDict, Field, StrictInt
 from typing import Any, ClassVar, Dict, List
-from pydantic import BaseModel, StrictInt
-from pydantic import Field
 from typing_extensions import Annotated
 from compute_api_client.models.backend_status import BackendStatus
-try:
-    from typing import Self
-except ImportError:
-    from typing_extensions import Self
+from typing import Optional, Set
+from typing_extensions import Self
 
 class Backend(BaseModel):
     """
     Backend
     """ # noqa: E501
-    id: StrictInt
-    name: Annotated[str, Field(strict=True, max_length=32)]
-    location: Annotated[str, Field(strict=True, max_length=32)]
-    backend_type_id: StrictInt
-    status: BackendStatus
-    last_heartbeat: datetime
+    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")
+    last_heartbeat: datetime = Field(description="Time of last heartbeat")
     __properties: ClassVar[List[str]] = ["id", "name", "location", "backend_type_id", "status", "last_heartbeat"]
 
-    model_config = {
-        "populate_by_name": True,
-        "validate_assignment": True
-    }
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
 
 
     def to_str(self) -> str:
@@ -56,7 +54,7 @@ class Backend(BaseModel):
         return json.dumps(self.to_dict())
 
     @classmethod
-    def from_json(cls, json_str: str) -> Self:
+    def from_json(cls, json_str: str) -> Optional[Self]:
         """Create an instance of Backend from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
@@ -70,16 +68,18 @@ class Backend(BaseModel):
           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={
-            },
+            exclude=excluded_fields,
             exclude_none=True,
         )
         return _dict
 
     @classmethod
-    def from_dict(cls, obj: Dict) -> Self:
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
         """Create an instance of Backend from a dict"""
         if obj is None:
             return None

compute_api_client/models/backend_in.py

@@ -18,31 +18,29 @@ import re  # noqa: F401
 import json
 
 from datetime import datetime
+from pydantic import BaseModel, ConfigDict, Field, StrictInt
 from typing import Any, ClassVar, Dict, List
-from pydantic import BaseModel, StrictInt
-from pydantic import Field
 from typing_extensions import Annotated
 from compute_api_client.models.backend_status import BackendStatus
-try:
-    from typing import Self
-except ImportError:
-    from typing_extensions import Self
+from typing import Optional, Set
+from typing_extensions import Self
 
 class BackendIn(BaseModel):
     """
     BackendIn
     """ # noqa: E501
-    name: Annotated[str, Field(strict=True, max_length=32)]
-    location: Annotated[str, Field(strict=True, max_length=32)]
-    backend_type_id: StrictInt
-    status: BackendStatus
-    last_heartbeat: datetime
+    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")
+    last_heartbeat: datetime = Field(description="Time of last heartbeat")
     __properties: ClassVar[List[str]] = ["name", "location", "backend_type_id", "status", "last_heartbeat"]
 
-    model_config = {
-        "populate_by_name": True,
-        "validate_assignment": True
-    }
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
 
 
     def to_str(self) -> str:
@@ -55,7 +53,7 @@ class BackendIn(BaseModel):
         return json.dumps(self.to_dict())
 
     @classmethod
-    def from_json(cls, json_str: str) -> Self:
+    def from_json(cls, json_str: str) -> Optional[Self]:
         """Create an instance of BackendIn from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
@@ -69,16 +67,18 @@ class BackendIn(BaseModel):
           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={
-            },
+            exclude=excluded_fields,
             exclude_none=True,
         )
         return _dict
 
     @classmethod
-    def from_dict(cls, obj: Dict) -> Self:
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
         """Create an instance of BackendIn from a dict"""
         if obj is None:
             return None

compute_api_client/models/backend_patch.py

@@ -18,26 +18,25 @@ import re  # noqa: F401
 import json
 
 from datetime import datetime
+from pydantic import BaseModel, ConfigDict, Field
 from typing import Any, ClassVar, Dict, List
-from pydantic import BaseModel
 from compute_api_client.models.backend_status import BackendStatus
-try:
-    from typing import Self
-except ImportError:
-    from typing_extensions import Self
+from typing import Optional, Set
+from typing_extensions import Self
 
 class BackendPatch(BaseModel):
     """
     BackendPatch
     """ # noqa: E501
-    status: BackendStatus
-    last_heartbeat: datetime
+    status: BackendStatus = Field(description="Status of the backend")
+    last_heartbeat: datetime = Field(description="Time of last heartbeat")
     __properties: ClassVar[List[str]] = ["status", "last_heartbeat"]
 
-    model_config = {
-        "populate_by_name": True,
-        "validate_assignment": True
-    }
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
 
 
     def to_str(self) -> str:
@@ -50,7 +49,7 @@ class BackendPatch(BaseModel):
         return json.dumps(self.to_dict())
 
     @classmethod
-    def from_json(cls, json_str: str) -> Self:
+    def from_json(cls, json_str: str) -> Optional[Self]:
         """Create an instance of BackendPatch from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
@@ -64,16 +63,18 @@ class BackendPatch(BaseModel):
           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={
-            },
+            exclude=excluded_fields,
             exclude_none=True,
         )
         return _dict
 
     @classmethod
-    def from_dict(cls, obj: Dict) -> Self:
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
         """Create an instance of BackendPatch from a dict"""
         if obj is None:
             return None

compute_api_client/models/backend_status.py

@@ -14,16 +14,8 @@
 
 from __future__ import annotations
 import json
-import pprint
-import re  # noqa: F401
 from enum import Enum
-
-
-
-try:
-    from typing import Self
-except ImportError:
-    from typing_extensions import Self
+from typing_extensions import Self
 
 
 class BackendStatus(str, Enum):

compute_api_client/models/backend_type.py

@@ -17,45 +17,42 @@ import pprint
 import re  # noqa: F401
 import json
 
-
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictInt, StrictStr
 from typing import Any, ClassVar, Dict, List, Optional
-from pydantic import BaseModel, StrictBool, StrictInt, StrictStr
-from pydantic import Field
 from typing_extensions import Annotated
 from compute_api_client.models.backend_status import BackendStatus
-try:
-    from typing import Self
-except ImportError:
-    from typing_extensions import Self
+from typing import Optional, Set
+from typing_extensions import Self
 
 class BackendType(BaseModel):
     """
     BackendType
     """ # noqa: E501
-    id: StrictInt
-    name: Annotated[str, Field(strict=True, max_length=32)]
-    infrastructure: Annotated[str, Field(strict=True, max_length=32)]
-    description: StrictStr
-    image_id: Annotated[str, Field(strict=True, max_length=16)]
-    is_hardware: StrictBool
-    supports_raw_data: StrictBool
-    features: List[StrictStr]
-    default_compiler_config: Dict[str, Any]
-    gateset: List[StrictStr]
-    topology: List[List[StrictInt]]
-    nqubits: StrictInt
-    status: BackendStatus
-    default_number_of_shots: StrictInt
-    max_number_of_shots: StrictInt
-    enabled: StrictBool
-    identifier: Annotated[str, Field(strict=True, max_length=32)]
+    id: StrictInt = Field(description="The id of the backend type")
+    name: Annotated[str, Field(strict=True, max_length=32)] = Field(description="Name of the backend type")
+    infrastructure: Annotated[str, Field(strict=True, max_length=32)] = Field(description="Name of the infrastructure")
+    description: StrictStr = Field(description="Description of the backendtype")
+    image_id: Annotated[str, Field(strict=True, max_length=16)] = Field(description="The id of the image")
+    is_hardware: StrictBool = Field(description="If it is hardware")
+    supports_raw_data: StrictBool = Field(description="If it supports raw data extraction")
+    features: List[Optional[StrictStr]] = Field(description="The features supported by backend type")
+    default_compiler_config: Dict[str, Any] = Field(description="The various passes for each stage")
+    gateset: List[Optional[StrictStr]] = Field(description="The primary gatesets supported by the backend")
+    topology: List[List[StrictInt]] = Field(description="The topology of the backend")
+    nqubits: StrictInt = Field(description="The number of qubits on the backend")
+    status: BackendStatus = Field(description="The status of the backend type")
+    default_number_of_shots: StrictInt = Field(description="The default shots")
+    max_number_of_shots: StrictInt = Field(description="The maximum number of shots")
+    enabled: StrictBool = Field(description="If it is enabled")
+    identifier: Annotated[str, Field(strict=True, max_length=32)] = Field(description="The identifier of the backend")
     protocol_version: Optional[StrictInt] = None
     __properties: ClassVar[List[str]] = ["id", "name", "infrastructure", "description", "image_id", "is_hardware", "supports_raw_data", "features", "default_compiler_config", "gateset", "topology", "nqubits", "status", "default_number_of_shots", "max_number_of_shots", "enabled", "identifier", "protocol_version"]
 
-    model_config = {
-        "populate_by_name": True,
-        "validate_assignment": True
-    }
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
 
 
     def to_str(self) -> str:
@@ -68,7 +65,7 @@ class BackendType(BaseModel):
         return json.dumps(self.to_dict())
 
     @classmethod
-    def from_json(cls, json_str: str) -> Self:
+    def from_json(cls, json_str: str) -> Optional[Self]:
         """Create an instance of BackendType from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
@@ -82,10 +79,12 @@ class BackendType(BaseModel):
           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={
-            },
+            exclude=excluded_fields,
             exclude_none=True,
         )
         # set to None if protocol_version (nullable) is None
@@ -96,7 +95,7 @@ class BackendType(BaseModel):
         return _dict
 
     @classmethod
-    def from_dict(cls, obj: Dict) -> Self:
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
         """Create an instance of BackendType from a dict"""
         if obj is None:
             return None

compute_api_client/models/backend_type_patch.py

@@ -17,15 +17,11 @@ import pprint
 import re  # noqa: F401
 import json
 
-
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictInt, StrictStr
 from typing import Any, ClassVar, Dict, List, Optional
-from pydantic import BaseModel, StrictBool, StrictInt, StrictStr
-from pydantic import Field
 from typing_extensions import Annotated
-try:
-    from typing import Self
-except ImportError:
-    from typing_extensions import Self
+from typing import Optional, Set
+from typing_extensions import Self
 
 class BackendTypePatch(BaseModel):
     """
@@ -49,10 +45,11 @@ class BackendTypePatch(BaseModel):
     protocol_version: Optional[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"]
 
-    model_config = {
-        "populate_by_name": True,
-        "validate_assignment": True
-    }
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
 
 
     def to_str(self) -> str:
@@ -65,7 +62,7 @@ class BackendTypePatch(BaseModel):
         return json.dumps(self.to_dict())
 
     @classmethod
-    def from_json(cls, json_str: str) -> Self:
+    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))
 
@@ -79,10 +76,12 @@ class BackendTypePatch(BaseModel):
           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={
-            },
+            exclude=excluded_fields,
             exclude_none=True,
         )
         # set to None if name (nullable) is None
@@ -168,7 +167,7 @@ class BackendTypePatch(BaseModel):
         return _dict
 
     @classmethod
-    def from_dict(cls, obj: Dict) -> Self:
+    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

compute_api_client/models/backend_with_authentication.py

@@ -18,33 +18,31 @@ import re  # noqa: F401
 import json
 
 from datetime import datetime
+from pydantic import BaseModel, ConfigDict, Field, StrictInt
 from typing import Any, ClassVar, Dict, List
-from pydantic import BaseModel, StrictInt
-from pydantic import Field
 from typing_extensions import Annotated
 from compute_api_client.models.backend_status import BackendStatus
-try:
-    from typing import Self
-except ImportError:
-    from typing_extensions import Self
+from typing import Optional, Set
+from typing_extensions import Self
 
 class BackendWithAuthentication(BaseModel):
     """
     BackendWithAuthentication
     """ # noqa: E501
-    id: StrictInt
-    name: Annotated[str, Field(strict=True, max_length=32)]
-    location: Annotated[str, Field(strict=True, max_length=32)]
-    backend_type_id: StrictInt
-    status: BackendStatus
-    last_heartbeat: datetime
-    authentication_hash: Annotated[str, Field(strict=True, max_length=32)]
+    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")
+    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", "last_heartbeat", "authentication_hash"]
 
-    model_config = {
-        "populate_by_name": True,
-        "validate_assignment": True
-    }
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
 
 
     def to_str(self) -> str:
@@ -57,7 +55,7 @@ class BackendWithAuthentication(BaseModel):
         return json.dumps(self.to_dict())
 
     @classmethod
-    def from_json(cls, json_str: str) -> Self:
+    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))
 
@@ -71,16 +69,18 @@ class BackendWithAuthentication(BaseModel):
           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={
-            },
+            exclude=excluded_fields,
             exclude_none=True,
         )
         return _dict
 
     @classmethod
-    def from_dict(cls, obj: Dict) -> Self:
+    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