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

classiq/applications/combinatorial_helpers/transformations/encoding.py

@@ -1,6 +1,6 @@
 import copy
 from itertools import chain, product
-from typing import Callable, Dict, List, Tuple, Union
+from typing import Callable, Union
 
 import pyomo.environ as pyo
 from pyomo.core.base import _GeneralVarData
@@ -61,7 +61,7 @@ class ModelEncoder:
         self._encode_objective()
 
     @property
-    def _shift_substitution_dict(self) -> Dict[int, pyo.Expression]:
+    def _shift_substitution_dict(self) -> dict[int, pyo.Expression]:
         variables = pyomo_utils.extract(self.encoded_model, pyo.Var)
         return {id(var): var + var.lb for var in variables}
 
@@ -97,7 +97,7 @@ class ModelEncoder:
         return vars_encoding_mapping
 
     def _get_encoding_expr(
-        self, var_data: _GeneralVarData, encoding_vars: List[_GeneralVarData]
+        self, var_data: _GeneralVarData, encoding_vars: list[_GeneralVarData]
     ) -> pyo.Expression:
         if self.encoding_type == EncodingType.BINARY:
             var_span = encoding_utils.get_var_span(var_data)
@@ -117,8 +117,8 @@ class ModelEncoder:
         return encoding_expr
 
     def _get_binary_coeffs(
-        self, encoding_vars: List[_GeneralVarData], var_span: int
-    ) -> List[int]:
+        self, encoding_vars: list[_GeneralVarData], var_span: int
+    ) -> list[int]:
         num_vars = len(encoding_vars)
         if self.qsolver == QSolver.QAOAMixer:
             return [2**idx for idx in range(num_vars)]
@@ -128,7 +128,7 @@ class ModelEncoder:
             coeffs += [var_span - sum(coeffs)]
             return coeffs
 
-    def _get_encoding_idxs(self, variable: pyo.Var) -> List[Tuple[int, int]]:
+    def _get_encoding_idxs(self, variable: pyo.Var) -> list[tuple[int, int]]:
         return list(
             chain(
                 *[
@@ -155,7 +155,7 @@ class ModelEncoder:
             )
 
     def _add_rule_constraint(
-        self, constraint_name: str, idxs: List[int], rule: Callable
+        self, constraint_name: str, idxs: list[int], rule: Callable
     ) -> None:
         encoding_constraint = pyo.Constraint(idxs, rule=rule)
 
@@ -172,7 +172,7 @@ class ModelEncoder:
     def encode_expr(
         self,
         expr: pyo.Expression,
-        substitution_dict: Union[Dict[int, pyo.Expression], None] = None,
+        substitution_dict: Union[dict[int, pyo.Expression], None] = None,
     ) -> pyo.Expression:
         if substitution_dict is None:
             substitution_dict = self.vars_encoding_mapping.substitution_dict

classiq/applications/combinatorial_helpers/transformations/fixed_variables.py

@@ -1,5 +1,5 @@
 import copy
-from typing import List, Tuple, Union
+from typing import Union
 
 from pyomo.core import ConcreteModel, Var
 from pyomo.core.base.constraint import _GeneralConstraintData
@@ -74,14 +74,14 @@ def _change_fixing_constraints_to_fixed_value(model: ConcreteModel) -> None:
         pyomo_utils.delete_component(model, constraint)
 
 
-def _get_fixing_constraints(model: ConcreteModel) -> List[_GeneralConstraintData]:
+def _get_fixing_constraints(model: ConcreteModel) -> list[_GeneralConstraintData]:
     constraints = pyomo_utils.extract(model, _GeneralConstraintData)
     return list(filter(_is_fixing_constraint, constraints))
 
 
 def _get_var_and_value_from_fixing_constraint(
     constraint: _GeneralConstraintData,
-) -> Tuple[_GeneralVarData, float]:
+) -> tuple[_GeneralVarData, float]:
     var = next(identify_variables(constraint.body))
 
     if isinstance(constraint.body, _GeneralVarData):
@@ -110,8 +110,8 @@ def _remove_empty_constraints(model: ConcreteModel) -> None:
 
 
 def add_fixed_variables_to_solution(
-    original_model: ConcreteModel, solution: List[int]
-) -> List[int]:
+    original_model: ConcreteModel, solution: list[int]
+) -> list[int]:
     variables = pyomo_utils.extract(original_model, Var)
     solution_iter = iter(solution)
     # var.value might be 0 as well

