Saravanan666/pypi-org huggingface dataset:
Package: bittray
Bittray running inside tint2.Bittray is an application to display the current bitcoin price in your
systray. If you enable electrum support it provides a handy launch menu
for your wallets.RequirementsIt’s probably the best to install wx and pillow through your operating
system, on Debian use:apt-get install python-wxgtk3.0 python-pilPython3 is not supported at this moment, wx is not packaged for it in Debian,
and some of the code would need porting as well. Nothing big, but I can’t do it
yet.InstallationTo install bittray and some dependencies run:python setup.py installAfter this you can use thebittraycommand, assuming the script is
somewhere on yourPATH.ConfigurationA default configuration file will be create in~/.config/bittray/bittray.cfg,
please see there for available settings.You should not delete settings from the configuration file, the application
doesn’t have internal default values. On upgrades new settings should be added
automatically, if not please report a bug.If you update the configuration whilebittrayis running you can make it
reload the configuration withpkill -SIGUSR1 bittray.Planned featuresNotifications for price changes, will require a price historyPossibly support more walletsDynamic price color, probably hooked into the notification logic
Package: bittrex-api
bittrex_apiDescriptionIMDB scraperInstallpipinstallbittrex_api# orpip3installbittrex_apiUsagefrombittrex_apiimportBittrexbittrex=Bittrex(api_key='',# YOUR API KEYsecret_key='',# YOUR API SECRETmax_request_try_count=3,# Max tries for a request to succeedsleep_time=2,# sleep seconds between failed requestsdebug_level=3)v3=bittrex.v3# or# from bittrex_api import *# v3 = BittrexV3(#     api_key='',              # YOUR API KEY#     secret_key='',           # YOUR API SECRET#     max_request_try_count=3, # Max tries for a request to succeed#     sleep_time=2,            # sleep seconds between failed requests#     debug_level=3,#     reverse_market_names=True# )# V3 Usage samplesfromkcuimportkjsonMARKET_NAME='BTC-XRP'kjson.print(v3.get_market(market=MARKET_NAME))kjson.print(v3.get_market_summary(market=MARKET_NAME))kjson.print(v3.get_orderbook(market=MARKET_NAME,depth=1))Dependencieskcu,requests
Package: bitvavo-aio
bitvavo-aioThis Python library provides access toBitvavo crypto exchangeAPI. The library is focussed on Bitvavo's REST API only for the moment, as lean and mean as possible, websocket support may follow later.binance-aiois designed as an asynchronous library utilizing modern features of Python usingaiohttp.For changes see:CHANGELOG.FeaturesAccess to Bitvavo's REST API like account details, market data and order managementFully asynchronous, designed for good performanceInstallationpip3installbitvavo-aioPrerequisitesDue to dependencies and Python features used by the library please make sure you use Python version >3.6.Before you can usebitvavo-aioyou need to define a API key pair inside your account on the website of Bitvavo, and set the needed permissions and specify your whitelist IP address.
Write down the Bitvavo API and SECRET key given to be used in the code.Basic Example#!/usr/bin/env python3importasyncioimportloggingimportosfromdatetimeimportdatetimefrombitvavo.BitvavoClientimportBitvavoClientfrombitvavo.PairimportPairfrombitvavoimportenumsfrombitvavo.BitvavoExceptionsimportBitvavoExceptionLOG=logging.getLogger("bitvavo")LOG.setLevel(logging.DEBUG)LOG.addHandler(logging.StreamHandler())print(f"Available loggers:{[namefornameinlogging.root.manager.loggerDict]}\n")asyncdefrun():# Retrieve your API and SECRET key from the Bitvavo website# and store them in the following environment variables.api_key=os.environ['APIKEY']sec_key=os.environ['SECKEY']client=BitvavoClient(api_key,sec_key)# Generalprint("\nServer time:")awaitclient.get_time()print("\nMarkets:")awaitclient.get_markets()print("\nMarkets ETH-BTC:")awaitclient.get_markets(pair=Pair('ETH','BTC'))print("\nAssets:")awaitclient.get_assets()print("\nAssets BTC:")awaitclient.get_assets('BTC')# Market dataprint("\nOrder book:")awaitclient.get_orderbook(pair=Pair('ETH','BTC'))print("\nCandelsticks:")awaitclient.get_candelsticks(pair=Pair('ETH','BTC'),interval='1m',limit=5)print("\nPrice ticker:")awaitclient.get_price_ticker()print("\nBest order book:")awaitclient.get_best_orderbook_ticker()print("\n24hour price ticker:")awaitclient.get_24h_price_ticker()# Ordersprint("\nGet open orders:")awaitclient.get_open_orders()print("\nGet orders ETH-BTC:")awaitclient.get_orders(pair=Pair('ETH','BTC'))# Tradesprint("\nGet historical trades ETH-BTC:")awaitclient.get_historical_trades(pair=Pair('ETH','BTC'),limit=5)# Accountprint("\nAccount:")awaitclient.get_account()print("\nBalance:")awaitclient.get_balance()print("\nDeposit history:")awaitclient.get_deposit_history()awaitclient.close()if__name__=="__main__":asyncio.run(run())A full overview of implemented API calls can be found in:examples/client.pySupport and ContactIf you like this library and you want to support further development or have a bug to report, please open a Github Issue.
Package: bitvavo-api-upgraded
Bitvavo API (upgraded)Hi, this isnotthe official API, but this one has:build-in documentationtyping forallfunctions and classesunit tests (I already foundthreefourfivesix bugs that I fixed, because the original code wasn't tested, at all)a changelog, so you can track of the changes that I makecompatible with Python 3.7 and newer (3.6 isn't supported as of 2021-12-23)a working version ofgetRemainingLimit()will actually wait until the ban has been lifted (in case you get banned)more stable api-calls, due to calculating lag between client and serverfancy logging viastructlog, including external loggers like from the urllib3 and websocket libs!a workingACCESSWINDOWvariable that actually times the api calls out - makes failing Bitvavo API calls fail faster!Version1.*is guaranteed compatible* with the original API.*: Except forBitvavo.candles. I had to renamed thesymbolargument tomarket, because thecandlescall actually excpects amarket. So that's more of a bugfix.**: Same goes forBitvavo.book; it had the same problem ascandles.***: And I removed therateLimitThreadclass, but that should've been used internally only anywayCustomizable settingsThrough the magic of the python-decouple lib, when you use this lib, you can create asettings.ini(Windowsexample) or a.env(Linuxexample) and add some handy settings there.Here is an example list of the settings for this lib:BITVAVO_API_UPGRADED_LOG_LEVEL=INFO# Set the lib's log levelBITVAVO_API_UPGRADED_LOG_EXTERNAL_LEVEL=WARNING# Set the libs that are used by *this* lib's log levelBITVAVO_API_UPGRADED_LAG=50# the time difference between the server and your local time (you'll have to calculate this yourself - tip: use the bitvavo.time() functionality in a separate script)BITVAVO_API_UPGRADED_RATE_LIMITING_BUFFER=25# default 25, set to 50 if you get "you have been banned" messages (or even higher, if needed)LinksOfficial API DocumentationOfficial Trading Rules(recommended read, as it explains a lot of jargon; It's OK to not understand this document if you're just starting out - I don't fully understand the document either)Github for this lib
Package: bitvector-for-humans
Bit Vectors For Humans™This simple bit vector implementation aims to make addressing single
bits a little less fiddly. It can be used by itself to work with bit
fields in an integer word, but it really starts to shine when you use
the suppliedBitFielddescriptor with a subclass ofBitVector:>frombitvectorimportBitVector,BitField>>classIOTDeviceCommand(BitVector):>def__init__(self):>super().__init__(size=32)>>power=BitField(0,1)# offset and size>spin=BitField(1,1)>speed=BitField(2,4)>sense=BitField(6,2)>red=BitField(8,8)>blue=BitField(16,8)>green=BitField(24,8)>>widget_cmd=IOTDeviceCommand()>widget_cmd.power=1>widget_cmd.sense=2>widget_cmd.speed=5>widget_cmd.red=0xaa>widget_cmd.blue=0xbb>widget_cmd.green=0xcc>widget_cmdIOTDeviceCommand(value=0xccbbaa95,size=32)>widget_cmd.bytesb'\xcc\xbb\xaa\x95'Installation$pipinstallbitvector-for-humans$pydocbitvector...Or directly from github:$pipinstallgit+https://github.com/JnyJny/bitvector.gitMotivationAddress sub-byte bits in a less error prone way.Minimize subdependencies.Learn something about descriptors.CaveatsThe tests need expanding and I got lazy when writing the multi-bit
setting / getting code and it could undoubtedly be improved. Pull
requests gladly accepted.Other Ways to Implement a Bit VectorPython builtinctypes.Structureallows sub-byte bit fieldsPython builtinstructprovides extensive support for byte manipulationsPython3 IntEnums can be used to build bit field masksThe plainintwill serve admirably with bitwise operatorsProvide cffi bindings to existing bit-twiddling librariesUse Numpy bool arrays as the "backing store"Other good ideas I overlooked, forgot about or just plain don't know.
Package: bitwallet
# BitWalletA python module that provides a wallet that can do P&L## InstallationQuick install/upgrade with `pip install bitwallet`## RunningYou can get your balances from any number of exchanges by doing:`bitwallet balances <your name>`. You should have a `<your name>.yaml` filewith the following format:```-   name: <exchange name - should be a ccxt module>key: <key>secret: <secret>uid: <uid for exchanges that need it>alias: <optional name - in case you have multiple accounts in singleexchange>```All the [ccxt exchanges](https://github.com/ccxt/ccxt/tree/master/python/ccxt)are supported.`bitwallet` creates temporary files to avoid hitting your exchanges at everycall. The temporary files are called `<your name>_balances.pkl`. Remove themevery time you make some transactions in order to reload them. Unless you do sothe only thing updated between subsequent calls is the coin-USD exchange rate.## NotesTo debug run: `clear && rm -f dkl_balances.pkl && PYTHONPATH=. bin/bitwalletbalances <your name>`Local installation: `python setup.py install`To run tests: `python setup.py test`To release, increase version number in setup.py and then `rm -rf dist`, `pythonsetup.py sdist`, `twine upload dist/*`.Clean install with updates: `pip install --no-cache-dir -U bitwallet`
Package: bitwarden2keepass
bitwarden2keepassOverviewDeveloped by me, Anton Bakuteev,bitwarden2keepassis a Python package tailored for securely migrating and backing up password data from Bitwarden to KeePass. This tool is ideal for users who are transitioning between these password managers or need a dependable solution for backing up their Bitwarden vaults.Explore my other projects, including AI/ML applications, websites, and Telegram bots, atsometechnologies.com.Key FeaturesCommand-Line Interface: Designed for simplicity, facilitating effortless data migration and backup.Migration and Backup: Efficiently transfers data from Bitwarden to KeePass, while also providing a backup solution for Bitwarden data.Secure Data Handling: Prioritizes the safety and privacy of your data throughout the migration and backup process.Customizable Paths: Allows flexibility for users to specify file paths and other parameters.RequirementsPython 3.9 or later.Bitwarden CLI installed and configured on your machine.InstallationInstallbitwarden2keepassusing pip:pipinstallgit+https://github.com/bakuteyev/bitwarden2keepassUsageAfter installation, run the package using:bitwarden2keepass--master_password<Your_Bitwarden_Master_Password>Replace<Your_Bitwarden_Master_Password>with your actual Bitwarden master password.How It WorksUnlock Bitwarden Vault: Uses your master password to unlock the Bitwarden vault.Export and Convert Data: Exports data from Bitwarden and converts it into KeePass format.Create Backups: Optionally creates backups of the Bitwarden vault.Ensures Security: Automatically removes any temporary files after completion.ContributingContributions are always welcome! Please feel free to fork the repository, make improvements, and submit pull requests.LicenseThis project is available under theMIT License.Support and ContactFor support, queries, or suggestions, please open an issue in the GitHub repository or contact me directly atbakuteyev@gmail.com.AcknowledgementsSpecial thanks to the Bitwarden and KeePass communities for their excellent tools that have inspired this project.
Package: bitwarden-menu
Bitwarden-menuDmenu/Rofi frontend for managing Bitwarden vaults. Uses theBitwarden CLItool to interact with the Bitwarden database.This project is not associated with the Bitwarden project nor 8bit Solutions
LLC.Installationpip install --user bitwarden-menuEnsure~/.local/binis in your$PATH. Runbwmand enter your database
path, keyfile path, and password.NOTE:Initial login to some servers, including vault.bitwarden.com, will
require theclient_secretfrom your account settings page. Ensure this is in
your clipboard and ready to paste prior to first run.  Once logged in for the
first time, you will not need this value again.For full installation documention see the [installation docs][docs/install.md].Full DocumentationInstallation-Configuration-UsageRequirementsPython 3.7+Bitwarden CLI. Ensure thebwcommand is in$PATHPynputandXdgDmenu,Rofi,WofiorBemenuxsel or wl-copy(optional) Pinentry.(optional) xdotool, ydotool(>= 1.0.0)/wtype (for Wayland).FeaturesSupports multiplebitwarden.comand self-hostedVaultwardenaccounts. Accounts can be switched on the fly.Auto-type username and/or password on selection. Select to clipboard if
desired (clipboard clears after 30 sec).Supports login with 2FA code from Authenticator(TOTP), Email, or Yubikey.Background process allows selectable time-out for locking the database.Use a customKeepass 2.x style auto-type sequence.Type, view or edit any field.Open the URL in the default web browser.Non U.S. English keyboard languages and layouts supported via xdotool or
ydotool/wtype (for Wayland).Edit notes using terminal or gui editor.Add and Delete entriesRename, move, delete and add folders and collectionsMove any item to or from an organization, including support for multiple
collections.Hide selected folders from the default and 'View/Type Individual entries'
views.Configure the characters and groups of characters used during password
generation.Optional Pinentry support for secure passphrase entry.Add, edit and type TOTP codes.LicenseMITUsagebwm [-h] [-v VAULT] [-l LOGIN] [-k] [-a AUTOTYPE] [-C]Runbwmor bind to keystroke combination.Enter account URL on first run.Start typing to match entries.Configure~/.config/bwm/config.ini as desired.More detailedusage information.Screencast (Using Bemenu on Sway):TestsTo run tests in a venv:make test(not implemented yet)DevelopmentTo install bitwarden-menu in a venv:makeBuild man page from Markdown source:make manUsinghatch:hatch shell: provies venv with editable installation.hatch build&&hatch publish: build and publish to Pypi.Usingnix:nix develop: Provides development shell with all dependencies.
Edit and run similar topip install -e .orhatch shell.Planned featuresUnit testsNotifications for syncing status (e.g. when a sync is complete)
Package: bitwarden-sdk
Build locallyRequirementsPython 3maturin(install withpip install maturin)npmBuildFrom the root of the repository:npmrunschemas# generate schemas.pycdlanguages/python/
maturindevelopYou can now importBitwardenClientin your Python code with:frombitwarden_sdkimportBitwardenClientUse without building locallypipinstallbitwarden-sdkRunSet theORGANIZATION_IDandACCESS_TOKENenvironment variables to your organization ID and access token, respectively.python3./example.py
Package: bitwarden-to-keepass
Bitwarden to KeePassA simple little script that backs up a Bitwarden vault to a local KeePass file.$bitwarden_to_keepass--keepass-file/path/to/file.kdbxInstallation and UsageInstall the Bitwarden CLI.Install this code.Run.Install the Bitwarden CLIHead to theBitwarden CLI pagepage and download the native executable
for your system.Place this file somewhere in yourPATH. For example, on Linux you might
download it to/usr/local/bin. Make sure that the file is executable (eg:chmod a+x /usr/local/bin/bw).For convenience, you can use this command to do all of the above (on Linux)wget https://github.com/bitwarden/cli/releases/download/v1.22.1/bw-linux-1.22.1.zip \&& sudo unzip -d /usr/local/bin bw-linux-1.22.1.zip \&& sudo chmod a+x /usr/local/bin/bwInstall this codepip install bitwarden-to-keepassOr seeDevelopment.RunRunbitwarden_to_keepass.You'll be prompted for all the secrets and whatnot. Each secret arg has an
associated env var (seebitwarden_to_keepass --helpfor env var names). If
that env var is found, the value from the env var will be used and you will
not be prompted.You can also send in your secrets via command line, though this is not
recommended.Personally I like to create asecrets.shfile:#!/bin/bashexportBW_MASTER_PW=<Bitwardenmasterpassword>exportBW_CLIENTID=<BitwardenAPIClientID>exportBW_CLIENTSECRET=<BitwardenAPIClientSecret># If you also want to backup your Organization data:exportBW_ORG_ID=<OrganizationID>and source it before running:$sourcesecrets.sh$bitwarden_to_keepass--keepass-file/c/foo/bar.kdbxDevelopmentInstall the Bitwarden CLI and the KeePass CLI as mentioned above.Clone the repo:git clone https://github.com/dougthor42/bitwarden_to_keepassMove into that dir:cd bitwarden-to-keepassCreate a virtual environment:python -m venv .venvActivate it:. .venv/bin/activateInstall python packages:pip install -U pip setuptools wheelpip install -e .[dev]Run tests to verify:pytestInstall pre-commit hooks:pre-commit installReady to developReleasingUpdateCHANGELOG.mdby inserting a new heading:--- a/CHANGELOG.md+++ b/CHANGELOG.md@@ -3,6 +3,9 @@## Unreleased++## v1.0.0 (2023-01-14)++ Finally decided to work on this again and got things to decent working state!This should be usable now and ticks all of the original requirements.Update pyproject.toml with the new version:--- a/pyproject.toml+++ b/pyproject.toml@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"[project]name = "bitwarden_to_keepass"-version = "0.0.1"+version = "1.0.0"description = "A simple little script that backs up a Bitwarden vault to a local KeePass file."readme = "README.md"requires-python = ">=3.8"Commit these changes.Create a new git taggit tag v1.0.0 -m "Release v1.0.0".Then push tags to github. CI will build the source distribution and wheel and
upload them to PyPI.ChangelogSeeCHANGELOG.md.
Package: bitwise
Bitwise is a Python library intended to make hardware design and simulation more accessible
for software engineers. While it can never replace a true hardware description language,
it aims to serve as a useful tool in the hardware design process, allowing a user to build and test
their digital circuits in a high-level programming language (i.e. with simpler syntax and more
flexible semantics) before implementing them using an HDL.Getting StartedRefer to thedocumentationfor installation
instructions, usage examples, API reference, and more.Quick ExampleThe following code creates a half-adder circuit:"""
Create a half-adder.
"""
import bitwise as bw

def main():
    # initialize inputs
    a = bw.wire.Wire()
    b = bw.wire.Wire()

    # initialize outputs
    sum_ = bw.wire.Wire()
    carry_out = bw.wire.Wire()

    # create circuit
    bw.gate.XORGate2(a, b, sum_)  # XORs a and b and puts the result into sum_
    bw.gate.ANDGate2(a, b, carry_out)  # ANDs a and b and puts the result into carry_out

if __name__ == "__main__":
    main()Interacting with it in a Python session:In [1]: a.value = 0

In [2]: b.value = 0

In [3]: sum_.value
Out[3]: 0

In [4]: carry_out.value
Out[4]: 0

In [5]: a.value = 1

In [6]: sum_.value
Out[6]: 1

In [7]: carry_out.value
Out[7]: 0

In [8]: b.value = 1

In [9]: sum_.value
Out[9]: 0

In [10]: carry_out.value
Out[10]: 1
Package: bitxchange-py-api
Bitxchange Python API LibraryThis is a lightweight library that works as a connector toBitxchange public APIInstallationpipinstallbitxchange-py-apiDocumentationhttps://bitxchange-python-api.readthedocs.io/en/latest/RESTful APIsUsage examples:frombitxchange.spotimportSpotexchange=Spot(key='<api_key ',secret='api_secret')params={"amount":1,"price":0.05917959,"pair":"BTC/ETH","order_type":2,"type":"sell"}order=exchange.create_order(**params)print(order)You can find more examples in the documentation at the link above.
Package: biuletyn-bip
Flask application that implements Polish BIP baseline (Bulletin of Public Information) according to Polish law requirements.Aplikacja Flask implementująca podstawowy Biuletyn Informacji Publicznej (BIP) zgodnie z polskimi wymogami prawnymi.Links / łączaReleases / wydaniaTests / testyCoverage / pokrycie testamiDocs / dokumentacjaCode quality report / raport z jakości koduLicenseThis application is provided under the terms of GNU General Public License, version 3. See file LICENSE in top level directory.Copyright: (c) 2019, Jarek ZgodaThis application includes 3rd party code, seedocumentationfor more details (in Polish).
Package: biur
biuRAn extract of the BIU R functionality, without any dependency onbiu.Installpip install biuRHow to useimportbiur.wrapperimportmatplotlib.pylabaspltimportpandasaspdR=biur.wrapper.R()Push some dataR.push(n=5000,mean=10,var=6,question="How many apples do you eat per day?")Run some commandsR("""dist <- rnorm(n, mean, var)print(mean(dist))""",get=False)[1] 9.883113Get some datadist=R.get("dist")dist_alt=R("dist",get=True)# the get parameter is True by default_=plt.hist(dist,bins=50)Do it all at the same timedist=R("""rnorm(n, mean, var)""",push=dict(n=5000,mean=10,var=6,question="How many apples do you eat per day?"))_=plt.hist(dist,bins=50)Dataframes also work as expecteddf=pd.DataFrame(dist.reshape(500,10),columns=["C%d"%(i+1)foriinrange(10)])df2=R("""df*2""",push=dict(df=df))df2.describe()<style scoped>
    .dataframe tbody tr th:only-of-type {
        vertical-align: middle;
    }.dataframe tbody tr th {
    vertical-align: top;
}

.dataframe thead th {
    text-align: right;
}</style>C1C2C3C4C5C6C7C8C9C10count500.000000500.000000500.000000500.000000500.000000500.000000500.000000500.000000500.000000500.000000mean19.66401419.84473021.39767620.31671519.91532720.47961720.60681120.67168019.97879220.363389std12.08248211.82931811.75607912.22808511.87844012.62645211.56042112.36055812.42538112.545196min-28.185781-11.851668-14.899577-15.940758-23.651277-17.811376-13.721199-17.615716-18.421257-22.17251525%11.90930012.04216213.25710312.16203112.21461711.77871712.92044912.17872611.74188212.25486650%19.31674319.56496520.98866920.49899219.76599020.16614420.27827720.02058720.05404020.27540375%27.77199128.08515729.17413728.44798028.06110328.31246028.38444728.86958128.67093829.319559max53.65866659.74053458.53188757.40227055.35101252.86713256.28609455.59651350.95340958.989365Some additional stuffDatesfromdatetimeimportdatetimeR("""print(today)""",push=dict(today=datetime.today()),get=False)[1] "2021-11-15 14:59:14 EET"DictionariesNote that individual numbers do not exist in R (everything is a vector) so it is impossible to transform this back perfectly.R.push(mydict={"A":10,"B":20,"C":40})R("""mydict$D <- 60mydict"""){'A': [10], 'B': [20], 'C': [40], 'D': [60.0]}