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

compute_api_client/exceptions.py

@@ -11,6 +11,8 @@
     Do not edit the class manually.
 """  # noqa: E501
 
+from typing import Any, Optional
+from typing_extensions import Self
 
 class OpenApiException(Exception):
     """The base exception class for all OpenAPIExceptions"""
@@ -101,17 +103,63 @@ class ApiKeyError(OpenApiException, KeyError):
 
 class ApiException(OpenApiException):
 
-    def __init__(self, status=None, reason=None, http_resp=None) -> None:
+    def __init__(
+        self, 
+        status=None, 
+        reason=None, 
+        http_resp=None,
+        *,
+        body: Optional[str] = None,
+        data: Optional[Any] = None,
+    ) -> None:
+        self.status = status
+        self.reason = reason
+        self.body = body
+        self.data = data
+        self.headers = None
+
         if http_resp:
-            self.status = http_resp.status
-            self.reason = http_resp.reason
-            self.body = http_resp.data.decode('utf-8')
+            if self.status is None:
+                self.status = http_resp.status
+            if self.reason is None:
+                self.reason = http_resp.reason
+            if self.body is None:
+                try:
+                    self.body = http_resp.data.decode('utf-8')
+                except Exception:
+                    pass
             self.headers = http_resp.getheaders()
-        else:
-            self.status = status
-            self.reason = reason
-            self.body = None
-            self.headers = None
+
+    @classmethod
+    def from_response(
+        cls, 
+        *, 
+        http_resp, 
+        body: Optional[str], 
+        data: Optional[Any],
+    ) -> Self:
+        if http_resp.status == 400:
+            raise BadRequestException(http_resp=http_resp, body=body, data=data)
+
+        if http_resp.status == 401:
+            raise UnauthorizedException(http_resp=http_resp, body=body, data=data)
+
+        if http_resp.status == 403:
+            raise ForbiddenException(http_resp=http_resp, body=body, data=data)
+
+        if http_resp.status == 404:
+            raise NotFoundException(http_resp=http_resp, body=body, data=data)
+
+        # Added new conditions for 409 and 422
+        if http_resp.status == 409:
+            raise ConflictException(http_resp=http_resp, body=body, data=data)
+
+        if http_resp.status == 422:
+            raise UnprocessableEntityException(http_resp=http_resp, body=body, data=data)
+
+        if 500 <= http_resp.status <= 599:
+            raise ServiceException(http_resp=http_resp, body=body, data=data)
+        raise ApiException(http_resp=http_resp, body=body, data=data)
 
     def __str__(self):
         """Custom error messages for exception"""
@@ -121,38 +169,40 @@ class ApiException(OpenApiException):
             error_message += "HTTP response headers: {0}\n".format(
                 self.headers)
 
-        if self.body:
-            error_message += "HTTP response body: {0}\n".format(self.body)
+        if self.data or self.body:
+            error_message += "HTTP response body: {0}\n".format(self.data or self.body)
 
         return error_message
 
+
 class BadRequestException(ApiException):
+    pass
 
-    def __init__(self, status=None, reason=None, http_resp=None) -> None:
-        super(BadRequestException, self).__init__(status, reason, http_resp)
 
 class NotFoundException(ApiException):
-
-    def __init__(self, status=None, reason=None, http_resp=None) -> None:
-        super(NotFoundException, self).__init__(status, reason, http_resp)
+    pass
 
 
 class UnauthorizedException(ApiException):
-
-    def __init__(self, status=None, reason=None, http_resp=None) -> None:
-        super(UnauthorizedException, self).__init__(status, reason, http_resp)
+    pass
 
 
 class ForbiddenException(ApiException):
-
-    def __init__(self, status=None, reason=None, http_resp=None) -> None:
-        super(ForbiddenException, self).__init__(status, reason, http_resp)
+    pass
 
 
 class ServiceException(ApiException):
+    pass
+
+
+class ConflictException(ApiException):
+    """Exception for HTTP 409 Conflict."""
+    pass
+
 
-    def __init__(self, status=None, reason=None, http_resp=None) -> None:
-        super(ServiceException, self).__init__(status, reason, http_resp)
+class UnprocessableEntityException(ApiException):
+    """Exception for HTTP 422 Unprocessable Entity."""
+    pass
 
 
 def render_path(path_to_item):

compute_api_client/models/__init__.py

@@ -45,7 +45,6 @@ from compute_api_client.models.job_in import JobIn
 from compute_api_client.models.job_patch import JobPatch
 from compute_api_client.models.job_status import JobStatus
 from compute_api_client.models.language import Language
-from compute_api_client.models.location_inner import LocationInner
 from compute_api_client.models.member import Member
 from compute_api_client.models.member_in import MemberIn
 from compute_api_client.models.page_algorithm import PageAlgorithm
@@ -81,3 +80,4 @@ from compute_api_client.models.transaction import Transaction
 from compute_api_client.models.user import User
 from compute_api_client.models.user_in import UserIn
 from compute_api_client.models.validation_error import ValidationError
+from compute_api_client.models.validation_error_loc_inner import ValidationErrorLocInner

compute_api_client/models/algorithm.py

@@ -17,34 +17,31 @@ 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 Algorithm(BaseModel):
     """
     Algorithm
     """ # noqa: E501
-    id: StrictInt
-    project_id: StrictInt
-    type: AlgorithmType
-    shared: ShareType
+    id: StrictInt = Field(description="ID of the algorithm")
+    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)]]
-    name: Annotated[str, Field(strict=True, max_length=255)]
+    name: Annotated[str, Field(strict=True, max_length=255)] = Field(description="Name of the algorithm")
     __properties: ClassVar[List[str]] = ["id", "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:
@@ -57,7 +54,7 @@ class Algorithm(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 Algorithm from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
@@ -71,10 +68,12 @@ class Algorithm(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
@@ -85,7 +84,7 @@ class Algorithm(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 Algorithm from a dict"""
         if obj is None:
             return None

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):