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

classiq/interface/generator/register_role.py

@@ -1,6 +1,4 @@
-from typing import Set
-
-from classiq._internals.enum_utils import StrEnum
+from classiq.interface.enum_utils import StrEnum
 
 
 class RegisterRole(StrEnum):
@@ -10,9 +8,10 @@ class RegisterRole(StrEnum):
     ZERO_INPUT = "zero_input"
     ZERO_OUTPUT = "zero_output"
     GARBAGE_OUTPUT = "garbage_output"
+    EXPLICIT_ZERO_INPUT = "explicit_zero_input"
 
     @staticmethod
-    def output_roles(include_garbage: bool = False) -> Set["RegisterRole"]:
+    def output_roles(include_garbage: bool = False) -> set["RegisterRole"]:
         roles = {
             RegisterRole.OUTPUT,
             RegisterRole.ZERO_OUTPUT,
@@ -23,5 +22,18 @@ class RegisterRole(StrEnum):
         return roles
 
     @staticmethod
-    def input_roles() -> Set["RegisterRole"]:
-        return {RegisterRole.INPUT, RegisterRole.ZERO_INPUT, RegisterRole.AUXILIARY}
+    def input_roles() -> set["RegisterRole"]:
+        return {
+            RegisterRole.INPUT,
+            RegisterRole.ZERO_INPUT,
+            RegisterRole.AUXILIARY,
+            RegisterRole.EXPLICIT_ZERO_INPUT,
+        }
+
+    @staticmethod
+    def clean_output_roles() -> set["RegisterRole"]:
+        return {RegisterRole.ZERO_OUTPUT, RegisterRole.AUXILIARY}
+
+    @staticmethod
+    def dirty_output_roles() -> set["RegisterRole"]:
+        return {RegisterRole.OUTPUT, RegisterRole.GARBAGE_OUTPUT}

classiq/interface/generator/slice_parsing_utils.py

@@ -1,6 +1,8 @@
 import re
-from typing import Match, Optional, Tuple
+from re import Match
+from typing import Optional
 
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.function_params import NAME_REGEX
 
 NAME = "name"
@@ -10,12 +12,12 @@ SLICING_CHARS = rf"[0-9\-{SEPARATOR}]+"
 IO_REGEX = rf"(?P<{NAME}>{NAME_REGEX})(\[(?P<{SLICING}>{SLICING_CHARS})\])?"
 
 
-def parse_io_slicing(io_str: str) -> Tuple[str, slice]:
+def parse_io_slicing(io_str: str) -> tuple[str, slice]:
     name, slicing = separate_name_and_slice(io_str)
     return name, get_slice(slicing)
 
 
-def separate_name_and_slice(io_str: str) -> Tuple[str, Optional[str]]:
+def separate_name_and_slice(io_str: str) -> tuple[str, Optional[str]]:
     match: Optional[Match] = re.fullmatch(IO_REGEX, io_str)
     if match is None:
         raise AssertionError("Input/output name validation error")
@@ -33,9 +35,12 @@ def get_slice(slicing: Optional[str]) -> slice:
 
     if len(split) == 1:
         index_block = split[0]
-        # failing int raises ValueError which Pydantic captures
-        # RegEx matching should deem this scenario impossible
-        index = int(index_block)
+        try:
+            index = int(index_block)
+        except ValueError:
+            raise ClassiqValueError(
+                f"Index {index_block!r} is not an integer"
+            ) from None
         stop = index + 1 if index != -1 else None
         return slice(index, stop, None)
 

classiq/interface/generator/standard_gates/controlled_standard_gates.py

@@ -1,7 +1,9 @@
-from typing import Any, Dict, Literal, Optional, Union
+from typing import Literal, Optional, Union
 
 import pydantic
+from pydantic_core.core_schema import ValidationInfo
 
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.arith.register_user_input import RegisterUserInput
 from classiq.interface.generator.control_state import ControlState
 from classiq.interface.generator.standard_gates.standard_gates import (
@@ -24,46 +26,29 @@ class ControlledGate(_StandardGate):  # type: ignore[misc]
     num_ctrl_qubits: pydantic.PositiveInt = pydantic.Field(
         default=DEFAULT_NUM_CTRL_QUBITS
     )
-
-    def _create_ios(self) -> None:
-        _StandardGate._create_ios(self)
-        control = RegisterUserInput(
-            name=CONTROLLED_GATE_CONTROL, size=self.num_ctrl_qubits
-        )
-        self._inputs[CONTROLLED_GATE_CONTROL] = control
-        self._outputs[CONTROLLED_GATE_CONTROL] = control
-
-    def to_control_state(self) -> ControlState:
-        return ControlState(
-            name=CONTROLLED_GATE_CONTROL, num_ctrl_qubits=self.num_ctrl_qubits
-        )
-
-
-class ControlledGateWithState(ControlledGate):  # type: ignore[misc]
-    """
-    Base model for controlled Gates with control over the controlled_state
-    """
-
     ctrl_state: CtrlState = pydantic.Field(
         description="The control state in decimal or as a bit string (e.g. '1011'). If not specified, the control "
         "state is 2**num_ctrl_qubits - 1.\n"
-        "The gate will be performed if the state of the control qubits matches the control state"
+        "The gate will be performed if the state of the control qubits matches the control state",
+        default=None,
+        validate_default=True,
     )
 
-    @pydantic.validator("ctrl_state", always=True)
+    @pydantic.field_validator("ctrl_state")
+    @classmethod
     def _validate_ctrl_state(
-        cls, ctrl_state: CtrlState, values: Dict[str, Any]
+        cls, ctrl_state: CtrlState, info: ValidationInfo
     ) -> CtrlState:
-        num_ctrl_qubits: int = values.get("num_ctrl_qubits", DEFAULT_NUM_CTRL_QUBITS)
+        num_ctrl_qubits: int = info.data.get("num_ctrl_qubits", DEFAULT_NUM_CTRL_QUBITS)
         ctrl_state = ctrl_state if ctrl_state is not None else "1" * num_ctrl_qubits
 
         if isinstance(ctrl_state, str) and len(ctrl_state) != num_ctrl_qubits:
-            raise ValueError(
+            raise ClassiqValueError(
                 f"Invalid control state: {ctrl_state!r}. "
                 f"Expected {num_ctrl_qubits} qubits"
             )
         elif isinstance(ctrl_state, int) and ctrl_state >= 2**num_ctrl_qubits:
-            raise ValueError(
+            raise ClassiqValueError(
                 f"Invalid control state: {ctrl_state}. "
                 f"Expected value between 0 and {2**num_ctrl_qubits-1}"
             )
@@ -77,12 +62,20 @@ class ControlledGateWithState(ControlledGate):  # type: ignore[misc]
         )
         return ControlState(name=CONTROLLED_GATE_CONTROL, ctrl_state=ctrl_state_str)
 
+    def _create_ios(self) -> None:
+        _StandardGate._create_ios(self)
+        control = RegisterUserInput(
+            name=CONTROLLED_GATE_CONTROL, size=self.num_ctrl_qubits
+        )
+        self._inputs[CONTROLLED_GATE_CONTROL] = control
+        self._outputs[CONTROLLED_GATE_CONTROL] = control
+
 
 def _num_to_control_string(ctrl_state_int: int, num_ctrl_qubits: int) -> str:
     return format(ctrl_state_int, f"0{num_ctrl_qubits}b")
 
 
-class CXGate(ControlledGateWithState):  # type: ignore[misc]
+class CXGate(ControlledGate):  # type: ignore[misc]
     """
     The Controlled-X Gate
     """
@@ -93,7 +86,7 @@ class CXGate(ControlledGateWithState):  # type: ignore[misc]
         return 2
 
 
-class CCXGate(ControlledGateWithState):  # type: ignore[misc]
+class CCXGate(ControlledGate):  # type: ignore[misc]
     """
     The Double Controlled-X Gate
     """
@@ -104,7 +97,7 @@ class CCXGate(ControlledGateWithState):  # type: ignore[misc]
         return 2
 
 
-class C3XGate(ControlledGateWithState):  # type: ignore[misc]
+class C3XGate(ControlledGate):  # type: ignore[misc]
     """
     The X Gate controlled on 3 qubits
     """
@@ -116,7 +109,7 @@ class C3XGate(ControlledGateWithState):  # type: ignore[misc]
         return 2
 
 
-class C4XGate(ControlledGateWithState):  # type: ignore[misc]
+class C4XGate(ControlledGate):  # type: ignore[misc]
     """
     The X Gate controlled on 4 qubits
     """
@@ -128,7 +121,7 @@ class C4XGate(ControlledGateWithState):  # type: ignore[misc]
         return 2
 
 
-class CYGate(ControlledGateWithState):  # type: ignore[misc]
+class CYGate(ControlledGate):  # type: ignore[misc]
     """
     The Controlled-Y Gate
     """
@@ -137,7 +130,7 @@ class CYGate(ControlledGateWithState):  # type: ignore[misc]
         return 2
 
 
-class CZGate(ControlledGateWithState):  # type: ignore[misc]
+class CZGate(ControlledGate):  # type: ignore[misc]
     """
     The Controlled-Z Gate
     """
@@ -146,7 +139,7 @@ class CZGate(ControlledGateWithState):  # type: ignore[misc]
         return 2
 
 
-class CHGate(ControlledGateWithState):  # type: ignore[misc]
+class CHGate(ControlledGate):  # type: ignore[misc]
     """
     The Controlled-H Gate
     """
@@ -155,7 +148,7 @@ class CHGate(ControlledGateWithState):  # type: ignore[misc]
         return 2
 
 
-class CSXGate(ControlledGateWithState):  # type: ignore[misc]
+class CSXGate(ControlledGate):  # type: ignore[misc]
     """
     The Controlled-SX Gate
     """
@@ -164,25 +157,25 @@ class CSXGate(ControlledGateWithState):  # type: ignore[misc]
         return 4
 
 
-class CRXGate(ControlledGateWithState, angles=["theta"]):  # type: ignore[misc]
+class CRXGate(ControlledGate, angles=["theta"]):  # type: ignore[misc]
     """
     The Controlled-RX Gate
     """
 
 
-class CRYGate(ControlledGateWithState, angles=["theta"]):  # type: ignore[misc]
+class CRYGate(ControlledGate, angles=["theta"]):  # type: ignore[misc]
     """
     The Controlled-RY Gate
     """
 
 
-class CRZGate(ControlledGateWithState, angles=["theta"]):  # type: ignore[misc]
+class CRZGate(ControlledGate, angles=["theta"]):  # type: ignore[misc]
     """
     The Controlled-RZ Gate
     """
 
 
-class CPhaseGate(ControlledGateWithState, angles=["theta"]):  # type: ignore[misc]
+class CPhaseGate(ControlledGate, angles=["theta"]):  # type: ignore[misc]
     """
     The Controlled-Phase Gate
     """

classiq/interface/generator/standard_gates/standard_angle_metaclass.py

@@ -2,7 +2,7 @@ from typing import Any
 
 import pydantic
 
-from classiq.interface.generator.parameters import ParameterFloatType
+from classiq.interface.generator.function_params import FunctionParamsNumericParameter
 
 PydanticMetaClass: Any = type(pydantic.BaseModel)
 
@@ -16,14 +16,10 @@ class MyMetaAngledClass(type):
     @staticmethod
     def _create_new_namespace(namespace: dict, **kwargs: Any) -> dict:
         angles = kwargs.get("angles", [])
-        annotations = {angle: ParameterFloatType for angle in angles}
-        fields = {
-            angle: pydantic.fields.FieldInfo(is_exec_param=True) for angle in angles
-        }
+        annotations = {angle: FunctionParamsNumericParameter for angle in angles}
         original_annotations = namespace.get("__annotations__", {})
         return {
             **namespace,
-            **fields,
             **{"__annotations__": {**original_annotations, **annotations}},
         }
 

classiq/interface/generator/standard_gates/standard_gates.py

@@ -1,4 +1,4 @@
-from typing import Any, List, Literal, Optional
+from typing import Any, Literal, Optional
 
 import pydantic
 
@@ -13,7 +13,7 @@ To add new standard gates, refer to the following guide
 https://docs.google.com/document/d/1Nt9frxnPkSn8swNpOQ983E95eaEiDWaiuWAKglGtUAA/edit#heading=h.e9g9309bzkxt
 """
 
-_POSSIBLE_PARAMETERS: List[str] = ["theta", "phi", "lam"]
+_POSSIBLE_PARAMETERS: list[str] = ["theta", "phi", "lam"]
 DEFAULT_STANDARD_GATE_ARG_NAME: str = "TARGET"
 
 
@@ -39,7 +39,7 @@ class _StandardGate(FunctionParams, metaclass=MyMetaAngledClassModel):  # type:
         return self._num_target_qubits
 
     def __init_subclass__(
-        cls, angles: Optional[List[str]] = None, **kwargs: Any
+        cls, angles: Optional[list[str]] = None, **kwargs: Any
     ) -> None:
         super().__init_subclass__(**kwargs)
 

classiq/interface/generator/standard_gates/u_gate.py

@@ -2,7 +2,7 @@ import pydantic
 
 from classiq.interface.generator import function_params
 from classiq.interface.generator.arith.register_user_input import RegisterUserInput
-from classiq.interface.generator.parameters import ParameterFloatType
+from classiq.interface.generator.function_params import FunctionParamsNumericParameter
 from classiq.interface.generator.standard_gates.standard_gates import (
     DEFAULT_STANDARD_GATE_ARG_NAME,
 )
@@ -18,24 +18,20 @@ class UGate(function_params.FunctionParams):
     e^(i*phi)*sin(theta/2) & e^(i*(phi+lam))*cos(theta/2) \\
     """
 
-    theta: ParameterFloatType = pydantic.Field(
+    theta: FunctionParamsNumericParameter = pydantic.Field(
         description="Angle to rotate by the Y-axis.",
-        is_exec_param=True,
     )
 
-    phi: ParameterFloatType = pydantic.Field(
+    phi: FunctionParamsNumericParameter = pydantic.Field(
         description="First angle to rotate by the Z-axis.",
-        is_exec_param=True,
     )
 
-    lam: ParameterFloatType = pydantic.Field(
+    lam: FunctionParamsNumericParameter = pydantic.Field(
         description="Second angle to rotate by the Z-axis.",
-        is_exec_param=True,
     )
 
-    gam: ParameterFloatType = pydantic.Field(
+    gam: FunctionParamsNumericParameter = pydantic.Field(
         description="Angle to apply phase gate by.",
-        is_exec_param=True,
     )
 
     _inputs = pydantic.PrivateAttr(
@@ -56,5 +52,6 @@ class UGate(function_params.FunctionParams):
     @property
     def is_parametric(self) -> bool:
         return not all(
-            isinstance(getattr(self, angle), (float, int)) for angle in self._params
+            isinstance(getattr(self, angle), (float, int))
+            for angle in ["theta", "phi", "lam", "gam"]
         )

classiq/interface/generator/state_preparation/bell_state_preparation.py

@@ -1,4 +1,4 @@
-from typing import FrozenSet, Literal
+from typing import Literal
 
 import pydantic
 
@@ -7,8 +7,8 @@ from classiq.interface.generator.state_preparation.state_preparation_abc import
 )
 
 BellStateName = Literal["psi+", "psi-", "phi+", "phi-"]
-_ALIGNED_STATES: FrozenSet[BellStateName] = frozenset({"phi+", "phi-"})
-_SIGNED_STATES: FrozenSet[BellStateName] = frozenset({"psi-", "phi-"})
+_ALIGNED_STATES: frozenset[BellStateName] = frozenset({"phi+", "phi-"})
+_SIGNED_STATES: frozenset[BellStateName] = frozenset({"psi-", "phi-"})
 
 
 class BellStatePreparation(StatePreparationABC):

classiq/interface/generator/state_preparation/computational_basis_state_preparation.py

@@ -12,7 +12,8 @@ class ComputationalBasisStatePreparation(StatePreparationABC):
         description="binary computational state to create"
     )
 
-    @pydantic.validator("computational_state")
+    @pydantic.field_validator("computational_state")
+    @classmethod
     def _validate_computational_state(
         cls, computational_state: PydanticNonEmptyString
     ) -> PydanticNonEmptyString:

classiq/interface/generator/state_preparation/distributions.py

@@ -1,7 +1,9 @@
-from typing import Collection, Tuple, Union
+from collections.abc import Collection, Sequence
+from typing import Union
 
 import pydantic
 from numpy.typing import ArrayLike
+from pydantic import ConfigDict
 
 from classiq.interface.generator.validations.validator_functions import (
     validate_probabilities,
@@ -10,36 +12,35 @@ from classiq.interface.helpers.custom_pydantic_types import PydanticProbabilityF
 
 
 class PMF(pydantic.BaseModel):
-    pmf: Tuple[PydanticProbabilityFloat, ...]
-    _validate_amplitudes = pydantic.validator("pmf", allow_reuse=True)(
-        validate_probabilities
-    )
+    pmf: tuple[PydanticProbabilityFloat, ...]
+
+    @pydantic.field_validator("pmf")
+    @classmethod
+    def _validate_pmf(
+        cls, pmf: tuple[PydanticProbabilityFloat, ...]
+    ) -> Sequence[PydanticProbabilityFloat]:
+        return validate_probabilities(cls, pmf)
 
-    class Config:
-        frozen = True
+    model_config = ConfigDict(frozen=True)
 
 
 class GaussianMoments(pydantic.BaseModel):
     mu: float
     sigma: pydantic.PositiveFloat
-
-    class Config:
-        frozen = True
+    model_config = ConfigDict(frozen=True)
 
 
 class GaussianMixture(pydantic.BaseModel):
-    gaussian_moment_list: Tuple[GaussianMoments, ...]
+    gaussian_moment_list: tuple[GaussianMoments, ...]
     num_qubits: pydantic.PositiveInt = pydantic.Field(
         description="Number of qubits for the provided state."
     )
-
-    class Config:
-        frozen = True
+    model_config = ConfigDict(frozen=True)
 
 
 Probabilities = Union[PMF, GaussianMixture]
 FlexibleProbabilities = Union[Probabilities, ArrayLike, dict, Collection[float]]
-Amplitudes = Tuple[float, ...]
+Amplitudes = tuple[float, ...]
 FlexibleAmplitudes = Union[ArrayLike, Collection[float]]
 Distribution = Union[Amplitudes, Probabilities]
 

classiq/interface/generator/state_preparation/metrics.py

@@ -1,16 +1,14 @@
-from typing import FrozenSet
-
+from classiq.interface.enum_utils import StrEnum
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.preferences.optimization import (
     StatePrepOptimizationMethod,
 )
 
-from classiq._internals.enum_utils import StrEnum
-
-_AMPLITUDE_SUPPORTING_METRICS: FrozenSet = frozenset(
+_AMPLITUDE_SUPPORTING_METRICS: frozenset = frozenset(
     {"L2", "L1", "MAX_PROBABILITY", "TOTAL_VARIATION"}
 )
 
-_ZERO_DIVERGENT_METRICS: FrozenSet = frozenset({"KL", "BHATTACHARYYA"})
+_ZERO_DIVERGENT_METRICS: frozenset = frozenset({"KL", "BHATTACHARYYA"})
 
 
 class Metrics(StrEnum):
@@ -30,7 +28,7 @@ class Metrics(StrEnum):
         try:
             return Metrics(sp_opt_method.value)
         except ValueError:
-            raise ValueError(
+            raise ClassiqValueError(
                 f"Failed to convert {sp_opt_method} to an error metric"
             ) from None
 

classiq/interface/generator/state_preparation/state_preparation.py

@@ -1,8 +1,11 @@
-from typing import Any, Dict, Optional, Union
+from typing import Optional, Union
 
 import numpy as np
 import pydantic
+from pydantic_core.core_schema import ValidationInfo
+from typing_extensions import Self
 
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.range_types import NonNegativeFloatRange
 from classiq.interface.generator.state_preparation.distributions import (
     PMF,
@@ -24,19 +27,24 @@ from classiq.interface.generator.validations.validator_functions import (
 
 class StatePreparation(StatePreparationABC):
     amplitudes: Optional[Amplitudes] = pydantic.Field(
-        description="vector of probabilities", default=None
+        description="vector of probabilities",
+        default=None,
+        validate_default=True,
     )
     probabilities: Optional[Probabilities] = pydantic.Field(
-        description="vector of amplitudes", default=None
+        description="vector of amplitudes",
+        default=None,
+        validate_default=True,
     )
-    error_metric: Dict[Metrics, NonNegativeFloatRange] = pydantic.Field(
+    error_metric: dict[Metrics, NonNegativeFloatRange] = pydantic.Field(
         default_factory=lambda: {
             Metrics.L2: NonNegativeFloatRange(lower_bound=0, upper_bound=1e-4)
         }
     )
     # The order of validations is important: amplitudes, probabilities, error_metric
 
-    @pydantic.validator("amplitudes", always=True, pre=True)
+    @pydantic.field_validator("amplitudes", mode="before")
+    @classmethod
     def _initialize_amplitudes(
         cls, amplitudes: Optional[FlexibleAmplitudes]
     ) -> Optional[Amplitudes]:
@@ -46,11 +54,12 @@ class StatePreparation(StatePreparationABC):
         if amplitudes.ndim == 1:
             return validate_amplitudes(tuple(amplitudes))
 
-        raise ValueError(
+        raise ClassiqValueError(
             "Invalid amplitudes were given, please ensure the amplitude is a vector of float in the form of either tuple or list or numpy array"
         )
 
-    @pydantic.validator("probabilities", always=True, pre=True)
+    @pydantic.field_validator("probabilities", mode="before")
+    @classmethod
     def _initialize_probabilities(
         cls, probabilities: Optional[FlexibleProbabilities]
     ) -> Optional[Union[PMF, GaussianMixture, dict]]:
@@ -64,15 +73,16 @@ class StatePreparation(StatePreparationABC):
         if probabilities.ndim == 1:
             return PMF(pmf=probabilities.tolist())
 
-        raise ValueError(
+        raise ClassiqValueError(
             "Invalid probabilities were given, please ensure the probabilities is a vector of float in the form of either tuple or list or numpy array"
         )
 
-    @pydantic.validator("error_metric", always=True, pre=True)
+    @pydantic.field_validator("error_metric", mode="before")
+    @classmethod
     def _validate_error_metric(
-        cls, error_metric: Dict[Metrics, NonNegativeFloatRange], values: Dict[str, Any]
-    ) -> Dict[Metrics, NonNegativeFloatRange]:
-        if not values.get("amplitudes"):
+        cls, error_metric: dict[Metrics, NonNegativeFloatRange], info: ValidationInfo
+    ) -> dict[Metrics, NonNegativeFloatRange]:
+        if not info.data.get("amplitudes"):
             return error_metric
         unsupported_metrics = {
             Metrics(metric).value
@@ -80,27 +90,24 @@ class StatePreparation(StatePreparationABC):
             if not Metrics(metric).supports_amplitudes
         }
         if unsupported_metrics:
-            raise ValueError(
+            raise ClassiqValueError(
                 f"{unsupported_metrics} are not supported for amplitude preparation"
             )
         return error_metric
 
-    @pydantic.root_validator
-    def _validate_either_probabilities_or_amplitudes(
-        cls,
-        values: Dict[str, Any],
-    ) -> Optional[Union[PMF, GaussianMixture, dict]]:
-        amplitudes = values.get("amplitudes")
-        probabilities = values.get("probabilities")
+    @pydantic.model_validator(mode="after")
+    def _validate_either_probabilities_or_amplitudes(self) -> Self:
+        amplitudes = self.amplitudes
+        probabilities = self.probabilities
         if amplitudes is not None and probabilities is not None:
-            raise ValueError(
+            raise ClassiqValueError(
                 "StatePreparation can't get both probabilities and amplitudes"
             )
-        return values
+        return self
 
     @property
     def num_state_qubits(self) -> int:
         distribution = self.probabilities or self.amplitudes
         if distribution is None:
-            raise ValueError("Must have either probabilities or amplitudes")
+            raise ClassiqValueError("Must have either probabilities or amplitudes")
         return num_of_qubits(distribution)

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/generator/synthesis_metadata/synthesis_execution_data.py

@@ -1,25 +1,39 @@
-from typing import Dict, Optional, Set
+from typing import Optional
 
 import pydantic
+import sympy
 
 from classiq.interface.backend.pydantic_backend import PydanticExecutionParameter
+from classiq.interface.exceptions import ClassiqValueError
+from classiq.interface.generator.parameters import ParameterType
 
 
 class FunctionExecutionData(pydantic.BaseModel):
-    power_parameter: Optional[PydanticExecutionParameter] = pydantic.Field(default=None)
+    power_parameter: Optional[ParameterType] = pydantic.Field(default=None)
+
+    @property
+    def power_var(self) -> Optional[str]:
+        if self.power_parameter is None:
+            return None
+        power_vars = sympy.sympify(self.power_parameter).free_symbols
+        if len(power_vars) != 1:
+            raise ClassiqValueError(
+                f"Power parameter expression: {self.power_parameter} must contain exactly one variable"
+            )
+        return str(list(power_vars)[0])
 
 
 class ExecutionData(pydantic.BaseModel):
-    function_execution: Dict[str, FunctionExecutionData] = pydantic.Field(
+    function_execution: dict[str, FunctionExecutionData] = pydantic.Field(
         default_factory=dict
     )
 
     @property
     def execution_parameters(
         self,
-    ) -> Set[PydanticExecutionParameter]:
+    ) -> set[PydanticExecutionParameter]:
         return {
-            function_execution_data.power_parameter
+            function_execution_data.power_var
             for function_execution_data in self.function_execution.values()
-            if function_execution_data.power_parameter is not None
+            if function_execution_data.power_var is not None
         }