classiq 0.38.0__py3-none-any.whl → 0.65.3__py3-none-any.whl

classiq/interface/generator/types/builtin_enum_declarations.py

@@ -0,0 +1,178 @@
+# This file was generated automatically - do not edit manually
+
+
+from enum import IntEnum
+
+
+class Element(IntEnum):
+    H = 0
+    He = 1
+    Li = 2
+    Be = 3
+    B = 4
+    C = 5
+    N = 6
+    O = 7  # noqa: E741
+    F = 8
+    Ne = 9
+    Na = 10
+    Mg = 11
+    Al = 12
+    Si = 13
+    P = 14
+    S = 15
+    Cl = 16
+    Ar = 17
+    K = 18
+    Ca = 19
+    Sc = 20
+    Ti = 21
+    V = 22
+    Cr = 23
+    Mn = 24
+    Fe = 25
+    Co = 26
+    Ni = 27
+    Cu = 28
+    Zn = 29
+    Ga = 30
+    Ge = 31
+    As = 32
+    Se = 33
+    Br = 34
+    Kr = 35
+    Rb = 36
+    Sr = 37
+    Y = 38
+    Zr = 39
+    Nb = 40
+    Mo = 41
+    Tc = 42
+    Ru = 43
+    Rh = 44
+    Pd = 45
+    Ag = 46
+    Cd = 47
+    In = 48
+    Sn = 49
+    Sb = 50
+    Te = 51
+    I = 52  # noqa: E741
+    Xe = 53
+    Cs = 54
+    Ba = 55
+    La = 56
+    Ce = 57
+    Pr = 58
+    Nd = 59
+    Pm = 60
+    Sm = 61
+    Eu = 62
+    Gd = 63
+    Tb = 64
+    Dy = 65
+    Ho = 66
+    Er = 67
+    Tm = 68
+    Yb = 69
+    Lu = 70
+    Hf = 71
+    Ta = 72
+    W = 73
+    Re = 74
+    Os = 75
+    Ir = 76
+    Pt = 77
+    Au = 78
+    Hg = 79
+    Tl = 80
+    Pb = 81
+    Bi = 82
+    Po = 83
+    At = 84
+    Rn = 85
+    Fr = 86
+    Ra = 87
+    Ac = 88
+    Th = 89
+    Pa = 90
+    U = 91
+    Np = 92
+    Pu = 93
+    Am = 94
+    Cm = 95
+    Bk = 96
+    Cf = 97
+    Es = 98
+    Fm = 99
+    Md = 100
+    No = 101
+    Lr = 102
+    Rf = 103
+    Db = 104
+    Sg = 105
+    Bh = 106
+    Hs = 107
+    Mt = 108
+    Ds = 109
+    Rg = 110
+    Cn = 111
+    Nh = 112
+    Fl = 113
+    Mc = 114
+    Lv = 115
+    Ts = 116
+    Og = 117
+
+
+class FermionMapping(IntEnum):
+    JORDAN_WIGNER = 0
+    PARITY = 1
+    BRAVYI_KITAEV = 2
+    FAST_BRAVYI_KITAEV = 3
+
+
+class FinanceFunctionType(IntEnum):
+    VAR = 0
+    SHORTFALL = 1
+    X_SQUARE = 2
+    EUROPEAN_CALL_OPTION = 3
+
+
+class LadderOperator(IntEnum):
+    PLUS = 0
+    MINUS = 1
+
+
+class Optimizer(IntEnum):
+    COBYLA = 1
+    SPSA = 2
+    L_BFGS_B = 3
+    NELDER_MEAD = 4
+    ADAM = 5
+
+
+class Pauli(IntEnum):
+    I = 0  # noqa: E741
+    X = 1
+    Y = 2
+    Z = 3
+
+
+class QSVMFeatureMapEntanglement(IntEnum):
+    FULL = 0
+    LINEAR = 1
+    CIRCULAR = 2
+    SCA = 3
+    PAIRWISE = 4
+
+
+__all__ = [
+    "Element",
+    "FermionMapping",
+    "FinanceFunctionType",
+    "LadderOperator",
+    "Optimizer",
+    "Pauli",
+    "QSVMFeatureMapEntanglement",
+]

