Merge remote-tracking branch 'origin/master' into mypy

Author: basnijholt

adaptive/learner/average_learner.py

@@ -74,6 +74,10 @@ def __init__(
         self.sum_f: Real = 0.0
         self.sum_f_sq: Real = 0.0
 
+    def new(self) -> AverageLearner:
+        """Create a copy of `~adaptive.AverageLearner` without the data."""
+        return AverageLearner(self.function, self.atol, self.rtol, self.min_npoints)
+
     @property
     def n_requested(self) -> int:
         return self.npoints + len(self.pending_points)

adaptive/learner/average_learner1D.py

@@ -125,6 +125,20 @@ def __init__(
         # {xii: error[xii]/min(_distances[xi], _distances[xii], ...}
         self.rescaled_error: dict[Real, float] = decreasing_dict()
 
+    def new(self) -> AverageLearner1D:
+        """Create a copy of `~adaptive.AverageLearner1D` without the data."""
+        return AverageLearner1D(
+            self.function,
+            self.bounds,
+            self.loss_per_interval,
+            self.delta,
+            self.alpha,
+            self.neighbor_sampling,
+            self.min_samples,
+            self.max_samples,
+            self.min_error,
+        )
+
     @property
     def nsamples(self) -> int:
         """Returns the total number of samples"""

adaptive/learner/balancing_learner.py

@@ -118,6 +118,14 @@ def __init__(
 
         self.strategy: STRATEGY_TYPE = strategy
 
+    def new(self) -> BalancingLearner:
+        """Create a new `BalancingLearner` with the same parameters."""
+        return BalancingLearner(
+            [learner.new() for learner in self.learners],
+            cdims=self._cdims_default,
+            strategy=self.strategy,
+        )
+
     @property
     def data(self) -> dict[tuple[int, Any], Any]:
         data = {}

adaptive/learner/base_learner.py

@@ -157,6 +157,11 @@ def _get_data(self):
     def _set_data(self, data: Any):
         pass
 
+    @abc.abstractmethod
+    def new(self):
+        """Return a new learner with the same function and parameters."""
+        pass
+
     def copy_from(self, other):
         """Copy over the data from another learner.
 

adaptive/learner/data_saver.py

@@ -47,6 +47,10 @@ def __init__(self, learner: BaseLearner, arg_picker: itemgetter) -> None:
         self.function = learner.function
         self.arg_picker = arg_picker
 
+    def new(self) -> DataSaver:
+        """Return a new `DataSaver` with the same `arg_picker` and `learner`."""
+        return DataSaver(self.learner.new(), self.arg_picker)
+
     def __getattr__(self, attr: str) -> Any:
         return getattr(self.learner, attr)
 

adaptive/learner/integrator_learner.py

@@ -390,6 +390,10 @@ def __init__(self, function: Callable, bounds: tuple[int, int], tol: float) -> N
         self.add_ival(ival)
         self.first_ival = ival
 
+    def new(self) -> IntegratorLearner:
+        """Create a copy of `~adaptive.Learner2D` without the data."""
+        return IntegratorLearner(self.function, self.bounds, self.tol)
+
     @property
     def approximating_intervals(self) -> set[_Interval]:
         return self.first_ival.done_leaves

adaptive/learner/learner1D.py

@@ -22,6 +22,12 @@
     partial_function_from_dataframe,
 )
 
+try:
+    from typing import TypeAlias
+except ImportError:
+    # Remove this when we drop support for Python 3.9
+    from typing_extensions import TypeAlias
+
 try:
     import pandas
 
@@ -33,21 +39,21 @@
 # -- types --
 
 # Commonly used types
-Interval = Union[Tuple[float, float], Tuple[float, float, int]]
-NeighborsType = Dict[float, List[Union[float, None]]]
+Interval: TypeAlias = Union[Tuple[float, float], Tuple[float, float, int]]
+NeighborsType: TypeAlias = Dict[float, List[Union[float, None]]]
 
 # Types for loss_per_interval functions
-NoneFloat = Union[Float, None]
-NoneArray = Union[np.ndarray, None]
-XsType0 = Tuple[Float, Float]
-YsType0 = Union[Tuple[Float, Float], Tuple[np.ndarray, np.ndarray]]
-XsType1 = Tuple[NoneFloat, NoneFloat, NoneFloat, NoneFloat]
-YsType1 = Union[
+NoneFloat: TypeAlias = Union[Float, None]
+NoneArray: TypeAlias = Union[np.ndarray, None]
+XsType0: TypeAlias = Tuple[Float, Float]
+YsType0: TypeAlias = Union[Tuple[Float, Float], Tuple[np.ndarray, np.ndarray]]
+XsType1: TypeAlias = Tuple[NoneFloat, NoneFloat, NoneFloat, NoneFloat]
+YsType1: TypeAlias = Union[
     Tuple[NoneFloat, NoneFloat, NoneFloat, NoneFloat],
     Tuple[NoneArray, NoneArray, NoneArray, NoneArray],
 ]
-XsTypeN = Tuple[NoneFloat, ...]
-YsTypeN = Union[Tuple[NoneFloat, ...], Tuple[NoneArray, ...]]
+XsTypeN: TypeAlias = Tuple[NoneFloat, ...]
+YsTypeN: TypeAlias = Union[Tuple[NoneFloat, ...], Tuple[NoneArray, ...]]
 
 
 __all__ = [
@@ -303,11 +309,15 @@ def __init__(
         # The precision in 'x' below which we set losses to 0.
         self._dx_eps = 2 * max(np.abs(bounds)) * np.finfo(float).eps
 
-        self.bounds = list(bounds)
+        self.bounds = tuple(bounds)
         self.__missing_bounds = set(self.bounds)  # cache of missing bounds
 
         self._vdim: int | None = None
 
+    def new(self) -> Learner1D:
+        """Create a copy of `~adaptive.Learner1D` without the data."""
+        return Learner1D(self.function, self.bounds, self.loss_per_interval)
+
     @property
     def vdim(self) -> int:
         """Length of the output of ``learner.function``.

adaptive/learner/learner2D.py

@@ -393,6 +393,9 @@ def __init__(
 
         self.stack_size = 10
 
+    def new(self) -> Learner2D:
+        return Learner2D(self.function, self.bounds, self.loss_per_triangle)
+
     @property
     def xy_scale(self) -> np.ndarray:
         xy_scale = self._xy_scale

adaptive/learner/learnerND.py

@@ -395,6 +395,10 @@ def __init__(
         # _pop_highest_existing_simplex
         self._simplex_queue = SortedKeyList(key=_simplex_evaluation_priority)
 
+    def new(self) -> LearnerND:
+        """Create a new learner with the same function and bounds."""
+        return LearnerND(self.function, self.bounds, self.loss_per_simplex)
+
     @property
     def npoints(self) -> int:
         """Number of evaluated points."""

adaptive/learner/sequence_learner.py

@@ -81,6 +81,10 @@ def __init__(self, function: Callable, sequence: Iterable) -> None:
         self.data = SortedDict()
         self.pending_points = set()
 
+    def new(self) -> SequenceLearner:
+        """Return a new `~adaptive.SequenceLearner` without the data."""
+        return SequenceLearner(self._original_function, self.sequence)
+
     def ask(self, n: int, tell_pending: bool = True) -> tuple[Any, list[float]]:
         indices = []
         points = []
@@ -179,7 +183,7 @@ def to_dataframe(
         df.attrs["inputs"] = [index_name]
         df.attrs["output"] = y_name
         if with_default_function_args:
-            assign_defaults(self.function, df, function_prefix)
+            assign_defaults(self._original_function, df, function_prefix)
         return df
 
     def load_dataframe(
@@ -216,7 +220,7 @@ def load_dataframe(
         self.tell_many(df[[index_name, x_name]].values, df[y_name].values)
         if with_default_function_args:
             self.function = partial_function_from_dataframe(
-                self.function, df, function_prefix
+                self._original_function, df, function_prefix
             )
 
     def _get_data(self) -> SortedDict:

adaptive/learner/skopt_learner.py

@@ -30,8 +30,13 @@ def __init__(self, function: Callable, **kwargs) -> None:
         self.function = function  # type: ignore
         self.pending_points = set()
         self.data = collections.OrderedDict()
+        self._kwargs = kwargs
         super().__init__(**kwargs)
 
+    def new(self) -> SKOptLearner:
+        """Return a new `~adaptive.SKOptLearner` without the data."""
+        return SKOptLearner(self.function, **self._kwargs)
+
     def tell(self, x: float | list[float], y: float, fit: bool = True) -> None:
         if isinstance(x, collections.abc.Iterable):
             self.pending_points.discard(tuple(x))

adaptive/tests/test_learners.py

@@ -294,7 +294,7 @@ def test_adding_existing_data_is_idempotent(learner_type, f, learner_kwargs):
     """
     f = generate_random_parametrization(f)
     learner = learner_type(f, **learner_kwargs)
-    control = learner_type(f, **learner_kwargs)
+    control = learner.new()
     if learner_type in (Learner1D, AverageLearner1D):
         learner._recompute_losses_factor = 1
         control._recompute_losses_factor = 1
@@ -345,7 +345,7 @@ def test_adding_non_chosen_data(learner_type, f, learner_kwargs):
     # XXX: learner, control and bounds are not defined
     f = generate_random_parametrization(f)
     learner = learner_type(f, **learner_kwargs)
-    control = learner_type(f, **learner_kwargs)
+    control = learner.new()
 
     if learner_type is Learner2D:
         # If the stack_size is bigger then the number of points added,
@@ -395,7 +395,7 @@ def test_point_adding_order_is_irrelevant(learner_type, f, learner_kwargs):
     """
     f = generate_random_parametrization(f)
     learner = learner_type(f, **learner_kwargs)
-    control = learner_type(f, **learner_kwargs)
+    control = learner.new()
 
     if learner_type in (Learner1D, AverageLearner1D):
         learner._recompute_losses_factor = 1
@@ -581,7 +581,7 @@ def test_balancing_learner(learner_type, f, learner_kwargs):
 def test_saving(learner_type, f, learner_kwargs):
     f = generate_random_parametrization(f)
     learner = learner_type(f, **learner_kwargs)
-    control = learner_type(f, **learner_kwargs)
+    control = learner.new()
     if learner_type in (Learner1D, AverageLearner1D):
         learner._recompute_losses_factor = 1
         control._recompute_losses_factor = 1
@@ -614,7 +614,7 @@ def test_saving(learner_type, f, learner_kwargs):
 def test_saving_of_balancing_learner(learner_type, f, learner_kwargs):
     f = generate_random_parametrization(f)
     learner = BalancingLearner([learner_type(f, **learner_kwargs)])
-    control = BalancingLearner([learner_type(f, **learner_kwargs)])
+    control = learner.new()
 
     if learner_type in (Learner1D, AverageLearner1D):
         for l, c in zip(learner.learners, control.learners):
@@ -654,7 +654,7 @@ def test_saving_with_datasaver(learner_type, f, learner_kwargs):
     g = lambda x: {"y": f(x), "t": random.random()}  # noqa: E731
     arg_picker = operator.itemgetter("y")
     learner = DataSaver(learner_type(g, **learner_kwargs), arg_picker)
-    control = DataSaver(learner_type(g, **learner_kwargs), arg_picker)
+    control = learner.new()
 
     if learner_type in (Learner1D, AverageLearner1D):
         learner.learner._recompute_losses_factor = 1
@@ -742,7 +742,7 @@ def test_to_dataframe(learner_type, f, learner_kwargs):
         assert len(df) == learner.npoints
 
     # Add points from the DataFrame to a new empty learner
-    learner2 = learner_type(learner.function, **learner_kwargs)
+    learner2 = learner.new()
     learner2.load_dataframe(df, **kw)
     assert learner2.npoints == learner.npoints
 
@@ -787,8 +787,7 @@ def test_to_dataframe(learner_type, f, learner_kwargs):
         assert len(df) == data_saver.npoints
 
     # Test loading from a DataFrame into a new DataSaver
-    learner2 = learner_type(learner.function, **learner_kwargs)
-    data_saver2 = DataSaver(learner2, operator.itemgetter("result"))
+    data_saver2 = data_saver.new()
     data_saver2.load_dataframe(df, **kw)
     assert data_saver2.extra_data.keys() == data_saver.extra_data.keys()
     assert all(

adaptive/types.py

@@ -2,6 +2,12 @@
 
 import numpy as np
 
-Float = Union[float, np.float_]
-Int = Union[int, np.int_]
-Real = Union[Float, Int]
+try:
+    from typing import TypeAlias
+except ImportError:
+    # Remove this when we drop support for Python 3.9
+    from typing_extensions import TypeAlias
+
+Float: TypeAlias = Union[float, np.float_]
+Int: TypeAlias = Union[int, np.int_]
+Real: TypeAlias = Union[Float, Int]

adaptive/utils.py

@@ -6,6 +6,7 @@
 import inspect
 import os
 import pickle
+import warnings
 from contextlib import _GeneratorContextManager, contextmanager
 from itertools import product
 from typing import Any, Callable, Mapping, Sequence
@@ -138,4 +139,19 @@ def partial_function_from_dataframe(function, df, function_prefix: str = "functi
             kwargs[k] = v
     if not kwargs:
         return function
+
+    sig = inspect.signature(function)
+    for k, v in kwargs.items():
+        if k not in sig.parameters:
+            raise ValueError(
+                f"The DataFrame contains a default parameter"
+                f" ({k}={v}) but the function does not have that parameter."
+            )
+        default = sig.parameters[k].default
+        if default != inspect._empty and kwargs[k] != default:
+            warnings.warn(
+                f"The DataFrame contains a default parameter"
+                f" ({k}={v}) but the function already has a default ({k}={default})."
+                " The DataFrame's value will be used."
+            )
     return functools.partial(function, **kwargs)

setup.py

@@ -31,7 +31,7 @@ def get_version_and_cmdclass(package_name):
     "cloudpickle",
     "loky >= 2.9",
 ]
-if sys.version_info < (3, 8):
+if sys.version_info < (3, 10):
     install_requires.append("typing_extensions")
 
 extras_require = {
@@ -80,6 +80,7 @@ def get_version_and_cmdclass(package_name):
         "Programming Language :: Python :: 3.7",
         "Programming Language :: Python :: 3.8",
         "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
     ],
     packages=find_packages("."),
     install_requires=install_requires,