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

classiq/qmod/builtins/structs.py

@@ -1,128 +1,151 @@
-# This file was generated automatically - do not edit manually
+from dataclasses import dataclass, fields, is_dataclass
 
-from typing import List
+from classiq.interface.generator.types.struct_declaration import StructDeclaration
 
-from classiq.qmod.qmod_struct import QStruct
+from classiq.qmod.builtins.enums import LadderOperator, Pauli
+from classiq.qmod.cparam import CArray, CBool, CInt, CReal
+from classiq.qmod.python_classical_type import PythonClassicalType
 
 
-@QStruct
+@dataclass
 class PauliTerm:
-    pauli: List[int]
-    coefficient: float
+    """
+    A term in a Hamiltonian, represented as a product of Pauli operators.
 
+    Attributes:
+        pauli (CArray[Pauli]): The list of the chosen Pauli operators in the term, corresponds to a product of them.
+        coefficient (CReal): The coefficient of the term (floating number).
+    """
 
-@QStruct
-class MoleculeProblem:
-    mapping: int
-    z2_symmetries: bool
-    molecule: "Molecule"
-    freeze_core: bool
-    remove_orbitals: List[int]
+    pauli: CArray[Pauli]
+    coefficient: CReal
 
 
-@QStruct
-class Molecule:
-    atoms: List["ChemistryAtom"]
-    spin: int
-    charge: int
+@dataclass
+class Position:
+    x: CReal
+    y: CReal
+    z: CReal
 
 
-@QStruct
+@dataclass
 class ChemistryAtom:
-    element: int
-    position: "Position"
+    element: CInt
+    position: Position
 
 
-@QStruct
-class Position:
-    x: float
-    y: float
-    z: float
+@dataclass
+class Molecule:
+    atoms: CArray[ChemistryAtom]
+    spin: CInt
+    charge: CInt
 
 
-@QStruct
-class FockHamiltonianProblem:
-    mapping: int
-    z2_symmetries: bool
-    terms: List["LadderTerm"]
-    num_particles: List[int]
+@dataclass
+class MoleculeProblem:
+    mapping: CInt
+    z2_symmetries: CBool
+    molecule: Molecule
+    freeze_core: CBool
+    remove_orbitals: CArray[CInt]
 
 
-@QStruct
+@dataclass
+class LadderOp:
+    op: LadderOperator
+    index: CInt
+
+
+@dataclass
 class LadderTerm:
-    coefficient: float
-    ops: List["LadderOp"]
+    coefficient: CReal
+    ops: CArray[LadderOp]
 
 
-@QStruct
-class LadderOp:
-    op: int
-    index: int
+@dataclass
+class FockHamiltonianProblem:
+    mapping: CInt
+    z2_symmetries: CBool
+    terms: CArray[LadderTerm]
+    num_particles: CArray[CInt]
 
 
-@QStruct
+@dataclass
 class CombinatorialOptimizationSolution:
-    probability: float
-    cost: float
-    solution: List[int]
-    count: int
+    probability: CReal
+    cost: CReal
+    solution: CArray[CInt]
+    count: CInt
 
 
-@QStruct
+@dataclass
 class GaussianModel:
-    num_qubits: int
-    normal_max_value: float
-    default_probabilities: List[float]
-    rhos: List[float]
-    loss: List[int]
-    min_loss: int
+    num_qubits: CInt
+    normal_max_value: CReal
+    default_probabilities: CArray[CReal]
+    rhos: CArray[CReal]
+    loss: CArray[CInt]
+    min_loss: CInt
 
 
-@QStruct
+@dataclass
 class LogNormalModel:
-    num_qubits: int
-    mu: float
-    sigma: float
+    num_qubits: CInt
+    mu: CReal
+    sigma: CReal
 
 
-@QStruct
+@dataclass
 class FinanceFunction:
-    f: int
-    threshold: float
-    larger: bool
-    polynomial_degree: int
-    use_chebyshev_polynomial_approximation: bool
-    tail_probability: float
+    f: CInt
+    threshold: CReal
+    larger: CBool
+    polynomial_degree: CInt
+    use_chebyshev_polynomial_approximation: CBool
+    tail_probability: CReal
 
 
-@QStruct
+@dataclass
 class QsvmResult:
