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

classiq/interface/executor/result.py

@@ -1,16 +1,12 @@
 import functools
 import operator
 from collections import defaultdict
+from collections.abc import Iterator, Mapping
 from typing import (
     TYPE_CHECKING,
     Any,
     DefaultDict,
-    Dict,
-    Iterator,
-    List,
-    Mapping,
     Optional,
-    Tuple,
     Union,
 )
 
@@ -37,8 +33,8 @@ RegisterValue: TypeAlias = Union[float, int, list, dict]
 MeasuredShots: TypeAlias = pydantic.NonNegativeInt
 ParsedState: TypeAlias = Mapping[Name, RegisterValue]
 ParsedStates: TypeAlias = Mapping[State, ParsedState]
-Counts: TypeAlias = Dict[State, MeasuredShots]
-StateVector: TypeAlias = Optional[Dict[str, Complex]]
+Counts: TypeAlias = dict[State, MeasuredShots]
+StateVector: TypeAlias = Optional[dict[str, Complex]]
 
 if TYPE_CHECKING:
     DotAccessParsedState = Mapping[Name, Any]
@@ -59,7 +55,7 @@ class SampledState(BaseModel):
         return {name: get_recursive_dotdict(value) for name, value in state.items()}
 
 
-ParsedCounts: TypeAlias = List[SampledState]
+ParsedCounts: TypeAlias = list[SampledState]
 
 
 class SimulatedState(BaseModel):
@@ -72,7 +68,7 @@ class SimulatedState(BaseModel):
 
 
 SimulatedState.model_rebuild()
-ParsedStateVector: TypeAlias = List[SimulatedState]
+ParsedStateVector: TypeAlias = list[SimulatedState]
 
 
 class VaRResult(BaseModel):
@@ -81,10 +77,10 @@ class VaRResult(BaseModel):
 
 
 class GroverSimulationResults(VersionedModel):
-    result: Dict[str, Any]
+    result: dict[str, Any]
 
 
-def _validate_qubit_indices(counts: Counts, indices: Tuple[int, ...]) -> None:
+def _validate_qubit_indices(counts: Counts, indices: tuple[int, ...]) -> None:
     if not indices:
         raise ClassiqError(_ILLEGAL_QUBIT_ERROR_MSG)
 
@@ -95,7 +91,7 @@ def _validate_qubit_indices(counts: Counts, indices: Tuple[int, ...]) -> None:
         raise ClassiqError(_REPEATED_QUBIT_ERROR_MSG)
 
 
-def _slice_str(s: str, indices: Tuple[int, ...]) -> str:
+def _slice_str(s: str, indices: tuple[int, ...]) -> str:
     return "".join(s[i] for i in indices)
 
 
