classiq 0.38.0__py3-none-any.whl → 0.65.4__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 struct
+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
 
 
-@struct
+@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).
+    """
 
-@struct
-class MoleculeProblem:
-    mapping: int
-    z2_symmetries: bool
-    molecule: "Molecule"
-    freeze_core: bool
-    remove_orbitals: List[int]
+    pauli: CArray[Pauli]
+    coefficient: CReal
 
 
-@struct
-class Molecule:
-    atoms: List["ChemistryAtom"]
-    spin: int
-    charge: int
+@dataclass
+class Position:
+    x: CReal
+    y: CReal
+    z: CReal
 
 
-@struct
+@dataclass
 class ChemistryAtom:
-    element: int
-    position: "Position"
+    element: CInt
+    position: Position
 
 
-@struct
-class Position:
-    x: float
-    y: float
-    z: float
+@dataclass
+class Molecule:
+    atoms: CArray[ChemistryAtom]
+    spin: CInt
+    charge: CInt
 
 
-@struct
-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]
 
 
-@struct
+@dataclass
+class LadderOp:
+    op: LadderOperator
+    index: CInt
+
+
+@dataclass
 class LadderTerm:
-    coefficient: float
-    ops: List["LadderOp"]
+    coefficient: CReal
+    ops: CArray[LadderOp]
 
 
-@struct
-class LadderOp:
-    op: int
-    index: int
+@dataclass
+class FockHamiltonianProblem:
+    mapping: CInt
+    z2_symmetries: CBool
+    terms: CArray[LadderTerm]
+    num_particles: CArray[CInt]
 
 
-@struct
+@dataclass
 class CombinatorialOptimizationSolution:
-    probability: float
-    cost: float
-    solution: List[int]
-    count: int
+    probability: CReal
+    cost: CReal
+    solution: CArray[CInt]
+    count: CInt
 
 
-@struct
+@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
 
 
-@struct
+@dataclass
 class LogNormalModel:
-    num_qubits: int
-    mu: float
-    sigma: float
+    num_qubits: CInt
+    mu: CReal
+    sigma: CReal
 
 
-@struct
+@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
 
 
-@struct
+@dataclass
 class QsvmResult:
-    test_score: float
-    predicted_labels: List[float]
+    test_score: CReal
+    predicted_labels: CArray[CReal]
 
 
-@struct
+@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

@@ -1,9 +1,9 @@
-from typing import Any, Callable, Dict, Optional, Union, overload
+from typing import Any, Callable, Optional, Union, overload
 
 from classiq.qmod.classical_function import CFunc
 
 
-def get_caller_locals() -> Dict[str, Any]:
+def get_caller_locals() -> dict[str, Any]:
     """Print the local variables in the caller's frame."""
     import inspect
 

classiq/qmod/classical_function.py

@@ -1,10 +1,9 @@
 import ast
 import inspect
-import sys
 from textwrap import dedent
-from typing import Any, Callable, Dict
+from typing import Any, Callable
 
-from classiq.exceptions import ClassiqValueError
+from classiq.interface.exceptions import ClassiqValueError
 
 
 def _unparse_function_body(code: str, func: ast.FunctionDef) -> str:
@@ -17,16 +16,13 @@ def _unparse_function_body(code: str, func: ast.FunctionDef) -> str:
 
 
 class CFunc:
