classiq 0.53.0__py3-none-any.whl → 0.54.0__py3-none-any.whl

classiq/qmod/builtins/functions/variational.py

@@ -1,7 +1,11 @@
+from classiq.qmod.builtins.functions.standard_gates import RX, RY, RZ
+from classiq.qmod.builtins.functions.state_preparation import allocate
+from classiq.qmod.builtins.operations import repeat
 from classiq.qmod.cparam import CReal
 from classiq.qmod.qfunc import qfunc
 from classiq.qmod.qmod_parameter import CArray
 from classiq.qmod.qmod_variable import Output, QArray, QBit
+from classiq.qmod.symbolic import ceiling, floor, pi
 
 
 @qfunc(external=True)
@@ -17,7 +21,11 @@ def encode_in_angle(data: CArray[CReal], qba: Output[QArray[QBit]]) -> None:
         data: A classical array representing the data to encode.
         qba: The array of qubits on which the data is encoded.
     """
-    pass
+    allocate(data.len, qba)
+    repeat(
+        count=data.len,
+        iteration=lambda index: RY(pi * data[index], qba[index]),
+    )
 
 
 @qfunc(external=True)
@@ -34,4 +42,12 @@ def encode_on_bloch(data: CArray[CReal], qba: Output[QArray]) -> None:
         data: A classical array representing the data to encode.
         qba: The QArray of QBits on which the data is encoded.
     """
-    pass
+    allocate(ceiling(data.len / 2), qba)
+    repeat(
+        count=ceiling(data.len / 2),
+        iteration=lambda index: RX(pi * data[2 * index], qba[index]),
+    )
+    repeat(
+        count=floor(data.len / 2),
+        iteration=lambda index: RZ(pi * data[2 * index + 1], qba[index]),
+    )

classiq/qmod/builtins/operations.py

@@ -1,12 +1,11 @@
 import inspect
 import sys
+from collections.abc import Mapping
 from types import FrameType
 from typing import (
     Any,
     Callable,
     Final,
-    List,
-    Mapping,
     Union,
 )
 
@@ -48,8 +47,8 @@ _MISSING_VALUE: Final[int] = -1
 
 
 def bind(
-    source: Union[Input[QVar], List[Input[QVar]]],
-    destination: Union[Output[QVar], List[Output[QVar]]],
+    source: Union[Input[QVar], list[Input[QVar]]],
+    destination: Union[Output[QVar], list[Output[QVar]]],
 ) -> None:
     assert QCallable.CURRENT_EXPANDABLE is not None
     source_ref = get_source_ref(sys._getframe(1))
@@ -311,5 +310,5 @@ __all__ = [
 ]
 
 
-def __dir__() -> List[str]:
+def __dir__() -> list[str]:
     return __all__

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,8 +1,7 @@
 import ast
 import inspect
-import sys
 from textwrap import dedent
-from typing import Any, Callable, Dict
+from typing import Any, Callable
 
 from classiq.interface.exceptions import ClassiqValueError
 
@@ -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/create_model_function.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING, Dict, List, Optional, Union, cast
+from typing import TYPE_CHECKING, Optional, Union, cast
 
 from classiq.interface.exceptions import ClassiqError
 from classiq.interface.executor.execution_preferences import ExecutionPreferences
@@ -116,7 +116,7 @@ def _expand_generative_model(
 
 def _get_generative_functions(
     gen_main: QFunc, preferences: Optional[Preferences]
-) -> List[NativeFunctionDefinition]:
+) -> list[NativeFunctionDefinition]:
     # The Interpreter accepts a model and a list of generative functions.
     # Since the main function is generative, it can only be expanded using the
     # Interpreter.
@@ -154,7 +154,7 @@ def _get_wrapper_main(gen_main: QFunc, preferences: Optional[Preferences]) -> Mo
     )
 
 
