Saravanan666/pypi-org huggingface dataset:
Package: programmingexcuses
ProgrammingExcusesTired of making up your own excuses? Get them fromhttp://programmingexcuses.comwith python!Installingpip install programmingexcusesTesting$programmingexcuseManagementinsistedwewouldn'tneedtowasteourtimewritingunittestsUsageIt’s quite simple:fromprogrammingexcusesimportget_excuseprint(get_excuse())And, for convenience:fromprogrammingexcusesimportRandomExcuseErrortry:...except:raiseRandomExcuseError()Also, from a terminal:programmingexcuse
Package: programmingquotes
ProgrammingQuotesOutputs great/funny programming quotes. Best to use with something like fish_greeting.Free software: MIT licenseDocumentation:https://programmingquotes.readthedocs.io.InstallationHave a look here:https://programmingquotes.readthedocs.io/en/latest/installation.htmlHow to useEvery arguement is explained in the docs:https://programmingquotes.readthedocs.io/en/latest/usage.htmlTODOAdding more funny quotes!Add color supportAdd option to edit the quotes(underlining, styling stuff in general)Howto ContributeJust read the CONTRIBUTING.rst to check out how to help me out!CreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.0 (2018-08-11)First release on PyPI.1.0.0 (2018-08-11)Actually working version1.1.0 (2018-08-14)Changed some namesRemoved python2 support2.0.0 (2018-08-16)Added mor quotesAdded language supportAdded option to display the number of arguements
Package: programs-integrator
Programs IntegratorPrograms integrator is a GNU/Linux daemon program, written in python, dynamicly generating "Programs" directory in user's home directory. It scans all XDG_DATA_DIRS periodically and makes symbolic links inside the managed directory to application desktop entries.systemdProgram is running as user systemd service. User session with graphical environment is required to run and manage the program.programs-integrator-ctlIt starts graphical tool managing configuration of the program. The configuration is stored in "~/.config/programs-integrator" directory. It let's you change settings, list destkop entries excluded from linking and provides you with information about XDG_DATA_DIRS.InstallationApplication supports only user install. System wide installation won't work, as this app serves as user-only service.Installing packageInstalling with PIPprograms-integrator is avalable as a PyPI package. It can be downloaded and installed with PIPpipinstall--userprograms-integratorManual installationInstalling program manually is not recommended, as application is not managed by any package manager. Manual installation can be done with "setup.py" script using setuputils package.gitclonehttps://github.com/artudi54/programs-integratorcdprograms-integrator
./setup.pyinstall--single-version-externally-managedRegistering systemd serviceTo start the service it is required to enable systemd user servicesystemctl--userdaemon-reload
systemctl--userenableprograms-integrator.service
systemctl--userstartprograms-integrator.service
Package: programslice
Static analysis tool for python programs to see depending lines of code.NoteThe Python programprogramslicein itself is rather
useless for the end user. Use it with theVim editor plugin. See Installation
for more information.Why Using ProgramsliceThe main benefits of the program are:the possibility to aid tracing the control flow of the programfind variables that are unnecessary to the program stateInstallationRequirements: Python 2.7Installprogramslicefirst in your favourite virtualenv:$ pip install https://github.com/romanofski/programslice/archive/master.zipInstall the Vim plugin by following the instructions on it’sgithub
page.Once the plugin is installed, either make sure that theprogramslicecommand is in your$PATHvariable or you adjust
theg:programslice_cmdvariable in your~/.vimrcto point it
to the executable.Forms of ContributionIf you find this program useful, here is a list of how you can
contribute:buy me a book off mywish listfile issues againstprogramsliceor thevim
pluginhelp to improve the codeDevelopmentThe project is hosted on github:http://romanofski.github.io/programslice/https://github.com/romanofski/programslice.vimBacklogs:https://github.com/romanofski/programslice/issueshttps://github.com/romanofski/programslice.vim/issuesDocumentation is available on:http://programslice.readthedocs.org/ScreenshotLicenseGPLv3CHANGES0.3.1 (2016-12-01)Bugfix release (see issue #25, Kudos to Adam Coddington)0.3 (2015-02-18)command: Added--versionto see command line tool version.New datastructures to improve slicing quality: Result can yield
line numbers, objects, sliced source codevim: Slicing result now highlights variables instead of just linesvim: moved VimL code into separate repository:https://github.com/romanofski/programslice.vim0.2 (2012-11-21)added output formatter to either output filtered lines of code or
just line numbersAllow to slice between functions calls (fixes #5)vim: Allow to toggle slicing markers0.1 (2012-08-22)initial release
Package: program-synthesis
Program SynthesisNEAR Program Synthesis provides a set of models, tools, and datasets for program synthesis tasks.This repository will make it easier for the community to compare and reuse program synthesis algorithms across different
datasets.PrerequisitesPython 3 (>=3.5) is required to run the code. We also recommend usingvirtualenvfor isolated Python environments andpipfor package management. Note, to create a Python 3 environment you need to run:virtualenv .env --python=python3
source .env/bin/activateThe code also assumes thatPyTorchis already installed.Installationpip install program-synthesisDevelopment installationFor development installation you need to clone the repository:git clone https://github.com/nearai/program_synthesis.git
cd program_synthesisInstall program-synthesis in editable mode:pip install -e .Models and datasetsAlgoLispKarelNAPS
Package: program-versions
[![Scrutinizer Code Quality](https://scrutinizer-ci.com/g/dupgit/versions/badges/quality-score.png?b=master)](https://scrutinizer-ci.com/g/dupgit/versions/?branch=master)[![Build Status](https://scrutinizer-ci.com/g/dupgit/versions/badges/build.png?b=master)](https://scrutinizer-ci.com/g/dupgit/versions/build-status/master)[![Code Coverage](https://scrutinizer-ci.com/g/dupgit/versions/badges/coverage.png?b=master)](https://scrutinizer-ci.com/g/dupgit/versions/?branch=master)# DescriptionVersions is an open source (GPL v3) software that checks releases andversions of your favorite programs through RSS or Atom feeds and tellsyou which one has been released since last check.It can check projects from :* github.com* sourceforge.net* freshcode.club* pypi.python.org* savanah.gnu.org* www.freshports.org (FreeBSD packages)* fossies.org* repo.continuum.ioProjects must be added to a YAML file (named by default`~/.config/versions/versions.yaml`). One can use `--file=FILENAME`option to specify an alternative YAML file. The structure of thisYAML file is explained below.Versions uses and produces text files. Those files are cache fileswritten into `~/.local/versions` directory. `*.cache` are cachefiles containing the project list and their associated version (the latest).`*.feed` are information feed cache files containing on each linethe latest parsed post of the feed.# YAML file structure```sitename:url: "https://the.url/to/theglobalfeed"type: listprojects:- list- of- projectsothersitename:url: "https://by.projects.site/{}.atom"type: byprojectprojects:- list- name: ofregex: '([\d.]+)'entry: last checked- projects```There is two types of sites :* 'list': The site has one feed with all projects in it such asfreshcode.club or fossies.org* 'byproject": The site gives access to one feed per project.brackets '{}' represents the name of the project as found inthe 'project' list. Those projects can be listed directly orcan take options. In the later case you have to name theproject and then you can specify either a regex or an entrytype option: regex is used to determine version number andentry is used to determine if versions has to print the latestentry (default behavior) or all entries from the "last checked"time.# InstallationIn pypi the project is named program_versions but is still invokedby the command `versions`.# Usage`./version.py` should be enough to bring you the list of updatedprograms since last run. To verify each day one can use the followingcommand in a persistant terminal (tmux, screen…):watch -n 86400 ./versions.pyOption `-l` or `--list-cache` prints the content of the local cache (ielatest known versions).Option `-f FILENAME` or `--file FILENAME` ease usage of differentYAML configuration files.Option `-d` or `--debug` runs doctests and prints information aboutwhat's going on in the program.# Links of interest* [https://release-monitoring.org/](https://release-monitoring.org/)* [https://wiki.debian.org/debian/watch](https://wiki.debian.org/debian/watch)* [http://semver.org/](http://semver.org/)
Package: programy
Program-YProgram Y is a fully compliant AIML 2.1 chatbot framework written in Python 3. It includes an entire platform for
building your own chat bots using Artificial Intelligence Markup Language, or AIML for short.
For more information about Program-y, its features and its history then check out the Background page.
qNew in 4.0Baseline ReleaseVersion 4.0 is a baseline release to prepare the ground work for a number of major changes in 2020.
It includes the addition of over 2000 unit tests which brings coverage up to 99% of the core system and 96% overall
Along with the unit tests, we have refactored major parts of the code base for ease of use, performance and long term
sustainability. A number of defects have also been corrected due to the addition of the unit testsConfiguration ChangesThe major change is in the configuration file struture. This has been refactored and while a breaking change, its
structural, rather than content and aligns the configuration files with the internal structure of the bot architecture.
The main change is the inclusion of brains and bots contains, so a configuration file now looks likeconsole:bots:bot1:brains:brain1:brain2:bot2:brains:brain3Fixing config files should be as simple as introducing the bots and brains elements and shifting bot and brain elements
a couple of tabs rightEmbeddable ClientsThe third major feature is a complete refresh of the embeddable client, which now provides 3 simple ways to add a bot
to you Python app in as little as 2 lines of codefromprogramy.clients.embed.basicimportEmbeddedBasicBotmy_bot=EmbeddedBasicBot()print("Response =%s"%my_bot.ask_question("Hello"))For more information on this feature, seeEmbedded BotsUnified NamingA number of configuration items have had their names changed so that all variables use underscore '_' as a
space seperator rather than a mix of underscore and dash '-'. The list of changes redefault_useriddefault_getdefault_propertydefault_mapdefault_responsedefault_response_sraiThe convention going forward is that all variables will use underscore '_' as a space seperatorContactThere are a number of ways you can get helpGithubRaise an issue directlySlackTalk live with the Dev TeamGitterTalk with the Dev TeamEmail (See below) although I don't check it every dayTwitter, but more of an announcement channel
Package: progress
Easy progress reporting for PythonBarsThere are 7 progress bars to choose from:BarChargingBarFillingSquaresBarFillingCirclesBarIncrementalBarPixelBarShadyBarTo use them, just callnextto advance andfinishto finish:fromprogress.barimportBarbar=Bar('Processing',max=20)foriinrange(20):# Do some workbar.next()bar.finish()or use any bar of this class as a context manager:fromprogress.barimportBarwithBar('Processing',max=20)asbar:foriinrange(20):# Do some workbar.next()The result will be a bar like the following:Processing |#############                   | 42/100To simplify the common case where the work is done in an iterator, you can
use theitermethod:foriinBar('Processing').iter(it):# Do some workProgress bars are very customizable, you can change their width, their fill
character, their suffix and more:bar=Bar('Loading',fill='@',suffix='%(percent)d%%')This will produce a bar like the following:Loading |@@@@@@@@@@@@@                   | 42%You can use a number of template arguments inmessageandsuffix:NameValueindexcurrent valuemaxmaximum valueremainingmax - indexprogressindex / maxpercentprogress * 100avgsimple moving average time per item (in seconds)elapsedelapsed time in secondselapsed_tdelapsed as a timedelta (useful for printing as a string)etaavg * remainingeta_tdeta as a timedelta (useful for printing as a string)Instead of passing all configuration options on instatiation, you can create
your custom subclass:classFancyBar(Bar):message='Loading'fill='*'suffix='%(percent).1f%%-%(eta)ds'You can also override any of the arguments or create your own:classSlowBar(Bar):suffix='%(remaining_hours)dhours remaining'@propertydefremaining_hours(self):returnself.eta//3600SpinnersFor actions with an unknown number of steps you can use a spinner:fromprogress.spinnerimportSpinnerspinner=Spinner('Loading ')whilestate!='FINISHED':# Do some workspinner.next()There are 5 predefined spinners:SpinnerPieSpinnerMoonSpinnerLineSpinnerPixelSpinnerInstallationDownload from PyPipipinstallprogressOtherThere are a number of other classes available too, please check the source or
subclass one of them to create your own.Licenseprogress is licensed under ISC
Package: progress2
Allows for easy creation of progress-bars and text.progresshas been tested with Python 2.6, 2.7, 3.2, 3.3 and PyPy, and as of now requires at least Python 2.6Installation:Note:PyPI already contains aprogressentry, so this module is located
atprogress2.You can install viapip:pip install progress2Alternatively, download the source files and run the following command from the
download directory:python setup.py installUsage:Creating aProgressBar:>>> import progress
>>> bar = progress.ProgressBar("[{progress}] {percentage:.2f}% ({minutes}:{seconds})", width=30)
>>> bar.show()
[                              ] 0.00% (0:0)>>>
>>> bar.update(26)
>>> bar.show()
[======>                       ] 26.00% (0:0)>>>
>>>Alternatively, you can use theautoupdatemethod:>>> bar.autoupdate(42)
[===================>          ] 68.00% (0:45)>>>
>>>Creating aProgressText:>>> text = progress.ProgressText("Searching: {progress}", "|/-\\", autoreset=True)
>>> text.show()
|>>>
>>> text.update(); text.show()
/>>>
>>> text.update(); text.show()
->>>
>>> text.update(); text.show()
\>>>You can supply custom args and kwargs toshowandautoupdate:>>> bar = progress.ProgressBar("[{progress}] {key} {},{},{}")
>>> d = dict(key=33)
>>> l = range(3)
>>> bar.update(50)
>>> bar.show(*l, **d)
[=========>          ] 33 0,1,2>>>
>>> bar.autoupdate(25, *l, **d)
[==============>     ] 33 0,1,2>>>
>>>Refer to theexamples/directory for more examples. There are also examples
of how to useprogresswith thethreadingmodule.Implementation Notes:Since most terminals cannot clear their output buffers across newlines or carriage returns,progressdoes not work if you insert them, e.g.progress.ProgressBar("{progress}\n{percentage}")will not be cleared from the terminal.
Package: progressbar
Text progress bar library for Python.A text progress bar is typically used to display the progress of a longrunning operation, providing a visual cue that processing is underway.The ProgressBar class manages the current progress, and the format of the lineis given by a number of widgets. A widget is an object that may displaydifferently depending on the state of the progress bar. There are three typesof widgets:- a string, which always shows itself- a ProgressBarWidget, which may return a different value every time itsupdate method is called- a ProgressBarWidgetHFill, which is like ProgressBarWidget, except itexpands to fill the remaining width of the line.The progressbar module is very easy to use, yet very powerful. It will alsoautomatically enable features like auto-resizing when the system supports it.
Package: progress_bar
A simple way of providing an informative and clean progress bar on the
terminal that:knows a terminal’s current widthhas a headerworksout of the boxwhenreading filesalways shows a relative percentageworks for Python 2.6+ and 3.0+Synopsisfile.txt: [========================79.3%===============>          ]Installationpip install progress_barUsageGenerally, to create any kind of progress bar with a default “size”
of 100 arbitrary units:fromprogress_barimportInitBarpbar=InitBar()pbar(10)# update % to 10%pbar(20)# update % to 20%pbar(15)# simulate a Microsoft progress barpbar(100)# donedelpbar# write the newlineTo easily create a progress bar for reporting (reading) progress in a
filehandle that cantell()its offset:fromprogress_barimportInitBarForInfilepbar=InitBarForInfile("./README.rst")instream=open("./README.rst")forlineiniter(instream.readline,''):pbar(instream.tell())delpbarWith those default arguments, the bar will be as wide as the terminal window.
However, it will have two whitespaces on both sides of the bar to achieve a
visually more appealing display. Terminal window width is defined bytermiosusingfcntl, both from the standard library. The progress bar
will be prefixed with thebasenameof the input file (“file.txt” in the
above example).Version History8: README improvements thanks to Marc Abramowitz, @msabramo7: fixed error with InitBar when no title is given6: removed remaining function annotations (Py2.7; thanks to Adam Knight
@ahknight)5: fixed a few rough edges from the last update4: made the bars with titles one-liners and fixed functions names
(FunctionNames, ClassNames, methodNames, variable_names) because the PEP8
convention of using “snake_case” for nearly all names makes no sense to me
what-so-ever…
Finally, fixed the documentation to reflect Sphinx standards.3: fixed the version number so PEP426 issues are avoided (pip install now
works…)2: updated the readme/usage section to reflect tell() issues with Python31: initial releaseCopyright and LicenseLicense:Apache License v2.
Copyright 2007-2014 Florian Leitner. All rights reserved.
Package: progressbar231
Text progress bar library for Python.A text progress bar is typically used to display the progress of a longrunning operation, providing a visual cue that processing is underway.The ProgressBar class manages the current progress, and the format of the lineis given by a number of widgets. A widget is an object that may displaydifferently depending on the state of the progress bar. There are three typesof widgets:- a string, which always shows itself- a ProgressBarWidget, which may return a different value every time itsupdate method is called- a ProgressBarWidgetHFill, which is like ProgressBarWidget, except itexpands to fill the remaining width of the line.The progressbar module is very easy to use, yet very powerful. It will alsoautomatically enable features like auto-resizing when the system supports it.
Package: progressbar33
Text progress bar library for Python.A text progress bar is typically used to display the progress of a longrunning operation, providing a visual cue that processing is underway.The ProgressBar class manages the current progress, and the format of the lineis given by a number of widgets. A widget is an object that may displaydifferently depending on the state of the progress bar. There are three typesof widgets:- a string, which always shows itself- a ProgressBarWidget, which may return a different value every time itsupdate method is called- a ProgressBarWidgetHFill, which is like ProgressBarWidget, except itexpands to fill the remaining width of the line.The progressbar module is very easy to use, yet very powerful. It will alsoautomatically enable features like auto-resizing when the system supports it.
Package: progressbar-easy
Progress BarThis is a simple progress bar that allows for easy use to display progress.FeaturesTimer to estimate time remainingTimer adjusts to ratesLearning rate can be changedChoice of length of barChoice of character bar is made ofOption for item count or percentage completed (or both)Option for method of computing completion time.InstallationInstall with pip:pip install progressbar_easyUsageImported withfrom progressbar import ProgressBarInitialize object withbar = ProgressBar(number of iterations)Use in loop. Inside loop at the end, putbar.update(K)orbar += Kwhere K is the number of iterations completed since last update.
Preferbar.update(K)if you want to update the bar every iteration.Defaults to use the Bellman equation to estimate time remaining.
Adduse_average=(True, N)arguement to use the average of the last N iterations instead of Bellman equation.Example:bar = ProgressBar(range(2000), use_average=(True, 420)):OrUse as an iterator objectforiinProgressBar(range(100),lr=.0001):...Change Log1.1.1 (4/21/2022)Added ability to use generators1.1.0 (10/22/2021)Added ability to use the average time to estimate future time.Added docstrings.Improved performance when using "+=" opperator.Increased efficiency of object.1.0.4.4 (6/11/2021)Bug Fixes1.0.4 (6/11/2021)Added "iter" attribute to allow for more effective use in loops.Example:foriinProgressBar(range(10)):...1.0.3.3 (6/8/2021)Bug Fixes1.0.3 (6/2/2021)Added ability to adjust "learning rate" for the rate of itemsMade "completed" arguement for "update" method default to None, which just means increment by one1.0.2.2 (5/7/2021)Bug Fixes1.0.2 (5/6/2021)Added support for updating multiple items (timer would update as one item)Added ability to adjust the starting rate of items for the timerFixed bugs using "+=" (iadd) (caused timer to not work)1.0.1.2 (5/6/2021)Bug Fixes1.0.0 (5/6/2021)First Release
Package: progressbar-ipython
Note: This is a just a packaged version of https://github.com/fnoble/python-progressbar.Text progress bar library for Python.A text progress bar is typically used to display the progress of a longrunning operation, providing a visual cue that processing is underway.The ProgressBar class manages the current progress, and the format of the lineis given by a number of widgets. A widget is an object that may displaydifferently depending on the state of the progress bar. There are three typesof widgets:- a string, which always shows itself- a ProgressBarWidget, which may return a different value every time itsupdate method is called- a ProgressBarWidgetHFill, which is like ProgressBarWidget, except itexpands to fill the remaining width of the line.The progressbar module is very easy to use, yet very powerful. It will alsoautomatically enable features like auto-resizing when the system supports it.
Package: progressbar-latest
Text progress bar library for Python.A text progress bar is typically used to display the progress of a longrunning operation, providing a visual cue that processing is underway.The ProgressBar class manages the current progress, and the format of the lineis given by a number of widgets. A widget is an object that may displaydifferently depending on the state of the progress bar. There are three typesof widgets:- a string, which always shows itself- a ProgressBarWidget, which may return a different value every time itsupdate method is called- a ProgressBarWidgetHFill, which is like ProgressBarWidget, except itexpands to fill the remaining width of the line.The progressbar module is very easy to use, yet very powerful. It will alsoautomatically enable features like auto-resizing when the system supports it.