classiq 0.33.0__py3-none-any.whl → 0.35.0__py3-none-any.whl

classiq/qmod/builtins/structs.py

@@ -0,0 +1,128 @@
+# This file was generated automatically - do not edit manually
+
+from typing import List
+
+from classiq.qmod.qmod_struct import QStruct
+
+
+@QStruct
+class PauliTerm:
+    pauli: List[int]
+    coefficient: float
+
+
+@QStruct
+class MoleculeProblem:
+    mapping: int
+    z2_symmetries: bool
+    molecule: "Molecule"
+    freeze_core: bool
+    remove_orbitals: List[int]
+
+
+@QStruct
+class Molecule:
+    atoms: List["ChemistryAtom"]
+    spin: int
+    charge: int
+
+
+@QStruct
+class ChemistryAtom:
+    element: int
+    position: "Position"
+
+
+@QStruct
+class Position:
+    x: float
+    y: float
+    z: float
+
+
+@QStruct
+class FockHamiltonianProblem:
+    mapping: int
+    z2_symmetries: bool
+    terms: List["LadderTerm"]
+    num_particles: List[int]
+
+
+@QStruct
+class LadderTerm:
+    coefficient: float
+    ops: List["LadderOp"]
+
+
+@QStruct
+class LadderOp:
+    op: int
+    index: int
+
+
+@QStruct
+class CombinatorialOptimizationSolution:
+    probability: float
+    cost: float
+    solution: List[int]
+    count: int
+
+
+@QStruct
+class GaussianModel:
+    num_qubits: int
+    normal_max_value: float
+    default_probabilities: List[float]
+    rhos: List[float]
+    loss: List[int]
+    min_loss: int
+
+
+@QStruct
+class LogNormalModel:
+    num_qubits: int
+    mu: float
+    sigma: float
+
+
+@QStruct
+class FinanceFunction:
+    f: int
+    threshold: float
+    larger: bool
+    polynomial_degree: int
+    use_chebyshev_polynomial_approximation: bool
+    tail_probability: float
+
+
+@QStruct
+class QsvmResult:
+    test_score: float
+    predicted_labels: List[float]
+
+
+@QStruct
+class QSVMFeatureMapPauli:
+    feature_dimension: int
+    reps: int
+    entanglement: int
+    alpha: float
+    paulis: List[List[int]]
+
+
+__all__ = [
+    "PauliTerm",
+    "MoleculeProblem",
+    "Molecule",
+    "ChemistryAtom",
+    "Position",
+    "FockHamiltonianProblem",
+    "LadderTerm",
+    "LadderOp",
+    "CombinatorialOptimizationSolution",
+    "GaussianModel",
+    "LogNormalModel",
+    "FinanceFunction",
+    "QsvmResult",
+    "QSVMFeatureMapPauli",
+]

classiq/qmod/declaration_inferrer.py

@@ -44,7 +44,9 @@ def _version_portable_get_args(py_type: type) -> tuple:
         return get_args(py_type)[0]
 
 
-def _python_type_to_qmod(py_type: type) -> Optional[ConcreteClassicalType]:
+def _python_type_to_qmod(
+    py_type: type, *, qmodule: ModelStateContainer
+) -> Optional[ConcreteClassicalType]:
     if py_type == int:
         return Integer()
     elif py_type == float:
@@ -52,7 +54,9 @@ def _python_type_to_qmod(py_type: type) -> Optional[ConcreteClassicalType]:
     elif py_type == bool:
         return Bool()
     elif get_origin(py_type) == list:
-        return ClassicalList(element_type=_python_type_to_qmod(get_args(py_type)[0]))
+        return ClassicalList(
+            element_type=_python_type_to_qmod(get_args(py_type)[0], qmodule=qmodule)
+        )
     elif get_origin(py_type) == Array:
         array_args = _version_portable_get_args(py_type)
         if len(array_args) != 2:
@@ -60,36 +64,41 @@ def _python_type_to_qmod(py_type: type) -> Optional[ConcreteClassicalType]:
                 "Array accepts two generic parameters in the form 'Array[<element-type>, <size>]'"
             )
         return ClassicalArray(
-            element_type=_python_type_to_qmod(array_args[0]),
+            element_type=_python_type_to_qmod(array_args[0], qmodule=qmodule),
             size=get_type_hint_expr(array_args[1]),
         )
     elif inspect.isclass(py_type) and issubclass(py_type, QStructBase):
-        _add_qmod_struct(py_type)
+        _add_qmod_struct(py_type, qmodule=qmodule)
         return Struct(name=py_type.__name__)
     return None
 
 
-def _add_qmod_struct(py_type: Type[QStructBase]) -> None:
+def _add_qmod_struct(
+    py_type: Type[QStructBase], *, qmodule: ModelStateContainer
+) -> None:
     if (
         py_type.__name__ in StructDeclaration.BUILTIN_STRUCT_DECLARATIONS
-        or py_type.__name__ in ModelStateContainer.TYPE_DECLS.keys()
+        or py_type.__name__ in qmodule.type_decls.keys()
     ):
         return
 
-    ModelStateContainer.TYPE_DECLS[py_type.__name__] = StructDeclaration(
+    qmodule.type_decls[py_type.__name__] = StructDeclaration(
         name=py_type.__name__,
         variables={
-            f.name: _python_type_to_qmod(f.type) for f in dataclasses.fields(py_type)
+            f.name: _python_type_to_qmod(f.type, qmodule=qmodule)
+            for f in dataclasses.fields(py_type)
         },
     )
 
 
-def _extract_param_decl(name: str, py_type: Any) -> ClassicalParameterDeclaration:
+def _extract_param_decl(
+    name: str, py_type: Any, *, qmodule: ModelStateContainer
+) -> ClassicalParameterDeclaration:
     if len(get_args(py_type)) != 1:
         raise ValueError("QParam takes exactly one generic argument")
     py_type = get_args(py_type)[0]
     return ClassicalParameterDeclaration(
-        name=name, classical_type=_python_type_to_qmod(py_type)
+        name=name, classical_type=_python_type_to_qmod(py_type, qmodule=qmodule)
     )
 
 
@@ -106,35 +115,43 @@ def _extract_port_decl(name: str, py_type: Any) -> PortDeclaration:
     )
 
 
-def _extract_operand_decl(name: str, py_type: Any) -> QuantumOperandDeclaration:
+def _extract_operand_decl(
+    name: str, py_type: Any, qmodule: ModelStateContainer
+) -> QuantumOperandDeclaration:
     qc_args = _version_portable_get_args(py_type)
     arg_dict = {
         OPERAND_ARG_NAME.format(i=i): arg_type for i, arg_type in enumerate(qc_args)
     }
     return QuantumOperandDeclaration(
         name=name,
-        positional_arg_declarations=_extract_positional_args(arg_dict),
+        positional_arg_declarations=_extract_positional_args(arg_dict, qmodule=qmodule),
     )
 
 
-def _extract_positional_args(args: Dict[str, Any]) -> List[PositionalArg]:
+def _extract_positional_args(
+    args: Dict[str, Any], qmodule: ModelStateContainer
+) -> List[PositionalArg]:
     result: List[PositionalArg] = []
     for name, py_type in args.items():
         if name == "return":
             continue
         name = unmangle_keyword(name)
         if get_origin(py_type) is QParam:
-            result.append(_extract_param_decl(name, py_type))
+            result.append(_extract_param_decl(name, py_type, qmodule=qmodule))
         elif QVar.from_type_hint(py_type) is not None:
             result.append(_extract_port_decl(name, py_type))
         else:
             assert get_origin(py_type) or py_type is QCallable
-            result.append(_extract_operand_decl(name, py_type))
+            result.append(_extract_operand_decl(name, py_type, qmodule=qmodule))
     return result
 
 
-def infer_func_decl(py_func: Callable) -> QuantumFunctionDeclaration:
+def infer_func_decl(
+    py_func: Callable, qmodule: ModelStateContainer
+) -> QuantumFunctionDeclaration:
     return QuantumFunctionDeclaration(
         name=unmangle_keyword(py_func.__name__),
-        positional_arg_declarations=_extract_positional_args(py_func.__annotations__),
+        positional_arg_declarations=_extract_positional_args(
+            py_func.__annotations__, qmodule=qmodule
+        ),
     )

classiq/qmod/model_state_container.py

@@ -1,4 +1,4 @@
-from typing import ClassVar, Dict
+from typing import Dict
 
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
 
@@ -6,5 +6,8 @@ from classiq import StructDeclaration
 
 
 class ModelStateContainer:
-    TYPE_DECLS: ClassVar[Dict[str, StructDeclaration]]
-    NATIVE_DEFS: ClassVar[Dict[str, NativeFunctionDefinition]]
+    type_decls: Dict[str, StructDeclaration]
+    native_defs: Dict[str, NativeFunctionDefinition]
+
+
+QMODULE = ModelStateContainer()

classiq/qmod/qmod_parameter.py

@@ -34,8 +34,13 @@ class QParamScalar(QParam, Symbol):
 
 class QParamList(QParam):
     def __init__(
-        self, expr_str: str, list_type: Union[ClassicalList, ClassicalArray]
+        self,
+        expr_str: str,
+        list_type: Union[ClassicalList, ClassicalArray],
+        *,
+        qmodule: ModelStateContainer,
     ) -> None:
