classiq 0.53.0__py3-none-any.whl → 0.54.0__py3-none-any.whl

classiq/interface/generator/quantum_program.py

@@ -1,7 +1,7 @@
 import uuid
 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
@@ -31,17 +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.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)
@@ -65,7 +65,7 @@ class QuantumProgram(VersionedModel, CircuitCodeInterface):
     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(
+    debug_info: Optional[list[FunctionDebugInfoInterface]] = pydantic.Field(
         default=None
     )
     program_id: str = pydantic.Field(default_factory=get_uuid_as_str)
@@ -123,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(
@@ -133,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,

classiq/interface/generator/register_role.py

@@ -1,5 +1,3 @@
-from typing import Set
-
 from classiq.interface.enum_utils import StrEnum
 
 
@@ -13,7 +11,7 @@ class RegisterRole(StrEnum):
     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,
@@ -24,7 +22,7 @@ class RegisterRole(StrEnum):
         return roles
 
     @staticmethod
-    def input_roles() -> Set["RegisterRole"]:
+    def input_roles() -> set["RegisterRole"]:
         return {
             RegisterRole.INPUT,
             RegisterRole.ZERO_INPUT,

classiq/interface/generator/slice_parsing_utils.py

@@ -1,5 +1,6 @@
 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
@@ -11,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")

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/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/distributions.py

@@ -1,4 +1,5 @@
-from typing import Collection, Sequence, Tuple, Union
+from collections.abc import Collection, Sequence
+from typing import Union
 
 import pydantic
 from numpy.typing import ArrayLike
@@ -11,12 +12,12 @@ from classiq.interface.helpers.custom_pydantic_types import PydanticProbabilityF
 
 
 class PMF(pydantic.BaseModel):
-    pmf: Tuple[PydanticProbabilityFloat, ...]
+    pmf: tuple[PydanticProbabilityFloat, ...]
 
     @pydantic.field_validator("pmf")
     @classmethod
     def _validate_pmf(
-        cls, pmf: Tuple[PydanticProbabilityFloat, ...]
+        cls, pmf: tuple[PydanticProbabilityFloat, ...]
     ) -> Sequence[PydanticProbabilityFloat]:
         return validate_probabilities(cls, pmf)
 
@@ -30,7 +31,7 @@ class GaussianMoments(pydantic.BaseModel):
 
 
 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."
     )
@@ -39,7 +40,7 @@ class GaussianMixture(pydantic.BaseModel):
 
 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,
 )
 
-_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):

classiq/interface/generator/state_preparation/state_preparation.py

@@ -1,4 +1,4 @@
-from typing import Dict, Optional, Union
+from typing import Optional, Union
 
 import numpy as np
 import pydantic
@@ -36,7 +36,7 @@ class StatePreparation(StatePreparationABC):
         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)
         }
