Saravanan666/pypi-org huggingface dataset:
Package: bloomfilter-py
bloomfilter-pyOverviewYet another Bloomfilter implementation in Python, compatible with Java's Guava library.I was looking for a Python library which is capable of reading what Bloomfilter of Java's Guava library serializes and is also able to output byte array which is recognizable by Java. But unfortunately failed. Hence I developed this library by borrowing how Guava implements Bloomfilter serialization/deserialization a lot to deal with Bloomfilters on both Python and Java sides.As for Bloomfilter usage in Java world, please refer tothis post.Here's a briefintroductionto Bloomfilter.RequirementsPython 3.7+This library is not tested under Python 3.6 and lower versions.Installpip install bloomfilter-pyUsage ExamplesBasic Usage>>>frombloomfilterimportBloomFilter>>>bloom_filter=BloomFilter(expected_insertions=500,err_rate=0.01)>>>foriinrange(100):...bloom_filter.put(i)...>>>1inbloom_filterTrue>>>100inbloom_filterFalse>>>Serialize BloomfilterYou can easily serializeBloomFilterinstance to a byte array>>>dumps=bloom_filter.dumps()>>>withopen("dumps.out","wb")asf:...f.write(dumps)...>>>or to a hex string>>>hex_str=bloom_filter.dumps_to_hex()or to a base64 encoded bytesbase64_bytes=bloom_filter.dumps_to_base64()Deserialize BloomfilterAnd you can easily initialize aBloomFilterinstance from a byte array>>>withopen("dumps.out","rb")asf:...bf=BloomFilter.loads(f.read())...>>>1inbfTrue>>>100inbfFalse>>>or from a hex string>>>bf=BloomFilter.loads_from_hex(hex_str)>>>1inbfTrue>>>100inbfFalseor from a base64 encoded bytes>>>bf=BloomFilter.loads_from_base64(base64_bytes)>>>100inbfFalse>>>200inbfFalse>>>1inbfTrue>>>99inbfTrue
Package: blooming
blooming===============================version number: 1.0.8author: LuxebengOverview--------`blooming` Framework is a generic open source test automation framework for acceptance test-driven development (ATDD). which is operating system and application independent. The core framework is implemented using Python 3.Project is hosted on [GitHub](https://github.com/luxebeng/blooming) where you can find source code, an issue tracker, and some further documentation.Installation------------To install use pip:$ pip install bloomingOr clone the repo:$ git clone https://github.com/luxebeng/blooming.git$ python setup.py installHow does it work----------------The test suites is component with series independent module, and all of them can be executed in sequence.For each test case, device and configuration file are abstracted as an object. which is defined as a .json file, and all the operation is defined as member function of an object.For different there are command lists on devices from different vendor, so there is a SAL layer to adapt the commands for different in future. but now it's called directly.The simple sketch is as follows:![SW_architecture](docs/media/SW_architecture.png)Example-------at the root folder, there is 2 json files are provided.`dev.json:`       which define the device information. which is static for a special devices.```***device information***{"bj340g":{"device name": "srx340g",            # device name"MGT IP address": "10.208.128.161",  # login IP address"port number": 22,                   # ssh login portID"ssh user": "root",                  # ssh login user"passwd": "Embe1mpls"                # ssh login passwd}}````xxxx_conf.json`: which is config related information. which is depended on the topology of testbed and configuration.```{"bj340g":{"l2 port":{"ge-0/0/5":{"peer":{"dev":"bj300a","port":"ge-0/0/5"}}},"l3 intf":{"irb.20":{"ip addr":"20.0.0.20"}}}}```There is a detail document about L2NG test suites. please refer to documents of [L2NG Test suites](./docs/l2ng_test_sutes.md).Contributing------------TBD
Package: bloomlib
______  ______                          ___________ ______  
___  /_ ___  /______ ______ _______ ___ ___  /___(_)___  /_ 
__  __ \__  / _  __ \_  __ \__  __ `__ \__  / __  / __  __ \
_  /_/ /_  /  / /_/ // /_/ /_  / / / / /_  /  _  /  _  /_/ /
/_.___/ /_/   \____/ \____/ /_/ /_/ /_/ /_/   /_/   /_.___/bloomlib: superfast Bloom filters for Python, optimized in RustPackageMetabloomlibis a Python package that provides superfast Bloom filters, designed to
optimize your applications in an easy and intuitive way.
It aims to be the go-to package to build and use Bloom Filters that make your applications
superfast, memory-efficient and user-friendly.pipinstallbloomlibTable of ContentsMain FeaturesUsage ExampleInstallationDependenciesLicenseDocumentationDevelopmentContributing to bloomlibMain Features🦀 Built in Rust⚡ Highly optimized for speed and memory-efficiency👨‍🎨 User-friendlyUsage ExamplefrombloomlibimportBloomFilter# 1. Create the filterbf=BloomFilter(expected_number_of_items=1_000,desired_false_positive_rate=0.05)# 2. Add itemsforiinrange(100):bf.add(item=i)# 3. Check if an item is contained; False means definitely not, True means "maybe"if(bf.contains(item=42)):print("This item may be in filter")else:print("This item is definitely not in the filter")InstallationpipinstallbloomlibThe source code is currently hosted on GitHub at:https://github.com/mike-huls/bloomlibBinary installers for the latest released version are available at thePython
Package Index (PyPI).DependenciesBloomlib has no Python dependenciesLicenseMITDocumentation🔨 Under constructionDevelopmentFind the changelog and list of upcoming featureshere.Contributionsare always welcome; feel free to submit bug reports, bug fixes, feature requests, documentation improvements or enhancements!Go to Top
Package: bloom-python-driver
bloom-python-driver=========Pybloom provides a Python client library to interface withbloomd servers. The library supports multiple bloomd servers,and automatically handles filter discovery and sharding.Features--------* Provides a simple API for using bloomd* Allows for using multiple bloomd servers- Auto-discovers filter locations- Balance the creation of new filters- Explicitly name the location to make filters* Command pipelining to reduce latencyInstall-------Download and install from source:python setup.py installExample------Using pybloom is very simple, and is similar to using native sets::from pybloom import BloomdClient# Create a client to a local bloomd server, default portclient = BloomdClient(["localhost"])# Get or create the foobar filterfoobar = client.create_filter("foobar")# Set a property and check it existsfoobar.add("Test Key!")assert "Test Key!" in foobarTo support multiple servers, just add multiple servers::from pybloom import BloomdClient# Create a client to a multiple bloomd servers, default portsclient = BloomdClient(["bloomd1", "bloomd2"])# Create 4 filters, should be on different machinesfor x in xrange(4):client.create_filter("test%d" % x)# Show which servers the filters are on by# specifying the inc_server flagprint client.list_filters(inc_server=True)# Use the filtersclient["test0"].add("Hi there!")client["test1"].add("ZING!")client["test2"].add("Chuck Testa!")client["test3"].add("Not cool, bro.")Using pipelining is straightforward as well::from pybloom import BloomdClient# Create a client to a local bloomd server, default portclient = BloomdClient(["localhost"])# Get or create the foobar filterpipe = client.create_filter("pipe").pipeline()# Chain multiple add commandsresults = pipe.add("foo").add("bar").add("baz").execute()assert results[0]assert results[1]assert results[2]
Package: bloonspy
BloonsPyBloonsPy is a Python wrapper for theNinja Kiwi Open Data API,
that makes you write more readable code and handles rate limiting automatically.
It also renames cryptic variable names so you can know what you're doing while coding.InstallingPython 3.10 or higher is requiredpython3-mpipinstallbloonspyQuick examplefrombloonspyimportClientboss_event=Client.bosses()[0].standard()boss_standard_top_3=boss_event.leaderboard()[:3]forplayerinboss_standard_top_3:print(f"{player.name}-{player.score}")ResourcesDocumentationGithub
Package: blopic
blopic (blog-post-image-converter)Descriptionblopic(forblog-postimageconverter ) is a CLI tool developed to convert and resize image to good format & size for blog post.Dependenciesclickto easily create a CLIInstallationWithpippip install blog-post-image-converterWith Dockerdocker pull romaiiiinnn/blopicUsageUsage: blopic [OPTIONS] IMAGE_PATHResizes an image based on a target width passed as a parameter, thenconverts it to the WebP format.Options:--version                   Show the version and exit.-w, --width INTEGER RANGE   Target width of the image  [default: 1200; x>0]-o, --output-dir DIRECTORY  Output directory  [default: .]-d, --delete                Delete source image after conversion.--help                      Show this message and exit.ExamplesFollowing command will create image namedimage.webpwith a width of 1200px in current directory.With installed packageblopic image.jpegWith Dockerdocker run --rm -v ${PWD}:/data -w /data romaiiiinnn/blopic image.jpegSupportGot questions?You couldopen an issue here.ContributingThis is an active open-source project. I am always open to people who want to use the code or contribute to it.Thank you for being involved! :heart_eyes:Authors & contributorsThe original setup of this repository is byRomain RICHARD.LicenseEvery details about licence are in aseparate document.
Package: blossalg
blossalgblossalg is a Python implementation of the Edmonds algorithm for constructing maximum matchings on graphs.
For more information on how the Edmonds algorithm works see theWikipediapage.InstallationYou can install blossalg from PyPI:pipinstallblossalgblossalg is supported on Python 2.7 and Python 3.8.UsageYou can run blossalg as follows:blossalginfile.csv[outfile.txt]The input fileinfile.csvcontains information on the number of nodes and the neighbours
of each node. This information is stored using a series of comma-delimited
binary-valued strings. Nodes are identified by different rows and columns
and a value of 1 indicates a node neighbour. By convention a node cannot be
a neighbour with itself.For example, the input file of a three node graph where both node 0 and node 2
are neighbours of node 1 would look as follows:0,1,0
1,0,1
0,1,0Given an input file, blossalg will compute the maximum matching
using the Edmonds blossom algorithm. The total number of
matched nodes will then be output to screen.If an output fileoutfile.txtis supplied the matched pairs from the
maximal matching will be saved to the file. The format of the output is as follows.
Each node and its matched node will be stored asnode_number: matched_node_number.
The node number will correspond to the node number from the input file (e.g. row 1
in the input file will represent node 0 in the output file). Each matched pair in
the output file will be separated by a newline. By convention, unmatched nodes are
not included in the outfile.
Package: blossompy
Blossom PackageThis python package includes all the basics necessary to run your
Blossom robot to make it perform various gestures and sequences, creating a
seamless platform for you to create sequences and run them from your laptop.About BlossomBlossom is a socially assistive robot developed by Cornell university.
Learn more about Blossom [here] (https://spectrum.ieee.org/automaton/robotics/home-robots/blossom-a-creative-handmade-approach-to-social-robotics-from-cornell-and-google).Some examples of a Blossom robot are here:Version 1.0.0-Change logInstall BlossompyBlossompy is fully available for Mac (OS X) and Linux. We are currently developing an
implementation for Windows.To install, run:pip install blossompyAlternatively, you may have to run:pip3 install blossompyRunning BlossompyTo execute this package and run commands for your Blossom robot from the command line,
plug in your Blossom and use:python -m blossompy
Package: blosum
A small module for easy access to BLOSUM matrices without dependencies.The BLOcks SUbstitution Matrices (BLOSUM) are used to score alignments between protein sequences and are therefore mainly used in bioinformatics.Reading such matrices is not particularly difficult, yet most off the shelf packages are overloaded with strange dependencies.
And why do we need to implement the same reader again if there is a simple module for that.blosumoffers a robust and easy-to-expand implementation without relying on third-party libraries.InstallationUsing pip  / pip3:pipinstallblosumOr by source:gitclonegit@github.com:not-a-feature/blosum.gitcdblosum
pipinstall.Or by conda:condainstallblosumHow to useDefault BLOSUMThis package provides the most commonly used BLOSUM matrices.
You can choose from BLOSUM 45, 50, 62, 80 and 90.To load a matrix:importblosumasblmatrix=bl.BLOSUM(62)val=matrix["A"]["Y"]Custom matrixIn addition, own matrices can be loaded. For this, the path is given as an argument.importblosumasblmatrix=bl.BLOSUM("path/to/blosum.file")val=matrix["A"]["Y"]The matrices are required to have following format:# Comments should start with #
# Each value should be seperated by one or many whitespace
   A  R  N  D
A  5 -2 -1 -2
R -2  7  0 -1
N -1  0  6  2
D -2 -1  2  7Getting values:Once loaded thematrixbehaves like adefaultdict.
To get a value use:val=matrix["A"]["Y"]To get a defaultdict of the row with a given key use:val_dict=matrix["A"]If the key cannot be found, the default valuefloat("-inf")is returned.
It is possible to set a custom default score:matrix=bl.BLOSUM(62,default=0)LicenseCopyright (C) 2023 by Jules Kreuer - @not_a_feature
This piece of software is published unter the GNU General Public License v3.0
TLDR:

| Permissions      | Conditions                   | Limitations |
| ---------------- | ---------------------------- | ----------- |
| ✓ Commercial use | Disclose source              | ✕ Liability |
| ✓ Distribution   | License and copyright notice | ✕ Warranty  |
| ✓ Modification   | Same license                 |             |
| ✓ Patent use     | State changes                |             |
| ✓ Private use    |                              |             |Go toLICENSE.mdto see the full version.DependenciesIn addition to packages included in Python 3, this piece of software uses 3rd-party software packages for development purposes that are not required in the published version.
Go toDEPENDENCIES.mdto see all dependencies and licenses.
Package: blotly
Blotblot基于plotly和cufflinks，是一个进程安全，比plotly更简约，比cufflinks更快的python动态图可视化库。更贴近日常使用场景，便捷的绘制基带、简单的静态图像转换存储…结合pandas的Series和DataFrame使用（monkey patching），仅需一行代码即可完成各类图表构建。安装方式pip3 install blotly下载源码。进入项目根目录执行 python setup.py install使用方式具体参照文档：Blot.pdf版本历史v1.0.0解决一些bug，支持多进程精简项目，优化参数和注释增加基带绘制和相关控制参数支持便捷的静态图保存……示例importpandasaspdimportnumpyasnpimportblotpd.DataFrame({'upper':np.random.randint(30,40,50),'lower':np.random.randint(10,20,50),'value1':np.random.randint(15,65,50),'value2':np.random.randint(0,20,50),}).blot(upper='upper',lower='lower',color='blue')
Package: blowtorch-py
BlowtorchBlowtorch is a Python package that allows you to train machine learning models
and run inference in pure Rust. This is done through a specifying the model
once in a JSON file. Blowtorch then exports your specification into Rust and Python
models. You can train the Python model as you prefer, and Blowtorch can be run again
to share the weights to Rust.An example application built with a predecessor of Blowtorch isZipNet,
which is a neural-network based compression algorithm run entirely in the browser.
We built Blowtorch as we could not find any easily extensible machine learning frameworks
that could be compiled to WebAssembly.Advantages over similar packagesInference is in pure Rust, meaning your model can run anywhere that Rust runs. You can for example compile it to WebAssembly.New layers can be implemented very easily, as one just has to write a forward pass in RustTraining is completely in Python, meaning you can use whatever training procedures you likeComplex networks can be built by splitting the architecture into simpler modules, which are combined together by some glue codeOur documentation can be found athttps://blowtorch.readthedocs.io/en/latest/.FeaturesExport and import trained weightsImplementations for the following layers:ConvConvTReLUGDNiGDNFlattenLinearEasy-to-use examplePossibilities to extend the frameworkDocumentation for Python & Rust
Package: bloxberg-cert-schema
cert-schemaBlockchain Certificate schemas implement those ofVerifiable Credentials. As with Verifiable Credentials, we've provided both a JSON-LD context and JSON schema. The purpose of the JSON-LD context is to map types to Internationalized Resource Identifiers (IRIs), providing semantic context for data. The JSON Schema is used for syntactic validation.This python package allows verification of a Blockchain Certificate against the JSON
schemas as a convenience. This is not the same as verifying the contents of a certificate against what is stored
on the blockchain. See thecert-verifier-jsproject.Blockcerts JSON SchemaExampleTODO update for V3 once cert-issuer issues oneThe following is a Blockchain Certificate issued on the testnet Bitcoin network.{"@context":["https://www.w3.org/2018/credentials/v1","https://www.blockcerts.org/schema/3.0-alpha/context.json","https://www.w3.org/2018/credentials/examples/v1"],"id":"urn:uuid:bbba8553-8ec1-445f-82c9-a57251dd731c","type":["VerifiableCredential"],"issuer":"did:example:23adb1f712ebc6f1c276eba4dfa","issuanceDate":"2010-01-01T19:73:24Z","credentialSubject":{"id":"did:example:ebfeb1f712ebc6f1c276e12ec21","alumniOf":{"id":"did:example:c276e12ec21ebfeb1f712ebc6f1"}},"signature":{"type":"MerkleProof2019","created":"2020-01-21T12:32:11.693759","proofValue":"z2LuLBVSfnVzaQtvzuA7EaPQsGEgYWeaMTH1p3uqAG3ESx9HYyFzFFrYsyPkZSbn1Ji5LN76jw6HBr3oiaa8KsQenCPqKk7dJvxEXsDnYvhuDHtsrSRbzHdJKd66jAowkzPxPFi3ivyAv7WRK1WV2VhegYVQEnCBTrGJWFUMFFXunTcus7ZyedQvS4sr61X2y8QuJ57ycB5JMEHvUgAVq3qh2g3ucehg2ERKLo98jmqTcsh9HThkECG3BTNYRD3QL7AHWPjxRbQNSA83QNYXcCNA7NaZnCWyjC17ZBj3xszp76XvqFRrLjQbRSbzjVTPtBSV8QjhxThT3KTfgwjRn5JeeXhYvebsTT9YGL3W4ufzFRDpH79n5KPiaj1BPbEUfUq7vf2dg26QWeZBi7ME56","proofPurpose":"assertionMethod","verificationMethod":"ecdsa-koblitz-pubkey:0x7e30a37763e6Ba1fFeDE1750bBeFB4c60b17a1B3"}}Publishing package to pypiFirst time infoPublish script:./release_package.shUnit testsThis project uses tox to validate against several python environments.Ensure you have an python environment.RecommendationsRun tests./run_tests.shCompile markdown from schemaNote that json-schema-to-markdown doesn't handle ref schemas well, so you will
need to manually update any 'undefined' references.scripts/generate_markdown.jsbuilds the markdown-formatted schemas from jsonContactContact us atthe Blockcerts community forum.
Package: bloxflippredictor
bloxflippackageExamplesCrashimportbloxflippredictoro=bloxflippredictor.crashvarName=o.crashpredictor()#  varName returns a dict {{'crashchance': str(chance), 'crashprediction': str(prediction)}chance=varName[crashchance]prediction=varName[crashprediction]print(chance,prediction)Minesimportbloxflippredictoro=bloxflippredictor.minesoutput=o.minespredictor(tileo,bombs)# tileo = How many tiles the user wants to open  # bombs = how many bombs on the fieldprint(output)Towersimportbloxflippredictoro=bloxflippredictor.towersoutput=o.towerspredictor()print(output)Rouletteimportbloxflippredictoro=bloxflippredictor.rouletteoutput=o.roulettepredictor()print(output)
Package: bloxlink.py
bloxlink.pyOverviewBloxlink.py is a lightweight wrapper for theBloxlinkAPI.InstallationTo install the latest stable version of bloxlink.py, run the following command:python3 -m pip install bloxlink.pyTo install the latestunstableversion of bloxlink.py, installgit-scmand run the following:python3 -m pip install git+https://github.com/Redacted-Nac/bloxlink.py.gitBasic UsageFetch ROBLOX user ID from Discord ID with the guild APIfromsrcimportbloxlinkclient=bloxlink.Bloxlink(token="YOUR TOKEN HERE",guild=GUILDIDHERE)userid=client.guild_discord_to_roblox(userid=IDHERE)print(userid)Fetch Discord user ID from ROBLOX ID with the guild APIfromsrcimportbloxlinkclient=bloxlink.Bloxlink(token="YOUR TOKEN HERE",guild=DISCORDGUILDIDHERE)userid=client.guild_roblox_to_discord(userid=IDHERE)print(userid)
Package: bloxone
The Infoblox BloxOne suite of applications provides a RESTful API that is
published using Swagger onhttps://csp.infoblox.com/apidocalong with other
Infoblox APIs.This module aims to provide a class hierarchy to simplify access to these
published APIs, performing the ‘heavy lifting’ whilst providing full access to
to their functionality. This is achieved by providing simple wrappers that enable
you to take the swagger documented object paths, fields and where appropriate
JSON body from the documentation and pass them to simple get, create, delete and
update methods. These methods simply return arequestsresponse object.In addition, useful utility methods are provided for common tasks such as
getting an object id, by defining the object key and value match pair. This is
combined with several (currently) undocumented API calls.Some basic configuration, such a base url, API version and API key are read
from an ini file. An example of which is provided. When instantiating/initialising
this will read config.ini by default. Alternatively a path can be provided.For more detailed documentation please see:https://python-bloxone.readthedocs.io/en/latest/PyPi:https://pypi.org/project/bloxone/GitHub:https://github.com/ccmarris/python-bloxoneAll feedback please tochris@infoblox.comThanksChris
Package: bloxplorer
Bloxploreris a simple yet very effective Bitcoin and Liquid blockchain explorer.It allows developers to make use of the full power of theBlockstream Esplora HTTP APIthrough a clean Python interface.UsageUsing the Bloxplorer package is easy and straightforward, as it should be.frombloxplorerimportbitcoin_explorerresponse=bitcoin_explorer.blocks.get_last_height()print(response.data)'586438'Full documentation is available athttps://valinsky.github.io/bloxplorer/InstallationTo install the Bloxplorer package just run this command in your favorite terminal:>>> pip install bloxplorerLinksDocumentation:https://valinsky.github.io/bloxplorer/GitHub:https://github.com/valinsky/bloxplorerPypi:https://pypi.org/project/bloxplorerCircleCI:https://circleci.com/gh/valinsky/bloxplorer/tree/masterLicense:https://github.com/valinsky/bloxplorer/blob/master/LICENSE
Package: bloxs
BloxsBloxs is a simple python package that helps you display information in an attractive way (formed in blocks). Perfect for building dashboards, reports and apps in the notebook.It works with: Jupyter Notebook, Google Colab, Deepnote, Kaggle Notebook,Mercury.Get startedInstall bloxs:pip install bloxsImport and create a bloxs:from bloxs import B
B(1234, "Bloxs in notebook!")ExmaplesBloxsCodeB(1234, "Bloxs in notebook!")B(1999, "Percent change!", percent_change=10)B("🎉🎉🎉", "Works with emojis")B("68%", "Loading progress", progress=68)B("68%", "Loading progress", progress=68, color="green")color can be "blue", "red", "green" or custom in hex format (exmaple "#fa33fa")B("123", "Display line chart", points=[1,4,2,3,5,6])B("123", "Display line chart", points=[1,4,2,3,5,6], color="red")B("123", "Display stepped chart", points=[1,4,2,3,5,6], chart_type="stepped")B("123", "Display bar chart", points=[1,4,2,3,5,6], chart_type="bar")B("123", "Display bar chart", points=[1,4,2,3,5,6], chart_type="bar", color="green")You can combine several bloxs in one row:B([
    B(1999, "Percent change!", percent_change=10),
    B("🎉🎉🎉", "Works with emojis"),
    B("68%", "Loading progress", progress=68),
    B(1234, "Bloxs in notebook!")
])B([
    B("786", "Display bar chart", points=[1,4,2,3,5,6], chart_type="bar", color="green"),
    B("123", "Display line chart", points=[1,4,2,3,5,6], color="red"),
    B("123", "Display stepped chart", points=[1,4,2,3,5,6], chart_type="stepped")
]):computer: You can check thenotebookwith above example bloxs.Bloxs works great with MercuryMercuryis a framework for converting notebook to an interactive web app. It adds widgets to the notebook based on the YAML config. Below is presented a notebook with bloxs and the same notebook served as a web app with Mercury.The notebook with bloxsThe Mercury web appThe web app is available onour server:computer: