@@ -46,7 +46,9 @@ with suppress(ModuleNotFoundError):

     asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())

-_default_executor = concurrent.ProcessPoolExecutor

+_default_executor = (

+    loky.get_reusable_executor if with_loky else concurrent.ProcessPoolExecutor

+)

 class BaseRunner(metaclass=abc.ABCMeta):

@@ -46,9 +46,7 @@ with suppress(ModuleNotFoundError):

     asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())

-_default_executor = (

-    loky.get_reusable_executor if with_loky else concurrent.ProcessPoolExecutor

-)

+_default_executor = concurrent.ProcessPoolExecutor

 class BaseRunner(metaclass=abc.ABCMeta):

@@ -62,7 +60,8 @@ class BaseRunner(metaclass=abc.ABCMeta):

         the learner as its sole argument, and return True when we should

         stop requesting more points.

     executor : `concurrent.futures.Executor`, `distributed.Client`,\

-               `mpi4py.futures.MPIPoolExecutor`, or `ipyparallel.Client`, optional

+               `mpi4py.futures.MPIPoolExecutor`, `ipyparallel.Client` or\

+               `loky.get_reusable_executor`, optional

         The executor in which to evaluate the function to be learned.

         If not provided, a new `~concurrent.futures.ProcessPoolExecutor`.

     ntasks : int, optional

@@ -5,7 +5,6 @@ import functools

 import inspect

 import itertools

 import pickle

-import sys

 import time

 import traceback

 import warnings

@@ -14,13 +13,9 @@ from contextlib import suppress

 from adaptive.notebook_integration import in_ipynb, live_info, live_plot

 try:

-    if sys.version_info < (3, 8):

-        # XXX: remove when ipyparallel 6.2.5 is released

-        import ipyparallel

+    import ipyparallel

-        with_ipyparallel = True

-    else:

-        with_ipyparallel = False

+    with_ipyparallel = True

 except ModuleNotFoundError:

     with_ipyparallel = False

@@ -379,9 +379,7 @@ class BlockingRunner(BaseRunner):

         raise_if_retries_exceeded=True,

     ):

         if inspect.iscoroutinefunction(learner.function):

-            raise ValueError(

-                "Coroutine functions can only be used " "with 'AsyncRunner'."

-            )