-    test_score: float
-    predicted_labels: List[float]
+    test_score: CReal
+    predicted_labels: CArray[CReal]
 
 
-@QStruct
+@dataclass
 class QSVMFeatureMapPauli:
-    feature_dimension: int
-    reps: int
-    entanglement: int
-    alpha: float
-    paulis: List[List[int]]
+    feature_dimension: CInt
+    reps: CInt
+    entanglement: CInt
+    alpha: CReal
+    paulis: CArray[CArray[Pauli]]
+
+
+BUILTIN_STRUCT_DECLARATIONS = {
+    struct_decl.__name__: StructDeclaration(
+        name=struct_decl.__name__,
+        variables={
+            field.name: PythonClassicalType().convert(field.type)
+            for field in fields(struct_decl)
+        },
+    )
+    for struct_decl in vars().values()
+    if is_dataclass(struct_decl)
+}
 
 
 __all__ = [
-    "PauliTerm",
-    "MoleculeProblem",
-    "Molecule",
     "ChemistryAtom",
-    "Position",
-    "FockHamiltonianProblem",
-    "LadderTerm",
-    "LadderOp",
     "CombinatorialOptimizationSolution",
+    "FinanceFunction",
+    "FockHamiltonianProblem",
     "GaussianModel",
+    "LadderOp",
+    "LadderTerm",
     "LogNormalModel",
-    "FinanceFunction",
-    "QsvmResult",
+    "Molecule",
+    "MoleculeProblem",
+    "PauliTerm",
+    "Position",
     "QSVMFeatureMapPauli",
+    "QsvmResult",
 ]

classiq/qmod/cfunc.py

@@ -0,0 +1,42 @@
+from typing import Any, Callable, Optional, Union, overload
+
+from classiq.qmod.classical_function import CFunc
+
+
+def get_caller_locals() -> dict[str, Any]:
+    """Print the local variables in the caller's frame."""
+    import inspect
+
+    frame = inspect.currentframe()
+    try:
+        assert frame is not None
+        cfunc_frame = frame.f_back
+        assert cfunc_frame is not None
+        caller_frame = cfunc_frame.f_back
+        assert caller_frame is not None
+
+        return caller_frame.f_locals
+    finally:
+        # See here for information about the `del`
+        # https://docs.python.org/3/library/inspect.html#the-interpreter-stack
+        del frame
+
+
+@overload
+def cfunc(func: Callable) -> CFunc: ...
+
+
+@overload
+def cfunc(func: None = None) -> Callable[[Callable], CFunc]: ...
+
+
+def cfunc(func: Optional[Callable] = None) -> Union[Callable[[Callable], CFunc], CFunc]:
+    caller_locals = get_caller_locals()
+
+    def wrapper(func: Callable) -> CFunc:
+        return CFunc(func, caller_locals)
+
+    if func is not None:
+        return wrapper(func)
+
+    return wrapper

classiq/qmod/classical_function.py

@@ -1,11 +1,9 @@
 import ast
 import inspect
-import sys
 from textwrap import dedent
-from typing import Callable
+from typing import Any, Callable
 
-from classiq.exceptions import ClassiqValueError
-from classiq.qmod.builtins.classical_execution_primitives import sample, save
+from classiq.interface.exceptions import ClassiqValueError
 
 
 def _unparse_function_body(code: str, func: ast.FunctionDef) -> str:
@@ -18,23 +16,13 @@ def _unparse_function_body(code: str, func: ast.FunctionDef) -> str:
 
 
 class CFunc:
-    @staticmethod
-    def default_cmain() -> "CFunc":
-        @CFunc
-        def cmain() -> None:
-            result = sample()
-            save({"result": result})
-
-        return cmain
-
-    def __init__(self, py_callable: Callable[[], None]):
+    def __init__(self, py_callable: Callable[[], None], caller_locals: dict[str, Any]):
         code = dedent(inspect.getsource(py_callable))
         func = ast.parse(code).body[0]
         if not isinstance(func, ast.FunctionDef):
-            raise ClassiqValueError(f"Use @{CFunc.__name__} to decorate a function")
+            raise ClassiqValueError("Use @cfunc to decorate a function")
         if len(func.args.args) > 0:
