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

classiq/qmod/quantum_expandable.py

@@ -1,20 +1,19 @@
 import inspect
 from abc import ABC
-from collections.abc import Generator, Iterable
+from collections.abc import Callable, Generator, Iterable
 from dataclasses import is_dataclass
 from enum import Enum as PythonEnum
 from types import TracebackType
 from typing import (
     TYPE_CHECKING,
     Any,
-    Callable,
     ClassVar,
-    Optional,
     Union,
     cast,
     overload,
 )
 
+import numpy as np
 import pydantic
 from sympy import Basic
 from typing_extensions import Self
@@ -55,7 +54,11 @@ from classiq.interface.model.variable_declaration_statement import (
 )
 from classiq.interface.source_reference import SourceReference
 
-from classiq.qmod.generative import generative_mode_context, is_generative_mode
+from classiq.qmod.generative import (
+    generative_mode_context,
+    interpret_expression,
+    is_generative_mode,
+)
 from classiq.qmod.global_declarative_switch import get_global_declarative_switch
 from classiq.qmod.model_state_container import QMODULE, ModelStateContainer
 from classiq.qmod.qmod_constant import QConstant
@@ -106,9 +109,9 @@ class QExpandable(QCallable, QExpandableInterface, ABC):
 
     def __exit__(
         self,
-        exc_type: Optional[type[BaseException]],
-        exc_val: Optional[BaseException],
-        exc_tb: Optional[TracebackType],
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
     ) -> None:
         assert QExpandable.STACK.pop() is self
         QCallable.CURRENT_EXPANDABLE = (
@@ -124,14 +127,14 @@ class QExpandable(QCallable, QExpandableInterface, ABC):
             with self, generative_mode_context(False):
                 self._py_callable(*self._get_positional_args())
 
-    def infer_rename_params(self) -> Optional[list[str]]:
+    def infer_rename_params(self) -> list[str] | None:
         return None
 
     def add_local_handle(
         self,
         name: str,
         qtype: QuantumType,
-        source_ref: Optional[SourceReference] = None,
+        source_ref: SourceReference | None = None,
     ) -> None:
         self.append_statement_to_body(
             VariableDeclarationStatement(
@@ -218,8 +221,8 @@ class QTerminalCallable(QCallable):
     def __init__(
         self,
         decl: QuantumFunctionDeclaration,
-        param_idx: Optional[int] = None,
-        index_: Optional[Union[int, CParamScalar]] = None,
+        param_idx: int | None = None,
+        index_: int | CParamScalar | None = None,
     ) -> None:
         pass
 
@@ -228,22 +231,22 @@ class QTerminalCallable(QCallable):
         self,
         decl: AnonQuantumFunctionDeclaration,
         param_idx: int,
-        index_: Optional[Union[int, CParamScalar]] = None,
+        index_: int | CParamScalar | None = None,
     ) -> None:
         pass
 
     def __init__(
         self,
         decl: AnonQuantumFunctionDeclaration,
-        param_idx: Optional[int] = None,
-        index_: Optional[Union[int, CParamScalar]] = None,
+        param_idx: int | None = None,
+        index_: int | CParamScalar | None = None,
     ) -> None:
         self._decl = self._override_decl_name(decl, param_idx)
         self._index = index_
 
     @staticmethod
     def _override_decl_name(
-        decl: AnonQuantumFunctionDeclaration, param_idx: Optional[int]
+        decl: AnonQuantumFunctionDeclaration, param_idx: int | None
     ) -> QuantumFunctionDeclaration:
         if (
             not isinstance(QCallable.CURRENT_EXPANDABLE, QLambdaFunction)
@@ -259,7 +262,7 @@ class QTerminalCallable(QCallable):
             isinstance(self._decl, AnonQuantumOperandDeclaration) and self._decl.is_list
         )
 
-    def __getitem__(self, key: Union[slice, int, CInt]) -> "QTerminalCallable":
+    def __getitem__(self, key: slice | int | CInt) -> "QTerminalCallable":
         if not self.is_list:
             raise ClassiqValueError("Cannot index a non-list operand")
         if isinstance(key, slice):
@@ -286,6 +289,9 @@ class QTerminalCallable(QCallable):
         def len(self) -> CParamScalar:
             if not self.is_list:
                 raise ClassiqValueError("Cannot get length of a non-list operand")
+            if is_generative_mode():
+                with generative_mode_context(False):
+                    return interpret_expression(str(self.len))
             return CParamScalar(f"{self.func_decl.name}.len")
 
     @property
@@ -314,25 +320,25 @@ class QTerminalCallable(QCallable):
 @overload
 def prepare_arg(
     arg_decl: AnonPositionalArg,
-    val: Union[QCallable, Callable[..., None]],
-    func_name: Optional[str],
+    val: QCallable | Callable[..., None],
+    func_name: str | None,
     param_name: str,
 ) -> QuantumLambdaFunction: ...
 
 
 @overload
 def prepare_arg(
-    arg_decl: AnonPositionalArg, val: Any, func_name: Optional[str], param_name: str
+    arg_decl: AnonPositionalArg, val: Any, func_name: str | None, param_name: str
 ) -> ArgValue: ...
 
 
 def prepare_arg(
-    arg_decl: AnonPositionalArg, val: Any, func_name: Optional[str], param_name: str
+    arg_decl: AnonPositionalArg, val: Any, func_name: str | None, param_name: str
 ) -> ArgValue:
     from classiq.qmod.quantum_function import BaseQFunc, GenerativeQFunc, QFunc
 
     if get_global_declarative_switch() and isinstance(val, GenerativeQFunc):
-        val = QFunc(val._py_callable)
+        val = QFunc(val._py_callable, permutation=val.permutation)
     if isinstance(val, BaseQFunc):
         val.add_function_dependencies()
     if isinstance(val, GenerativeQFunc):
@@ -390,7 +396,7 @@ def prepare_arg(
 
 
 def _validate_classical_arg(
-    arg: Any, arg_decl: AnonClassicalParameterDeclaration, func_name: Optional[str]
+    arg: Any, arg_decl: AnonClassicalParameterDeclaration, func_name: str | None
 ) -> None:
     is_native_or_compatible_type = (
         not isinstance(
@@ -400,6 +406,7 @@ def _validate_classical_arg(
         and not _is_legal_iterable(arg)
         and not is_dataclass(arg)  # type: ignore[unreachable]
         and not isinstance(arg, QmodStructInstance)
+        and not np.isscalar(arg)
     )
     try:
         is_pydantic_classical_type = isinstance(
@@ -502,8 +509,8 @@ def _validate_argument_names(
 
 def _create_quantum_function_call(
     decl_: QuantumFunctionDeclaration,
-    index_: Optional[Union[CParamScalar, int]] = None,
-    source_ref_: Optional[SourceReference] = None,
+    index_: CParamScalar | int | None = None,
+    source_ref_: SourceReference | None = None,
     *args: Any,
     **kwargs: Any,
 ) -> QuantumFunctionCall:
@@ -511,7 +518,7 @@ def _create_quantum_function_call(
     _validate_argument_names(decl_, arg_list, kwargs)
     prepared_args = _prepare_args(decl_, arg_list, kwargs)
 
-    function_ident: Union[str, OperandIdentifier] = decl_.name
+    function_ident: str | OperandIdentifier = decl_.name
     if index_ is not None:
         function_ident = OperandIdentifier(
             index=Expression(expr=str(index_)), name=function_ident
@@ -539,7 +546,7 @@ def _is_legal_iterable_element(arg: Any) -> bool:
     return True
 
 
-def _try_preparing_handles_list(val: Any) -> Optional[HandlesList]:
+def _try_preparing_handles_list(val: Any) -> HandlesList | None:
     if not isinstance(val, list):
         return None
     items = [

classiq/qmod/quantum_function.py

@@ -2,10 +2,11 @@ import ast
 import functools
 import warnings
 from abc import abstractmethod
+from collections.abc import Callable
 from dataclasses import is_dataclass
 from enum import EnumMeta
 from inspect import isclass
-from typing import Any, Callable, Optional, get_origin
+from typing import Any, get_origin
 
 from classiq.interface.exceptions import ClassiqDeprecationWarning, ClassiqError
 from classiq.interface.executor.execution_preferences import ExecutionPreferences
@@ -30,7 +31,7 @@ from classiq.qmod.generative import set_frontend_interpreter
 from classiq.qmod.global_declarative_switch import get_global_declarative_switch
 from classiq.qmod.qmod_constant import QConstant
 from classiq.qmod.qmod_parameter import CArray, CParamList
-from classiq.qmod.quantum_callable import QCallable, QCallableList
+from classiq.qmod.quantum_callable import QCallable, QCallableList, QPerm, QPermList
 from classiq.qmod.quantum_expandable import QExpandable, QTerminalCallable
 from classiq.qmod.semantics.annotation.qstruct_annotator import QStructAnnotator
 from classiq.qmod.semantics.validation.main_validation import validate_main_function
@@ -41,11 +42,13 @@ class BaseQFunc(QExpandable):
     def __init__(
         self,
         py_callable: Callable,
-        compilation_metadata: Optional[CompilationMetadata] = None,
+        compilation_metadata: CompilationMetadata | None = None,
+        permutation: bool = False,
     ) -> None:
         super().__init__(py_callable)
         functools.update_wrapper(self, py_callable)
         self.compilation_metadata = compilation_metadata
+        self.permutation = permutation
 
     @property
     def func_decl(self) -> NamedParamsQuantumFunctionDeclaration:
@@ -84,10 +87,10 @@ class BaseQFunc(QExpandable):
     @abstractmethod
     def create_model(
         self,
-        constraints: Optional[Constraints] = None,
-        execution_preferences: Optional[ExecutionPreferences] = None,
-        preferences: Optional[Preferences] = None,
-        classical_execution_function: Optional[CFunc] = None,
+        constraints: Constraints | None = None,
+        execution_preferences: ExecutionPreferences | None = None,
+        preferences: Preferences | None = None,
+        classical_execution_function: CFunc | None = None,
     ) -> Model:
         pass
 
@@ -98,13 +101,17 @@ class QFunc(BaseQFunc):
     def __init__(
         self,
         py_callable: Callable,
-        compilation_metadata: Optional[CompilationMetadata] = None,
+        compilation_metadata: CompilationMetadata | None = None,
+        permutation: bool = False,
     ) -> None:
         _validate_no_gen_params(py_callable.__annotations__)
-        super().__init__(py_callable, compilation_metadata)
-        if compilation_metadata is not None and compilation_metadata.unchecked:
-            self.compilation_metadata: Optional[CompilationMetadata] = (
-                CompilationMetadata(unchecked=compilation_metadata.unchecked)
+        super().__init__(py_callable, compilation_metadata, permutation)
+        if (
+            compilation_metadata is not None
+            and compilation_metadata.has_user_directives
+        ):
+            self.compilation_metadata: CompilationMetadata | None = (
+                compilation_metadata.copy_user_directives()
             )
         else:
             self.compilation_metadata = None
@@ -114,7 +121,9 @@ class QFunc(BaseQFunc):
         name = self._py_callable.__name__
         if name in self._qmodule.native_defs:
             return self._qmodule.native_defs[name]
-        return infer_func_decl(self._py_callable, qmodule=self._qmodule)
+        return infer_func_decl(
+            self._py_callable, qmodule=self._qmodule, permutation=self.permutation
+        )
 
     def __call__(self, *args: Any, **kwargs: Any) -> None:
         self.expand()
@@ -122,10 +131,10 @@ class QFunc(BaseQFunc):
 
     def create_model(
         self,
-        constraints: Optional[Constraints] = None,
-        execution_preferences: Optional[ExecutionPreferences] = None,
-        preferences: Optional[Preferences] = None,
-        classical_execution_function: Optional[CFunc] = None,
+        constraints: Constraints | None = None,
+        execution_preferences: ExecutionPreferences | None = None,
+        preferences: Preferences | None = None,
+        classical_execution_function: CFunc | None = None,
     ) -> Model:
         self._qmodule.reset()
         QConstant.set_current_model(self._qmodule)
@@ -222,9 +231,10 @@ class ExternalQFunc(QTerminalCallable):
     FRAME_DEPTH = 2  # FIXME: Remove (CLS-2912)
     _decl: NamedParamsQuantumFunctionDeclaration
 
-    def __init__(self, py_callable: Callable) -> None:
+    def __init__(self, py_callable: Callable, permutation: bool = False) -> None:
         self._py_callable = py_callable
-        decl = infer_func_decl(py_callable)
+        self.permutation = permutation
+        decl = infer_func_decl(py_callable, permutation=permutation)
 
         py_callable.__annotations__.pop("return", None)
         if py_callable.__annotations__.keys() != {
@@ -289,41 +299,48 @@ class GenerativeQFunc(BaseQFunc):
     def __init__(
         self,
         py_callable: Callable,
-        func_decl: Optional[NamedParamsQuantumFunctionDeclaration] = None,
-        compilation_metadata: Optional[CompilationMetadata] = None,
+        func_decl: NamedParamsQuantumFunctionDeclaration | None = None,
+        compilation_metadata: CompilationMetadata | None = None,
+        permutation: bool = False,
     ) -> None:
-        super().__init__(py_callable, compilation_metadata)
+        super().__init__(py_callable, compilation_metadata, permutation)
         self._func_decl = func_decl
-        self._inferred_func_decl: Optional[NamedParamsQuantumFunctionDeclaration] = None
+        self._inferred_func_decl: NamedParamsQuantumFunctionDeclaration | None = None
 
     @property
     def func_decl(self) -> NamedParamsQuantumFunctionDeclaration:
         if self._func_decl is not None:
             return self._func_decl
         if self._inferred_func_decl is None:
-            self._inferred_func_decl = infer_func_decl(self._py_callable, self._qmodule)
+            self._inferred_func_decl = infer_func_decl(
+                self._py_callable, self._qmodule, permutation=self.permutation
+            )
         return self._inferred_func_decl
 
     def __call__(self, *args: Any, **kwargs: Any) -> None:
         if get_global_declarative_switch():
-            return QFunc(self._py_callable, self.compilation_metadata)(*args, **kwargs)
+            return QFunc(
+                self._py_callable,
+                self.compilation_metadata,
+                permutation=self.permutation,
+            )(*args, **kwargs)
         if self.func_decl.name not in self._qmodule.generative_functions:
             self._qmodule.generative_functions[self.func_decl.name] = self
             if self._func_decl is None:
                 self._inferred_func_decl = infer_func_decl(
-                    self._py_callable, self._qmodule
+                    self._py_callable, self._qmodule, permutation=self.permutation
                 )
         super().__call__(*args, **kwargs)
 
     def create_model(
         self,
-        constraints: Optional[Constraints] = None,
-        execution_preferences: Optional[ExecutionPreferences] = None,
-        preferences: Optional[Preferences] = None,
-        classical_execution_function: Optional[CFunc] = None,
+        constraints: Constraints | None = None,
+        execution_preferences: ExecutionPreferences | None = None,
+        preferences: Preferences | None = None,
+        classical_execution_function: CFunc | None = None,
     ) -> Model:
         if get_global_declarative_switch():
-            return QFunc(self._py_callable).create_model(
+            return QFunc(self._py_callable, permutation=self.permutation).create_model(
                 constraints,
                 execution_preferences,
                 preferences,
@@ -338,7 +355,7 @@ class GenerativeQFunc(BaseQFunc):
 
         _dec_main.__annotations__ = self._py_callable.__annotations__
 
-        return QFunc(_dec_main).create_model(
+        return QFunc(_dec_main, permutation=self.permutation).create_model(
             constraints=constraints,
             execution_preferences=execution_preferences,
             preferences=preferences,
@@ -371,6 +388,8 @@ def _validate_no_gen_params(annotations: dict[str, Any]) -> None:
             or get_origin(annotation) is CArray
             or (get_origin(annotation) or annotation) is QCallable
             or (get_origin(annotation) or annotation) is QCallableList
+            or (get_origin(annotation) or annotation) is QPerm
+            or (get_origin(annotation) or annotation) is QPermList
             or is_qvar(annotation)
         )
     }

classiq/qmod/semantics/annotation/call_annotation.py

@@ -1,6 +1,6 @@
 from collections.abc import Iterator, Mapping
 from contextlib import contextmanager
-from typing import Any, Optional
+from typing import Any
 
 from classiq.interface.exceptions import ClassiqError
 from classiq.interface.model.model import Model
@@ -81,7 +81,7 @@ class _CallLambdaAnnotator(ModelVisitor):
 
 def resolve_function_calls(
     root: Any,
-    quantum_function_dict: Optional[Mapping[str, QuantumFunctionDeclaration]] = None,
+    quantum_function_dict: Mapping[str, QuantumFunctionDeclaration] | None = None,
     annotate_types: bool = True,
 ) -> None:
     if quantum_function_dict is None:

classiq/qmod/semantics/error_manager.py

@@ -1,6 +1,5 @@
 from collections.abc import Iterator
 from contextlib import contextmanager
-from typing import Optional
 
 from classiq.interface.ast_node import ASTNode
 from classiq.interface.exceptions import CLASSIQ_SLACK_COMMUNITY_LINK
@@ -24,7 +23,7 @@ class ErrorManager:
         self._ignore_errors: bool = False
 
     @property
-    def _current_source_ref(self) -> Optional[SourceReference]:
+    def _current_source_ref(self) -> SourceReference | None:
         if self._current_nodes_stack:
             return self._current_nodes_stack[-1].source_ref
         return None
@@ -50,8 +49,8 @@ class ErrorManager:
         self,
         error: str,
         *,
-        source_ref: Optional[SourceReference] = None,
-        function: Optional[str] = None,
+        source_ref: SourceReference | None = None,
+        function: str | None = None,
         warning: bool = False,
     ) -> None:
         if self._ignore_errors:
@@ -93,7 +92,7 @@ class ErrorManager:
         return len(self._warnings) > 0
 
     def report_errors(
-        self, error_type: type[Exception], mask: Optional[list[int]] = None
+        self, error_type: type[Exception], mask: list[int] | None = None
     ) -> None:
         if self.has_errors():
             errors = (
@@ -105,7 +104,7 @@ class ErrorManager:
             raise error_type("\n\t" + "\n\t".join(errors))
 
     @property
-    def current_function(self) -> Optional[str]:
+    def current_function(self) -> str | None:
         return self._call_stack[-1] if self._call_stack else None
 
     @contextmanager

classiq/qmod/semantics/lambdas.py

@@ -1,4 +1,3 @@
-from classiq.interface.helpers.backward_compatibility import zip_strict
 from classiq.interface.model.port_declaration import PortDeclaration
 from classiq.interface.model.quantum_function_declaration import (
     AnonQuantumOperandDeclaration,
@@ -15,7 +14,7 @@ def get_renamed_parameters(
     renamed_parameters: list[str] = []
     renamed_operands: dict[str, QuantumOperandDeclaration] = {}
     renamed_ports: list[PortDeclaration] = []
-    for param, param_name in zip_strict(
+    for param, param_name in zip(
         lambda_func.func_decl.positional_arg_declarations,
         lambda_func.pos_rename_params,
         strict=False,

classiq/qmod/semantics/validation/types_validation.py

@@ -1,5 +1,4 @@
 from collections.abc import Sequence
-from typing import Union
 
 from classiq.interface.exceptions import ClassiqExpansionError
 from classiq.interface.generator.functions.type_name import TypeName
@@ -16,7 +15,7 @@ TYPE_EXISTS_ERROR_MESSAGE = "Type {!r} already exists"
 
 
 def check_duplicate_types(
-    types: Sequence[Union[EnumDeclaration, StructDeclaration, QStructDeclaration]],
+    types: Sequence[EnumDeclaration | StructDeclaration | QStructDeclaration],
 ) -> None:
     known_types = {type_.name for type_ in BUILTIN_ENUM_DECLARATIONS.values()}
     known_types |= {type_.name for type_ in BUILTIN_STRUCT_DECLARATIONS.values()}

classiq/qmod/symbolic.py

@@ -2,9 +2,7 @@ import sys
 from typing import (
     TYPE_CHECKING,
     Any,
-    Optional,
     TypeVar,
-    Union,
     overload,
 )
 
@@ -52,7 +50,7 @@ def symbolic_function(*args: Any, return_type: None = None) -> CParamScalar: ...
 def symbolic_function(*args: Any, return_type: type[T]) -> T: ...
 
 
-def symbolic_function(*args: Any, return_type: Optional[type[T]] = None) -> CParam:
+def symbolic_function(*args: Any, return_type: type[T] | None = None) -> CParam:
     qmodule = (
         model_state_container.QMODULE
     )  # FIXME: https://classiq.atlassian.net/browse/CAD-15126
@@ -321,7 +319,7 @@ def _subscript_to_str(index: Any) -> str:
 
 
 def subscript(
-    array: Union[list, CArray[CReal], np.ndarray],
+    array: list | CArray[CReal] | np.ndarray,
     index: Any,
 ) -> CParamScalar:
     return CParamScalar(

classiq/qmod/symbolic_expr.py

@@ -6,6 +6,8 @@ from typing import Any
 
 import sympy
 
+from classiq.interface.exceptions import ClassiqTypeError
+
 from classiq.qmod.utilities import qmod_val_to_expr_str
 
 
@@ -24,7 +26,7 @@ class Symbolic:
         try:
             return bool(ast.literal_eval(self._expr))
         except ValueError:
-            raise TypeError(
+            raise ClassiqTypeError(
                 f"Symbolic expression {self._expr!r} cannot be converted to bool"
             ) from None
 
@@ -38,12 +40,16 @@ class SymbolicExpr(Symbolic):
         if not isinstance(
             lhs, (SymbolicExpr, int, float, bool, PythonEnum, sympy.Basic)
         ):
-            raise TypeError(f"Invalid lhs argument {lhs!r} for binary operation {op!r}")
+            raise ClassiqTypeError(
+                f"Invalid lhs argument {lhs!r} for binary operation {op!r}"
+            )
 
         if not isinstance(
             rhs, (SymbolicExpr, int, float, bool, PythonEnum, sympy.Basic)
         ):
-            raise TypeError(f"Invalid lhs argument {rhs!r} for binary operation {op!r}")
+            raise ClassiqTypeError(
+                f"Invalid lhs argument {rhs!r} for binary operation {op!r}"
+            )
 
         lhs_str = qmod_val_to_expr_str(lhs)
         if not isinstance(lhs, (int, float, bool, PythonEnum)):
@@ -62,7 +68,9 @@ class SymbolicExpr(Symbolic):
     @staticmethod
     def _unary_op(arg: Any, op: str) -> SymbolicExpr:
         if not isinstance(arg, (SymbolicExpr, int, float, bool)):
-            raise TypeError(f"Invalid argument {arg!r} for unary operation {op!r}")
+            raise ClassiqTypeError(
+                f"Invalid argument {arg!r} for unary operation {op!r}"
+            )
 
         arg_is_quantum = isinstance(arg, SymbolicExpr) and arg.is_quantum
 

classiq/qmod/utilities.py

@@ -4,16 +4,14 @@ import itertools
 import keyword
 import sys
 from collections import Counter
-from collections.abc import Iterable
+from collections.abc import Callable, Iterable
 from enum import Enum as PythonEnum
 from types import FrameType
 from typing import (
     TYPE_CHECKING,
     Any,
-    Callable,
     ForwardRef,
     Literal,
-    Optional,
     Union,
     get_args,
     get_origin,
@@ -49,7 +47,7 @@ def unmangle_keyword(name: None) -> None:
     pass
 
 
-def unmangle_keyword(name: Optional[str]) -> Optional[str]:
+def unmangle_keyword(name: str | None) -> str | None:
     if name is None:
         return None
     if name[-1] == "_" and keyword.iskeyword(name[:-1]):
@@ -60,10 +58,7 @@ def unmangle_keyword(name: Optional[str]) -> Optional[str]:
 def version_portable_get_args(py_type: type) -> tuple:
     if get_origin(py_type) is None:
         return tuple()
-    if sys.version_info[0:2] < (3, 10):
-        type_args = get_args(py_type)  # The result of __class_getitem__
-    else:
-        type_args = get_args(py_type)[0]
+    type_args = get_args(py_type)[0]
     if not isinstance(type_args, tuple):
         return (type_args,)
     return tuple(
@@ -76,6 +71,12 @@ def version_portable_get_args(py_type: type) -> tuple:
     )
 
 
+def type_to_str(py_type: Any) -> str:
+    if isinstance(py_type, type):
+        return py_type.__name__
+    return str(py_type)
+
+
 def get_source_ref(frame: FrameType) -> SourceReference:
     filename = inspect.getfile(frame)
     lineno = frame.f_lineno
@@ -101,6 +102,8 @@ def get_source_ref(frame: FrameType) -> SourceReference:
 
 
 def qmod_val_to_expr_str(val: Any) -> str:
+    from classiq.qmod.qmod_parameter import CParamList
+
     if isinstance(val, sympy.Basic):
         return str(val)
 
@@ -122,7 +125,7 @@ def qmod_val_to_expr_str(val: Any) -> str:
         )
         return f"struct_literal({val.struct_declaration.name}, {kwargs_str})"
 
-    if isinstance(val, Iterable):
+    if isinstance(val, Iterable) and not isinstance(val, CParamList):
         elements_str = ", ".join([qmod_val_to_expr_str(elem) for elem in val])
         return f"[{elements_str}]"
 
@@ -138,7 +141,7 @@ def unwrap_forward_ref(x: Any) -> Any:
     return x
 
 
-def varname(depth: int) -> Optional[str]:
+def varname(depth: int) -> str | None:
     frame = sys._getframe(depth)
     codes = inspect.getframeinfo(frame).code_context
     if codes is None or len(codes) != 1:

classiq/qmod/write_qmod.py

@@ -1,6 +1,5 @@
 import json
 from pathlib import Path
-from typing import Optional, Union
 
 from classiq.interface.constants import DEFAULT_DECIMAL_PRECISION
 from classiq.interface.model.model import Model, SerializedModel
@@ -14,9 +13,9 @@ _SYNTHESIS_OPTIONS_SUFFIX = "synthesis_options.json"
 
 
 def write_qmod(
-    model: Union[SerializedModel, QFunc, GenerativeQFunc],
+    model: SerializedModel | QFunc | GenerativeQFunc,
     name: str,
-    directory: Optional[Path] = None,
+    directory: Path | None = None,
     decimal_precision: int = DEFAULT_DECIMAL_PRECISION,
     symbolic_only: bool = True,
 ) -> None:
@@ -58,7 +57,7 @@ def write_qmod(
 
 
 def prepare_write_qmod_model(
-    model: Union[SerializedModel, QFunc, GenerativeQFunc], symbolic_only: bool
+    model: SerializedModel | QFunc | GenerativeQFunc, symbolic_only: bool
 ) -> Model:
     if isinstance(model, str) and hasattr(model, "entry_point") and symbolic_only:
         model_obj = Model.model_validate_json(model)

classiq/quantum_program.py

@@ -1,5 +1,3 @@
-from typing import Optional
-
 from classiq.interface.executor.quantum_program_params import (
     ParameterAssignmentsParams,
     TranspilationParams,
@@ -19,7 +17,7 @@ async def transpile_async(params: TranspilationParams) -> QuantumProgram:
 
 
 def transpile(
-    quantum_program: QuantumProgram, preferences: Optional[Preferences] = None
+    quantum_program: QuantumProgram, preferences: Preferences | None = None
 ) -> QuantumProgram:
     """
     Transpiles a quantum program.