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

classiq/interface/executor/execution_request.py

@@ -1,9 +1,8 @@
 from datetime import datetime
-from typing import List, Literal, Optional, Union
+from typing import Annotated, Literal, Optional, Union
 
 import pydantic
 from pydantic import BaseModel, Field
-from typing_extensions import Annotated
 
 from classiq.interface.executor.estimation import OperatorsEstimation
 from classiq.interface.executor.execution_preferences import ExecutionPreferences
@@ -63,4 +62,4 @@ class ExecutionJobDetails(VersionedModel):
 
 
 class ExecutionJobsQueryResults(VersionedModel):
-    results: List[ExecutionJobDetails]
+    results: list[ExecutionJobDetails]

classiq/interface/executor/execution_result.py

@@ -1,7 +1,7 @@
-from typing import Any, List, Literal, Union
+from typing import Annotated, Any, Literal, Union
 
 from pydantic import BaseModel, ConfigDict, Field
-from typing_extensions import Annotated, TypeAlias
+from typing_extensions import TypeAlias
 
 from classiq.interface.enum_utils import StrEnum
 from classiq.interface.executor.iqae_result import IQAEResult
@@ -104,7 +104,7 @@ SavedResult = Annotated[
     Field(..., discriminator="value_type"),
 ]
 
-ResultsCollection: TypeAlias = List[SavedResult]
+ResultsCollection: TypeAlias = list[SavedResult]
 
 
 class ExecuteGeneratedCircuitResults(VersionedModel):

classiq/interface/executor/iqae_result.py

@@ -1,5 +1,3 @@
-from typing import List
-
 from pydantic import BaseModel, Field
 
 from classiq.interface.executor.result import ExecutionDetails
@@ -14,6 +12,6 @@ class IQAEIterationData(BaseModel):
 
 class IQAEResult(VersionedModel, QmodPyObject):
     estimation: float
-    confidence_interval: List[float] = Field(min_length=2, max_length=2)
-    iterations_data: List[IQAEIterationData]
-    warnings: List[str]
+    confidence_interval: list[float] = Field(min_length=2, max_length=2)
+    iterations_data: list[IQAEIterationData]
+    warnings: list[str]

classiq/interface/executor/optimizer_preferences.py

@@ -1,4 +1,4 @@
-from typing import List, Optional
+from typing import Optional
 
 import pydantic
 from pydantic import BaseModel
@@ -45,7 +45,7 @@ class OptimizerPreferences(BaseModel):
         default=None,
         description="The random seed used for the generation",
     )
-    initial_point: Optional[List[float]] = pydantic.Field(
+    initial_point: Optional[list[float]] = pydantic.Field(
         default=None,
         description="Initial values for the ansatz parameters",
     )

classiq/interface/executor/quantum_code.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from pathlib import Path
-from typing import Any, Dict, Optional, Tuple, Union
+from typing import Any, Optional, Union
 
 import pydantic
 from pydantic import BaseModel, ConfigDict
@@ -16,12 +16,12 @@ from classiq.interface.generator.synthesis_metadata.synthesis_execution_data imp
     ExecutionData,
 )
 
-Arguments = Dict[PydanticArgumentNameType, Any]
-MultipleArguments = Tuple[Arguments, ...]
+Arguments = dict[PydanticArgumentNameType, Any]
+MultipleArguments = tuple[Arguments, ...]
 CodeType = str
-RegistersInitialization = Dict[str, RegisterInitialization]
-Qubits = Tuple[int, ...]
-OutputQubitsMap = Dict[str, Qubits]
+RegistersInitialization = dict[str, RegisterInitialization]
+Qubits = tuple[int, ...]
+OutputQubitsMap = dict[str, Qubits]
 
 
 class QuantumBaseCode(BaseModel):

classiq/interface/executor/register_initialization.py

@@ -1,5 +1,3 @@
-from typing import List
-
 import pydantic
 from typing_extensions import Self
 
@@ -13,7 +11,7 @@ _NON_INTEGER_INITIALIZATION_ERROR_MSG: str = (
 
 class RegisterInitialization(pydantic.BaseModel):
     name: str
-    qubits: List[int]
+    qubits: list[int]
     initial_condition: pydantic.NonNegativeInt
 
     @pydantic.field_validator("initial_condition", mode="before")
@@ -25,7 +23,7 @@ class RegisterInitialization(pydantic.BaseModel):
 
     @pydantic.model_validator(mode="after")
     def _validate_register_initialization(self) -> Self:
-        qubits: List[int] = self.qubits or []
+        qubits: list[int] = self.qubits or []
         initial_condition: int = self.initial_condition or 0
         name: str = self.name or ""
 

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,
 )
 
@@ -24,6 +20,7 @@ from classiq.interface.generator.arith import number_utils
 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 PydanticNonNegIntTuple
+from classiq.interface.helpers.dotdict import get_recursive_dotdict
 from classiq.interface.helpers.versioned_model import VersionedModel
 
 _ILLEGAL_QUBIT_ERROR_MSG: str = "Illegal qubit index requested"
@@ -36,19 +33,29 @@ 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]
+else:
+    DotAccessParsedState = ParsedState
 
 
 class SampledState(BaseModel):
-    state: ParsedState
+    state: DotAccessParsedState
     shots: MeasuredShots
 
     def __repr__(self) -> str:
         return f"{self.state}: {self.shots}"
 
+    @pydantic.field_validator("state", mode="after")
+    @classmethod
+    def _convert_state_to_dotdict(cls, state: ParsedState) -> DotAccessParsedState:
+        return {name: get_recursive_dotdict(value) for name, value in state.items()}
+
 
-ParsedCounts: TypeAlias = List[SampledState]
+ParsedCounts: TypeAlias = list[SampledState]
 
 
 class SimulatedState(BaseModel):
@@ -61,7 +68,7 @@ class SimulatedState(BaseModel):
 
 
 SimulatedState.model_rebuild()
-ParsedStateVector: TypeAlias = List[SimulatedState]
+ParsedStateVector: TypeAlias = list[SimulatedState]
 
 
 class VaRResult(BaseModel):
@@ -70,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)
 
@@ -84,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)
 
 
@@ -102,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: {
@@ -141,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(
@@ -151,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)",
     )
@@ -241,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():
@@ -258,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,)
@@ -268,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
         )
@@ -285,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)
@@ -294,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]
@@ -303,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):
@@ -317,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: