fix flake8 issues for the learners

Author: basnijholt

adaptive/learner/average_learner.py

@@ -1,5 +1,4 @@
 # -*- coding: utf-8 -*-
-import itertools
 from math import sqrt
 
 import numpy as np

adaptive/learner/balancing_learner.py

@@ -76,7 +76,7 @@ def __init__(self, learners, *, cdims=None, strategy='loss_improvements'):
     @property
     def strategy(self):
         return self._strategy
-    
+
     @strategy.setter
     def strategy(self, strategy):
         self._strategy = strategy
@@ -87,8 +87,9 @@ def strategy(self, strategy):
         elif strategy == 'npoints':
             self._ask_and_tell = self._ask_and_tell_based_on_npoints
         else:
-            raise ValueError('Only strategy="loss_improvements",'
-                ' strategy="loss", or strategy="npoints" is implemented.')
+            raise ValueError(
+                'Only strategy="loss_improvements", strategy="loss", or'
+                ' strategy="npoints" is implemented.')
 
     def _ask_and_tell_based_on_loss_improvements(self, n):
         points = []

adaptive/learner/base_learner.py

@@ -1,6 +1,5 @@
 # -*- coding: utf-8 -*-
 import abc
-import collections
 from copy import deepcopy
 
 

adaptive/learner/data_saver.py

@@ -2,6 +2,7 @@
 from collections import OrderedDict
 import functools
 
+
 class DataSaver:
     """Save extra data associated with the values that need to be learned.
 

adaptive/learner/integrator_learner.py

@@ -206,7 +206,7 @@ def calc_ndiv(self):
         div = (self.parent.c00 and self.c00 / self.parent.c00 > 2)
         self.ndiv += div
 
-        if self.ndiv > ndiv_max and 2*self.ndiv > self.rdepth:
+        if self.ndiv > ndiv_max and 2 * self.ndiv > self.rdepth:
             raise DivergentIntegralError
 
         if div:
@@ -215,7 +215,7 @@ def calc_ndiv(self):
 
     def update_ndiv_recursively(self):
         self.ndiv += 1
-        if self.ndiv > ndiv_max and 2*self.ndiv > self.rdepth:
+        if self.ndiv > ndiv_max and 2 * self.ndiv > self.rdepth:
             raise DivergentIntegralError
 
         for child in self.children:
@@ -418,7 +418,6 @@ def add_ival(self, ival):
                 self._stack.append(x)
         self.ivals.add(ival)
 
-
     def ask(self, n, tell_pending=True):
         """Choose points for learners."""
         if not tell_pending:

adaptive/learner/learner1D.py

@@ -49,7 +49,7 @@ def default_loss(interval, scale, function_values):
     else:
         dy = (y_right - y_left) / y_scale
         try:
-            _ = len(dy)
+            len(dy)
             loss = np.hypot(dx, dy).max()
         except TypeError:
             loss = math.hypot(dx, dy)
@@ -409,7 +409,7 @@ def finite_loss(loss, xs):
             # If the loss is infinite we return the
             # distance between the two points.
             return (loss if not math.isinf(loss)
-                else (xs[1] - xs[0]) / self._scale[0])
+                    else (xs[1] - xs[0]) / self._scale[0])
 
         quals = [(-finite_loss(loss, x), x, 1)
                  for x, loss in self.losses_combined.items()]

adaptive/learner/learner2D.py

@@ -1,6 +1,5 @@
 # -*- coding: utf-8 -*-
 from collections import OrderedDict
-from copy import copy
 import itertools
 from math import sqrt
 
@@ -86,13 +85,13 @@ def resolution_loss(ip, min_distance=0, max_distance=1):
     """
     A = areas(ip)
     dev = np.sum(deviations(ip), axis=0)
-    
+
     # similar to the default_loss
     loss = np.sqrt(A) * dev + A
-    
+
     # Setting areas with a small area to zero such that they won't be chosen again
-    loss[A < min_distance**2] = 0 
-    
+    loss[A < min_distance**2] = 0
+
     # Setting triangles that have a size larger than max_distance to infinite loss
     # such that these triangles will be picked
     loss[A > max_distance**2] = np.inf
@@ -109,7 +108,7 @@ def minimize_triangle_surface_loss(ip):
 
     Examples
     --------
-    >>> from adaptive.learner.learner2D import minimize_triangle_surface_loss 
+    >>> from adaptive.learner.learner2D import minimize_triangle_surface_loss
     >>> def f(xy):
     ...     x, y = xy
     ...     return x**2 + y**2

adaptive/learner/learnerND.py

@@ -59,8 +59,8 @@ def default_loss(simplex, ys):
 def choose_point_in_simplex(simplex, transform=None):
     """Choose a new point in inside a simplex.
 
-    Pick the center of the simplex if the shape is nice (that is, the 
-    circumcenter lies within the simplex). Otherwise take the middle of the 
+    Pick the center of the simplex if the shape is nice (that is, the
+    circumcenter lies within the simplex). Otherwise take the middle of the
     longest edge.
 
     Parameters
@@ -94,7 +94,7 @@ def choose_point_in_simplex(simplex, transform=None):
 
     if transform is not None:
         point = np.linalg.solve(transform, point)  # undo the transform
-        
+
     return point
 
 
@@ -180,7 +180,7 @@ def __init__(self, func, bounds, loss_per_simplex=None):
         # create a private random number generator with fixed seed
         self._random = random.Random(1)
 
-        # all real triangles that have not been subdivided and the pending 
+        # all real triangles that have not been subdivided and the pending
         # triangles heap of tuples (-loss, real simplex, sub_simplex or None)
 
         # _simplex_queue is a heap of tuples (-loss, real_simplex, sub_simplex)
@@ -268,7 +268,7 @@ def _simplex_exists(self, simplex):
 
     def inside_bounds(self, point):
         return all(mn <= p <= mx for p, (mn, mx) in zip(point, self.bounds))
-            
+
     def tell_pending(self, point, *, simplex=None):
         point = tuple(point)
         if not self.inside_bounds(point):
@@ -354,21 +354,21 @@ def _pop_highest_existing_simplex(self):
         # find the simplex with the highest loss, we do need to check that the
         # simplex hasn't been deleted yet
         while len(self._simplex_queue):
-            loss, simplex, subsimplex = heapq.heappop(self._simplex_queue) 
+            loss, simplex, subsimplex = heapq.heappop(self._simplex_queue)
             if (subsimplex is None
-                    and simplex in self.tri.simplices
-                    and simplex not in self._subtriangulations):
+                and simplex in self.tri.simplices
+                and simplex not in self._subtriangulations):
                 return abs(loss), simplex, subsimplex
             if (simplex in self._subtriangulations
-                    and simplex in self.tri.simplices
-                    and subsimplex in self._subtriangulations[simplex].simplices):
+                and simplex in self.tri.simplices
+                and subsimplex in self._subtriangulations[simplex].simplices):
                 return abs(loss), simplex, subsimplex
 
         # Could not find a simplex, this code should never be reached
         assert self.tri is not None
         raise AssertionError(
-            "Could not find a simplex to subdivide. Yet there should always be" 
-            "a simplex available if LearnerND.tri() is not None."
+            "Could not find a simplex to subdivide. Yet there should always"
+            "  be a simplex available if LearnerND.tri() is not None."
         )
 
     def _ask_best_point(self):
@@ -435,8 +435,8 @@ def update_losses(self, to_delete: set, to_add: set):
                 heapq.heappush(self._simplex_queue, (-loss, simplex, None))
                 continue
 
-            self._update_subsimplex_losses(simplex,
-                                self._subtriangulations[simplex].simplices)
+            self._update_subsimplex_losses(
+                simplex, self._subtriangulations[simplex].simplices)
 
     def losses(self):
         """Get the losses of each simplex in the current triangulation, as dict

adaptive/learner/skopt_learner.py

@@ -4,7 +4,7 @@
 
 from .base_learner import BaseLearner
 from ..notebook_integration import ensure_holoviews
-from ..utils import restore, cache_latest
+from ..utils import cache_latest
 
 
 class SKOptLearner(Optimizer, BaseLearner):

adaptive/learner/triangulation.py

@@ -214,7 +214,7 @@ def simplex_volume_in_embedding(vertices) -> float:
         # Heron's formula
         a, b, c = scipy.spatial.distance.pdist(vertices, metric='euclidean')
         s = 0.5 * (a + b + c)
-        return math.sqrt(s*(s-a)*(s-b)*(s-c))
+        return math.sqrt(s * (s - a) * (s - b) * (s - c))
 
     # β_ij = |v_i - v_k|²
     sq_dists = scipy.spatial.distance.pdist(vertices, metric='sqeuclidean')
@@ -494,13 +494,13 @@ def bowyer_watson(self, pt_index, containing_simplex=None, transform=None):
 
                 # Get all simplices that share at least a point with the simplex
                 neighbours = set.union(*[self.vertex_to_simplices[p]
-                                            for p in todo_points])
+                                         for p in todo_points])
                 # Filter out the already evaluated simplices
                 neighbours = neighbours - done_simplices
 
                 # Keep only the simplices sharing a whole face with the current simplex
                 neighbours = set(
-                    simpl for simpl in neighbours 
+                    simpl for simpl in neighbours
                     if len(set(simpl) & set(simplex)) == self.dim  # they share a face
                 )
                 queue.update(neighbours)
@@ -568,7 +568,7 @@ def add_point(self, point, simplex=None, transform=None):
         else:
             reduced_simplex = self.get_reduced_simplex(point, simplex)
             if not reduced_simplex:
-                self.vertex_to_simplices.pop() # revert adding vertex
+                self.vertex_to_simplices.pop()  # revert adding vertex
                 raise ValueError('Point lies outside of the specified simplex.')
             else:
                 simplex = reduced_simplex