Saravanan666/pypi-org huggingface dataset:
Package: bipedal-skills
The Bipedal Skills BenchmarkThe bipedal skills benchmark is a suite of reinforcement learning
environments implemented for the MuJoCo physics simulator. It aims to provide a
set of tasks that demand a variety of motor skills beyond locomotion, and is
intended for evaluating skill discovery and hierarchical learning methods. The
majority of tasks exhibit a sparse reward structure.This benchmark was introduced inHierarchial Skills for Efficient Exploration.UsageIn order to run the environments, a working MuJoCo setup (version 2.0 or higher) is required. You
can follow the respectiveinstallation steps of
dm_controlfor that.Afterwards, install the Python package with pip:pipinstallbipedal-skillsTo install the package from a working copy, do:pipinstall.All tasks are exposed and registered as Gym environments once thebiskmodule
is imported:importgymimportbiskenv=gym.make('BiskHurdles-v1',robot='Walker')# Alternativelyenv=gym.make('BiskHurdlesWalker-v1')A detailed description of the tasks can be found in thecorresponding
publication.Evaluation ProtocolFor evaluating agents, we recommend estimating returns on 50 environment
instances with distinct seeds.
This can be acheived in sequence or by using one of Gym's vector wrappers:# Sequential evaluationenv=gym.make('BiskHurdlesWalker-v1')retrns=[]foriinrange(50):obs,_=env.reset(seed=i)retrn=0whileTrue:# Retrieve `action` from agentobs,reward,terminated,truncated,info=env.step(action)retrn+=rewardifterminatedortruncated:# End of episoderetrns.append(reward)breakprint(f'Average return:{sum(retrns)/len(retrns)}')# Batched evaluationfromgym.vectorimportSyncVectorEnvimportnumpyasnpn=50env=SyncVectorEnv([lambda:gym.make('BiskHurdlesWalker-v1')]*n)retrns=np.array([0.0]*n)dones=np.array([False]*n)obs,_=env.reset(seed=0)whilenotdones.all():# Retrieve `action` from agentobs,reward,terminated,truncated,info=env.step(action)retrns+=reward*np.logical_not(dones)dones|=(terminated|truncated)print(f'Average return:{retrns.mean()}')LicenseThe bipedal skills benchmark is MIT licensed, as found in the LICENSE file.Model definitions have been adapted from:Gym(HalfCheetah)dm_control(Walker, Humanoid)
Package: bipf
BIPF-PythonA Python library for BIPF (Binary In-Place Format)Seehttps://github.com/ssbc/bipffor the origin of BIPF and a description of the format. A condensed
writeup is at the end of this document.Quick start (the interface is the same as in json and cbor2):install the library:python3 -m pip install bipfin your code:from bipf import dumps, loadsdumps(<your_python_data>)serializes the object to bytesloads(<some_bipf_bytes>)restores a BIPF-serialized objectA rich demo intests/demo.pyalso generates a testvector. The output is:# encoded 80 bytes: f50418666f6f8c02127fff0a800a810aff0a000a010a7f12800012007f1a0080000e002179656168061862616695014046726564686f6c6d4305413da6832fbc3f186261722868656c6c6f1862617a06

# generator demo:
> 18666f6f 8c02127fff0a800a810aff0a000a010a7f12800012007f1a0080000e00217965616806
  > 0 127fff
  > 1 0a80
  > 2 0a81
  > 3 0aff
  > 4 0a00
  > 5 0a01
  > 6 0a7f
  > 7 128000
  > 8 12007f
  > 9 1a008000
  > 10 0e00
  > 11 2179656168
  > 12 06
> 18626166 95014046726564686f6c6d4305413da6832fbc3f
  > 4046726564686f6c6d 4305413da6832fbc3f
> 18626172 2868656c6c6f
> 1862617a 06

# parse entire object and read a single value
{'foo': [-129, -128, -127, -1, 0, 1, 127, 128, 32512, 32768, False, b'yeah', None], 'baf': {'Fredholm': 0.1101000100000001}, 'bar': 'hello', 'baz': None}
hello

# seek and decode a single value
key pos 69 --> hello
path pos 56 --> 0.1101000100000001

