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

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/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:

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):