>>> Call to Pool.terminate in "pool.py", line 653
.......... self = <multiprocessing.pool.Pool state=RUN pool_size=1>
 653 |     def terminate(self):
 654 |         util.debug('terminating pool')
 655 |         self._state = TERMINATE
.............. self = <multiprocessing.pool.Pool state=TERMINATE pool_size=1>
 656 |         self._worker_handler._state = TERMINATE
 657 |         self._change_notifier.put(None)
    >>> Call to SimpleQueue.put in "queues.py", line 360
    .......... self = <multiprocessing.queues.SimpleQueue object at 0x109948250>
    .......... obj = None
     360 |     def put(self, obj):
     362 |         obj = _ForkingPickler.dumps(obj)
        >>> Call to ForkingPickler.dumps in "reduction.py", line 49
        .......... cls = <class 'multiprocessing.reduction.ForkingPickler'>
        .......... obj = None
        .......... protocol = None
          49 |     def dumps(cls, obj, protocol=None):
          50 |         buf = io.BytesIO()
        .............. buf = <_io.BytesIO object at 0x108f4d680>
          51 |         cls(buf, protocol).dump(obj)
            >>> Call to ForkingPickler.__init__ in "reduction.py", line 38
            .......... self = <multiprocessing.reduction.ForkingPickler object at 0x1099137c0>
            .......... args = (<_io.BytesIO object at 0x108f4d680>, None)
            .......... len(args) = 2
            .......... __class__ = <class 'multiprocessing.reduction.ForkingPickler'>
              38 |     def __init__(self, *args):
              39 |         super().__init__(*args)
              40 |         self.dispatch_table = self._copyreg_dispatch_table.copy()
              41 |         self.dispatch_table.update(self._extra_reducers)
            <<< Return value from ForkingPickler.__init__: None
          51 |         cls(buf, protocol).dump(obj)
          52 |         return buf.getbuffer()
        <<< Return value from ForkingPickler.dumps: <memory at 0x1099137c0>
     362 |         obj = _ForkingPickler.dumps(obj)
    .............. obj = <memory at 0x1099137c0>
    .............. obj.shape = (4,)
     363 |         if self._wlock is None:
     367 |             with self._wlock:
        >>> Call to SemLock.__enter__ in "synchronize.py", line 94
        .......... self = <Lock(owner=unknown)>
          94 |     def __enter__(self):
          95 |         return self._semlock.__enter__()
        .............. self = <Lock(owner=MainProcess|Thread-2)>
        <<< Return value from SemLock.__enter__: True
     367 |             with self._wlock:
     368 |                 self._writer.send_bytes(obj)
        >>> Call to _ConnectionBase.send_bytes in "connection.py", line 181
        .......... self = <multiprocessing.connection.Connection object at 0x1099483a0>
        .......... buf = <memory at 0x1099137c0>
        .......... buf.shape = (4,)
        .......... offset = 0
        .......... size = None
         181 |     def send_bytes(self, buf, offset=0, size=None):
         183 |         self._check_closed()
            >>> Call to _ConnectionBase._check_closed in "connection.py", line 134
            .......... self = <multiprocessing.connection.Connection object at 0x1099483a0>
             134 |     def _check_closed(self):
             135 |         if self._handle is None:
            <<< Return value from _ConnectionBase._check_closed: None
         183 |         self._check_closed()
         184 |         self._check_writable()
            >>> Call to _ConnectionBase._check_writable in "connection.py", line 142
            .......... self = <multiprocessing.connection.Connection object at 0x1099483a0>
             142 |     def _check_writable(self):
             143 |         if not self._writable:
            <<< Return value from _ConnectionBase._check_writable: None
         184 |         self._check_writable()
         185 |         m = memoryview(buf)
        .............. m = <memory at 0x109913a00>
        .............. m.shape = (4,)
         187 |         if m.itemsize > 1:
         189 |         n = len(m)
        .............. n = 4
         190 |         if offset < 0:
         192 |         if n < offset:
         194 |         if size is None:
         195 |             size = n - offset
        .................. size = 4
         200 |         self._send_bytes(m[offset:offset + size])
            >>> Call to Connection._send_bytes in "connection.py", line 390
            .......... self = <multiprocessing.connection.Connection object at 0x1099483a0>
            .......... buf = <memory at 0x109913340>
            .......... buf.shape = (4,)
             390 |     def _send_bytes(self, buf):
             391 |         n = len(buf)
            .............. n = 4
             392 |         if n > 0x7fffffff:
             400 |             header = struct.pack("!i", n)
            .................. header = b'\x00\x00\x00\x04'
            .................. len(header) = 4
             401 |             if n > 16384:
             411 |                 self._send(header + buf)
                >>> Call to Connection._send in "connection.py", line 365
                .......... self = <multiprocessing.connection.Connection object at 0x1099483a0>
                .......... buf = b'\x00\x00\x00\x04\x80\x04N.'
                .......... len(buf) = 8
                .......... write = <built-in function write>
                 365 |     def _send(self, buf, write=_write):
                 366 |         remaining = len(buf)
                .............. remaining = 8
                 368 |             n = write(self._handle, buf)
                .................. n = 8
                 369 |             remaining -= n
                .................. remaining = 0
                 370 |             if remaining == 0:
                 371 |                 break
                <<< Return value from Connection._send: None
             411 |                 self._send(header + buf)
            <<< Return value from Connection._send_bytes: None
         200 |         self._send_bytes(m[offset:offset + size])
        <<< Return value from _ConnectionBase.send_bytes: None
        >>> Call to SemLock.__exit__ in "synchronize.py", line 97
        .......... self = <Lock(owner=MainProcess|Thread-2)>
        .......... args = (None, None, None)
        .......... len(args) = 3
          97 |     def __exit__(self, *args):
          98 |         return self._semlock.__exit__(*args)
        .............. self = <Lock(owner=unknown)>
        <<< Return value from SemLock.__exit__: None
     368 |                 self._writer.send_bytes(obj)
    <<< Return value from SimpleQueue.put: None
 657 |         self._change_notifier.put(None)
 658 |         self._terminate()
    >>> Call to Finalize.__call__ in "util.py", line 182
    .......... self = <Finalize object, callback=_terminate_pool, args...d daemon 123145500270592)>, {}), exitpriority=15>
    .......... wr = None
    .......... _finalizer_registry = {(None, 8): <Finalize object, callback=close_fds, args=[27, 30]>, (0, 9): <Finalize object, callback=_finalize_manager, ar...function Client at 0x1089478b0>), exitpriority=0>, (10, 10): <Finalize object, callback=_decref, args=(Token(...unction Client at 0x1089478b0>), exitpriority=10>, (10, 11): <Finalize object, callback=_decref, args=(Token(...unction Client at 0x1089478b0>), exitpriority=10>, ...}
    .......... len(_finalizer_registry) = 12
    .......... sub_debug = <function sub_debug at 0x10893c4c0>
    .......... getpid = <built-in function getpid>
     182 |     def __call__(self, wr=None,
     190 |         try:
     191 |             del _finalizer_registry[self._key]
    .................. len(_finalizer_registry) = 11
     195 |             if self._pid != getpid():
     199 |                 sub_debug('finalizer calling %s with args %s and kwargs %s',
     200 |                           self._callback, self._args, self._kwargs)
     199 |                 sub_debug('finalizer calling %s with args %s and kwargs %s',
        >>> Call to sub_debug in "util.py", line 44
        ...... msg = 'finalizer calling %s with args %s and kwargs %s'
        ...... args = (<bound method type._terminate_pool of <class 'multiprocessing.pool.Pool'>>, (<_queue.SimpleQueue object at 0x109943680>, <multiprocessing.queues.SimpleQueue object at 0x109447b50>, <multiprocessing.queues.SimpleQueue object at 0x109946bb0>, ..., <Thread(Thread-7, started daemon 123145483481088)>, <Thread(Thread-8, started daemon 123145500270592)>, {}), {})
        ...... len(args) = 3
          44 | def sub_debug(msg, *args):
          45 |     if _logger:
        <<< Return value from sub_debug: None
     199 |                 sub_debug('finalizer calling %s with args %s and kwargs %s',
     201 |                 res = self._callback(*self._args, **self._kwargs)
        >>> Call to Pool._terminate_pool in "pool.py", line 682
        .......... cls = <class 'multiprocessing.pool.Pool'>
        .......... taskqueue = <_queue.SimpleQueue object at 0x109943680>
        .......... inqueue = <multiprocessing.queues.SimpleQueue object at 0x109447b50>
        .......... outqueue = <multiprocessing.queues.SimpleQueue object at 0x109946bb0>
        .......... pool = [<SpawnProcess name='SpawnPoolWorker-4' pid=23917 parent=23906 started daemon>]
        .......... len(pool) = 1
        .......... change_notifier = <multiprocessing.queues.SimpleQueue object at 0x109948250>
        .......... worker_handler = <Thread(Thread-6, started daemon 123145466691584)>
        .......... task_handler = <Thread(Thread-7, started daemon 123145483481088)>
        .......... result_handler = <Thread(Thread-8, started daemon 123145500270592)>
        .......... cache = {}
         682 |     def _terminate_pool(cls, taskqueue, inqueue, outqueue, pool, change_notifier,
         685 |         util.debug('finalizing pool')
         687 |         worker_handler._state = TERMINATE
         688 |         task_handler._state = TERMINATE
         690 |         util.debug('helping task handler/workers to finish')
         691 |         cls._help_stuff_finish(inqueue, task_handler, len(pool))
            >>> Call to Pool._help_stuff_finish in "pool.py", line 673
            .......... inqueue = <multiprocessing.queues.SimpleQueue object at 0x109447b50>
            .......... task_handler = <Thread(Thread-7, started daemon 123145483481088)>
            .......... size = 1
             673 |     def _help_stuff_finish(inqueue, task_handler, size):
             675 |         util.debug('removing tasks from inqueue until task handler finished')
             676 |         inqueue._rlock.acquire()