Saravanan666/pypi-org huggingface dataset:
Package: progressbars
ProgressBarsA python package to display progress of loops to the user.InstallationThis package can be installed using pip.pip install progressbarsUsageThe class you'll be using is called the ProgressBar class, here is an example of how to use it.fromprogressbarsimportProgressBar,widgetsdefisPrime(n:int)->bool:"A very slow algorithm to calculate if a given number is prime."foriinrange(2,n):ifn%i==0:returnFalsereturnn>1# Create an empty list to store the primes we findprimes=[]# Create a colorless progress bar that uses all the default widgetsbar=ProgressBar([widgets.Percentage,widgets.IterationSpeed,widgets.Counter,widgets.ElapsedTime,widgets.RemainingTime],color=None)# Loop through all numbers from 0-30_000foriinbar(range(30_000)):ifisPrime(i):# If the current number is prime, append it to the primes listprimes.append(i)# Print how many primes we foundprint("\nFound",len(primes),"primes!")
Package: progressbar-simple
Another simple progress bar to show the progress of a for loop iteration process
in python working also for multiprocessing.The progress bar has the following look:[###########            ]InstallationInstallation should be straight forward:pip install progressbar-simpleFrom SourceAlternativly, to get the most current version, the code can be installed from github as follows:git clone git@github.com:vgeck/progressBar.git
cd progressBar
pip install -r requirements.txt
python setupy.py installThe last command might need sudo prefix, depending on your python setup.UsageAssume a for loop with 100 iterations calling the function foo:for i in range(100):
    foo()To monitor the process of the for loop we consider a progress bar with 10
elements for the 100 iterations.
The progress bar is initialized with:from progressbarsimple import ProgressBar

myProgressBar = ProgressBar(nElements = 10, nIterations = 100)The progressBar is updated within the for loop with the iterator i:myProgressBar.progress(i)The full code for the examples is:from progressbarsimple import ProgressBar

myProgressBar = ProgressBar(nElements = 10, nIterations = 100)
for i in range(100):
    foo()
    myProgressBar.progress(i)For more information on how to use the progressbarsimple see the 2 example files.
Package: progress-checkpoint
Progress-checkpointHelpers for reporting a progress from functions by the means of callbacks.ExamplesTrivialfromprogress_checkpointimportdummy_checkpoint,with_progressdeftime_consuming_operation(checkpoint=dummy_checkpoint):foriinwith_progress(range(10),checkpoint):time.sleep(0.2)time_consuming_operation(lambdap,_:print("{:.0f}%%ready".format(p*100)))Subcheckpointsfromprogress_checkpointimportdummy_checkpoint,with_progress,with_progress_subdeftime_consuming_operation(checkpoint=dummy_checkpoint):for_inwith_progress(range(10),checkpoint):sleep(0.1)defcompound_time_consuming_operation(checkpoint=dummy_checkpoint):for_,subcheckpointinwith_progress_sub(range(2),checkpoint):time_consuming_operation(subcheckpoint)compound_time_consuming_operation(lambdap,_:print("{:.0f}% ready".format(p*100)))Subcheckpoints with different weightsdeftime_consuming_operation(num,checkpoint=dummy_checkpoint):for_inwith_progress(range(num),checkpoint):sleep(0.1)defcompound_time_consuming_operation(checkpoint=dummy_checkpoint):counts=[1,3,7]forcnt,subcheckpointinwith_progress_sub(counts,checkpoint,weights=counts):time_consuming_operation(cnt,subcheckpoint)compound_time_consuming_operation(lambdap,_:print("{:.0f}% ready".format(p*100)))Reporting using progresssbar packagefromprogress_checkpoint.consoleimportProgressbarCheckpointdeftime_consuming_operation(checkpoint=dummy_checkpoint):for_inwith_progress(range(10),checkpoint):sleep(0.1)time_consuming_operation(ProgressbarCheckpoint())
Package: progressindicator
IntroductionThis Package provides ProgressIndicator class for easily providing
visual cue about the progress of a task underway. Using the concept
of components and providers, One can easily customize the look and
feel of the Progress Indicator.Features include:Full customization of the look and feel of the Progress IndicatorAlthough by default a large number of components are provided in the package,
you can easily create new ones.Installationpip install progressindicatorLinksDocumentationSourceAPI ReferenceLicenseThis project is licensed under the MIT License - see theLICENSE.txtfile for details.
Package: progression
An advanced progress bar in ASCII art which featuresspeed and estimated time of arrivalmultiple barsauto adjustment to the available terminal widthIPython notebook html output availableIf you have one or more time consuming processes running and want to
keep track of the current state, get an estimate on when the process
is going to finish or if you just like statistics this package does the job.It is pure python. It runs with python version 2 and 3.
If you have IPython (and ipywidgets) installed and enable the widgets extension
an html variant of the ASCII art progress is available.Further reading (install, examples and co) in the docs
Package: progressive
Alpha Warning! Until `1.0.0`, `progressive` will likely be going under some kind of radical API revision every minor release; just a forewarning.#progressive[![Build Status](https://travis-ci.org/hfaran/progressive.svg?branch=master)](https://travis-ci.org/hfaran/progressive?branch=master)
[![Coverage Status](https://coveralls.io/repos/hfaran/progressive/badge.svg?branch=master)](https://coveralls.io/r/hfaran/progressive?branch=master)
[![PyPI version](https://badge.fury.io/py/progressive.svg)](http://badge.fury.io/py/progressive)
[![Documentation Status](https://readthedocs.org/projects/progressive/badge/?version=latest)](https://readthedocs.org/projects/progressive/?badge=latest)
[![Stories in Ready](https://badge.waffle.io/hfaran/progressive.png?label=Ready)](http://waffle.io/hfaran/progressive)Colorful progress bars and trees for your terminal, powered by [blessings](https://github.com/erikrose/blessings). Compatible with both Python 2 and 3.## Introductionprogressivelets you view progress of complex workflows as well as simple ones:[![Tree Progress View](https://raw.githubusercontent.com/hfaran/progressive/master/example.gif)](https://github.com/hfaran/progressive)## InstallationFor the possibly stable` pip install progressive `For the latest and greatest` git clonehttps://github.com/hfaran/progressive.gitcd progressive python setup.py install `## Getting StartedThere is preliminary documentation is available at [readthedocs](http://progressive.readthedocs.org/) but more detailed documentation is coming soon on completion of the 1.0 API, but in the meantime check out the [examples](https://github.com/hfaran/progressive/blob/master/progressive/examples.py).progressivesupports graceful fallback modes for terminals without colors, [but you really should upgrade your terminal to 256 colors](http://pastelinux.wordpress.com/2010/12/01/upgrading-linux-terminal-to-256-colors/) to make full use ofprogressive.
Package: progressiveai
ProgressiveAI Python LibraryWelcome to the official ProgressiveAI Python Library! This library allows you to easily connect with ProgressiveAI's powerful AI Models and integrate them into your Python projects.InstallationYou can install the library using pip:pipinstallprogressiveaiGetting Started# Call the official ProgressiveAI Python Library# From the "progressiveai" library, import the "Chat" class to create a connection with ProgressiveAI's AI ModelsfromprogressiveaiimportChat# Create a chatchat=Chat(# Input your ProgressiveAI API Keyapi_key="keyid-xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",text="Hello, AI!",# Enter a question of your choicemodel="wispar"# Mention the AI Model you want to use. Currently, we offer "WISPAR Lite", and soon "WISPAR" will also be available.)# Get AI response# Fetch a response from the AI Model; if not included, the request will not be submitted and processedresponse=chat.get_response()print(response)# Print the AI's responseMake sure to replace"keyid-xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"with your actual ProgressiveAI API key.Help and SupportIf you need help or have any questions, feel free to reach out to us:ProgressiveAI Support: Visit our support platform for assistance.ProgressiveAI Documentation: Check out our documentation for detailed information and guides.GitHub Repository: Report issues or contribute to the development on GitHub.We're here to help you make the most of ProgressiveAI's AI capabilities!
Package: progressive-cmd
Executes a cmd while interpreting its completion percentage.The completion percentage of the cmd is stored in
an attributepercentageand the user can obtain percentage
increments by executingincrementor by passing
acallbackwhen initializing.This class is useful to use within a child thread, so the child thread
executes the cmd, blocking and updating the increment and percentage
to the parent thread, that can do other things in the meantime.ExamplesBadblocksdefmy_callback(increment,total):print(f'Update: +{increment}% /{total}%.')defchild_thread():progress=ProgressiveCmd('badblocks','-st','random','-w','dev/sda1',digits=ProgressiveCmd.DECIMALS,decimal_digits=2,read=35,callback=my_callback)progress.run()t=threading.Thread(target=child_thread)t.start()Shreddefmy_callback(increment,total):print(f'Update: +{increment}/{total}%.')defchild_thread():progress=ProgressiveCmd('shred','-vn 1','dev/sda1',callback=my_callback)progress.run()t=threading.Thread(target=child_thread)t.start()fsarchiverdefmy_callback(increment,total):print(f'Update: +{increment}/{total}%.')defchild_thread():progress=ProgressiveCmd('fsarchiver','restfs','-v','foo/bar/','id=0,dest=dev/sda1',callback=my_callback)progress.run()t=threading.Thread(target=child_thread)t.start()Using tqdmYou can use theincrementvalue to updatetqdm:t=tqdm(total=100)defmy_callback(increment,total):t.update(increment)defchild_thread():progress=ProgressiveCmd('a-program',callback=my_callback)progress.run()thread=threading.Thread(target=child_thread)thread.start()Testinggit clonethis project.Executepython setup.py testin the project folder.ContributingIs a missing or wrong code? Say it in the issues! Feel free to contribute.
Package: progressive-mypy
progressive-mypyThis is a package made for improve type annotation coverage on big repositories.What this package does:dump: Generates alistof files that are currently not type annotated.check: Given an input of files:If a file is in thelist, and is fully type annotated, it will be removed from thelist.If a file is in thelist, and isnotfully annotated, it will be ignored.If a file isnotin thelist, and is fully annotated, it will be ignored.If a file isnotin thelist, and isnotfully annotated, it will raise errors.Installationpipinstallprogressive-mypyUsageDumpLicenseThis project is licensed under the terms of the MIT license.
Package: progressive-overload
Progressive OverloadCalculates the next workout sets for progressive overload given previous
ones.Installing$pipinstallprogressive-overloadUsingfromprogressive_overloadimport*progressive_overload([(8,10),(8,10),(8,10)],# weight x reps for each setmax_reps=12,# maximum number of reps per set in the outputweight_increment=2,# the amount the weight can increase by)guess_max_reps([12,10,10])# the already performed repsguess_weight_increment([Decimal(10),Decimal(8),Decimal(8)])# the already performed weightsRunning$progressive-overload--max-reps10--increment2'8 x 10''8 x 10''8 x 10'Testing$pipenvinstall--dev
$pipenvrunpythonsetup.pytest
Package: progress-keeper
progress-keeperThis module is for keeping track of progress.  It's useful for idempotent multi-part processes.  If a process is interrupted or quits unexpectantly this can be used to keep track of the progress so that the next time the process is run, it can pick up where it left off.Installpip install progress_keeperUsageTo create a progress object you need to define the following args:fp (str): file path of file to save progress intovars (list(str), optional): list of variables to include in progress file and keep track of. If undefined then it will assume only one var and use the default name - 'last_index_processed'.When you create a progress object the module will check if the 'fp' exists and either use the values in that file if it does exist or create a new file (and set progress values to 0) if it does not exist.fp = 'tmp/my-progress.cfg'
vars = ['process_abc','sub_process_a']

# create progress object
progress = Progress(fp, vars)

# increment progress 'var' by 1
progress.increment('process_abc')

# get value of progress 'var'
progress.values['progress_abc']

# reset value of progress
progress.reset('process_abc')

# delete progress file
progress.delete()
Package: progresslogger
Progress Loggerpip install progressloggerProgress Logger is a simple, lightweight logger for your Python loops. Quickly see the current status of long loops, its estimated time remaining, and more useful stats!Simple UsageProgress Logger works great right out of the box, with no customization required. When imported, it will overwrite the built-inenumerate()function. That's it!from progresslogger import *

my_list = ['a', 'b', 'c', 'd', 'e']

for i, letter in enumerate(my_list):
    execute_code(letter)Output:>>> Starting progress logger for 5 items.
>>> Iteration 1 of 5 (20.0%) complete. Approximately 4 seconds remaining.
>>> Iteration 2 of 5 (40.0%) complete. Approximately 3 seconds remaining.
>>> ...
>>> Loop complete! Average iteration time: 1.0 secondsAdvanced UsageYou may customize your logger and pass it directly to theenumerate()function:my_logger = ProgressLogger(show_next_value=True)
for i, letter in enumerate(my_list, my_logger):
    execute_code(letter)Output:>>> Starting progress logger for 5 items. Next value: "a".
>>> Iteration 1 of 5 (20.0%) complete. Approximately 4 seconds remaining. Next value: "b".
>>> Iteration 2 of 5 (40.0%) complete. Approximately 3 seconds remaining. Next value: "c".
>>> ...If you'd like to retain the built-inenumerate()function, or you'd like to have both, you can usefrom progresslogger import ProgressLoggerorimport progressloggerand useprogresslogger.enumerate(...).You may wish to insert the log in the middle of a loop, or otherwise implement your logger yourself. Simply initializeProgressLoggerbefore the loop, and callmy_logger.log()once each loop:my_logger = ProgressLogger(my_list) # be sure to pass your collection when initializing your logger
for letter in my_list:
    my_logger.log()
    execute_code(letter)
Package: progress_meter
This provides a very simple progress bar for long running tasks.The design is somewhat similar toEasyGUI,
allowing simple scripts to be GUI-fied without being refactored into callbacks
and an event loop. It can naturally be used as an addition to the tools in
EasyGUI. The interface can’t be quite as simple, but hopefully it’s only a
little more complex.progress_meter is based onthis codeby Michael Lange.The high-level interface looks like this:from progress_meter import withprogress

@withprogress(300, color="green")
def demo(foo, bar=None):
    for i in range(300):
        # Do one (or a few) steps of processing, then...
        yield i

demo()You can use exceptions to see if the user cancelled the process before it
completed:try:
    demo()
except UserCancelled:
    print("Cancelled")
else:
    print("Completed")There’s also a lower-level interface in which you instantiate the window directly:from progress_meter import MeterWindow

def _demostep(meter, value):
    meter.set(value)
    if value < 1.0:
        value = value + 0.005
        meter.after(50, lambda: _demostep(meter, value))
    else:
        meter.set(value, 'Demo successfully finished')

def demo():
    root = MeterWindow(className='meter demo')
    root.meter.set(0.0, 'Starting demo...')
    root.after(1000, lambda: _demostep(root.meter, 0.0))
    root.mainloop()To use the progress bar alone in a more complete GUI, you can use theMeterclass from this module (which subclassestkinter.Frame).
Package: progressor
A visually appealing progress bar for long lasting computations. It also
computes the remaining estimated time for the task by ad-hoc learning of
the completion so far. For this reasonscikit-learnandnumpyare required.You can installprogressorviapipinstallprogressorand import it in python using:importprogressorCompute a task as follows:from__future__importprint_functionimporttimeres=[0]deftask(elem):time.sleep(0.01)res[0]+=elemprogressor.progress_list(range(1000),task,prefix="sleep list")print(res[0])or in a range:deftask_range(cur_ix,length):task(cur_ix)progressor.progress(0,1000,task_range,prefix="sleep range")print(res[0])or while reading a file:withprogressor.IOWrapper(open(datafile,"r"),prefix="loading data",out=sys.stdout)asf_in:data=f_in.read()The output looks roughly like this:sleep list: |████████████▌       |  62.30% (T   7.492s ETA   6.791s)If no estimate of the progress towards completion can be made use:defrepeat(num):whileTrue:yieldnumprogressor.progress_indef(repeat(1),task,prefix="sleep indefinitely")which produces output like this:sleep indefinitely: /
Package: 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.Installationwith pip:pip install progress_reporterIf you use IPython/Jupyter, you are strongly encourage to also install the jupyter widgets:pip install ipywidgetsExamplesImage 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_registermethod
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.fromprogress_reporterimportProgressReporterimporttimeclassExampleWorker(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')defwork(self):""" do some fake work (sleep) and update the progress via the reporter
        """forjobin(lambda:time.sleep(0.1)for_inrange(self.n_jobs)):job()# indicate we've finished one job, to update the progress barself._progress_update(1)It also supports multi-stage sequential work loads by setting the parameterstage.
This is just the dictionary key to the underlying process:classMultiStageWorker(ProgressReporter):def__init__(self,n_jobs_init,n_jobs):self.n_jobs_init=n_jobs_initself.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)defwork(self):""" do the initialization """forjobin(lambda:time.sleep(0.1)for_inrange(self.n_jobs_init)):job()self._progress_update(1,stage=0)""" perform the next stage of the algorithm """forjobin(lambda:time.sleep(0.2)for_inrange(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.fromprogress_reporterimportProgressReporter_classEstimator(object):deffit(self,X,y=None):pg=ProgressReporter_()pg.register(100,description='work')withpg.context():# ensure progress bars are closed if an exception occurs.pg.update(50)# ...
Package: progress-runner
Progress Runnerprogress_runneris an ncurses display for batch-processing.Installation:$pip3installprogress_runnerUsage from shell:Create a python file with aworkfunction in it. Ex:asyncdefwork(param):returnTrueThe function must be async, take one parameter, and return bool.$progress_runnertest.pytest_params.txtWhen using the shell command, the params file will be parsed as newline-delimited-text, and each line will be passed into your customworkfunction.Usage in python:importprogress_runnerasyncdefwork(param):returnTrueparams=[(1,2,3),(4,5,6),(7,8,9)]progress_runner.run(work,params,nthreads=5)# or:p=progress_runner.ProgressRunner(work,params,nthreads=5)p.run()
Package: progress_sa
A SQLAlchemy dialect that can be used to read OpenEdge 10 (akaProgress) databases over ODBC.This dialect was written to do some simple reporting only. It has
not been tested with write operations.The Progress ODBC drivers come from DataDirect and return UTF-8
by default or UCS-2. To work properly with these drivers, pyodbc
needs to be compiled with the -fshort-wchar option and a small
patch (included in the source distribution) that asks the DataDirect
ODBC driver for UCS-2.
Package: progress-table
Note: version 1.0 introduced new features and changes of default behaviour.The old version is still available asprogress_table.ProgressTableV0.New features include:Custom table styles are supportedColor customization on row level is supportedAdding columns automatically, without callingadd_columnContinuous progress bar when iterator length is unknownPandas and numpy are only optional dependenciesOther minor changesProgress TableLightweight utility to display the progress of your process as a pretty table in the command line.Designed to monitor machine learning experiments, but can be used for anything.
Allows you to quickly see what is going on.
Increases readability and cuteness of your command line logging.FeaturesDisplaying pretty table in the terminalProgress bar embedded into the tableExporting data as lists, numpy arrays or pandas dataframesBuilt-in basic data aggregation:sumandmeanPurposeChange this:Into this:ExampleClick here for examples of integration with PyTorch and Keras:integrations.md.importrandomimportsysimporttimefromprogress_tableimportProgressTable# Create table object:table=ProgressTable()# Or customize its settings:table=ProgressTable(columns=["step"],refresh_rate=10,num_decimal_places=4,default_column_width=None,default_column_color=None,default_column_alignment=None,default_column_aggregate=None,default_row_color=None,embedded_progress_bar=True,pbar_show_throughput=True,pbar_show_progress=False,print_row_on_update=True,reprint_header_every_n_rows=30,custom_format=None,table_style="round",file=sys.stdout,)# You can define the columns at the beginningtable.add_column("x",width=3)table.add_column("x root",color="red")table.add_column("random average",color=["bright","red"],aggregate="mean")forstepinrange(10):x=random.randint(0,200)# There are two ways to add new values:table["x"]=xtable["step"]=step# Second:table.update("x root",x**0.5)table.update("x squared",x**2)# Display the progress bar by wrapping the iteratorfor_intable(10):# -> Equivalent to `table(range(10))`# You can use weights for aggregated valuestable.update("random average",random.random(),weight=1)time.sleep(0.1)# Go to the next row when you're readytable.next_row()# Close the table when it's readytable.close()# Export your datadata=table.to_list()pandas_df=table.to_df()# Requires pandas to be installednp_array=table.to_numpy()# Requires numpy to be installedInstallationInstall Progress Table easily with pip:pip install progress-tableLinksSee on GitHubSee on PyPIAlternativesProgress bars: great for tracking progress, but they do not provide pretty CLI data displaytqdmKeras.utils.ProgbarLibraries displaying data: great for presenting data, but they lack the tracking progress elementtabulatetexttable