classiq 0.92.0__py3-none-any.whl → 0.99.0__py3-none-any.whl

classiq/qmod/builtins/structs.py

@@ -3,10 +3,11 @@ from typing import Union
 
 from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.types.struct_declaration import StructDeclaration
+from classiq.interface.helpers.datastructures import LenList
 from classiq.interface.helpers.text_utils import are, readable_list, s
 
-from classiq.qmod.builtins.enums import LadderOperator, Pauli
-from classiq.qmod.cparam import CArray, CBool, CInt, CReal
+from classiq.qmod.builtins.enums import Pauli
+from classiq.qmod.cparam import CArray, CInt, CReal
 from classiq.qmod.python_classical_type import PythonClassicalType
 
 
@@ -69,13 +70,15 @@ class SparsePauliOp:
     def __mul__(self, obj: Union[float, "SparsePauliOp"]) -> "SparsePauliOp":
         if isinstance(obj, (int, float, complex)):
             return SparsePauliOp(
-                terms=[
-                    SparsePauliTerm(
-                        paulis=term.paulis,
-                        coefficient=obj * term.coefficient,  # type:ignore[arg-type]
-                    )
-                    for term in self.terms
-                ],
+                terms=LenList(
+                    [
+                        SparsePauliTerm(
+                            paulis=term.paulis,
+                            coefficient=obj * term.coefficient,  # type:ignore[arg-type]
+                        )
+                        for term in self.terms
+                    ]
+                ),
                 num_qubits=self.num_qubits,
             )
         if len(self.terms) != 1 or len(obj.terms) != 1:
@@ -97,14 +100,17 @@ class SparsePauliOp:
                 f"already assigned"
             )
         return SparsePauliOp(
-            terms=[
-                SparsePauliTerm(
-                    paulis=self.terms[0].paulis
-                    + obj.terms[0].paulis,  # type:ignore[arg-type]
-                    coefficient=self.terms[0].coefficient
-                    * obj.terms[0].coefficient,  # type:ignore[arg-type]
-                )
-            ],
+            terms=LenList(
+                [
+                    SparsePauliTerm(
+                        paulis=LenList(  # type:ignore[call-overload]
+                            self.terms[0].paulis + obj.terms[0].paulis
+                        ),
+                        coefficient=self.terms[0].coefficient
+                        * obj.terms[0].coefficient,  # type:ignore[arg-type]
+                    )
+                ]
+            ),
             num_qubits=max(self.num_qubits, obj.num_qubits),
         )
 
@@ -113,7 +119,7 @@ class SparsePauliOp:
 
     def __add__(self, other: "SparsePauliOp") -> "SparsePauliOp":
         return SparsePauliOp(
-            terms=self.terms + other.terms,
+            terms=LenList(self.terms + other.terms),
             num_qubits=max(self.num_qubits, other.num_qubits),
         )
 
@@ -131,55 +137,6 @@ class SparsePauliOp:
         )
 
 
-@dataclass
-class Position:
-    x: CReal
-    y: CReal
-    z: CReal
-
-
-@dataclass
-class ChemistryAtom:
-    element: CInt
-    position: Position
-
-
-@dataclass
-class Molecule:
-    atoms: CArray[ChemistryAtom]
-    spin: CInt
-    charge: CInt
-
-
-@dataclass
-class MoleculeProblem:
-    mapping: CInt
-    z2_symmetries: CBool
-    molecule: Molecule
-    freeze_core: CBool
-    remove_orbitals: CArray[CInt]
-
-
-@dataclass
-class LadderOp:
-    op: LadderOperator
-    index: CInt
-
-
-@dataclass
-class LadderTerm:
-    coefficient: CReal
-    ops: CArray[LadderOp]
-
-
-@dataclass
-class FockHamiltonianProblem:
-    mapping: CInt
-    z2_symmetries: CBool
-    terms: CArray[LadderTerm]
-    num_particles: CArray[CInt]
-
-
 @dataclass
 class CombinatorialOptimizationSolution:
     probability: CReal
@@ -205,21 +162,6 @@ class LogNormalModel:
     sigma: CReal
 
 
