mqdm 0.0.1__tar.gz

mqdm-0.0.1/PKG-INFO

@@ -0,0 +1,79 @@
+Metadata-Version: 2.1
+Name: mqdm
+Version: 0.0.1
+Description-Content-Type: text/markdown
+Requires-Dist: rich
+
+# mqdm: progress bars for multiprocessing
+Pretty progress bars with `rich`, in your child processes.
+
+## Install
+
+```bash
+pip install mqdm
+```
+
+## Worker progress
+```python
+import mqdm
+import time
+
+def my_work(n, sleep, pbar):
+    for i in pbar(range(n), description=f'counting to {n}'):
+        time.sleep(sleep)
+
+# executes my task in a concurrent futures process pool
+mqdm.pool(
+    my_work,
+    range(1, 10),
+    sleep=1,
+    n_workers=3,
+)
+```
+
+![alt text](static/image.png)
+
+## Less high level please
+Basically, the mechanics are this:
+```python
+# use context manager to start background listener and message queue
+with mqdm.Bars() as pbars:
+    # create progress bars and send them to the remote processes
+    pool.submit(my_work, 1, pbar=pbars.add())
+    pool.submit(my_work, 2, pbar=pbars.add())
+    pool.submit(my_work, 3, pbar=pbars.add())
+
+# your worker function can look like this
+def my_work(n, sleep, pbar):
+    for i in pbar(range(n), description=f'counting to {n}'):
+        time.sleep(sleep)
+
+# or this
+def my_work(n, pbar, sleep=0.2):
+    import time
+    with pbar(description=f'counting to {n}', total=n):
+        for i in range(n):
+            pbar.update(0.5, description=f'Im counting - {n}  ')
+            time.sleep(sleep/2)
+            pbar.update(0.5, description=f'Im counting - {n+0.5}')
+            time.sleep(sleep/2)
+```
+
+And you can use it in a pool like this:
+
+```python
+import mqdm
+from concurrent.futures import ProcessPoolExecutor, as_completed
+
+items = range(1, 10)
+
+with ProcessPoolExecutor(max_workers=n_workers) as pool, mqdm.Bars() as pbars:
+    futures = [
+        pool.submit(my_work, i, pbar=pbars.add())
+        for i in items
+    ]
+    for f in as_completed(futures):
+        print(f.result())
+```
+
+It works by spawning a background thread with a multiprocessing queue. The Bars instance listens for messages from the progress bar proxies in the child processes.

mqdm-0.0.1/README.md

@@ -0,0 +1,73 @@
+# mqdm: progress bars for multiprocessing
+Pretty progress bars with `rich`, in your child processes.
+
+## Install
+
+```bash
+pip install mqdm
+```
+
+## Worker progress
+```python
+import mqdm
+import time
+
+def my_work(n, sleep, pbar):
+    for i in pbar(range(n), description=f'counting to {n}'):
+        time.sleep(sleep)
+
+# executes my task in a concurrent futures process pool
+mqdm.pool(
+    my_work,
+    range(1, 10),
+    sleep=1,
+    n_workers=3,
+)
+```
+
+![alt text](static/image.png)
+
+## Less high level please
+Basically, the mechanics are this:
+```python
+# use context manager to start background listener and message queue
+with mqdm.Bars() as pbars:
+    # create progress bars and send them to the remote processes
+    pool.submit(my_work, 1, pbar=pbars.add())
+    pool.submit(my_work, 2, pbar=pbars.add())
+    pool.submit(my_work, 3, pbar=pbars.add())
+
+# your worker function can look like this
+def my_work(n, sleep, pbar):
+    for i in pbar(range(n), description=f'counting to {n}'):
+        time.sleep(sleep)
+
+# or this
+def my_work(n, pbar, sleep=0.2):
+    import time
+    with pbar(description=f'counting to {n}', total=n):
+        for i in range(n):
+            pbar.update(0.5, description=f'Im counting - {n}  ')
+            time.sleep(sleep/2)
+            pbar.update(0.5, description=f'Im counting - {n+0.5}')
+            time.sleep(sleep/2)
+```
+
+And you can use it in a pool like this:
+
+```python
+import mqdm
+from concurrent.futures import ProcessPoolExecutor, as_completed
+
+items = range(1, 10)
+
+with ProcessPoolExecutor(max_workers=n_workers) as pool, mqdm.Bars() as pbars:
+    futures = [
+        pool.submit(my_work, i, pbar=pbars.add())
+        for i in items
+    ]
+    for f in as_completed(futures):
+        print(f.result())
+```
+
+It works by spawning a background thread with a multiprocessing queue. The Bars instance listens for messages from the progress bar proxies in the child processes.