-            raise ClassiqValueError(f"A @{CFunc.__name__} must receive no arguments")
-        if sys.version_info >= (3, 9):
-            self.code = "\n".join([ast.unparse(statement) for statement in func.body])
-        else:
-            self.code = _unparse_function_body(code, func)
+            raise ClassiqValueError("A @cfunc must receive no arguments")
+        self.code = "\n".join([ast.unparse(statement) for statement in func.body])
+
+        self._caller_constants = caller_locals

classiq/qmod/cparam.py

@@ -0,0 +1,64 @@
+import sys
+from typing import (  # type: ignore[attr-defined]
+    TYPE_CHECKING,
+    Any,
+    Generic,
+    Union,
+    _GenericAlias,
+)
+
+from typing_extensions import ParamSpec
+
+from classiq.qmod.symbolic_expr import Symbolic, SymbolicExpr
+
+if TYPE_CHECKING:
+    from classiq.qmod.qmod_variable import QNum
+
+    SymbolicSuperclass = SymbolicExpr
+else:
+    SymbolicSuperclass = Symbolic
+
+
+class CParam(SymbolicSuperclass):
+    def __init__(self, expr: str) -> None:
+        super().__init__(expr, False)
+
+
+class CInt(CParam):
+    pass
+
+
+class CReal(CParam):
+    pass
+
+
+class CBool(CParam):
+    pass
+
+
+_P = ParamSpec("_P")
+
+
+class ArrayBase(Generic[_P]):
+    # Support comma-separated generic args in older Python versions
+    if sys.version_info[0:2] < (3, 10):
+
+        def __class_getitem__(cls, args) -> _GenericAlias:
+            return _GenericAlias(cls, args)
+
+
+class CArray(CParam, ArrayBase[_P]):
+    if TYPE_CHECKING:
+
+        @property
+        def len(self) -> int: ...
+
+        def __getitem__(self, idx: Union[int, CInt, slice, "QNum"]) -> Any: ...
+
+
+Array = CArray
+
+
+class CParamScalar(CParam, SymbolicExpr):
+    def __hash__(self) -> int:
+        return hash(str(self))

classiq/qmod/create_model_function.py

@@ -0,0 +1,56 @@
+from typing import Optional, Union
+
+from classiq.interface.exceptions import ClassiqError
+from classiq.interface.executor.execution_preferences import ExecutionPreferences
+from classiq.interface.generator.model.constraints import Constraints
+from classiq.interface.generator.model.preferences.preferences import Preferences
+from classiq.interface.model.model import MAIN_FUNCTION_NAME, SerializedModel
+
+from classiq.qmod.classical_function import CFunc
+from classiq.qmod.quantum_function import GenerativeQFunc, QFunc
+from classiq.qmod.write_qmod import write_qmod
+
+
+def create_model(
+    entry_point: Union[QFunc, GenerativeQFunc],
+    constraints: Optional[Constraints] = None,
+    execution_preferences: Optional[ExecutionPreferences] = None,
+    preferences: Optional[Preferences] = None,
+    classical_execution_function: Optional[CFunc] = None,
+    out_file: Optional[str] = None,
+) -> SerializedModel:
+    """
+    Create a serialized model from a given Qmod entry function and additional parameters.
+
+    Args:
+        entry_point: The entry point function for the model, which must be a QFunc named 'main'.
+        constraints: Constraints for the synthesis of the model. See Constraints (Optional).
+        execution_preferences: Preferences for the execution of the model. See ExecutionPreferences (Optional).
+        preferences: Preferences for the synthesis of the model. See Preferences (Optional).
+        classical_execution_function: A function for the classical execution logic, which must be a CFunc (Optional).
+        out_file: File path to write the Qmod model in native Qmod representation to (Optional).
+
+    Returns:
+        SerializedModel: A serialized model.
+
+    Raises:
+        ClassiqError: If the entry point function is not named 'main'.
+    """
+
+    if entry_point.func_decl.name != MAIN_FUNCTION_NAME:
+        raise ClassiqError(
+            f"The entry point function must be named 'main', got '{entry_point.func_decl.name}'"
+        )
+
+    model = entry_point.create_model(
+        constraints,
+        execution_preferences,
+        preferences,
+        classical_execution_function,
+    )
+    result = model.get_model()
+
+    if out_file is not None:
+        write_qmod(result, out_file)
+
+    return result