classiq 0.51.1__py3-none-any.whl → 0.53.0__py3-none-any.whl

classiq/interface/backend/ionq/ionq_quantum_program.py

@@ -2,8 +2,8 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, List, Optional
 
-import pydantic
-from pydantic import BaseModel
+from pydantic import BaseModel, ConfigDict, Field
+from typing_extensions import Annotated
 
 # This file is based on autogenerated code from: https://static.ionq.co/schemas/circuit-v0.json using
 # https://pydantic-docs.helpmanual.io/datamodel_code_generator/
@@ -12,10 +12,13 @@ from pydantic import BaseModel
 if TYPE_CHECKING:
     PydanticGateName = str
 else:
-    PydanticGateName = pydantic.constr(
-        regex=r"^\w+$",
-        min_length=1,
-    )
+    PydanticGateName = Annotated[
+        str,
+        Field(
+            pattern=r"^\w+$",
+            min_length=1,
+        ),
+    ]
 
 
 class Gate(BaseModel):
@@ -24,23 +27,13 @@ class Gate(BaseModel):
     control: Optional[int] = None
     targets: Optional[List[int]] = None
     controls: Optional[List[int]] = None
-
-    # Ionq changes format sometimes.
-    #   One example is that `IonqQauntumCircuit` got a field name "gateset" with the value "qis"
-    #   Another is that `Gate` got a field named "rotation"
-    class Config:
-        extra = pydantic.Extra.allow
+    model_config = ConfigDict(extra="allow")
 
 
 class IonqQuantumCircuit(BaseModel):
     qubits: int
     circuit: List[Gate]
-
-    # Ionq changes format sometimes.
-    #   One example is that `IonqQuantumCircuit` got a field name "gateset" with the value "qis"
-    #   Another is that `Gate` got a field named "rotation"
-    class Config:
-        extra = pydantic.Extra.allow
+    model_config = ConfigDict(extra="allow")
 
     @classmethod
     def from_string(cls, code: str) -> IonqQuantumCircuit:
@@ -48,4 +41,4 @@ class IonqQuantumCircuit(BaseModel):
         commentless_code = "\n".join(
             line for line in code_lines if not line.startswith("//")
         )
-        return cls.parse_raw(commentless_code)
+        return cls.model_validate_json(commentless_code)

classiq/interface/backend/pydantic_backend.py

@@ -1,6 +1,7 @@
 from typing import TYPE_CHECKING
 
-import pydantic
+from pydantic import Field, StrictStr, constr
+from typing_extensions import Annotated
 
 AZURE_QUANTUM_RESOURCE_ID_REGEX = r"^/subscriptions/([a-fA-F0-9-]*)/resourceGroups/([^\s/]*)/providers/Microsoft\.Quantum/Workspaces/([^\s/]*)$"
 
@@ -25,20 +26,31 @@ if TYPE_CHECKING:
 else:
     # TODO Simplify regular expressions in this file
 
-    PydanticAwsRoleArn = pydantic.constr(
-        strip_whitespace=True,
-    )
+    PydanticAwsRoleArn = Annotated[
+        StrictStr,
+        constr(
+            strip_whitespace=True,
+        ),
+    ]
 
-    PydanticS3BucketKey = pydantic.constr(strip_whitespace=True, min_length=1)
+    PydanticS3BucketKey = Annotated[
+        StrictStr, constr(strip_whitespace=True, min_length=1)
+    ]
 
-    PydanticAzureResourceIDType = pydantic.constr(regex=AZURE_QUANTUM_RESOURCE_ID_REGEX)
+    PydanticAzureResourceIDType = Annotated[
+        str, Field(pattern=AZURE_QUANTUM_RESOURCE_ID_REGEX)
+    ]
 