mqdm-0.0.1/mqdm/__init__.py

@@ -0,0 +1,3 @@
+from . import utils
+from .core import Bars, RemoteBar, Bar, args
+pool = Bars.pool

mqdm-0.0.1/mqdm/__main__.py

@@ -0,0 +1,4 @@
+from mqdm.core import example_run
+
+import fire
+fire.Fire(example_run)

mqdm-0.0.1/mqdm/_alt_dict.py

@@ -0,0 +1,119 @@
+'''First draft implementation using manager dict.
+
+
+'''
+
+import random
+from time import sleep
+import threading
+import multiprocessing
+from concurrent.futures import ProcessPoolExecutor
+from rich import progress
+
+
+class Bars:
+    def __init__(self, desc="[green]All jobs progress:") -> None:
+        self.desc = desc
+        self.pbar = progress.Progress(
+            "[progress.description]{task.description}",
+            progress.BarColumn(),
+            "[progress.percentage]{task.percentage:>3.0f}%",
+            progress.TimeRemainingColumn(),
+            progress.TimeElapsedColumn(),
+            refresh_per_second=8,
+        )
+        # Create and start a thread for reading from the queue
+        reader_thread = threading.Thread(target=queue_reader, args=(queue,))
+        reader_thread.start()
+        self.manager = multiprocessing.Manager()
+
+    def __enter__(self):
+        self.pbar.__enter__()
+        self.manager.__enter__()
+        self.tasks = self.manager.dict()
+        self.overall_task = self.pbar.add_task(self.desc)
+        return self
+   
+    def __exit__(self, c,v,t):
+        self.pbar.__exit__(c,v,t)
+        self.manager.__exit__(c,v,t)
+
+    def add(self, title, visible=False, **kw):
+        task_id = self.pbar.add_task(title, visible=visible, start=False, **kw)
+        return Bar(self.tasks, task_id)
+
+    def update(self):
+        n_finished = 0
+        for task_id, data in self.tasks.items():
+            data = dict(data)
+            complete = data['total'] and data['completed'] >= data['total']
+            visible = bool(data['total'] and not complete)
+            data.setdefault('visible', visible)
+            n_finished += complete
+            # update the progress bar for this task:
+            self.pbar.update(task_id, **data)
+        self.pbar.update(self.overall_task, completed=n_finished, total=len(self.tasks))
+
+    def as_completed(self, futures, cycle=0.1):
+        while futures:
+            done = [futures.pop(i) for i, f in enumerate(futures) if f.done()]
+            for f in done:
+                yield f
+            self.update()
+            sleep(cycle)
+
+    @classmethod
+    def map(cls, fn, xs, n_workers=8, desc=None, **kw):
+        futures = []
+        with cls() as pbars, ProcessPoolExecutor(max_workers=n_workers) as executor:
+            for i, x in enumerate(xs):
+                desc_i = desc(*x, **kw) if callable(desc) else desc or f'task {i}'
+                futures.append(executor.submit(fn, *x, pbar=pbars.add(desc_i), **kw))
+            for f in pbars.as_completed(futures):
+                result = f.result()
+
+
+class Bar:
+    def __init__(self, tasks, task_id):
+        self.tasks = tasks
+        self.task_id = task_id
+        self.current = 0
+        self.total = 0
+        self.update(0)
+
+    def __call__(self, iter, total=None):
+        try:
+            self.total = len(iter)
+        except TypeError:
+            self.total = total
+        def _iter():
+            
+            for x in iter:
+                yield x
+                self.update()
+        return _iter()
+
+    def set(self, value):
+        self.current = value
+        self.update(0)
+        return self
+
+    def update(self, n=1):
+        self.current += n
+        total = self.total if self.current or not self.total else (self.current+1)
+        self.tasks[self.task_id] = {"completed": self.current, "total": total}
+        return self
+
+
+
+def example_fn(i, pbar):
+    import random
+    for i in pbar(range(i + 1)):
+        sleep(random.random())
+
+def pbar_test():
+    Bars.map(example_fn, [[i] for i in range(10)], n_workers=5)
+if __name__ == '__main__':
+
+    import fire
+    fire.Fire(pbar_test)

mqdm-0.0.1/mqdm/core.py

