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

classiq/interface/generator/transpiler_basis_gates.py

@@ -1,10 +1,10 @@
-from typing import TYPE_CHECKING, FrozenSet, Optional
+from typing import TYPE_CHECKING, Optional
 
 from typing_extensions import TypeAlias
 
-from classiq._internals.enum_utils import StrEnum
+from classiq.interface.enum_utils import StrEnum
 
-BasisGates: TypeAlias = FrozenSet[str]
+BasisGates: TypeAlias = frozenset[str]
 
 SINGLE_QUBIT_GATES: BasisGates = frozenset(
     (
@@ -86,6 +86,10 @@ class LowerValsEnum(StrEnum):
 if TYPE_CHECKING:
     # A subset of the gates for better type checking
     class TranspilerBasisGates(StrEnum):
+        """
+        A subset of the gates used in the transpiler.
+        """
+
         X = "x"
         CX = "cx"
         CZ = "cz"

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,26 @@
-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 type",
+        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:
-        if set(self.variables.keys()) != {field for field in fields.keys()}:
-            raise ClassiqValueError(f"Invalid fields for {self.name} instance")
+        expected_field_names = list(self.variables.keys())
+        received_field_names = list(fields.keys())
+        if set(expected_field_names) != set(received_field_names):
+            raise ClassiqValueError(
+                f"Invalid fields for {self.name} instance. Expected fields "
+                f"{expected_field_names}, got {received_field_names}"
+            )

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,
 )
@@ -40,11 +42,12 @@ 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():
-                raise ValueError(
+                raise ClassiqValueError(
                     f"possible values of excitations are {list(_EXCITATIONS_DICT.values())}"
                 )
             excitations = [excitations]
@@ -53,19 +56,19 @@ class UCC(ChemistryFunctionParams):
             excitations = list(excitations)  # type: ignore[assignment]
             if all(isinstance(idx, int) for idx in excitations):
                 if any(idx not in _EXCITATIONS_DICT.values() for idx in excitations):
-                    raise ValueError(
+                    raise ClassiqValueError(
                         f"possible values of excitations are {list(_EXCITATIONS_DICT.values())}"
                     )
 
             elif all(isinstance(idx, str) for idx in excitations):
                 if any(idx not in _EXCITATIONS_DICT.keys() for idx in excitations):
-                    raise ValueError(
+                    raise ClassiqValueError(
                         f"possible values of excitations are {list(_EXCITATIONS_DICT.keys())}"
                     )
                 excitations = sorted(_EXCITATIONS_DICT[idx] for idx in excitations)  # type: ignore[index]
 
             else:
-                raise ValueError(
+                raise ClassiqValueError(
                     "excitations must be of the same type (all str or all int)"
                 )
         return excitations

classiq/interface/generator/unitary_gate.py

@@ -1,13 +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
 
 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"
@@ -24,15 +25,18 @@ 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:
-            raise ValueError("Data must me two dimensional")
+            raise ClassiqValueError("Data must me two dimensional")
         if data_np.shape[0] != data_np.shape[1]:
-            raise ValueError("Matrix must be square")
+            raise ClassiqValueError("Matrix must be square")
         if not np.mod(np.log2(data_np.shape[0]), 1) == 0:
-            raise ValueError("Matrix dimensions must be an integer exponent of 2")
+            raise ClassiqValueError(
+                "Matrix dimensions must be an integer exponent of 2"
+            )
         return data
 
     @property

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,10 +1,12 @@
 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,
@@ -40,7 +42,7 @@ def _parse_call_inputs(
         wire = wires[wire_name]
 
         if wire.end:
-            raise ValueError(
+            raise ClassiqValueError(
                 IO_MULTI_USE_ERROR_MSG
                 + f". The name {wire_name} is used multiple times."
             )
@@ -62,7 +64,7 @@ def _parse_call_outputs(
         wire = wires[wire_name]
 
         if wire.start:
-            raise ValueError(
+            raise ClassiqValueError(
                 IO_MULTI_USE_ERROR_MSG
                 + f". The name {wire_name} is used multiple times."
             )
@@ -148,10 +150,10 @@ def validate_legal_wiring(
     if unconnected_wires:
         error_messages.append(f"{UNCONNECTED_WIRES_ERROR_MSG}: {unconnected_wires}")
 
-    raise ValueError(_join_errors(error_messages))
+    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}")
 
@@ -161,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)
 
@@ -180,17 +182,17 @@ def validate_acyclic_logic_flow(
 
     if not nx.algorithms.is_directed_acyclic_graph(graph):
         cycles = list(nx.algorithms.simple_cycles(graph))
-        raise ValueError(CYCLE_ERROR_MSG + ". Cycles are: " + str(cycles))
+        raise ClassiqValueError(CYCLE_ERROR_MSG + ". Cycles are: " + str(cycles))
 
     return graph
 
 
 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,14 +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
 
 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:
@@ -26,9 +28,9 @@ def is_probabilities_sum_to_one(pro: Iterable[PydanticProbabilityFloat]) -> bool
 
 def validate_amplitudes(amp: Amplitude) -> Amplitude:
     if not is_amplitudes_sum_to_one(amp):
-        raise ValueError("Amplitudes do not sum to 1")
+        raise ClassiqValueError("Amplitudes do not sum to 1")
     if not _is_power_of_two(amp):
-        raise ValueError("Amplitudes length must be power of 2")
+        raise ClassiqValueError("Amplitudes length must be power of 2")
     return amp
 
 
@@ -36,7 +38,7 @@ def validate_probabilities(
     cls: type, pmf: Sequence[PydanticProbabilityFloat]
 ) -> Sequence[PydanticProbabilityFloat]:
     if not is_probabilities_sum_to_one(pmf):
-        raise ValueError(NOT_SUM_TO_ONE_ERROR)
+        raise ClassiqValueError(NOT_SUM_TO_ONE_ERROR)
     if not _is_power_of_two(pmf):
-        raise ValueError("Probabilities length must be power of 2")
+        raise ClassiqValueError("Probabilities length must be power of 2")
     return pmf

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