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

classiq/interface/generator/quantum_function_call.py

@@ -6,25 +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 EXPANDED_KEYWORD
+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,
@@ -47,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"
@@ -63,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"
@@ -80,12 +78,12 @@ class WirePair(HashablePydanticBaseModel):
     out_wire: WireName
 
 
-SUFFIX_RANDOMIZER = random.Random()
+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
 
 
@@ -97,7 +95,7 @@ def randomize_suffix(suffix_len: int = DEFAULT_SUFFIX_LEN) -> str:
 
 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>
@@ -221,9 +226,9 @@ class SynthesisQuantumFunctionCall(BaseModel):
                 raise ClassiqValueError(BAD_CALL_NAME_ERROR_MSG)
             return name
 
-        function = values.get("function")
+        function = info.data.get("function")
 
-        params = values.get("function_params")
+        params = info.data.get("function_params")
         if (
             isinstance(params, CustomFunction)
             and function == CustomFunction.discriminator()
@@ -234,27 +239,32 @@ class SynthesisQuantumFunctionCall(BaseModel):
         suffix = f"{SUFFIX_MARKER}_{randomize_suffix()}"
         if not function or params is None:
             return name if name else suffix
-        return f"{function.split(f'_{EXPANDED_KEYWORD}')[0]}_{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
@@ -266,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:
         (
@@ -290,22 +300,25 @@ class SynthesisQuantumFunctionCall(BaseModel):
         if 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)
@@ -333,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)
 
@@ -358,7 +371,7 @@ class SynthesisQuantumFunctionCall(BaseModel):
                 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
@@ -377,12 +390,13 @@ 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):
@@ -423,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:
         (
@@ -447,12 +461,13 @@ class SynthesisQuantumFunctionCall(BaseModel):
         if error_msg:
             raise ClassiqValueError("\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())
+    @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):
@@ -487,15 +502,16 @@ 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 ClassiqValueError("Cannot power this operator")
         return power
@@ -530,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)
@@ -546,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
@@ -628,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/quantum_program.py

@@ -1,11 +1,16 @@
 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.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
@@ -17,7 +22,7 @@ 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
@@ -26,22 +31,17 @@ 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())
 
 
+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: ExecutionModel
-    transpiled_circuit: Optional[TranspiledCircuitData]
-    creation_time: str = pydantic.Field(default_factory=datetime.utcnow().isoformat)
-    synthesis_duration: Optional[SynthesisStepDurations]
-    debug_info: Optional[List[FunctionDebugInfo]]
+    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()
@@ -114,7 +123,7 @@ class QuantumProgram(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 QuantumProgram(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 QuantumProgram(VersionedModel, CircuitCodeInterface):
 
     def save_results(self, filename: Optional[Union[str, Path]] = None) -> None:
         """
-        Saves quantum program 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 QuantumProgram(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) -> "QuantumProgram":
-        return cls.parse_raw(qprog)
+        """
+        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:

classiq/interface/generator/range_types.py

@@ -1,10 +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.exceptions import ClassiqValueError
+from classiq.interface.exceptions import ClassiqValueError
 
 RangeType = TypeVar("RangeType", int, float)
 
@@ -15,17 +16,15 @@ 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
@@ -34,7 +33,7 @@ class Range(GenericModel, Generic[RangeType]):
         ):
             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

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,10 +1,10 @@
 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
 
-from classiq.exceptions import ClassiqValueError
-
 NAME = "name"
 SLICING = "slicing"
 SEPARATOR = ":"
@@ -12,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")