@@ -0,0 +1,347 @@
+''''''
+import sys
+import queue
+import threading
+import multiprocessing as mp
+from concurrent.futures import ProcessPoolExecutor, ThreadPoolExecutor, as_completed
+from rich import progress, print
+from . import utils
+
+
+
+def get_pbar(pbar=None, bytes=False):
+    return pbar or progress.Progress(
+        "[progress.description]{task.description}",
+        progress.BarColumn(),
+        "[progress.percentage]{task.percentage:>3.0f}%",
+        *([progress.DownloadColumn()] if bytes else [utils.MofNColumn()]),
+        progress.TimeRemainingColumn(),
+        progress.TimeElapsedColumn(),
+        refresh_per_second=8,
+    )
+
+
+'''
+-- Multi Process:
+
+Bars(**kw) -> add_task(overall, **kw)
+Bars.add(**kw) -> add_task(item, **kw)
+
+RemoteBar__init__() -> --
+RemoteBar.__call__(**kw) -> RemoteBar.__enter__(**kw)
+RemoteBar.__enter__(**kw) -> start_task(item, **kw)
+iter(RemoteBar(**kw)) -> start_task(item, **kw)
+RemoteBar.update(**kw) -> update(item, **kw)
+
+-- Single Process:
+
+Bar(**kw) -> add_task(item, **kw)
+Bar.__call__(**kw) -> iter(Bar(**kw))
+Bar.update(**kw) -> update(item, **kw)
+
+'''
+    
+
+class Bars:
+    def __init__(self, desc="", pbar=None, iter=None, total=None, pool_mode='process', **kw) -> None:
+        if isinstance(desc, progress.Progress):
+            desc, pbar = None, desc
+        self.desc = desc
+        self.pbar = get_pbar(pbar)
+        self._overall_kw = kw
+        self.total = utils.try_len(iter, total)
+        self._pq = utils.POOL_QUEUES[pool_mode](self._on_message)
+        self._tasks = {}
+
+    def __enter__(self):
+        self.pbar.__enter__()
+        self._pq.__enter__()
+        self._tasks = {}
+        # ---------------------------------------------------------------------------- #
+        #                               add overall task                               #
+        # ---------------------------------------------------------------------------- #
+        self.overall_task = self.pbar.add_task(self.desc, total=self.total, **self._overall_kw)
+        return self
+   
+    def __exit__(self, c,v,t):
+        self._pq.__exit__(c,v,t)
+        self.pbar.__exit__(c,v,t)
+
+    def add(self, title, visible=False, **kw):
+        # ---------------------------------------------------------------------------- #
+        #                                   add task                                   #
+        # ---------------------------------------------------------------------------- #
+        task_id = self.pbar.add_task(title, visible=visible, start=False, **kw)
+        self._tasks[task_id] = {}
+        return RemoteBar(self._pq.queue, task_id)
+    
+    def close(self):
+        self.__exit__(None,None,None)
+
+    def _on_message(self, task_id, method, data):
+        if method == 'update':
+            self._update(task_id, **data)
+        else:
+            getattr(self.pbar, method)(**data)
+
+    def _update(self, task_id, **data):
+        # update the task-specific progress bar
+        if task_id is not None:
+            self._tasks[task_id].update(**data)
+            data.pop('complete', None)
+            # ---------------------------------------------------------------------------- #
+            #                                  update task                                 #
+            # ---------------------------------------------------------------------------- #
+            self.pbar.update(task_id, **data)
+
+        # update the overall task progress bar
+        n_finished = sum(bool(d and d.get('complete', False)) for d in self._tasks.values())
+        # ---------------------------------------------------------------------------- #
+        #                                update overall                                #
+        # ---------------------------------------------------------------------------- #
+        self.pbar.update(self.overall_task, completed=n_finished, total=len(self._tasks))
+
+    @classmethod
+    def ipool(cls, fn, xs, *a, n_workers=8, desc=None, mainbar_kw=None, subbar_kw=None, pool_mode='process', **kw):
+        """Execute a function in a process pool with a progress bar for each task."""
+        # get the arguments for each task
+        items = [x if isinstance(x, args) else args(x) for x in xs]
+    
+        # no workers, just run the function
+        if n_workers < 2:
+            for i, arg in enumerate(items):
+                desc_i = arg(desc or f'task {i}')
+                yield arg(fn, *a, pbar=Bar, **kw)
+            return
+
+        # run the function in a process pool
+        futures = []
+        with utils.POOL_EXECUTORS[pool_mode](max_workers=n_workers) as executor, cls(pool_mode=pool_mode, **(mainbar_kw or {})) as pbars:
+            for i, arg in enumerate(items):
+                desc_i = arg(desc or f'task {i}')
+                pbar = pbars.add(desc_i, **(subbar_kw or {}))
+                futures.append(executor.submit(fn, *arg.a, *a, pbar=pbar, **dict(kw, **arg.kw)))
+            for f in as_completed(futures):
+                yield f.result()
+
+    @classmethod
+    def pool(cls, fn, xs, *a, n_workers=8, desc=None, **kw):
+        return list(cls.imap(fn, xs, *a, n_workers=n_workers, desc=desc, **kw))
+
+    # not sure which name is better
+    imap = ipool
+    map = pool
+
+
+class args:
+    def __init__(self, *a, **kw):
+        self.a = a
+        self.kw = kw
+
+    def __call__(self, fn, *a, **kw):
+        return fn(*self.a, *a, **dict(self.kw, **kw)) if callable(fn) else fn
+
+
+class RemoteBar:
+    def __init__(self, q, task_id):
+        self._queue = q
+        self.task_id = task_id
+        self.current = 0
+        self.total = 0
+        self.complete = False
+        self._started = False
+        self.kw = {}
+        self.update(0)
+    
+    def __enter__(self, **kw):
+        # ---------------------------------------------------------------------------- #
+        #                                  start task                                  #
+        # ---------------------------------------------------------------------------- #
+        # start the task if it hasn't been started yet
+        if not self._started:
+            self._call('start_task', task_id=self.task_id, **kw)
+            self._started = True
+        return self
+            
+    def __exit__(self, exc_type, exc_value, tb):
+        self.close()
+
+    def close(self):
+        self.update(0, complete=True)
+        # ---------------------------------------------------------------------------- #
+        #                                   stop task                                  #
+        # ---------------------------------------------------------------------------- #
+        if self._started:
+            self._call('stop_task', task_id=self.task_id)
+            self._started = False
+        return
+
+    def __call__(self, iter=None, total=None, **kw):
+        # if the first argument is a string, use it as the description
+        if isinstance(iter, str):
+            iter, kw['description'] = None, iter
+        if iter is None:
+            if total is not None:
+                self.total = kw['total'] = total
+            # if kw or total is not None:
+            #     self.update(0, **kw)
+            # ---------------------------------------------------------------------------- #
+            #                                  start task                                  #
+            # ---------------------------------------------------------------------------- #
+            self.__enter__(**kw)
+            return self
+        
+        # --------------------------------- iterable --------------------------------- #
+
+        self.total = kw['total'] = utils.try_len(iter, total)
+        def _iter():
+            # ---------------------------------------------------------------------------- #
+            #                                  start task                                  #
+            # ---------------------------------------------------------------------------- #
+            self.__enter__(**kw)
+            try:
+                for x in iter:
+                    yield x
+                    # ---------------------------------------------------------------------------- #
+                    #                                    update                                    #
+                    # ---------------------------------------------------------------------------- #
+                    self.update()
+            finally:
+                # ---------------------------------------------------------------------------- #
+                #                                   stop task                                  #
+                # ---------------------------------------------------------------------------- #
+                self.__exit__(*sys.exc_info())
+        return _iter()
+    
+    def _call(self, method, **kw):
+        self._queue.put((self.task_id, method, kw))
+
+    def set(self, value):
+        self.current = value
+        self.update(0)
+        return self
+
+    def update(self, n=1, **kw):
+        if not self._started:
+            self.__enter__(**kw)
+
+        if 'total' in kw:
+            self.total = kw['total']
+
+        # track all keyword arguments
+        self.kw = dict(self.kw, **kw)
+        kw = dict(self.kw)
+
+        # calculate task progress
+        self.current += n
+        total = self.total if self.current or not self.total else (self.current+1)
+        self.complete = total and self.current >= total
+        visible = bool(total and not self.complete or not kw.get('transient', True))
+        kw.setdefault('visible', visible)
+        kw.setdefault('total', total)
+        kw.setdefault('complete', self.complete)
+
+        # ---------------------------------------------------------------------------- #
+        #                                    update                                    #
+        # ---------------------------------------------------------------------------- #
+        self._call('update', completed=self.current, **kw)
+        return self
+
+
+
+class Bar:
+    def __init__(self, desc=None, bytes=False, pbar=None, total=None, **kw):
+        if isinstance(desc, progress.Progress):
+            desc, pbar = None, desc
+        self.pbar = get_pbar(pbar, bytes=bytes)
+        # ---------------------------------------------------------------------------- #
+        #                                   add task                                   #
+        # ---------------------------------------------------------------------------- #
+        self.task_id = self.pbar.add_task(desc, start=total is not None, total=total, **kw)
+        self.pbar.__enter__()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, c,v,t):
+        self.pbar.__exit__(c,v,t)
+
+    def __call__(self, iter, total=None, **kw):
+        with self.pbar:
+            # ---------------------------------------------------------------------------- #
+            #                                 update total                                 #
+            # ---------------------------------------------------------------------------- #
+            # set the initial total
+            self.update(0, total=utils.try_len(iter, total), **kw)
+            # loop through the elements
+            for i, x in enumerate(iter):
+                yield x
+                # ---------------------------------------------------------------------------- #
+                #                                    update                                    #
+                # ---------------------------------------------------------------------------- #
+                self.update()
+
+    def update(self, n=1, total=None, **kw):
+        # start the task if it hasn't been started yet
+        if total is not None:
+            # ---------------------------------------------------------------------------- #
+            #                                  start task                                  #
+            # ---------------------------------------------------------------------------- #
+            task = self.pbar._tasks[self.task_id]
+            if task.start_time is None:
+                self.pbar.start_task(self.task_id)
+                print('starting task', total, task, self.task_id)
+
+        # ---------------------------------------------------------------------------- #
+        #                                    update                                    #
+        # ---------------------------------------------------------------------------- #
+        self.pbar.update(self.task_id, advance=n, total=total, **kw)
+        return self
+
+    def close(self):
+        pass
+
+
+
+# ---------------------------------------------------------------------------- #
+#                                   Examples                                   #
+# ---------------------------------------------------------------------------- #
+
+
+def example_fn(i, pbar):
+    import random
+    from time import sleep
+    for i in pbar(range(i + 1)):
+        sleep(random.random()*2)
+
+def my_work(n, pbar, sleep=0.2):
+    import time
+    for i in pbar(range(n), description=f'counting to {n}'):
+        time.sleep(sleep)
+
+
+def my_other_work(n, pbar, sleep=0.2):
+    import time
+    time.sleep(1)
+    with pbar(description=f'counting to {n}', total=n):
+        for i in range(n):
+            pbar.update(0.5, description=f'Im counting - {n}  ')
+            time.sleep(sleep/2)
+            pbar.update(0.5, description=f'Im counting - {n+0.5}')
+            time.sleep(sleep/2)
+
+
+def example_run():
+    Bars.pool(
+        example_fn, 
+        range(10), 
+        # desc=lambda i: f"wowow {i} :o", 
+        mainbar_kw={'transient': False},
+        subbar_kw={'transient': False},
+        n_workers=5)
+
+    
+
+if __name__ == '__main__':
+    import fire
+    fire.Fire(example_run)

mqdm-0.0.1/mqdm/utils.py

@@ -0,0 +1,93 @@
+import queue
+import threading
+import multiprocessing as mp
+from concurrent.futures import ProcessPoolExecutor, ThreadPoolExecutor
+from rich import progress
+
+
+def try_len(it, default):
+    try:
+        return len(it)
+    except TypeError:
+        return default
+
+
+class ThreadQueue:
+    '''An event queue to respond to events in a separate thread.'''
+    def __init__(self, fn):
+        self._fn = fn
+        self._closed = False
+        self.queue = queue.Queue()
+        self._thread = threading.Thread(target=self._monitor, daemon=True)
+
+    def __enter__(self):
+        self._closed = False
+        self._thread.start()
+        return self
+    
+    def __exit__(self, c,v,t):
+        self._closed = True
+        self._thread.join()
+
+    def _monitor(self):
+        while not self._closed:
+            try:
+                xs = self.queue.get(timeout=0.1)
+                self._fn(*xs)
+            except queue.Empty:
+                continue
+
+class ProcessQueue:
+    '''An event queue to respond to events in a separate process.'''
+    def __init__(self, fn):
+        self._fn = fn
+        self._closed = False
+        self._manager = mp.Manager()
+        self.queue = self._manager.Queue()
+        self._thread = threading.Thread(target=self._monitor, daemon=True)
+
+    def put(self, *args, **kw):
+        self._queue.put(*args, **kw)
+    
+    def get(self, *args, **kw):
+        return self._queue.get(*args, **kw)
+    
+    def __enter__(self):
+        self._closed = False
+        self._manager.__enter__()
+        self._thread.start()
+        return self
+    
+    def __exit__(self, c,v,t):
+        self._closed = True
+        self._thread.join()
+        self._manager.__exit__(c,v,t)
+
+    def _monitor(self):
+        while not self._closed:
+            try:
+                xs = self.queue.get(timeout=0.1)
+                self._fn(*xs)
+            except queue.Empty:
+                continue
+
+POOL_QUEUES = {
+    'thread': ThreadQueue,
+    'process': ProcessQueue,
+}
+
+POOL_EXECUTORS = {
+    'thread': ThreadPoolExecutor,
+    'process': ProcessPoolExecutor,
+}
+
+
+
+class MofNColumn(progress.MofNCompleteColumn):
+    '''A progress column that shows the current vs. total count of items.'''
+    def render(self, task):
+        total = f'{int(task.total):,}' if task.total is not None else "?"
+        return progress.Text(
+            f"{int(task.completed):,d}{self.separator}{total}",
+            style="progress.download",
+        )