-    def __init__(self, py_callable: Callable[[], None], caller_locals: Dict[str, Any]):
+    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("Use @cfunc to decorate a function")
         if len(func.args.args) > 0:
             raise ClassiqValueError("A @cfunc 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)
+        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

classiq/qmod/declaration_inferrer.py

@@ -1,151 +1,193 @@
 import dataclasses
-import inspect
-from typing import Any, Callable, Dict, List, Optional, Type, get_args, get_origin
+import sys
+from collections.abc import Sequence
+from enum import EnumMeta
+from typing import (
+    Any,
+    Callable,
+    Literal,
+    Optional,
+    get_args,
+    get_origin,
+    overload,
+)
 
 from typing_extensions import _AnnotatedAlias
 
-from classiq.interface.generator.functions.classical_type import (
-    Bool,
-    ClassicalArray,
-    ClassicalList,
-    ConcreteClassicalType,
-    Integer,
-    QStructBase,
-    Real,
-    Struct,
+from classiq.interface.exceptions import ClassiqValueError
+from classiq.interface.generator.functions.concrete_types import ConcreteClassicalType
+from classiq.interface.generator.functions.port_declaration import (
+    PortDeclarationDirection,
 )
+from classiq.interface.generator.types.enum_declaration import declaration_from_enum
+from classiq.interface.generator.types.struct_declaration import StructDeclaration
 from classiq.interface.model.classical_parameter_declaration import (
-    ClassicalParameterDeclaration,
+    AnonClassicalParameterDeclaration,
 )
-from classiq.interface.model.port_declaration import PortDeclaration
+from classiq.interface.model.port_declaration import AnonPortDeclaration
 from classiq.interface.model.quantum_function_declaration import (
+    AnonPositionalArg,
+    AnonQuantumOperandDeclaration,
+    NamedParamsQuantumFunctionDeclaration,
     PositionalArg,
-    QuantumFunctionDeclaration,
-    QuantumOperandDeclaration,
 )
 
-from classiq import StructDeclaration
-from classiq.exceptions import ClassiqValueError
+from classiq.qmod.builtins.enums import BUILTIN_ENUM_DECLARATIONS
+from classiq.qmod.builtins.structs import BUILTIN_STRUCT_DECLARATIONS
 from classiq.qmod.model_state_container import ModelStateContainer
-from classiq.qmod.qmod_parameter import Array, QParam
-from classiq.qmod.qmod_variable import QVar, get_type_hint_expr
-from classiq.qmod.quantum_callable import QCallable, QCallableList
+from classiq.qmod.python_classical_type import PythonClassicalType
+from classiq.qmod.qmod_variable import QVar
+from classiq.qmod.quantum_callable import QCallableList
 from classiq.qmod.utilities import unmangle_keyword, version_portable_get_args
 
-OPERAND_ARG_NAME = "arg{i}"
+if sys.version_info[0:2] >= (3, 9):
+    from typing import Annotated
+
+
+class _PythonClassicalType(PythonClassicalType):
+    def __init__(self, qmodule: Optional[ModelStateContainer]):
+        super().__init__()
+        self.qmodule = qmodule
+
+    def register_enum(self, py_type: EnumMeta) -> None:
+        if (
+            self.qmodule is None
+            or py_type.__name__ in BUILTIN_ENUM_DECLARATIONS
+            or py_type.__name__ in self.qmodule.enum_decls
+        ):
+            return
+
+        enum_decl = declaration_from_enum(py_type)
+        self.qmodule.enum_decls[py_type.__name__] = enum_decl
+
+    def register_struct(self, py_type: type) -> None:
+        if (
+            self.qmodule is None
+            or py_type.__name__ in BUILTIN_STRUCT_DECLARATIONS
+            or py_type.__name__ in self.qmodule.type_decls
+        ):
+            return
+
+        struct_decl = StructDeclaration(
+            name=py_type.__name__,
+            variables={
+                f.name: self.convert(f.type) for f in dataclasses.fields(py_type)
+            },
+        )
+        self.qmodule.type_decls[py_type.__name__] = struct_decl
 
 
 def python_type_to_qmod(
-    py_type: type, *, qmodule: ModelStateContainer
+    py_type: type, *, qmodule: Optional[ModelStateContainer]
 ) -> Optional[ConcreteClassicalType]:
-    if py_type == int:
-        return Integer()
-    elif py_type == float:
-        return Real()
-    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], qmodule=qmodule)
-        )
-    elif get_origin(py_type) == Array:
-        array_args = version_portable_get_args(py_type)
-        if len(array_args) != 2:
-            raise ClassiqValueError(
-                "Array accepts two generic parameters in the form 'Array[<element-type>, <size>]'"
-            )
-        return ClassicalArray(
-            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, qmodule=qmodule)
-        return Struct(name=py_type.__name__)
-    return 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 qmodule.type_decls
-    ):
-        return
-
-    qmodule.type_decls[py_type.__name__] = StructDeclaration(
-        name=py_type.__name__,
-        variables={
-            f.name: python_type_to_qmod(f.type, qmodule=qmodule)
-            for f in dataclasses.fields(py_type)
-        },
-    )
-
+    return _PythonClassicalType(qmodule).convert(py_type)
 
-def _extract_param_decl(
-    name: str, py_type: Any, *, qmodule: ModelStateContainer
-) -> ClassicalParameterDeclaration:
-    if len(get_args(py_type)) != 1:
-        raise ClassiqValueError("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, qmodule=qmodule)
-    )
 
-
-def _extract_port_decl(name: str, py_type: Any) -> PortDeclaration:
+def _extract_port_decl(name: Optional[str], py_type: Any) -> AnonPortDeclaration:
     # FIXME: CAD-13409
-    qtype: Type[QVar] = QVar.from_type_hint(py_type)  # type:ignore[assignment]
+    qtype: type[QVar] = QVar.from_type_hint(py_type)  # type:ignore[assignment]
     direction = qtype.port_direction(py_type)
     if isinstance(py_type, _AnnotatedAlias):
         py_type = py_type.__args__[0]