-    PydanticIonQApiKeyType = pydantic.constr(
-        regex=f"[A-Za-z0-9]{{{_IONQ_API_KEY_LENGTH}}}"
-    )
+    PydanticIonQApiKeyType = Annotated[
+        str, Field(pattern=f"[A-Za-z0-9]{{{_IONQ_API_KEY_LENGTH}}}")
+    ]
 
-    PydanticAliceBobApiKeyType = pydantic.constr(min_length=1, strip_whitespace=True)
+    PydanticAliceBobApiKeyType = Annotated[
+        StrictStr, constr(min_length=1, strip_whitespace=True)
+    ]
 
-    PydanticArgumentNameType = pydantic.constr(regex="[_a-zA-Z][_a-zA-Z0-9]*")
+    PydanticArgumentNameType = Annotated[str, Field(pattern="[_a-zA-Z][_a-zA-Z0-9]*")]
 
-    PydanticExecutionParameter = pydantic.constr(regex=EXECUTION_PARAMETER_PATTERN)
+    PydanticExecutionParameter = Annotated[
+        str, Field(pattern=EXECUTION_PARAMETER_PATTERN)
+    ]

classiq/interface/backend/quantum_backend_providers.py

@@ -20,6 +20,7 @@ class ProviderVendor(StrEnum):
     OQC = "OQC"
     INTEL = "Intel"
     AQT = "AQT"
+    IQCC = "IQCC"
 
 
 class ProviderTypeVendor:
@@ -33,6 +34,7 @@ class ProviderTypeVendor:
     OQC = Literal[ProviderVendor.OQC]
     INTEL = Literal[ProviderVendor.INTEL]
     AQT = Literal[ProviderVendor.AQT]
+    IQCC = Literal[ProviderVendor.IQCC]
 
 
 class ClassiqSimulatorBackendNames(StrEnum):

classiq/interface/chemistry/fermionic_operator.py

@@ -5,6 +5,7 @@ from typing import Set, Tuple, Union
 
 import numpy as np
 import pydantic
+from pydantic import ConfigDict
 
 from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.helpers.hashable_pydantic_base_model import (
@@ -75,7 +76,8 @@ class FermionicOperator(HashablePydanticBaseModel):
 
         return (op_symbol, op_index)
 
-    @pydantic.validator("op_list")
+    @pydantic.field_validator("op_list")
+    @classmethod
     def _validate_op_list(cls, op_list: list) -> list:
         return list(map(cls._validate_single_op, op_list))
 
@@ -99,8 +101,7 @@ class FermionicOperator(HashablePydanticBaseModel):
             "FermionicOperator can be summed together only with type FermionicOperator or SummedFermionicOperator"
         )
 
-    class Config:
-        frozen = True
+    model_config = ConfigDict(frozen=True)
 
     @staticmethod
     def _to_ladder_op(char: str) -> str:
@@ -135,9 +136,7 @@ class SummedFermionicOperator(HashablePydanticBaseModel):
     op_list: list = pydantic.Field(
         description="A list of tuples each containing a FermionicOperator and a coefficient.",
     )
-
-    class Config:
-        frozen = True
+    model_config = ConfigDict(frozen=True)
 
     @staticmethod
     def _validate_single_op(op: tuple) -> FermionicOperatorTuple:
@@ -166,7 +165,8 @@ class SummedFermionicOperator(HashablePydanticBaseModel):
 
         return op  # type: ignore[return-value] # mypy thinks that it is `Tuple[Any, ...]`, though the asserts here tell otherwise..
 
-    @pydantic.validator("op_list")
+    @pydantic.field_validator("op_list")
+    @classmethod
     def _validate_op_list(cls, op_list: list) -> list:
         return list(map(cls._validate_single_op, op_list))
 

classiq/interface/chemistry/ground_state_problem.py

@@ -1,7 +1,8 @@
-from typing import Any, Dict, List, Literal, Optional, Tuple, Union
+from typing import List, Literal, Optional, Tuple, Union, cast
 
 import pydantic
