classiq 0.38.0__py3-none-any.whl → 0.65.3__py3-none-any.whl

classiq/interface/generator/circuit_code/types_and_constants.py

@@ -1,22 +1,19 @@
-from typing import Dict, Tuple
-
 from typing_extensions import TypeAlias
 
+from classiq.interface.enum_utils import StrEnum
 from classiq.interface.executor.quantum_instruction_set import QuantumInstructionSet
 from classiq.interface.generator.model.preferences.preferences import QuantumFormat
 from classiq.interface.hardware import Provider
 
-from classiq._internals.enum_utils import StrEnum
-
 Code: TypeAlias = str
-CodeAndSyntax: TypeAlias = Tuple[Code, QuantumInstructionSet]
+CodeAndSyntax: TypeAlias = tuple[Code, QuantumInstructionSet]
 
-INSTRUCTION_SET_TO_FORMAT: Dict[QuantumInstructionSet, QuantumFormat] = {
+INSTRUCTION_SET_TO_FORMAT: dict[QuantumInstructionSet, QuantumFormat] = {
     QuantumInstructionSet.QASM: QuantumFormat.QASM,
     QuantumInstructionSet.QSHARP: QuantumFormat.QSHARP,
     QuantumInstructionSet.IONQ: QuantumFormat.IONQ,
 }
-VENDOR_TO_INSTRUCTION_SET: Dict[Provider, QuantumInstructionSet] = {
+VENDOR_TO_INSTRUCTION_SET: dict[Provider, QuantumInstructionSet] = {
     Provider.CLASSIQ: QuantumInstructionSet.QASM,
     Provider.IONQ: QuantumInstructionSet.IONQ,
     Provider.AZURE_QUANTUM: QuantumInstructionSet.QSHARP,

classiq/interface/generator/commuting_pauli_exponentiation.py

@@ -2,15 +2,14 @@ import pydantic
 
 from classiq.interface.chemistry import operator
 from classiq.interface.chemistry.operator import PauliOperator
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.arith.register_user_input import RegisterUserInput
 from classiq.interface.generator.function_params import (
     DEFAULT_INPUT_NAME,
     DEFAULT_OUTPUT_NAME,
     FunctionParams,
+    FunctionParamsNumericParameter,
 )
-from classiq.interface.generator.parameters import ParameterFloatType
-
-from classiq.exceptions import ClassiqValueError
 
 
 class CommutingPauliExponentiation(FunctionParams):
@@ -21,17 +20,18 @@ class CommutingPauliExponentiation(FunctionParams):
     pauli_operator: PauliOperator = pydantic.Field(
         description="A weighted sum of Pauli strings."
     )
-    evolution_coefficient: ParameterFloatType = pydantic.Field(
+    evolution_coefficient: FunctionParamsNumericParameter = pydantic.Field(
         default=1.0,
         description="A global coefficient multiplying the operator.",
-        is_exec_param=True,
     )
 
-    @pydantic.validator("pauli_operator")
+    @pydantic.field_validator("pauli_operator")
+    @classmethod
     def _validate_is_hermitian(cls, pauli_operator: PauliOperator) -> PauliOperator:
         return operator.validate_operator_is_hermitian(pauli_operator)
 
-    @pydantic.validator("pauli_operator")
+    @pydantic.field_validator("pauli_operator")
+    @classmethod
     def _validate_paulis_commute(cls, pauli_operator: PauliOperator) -> PauliOperator:
         if not pauli_operator.is_commutative:
             raise ClassiqValueError("Pauli strings are not commutative")

classiq/interface/generator/compiler_keywords.py

@@ -1,4 +1,8 @@
 EXPANDED_KEYWORD = "expanded__"
 CAPTURE_SUFFIX = "_captured__"
 LAMBDA_KEYWORD = "lambda__"
-GENERAL_INPLACE_ARITHMETIC_AUXILIARY_VARIABLE = "result__temp__"
+INPLACE_ARITH_AUX_VAR_PREFIX = "result__temp__"
+
+
+def generate_original_function_name(name: str) -> str:
+    return name.split(f"_{EXPANDED_KEYWORD}")[0]

classiq/interface/generator/complex_type.py

@@ -1,23 +1,18 @@
-from typing import Any, Callable, Dict, Iterator
+from typing import Annotated, Union
 
-from typing_extensions import Self
+from pydantic import PlainSerializer, PlainValidator
+from pydantic.json_schema import WithJsonSchema
 
 
-# Use this class as a type for complex data from the json, e.g., in the state_propagator function.
-class Complex(complex):
-    @classmethod
-    def __get_validators__(cls) -> Iterator[Callable]:
-        yield cls.validate
+def validate_complex(v: Union[complex, str]) -> complex:
+    if isinstance(v, str):
+        v = "".join(v.split())
+    return complex(v)
 
-    @classmethod
-    def __modify_schema__(cls, field_schema: Dict[str, Any]) -> None:
-        field_schema.update(
-            pattern=r"[+-]?\d+\.?\d* *[+-] *\d+\.?\d*j",
-        )
 
-    @classmethod
-    def validate(cls, v: Any) -> Self:
-        if isinstance(v, str):
-            v = "".join(v.split())
-
-        return cls(v)
+Complex = Annotated[
+    complex,
+    PlainValidator(validate_complex),
+    PlainSerializer(lambda x: str(x)),
+    WithJsonSchema({"type": "string", "pattern": r"[+-]?\d+\.?\d* *[+-] *\d+\.?\d*j"}),
+]

classiq/interface/generator/constant.py

@@ -1,10 +1,9 @@
-import pydantic
-
+from classiq.interface.ast_node import ASTNode
 from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.generator.functions.classical_type import ConcreteClassicalType
+from classiq.interface.generator.functions.concrete_types import ConcreteClassicalType
 
 
-class Constant(pydantic.BaseModel):
+class Constant(ASTNode):
     name: str
     const_type: ConcreteClassicalType
     value: Expression

classiq/interface/generator/control_state.py

@@ -1,14 +1,13 @@
 from __future__ import annotations
 
-from typing import Any, Dict
+from typing import Any
 
 import pydantic
-from pydantic import BaseModel
+from pydantic import BaseModel, ConfigDict
 
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.arith.register_user_input import RegisterUserInput
 
-from classiq.exceptions import ClassiqValueError
-
 _DEFAULT_CONTROL_NAME: str = "ctrl"
 _DEFAULT_NUM_CONTROL_QUBITS = 1
 _INVALID_CONTROL_STATE = "invalid_control_state"
@@ -19,45 +18,52 @@ class ControlState(BaseModel):
         default=_DEFAULT_NUM_CONTROL_QUBITS, description="Number of control qubits"
     )
     ctrl_state: str = pydantic.Field(
-        default=_INVALID_CONTROL_STATE, description="Control state string"
+        default=_INVALID_CONTROL_STATE,
+        description="Control state string",
+        validate_default=True,
+    )
+    name: str = pydantic.Field(
+        default=_DEFAULT_CONTROL_NAME, description="Control name"
     )
-    name: str = pydantic.Field(default=None, description="Control name")
 
-    @pydantic.root_validator()
-    def _validate_control(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        num_ctrl_qubits: int = values.get(
-            "num_ctrl_qubits", _DEFAULT_NUM_CONTROL_QUBITS
-        )
-        ctrl_state: str = values.get("ctrl_state", _INVALID_CONTROL_STATE)
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def _validate_control(cls, values: Any) -> dict[str, Any]:
+        if isinstance(values, dict):
+            num_ctrl_qubits: int = (
+                values.get("num_ctrl_qubits", _DEFAULT_NUM_CONTROL_QUBITS) or 0
+            )
 
-        if ctrl_state == _INVALID_CONTROL_STATE:
-            ctrl_state = "1" * num_ctrl_qubits
-            values["ctrl_state"] = ctrl_state
+            ctrl_state: str = values.get("ctrl_state") or _INVALID_CONTROL_STATE
 
-        cls.validate_control_string(ctrl_state)
+            if ctrl_state == _INVALID_CONTROL_STATE:
+                ctrl_state = "1" * num_ctrl_qubits
+                values["ctrl_state"] = ctrl_state
 
-        if num_ctrl_qubits == _DEFAULT_NUM_CONTROL_QUBITS:
-            num_ctrl_qubits = len(ctrl_state)
-            values["num_ctrl_qubits"] = num_ctrl_qubits
+            cls.validate_control_string(ctrl_state)
 
-        if len(ctrl_state) != num_ctrl_qubits:
-            raise ClassiqValueError(
-                "Control state length should be equal to the number of control qubits"
-            )
+            if num_ctrl_qubits == _DEFAULT_NUM_CONTROL_QUBITS:
+                num_ctrl_qubits = len(ctrl_state)
+                values["num_ctrl_qubits"] = num_ctrl_qubits
 
-        if values.get("name") is None:
-            values["name"] = f"{_DEFAULT_CONTROL_NAME}_{ctrl_state}"
+            if len(ctrl_state) != num_ctrl_qubits:
+                raise ClassiqValueError(
+                    "Control state length should be equal to the number of control qubits"
+                )
+
+            if "name" not in values or values["name"] is None:
+                values["name"] = f"{_DEFAULT_CONTROL_NAME}_{ctrl_state}"
 
         return values
 
     @staticmethod
     def validate_control_string(ctrl_state: str) -> None:
+        if not ctrl_state:
+            raise ClassiqValueError("Control state cannot be empty")
         if not set(ctrl_state) <= {"1", "0"}:
             raise ClassiqValueError(
                 f"Control state can only be constructed from 0 and 1, received: {ctrl_state}"
             )
-        if not ctrl_state:
-            raise ClassiqValueError("Control state cannot be empty")
 
     def __str__(self) -> str:
         return self.ctrl_state
@@ -72,5 +78,4 @@ class ControlState(BaseModel):
     def rename(self, name: str) -> ControlState:
         return ControlState(ctrl_state=self.ctrl_state, name=name)
 
-    class Config:
-        frozen = True
+    model_config = ConfigDict(frozen=True)

classiq/interface/generator/copy.py

@@ -0,0 +1,47 @@
+from typing import Optional
+
+import pydantic
+
+from classiq.interface.generator.arith import argument_utils
+from classiq.interface.generator.arith.register_user_input import RegisterArithmeticInfo
+from classiq.interface.generator.function_params import FunctionParams
+
+
+class Copy(FunctionParams):
+    source: argument_utils.RegisterOrConst
+    target: RegisterArithmeticInfo
+    output_size: Optional[pydantic.PositiveInt] = pydantic.Field(default=None)
+
+    @property
+    def source_size(self) -> int:
+        return argument_utils.size(self.source)
+
+    @property
+    def source_reg_size(self) -> int:
+        return (
+            self.source.size if isinstance(self.source, RegisterArithmeticInfo) else 0
+        )
+
+    @property
+    def source_fraction_places(self) -> int:
+        return argument_utils.fraction_places(self.source)
+
+    @property
+    def offset(self) -> int:
+        return self.target.fraction_places - self.source_fraction_places
+
+    @property
+    def source_name(self) -> str:
+        return "source"
+
+    @property
+    def target_name(self) -> str:
+        return "target"
+
+    def _create_ios(self) -> None:
+        self._inputs = {
+            self.target_name: self.target,
+        }
+        if isinstance(self.source, RegisterArithmeticInfo):
+            self._inputs[self.source_name] = self.source
+        self._outputs = {**self._inputs}

classiq/interface/generator/custom_ansatz.py

@@ -1,7 +1,6 @@
-from typing import Dict, Type
-
 import pydantic
 
+from classiq.interface.enum_utils import StrEnum
 from classiq.interface.generator.ansatz_library import (
     EntanglingLayersArgs,
     HypercubeArgs,
@@ -11,8 +10,6 @@ from classiq.interface.generator.ansatz_library import (
     TwoLocalArgs,
 )
 
-from classiq._internals.enum_utils import StrEnum
-
 
 class CustomAnsatzType(StrEnum):
     TwoLocal = "TwoLocal"
@@ -23,7 +20,7 @@ class CustomAnsatzType(StrEnum):
     RandomTwoQubitGates = "RandomTwoQubitGates"
 
 
-CUSTOM_ANSATZ_ARGS_MAPPING: Dict[CustomAnsatzType, Type[pydantic.BaseModel]] = {
+CUSTOM_ANSATZ_ARGS_MAPPING: dict[CustomAnsatzType, type[pydantic.BaseModel]] = {
     CustomAnsatzType.TwoLocal: TwoLocalArgs,
     CustomAnsatzType.SeparateU3: SeparateU3Args,
     CustomAnsatzType.Hypercube: HypercubeArgs,

classiq/interface/generator/distance.py

@@ -1,5 +1,3 @@
-from typing import List
-
 import numpy as np
 
 # Taken and modified from quantum_tsp_tutorials repository of mstechly in github.
@@ -10,7 +8,7 @@ def _distance_between_points(point_1: np.ndarray, point_2: np.ndarray) -> float:
     return float(np.linalg.norm(point_1 - point_2))
 
 
-def get_distance_matrix(cities: np.ndarray) -> List[List[float]]:
+def get_distance_matrix(cities: np.ndarray) -> list[list[float]]:
     number_of_cities = len(cities)
     matrix = np.zeros((number_of_cities, number_of_cities))
     for i in range(number_of_cities):
@@ -20,14 +18,14 @@ def get_distance_matrix(cities: np.ndarray) -> List[List[float]]:
     return matrix.tolist()
 
 
-def get_rand_euclidean_distance_matrix(num_points: int) -> List[List[float]]:
+def get_rand_euclidean_distance_matrix(num_points: int) -> list[list[float]]:
     _points_array_dim = 2
     points = np.random.rand(num_points, _points_array_dim)
     distance_matrix = get_distance_matrix(points)
     return distance_matrix
 
 
-def get_rand_distance_matrix(num_points: int) -> List[List[float]]:
+def get_rand_distance_matrix(num_points: int) -> list[list[float]]:
     distance_matrix = np.random.rand(num_points, num_points)
     distance_matrix *= 0.5
     distance_matrix += distance_matrix.T

classiq/interface/generator/excitations.py

@@ -1,4 +1,5 @@
-from typing import Iterable, List, Union
+from collections.abc import Iterable
+from typing import Union
 
 EXCITATIONS_TYPE = Union[str, int, Iterable[int], Iterable[str]]
-EXCITATIONS_TYPE_EXACT = List[int]
+EXCITATIONS_TYPE_EXACT = list[int]

classiq/interface/generator/expressions/atomic_expression_functions.py

@@ -1,6 +1,11 @@
-SUPPORTED_BUILTIN_FUNCTIONS = {"len", "sum", "print"}
+from classiq.interface.generator.functions.classical_type import CLASSICAL_ATTRIBUTES
 
-SUPPORTED_ATOMIC_EXPRESSION_FUNCTIONS = {
+SUPPORTED_PYTHON_BUILTIN_FUNCTIONS = {"len", "sum", "print"}
+
+SUPPORTED_CLASSIQ_BUILTIN_FUNCTIONS = {
+    "do_div",
+    "do_slice",
+    "do_subscript",
     "hypercube_entangler_graph",
     "grid_entangler_graph",
     "qft_const_adder_phase",
@@ -9,14 +14,25 @@ SUPPORTED_ATOMIC_EXPRESSION_FUNCTIONS = {
     "get_type",
     "struct_literal",
     "get_field",
-    "fraction_digits",
-    "is_signed",
     "molecule_problem_to_hamiltonian",
     "fock_hamiltonian_problem_to_hamiltonian",
     "molecule_ground_state_solution_post_process",
+}
+
+SUPPORTED_CLASSIQ_SYMPY_WRAPPERS = {
     "BitwiseAnd",
     "BitwiseXor",
     "BitwiseNot",
     "BitwiseOr",
-    *SUPPORTED_BUILTIN_FUNCTIONS,
+    "LogicalXor",
 }
+
+SUPPORTED_ATOMIC_EXPRESSION_FUNCTIONS = {
+    *SUPPORTED_CLASSIQ_BUILTIN_FUNCTIONS,
+    *SUPPORTED_CLASSIQ_SYMPY_WRAPPERS,
+    *SUPPORTED_PYTHON_BUILTIN_FUNCTIONS,
+}
+
+SUPPORTED_ATOMIC_EXPRESSION_FUNCTIONS_QMOD = (
+    SUPPORTED_ATOMIC_EXPRESSION_FUNCTIONS - CLASSICAL_ATTRIBUTES
+)

classiq/interface/generator/expressions/enums/__init__.py

@@ -1,10 +0,0 @@
-from enum import EnumMeta
-
-from .chemistry import Element, FermionMapping
-from .finance_functions import FinanceFunctionType
-from .ladder_operator import LadderOperator
-from .optimizers import Optimizer
-from .pauli import Pauli
-from .qsvm_feature_map_entanglement import QSVMFeatureMapEntanglement
-
-BUILTIN_ENUMS = dict(filter(lambda pair: isinstance(pair[1], EnumMeta), vars().items()))

classiq/interface/generator/expressions/enums/finance_functions.py

@@ -1,22 +1,12 @@
-from typing import Dict
-
-from classiq.interface.generator.expressions.enums.classical_enum import ClassicalEnum
-
-
-class FinanceFunctionType(ClassicalEnum):
-    VAR = 0
-    SHORTFALL = 1
-    X_SQUARE = 2
-    EUROPEAN_CALL_OPTION = 3
-
-    @staticmethod
-    def from_string(func_str: str) -> "FinanceFunctionType":
-        return FINANCE_FUNCTION_STRING[func_str]
-
-
-FINANCE_FUNCTION_STRING: Dict[str, FinanceFunctionType] = {
-    "var": FinanceFunctionType.VAR,
-    "expected shortfall": FinanceFunctionType.SHORTFALL,
-    "x**2": FinanceFunctionType.X_SQUARE,
-    "european call option": FinanceFunctionType.EUROPEAN_CALL_OPTION,
-}
+from classiq.interface.generator.types.builtin_enum_declarations import (
+    FinanceFunctionType,
+)
+
+
+def get_finance_function_dict() -> dict[str, "FinanceFunctionType"]:
+    return {
+        "var": FinanceFunctionType.VAR,
+        "expected shortfall": FinanceFunctionType.SHORTFALL,
+        "x**2": FinanceFunctionType.X_SQUARE,
+        "european call option": FinanceFunctionType.EUROPEAN_CALL_OPTION,
+    }

classiq/interface/generator/expressions/evaluated_expression.py

@@ -1,11 +1,13 @@
 import re
+from collections.abc import Mapping
 from dataclasses import dataclass
-from typing import Any, Mapping, Optional, Type
+from typing import Any, Optional
 
 from sympy import Expr
 from typing_extensions import get_args
 
 from classiq.interface.backend.pydantic_backend import EXECUTION_PARAMETER_PATTERN
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.expressions.expression_types import (
     ExpressionValue,
     QmodStructInstance,
@@ -13,14 +15,12 @@ from classiq.interface.generator.expressions.expression_types import (
 )
 from classiq.interface.generator.expressions.handle_identifier import HandleIdentifier
 
-from classiq.exceptions import ClassiqValueError
-
 
 @dataclass(frozen=True)
 class EvaluatedExpression:
     value: ExpressionValue
 
-    def is_constant(self, constant_type: Optional[Type] = None) -> bool:
+    def is_constant(self, constant_type: Optional[type] = None) -> bool:
         if self.value is None:
             return False
 
@@ -29,7 +29,7 @@ class EvaluatedExpression:
             get_args(RuntimeConstant) if constant_type is None else constant_type,
         )
 
-    def as_constant_type(self, constant_type: Type) -> Any:
+    def as_constant_type(self, constant_type: type) -> Any:
         if not self.is_constant():
             raise ClassiqValueError(
                 f"Invalid access to expression {self.value!r} as {constant_type}"

classiq/interface/generator/expressions/expression.py

@@ -1,14 +1,17 @@
 import ast
-from typing import Any, Mapping, Optional, Type
+from collections.abc import Mapping
+from typing import Any, Optional
 
 import pydantic
-from pydantic import PrivateAttr
+from pydantic import ConfigDict, PrivateAttr
 
+from classiq.interface.ast_node import HashableASTNode
+from classiq.interface.exceptions import ClassiqError
 from classiq.interface.generator.arith.arithmetic_expression_validator import (
     DEFAULT_SUPPORTED_FUNC_NAMES,
 )
 from classiq.interface.generator.expressions.atomic_expression_functions import (
-    SUPPORTED_ATOMIC_EXPRESSION_FUNCTIONS,
+    SUPPORTED_ATOMIC_EXPRESSION_FUNCTIONS_QMOD,
 )
 from classiq.interface.generator.expressions.evaluated_expression import (
     EvaluatedExpression,
@@ -17,14 +20,9 @@ from classiq.interface.generator.expressions.sympy_supported_expressions import
     SYMPY_SUPPORTED_EXPRESSIONS,
 )
 from classiq.interface.generator.function_params import validate_expression_str
-from classiq.interface.helpers.hashable_pydantic_base_model import (
-    HashablePydanticBaseModel,
-)
-
-from classiq.exceptions import ClassiqError
 
 
-class Expression(HashablePydanticBaseModel):
+class Expression(HashableASTNode):
     expr: str
     _evaluated_expr: Optional[EvaluatedExpression] = PrivateAttr(default=None)
 
@@ -33,20 +31,27 @@ class Expression(HashablePydanticBaseModel):
 
         self._try_to_immediate_evaluate()
 
-    @pydantic.validator("expr")
+    @pydantic.field_validator("expr")
+    @classmethod
     def validate_expression(cls, expr: str) -> str:
         supported_functions = (
-            SUPPORTED_ATOMIC_EXPRESSION_FUNCTIONS
+            SUPPORTED_ATOMIC_EXPRESSION_FUNCTIONS_QMOD
             | set(SYMPY_SUPPORTED_EXPRESSIONS)
             | set(DEFAULT_SUPPORTED_FUNC_NAMES)
         )
         validate_expression_str(expr, supported_functions=supported_functions)
         return expr
 
+    @pydantic.field_validator("expr")
+    @classmethod
+    def format_expression(cls, expr: str) -> str:
+        expr = ast.unparse(ast.parse(expr))
+        return expr
+
     def is_evaluated(self) -> bool:
         return self._evaluated_expr is not None
 
-    def as_constant(self, constant_type: Type) -> Any:
+    def as_constant(self, constant_type: type) -> Any:
         return self.value.as_constant_type(constant_type)
 
     def to_int_value(self) -> int:
@@ -65,6 +70,14 @@ class Expression(HashablePydanticBaseModel):
         return self.as_constant(list)
 
     def _try_to_immediate_evaluate(self) -> None:
+        # FIXME remove special treatment (CAD-22999)
+        if self.expr == "SIGNED":
+            self._evaluated_expr = EvaluatedExpression(value=True)
+            return
+        if self.expr == "UNSIGNED":
+            self._evaluated_expr = EvaluatedExpression(value=False)
+            return
+
         try:
             result = ast.literal_eval(self.expr)
             if isinstance(result, (int, float, bool)):
@@ -85,8 +98,7 @@ class Expression(HashablePydanticBaseModel):
     def is_constant(self) -> bool:
         return self.value.is_constant()
 
-    class Config:
-        frozen = True
+    model_config = ConfigDict(frozen=True)
 
     def __str__(self) -> str:
         return self.expr

classiq/interface/generator/expressions/expression_constants.py

@@ -1,5 +1,5 @@
 import keyword
-from typing import Set
+from typing import Final
 
 from classiq.interface.generator.arith.arithmetic_expression_parser import (
     DEFAULT_SUPPORTED_FUNC_NAMES,
@@ -11,9 +11,15 @@ from classiq.interface.generator.function_params import NAME_REGEX
 
 SUPPORTED_VAR_NAMES_REG = NAME_REGEX
 
-SUPPORTED_FUNC_NAMES: Set[str] = (
+SUPPORTED_FUNC_NAMES: set[str] = (
     {"or", "and"}
     .union(DEFAULT_SUPPORTED_FUNC_NAMES)
     .union(set(SYMPY_SUPPORTED_EXPRESSIONS))
 )
-FORBIDDEN_LITERALS: Set[str] = set(keyword.kwlist) - SUPPORTED_FUNC_NAMES
+BOOLEAN_LITERALS = {"True", "False"}
+FORBIDDEN_LITERALS: set[str] = set(keyword.kwlist) - SUPPORTED_FUNC_NAMES
+CPARAM_EXECUTION_SUFFIX: Final[str] = "_param"
+RESERVED_EXPRESSIONS: frozenset[str] = frozenset({"i"})
+CPARAM_EXECUTION_SUFFIX_PATTERN = (
+    rf"({CPARAM_EXECUTION_SUFFIX}|^({'|'.join(RESERVED_EXPRESSIONS)}))(_\d+)*$"
+)