Modernize type hints

qiskit_optimization/algorithms/admm_optimizer.py

@@ -17,7 +17,7 @@
 import copy
 import logging
 import time
-from typing import List, Optional, Tuple, cast
+from typing import cast
 
 import numpy as np
 
@@ -182,7 +182,7 @@ def __init__(  # pylint: disable=too-many-positional-arguments
         self,
         x: np.ndarray,
         fval: float,
-        variables: List[Variable],
+        variables: list[Variable],
         state: ADMMState,
         status: OptimizationResultStatus,
     ) -> None:
@@ -215,9 +215,9 @@ class ADMMOptimizer(OptimizationAlgorithm):
 
     def __init__(
         self,
-        qubo_optimizer: Optional[OptimizationAlgorithm] = None,
-        continuous_optimizer: Optional[OptimizationAlgorithm] = None,
-        params: Optional[ADMMParameters] = None,
+        qubo_optimizer: OptimizationAlgorithm | None = None,
+        continuous_optimizer: OptimizationAlgorithm | None = None,
+        params: ADMMParameters | None = None,
     ) -> None:
         """
         Args:
@@ -400,7 +400,7 @@ def solve(self, problem: QuadraticProgram) -> ADMMOptimizationResult:
         )
 
     @staticmethod
-    def _get_variable_indices(op: QuadraticProgram, var_type: VarType) -> List[int]:
+    def _get_variable_indices(op: QuadraticProgram, var_type: VarType) -> list[int]:
         """Returns a list of indices of the variables of the specified type.
 
         Args:
@@ -483,7 +483,7 @@ def _convert_problem_representation(self) -> None:
         # equality constraints with binary vars only
         self._state.a0, self._state.b0 = self._get_a0_b0()
 
-    def _get_step1_indices(self) -> Tuple[List[int], List[int]]:
+    def _get_step1_indices(self) -> tuple[list[int], list[int]]:
         """
         Constructs two arrays of absolute (pointing to the original problem) and relative (pointing
         to the list of all binary variables) indices of the variables considered
@@ -550,7 +550,7 @@ def _get_step1_indices(self) -> Tuple[List[int], List[int]]:
 
         return step1_absolute_indices, step1_relative_indices
 
-    def _get_q(self, variable_indices: List[int]) -> np.ndarray:
+    def _get_q(self, variable_indices: list[int]) -> np.ndarray:
         """Constructs a quadratic matrix for the variables with the specified indices
         from the quadratic terms in the objective.
 
@@ -573,7 +573,7 @@ def _get_q(self, variable_indices: List[int]) -> np.ndarray:
 
         return q
 
-    def _get_a0_b0(self) -> Tuple[np.ndarray, np.ndarray]:
+    def _get_a0_b0(self) -> tuple[np.ndarray, np.ndarray]:
         """Constructs a matrix and a vector from the constraints in a form of Ax = b, where
         x is a vector of binary variables.
 
@@ -705,7 +705,7 @@ def _update_x0(self, op1: QuadraticProgram) -> np.ndarray:
         x0_all_binaries[self._state.step1_relative_indices] = x0_qubo
         return x0_all_binaries
 
-    def _update_x1(self, op2: QuadraticProgram) -> Tuple[np.ndarray, np.ndarray]:
+    def _update_x1(self, op2: QuadraticProgram) -> tuple[np.ndarray, np.ndarray]:
         """Solves the Step2 QuadraticProgram via the continuous optimizer.
 
         Args:
@@ -734,7 +734,7 @@ def _update_y(self, op3: QuadraticProgram) -> np.ndarray:
         """
         return np.asarray(self._continuous_optimizer.solve(op3).x)
 
-    def _get_best_merit_solution(self) -> Tuple[np.ndarray, np.ndarray, float]:
+    def _get_best_merit_solution(self) -> tuple[np.ndarray, np.ndarray, float]:
         """The ADMM solution is that for which the merit value is the min
             * sol: Iterate with the min merit value
             * sol_val: Value of sol, according to the original objective
@@ -825,7 +825,7 @@ def _get_objective_value(self) -> float:
         """
         return self._state.op.objective.evaluate(self._get_current_solution())
 
-    def _get_solution_residuals(self, iteration: int) -> Tuple[float, float]:
+    def _get_solution_residuals(self, iteration: int) -> tuple[float, float]:
         """Compute primal and dual residual.
 
         Args:

