Saravanan666/pypi-org huggingface dataset:
Package: boozelib
boozelibVERSION:0.7.0A Python module containing a couple of tools to calculate theblood alcohol contentof people.It's at home at GitHub:https://github.com/brutus/boozelib/.As a side note: I created this library mainly to have a very simple module to
try different Python testing and packaging best practice.This is in no way a
serious medical approach and also accepts a rather big level of abstraction.Depending on your use case, this might be okay; but I would not deem it fit for
serious health and / or legal stuff 😉 🍻InstallYou can install it fromPyPi, it is known asboozeliband has no
dependencies:pipinstall--userboozelibUsageThe two main functions are:get_blood_alcohol_content(age, weight, height, sex, volume, percent)Return theblood alcohol contentsraise (per mill) for a person after a
drink.Given a drink containingvolume(ml) ofpercent(vol/vol) alcohol, for a
person withage(years),weight(kg) andheight(cm) — using a
formular for "female body types" ifsexis true.get_blood_alcohol_degradation(age, weight, height, sex, minutes=1, degradation=None)Return thealcohol degradation(per mill) for a person overminutes.For a person withage(years),weight(kg) andheight(cm), using the
formular for "female body types" ifsexis true, over the givenminutes.
Ifdegradationis not set,ALCOHOL_DEGRADATIONis used as default.This uses some constants and one variable you might want to review:ALCOHOL_DEGRADATION: the default value for alcohol degradation; meaning
the amount of alcohol (in gram) your body is degrading per minute, per
kilogram body weight. This is usually a value between0.0017and0.0025(about 0.1—0.2 per thousand per hour).ExamplesReturn theblood alcohol contentsraise (per mill) for a person after a
drink:fromboozelibimportget_blood_alcohol_contentget_blood_alcohol_content(age=32,weight=48,height=162,sex=True,volume=500,percent=4.9)# ⇒ 0.5480779730398769And to calculate alcohol degradation:fromboozelibimportget_blood_alcohol_degradationget_blood_alcohol_degradation(age=32,weight=48,height=162,sex=True,minutes=60)# ⇒ 0.20133476560648536You can change the default foralcohol degradationglobally via settingboozelib.ALCOHOL_DEGRADATION. Or change the value foralcohol degradationper call:get_blood_alcohol_degradation(age=32,weight=48,height=162,sex=True,minutes=60,degradation=0.002)# ⇒ 0.16106781248518828DocumentationSee the source or thedocumentationfor more information and the usedformulas.Development SetupPoetryis used to manage avirtual environmentfor the development setup.AMakefileis provided, that collects some common tasks. You have to run
the followingonce, to setup your environment:makesetupTestingnoxis used as a test runner (withwardas the framework). If you have thedevelopment environmentactivated, you can just run:maketestsIf something fails, please get in touch.Thanks and ContributionsBig hugs to Mathilda for hanging around and helping me figuring out all
that math and biology stuff.If you find bugs, issues or anything else, please use theissue trackeron
GitHub. Issues and PRs are welcome ❤️
Package: booz-xform
# booz_xform
![booz_xform logo](docs/source/logo_lores.png)booz_xformis a package for computing Boozer coordinates in toroidal
magnetohydrodynamic equilibria, including both stellarators and
tokamaks.  The package described here follows the same algorithm as
the fortran 77 code of the same name in
[Stellopt](https://github.com/PrincetonUniversity/STELLOPT/tree/develop/BOOZ_XFORM).
However the package here is written in C++, with python bindings.  The
package here is also written so as to allow input from equilibrium
codes other than VMEC, it is parallelized using OpenMP, and it
includes functions for plotting output.  It is also equipped with unit
and regression tests and continuous integration.booz_xformrequires NetCDF, a C++ compiler, and python3. For many
users, the code can be installed by executingpip install booz_xformFor more installation options and other information, see the
[booz_xform documentation
here.](https://hiddensymmetries.github.io/booz_xform/)
Package: bop
Parses output fromBoain Python! :thumbsup:Note: This isnota Boa client! (I would have come up with
a egregious snake pun had I made that).InstallInstall using pip:$pipinstallbopExampleUsing the dataviewable here:>>>importbop>>>withopen('boa-job-output.txt')asf:...results=bop.parse(f,weighted=True)...>>>results{'c#':'145','python':'127','php':'358','c':...}LicenseCopyright 2016 Eddie Antonio SantosLicensed under the Apache License, Version 2.0 (the “License”);
you may not use this file except in compliance with the License.
You may obtain a copy of the License at<http://www.apache.org/licenses/LICENSE-2.0>Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an “AS IS” BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Package: bopen
BopenOpen bookmarks from the shell.TODOSuport Firefox.*Automatically detect default browser cookies.A bopen command that handles variables and funcitonalities (?)* Hint: SELECT moz_places.url, moz_bookmarks.title FROM moz_places INNER JOIN moz_bookmarks ON moz_places.id=moz_bookmarks.fk WHERE moz_bookmarks.title NOTNULL in ~/.mozilla
Package: bophono
Tibetan Phonetics EngineDescriptionThe goal of this code is to provide a library to:implement the conversion of a Tibetan Unicode word into IPA, according to different schemes / dialectsimplement some conversions between IPA and phonetics readable by people with various language backgrounds (Chinese, English, etc.)The primary focus of this library is litterary pronounciation, ideally representing how an umze would pronounce a traditional text, but contributions for other uses are welcome. We also do not handle Sanskrit transliteration (this can be done through custom exceptions lists).Note that this library integrates no segmenter and needs to be applied on each word separately. You can use it in combination withpyboto get the phonetics of full sentences.Phonetics methodsWe currently provide two phonetics schemes:Manual of Standard Tibetan (by Tournadre)Colloquial Amdo Tibetan (by Kuo-ming Sung and Lha Byams Rgyal)OutputsApart from raw IPA, we provide the following output possibilities:Chinese phoneticsThe Chinese is produced by a streamlined phonetic scheme in order to match the Mandarin phonology (vowels have been simplified and most of the Tibetan suffixes removed).To produce the final output, we first transform the generated IPA intoZhuyin, and then the Zhuyin into Traditional Chinese characters, with a manually built correspondance list.Installationpip install bophonoAPITo get the IPA for a word according to theMSTscheme:importbophono# see PhonStateMST.py for other optionsoptions={'aspirateLowTones':True}mstconverter=bophono.UnicodeToApi(schema="MST",options=options)mstipa=mstconverter.get_api("སྐུ")print(mstipa)# kúNote that you must first segment your text in words and then convert each word.ChangesSeeCHANGELOG.md.LicenseThe Python code is Copyright (C) 2018-2023 Esukhia, provided underMIT License. SeeCONTRIBUTORS.mdfor a list of authors and contributors.
Package: bopku
BopkuBopku merupakan alat bantu administrasi BOP Paud.Fitur yang akan datangBerikut fitur yang akan direncanakan untuk aplikasi ini.Export ke excelExport ke wordPrint KwitansiDonasiJika anda ingin melakukan donasi untuk kami, bisa menghubungi kami melaluiWhatsAppataupunTelegram.Legal / HukumKode ini sama sekali tidak berafiliasi dengan, diizinkan, dipelihara, disponsori atau didukung oleh Kemdikbud atau afiliasi atau anak organisasinya. Ini adalah perangkat lunak yang independen dan tidak resmi.Gunakan dengan risiko Anda sendiri.
Package: bopomo
bopomoThis is a package to translate a chinese sentence into bopomofo letters baesed on revised dictionary of Ministry of Education, segment corpus, artificial label data, and python package jieba and python-crfsuite.>>>importbopomo>>>sent='妹妹背著洋娃娃，走到花園來看花。'>>>bopomo_sent=bopomo.bopomo_sent(sent)>>>print(bopomo_sent.bopomo_tag())[['妹妹背著洋娃娃','ㄇㄟˋ ˙ㄇㄟ ㄅㄟ ˙ㄓㄜ ㄧㄤˊ ㄨㄚˊ ˙ㄨㄚ'],['走到花園來看花','ㄗㄡˇ ㄉㄠˋ ㄏㄨㄚ ㄩㄢˊ ㄌㄞˊ ㄎㄢˋ ㄏㄨㄚ']]>>>sent='如果薪水不到4萬8，可向老闆說你給的薪水太低了。'>>>bopomo_sent=bopomo.bopomo_sent(sent)>>>print(bopomo_sent.bopomo_tag())[['如果薪水不到4萬8','ㄖㄨˊ ㄍㄨㄛˇ ㄒㄧㄣ ㄕㄨㄟˇ ㄅㄨˋ ㄉㄠˋ 4 ㄨㄢˋ 8'],['可向老闆說你給的薪水太低了','ㄎㄜˇ ㄒㄧㄤˋ ㄌㄠˇ ㄅㄢˇ ㄕㄨㄛ ㄋㄧˇ ㄍㄟˇ ˙ㄉㄜ ㄒㄧㄣ ㄕㄨㄟˇ ㄊㄞˋ ㄉㄧ ˙ㄌㄜ']]
Package: bopomofo
Translate 漢字 to ㄅㄆㄇㄈ, based onlxneng/xpinyin.Installpip install bopomofoUsage>>>frombopomofoimportto_bopomofo>>>to_bopomofo(u'注音')'ㄓㄨˋ ㄧㄣ'>>>to_bopomofo(u'注音',tones=False)'ㄓㄨ ㄧㄣ'>>>to_bopomofo(u'注音',u'、')'ㄓㄨˋ、ㄧㄣ'>>>bopomofo.to_bopomofo(u'注音',first_tone_symbol=True)'ㄓㄨˋ ㄧㄣˉ'
Package: boppf
Bayesian Optimization of Particle Packing Fractions (BOPPF)Bayesian optimization of particle packing fractions for solid rocket propellant fuels. The objective function (not released here) is based on proprietary code from Northrop Grumman Innovation Systems (NGIS).To reproduce, this requires a proprietary Windows executable (renamed toparticle_packing_sim.exe) and Python functions contained in an unreleased module namedproprietary.mfor writing the input files and reading the volume fraction from the output files. These files should be placed into theboppf/utilsdirectory.InstallationA local installation can be performed via:condacreate-npackingpython==3.9.*
condaactivatepacking
gitclonehttps://github.com/sparks-baird/bayes-opt-particle-packing.gitcdbayes-opt-particle-packing
condainstallflit
flitinstall--pth-fileUsageThe following is based onboppf_example.py, which can be run viapython examples/boppf_example.pyFirst, take care of imports.fromboppf.boppfimportBOPPFfromboppf.utils.dataimportload_dataDefine how many pseudo-random initial Sobol points to generate (n_sobol, typical is twice the number of parameters), the number of Bayesian optimization iterationsn_bayes, and the number of particles to drop in each simulation (particles).n_sobol=10n_bayes=40particles=int(2.5e4)Instantiate theBOPPFclass, and call theoptimizemethod.boppf=BOPPF(n_sobol=n_sobol,n_bayes=n_bayes,particles=particles)best_parameters,means,covariances,ax_client=boppf.optimize(np.array([]),np.array([]),return_ax_client=True)The Axexperimentobject and a tabular summary are saved to theresultsdirectory.
Package: bops
Bops is a numpy-based analysis module focusing on the manipulation, grouping and
filtering of data from various sources. Bops also has map-reduce functionality.
While there are some datasets which need distributed map-reduce jobs, the
author has the point of view that most do not. Bops gives tremendous power in
data grouping without the sacrifice of speed or simplicity.Bops is tightly integrated with numpy to produce a very fast analysis package.
The module has one main class for data manipulation, called a ‘bop’. Bops was
initially named for ‘boolean operations’. The module has been greatly expanded
to include map-reduce and data grouping on top of the initial filtering
capability.Bops expects a two-dimensional data structure for initialization along with the
attributes of the data (ie. column names). After the data is contained in
a ‘bop’, it can be filtered (‘select’ function), grouped on
multiple columns (‘groupby’ function) and sorted (‘orderby’ function).The ‘select’ function allows you to filter on multiple aspects of the data
by manipulating numpy boolean arrays. The ‘groupby’ function can group data on
similar attributes. However, unlike the ‘GROUP BY’ functions found in SQL,
bops’ ‘groupby’ function returns the data found in the group along with the
group’s unique identifiers. On top of these functions, bops also contains a
sort function, called ‘orderby’, which allows the programmer to order the data
on multiple columns.These functions provide enormous power in data analysis, primarily by grouping
data on multiple attributes then returning the results to be manipulated. This
strength is magnified by added map-reduce functionality. The map function
allows a programmer to aggregate data based on custom logic. A simple example
would be grouping by gender and decade of age (30’s, 40’s, …) for every
row in a dataset. A reduce function would then be ran on each group found by
the map function. Using the same example, one could use the built-in len or sum
functions in python as the reduce function to generate histograms of gender
and age groups.Giving the programmer capability and removing limitations is the goal for Bops
to aid data analysis.Changes v0.4.1 - 0.5Added aliases:float:np.float_int:np.int_bool:np.bool_str:np.str_unicode:np.unicode_complex:np.complex_Changed the defaultexpandoption to True for the ‘mapreduce’ and ‘mapreducebatch’ functions. This is to comply with the groupby function, so that theexpandoptions would match across the module.Mailing ListA mailing list has been created to support the use of this module. You can join
and follow the discussion onGoogle groups. Any errors, issues and enhancements can be discussed here.Bops aims to be a top-notch data analysis module, but only with your help can this module actually be great. Please chime into the discussion. Your inputs are welcome as well as any suggested features, patches or fixes.Google CodeThe module is now on Google Code:http://code.google.com/p/bops/Issues, bugs and suggested enhancments can be submitted there.
Package: bopt
# Bayesian Optimization of HyperParameters - `bopt` [![Build Status](https://travis-ci.com/darthdeus/bopt.svg?branch=master)](https://travis-ci.com/darthdeus/bopt)Available commands:```python# Create a new experiment.bopt init -C META_DIR# Start tuning hyperparameters.bopt run -C META_DIR# Get an overview status of an experiment.bopt exp -C META_DIR# Start web visualizations of the results.bopt web -C META_DIR```# Installation```pip install bopt```
Package: bopy
BOPYBo Zhang's python package, for those who need it.Github url:https://github.com/hypergravity/bopyPYPI url:https://pypi.python.org/pypi/bopyAUTHORBo Zhang (@NAOC,bozhang@nao.cas.cn,bzhang@mpia.de)If you find this code useful in your research, please let me know. Thanks!Any people are welcome to contribute to this package.CONTRIBUTORSBo Zhang (@NAOC,bozhang@nao.cas.cn,bzhang@mpia.de)DOCUMENTATIONWill be featured in the near future.INSTALLsudo pip install -U bopyorpip install --user bopyPYTHON VERSIONS AND DEPENDENCIESPython 3.6ISSUESBOPYis originally designed to work under python2.7, but will support python3.X in the future.
Package: bor
User-friendly, tiny source code searcher written in pure Python.Installationborcan be installed by runningpip install bor. It requires Python 3.8.0+ to run.Usageborcurrently supportsclassanddefkeywords. Other Python keywords will be added
in the future releases.bor{keyword}{pattern}By default,borruns in your current directory. You can runborwith the specific
source file or directory:bor{keyword}{pattern}{source_file_or_directory}ConfigurationBy default, ifborencounters an error(syntax, indentation error etc.) while analyzing
files, it will stop working. If you want to the ignore errors, you can use--ignore-erroror-iargument. For example;borclassCat--ignore-errorExample UsagesCatis equivalent in the regular expression as^Cat$borclassCatOutput:Catatexamples/test.py:18.Catis equivalent in the regular expression asCat$borclass.CatOutput:Catatexamples/test.py:18
BlueCatatexamples/test.py:26get.is equivalent in the regular expression as^getbordefget.examples/test.pyOutput:get_valueatexamples/test.py:5
get_blue_valueatexamples/test.py:11
get_purple_valueatexamples/test.py:14
get_meowatexamples/test.py:22.cat.is equivalent in the regular expression ascat+bordef.cat.Output:catch_me_if_you_canatexamples/test.py:8
am_i_blue_catatexamples/test.py:30
where_is_the_catatexamples/test.py:38
Package: borasem-waste
Borås Energi och Miljö Waste CollectionSimple package to get the schedule for upcoming waste pickups.Exampleimport asyncio
import aiohttp
from borasem_waste import auth,borasem

valid_address = 'Validated address from async_get_address()'
search_address = 'Any address to search on.'

async def main():

    async with aiohttp.ClientSession() as session:

        authObj = auth.Auth(session)
        api = borasem.BorasEM(authObj)

        # Get Waste Schedule
        schedule = await api.async_get_schedule(valid_address)

        # Print states
        for scheduleEntry in schedule:
            print(f"The entry {scheduleEntry.containerId} is being picked up at {scheduleEntry.NextWastePickup}")

        # Get Waste Schedule
        addressList = await api.async_get_address(search_address)

        # Print states
        for address in addressList:
            print(address)

asyncio.run(main())
Package: borb
borbborbis a library for creating and manipulating PDF files in python.0. About borbborbis a pure python library to read, write and manipulate PDF documents.
It represents a PDF document as a JSON-like datastructure of nested lists, dictionaries and primitives (numbers, string, booleans, etc)This is currently a one-man project, so the focus will always be to support those use-cases that are more common in favor of those that are rare.1. About the ExamplesThe examples can be found in a separate repository.
This ensures theborbrepository stays relatively small, whilst still providing a thorough knowledgebase of code-samples, screenshots and explanatory text.Check out the examples repository here!They include;Reading a PDF and extracting meta-informationChanging meta-informationExtracting text from a PDFExtracting images from a PDFChanging images in a PDFAdding annotations (notes, links, etc) to a PDFAdding text to a PDFAdding tables to a PDFAdding lists to a PDFUsing a PageLayout managerand much more1.0 Installingborbborbcan be installed usingpippip install borbIf you have installedborbbefore, and you want to ensurepipdownloads the latest version (rather than using its internal cache) you can use the following commands:pip uninstall borb
pip install --no-cache borb1.1 Hello WorldTo give you an immediate idea of the wayborbworks,
this is the classicHello Worldexample, inborb:frompathlibimportPathfromborb.pdfimportDocumentfromborb.pdfimportPagefromborb.pdfimportSingleColumnLayoutfromborb.pdfimportParagraphfromborb.pdfimportPDF# create an empty Documentpdf=Document()# add an empty Pagepage=Page()pdf.add_page(page)# use a PageLayout (SingleColumnLayout in this case)layout=SingleColumnLayout(page)# add a Paragraph objectlayout.add(Paragraph("Hello World!"))# store the PDFwithopen(Path("output.pdf"),"wb")aspdf_file_handle:PDF.dumps(pdf_file_handle,pdf)2. Licenseborbis dual licensed as AGPL/Commercial software.AGPL is a free / open source software license.
This doesn't mean the software isgratis!Buying a license is mandatory as soon as you develop commercial activities distributing the borb software inside your product or deploying it on a network without disclosing the source code of your own applications under the AGPL license.
These activities include:Offering paid services to customers as an ASPServing PDFs on the fly in the cloud or in a web applicationShippingborbwith a closed source productContact salesfor more information.3. AcknowledgementsI would like to thank the following people, for their contributions / advice with regards to developingborb:Aleksander BanasikBenoît LagaeMichael Klink
Package: borch
BorchGetting Started|Documentation|ContributingBorchis a universal probabilistic programming language (PPL) framework
developed byDesupervised, that uses and integrates
withPyTorch. Borch was designed with special attention
to support Bayesian neural networks in a native fashion. Further, it's designed
toFlexible and scalable frameworkSupport neural networks out of the box.Have bells and whistles a universal PPL needs.It can be installed withpipinstallborchUsageSee our full tutorialshere.As a quick example let's look into how the neural network interface looks. The
moduleborch.nnprovides implementations of neural network modules that are
used for deep probabilistic programming and provides an interface almost
identical to thetorch.nnmodules. In many cases it is possible to just switchimporttorch.nnasnntoimportborch.nnasnnand a network defined in torch is now probabilistic, without any other changes
in the model specification, one also need to change the loss function toinfer.vi.vi_loss.For example, a convolutional neural network can be written asimporttorchimporttorch.nn.functionalasFfromborchimportnnclassNet(nn.Module):def__init__(self):super(Net,self).__init__()self.conv1=nn.Conv2d(1,6,5)self.conv2=nn.Conv2d(6,16,5)self.fc1=nn.Linear(16*5*5,120)self.fc2=nn.Linear(120,84)self.fc3=nn.Linear(84,10)defforward(self,x):x=F.max_pool2d(F.relu(self.conv1(x)),(2,2))x=F.max_pool2d(F.relu(self.conv2(x)),2)x=x.view(-1,self.num_flat_features(x))x=F.relu(self.fc1(x))x=F.relu(self.fc2(x))x=self.fc3(x)returnxdefnum_flat_features(self,x):size=x.size()[1:]num_features=1forsinsize:num_features*=sreturnnum_featuresInstallationBorch can be installed usingpipinstallborchDockerThe Borch Docker images are available as both CPU and GPU versions atgitlab.com/desupervised/borch/container_registry.
The latest CPU images can be used asdockerrunregistry.gitlab.com/desupervised/borch/cpu:masterContributingPlease read the contribution guidelines inCONTRIBUTING.md.CitationIf you use this software for your research or business please cite us and help
the package grow!@misc{borch,
  author = {Belcher, Lewis and Gudmundsson, Johan and Green, Michael},
  title = {Borch},
  howpublished = {https://gitlab.com/desupervised/borch},
  month        = "Apr",
  year         = "2021",
  note         = "v0.1.0",
  annote       = ""
}
Package: borda
The Borda count is a single-winner election method in which voters rank
candidates in order of preference. The Borda count determines the winner of an
election by giving each candidate a certain number of points corresponding to
the position in which he or she is ranked by each voter. Once all votes have
been counted the candidate with the most points is the winner. Because it
sometimes elects broadly acceptable candidates, rather than those preferred by
the majority, the Borda count is often described as a consensus-based electoral
system, rather than a majoritarian one.>>> import borda.count
>>> who_is_superman = borda.count.Election()>>> calisto = borda.count.Candidate('calisto')
>>> calvin = borda.count.Candidate('calvin')
>>> clark = borda.count.Candidate('clark')
>>> who_is_superman.set_candidates([calisto, calvin])
>>> who_is_superman.add_candidate(clark)>>> valentine = borda.count.Voter(who_is_superman, 'valentine')
>>> veronica = borda.count.Voter(who_is_superman, 'veronica')>>> valentine.votes([clark, calisto, calvin])
>>> veronica.votes([clark, calvin, calisto])>>> who_is_superman.get_winner() is clark
True