+            raise ValueError("Coroutine functions can only be used with 'AsyncRunner'.")

         super().__init__(

             learner,

             goal,

@@ -549,7 +547,7 @@ class AsyncRunner(BaseRunner):

         if inspect.iscoroutinefunction(learner.function):

             if executor:  # user-provided argument

                 raise RuntimeError(

-                    "Cannot use an executor when learning an " "async function."

+                    "Cannot use an executor when learning an async function."

                 )

             self.executor.shutdown()  # Make sure we don't shoot ourselves later

@@ -171,6 +171,7 @@ class BaseRunner(metaclass=abc.ABCMeta):

     def _ask(self, n):

         pending_ids = self._pending_tasks.values()

+        # using generator here because we only need until `n`

         pids_gen = (pid for pid in self._to_retry.keys() if pid not in pending_ids)

         pids = list(itertools.islice(pids_gen, n))

@@ -128,7 +128,7 @@ class BaseRunner(metaclass=abc.ABCMeta):

         self._max_tasks = ntasks

-        self._pending_pids = {}

+        self._pending_tasks = {}  # mapping from concurrent.futures.Future → point id

         # if we instantiate our own executor, then we are also responsible

         # for calling 'shutdown'

@@ -170,7 +170,7 @@ class BaseRunner(metaclass=abc.ABCMeta):

         return self.log is not None

     def _ask(self, n):

-        pending_ids = self._pending_pids.values()

+        pending_ids = self._pending_tasks.values()

         pids_gen = (pid for pid in self._to_retry.keys() if pid not in pending_ids)

         pids = list(itertools.islice(pids_gen, n))

@@ -210,7 +210,7 @@ class BaseRunner(metaclass=abc.ABCMeta):

     def _process_futures(self, done_futs):

         for fut in done_futs:

-            pid = self._pending_pids.pop(fut)

+            pid = self._pending_tasks.pop(fut)

             try:

                 y = fut.result()

                 t = time.time() - fut.start_time  # total execution time

@@ -234,7 +234,7 @@ class BaseRunner(metaclass=abc.ABCMeta):

         # Launch tasks to replace the ones that completed

         # on the last iteration, making sure to fill workers

         # that have started since the last iteration.

-        n_new_tasks = max(0, self._get_max_tasks() - len(self._pending_pids))

+        n_new_tasks = max(0, self._get_max_tasks() - len(self._pending_tasks))

         if self.do_log:

             self.log.append(("ask", n_new_tasks))

@@ -246,17 +246,17 @@ class BaseRunner(metaclass=abc.ABCMeta):

             point = self._id_to_point[pid]

             fut = self._submit(point)

             fut.start_time = start_time

-            self._pending_pids[fut] = pid

+            self._pending_tasks[fut] = pid

         # Collect and results and add them to the learner

-        futures = list(self._pending_pids.keys())

+        futures = list(self._pending_tasks.keys())

         return futures

     def _remove_unfinished(self):

         # remove points with 'None' values from the learner

         self.learner.remove_unfinished()

         # cancel any outstanding tasks

-        remaining = list(self._pending_pids.keys())

+        remaining = list(self._pending_tasks.keys())

         for fut in remaining:

             fut.cancel()

         return remaining

@@ -302,7 +302,7 @@ class BaseRunner(metaclass=abc.ABCMeta):

     @property

     def pending_points(self):

         return [

-            (fut, self._id_to_point[pid]) for fut, pid in self._pending_pids.items()

+            (fut, self._id_to_point[pid]) for fut, pid in self._pending_tasks.items()

         ]

@@ -128,7 +128,7 @@ class BaseRunner(metaclass=abc.ABCMeta):

         self._max_tasks = ntasks

-        self._pending_points = {}

+        self._pending_pids = {}

         # if we instantiate our own executor, then we are also responsible

         # for calling 'shutdown'

@@ -170,7 +170,7 @@ class BaseRunner(metaclass=abc.ABCMeta):

         return self.log is not None

     def _ask(self, n):

-        pending_ids = self._pending_points.values()

+        pending_ids = self._pending_pids.values()

         pids_gen = (pid for pid in self._to_retry.keys() if pid not in pending_ids)

         pids = list(itertools.islice(pids_gen, n))

@@ -210,7 +210,7 @@ class BaseRunner(metaclass=abc.ABCMeta):

     def _process_futures(self, done_futs):

         for fut in done_futs:

-            pid = self._pending_points.pop(fut)

+            pid = self._pending_pids.pop(fut)

             try:

                 y = fut.result()

                 t = time.time() - fut.start_time  # total execution time

@@ -234,7 +234,7 @@ class BaseRunner(metaclass=abc.ABCMeta):

         # Launch tasks to replace the ones that completed

         # on the last iteration, making sure to fill workers

         # that have started since the last iteration.

-        n_new_tasks = max(0, self._get_max_tasks() - len(self._pending_points))

+        n_new_tasks = max(0, self._get_max_tasks() - len(self._pending_pids))

         if self.do_log:

             self.log.append(("ask", n_new_tasks))

@@ -246,17 +246,17 @@ class BaseRunner(metaclass=abc.ABCMeta):

             point = self._id_to_point[pid]

             fut = self._submit(point)

             fut.start_time = start_time

-            self._pending_points[fut] = pid

+            self._pending_pids[fut] = pid

         # Collect and results and add them to the learner

-        futures = list(self._pending_points.keys())

+        futures = list(self._pending_pids.keys())

         return futures

     def _remove_unfinished(self):

         # remove points with 'None' values from the learner

         self.learner.remove_unfinished()

         # cancel any outstanding tasks

-        remaining = list(self._pending_points.keys())

+        remaining = list(self._pending_pids.keys())

         for fut in remaining:

             fut.cancel()

         return remaining

@@ -302,7 +302,7 @@ class BaseRunner(metaclass=abc.ABCMeta):

     @property

     def pending_points(self):

         return [

-            (fut, self._id_to_point[pid]) for fut, pid in self._pending_points.items()

+            (fut, self._id_to_point[pid]) for fut, pid in self._pending_pids.items()

         ]

@@ -170,11 +170,10 @@ class BaseRunner(metaclass=abc.ABCMeta):

         return self.log is not None

     def _ask(self, n):

-        pids = [

-            pid

-            for pid in self._to_retry.keys()

-            if pid not in self._pending_points.values()

-        ][:n]

+        pending_ids = self._pending_points.values()

+        pids_gen = (pid for pid in self._to_retry.keys() if pid not in pending_ids)

+        pids = list(itertools.islice(pids_gen, n))

+

         loss_improvements = len(pids) * [float("inf")]

         if len(pids) < n:

@@ -56,10 +56,6 @@ _default_executor = (

 )

-def _key_by_value(dct, value):

-    return next(k for k, v in dct.items() if v == value)

-

-

 class BaseRunner(metaclass=abc.ABCMeta):

     r"""Base class for runners that use `concurrent.futures.Executors`.

@@ -103,8 +103,8 @@ class BaseRunner(metaclass=abc.ABCMeta):

         in ``runner.tracebacks``.

     tracebacks : list of tuples

         List of of ``(point, tb)`` for points that failed.

-    pending_points : dict

-        A mapping of `~concurrent.futures.Future`\s to points.

+    pending_points : list of tuples

+        A list of tuples with ``(concurrent.futures.Future, point)``.

     Methods

     -------

@@ -132,7 +132,7 @@ class BaseRunner(metaclass=abc.ABCMeta):

         self._max_tasks = ntasks

-        self.pending_points = {}

+        self._pending_points = {}

         # if we instantiate our own executor, then we are also responsible

         # for calling 'shutdown'

@@ -177,7 +177,7 @@ class BaseRunner(metaclass=abc.ABCMeta):

         pids = [

             pid

             for pid in self._to_retry.keys()

-            if pid not in self.pending_points.values()

+            if pid not in self._pending_points.values()

         ][:n]

         loss_improvements = len(pids) * [float("inf")]

@@ -215,7 +215,7 @@ class BaseRunner(metaclass=abc.ABCMeta):

     def _process_futures(self, done_futs):

         for fut in done_futs:

-            pid = self.pending_points.pop(fut)

+            pid = self._pending_points.pop(fut)

             try:

                 y = fut.result()

                 t = time.time() - fut.start_time  # total execution time

@@ -239,7 +239,7 @@ class BaseRunner(metaclass=abc.ABCMeta):

         # Launch tasks to replace the ones that completed

         # on the last iteration, making sure to fill workers

         # that have started since the last iteration.

-        n_new_tasks = max(0, self._get_max_tasks() - len(self.pending_points))

+        n_new_tasks = max(0, self._get_max_tasks() - len(self._pending_points))

         if self.do_log:

             self.log.append(("ask", n_new_tasks))

@@ -251,17 +251,17 @@ class BaseRunner(metaclass=abc.ABCMeta):

             point = self._id_to_point[pid]

             fut = self._submit(point)

             fut.start_time = start_time

-            self.pending_points[fut] = pid

+            self._pending_points[fut] = pid

         # Collect and results and add them to the learner

-        futures = list(self.pending_points.keys())

+        futures = list(self._pending_points.keys())

         return futures

     def _remove_unfinished(self):

         # remove points with 'None' values from the learner

         self.learner.remove_unfinished()

         # cancel any outstanding tasks

-        remaining = list(self.pending_points.keys())

+        remaining = list(self._pending_points.keys())

         for fut in remaining:

             fut.cancel()

         return remaining

@@ -298,11 +298,17 @@ class BaseRunner(metaclass=abc.ABCMeta):

     @property

     def tracebacks(self):

-        return [(self._id_to_point[i], tb) for i, tb in self._tracebacks.items()]

+        return [(self._id_to_point[pid], tb) for pid, tb in self._tracebacks.items()]

     @property

     def to_retry(self):

-        return [(self._id_to_point[i], n) for i, n in self._to_retry.items()]

+        return [(self._id_to_point[pid], n) for pid, n in self._to_retry.items()]

+

+    @property

+    def pending_points(self):

+        return [

+            (fut, self._id_to_point[pid]) for fut, pid in self._pending_points.items()

+        ]

 class BlockingRunner(BaseRunner):

@@ -343,14 +349,14 @@ class BlockingRunner(BaseRunner):

     log : list or None

         Record of the method calls made to the learner, in the format

         ``(method_name, *args)``.

-    to_retry : dict

-        Mapping of ``{point: n_fails, ...}``. When a point has failed

+    to_retry : list of tuples

+        List of ``(point, n_fails)``. When a point has failed

         ``runner.retries`` times it is removed but will be present

         in ``runner.tracebacks``.

-    tracebacks : dict

-        A mapping of point to the traceback if that point failed.

-    pending_points : dict

-        A mapping of `~concurrent.futures.Future`\to points.

+    tracebacks : list of tuples

+        List of of ``(point, tb)`` for points that failed.

+    pending_points : list of tuples

+        A list of tuples with ``(concurrent.futures.Future, point)``.

     Methods

     -------

@@ -466,14 +472,14 @@ class AsyncRunner(BaseRunner):

     log : list or None

         Record of the method calls made to the learner, in the format

         ``(method_name, *args)``.

-    to_retry : dict

-        Mapping of ``{point: n_fails, ...}``. When a point has failed

+    to_retry : list of tuples

+        List of ``(point, n_fails)``. When a point has failed

         ``runner.retries`` times it is removed but will be present

         in ``runner.tracebacks``.

-    tracebacks : dict

-        A mapping of point to the traceback if that point failed.

-    pending_points : dict

-        A mapping of `~concurrent.futures.Future`\s to points.

+    tracebacks : list of tuples

+        List of of ``(point, tb)`` for points that failed.

+    pending_points : list of tuples

+        A list of tuples with ``(concurrent.futures.Future, point)``.

     Methods

     -------

@@ -174,22 +174,21 @@ class BaseRunner(metaclass=abc.ABCMeta):

         return self.log is not None

     def _ask(self, n):

-        points = []

-        for i, pid in enumerate(self._to_retry.keys()):

-            if i == n:

-                break

-            point = self._id_to_point[pid]

-            if point not in self.pending_points.values():

-                points.append(point)

-

-        loss_improvements = len(points) * [float("inf")]

-        if len(points) < n:

-            new_points, new_losses = self.learner.ask(n - len(points))

-            points += new_points

+        pids = [

+            pid

+            for pid in self._to_retry.keys()

+            if pid not in self.pending_points.values()

+        ][:n]

+        loss_improvements = len(pids) * [float("inf")]

+

+        if len(pids) < n:

+            new_points, new_losses = self.learner.ask(n - len(pids))

             loss_improvements += new_losses

-            for p in new_points:

-                self._id_to_point[self._next_id()] = p

-        return points, loss_improvements

+            for point in new_points:

+                pid = self._next_id()

+                self._id_to_point[pid] = point

+                pids.append(pid)

+        return pids, loss_improvements

     def overhead(self):

         """Overhead of using Adaptive and the executor in percent.

@@ -216,23 +215,22 @@ class BaseRunner(metaclass=abc.ABCMeta):

     def _process_futures(self, done_futs):

         for fut in done_futs:

-            x = self.pending_points.pop(fut)

-            i = _key_by_value(self._id_to_point, x)  # O(N)

+            pid = self.pending_points.pop(fut)

             try:

                 y = fut.result()

                 t = time.time() - fut.start_time  # total execution time

             except Exception as e:

-                self._tracebacks[i] = traceback.format_exc()

-                self._to_retry[i] = self._to_retry.get(i, 0) + 1

-                if self._to_retry[i] > self.retries:

-                    self._to_retry.pop(i)

+                self._tracebacks[pid] = traceback.format_exc()

+                self._to_retry[pid] = self._to_retry.get(pid, 0) + 1

+                if self._to_retry[pid] > self.retries:

+                    self._to_retry.pop(pid)

                     if self.raise_if_retries_exceeded:

-                        self._do_raise(e, i)

+                        self._do_raise(e, pid)

             else:

                 self._elapsed_function_time += t / self._get_max_tasks()

-                self._to_retry.pop(i, None)

-                self._tracebacks.pop(i, None)

-                self._id_to_point.pop(i)

+                self._to_retry.pop(pid, None)

+                self._tracebacks.pop(pid, None)

+                x = self._id_to_point.pop(pid)

                 if self.do_log:

                     self.log.append(("tell", x, y))

                 self.learner.tell(x, y)

@@ -246,13 +244,14 @@ class BaseRunner(metaclass=abc.ABCMeta):

         if self.do_log:

             self.log.append(("ask", n_new_tasks))

-        points, _ = self._ask(n_new_tasks)

+        pids, _ = self._ask(n_new_tasks)

-        for x in points:

+        for pid in pids:

             start_time = time.time()  # so we can measure execution time

-            fut = self._submit(x)

+            point = self._id_to_point[pid]

+            fut = self._submit(point)

             fut.start_time = start_time

-            self.pending_points[fut] = x

+            self.pending_points[fut] = pid

         # Collect and results and add them to the learner

         futures = list(self.pending_points.keys())

@@ -175,10 +175,10 @@ class BaseRunner(metaclass=abc.ABCMeta):

     def _ask(self, n):

         points = []

-        for i, _id in enumerate(self._to_retry.keys()):

+        for i, pid in enumerate(self._to_retry.keys()):

             if i == n:

                 break

-            point = self._id_to_point[_id]

+            point = self._id_to_point[pid]

             if point not in self.pending_points.values():

                 points.append(point)

@@ -187,6 +187,8 @@ class BaseRunner(metaclass=abc.ABCMeta):

             new_points, new_losses = self.learner.ask(n - len(points))

             points += new_points

             loss_improvements += new_losses

+            for p in new_points:

+                self._id_to_point[self._next_id()] = p

         return points, loss_improvements

     def overhead(self):

@@ -251,11 +253,6 @@ class BaseRunner(metaclass=abc.ABCMeta):

             fut = self._submit(x)

             fut.start_time = start_time

             self.pending_points[fut] = x

-            try:

-                _id = _key_by_value(self._id_to_point, x)  # O(N)

-            except StopIteration:  # `x` is not a value in `self._id_to_point`

-                _id = self._next_id()

-            self._id_to_point[_id] = x

         # Collect and results and add them to the learner

         futures = list(self.pending_points.keys())

@@ -1,7 +1,9 @@

 import abc

 import asyncio

 import concurrent.futures as concurrent

+import functools

 import inspect

+import itertools

 import pickle

 import sys

 import time

@@ -150,9 +152,10 @@ class BaseRunner(metaclass=abc.ABCMeta):

         self._to_retry = {}

         self._tracebacks = {}

-        # Keeping track of index -> point

         self._id_to_point = {}

-        self._i = 0  # some unique index to be associated with each point

+        self._next_id = functools.partial(

+            next, itertools.count()

+        )  # some unique id to be associated with each point

     def _get_max_tasks(self):

         return self._max_tasks or _get_ncores(self.executor)

@@ -172,10 +175,10 @@ class BaseRunner(metaclass=abc.ABCMeta):

     def _ask(self, n):

         points = []

-        for i, index in enumerate(self._to_retry.keys()):

+        for i, _id in enumerate(self._to_retry.keys()):

             if i == n:

                 break

-            point = self._id_to_point[index]

+            point = self._id_to_point[_id]

             if point not in self.pending_points.values():

                 points.append(point)

@@ -249,11 +252,10 @@ class BaseRunner(metaclass=abc.ABCMeta):

             fut.start_time = start_time

             self.pending_points[fut] = x

             try:

-                i = _key_by_value(self._id_to_point, x)  # O(N)

+                _id = _key_by_value(self._id_to_point, x)  # O(N)

             except StopIteration:  # `x` is not a value in `self._id_to_point`

-                self._i += 1

-                i = self._i

-            self._id_to_point[i] = x

+                _id = self._next_id()

+            self._id_to_point[_id] = x

         # Collect and results and add them to the learner

         futures = list(self.pending_points.keys())

@@ -151,7 +151,7 @@ class BaseRunner(metaclass=abc.ABCMeta):

         self._tracebacks = {}

         # Keeping track of index -> point

-        self._index_to_point = {}

+        self._id_to_point = {}

         self._i = 0  # some unique index to be associated with each point

     def _get_max_tasks(self):

@@ -159,7 +159,7 @@ class BaseRunner(metaclass=abc.ABCMeta):

     def _do_raise(self, e, i):

         tb = self._tracebacks[i]

-        x = self._index_to_point[i]

+        x = self._id_to_point[i]

         raise RuntimeError(

             "An error occured while evaluating "

             f'"learner.function({x})". '

@@ -175,7 +175,7 @@ class BaseRunner(metaclass=abc.ABCMeta):

         for i, index in enumerate(self._to_retry.keys()):

             if i == n:

                 break

-            point = self._index_to_point[index]

+            point = self._id_to_point[index]

             if point not in self.pending_points.values():

                 points.append(point)

@@ -212,7 +212,7 @@ class BaseRunner(metaclass=abc.ABCMeta):

     def _process_futures(self, done_futs):

         for fut in done_futs:

             x = self.pending_points.pop(fut)

-            i = _key_by_value(self._index_to_point, x)  # O(N)

+            i = _key_by_value(self._id_to_point, x)  # O(N)

             try:

                 y = fut.result()

                 t = time.time() - fut.start_time  # total execution time

@@ -227,7 +227,7 @@ class BaseRunner(metaclass=abc.ABCMeta):

                 self._elapsed_function_time += t / self._get_max_tasks()

                 self._to_retry.pop(i, None)

                 self._tracebacks.pop(i, None)

-                self._index_to_point.pop(i)

+                self._id_to_point.pop(i)

                 if self.do_log:

                     self.log.append(("tell", x, y))

                 self.learner.tell(x, y)

@@ -249,11 +249,11 @@ class BaseRunner(metaclass=abc.ABCMeta):

             fut.start_time = start_time

             self.pending_points[fut] = x

             try:

-                i = _key_by_value(self._index_to_point, x)  # O(N)

-            except StopIteration:  # `x` is not a value in `self._index_to_point`

+                i = _key_by_value(self._id_to_point, x)  # O(N)

+            except StopIteration:  # `x` is not a value in `self._id_to_point`

                 self._i += 1

                 i = self._i

-            self._index_to_point[i] = x

+            self._id_to_point[i] = x

         # Collect and results and add them to the learner

         futures = list(self.pending_points.keys())

@@ -300,11 +300,11 @@ class BaseRunner(metaclass=abc.ABCMeta):

     @property

     def tracebacks(self):

-        return [(self._index_to_point[i], tb) for i, tb in self._tracebacks.items()]

+        return [(self._id_to_point[i], tb) for i, tb in self._tracebacks.items()]

     @property

     def to_retry(self):

-        return [(self._index_to_point[i], n) for i, n in self._to_retry.items()]

+        return [(self._id_to_point[i], n) for i, n in self._to_retry.items()]

 class BlockingRunner(BaseRunner):

@@ -55,7 +55,7 @@ _default_executor = (

 def _key_by_value(dct, value):

-    return next((k for k, v in dct.items() if v == value), None)

+    return next(k for k, v in dct.items() if v == value)

 class BaseRunner(metaclass=abc.ABCMeta):

@@ -248,9 +248,9 @@ class BaseRunner(metaclass=abc.ABCMeta):

             fut = self._submit(x)

             fut.start_time = start_time

             self.pending_points[fut] = x

-            i = _key_by_value(self._index_to_point, x)  # O(N)

-            if i is None:

-                # `x` is not a value in `self._index_to_point`

+            try:

+                i = _key_by_value(self._index_to_point, x)  # O(N)

+            except StopIteration:  # `x` is not a value in `self._index_to_point`

                 self._i += 1

                 i = self._i

             self._index_to_point[i] = x

@@ -55,9 +55,7 @@ _default_executor = (

 def _key_by_value(dct, value):

-    for k, v in dct.items():

-        if v == value:

-            return k

+    return next((k for k, v in dct.items() if v == value), None)

 class BaseRunner(metaclass=abc.ABCMeta):

@@ -97,12 +97,12 @@ class BaseRunner(metaclass=abc.ABCMeta):

     log : list or None

         Record of the method calls made to the learner, in the format

         ``(method_name, *args)``.

-    to_retry : dict

-        Mapping of ``{point: n_fails, ...}``. When a point has failed

+    to_retry : list of tuples

+        List of ``(point, n_fails)``. When a point has failed

         ``runner.retries`` times it is removed but will be present

         in ``runner.tracebacks``.

-    tracebacks : dict

-        A mapping of point to the traceback if that point failed.

+    tracebacks : list of tuples

+        List of of ``(point, tb)`` for points that failed.

     pending_points : dict

         A mapping of `~concurrent.futures.Future`\s to points.

@@ -149,19 +149,19 @@ class BaseRunner(metaclass=abc.ABCMeta):

         # Error handling attributes

         self.retries = retries

         self.raise_if_retries_exceeded = raise_if_retries_exceeded

-        self.to_retry = {}

-        self.tracebacks = {}

+        self._to_retry = {}

+        self._tracebacks = {}

         # Keeping track of index -> point

-        self.index_to_point = {}

+        self._index_to_point = {}

         self._i = 0  # some unique index to be associated with each point

     def _get_max_tasks(self):

         return self._max_tasks or _get_ncores(self.executor)

     def _do_raise(self, e, i):

-        tb = self.tracebacks[i]

-        x = self.index_to_point[i]

+        tb = self._tracebacks[i]

+        x = self._index_to_point[i]

         raise RuntimeError(

             "An error occured while evaluating "

             f'"learner.function({x})". '

@@ -174,10 +174,10 @@ class BaseRunner(metaclass=abc.ABCMeta):

     def _ask(self, n):

         points = []

-        for i, index in enumerate(self.to_retry.keys()):

+        for i, index in enumerate(self._to_retry.keys()):

             if i == n:

                 break

-            point = self.index_to_point[index]

+            point = self._index_to_point[index]

             if point not in self.pending_points.values():

                 points.append(point)

@@ -214,22 +214,22 @@ class BaseRunner(metaclass=abc.ABCMeta):

     def _process_futures(self, done_futs):

         for fut in done_futs:

             x = self.pending_points.pop(fut)

-            i = _key_by_value(self.index_to_point, x)  # O(N)

+            i = _key_by_value(self._index_to_point, x)  # O(N)

             try:

                 y = fut.result()

                 t = time.time() - fut.start_time  # total execution time

             except Exception as e:

-                self.tracebacks[i] = traceback.format_exc()

-                self.to_retry[i] = self.to_retry.get(i, 0) + 1

-                if self.to_retry[i] > self.retries:

-                    self.to_retry.pop(i)

+                self._tracebacks[i] = traceback.format_exc()

+                self._to_retry[i] = self._to_retry.get(i, 0) + 1

+                if self._to_retry[i] > self.retries:

+                    self._to_retry.pop(i)

                     if self.raise_if_retries_exceeded:

                         self._do_raise(e, i)

             else:

                 self._elapsed_function_time += t / self._get_max_tasks()

-                self.to_retry.pop(i, None)

-                self.tracebacks.pop(i, None)

-                self.index_to_point.pop(i)

+                self._to_retry.pop(i, None)

+                self._tracebacks.pop(i, None)

+                self._index_to_point.pop(i)

                 if self.do_log:

                     self.log.append(("tell", x, y))

                 self.learner.tell(x, y)

@@ -250,12 +250,12 @@ class BaseRunner(metaclass=abc.ABCMeta):

             fut = self._submit(x)

             fut.start_time = start_time

             self.pending_points[fut] = x

-            i = _key_by_value(self.index_to_point, x)  # O(N)

+            i = _key_by_value(self._index_to_point, x)  # O(N)

             if i is None:

-                # `x` is not a value in `self.index_to_point`

+                # `x` is not a value in `self._index_to_point`

                 self._i += 1

                 i = self._i

-            self.index_to_point[i] = x

+            self._index_to_point[i] = x

         # Collect and results and add them to the learner

         futures = list(self.pending_points.keys())

@@ -284,7 +284,7 @@ class BaseRunner(metaclass=abc.ABCMeta):

     @property

     def failed(self):

         """Set of points that failed ``runner.retries`` times."""

-        return set(self.tracebacks) - set(self.to_retry)

+        return set(self._tracebacks) - set(self._to_retry)

     @abc.abstractmethod

     def elapsed_time(self):

@@ -300,6 +300,14 @@ class BaseRunner(metaclass=abc.ABCMeta):

         """Is called in `_get_futures`."""

         pass

+    @property

+    def tracebacks(self):

+        return [(self._index_to_point[i], tb) for i, tb in self._tracebacks.items()]

+

+    @property

+    def to_retry(self):

+        return [(self._index_to_point[i], n) for i, n in self._to_retry.items()]

+

 class BlockingRunner(BaseRunner):

     """Run a learner synchronously in an executor.

@@ -54,6 +54,12 @@ _default_executor = (

 )

+def _key_by_value(dct, value):

+    for k, v in dct.items():

+        if v == value:

+            return k

+

+

 class BaseRunner(metaclass=abc.ABCMeta):

     r"""Base class for runners that use `concurrent.futures.Executors`.

@@ -146,11 +152,16 @@ class BaseRunner(metaclass=abc.ABCMeta):

         self.to_retry = {}

         self.tracebacks = {}

+        # Keeping track of index -> point

+        self.index_to_point = {}

+        self._i = 0  # some unique index to be associated with each point

+

     def _get_max_tasks(self):

         return self._max_tasks or _get_ncores(self.executor)

-    def _do_raise(self, e, x):

-        tb = self.tracebacks[x]

+    def _do_raise(self, e, i):

+        tb = self.tracebacks[i]

+        x = self.index_to_point[i]

         raise RuntimeError(

             "An error occured while evaluating "

             f'"learner.function({x})". '

@@ -162,9 +173,14 @@ class BaseRunner(metaclass=abc.ABCMeta):

         return self.log is not None

     def _ask(self, n):

-        points = [

-            p for p in self.to_retry.keys() if p not in self.pending_points.values()

-        ][:n]

+        points = []

+        for i, index in enumerate(self.to_retry.keys()):

+            if i == n:

+                break

+            point = self.index_to_point[index]

+            if point not in self.pending_points.values():

+                points.append(point)

+

         loss_improvements = len(points) * [float("inf")]

         if len(points) < n:

             new_points, new_losses = self.learner.ask(n - len(points))

@@ -198,20 +214,22 @@ class BaseRunner(metaclass=abc.ABCMeta):

     def _process_futures(self, done_futs):

         for fut in done_futs:

             x = self.pending_points.pop(fut)

+            i = _key_by_value(self.index_to_point, x)  # O(N)

             try:

                 y = fut.result()

                 t = time.time() - fut.start_time  # total execution time

             except Exception as e:

-                self.tracebacks[x] = traceback.format_exc()

-                self.to_retry[x] = self.to_retry.get(x, 0) + 1

-                if self.to_retry[x] > self.retries:

-                    self.to_retry.pop(x)

+                self.tracebacks[i] = traceback.format_exc()

+                self.to_retry[i] = self.to_retry.get(i, 0) + 1

+                if self.to_retry[i] > self.retries:

+                    self.to_retry.pop(i)

                     if self.raise_if_retries_exceeded:

-                        self._do_raise(e, x)

+                        self._do_raise(e, i)

             else:

                 self._elapsed_function_time += t / self._get_max_tasks()

-                self.to_retry.pop(x, None)

-                self.tracebacks.pop(x, None)

+                self.to_retry.pop(i, None)

+                self.tracebacks.pop(i, None)

+                self.index_to_point.pop(i)

                 if self.do_log:

                     self.log.append(("tell", x, y))

                 self.learner.tell(x, y)

@@ -232,6 +250,12 @@ class BaseRunner(metaclass=abc.ABCMeta):

             fut = self._submit(x)