Saravanan666/pypi-org huggingface dataset:
Package: bp-data-grid
Data GridData Gridis a Python package that allows you to effortlessly present tabular data in a visually appealing format. With built-in features such as client-side filtering, pagination, and export options, it provides a comprehensive solution for displaying and manipulating data.FeaturesTabular Data Display: Easily present data in a grid-like structure for clear and organized visualization.Client-Side Filtering: Enable users to quickly search and filter data within the grid, improving data exploration and analysis.Pagination:Divide large datasets into manageable chunks, enabling smooth navigation and enhanced performance.Export Options: Provide users with the ability to export grid data to various formats such as CSV or Excel, facilitating data sharing and external analysis.Data Masking: Ensure data security by incorporating data masking capabilities during export, safeguarding sensitive information from unauthorized access.InstallationYou can install theData Gridpackage from PyPI using pip:pipinstallbp-data-gridUsageTo use the Data Grid component in your Streamlit application, follow these steps:Import the necessary modules:importdata_gridasdgAdd theData Gridcomponent to your application:dg.data_grid(title="Results",rows=rows,columns=columns,)Run your Streamlit application:streamlitrunyour_app.pyExampleimportdata_gridasdgcolumns=[{"field":"id","headerName":"ID","width":90},{"field":"firstName","headerName":"First Name","width":150,"editable":True},{"field":"lastName","headerName":"Last Name","width":150,"editable":True},{"field":"age","headerName":"Age","type":"number","width":110,"editable":True}]rows=[{"id":1,"lastName":"Snow","firstName":"Jon","age":35},{"id":2,"lastName":"Lannister","firstName":"Cersei","age":42},{"id":3,"lastName":"Lannister","firstName":"Jaime","age":45},{"id":4,"lastName":"Stark","firstName":"Arya","age":16},{"id":5,"lastName":"Targaryen","firstName":"Daenerys","age":90},{"id":6,"lastName":"Melisandre","firstName":"Tom","age":150},{"id":7,"lastName":"Clifford","firstName":"Ferrara","age":44},{"id":8,"lastName":"Frances","firstName":"Rossini","age":36},{"id":9,"lastName":"Roxie","firstName":"Harvey","age":65},]dg.data_grid(title="Results",rows=rows,columns=columns,key="data_grid",)Screenshot
Package: bp-data-visualization
Data VisualizationData Visualizationis a Python package that provides a Streamlit component for easy and interactive data visualization. This component allows you to create beautiful and insightful visualizations with just a few lines of code.FeaturesChart Variety: Utilize a wide range of chart types, including bar charts, pie charts, scatter charts, and heatmaps, to effectively convey data insights.Export Options: Export charts as SVG, PNG, or PDF files, allowing for seamless integration into various platforms and documents.Chart Configuration: Customize charts by adjusting parameters such as color schemes, labels, axes, and legends to specific requirements.InstallationYou can install theData Visualizationpackage from PyPI using pip:pipinstallbp-data-visualizationUsageTo use the Data Visualization component in your Streamlit application, follow these steps:Import the necessary modules:importdata_visualizationasdvAdd theData Visualizationcomponent to your application:dv.data_visualizer(title=title,data=data,key="data_visualizer",)Run your Streamlit application:streamlitrunyour_app.pyExampleimportdata_visualizationasdvdata=[{"id":1,"lastName":"Snow","firstName":"Jon","age":35},{"id":2,"lastName":"Lannister","firstName":"Cersei","age":42},{"id":3,"lastName":"Lannister","firstName":"Jaime","age":45},{"id":4,"lastName":"Stark","firstName":"Arya","age":16},{"id":5,"lastName":"Targaryen","firstName":"Daenerys","age":90},{"id":6,"lastName":"Melisandre","firstName":"Tom","age":150},{"id":7,"lastName":"Clifford","firstName":"Ferrara","age":44},{"id":8,"lastName":"Frances","firstName":"Rossini","age":36},{"id":9,"lastName":"Roxie","firstName":"Harvey","age":65},]dv.data_visualizer(title="Data Visualization",data=data,key="data_visualizer",)Screenshot
Package: bpe
BPEAKA Byte Pair Encoding.  Learns a vocab and byte pair encoding for provided white-space separated text.Usage$pip3installbpefrombpeimportEncoder# Generated with http://pythonpsum.comtest_corpus='''Object raspberrypi functools dict kwargs. Gevent raspberrypi functools. Dunder raspberrypi decorator dict didn't lambda zip import pyramid, she lambda iterate?Kwargs raspberrypi diversity unit object gevent. Import fall integration decorator unit django yield functools twisted. Dunder integration decorator he she future. Python raspberrypi community pypy. Kwargs integration beautiful test reduce gil python closure. Gevent he integration generator fall test kwargs raise didn't visor he itertools...Reduce integration coroutine bdfl he python. Cython didn't integration while beautiful list python didn't nit!Object fall diversity 2to3 dunder script. Python fall for: integration exception dict kwargs dunder pycon. Import raspberrypi beautiful test import six web. Future integration mercurial self script web. Return raspberrypi community test she stable.Django raspberrypi mercurial unit import yield raspberrypi visual rocksdahouse. Dunder raspberrypi mercurial list reduce class test scipy helmet zip?'''encoder=Encoder(200,pct_bpe=0.88)# params chosen for demonstration purposesencoder.fit(test_corpus.split('\n'))example="Vizzini: He didn't fall? INCONCEIVABLE!"print(encoder.tokenize(example))# ['__sow', 'vi', 'z', 'zi', 'ni', '__eow', '__sow', ':', '__eow', 'he', 'didn', "'", 't', 'fall', '__sow', '?', '__eow', '__sow', 'in', 'co', 'n', 'ce', 'iv', 'ab', 'le', '__eow', '__sow', '!', '__eow']print(next(encoder.transform([example])))# [26, 108, 79, 104, 72, 24, 26, 117, 24, 9, 11, 8, 12, 10, 26, 90, 24, 26, 154, 56, 37, 149, 80, 169, 84, 24, 26, 156, 24]print(next(encoder.inverse_transform(encoder.transform([example]))))# vizzini : he didn ' t fall ? inconceivable !
Package: bpelib
coveragetestsByte Pair Encoding for Natural Language Processing.InstallationInstall with pip:pip install bpelibUninstallingUninstall with pip:pip uninstall bpelibUsageImport the BPE class.frombpelibimportbpeLearn encoding on construct or at a later time:bpe=BPE(['start','learning','now'])# or ...bpe.learn_encoding(['start','learning','now'])To encode or decode a word, simply call the BPE object.encoded=bpe('encode')# '<w/> e n c o d e </w>'decoded=bpe(encoded)# 'encode'assert'encode'==decodedYou can call encode or decode explicitly, too.encoded=bpe.encode('encode')# '<w/> e n c o d e </w>'decoded=bpe.decode(encoded)# 'encode'assert'encode'==decodedYou can also specify maximum vocabulary size and the used encoding.bpe=BPE(max_vocab_size=1024,encoding='ascii')
Package: bpf2eaf
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the “Software”), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
Description: # BPF2EAFThis package provices code to convert BAS Partitur Formate (BPF) files to
ELAN files. Internally the [pympi](https://github.com/dopefishh/pympi) package is used for the file handling.If you have any problems using this package, contact [Thomas Kisler](mailto:kisler@bas.uni-muenchen.de).Platform: UNKNOWN
Classifier: Programming Language :: Python :: 3
Classifier: License :: OSI Approved :: MIT License
Classifier: Operating System :: OS Independent
Description-Content-Type: text/markdown
Package: bp-fabric-search
Fabric SearchQuickly search endpoints and routing tables across a large number of APIC's and display the results in a table.Endpoints can be searched using the following criteria:MAC AddressIP AddressIP NetworkNodeRoute can be search using the following criteria:PrefixVRFIt is also possible to do searches based on partial data. for example the last 4 characters of a MAC address.Installationpipinstallbp-fabric-searchUsageInventory FileAn simple inventory file is used to store a list of APIC's to search. This is a YAML file with a name and host key----name:FABRIC-1host:https://10.1.0.1-name:FABRIC-2host:https://10.2.0.1Environment VariablesThe following environment variables are required for the script to run, these can be set using
theEXPORTcommand or loaded in at runtime from a .env file.INVENTORY_USERNAME="USERNAME"
INVENTORY_PASSWORD="PASSWORD"

# Optional value for path to inventory file
# if not included it will default to inventory.yml

INVENTORY_PATH=path/to/my/inventory.ymlEndpoint SearchesSearch by Nodefabric-searchnode--id101Search by MACfabric-searchmac-m00:50:56:85:6F:F9Search by Network / IPfabric-searchip--network10.96.0.0/16fabric-searchip--host10.96.252.1ResultSkippedHosts:
Timetaken:0.20seconds.


+----------+-------------------+---------------+---------------+-----+-------+------+-----------+---------+|Host|MAC|IP|Tenant|EPG|Encap|Node|Interface|Source|+----------+-------------------+---------------+---------------+-----+-------+------+-----------+---------+|FABRIC-1|00:50:56:85:EF:89|10.96.252.102|CUST-TENANT-2||1411|101|eth1/10|learned||FABRIC-1|00:50:56:85:EF:89|10.96.252.86|CUST-NET-SVCS||1413|101|eth1/10|learned|+----------+-------------------+---------------+---------------+-----+-------+------+-----------+---------+Route SearchesSearch by Prefixfabric-searchroute--prefix10.96.0.0/24Search by Prefix and VRFfabric-searchroute--prefix10.96.0.0/24--vrfFRASER-LAB:FRASER-LABSearch by exact prefixfabric-searchroute--prefix10.96.0.0/24--exactResultSkippedHosts:FABRIC-2
QueryType:route
Timetaken:5.13seconds.


+-----------+---------------+-------+--------+------+------------------+------+-------------+-----------------------+|Host|Route|Type|Metric|Pref|NextHop|Node|Interface|Vrf|+-----------+---------------+-------+--------+------+------------------+------+-------------+-----------------------+|FABRIC-1|0.0.0.0/0|ebgp|0|20|10.96.252.255/32|102|unspecified|FRASER-LAB:FRASER-LAB||FABRIC-1|10.96.0.30/32|local|0|0|10.96.0.30/32|102|vlan25|FRASER-LAB:FRASER-LAB||FABRIC-1|10.96.0.62/32|local|0|0|10.96.0.62/32|102|vlan23|FRASER-LAB:FRASER-LAB||FABRIC-1|0.0.0.0/0|ebgp|0|20|10.96.252.253/32|101|unspecified|FRASER-LAB:FRASER-LAB||FABRIC-1|10.96.0.30/32|local|0|0|10.96.0.30/32|101|vlan23|FRASER-LAB:FRASER-LAB||FABRIC-1|10.96.0.62/32|local|0|0|10.96.0.62/32|101|vlan29|FRASER-LAB:FRASER-LAB|+-----------+---------------+-------+--------+------+------------------+------+-------------+-----------------------+
Package: bpf-asm
Python BPF Assembler.Based on the BPF assembler in Linux sources.InstallationsWheels are available.To build from source you need a relatively recent Flex & Bison:On Windows, you can usewinflexbison.On macOS (and sometimes on Linux, on older distributions), you can install them fromHomebrew. Note that you might have to add Homebrew’s version to the front of thePATH, e.g.PATH="$(brew--prefix)/opt/flex/bin:$(brew--prefix)/opt/bison/bin:$PATH".Usageimportbpf_asmASM="""\ldh [12]
    jeq #0x800, accept, drop
accept:
    ret #65536
drop:
    ret #0
"""print(bpf_asm.assemble(ASM))Or use thepybpf_asmscript. Seepybpf_asm--helpfor usage.LicenseGPL-2.0-only.
Package: bpfmaps
PybpfmapsSimple standalone python library to interact with bpf/ebpf maps via libbpf bindings.This project aims to ease communication with eBPF programs using eBPF maps.Installationpip install bpfmapsNo need for any other dependencies, because the libbpf binary is built from source inside thegithub actionand included in the python package.
You can verify its authenticity by comparing the hashes of the pypi package with the ones printed in the github action that released it.Usageimportbpfmapsmy_map=bpfmaps.BPF_Map.get_map_by_name('some_global')my_map[0]=10ContributingDependenciesTo locally work on this project you need to get the libbpf binary and put it into src/bpfmaps/libbpf/This can be done by extracting it from the pypi package or building from source:gitclone--recurse-submodulesgit@github.com:PeterStolz/pybpfmaps.gitcdpybpfmaps/dependencies/libbpf/srcOBJDIR=../../../src/bpfmaps/libbpf/makecd../../../To install the build dependencies you may run:sudoapt-getupdate
sudoapt-getinstallclangllvmlibelf-devlibpcap-devgcc-multilibbuild-essentiallinux-libc-devTestingThis project uses pytest for testing and the tests forx.pyare stored in the filetest_x.py.
As working with eBPF maps requires root you can execute the tests with:sudo python3.10 -m pytest ./srcThe tests may leave some bpf maps lying around, but they will perish after a reboot.
Package: bph-pal
BPH PAL (Bluepill Hat Protocol Abstraction Layer)DescriptionProvides both a simple shell interface, some useful CLI commands and a bootloader for the BPH.
Simplifies dealing with pinouts with a json config file.
Simplifies installation with a pip package.bph_pal installationTo install bph_pal use the python3 pip package.pip3 install bph_palUsage of bph_palTo use the CLI calls check the help.python3 -m bph_pal -hFor using the interactive shell, for example when testing.bph_shellFor bootloading PHiLIP the port should be specified on the Raspberry Pi if another board is plugged in.bootload_philip -p /dev/ttyAMA0 -e -w -v -pv <PHiLIP_VERSION>The-hcan also be used to see optional parameters.
Package: bpipe
# basic-pipelinebasic-pipeline (or *bpipe*) is a minimal &amp; simple pipeline engine for Python- [Getting Started](#getting-started)- [Examples](#examples)- [Installation](#installation)- [Tests](#tests)- [Tutorial](#tutorial)- [Reference](#reference)## Getting Started## Examples```pythonfrom bpipe import *for r in echo("Hello World") | map_to(lambda x: x.upper()):print(r)# HELLO WORLD```### InstallationJust install it with the pip client:```bashpip install bpipe```Or from source code:```pythongit clone https://github.com/jepemo/basic-pipelinecd basic-pipelinepython3 -m venv venvsource venv/bin/activatepip install -e .```### Tests```pythonpython setup.py test```## [Tutorial](docs/tutorial.md)## [Reference](docs/reference.md)
Package: bpl
bplbplis a python 3 library for fitting Bayesian versions of the Dixon & Coles (1997) model to data.
It uses thestanlibrary to fit models to data.InstallationpipinstallbplUsagebplprovides a classBPLModelthat can be used to forecast the outcome of football matches.
Data should be provided to the model as apandasdataframe, with columnshome_team,away_team,home_goalsandaway_goals.
You can also optionally provide a set of numerical covariates for each team (e.g. their ratings on FIFA) and these will be used in the fit.
Example usage:importbplimportpandasaspddf_train=pd.read_csv("<path-to-training-data>")df_X=pd.read_csv("<path-to-team-level-covariates>")forecaster=bpl.BPLModel(data=df_train,X=df_X)forecaster.fit(seed=42)# calculate the probability that team 1 beats team 2 3-0 at home:forecaster.score_probability("Team 1","Team 2",3,0)# calculate the probabilities of a home win, an away win and a draw:forecaster.overall_probabilities("Team 1","Team 2")# compute home win, away win and draw probabilities for a collection of matches:df_test=pd.read_csv("<path-to-test-data>")# must have columns "home_team" and "away_team"forecaster.predict_future_matches(df_test)# add a new, previously unseen team to the model by sampling from the priorX_3=np.array([0.1,-0.5,3.0])# the covariates for the new teamforecaster.add_new_team("Team 3",X=X_3,seed=43)Statistical modelThe statistical model behindbplis a slight variation on the Dixon & Coles approach.
The likelihood is:where y_h and y_a are the number of goals scored by the home team and the away team, respectively.
a_i is theattacking aptitudeof team i and b_i is thedefending aptitudeof team j.
gamma_i represents the home advantage for team i, and tau is a correlation term that was introduced by Dixon and Coles to produce more realistic scorelines in low-scoring matches.
The model uses the following bivariate, hierarchical prior for a and bX_i are a set of (optional) team-level covariates (these could be, for example, the attack and defence ratings of team i on Fifa).
beta are coefficient vectors, and mu_b is an offset for the defence parameter.
rho encodes the correlation between a and b, since teams that are strong at attacking also tend to be strong at defending as well.
The home advantage has a log-normal priorFinally, the hyper-priors are
Package: bpl-api
BPL APIA simple Python API for the Blockpool blockchainThis is a easy-to-use Python API for interacting with a Blockpool blockchain. This API provides a Python wrapper for the majority of the API endpoints forBPL-NodeFeaturesAccounts EndpointRetrieve an accountRetrieve the balance of an accountRetrieve the public key of an accountRetrieve the delegate registration feeRetrieve the voted delegate of an accountBlocks EndpointRetrieve for a blockList all blocksRetrieve the epoch of the blockchainRetrieve the height of the blockchainRetrieve the nethash of the blockchainRetrieve a feeList all fees of the blockchainRetrieve the milestone of the blockchainRetrieve the reward of the blockchainRetrieve the supply of the blockchainRetrieve the status of the blockchainDelegates EndpointRetrieve a delegateRetrieve the total count of delegatesRetrieve the delegate registration feeRetrieve the total forged of a delegateList all voters of a delegateList all delegatesSearch all delegatesList the next forgersRetrieve the forging status of a delegateLoader EndpointRetrieve the status of the connected nodeRetrieve the synchronisation status of the connected nodeRetrieve the configuration of the connected nodeMultisignature EndpointRetrieve the pending multisignature transactions of an accountRetrieve a multisignature accountPeers EndpointRetrieve a peerList all peersRetrieve the core versionSignatures EndpointRetrieve the signature registration feeTransaction EndpointRetrieve a transactionList all transactionsRetrieve an unconfirmed transactionList all unconfirmed transactionsSend a transactionEndpoint EntityGETPOSTPUTDELETEInstallationpipinstallbpl-apiNote: not working as of 2018-07-26UsageThere are 8 API endpoints in bpl-api:accountsblocksdelegatesloadermultisignaturespeerssignaturestransactionsEach endpoint can be accessed using theClientinterface, for example:frombpl_apiimportClientaccounts_endpoint=Client("s01.mc.blockpool.io:9030").api("accounts")See the documented code for how each endpoint may be used.Security or ErrorsIf you discover a security vulnerability or error within this package, please emailmeor message me on theBPL discord.CreditsAlistair O'Brien
Package: bplate
bplatebplate is a command line tool that allows you to create and store boilerplates.Using bplate, you can store a directory as boilerplate template and easily
generate a boilerplate later using a simple command within matter of seconds.InstallationPython 3.8 or higher is required to use this tool.bplate can easily be installed using thepippackage manager:python -m pip install bplateBasic UsageTo start using bplate, you first need to store a directory as boilerplate template. In
order to do that, use thebplate newfollowed by path of directory:bplate new .\web-app-templateWhen prompted for boilerplate name, enter a name which will be used to reference to
boilerplate later:$ bplate new .\web-app-template
...
Boilerplate name: simple-web-app
...Once the boilerplate has been created, you can use thebplate initcommand to easily
generate boilerplate in a directory. The first argument is name of boilerplate that we
set earlier and second argument is the path where boilerplate is being generated:bplate init simple-web-app .\my-web-app-projectCustomizationOne of the main focus of bplate is to provide maximum customization and while this project
is in its early stages and there are not many options yet, we are constantly working on
bringing more customization options to the CLI.When you create a boilerplate using thebplate new, abplate_config.jsonfile is
created in the root directory that can be edited to modify various aspect of the
boilerplate.For all customization options, see theCustomizationpage on the documentation.Contributingbplate is currently in its early stage and we are constantly working on improving this
tool. You can help us improve bplate and any contribution in this regard will be
appreciated.For more information, see theContributing to bplatepage on the documentation.
Package: bplib
Thebplibis a library implementing support for computations on groups supporting
bilinear pairings, as used in modern cryptography.It is based on the OpenPairing library by
Diego Aranha (https://github.com/dfaranha/OpenPairing), which is itself based on, and compatible
with, OpenSSL math functions (bnandec). Thebplibis compatible withpetlibtypes
includingpetlib.bnand the group G1 is apetlib.ecEC group. Along withpetlib,
they provide easy to use
support for maths and ciphers used in modern Privacy Enhancing Technologies.”A set of bilinear EC groups is defined as:>>> G = bp.BpGroup()Such a BpGroup describes 3 groups G1, G2 and GT such that pair(G1,G2)->GT. Generators
for the groups G1 and G2 are denoted by:>>> g1, g2 = G.gen1(), G.gen2()The specialpairoperation computes to pairing into GT:>>> gt = G.pair(g1, g2)Operations are defined on all elements of G1, G2 or GT in a natural additive infix notation for G1 and G2, and a multiplicative notation for GT:>>> gt6 = gt**6As expected thepairoperations is additive:>>> G.pair(g1, 6*g2) == gt6
True
>>> G.pair(6*g1, g2) == gt6
True
>>> G.pair(2*g1, 3*g2) == gt6
True
Package: bplib-fork
Thebplibis a library implementing support for computations on groups supporting
bilinear pairings, as used in modern cryptography.It is based on the OpenPairing library by
Diego Aranha (https://github.com/dfaranha/OpenPairing), which is itself based on, and compatible
with, OpenSSL math functions (bnandec). Thebplibis compatible withpetlibtypes
includingpetlib.bnand the group G1 is apetlib.ecEC group. Along withpetlib,
they provide easy to use
support for maths and ciphers used in modern Privacy Enhancing Technologies.”A set of bilinear EC groups is defined as:>>> G = bp.BpGroup()Such a BpGroup describes 3 groups G1, G2 and GT such that pair(G1,G2)->GT. Generators
for the groups G1 and G2 are denoted by:>>> g1, g2 = G.gen1(), G.gen2()The specialpairoperation computes to pairing into GT:>>> gt = G.pair(g1, g2)Operations are defined on all elements of G1, G2 or GT in a natural additive infix notation for G1 and G2, and a multiplicative notation for GT:>>> gt6 = gt**6As expected thepairoperations is additive:>>> G.pair(g1, 6*g2) == gt6
True
>>> G.pair(6*g1, g2) == gt6
True
>>> G.pair(2*g1, 3*g2) == gt6
True