+        self._qmodule = qmodule
         self._expr_str = expr_str
         self._list_type = list_type
 
@@ -44,7 +49,9 @@ class QParamList(QParam):
 
     def __getitem__(self, key: Any) -> QParam:
         return create_param(
-            f"{self._expr_str}[{str(key)}]", self._list_type.element_type
+            f"{self._expr_str}[{str(key)}]",
+            self._list_type.element_type,
+            qmodule=self._qmodule,
         )
 
     def __len__(self) -> int:
@@ -57,7 +64,10 @@ class QParamList(QParam):
 
 
 class QParamStruct(QParam):
-    def __init__(self, expr_str: str, struct_type: Struct) -> None:
+    def __init__(
+        self, expr_str: str, struct_type: Struct, *, qmodule: ModelStateContainer
+    ) -> None:
+        self._qmodule = qmodule
         self._expr_str = expr_str
         self._struct_type = struct_type
 
@@ -69,7 +79,7 @@ class QParamStruct(QParam):
             self._struct_type.name
         )
         if struct_decl is None:
-            struct_decl = ModelStateContainer.TYPE_DECLS.get(self._struct_type.name)
+            struct_decl = self._qmodule.type_decls.get(self._struct_type.name)
         assert struct_decl is not None
         field_type = struct_decl.variables.get(field_name)
         if field_type is None:
@@ -77,7 +87,11 @@ class QParamStruct(QParam):
                 f"Struct {self._struct_type.name!r} doesn't have field {field_name!r}"
             )
 
-        return create_param(f"get_field({self._expr_str},{field_name!r})", field_type)
+        return create_param(
+            f"get_field({self._expr_str},{field_name!r})",
+            field_type,
+            qmodule=self._qmodule,
+        )
 
 
 _P = ParamSpec("_P")
@@ -95,10 +109,12 @@ class Array(ArrayBase[_P]):
     pass
 
 
-def create_param(expr_str: str, ctype: ClassicalType) -> QParam:
+def create_param(
+    expr_str: str, ctype: ClassicalType, qmodule: ModelStateContainer
+) -> QParam:
     if isinstance(ctype, ClassicalList) or isinstance(ctype, ClassicalArray):
-        return QParamList(expr_str, ctype)
+        return QParamList(expr_str, ctype, qmodule=qmodule)
     elif isinstance(ctype, Struct):
-        return QParamStruct(expr_str, ctype)
+        return QParamStruct(expr_str, ctype, qmodule=qmodule)
     else:
         return QParamScalar(expr_str)

classiq/qmod/qmod_variable.py

@@ -134,9 +134,9 @@ class QScalar(QVar, Symbol):
         # Fixme: Arithmetic operations are not yet supported on slices (see CAD-12670)
         if TYPE_CHECKING:
             assert QCallable.CURRENT_EXPANDABLE is not None