@@ -113,7 +109,7 @@ def get_sampled_state(
 
 
 def reduce_parsed_states(
-    parsed_states: ParsedStates, outputs: Tuple[Name, ...]
+    parsed_states: ParsedStates, outputs: tuple[Name, ...]
 ) -> ParsedStates:
     return {
         state: {
@@ -152,7 +148,7 @@ def prepare_parsed_state_vector(
 
 
 class ExecutionDetails(BaseModel, QmodPyObject):
-    vendor_format_result: Dict[str, Any] = pydantic.Field(
+    vendor_format_result: dict[str, Any] = pydantic.Field(
         ..., description="Result in proprietary vendor format"
     )
     counts: Counts = pydantic.Field(
@@ -162,14 +158,14 @@ class ExecutionDetails(BaseModel, QmodPyObject):
         True,
         description="Is the qubit order of counts field such that the LSB is right?",
     )
-    probabilities: Dict[State, pydantic.NonNegativeFloat] = pydantic.Field(
+    probabilities: dict[State, pydantic.NonNegativeFloat] = pydantic.Field(
         default_factory=dict, description="Probabilities of each state"
     )
     parsed_states: ParsedStates = pydantic.Field(
         default_factory=dict,
         description="A mapping between the raw states of counts (bitstrings) to their parsed states (registers' values)",
     )
-    histogram: Optional[Dict[State, pydantic.NonNegativeFloat]] = pydantic.Field(
+    histogram: Optional[dict[State, pydantic.NonNegativeFloat]] = pydantic.Field(
         None,
         description="Histogram of probability per state (an alternative to counts)",
     )
@@ -252,15 +248,15 @@ class ExecutionDetails(BaseModel, QmodPyObject):
         return self.counts_of_qubits(*self.output_qubits_map[output_name])
 
     def counts_of_multiple_outputs(
-        self, output_names: Tuple[Name, ...]
-    ) -> Dict[Tuple[State, ...], pydantic.NonNegativeInt]:
+        self, output_names: tuple[Name, ...]
+    ) -> dict[tuple[State, ...], pydantic.NonNegativeInt]:
         if any(name not in self.output_qubits_map for name in output_names):
             raise ClassiqError(_UNAVAILABLE_OUTPUT_ERROR_MSG)
 
-        output_regs: Tuple[Qubits, ...] = tuple(
+        output_regs: tuple[Qubits, ...] = tuple(
             self.output_qubits_map[name] for name in output_names
         )
-        reduced_counts: DefaultDict[Tuple[State, ...], int] = defaultdict(int)
+        reduced_counts: DefaultDict[tuple[State, ...], int] = defaultdict(int)
         for state_str, state_count in self.counts_by_qubit_order(
             lsb_right=False
         ).items():
@@ -269,7 +265,7 @@ class ExecutionDetails(BaseModel, QmodPyObject):
         return dict(reduced_counts)
 
     def parsed_counts_of_outputs(
-        self, output_names: Union[Name, Tuple[Name, ...]]
+        self, output_names: Union[Name, tuple[Name, ...]]
     ) -> ParsedCounts:
         if isinstance(output_names, Name):
             output_names = (output_names,)
@@ -279,8 +275,8 @@ class ExecutionDetails(BaseModel, QmodPyObject):
         reduced_parsed_states = reduce_parsed_states(self.parsed_states, output_names)
         return get_parsed_counts(self.counts, reduced_parsed_states)
 
-    def register_output_from_qubits(self, qubits: Tuple[int, ...]) -> Dict[float, int]:
-        register_output: Dict[float, int] = {}
+    def register_output_from_qubits(self, qubits: tuple[int, ...]) -> dict[float, int]:
+        register_output: dict[float, int] = {}
         value_from_str_bin = functools.partial(
             self._get_register_value_from_binary_string_results, register_qubits=qubits
         )
@@ -296,7 +292,7 @@ class ExecutionDetails(BaseModel, QmodPyObject):
 
     @staticmethod
     def _get_register_value_from_binary_string_results(
-        binary_string: str, register_qubits: List[int]
+        binary_string: str, register_qubits: list[int]
     ) -> RegisterValue:
         register_binary_string = "".join(
             operator.itemgetter(*register_qubits)(binary_string)
@@ -305,7 +301,7 @@ class ExecutionDetails(BaseModel, QmodPyObject):
 
 
 class MultipleExecutionDetails(VersionedModel):
-    details: List[ExecutionDetails]
+    details: list[ExecutionDetails]
 
     def __getitem__(self, index: int) -> ExecutionDetails:
         return self.details[index]
@@ -314,7 +310,7 @@ class MultipleExecutionDetails(VersionedModel):
 class EstimationMetadata(BaseModel, extra="allow"):
     shots: Optional[pydantic.NonNegativeInt] = None
     remapped_qubits: bool = False
-    input_qubit_map: Optional[List[PydanticNonNegIntTuple]] = None
+    input_qubit_map: Optional[list[PydanticNonNegIntTuple]] = None
 
 
 class EstimationResult(BaseModel, QmodPyObject):
@@ -328,7 +324,7 @@ class EstimationResult(BaseModel, QmodPyObject):
 
 
 class EstimationResults(VersionedModel):
-    results: List[EstimationResult]
+    results: list[EstimationResult]
 
     def __len__(self) -> int:
         return len(self.results)

classiq/interface/executor/vqe_result.py

@@ -1,7 +1,7 @@
 import base64
 import io
 from datetime import datetime
-from typing import Dict, List, Optional, Tuple
+from typing import Optional
 
 import pydantic
 from PIL import Image
@@ -12,7 +12,7 @@ from classiq.interface.generator.complex_type import Complex
 from classiq.interface.generator.functions.classical_type import QmodPyObject
 from classiq.interface.helpers.custom_pydantic_types import PydanticProbabilityFloat
 
-Solution = Tuple[int, ...]
+Solution = tuple[int, ...]
 
 
 class SolverResult(BaseModel):
@@ -34,13 +34,13 @@ class VQEIntermediateData(BaseModel):
     iteration_number: pydantic.PositiveInt = pydantic.Field(
         description="The iteration's number (evaluation count)"
     )
-    parameters: List[float] = pydantic.Field(
+    parameters: list[float] = pydantic.Field(
         description="The optimizer parameters for the variational form"
     )
     mean_all_solutions: Optional[float] = pydantic.Field(
         default=None, description="The mean score of all solutions in this iteration"
     )
-    solutions: List[SolutionData] = pydantic.Field(
+    solutions: list[SolutionData] = pydantic.Field(
         description="Solutions found in this iteration, their score and"
         "number of repetitions"
     )
@@ -50,11 +50,11 @@ class VQEIntermediateData(BaseModel):
 
 
 class VQESolverResult(SolverResult, QmodPyObject):
-    eigenstate: Dict[str, Complex]
-    reduced_probabilities: Optional[Dict[str, float]] = None
+    eigenstate: dict[str, Complex]
+    reduced_probabilities: Optional[dict[str, float]] = None
     optimized_circuit_sample_results: ExecutionDetails
-    intermediate_results: List[VQEIntermediateData]
-    optimal_parameters: Dict[str, float]
+    intermediate_results: list[VQEIntermediateData]
+    optimal_parameters: dict[str, float]
     convergence_graph_str: str
     num_solutions: Optional[int] = None
     num_shots: int

classiq/interface/finance/function_input.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, Optional, Union
+from typing import Any, Optional, Union
 
 import pydantic
 from pydantic import ConfigDict
@@ -52,7 +52,7 @@ class FinanceFunctionInput(pydantic.BaseModel):
 
     @pydantic.model_validator(mode="before")
     @classmethod
-    def _convert_f_if_str(cls, values: Any, info: ValidationInfo) -> Dict[str, Any]:
+    def _convert_f_if_str(cls, values: Any, info: ValidationInfo) -> dict[str, Any]:
         if isinstance(values, dict):
             f = values.get("f")
         elif isinstance(values, FinanceFunctionInput):

classiq/interface/finance/gaussian_model_input.py

@@ -1,5 +1,5 @@
 import math
-from typing import List, Literal, Optional, Tuple
+from typing import Literal, Optional
 
 import pydantic
 
@@ -18,15 +18,15 @@ class GaussianModelInput(FinanceModelInput):
     normal_max_value: float = pydantic.Field(
         description="Min/max value to truncate the " "latent normal random variable Z"
     )
-    default_probabilities: List[PydanticProbabilityFloat] = pydantic.Field(
+    default_probabilities: list[PydanticProbabilityFloat] = pydantic.Field(
         description="default probabilities for each asset"
     )
 
-    rhos: List[pydantic.PositiveFloat] = pydantic.Field(
+    rhos: list[pydantic.PositiveFloat] = pydantic.Field(
         description="Sensitivities of default probability of assets "
         "with respect to Z (1/sigma(Z))"
     )
-    loss: List[int] = pydantic.Field(
+    loss: list[int] = pydantic.Field(
         description="List of ints signifying loss per asset"
     )
     min_loss: Optional[int] = pydantic.Field(
@@ -38,7 +38,7 @@ class GaussianModelInput(FinanceModelInput):
         return len(self.rhos)
 
     @property
-    def distribution_range(self) -> Tuple[float, float]:
+    def distribution_range(self) -> tuple[float, float]:
         return 0, sum(self.loss)
 
     @property

classiq/interface/finance/log_normal_model_input.py

@@ -1,4 +1,4 @@
-from typing import Literal, Tuple
+from typing import Literal
 
 import numpy as np
 import pydantic
@@ -21,7 +21,7 @@ class LogNormalModelInput(FinanceModelInput):
     )
 
     @property
-    def distribution_range(self) -> Tuple[float, float]:
+    def distribution_range(self) -> tuple[float, float]:
         mean = np.exp(self.mu + self.sigma**2 / 2)
         variance = (np.exp(self.sigma**2) - 1) * np.exp(2 * self.mu + self.sigma**2)
         stddev = np.sqrt(variance)

classiq/interface/finance/model_input.py

@@ -1,5 +1,4 @@
 import abc
-from typing import Tuple
 
 from pydantic import ConfigDict
 
@@ -19,5 +18,5 @@ class FinanceModelInput(HashablePydanticBaseModel):
 
     @property
     @abc.abstractmethod
-    def distribution_range(self) -> Tuple[float, float]:
+    def distribution_range(self) -> tuple[float, float]:
         pass

classiq/interface/generator/adjacency.py

@@ -1,9 +1,7 @@
-from typing import List
-
 import numpy as np
 
 
-def get_rand_adjacency_matrix(num_vertices: int) -> List[List[bool]]:
+def get_rand_adjacency_matrix(num_vertices: int) -> list[list[bool]]:
     adjacency_matrix = np.random.choice([0, 1], size=(num_vertices, num_vertices))
     for i in range(num_vertices):
         for j in range(num_vertices):

classiq/interface/generator/ansatz_library.py

@@ -1,4 +1,4 @@
-from typing import Dict, List, Optional, Union
+from typing import Optional, Union
 
 from pydantic import BaseModel
 
@@ -42,7 +42,7 @@ class EntanglingLayersArgs(CustomAnsatzArgs):
 
 class RandomArgs(CustomAnsatzArgs):
     gate_count: int = 100
-    gate_probabilities: Dict[str, float] = {"cx": 0.5, "u": 0.5}
+    gate_probabilities: dict[str, float] = {"cx": 0.5, "u": 0.5}
     random_seed: Optional[int] = None
 
 
@@ -52,11 +52,11 @@ class RandomTwoQubitGatesArgs(CustomAnsatzArgs):
 
 
 class TwoLocalArgs(CustomAnsatzArgs):
-    rotation_blocks: Optional[Union[RotationBlocksType, List[RotationBlocksType]]] = (
+    rotation_blocks: Optional[Union[RotationBlocksType, list[RotationBlocksType]]] = (
         RotationBlocksType.ry
     )
     entanglement_blocks: Optional[
-        Union[EntanglementBlocksType, List[EntanglementBlocksType]]
+        Union[EntanglementBlocksType, list[EntanglementBlocksType]]
     ] = EntanglementBlocksType.cx
     entanglement: EntanglementStructureType = EntanglementStructureType.full
     reps: int = 3

classiq/interface/generator/application_apis/finance_declarations.py

@@ -1,5 +1,5 @@
+from collections.abc import Mapping
 from enum import Enum
-from typing import Mapping
 
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.classical_function_declaration import (

classiq/interface/generator/arith/argument_utils.py

@@ -1,4 +1,4 @@
-from typing import Tuple, Union
+from typing import Union
 
 from classiq.interface.generator.arith import number_utils
 from classiq.interface.generator.arith.number_utils import (
@@ -45,7 +45,7 @@ def lower_bound(argument: RegisterOrConst) -> float:
     return argument
 
 
-def bounds(argument: RegisterOrConst) -> Tuple[float, float]:
+def bounds(argument: RegisterOrConst) -> tuple[float, float]:
     if isinstance(argument, RegisterArithmeticInfo):
         return argument.bounds
     return argument, argument
@@ -59,7 +59,7 @@ def limit_fraction_places(
     return number_utils.limit_fraction_places(argument, machine_precision)
 
 
-def arg_bounds_overlap(args: Tuple[RegisterOrConst, RegisterOrConst]) -> bool:
+def arg_bounds_overlap(args: tuple[RegisterOrConst, RegisterOrConst]) -> bool:
     return (max(bounds(args[0])) - min(bounds(args[1]))) * (
         min(bounds(args[0])) - max(bounds(args[1]))
     ) < 0

classiq/interface/generator/arith/arithmetic.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, Final, Optional, Set
+from typing import Any, Final, Optional
 
 import networkx as nx
 import pydantic
@@ -30,18 +30,18 @@ ARITHMETIC_EXPRESSION_GARBAGE_NAME: Final[str] = "expression_garbage"
 
 class Arithmetic(ArithmeticExpressionABC):
     target: Optional[RegisterArithmeticInfo] = None
-    inputs_to_save: Set[str] = pydantic.Field(default_factory=set)
+    inputs_to_save: set[str] = pydantic.Field(default_factory=set)
 
     @pydantic.field_validator("inputs_to_save")
     @classmethod
     def _validate_inputs_to_save(
-        cls, inputs_to_save: Set[str], info: ValidationInfo
-    ) -> Set[str]:
+        cls, inputs_to_save: set[str], info: ValidationInfo
+    ) -> set[str]:
         assert all(reg in info.data.get("definitions", {}) for reg in inputs_to_save)
         return inputs_to_save
 
     @staticmethod
-    def _validate_expression_graph(graph: nx.DiGraph, values: Dict[str, Any]) -> None:
+    def _validate_expression_graph(graph: nx.DiGraph, values: dict[str, Any]) -> None:
         target = values.get("target")
         if target is None:
             return
@@ -80,7 +80,7 @@ class Arithmetic(ArithmeticExpressionABC):
 
 def get_arithmetic_params(
     expr_str: str,
-    var_types: Dict[str, QuantumType],
+    var_types: dict[str, QuantumType],
     machine_precision: int,
     enable_target: bool = False,
 ) -> Arithmetic:
@@ -98,7 +98,7 @@ def get_arithmetic_params(
 
 
 def compute_arithmetic_result_type(
-    expr_str: str, var_types: Dict[str, QuantumType], machine_precision: int
+    expr_str: str, var_types: dict[str, QuantumType], machine_precision: int
 ) -> QuantumType:
     arith_param = get_arithmetic_params(expr_str, var_types, machine_precision)
     return register_info_to_quantum_type(

classiq/interface/generator/arith/arithmetic_arg_type_validator.py

@@ -1,4 +1,4 @@
-from typing import Callable, Dict, List
+from typing import Callable
 
 from typing_extensions import TypeAlias
 
@@ -6,15 +6,15 @@ from classiq.interface.exceptions import ClassiqArithmeticError
 from classiq.interface.generator.arith import argument_utils
 from classiq.interface.generator.arith.binary_ops import BOOLEAN_OP_WITH_FRACTIONS_ERROR
 
-ArgTypeValidator: TypeAlias = Callable[[List[argument_utils.RegisterOrConst]], None]
+ArgTypeValidator: TypeAlias = Callable[[list[argument_utils.RegisterOrConst]], None]
 
 
-def _validate_bitwise_op_args(args: List[argument_utils.RegisterOrConst]) -> None:
+def _validate_bitwise_op_args(args: list[argument_utils.RegisterOrConst]) -> None:
     if any(argument_utils.fraction_places(arg) > 0 for arg in args):
         raise ClassiqArithmeticError(BOOLEAN_OP_WITH_FRACTIONS_ERROR)
 
 
-arg_type_validator_map: Dict[str, ArgTypeValidator] = dict(
+arg_type_validator_map: dict[str, ArgTypeValidator] = dict(
     BitXor=_validate_bitwise_op_args,
     BitAnd=_validate_bitwise_op_args,
     BitOr=_validate_bitwise_op_args,
@@ -23,7 +23,7 @@ arg_type_validator_map: Dict[str, ArgTypeValidator] = dict(
 
 def validate_operation_arg_types(
     operation: str,
-    arguments: List[argument_utils.RegisterOrConst],
+    arguments: list[argument_utils.RegisterOrConst],
     machine_precision: int,
 ) -> None:
     if operation not in arg_type_validator_map:

classiq/interface/generator/arith/arithmetic_expression_abc.py

@@ -1,7 +1,7 @@
 import abc
 import ast
 import re
-from typing import Any, Dict, Optional, Set, Tuple, Union
+from typing import Any, Optional, Union
 
 import networkx as nx
 import pydantic
@@ -41,16 +41,16 @@ class ArithmeticExpressionABC(abc.ABC, FunctionParams):
     uncomputation_method: UncomputationMethods = UncomputationMethods.optimized
     machine_precision: pydantic.NonNegativeInt = DEFAULT_MACHINE_PRECISION
     expression: PydanticExpressionStr
-    definitions: Dict[str, ValidDefinitions]
+    definitions: dict[str, ValidDefinitions]
     qubit_count: Optional[pydantic.NonNegativeInt] = None
 
-    def _get_literal_set(self) -> Set[str]:
+    def _get_literal_set(self) -> set[str]:
         return _extract_literals(self.expression)
 
     @classmethod
     def _validate_expression_literals_and_definitions(
-        cls, definitions: Dict[str, ValidDefinitions], expression: PydanticExpressionStr
-    ) -> Dict[str, ValidDefinitions]:
+        cls, definitions: dict[str, ValidDefinitions], expression: PydanticExpressionStr
+    ) -> dict[str, ValidDefinitions]:
         literals = _extract_literals(expression)
 
         forbidden = literals.intersection(FORBIDDEN_LITERALS)
@@ -69,13 +69,13 @@ class ArithmeticExpressionABC(abc.ABC, FunctionParams):
 
     @pydantic.model_validator(mode="before")
     @classmethod
-    def _validate_expression(cls, values: Any) -> Dict[str, Any]:
+    def _validate_expression(cls, values: Any) -> dict[str, Any]:
         if not isinstance(values, dict):
             return values
         expression_adapter: TypeAdapter = TypeAdapter(Optional[PydanticExpressionStr])
         expression = expression_adapter.validate_python(values.get("expression"))
         definitions_adapter: TypeAdapter = TypeAdapter(
-            Optional[Dict[str, ValidDefinitions]]
+            Optional[dict[str, ValidDefinitions]]
         )
         definition_dict = values.get("definitions")
         if (
@@ -148,16 +148,16 @@ class ArithmeticExpressionABC(abc.ABC, FunctionParams):
         pass
 
     @staticmethod
-    def _validate_expression_graph(graph: nx.DiGraph, values: Dict[str, Any]) -> None:
+    def _validate_expression_graph(graph: nx.DiGraph, values: dict[str, Any]) -> None:
         pass
 
     @classmethod
     def _replace_const_definitions_in_expression(
         cls,
         expression: str,
-        definitions: Dict[str, ValidDefinitions],
+        definitions: dict[str, ValidDefinitions],
         machine_precision: int,
-    ) -> Tuple[str, Dict[str, RegisterArithmeticInfo]]:
+    ) -> tuple[str, dict[str, RegisterArithmeticInfo]]:
         new_definitions = dict()
         for var_name, value in definitions.items():
             if isinstance(value, RegisterArithmeticInfo):
@@ -182,5 +182,5 @@ class ArithmeticExpressionABC(abc.ABC, FunctionParams):
         return re.sub(r"\b" + var + r"\b", str(value), expression)
 
 
-def _extract_literals(expression: str) -> Set[str]:
+def _extract_literals(expression: str) -> set[str]:
     return set(re.findall(SUPPORTED_VAR_NAMES_REG, expression)) - SUPPORTED_FUNC_NAMES

classiq/interface/generator/arith/arithmetic_expression_parser.py

@@ -1,6 +1,7 @@
 import ast
 from _ast import AST
-from typing import Collection, List, Optional, Set, Tuple, Type, Union, cast
+from collections.abc import Collection
+from typing import Optional, Union, cast
 
 import networkx as nx
 
@@ -28,9 +29,9 @@ Node = Union[str, float, int]
 class ExpressionVisitor(ExpressionValidator):
     def __init__(
         self,
-        supported_nodes: Tuple[Type[AST], ...],
+        supported_nodes: tuple[type[AST], ...],
         expression_type: str = DEFAULT_EXPRESSION_TYPE,
-        supported_functions: Optional[Set[str]] = None,
+        supported_functions: Optional[set[str]] = None,
     ) -> None:
         super().__init__(supported_nodes, expression_type, supported_functions)
         self.graph = nx.DiGraph()
@@ -90,8 +91,8 @@ class ExpressionVisitor(ExpressionValidator):
 class InDegreeLimiter:
     @staticmethod
     def _sort_in_edges(
-        in_edges: Collection[Tuple[Node, str]]
-    ) -> List[Tuple[Node, str]]:
+        in_edges: Collection[tuple[Node, str]]
+    ) -> list[tuple[Node, str]]:
         return sorted(
             in_edges,
             key=lambda edge_tuple: isinstance(edge_tuple[0], str),  # vars before consts
@@ -134,9 +135,9 @@ class InDegreeLimiter:
 def parse_expression(
     expression: str,
     *,
-    supported_nodes: Tuple[Type[AST], ...] = DEFAULT_SUPPORTED_NODE_TYPES,
+    supported_nodes: tuple[type[AST], ...] = DEFAULT_SUPPORTED_NODE_TYPES,
     expression_type: str = DEFAULT_EXPRESSION_TYPE,
-    supported_functions: Optional[Set[str]] = None,
+    supported_functions: Optional[set[str]] = None,
 ) -> nx.DiGraph:
     supported_functions = supported_functions or DEFAULT_SUPPORTED_FUNC_NAMES
 

classiq/interface/generator/arith/arithmetic_expression_validator.py

@@ -1,7 +1,7 @@
 import ast
 import re
 from _ast import AST
-from typing import Any, Dict, Optional, Set, Tuple, Type, Union
+from typing import Any, Optional, Union
 
 from typing_extensions import TypeAlias, get_args
 
@@ -11,7 +11,7 @@ from classiq.interface.generator.expressions.sympy_supported_expressions import
     SYMPY_SUPPORTED_EXPRESSIONS,
 )
 
-DEFAULT_SUPPORTED_FUNC_NAMES: Set[str] = {"CLShift", "CRShift", "min", "max"}
+DEFAULT_SUPPORTED_FUNC_NAMES: set[str] = {"CLShift", "CRShift", "min", "max"}
 
 DEFAULT_EXPRESSION_TYPE = "arithmetic"
 IDENITIFIER_REGEX = re.compile(r"[a-zA-Z_][a-zA-Z0-9_]*")
@@ -19,7 +19,7 @@ IDENITIFIER_REGEX = re.compile(r"[a-zA-Z_][a-zA-Z0-9_]*")
 _REPEATED_VARIABLES_ERROR_MESSAGE: str = (
     "Repeated variables in the beginning of an arithmetic expression are not allowed."
 )
-ValidKeyValuePairs: TypeAlias = Dict[str, Set[str]]
+ValidKeyValuePairs: TypeAlias = dict[str, set[str]]
 
 SupportedNodesTypes = Union[
     ast.Expression,
@@ -68,9 +68,9 @@ def _is_constant(expr: str) -> bool:
 class ExpressionValidator(ast.NodeVisitor):
     def __init__(
         self,
-        supported_nodes: Tuple[Type[AST], ...],
+        supported_nodes: tuple[type[AST], ...],
         expression_type: str = DEFAULT_EXPRESSION_TYPE,
-        supported_functions: Optional[Set[str]] = None,
+        supported_functions: Optional[set[str]] = None,
         mode: str = "eval",
     ) -> None:
         super().__init__()
@@ -108,7 +108,7 @@ class ExpressionValidator(ast.NodeVisitor):
         return self._ast_obj
 
     @staticmethod
-    def _check_repeated_variables(variables: Tuple[Any, Any]) -> None:
+    def _check_repeated_variables(variables: tuple[Any, Any]) -> None:
         if (
             all(isinstance(var, ast.Name) for var in variables)
             and variables[0].id == variables[1].id
@@ -186,9 +186,9 @@ class ExpressionValidator(ast.NodeVisitor):
 def validate_expression(
     expression: str,
     *,
-    supported_nodes: Tuple[Type[AST], ...] = DEFAULT_SUPPORTED_NODE_TYPES,
+    supported_nodes: tuple[type[AST], ...] = DEFAULT_SUPPORTED_NODE_TYPES,
     expression_type: str = DEFAULT_EXPRESSION_TYPE,
-    supported_functions: Optional[Set[str]] = None,
+    supported_functions: Optional[set[str]] = None,
     mode: str = "eval",
 ) -> ast.AST:
     supported_functions = supported_functions or set(SYMPY_SUPPORTED_EXPRESSIONS).union(

classiq/interface/generator/arith/arithmetic_operations.py

@@ -1,5 +1,6 @@
 import abc
-from typing import ClassVar, Final, Iterable, Optional, Tuple
+from collections.abc import Iterable
+from typing import ClassVar, Final, Optional
 
 import pydantic
 
@@ -43,8 +44,8 @@ class ArithmeticOperationParams(FunctionParams):
         return self.output_size is None
 
     def _legal_bounds(
-        self, suggested_bounds: Tuple[float, float], max_bounds: Tuple[float, float]
-    ) -> Optional[Tuple[float, float]]:
+        self, suggested_bounds: tuple[float, float], max_bounds: tuple[float, float]
+    ) -> Optional[tuple[float, float]]:
         if self.output_size is None or (
             suggested_bounds[0] >= max_bounds[0]
             and suggested_bounds[1] <= max_bounds[1]