classiq/applications/combinatorial_helpers/transformations/ising_converter.py

@@ -1,5 +1,3 @@
-from typing import List
-
 import pyomo
 import sympy as sp
 from pyomo.core.base import _GeneralVarData
@@ -20,8 +18,8 @@ PYOMO_PARSING_ERROR_MESAGE = "Parsing of this pyomo model is not supported."
 
 def convert_pyomo_to_hamiltonian(
     pyomo_expr: pyomo.core.Expression,
-    ordered_pyomo_vars: List[_GeneralVarData],
-    qregs: List[InternalQuantumReg],
+    ordered_pyomo_vars: list[_GeneralVarData],
+    qregs: list[InternalQuantumReg],
 ) -> PauliOperator:
     symbols_map = sympyify_vars(ordered_pyomo_vars)
     sympy_expr = sympyify_expression(pyomo_expr, symbols_map)
@@ -41,7 +39,7 @@ def convert_pyomo_to_hamiltonian(
 
 
 def _convert_ising_sympy_to_operator(
-    ising_expr: sp.Expr, ordered_sympy_vars: List[sp.Symbol]
+    ising_expr: sp.Expr, ordered_sympy_vars: list[sp.Symbol]
 ) -> custom_pydantic_types.PydanticPauliList:
     pauli_op_list: custom_pydantic_types.PydanticPauliList = []
     for expr_term in ising_expr.args:
@@ -87,7 +85,7 @@ def _to_ising_symbolic_objective_function(objective: sp.Expr) -> sp.Expr:
     return sp.expand(objective_ising)
 
 
-def _get_vars(expr_term: sp.AtomicExpr) -> List[sp.Symbol]:
+def _get_vars(expr_term: sp.AtomicExpr) -> list[sp.Symbol]:
     if isinstance(expr_term, sp.Symbol):
         return [expr_term]
     else:
@@ -95,8 +93,8 @@ def _get_vars(expr_term: sp.AtomicExpr) -> List[sp.Symbol]:
 
 
 def _find_sub_list_items(
-    long_list: List[sp.Symbol], sub_list: List[sp.Symbol]
-) -> List[bool]:
+    long_list: list[sp.Symbol], sub_list: list[sp.Symbol]
+) -> list[bool]:
     return [x in sub_list for x in long_list]
 
 
@@ -111,7 +109,7 @@ def _get_coeff_from_expr(expr: sp.Expr) -> float:
 
 
 def _add_auxiliary_qubits_to_operator(
-    operator: custom_pydantic_types.PydanticPauliList, qregs: List[InternalQuantumReg]
+    operator: custom_pydantic_types.PydanticPauliList, qregs: list[InternalQuantumReg]
 ) -> custom_pydantic_types.PydanticPauliList:
     # TODO: handle the case when the auxiliary are in the middle of the circuit
     for qreg in qregs:

classiq/applications/combinatorial_helpers/transformations/penalty.py

@@ -1,5 +1,4 @@
 import itertools
-from typing import List
 
 from pyomo.core.base.constraint import _GeneralConstraintData
 from pyomo.core.expr.relational_expr import EqualityExpression