classiq/interface/generator/types/compilation_metadata.py

@@ -0,0 +1,6 @@
+from pydantic import BaseModel, Field, NonNegativeInt
+
+
+class CompilationMetadata(BaseModel):
+    should_synthesize_separately: bool = Field(default=False)
+    occurrences_number: NonNegativeInt = Field(default=1)

classiq/interface/generator/types/enum_declaration.py

@@ -0,0 +1,54 @@
+from collections import Counter
+from enum import Enum, EnumMeta, IntEnum
+
+import pydantic
+
+from classiq.interface.ast_node import HashableASTNode
+from classiq.interface.exceptions import ClassiqValueError
+
+
+class EnumDeclaration(HashableASTNode):
+    name: str
+
+    members: dict[str, int] = pydantic.Field(
+        default_factory=dict,
+        description="Dictionary of member names and their values",
+    )
+
+    @pydantic.field_validator("members")
+    @classmethod
+    def _validate_members(cls, members: dict[str, int]) -> dict[str, int]:
+        underscore_members = [
+            member for member in members.keys() if member.startswith("_")
+        ]
+        if len(underscore_members) > 0:
+            raise ClassiqValueError(
+                f"Enum member names must not start with an underscore. The offending "
+                f"members: {underscore_members}"
+            )
+
+        counter = Counter(members.values())
+        repeating_members = [
+            member for member, value in members.items() if counter[value] > 1
+        ]
+        if len(repeating_members) > 0:
+            raise ClassiqValueError(
+                f"Cannot assign the same value to more than one enum member. The "
+                f"offending members: {repeating_members}"
+            )
+
+        return members
+
+    def create_enum(self) -> IntEnum:
+        return IntEnum(self.name, self.members)
+
+
+def declaration_from_enum(enum_type: EnumMeta) -> EnumDeclaration:
+    members: list[Enum] = list(enum_type)
+    return EnumDeclaration(
+        name=enum_type.__name__,
+        members={
+            member.name: member.value
+            for member in sorted(members, key=lambda member: member.value)
+        },
+    )

classiq/interface/generator/types/qstruct_declaration.py

@@ -0,0 +1,18 @@
+from collections.abc import Mapping
+from typing import TYPE_CHECKING
+
+import pydantic
+
+from classiq.interface.ast_node import HashableASTNode
+
+if TYPE_CHECKING:
+    from classiq.interface.generator.functions.concrete_types import ConcreteQuantumType
+
+
+class QStructDeclaration(HashableASTNode):
+    name: str
+
+    fields: Mapping[str, "ConcreteQuantumType"] = pydantic.Field(
+        default_factory=dict,
+        description="Dictionary of field names and their quantum types",
+    )

classiq/interface/generator/types/struct_declaration.py

@@ -1,25 +1,21 @@
-from typing import Any, ClassVar, Dict, Mapping
+from collections.abc import Mapping
+from typing import Any
 
 import pydantic
 
-from classiq.interface.generator.functions.classical_type import ConcreteClassicalType
-from classiq.interface.helpers.hashable_pydantic_base_model import (
-    HashablePydanticBaseModel,
-)
+from classiq.interface.ast_node import HashableASTNode
+from classiq.interface.exceptions import ClassiqValueError
+from classiq.interface.generator.functions.concrete_types import ConcreteClassicalType
 
-from classiq.exceptions import ClassiqValueError
 
-
-class StructDeclaration(HashablePydanticBaseModel):
+class StructDeclaration(HashableASTNode):
     name: str
 
-    variables: Dict[str, ConcreteClassicalType] = pydantic.Field(
+    variables: dict[str, ConcreteClassicalType] = pydantic.Field(
         default_factory=dict,
         description="Dictionary of variable names and their classical types",
     )
 
-    BUILTIN_STRUCT_DECLARATIONS: ClassVar[Dict[str, "StructDeclaration"]] = {}
-
     def validate_fields(self, fields: Mapping[str, Any]) -> None:
         expected_field_names = list(self.variables.keys())
         received_field_names = list(fields.keys())

classiq/interface/generator/ucc.py

@@ -1,7 +1,9 @@
-from typing import Iterable, Optional
+from collections.abc import Iterable
+from typing import Optional
 
 import pydantic
 
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.chemistry_function_params import (
     ChemistryFunctionParams,
 )
@@ -10,8 +12,6 @@ from classiq.interface.generator.excitations import (
     EXCITATIONS_TYPE_EXACT,
 )
 
-from classiq.exceptions import ClassiqValueError
-
 _EXCITATIONS_DICT = {"s": 1, "d": 2, "t": 3, "q": 4}
 
 DEFAULT_EXCITATIONS = [1, 2]
@@ -42,7 +42,8 @@ class UCC(ChemistryFunctionParams):
         description="Prefix for the generated parameters",
     )
 
-    @pydantic.validator("excitations")
+    @pydantic.field_validator("excitations")
+    @classmethod
     def _validate_excitations(cls, excitations: EXCITATIONS_TYPE) -> EXCITATIONS_TYPE:
         if isinstance(excitations, int):
             if excitations not in _EXCITATIONS_DICT.values():

classiq/interface/generator/unitary_gate.py

@@ -1,15 +1,14 @@
-from typing import List, Union
+from typing import Union
 
 import numpy as np
 import pydantic
 
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator import complex_type, function_params
 from classiq.interface.generator.arith.register_user_input import RegisterArithmeticInfo
 
-from classiq.exceptions import ClassiqValueError
-
 DataNumber = Union[complex_type.Complex, float, int]
-DataArray = List[List[DataNumber]]
+DataArray = list[list[DataNumber]]
 
 UNITARY_GATE_INPUT: str = "TARGET"
 UNITARY_GATE_OUTPUT: str = "TARGET"
@@ -26,7 +25,8 @@ class UnitaryGate(function_params.FunctionParams):
     )
 
     # TODO - decide if to include assertion on the unitarity of the matrix. It is already done in Qiskit and could be computationally expensive
-    @pydantic.validator("data")
+    @pydantic.field_validator("data")
+    @classmethod
     def validate_data(cls, data: DataArray) -> DataArray:
         data_np = np.array(data, dtype=object)
         if data_np.ndim != 2:

classiq/interface/generator/user_defined_function_params.py

@@ -1,6 +1,7 @@
-from typing import Mapping
+from collections.abc import Mapping
 
 import pydantic
+from pydantic import ConfigDict
 
 from classiq.interface.generator.arith.register_user_input import RegisterArithmeticInfo
 from classiq.interface.generator.function_params import ArithmeticIODict, FunctionParams
@@ -11,6 +12,8 @@ class CustomFunction(FunctionParams):
     A user-defined custom function parameters object.
     """
 
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
     _name: str = pydantic.PrivateAttr(default="")
 
     input_decls: ArithmeticIODict = pydantic.Field(

classiq/interface/generator/validations/flow_graph.py

@@ -1,18 +1,18 @@
 from collections import Counter, defaultdict
+from collections.abc import Collection, Iterable, Mapping
 from dataclasses import dataclass
 from itertools import chain
-from typing import Collection, Iterable, List, Mapping, Optional, TypeVar
+from typing import Optional, TypeVar
 
 import networkx as nx
 
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.quantum_function_call import (
     SynthesisQuantumFunctionCall,
     WireName,
 )
 from classiq.interface.helpers.custom_pydantic_types import PydanticNonEmptyString
 
-from classiq.exceptions import ClassiqValueError
-
 IO_MULTI_USE_ERROR_MSG = "Input and output names can only be used once"
 UNCONNECTED_WIRES_ERROR_MSG = "Wires connected only on one end"
 UNCONNECTED_FLOW_IO_ERROR_MSG = "Flow IOs not connected to inner calls"
@@ -153,7 +153,7 @@ def validate_legal_wiring(
     raise ClassiqValueError(_join_errors(error_messages))
 
 
-def _join_errors(error_messages: List[str]) -> str:
+def _join_errors(error_messages: list[str]) -> str:
     if not error_messages:
         error_messages.append(f"{UNKNOWN_ERROR_MSG}")
 
@@ -163,7 +163,7 @@ def _join_errors(error_messages: List[str]) -> str:
 T = TypeVar("T")
 
 
-def _recurring_names(name_list: List[T]) -> Iterable[T]:
+def _recurring_names(name_list: list[T]) -> Iterable[T]:
     name_counter = Counter(name_list)
     return (name for name, appearances in name_counter.items() if appearances > 1)
 
@@ -188,11 +188,11 @@ def validate_acyclic_logic_flow(
 
 
 def validate_acyclicity_and_topologically_sort_logic_flow(
-    body: List[SynthesisQuantumFunctionCall],
+    body: list[SynthesisQuantumFunctionCall],
     *,
     flow_input_names: Collection[str],
     flow_output_names: Collection[str],
-) -> List[SynthesisQuantumFunctionCall]:
+) -> list[SynthesisQuantumFunctionCall]:
     graph = validate_acyclic_logic_flow(
         body=body,
         flow_input_names=flow_input_names,

classiq/interface/generator/validations/validator_functions.py

@@ -1,16 +1,16 @@
-from typing import Iterable, List, Sequence, Sized, Tuple, TypeVar
+from collections.abc import Iterable, Sequence, Sized
+from typing import TypeVar
 
 import numpy as np
 
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.helpers.custom_pydantic_types import PydanticProbabilityFloat
 
-from classiq.exceptions import ClassiqValueError
-
 NOT_SUM_TO_ONE_ERROR = "Probabilities do not sum to 1"
 
 SUM_TO_ONE_SENSITIVITY = 8
 
-Amplitude = TypeVar("Amplitude", Tuple[float, ...], List[complex])
+Amplitude = TypeVar("Amplitude", tuple[float, ...], list[complex])
 
 
 def _is_power_of_two(vector: Sized) -> bool:

classiq/interface/generator/visitor.py

@@ -1,14 +1,10 @@
-from collections import abc
+from collections import abc, defaultdict
+from collections.abc import Collection, Mapping, Sequence
 from typing import (
     TYPE_CHECKING,
     Any,
-    Collection,
-    Dict,
-    List,
-    Mapping,
+    Callable,
     Optional,
-    Sequence,
-    Tuple,
     TypeVar,
     Union,
 )
@@ -21,7 +17,7 @@ NodeType = Union[
     BaseModel,
     int,
     bool,
-    Tuple["NodeType", ...],
+    tuple["NodeType", ...],
     Mapping[Key, "NodeType"],
     Sequence["NodeType"],
 ]
@@ -47,19 +43,19 @@ class Visitor:
 
         return node
 
-    def visit_list(self, node: List[NodeType]) -> Optional[RetType]:
+    def visit_list(self, node: list[NodeType]) -> Optional[RetType]:
         for elem in node:
             self.visit(elem)
 
         return None
 
-    def visit_dict(self, node: Dict[Key, NodeType]) -> Optional[RetType]:
+    def visit_dict(self, node: dict[Key, NodeType]) -> Optional[RetType]:
         for value in node.values():
             self.visit(value)
 
         return None
 
-    def visit_tuple(self, node: Tuple[NodeType, ...]) -> Optional[Tuple[RetType, ...]]:
+    def visit_tuple(self, node: tuple[NodeType, ...]) -> Optional[tuple[RetType, ...]]:
         for value in node:
             self.visit(value)
 
@@ -83,13 +79,24 @@ class Transformer(Visitor):
 
         def visit(self, node: NodeType) -> Any: ...
 
-    def visit_list(self, node: List[NodeType]) -> List[RetType]:
+    def visit_list(self, node: list[NodeType]) -> list[RetType]:
         return [self.visit(elem) for elem in node]
 
-    def visit_dict(self, node: Dict[Key, NodeType]) -> Dict[Key, RetType]:
+    def visit_dict(self, node: dict[Key, NodeType]) -> dict[Key, RetType]:
         return {key: self.visit(value) for key, value in node.items()}
 
-    def visit_tuple(self, node: Tuple[NodeType, ...]) -> Tuple[RetType, ...]:
+    def visit_defaultdict(
+        self, node: defaultdict[Key, NodeType]
+    ) -> defaultdict[Key, RetType]:
+        new_default_factory: Callable[[], RetType] | None = None
+        if (default_factory := node.default_factory) is not None:
+
+            def new_default_factory() -> RetType:
+                return self.visit(default_factory())  # type: ignore[misc]
+
+        return defaultdict(new_default_factory, self.visit_dict(node))
+
+    def visit_tuple(self, node: tuple[NodeType, ...]) -> tuple[RetType, ...]:
         return tuple(self.visit(value) for value in node)
 
     def visit_BaseModel(
@@ -97,12 +104,12 @@ class Transformer(Visitor):
     ) -> RetType:
         fields_to_skip = fields_to_skip or set()
 
-        result: Dict[str, Any] = dict()
+        result: dict[str, Any] = dict()
         for name, value in node:
             if name not in fields_to_skip:
                 result[name] = self.visit(value)
 
-        return node.copy(update=result)
+        return node.model_copy(update=result)
 
     def visit_int(self, n: int) -> int:
         return n

classiq/interface/hardware.py

@@ -1,12 +1,27 @@
 import datetime
-from typing import TYPE_CHECKING, List, Optional, Tuple
+from typing import TYPE_CHECKING, Annotated, Optional
 
 import pydantic
 
-from classiq._internals.enum_utils import StrEnum
+from classiq.interface.enum_utils import StrEnum
+
+QueueTime = Annotated[
+    Optional[datetime.timedelta],
+    pydantic.PlainSerializer(
+        lambda _timedelta: (
+            _timedelta.total_seconds() if _timedelta is not None else None
+        ),
+        return_type=Optional[float],
+    ),
+]
 
 
 class Provider(StrEnum):
+    """
+    This class defines all Providers that Classiq supports.
+    This is mainly used in backend_preferences when specifying where do we want to execute the defined model.
+    """
+
     IBM_QUANTUM = "IBM Quantum"
     AZURE_QUANTUM = "Azure Quantum"
     AMAZON_BRAKET = "Amazon Braket"
@@ -15,6 +30,9 @@ class Provider(StrEnum):
     GOOGLE = "Google"
     ALICE_AND_BOB = "Alice & Bob"
     OQC = "OQC"
+    INTEL = "Intel"
+    AQT = "AQT"
+    IQCC = "IQCC"
 
     @property
     def id(self) -> "ProviderIDEnum":
@@ -48,14 +66,17 @@ class HardwareStatus(pydantic.BaseModel):
         default_factory=lambda: datetime.datetime.now(tz=datetime.UTC)
     )
     availability: AvailabilityStatus
-    queue_time: Optional[datetime.timedelta]
-    pending_jobs: Optional[int]
+    queue_time: QueueTime = pydantic.Field(
+        default=None,
+        description="The estimated queue time for the hardware in seconds.",
+    )
+    pending_jobs: Optional[int] = None
 
 
 if TYPE_CHECKING:
-    ConnectivityMapEntry = Tuple[int, int]
+    ConnectivityMapEntry = tuple[int, int]
 else:
-    ConnectivityMapEntry = List[int]
+    ConnectivityMapEntry = list[int]
 
 
 class HardwareInformation(pydantic.BaseModel):
@@ -65,8 +86,8 @@ class HardwareInformation(pydantic.BaseModel):
     display_name: str
     device_type: DeviceType
     number_of_qubits: int
-    connectivity_map: Optional[List[ConnectivityMapEntry]]
-    basis_gates: List[str]
+    connectivity_map: Optional[list[ConnectivityMapEntry]] = None
+    basis_gates: list[str]
     status: HardwareStatus
 
     def is_simulator(self) -> bool:

classiq/interface/helpers/classproperty.py

@@ -0,0 +1,8 @@
+from typing import TYPE_CHECKING, Any, Optional
+
+
+class classproperty(property):  # noqa: N801
+    def __get__(self, owner_self: Any, owner_cls: Optional[type] = None) -> Any:
+        if TYPE_CHECKING:
+            assert self.fget is not None
+        return self.fget(owner_cls)

classiq/interface/helpers/custom_encoders.py

@@ -1,3 +1,3 @@
-from typing import Any, Callable, Dict
+from typing import Any, Callable
 
-CUSTOM_ENCODERS: Dict[type, Callable[[Any], Any]] = {complex: str}
+CUSTOM_ENCODERS: dict[type, Callable[[Any], Any]] = {complex: str}