-        QCallable.CURRENT_EXPANDABLE.append_call_to_body(
+        QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
             ArithmeticOperation(
-                expr_str=_python_expr(expr),
+                expression=Expression(expr=_python_expr(expr)),
                 result_var=self.get_handle_binding(),
                 inplace_result=inplace,
             )
@@ -145,9 +145,9 @@ class QScalar(QVar, Symbol):
     def _insert_amplitude_loading(self, expr: Basic) -> None:
         if TYPE_CHECKING:
             assert QCallable.CURRENT_EXPANDABLE is not None
-        QCallable.CURRENT_EXPANDABLE.append_call_to_body(
+        QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
             AmplitudeLoadingOperation(
-                expr_str=_python_expr(expr),
+                expression=Expression(expr=_python_expr(expr)),
                 result_var=self.get_handle_binding(),
             )
         )

classiq/qmod/quantum_callable.py

@@ -17,7 +17,7 @@ P = ParamSpec("P")
 
 class QExpandableInterface(ABC):
     @abstractmethod
-    def append_call_to_body(self, qfunc_call: QuantumStatement) -> None:
+    def append_statement_to_body(self, stmt: QuantumStatement) -> None:
         raise NotImplementedError()
 
     @abstractmethod
@@ -30,7 +30,7 @@ class QCallable(Generic[P]):
 
     def __call__(self, *args: Any, **kwargs: Any) -> None:
         assert QCallable.CURRENT_EXPANDABLE is not None
-        QCallable.CURRENT_EXPANDABLE.append_call_to_body(
+        QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
             self.create_quantum_function_call(*args, **kwargs)
         )
         return

classiq/qmod/quantum_expandable.py

@@ -23,6 +23,7 @@ from classiq.interface.model.quantum_function_declaration import (
 from classiq.interface.model.quantum_statement import QuantumStatement
 from classiq.interface.model.quantum_type import QuantumType
 
+from classiq.qmod.model_state_container import QMODULE, ModelStateContainer
 from classiq.qmod.qmod_parameter import QParam, create_param
 from classiq.qmod.qmod_variable import QVar, create_qvar_for_port_decl
 from classiq.qmod.quantum_callable import QCallable, QExpandableInterface
@@ -35,7 +36,8 @@ class QExpandable(QCallable, QExpandableInterface, ABC):
     STACK: ClassVar[List["QExpandable"]] = list()
 
     def __init__(self, py_callable: Callable) -> None:
-        self._py_callable = py_callable
+        self._qmodule: ModelStateContainer = QMODULE
+        self._py_callable: Callable = py_callable
         self._local_handles: List[LocalVariableDeclaration] = list()
         self._body: List[QuantumStatement] = list()
 
@@ -77,7 +79,7 @@ class QExpandable(QCallable, QExpandableInterface, ABC):
             LocalVariableDeclaration(name=name, quantum_type=qtype)
         )
 
-    def append_call_to_body(self, stmt: QuantumStatement) -> None:
+    def append_statement_to_body(self, stmt: QuantumStatement) -> None:
         self._body.append(stmt)
 
     def _get_positional_args(self) -> List[ArgType]:
@@ -88,7 +90,9 @@ class QExpandable(QCallable, QExpandableInterface, ABC):
                 actual_name = (
                     rename_dict[arg.name] if arg.name in rename_dict else arg.name
                 )
-                result.append(create_param(actual_name, arg.classical_type))
+                result.append(
+                    create_param(actual_name, arg.classical_type, qmodule=self._qmodule)
+                )
             elif isinstance(arg, PortDeclaration):
                 result.append(create_qvar_for_port_decl(arg))
             else:

classiq/qmod/quantum_function.py

@@ -12,7 +12,6 @@ from classiq.interface.model.quantum_function_declaration import (
 
 from classiq.exceptions import ClassiqError
 from classiq.qmod.declaration_inferrer import infer_func_decl
-from classiq.qmod.model_state_container import ModelStateContainer
 from classiq.qmod.qmod_parameter import QParam
 from classiq.qmod.qmod_variable import QVar
 from classiq.qmod.quantum_callable import QCallable
@@ -55,8 +54,9 @@ class QFunc(QExpandable):
 
     @property
     def func_decl(self) -> QuantumFunctionDeclaration:
-        return ModelStateContainer.NATIVE_DEFS.get(
-            self._py_callable.__name__, infer_func_decl(self._py_callable)
+        return self._qmodule.native_defs.get(
+            self._py_callable.__name__,
+            infer_func_decl(self._py_callable, qmodule=self._qmodule),
         )
 
     def __call__(self, *args: Any, **kwargs: Any) -> None:
@@ -69,8 +69,8 @@ class QFunc(QExpandable):
         execution_preferences: Optional[ExecutionPreferences] = None,
         preferences: Optional[Preferences] = None,
     ) -> Model:
-        ModelStateContainer.TYPE_DECLS = dict()
-        ModelStateContainer.NATIVE_DEFS = dict()
+        self._qmodule.type_decls = dict()
+        self._qmodule.native_defs = dict()
         self._add_native_func_def()
         model_extra_settings: List[Tuple[str, Any]] = [
             ("constraints", constraints),
@@ -78,16 +78,16 @@ class QFunc(QExpandable):
             ("preferences", preferences),
         ]
         return Model(
-            functions=list(ModelStateContainer.NATIVE_DEFS.values()),
-            types=list(ModelStateContainer.TYPE_DECLS.values()),
+            functions=list(self._qmodule.native_defs.values()),
+            types=list(self._qmodule.type_decls.values()),
             **{key: value for key, value in model_extra_settings if value},
         )
 
     def _add_native_func_def(self) -> None:
-        if self.func_decl.name in ModelStateContainer.NATIVE_DEFS:
+        if self.func_decl.name in self._qmodule.native_defs:
             return
         self.expand()
-        ModelStateContainer.NATIVE_DEFS[self.func_decl.name] = NativeFunctionDefinition(
+        self._qmodule.native_defs[self.func_decl.name] = NativeFunctionDefinition(
             **self.func_decl.__dict__, local_handles=self.local_handles, body=self.body
         )
 

{classiq-0.33.0.dist-info → classiq-0.35.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: classiq
-Version: 0.33.0
+Version: 0.35.0
 Summary: Classiq's Python SDK for quantum computing
 Home-page: https://classiq.io
 License: Proprietary