-from pydantic import Field
+from pydantic import ConfigDict, Field
+from pydantic_core.core_schema import ValidationInfo
 from typing_extensions import Annotated
 
 from classiq.interface.chemistry.fermionic_operator import SummedFermionicOperator
@@ -52,18 +53,19 @@ class GroundStateProblem(HashablePydanticBaseModel):
     )
     num_qubits: Optional[int] = pydantic.Field(default=None)
 
-    @pydantic.validator("z2_symmetries")
-    def _validate_z2_symmetries(
-        cls, z2_symmetries: bool, values: Dict[str, Any]
-    ) -> bool:
-        if z2_symmetries and values.get("mapping") == FermionMapping.FAST_BRAVYI_KITAEV:
+    @pydantic.field_validator("z2_symmetries")
+    @classmethod
+    def _validate_z2_symmetries(cls, z2_symmetries: bool, info: ValidationInfo) -> bool:
+        if (
+            z2_symmetries
+            and info.data.get("mapping") == FermionMapping.FAST_BRAVYI_KITAEV
+        ):
             raise ClassiqValueError(
                 "z2 symmetries reduction can not be used for fast_bravyi_kitaev mapping"
             )
         return z2_symmetries
 
-    class Config:
-        frozen = True
+    model_config = ConfigDict(frozen=True)
 
 
 class MoleculeProblem(GroundStateProblem):
@@ -87,20 +89,23 @@ class HamiltonianProblem(GroundStateProblem):
         description="Tuple containing the numbers of alpha particles and beta particles"
     )
 
-    @pydantic.validator("num_particles")
-    def _validate_num_particles(cls, num_particles: List[int]) -> List[int]:
-        assert isinstance(num_particles, list)
+    @pydantic.field_validator("num_particles", mode="before")
+    @classmethod
+    def _validate_num_particles(
+        cls,
+        num_particles: Union[
+            List[Union[int, float]], Tuple[Union[int, float], Union[int, float]]
+        ],
+    ) -> List[int]:
+        assert isinstance(num_particles, (list, tuple))
         assert len(num_particles) == 2
 
-        # This probably will never happen, since pydantic automatically converts
-        #   floats to ints
-        assert isinstance(num_particles[0], int)
-        assert num_particles[0] >= 1
+        num_particles = [int(x) for x in num_particles]
 
-        assert isinstance(num_particles[1], int)
+        assert num_particles[0] >= 1
         assert num_particles[1] >= 1
 
-        return num_particles
+        return cast(List[int], num_particles)
 
 
 CHEMISTRY_PROBLEMS = (MoleculeProblem, HamiltonianProblem)

classiq/interface/chemistry/molecule.py

@@ -1,6 +1,7 @@
 from typing import List, Literal, Union
 
 import pydantic
+from pydantic import ConfigDict
 
 from classiq.interface.chemistry.elements import ELEMENTS
 from classiq.interface.exceptions import ClassiqValueError
