Change typing.List and typing.Tuple to list and tuple equivalents

Author: tturocy

src/pygambit/action.pxi

@@ -108,7 +108,7 @@ class Action:
             return Rational(py_string.decode("ascii"))
 
     @property
-    def plays(self) -> typing.List[Node]:
+    def plays(self) -> list[Node]:
         """Returns a list of all terminal `Node` objects consistent with it.
         """
         return [

src/pygambit/behavmixed.pxi

@@ -81,7 +81,7 @@ class MixedAction:
     def __len__(self) -> len:
         return len(self.infoset.actions)
 
-    def __iter__(self) -> typing.Iterator[typing.Tuple[Action, ProfileDType], None, None]:
+    def __iter__(self) -> typing.Iterator[tuple[Action, ProfileDType], None, None]:
         """Iterate over the probabilities assigned to actions by the mixed action.
 
         .. versionadded:: 16.2.0
@@ -225,7 +225,7 @@ class MixedBehavior:
     def __len__(self) -> int:
         return len(self.player.actions)
 
-    def mixed_actions(self) -> typing.Iterator[typing.Tuple[Infoset, MixedAction], None, None]:
+    def mixed_actions(self) -> typing.Iterator[tuple[Infoset, MixedAction], None, None]:
         """Iterate over the mixed actions specified by the mixed behavior.
 
         .. versionadded:: 16.2.0
@@ -240,7 +240,7 @@ class MixedBehavior:
         for infoset in self.player.infosets:
             yield infoset, self[infoset]
 
-    def __iter__(self) -> typing.Iterator[typing.Tuple[Action, ProfileDType], None, None]:
+    def __iter__(self) -> typing.Iterator[tuple[Action, ProfileDType], None, None]:
         """Iterate over the probabilities assigned to actions by the mixed behavior.
 
         .. versionadded:: 16.2.0
@@ -387,7 +387,7 @@ class MixedBehaviorProfile:
         """The game on which this mixed behavior profile is defined."""
         return self._game
 
-    def mixed_behaviors(self) -> typing.Iterator[typing.Tuple[Player, MixedBehavior], None, None]:
+    def mixed_behaviors(self) -> typing.Iterator[tuple[Player, MixedBehavior], None, None]:
         """Iterate over the mixed behaviors in the profile.
 
         .. versionadded:: 16.2.0
@@ -402,7 +402,7 @@ class MixedBehaviorProfile:
         for player in self.game.players:
             yield player, self[player]
 
-    def mixed_actions(self) -> typing.Iterator[typing.Tuple[Infoset, MixedAction], None, None]:
+    def mixed_actions(self) -> typing.Iterator[tuple[Infoset, MixedAction], None, None]:
         """Iterate over the mixed actions specified by the profile.
 
         .. versionadded:: 16.2.0
@@ -417,7 +417,7 @@ class MixedBehaviorProfile:
         for infoset in self.game.infosets:
             yield infoset, self[infoset]
 
-    def __iter__(self) -> typing.Iterator[typing.Tuple[Action, ProfileDType], None, None]:
+    def __iter__(self) -> typing.Iterator[tuple[Action, ProfileDType], None, None]:
         """Iterate over the probabilities assigned to actions by the profile.
 
         .. versionadded:: 16.2.0

src/pygambit/game.pxi

@@ -468,7 +468,7 @@ class Game:
 
     @classmethod
     def new_tree(cls,
-                 players: typing.List[str] | None = None,
+                 players: list[str] | None = None,
                  title: str = "Untitled extensive game") -> Game:
         """Create a new ``Game`` consisting of a trivial game tree,
         with one node, which is both root and terminal.
@@ -562,7 +562,7 @@ class Game:
         g.title = title
         return g
 
-    def to_arrays(self, dtype: typing.Type = Rational) -> typing.List[np.array]:
+    def to_arrays(self, dtype: typing.Type = Rational) -> list[np.array]:
         """Generate the payoff tables for players represented as numpy arrays.
 
         Parameters
@@ -1475,7 +1475,7 @@ class Game:
     def _resolve_nodes(self,
                        nodes: typing.Any,
                        funcname: str,
-                       argname: str = "nodes") -> typing.List[Node]:
+                       argname: str = "nodes") -> list[Node]:
         """Resolve an attempt to reference a subset of the nodes of the game of the game.
 
         See `_resolve_node` for details on functionality.
@@ -1575,7 +1575,7 @@ class Game:
 
     def append_move(self, nodes: Node | NodeReferenceSet,
                     player: Player | str,
-                    actions: typing.List[str]) -> None:
+                    actions: list[str]) -> None:
         """Add a move for `player` at terminal `nodes`.  All elements of `nodes` become part of
         a new information set, with actions labeled according to `actions`.
 
@@ -1753,7 +1753,7 @@ class Game:
         self.game.deref().DeleteTree(resolved_node.node)
 
     def add_action(self,
-                   infoset: typing.Infoset | str,
+                   infoset: Infoset | str,
                    before: Action | str | None = None) -> None:
         """Add an action at the information set `infoset`.   If `before` is not null, the new
         action is inserted before `before`.

src/pygambit/infoset.pxi

@@ -167,7 +167,7 @@ class Infoset:
         return InfosetActions.wrap(self.infoset)
 
     @property
-    def own_prior_actions(self) -> typing.List[Action | None]:
+    def own_prior_actions(self) -> list[Action | None]:
         """The set of actions taken by the player immediately preceding the member nodes
         in the information set.
 
@@ -216,7 +216,7 @@ class Infoset:
         return Player.wrap(self.infoset.deref().GetPlayer())
 
     @property
-    def plays(self) -> typing.List[Node]:
+    def plays(self) -> list[Node]:
         """Returns a list of all terminal `Node` objects consistent with it.
         """
         return [

src/pygambit/nash.pxi

@@ -25,120 +25,117 @@ from cython.operator cimport dereference as deref
 from libcpp.list cimport list as stdlist
 
 
-import typing
-
-
 @cython.cfunc
 def _convert_mspd(
         inlist: stdlist[c_MixedStrategyProfile[float]]
-) -> typing.List[MixedStrategyProfile[double]]:
+) -> list[MixedStrategyProfile[double]]:
     return [MixedStrategyProfileDouble.wrap(profile)
             for profile in make_list_of_pointer(inlist)]
 
 
 @cython.cfunc
 def _convert_mspr(
         inlist: stdlist[c_MixedStrategyProfile[c_Rational]]
-) -> typing.List[MixedStrategyProfile[c_Rational]]:
+) -> list[MixedStrategyProfile[c_Rational]]:
     return [MixedStrategyProfileRational.wrap(profile)
             for profile in make_list_of_pointer(inlist)]
 
 
 @cython.cfunc
 def _convert_mbpd(
         inlist: stdlist[c_MixedBehaviorProfile[float]]
-) -> typing.List[MixedBehaviorProfile[double]]:
+) -> list[MixedBehaviorProfile[double]]:
     return [MixedBehaviorProfileDouble.wrap(profile)
             for profile in make_list_of_pointer(inlist)]
 
 
 @cython.cfunc
 def _convert_mbpr(
         inlist: stdlist[c_MixedBehaviorProfile[c_Rational]]
-) -> typing.List[MixedBehaviorProfile[c_Rational]]:
+) -> list[MixedBehaviorProfile[c_Rational]]:
     return [MixedBehaviorProfileRational.wrap(profile)
             for profile in make_list_of_pointer(inlist)]
 
 
-def _enumpure_strategy_solve(game: Game) -> typing.List[MixedStrategyProfile[c_Rational]]:
+def _enumpure_strategy_solve(game: Game) -> list[MixedStrategyProfile[c_Rational]]:
     return _convert_mspr(EnumPureStrategySolve(game.game))
 
 
-def _enumpure_agent_solve(game: Game) -> typing.List[MixedBehaviorProfileRational]:
+def _enumpure_agent_solve(game: Game) -> list[MixedBehaviorProfileRational]:
     return _convert_mbpr(EnumPureAgentSolve(game.game))
 
 
-def _enummixed_strategy_solve_double(game: Game) -> typing.List[MixedStrategyProfileDouble]:
+def _enummixed_strategy_solve_double(game: Game) -> list[MixedStrategyProfileDouble]:
     return _convert_mspd(EnumMixedStrategySolve[double](game.game))
 
 
-def _enummixed_strategy_solve_rational(game: Game) -> typing.List[MixedStrategyProfileRational]:
+def _enummixed_strategy_solve_rational(game: Game) -> list[MixedStrategyProfileRational]:
     return _convert_mspr(EnumMixedStrategySolve[c_Rational](game.game))
 
 
 def _lcp_behavior_solve_double(
         game: Game, stop_after: int, max_depth: int
-) -> typing.List[MixedBehaviorProfileDouble]:
+) -> list[MixedBehaviorProfileDouble]:
     return _convert_mbpd(LcpBehaviorSolve[double](game.game, stop_after, max_depth))
 
 
 def _lcp_behavior_solve_rational(
         game: Game, stop_after: int, max_depth: int
-) -> typing.List[MixedBehaviorProfileRational]:
+) -> list[MixedBehaviorProfileRational]:
     return _convert_mbpr(LcpBehaviorSolve[c_Rational](game.game, stop_after, max_depth))
 
 
 def _lcp_strategy_solve_double(
         game: Game, stop_after: int, max_depth: int
-) -> typing.List[MixedStrategyProfileDouble]:
+) -> list[MixedStrategyProfileDouble]:
     return _convert_mspd(LcpStrategySolve[double](game.game, stop_after, max_depth))
 
 
 def _lcp_strategy_solve_rational(
         game: Game, stop_after: int, max_depth: int
-) -> typing.List[MixedStrategyProfileRational]:
+) -> list[MixedStrategyProfileRational]:
     return _convert_mspr(LcpStrategySolve[c_Rational](game.game, stop_after, max_depth))
 
 
-def _lp_behavior_solve_double(game: Game) -> typing.List[MixedBehaviorProfileDouble]:
+def _lp_behavior_solve_double(game: Game) -> list[MixedBehaviorProfileDouble]:
     return _convert_mbpd(LpBehaviorSolve[double](game.game))
 
 
-def _lp_behavior_solve_rational(game: Game) -> typing.List[MixedBehaviorProfileRational]:
+def _lp_behavior_solve_rational(game: Game) -> list[MixedBehaviorProfileRational]:
     return _convert_mbpr(LpBehaviorSolve[c_Rational](game.game))
 
 
-def _lp_strategy_solve_double(game: Game) -> typing.List[MixedStrategyProfileDouble]:
+def _lp_strategy_solve_double(game: Game) -> list[MixedStrategyProfileDouble]:
     return _convert_mspd(LpStrategySolve[double](game.game))
 
 
-def _lp_strategy_solve_rational(game: Game) -> typing.List[MixedStrategyProfileRational]:
+def _lp_strategy_solve_rational(game: Game) -> list[MixedStrategyProfileRational]:
     return _convert_mspr(LpStrategySolve[c_Rational](game.game))
 
 
 def _liap_strategy_solve(start: MixedStrategyProfileDouble,
                          maxregret: float,
-                         maxiter: int) -> typing.List[MixedStrategyProfileDouble]:
+                         maxiter: int) -> list[MixedStrategyProfileDouble]:
     return _convert_mspd(LiapStrategySolve(deref(start.profile), maxregret, maxiter))
 
 
 def _liap_behavior_solve(start: MixedBehaviorProfileDouble,
                          maxregret: float,
-                         maxiter: int) -> typing.List[MixedBehaviorProfileDouble]:
+                         maxiter: int) -> list[MixedBehaviorProfileDouble]:
     return _convert_mbpd(LiapBehaviorSolve(deref(start.profile), maxregret, maxiter))
 
 
 def _simpdiv_strategy_solve(
         start: MixedStrategyProfileRational, maxregret: Rational, gridstep: int, leash: int
-) -> typing.List[MixedStrategyProfileRational]:
+) -> list[MixedStrategyProfileRational]:
     return _convert_mspr(SimpdivStrategySolve(deref(start.profile),
                                               to_rational(str(maxregret).encode("ascii")),
                                               gridstep, leash))
 
 
 def _ipa_strategy_solve(
         pert: MixedStrategyProfileDouble
-) -> typing.List[MixedStrategyProfileDouble]:
+) -> list[MixedStrategyProfileDouble]:
     try:
         return _convert_mspd(IPAStrategySolve(deref(pert.profile)))
     except RuntimeError as e:
@@ -153,7 +150,7 @@ def _gnm_strategy_solve(
         steps: int,
         local_newton_interval: int,
         local_newton_maxits: int,
-) -> typing.List[MixedStrategyProfileDouble]:
+) -> list[MixedStrategyProfileDouble]:
     try:
         return _convert_mspd(GNMStrategySolve(deref(pert.profile), end_lambda,
                                               steps, local_newton_interval, local_newton_maxits))
@@ -163,7 +160,7 @@ def _gnm_strategy_solve(
         raise
 
 
-def _nashsupport_strategy_solve(game: Game) -> typing.List[StrategySupportProfile]:
+def _nashsupport_strategy_solve(game: Game) -> list[StrategySupportProfile]:
     return [
         StrategySupportProfile.wrap(support)
         for support in make_list_of_pointer(
@@ -176,27 +173,27 @@ def _enumpoly_strategy_solve(
         game: Game,
         stop_after: int,
         maxregret: float,
-) -> typing.List[MixedStrategyProfileDouble]:
+) -> list[MixedStrategyProfileDouble]:
     return _convert_mspd(EnumPolyStrategySolve(game.game, stop_after, maxregret))
 
 
 def _enumpoly_behavior_solve(
         game: Game,
         stop_after: int,
         maxregret: float,
-) -> typing.List[MixedBehaviorProfileDouble]:
+) -> list[MixedBehaviorProfileDouble]:
     return _convert_mbpd(EnumPolyBehaviorSolve(game.game, stop_after, maxregret))
 
 
 def _logit_strategy_solve(
         game: Game, maxregret: float, first_step: float, max_accel: float,
-) -> typing.List[MixedStrategyProfileDouble]:
+) -> list[MixedStrategyProfileDouble]:
     return _convert_mspd(LogitStrategySolveWrapper(game.game, maxregret, first_step, max_accel))
 
 
 def _logit_behavior_solve(
         game: Game, maxregret: float, first_step: float, max_accel: float,
-) -> typing.List[MixedBehaviorProfileDouble]:
+) -> list[MixedBehaviorProfileDouble]:
     return _convert_mbpd(LogitBehaviorSolveWrapper(game.game, maxregret, first_step, max_accel))
 
 
@@ -261,9 +258,9 @@ def _logit_strategy_estimate(profile: MixedStrategyProfileDouble,
 
 
 def _logit_strategy_lambda(game: Game,
-                           lam: float | typing.List[float],
+                           lam: float | list[float],
                            first_step: float = .03,
-                           max_accel: float = 1.1) -> typing.List[LogitQREMixedStrategyProfile]:
+                           max_accel: float = 1.1) -> list[LogitQREMixedStrategyProfile]:
     """Compute the first QRE encountered along the principal branch of the strategic
     game corresponding to lambda value `lam`.
     """
@@ -342,9 +339,9 @@ def _logit_behavior_estimate(profile: MixedBehaviorProfileDouble,
 
 
 def _logit_behavior_lambda(game: Game,
-                           lam: float | typing.List[float],
+                           lam: float | list[float],
                            first_step: float = .03,
-                           max_accel: float = 1.1) -> typing.List[LogitQREMixedBehaviorProfile]:
+                           max_accel: float = 1.1) -> list[LogitQREMixedBehaviorProfile]:
     """Compute the first QRE encountered along the principal branch of the extensive
     game corresponding to lambda value `lam`.
     """

src/pygambit/node.pxi

@@ -255,7 +255,7 @@ class Node:
         return Outcome.wrap(self.node.deref().GetOutcome())
 
     @property
-    def plays(self) -> typing.List[Node]:
+    def plays(self) -> list[Node]:
         """Returns a list of all terminal `Node` objects consistent with it.
         """
         return [Node.wrap(n) for n in self.node.deref().GetGame().deref().GetPlays(self.node)]