classiq 0.40.0__py3-none-any.whl → 0.41.1__py3-none-any.whl

classiq/interface/generator/functions/classical_type.py

@@ -14,9 +14,7 @@ from classiq.interface.generator.expressions.enums.pauli import Pauli as PauliEn
 from classiq.interface.generator.expressions.expression_types import RuntimeExpression
 from classiq.interface.helpers.pydantic_model_helpers import values_with_discriminator
 
-CLASSICAL_ATTRIBUTES = {
-    "len": len,
-}
+CLASSICAL_ATTRIBUTES = {"len", "size", "is_signed", "fraction_digits"}
 
 NamedSymbol = Union[IndexedBase, Symbol]
 

classiq/interface/generator/synthesis_metadata/synthesis_duration.py

@@ -1,10 +1,7 @@
-from typing import Optional
-
 import pydantic
 
 
 class SynthesisStepDurations(pydantic.BaseModel):
-    model_preprocessing: Optional[float] = None
     preprocessing: float
     solving: float
     conversion_to_circuit: float
@@ -14,7 +11,6 @@ class SynthesisStepDurations(pydantic.BaseModel):
         return sum(
             time if time is not None else 0
             for time in (
-                self.model_preprocessing,
                 self.preprocessing,
                 self.solving,
                 self.conversion_to_circuit,

classiq/interface/model/bind_operation.py

@@ -1,4 +1,4 @@
-from typing import List, Mapping
+from typing import List, Literal, Mapping
 
 import pydantic
 
@@ -12,6 +12,8 @@ BIND_OUTPUT_NAME = "bind_output"
 
 
 class BindOperation(QuantumOperation):
+    kind: Literal["BindOperation"]
+
     in_handles: List[HandleBinding]
     out_handles: List[HandleBinding]
 

classiq/interface/model/call_synthesis_data.py

@@ -36,24 +36,13 @@ class CallSynthesisData(Mapping):
             should_control=self.should_control and other.should_control,
         )
 
-    def set_control(self, ctrl_name: str, ctrl_size: int) -> None:
+    def set_control(self, ctrl_name: str, ctrl_size: int, ctrl_state: str) -> None:
         self.control_states = [
             ControlState(
-                name=ctrl_name,
-                num_ctrl_qubits=ctrl_size,
+                name=ctrl_name, num_ctrl_qubits=ctrl_size, ctrl_state=ctrl_state
             )
         ]
 
-    def update_control_state(self, ctrl_size: int, ctrl_state: str) -> None:
-        prev_ctrl_state = self.control_states.pop()
-        self.control_states.append(
-            ControlState(
-                name=prev_ctrl_state.name,
-                num_ctrl_qubits=ctrl_size,
-                ctrl_state=ctrl_state,
-            )
-        )
-
     @property
     def has_control(self) -> bool:
         return bool(self.control_states)

classiq/interface/model/classical_if.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Literal
 
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.model.quantum_statement import QuantumOperation
@@ -8,6 +8,8 @@ if TYPE_CHECKING:
 
 
 class ClassicalIf(QuantumOperation):
+    kind: Literal["ClassicalIf"]
+
     condition: Expression
     then: "StatementBlock"
     else_: "StatementBlock"

classiq/interface/model/classical_parameter_declaration.py

@@ -1,7 +1,20 @@
+from typing import Any, Dict, Literal
+
+import pydantic
+
 from classiq.interface.ast_node import ASTNode
 from classiq.interface.generator.functions.classical_type import ConcreteClassicalType
+from classiq.interface.helpers.pydantic_model_helpers import values_with_discriminator
 
 
 class ClassicalParameterDeclaration(ASTNode):
+    kind: Literal["ClassicalParameterDeclaration"]
+
     name: str
     classical_type: ConcreteClassicalType
+
+    @pydantic.root_validator(pre=True)
+    def _set_kind(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+        return values_with_discriminator(
+            values, "kind", "ClassicalParameterDeclaration"
+        )

classiq/interface/model/control.py

@@ -1,112 +1,14 @@
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING, Literal
 
-import pydantic
-from sympy import Equality
-from sympy.core.numbers import Integer
-
-from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.generator.expressions.qmod_qscalar_proxy import (
-    QmodQNumProxy,
-    QmodSizedProxy,
-)
-from classiq.interface.model.quantum_expressions.control_state import (
-    min_bit_length,
-    to_twos_complement,
-)
 from classiq.interface.model.quantum_expressions.quantum_expression import (
     QuantumExpressionOperation,
 )
 
-from classiq.exceptions import ClassiqValueError
-
 if TYPE_CHECKING:
     from classiq.interface.model.statement_block import StatementBlock
 
-CONTROL_INOUT_NAME = "ctrl"
-CONTROL_CTRL_ARG_ERROR_MESSAGE_FORMAT = (
-    "control condition must be of the form '<quantum-variable> == "
-    "<classical-integer-expression>', but condition's {}-hand side was {!r}"
-)
-
 
 class Control(QuantumExpressionOperation):
-    body: "StatementBlock"
-    _ctrl: Optional[QmodSizedProxy] = pydantic.PrivateAttr(
-        default=None,
-    )
-    _ctrl_val: Optional[int] = pydantic.PrivateAttr(
-        default=None,
-    )
-
-    @property
-    def condition(self) -> Expression:
-        return self.expression
+    kind: Literal["Control"]
 
-    @property
-    def ctrl(self) -> QmodSizedProxy:
-        assert self._ctrl is not None
-        return self._ctrl
-
-    @property
-    def ctrl_val(self) -> int:
-        assert self._ctrl_val is not None
-        return self._ctrl_val
-
-    def resolve_condition(self) -> None:
-        condition = self.condition.value.value
-        if isinstance(condition, QmodSizedProxy):
-            self._resolve_port_condition(condition)
-        elif isinstance(condition, Equality):
-            self._resolve_num_condition(condition)
-        else:
-            raise ClassiqValueError(
-                f"control condition must be a qubit, an array of qubits, or a quantum "
-                f"numeric equality, was {str(condition)!r}"
-            )
-
-    def _resolve_port_condition(self, condition: QmodSizedProxy) -> None:
-        self._ctrl = condition
-
-    def _resolve_num_condition(self, condition: Equality) -> None:
-        ctrl, ctrl_val = condition.args
-        if isinstance(ctrl, Integer) and isinstance(ctrl_val, QmodQNumProxy):
-            ctrl, ctrl_val = ctrl_val, ctrl
-        if not isinstance(ctrl, QmodQNumProxy):
-            raise ClassiqValueError(
-                CONTROL_CTRL_ARG_ERROR_MESSAGE_FORMAT.format("left", str(ctrl))
-            )
-        if not isinstance(ctrl_val, Integer):
-            raise ClassiqValueError(
-                CONTROL_CTRL_ARG_ERROR_MESSAGE_FORMAT.format("right", str(ctrl_val))
-            )
-        self._ctrl, self._ctrl_val = ctrl, int(ctrl_val)
-
-    @property
-    def has_ctrl_state(self) -> bool:
-        assert self._ctrl is not None
-        return self._ctrl_val is not None
-
-    @property
-    def ctrl_state(self) -> str:
-        ctrl = self.ctrl
-        assert isinstance(ctrl, QmodQNumProxy)
-        is_signed = ctrl.is_signed
-        fraction_places = ctrl.fraction_digits
-        ctrl_size = len(ctrl)
-        if not is_signed and self.ctrl_val < 0:
-            raise ClassiqValueError(
-                f"Variable {str(ctrl)!r} is not signed but control value "
-                f"{self.ctrl_val} is negative"
-            )
-        required_qubits = min_bit_length(self.ctrl_val, is_signed)
-        if ctrl_size < required_qubits:
-            raise ClassiqValueError(
-                f"Variable {str(ctrl)!r} has {ctrl_size} qubits but control value "
-                f"{str(self.ctrl_val)!r} requires at least {required_qubits} qubits"
-            )
-        if fraction_places != 0:
-            raise ClassiqValueError(
-                f"Comparison (`==`) on a non-integer quantum variable {str(ctrl)!r} is "
-                f"not supported at the moment"
-            )
-        return to_twos_complement(self.ctrl_val, ctrl_size, is_signed)
+    body: "StatementBlock"

classiq/interface/model/inplace_binary_operation.py

@@ -1,4 +1,4 @@
-from typing import Mapping
+from typing import Literal, Mapping
 
 import pydantic
 
@@ -23,6 +23,8 @@ class BinaryOperation(StrEnum):
 
 
 class InplaceBinaryOperation(QuantumOperation):
+    kind: Literal["InplaceBinaryOperation"]
+
     target: HandleBinding
     value: HandleBinding
     operation: BinaryOperation

classiq/interface/model/invert.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Literal
 
 from classiq.interface.model.quantum_statement import QuantumOperation
 
@@ -7,4 +7,6 @@ if TYPE_CHECKING:
 
 
 class Invert(QuantumOperation):
+    kind: Literal["Invert"]
+
     body: "StatementBlock"

classiq/interface/model/port_declaration.py

@@ -1,10 +1,11 @@
-from typing import Any, Mapping
+from typing import Any, Dict, Literal, Mapping
 
 import pydantic
 
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
+from classiq.interface.helpers.pydantic_model_helpers import values_with_discriminator
 from classiq.interface.model.quantum_variable_declaration import (
     QuantumVariableDeclaration,
 )
@@ -13,8 +14,14 @@ from classiq.exceptions import ClassiqValueError
 
 
 class PortDeclaration(QuantumVariableDeclaration):
+    kind: Literal["PortDeclaration"]
+
     direction: PortDeclarationDirection
 
+    @pydantic.root_validator(pre=True)
+    def _set_kind(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+        return values_with_discriminator(values, "kind", "PortDeclaration")
+
     @pydantic.validator("direction")
     def _direction_validator(
         cls, direction: PortDeclarationDirection, values: Mapping[str, Any]

classiq/interface/model/power.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Literal
 
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.model.quantum_statement import QuantumOperation
@@ -8,5 +8,7 @@ if TYPE_CHECKING:
 
 
 class Power(QuantumOperation):
+    kind: Literal["Power"]
+
     power: Expression
     body: "StatementBlock"

classiq/interface/model/quantum_expressions/amplitude_loading_operation.py

@@ -1,4 +1,4 @@
-from typing import Dict, Mapping, Union
+from typing import Dict, Literal, Mapping, Union
 
 import pydantic
 
@@ -28,6 +28,8 @@ VAR_DOMAIN_ILLEGAL = (
 
 
 class AmplitudeLoadingOperation(QuantumAssignmentOperation):
+    kind: Literal["AmplitudeLoadingOperation"]
+
     _result_type: QuantumType = pydantic.PrivateAttr(default_factory=QuantumBit)
 
     @property
@@ -52,7 +54,7 @@ class AmplitudeLoadingOperation(QuantumAssignmentOperation):
     ) -> None:
         if len(var_types) != 1:
             raise ClassiqValueError(MULTI_VARS_UNSUPPORTED_ERROR)
-        var_type = var_types[self.var_handles[0].name]
+        var_type = list(var_types.values())[0]
         if not (
             isinstance(var_type, QuantumNumeric)
             and var_type.fraction_digits_value == var_type.size_in_bits

classiq/interface/model/quantum_expressions/arithmetic_operation.py

@@ -1,4 +1,4 @@
-from typing import Dict, Mapping, Union
+from typing import Dict, Literal, Mapping, Union
 
 import pydantic
 
@@ -18,6 +18,8 @@ from classiq.interface.model.quantum_type import QuantumType
 
 
 class ArithmeticOperation(QuantumAssignmentOperation):
+    kind: Literal["ArithmeticOperation"]
+
     inplace_result: bool = pydantic.Field(
         description="Determines whether the result variable is initialized",
     )

classiq/interface/model/quantum_expressions/quantum_expression.py

@@ -33,6 +33,16 @@ class VarRefCollector(ast.NodeVisitor):
         super().generic_visit(node)
 
 
+class VarRefTransformer(ast.NodeTransformer):
+    def __init__(self, var_mapping: Dict[str, str]) -> None:
+        self.var_mapping = var_mapping
+
+    def visit_Name(self, node: ast.Name) -> ast.Name:
+        if node.id in self.var_mapping:
+            node.id = self.var_mapping[node.id]
+        return node
+
+
 class QuantumExpressionOperation(QuantumOperation):
     expression: Expression = pydantic.Field()
     _var_handles: List[HandleBinding] = pydantic.PrivateAttr(
@@ -58,7 +68,7 @@ class QuantumExpressionOperation(QuantumOperation):
         var_types: Dict[str, QuantumType],
         machine_precision: int,
     ) -> None:
-        assert len(var_types) == len(self.var_handles)
+        assert len(var_types) == len(self.var_handles) or len(self.var_handles) == 0
         self._var_types = var_types
 
     @property

classiq/interface/model/quantum_function_call.py

@@ -1,6 +1,6 @@
 import itertools
 import re
-from typing import Any, Dict, List, Mapping, Optional, Set, Type, Union
+from typing import Any, Dict, List, Literal, Mapping, Optional, Set, Type, Union
 
 import pydantic
 
@@ -23,7 +23,6 @@ from classiq.interface.model.quantum_function_declaration import (
     QuantumOperandDeclaration,
 )
 from classiq.interface.model.quantum_lambda_function import (
-    LambdaListComprehension,
     QuantumCallable,
     QuantumLambdaFunction,
     QuantumOperand,
@@ -114,6 +113,8 @@ class OperandIdentifier(ASTNode):
 
 
 class QuantumFunctionCall(QuantumOperation):
+    kind: Literal["QuantumFunctionCall"]
+
     function: Union[str, OperandIdentifier] = pydantic.Field(
         description="The function that is called"
     )
@@ -304,10 +305,7 @@ class QuantumFunctionCall(QuantumOperation):
 def get_lambda_defs(operand: QuantumOperand) -> List[QuantumCallable]:
     if isinstance(operand, list):
         return operand
-    elif isinstance(operand, LambdaListComprehension):
-        return [operand.func]
-    else:
-        return [operand]
+    return [operand]
 
 
 def _check_ports_against_declaration(
@@ -368,10 +366,6 @@ def _check_operand_against_declaration(
         if operand_argument.func_decl is None:
             return
         operand_arg_decl = operand_argument.func_decl
-    elif isinstance(operand_argument, LambdaListComprehension):
-        if operand_argument.func.func_decl is None:
-            return
-        operand_arg_decl = operand_argument.func.func_decl
     else:
         raise ClassiqValueError(
             f"{str(operand_argument)!r} argument to {call.func_decl.name!r} is not a "

classiq/interface/model/quantum_function_declaration.py

@@ -1,6 +1,18 @@
-from typing import Any, ClassVar, Dict, List, Mapping, Sequence, Set, Type, Union
+from typing import (
+    Any,
+    ClassVar,
+    Dict,
+    List,
+    Literal,
+    Mapping,
+    Sequence,
+    Set,
+    Type,
+    Union,
+)
 
 import pydantic
+from typing_extensions import Annotated
 
 from classiq.interface.generator.function_params import ArithmeticIODict, PortDirection
 from classiq.interface.generator.functions.function_declaration import (
@@ -9,7 +21,10 @@ from classiq.interface.generator.functions.function_declaration import (
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
-from classiq.interface.helpers.pydantic_model_helpers import Nameable
+from classiq.interface.helpers.pydantic_model_helpers import (
+    Nameable,
+    values_with_discriminator,
+)
 from classiq.interface.helpers.validation_helpers import (
     validate_nameables_mapping,
     validate_nameables_no_overlap,
@@ -49,8 +64,9 @@ def _populate_declaration_dicts_with_positional_lists(
         )
 
 
-PositionalArg = Union[
-    ClassicalParameterDeclaration, "QuantumOperandDeclaration", PortDeclaration
+PositionalArg = Annotated[
+    Union[ClassicalParameterDeclaration, "QuantumOperandDeclaration", PortDeclaration],
+    pydantic.Field(..., discriminator="kind"),
 ]
 
 
@@ -218,10 +234,16 @@ class QuantumFunctionDeclaration(FunctionDeclaration):
 
 
 class QuantumOperandDeclaration(QuantumFunctionDeclaration):
+    kind: Literal["QuantumOperandDeclaration"]
+
     is_list: bool = pydantic.Field(
         description="Indicate whether the operand expects an unnamed list of lambdas",
         default=False,
     )
 
+    @pydantic.root_validator(pre=True)
+    def _set_kind(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+        return values_with_discriminator(values, "kind", "QuantumOperandDeclaration")
+
 
 QuantumFunctionDeclaration.update_forward_refs()

classiq/interface/model/quantum_lambda_function.py

@@ -3,7 +3,6 @@ from typing import TYPE_CHECKING, Dict, List, Optional, Union
 import pydantic
 
 from classiq.interface.ast_node import ASTNode
-from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.model.quantum_function_declaration import (
     QuantumOperandDeclaration,
 )
@@ -36,23 +35,5 @@ class QuantumLambdaFunction(ASTNode):
         self._func_decl = fd
 
 
-class LambdaListComprehension(ASTNode):
-    """
-    Specification of a list of lambda functions iteratively
-    """
-
-    count: Expression = pydantic.Field(
-        description="The number of lambda functions in the list"
-    )
-
-    index_var: str = pydantic.Field(
-        description="The name of the integer variable holding the iteration index"
-    )
-
-    func: QuantumLambdaFunction = pydantic.Field(
-        description="A lambda function definition replicated for index values 0 to count-1"
-    )
-
-
 QuantumCallable = Union[str, QuantumLambdaFunction]
-QuantumOperand = Union[QuantumCallable, List[QuantumCallable], LambdaListComprehension]
+QuantumOperand = Union[QuantumCallable, List[QuantumCallable]]

classiq/interface/model/quantum_statement.py

@@ -1,8 +1,9 @@
-from typing import Mapping, Union
+from typing import Any, Dict, Mapping, Union
 
-from pydantic import Extra
+from pydantic import Extra, root_validator
 
 from classiq.interface.ast_node import ASTNode
+from classiq.interface.helpers.pydantic_model_helpers import values_with_discriminator
 from classiq.interface.model.handle_binding import (
     HandleBinding,
     SlicedHandleBinding,
@@ -11,9 +12,15 @@ from classiq.interface.model.handle_binding import (
 
 
 class QuantumStatement(ASTNode):
+    kind: str
+
     class Config:
         extra = Extra.forbid
 
+    @root_validator(pre=True)
+    def _set_kind(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+        return values_with_discriminator(values, "kind", cls.__name__)  # type: ignore[attr-defined]
+
 
 class QuantumOperation(QuantumStatement):
     @property

classiq/interface/model/repeat.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Literal
 
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.model.quantum_statement import QuantumOperation
@@ -8,6 +8,8 @@ if TYPE_CHECKING:
 
 
 class Repeat(QuantumOperation):
+    kind: Literal["Repeat"]
+
     iter_var: str
     count: Expression
     body: "StatementBlock"

classiq/interface/model/statement_block.py

@@ -1,5 +1,8 @@
 from typing import List, Union
 
+from pydantic import Field
+from typing_extensions import Annotated
+
 from classiq.interface.model.bind_operation import BindOperation
 from classiq.interface.model.classical_if import ClassicalIf
 from classiq.interface.model.control import Control
@@ -20,19 +23,22 @@ from classiq.interface.model.variable_declaration_statement import (
 )
 from classiq.interface.model.within_apply_operation import WithinApply
 
-ConcreteQuantumStatement = Union[
-    QuantumFunctionCall,
-    ArithmeticOperation,
-    AmplitudeLoadingOperation,
-    VariableDeclarationStatement,
-    BindOperation,
-    InplaceBinaryOperation,
-    Repeat,
-    Power,
-    Invert,
-    ClassicalIf,
-    Control,
-    WithinApply,
+ConcreteQuantumStatement = Annotated[
+    Union[
+        QuantumFunctionCall,
+        ArithmeticOperation,
+        AmplitudeLoadingOperation,
+        VariableDeclarationStatement,
+        BindOperation,
+        InplaceBinaryOperation,
+        Repeat,
+        Power,
+        Invert,
+        ClassicalIf,
+        Control,
+        WithinApply,
+    ],
+    Field(..., discriminator="kind"),
 ]
 
 StatementBlock = List[ConcreteQuantumStatement]

classiq/interface/model/validations/handles_validator.py

@@ -61,8 +61,14 @@ class HandleValidator(HandleValidationBase):
             self._handle_apply([QuantumFunctionCall(function=call_name)])
         elif isinstance(op, WithinApply):
             self._handle_apply(op.action)
-        self._handle_inputs(op.wiring_inputs)
-        self._handle_outputs(op.wiring_outputs)
+
+        if isinstance(op, QuantumFunctionCall) and op.synthesis_data.is_inverse:
+            self._handle_inputs(op.wiring_outputs)
+            self._handle_outputs(op.wiring_inputs)
+        else:
+            self._handle_inputs(op.wiring_inputs)
+            self._handle_outputs(op.wiring_outputs)
+
         self._handle_inouts(op.wiring_inouts)
 
     def handle_variable_declaration(

classiq/interface/model/variable_declaration_statement.py

@@ -1,3 +1,5 @@
+from typing import Literal
+
 from classiq.interface.model.quantum_statement import QuantumStatement
 from classiq.interface.model.quantum_variable_declaration import (
     QuantumVariableDeclaration,
@@ -5,4 +7,4 @@ from classiq.interface.model.quantum_variable_declaration import (
 
 
 class VariableDeclarationStatement(QuantumStatement, QuantumVariableDeclaration):
-    pass
+    kind: Literal["VariableDeclarationStatement"]

classiq/interface/model/within_apply_operation.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Literal
 
 from classiq.interface.model.quantum_statement import QuantumOperation
 
@@ -7,5 +7,7 @@ if TYPE_CHECKING:
 
 
 class WithinApply(QuantumOperation):
+    kind: Literal["WithinApply"]
+
     compute: "StatementBlock"
     action: "StatementBlock"

classiq/interface/server/routes.py

@@ -1,6 +1,5 @@
 ANALYZER_PREFIX = "/analyzer"
 CHEMISTRY_PREFIX = "/chemistry"
-LEGACY_EXECUTE_PREFIX = "/execute"
 EXECUTION_PREFIX = "/execution"
 CONVERSION_PREFIX = "/conversion"
 
@@ -22,8 +21,6 @@ ANALYZER_OPTIONAL_DEVICES = "/graphs/available_devices"
 ANALYZER_OPTIONAL_DEVICES_FULL_PATH = ANALYZER_PREFIX + ANALYZER_OPTIONAL_DEVICES
 
 TASKS_SUFFIX = "/tasks"
-QUANTUM_PROGRAM_SUFFIX = "/quantum_program"
-ESTIMATE_SUFFIX = "/estimate"
 RB = "/rb"
 ANALYZER_DATA_TASK = f"{TASKS_SUFFIX}/data"
 ANALYZER_QASM_TASK = f"{TASKS_SUFFIX}/qasm"
@@ -60,8 +57,6 @@ EXECUTION_JOBS_FULL_PATH = EXECUTION_PREFIX + EXECUTION_JOBS_SUFFIX
 EXECUTION_JOBS_NON_VERSIONED_FULL_PATH = (
     EXECUTION_NON_VERSIONED_PREFIX + EXECUTION_JOBS_SUFFIX
 )
-EXECUTE_QUANTUM_PROGRAM_FULL_PATH = LEGACY_EXECUTE_PREFIX + QUANTUM_PROGRAM_SUFFIX
-EXECUTE_ESTIMATE_FULL_PATH = LEGACY_EXECUTE_PREFIX + ESTIMATE_SUFFIX
 
 ANALYZER_FULL_PATH = ANALYZER_PREFIX + TASKS_SUFFIX
 ANALYZER_RB_FULL_PATH = ANALYZER_PREFIX + TASK_RB_SUFFIX