Saravanan666/pypi-org huggingface dataset:
Package: bullseye_method
# Bullseye!"Bullseye!" is a new algorithm for computing the Gaussian Variational Approximation of a target distribution. Its strong point lies in the fact that it can easily be parallelized and distributed.## Getting StartedThese instructions will get you a copy of the project up and running on your local machine for development and testing purposes. See deployment for notes on how to deploy the project on a live system.### InstallingBullseye! is now available as a [PyPI package](https://pypi.python.org/pypi/bullseye_method/):```pip install bullseye_method```or clone the repository :```git clone https://github.com/Whenti/bullseye```or [download and extract the zip](https://github.com/Whenti/bullseye/archive/master.zip) into your project folder.## Running the testsTo see if everything is working properly, you can already run the algorithm on a multilogit model with artificially generated data.```pyfrom Bullseye.Tests import simple_testsimple_test()```## Example```pyimport Bullseyefrom Bullseye import generate_multilogittheta_0, x_array, y_array = generate_multilogit(d = 10, n = 10**3, k = 5)bull = Bullseye.Graph()bull.feed_with(x_array,y_array)bull.set_predefined_model("multilogit")bull.set_predefined_prior("normal_iid")bull.init_with(mu_0 = 0, cov_0 = 1)bull.set_options(local_std_trick = True, s=5)bull.build()bull.run()```## Authors* **Quentin Lévêque** [Whenti](https://github.com/Whenti)See also the list of [contributors](https://github.com/Whenti/bullseye/contributors) who participated in this project. Hopefully, there will be more.## LicenseThis project licensed under the GPL3 License - see the [LICENSE.txt](LICENSE.txt) file for details.
Package: bulltools
Installation$pipinstallbulltoolsFeaturesbulltools, ** Hacking tools auto-install script**How it works$ pip install bulltools
$ bulltoolsUsage$ bulltools [-h|i|v|a|r]

options :-
-h : print help
-i : install
-v : version
-a : about us
-r : remove


Created by Parixit Sutariya
Github : github.com/Bhai4You
Blogspot : https://bhai4you.blogspot.comGithub
Package: bullycomp
bullybullycompはkisode-ta_tokyo.csvを使って各都市のいじめ件数の認知度を比較する簡単なPythonプログラムです。kisode-ta_tokyobullycomp は 件数を比較するために kisode-ta_tokyo.csv を必要とします。how to install$ pip install bully_comparsionhow to run bully_comparsion"year" には知りたい年度を入れます。ex)H23,H24,H25..."c_year" には比較したい年度を入れます。ex)H23,H24,H25..."school" には対象となる学年を入れます。ex)e_school,jh_school,h_school...$ bullycomp year c_year school→$ bullycomp H23 H24 h_schoolyear="H23",c_year="H24", school="h_school"$ bullycomp H26 H23 sn_schoolyear="H26",c_year="H23", school="jh_school"
Package: bulma-load
BulmaA companion toVegetathat tells him what to do. Define a configuration file like below and run:python-mbulma-csamples/bulma.config.jsonbulma.config.json{"Project":"My Super Project","Duration":"5s","Rate":"50/1s","Header":{"Content-Type":["application/json"],"Accept-Encoding":["*"]},"Corpus":[{"id":"Getting Todo JSON data","method":"GET","url":"https://jsonplaceholder.typicode.com/todos/1","header":{"Content-Type":["application/json"]}},{"id":"Converting text to Md5","method":"GET","url":"http://md5.jsontest.com/?text=example_text","header":{"Content-Type":["application/json"]}}]}Each of the cases within theCorpusare passed directly toVegeta's JSON formatallowing you to specify anything that would normally be supported by that tool.Bulma supports the following body types which can be attached to any cases witin theCorpus:body: Raw string bodybody_file: Relative location to a file, content's are extractedbody_graphql: Relative location to a file containing a GraphQL query. contents are extracted and pushed intoqueryproperty for a GraphQL requestNote that relativity here is relative to where you run the scriptFull Sample
Package: bulma-sphinx-theme
Bulma Sphinx ThemeAbulmabasedsphinxtheme.Get startedTo use this theme in your documentation build environment, first install thebulma-sphinx-themewithpip:pip install bulma-sphinx-themethen, configure the Sphinx docs to use the theme by editingconf.pyhtml_theme="bulma_sphinx_theme"Your Sphinx documentation's HTML pages will now be generated with this theme! 🎉ExamplesAn examples without fixed navbar:https://zclab.github.io/bst-demo/An examples without navbar:https://zclab.github.io/bst-nonavbar/DocumentationSeethe bulma sphinx themefor more information. Your can also refer toBulma Documentationfor more sophisticated change.
Package: bulstem
BulStem-py: A Python Re-implementation of BulStem - inflectional stemmer for BulgarianIntroductionThis is the Python version of the BulStem stemming algorithm. It follows the algorithm presented inNakov, P. BulStem: Design and evaluation of inflectional stemmer for Bulgarian. In Workshop on 
Balkan Language Resources and Tools (Balkan Conference in Informatics).Seehttp://people.ischool.berkeley.edu/~nakov/bulstem/for the homepage of the algorithm. Also, check the originalpaperfor more details and examples.ImplementationThis implementation, in contrast of the other available uses a Trie, instead of Dictionary/Hashtable/, in order to find the longest possible rule, that can be applied to a token.Basic algorithm steps:Find the position of the first vowel in the token.Find the longest possible rule by traversing the string in reverse order until there is a matching suffix, or down to the position of the first vowel (found in Step. 1).Prepend the non-stemmed prefix to the stemmed suffix (Step. 2).InstallationThis library is compatible with Python >= 3.6.Clone the repository and run:With pippipinstall-e.
pipinstall-rrequirements.txtTestA set of tests are included in the project, under thetests folder.
The test suit can be run as follows:pipinstall-e".[testing]"pipinstall-rrequirements-test.txt
python-munittestUsageThe library works with a set of rules used for stemming. The rules can be either passed as a list to theBulStemmerconstructor, or as a path to a file.For both options the rules need to be formatted as follows:word ==> stem ==> freqA pre-defined set of rules is included in the package, and can be used directly. The stemming rules can be foundhere. (examples:Reading the rules from an external file)Manually loading rulesfrombulstem.stemimportBulStemmerstemmer=BulStemmer(["ой ==> о 10"],min_freq=0,left_context=2)stemmer.stem('порой')# Excepted output: 1. 'поро'BulStemmerconstructor params:rules- Iterable of strings containing rules.min_freq- The minimum frequency of a rule to be used when stemming.left_context- Size of the prefix which will not be stemmed.Reading the rules from an external filefrombulstem.stemimportBulStemmer# Pre-defined names of rule setsPRE_DEFINED_RULES=['stem-context-1','stem-context-2','stem-context-3']# Excepted output:# 1 втор# 2 втори# 3 вториятfori,rules_nameinenumerate(PRE_DEFINED_RULES,start=1):stemmer=BulStemmer.from_file(rules_name,min_freq=2,left_context=i)print(i,stemmer.stem('вторият'))stemmer=BulStemmer.from_file('stem_rules_context_2_utf8.txt',min_freq=2,left_context=i)stemmer.stem('вторият')# Excepted output: 1. 'втори'stemmer.stem('вероятен')# Excepted output: 1. 'вероят'BulStemmer.from_fileparams:path- Path (or pre-defined name) to the rules file formatted as follows: word ==> stem ==> freq.min_freq- The minimum frequency of a rule to be used when stemming.left_context- Size of the prefix which will not be stemmed.Other implementationsPerl (Original),Java (JDK 1.4),Ruby,C#,Python2,GATE plugin (Java)LicenseFor license information, seeLICENSE.
Package: bulu-faq
Stupid simple FAQ app to use with any django project. Includes admin definitions and a read-only API using Django Rest Framework.InstallationInstall using pip:pip install bulu-faqConfigurationAddfaqto your installed apps insettings.py:INSTALLED_APPS = (
    ...
    'faq',
)Add the urls inurls.py:urlpatterns = [
    ...
    path('faq/', include('faq.urls'))
]
Package: bum
# 🎵 bum[![PyPI](https://img.shields.io/pypi/v/bum.svg)](https://pypi.python.org/pypi/bum/)[![MIT licensed](https://img.shields.io/badge/license-MIT-blue.svg)](./LICENSE.md)[![Build Status](https://travis-ci.org/dylanaraps/bum.svg?branch=master)](https://travis-ci.org/dylanaraps/bum)[![Donate](https://img.shields.io/badge/donate-patreon-yellow.svg)](https://www.patreon.com/dyla)`bum` is a daemon that downloads album art for songs playing in `mpd`/`mopidy` and displays them in a little window. `bum` doesn't loop on a timer, instead it waits for `mpd`/`mopidy` to send a `player` event. When it receives a `player` event it wakes up and downloads album art for the current playing track. This makes `bum` lightweight and makes it idle at `~0%` CPU usage.`bum` uses [musicbrainz](https://musicbrainz.org/) to source and download cover art, if an album is missing it's cover art you can easily create an account and fill in the data yourself. `bum` outputs a `release-id` which you can use to find the exact entry on musicbrainz.Note: `bum` is meant to be used with files that don't have embedded album art (`mopidy-spotify`).![showcase](http://i.imgur.com/uKomDoL.gif)## Dependencies- `python 3.6+`- `python-mpv`- `python-mpd2`- `musicbrainzngs`## Installation```shpip3 install --user bum```## Usage```shusage: bum [-h] [--size "px"] [--cache_dir "/path/to/dir"] [--version]bum - Download and display album art for mpd tracks.optional arguments:-h, --help            show this help message and exit--size "px"           what size to display the album art in.--cache_dir "/path/to/dir"Where to store the downloaded cover art.--version             Print "bum" version.--port                Use a custom mpd port.```## DonateDonations will allow me to spend more time working on `bum`.If you like `bum` and want to give back in some way you can donate here:**https://patreon.com/dyla**
Package: bumbag
AboutBumBag is a collection of Python utility functions:DocumentationExample usageAPI ReferenceInstallationbumbagis available onPyPIfor Python 3.8+:pipinstallbumbagExamplesMeasure elapsed wall-clock time and compute total elapsed time withstopwatch:>>>importbumbag>>>importtime>>>withbumbag.stopwatch(1)assw1:...time.sleep(1)...2023-01-0112:00:00->2023-01-0112:00:01=1.00124s-1>>>withbumbag.stopwatch(2)assw2:...time.sleep(1)...2023-01-0112:01:00->2023-01-0112:01:01=1.00168s-2>>>sw1+sw22.00291s-totalelapsedtimeEasilyflattenan irregular list:>>>importbumbag>>>irregular_list=[...["one",2],...3,...[(4,"five")],...[[["six"]]],..."seven",...[],...]>>>list(bumbag.flatten(irregular_list,8,[9,("ten",)]))['one',2,3,4,'five','six','seven',8,9,'ten']Usehighlight_string_differencesto see differences between two strings easily:>>>importbumbag>>>print(bumbag.highlight_string_differences("hello","hall"))hello||hallQuickly compare two Python sets withtwo_set_summary:>>>importbumbag>>>x={"a","c","b","g","h"}>>>y={"c","d","e","f","g"}>>>summary=bumbag.two_set_summary(x,y)>>>print(summary["report"])x(n=5):{'a','b','c',...}y(n=5):{'c','d','e',...}x|y(n=8):{'a','b','c',...}x&y(n=2):{'c','g'}x-y(n=3):{'a','b','h'}y-x(n=3):{'d','e','f'}x^y(n=6):{'a','b','d',...}jaccard=0.25overlap=0.4dice=0.4disjoint?:Falsex==y:Falsex<=y:Falsex<y:Falsey<=x:Falsey<x:FalseContributing to BumBagYour contribution is greatly appreciated!
See the following links to help you get started:Contributing GuideDeveloper GuideContributor Code of ConductLicensebumbagwas created by the BumBag Developers.
It is licensed under the terms of the BSD 3-Clause license.
Package: bumble
_                 _     _
| |               | |   | |
| |__  _   _ ____ | |__ | | _____
|  _ \| | | |    \|  _ \| || ___ |
| |_) ) |_| | | | | |_) ) || ____|
|____/|____/|_|_|_|____/ \_)_____)Bluetooth Stack for Apps, Emulation, Test and ExperimentationBumble is a full-featured Bluetooth stack written entirely in Python. It supports most of the common Bluetooth Low Energy (BLE) and Bluetooth Classic (BR/EDR) protocols and profiles, including GAP, L2CAP, ATT, GATT, SMP, SDP, RFCOMM, HFP, HID and A2DP. The stack can be used with physical radios via HCI over USB, UART, or the Linux VHCI, as well as virtual radios, including the virtual Bluetooth support of the Android emulator.DocumentationBrowse the pre-builtOnline Documentation,
or see the documentation source underdocs/mkdocs/src, or build the static HTML site from the markdown text with:mkdocs build -f docs/mkdocs/mkdocs.ymlUsageGetting StartedFor a quick start to using Bumble, see theGetting Startedguide.DependenciesTo install package dependencies needed to run the bumble examples, execute the following commands:python -m pip install --upgrade pip
python -m pip install ".[test,development,documentation]"ExamplesRefer to theExamples Documentationfor details on the included example scripts and how to run them.The completelist of Examples, and what they are designed to do is here.There are also a set ofApps and Toolsthat show the utility of Bumble.Using Bumble With a USB DongleBumble is easiest to use with a dedicated USB dongle.
This is because internal Bluetooth interfaces tend to be locked down by the operating system.
You can use theusb_probetool (all platforms) orlsusb(Linux or macOS) to list the available USB devices on your system.See theUSB Transportpage for details on how to refer to USB devices. Also, if your are on a mac, seethese instructions.LicenseLicensed under theApache 2.0License.DisclaimerThis is not an official Google product.This library is in alpha and will be going through a lot of breaking changes. While releases will be stable enough for prototyping, experimentation and research, we do not recommend using it in any production environment yet.
Expect bugs and sharp edges.
Please help by trying it out, reporting bugs, and letting us know what you think!
Package: bumbleview
RetinolPython package for converting wavelength spectra of e.g. petals to trichromatic insect vision. Designed to be used as a colab notebook, to ease the process.How do insects see the world? A recent review shows the magnitude of variation of visual perception across the phylum of insects (van der Kooi et al. 2021). Nonetheless, many of which have a set of 3 different wavelength receptors, covering a range of wavelengths from ~300 to ~700 nm (or in words, from UV to red). As there is no direct physical way of measuring this perception, a framework combining physiological exminations, wavelength measurements and mathematical transformations was set up during the 20th century (Wyszecki & Spines 1982, Chittka & Waser 1997). Thus, it is possible to compare different flowers by how they are perceived by an insect. This notebook implements the concept described by Chittka & Kevan (2005) (and basically shares its nomenclature) and enables the comparison of multiple species of flowers on how they are sensed by a trichromatic insect eye.For any questions or help please contact thomas.huberevobio.eu
Package: bumbling
Bumbling is a python module that reads exif data from image files and renames them accordingly.Bumbling relies on the “exiftool” command-line tool which is available here:https://exiftool.org/The source code is available at this github repository:https://github.com/JonathanRoth13/bumbling.gitDocumentation is available at:https://jonathanroth13.com/projects/bumbling/
Package: bumbo
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: bumbo12345
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: bumbo2
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)