qiskit_optimization/algorithms/amplitude_amplifiers/amplification_problem.py

@@ -14,7 +14,7 @@
 from __future__ import annotations
 
 from collections.abc import Callable
-from typing import Any, List, cast
+from typing import Any, cast
 
 from qiskit.circuit import QuantumCircuit
 from qiskit.circuit.library import GroverOperator
@@ -168,10 +168,10 @@ def is_good_state(self) -> Callable[[str], bool]:
             return self._is_good_state  # returns None if no is_good_state arg has been set
         elif isinstance(self._is_good_state, list):
             if all(isinstance(good_bitstr, str) for good_bitstr in self._is_good_state):
-                return lambda bitstr: bitstr in cast(List[str], self._is_good_state)
+                return lambda bitstr: bitstr in cast(list[str], self._is_good_state)
             else:
                 return lambda bitstr: all(
-                    bitstr[good_index] == "1" for good_index in cast(List[int], self._is_good_state)
+                    bitstr[good_index] == "1" for good_index in cast(list[int], self._is_good_state)
                 )
 
         return lambda bitstr: bitstr in cast(Statevector, self._is_good_state).probabilities_dict()

qiskit_optimization/algorithms/cobyla_optimizer.py

@@ -11,8 +11,9 @@
 # that they have been altered from the originals.
 
 """The COBYLA optimizer wrapped to be used within Qiskit optimization module."""
+from __future__ import annotations
 
-from typing import Optional, cast, List, Tuple, Any
+from typing import cast, Any
 
 import numpy as np
 from scipy.optimize import fmin_cobyla