# keys can be bytes, int, double, bool and None:
# input:
 {b'\x00\x01': 'ah', 99: 'eh', 4.3: 'ih', True: 'oh', None: 'uh'}
# encoded 34 bytes: 85021100011061680a631065684333333333333311401069680e01106f6806107568
# parse entire serialization
 {b'\x00\x01': 'ah', 99: 'eh', 4.3: 'ih', True: 'oh', None: 'uh'}BIPF formatBIPF uses type-length-value (TLV) encoding for atomic types
as well as for lists and dictionaries. This allows to skip entries
without having to hunt for an end-of-list or end-of-dict marker.TLV:= concatenation oftag_bytesandvalue_bytestag_bytes:= varint_encoding( len(value_bytes) << 3 |type_bits)type_bits:=value bytes:
   TYPE_STRING   # 000  utf-8 encoded string
   TYPE_BYTES    # 001  raw
   TYPE_INT      # 010  signed little endian, 1 to 8 bytes, minimal size
   TYPE_DOUBLE   # 011  64bit IEEE-754 float, little endian
   TYPE_LIST     # 100  sequence of BIPF-encoded elements
   TYPE_DICT     # 101  sequence with alternating BIPF-encoded key and val
   TYPE_BOOLNONE # 110  length==0 -> None, else one byte with 0 or 1 for F/T
   TYPE_RESERVED # 111varint_encoding isunsigned LEB128as used in WebAssemblykeys for dictionaries can have any type except list or dict (and reserved)
