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

classiq/interface/generator/quantum_function_call.py

@@ -6,24 +6,25 @@ import random
 import re
 import string
 from collections import defaultdict
+from collections.abc import Iterable, Mapping, Sequence
+from re import Match
 from typing import (
     Any,
-    Dict,
-    Iterable,
-    List,
-    Mapping,
-    Match,
     Optional,
-    Sequence,
-    Tuple,
     Union,
 )
+from uuid import UUID, uuid4
 
 import pydantic
-from pydantic import BaseModel, Extra
+from pydantic import BaseModel, ConfigDict
+from pydantic_core.core_schema import ValidationInfo
 
+from classiq.interface.exceptions import ClassiqControlError, ClassiqValueError
 from classiq.interface.generator import function_param_list, function_params as f_params
 from classiq.interface.generator.arith.arithmetic import Arithmetic
+from classiq.interface.generator.compiler_keywords import (
+    generate_original_function_name,
+)
 from classiq.interface.generator.control_state import ControlState
 from classiq.interface.generator.function_params import (
     NAME_REGEX,
@@ -46,8 +47,6 @@ from classiq.interface.helpers.hashable_pydantic_base_model import (
     HashablePydanticBaseModel,
 )
 
-from classiq.exceptions import ClassiqControlError, ClassiqValueError
-
 DEFAULT_SUFFIX_LEN: int = 6
 BAD_INPUT_ERROR_MSG = "Bad input name given"
 BAD_OUTPUT_ERROR_MSG = "Bad output name given"
@@ -62,7 +61,7 @@ LEGAL_SLICING = rf"(\-?\d+)?({SEPARATOR}(\-?\d+)?)?({SEPARATOR}(\-?\d+)?)?"
 
 _ALPHANUM_CHARACTERS = string.ascii_letters + string.digits
 
-RegNameAndSlice = Tuple[str, slice]
+RegNameAndSlice = tuple[str, slice]
 
 ZERO_INDICATOR = "0"
 INVERSE_SUFFIX = "_qinverse"
@@ -79,25 +78,24 @@ class WirePair(HashablePydanticBaseModel):
     out_wire: WireName
 
 
-SUFFIX_RANDOMIZER = random.Random()  # nosec B311
+SUFFIX_RANDOMIZER = random.Random()  # noqa: S311
 
 
 def split_wire_pair_to_wires(
     inout: WirePair,
-) -> Tuple[WireName, WireName]:
+) -> tuple[WireName, WireName]:
     return inout.in_wire, inout.out_wire
 
 
 def randomize_suffix(suffix_len: int = DEFAULT_SUFFIX_LEN) -> str:
     return "".join(
-        SUFFIX_RANDOMIZER.choice(_ALPHANUM_CHARACTERS)
-        for _ in range(suffix_len)  # nosec B311
+        SUFFIX_RANDOMIZER.choice(_ALPHANUM_CHARACTERS) for _ in range(suffix_len)
     )
 
 
 def get_non_zero_wires(
     wires: Iterable[WireName],
-) -> List[WireName]:
+) -> list[WireName]:
     return [wire for wire in wires if wire != ZERO_INDICATOR]
 
 
@@ -121,7 +119,7 @@ class SynthesisQuantumFunctionCall(BaseModel):
     release_by_inverse: bool = pydantic.Field(
         default=False, description="Release zero inputs in inverse call."
     )
-    control_states: List[ControlState] = pydantic.Field(
+    control_states: list[ControlState] = pydantic.Field(
         default_factory=list,
         description="Call the controlled function with the given controlled states.",
     )
@@ -146,9 +144,15 @@ class SynthesisQuantumFunctionCall(BaseModel):
     )
     name: PydanticNonEmptyString = pydantic.Field(
         default=None,
+        validate_default=True,
         description="The name of the function instance. "
         "If not set, determined automatically.",
     )