@@ -7,7 +6,7 @@ from pyomo.environ import Expression
 
 
 def get_penalty_expression(
-    flat_constraints: List[_GeneralConstraintData],
+    flat_constraints: list[_GeneralConstraintData],
 ) -> Expression:
     return sum(
         _convert_constraint_to_penalty_term(constraint)

classiq/applications/combinatorial_helpers/transformations/sign_seperation.py

@@ -1,5 +1,4 @@
 from itertools import filterfalse
-from typing import List, Tuple
 
 from sympy import (
     Add,
@@ -43,7 +42,7 @@ def sign_separation(expr: Expr) -> LessThan:
     return modified_expr
 
 
-def _get_positive_and_negative_args(expr: Expr) -> Tuple[List[Expr], List[Expr]]:
+def _get_positive_and_negative_args(expr: Expr) -> tuple[list[Expr], list[Expr]]:
     positive_args = []
     negative_args = []
 

classiq/applications/combinatorial_helpers/transformations/slack_variables.py

@@ -1,7 +1,6 @@
 import math
 from functools import cached_property
 from itertools import filterfalse
-from typing import List
 
 import pyomo.core as pyo
 from pyomo.core.base.component import _ComponentBase
@@ -67,7 +66,7 @@ class ConstraintConvertor:
         return max_upper - min_lower
 
     @cached_property
-    def _slack_coeffs(self) -> List[int]:
+    def _slack_coeffs(self) -> list[int]:
         coeffs = [2**idx for idx in self.slack_var_idxs[:-1]]
         coeffs += [self._bound_int - sum(coeffs)]
         return coeffs

classiq/applications/combinatorial_optimization/__init__.py

@@ -1,5 +1,3 @@
-from typing import List
-
 from classiq.interface.combinatorial_optimization import examples
 from classiq.interface.combinatorial_optimization.encoding_types import EncodingType
 from classiq.interface.combinatorial_optimization.solver_types import QSolver
@@ -28,5 +26,5 @@ __all__ = [
 ]
 
 
-def __dir__() -> List[str]:
+def __dir__() -> list[str]:
     return __all__

classiq/applications/combinatorial_optimization/combinatorial_optimization_config.py

@@ -1,6 +1,6 @@
 import dataclasses
 from dataclasses import dataclass
-from typing import List, Optional
+from typing import Optional
 
 from classiq.interface.executor.optimizer_preferences import CostType, OptimizerType
 
@@ -20,4 +20,4 @@ class OptimizerConfig:
     skip_compute_variance: bool = False
     cost_type: CostType = CostType.CVAR
     alpha_cvar: float = 1.0
-    initial_point: Optional[List[float]] = dataclasses.field(default=None)
+    initial_point: Optional[list[float]] = dataclasses.field(default=None)

classiq/applications/combinatorial_optimization/examples/__init__.py

@@ -1,5 +1,3 @@
-from typing import List
-
 from classiq.interface.combinatorial_optimization.examples.ascending_sequence import (
     ascending_sequence,
 )
@@ -47,5 +45,5 @@ __all__ = [
 ]
 
 
-def __dir__() -> List[str]:
+def __dir__() -> list[str]:
     return __all__

classiq/applications/finance/__init__.py

@@ -1,5 +1,3 @@
-from typing import List
-
 from classiq.interface.finance import (
     function_input,
     gaussian_model_input,
@@ -16,5 +14,5 @@ __all__ = [
 ]
 
 
-def __dir__() -> List[str]:
+def __dir__() -> list[str]:
     return __all__

classiq/applications/grover/__init__.py

@@ -1,5 +1,3 @@
-from typing import List
-
 from .grover_model_constructor import construct_grover_model
 
 __all__ = [
@@ -7,5 +5,5 @@ __all__ = [
 ]
 
 
-def __dir__() -> List[str]:
+def __dir__() -> list[str]:
     return __all__

classiq/applications/grover/grover_model_constructor.py

@@ -1,5 +1,3 @@
-from typing import List, Tuple
-
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
@@ -28,10 +26,10 @@ _PREDICATE_FUNCTION_NAME = "expr_predicate"
 
 
 def _arithmetic_oracle_ios(
-    definitions: List[Tuple[str, RegisterUserInput]], handle_name: str
-) -> List[HandleBinding]:
+    definitions: list[tuple[str, RegisterUserInput]], handle_name: str
+) -> list[HandleBinding]:
     cursor = 0
-    ios: List[HandleBinding] = []
+    ios: list[HandleBinding] = []
     for _, reg in definitions:
         ios.append(
             SlicedHandleBinding(
@@ -46,7 +44,7 @@ def _arithmetic_oracle_ios(
 
 def _construct_arithmetic_oracle(
     predicate_function: str,
-    definitions: List[Tuple[str, RegisterUserInput]],
+    definitions: list[tuple[str, RegisterUserInput]],
 ) -> QuantumFunctionCall:
     predicate_var_binding = _arithmetic_oracle_ios(definitions, "state")
     predicate_var_binding.append(HandleBinding(name="oracle"))
@@ -68,9 +66,9 @@ def _construct_arithmetic_oracle(
 
 
 def grover_main_port_declarations(
-    definitions: List[Tuple[str, RegisterUserInput]],
+    definitions: list[tuple[str, RegisterUserInput]],
     direction: PortDeclarationDirection,
-) -> List[PortDeclaration]:
+) -> list[PortDeclaration]:
     return [
         PortDeclaration(
             name=name,
@@ -86,7 +84,7 @@ def grover_main_port_declarations(
 
 
 def construct_grover_model(
-    definitions: List[Tuple[str, RegisterUserInput]],
+    definitions: list[tuple[str, RegisterUserInput]],
     expression: str,
     num_reps: int = 1,
 ) -> SerializedModel:

classiq/applications/hamiltonian/pauli_decomposition.py

@@ -1,4 +1,4 @@
-from typing import List, Tuple, Union
+from typing import Union
 
 import numpy as np
 from sympy import fwht
@@ -17,7 +17,7 @@ PAULI_MATRICES_DICT = {
 }
 
 
-def _get_pauli_string(set_index: int, term_index: int, num_qubits: int) -> List[Pauli]:
+def _get_pauli_string(set_index: int, term_index: int, num_qubits: int) -> list[Pauli]:
     """
     The basis of 4^N Pauli strings on N qubits can be partitioned to 2^N sets, each contains 2^N Pauli strings.
     In the k-th set we have Pauli strings of the form s_1s_2...s_N, where s_j is in {I,Z} if k_j is 0,
@@ -25,7 +25,7 @@ def _get_pauli_string(set_index: int, term_index: int, num_qubits: int) -> List[
     """
 
     # returns the Pauli (I,Z) or (iY, X) appearing in the pauli_index position for a given set
-    def _get_paulis_for_set(set_index: int, pauli_index: int) -> Tuple[Pauli, Pauli]:
+    def _get_paulis_for_set(set_index: int, pauli_index: int) -> tuple[Pauli, Pauli]:
         if (set_index >> pauli_index) & 1:
             return Pauli.Y, Pauli.X
         else:
@@ -63,7 +63,7 @@ def _get_signed_coefficient(
 
 def matrix_to_hamiltonian(
     mat: np.ndarray, tol: float = ATOL, is_hermitian: bool = True
-) -> List[PauliTerm]:
+) -> list[PauliTerm]:
     """
     The decomposition per set is done by the Walsh-Hadamard transform,
     since the transformation between {e_0,e_3} ({e_1,e_2}) to {I,Z} ({X,iY}) is the Hadamard matrix.
@@ -94,7 +94,7 @@ def matrix_to_hamiltonian(
 
 
 # convert a single puali string of length N to 2**N X 2**N matrix
-def pauli_string_to_mat(seq: List[Pauli]) -> np.ndarray:
+def pauli_string_to_mat(seq: list[Pauli]) -> np.ndarray:
     real_matrix = PAULI_MATRICES_DICT[seq[0]]
     for p in seq[1:]:
         real_matrix = np.kron(real_matrix, PAULI_MATRICES_DICT[p])
@@ -102,7 +102,7 @@ def pauli_string_to_mat(seq: List[Pauli]) -> np.ndarray:
 
 
 # return matrix from hamiltonian
-def hamiltonian_to_matrix(hamiltonian: List[PauliTerm]) -> np.ndarray:
+def hamiltonian_to_matrix(hamiltonian: list[PauliTerm]) -> np.ndarray:
     matrix = np.zeros(
         [2 ** len(hamiltonian[0].pauli), 2 ** len(hamiltonian[0].pauli)],
         dtype=np.complex_,

classiq/applications/qnn/__init__.py

@@ -1,7 +1,5 @@
 # This file will be called first whenever any file from within this directory is imported.
 # Thus, we'll test dependencies only here, once.
-from typing import List
-
 try:
     import torch
 except ImportError as exc:
@@ -13,5 +11,5 @@ from ..qnn.qlayer import QLayer
 __all__ = ["datasets", "types", "QLayer"]
 
 
-def __dir__() -> List[str]:
+def __dir__() -> list[str]:
     return __all__

classiq/applications/qnn/circuit_utils.py

@@ -1,6 +1,6 @@
 import itertools
-from collections.abc import Collection
-from typing import Iterable, List, Tuple, Union
+from collections.abc import Collection, Iterable
+from typing import Union
 
 from torch import Tensor
 
@@ -14,8 +14,8 @@ from classiq.applications.qnn.types import Arguments, Circuit
 WEIGHT_INITIALS = ["weight_", "w_"]
 INPUT_INITIALS = ["input_", "i_"]
 
-Parameters = List[str]
-ParametersTuple = Tuple[Parameters, Parameters]
+Parameters = list[str]
+ParametersTuple = tuple[Parameters, Parameters]
 
 
 def _is_name_valid(name: str) -> bool:
@@ -46,7 +46,7 @@ def validate_circuit(circuit: Circuit) -> bool:
     return True
 
 
-def _extract_by_prefix(lst: Parameters, prefix: List[str]) -> Parameters:
+def _extract_by_prefix(lst: Parameters, prefix: list[str]) -> Parameters:
     return [s for s in lst if any(s.startswith(p) for p in prefix)]
 
 

classiq/applications/qnn/datasets/__init__.py

@@ -1,5 +1,3 @@
-from typing import List
-
 from ..datasets import builtin_datasets
 from ..datasets.builtin_datasets import (
     DATALOADER_NOT,
@@ -31,5 +29,5 @@ __all__ = [
 ]
 
 
-def __dir__() -> List[str]:
+def __dir__() -> list[str]:
     return __all__

classiq/applications/qnn/datasets/dataset_base_classes.py

@@ -1,5 +1,6 @@
 from abc import ABC, abstractmethod
-from typing import List, Literal, Optional, Sequence, Tuple, TypeVar, Union
+from collections.abc import Sequence
+from typing import Literal, Optional, TypeVar, Union
 
 from torch import Tensor, tensor
 from torch.utils.data import Dataset
@@ -30,7 +31,7 @@ class MyDataset(Dataset, ABC):
     def _get_data_and_label(self, index: int) -> DataAndLabel:
         pass
 
-    def __getitem__(self, index: int) -> Tuple[Tensor, Tensor]:
+    def __getitem__(self, index: int) -> tuple[Tensor, Tensor]:
         if index < 0 or index >= len(self):
             raise ClassiqIndexError(f"{self.__class__.__name__} out of range")
 
@@ -54,7 +55,7 @@ class MySubsetDataset(MyDataset, ABC):
     def __init__(
         self,
         n: int = 2,
-        subset: Union[List[int], Literal["all"]] = "all",
+        subset: Union[list[int], Literal["all"]] = "all",
         transform: Optional[Transform] = None,
         target_transform: Optional[Transform] = None,
     ) -> None:
@@ -74,5 +75,5 @@ class MySubsetDataset(MyDataset, ABC):
                 'Invalid subset - please enter a `list` of `int`, or the string "all"'
             )
 
-    def _get_subset(self, coll: Sequence[T]) -> List[T]:
+    def _get_subset(self, coll: Sequence[T]) -> list[T]:
         return [coll[i] for i in self._subset]

classiq/applications/qnn/datasets/dataset_parity.py

@@ -1,4 +1,4 @@
-from typing import List, Literal, Optional, Union
+from typing import Literal, Optional, Union
 
 from classiq.applications.qnn.datasets.dataset_base_classes import MySubsetDataset
 from classiq.applications.qnn.types import DataAndLabel, Transform
@@ -8,7 +8,7 @@ class DatasetSubsetParity(MySubsetDataset):
     def __init__(
         self,
         n: int = 2,
-        subset: Union[List[int], Literal["all"]] = "all",
+        subset: Union[list[int], Literal["all"]] = "all",
         add_readout_qubit: bool = True,
         transform: Optional[Transform] = None,
         target_transform: Optional[Transform] = None,

classiq/applications/qnn/gradients/simple_quantum_gradient.py

@@ -1,5 +1,6 @@
 import itertools
-from typing import Any, Iterable
+from collections.abc import Iterable
+from typing import Any
 
 import torch
 from torch import Tensor

classiq/applications/qnn/qlayer.py

@@ -1,5 +1,5 @@
 import functools
-from typing import Any, Callable, Optional, Tuple, Union
+from typing import Any, Callable, Optional, Union
 
 import torch
 import torch.nn as nn
@@ -15,6 +15,7 @@ from classiq.applications.qnn.circuit_utils import (
     validate_circuit,
 )
 from classiq.applications.qnn.gradients.simple_quantum_gradient import (
+    EPSILON,
     SimpleQuantumGradient,
 )
 from classiq.applications.qnn.torch_utils import (
@@ -40,6 +41,7 @@ class QLayerFunction(torch.autograd.Function):
         quantum_program: SerializedQuantumProgram,
         execute: ExecuteFunction,
         post_process: PostProcessFunction,
+        epsilon: Optional[float] = EPSILON,
     ) -> Tensor:
         """
         This function receives:
@@ -52,6 +54,8 @@ class QLayerFunction(torch.autograd.Function):
                 and returning a `Tensor`
 
         """
+        if epsilon is None:
+            epsilon = EPSILON
         circuit = Circuit.model_validate_json(quantum_program)
         validate_circuit(circuit)
 
@@ -61,7 +65,7 @@ class QLayerFunction(torch.autograd.Function):
         ctx.execute = execute
         ctx.post_process = post_process
         ctx.quantum_gradient = SimpleQuantumGradient(
-            quantum_program, execute, post_process
+            quantum_program, execute, post_process, epsilon
         )
 
         ctx.batch_size, ctx.num_in_features = inputs.shape
@@ -95,7 +99,7 @@ class QLayerFunction(torch.autograd.Function):
     @staticmethod
     def backward(  # type: ignore[override]
         ctx: Any, grad_output: Tensor
-    ) -> Tuple[Optional[Tensor], Optional[Tensor], None, None, None]:
+    ) -> tuple[Optional[Tensor], Optional[Tensor], None, None, None, None]:
         """
         grad_output: Tensor
             is of shape (ctx.batch_size, ctx.num_out_features)
@@ -104,6 +108,7 @@ class QLayerFunction(torch.autograd.Function):
 
         grad_weights = grad_inputs = None
         grad_circuit = grad_execute = grad_post_process = None
+        grad_epsilon = None
         is_single_layer = is_single_layer_circuit(weights)
 
         if ctx.needs_input_grad[1]:
@@ -119,7 +124,14 @@ class QLayerFunction(torch.autograd.Function):
                 f"Grad required for unknown type: {ctx.needs_input_grad}"
             )
 
-        return grad_inputs, grad_weights, grad_circuit, grad_execute, grad_post_process
+        return (
+            grad_inputs,
+            grad_weights,
+            grad_circuit,
+            grad_execute,
+            grad_post_process,
+            grad_epsilon,
+        )
 
 
 CalcNumOutFeatures = Callable[[SerializedQuantumProgram], int]
@@ -143,6 +155,7 @@ class QLayer(nn.Module):
         head_start: Union[float, Tensor, None] = None,
         # Experimental parameters:
         calc_num_out_features: CalcNumOutFeatures = calc_num_out_features_single_output,
+        epsilon: float = EPSILON,
     ) -> None:
         circuit = Circuit.model_validate_json(quantum_program)
         validate_circuit(circuit)
@@ -152,6 +165,7 @@ class QLayer(nn.Module):
         self._execute = execute
         self._post_process = post_process
         self._head_start = head_start
+        self._epsilon = epsilon
 
         self.quantum_program = quantum_program
 
@@ -162,7 +176,7 @@ class QLayer(nn.Module):
         self._initialize_parameters()
 
     def _initialize_parameters(self) -> None:
-        shape: Tuple[int, ...] = (
+        shape: tuple[int, ...] = (
             (self.out_features, self.in_features)
             if self.out_features > 1
             else (self.in_features,)
@@ -183,5 +197,10 @@ class QLayer(nn.Module):
 
     def forward(self, x: Tensor) -> Tensor:
         return QLayerFunction.apply(
-            x, self.weight, self.quantum_program, self._execute, self._post_process
+            x,
+            self.weight,
+            self.quantum_program,
+            self._execute,
+            self._post_process,
+            self._epsilon,
         )

classiq/applications/qnn/torch_utils.py

@@ -1,6 +1,6 @@
 from collections.abc import Sized
 from functools import reduce
-from typing import Optional, Tuple
+from typing import Optional
 
 import torch
 import torch.nn as nn
@@ -98,7 +98,7 @@ def iter_inputs_weights(
 ) -> Tensor:
     if is_single_layer_circuit(weights):
         iter_weights = torch.reshape(weights, (1, weights.shape[0]))
-        inputs_weights_shape: Tuple[int, ...] = (inputs.shape[0],)
+        inputs_weights_shape: tuple[int, ...] = (inputs.shape[0],)
     else:
         iter_weights = weights
         inputs_weights_shape = (inputs.shape[0], weights.shape[0])

classiq/applications/qnn/types.py

@@ -1,4 +1,4 @@
-from typing import Callable, Dict, List, Tuple, Union
+from typing import Callable, Union
 
 import torch
 from torch import Tensor
@@ -8,8 +8,8 @@ from classiq.interface.executor.execution_result import ResultsCollection, Saved
 from classiq import QuantumProgram
 from classiq.synthesis import SerializedQuantumProgram
 
-Arguments = Dict[str, float]
-MultipleArguments = Tuple[Arguments, ...]
+Arguments = dict[str, float]
+MultipleArguments = tuple[Arguments, ...]
 
 Circuit = QuantumProgram
 ExecuteFunction = Callable[
@@ -19,10 +19,10 @@ ExecuteFuncitonOnlyArguments = Callable[[MultipleArguments], ResultsCollection]
 PostProcessFunction = Callable[[SavedResult], Tensor]
 TensorToArgumentsCallable = Callable[[Tensor, Tensor], MultipleArguments]
 
-Shape = Union[torch.Size, Tuple[int, ...]]
+Shape = Union[torch.Size, tuple[int, ...]]
 
 GradientFunction = Callable[[Tensor, Tensor], Tensor]
 SimulateFunction = Callable[[Tensor, Tensor], Tensor]
 
-DataAndLabel = Tuple[List[int], Union[List[int], int]]
+DataAndLabel = tuple[list[int], Union[list[int], int]]
 Transform = Callable[[Tensor], Tensor]

classiq/applications/qsvm/qsvm.py

@@ -1,5 +1,3 @@
-from typing import List
-
 from classiq.interface.applications.qsvm import Data, Labels, QSVMData
 
 __all__ = [
@@ -9,5 +7,5 @@ __all__ = [
 ]
 
 
-def __dir__() -> List[str]:
+def __dir__() -> list[str]:
     return __all__