https://github.com/marscher/progress_reporter

Progress reporting for Python/Jupyter
https://github.com/marscher/progress_reporter

console jupyter-notebook jupyter-notebooks progress-bar progressbar python

Last synced: about 1 month ago
JSON representation

Progress reporting for Python/Jupyter

• Host: GitHub
• URL: https://github.com/marscher/progress_reporter
• Owner: marscher
• License: other
• Created: 2016-08-08T12:44:34.000Z (over 8 years ago)
• Default Branch: master
• Last Pushed: 2018-12-03T11:48:50.000Z (almost 6 years ago)
• Last Synced: 2024-10-01T16:18:54.087Z (about 2 months ago)
• Topics: console, jupyter-notebook, jupyter-notebooks, progress-bar, progressbar, python
• Language: Python
• Homepage:
• Size: 124 KB
• Stars: 2
• Watchers: 3
• Forks: 1
• Open Issues: 1
• Metadata Files:
  • Readme: README.rst
  • License: LICENSE.rst

Awesome Lists containing this project

README

        
Progress Reporter

=================

This library provides a simple interface to register different workloads and

visualize their progress with either a plain text progress bar or a jupyter

widget, depending on the current environment.

It optionally depends on Jupyter widgets to draw nice progress bars in the interactive

Jupyter notebook environment.

Installation

------------

with pip::

   pip install progress_reporter

If you use IPython/Jupyter, you are strongly encourage to also install the jupyter widgets::

    pip install ipywidgets

Examples

--------

Image you have a class doing some heavy calculations, which are split into several

jobs/tasks/threads etc.

In order to visualize the progress, one just needs to derive the worker class from

progress_reporter.ProgressReporter and invoke the **_progress_register** method

to tell the reporter how many pieces of work have to be done. Then the reporter

is instructed by **_progress_update(n)** how many of pieces of work have been

dispatched.

Note that these are "private" to use this class as a mixin class and not polute the

public interface.

.. code:: python

    from progress_reporter import ProgressReporter

    import time

    class ExampleWorker(ProgressReporter):

        def __init__(self, n_jobs=100):

            self.n_jobs = n_jobs

            """ register the amount of work with the given description """

            self._progress_register(n_jobs, description='Dispatching jobs')

        def work(self):

            """ do some fake work (sleep) and update the progress via the reporter

            """

            for job in (lambda: time.sleep(0.1) for _ in range(self.n_jobs)):

                job()

                # indicate we've finished one job, to update the progress bar

                self._progress_update(1)

It also supports multi-stage sequential work loads by setting the parameter **stage**.

This is just the dictionary key to the underlying process:

.. code:: python

    class MultiStageWorker(ProgressReporter):

        def __init__(self, n_jobs_init, n_jobs):

            self.n_jobs_init = n_jobs_init

            self.n_jobs = n_jobs

            """ register an expensive initialization routine """

            self._progress_register(self.n_jobs_init, description='initializing', stage=0)

            """ register the main computation """

            self._progress_register(self.n_jobs, description='main computation', stage=1)

        def work(self):

            """ do the initialization """

            for job in (lambda: time.sleep(0.1) for _ in range(self.n_jobs_init)):

                job()

                self._progress_update(1, stage=0)

            """ perform the next stage of the algorithm """

            for job in (lambda: time.sleep(0.2) for _ in range(self.n_jobs)):

                job()

                self._progress_update(1, stage=1)

Since version 2.0 there is also a version of the this class suitable for compositions.

.. code:: python

    from progress_reporter import ProgressReporter_

    class Estimator(object):

        def fit(self, X, y=None):

            pg = ProgressReporter_()

            pg.register(100, description='work')

            with pg.context(): # ensure progress bars are closed if an exception occurs.

                pg.update(50)

                # ...