@@ -20,7 +21,7 @@ class Atom(HashablePydanticBaseModel):
 class Molecule(HashablePydanticBaseModel):
     atoms: List[Atom] = pydantic.Field(
         description="A list of atoms each containing the atoms symbol and  its (x,y,z) location",
-        min_items=1,
+        min_length=1,
     )
     spin: pydantic.NonNegativeInt = pydantic.Field(
         default=1, description="spin of the molecule"
@@ -33,12 +34,17 @@ class Molecule(HashablePydanticBaseModel):
     def atoms_type(self) -> List[AtomType]:
         return [(atom.symbol, [atom.x, atom.y, atom.z]) for atom in self.atoms]
 
-    @pydantic.validator("atoms", each_item=True, pre=True)
-    def _validate_atoms(cls, atom: Union[AtomType, Atom]) -> Atom:
+    @classmethod
+    def _validate_atom(cls, atom: Union[AtomType, Atom]) -> Atom:
         if isinstance(atom, (list, tuple)):
             return cls._validate_old_atoms_type(atom)
         return atom
 
+    @pydantic.field_validator("atoms", mode="before")
+    @classmethod
+    def _validate_atoms(cls, atoms: List[Union[AtomType, Atom]]) -> List[Atom]:
+        return [cls._validate_atom(atom) for atom in atoms]
+
     @staticmethod
     def _validate_old_atoms_type(atom: AtomType) -> Atom:
         if len(atom) != 2:
@@ -62,5 +68,4 @@ class Molecule(HashablePydanticBaseModel):
 
         return Atom(symbol=symbol, x=coordinate[0], y=coordinate[1], z=coordinate[2])
 
-    class Config:
-        frozen = True
+    model_config = ConfigDict(frozen=True)

classiq/interface/chemistry/operator.py

@@ -5,7 +5,6 @@ from typing import (
     Dict,
     List,
     Optional,
-    Tuple,
     Union,
     cast,
 )
@@ -14,6 +13,7 @@ import numpy as np
 import pydantic
 import sympy
 from more_itertools import all_equal
+from pydantic import ConfigDict
 
 from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.function_params import validate_expression_str
@@ -42,8 +42,8 @@ class PauliOperator(HashablePydanticBaseModel, VersionedModel):
     pauli_list: PydanticPauliList = pydantic.Field(
         description="A list of tuples each containing a pauli string comprised of I,X,Y,Z characters and a complex coefficient; for example [('IZ', 0.1), ('XY', 0.2)].",
     )
-    is_hermitian: bool = pydantic.Field(default=False)
     has_complex_coefficients: bool = pydantic.Field(default=True)
+    is_hermitian: bool = pydantic.Field(default=False)
 
     def show(self) -> str:
         if self.is_hermitian:
@@ -55,16 +55,19 @@ class PauliOperator(HashablePydanticBaseModel, VersionedModel):
             f"+({summand[1]:+.3f}) * {summand[0]}" for summand in self.pauli_list
         )
 
