Saravanan666/pypi-org huggingface dataset:
Package: bumbov
Bumbov: Python Web Framework built for learning purposesBumbov is a Python web framework built for learning purposes.It's a WSGI framework and can be used with any WSGI application server such as Gunicorn.InstallationpipinstallbumbovHow to use itBasic usage:frombumbov.apiimportAPIapp=API()@app.route("/home")defhome(request,response):response.text="Hello from the HOME page"@app.route("/hello/{name}")defgreeting(request,response,name):response.text=f"Hello,{name}"@app.route("/book")classBooksResource:defget(self,req,resp):resp.text="Books Page"defpost(self,req,resp):resp.text="Endpoint to create a book"@app.route("/template")deftemplate_handler(req,resp):resp.body=app.template("index.html",context={"name":"Bumbov","title":"Best Framework"}).encode()Unit TestsThe recommended way of writing unit tests is withpytest. There are two built in fixtures
that you may want to use when writing unit tests with Bumbov. The first one isappwhich is an instance of the mainAPIclass:deftest_route_overlap_throws_exception(app):@app.route("/")defhome(req,resp):resp.text="Welcome Home."withpytest.raises(AssertionError):@app.route("/")defhome2(req,resp):resp.text="Welcome Home2."The other one isclientthat you can use to send HTTP requests to your handlers. It is based on the famousrequestsand it should feel very familiar:deftest_parameterized_route(app,client):@app.route("/{name}")defhello(req,resp,name):resp.text=f"hey{name}"assertclient.get("http://testserver/matthew").text=="hey matthew"TemplatesThe default folder for templates istemplates. You can change it when initializing the mainAPI()class:app=API(templates_dir="templates_dir_name")Then you can use HTML files in that folder like so in a handler:@app.route("/show/template")defhandler_with_template(req,resp):resp.html=app.template("example.html",context={"title":"Awesome Framework","body":"welcome to the future!"})Static FilesJust like templates, the default folder for static files isstaticand you can override it:app=API(static_dir="static_dir_name")Then you can use the files inside this folder in HTML files:<!DOCTYPE html><htmllang="en"><head><metacharset="UTF-8"><title>{{title}}</title><linkhref="/static/main.css"rel="stylesheet"type="text/css"></head><body><h1>{{body}}</h1><p>This is a paragraph</p></body></html>MiddlewareYou can create custom middleware classes by inheriting from thebumbov.middleware.Middlewareclass and overriding its two methods
that are called before and after each request:frombumbov.apiimportAPIfrombumbov.middlewareimportMiddlewareapp=API()classSimpleCustomMiddleware(Middleware):defprocess_request(self,req):print("Before dispatch",req.url)defprocess_response(self,req,res):print("After dispatch",req.url)app.add_middleware(SimpleCustomMiddleware)
Package: bumboyo
Bumboyo: Python Web Framework built for learning purposesPython frameworkBumboyo is a Python web framework built for learning purposes.It's a WSGI framework and can be used with any WSGI application server such as Gunicorn.InstallationpipinstallbumboyoHow to use itBasic usagefrombumboyo.apiimportAPIapp=API()@app.route("/home")defhome(request,response):response.text="Hello from the HOME page"@app.route("/home/{name})defgreeting(request,response,name):response.text=f"Hello,{name}"@app.route("/book")classBooksResource:defget(self,req,resp):resp.text="Books Page"defpost(self,req,resp):resp.text="Endpoint to create a book"@app.route("/template")deftemplate_handler(req,resp):resp.body=app.template("index.html",context={"name":"Bumboyo","title":"Best Framework"}).encode()Unit TestsThe recommended way of writing unit tests is withpytest. There are two built in fixtures that you may want to use when writing unit tests with Bumboyo. The first one isappwhich is an instance of the mainAPIclass:deftest_route_overlap_throws_exception(app):@app.route("/")defhome(req,resp):resp.text="Welcome Home"withpytest.raises(AssertionError):@app.route("/")defhome2(req,resp):resp.text="Welcome Home 2"The other one isclientthat you can use to send HTTP requests to your handler. It is based on the famousrequestsand it should feel very familiar:deftest_parameterized_route(app,client):@app.route("/{name}")defhello(req,resp,name):resp.text=f"hey{name}"assertclient.get("http://testserver/someone").text=="hey someone"TemplatesThe default folder for templates istemplates. You can change it when initializing the mainAPI()class:app=API(templates_dir="templates_dir_name")Then you can use HTML files in hat folder like so in a handler:@app.route("/show/template")defhandler_with_template(req,resp):resp.html=app.template("example.html",context={"title":"Awesome Framework","body":"welcome to the future!"})Static filesJust like templates, the default folder for static files isstaticand you can override it:app=API(static_dir="static_dir_name")Then you can use the files inside tis folder in HTML files:<!DOCTYPE html><htmllang="en"><head><metacharset="UTF-8"><title>{{title}}</title><linkhref="/static/main.css"rel="stylesheet"type="text/css"></head><body><h1>{{body}}</h1><p>This is a paragraph</p></body></html>MiddlewareYou can create custom middleware classes by inheriting from thebumboyo.middleware.Middlewareclass and overriding its two methods that are called before and after each request:frombumboyo.apiimpoortAPIfrombumboyo.middlewareimportMiddlewareapp=API()classSimpleCustomMiddleware(Middleware):defprocess_request(self,req):print("Before dispatch",req.url)defprocess_response(self,req,res):print("After dispatch",req.url)app.add_middleware(SimpleCustomMiddleware)
Package: bumbo-yuzhanhuang1119
Bumbo: Python Web Framework built for learning purposesBumbo is a Python web framework built for learning purposes.It's a WSGI framework and can be used with any WSGI application server such as Gunicorn.InstallationpipinstallbumboHow to use itBasic usage:frombumbo.apiimportAPIapp=API()@app.route("/home")defhome(request,response):response.text="Hello from the HOME page"@app.route("/hello/{name}")defgreeting(request,response,name):response.text=f"Hello,{name}"@app.route("/book")classBooksResource:defget(self,req,resp):resp.text="Books Page"defpost(self,req,resp):resp.text="Endpoint to create a book"@app.route("/template")deftemplate_handler(req,resp):resp.body=app.template("index.html",context={"name":"Bumbo","title":"Best Framework"}).encode()Unit TestsThe recommended way of writing unit tests is withpytest. There are two built in fixtures
that you may want to use when writing unit tests with Bumbo. The first one isappwhich is an instance of the mainAPIclass:deftest_route_overlap_throws_exception(app):@app.route("/")defhome(req,resp):resp.text="Welcome Home."withpytest.raises(AssertionError):@app.route("/")defhome2(req,resp):resp.text="Welcome Home2."The other one isclientthat you can use to send HTTP requests to your handlers. It is based on the famousrequestsand it should feel very familiar:deftest_parameterized_route(app,client):@app.route("/{name}")defhello(req,resp,name):resp.text=f"hey{name}"assertclient.get("http://testserver/matthew").text=="hey matthew"TemplatesThe default folder for templates istemplates. You can change it when initializing the mainAPI()class:app=API(templates_dir="templates_dir_name")Then you can use HTML files in that folder like so in a handler:@app.route("/show/template")defhandler_with_template(req,resp):resp.html=app.template("example.html",context={"title":"Awesome Framework","body":"welcome to the future!"})Static FilesJust like templates, the default folder for static files isstaticand you can override it:app=API(static_dir="static_dir_name")Then you can use the files inside this folder in HTML files:<!DOCTYPE html><htmllang="en"><head><metacharset="UTF-8"><title>{{title}}</title><linkhref="/static/main.css"rel="stylesheet"type="text/css"></head><body><h1>{{body}}</h1><p>This is a paragraph</p></body></html>MiddlewareYou can create custom middleware classes by inheriting from thebumbo.middleware.Middlewareclass and overriding its two methods
that are called before and after each request:frombumbo.apiimportAPIfrombumbo.middlewareimportMiddlewareapp=API()classSimpleCustomMiddleware(Middleware):defprocess_request(self,req):print("Before dispatch",req.url)defprocess_response(self,req,res):print("After dispatch",req.url)app.add_middleware(SimpleCustomMiddleware)
Package: bumerge
bumergeMerge Butane configurationsThis is a simple Python script that will mergeButaneconfigurations from
multiple files into one. Makes your job easier when you manage servers.mergesmultiple.bufiles into oneinlinesexternal files into the configscheckssource configs for errorsbumerge currently supportsFedora CoreOS Specification v1.5.0.
Support for other distributions is planned, but not prioritized.Installpipxinstallbumerge# or pip, or conda, or pipsi, or ...UseJust pass the list of the files to the appbumergeroot.bumodules/time.bumodules/user.buImportant:bumerge will perform a deep merge. If there are key conflicts,
the latter file takes precedence.Command-line argumentsusage:bumerge[-h][--version][--outputFILE][--variant{fcos}][--spec-version{1.5.0}]FILE[FILE...]positionalarguments:FILEconfigfilestomerge

options:-h,--helpshowthishelpmessageandexit--version,-Vshowprogram'sversionnumberandexit--outputFILE,-oFILEoutputfile.Outputstostdoutbydefault--variant{fcos}Butanespecificationvariant--spec-version{1.5.0}ButanespecificationversionLicence© 2023Nikita KaramovLicensed under theBSD 2-Clause "Simplified" License.This README can also be licensed under theCreative Commons Attribution 4.0 InternationalThis project is hosted on GitHub:https://github.com/kytta/bumerge.git
Package: buml
bumlconsists ofhighly configurableblockandinline
markup languagesand makes iteasy to process documentsfrom a source
form to a final form withyour own custom markup behavior.Pluggable
writerscan render the parse tree in different output formats–at the moment
anXML/HTML writeris supplied.  In thedefault configuration,bumlprovides ashorthand syntaxforxml and htmlsimilar tosphpaml.
(seeshorthand tutorial)See thedocumentationfor details.Feel free tocontact me
Package: bump
bumpBumps package versions.ExampleBy default, runningbumpin a directory with asetup.pywill bump the
“patch” number in place:$ bump
1.0.1
$ git diff setup.py
─────────────────────────────────────────────────
modified: setup.py
─────────────────────────────────────────────────
@ setup.py:6 @ from setuptools import setup

setup(
    name='bump',
-    version='1.0.0',
+    version='1.0.1',
    description='Bumps package version numbers',
    long_description=open('README.rst').read(),
    license='MIT',Convenientlybumpwill also return the new version number, so you can use
it after running the command, for example:$ export VERSION=`bump`
$ echo "The new version is $VERSION"
The new version is 1.0.1OptionsThebumpcommand can also bump the major or minor version numbers, or set
the pre-release identifier or local version segment:$ bump --help
Usage: bump [OPTIONS] [INPUT] [OUTPUT]

Options:
  -M, --major     Bump major number. Ex.: 1.2.3 -> 2.2.3
  -m, --minor     Bump minor number. Ex.: 1.2.3 -> 1.3.3
  -p, --patch     Bump patch number. Ex.: 1.2.3 -> 1.2.4
  -r, --reset     Reset subversions. Ex.: Major bump from 1.2.3 will be 2.0.0
                  instead of 2.2.3
  --pre TEXT      Set the pre-release identifier
  --local TEXT    Set the local version segment
  --canonicalize  Canonicalize the new version
  --help          Show this message and exit.The–resetoption should be used alongside with minor or major bump.You can configure these options by setting them in a.bumporsetup.cfgconfiguration file as well, so you don’t have to specify them every time:$ cat .bump
[bump]
input = some_directory/__file__.py
minor = true
patch = false
reset = true
Package: bump2release
bump2releaseA CLI utility extension ofbump2versionthat will push release tag to git remote in same flow.Installationpip install bump2releaseBasic UsageMerge all feature branches to release branch. Either by pull request on remote, or local mergeRun bump2Release (alias b2r), passingSEMVERrelease type (Major/Minor/Patch), and message for annotated tagCLI Usage:usage: bump2release [-h] bump_type tag_message

positional arguments:
  bump_type    Major / Minor / Patch etc.
  tag_message  annotated tag message

optional arguments:
  -h, --help   show this help message and exitSample Commandbump2release minor "new feature added"CLI Output:Sample Github Result:Command Flow DetailsValidate that git staging isn't dirtyValidate that script is running from main/master/dev branchPull latest changes from upstream (if feature branch was just merged)Leverage bump2version to bump version files, commit the change, and create matching annotated tagPush newly created tag to git remote (which can kick off a publish CI action)NotesAversion.txtfile is requiredAdditional files can optionally be specified in.bumpversion.cfgLicenseFree Software: MIT License
Package: bump2v
This release of thebump2vpackage brings a set of enhancements, bug fixes, and new features aimed at enhancing functionality and improving the user experience. The version is deemed production-ready.Readiness for Production
This version has undergone thorough testing and is considered stable for production use.Manual
This package is built on top of thebump2versionpackage. For more information on how to use the package, please refer to thebump2versiondocumentation.Contributors
A sincere thank you to all contributors who participated in making this release possible.
Package: bump-anything
Bump AnythingCopyright 2019-2023 Caleb EvansReleased under the MIT licenseBump Anything is a command-line utility for incrementing the version  It serves
as a more-flexible alternative tonpm versionand similar tools because
Bump Anything can handle any arbitrary text file and has built-in support for
different types of projects.FeaturesBump the version number in any arbitrary fileSupports most project types (if no paths are supplied, automatically detectspackage.jsonin Node,setup.pyorpyproject.tomlin Python,style.cssfor WordPress themes, etc.)InstallationBump Anything requires Python 3.9 or newer to run, so please ensure you have it
installed.pip3installbump-anythingUsageBump Anything exposes to your shell abump-anythingcommand (also aliased tobump). The only required argument is a keyword indicating how you want to
increment each version. It can be eithermajor,minor, orpatch.bumpmajor# 1.2.3 -> 2.0.0bumpminor# 1.2.3 -> 1.3.0bumppatch# 1.2.3 -> 1.2.4bumpprerelease# 1.2.3-beta.1 -> 1.2.3-beta.2bump2.3.4bumpv2.3.4# same as `bump 2.3.4`With this syntax, Bump Anything will do its best to find the relevant files to
bump. However, Bump Anything can also accept an optional list of one or more
file paths whose versions to bump. Only the first occurrence of the version
field in each file will be updated.bumpminorsubdir/myfile1.jsonsubdir/myfile2.tomlGit IntegrationThebumpcommand will automatically create a tagged commit if the current
directory is a Git repository. Only the files that have been modified bybumpwill be staged.Custom commit messageYou can explicitly specify the commit message with--commit-messageor-m.
The default isPrepare v<new_version> release. You can use the{new_version}placeholder to represent the new version (without any prefix).bump--commit-message'Release v{new_version}'majorbump-m'Release v{new_version}'majorCustom tag nameYou can explicitly specify the tag name with--tag-nameor-t(default:v<new_version>). You can use the{new_version}placeholder to represent the
new version (without any prefix).bump--tag-name'release/{new_version}'patchbump-t'release/{new_version}'patchDisabling committing and/or taggingIf you do not wish forbumpto automatically create a commit and tag, you can
pass the--no-commitflag (alias:-n):bump--no-commitminorbump-nminorDisabling tagging onlyIf you wish to disable the automatic tag creation but still create a commit, you
can pass the--no-tagflag:bump--no-tagpatchAuto-Detected Filespackage.json(Node)package-lock.json(Node)setup.py(Python)pyproject.toml(Python)style.css(WordPress Theme)<cwd name>.php(WordPress Plugin)
Package: bumpAPI
BumpAPI - A Python Library for Website InteractionBumpAPI is a Python library developed by BumpAPI Labs to facilitate interaction with external APIs of websites. It empowers users to interact with the content and functionalities of various websites through a range of methods and commands.Features:Fetch content from a specified URL.Retrieve text content from the page, removing HTML tags.Search for specific text occurrences on a page.Display HTML code from a webpage.Refresh or reload a web page.Retrieve links or images from a webpage.Generate a summary of the page content.Gather statistics about HTML tags used on the page.Fetch header information of the webpage.Compare two web pages for differences.Extract specific elements based on their titles.Simulate wait time between commands.Click on elements using their IDs.Send text inputs to the targeted webpage.Usage:
The library offers a set of methods to interact with web content. Users can specify a target URL and perform various operations to extract, analyze, or interact with elements on the webpage. It's important to understand and adhere to the terms of service of the websites being accessed using this library.Note:
BumpAPI is currently in a testing phase, and although efforts are being made to enhance its reliability and stability, users should expect potential bugs or errors during usage.Contributions:
BumpAPI welcomes contributions and feedback from the community. Feel free to contribute to the project or report any issues encountered during usage.Disclaimer:
Usage of this library to interact with websites should comply with ethical and legal standards. The developers assume no liability for the usage of BumpAPI beyond its intended functionality.Support:
For any inquiries, suggestions, or issues, please reach out to BumpAPI Labs viaecomatedev@gmail.comThank you for considering BumpAPI for your web interaction needs!
Package: bumpemu
bumpemuThis is a bump controller emulator for CellPro PowerLab 6 and 8 chargers.
It allows you to use the CCS mobile app to control your charger over
bluetooth low energy (BLE).To interface to the PowerLab with BLE, you need two pieces of hardware:FUIM3 USB AdapterRaspberry Pi Zero WIf you've ever hooked up your PowerLab to your PC and monitored charging,
you already have the FUIM3.Pi Zero W SetupThis controller emulator will run on the Pi Zero W. Follow theinstructionsfor installing the
Pi with the latest version ofRaspbian.Once you have the Pi up and running, make sure everything is up to date:sudo apt-get update
sudo apt-get upgradeThen install the required libraries:sudo apt-get install -y libusb-dev libdbus-1-dev libglib2.0-dev libudev-dev libical-dev libreadline-dev libgirepository1.0-dev libcairo2-devThe Pi will come withbluezalready installed, but it will probably be an
older version. Version5.45has proven to work well so you will need to
install it. Download it fromhere.
Then followthese instructionsto install it. Make sure to do the step where you enable the experimental
features.Finally,bumpemucan be installed usingpip:sudo pip3 install bumpemuThen you can run bumpemu as follows:/usr/local/bin/bumpemu-controllerYou can view various configuration options with-h:/usr/local/bin/bumpemu-controller -hA systemd service is in the repo if you wish to have bumpemu run at boot.Presets configurationTheBumpCCS2app has 7 predefined charger profiles:AccurateAnalyzeDischargeFastestMonitorNormalStorageBumpemu will map the app's predefined profiles to existing presets in your charger. To do this, create the file/etc/bumpemu/presets.ymlon your pi. Set the number of the charger preset you want each app charger profile to map to.An example presets file is in the repo.To verify you have set the profiles the way you want them, make sure no other instances ofbumpemu-controllerare running, and then run the following:/usr/local/bin/bumpemu-controller --show-presetsBattery configurationWhen running theBumpCCSapp with a real bump controller, you would bump a battery to load the battery configuration to the app. To emulate that,bumpemuloads a battery configuration when it starts up. The battery configuration should go in/etc/bumpemu/battery.yml.An example battery configuration file is in the repo.
Package: bumper
bumperBump (pin/manage) your dependency requirements with easeFeature SummaryBumps dependencies in requirements.txt / pinned.txt to latest or specified versionVersions are validated against published versions in PyPIShow detailed changelogs for pinned version bumpsAutomatically pin dependency requirements from detailed changelogsEasily extendible by writing your own bumper classQuick Start TutorialTo install:sudo pip3 install autopip
app install bumperTo bump everything to latest version:$ cat requirements.txt
localconfig<=0.3
remoteconfig
requests==2

$ bump
[INFO] Updated requirements.txt: requests==2.5.1

$ cat requirements.txt
localconfig<=0.3
remoteconfig
requests==2.5.1To bump to specific version:$ bump localconfig==0.5
[ERROR] There are no published versions that satisfies localconfig==0.5
        Please change to match at least one of these: 0.4.1, 0.4.0, 0.3.6, 0.3.5, 0.3.4, 0.3.3, 0.3.2, 0.3.1, 0.3.0, 0.2.9

# Needs quote when using > or < sign they are stdout/in redirects in bash.
$ bump 'localconfig>=0.4' requests==2.5
[INFO] Updated requirements.txt: localconfig>=0.4 requests==2.5To show details of the bump:$ bump --detail
[INFO] Checking requests
[INFO] Updated requirements.txt: requests==2.5.1

requests
  2.5.1
    **Behavioural Changes**
    + Only catch HTTPErrors in raise_for_status (#2382)
    **Bugfixes**
    + Handle LocationParseError from urllib3 (#2344)
    + Handle file-like object filenames that are not strings (#2379)
    + Unbreak HTTPDigestAuth handler. Allow new nonces to be negotiated (#2389)

$ bump
[INFO] No need to bump. Everything is up to date!In order for details to show, the package’s long_description, docs_url, or url must link to the package’s git/bitbucket repository where CHANGELOG.rst (or its variances: CHANGELOG|CHANGES|HISTORY|changes.md|txt) can be found at the source root or ‘docs’ folder.For pinned.txt, it will even pin any requirements from changes:$ cat pinned.txt
remoteconfig==0.2

$ bump --dependencies
[INFO] Checking remoteconfig
[INFO] Changes in remoteconfig require: localconfig>=0.4
[INFO] Pinned localconfig==0.4.1, remoteconfig==0.2.4

remoteconfig
  0.2.4
    * Add py26 testing to tox
    * Use mangled url as file name instead of base64 encode
    * Fix tests
  0.2.2
    * Add an example to instantiate another config
    * Raise a more descriptive error when requests.get fails
  0.2.1
    * Require localconfig>=0.4
    * Fix API doc
    * Update changelogEasy and cool, right? :)Want it to be even easier? Check out the integrated version inworkspace-toolsthat does the commit with the change details for you.MoreDocumentation:http://bumper-lib.readthedocs.org/workspace-tools:https://pypi.python.org/pypi/workspace-toolsPyPI:https://pypi.python.org/pypi/bumperGitHub Project:https://github.com/maxzheng/bumperReport Issues/Bugs:https://github.com/maxzheng/bumper/issuesConnect:https://www.linkedin.com/in/maxzhengContact: maxzheng.os @t gmail.com
Package: bumper-lib
bumper-libA library to bump / pin your dependency requirements.
This is used by thebumperandworkspace-toolspackage.Morebumper:https://pypi.python.org/pypi/bumperworkspace-tools:https://pypi.python.org/pypi/workspace-toolsDocumentation:http://bumper-lib.readthedocs.org/PyPI:https://pypi.python.org/pypi/bumper-libGitHub Project:https://github.com/maxzheng/bumper-libReport Issues/Bugs:https://github.com/maxzheng/bumper-lib/issuesConnect:https://www.linkedin.com/in/maxzhengContact: maxzheng.os @t gmail.com