Remove _RequireAttrsABCMeta metaclass and replace with simple check

adaptive/learner/average_learner.py

@@ -75,6 +75,7 @@ def __init__(
         self.min_npoints = max(min_npoints, 2)
         self.sum_f: Real = 0.0
         self.sum_f_sq: Real = 0.0
+        self._check_required_attributes()
 
     def new(self) -> AverageLearner:
         """Create a copy of `~adaptive.AverageLearner` without the data."""

adaptive/learner/average_learner1D.py

@@ -125,6 +125,7 @@ def __init__(
         self._distances: dict[Real, float] = decreasing_dict()
         # {xii: error[xii]/min(_distances[xi], _distances[xii], ...}
         self.rescaled_error: dict[Real, float] = decreasing_dict()
+        self._check_required_attributes()
 
     def new(self) -> AverageLearner1D:
         """Create a copy of `~adaptive.AverageLearner1D` without the data."""

adaptive/learner/balancing_learner.py

@@ -118,6 +118,7 @@ def __init__(
             )
 
         self.strategy: STRATEGY_TYPE = strategy
+        self._check_required_attributes()
 
     def new(self) -> BalancingLearner:
         """Create a new `BalancingLearner` with the same parameters."""

adaptive/learner/base_learner.py

@@ -3,7 +3,7 @@
 
 import cloudpickle
 
-from adaptive.utils import _RequireAttrsABCMeta, load, save
+from adaptive.utils import load, save
 
 
 def uses_nth_neighbors(n: int):
@@ -60,7 +60,7 @@ def _wrapped(loss_per_interval):
     return _wrapped
 
 
-class BaseLearner(metaclass=_RequireAttrsABCMeta):
+class BaseLearner(abc.ABC):
     """Base class for algorithms for learning a function 'f: X → Y'.
 
     Attributes
@@ -198,3 +198,16 @@ def __getstate__(self):
 
     def __setstate__(self, state):
         self.__dict__ = cloudpickle.loads(state)
+
+    def _check_required_attributes(self):
+        for name, type_ in self.__annotations__.items():
+            try:
+                x = getattr(self, name)
+            except AttributeError:
+                raise AttributeError(
+                    f"Required attribute {name} not set in __init__."
+                ) from None
+            else:
+                if not isinstance(x, type_):
+                    msg = f"The attribute '{name}' should be of type {type_}, not {type(x)}."
+                    raise TypeError(msg)

adaptive/learner/data_saver.py

@@ -45,6 +45,7 @@ def __init__(self, learner: BaseLearner, arg_picker: Callable) -> None:
         self.extra_data = OrderedDict()
         self.function = learner.function
         self.arg_picker = arg_picker
+        self._check_required_attributes()
 
     def new(self) -> DataSaver:
         """Return a new `DataSaver` with the same `arg_picker` and `learner`."""

adaptive/learner/integrator_learner.py

@@ -389,6 +389,7 @@ def __init__(self, function: Callable, bounds: tuple[int, int], tol: float) -> N
         ival = _Interval.make_first(*self.bounds)
         self.add_ival(ival)
         self.first_ival = ival
+        self._check_required_attributes()
 
     def new(self) -> IntegratorLearner:
         """Create a copy of `~adaptive.Learner2D` without the data."""

adaptive/learner/learner1D.py

@@ -315,6 +315,7 @@ def __init__(
         self.__missing_bounds = set(self.bounds)  # cache of missing bounds
 
         self._vdim: int | None = None
+        self._check_required_attributes()
 
     def new(self) -> Learner1D:
         """Create a copy of `~adaptive.Learner1D` without the data."""

adaptive/learner/learner2D.py

@@ -393,6 +393,7 @@ def __init__(
         self._ip = self._ip_combined = None
 
         self.stack_size = 10
+        self._check_required_attributes()
 
     def new(self) -> Learner2D:
         return Learner2D(self.function, self.bounds, self.loss_per_triangle)

adaptive/learner/learnerND.py

@@ -376,6 +376,8 @@ def __init__(self, func, bounds, loss_per_simplex=None):
         # _pop_highest_existing_simplex
         self._simplex_queue = SortedKeyList(key=_simplex_evaluation_priority)
 
+        self._check_required_attributes()
+
     def new(self) -> LearnerND:
         """Create a new learner with the same function and bounds."""
         return LearnerND(self.function, self.bounds, self.loss_per_simplex)

adaptive/learner/sequence_learner.py

@@ -92,6 +92,7 @@ def __init__(self, function, sequence):
         self.sequence = copy(sequence)
         self.data = SortedDict()
         self.pending_points = set()
+        self._check_required_attributes()
 
     def new(self) -> SequenceLearner:
         """Return a new `~adaptive.SequenceLearner` without the data."""

adaptive/utils.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import abc
 import concurrent.futures as concurrent
 import functools
 import gzip
@@ -90,23 +89,6 @@ def decorator(method):
     return decorator
 
 
-class _RequireAttrsABCMeta(abc.ABCMeta):
-    def __call__(self, *args, **kwargs):
-        obj = super().__call__(*args, **kwargs)
-        for name, type_ in obj.__annotations__.items():
-            try:
-                x = getattr(obj, name)
-            except AttributeError:
-                raise AttributeError(
-                    f"Required attribute {name} not set in __init__."
-                ) from None
-            else:
-                if not isinstance(x, type_):
-                    msg = f"The attribute '{name}' should be of type {type_}, not {type(x)}."
-                    raise TypeError(msg)
-        return obj
-
-
 def _default_parameters(function, function_prefix: str = "function."):
     sig = inspect.signature(function)
     defaults = {