-    return PortDeclaration(
-        name=name,
+    param = AnonPortDeclaration(
+        name=None,
         direction=direction,
         quantum_type=qtype.to_qmod_quantum_type(py_type),
     )
+    if name is not None:
+        param = param.rename(name)
+    return param
 
 
 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: Optional[str], py_type: Any, qmodule: Optional[ModelStateContainer]
+) -> AnonQuantumOperandDeclaration:
+    is_list = (get_origin(py_type) or py_type) is QCallableList
+    if get_origin(py_type) is list:
+        is_list = True
+        py_type = version_portable_get_args(py_type)[0]
+    type_args = version_portable_get_args(py_type)
+    if len(type_args) > 0 and isinstance(type_args[0], list):  # Callable support
+        type_args = tuple(type_args[0])
+    param_decls = [_extract_operand_param(arg_type) for arg_type in type_args]
+    param = AnonQuantumOperandDeclaration(
         name=name,
-        positional_arg_declarations=_extract_positional_args(arg_dict, qmodule=qmodule),
-        is_list=(get_origin(py_type) or py_type) is QCallableList,
+        positional_arg_declarations=_extract_positional_args(
+            param_decls, qmodule=qmodule
+        ),
+        is_list=is_list,
+    )
+    if name is not None:
+        param = param.rename(name)
+    return param
+
+
+def _extract_operand_param(py_type: Any) -> tuple[Optional[str], Any]:
+    if sys.version_info[0:2] < (3, 9) or get_origin(py_type) is not Annotated:
+        return None, py_type
+    args = get_args(py_type)
+    if len(args) == 2:
+        if isinstance(args[1], PortDeclarationDirection):
+            return None, py_type
+        elif isinstance(args[1], str):
+            return args[1], args[0]
+        elif get_origin(args[1]) is Literal:
+            return version_portable_get_args(args[1])[0], args[0]
+    elif len(args) == 3 and isinstance(args[1], PortDeclarationDirection):
+        if isinstance(args[2], str):
+            return args[2], Annotated[args[0], args[1]]
+        elif get_origin(args[2]) is Literal:
+            return version_portable_get_args(args[2])[0], Annotated[args[0], args[1]]
+    raise ClassiqValueError(
+        f"Operand parameter declaration must be of the form <param-type> or "
+        f"Annotated[<param-type>, <param-name>]. Got {py_type}"
     )
 
 
+@overload
+def _extract_positional_args(
+    args: Sequence[tuple[str, Any]], qmodule: Optional[ModelStateContainer]
+) -> Sequence[PositionalArg]:
+    pass
+
+
+@overload
 def _extract_positional_args(
-    args: Dict[str, Any], qmodule: ModelStateContainer
-) -> List[PositionalArg]:
-    result: List[PositionalArg] = []
-    for name, py_type in args.items():
+    args: Sequence[tuple[Optional[str], Any]], qmodule: Optional[ModelStateContainer]
+) -> Sequence[AnonPositionalArg]:
+    pass
+
+
+def _extract_positional_args(
+    args: Sequence[tuple[Optional[str], Any]], qmodule: Optional[ModelStateContainer]
+) -> Sequence[AnonPositionalArg]:
+    result: list[AnonPositionalArg] = []
+    for name, py_type in args:
         if name == "return":
             continue
         name = unmangle_keyword(name)
-        if get_origin(py_type) is QParam:
-            result.append(_extract_param_decl(name, py_type, qmodule=qmodule))
+        classical_type = python_type_to_qmod(py_type, qmodule=qmodule)
+        if classical_type is not None:
+            param = AnonClassicalParameterDeclaration(
+                name=None,
+                classical_type=classical_type,
+            )
+            if name is not None:
+                param = param.rename(name)
+            result.append(param)
         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 or (
-                get_origin(py_type) or py_type
-            ) is QCallableList
             result.append(_extract_operand_decl(name, py_type, qmodule=qmodule))
     return result
 
 
 def infer_func_decl(
-    py_func: Callable, qmodule: ModelStateContainer
-) -> QuantumFunctionDeclaration:
-    return QuantumFunctionDeclaration(
+    py_func: Callable, qmodule: Optional[ModelStateContainer] = None
+) -> NamedParamsQuantumFunctionDeclaration:
+    return NamedParamsQuantumFunctionDeclaration(
         name=unmangle_keyword(py_func.__name__),
         positional_arg_declarations=_extract_positional_args(
-            py_func.__annotations__, qmodule=qmodule
+            list(py_func.__annotations__.items()), qmodule=qmodule
         ),
     )