Package: bipl
BIPL is a Big Image Python LibraryLibrary to read big pyramidal images like in formats like BigTiff, Aperio SVS, Leica MRXS.bipl.Slide- ndarray-like reader for multiscale images (svs, tiff, etc...)importnumpyasnpfrombiplimportSlideslide=Slide.open('test.svs')shape:Sequence[int]=slide.shape# Native shapedownsamples:Sequence[int]=slide.downsamples# List of pre-existing sub-resolution levels# Get native miniaturetmb:np.ndarray=slide.thumbnail()mpp:float=slide.mpp# X um per pixel, native resolutionimage:np.ndarray=slide[:2048,:2048]# Get numpy.ndarray of 2048x2048 from full resolutionMPP=16.# Let's say we want slide at 16 um/px resolutiondownsample=MPP/slide.mppmini=slide.pool(downsample)# Gives `downsample`-times smaller imagemini=slide.resample(MPP)# Gives the same result# Those ones trigger ndarray conversionimage:np.ndarrayimage=mini[:512,:512]# Take a crop ofimage=mini.numpy()# Take a whole resolution levelimage=np.array(mini,copy=False)# Use __array__ APIbipl.Mosaic- apply function for each tile of big image on desired scale.importnumpyasnpfrombiplimportMosaic,Slidem=Mosaic(step=512,overlap=0)# Read at [0:512], [512:1024], ...# Open slide at 1:1 scales=Slide.open('test.svs')# Target at 4 um/px resolution# If `test.svs` has some pyramid in it (i.e. 1:1, 1:4, 1:16), it will be used to speed up reads.s4=s.resample(mpp=4.0)# Get iterator over tiles.# Reads will be at [0:512], [512:1024] ... @ MPPtiles=m.iterate(s4)# Read only subset of tiles according to binary mask (1s are read, 0s are not).# `s4.shape * scale = mask.shape`, `scale <= 1`tiles=tiles.select(mask,scale)# Read all data, trigger I/O. All the previous calls do not trigger any disk reads beyond metadata.images:list[np.ndarray]=[*tiles]Installationpipinstallbiplbipl is compatible with: Python 3.10+.
Tested on ArchLinux, Ubuntu 20.04/22.04, Windows 10/11.
Package: bip-tools
DescriptionThis repository presents a library for generating and managing hierarchical deterministic (HD) wallets. The core of this software includes an implementation of the BIP 39 and BIP 32 (Bitcoin Improvement Protocol) protocols for generating mnemonic seeds and wallets, respectively. The BIP 32 module contains the BIP32_Account base class for deriving HD wallets based on the BIP 32 specification. It's recommended that you use the BIP44, BIP49, and BIP84 subclasses to generate HD wallets. These class make use of the BIP32_Account core functionality but allow for deriving extended key pairs off of the 44', 49', and 84' purpose paths.Usagefrombiptools.bip44importBIP44phrase='cactus fringe crater danger leave pill endorse night clown change apology issue'wallet=BIP44(phrase)xprv,xpub=wallet.get_master_keys()
Package: biptrader
KuCoinمستندات APIhttps://api-docs.wallex.ir/?python#احراز هویت و توکنhttps://wallex.ir/app/my-account/settingsCrypto Trading BotBuilding a Basic Crypto Trading Bot in Pythonhttps://medium.com/geekculture/building-a-basic-crypto-trading-bot-in-python-4f272693c375SimpleTradingBot
git clonehttps://github.com/Lakshmi-1212/SimpleTradingBot.gitWelcome to python-wazirx v1.0.0
git clonehttps://github.com/WazirX/wazirx-connector-python.gitCCXT – CryptoCurrency eXchange Trading Library
pip install ccxtMicrosoft Visual C++ 14.0 or greater is required. Get it with "Microsoft C++ Build Tools":https://visualstudio.microsoft.com/visual-cpp-build-tools/TA-Lib UnofficialTA-Lib : Technical Analysis Library
pip install ta-libCommands// pip install pipreqs
pipreqs .
export SETUP_VERSION="0.1"
export SETUP_LICENSE="MIT"
export SETUP_URL="https://github.com/adramazany/biptrader"
export SETUP_AUTHOR="Adel Ramezani"
export SETUP_AUTHOR_EMAIL="adramazany@gmail.com"
export SETUP_CLASSIFIERS="classifiers.txt"
export SETUP_DESCRIPTION="cryptocurrency trading helper library"
export SETUP_KEYWORDS="cryptocurrency kucoin technical-analysis"
export SETUP_LONG_DESCRIPTION="README.md"
export SETUP_INSTALL_REQUIRES="requirements.txt"
// pip install setuppy-generator
python3 -m setuppy_generator > setup.py
python3 setup.py sdist
twine upload dist/*
Package: bipwrapper
bipwrapperBIP Messenger API Wrapperpip install bipwrapperusage:from bipwrapper import BipWrapper

...

wrapper_test = BipWrapper("TEST","username", "password") # for test 
wrapper_prod = BipWrapper("PROD","username", "password") # for prod

...

wrapper_test.single.send_text_message("532xxxxxxx")

...
Package: bipython
the boldly indiscriminate python interpreter“…because you shouldn’t have to choose.”PROLOGUETwo interpreters, both alike in dignity,In fair Pythona, where we lay our scene,From ancient grudge break to new mutiny,Where civil code makes git commits unclean.From forth the fatal loins of these two foesA newer kind of strager’s given life;Whose misadventured piteous overthrowsDoth with its birth bury its parents’ strife.ACT IEnter ``bpython`` and ``ipython``**``bpython``**I’m a fancy terminal-based interface to the Python interpreter. I give youinline syntax highlighting and auto-completion prompts as you type, and I’lleven automatically show you a little tooltip with a docstring and parameterlist as soon as you hit(to make the function call, so you always knowwhat you’re doing! I’m svelte and proud of it - I don’t try to do all of theshenanigans thatipythondoes with the shell and the web, but the cool kidslove my rewind feature for demos. I strive to make interactive python codinga joy!**``ipython``**I’m an awesomesuiteof interactive computing ideas that work together.For millenia, I’ve given you tab-completion and object introspection viaobj?instead ofhelp(obj)in Python. I also have sweet shell features,special magic commands (%run,%timeit,%matplotlib, etc.) and ahistory mechanism for both input (command history) and output (resultscaching).More recently, I’ve decoupled the REPL into clients and kernels, allowingthem to run on independent of each other. One popular client is theIPython Notebook which allows you to write code and prose using a webbrowser, sending code to the kernel for execution and getting rich mediaresults back inline. The decoupling of clients and kernels also allowsmultiple clients to interact with the same kernel, so you can hook-up tothat same running kernel from the terminal. The terminal workflow makesmore sense for some things, but my user interface there isn’t as polishedasbpython’s.Enter ``bipython``**``bipython``**By your powers combined… I am``bipython``!ExeuntThe Power is Yours!pip install  bipython
easy_install bipythonbipythonrequires ipython, pyzmq, bpython, and urwid.For now, you’ll need to have a running ipython kernel before runningbipython. You can do this by either opening a notebook or runningipython console. It won’t always be like this, I’ll fix it as soon
as I can, but it’ll be soonerwith your help over
ivanov/bipython.After that, just runbipythonand enjoy the ride.Copyright (c) 2014,Paul Ivanov
Package: biquad
Alterable biquad filtersThis is a collection ofdigital biquad filterswhose parametersf(frequency inHz),g(gain indB) andq(quality) can be varied at runtime. FollowingDF1filter implementations are available:AllpassBandpassHighpassLowpassHighshelfLowshelfNotchPeakBasic usageFilter with static configuration:importbiquadimportnumpyasnp# load audio samples somehowx,sr=np.zeros(...),44100# create a filter of your choicef=biquad.bandpass(sr,f=sr/4,q=1)# process all audio samplesy=f(x)Filter with dynamic configuration:importbiquadimportnumpyasnp# load audio samples somehowx,sr=np.zeros(...),44100# create a filter of your choicef=biquad.bandpass(sr)# create parameter modifications as you likemyf=np.linspace(1,sr/4,len(x))myq=np.linspace(2,1/2,len(x))# process all audio samplesy=f(x,f=myf,q=myq)Keep in mind:All filters have a default value for the persistent parametersgandq, which is set in the particular__init__method.Parameterfmust be set either in the__init__or in the__call__method.The optional instantaneous parametersf,gandq, if specified in the__call__method, override the persistent ones.ReferencesCookbook formulae for audio EQ biquad filter coefficientsby Robert Bristow-JohnsonIntroduction to Digital Filters with Audio Applicationsby Julius O. Smith IIILicensegithub.com/jurihock/biquadis licensed under the terms of the MIT license.
For details please refer to the accompanyingLICENSEfile distributed with it.
Package: biquality-learn
biquality-learnbiquality-learn(or bqlearn in short) is a library à lascikit-learnfor Biquality Learning.Biquality LearningBiquality Learning is a machine learning framework to train classifiers on Biquality Data, where the dataset is split into a trusted and an untrusted part:Thetrusteddataset contains trustworthy samples with clean labels and proper feature distribution.Theuntrusteddataset contains potentially corrupted samples from label noise or covariate shift (distribution shift).biquality-learnaims at making well-known and proven biquality learning algorithmsaccessibleandeasy to usefor everyone and enabling researchers to experiment in areproducibleway on biquality data.Installbiquality-learn requires multiple dependencies:numpy>=1.17.3scipy>=1.5.0scikit-learn>=1.3.0scs>=3.2.2The package is available onPyPi. To install biquality-learn, run the following command :pipinstallbiquality-learnA dev version is available onTestPyPi:pipinstall--index-urlhttps://test.pypi.org/simple/biquality-learnQuick StartFor a quick example, we are going to train one of the available biquality classifiers,KPDR, on thedigitsdataset with synthetic asymmetric label noise.Loading DataFirst, we must load the dataset withscikit-learnand split it into atrustedanduntrusteddataset.fromsklearn.datasetsimportload_digitsfromsklearn.model_selectionimportStratifiedShuffleSplitX,y=load_digits(return_X_y=True)trusted,untrusted=next(StratifiedShuffleSplit(train_size=0.1).split(X,y))Simulating Label NoiseThen we generate label noise on the untrusted dataset.frombqlearn.corruptionimportmake_label_noisey[untrusted]=make_label_noise(y[untrusted],"flip",noise_ratio=0.8)Training Biquality ClassifierFinally, we trainKKMMon the biquality dataset by providing thesample_qualitymetadata, indicating if a sample is trusted or untrusted.fromsklearn.linear_modelsimportLogisticRegressionfrombqlearn.density_ratioimportKKMMbqclf=KKMM(LogisticRegression(),kernel="rbf")sample_quality=np.ones(X.shape[0])sample_quality[untrusted]=0bqclf.fit(X,y,sample_quality=sample_quality)bqclf.predict(X)CitationIf you usebiquality-learnin your research, please consider citing us :@misc{nodet2023biqualitylearn,
      title={biquality-learn: a Python library for Biquality Learning}, 
      author={Pierre Nodet and Vincent Lemaire and Alexis Bondu and Antoine Cornuéjols},
      year={2023},
      eprint={2308.09643},
      archivePrefix={arXiv},
      primaryClass={cs.LG}
}AcknowledgmentThis work has been funded by Orange Labs.
Package: biquaternion-py
biquaternion_pyThis package implements the biquaternion algebra in python in a sympy compatible way.
The user can therefore not only calculate numerically, but also symbolically.InstallationThis package can be installed through the PyPipip install biquaternion_pyor by downloading the source, opening a terminal in this folder and installing it from there.pip install -r requirements.py 
pip install -e .
Package: birankpy
BiRankpyBipartite (two-mode) networks are ubiquitous.
When calculating node centrality measures in bipartite networks, a common approach is to apply PageRank on the one-mode projection of the network.
However, the projection can cause information loss and distort the network topology.
For better node ranking on bipartite networks, it is preferable to use a ranking algorithm that fully accounts for the topology of both modes of the network.We present the BiRank package, which implements bipartite ranking algorithms HITS, CoHITS, BGRM, and Birank.
BiRank provides convenience options for incorporating node-level weights into rank estimations, allowing maximum flexibility for different purpose.
It can efficiently handle networks with millions of nodes on a single midrange server.
Both R and Python versions.Overviewbirankpyprovides functions for estimating various rank measures of nodes in bipartite networks including HITS, CoHITS, BGRM, and Birank.
It can also project two-mode networks to one-mode, and estimat PageRank on it.birankpyallows user-defined edge weights.
Implemented with sparse matrix, it's highly efficient.ExampleLet's pretend we have a edge listedgelist_dfcontaining ties between top nodes and bottom nodes:top_nodebottom_node1a1b2aTo performing BiRank on, just:bn=birankpy.BipartiteNetwork()bn.set_edgelist(edgelist_df,top_col='top_node',bottom_col='bottom_node')top_birank_df,bottom_birank_df=bn.generate_birank()
Package: birb
# birb![birb](images/birb.png)birb is a minimalist app that lets you tweet from your CLI. No timeline, no search, no mentions: only posting.## But why?Twitter is noisy, and even a quick post can end up being distracting with your timeline and mentions popping up.birb is limited on purpose so you don't fall into that timesink: post now from your CLI, and deal with the rest later on.## Usage[![asciicast](https://asciinema.org/a/177047.png)](https://asciinema.org/a/177047)```shUsage: birb.py [OPTIONS] COMMAND [ARGS]...Options:--help  Show this message and exit.Commands:oops   delete your most recent tweettweet  send a tweet```Using the app without any command or parameter automatically triggers the `tweet` command.You can delete your most recent tweet with `birb oops` if needed.Be aware that this will delete your tweet regardless of where or when it has been posted.If you want to repost right away, `birb oops --resend` will trigger the `tweet` command after deletion.## Compatibilitybirb has only been tested with Linux, and works with any version of Python3.## InstallationCreate an app on [apps.twitter.com](https://apps.twitter.com) with a name of your liking, and run `pip`:```shpip install --user birb```When launching `birb` for the first time, you will be prompted to copy/paste the consumer keys and access tokens of the app you just created.Those credentials will be locally stored and obfuscated in `birb_keys.py` and nowhere else.Be aware however that this is only obfuscation: do not store that file online or share its content.You're all set and ready to use birb!## Todo* tweet threads* tweet with media files
Package: bird
Pure Python implementation of the BIRD algorithm. BIRD is a denoising
algorithm using randomized greedy pursuits. It works for single
signal and supports (structured)-sparsity for multivariate signals, e.g.
multichannel array data.ReferenceAlgorithm presented here are described in:Blind Denoising with Random Greedy Pursuits. Moussallam, M., Gramfort, A., Daudet, L., & Richard, G. (2014). IEEE Signal Processing Letters, 21(11), 1341-1345
Preprint available at:http://arxiv.org/abs/1312.5444
Package: bird2board
bird2boardConvert bird based bookmarks to board based ones.This tool takes rawTwitter Bookmarksdata
and pushes the bookmarks toPinboard.Installation:Clone this repositoryInstall withpip#> cd bird2board
#> pip install .Usage:First download the raw Twitter bookmarks data:Open the Twitter Bookmarks pageUsing Developer tools, look for Network requests starting withBookmarks?variables=.For each of these requests, copy the response, which starts with{"data":{.
You can copy the response through the right click context menu.Save the response JSON into a new file.If you have more than a single screen of bookmarks,
scroll down to create more requests and responses. Copy these into new files in a directory.Next find your Pinboard API token:Sign intoPinboardGo to Settings page and select Password tab.Copy the API token including the username at the start.Then use the tool to convert the bookmark data and save in Pinboard:#> bird2board --help
Usage: bird2board [OPTIONS] PATH

  Save Twitter Bookmark .json file(s) at PATH (file or directory) to account
  using PINBOARD TOKEN.

Options:
  --toread / --not-toread    set Pinboard bookmarks as "to read"
  --shared / --not-shared    set Pinboard bookmarks as shared
  --replace / --no-replace   replace existing Pinboard bookmark for an URL
  -p, --pinboard-token TEXT  user token for Pinboard API  [required]
  --help                     Show this message and exit.Example usage:#> bird2board -p MY_TOKEN --toread ./responses/Instead of providing the Pinboard API token as an option to the script,
you can set the$BIRD2BOARD_PINBOARD_TOKENenvironmental variable.#> export BIRD2BOARD_PINBOARD_TOKEN=MY_TOKEN
#> bird2board --toread ./responses/Notes:The Pinboard API requires a 3 second wait between API requests,
so submitting a large number of bookmarks can take a long time.The Twitter Bookmark responses captured above are from the non-public API,
and there will likely be breaking changes to the response structure in the future.
Most recent breaking change to the response data was in June 2021.
Package: birdback
Client library written in Python for the Birdback API.Usage:>>> from birdback.xauth import Client
>>> client = Client(consumer_id=<id>, consumer_secret=<secret>)
>>> client.authenticate()Theclientobject is now ready to use. It supports the standard
set of HTTP methods such asgetandpostwhich are available
as methods.The client library uses the popularrequestslibrary and the methods take
the same arguments.LicenseThe client library is licensed under the MIT License.
Package: birdbrain-python-library
Python Library for Birdbrain Technologies Hummingbird Bit and Finch 2Free software: GNU Lesser General Public License v3 (LGPLv3)Installationpip install birdbrain-python-libraryYou can also install the in-development version with:pip install https://github.com/fmorton/BirdBrain-Python-Library/archive/main.zipDocumentationFinch:https://learn.birdbraintechnologies.com/finch/python/library/Hummingbird:https://learn.birdbraintechnologies.com/hummingbirdbit/python/library/DevelopmentTo run all the tests run:toxNote, to combine the coverage data from all the tox environments run:Windowsset PYTEST_ADDOPTS=--cov-append
toxOtherPYTEST_ADDOPTS=--cov-append toxChangelog0.0.1 (2022-10-01)First release on PyPI.
Package: bird-browser
Bird BrowserThe Bird browser is a browser written in Python and Qtthe browser.ui file can be loaded in the qt-designer.This is how I want the browser to look at some pointplaned features are:Tabssearch engine integrationsource-code viewpassword manager integrationbookmarksconfigurationsome of these features weren't done by me before
This Project also has an Adblocker build into it.Installationfinished versions can be found on pip:pip install bird-browserearlier versions can be installed like this:pip instal -i https://test.pypi.org/simple/ bird-browsermaybe you need to install the birdlib separatly:pip install -i https://test.pypi.org/simple/ birdlibWikithe wiki/manual/cheatsheet can be foundhereLicenseGNU GPL 3for more information see the LICENSE file