-def _get_all_model_functions_as_generative_functions() -> List[GenerativeQFunc]:
+def _get_all_model_functions_as_generative_functions() -> list[GenerativeQFunc]:
 
     gen_functions = list(GEN_QFUNCS) + [
         _get_gen_from_dec(dec_func) for dec_func in DEC_QFUNCS
@@ -184,15 +184,16 @@ def _get_gen_from_dec(dec_func: QFunc) -> GenerativeQFunc:
 
 
 def _interpret_generative_model(
-    gen_model: Model, gen_functions: List[GenerativeQFunc]
-) -> Dict[str, NativeFunctionDefinition]:
+    gen_model: Model, gen_functions: list[GenerativeQFunc]
+) -> dict[str, NativeFunctionDefinition]:
     resolve_function_calls(
         gen_model,
         {gen_func.func_decl.name: gen_func.func_decl for gen_func in gen_functions},
     )
     interpreter = Interpreter(gen_model, gen_functions, is_frontend=True)
     set_frontend_interpreter(interpreter)
-    functions_dict = nameables_to_dict(interpreter.expand().functions)
+    expand_model, _ = interpreter.expand()
+    functions_dict = nameables_to_dict(expand_model.functions)
 
     # Inline _gen_main call in main
     expanded_gen_main_name = cast(

classiq/qmod/declaration_inferrer.py

@@ -1,15 +1,12 @@
 import dataclasses
 import sys
+from collections.abc import Sequence
 from enum import EnumMeta
 from typing import (
     Any,
     Callable,
-    List,
     Literal,
     Optional,
-    Sequence,
-    Tuple,
-    Type,
     get_args,
     get_origin,
     overload,
@@ -91,7 +88,7 @@ def python_type_to_qmod(
 
 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]
@@ -128,7 +125,7 @@ def _extract_operand_decl(
     return param
 
 
-def _extract_operand_param(py_type: Any) -> Tuple[Optional[str], Any]:
+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)
@@ -152,22 +149,22 @@ def _extract_operand_param(py_type: Any) -> Tuple[Optional[str], Any]:
 
 @overload
 def _extract_positional_args(
-    args: Sequence[Tuple[str, Any]], qmodule: Optional[ModelStateContainer]
+    args: Sequence[tuple[str, Any]], qmodule: Optional[ModelStateContainer]
 ) -> Sequence[PositionalArg]:
     pass
 
 
 @overload
 def _extract_positional_args(
-    args: Sequence[Tuple[Optional[str], Any]], qmodule: Optional[ModelStateContainer]
+    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]
+    args: Sequence[tuple[Optional[str], Any]], qmodule: Optional[ModelStateContainer]
 ) -> Sequence[AnonPositionalArg]:
-    result: List[AnonPositionalArg] = []
+    result: list[AnonPositionalArg] = []
     for name, py_type in args:
         if name == "return":
             continue

classiq/qmod/expression_query.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING, List, Tuple
+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
@@ -9,10 +9,10 @@ from classiq.qmod.symbolic_type import SymbolicTypes
 
 
 def get_expression_numeric_attributes(
-    vars: List[QNum],
+    vars: list[QNum],
     expr: SymbolicTypes,
     machine_precision: int = MAXIMAL_MACHINE_PRECISION,
-) -> Tuple[int, bool, int]:
+) -> tuple[int, bool, int]:
     """
     Computes and returns the numeric attributes of a given symbolic expression.
 

classiq/qmod/generative.py

@@ -1,5 +1,6 @@
+from collections.abc import Iterator
 from contextlib import contextmanager
-from typing import TYPE_CHECKING, Any, Iterator, Optional
+from typing import TYPE_CHECKING, Any, Optional
 
 from classiq.interface.exceptions import ClassiqError
 from classiq.interface.generator.expressions.expression import Expression

classiq/qmod/model_state_container.py

@@ -1,5 +1,3 @@
-from typing import Dict
-
 from classiq.interface.generator.constant import Constant
 from classiq.interface.generator.types.enum_declaration import EnumDeclaration
 from classiq.interface.generator.types.qstruct_declaration import QStructDeclaration
@@ -8,11 +6,11 @@ from classiq.interface.model.native_function_definition import NativeFunctionDef
 
 
 class ModelStateContainer:
-    enum_decls: Dict[str, EnumDeclaration]
-    type_decls: Dict[str, StructDeclaration]
-    qstruct_decls: Dict[str, QStructDeclaration]
-    native_defs: Dict[str, NativeFunctionDefinition]
-    constants: Dict[str, Constant]
+    enum_decls: dict[str, EnumDeclaration]
+    type_decls: dict[str, StructDeclaration]
+    qstruct_decls: dict[str, QStructDeclaration]
+    native_defs: dict[str, NativeFunctionDefinition]
+    constants: dict[str, Constant]
 
 
 QMODULE = ModelStateContainer()

classiq/qmod/native/__init__.py

@@ -1,9 +1,7 @@
-from typing import List
-
 from .pretty_printer import DSLPrettyPrinter
 
 __all__ = ["DSLPrettyPrinter"]
 
 
-def __dir__() -> List[str]:
+def __dir__() -> list[str]:
     return __all__

classiq/qmod/native/expression_to_qmod.py

@@ -1,14 +1,15 @@
 import ast
 import re
+from collections.abc import Mapping
 from dataclasses import dataclass
-from typing import Callable, Dict, List, Mapping, Optional, Type
+from typing import Callable, Optional
 
 import numpy as np
 
 from classiq.qmod.utilities import DEFAULT_DECIMAL_PRECISION
 
 IDENTIFIER = re.compile(r"[a-zA-Z_]\w*")
-BINARY_OPS: Mapping[Type[ast.operator], str] = {
+BINARY_OPS: Mapping[type[ast.operator], str] = {
     ast.Add: "+",
     ast.Sub: "-",
     ast.Mult: "*",
@@ -21,14 +22,14 @@ BINARY_OPS: Mapping[Type[ast.operator], str] = {
     ast.LShift: "<<",
     ast.RShift: ">>",
 }
-BOOL_OPS: Mapping[Type[ast.boolop], str] = {ast.And: "and", ast.Or: "or"}
-UNARY_OPS: Mapping[Type[ast.unaryop], str] = {
+BOOL_OPS: Mapping[type[ast.boolop], str] = {ast.And: "and", ast.Or: "or"}
+UNARY_OPS: Mapping[type[ast.unaryop], str] = {
     ast.UAdd: "+",
     ast.USub: "-",
     ast.Invert: "~",
     ast.Not: "not",
 }
-COMPARE_OPS: Mapping[Type[ast.cmpop], str] = {
+COMPARE_OPS: Mapping[type[ast.cmpop], str] = {
     ast.Eq: "==",
     ast.NotEq: "!=",
     ast.Lt: "<",
@@ -139,7 +140,7 @@ class ASTToQMODCode:
         else:
             raise AssertionError("Error parsing expression: unsupported AST node.")
 
-    def indent_items(self, items: Callable[[], List[str]]) -> str:
+    def indent_items(self, items: Callable[[], list[str]]) -> str:
         should_indent = (
             len("".join([i.strip() for i in items()])) >= LIST_FORMAT_CHAR_LIMIT
         )
@@ -165,8 +166,8 @@ class ASTToQMODCode:
 def _remove_redundant_parentheses(expr: str) -> str:
     if not (expr.startswith("(") and expr.endswith(")")):
         return expr
-    parentheses_map: Dict[int, int] = dict()
-    stack: List[int] = []
+    parentheses_map: dict[int, int] = dict()
+    stack: list[int] = []
     for index, char in enumerate(expr):
         if char == "(":
             stack.append(index)

classiq/qmod/native/pretty_printer.py

@@ -1,4 +1,5 @@
-from typing import Dict, List, Mapping, Optional, Union
+from collections.abc import Mapping
+from typing import Optional, Union
 
 from classiq.interface.generator.constant import Constant
 from classiq.interface.generator.expressions.expression import Expression
@@ -135,7 +136,7 @@ class DSLPrettyPrinter(Visitor):
     def visit_EnumDeclaration(self, enum_decl: EnumDeclaration) -> str:
         return f"enum {enum_decl.name} {{\n{self._visit_members(enum_decl.members)}}}\n"
 
-    def _visit_members(self, members: Dict[str, int]) -> str:
+    def _visit_members(self, members: dict[str, int]) -> str:
         self._level += 1
         members_str = "".join(
             f"{self._indent}{self.visit(member_name)} = {member_value};\n"
@@ -310,7 +311,7 @@ class DSLPrettyPrinter(Visitor):
     def visit_InplaceBinaryOperation(self, op: InplaceBinaryOperation) -> str:
         return f"{self._indent}{op.operation.value}({self.visit(op.value)}, {self.visit(op.target)});\n"
 
-    def _visit_pack_expr(self, vars: List[HandleBinding]) -> str:
+    def _visit_pack_expr(self, vars: list[HandleBinding]) -> str:
         if len(vars) == 1:
             return self.visit(vars[0])
 
@@ -324,7 +325,7 @@ class DSLPrettyPrinter(Visitor):
 
     def visit_QuantumLambdaFunction(self, qlambda: QuantumLambdaFunction) -> str:
         positional_args = ", ".join(
-            qlambda.get_rename_params()[idx]
+            qlambda.pos_rename_params[idx]
             for idx, arg_decl in enumerate(
                 qlambda.func_decl.positional_arg_declarations
             )
@@ -358,7 +359,7 @@ class DSLPrettyPrinter(Visitor):
     ) -> str:
         return f"{self._indent}{self.visit(amplitude_loading_op.result_var)} *= {self.visit(amplitude_loading_op.expression)};\n"
 
-    def _print_bind_handles(self, handles: List[HandleBinding]) -> str:
+    def _print_bind_handles(self, handles: list[HandleBinding]) -> str:
         if len(handles) == 1:
             return self.visit(handles[0])
 

classiq/qmod/pretty_print/__init__.py

@@ -1,9 +1,7 @@
-from typing import List
-
 from .pretty_printer import PythonPrettyPrinter
 
 __all__ = ["PythonPrettyPrinter"]
 
 
-def __dir__() -> List[str]:
+def __dir__() -> list[str]:
     return __all__

classiq/qmod/pretty_print/expression_to_python.py

@@ -1,7 +1,8 @@
 import ast
 import re
+from collections.abc import Mapping
 from dataclasses import dataclass
-from typing import Callable, Dict, List, Mapping, Type
+from typing import Callable
 
 import numpy as np
 
@@ -9,7 +10,7 @@ import classiq
 from classiq.qmod.utilities import DEFAULT_DECIMAL_PRECISION
 
 IDENTIFIER = re.compile(r"[a-zA-Z_]\w*")
-BINARY_OPS: Mapping[Type[ast.operator], str] = {
+BINARY_OPS: Mapping[type[ast.operator], str] = {
     ast.Add: "+",
     ast.Sub: "-",
     ast.Mult: "*",
@@ -22,14 +23,14 @@ BINARY_OPS: Mapping[Type[ast.operator], str] = {
     ast.LShift: "<<",
     ast.RShift: ">>",
 }
-BOOL_OPS: Mapping[Type[ast.boolop], str] = {ast.And: "and", ast.Or: "or"}
-UNARY_OPS: Mapping[Type[ast.unaryop], str] = {
+BOOL_OPS: Mapping[type[ast.boolop], str] = {ast.And: "and", ast.Or: "or"}
+UNARY_OPS: Mapping[type[ast.unaryop], str] = {
     ast.UAdd: "+",
     ast.USub: "-",
     ast.Invert: "~",
     ast.Not: "not",
 }
-COMPARE_OPS: Mapping[Type[ast.cmpop], str] = {
+COMPARE_OPS: Mapping[type[ast.cmpop], str] = {
     ast.Eq: "==",
     ast.NotEq: "!=",
     ast.Lt: "<",
@@ -43,8 +44,8 @@ LIST_FORMAT_CHAR_LIMIT = 20
 @dataclass
 class ASTToQMODCode(ast.NodeVisitor):
     level: int
-    imports: Dict[str, int]
-    symbolic_imports: Dict[str, int]
+    imports: dict[str, int]
+    symbolic_imports: dict[str, int]
     decimal_precision: int
     indent_seq: str = "    "
 
@@ -162,7 +163,7 @@ class ASTToQMODCode(ast.NodeVisitor):
     def generic_visit(self, node: ast.AST) -> None:
         raise AssertionError("Cannot parse node of type: " + type(node).__name__)
 
-    def indent_items(self, items: Callable[[], List[str]]) -> str:
+    def indent_items(self, items: Callable[[], list[str]]) -> str:
         should_indent = (
             len("".join([i.strip() for i in items()])) >= LIST_FORMAT_CHAR_LIMIT
         )
@@ -188,8 +189,8 @@ class ASTToQMODCode(ast.NodeVisitor):
 def _remove_redundant_parentheses(expr: str) -> str:
     if not (expr.startswith("(") and expr.endswith(")")):
         return expr
-    parentheses_map: Dict[int, int] = dict()
-    stack: List[int] = []
+    parentheses_map: dict[int, int] = dict()
+    stack: list[int] = []
     for index, char in enumerate(expr):
         if char == "(":
             stack.append(index)
@@ -208,8 +209,8 @@ def _remove_redundant_parentheses(expr: str) -> str:
 
 def transform_expression(
     expr: str,
-    imports: Dict[str, int],
-    symbolic_imports: Dict[str, int],
+    imports: dict[str, int],
+    symbolic_imports: dict[str, int],
     level: int = 0,
     decimal_precision: int = DEFAULT_DECIMAL_PRECISION,
 ) -> str:

classiq/qmod/pretty_print/pretty_printer.py

@@ -1,4 +1,5 @@
-from typing import Dict, List, Mapping, Optional, Tuple, Union, cast
+from collections.abc import Mapping
+from typing import Optional, Union, cast
 
 import black
 
@@ -88,20 +89,20 @@ class VariableDeclarationAssignment(Visitor):
     def __init__(self, pretty_printer: "PythonPrettyPrinter") -> None:
         self.pretty_printer = pretty_printer
 
-    def visit(self, node: NodeType) -> Tuple[str, Optional[List[str]]]:
+    def visit(self, node: NodeType) -> tuple[str, Optional[list[str]]]:
         res = super().visit(node)
         if not isinstance(res, tuple):
             raise AssertionError(f"Pretty printing for {type(node)} is not supported ")
         return res  # type: ignore[return-value]
 
-    def visit_QuantumBit(self, qtype: QuantumBit) -> Tuple[str, Optional[List[str]]]:
+    def visit_QuantumBit(self, qtype: QuantumBit) -> tuple[str, Optional[list[str]]]:
         self.pretty_printer._imports["QBit"] = 1
 
         return "QBit", None
 
     def visit_QuantumBitvector(
         self, qtype: QuantumBitvector
-    ) -> Tuple[str, Optional[List[str]]]:
+    ) -> tuple[str, Optional[list[str]]]:
         self.pretty_printer._imports["QArray"] = 1
 
         element_type = self.pretty_printer.visit(qtype.element_type)
@@ -111,7 +112,7 @@ class VariableDeclarationAssignment(Visitor):
 
     def visit_QuantumNumeric(
         self, qtype: QuantumNumeric
-    ) -> Tuple[str, Optional[List[str]]]:
+    ) -> tuple[str, Optional[list[str]]]:
         self.pretty_printer._imports["QNum"] = 1
 
         params = []
@@ -124,7 +125,7 @@ class VariableDeclarationAssignment(Visitor):
 
         return "QNum", params
 
-    def visit_TypeName(self, qtype: TypeName) -> Tuple[str, None]:
+    def visit_TypeName(self, qtype: TypeName) -> tuple[str, None]:
         return qtype.name, None
 
 
@@ -136,7 +137,7 @@ class PythonPrettyPrinter(Visitor):
         self._import_enum = False
         self._import_dataclass = False
         self._import_annotated = False
-        self._symbolic_imports: Dict[str, int] = dict()
+        self._symbolic_imports: dict[str, int] = dict()
         self._functions: Optional[Mapping[str, QuantumFunctionDeclaration]] = None
 
     def visit(self, node: NodeType) -> str:
@@ -183,7 +184,7 @@ class PythonPrettyPrinter(Visitor):
     def special_imports(self) -> str:
         imports = ""
         if self._import_annotated:
-            imports += "from typing_extensions import Annotated\n"
+            imports += "from typing import Annotated\n"
         if self._import_dataclass:
             imports += "from dataclasses import dataclass\n"
         if self._import_enum:
@@ -214,7 +215,7 @@ class PythonPrettyPrinter(Visitor):
         self._import_enum = True
         return f"class {enum_decl.name}(IntEnum):\n{self._visit_members(enum_decl.members)}\n"
 
-    def _visit_members(self, members: Dict[str, int]) -> str:
+    def _visit_members(self, members: dict[str, int]) -> str:
         self._level += 1
         members_str = "".join(
             f"{self._indent}{self.visit(member_name)} = {member_value}\n"
@@ -418,7 +419,7 @@ class PythonPrettyPrinter(Visitor):
         return f"{self._indent}invert({self._visit_body(invert.body)})\n"
 
     def _visit_body(
-        self, body: StatementBlock, operand_arguments: Optional[List[str]] = None
+        self, body: StatementBlock, operand_arguments: Optional[list[str]] = None
     ) -> str:
         if len(body) == 0:
             return "lambda: []"
@@ -454,7 +455,7 @@ class PythonPrettyPrinter(Visitor):
         )
 
     def visit_QuantumLambdaFunction(self, qlambda: QuantumLambdaFunction) -> str:
-        return self._visit_body(qlambda.body, qlambda.get_rename_params())
+        return self._visit_body(qlambda.body, qlambda.pos_rename_params)
 
     def visit_HandleBinding(self, var_ref: HandleBinding) -> str:
         return var_ref.name
@@ -482,7 +483,7 @@ class PythonPrettyPrinter(Visitor):
     ) -> str:
         return f"{self._indent}{self.visit(amplitude_loading_op.result_var)} *= {self.visit(amplitude_loading_op.expression)}\n"
 
-    def _print_bind_handles(self, handles: List[HandleBinding]) -> str:
+    def _print_bind_handles(self, handles: list[HandleBinding]) -> str:
         if len(handles) == 1:
             return self.visit(handles[0])
 

classiq/qmod/python_classical_type.py

@@ -26,6 +26,11 @@ if sys.version_info[0:2] >= (3, 9):
     pass
 from classiq.interface.generator.functions.concrete_types import ConcreteClassicalType
 
+CARRAY_ERROR_MESSAGE = (
+    "CArray accepts one or two generic parameters in the form "
+    "`CArray[<element-type>]` or `CArray[<element-type>, <size>]`"
+)
+
 
 class PythonClassicalType:
     def convert(self, py_type: type) -> Optional[ConcreteClassicalType]:
@@ -48,16 +53,15 @@ class PythonClassicalType:
                     element_type=self.convert(array_args[0]),
                     size=get_type_hint_expr(array_args[1]),
                 )
-            raise ClassiqValueError(
-                "CArray accepts one or two generic parameters in the form "
-                "`CArray[<element-type>]` or `CArray[<element-type>, <size>]`"
-            )
+            raise ClassiqValueError(CARRAY_ERROR_MESSAGE)
         elif inspect.isclass(py_type) and dataclasses.is_dataclass(py_type):
             self.register_struct(py_type)
             return Struct(name=py_type.__name__)
         elif inspect.isclass(py_type) and isinstance(py_type, EnumMeta):
             self.register_enum(py_type)
             return Enum(name=py_type.__name__)
+        elif py_type in (CArray, list):
+            raise ClassiqValueError(CARRAY_ERROR_MESSAGE)
         return None
 
     def register_struct(self, py_type: type) -> None:

classiq/qmod/qfunc.py

@@ -1,14 +1,14 @@
-from typing import Callable, List, Literal, Optional, Union, overload
+from typing import Callable, Literal, Optional, Union, overload
 
 from classiq.qmod.quantum_callable import QCallable
 from classiq.qmod.quantum_function import ExternalQFunc, GenerativeQFunc, QFunc
 
-GEN_QFUNCS: List[GenerativeQFunc] = []
-DEC_QFUNCS: List[QFunc] = []
+GEN_QFUNCS: list[GenerativeQFunc] = []
+DEC_QFUNCS: list[QFunc] = []
 
 
 def set_discovered_functions(
-    dec_funcs: List[QFunc], gen_funcs: List[GenerativeQFunc]
+    dec_funcs: list[QFunc], gen_funcs: list[GenerativeQFunc]
 ) -> None:
     DEC_QFUNCS.clear()
     DEC_QFUNCS.extend(dec_funcs)