@@ -80,8 +80,8 @@ class StatePreparation(StatePreparationABC):
     @pydantic.field_validator("error_metric", mode="before")
     @classmethod
     def _validate_error_metric(
-        cls, error_metric: Dict[Metrics, NonNegativeFloatRange], info: ValidationInfo
-    ) -> Dict[Metrics, NonNegativeFloatRange]:
+        cls, error_metric: dict[Metrics, NonNegativeFloatRange], info: ValidationInfo
+    ) -> dict[Metrics, NonNegativeFloatRange]:
         if not info.data.get("amplitudes"):
             return error_metric
         unsupported_metrics = {

classiq/interface/generator/synthesis_metadata/synthesis_execution_data.py

@@ -1,4 +1,4 @@
-from typing import Dict, Optional, Set
+from typing import Optional
 
 import pydantic
 import sympy
@@ -24,14 +24,14 @@ class FunctionExecutionData(pydantic.BaseModel):
 
 
 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_var
             for function_execution_data in self.function_execution.values()

classiq/interface/generator/transpiler_basis_gates.py

@@ -1,10 +1,10 @@
-from typing import TYPE_CHECKING, FrozenSet, Optional
+from typing import TYPE_CHECKING, Optional
 
 from typing_extensions import TypeAlias
 
 from classiq.interface.enum_utils import StrEnum
 
-BasisGates: TypeAlias = FrozenSet[str]
+BasisGates: TypeAlias = frozenset[str]
 
 SINGLE_QUBIT_GATES: BasisGates = frozenset(
     (

classiq/interface/generator/types/enum_declaration.py

@@ -1,6 +1,5 @@
 from collections import Counter
 from enum import Enum, EnumMeta, IntEnum
-from typing import Dict
 
 import pydantic
 
@@ -11,14 +10,14 @@ from classiq.interface.exceptions import ClassiqValueError
 class EnumDeclaration(HashableASTNode):
     name: str
 
-    members: Dict[str, int] = pydantic.Field(
+    members: dict[str, int] = pydantic.Field(
         default_factory=dict,
         description="Dictionary of member names and their values",
     )
 
     @pydantic.field_validator("members")
     @classmethod
-    def _validate_members(cls, members: Dict[str, int]) -> Dict[str, int]:
+    def _validate_members(cls, members: dict[str, int]) -> dict[str, int]:
         underscore_members = [
             member for member in members.keys() if member.startswith("_")
         ]

classiq/interface/generator/types/qstruct_declaration.py

@@ -1,4 +1,5 @@
-from typing import TYPE_CHECKING, Mapping
+from collections.abc import Mapping
+from typing import TYPE_CHECKING
 
 import pydantic
 

classiq/interface/generator/types/struct_declaration.py

@@ -1,4 +1,5 @@
-from typing import Any, Dict, Mapping
+from collections.abc import Mapping
+from typing import Any
 
 import pydantic
 
@@ -10,7 +11,7 @@ from classiq.interface.generator.functions.concrete_types import ConcreteClassic
 class StructDeclaration(HashableASTNode):
     name: str
 
-    variables: Dict[str, ConcreteClassicalType] = pydantic.Field(
+    variables: dict[str, ConcreteClassicalType] = pydantic.Field(
         default_factory=dict,
         description="Dictionary of variable names and their classical types",
     )

classiq/interface/generator/ucc.py

@@ -1,4 +1,5 @@
-from typing import Iterable, Optional
+from collections.abc import Iterable
+from typing import Optional
 
 import pydantic
 

classiq/interface/generator/unitary_gate.py

@@ -1,4 +1,4 @@
-from typing import List, Union
+from typing import Union
 
 import numpy as np
 import pydantic
@@ -8,7 +8,7 @@ from classiq.interface.generator import complex_type, function_params
 from classiq.interface.generator.arith.register_user_input import RegisterArithmeticInfo
 
 DataNumber = Union[complex_type.Complex, float, int]
-DataArray = List[List[DataNumber]]
+DataArray = list[list[DataNumber]]
 
 UNITARY_GATE_INPUT: str = "TARGET"
 UNITARY_GATE_OUTPUT: str = "TARGET"

classiq/interface/generator/user_defined_function_params.py

@@ -1,4 +1,4 @@
-from typing import Mapping
+from collections.abc import Mapping
 
 import pydantic
 from pydantic import ConfigDict

classiq/interface/generator/validations/flow_graph.py

@@ -1,7 +1,8 @@
 from collections import Counter, defaultdict
+from collections.abc import Collection, Iterable, Mapping
 from dataclasses import dataclass
 from itertools import chain
-from typing import Collection, Iterable, List, Mapping, Optional, TypeVar
+from typing import Optional, TypeVar
 
 import networkx as nx
 
@@ -152,7 +153,7 @@ def validate_legal_wiring(
     raise ClassiqValueError(_join_errors(error_messages))
 
 
-def _join_errors(error_messages: List[str]) -> str:
+def _join_errors(error_messages: list[str]) -> str:
     if not error_messages:
         error_messages.append(f"{UNKNOWN_ERROR_MSG}")
 
@@ -162,7 +163,7 @@ def _join_errors(error_messages: List[str]) -> str:
 T = TypeVar("T")
 
 
-def _recurring_names(name_list: List[T]) -> Iterable[T]:
+def _recurring_names(name_list: list[T]) -> Iterable[T]:
     name_counter = Counter(name_list)
     return (name for name, appearances in name_counter.items() if appearances > 1)
 
@@ -187,11 +188,11 @@ def validate_acyclic_logic_flow(
 
 
 def validate_acyclicity_and_topologically_sort_logic_flow(
-    body: List[SynthesisQuantumFunctionCall],
+    body: list[SynthesisQuantumFunctionCall],
     *,
     flow_input_names: Collection[str],
     flow_output_names: Collection[str],
-) -> List[SynthesisQuantumFunctionCall]:
+) -> list[SynthesisQuantumFunctionCall]:
     graph = validate_acyclic_logic_flow(
         body=body,
         flow_input_names=flow_input_names,

classiq/interface/generator/validations/validator_functions.py

@@ -1,4 +1,5 @@
-from typing import Iterable, List, Sequence, Sized, Tuple, TypeVar
+from collections.abc import Iterable, Sequence, Sized
+from typing import TypeVar
 
 import numpy as np
 
@@ -9,7 +10,7 @@ NOT_SUM_TO_ONE_ERROR = "Probabilities do not sum to 1"
 
 SUM_TO_ONE_SENSITIVITY = 8
 
-Amplitude = TypeVar("Amplitude", Tuple[float, ...], List[complex])
+Amplitude = TypeVar("Amplitude", tuple[float, ...], list[complex])
 
 
 def _is_power_of_two(vector: Sized) -> bool:

classiq/interface/generator/visitor.py

@@ -1,14 +1,9 @@
 from collections import abc
+from collections.abc import Collection, Mapping, Sequence
 from typing import (
     TYPE_CHECKING,
     Any,
-    Collection,
-    Dict,
-    List,
-    Mapping,
     Optional,
-    Sequence,
-    Tuple,
     TypeVar,
     Union,
 )
@@ -21,7 +16,7 @@ NodeType = Union[
     BaseModel,
     int,
     bool,
-    Tuple["NodeType", ...],
+    tuple["NodeType", ...],
     Mapping[Key, "NodeType"],
     Sequence["NodeType"],
 ]
@@ -47,19 +42,19 @@ class Visitor:
 
         return node
 
-    def visit_list(self, node: List[NodeType]) -> Optional[RetType]:
+    def visit_list(self, node: list[NodeType]) -> Optional[RetType]:
         for elem in node:
             self.visit(elem)
 
         return None
 
-    def visit_dict(self, node: Dict[Key, NodeType]) -> Optional[RetType]:
+    def visit_dict(self, node: dict[Key, NodeType]) -> Optional[RetType]:
         for value in node.values():
             self.visit(value)
 
         return None
 
-    def visit_tuple(self, node: Tuple[NodeType, ...]) -> Optional[Tuple[RetType, ...]]:
+    def visit_tuple(self, node: tuple[NodeType, ...]) -> Optional[tuple[RetType, ...]]:
         for value in node:
             self.visit(value)
 
@@ -83,13 +78,13 @@ class Transformer(Visitor):
 
         def visit(self, node: NodeType) -> Any: ...
 
-    def visit_list(self, node: List[NodeType]) -> List[RetType]:
+    def visit_list(self, node: list[NodeType]) -> list[RetType]:
         return [self.visit(elem) for elem in node]
 
-    def visit_dict(self, node: Dict[Key, NodeType]) -> Dict[Key, RetType]:
+    def visit_dict(self, node: dict[Key, NodeType]) -> dict[Key, RetType]:
         return {key: self.visit(value) for key, value in node.items()}
 
-    def visit_tuple(self, node: Tuple[NodeType, ...]) -> Tuple[RetType, ...]:
+    def visit_tuple(self, node: tuple[NodeType, ...]) -> tuple[RetType, ...]:
         return tuple(self.visit(value) for value in node)
 
     def visit_BaseModel(
@@ -97,7 +92,7 @@ class Transformer(Visitor):
     ) -> RetType:
         fields_to_skip = fields_to_skip or set()
 
-        result: Dict[str, Any] = dict()
+        result: dict[str, Any] = dict()
         for name, value in node:
             if name not in fields_to_skip:
                 result[name] = self.visit(value)

classiq/interface/hardware.py

@@ -1,8 +1,7 @@
 import datetime
-from typing import TYPE_CHECKING, List, Optional, Tuple
+from typing import TYPE_CHECKING, Annotated, Optional
 
 import pydantic
-from typing_extensions import Annotated
 
 from classiq.interface.enum_utils import StrEnum
 
@@ -75,9 +74,9 @@ class HardwareStatus(pydantic.BaseModel):
 
 
 if TYPE_CHECKING:
-    ConnectivityMapEntry = Tuple[int, int]
+    ConnectivityMapEntry = tuple[int, int]
 else:
-    ConnectivityMapEntry = List[int]
+    ConnectivityMapEntry = list[int]
 
 
 class HardwareInformation(pydantic.BaseModel):
@@ -87,8 +86,8 @@ class HardwareInformation(pydantic.BaseModel):
     display_name: str
     device_type: DeviceType
     number_of_qubits: int
-    connectivity_map: Optional[List[ConnectivityMapEntry]] = None
-    basis_gates: List[str]
+    connectivity_map: Optional[list[ConnectivityMapEntry]] = None
+    basis_gates: list[str]
     status: HardwareStatus
 
     def is_simulator(self) -> bool:

classiq/interface/helpers/custom_encoders.py

@@ -1,3 +1,3 @@
-from typing import Any, Callable, Dict
+from typing import Any, Callable
 
-CUSTOM_ENCODERS: Dict[type, Callable[[Any], Any]] = {complex: str}
+CUSTOM_ENCODERS: dict[type, Callable[[Any], Any]] = {complex: str}

classiq/interface/helpers/custom_pydantic_types.py

@@ -1,8 +1,7 @@
-from typing import TYPE_CHECKING, Any, List, Tuple
+from typing import TYPE_CHECKING, Annotated, Any
 
 import pydantic
 from pydantic import Field, StrictStr, StringConstraints
-from typing_extensions import Annotated
 
 from classiq.interface.generator.arith.number_utils import MAXIMAL_MACHINE_PRECISION
 from classiq.interface.generator.parameters import ParameterComplexType
@@ -57,7 +56,7 @@ else:
 if TYPE_CHECKING:
     PydanticPauliMonomial = tuple
 else:
-    PydanticPauliMonomial = Annotated[List[Any], Field(min_length=2, max_length=2)]
+    PydanticPauliMonomial = Annotated[list[Any], Field(min_length=2, max_length=2)]
 
 if TYPE_CHECKING:
     PydanticPauliMonomialStr = str
@@ -68,16 +67,16 @@ else:
     ]
 
 PydanticPauliList = Annotated[
-    List[Tuple[PydanticPauliMonomialStr, ParameterComplexType]], Field(min_length=1)
+    list[tuple[PydanticPauliMonomialStr, ParameterComplexType]], Field(min_length=1)
 ]
 
 if TYPE_CHECKING:
-    PydanticFloatTuple = Tuple[float, float]
+    PydanticFloatTuple = tuple[float, float]
 else:
-    PydanticFloatTuple = Annotated[List[float], Field(min_length=2, max_length=2)]
+    PydanticFloatTuple = Annotated[list[float], Field(min_length=2, max_length=2)]
 
 PydanticNonNegIntTuple = Annotated[
-    List[pydantic.NonNegativeInt], Field(min_length=2, max_length=2)
+    list[pydantic.NonNegativeInt], Field(min_length=2, max_length=2)
 ]
 
 if TYPE_CHECKING:
@@ -90,9 +89,9 @@ else:
         ),
     ]
 if TYPE_CHECKING:
-    AtomType = Tuple[str, List[float]]
+    AtomType = tuple[str, list[float]]
 else:
-    AtomType = Annotated[List[Any], Field(min_length=2, max_length=2)]
+    AtomType = Annotated[list[Any], Field(min_length=2, max_length=2)]
 
 
 if TYPE_CHECKING:

classiq/interface/helpers/hashable_mixin.py

@@ -1,7 +1,8 @@
 import itertools
 import numbers
+from collections.abc import Iterator
 from enum import EnumMeta
-from typing import Any, Iterator, Tuple
+from typing import Any
 
 
 def immutable_version(value: Any) -> Any:
@@ -29,5 +30,5 @@ class HashableMixin:
         for val in self._values_to_hash():
             yield immutable_version(val)
 
-    def _value_tuple(self) -> Tuple[Any, ...]:
+    def _value_tuple(self) -> tuple[Any, ...]:
         return tuple(itertools.chain((str(type(self))), self._immutable_fields()))

classiq/interface/helpers/hashable_pydantic_base_model.py

@@ -1,4 +1,5 @@
-from typing import Any, Collection, Iterator
+from collections.abc import Collection, Iterator
+from typing import Any
 
 import pydantic
 

classiq/interface/helpers/pydantic_model_helpers.py

@@ -1,9 +1,10 @@
-from typing import Any, Dict, Protocol, Sequence, TypeVar
+from collections.abc import Sequence
+from typing import Any, Protocol, TypeVar
 
 
 def values_with_discriminator(
     values: Any, discriminator: str, discriminator_value: Any
-) -> Dict[str, Any]:
+) -> dict[str, Any]:
     if isinstance(values, dict):
         values.setdefault(discriminator, discriminator_value)
     return values
@@ -16,5 +17,5 @@ class Nameable(Protocol):
 NameableType = TypeVar("NameableType", bound=Nameable)
 
 
-def nameables_to_dict(nameables: Sequence[NameableType]) -> Dict[str, NameableType]:
+def nameables_to_dict(nameables: Sequence[NameableType]) -> dict[str, NameableType]:
     return {value.name: value for value in nameables}

classiq/interface/helpers/validation_helpers.py

@@ -1,10 +1,10 @@
-from typing import Hashable, List, Mapping
+from collections.abc import Hashable, Mapping
 
 from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.helpers.pydantic_model_helpers import Nameable
 
 
-def is_list_unique(lst: List[Hashable]) -> bool:
+def is_list_unique(lst: list[Hashable]) -> bool:
     return len(set(lst)) == len(lst)