classiq 0.93.0__py3-none-any.whl → 0.100.0__py3-none-any.whl

classiq/qmod/pretty_print/pretty_printer.py

@@ -1,5 +1,5 @@
 from collections.abc import Mapping
-from typing import Optional, Union, cast
+from typing import cast
 
 import black
 
@@ -108,7 +108,7 @@ class VariableDeclarationAssignment(Visitor):
 
     def visit_QuantumBitvector(
         self, qtype: QuantumBitvector
-    ) -> tuple[str, Optional[list[str]]]:
+    ) -> tuple[str, list[str] | None]:
         self.pretty_printer._imports["QArray"] = 1
 
         element_type = self.pretty_printer.visit(qtype.element_type)
@@ -118,7 +118,7 @@ class VariableDeclarationAssignment(Visitor):
 
     def visit_QuantumNumeric(
         self, qtype: QuantumNumeric
-    ) -> tuple[str, Optional[list[str]]]:
+    ) -> tuple[str, list[str] | None]:
         self.pretty_printer._imports["QNum"] = 1
         return "QNum", self.pretty_printer._get_qnum_properties(qtype)
 
@@ -130,12 +130,12 @@ class PythonPrettyPrinter(ModelVisitor):
     def __init__(self, decimal_precision: int = DEFAULT_DECIMAL_PRECISION) -> None:
         self._level = 0
         self._decimal_precision = decimal_precision
-        self._imports = {"qfunc": 1}
+        self._imports: dict[str, int] = {}
         self._import_enum = False
         self._import_dataclass = False
         self._import_annotated = False
         self._symbolic_imports: dict[str, int] = dict()
-        self._functions: Optional[Mapping[str, QuantumFunctionDeclaration]] = None
+        self._functions: Mapping[str, QuantumFunctionDeclaration] | None = None
         self._compilation_metadata: dict[str, CompilationMetadata] = dict()
 
     def visit(self, node: NodeType) -> str:
@@ -204,16 +204,33 @@ class PythonPrettyPrinter(ModelVisitor):
         )
 
     def _get_qfunc_decorator(self, func_decl: QuantumFunctionDeclaration) -> str:
-        no_unchecked_decorator = "@qfunc"
+        if func_decl.permutation:
+            decorator = "@qperm"
+            self._imports["qperm"] = 1
+        else:
+            decorator = "@qfunc"
+            self._imports["qfunc"] = 1
+
         if func_decl.name not in self._compilation_metadata:
-            return no_unchecked_decorator
-        unchecked = self._compilation_metadata[func_decl.name].unchecked
-        if len(unchecked) == 0:
-            return no_unchecked_decorator
+            return decorator
+
+        metadata = self._compilation_metadata[func_decl.name]
+
+        decorator_params: list[str] = []
+        if metadata.disable_perm_check:
+            decorator_params.append("disable_perm_check=True")
 
-        unchecked_modifiers = (f'"{modifier}"' for modifier in unchecked)
-        unchecked_list = f"[{', '.join(unchecked_modifiers)}]"
-        return no_unchecked_decorator + f" (unchecked={unchecked_list})"
+        if metadata.disable_const_checks:
+            if metadata.disable_const_checks is True:
+                value = "True"
+            else:
+                value = f"[{', '.join(f'{param!r}' for param in metadata.disable_const_checks)}]"
+            decorator_params.append(f"disable_const_checks={value}")
+
+        if decorator_params:
+            return f"{decorator}({', '.join(decorator_params)})"
+        else:
+            return decorator
 
     def visit_QuantumFunctionDeclaration(
         self, func_decl: QuantumFunctionDeclaration
@@ -243,7 +260,7 @@ class PythonPrettyPrinter(ModelVisitor):
         return f"class {qstruct_decl.name}(QStruct):\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(
@@ -262,7 +279,7 @@ class PythonPrettyPrinter(ModelVisitor):
         if port_decl.direction is not PortDeclarationDirection.Inout:
             self._imports[port_decl.direction.name] = 1
             var_type = f"{port_decl.direction.name}[{var_type}]"
-        if port_decl.type_modifier in [TypeModifier.Const, TypeModifier.Permutable]:
+        if port_decl.type_modifier is TypeModifier.Const:
             self._imports[port_decl.type_modifier.name] = 1
             var_type = f"{port_decl.type_modifier.name}[{var_type}]"
         return var_type
@@ -394,7 +411,12 @@ class PythonPrettyPrinter(ModelVisitor):
     def visit_AnonQuantumOperandDeclaration(
         self, op_decl: AnonQuantumOperandDeclaration, no_param: bool = False
     ) -> str:
-        qcallable_identifier = "QCallableList" if op_decl.is_list else "QCallable"
+        qcallable_identifier = {
+            (False, False): "QCallable",
+            (False, True): "QCallableList",
+            (True, False): "QPerm",
+            (True, True): "QPermList",
+        }[(op_decl.permutation, op_decl.is_list)]
         self._imports[qcallable_identifier] = 1
         args = ", ".join(
             self._visit_operand_arg_decl(arg_decl)
@@ -494,7 +516,7 @@ class PythonPrettyPrinter(ModelVisitor):
         return f"{self._indent}block({self._visit_body(block.statements)})\n"
 
     def _visit_body(
-        self, body: StatementBlock, operand_arguments: Optional[list[str]] = None
+        self, body: StatementBlock, operand_arguments: list[str] | None = None
     ) -> str:
         if len(body) == 0:
             return "lambda: []"

classiq/qmod/python_classical_type.py

@@ -5,7 +5,6 @@ from typing import (
     Any,
     ForwardRef,
     Literal,
-    Optional,
     get_args,
     get_origin,
 )
@@ -15,6 +14,7 @@ from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.classical_type import (
     Bool,
     ClassicalArray,
+    ClassicalTuple,
     Integer,
     Real,
 )
@@ -22,7 +22,7 @@ from classiq.interface.generator.functions.concrete_types import ConcreteClassic
 from classiq.interface.generator.functions.type_name import Enum, Struct, TypeName
 
 from classiq.qmod.cparam import CArray, CBool, CInt, CReal
-from classiq.qmod.utilities import version_portable_get_args
+from classiq.qmod.utilities import type_to_str, version_portable_get_args
 
 CARRAY_ERROR_MESSAGE = (
     "CArray accepts one or two generic parameters in the form "
@@ -30,10 +30,23 @@ CARRAY_ERROR_MESSAGE = (
 )
 
 
+def _has_struct_or_enum(classical_type: ConcreteClassicalType) -> bool:
+    if isinstance(classical_type, TypeName):
+        return True
+    if isinstance(classical_type, ClassicalArray):
+        return _has_struct_or_enum(classical_type.element_type)
+    if isinstance(classical_type, ClassicalTuple):
+        return any(
+            _has_struct_or_enum(element_type)
+            for element_type in classical_type.element_types
+        )
+    return False
+
+
 class PythonClassicalType:
     def convert(
         self, py_type: type, nested: bool = False
-    ) -> Optional[ConcreteClassicalType]:
+    ) -> ConcreteClassicalType | None:
         if py_type is int:
             return Integer().set_generative()
         elif py_type is CInt:
@@ -47,21 +60,35 @@ class PythonClassicalType:
         elif py_type is CBool:
             return Bool()
         elif get_origin(py_type) is list:
-            element_type = self.convert(get_args(py_type)[0], nested=True)
-            if element_type is not None:
-                return ClassicalArray(element_type=element_type).set_generative()
+            element_py_type = get_args(py_type)[0]
+            element_type = self.convert(element_py_type, nested=True)
+            if element_type is None:
+                return None
+            if not element_type.is_generative and not _has_struct_or_enum(element_type):
+                raise ClassiqValueError(
+                    f"Invalid type annotation: 'list' is generative but "
+                    f"{type_to_str(element_py_type)!r} is declarative"
+                )
+            return ClassicalArray(element_type=element_type).set_generative()
         elif get_origin(py_type) is CArray:
             array_args = version_portable_get_args(py_type)
             if len(array_args) == 1:
-                return ClassicalArray(
-                    element_type=self.convert(array_args[0], nested=True)
-                )
+                length = None
             elif len(array_args) == 2:
-                return ClassicalArray(
-                    element_type=self.convert(array_args[0], nested=True),
-                    length=Expression(expr=get_type_hint_expr(array_args[1])),
+                length = Expression(expr=get_type_hint_expr(array_args[1]))
+            else:
+                raise ClassiqValueError(CARRAY_ERROR_MESSAGE)
+            element_type = self.convert(array_args[0], nested=True)
+            if element_type is None:
+                return None
+            if element_type.is_generative and not _has_struct_or_enum(element_type):
+                raise ClassiqValueError(
+                    f"Invalid type annotation: 'CArray' is declarative but "
+                    f"{type_to_str(array_args[0])!r} is generative"
                 )
-            raise ClassiqValueError(CARRAY_ERROR_MESSAGE)
+            return ClassicalArray(
+                element_type=self.convert(array_args[0], nested=True), length=length
+            )
         elif inspect.isclass(py_type) and dataclasses.is_dataclass(py_type):
             return self.register_struct(py_type)
         elif inspect.isclass(py_type) and isinstance(py_type, EnumMeta):

classiq/qmod/qfunc.py

@@ -1,6 +1,9 @@
-from typing import Callable, Literal, Optional, Union, overload
+from collections.abc import Callable
+from typing import Literal, overload
 
-from classiq.interface.exceptions import ClassiqInternalError
+from classiq.interface.exceptions import (
+    ClassiqInternalError,
+)
 
 from classiq.qmod.global_declarative_switch import get_global_declarative_switch
 from classiq.qmod.quantum_callable import QCallable
@@ -21,7 +24,8 @@ def qfunc(
     *,
     external: Literal[True],
     synthesize_separately: Literal[False] = False,
-    unchecked: Optional[list[str]] = None,
+    disable_perm_check: bool = False,
+    disable_const_checks: list[str] | bool = False,
 ) -> Callable[[Callable], ExternalQFunc]: ...
 
 
@@ -30,13 +34,17 @@ def qfunc(
     *,
     generative: Literal[False],
     synthesize_separately: bool = False,
-    unchecked: Optional[list[str]] = None,
+    disable_perm_check: bool = False,
+    disable_const_checks: list[str] | bool = False,
 ) -> Callable[[Callable], QFunc]: ...
 
 
 @overload
 def qfunc(
-    *, synthesize_separately: bool, unchecked: Optional[list[str]] = None
+    *,
+    synthesize_separately: bool,
+    disable_perm_check: bool = False,
+    disable_const_checks: list[str] | bool = False,
 ) -> Callable[[Callable], GenerativeQFunc]: ...
 
 
@@ -44,18 +52,103 @@ def qfunc(
 def qfunc(
     *,
     synthesize_separately: bool = False,
-    unchecked: Optional[list[str]] = None,
+    disable_perm_check: bool = False,
+    disable_const_checks: list[str] | bool = False,
 ) -> Callable[[Callable], GenerativeQFunc]: ...
 
 
 def qfunc(
-    func: Optional[Callable] = None,
+    func: Callable | None = None,
+    *,
+    external: bool = False,
+    generative: bool | None = None,
+    synthesize_separately: bool = False,
+    disable_perm_check: bool = False,
+    disable_const_checks: list[str] | bool = False,
+) -> Callable[[Callable], QCallable] | QCallable:
+    return _qfunc_inner(
+        func=func,
+        external=external,
+        generative=generative,
+        synthesize_separately=synthesize_separately,
+        permutation=False,
+        disable_perm_check=disable_perm_check,
+        disable_const_checks=disable_const_checks,
+    )
+
+
+@overload
+def qperm(func: Callable) -> GenerativeQFunc: ...
+
+
+@overload
+def qperm(
+    *,
+    external: Literal[True],
+    synthesize_separately: Literal[False] = False,
+    disable_perm_check: bool = False,
+    disable_const_checks: list[str] | bool = False,
+) -> Callable[[Callable], ExternalQFunc]: ...
+
+
+@overload
+def qperm(
+    *,
+    generative: Literal[False],
+    synthesize_separately: bool = False,
+    disable_perm_check: bool = False,
+    disable_const_checks: list[str] | bool = False,
+) -> Callable[[Callable], QFunc]: ...
+
+
+@overload
+def qperm(
+    *,
+    synthesize_separately: bool,
+    disable_perm_check: bool = False,
+    disable_const_checks: list[str] | bool = False,
+) -> Callable[[Callable], GenerativeQFunc]: ...
+
+
+@overload
+def qperm(
+    *,
+    synthesize_separately: bool = False,
+    disable_perm_check: bool = False,
+    disable_const_checks: list[str] | bool = False,
+) -> Callable[[Callable], GenerativeQFunc]: ...
+
+
+def qperm(
+    func: Callable | None = None,
+    *,
+    external: bool = False,
+    generative: bool | None = None,
+    synthesize_separately: bool = False,
+    disable_perm_check: bool = False,
+    disable_const_checks: list[str] | bool = False,
+) -> Callable[[Callable], QCallable] | QCallable:
+    return _qfunc_inner(
+        func=func,
+        external=external,
+        generative=generative,
+        synthesize_separately=synthesize_separately,
+        permutation=True,
+        disable_perm_check=disable_perm_check,
+        disable_const_checks=disable_const_checks,
+    )
+
+
+def _qfunc_inner(
     *,
+    func: Callable | None = None,
     external: bool = False,
-    generative: Optional[bool] = None,
+    generative: bool | None = None,
     synthesize_separately: bool = False,
-    unchecked: Optional[list[str]] = None,
-) -> Union[Callable[[Callable], QCallable], QCallable]:
+    permutation: bool = False,
+    disable_perm_check: bool = False,
+    disable_const_checks: list[str] | bool = False,
+) -> Callable[[Callable], QCallable] | QCallable:
     if generative is None:
         generative = True
     if get_global_declarative_switch():
@@ -65,17 +158,21 @@ def qfunc(
         qfunc: BaseQFunc
 
         if external:
-            _validate_directives(synthesize_separately, unchecked)
-            return ExternalQFunc(func)
+            _validate_directives(
+                synthesize_separately, disable_perm_check, disable_const_checks
+            )
+            return ExternalQFunc(func, permutation=permutation)
 
         if generative:
-            qfunc = GenerativeQFunc(func)
+            qfunc = GenerativeQFunc(func, permutation=permutation)
         else:
-            qfunc = QFunc(func)
+            qfunc = QFunc(func, permutation=permutation)
         if synthesize_separately:
             qfunc.update_compilation_metadata(should_synthesize_separately=True)
-        if unchecked is not None and len(unchecked) > 0:
-            qfunc.update_compilation_metadata(unchecked=unchecked)
+        if disable_perm_check:
+            qfunc.update_compilation_metadata(disable_perm_check=disable_perm_check)
+        if disable_const_checks:
+            qfunc.update_compilation_metadata(disable_const_checks=disable_const_checks)
         return qfunc
 
     if func is not None:
@@ -84,12 +181,20 @@ def qfunc(
 
 
 def _validate_directives(
-    synthesize_separately: bool, unchecked: Optional[list[str]] = None
+    synthesize_separately: bool,
+    disable_perm_check: bool = False,
+    disable_const_checks: list[str] | bool = False,
 ) -> None:
     error_msg = ""
     if synthesize_separately:
         error_msg += "External functions can't be marked as synthesized separately. \n"
-    if unchecked is not None and len(unchecked) > 0:
-        error_msg += "External functions can't have unchecked modifiers."
+    if disable_perm_check:
+        error_msg += (
+            "External functions can't have the `disable_perm_check` decorator. \n"
+        )
+    if disable_const_checks:
+        error_msg += (
+            "External functions can't have the `disable_const_checks` decorator. \n"
+        )
     if error_msg:
         raise ClassiqInternalError(error_msg)

classiq/qmod/qmod_constant.py

@@ -1,6 +1,6 @@
 import inspect
 from dataclasses import is_dataclass
-from typing import TYPE_CHECKING, Any, Optional, cast, get_origin
+from typing import TYPE_CHECKING, Any, cast, get_origin
 
 from classiq.interface.exceptions import ClassiqError, ClassiqValueError
 from classiq.interface.generator.constant import Constant
@@ -25,7 +25,7 @@ QMODULE_ERROR_MESSAGE = (
 
 
 class QConstant(SymbolicExpr):
-    CURRENT_QMODULE: Optional[ModelStateContainer] = None
+    CURRENT_QMODULE: ModelStateContainer | None = None
 
     def __init__(self, name: str, py_type: type, value: Any) -> None:
         super().__init__(name, False)

classiq/qmod/qmod_parameter.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING, Any, Union
+from typing import TYPE_CHECKING, Any, NoReturn
 
 from classiq.interface.exceptions import ClassiqInternalError, ClassiqValueError
 from classiq.interface.generator.functions.classical_type import (
@@ -41,7 +41,7 @@ class CParamList(CParam):
     def __init__(
         self,
         expr: str,
-        list_type: Union[ClassicalArray, ClassicalTuple],
+        list_type: ClassicalArray | ClassicalTuple,
         qmodule: ModelStateContainer,
     ) -> None:
         super().__init__(expr)
@@ -102,6 +102,9 @@ class CParamList(CParam):
                 return interpret_expression(str(self.len))
         return CParamScalar(f"{self}.len")
 
+    def __iter__(self) -> NoReturn:
+        raise TypeError(f"{type(self).__name__!r} object is not iterable")
+
 
 class CParamStruct(CParam):
     def __init__(