@@ -48,7 +49,7 @@ def __init__(  # pylint: disable=too-many-positional-arguments
         rhobeg: float = 1.0,
         rhoend: float = 1e-4,
         maxfun: int = 1000,
-        disp: Optional[int] = None,
+        disp: int | None = None,
         catol: float = 2e-4,
         trials: int = 1,
         clip: float = 100.0,
@@ -145,8 +146,8 @@ def ub_constraint(x, u_b=upperbound, j=i):
 
         # pylint: disable=no-member
         # add linear and quadratic constraints
-        for constraint in cast(List[Constraint], problem.linear_constraints) + cast(
-            List[Constraint], problem.quadratic_constraints
+        for constraint in cast(list[Constraint], problem.linear_constraints) + cast(
+            list[Constraint], problem.quadratic_constraints
         ):
             rhs = constraint.rhs
             sense = constraint.sense
@@ -164,7 +165,7 @@ def ub_constraint(x, u_b=upperbound, j=i):
                 raise QiskitOptimizationError("Unsupported constraint type!")
 
         # actual minimization function to be called by multi_start_solve
-        def _minimize(x_0: np.ndarray) -> Tuple[np.ndarray, Any]:
+        def _minimize(x_0: np.ndarray) -> tuple[np.ndarray, Any]:
             x = fmin_cobyla(
                 problem.objective.evaluate,
                 x_0,

qiskit_optimization/algorithms/cplex_optimizer.py

@@ -11,8 +11,9 @@
 # that they have been altered from the originals.
 
 """The CPLEX optimizer wrapped to be used within Qiskit optimization module."""
+from __future__ import annotations
 
-from typing import Any, Dict, Optional
+from typing import Any
 from warnings import warn
 
 from qiskit_optimization.problems.quadratic_program import QuadraticProgram
@@ -41,9 +42,7 @@ class CplexOptimizer(OptimizationAlgorithm):
         >>> if optimizer: result = optimizer.solve(problem)
     """
 
-    def __init__(
-        self, disp: bool = False, cplex_parameters: Optional[Dict[str, Any]] = None
-    ) -> None:
+    def __init__(self, disp: bool = False, cplex_parameters: dict[str, Any] | None = None) -> None:
         """Initializes the CplexOptimizer.
 
         Args:
@@ -77,12 +76,12 @@ def disp(self, disp: bool):
         self._disp = disp
 
     @property
-    def cplex_parameters(self) -> Optional[Dict[str, Any]]:
+    def cplex_parameters(self) -> dict[str, Any] | None:
         """Returns parameters for CPLEX"""
         return self._cplex_parameters
 
     @cplex_parameters.setter
-    def cplex_parameters(self, parameters: Optional[Dict[str, Any]]):
+    def cplex_parameters(self, parameters: dict[str, Any] | None):
         """Set parameters for CPLEX
         Args:
             parameters: The parameters for CPLEX

qiskit_optimization/algorithms/goemans_williamson_optimizer.py

@@ -14,8 +14,9 @@
 Implementation of the Goemans-Williamson algorithm as an optimizer.
 Requires CVXPY to run.
 """
+from __future__ import annotations
 import logging
-from typing import Optional, List, Tuple, Union, cast
+from typing import cast
 
 import numpy as np
 
@@ -41,12 +42,12 @@ class GoemansWilliamsonOptimizationResult(OptimizationResult):
 
     def __init__(  # pylint: disable=too-many-positional-arguments
         self,
-        x: Optional[Union[List[float], np.ndarray]],
+        x: list[float] | np.ndarray | None,
         fval: float,
-        variables: List[Variable],
+        variables: list[Variable],
         status: OptimizationResultStatus,
-        samples: Optional[List[SolutionSample]],
-        sdp_solution: Optional[np.ndarray] = None,
+        samples: list[SolutionSample] | None,
+        sdp_solution: np.ndarray | None = None,
     ) -> None:
         """
         Args:
@@ -61,7 +62,7 @@ def __init__(  # pylint: disable=too-many-positional-arguments
         self._sdp_solution = sdp_solution
 
     @property
-    def sdp_solution(self) -> Optional[np.ndarray]:
+    def sdp_solution(self) -> np.ndarray | None:
         """
         Returns:
             Returns an SDP solution of the problem.
@@ -188,8 +189,8 @@ def solve(self, problem: QuadraticProgram) -> OptimizationResult:
         )
 
     def _get_unique_cuts(
-        self, solutions: List[Tuple[np.ndarray, float]]
-    ) -> List[Tuple[np.ndarray, float]]:
+        self, solutions: list[tuple[np.ndarray, float]]
+    ) -> list[tuple[np.ndarray, float]]:
         """
         Returns:
             Unique Goemans-Williamson cuts.

qiskit_optimization/algorithms/grover_optimizer.py

@@ -11,12 +11,13 @@
 # that they have been altered from the originals.
 
 """GroverOptimizer module"""
+from __future__ import annotations
 
 import logging
 import math
 import warnings
 from copy import deepcopy
-from typing import Dict, List, Optional, Union, cast
+from typing import cast
 
 import numpy as np
 from qiskit import QuantumCircuit, QuantumRegister
@@ -46,12 +47,10 @@ def __init__(  # pylint: disable=too-many-positional-arguments
         self,
         num_value_qubits: int,
         num_iterations: int = 3,
-        converters: Optional[
-            Union[QuadraticProgramConverter, List[QuadraticProgramConverter]]
-        ] = None,
-        penalty: Optional[float] = None,
-        sampler: Optional[Union[BaseSamplerV1, BaseSamplerV2]] = None,
-        pass_manager: Optional[BasePassManager] = None,
+        converters: QuadraticProgramConverter | list[QuadraticProgramConverter] | None = None,
+        penalty: float | None = None,
+        sampler: BaseSamplerV1 | BaseSamplerV2 | None = None,
+        pass_manager: BasePassManager | None = None,
     ) -> None:
         """
         Args:
@@ -303,7 +302,7 @@ def _measure(self, circuit: QuantumCircuit) -> str:
         # Pick a random outcome.
         return algorithm_globals.random.choice(list(probs.keys()), 1, p=list(probs.values()))[0]
 
-    def _get_prob_dist(self, qc: QuantumCircuit) -> Dict[str, float]:
+    def _get_prob_dist(self, qc: QuantumCircuit) -> dict[str, float]:
         """Gets probabilities from a given backend."""
         if self._pass_manager:
             qc = self._pass_manager.run(qc)
@@ -345,17 +344,17 @@ class GroverOptimizationResult(OptimizationResult):
 
     def __init__(  # pylint: disable=too-many-positional-arguments
         self,
-        x: Union[List[float], np.ndarray],
+        x: list[float] | np.ndarray,
         fval: float,
-        variables: List[Variable],
-        operation_counts: Dict[int, Dict[str, int]],
+        variables: list[Variable],
+        operation_counts: dict[int, dict[str, int]],
         n_input_qubits: int,
         n_output_qubits: int,
         intermediate_fval: float,
         threshold: float,
         status: OptimizationResultStatus,
-        samples: Optional[List[SolutionSample]] = None,
-        raw_samples: Optional[List[SolutionSample]] = None,
+        samples: list[SolutionSample] | None = None,
+        raw_samples: list[SolutionSample] | None = None,
     ) -> None:
         """
         Constructs a result object with the specific Grover properties.
@@ -392,7 +391,7 @@ def __init__(  # pylint: disable=too-many-positional-arguments
         self._threshold = threshold
 
     @property
-    def operation_counts(self) -> Dict[int, Dict[str, int]]:
+    def operation_counts(self) -> dict[int, dict[str, int]]:
         """Get the operation counts.
 
         Returns:
@@ -437,7 +436,7 @@ def threshold(self) -> float:
         return self._threshold
 
     @property
-    def raw_samples(self) -> Optional[List[SolutionSample]]:
+    def raw_samples(self) -> list[SolutionSample] | None:
         """Returns the list of raw solution samples of ``GroverOptimizer``.
 
         Returns:

qiskit_optimization/algorithms/minimum_eigen_optimizer.py

@@ -11,7 +11,8 @@
 # that they have been altered from the originals.
 
 """A wrapper for minimum eigen solvers to be used within the optimization module."""
-from typing import List, Optional, Union, cast
+from __future__ import annotations
+from typing import Union, cast
 
 import numpy as np
 from qiskit.quantum_info import SparsePauliOp
@@ -41,13 +42,13 @@ class MinimumEigenOptimizationResult(OptimizationResult):
 
     def __init__(  # pylint: disable=too-many-positional-arguments
         self,
-        x: Optional[Union[List[float], np.ndarray]],
-        fval: Optional[float],
-        variables: List[Variable],
+        x: list[float] | np.ndarray | None,
+        fval: float | None,
+        variables: list[Variable],
         status: OptimizationResultStatus,
-        samples: Optional[List[SolutionSample]] = None,
-        min_eigen_solver_result: Optional[MinimumEigensolverResult] = None,
-        raw_samples: Optional[List[SolutionSample]] = None,
+        samples: list[SolutionSample] | None = None,
+        min_eigen_solver_result: MinimumEigensolverResult | None = None,
+        raw_samples: list[SolutionSample] | None = None,
     ) -> None:
         """
         Args:
@@ -79,7 +80,7 @@ def min_eigen_solver_result(self) -> MinimumEigensolverResult:
         return self._min_eigen_solver_result
 
     @property
-    def raw_samples(self) -> Optional[List[SolutionSample]]:
+    def raw_samples(self) -> list[SolutionSample] | None:
         """Returns the list of raw solution samples of
         ``SamplingMinimumEigensolver`` or ``NumPyMinimumEigensolver``.
 
@@ -123,10 +124,8 @@ class MinimumEigenOptimizer(OptimizationAlgorithm):
     def __init__(
         self,
         min_eigen_solver: MinimumEigensolver,
-        penalty: Optional[float] = None,
-        converters: Optional[
-            Union[QuadraticProgramConverter, List[QuadraticProgramConverter]]
-        ] = None,
+        penalty: float | None = None,
+        converters: QuadraticProgramConverter | list[QuadraticProgramConverter] | None = None,
     ) -> None:
         """
         This initializer takes the minimum eigen solver to be used to approximate the ground state
@@ -212,7 +211,7 @@ def _solve_internal(
         original_problem: QuadraticProgram,
     ):
         # only try to solve non-empty Ising Hamiltonians
-        eigen_result: Optional[MinimumEigensolverResult] = None
+        eigen_result: MinimumEigensolverResult | None = None
         if operator.num_qubits > 0:
             # approximate ground state of operator using min eigen solver
             eigen_result = self._min_eigen_solver.compute_minimum_eigenvalue(operator)