-    @pydantic.validator("pauli_list", each_item=True, pre=True)
+    @pydantic.field_validator("pauli_list", mode="before")
+    @classmethod
     def _validate_pauli_monomials(
-        cls, monomial: Tuple[PydanticPauliMonomialStr, ParameterComplexType]
-    ) -> Tuple[PydanticPauliMonomialStr, ParameterComplexType]:
-        _PauliMonomialLengthValidator(  # type: ignore[call-arg]
-            monomial=monomial
-        )  # Validate the length of the monomial.
-        coeff = cls._validate_monomial_coefficient(monomial[1])
-        parsed_monomial = _PauliMonomialParser(string=monomial[0], coeff=coeff)  # type: ignore[call-arg]
-        return (parsed_monomial.string, parsed_monomial.coeff)
+        cls, pauli_list: PydanticPauliList
+    ) -> PydanticPauliList:
+        validated_pauli_list = []
+        for monomial in pauli_list:
+            # Validate the length
+            _PauliMonomialLengthValidator(monomial=monomial)  # type: ignore[call-arg]
+            coeff = cls._validate_monomial_coefficient(monomial[1])
+            parsed_monomial = _PauliMonomialParser(string=monomial[0], coeff=coeff)
+            validated_pauli_list.append((parsed_monomial.string, parsed_monomial.coeff))
+        return validated_pauli_list
 
     @staticmethod
     def _validate_monomial_coefficient(
@@ -76,16 +79,38 @@ class PauliOperator(HashablePydanticBaseModel, VersionedModel):
             coeff = str(coeff)
         return coeff
 
-    @pydantic.validator("pauli_list")
+    @pydantic.field_validator("pauli_list", mode="after")
+    @classmethod
     def _validate_pauli_list(cls, pauli_list: PydanticPauliList) -> PydanticPauliList:
         if not all_equal(len(summand[0]) for summand in pauli_list):
             raise ClassiqValueError("Pauli strings have incompatible lengths.")
         return pauli_list
 
-    @pydantic.root_validator
+    @staticmethod
+    def check_if_hermitian(pauli_list: PydanticPauliList) -> bool:
+        if all(isinstance(summand[1], (float, int, complex)) for summand in pauli_list):
+            if all(np.isclose(summand[1].imag, 0) for summand in pauli_list):  # type: ignore[union-attr]
+                return True
+
+            for pauli_string, coeff in pauli_list:
+                reverse_string = pauli_string[::-1]
+                reverse_found = False
+                for other_string, other_coeff in pauli_list:
+                    if other_string == reverse_string and np.isclose(
+                        coeff, other_coeff.conjugate()  # type: ignore[union-attr]
+                    ):
+                        reverse_found = True
+                        break
+                if not reverse_found:
+                    return False
+            return True
+        return False
+
+    @pydantic.model_validator(mode="before")
+    @classmethod
     def _validate_hermitianity(cls, values: Dict[str, Any]) -> Dict[str, Any]:
         pauli_list = values.get("pauli_list", [])
-        if all(isinstance(summand[1], complex) for summand in pauli_list):
+        if PauliOperator.check_if_hermitian(pauli_list):
             values["is_hermitian"] = all(
                 np.isclose(complex(summand[1]).real, summand[1])
                 for summand in pauli_list
@@ -93,7 +118,7 @@ class PauliOperator(HashablePydanticBaseModel, VersionedModel):
         if values.get("is_hermitian", False):
             values["has_complex_coefficients"] = False
             values["pauli_list"] = [
-                (summand[0], complex(summand[1].real)) for summand in pauli_list
+                (summand[0], complex(summand[1]).real) for summand in pauli_list
             ]
         else:
             values["has_complex_coefficients"] = not all(
@@ -161,7 +186,7 @@ class PauliOperator(HashablePydanticBaseModel, VersionedModel):
             (self._extend_pauli_string(pauli_string, num_extra_qubits), coeff)
             for (pauli_string, coeff) in self.pauli_list
         ]
-        return self.copy(update={"pauli_list": new_pauli_list}, deep=True)
+        return self.model_copy(update={"pauli_list": new_pauli_list}, deep=True)
 
     @staticmethod
     def _reorder_pauli_string(
@@ -211,7 +236,7 @@ class PauliOperator(HashablePydanticBaseModel, VersionedModel):
             (cls._reorder_pauli_string(pauli_string, order, new_num_qubits), coeff)
             for pauli_string, coeff in operator.pauli_list
         ]
-        return cls(pauli_list=new_pauli_list)
+        return cls(pauli_list=new_pauli_list, is_hermitian=operator.is_hermitian)
 
     @classmethod
     def from_unzipped_lists(
@@ -234,8 +259,7 @@ class PauliOperator(HashablePydanticBaseModel, VersionedModel):
             ]
         )
 
-    class Config:
-        frozen = True
+    model_config = ConfigDict(frozen=True)
 
 
 class PauliOperatorV1(HashablePydanticBaseModel):
@@ -259,16 +283,19 @@ class PauliOperatorV1(HashablePydanticBaseModel):
             f"+({summand[1]:+.3f}) * {summand[0]}" for summand in self.pauli_list
         )
 
-    @pydantic.validator("pauli_list", each_item=True, pre=True)
+    @pydantic.field_validator("pauli_list", mode="before")
+    @classmethod
     def _validate_pauli_monomials(
-        cls, monomial: Tuple[PydanticPauliMonomialStr, ParameterComplexType]
-    ) -> Tuple[PydanticPauliMonomialStr, ParameterComplexType]:
-        _PauliMonomialLengthValidator(  # type: ignore[call-arg]
-            monomial=monomial
-        )  # Validate the length of the monomial.
-        coeff = cls._validate_monomial_coefficient(monomial[1])
-        parsed_monomial = _PauliMonomialParser(string=monomial[0], coeff=coeff)  # type: ignore[call-arg]
-        return (parsed_monomial.string, parsed_monomial.coeff)
+        cls, pauli_list: PydanticPauliList
+    ) -> PydanticPauliList:
+        validated_pauli_list = []
+        for monomial in pauli_list:
+            # Validate the length
+            _PauliMonomialLengthValidator(monomial=monomial)  # type: ignore[call-arg]
+            coeff = cls._validate_monomial_coefficient(monomial[1])
+            parsed_monomial = _PauliMonomialParser(string=monomial[0], coeff=coeff)
+            validated_pauli_list.append((parsed_monomial.string, parsed_monomial.coeff))
+        return validated_pauli_list
 
     @staticmethod
     def _validate_monomial_coefficient(
@@ -280,32 +307,34 @@ class PauliOperatorV1(HashablePydanticBaseModel):
             coeff = str(coeff)
         return coeff
 
-    @pydantic.validator("pauli_list")
+    @pydantic.field_validator("pauli_list", mode="after")
+    @classmethod
     def _validate_pauli_list(cls, pauli_list: PydanticPauliList) -> PydanticPauliList:
         if not all_equal(len(summand[0]) for summand in pauli_list):
             raise ClassiqValueError("Pauli strings have incompatible lengths.")
         return pauli_list
 
-    @pydantic.root_validator
-    def _validate_hermitianity(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        pauli_list = values.get("pauli_list", [])
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def _validate_hermitianity(cls, v: Dict[str, Any]) -> Dict[str, Any]:
+        pauli_list = cast(PydanticPauliList, v.get("pauli_list"))
         if all(isinstance(summand[1], complex) for summand in pauli_list):
-            values["is_hermitian"] = all(
+            v["is_hermitian"] = all(
                 np.isclose(complex(summand[1]).real, summand[1])
                 for summand in pauli_list
             )
-        if values.get("is_hermitian", False):
-            values["has_complex_coefficients"] = False
-            values["pauli_list"] = [
-                (summand[0], complex(summand[1].real)) for summand in pauli_list
+        if v["is_hermitian"]:
+            v["has_complex_coefficients"] = False
+            v["pauli_list"] = [
+                (summand[0], complex(summand[1]).real) for summand in pauli_list
             ]
         else:
-            values["has_complex_coefficients"] = not all(
+            v["has_complex_coefficients"] = not all(
                 np.isclose(complex(summand[1]).real, summand[1])
                 for summand in pauli_list
                 if isinstance(summand[1], complex)
             )
-        return values
+        return v
 
     def __mul__(self, coefficient: complex) -> "PauliOperatorV1":
         multiplied_ising = [
@@ -361,7 +390,7 @@ class PauliOperatorV1(HashablePydanticBaseModel):
             (self._extend_pauli_string(pauli_string, num_extra_qubits), coeff)
             for (pauli_string, coeff) in self.pauli_list
         ]
-        return self.copy(update={"pauli_list": new_pauli_list}, deep=True)
+        return self.model_copy(update={"pauli_list": new_pauli_list}, deep=True)
 
     @staticmethod
     def _reorder_pauli_string(
@@ -434,8 +463,7 @@ class PauliOperatorV1(HashablePydanticBaseModel):
             ]
         )
 
-    class Config:
-        frozen = True
+    model_config = ConfigDict(frozen=True)
 
 
 # This class validates the length of a monomial.
@@ -444,8 +472,7 @@ class _PauliMonomialLengthValidator:
     monomial: PydanticPauliMonomial
 
 
-@pydantic.dataclasses.dataclass
-class _PauliMonomialParser:
+class _PauliMonomialParser(pydantic.BaseModel):
     string: PydanticPauliMonomialStr
     coeff: PydanticParameterComplexType
 

classiq/interface/combinatorial_optimization/mht_qaoa_input.py

@@ -53,7 +53,8 @@ class MhtQaoaInput(BaseModel):
     def is_valid_cost(self, cost: float) -> bool:
         return True
 
-    @pydantic.validator("plot_list")
+    @pydantic.field_validator("plot_list")
+    @classmethod
     def round_plot_list_times_and_validate(
         cls, plot_list: List[PlotData]
     ) -> List[PlotData]:

classiq/interface/debug_info/debug_info.py

@@ -15,8 +15,7 @@ ParameterValue = Union[float, int, str, None]
 class FunctionDebugInfo(BaseModel):
     name: str
     # Parameters describe classical parameters passed to function
-    # ParameterValue appears in type only for backwards compatibility
-    parameters: Dict[str, str] = Field(type=Dict[str, ParameterValue])
+    parameters: Dict[str, str]
     level: OperationLevel
     is_allocate_or_free: bool = Field(default=False)
     is_inverse: bool = Field(default=False)
@@ -54,8 +53,8 @@ class DebugInfoCollection(BaseModel):
     # Pydantic only started supporting UUID as keys in Pydantic V2
     # See https://github.com/pydantic/pydantic/issues/2096#issuecomment-814860206
     # For now, we use strings as keys in the raw data and use UUID in the wrapper logic
-    data: Dict[str, FunctionDebugInfo] = Field(default_factory=dict)
-    blackbox_data: Dict[str, FunctionDebugInfoInterface] = Field(default_factory=dict)
+    data: Dict[str, FunctionDebugInfo] = Field(default={})
+    blackbox_data: Dict[str, FunctionDebugInfoInterface] = Field(default={})
 
     def __setitem__(self, key: UUID, value: FunctionDebugInfo) -> None:
         self.data[str(key)] = value

classiq/interface/exceptions.py

@@ -51,7 +51,9 @@ class ClassiqAnalyzerVisualizationError(ClassiqError):
 
 
 class ClassiqAPIError(ClassiqError):
-    pass
+    def __init__(self, message: str, status_code: Optional[int] = None) -> None:
+        self.status_code = status_code
+        super().__init__(message)
 
 
 class ClassiqVersionError(ClassiqError):

classiq/interface/execution/iqcc.py

@@ -0,0 +1,19 @@
+from classiq.interface.helpers.versioned_model import VersionedModel
+
+
+class IQCCInitAuthData(VersionedModel):
+    auth_scope_id: str
+    auth_method_id: str
+
+
+class IQCCInitAuthResponse(VersionedModel):
+    auth_url: str
+    token_id: str
+
+
+class IQCCProbeAuthData(IQCCInitAuthData):
+    token_id: str
+
+
+class IQCCProbeAuthResponse(VersionedModel):
+    auth_token: str

classiq/interface/execution/jobs.py

@@ -1,28 +1,28 @@
 from datetime import datetime
 from typing import List, Optional
 
-from pydantic import BaseModel, Extra
+from pydantic import BaseModel
 
 from classiq.interface.jobs import JobStatus
 
 
-class ExecutionJobDetailsV1(BaseModel, extra=Extra.ignore):
+class ExecutionJobDetailsV1(BaseModel, extra="ignore"):
     id: str
 
-    name: Optional[str]
+    name: Optional[str] = None
     start_time: datetime
-    end_time: Optional[datetime]
+    end_time: Optional[datetime] = None
 
-    provider: Optional[str]
-    backend_name: Optional[str]
+    provider: Optional[str] = None
+    backend_name: Optional[str] = None
 
     status: JobStatus
 
-    num_shots: Optional[int]
-    program_id: Optional[str]
+    num_shots: Optional[int] = None
+    program_id: Optional[str] = None
 
-    error: Optional[str]
+    error: Optional[str] = None
 
 
-class ExecutionJobsQueryResultsV1(BaseModel, extra=Extra.ignore):
+class ExecutionJobsQueryResultsV1(BaseModel, extra="ignore"):
     results: List[ExecutionJobDetailsV1]