Saravanan666/pypi-org huggingface dataset:
Package: cryptopp
cryptopp is a lightweight command line based cryptocurrency portfolio.
Built on Python 3 and ncurses with simplicity in mind, cryptop updates in realtime.version 1.0.1ChangesThis now requires a CryptoCompare.com and CoinMarketCap.com API key because of rate limits and extra data points.See the Credits section on how to get an API key.Added option for extra decimal places in .cryptop/config.ini based on currency.localeFixed + add coin user error to just add coin instead of error.Added Market Cap from CoinMarketCap. API required.Reads wallet every refresh and entry. Enables cryptop to be run on multiple computers from within a sharedrive.Less url requests. Coin list is fetched every 10 days, instead of
every coin addition. Speeds up processing of app.TODOInstead of using CC for 24h +/-, data already fetched from CMC in quote. Use CMC quote data for less requests.Add average price paid within wallet. Requires an addition “history” wallet.More historical portfolio changes.Coin Value +/- with mrkt conditions.History interface to interact with coin additions / subtractions.InstallationVia Pippip3installcryptoppOr locallycryptop requires Python 3 to run, and has only been tested in Python 3.6-3.10 so far.First clone this repogitclonehttps://github.com/GordianSimpul/cryptoppThen install cryptop through pipcdcryptopppip3install-e.Make sure $HOME/.local/bin is in your environment PATH variable.UsageStart from a terminal.cryptopp[-kapi_key][-lapi_key]Follow the on screen instructions to add/remove or add/subtract values from your current wallet. The api_key options are only necessary if you didn’t specify it in the .cryptop/config.ini file. An initial run is necessary to copy over config.ini to the .cryptop directory..cryptop/config.inikey=CryptoComareAPIKEYkey2=CoinMarketCapAPIKEYBoth of those need to edited o/w cryptop will not work.CustomisationCryptop creates two config files in a .cryptop folder in your home directory..cryptop/config.ini contains theme configuration (text/background colors) and
options to change the output currency (default USD), update frequency, number of decimal places to display and maximum width for float values..cryptop/wallet.json contains the coins and amounts you hold, you shouldn’t need to edit it manuallyCredits / APIBoth are FREE.Uses thecryptocompare.com API.Uses thecoinmarketcap.com API.TipjarHelp me reach my goal of contributing to the ongoing development of privacy coinsXMR:83az9t2fLjoC25d9UBUUiM1v6zemeKhjNf2Qw2Fnk1MFB3ecDx5oNVEG2tmdJJbxc97oAgjVbgCKHEgwTNFALh2c9jeWfdSDERO:dero1qyxctkgzee00jh3md4etc8kxkr8x4hh7cckezrhn7de39kj4xaf9xqqa6xetaBTC:bc1qfckkcnxxhxh5h0hnuc8gucymuvnxrw2a4trawsARRR:zs1gn457262c52z5xa666k77zafqmke0hd60qvc38dk48w9fx378h4zjs5rrwnl0x8qazj4q3x4svzDisclaimerI am not liable for the accuracy of this program’s output nor actions
performed based upon it.
Package: cryptopy-cli
/ ___|  _ \ \ / /  _ \_   _/ _ \|  _ \ \ / /                  
            | |   | |_) \ V /| |_) || || | | | |_) \ V /                   
            | |___|  _ < | | |  __/ | || |_| |  __/ | |                    
             \____|_| \_\|_| |_|    |_| \___/|_|    |_|**cryptopy is a CLI based encryption-decryption tool.Since it is using theclickmodule, flags like --help etc are active.By definition, the tool has 2 options, encrypt and decrypt, and requires 2 parameters:
1- A file to be encrypted or decrypted
2- A keyword that works both sides of the action. So the user needs to give the same keyword
for the actions on the same file.The program also asks to keep or remove the original file during encryption or the encrypted file during decryption.y || n will suffice.This is just the first version. The more muscular versions will arrive soon,hopefully.
the script also makes the verification check, whether the files exists or not.Use case example:cryptopy [encrypt||decrypt] /path/to/file/ keywordEnjoy and give me feedbacks!
M Yavuz YAGISChange Log1.0.0(03.09.2020)-The first release.
Package: cryptopyutils
cryptopyutilsHigh-level Python3 cryptography library usingcryptographywith sensible configurable defaults and CLI scripts.cryptopyutilscan be used to :encrypt (“derive”) and verify passwords.generate, save and load Asymmetric encryption keys and certificates :private keys/public keys (RSA, ED25519, ECDSA, DSA, etc).generate, save and load x509 Certificate Signing Request (CSR).generate, save and load x509 Certificates, particularly self-signed certificates, to be used in SSL applications.encrypt or decrypt messages with RSA.sign and verify messages with asymetric encryption. It works with small messages or in digest mode.perform constant time comparisons between two series of bytes (prevents timing attacks).Please provide feedback to@dheurtevent1.DisclaimerCaution!USE AT YOUR OWN RISK. Has been tested only on Ubuntu 20.04 (Linux) with python 3.9.12.How to installRequirementsThis library requires pythoncryptography,distroandpyaml(for the CLI examples)$pipinstallcryptographydistropyamlcryptographyuses openSSL as its backend engine.Install the library$pipinstallcryptopyutilsUsagecryptopyutilsis free open source software. It is released underthe Apache 2.0 licence.You are free to incorporate the library and/or its CLI in your open-source or proprietary projects.To use the libraryYou can read the following how to guides:How to : private keyHow to : public keyHow to : passwordYou can also read the source code of other examples.In addition, you can have a look at theAPIand at the source code
in theGithub repository.To use the CLI examplesYou can have a look at the CLI page.Code quality and stabilityThe code is documented, tested (>70 tests) and provided with examples.Defaults can be provided at run time by developers or can be modified in the config.py file.The default values use the NIST recommendations and recommendations of thecryptographypackages, as well as :https://www.daemonology.net/blog/2009-06-11-cryptographic-right-answers.htmlhttps://soatok.blog/2022/05/19/guidance-for-choosing-an-elliptic-curve-signature-algorithm-in-2022https://www.keylength.com/en/4/cryptopyutilshas a goal of strong API stability policy:Public API shall not be removed or renamed without providing a compatibility alias.The behavior of existing APIs shall not change.Exceptions to API stability are for security purposes to resolve security issues or harden the library against a possible attack or underlying changes incryptography.
Package: crypto-qr-codes
Crypto QR CodesCrypto QR Codes is a Python package that allows you to generate QR codes for various cryptocurrencies.InstallationYou can install Crypto QR Codes using pip:pipinstallcrypto-qr-codesUsageTo use Crypto QR Codes, import thecreate_qr_codefunction from thecrypto_qr_codes.qrmodule. Here's an example:fromcrypto_qr_codes.qrimportcreate_qr_codecrypto_currency="bitcoin"crypto_address="18Qz324MxCwBbrWqNv1Ew3vcgpi9N9DmXM"amount=0.1message="Payment for goods"create_qr_code(crypto_currency,crypto_address,amount,message)ParametersThe create_qr_code function takes the following parameters:crypto_currency (required): A string that represents the cryptocurrency.crypto_address (required): A string that represents the cryptocurrency address.amount (optional): A float that represents the amount to be paid.message (optional): A string that represents a message for the payment.filename (optional): A string that represents the name of the file to save the QR code. Defaults to output.png.ReturnsThe create_qr_code function returns the full path of the generated QR code image file.TestingTo run the tests for Crypto QR Codes, run the following command:python-munittesttests.test_qrExamplesYou can check theexamples.pyfile for examples of how to use the package. The outputs of the examples are stored in theqr_codesfolder.LicenseThis project is licensed under the MIT License.
Package: cryptor
Crypto PlaygroundPlace for various test of crypto libs in pythonSourcesPython 3: An Intro to Encryptionpycryptodome examplesCreating RSA KeysInstallationConda - Windowscondainstall-cconda-forgepycryptodomeexpip - LinuxGet it from gitcd~/_projects/github/
gitclonehttps://github.com/pavelsuk/crypto_playgroundcrypto_playgroundcd~/_projects/github/crypto_playgroundCreate virtual environmentsudoaptinstallpython3-venvcd~/_projects/github/crypto_playground
python3.6-mvenvenvsourceenv/bin/activateInstall packagescd~/_projects/github/crypto_playground
gitfetch
gitmergesourceenv/bin/activate
pipinstall-rrequirements.txtUsageGenerate key pair# generate private_key.pem (without password) and public_key.pem:pythoncryptorshell.pygenerate# generate key pair (password protected) to specific files:pythoncryptorshell.pygenerate--privkeyprivate_pwd.pem--pubkeypublic_pwd.pem--pwdmylittlesecretpwdEncrypt & Decrypt file# encrypt little_secret.txt to little_secret.txt.encrypted using default public_key.pempythoncryptorshell.pyencryptlittle_secret.txt# decrypt little_secret.txt.encrypted to little_secret.txt.dec using default public_key.pempythoncryptorshell.pydecryptlittle_secret.txt.encryptedlittle_secret.txt.dec# encrypt file little_secret.txt to encrypted_secret.enc  using public key public_pwd.pempythoncryptorshell.pyencryptlittle_secret.txtencrypted_secret.enc--pubkeypublic_pwd.pem# decrypt encrypted_secret.enc to encrypted_secret.dec using password protected private keypythoncryptorshell.pydecryptencrypted_secret.encdecrypted_secret.dec--privkeyprivate_pwd.pem--pwdmylittlesecretpwd
Package: cryptorama
DescriptionThe Cryptorama module provides Python 3 classes for encrypting, decrypting and
cracking messages using several classical ciphers.  These include the Caesar,
Affine, Multiplicative and Vigenere ciphers.For more information, see thedocumentation.Source code is available onbitbucket.InstallationSimply type:python3 -m pip install cryptoramaor, on linux:sudo python3 -m pip install cryptorama
Package: cryptorandom
Pseudorandom number generator and random sampling using cryptographic
hash functions. The prototype generator is built on SHA-256.Website:https://statlab.github.io/cryptorandomSource:https://github.com/statlab/cryptorandomBug reports:https://github.com/statlab/cryptorandom/issuesInstallation from binaries$ pip install cryptorandomInstallation from sourceInstall dependencies using:$ pip install -r requirements.txtThen, install cryptorandom using:$ pip install .If you plan to develop the package, you may run it directly from source:$ pip install -e .       # Do this once to add pkg to Python pathLicense informationSee the file LICENSE for information on the history of this software,
terms & conditions for usage, and a DISCLAIMER OF ALL WARRANTIES.
Package: crypto-scan
Build and update packagerm -rf ./dist ./buildUpdate version insetup.pypython setup.py sdist bdist_wheeltwine check dist/*to check errortwine upload dist/*to deploy pkgUse below command to update the latest versionpip install --no-cache-dir --upgrade crypto-scanExamplefromcrypto_scan.configsimportETH_CHAINfromcrypto_scan.scanimportScanscan=Scan(ETH_CHAIN,env['ETHSCAN_API_KEY'])scan.get_contract(addr)scan.get_all_trans(addr,startblock=qr.max_block_num)
Package: crypto-screening
crypto-screeningA software for automatically recording real-time crypto exchanges and pairs OHLCV and Orderbook rates.first of allspecifics:written and owned by: Shahaf Frank-Shapirall the rights are saved for Shahaf Frank-Shapirprogramming languages: python 3.9.12 (100%)before we startdescription:visit the docs to learn more about this project and how to develop using it.dependencies:opening:
As this is a really complex program, which uses a lot of modules, there are required dependencies needed
in order to run the program. keep in mind the program was written in Python 3.9, so any Python version lower
than 3.8 might not work properly. Moreover, built-in Python modules are being used, so keep that in mind.install app dependencies by writing the "-r" option to install the requirements
written in a file, and write the following line in the project directory:pip install -r requirements.txtrun a testrun from the Windows command line (inside the project directory)run with Python by writing to the command line in the project directory:python test.py
Package: cryptoshred
CryptoshredWelcome to cryptoshred. You can find more extensive documentation over atreadthedocs.This project arose manly out of the necessity to work with events that contain cryptoshredded information.
It is an implementation of cryptoshredding that is compatible withthis Java implementation. It can either be used independently or together withpyfactcast.Contributions are welcome. Just get in touch.QuickstartSimplypip install cryptoshredand get going. The cli is available ascryptoshredand
you can runcryptoshred --helpto get up to speed on what you can do.DevelopmentThis project usespoetryfor dependency management andpre-commitfor local checks.
Package: cryptoshredding
Crypto shredding is the practice of ‘deleting’ data through the destruction of the cryptographic keys protecting the data.You can find the source onGitHub.Getting StartedRequired PrerequisitesPython 3.6+InstallationNoteIf you have not already installedcryptography, you might need to install additional
prerequisites as detailed in thecryptography installation guidefor your operating
system.$ pip install cryptoshreddingUsageKeyStore>>>importboto3>>>fromcryptoshreddingimportDynamodbKeyStore>>>fromdynamodb_encryption_sdk.material_providers.aws_kmsimportAwsKmsCryptographicMaterialsProvider>>>>>>aws_cmk_id="arn:aws:kms:YOUR_KEY">>>aws_kms_cmp=AwsKmsCryptographicMaterialsProvider(key_id=aws_cmk_id)>>>>>>table=boto3.resource("dynamodb").Table("key_store_table")>>>>>>key_store=DynamodbKeyStore(table=table,materials_provider=aws_kms_cmp)>>>>>>key_store.create_main_key("foo")>>>>>>main_key=key_store.get_main_key("foo")>>>>>>key_store.delete_main_key("foo")# shreddingMainKey>>>importboto3>>>fromcryptoshreddingimportMainKey>>>>>>main_key=key_store.get_main_key("foo")>>>>>>data_key,encrypted_data_key=main_key.generate_data_key()>>>>>>decrypted_data_key=main_key.decrypt(encrypted_data_key)>>>>>>assertdata_key==decrypted_data_keyDynamodb>>>importboto3>>>fromcryptoshredding.dynamodbimportCryptoTable>>>>>>table=boto3.resource("dynamodb").Table("data_table")>>>>>>crypto_table=CryptoTable(...table=table,...key_store=key_store,...)>>>crypto_table.put_item(...CSEKeyId=key_id,...Item=plaintext_item...)>>>>>>index_key={"id":"foo"}>>>encrypted_item=table.get_item(Key=index_key)["Item"]>>>decrypted_item=crypto_table.get_item(Key=index_key)["Item"]>>>>>>encrypted_items=table.scan()["Items"]>>>decrypted_items=crypto_table.scan()["Items"]>>>>>>assertlen(encrypted_items)==1>>>assertlen(decrypted_items)==1>>>>>>key_store.delete_main_key(key_id)# shredding>>>>>>encrypted_items=table.scan()["Items"]>>>decrypted_items=crypto_table.scan()["Items"]>>>>>>assertlen(encrypted_items)==1>>>assertlen(decrypted_items)==0# !!!S3>>>importboto3>>>fromcryptoshredding.s3importCryptoClient>>>>>>s3=boto3.client("s3",region_name="us-east-1")>>>>>>crypto_client=CryptoClient(...client=s3,...key_store=key_store,...)>>>crypto_s3.put_object(...CSEKeyId=key_id,...Bucket=bucket.name,...Key="object",...Body="foo bar"",...)>>>encrypted_obj=s3.get_object(...Bucket=bucket.name,...Key="object",...)>>>decrypted_obj=crypto_s3.get_object(...Bucket=bucket.name,...Key="object",...)File>>>fromcryptoshredding.rawimportCryptoFile>>>>>>crypto_file=CryptoFile(...key_store=key_store,...)>>>crypto_file.encrypt(...key_id=key_id,...plaintext_filename="plain.txt",...ciphertext_filename="cipher.txt"...)>>>crypto_file.decrypt(...ciphertext_filename="cipher.txt",...plaintext_filename="decrypt.txt",...)Bytes>>>fromcryptoshredding.rawimportCryptoBytes>>>>>>crypto_bytes=CryptoBytes(...key_store=key_store,...)>>>encrypted,encrypted_header=crypto_bytes.encrypt(...key_id=key_id,...data=plain,...)>>>decrypted,decrypted_header=crypto_bytes.decrypt(...data=encrypted,...)KinesisMongodbSqlalchemy
Package: crypto-sim
Crypto-simCrypto_sim/crypto-sim is a Python library for dealing with cryptography(secure encryption and decryption).InstallationUse the package managerpipto install crypto-sim.pip install crypto-simUsageTo generate a keyfromcrypto_simimportcryptocrypto.generate_key()# this is the output>>>b'KFH1RhgN_JydLaZzAv6QbpQzsET1SQLjjaFz9dR2-To='#A key will be returnedTo save the key in default dirfromcrypto_simimportcryptocrypto.save_and_create_key()#A key will be automatically generate and savedTo get the saved keyfromcrypto_simimportcryptocrypto.get_key()Note:- this only works when the save_and_create_key() is usedTo encrypt a strfromcrypto_simimportcryptokey=crypto.generate_key()plain_message="hi"encrypted=crypto.encrypt(plain_message,key)print(encrypted)Output:->>>b'gAAAAABe7uOq4PYOSe9usicMgivc0oVJWaWBzBQmbZbICgrG7TfbdxK8bIuXqttaw-rnScJBGd2RUxgSaC3_CTK0NwbJS_THJA=='To decryptFirst, we will execute the above code and then we will get the key and the encrypted messageAfter that,# This full code is after the above codedecrypted=crypto.decrypt(encryption,key)print(decrypted)plain_message==decryptedOutput:->>>hi
>>>TrueLinksCODELICENSESee what's new in the next project
Package: cryptosnake
Simple, unofficial python wrapper forBinance API.You'll find this easy-to-use package helpful if you're interested in general market data and cryptocurrency values. You don't need to have a Binance account or API Key since you can't purchase/trade cryptocurrencies using this package.Installationpython3 -m pip install cryptosnakeorpip3 install cryptosnakeUsagefrom cryptosnake import CryptoSnake

snake = CryptoSnake()

# Crypto to USDT. Takes currency as an argument.
snake.crypto_to_tether('ETH')

# Crypto to BUSD. Takes currency as an argument. Keep in mind that it is BUSD, not USDT and make sure that API provides you the info you need.
snake.crypto_to_usd('ADA')

# Crypto to euro. 
snake.crypto_to_euro('BTC')

# Get a list of available symbols
snake.get_available_symbols()

# Get a list of available pairings
snake.get_available_pairings()

# Get crypto price. Takes crypto pairing as an argument
snake.get_crypto_price('ETHUSDT')DonateIf this package was useful, and you'd like to help out, feel free to donate.ETH: 0x47b9afb6a0580e79ac228f0ce233323549f30284BTC: 1FosbV9CXXwTiLvVa33QyUGvqeF6zhA629ADA: DdzFFzCqrhssxaX8qbkwKrG5ZWjeZCBnRVEcV12f2D2TdQttkgjDukZqHv9sTEwdNq8KwXbCEGZboE6rEwLXDYSiVWiVA7RvmyYpoWiALTC: LZNHh8bVZtdeegDPnaMZu1aHYMwKpYsUiW
Package: cryptostocks
Welcome to crypto-stocksHere are some instructions how to use this libralyHow to import libraryimportcryptostocksHow to get price for crypto currency from Binanceprice_binance=cryptostocks.Binance('crypto_name','fiat_currency')#example:price_binance=cryptostocks.Binance('btc','usd')How to get price for crypto currency from Coinbaseprice_coinbase=cryptostocks.Coinbase('crypto_name','fiat_currency')#example:price_coinbase=cryptostocks.Coinbase('btc','usd')How to get price for crypto currency from FTXprice_ftx=cryptostocks.FTX('crypto_name','fiat_currency')#example:price_ftx=cryptostocks.FTX('btc','usd')How to get price for crypto currency from Krakenprice_kraken=cryptostocks.Kraken('crypto_name','fiat_currency')#example:price_kraken=cryptostocks.Kraken('btc','usd')How to get price for crypto currency from BitStampprice_bitstamp=cryptostocks.BitStamp('crypto_name','fiat_currency')#example:price_bitstamp=cryptostocks.BitStamp('btc','usd')
Package: crypto-stocks
Welcome to crypto-stocksHere are some instructions how to use this libralyHow to import libraryimportcrypto-stocksHow to get price for crypto currency from Binanceprice_binance=Binance('crypto_name','fiat_currency')#example:price_binance=Binance('btc','usd')How to get price for crypto currency from Coinbaseprice_coinbase=Coinbase('crypto_name','fiat_currency')#example:price_coinbase=Coinbase('btc','usd')How to get price for crypto currency from FTXprice_ftx=FTX('crypto_name','fiat_currency')#example:price_ftx=FTX('btc','usd')How to get price for crypto currency from Krakenprice_kraken=Kraken('crypto_name','fiat_currency')#example:price_kraken=Kraken('btc','usd')How to get price for crypto currency from BitStampprice_bitstamp=BitStamp('crypto_name','fiat_currency')#example:price_bitstamp=BitStamp('btc','usd')
Package: cryptostore
A storage engine for cryptocurrency market data. You supply the
exchanges, data type (trade, book, etc), and trading pairs you’re
interested in and Cryptostore does the rest!RequirementsCryptostore currently requires either Kafka or Redis to be installed.
The extra dependencies for your backend of choice must be installed as
well (egpip install cryptostore[redis]). Redis requires Redis
Streams, which is supported in versions >= 5.0.Running CryptostoreOnce installed with pip, an executable is placed on the path, so you can
simply runcryptostoreto start the collector. It requires aconfig.yamlfile. If its not in the current working directory, you
can specify the path to the config with the--configoption.An exampleconfig, with documentation inline is
provided in the root of the repository. The config file is monitored by
cryptostore, so you can change the options in the file and it will apply
them without the need to reload the service. This only applies to
changes made to data within theexchangesblock. Other changes will
be ignored.Storing dataStores data to:ArcticInfluxDBElasticsearchParquet, either on your local drive, or in the cloud using:Google Cloud StorageAmazon S3Google DriveRunning with other consumersCryptostore can operate with other consumers of the exchange data (eg. a
trading engine consuming updates).For RedisDisable the message removal in the Redis settings inconfig.yaml.
The other consumer will need to be responsible for message removal
(if so desired), and it must ensure messages are not removed before
cryptostore has had a chance to process them.For KafkaYou need only supply a different consumer group id for the other
consumers to ensure all consumers receive all messages. Kafka’s
configuration controls the removal of committed messages in a topic
(typically by time or size).With a pass throughCryptostore supports forwarding realtime data using ZeroMQ. To
enable, use thepass_throughoption in the config. Data will be
sent in real time (not subject to aggregation in redis/kafka). This
can be used with or without data aggregation and storage.Running in a containerYou can run Cryptostore in a docker container. A Dockerfile and a
docker-compose.yml are provided. It uses the config in
config-docker.yaml, and its set up to use redis and store the data into
Arctic/MongoDB. The port is mapped to 37017 (as opposed to 27017) so
when connecting to Arctic from outside the container make sure you
specify the port. Additionally, a volume should be configured in the
docker-compose so that the mongoDB data will persist across restarts.Planned features☐ More data types (eg. open interest)☐ Postgres support☐ Missing data detection and correction (for exchanges that support
historical data, typically only trade data)☐ Storing data to MongoDB☐ Support for enabling computation and storage of diverse metrics in
parallel with data collection (eg. configurable OHLCV)ContributingIssues and PRs are welcomed. If you’d like to discuss ongoing
development please join theslack(use the #cryptostore channel).
Package: cryptostream
InstallingYou can easily install cryptostream with pip:pipinstallcryptostreamMotivationImagine two companies A and B. Company B is building drones and writing software for drones. Company A wants to use those drones. The drone saves log files onboard. If the drone crashes or any other accident happens, this log file gives us information about what went wrong. However, this causes several issues: Company A could manipulate those log files, especially if they know that the crash is their own mistake. A simple solution would be to stream the log files to company B, for example via LTE. This, however, causes another type of problem: Privacy. If company A does not want company B to know the contents of the log files, except for rare occasions like accidents, we encrypt the data so that company B can only decode the logs if company A gives them the private key.Examplescdexamplespythongenerate-keys.pypythonencrypt-and-decrypt.py