mqdm-0.0.1/mqdm.egg-info/PKG-INFO

@@ -0,0 +1,79 @@
+Metadata-Version: 2.1
+Name: mqdm
+Version: 0.0.1
+Description-Content-Type: text/markdown
+Requires-Dist: rich
+
+# mqdm: progress bars for multiprocessing
+Pretty progress bars with `rich`, in your child processes.
+
+## Install
+
+```bash
+pip install mqdm
+```
+
+## Worker progress
+```python
+import mqdm
+import time
+
+def my_work(n, sleep, pbar):
+    for i in pbar(range(n), description=f'counting to {n}'):
+        time.sleep(sleep)
+
+# executes my task in a concurrent futures process pool
+mqdm.pool(
+    my_work,
+    range(1, 10),
+    sleep=1,
+    n_workers=3,
+)
+```
+
+![alt text](static/image.png)
+
+## Less high level please
+Basically, the mechanics are this:
+```python
+# use context manager to start background listener and message queue
+with mqdm.Bars() as pbars:
+    # create progress bars and send them to the remote processes
+    pool.submit(my_work, 1, pbar=pbars.add())
+    pool.submit(my_work, 2, pbar=pbars.add())
+    pool.submit(my_work, 3, pbar=pbars.add())
+
+# your worker function can look like this
+def my_work(n, sleep, pbar):
+    for i in pbar(range(n), description=f'counting to {n}'):
+        time.sleep(sleep)
+
+# or this
+def my_work(n, pbar, sleep=0.2):
+    import time
+    with pbar(description=f'counting to {n}', total=n):
+        for i in range(n):
+            pbar.update(0.5, description=f'Im counting - {n}  ')
+            time.sleep(sleep/2)
+            pbar.update(0.5, description=f'Im counting - {n+0.5}')
+            time.sleep(sleep/2)
+```
+
+And you can use it in a pool like this:
+
+```python
+import mqdm
+from concurrent.futures import ProcessPoolExecutor, as_completed
+
+items = range(1, 10)
+
+with ProcessPoolExecutor(max_workers=n_workers) as pool, mqdm.Bars() as pbars:
+    futures = [
+        pool.submit(my_work, i, pbar=pbars.add())
+        for i in items
+    ]
+    for f in as_completed(futures):
+        print(f.result())
+```
+
+It works by spawning a background thread with a multiprocessing queue. The Bars instance listens for messages from the progress bar proxies in the child processes.

mqdm-0.0.1/mqdm.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+README.md
+setup.py
+mqdm/__init__.py
+mqdm/__main__.py
+mqdm/_alt_dict.py
+mqdm/core.py
+mqdm/utils.py
+mqdm.egg-info/PKG-INFO
+mqdm.egg-info/SOURCES.txt
+mqdm.egg-info/dependency_links.txt
+mqdm.egg-info/requires.txt
+mqdm.egg-info/top_level.txt

mqdm-0.0.1/mqdm.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

mqdm-0.0.1/mqdm.egg-info/requires.txt

@@ -0,0 +1 @@
+rich

mqdm-0.0.1/mqdm.egg-info/top_level.txt

@@ -0,0 +1 @@
+mqdm

mqdm-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

mqdm-0.0.1/setup.py

@@ -0,0 +1,13 @@
+import setuptools
+
+setuptools.setup(
+    name='mqdm',
+    version='0.0.1',
+    description='',
+    long_description=open('README.md').read().strip(),
+    long_description_content_type='text/markdown',
+    packages=setuptools.find_packages(),
+    install_requires=[
+        'rich',
+    ],
+    extras_require={})