-@dataclass
-class QsvmResult:
-    test_score: CReal
-    predicted_labels: CArray[CReal]
-
-
-@dataclass
-class QSVMFeatureMapPauli:
-    feature_dimension: CInt
-    reps: CInt
-    entanglement: CInt
-    alpha: CReal
-    paulis: CArray[CArray[Pauli]]
-
-
 BUILTIN_STRUCT_DECLARATIONS = {
     struct_decl.__name__: StructDeclaration(
         name=struct_decl.__name__,
@@ -234,20 +176,11 @@ BUILTIN_STRUCT_DECLARATIONS = {
 
 
 __all__ = [
-    "ChemistryAtom",
     "CombinatorialOptimizationSolution",
-    "FockHamiltonianProblem",
     "GaussianModel",
     "IndexedPauli",
-    "LadderOp",
-    "LadderTerm",
     "LogNormalModel",
-    "Molecule",
-    "MoleculeProblem",
     "PauliTerm",
-    "Position",
-    "QSVMFeatureMapPauli",
-    "QsvmResult",
     "SparsePauliOp",
     "SparsePauliTerm",
 ]

classiq/qmod/cfunc.py

@@ -1,4 +1,5 @@
-from typing import Any, Callable, Optional, Union, overload
+from collections.abc import Callable
+from typing import Any, overload
 
 from classiq.qmod.classical_function import CFunc
 
@@ -30,7 +31,7 @@ def cfunc(func: Callable) -> CFunc: ...
 def cfunc(func: None = None) -> Callable[[Callable], CFunc]: ...
 
 
-def cfunc(func: Optional[Callable] = None) -> Union[Callable[[Callable], CFunc], CFunc]:
+def cfunc(func: Callable | None = None) -> Callable[[Callable], CFunc] | CFunc:
     caller_locals = get_caller_locals()
 
     def wrapper(func: Callable) -> CFunc:

classiq/qmod/classical_function.py

@@ -1,7 +1,8 @@
 import ast
 import inspect
+from collections.abc import Callable
 from textwrap import dedent
-from typing import Any, Callable
+from typing import Any
 
 from classiq.interface.exceptions import ClassiqValueError
 

classiq/qmod/classical_variable.py

@@ -1,7 +1,7 @@
 import sys
 from typing import TYPE_CHECKING, Any
 
-from classiq.interface.exceptions import ClassiqInternalError
+from classiq.interface.exceptions import ClassiqInternalError, ClassiqTypeError
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.classical_type import Bool, ClassicalType
 from classiq.interface.model.handle_binding import HandleBinding
@@ -37,7 +37,9 @@ def declare_classical_variable(
 
 def assign_classical_variable(target: CParam, value: Any, frame_depth: int) -> None:
     if not isinstance(value, SYMBOLIC_TYPES):
-        raise TypeError(f"Invalid argument {value!r} for classical variable assignment")
+        raise ClassiqTypeError(
+            f"Invalid argument {value!r} for classical variable assignment"
+        )
 
     if TYPE_CHECKING:
         assert QCallable.CURRENT_EXPANDABLE is not None

classiq/qmod/cparam.py

@@ -1,11 +1,9 @@
-import sys
 from abc import ABC, abstractmethod
-from typing import (  # type: ignore[attr-defined]
+from typing import (
     TYPE_CHECKING,
     Any,
     Generic,
     Union,
-    _GenericAlias,
 )
 
 from typing_extensions import ParamSpec
@@ -59,11 +57,7 @@ _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)
+    pass
 
 
 class CArray(CParamAbstract, ArrayBase[_P]):

classiq/qmod/create_model_function.py

@@ -1,4 +1,4 @@
-from typing import Optional, Union, cast
+from typing import cast
 
 from classiq.interface.exceptions import ClassiqError
 from classiq.interface.executor.execution_preferences import ExecutionPreferences
@@ -28,12 +28,12 @@ def add_entry_point(
 
 
 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,
+    entry_point: QFunc | GenerativeQFunc,
+    constraints: Constraints | None = None,
+    execution_preferences: ExecutionPreferences | None = None,
+    preferences: Preferences | None = None,
+    classical_execution_function: CFunc | None = None,
+    out_file: str | None = None,
 ) -> SerializedModel:
     """
     Create a serialized model from a given Qmod entry function and additional parameters.

classiq/qmod/declaration_inferrer.py

@@ -1,12 +1,10 @@
 import dataclasses
-import sys
-from collections.abc import Sequence
+from collections.abc import Callable, Sequence
 from enum import EnumMeta
 from typing import (
+    Annotated,
     Any,
-    Callable,
     Literal,
-    Optional,
     get_args,
     get_origin,
     overload,
@@ -39,21 +37,22 @@ from classiq.qmod.builtins.structs import BUILTIN_STRUCT_DECLARATIONS
 from classiq.qmod.model_state_container import ModelStateContainer
 from classiq.qmod.python_classical_type import PythonClassicalType
 from classiq.qmod.qmod_variable import QVar, get_port_from_type_hint
-from classiq.qmod.quantum_callable import QCallableList
+from classiq.qmod.quantum_callable import QCallable, QCallableList, QPerm, QPermList
 from classiq.qmod.semantics.annotation.qstruct_annotator import QStructAnnotator
 from classiq.qmod.semantics.validation.type_hints import validate_annotation
 from classiq.qmod.semantics.validation.types_validation import (
     check_duplicate_types,
     validate_cstruct,
 )
-from classiq.qmod.utilities import unmangle_keyword, version_portable_get_args
-
-if sys.version_info[0:2] >= (3, 9):
-    from typing import Annotated
+from classiq.qmod.utilities import (
+    type_to_str,
+    unmangle_keyword,
+    version_portable_get_args,
+)
 
 
 class _PythonClassicalType(PythonClassicalType):
-    def __init__(self, qmodule: Optional[ModelStateContainer]):
+    def __init__(self, qmodule: ModelStateContainer | None):
         super().__init__()
         self.qmodule = qmodule
 
@@ -97,12 +96,12 @@ class _PythonClassicalType(PythonClassicalType):
 
 
 def python_type_to_qmod(
-    py_type: type, *, qmodule: Optional[ModelStateContainer]
-) -> Optional[ConcreteClassicalType]:
+    py_type: type, *, qmodule: ModelStateContainer | None
+) -> ConcreteClassicalType | None:
     return _PythonClassicalType(qmodule).convert(py_type)
 
 
-def _extract_port_decl(name: Optional[str], py_type: Any) -> AnonPortDeclaration:
+def _extract_port_decl(name: str | None, py_type: Any) -> AnonPortDeclaration:
     quantum_type, direction, modifier = get_port_from_type_hint(py_type)
     param = AnonPortDeclaration(
         name=None,
@@ -116,33 +115,30 @@ def _extract_port_decl(name: Optional[str], py_type: Any) -> AnonPortDeclaration
 
 
 def _extract_operand_decl(
-    name: Optional[str], py_type: Any, qmodule: Optional[ModelStateContainer]
+    name: str | None, py_type: Any, qmodule: ModelStateContainer | None
 ) -> AnonQuantumOperandDeclaration:
-    is_list = (get_origin(py_type) or py_type) is QCallableList
-    is_generative = False
-    if get_origin(py_type) is list:
-        is_list = True
-        is_generative = True
-        py_type = version_portable_get_args(py_type)[0]
+    is_list = (get_origin(py_type) or py_type) is QCallableList or (
+        get_origin(py_type) or py_type
+    ) is QPermList
+    is_permutation = (get_origin(py_type) or py_type) is QPerm or (
+        get_origin(py_type) or py_type
+    ) is QPermList
     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(
             param_decls, qmodule=qmodule
         ),
+        permutation=is_permutation,
         is_list=is_list,
     )
-    if is_generative:
-        param = param.set_generative()
     if name is not None:
         param = param.rename(name)
     return param
 
 
-def _extract_operand_param(py_type: Any) -> tuple[Optional[str], Any]:
+def _extract_operand_param(py_type: Any) -> tuple[str | None, Any]:
     if get_origin(py_type) is not Annotated:
         return None, py_type
 
@@ -164,7 +160,7 @@ def _unpacked_annotated(arg_0: Any, args: Any) -> _AnnotatedAlias:
     return Annotated.__class_getitem__((arg_0, *args))  # type:ignore[attr-defined]
 
 
-def _get_param_name(py_type_args: Any) -> Optional[str]:
+def _get_param_name(py_type_args: Any) -> str | None:
     if isinstance(py_type_args[-1], str) and not isinstance(
         py_type_args[-1], (PortDeclarationDirection, TypeModifier)
     ):
@@ -189,20 +185,20 @@ def _validate_annotations(py_type_args: Any, py_type: Any) -> None:
 
 @overload
 def _extract_positional_args(
-    args: Sequence[tuple[str, Any]], qmodule: Optional[ModelStateContainer]
+    args: Sequence[tuple[str, Any]], qmodule: ModelStateContainer | None
 ) -> Sequence[PositionalArg]:
     pass
 
 
 @overload
 def _extract_positional_args(
-    args: Sequence[tuple[Optional[str], Any]], qmodule: Optional[ModelStateContainer]
+    args: Sequence[tuple[str | None, Any]], qmodule: ModelStateContainer | None
 ) -> Sequence[AnonPositionalArg]:
     pass
 
 
 def _extract_positional_args(
-    args: Sequence[tuple[Optional[str], Any]], qmodule: Optional[ModelStateContainer]
+    args: Sequence[tuple[str | None, Any]], qmodule: ModelStateContainer | None
 ) -> Sequence[AnonPositionalArg]:
     result: list[AnonPositionalArg] = []
     for name, py_type in args:
@@ -222,18 +218,25 @@ def _extract_positional_args(
         elif is_qvar(py_type):
             result.append(_extract_port_decl(name, py_type))
         else:
+            if not issubclass(get_origin(py_type) or py_type, QCallable):
+                raise ClassiqValueError(
+                    f"Unsupported type annotation {type_to_str(py_type)!r}"
+                )
             result.append(_extract_operand_decl(name, py_type, qmodule=qmodule))
     return result
 
 
 def infer_func_decl(
-    py_func: Callable, qmodule: Optional[ModelStateContainer] = None
+    py_func: Callable,
+    qmodule: ModelStateContainer | None = None,
+    permutation: bool = False,
 ) -> NamedParamsQuantumFunctionDeclaration:
     return NamedParamsQuantumFunctionDeclaration(
         name=unmangle_keyword(py_func.__name__),
         positional_arg_declarations=_extract_positional_args(
             list(py_func.__annotations__.items()), qmodule=qmodule
         ),
+        permutation=permutation,
     )
 
 

classiq/qmod/expression_query.py

@@ -1,9 +1,11 @@
 from typing import TYPE_CHECKING
 
-from classiq.interface.generator.arith.arithmetic import compute_arithmetic_result_type
 from classiq.interface.generator.arith.number_utils import MAXIMAL_MACHINE_PRECISION
 from classiq.interface.model.quantum_type import QuantumNumeric
 
+from classiq.evaluators.qmod_expression_visitors.qmod_expression_evaluator import (
+    evaluate_qmod_expression,
+)
 from classiq.qmod.qmod_variable import QNum
 from classiq.qmod.symbolic_type import SymbolicTypes
 
@@ -29,11 +31,12 @@ def get_expression_numeric_attributes(
             - The number of fraction digits (int) in the result.
 
     """
-    res_type = compute_arithmetic_result_type(
-        expr_str=str(expr),
-        var_types={str(var.get_handle_binding()): var.get_qmod_type() for var in vars},
+    expr_val = evaluate_qmod_expression(
+        expr=str(expr),
+        scope={str(var.get_handle_binding()): var.get_qmod_type() for var in vars},
         machine_precision=machine_precision,
     )
+    res_type = expr_val.get_type(expr_val.root)
     if TYPE_CHECKING:
         assert isinstance(res_type, QuantumNumeric)
     return res_type.size_in_bits, res_type.sign_value, res_type.fraction_digits_value

classiq/qmod/model_state_container.py

@@ -1,6 +1,6 @@
 from collections import defaultdict
 from collections.abc import Sequence
-from typing import TYPE_CHECKING, Union
+from typing import TYPE_CHECKING
 
 from classiq.interface.generator.constant import Constant
 from classiq.interface.generator.types.compilation_metadata import CompilationMetadata
@@ -40,7 +40,7 @@ class ModelStateContainer:
 
     def user_types(
         self,
-    ) -> Sequence[Union[EnumDeclaration, StructDeclaration, QStructDeclaration]]:
+    ) -> Sequence[EnumDeclaration | StructDeclaration | QStructDeclaration]:
         type_decls = [
             t
             for t in self.type_decls.values()

classiq/qmod/native/pretty_printer.py

@@ -1,5 +1,4 @@
 from collections.abc import Mapping
-from typing import Optional, Union
 
 from classiq.interface.constants import DEFAULT_DECIMAL_PRECISION
 from classiq.interface.exceptions import ClassiqInternalError
@@ -93,9 +92,9 @@ from classiq.qmod.semantics.annotation.call_annotation import resolve_function_c
 class DSLPrettyPrinter(ModelVisitor):
     def __init__(
         self,
-        decimal_precision: Optional[int] = DEFAULT_DECIMAL_PRECISION,
+        decimal_precision: int | None = DEFAULT_DECIMAL_PRECISION,
         emit_open_lib_functions: bool = False,
-        compilation_metadata: Optional[dict[str, CompilationMetadata]] = None,
+        compilation_metadata: dict[str, CompilationMetadata] | None = None,
     ) -> None:
         self._level = 0
         self._decimal_precision = decimal_precision
@@ -145,19 +144,30 @@ class DSLPrettyPrinter(ModelVisitor):
         )
         return f"({positional_args})"
 
-    def _get_unchecked_string(self, func_decl: QuantumFunctionDeclaration) -> str:
-        if func_decl.name not in self._compilation_metadata:
+    def _get_decorators(self, func: str) -> str:
+        if func not in self._compilation_metadata:
             return ""
-        unchecked = self._compilation_metadata[func_decl.name].unchecked
-        if len(unchecked) == 0:
-            return ""
-        return f" unchecked ({', '.join(unchecked)})\n"
+
+        decorators = ""
+        metadata = self._compilation_metadata[func]
+
+        if metadata.disable_perm_check:
+            decorators += "@disable_perm_check\n"
+
+        if metadata.disable_const_checks:
+            if metadata.disable_const_checks is True:
+                decorators += "@disable_const_checks\n"
+            else:
+                decorators += f"@disable_const_checks({', '.join(metadata.disable_const_checks)})\n"
+
+        return decorators
 
     def visit_QuantumFunctionDeclaration(
         self, func_decl: QuantumFunctionDeclaration
     ) -> str:
-        unchecked = self._get_unchecked_string(func_decl)
-        return f"qfunc {func_decl.name}{self._visit_arg_decls(func_decl)}{unchecked}"
+        decorators = self._get_decorators(func_decl.name)
+        function_type = "qperm" if func_decl.permutation else "qfunc"
+        return f"{decorators}{function_type} {func_decl.name}{self._visit_arg_decls(func_decl)}"
 
     def visit_EnumDeclaration(self, enum_decl: EnumDeclaration) -> str:
         return f"enum {enum_decl.name} {{\n{self._visit_members(enum_decl.members)}}}\n"
@@ -178,7 +188,7 @@ class DSLPrettyPrinter(ModelVisitor):
         return f"qstruct {qstruct_decl.name} {{\n{self._visit_variables(qstruct_decl.fields)}}}\n"
 
     def _visit_variables(
-        self, variables: Mapping[str, Union[ConcreteClassicalType, ConcreteQuantumType]]
+        self, variables: Mapping[str, ConcreteClassicalType | ConcreteQuantumType]
     ) -> str:
         self._level += 1
         variables_str = "".join(
@@ -191,7 +201,7 @@ class DSLPrettyPrinter(ModelVisitor):
     def visit_AnonPortDeclaration(self, port_decl: AnonPortDeclaration) -> str:
         modifier_str = (
             f"{port_decl.type_modifier} "
-            if port_decl.type_modifier in [TypeModifier.Const, TypeModifier.Permutable]
+            if port_decl.type_modifier is TypeModifier.Const
             else ""
         )
         dir_str = (
@@ -265,7 +275,8 @@ class DSLPrettyPrinter(ModelVisitor):
         self, op_decl: AnonQuantumOperandDeclaration
     ) -> str:
         param_name = f"{op_decl.name}: " if op_decl.name is not None else ""
-        return f"{param_name}qfunc{[] if op_decl.is_list else ''} {self._visit_arg_decls(op_decl)}"
+        function_type = "qperm" if op_decl.permutation else "qfunc"
+        return f"{param_name}{function_type}{[] if op_decl.is_list else ''} {self._visit_arg_decls(op_decl)}"
 
     def visit_QuantumOperandDeclaration(
         self, op_decl: QuantumOperandDeclaration

classiq/qmod/pretty_print/expression_to_python.py

@@ -1,8 +1,7 @@
 import ast
 import re
-from collections.abc import Mapping
+from collections.abc import Callable, Mapping
 from dataclasses import dataclass
-from typing import Callable
 
 import numpy as np
 
@@ -120,7 +119,10 @@ class ASTToQMODCode(ast.NodeVisitor):
         return f"[{elements}]"
 
     def visit_Subscript(self, node: ast.Subscript) -> str:
-        return f"{self.visit(node.value)}[{_remove_redundant_parentheses(self.visit(node.slice))}]"
+        if not isinstance(node.value, ast.List):
+            return f"{self.visit(node.value)}[{_remove_redundant_parentheses(self.visit(node.slice))}]"
+        self.symbolic_imports["subscript"] = 1
+        return f"subscript({self.visit(node.value)}, {_remove_redundant_parentheses(self.visit(node.slice))})"
 
     def visit_Slice(self, node: ast.Slice) -> str:
         if node.lower is None or node.upper is None or node.step is not None: