add 'from __future__ import annotations'

Author: basnijholt

adaptive/learner/__init__.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from contextlib import suppress
 
 from adaptive.learner.average_learner import AverageLearner

adaptive/learner/average_learner.py

@@ -1,5 +1,7 @@
+from __future__ import annotations
+
 from math import sqrt
-from typing import Callable, Dict, List, Optional, Tuple
+from typing import Callable
 
 import cloudpickle
 import numpy as np
@@ -38,8 +40,8 @@ class AverageLearner(BaseLearner):
     def __init__(
         self,
         function: Callable[[int], Real],
-        atol: Optional[float] = None,
-        rtol: Optional[float] = None,
+        atol: float | None = None,
+        rtol: float | None = None,
         min_npoints: int = 2,
     ) -> None:
         if atol is None and rtol is None:
@@ -68,7 +70,7 @@ def to_numpy(self):
         """Data as NumPy array of size (npoints, 2) with seeds and values."""
         return np.array(sorted(self.data.items()))
 
-    def ask(self, n: int, tell_pending: bool = True) -> Tuple[List[int], List[Float]]:
+    def ask(self, n: int, tell_pending: bool = True) -> tuple[list[int], list[Float]]:
         points = list(range(self.n_requested, self.n_requested + n))
 
         if any(p in self.data or p in self.pending_points for p in points):
@@ -159,10 +161,10 @@ def plot(self):
         vals = hv.Points(vals)
         return hv.operation.histogram(vals, num_bins=num_bins, dimension="y")
 
-    def _get_data(self) -> Tuple[Dict[int, Real], int, Real, Real]:
+    def _get_data(self) -> tuple[dict[int, Real], int, Real, Real]:
         return (self.data, self.npoints, self.sum_f, self.sum_f_sq)
 
-    def _set_data(self, data: Tuple[Dict[int, Real], int, Real, Real]) -> None:
+    def _set_data(self, data: tuple[dict[int, Real], int, Real, Real]) -> None:
         self.data, self.npoints, self.sum_f, self.sum_f_sq = data
 
     def __getstate__(self):

adaptive/learner/average_learner1D.py

@@ -1,9 +1,11 @@
+from __future__ import annotations
+
 import math
 import sys
 from collections import defaultdict
 from copy import deepcopy
 from math import hypot
-from typing import Callable, DefaultDict, Dict, List, Optional, Sequence, Set, Tuple
+from typing import Callable, DefaultDict, List, Sequence, Tuple
 
 import numpy as np
 import scipy.stats
@@ -17,7 +19,7 @@
 Point = Tuple[int, Real]
 Points = List[Point]
 
-__all__: List[str] = ["AverageLearner1D"]
+__all__: list[str] = ["AverageLearner1D"]
 
 
 class AverageLearner1D(Learner1D):
@@ -65,11 +67,10 @@ class AverageLearner1D(Learner1D):
 
     def __init__(
         self,
-        function: Callable[[Tuple[int, Real]], Real],
-        bounds: Tuple[Real, Real],
-        loss_per_interval: Optional[
-            Callable[[Sequence[Real], Sequence[Real]], float]
-        ] = None,
+        function: Callable[[tuple[int, Real]], Real],
+        bounds: tuple[Real, Real],
+        loss_per_interval: None
+        | (Callable[[Sequence[Real], Sequence[Real]], float]) = None,
         delta: float = 0.2,
         alpha: float = 0.005,
         neighbor_sampling: float = 0.3,
@@ -105,7 +106,7 @@ def __init__(
         self._number_samples = SortedDict()
         # This set contains the points x that have less than min_samples
         # samples or less than a (neighbor_sampling*100)% of their neighbors
-        self._undersampled_points: Set[Real] = set()
+        self._undersampled_points: set[Real] = set()
         # Contains the error in the estimate of the
         # mean at each point x in the form {x0: error(x0), ...}
         self.error: ItemSortedDict[Real, float] = decreasing_dict()
@@ -126,7 +127,7 @@ def min_samples_per_point(self) -> int:
             return 0
         return min(self._number_samples.values())
 
-    def ask(self, n: int, tell_pending: bool = True) -> Tuple[Points, List[float]]:
+    def ask(self, n: int, tell_pending: bool = True) -> tuple[Points, list[float]]:
         """Return 'n' points that are expected to maximally reduce the loss."""
         # If some point is undersampled, resample it
         if len(self._undersampled_points):
@@ -155,7 +156,7 @@ def ask(self, n: int, tell_pending: bool = True) -> Tuple[Points, List[float]]:
 
         return points, loss_improvements
 
-    def _ask_for_more_samples(self, x: Real, n: int) -> Tuple[Points, List[float]]:
+    def _ask_for_more_samples(self, x: Real, n: int) -> tuple[Points, list[float]]:
         """When asking for n points, the learner returns n times an existing point
         to be resampled, since in general n << min_samples and this point will
         need to be resampled many more times"""
@@ -174,7 +175,7 @@ def _ask_for_more_samples(self, x: Real, n: int) -> Tuple[Points, List[float]]:
         loss_improvements = [loss_improvement / n] * n
         return points, loss_improvements
 
-    def _ask_for_new_point(self, n: int) -> Tuple[Points, List[float]]:
+    def _ask_for_new_point(self, n: int) -> tuple[Points, list[float]]:
         """When asking for n new points, the learner returns n times a single
         new point, since in general n << min_samples and this point will need
         to be resampled many more times"""
@@ -388,7 +389,7 @@ def tell_many(self, xs: Points, ys: Sequence[Real]) -> None:
                 # simultaneously, before we move on to a new x
                 self.tell_many_at_point(x, seed_y_mapping)
 
-    def tell_many_at_point(self, x: Real, seed_y_mapping: Dict[int, Real]) -> None:
+    def tell_many_at_point(self, x: Real, seed_y_mapping: dict[int, Real]) -> None:
         """Tell the learner about many samples at a certain location x.
 
         Parameters

adaptive/learner/balancing_learner.py

@@ -1,22 +1,13 @@
+from __future__ import annotations
+
 import itertools
 import numbers
 from collections import defaultdict
 from collections.abc import Iterable
 from contextlib import suppress
 from functools import partial
 from operator import itemgetter
-from typing import (
-    Any,
-    Callable,
-    Dict,
-    List,
-    Literal,
-    Optional,
-    Sequence,
-    Set,
-    Tuple,
-    Union,
-)
+from typing import Any, Callable, Dict, Literal, Sequence, Tuple, Union
 
 import numpy as np
 
@@ -25,7 +16,7 @@
 from adaptive.utils import cache_latest, named_product, restore
 
 
-def dispatch(child_functions: List[Callable], arg: Any) -> Union[Any]:
+def dispatch(child_functions: list[Callable], arg: Any) -> Any:
     index, x = arg
     return child_functions[index](x)
 
@@ -91,9 +82,9 @@ class BalancingLearner(BaseLearner):
 
     def __init__(
         self,
-        learners: List[BaseLearner],
+        learners: list[BaseLearner],
         *,
-        cdims: Optional[CDIMS_TYPE] = None,
+        cdims: CDIMS_TYPE | None = None,
         strategy: STRATEGY_TYPE = "loss_improvements",
     ) -> None:
         self.learners = learners
@@ -116,14 +107,14 @@ def __init__(
         self.strategy: STRATEGY_TYPE = strategy
 
     @property
-    def data(self) -> Dict[Tuple[int, Any], Any]:
+    def data(self) -> dict[tuple[int, Any], Any]:
         data = {}
         for i, l in enumerate(self.learners):
             data.update({(i, p): v for p, v in l.data.items()})
         return data
 
     @property
-    def pending_points(self) -> Set[Tuple[int, Any]]:
+    def pending_points(self) -> set[tuple[int, Any]]:
         pending_points = set()
         for i, l in enumerate(self.learners):
             pending_points.update({(i, p) for p in l.pending_points})
@@ -173,7 +164,7 @@ def strategy(self, strategy: STRATEGY_TYPE) -> None:
 
     def _ask_and_tell_based_on_loss_improvements(
         self, n: int
-    ) -> Tuple[List[Tuple[int, Any]], List[float]]:
+    ) -> tuple[list[tuple[int, Any]], list[float]]:
         selected = []  # tuples ((learner_index, point), loss_improvement)
         total_points = [l.npoints + len(l.pending_points) for l in self.learners]
         for _ in range(n):
@@ -198,7 +189,7 @@ def _ask_and_tell_based_on_loss_improvements(
 
     def _ask_and_tell_based_on_loss(
         self, n: int
-    ) -> Tuple[List[Tuple[int, Any]], List[float]]:
+    ) -> tuple[list[tuple[int, Any]], list[float]]:
         selected = []  # tuples ((learner_index, point), loss_improvement)
         total_points = [l.npoints + len(l.pending_points) for l in self.learners]
         for _ in range(n):
@@ -221,7 +212,7 @@ def _ask_and_tell_based_on_loss(
 
     def _ask_and_tell_based_on_npoints(
         self, n: numbers.Integral
-    ) -> Tuple[List[Tuple[numbers.Integral, Any]], List[float]]:
+    ) -> tuple[list[tuple[numbers.Integral, Any]], list[float]]:
         selected = []  # tuples ((learner_index, point), loss_improvement)
         total_points = [l.npoints + len(l.pending_points) for l in self.learners]
         for _ in range(n):
@@ -239,7 +230,7 @@ def _ask_and_tell_based_on_npoints(
 
     def _ask_and_tell_based_on_cycle(
         self, n: int
-    ) -> Tuple[List[Tuple[numbers.Integral, Any]], List[float]]:
+    ) -> tuple[list[tuple[numbers.Integral, Any]], list[float]]:
         points, loss_improvements = [], []
         for _ in range(n):
             index = next(self._cycle)
@@ -252,7 +243,7 @@ def _ask_and_tell_based_on_cycle(
 
     def ask(
         self, n: int, tell_pending: bool = True
-    ) -> Tuple[List[Tuple[numbers.Integral, Any]], List[float]]:
+    ) -> tuple[list[tuple[numbers.Integral, Any]], list[float]]:
         """Chose points for learners."""
         if n == 0:
             return [], []
@@ -263,20 +254,20 @@ def ask(
         else:
             return self._ask_and_tell(n)
 
-    def tell(self, x: Tuple[numbers.Integral, Any], y: Any) -> None:
+    def tell(self, x: tuple[numbers.Integral, Any], y: Any) -> None:
         index, x = x
         self._ask_cache.pop(index, None)
         self._loss.pop(index, None)
         self._pending_loss.pop(index, None)
         self.learners[index].tell(x, y)
 
-    def tell_pending(self, x: Tuple[numbers.Integral, Any]) -> None:
+    def tell_pending(self, x: tuple[numbers.Integral, Any]) -> None:
         index, x = x
         self._ask_cache.pop(index, None)
         self._loss.pop(index, None)
         self.learners[index].tell_pending(x)
 
-    def _losses(self, real: bool = True) -> List[float]:
+    def _losses(self, real: bool = True) -> list[float]:
         losses = []
         loss_dict = self._loss if real else self._pending_loss
 
@@ -294,8 +285,8 @@ def loss(self, real: bool = True) -> float:
 
     def plot(
         self,
-        cdims: Optional[CDIMS_TYPE] = None,
-        plotter: Optional[Callable[[BaseLearner], Any]] = None,
+        cdims: CDIMS_TYPE | None = None,
+        plotter: Callable[[BaseLearner], Any] | None = None,
         dynamic: bool = True,
     ):
         """Returns a DynamicMap with sliders.
@@ -380,9 +371,9 @@ def from_product(
         cls,
         f,
         learner_type: BaseLearner,
-        learner_kwargs: Dict[str, Any],
-        combos: Dict[str, Sequence[Any]],
-    ) -> "BalancingLearner":
+        learner_kwargs: dict[str, Any],
+        combos: dict[str, Sequence[Any]],
+    ) -> BalancingLearner:
         """Create a `BalancingLearner` with learners of all combinations of
         named variables’ values. The `cdims` will be set correctly, so calling
         `learner.plot` will be a `holoviews.core.HoloMap` with the correct labels.
@@ -431,7 +422,7 @@ def from_product(
 
     def save(
         self,
-        fname: Union[Callable[[BaseLearner], str], Sequence[str]],
+        fname: Callable[[BaseLearner], str] | Sequence[str],
         compress: bool = True,
     ) -> None:
         """Save the data of the child learners into pickle files
@@ -473,7 +464,7 @@ def save(
 
     def load(
         self,
-        fname: Union[Callable[[BaseLearner], str], Sequence[str]],
+        fname: Callable[[BaseLearner], str] | Sequence[str],
         compress: bool = True,
     ) -> None:
         """Load the data of the child learners from pickle files
@@ -499,20 +490,20 @@ def load(
             for l in self.learners:
                 l.load(fname(l), compress=compress)
 
-    def _get_data(self) -> List[Any]:
+    def _get_data(self) -> list[Any]:
         return [l._get_data() for l in self.learners]
 
-    def _set_data(self, data: List[Any]):
+    def _set_data(self, data: list[Any]):
         for l, _data in zip(self.learners, data):
             l._set_data(_data)
 
-    def __getstate__(self) -> Tuple[List[BaseLearner], CDIMS_TYPE, STRATEGY_TYPE]:
+    def __getstate__(self) -> tuple[list[BaseLearner], CDIMS_TYPE, STRATEGY_TYPE]:
         return (
             self.learners,
             self._cdims_default,
             self.strategy,
         )
 
-    def __setstate__(self, state: Tuple[List[BaseLearner], CDIMS_TYPE, STRATEGY_TYPE]):
+    def __setstate__(self, state: tuple[list[BaseLearner], CDIMS_TYPE, STRATEGY_TYPE]):
         learners, cdims, strategy = state
         self.__init__(learners, cdims=cdims, strategy=strategy)

adaptive/learner/base_learner.py

@@ -1,7 +1,9 @@
+from __future__ import annotations
+
 import abc
 from contextlib import suppress
 from copy import deepcopy
-from typing import Any, Callable, Dict
+from typing import Any, Callable
 
 from adaptive.utils import _RequireAttrsABCMeta, load, save
 
@@ -115,12 +117,10 @@ def tell_many(self, xs: Any, ys: Any) -> None:
     def tell_pending(self, x):
         """Tell the learner that 'x' has been requested such
         that it's not suggested again."""
-        pass
 
     @abc.abstractmethod
     def remove_unfinished(self):
         """Remove uncomputed data from the learner."""
-        pass
 
     @abc.abstractmethod
     def loss(self, real: bool = True):
@@ -147,7 +147,6 @@ def ask(self, n: int, tell_pending: bool = True):
             `pending_points`. Set this to False if you do not
             want to modify the state of the learner.
         """
-        pass
 
     @abc.abstractmethod
     def _get_data(self):
@@ -196,8 +195,8 @@ def load(self, fname: str, compress: bool = True) -> None:
             data = load(fname, compress)
             self._set_data(data)
 
-    def __getstate__(self) -> Dict[str, Any]:
+    def __getstate__(self) -> dict[str, Any]:
         return deepcopy(self.__dict__)
 
-    def __setstate__(self, state: Dict[str, Any]) -> None:
+    def __setstate__(self, state: dict[str, Any]) -> None:
         self.__dict__ = state