+    source_id: Optional[UUID] = pydantic.Field(default=None)
+    arithmetic_id: Optional[str] = pydantic.Field(default=None)
+    inverse_op_id: Optional[UUID] = pydantic.Field(default=None)
+
+    uuid: UUID = pydantic.Field(default_factory=uuid4)
 
     def __eq__(self, other: Any) -> bool:
         return (
@@ -159,14 +163,14 @@ class SynthesisQuantumFunctionCall(BaseModel):
         return hash(self.name)
 
     @property
-    def non_zero_input_wires(self) -> List[WireName]:
+    def non_zero_input_wires(self) -> list[WireName]:
         in_out_input_wires = [
             split_wire_pair_to_wires(inout)[0] for inout in self.inouts.values()
         ]
         return get_non_zero_wires(self.inputs_dict.values()) + in_out_input_wires
 
     @property
-    def non_zero_output_wires(self) -> List[WireName]:
+    def non_zero_output_wires(self) -> list[WireName]:
         in_out_output_wires = [
             split_wire_pair_to_wires(inout)[1] for inout in self.inouts.values()
         ]
@@ -209,8 +213,9 @@ class SynthesisQuantumFunctionCall(BaseModel):
             return self.function_params.inputs_full(self.strict_zero_ios)
         return self.function_params.outputs
 
-    @pydantic.validator("name", pre=True, always=True)
-    def _create_name(cls, name: Optional[str], values: Dict[str, Any]) -> str:
+    @pydantic.field_validator("name", mode="before")
+    @classmethod
+    def _create_name(cls, name: Optional[str], info: ValidationInfo) -> str:
         """
         generates a name to a user defined-functions as follows:
         <function_name>_<SUFFIX_MARKER>_<random_suffix>
@@ -218,40 +223,48 @@ class SynthesisQuantumFunctionCall(BaseModel):
         if name is not None:
             match = re.fullmatch(pattern=NAME_REGEX, string=name)
             if match is None:
-                raise ValueError(BAD_CALL_NAME_ERROR_MSG)
+                raise ClassiqValueError(BAD_CALL_NAME_ERROR_MSG)
             return name
 
-        function = values.get("function")
+        function = info.data.get("function")
 
-        params = values.get("function_params")
-        if isinstance(params, CustomFunction):
-            if function == CustomFunction.discriminator() and params.name != "":
-                function = params.name
+        params = info.data.get("function_params")
+        if (
+            isinstance(params, CustomFunction)
+            and function == CustomFunction.discriminator()
+            and params.name != ""
+        ):
+            function = params.name
 
         suffix = f"{SUFFIX_MARKER}_{randomize_suffix()}"
         if not function or params is None:
             return name if name else suffix
-        return f"{function}_{suffix}"
+        return f"{generate_original_function_name(function)}_{suffix}"
 
-    @pydantic.root_validator(pre=True)
-    def validate_composite_name(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        if isinstance(values.get("unitary_params"), CustomFunction) and not values.get(
-            "unitary"
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def validate_composite_name(cls, values: Any) -> dict[str, Any]:
+        if (
+            isinstance(values, dict)
+            and isinstance(values.get("unitary_params"), CustomFunction)
+            and not values.get("unitary")
         ):
             raise ClassiqValueError(
                 "`PhaseEstimation` of a user define function (`CustomFunction`) must receive the function name from the `unitary` field"
             )
         return values
 
-    @pydantic.root_validator(pre=True)
-    def _parse_function_params(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        f_params.parse_function_params_values(
-            values=values,
-            params_key="function_params",
-            discriminator_key="function",
-            param_classes=function_param_list.function_param_library.param_list,
-            default_parser_class=CustomFunction,
-        )
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def _parse_function_params(cls, values: Any) -> dict[str, Any]:
+        if isinstance(values, dict):
+            f_params.parse_function_params_values(
+                values=values,
+                params_key="function_params",
+                discriminator_key="function",
+                param_classes=function_param_list.function_param_library.param_list,
+                default_parser_class=CustomFunction,
+            )
         return values
 
     # TODO: note that this checks QuantumFunctionCall input register names
@@ -263,7 +276,7 @@ class SynthesisQuantumFunctionCall(BaseModel):
         params: f_params.FunctionParams,
         inputs: WireDict,
         is_inverse: bool,
-        control_states: List[ControlState],
+        control_states: list[ControlState],
         strict_zero_ios: bool,
     ) -> None:
         (
@@ -285,24 +298,27 @@ class SynthesisQuantumFunctionCall(BaseModel):
         if invalid_slicings:
             error_msg.append(f"{BAD_INPUT_SLICING_MSG}: {invalid_slicings}")
         if error_msg:
-            raise ValueError("\n".join(error_msg))
+            raise ClassiqValueError("\n".join(error_msg))
 
-    @pydantic.validator("strict_zero_ios")
+    @pydantic.field_validator("strict_zero_ios")
+    @classmethod
     def _validate_arithmetic_cannot_strict_zero_ios(
-        cls, strict_zero_ios: bool, values: Dict[str, Any]
+        cls, strict_zero_ios: bool, info: ValidationInfo
     ) -> bool:
         assert not (
-            values.get("function") == Arithmetic.discriminator() and not strict_zero_ios
+            info.data.get("function") == Arithmetic.discriminator()
+            and not strict_zero_ios
         ), "when using the Arithmetic function, assign to the expression result register via the target parameter instead of the strict_zero_ios flag"
         return strict_zero_ios
 
-    @pydantic.validator("control_states")
+    @pydantic.field_validator("control_states")
+    @classmethod
     def _validate_control_states(
-        cls, control_states: List[ControlState], values: Dict[str, Any]
-    ) -> List[ControlState]:
+        cls, control_states: list[ControlState], info: ValidationInfo
+    ) -> list[ControlState]:
         control_names = [ctrl_state.name for ctrl_state in control_states]
-        function_params = values.get("function_params")
-        strict_zero_ios = values.get("strict_zero_ios")
+        function_params = info.data.get("function_params")
+        strict_zero_ios = info.data.get("strict_zero_ios")
         if not (
             isinstance(function_params, FunctionParams)
             and isinstance(strict_zero_ios, bool)
@@ -330,10 +346,10 @@ class SynthesisQuantumFunctionCall(BaseModel):
         inputs: IOType,
         fp: FunctionParams,
         strict_zero_ios: bool,
-        control_states: List[ControlState],
+        control_states: list[ControlState],
     ) -> None:
         name_slice_pairs = [parse_io_slicing(input) for input in inputs]
-        slices_dict: Dict[str, List[slice]] = defaultdict(list)
+        slices_dict: dict[str, list[slice]] = defaultdict(list)
         for name, slice in name_slice_pairs:
             slices_dict[name].append(slice)
 
@@ -352,10 +368,10 @@ class SynthesisQuantumFunctionCall(BaseModel):
             if not SynthesisQuantumFunctionCall._register_validate_slices(
                 slices_dict[name], widths[name]
             ):
-                raise ValueError(BAD_INPUT_SLICING_MSG)
+                raise ClassiqValueError(BAD_INPUT_SLICING_MSG)
 
     @staticmethod
-    def _register_validate_slices(slices: List[slice], reg_width: int) -> bool:
+    def _register_validate_slices(slices: list[slice], reg_width: int) -> bool:
         widths_separated = [len(range(reg_width)[reg_slice]) for reg_slice in slices]
         # examples: slice(0), slice(5,None) when width <= 5, slice(5,3)
         empty_slices = 0 in widths_separated
@@ -374,17 +390,18 @@ class SynthesisQuantumFunctionCall(BaseModel):
 
         return not any((empty_slices, out_of_range, overlapping_slices))
 
-    @pydantic.validator("inputs")
-    def _validate_inputs(cls, inputs: IOType, values: Dict[str, Any]) -> WireDict:
-        params: Optional[FunctionParams] = values.get("function_params")
-        is_inverse: bool = values.get("is_inverse", False)
-        strict_zero_ios: bool = values.get("strict_zero_ios", True)
-        control_states: List[ControlState] = values.get("control_states", list())
+    @pydantic.field_validator("inputs", mode="before")
+    @classmethod
+    def _validate_inputs(cls, inputs: IOType, info: ValidationInfo) -> WireDict:
+        params: Optional[FunctionParams] = info.data.get("function_params")
+        is_inverse: bool = info.data.get("is_inverse", False)
+        strict_zero_ios: bool = info.data.get("strict_zero_ios", True)
+        control_states: list[ControlState] = info.data.get("control_states", list())
         if params is None:
             return dict()
         if isinstance(params, CustomFunction):
             if not isinstance(inputs, dict):
-                raise ValueError(CUSTOM_FUNCTION_SINGLE_IO_ERROR)
+                raise ClassiqValueError(CUSTOM_FUNCTION_SINGLE_IO_ERROR)
             return inputs
 
         if isinstance(inputs, str):
@@ -420,7 +437,7 @@ class SynthesisQuantumFunctionCall(BaseModel):
         params: f_params.FunctionParams,
         outputs: WireDict,
         is_inverse: bool,
-        control_states: List[ControlState],
+        control_states: list[ControlState],
         strict_zero_ios: bool,
     ) -> None:
         (
@@ -442,19 +459,20 @@ class SynthesisQuantumFunctionCall(BaseModel):
         if invalid_slicings:
             error_msg.append(f"{BAD_OUTPUT_SLICING_MSG}: {invalid_slicings}")
         if error_msg:
-            raise ValueError("\n".join(error_msg))
-
-    @pydantic.validator("outputs")
-    def _validate_outputs(cls, outputs: IOType, values: Dict[str, Any]) -> IOType:
-        params = values.get("function_params")
-        is_inverse: bool = values.get("is_inverse", False)
-        strict_zero_ios: bool = values.get("strict_zero_ios", True)
-        control_states = values.get("control_states", list())
+            raise ClassiqValueError("\n".join(error_msg))
+
+    @pydantic.field_validator("outputs", mode="before")
+    @classmethod
+    def _validate_outputs(cls, outputs: IOType, info: ValidationInfo) -> IOType:
+        params = info.data.get("function_params")
+        is_inverse: bool = info.data.get("is_inverse", False)
+        strict_zero_ios: bool = info.data.get("strict_zero_ios", True)
+        control_states = info.data.get("control_states", list())
         if params is None:
             return outputs
         if isinstance(params, CustomFunction):
             if not isinstance(outputs, dict):
-                raise ValueError(CUSTOM_FUNCTION_SINGLE_IO_ERROR)
+                raise ClassiqValueError(CUSTOM_FUNCTION_SINGLE_IO_ERROR)
             return outputs
 
         if isinstance(outputs, str):
@@ -484,17 +502,18 @@ class SynthesisQuantumFunctionCall(BaseModel):
 
         return outputs
 
-    @pydantic.validator("power", always=True)
+    @pydantic.field_validator("power")
+    @classmethod
     def _validate_power(
-        cls, power: pydantic.NonNegativeInt, values: Dict[str, Any]
+        cls, power: pydantic.NonNegativeInt, info: ValidationInfo
     ) -> pydantic.NonNegativeInt:
-        function_params = values.get("function_params")
+        function_params = info.data.get("function_params")
         if function_params is None:
             return power
         if power != 1 and not function_params.is_powerable(
-            values.get("strict_zero_ios")
+            info.data.get("strict_zero_ios")
         ):
-            raise ValueError("Cannot power this operator")
+            raise ClassiqValueError("Cannot power this operator")
         return power
 
     @staticmethod
@@ -519,7 +538,7 @@ class SynthesisQuantumFunctionCall(BaseModel):
             io_wire=io_wire,
             function_name=type(params).__name__,
         )
-        raise ValueError(error_message)
+        raise ClassiqValueError(error_message)
 
     @staticmethod
     def _get_invalid_ios(
@@ -527,15 +546,15 @@ class SynthesisQuantumFunctionCall(BaseModel):
         expressions: Iterable[str],
         params: f_params.FunctionParams,
         io: f_params.PortDirection,
-        control_states: List[ControlState],
+        control_states: list[ControlState],
         strict_zero_ios: bool,
-    ) -> Tuple[List[str], List[str], List[str]]:
+    ) -> tuple[list[str], list[str], list[str]]:
         expression_matches: Iterable[Optional[Match]] = map(
             functools.partial(re.fullmatch, IO_REGEX), expressions
         )
 
-        valid_matches: List[Match] = []
-        invalid_expressions: List[str] = []
+        valid_matches: list[Match] = []
+        invalid_expressions: list[str] = []
         for expression, expression_match in zip(expressions, expression_matches):
             (
                 invalid_expressions.append(expression)
@@ -543,8 +562,8 @@ class SynthesisQuantumFunctionCall(BaseModel):
                 else valid_matches.append(expression_match)
             )
 
-        invalid_slicings: List[str] = []
-        invalid_names: List[str] = []
+        invalid_slicings: list[str] = []
+        invalid_names: list[str] = []
         valid_names = frozenset(
             params.inputs_full(strict_zero_ios)
             if io == PortDirection.Input
@@ -610,7 +629,9 @@ class SynthesisQuantumFunctionCall(BaseModel):
             control_state.name in self.inputs_dict
             or control_state.name in self.outputs_dict
         ):
-            raise ValueError(f"Control name: {control_state.name} already exists")
+            raise ClassiqValueError(
+                f"Control name: {control_state.name} already exists"
+            )
 
         inputs, outputs = dict(self.inputs_dict), dict(self.outputs_dict)
         inputs.update({control_state.name: input_wire})
@@ -623,8 +644,7 @@ class SynthesisQuantumFunctionCall(BaseModel):
         call_kwargs["control_states"] = self.control_states + [control_state]
         return SynthesisQuantumFunctionCall(**call_kwargs)
 
-    class Config:
-        extra = Extra.forbid
+    model_config = ConfigDict(extra="forbid")
 
 
 def _generate_single_io_err(

classiq/interface/generator/{generated_circuit.py → quantum_program.py}

@@ -1,12 +1,17 @@
 import uuid
-from datetime import datetime
+from datetime import datetime, timezone
 from pathlib import Path
-from typing import Dict, List, Optional, Tuple, Union
+from typing import Optional, Union
 
 import pydantic
 from typing_extensions import TypeAlias
 
-from classiq.interface.executor import quantum_program
+from classiq.interface.exceptions import (
+    ClassiqMissingOutputFormatError,
+    ClassiqStateInitializationError,
+)
+from classiq.interface.execution.primitives import PrimitivesInput
+from classiq.interface.executor import quantum_code
 from classiq.interface.executor.quantum_instruction_set import QuantumInstructionSet
 from classiq.interface.executor.register_initialization import RegisterInitialization
 from classiq.interface.generator.circuit_code.circuit_code import CircuitCodeInterface
@@ -17,31 +22,26 @@ from classiq.interface.generator.circuit_code.types_and_constants import (
     CodeAndSyntax,
 )
 from classiq.interface.generator.generated_circuit_data import (
-    FunctionDebugInfo,
+    FunctionDebugInfoInterface,
     GeneratedCircuitData,
 )
 from classiq.interface.generator.hardware.hardware_data import SynthesisHardwareData
-from classiq.interface.generator.model.model import ExecutionModel, SynthesisModel
+from classiq.interface.generator.model.model import ExecutionModel
 from classiq.interface.generator.synthesis_metadata.synthesis_duration import (
     SynthesisStepDurations,
 )
 from classiq.interface.helpers.versioned_model import VersionedModel
-from classiq.interface.ide.ide_data import CircuitMetrics
-
-from classiq.exceptions import (
-    ClassiqMissingOutputFormatError,
-    ClassiqStateInitializationError,
-)
+from classiq.interface.ide.visual_model import CircuitMetrics
 
 RegisterName: TypeAlias = str
-InitialConditions: TypeAlias = Dict[RegisterName, int]
+InitialConditions: TypeAlias = dict[RegisterName, int]
 
 
 class TranspiledCircuitData(CircuitCodeInterface):
     depth: int
-    count_ops: Dict[str, int]
-    logical_to_physical_input_qubit_map: List[int]
-    logical_to_physical_output_qubit_map: List[int]
+    count_ops: dict[str, int]
+    logical_to_physical_input_qubit_map: list[int]
+    logical_to_physical_output_qubit_map: list[int]
 
     def get_circuit_metrics(self) -> CircuitMetrics:
         return CircuitMetrics(depth=self.depth, count_ops=self.count_ops)
@@ -51,16 +51,25 @@ def get_uuid_as_str() -> str:
     return str(uuid.uuid4())
 
 
-class GeneratedCircuit(VersionedModel, CircuitCodeInterface):
+def _get_formatted_utc_current_time() -> str:
+    # The purpose of this method is to replicate the behavior of
+    # datetime.utcnow().isoformat(), since `utcnow` is now deprecated
+    return datetime.now(timezone.utc).isoformat().split("+")[0]
+
+
+class QuantumProgram(VersionedModel, CircuitCodeInterface):
     hardware_data: SynthesisHardwareData
-    initial_values: Optional[InitialConditions]
+    initial_values: Optional[InitialConditions] = pydantic.Field(default=None)
     data: GeneratedCircuitData
-    model: SynthesisModel
-    transpiled_circuit: Optional[TranspiledCircuitData]
-    creation_time: str = pydantic.Field(default_factory=datetime.utcnow().isoformat)
-    synthesis_duration: Optional[SynthesisStepDurations]
-    debug_info: Optional[List[FunctionDebugInfo]]
+    model: ExecutionModel
+    transpiled_circuit: Optional[TranspiledCircuitData] = pydantic.Field(default=None)
+    creation_time: str = pydantic.Field(default_factory=_get_formatted_utc_current_time)
+    synthesis_duration: Optional[SynthesisStepDurations] = pydantic.Field(default=None)
+    debug_info: Optional[list[FunctionDebugInfoInterface]] = pydantic.Field(
+        default=None
+    )
     program_id: str = pydantic.Field(default_factory=get_uuid_as_str)
+    execution_primitives_input: Optional[PrimitivesInput] = pydantic.Field(default=None)
 
     def _hardware_agnostic_program_code(self) -> CodeAndSyntax:
         circuit_code = self.program_circuit.get_code_by_priority()
@@ -81,15 +90,15 @@ class GeneratedCircuit(VersionedModel, CircuitCodeInterface):
         )
         return self.program_circuit.get_code(instruction_set), instruction_set
 
-    def to_base_program(self) -> quantum_program.QuantumBaseProgram:
+    def to_base_program(self) -> quantum_code.QuantumBaseCode:
         code, syntax = self._default_program_code()
-        return quantum_program.QuantumBaseProgram(code=code, syntax=syntax)
+        return quantum_code.QuantumBaseCode(code=code, syntax=syntax)
 
     def to_program(
         self,
         initial_values: Optional[InitialConditions] = None,
         instruction_set: Optional[QuantumInstructionSet] = None,
-    ) -> quantum_program.QuantumProgram:
+    ) -> quantum_code.QuantumCode:
         initial_values = initial_values or self.initial_values
 
         if instruction_set is not None:
@@ -106,7 +115,7 @@ class GeneratedCircuit(VersionedModel, CircuitCodeInterface):
             )
         else:
             registers_initialization = None
-        return quantum_program.QuantumProgram(
+        return quantum_code.QuantumCode(
             code=code,
             syntax=syntax,
             output_qubits_map=self.data.qubit_mapping.physical_outputs,
@@ -114,7 +123,7 @@ class GeneratedCircuit(VersionedModel, CircuitCodeInterface):
             synthesis_execution_data=self.data.execution_data,
         )
 
-    def _get_initialization_qubits(self, name: str) -> Tuple[int, ...]:
+    def _get_initialization_qubits(self, name: str) -> tuple[int, ...]:
         qubits = self.data.qubit_mapping.logical_inputs.get(name)
         if qubits is None:
             raise ClassiqStateInitializationError(
@@ -124,7 +133,7 @@ class GeneratedCircuit(VersionedModel, CircuitCodeInterface):
 
     def get_registers_initialization(
         self, initial_values: InitialConditions
-    ) -> Dict[RegisterName, RegisterInitialization]:
+    ) -> dict[RegisterName, RegisterInitialization]:
         return {
             name: RegisterInitialization(
                 name=name,
@@ -136,11 +145,10 @@ class GeneratedCircuit(VersionedModel, CircuitCodeInterface):
 
     def save_results(self, filename: Optional[Union[str, Path]] = None) -> None:
         """
-        Saves generated circuit results as json.
+        Saves quantum program results as json into a file.
             Parameters:
                 filename (Union[str, Path]): Optional, path + filename of file.
                                              If filename supplied add `.json` suffix.
-
             Returns:
                   None
         """
@@ -148,11 +156,20 @@ class GeneratedCircuit(VersionedModel, CircuitCodeInterface):
             filename = f"synthesised_circuit_{self.creation_time}.json"
 
         with open(filename, "w") as file:
-            file.write(self.json(indent=4))
+            file.write(self.model_dump_json(indent=4))
 
     @classmethod
-    def from_qprog(cls, qprog: str) -> "GeneratedCircuit":
-        return cls.parse_raw(qprog)
+    def from_qprog(cls, qprog: str) -> "QuantumProgram":
+        """
+        Creates a `QuantumProgram` instance from a raw quantum program string.
+
+        Args:
+            qprog: The raw quantum program in string format.
+
+        Returns:
+            QuantumProgram: The `QuantumProgram` instance.
+        """
+        return cls.model_validate_json(qprog)
 
     @property
     def _can_use_transpiled_code(self) -> bool:
@@ -165,7 +182,3 @@ class GeneratedCircuit(VersionedModel, CircuitCodeInterface):
             if self.transpiled_circuit and self._can_use_transpiled_code
             else self
         )
-
-    @property
-    def execution_model(self) -> ExecutionModel:
-        return self.model.classical_model()

classiq/interface/generator/range_types.py

@@ -1,8 +1,11 @@
 import math
-from typing import Any, Dict, Generic, Optional, TypeVar
+from typing import Generic, Optional, TypeVar
 
 import pydantic
-from pydantic.generics import GenericModel
+from pydantic import BaseModel, ConfigDict
+from typing_extensions import Self
+
+from classiq.interface.exceptions import ClassiqValueError
 
 RangeType = TypeVar("RangeType", int, float)
 
@@ -13,26 +16,24 @@ DEF_ATOL: float = 1e-08
 DEF_RTOL: float = 1e-05
 
 
-class Range(GenericModel, Generic[RangeType]):
+class Range(BaseModel, Generic[RangeType]):
     lower_bound: Optional[RangeType] = None
     upper_bound: Optional[RangeType] = None
+    model_config = ConfigDict(frozen=True)
 
-    class Config:
-        frozen = True
-
-    @pydantic.root_validator()
-    def _validate_bounds_order(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        lower_bound = values.get("lower_bound")
-        upper_bound = values.get("upper_bound")
+    @pydantic.model_validator(mode="after")
+    def _validate_bounds_order(self) -> Self:
+        lower_bound = self.lower_bound
+        upper_bound = self.upper_bound
 
         if (
             lower_bound is not None
             and upper_bound is not None
             and lower_bound > upper_bound
         ):
-            raise ValueError("lower bound must not be greater than upper bound")
+            raise ClassiqValueError("lower bound must not be greater than upper bound")
 
-        return values
+        return self
 
     def is_lower_bound_sat_by(
         self, value: float, atol: float = DEF_ATOL, rtol: float = DEF_RTOL