Saravanan666/pypi-org huggingface dataset:
Package: encrypted-credentials
encrypted-credentialsencrypts credentials to allow them to be securely added to git repositories.It can import encrypted settings into Django defined in a python module and or a json file.
Encrypted files are automatically generated.Django settingsexamplePRIVATE_settings.pyFile stored in folder with django settings.py fileprivate_settings = {
  "AWS_ACCESS_KEY_ID":"ABCDEFGHIJKLMNOP",
  "AWS_SECRET_ACCESS_KEY":"ABCDEFGHIJKLMNOP"
}settings.jsonFile stored in folder with django settings.py file{
  "AWS_ACCESS_KEY_ID":"ABCDEFGHIJKLMNOP",
  "AWS_SECRET_ACCESS_KEY":"ABCDEFGHIJKLMNOP"
}settings.pyfrom encrypted_credentials.django_credentials import add_encrypted_settings

add_encrypted_settings(globals())Upon first execution a PRIVATE_KEY.env file will be generated with a random encryption key. DO NOT check this into repository.
if PRIVATE_settings.py does not exist it will generate a template module.set environment variableexport SETTINGS_KEY=FQQcgYWCBPE8l8IbHdcNie0WARbYHeFwCl4hIL3ecF0=If thesettings.jsonfile exists andsettings.json.encdoes not exist thensettings.json.encwill be created.(development)Ifsettings.jsonandsettings.json.encexist then they will be compared and if differentsettings.json.encwill be overwritten.(development)Ifsettings.jsondoes not exist thensettings.json.encwill be used(production)settings.json.enc and or PRIVATE_settings.enc can be checked into git as it is encrypted with Fernet AES128 encryptionCredential filesget_decrypted_filewill automatically encrypt the original file and supply the decrypted datafrom encrypted_credentials.encrypted_file import get_decrypted_file

get_decrypted_file('full_path/orginal.pem')original.pem.enc can be checked into a repositoryCredential files with DjangoBy default environment variable SETTINGS_KEY will be used as keysettings.pyCREDENTIAL_FOLDER = os.path.join(BASE_DIR, 'credentials')
CREDENTIAL_FILES = {
    'gmail': 'service-account-abcd.json',
    'drive': 'service-account-efgh.json',
}service-account-abcd.json.encusagefrom encrypted_credentials.django_credentials import get_credentials


credentials = get_credentials('gmail')
Package: encrypted-datasets
Installationpipinstallencrypted-datasetsUsageRaw string keyfromdatasetsimportload_datasetfromencrypted_datasetsimportencrypt_dataset,decrypt_datasethuggingface_api_token='API_TOKEN'downloaded_dataset=load_dataset('organization/dataset_repo',token=huggingface_api_token)key='Your Symetric encryption key'decrypted_dataset=decrypt_dataset(downloaded_dataset,key)# Make modifications to decrypted_dataset...re_encrypted_dataset=encrypt_dataset(decrypted_dataset,key)re_encrypted_dataset.push_to_hub('organization/dataset_repo',token=huggingface_api_token)AWS Key management service keyIn this method, you use an AWS KMS key to encrypt data keys that are stored in huggingface with the data.Create new encryped dataset and upload it to huggingface hubfromencrypted_datasetsimportEncryptedDataset,KMSCypherimportboto3kms_client=boto3.client('kms')kms_key_id='<KMS_KEY_ID>'cypher=KMSCypher(key_id=kms_key_id,client=client)dataset=Dataset.from_pandas(...)encrypted_dataset=EncryptedDataset.encrypt(dataset,cypher)encrypted_dataset.push_to_hub('organization/repo_id',token='<ACCESS_TOKEN>')Load encrypted dataset, modify it, and reuploadfromencrypted_datasetsimportEncryptedDataset,KMSCypherimportboto3kms_client=boto3.client('kms')kms_key_id='<KMS_KEY_ID>'hf_token='<HF_TOKEN>'cypher=KMSCypher(key_id=kms_key_id,client=client)encrypted_dataset=EncryptedDataset.load('organization/repo_id',token=hf_token)dataset=encrypted_dataset.decrypt(cypher)# Make modifications to dataset...new_encrypted_dataset=EncryptedDataset.encrypt(dataset,cypher)new_encrypted_dataset.push_to_hub('organization/repo_id',token=hf_token)
Package: encryptedfile
Write OpenPGP compatible-encrypted files like it ain’t no thang.
Symmetric ciphers only.UsageUse it by itself:from encryptedfile import EncryptedFile
f = EncryptedFile("hello.gpg", passphrase=getpass.getpass(),
                  encryption_algo=EncryptedFile.ALGO_AES256)
f.write("super secret message")
f.close()Or with something passed through it:from encryptedfile import EncryptedFile
import PIL
img = ... # obtain image somehow
f = EncryptedFile("pic.png.gpg", passphrase=getpass.getpass(),
                  encryption_algo=EncryptedFile.ALGO_BLOWFISH)
img.save(f, "png")Or use it in aPEP-343block:from encryptedfile import EncryptedFile
with EncryptedFile("txt.gpg", passphrase=getpass.getpass()) as f:
     ... use f ...DecryptLet’s say we’re using gpg:gpg filenameSupply the right passphrase, and tada!FAQDo you support reading?No, reading would mean supporting the bajillion ways that OpenPGP files
have been created throughout history. That would be a pain. I may at
some point in time support reading well enough to be able to read
whatever written by this module.License“THE BEER-WARE LICENSE” (Revision 42): wrote this file. As long as you
retain this notice you can do whatever you want with this stuff. If we
meet some day, and you think this stuff is worth it, you can buy me a
beer in return
Package: encrypted-inference
Encrypted inference SDKThis package allows calling a remotely deployed inferencing service that operates on encrypted input data.
The data is encrypted using homomorphic encryption with theMicrosoft SEALlibrary.
This SDK handles calls to Microsoft SEAL to create a secret key and encrypt the input data, returning an encrypted query as a byte array.
The byte array must then be communicated to a server component, where a model is deployed.
The server performs the prediction, obtaining an encrypted result, which can be decrypted by this SDK with the secret key.
In this process, the server is guaranteed to never learn the client's query.
Package: encrypted-json-field
Encrypted JSON FieldEncrypted JSON field supports automatic encryption/ decryption of JSON fields with padding to conceal start and end of value.SetupNothing really to setup, just import the field and get to work.
You could, however, setup an optional variable in your django settings namedENCRYPTED_JSON_FIELD_SECRET(It should be 16 chars minimum) which will be used to encrypt/ decrypt
the data of your fields. The default behaviour uses the first 16 characters ofSECRET_KEY(Block size).Example:fromencrypted_json_fieldimportEncryptedJSONFieldfromdjango.dbimportmodelsclassCompany(models.Model):name=models.CharField(max_length=32)config=EncryptedJSONField(blank=True)SupportThis supports Python >= 3.8 and Django >= 4.2.
If you need to support other versions, please create an issue.
Package: encrypt-encode
encrypt,encoderencryptและdecryptข้อความแบบง่ายๆ(ง่ายมาก)วิธีใช้importencrypt_encodeasencprint(enc.encode("hello"))#aGVsbG8=print(enc.decode("aGVsbG8="))#helloprint(enc.encrypt("hello"))#('ncdLAcZ=', 'rAGVhPt3lExQBay6RDK1S5wvCLbXHcpUjW2gms4TFizMNo0Zq7k8Jdfnu9OeIY')#encrypt(text,key)ถ้าไม่ใส่keyจะสุ่มkeyให้เองprint(enc.encrypt("hello","rAGVhPt3lExQBay6RDK1S5wvCLbXHcpUjW2gms4TFizMNo0Zq7k8Jdfnu9OeIY"))#ncdLAcZ=#encrypt(text,key)ถ้าใส่keyจะreturnแค่ข้อความprint(enc.decrypt("ncdLAcZ=","rAGVhPt3lExQBay6RDK1S5wvCLbXHcpUjW2gms4TFizMNo0Zq7k8Jdfnu9OeIY"))#keyหาได้จาก keygen() หรือ encrypt() ก็ได้
Package: encrypter
EncrypterEncrypter is a module designed to convert characters into their corresponding numerical value, change it according to a randomly generated constant and finally turn them into characters againInstallationpipinstallencrypterUsageimportencrypterasenc# create the Encrypter Objectencrypter_obj=enc.Encrypter()text="hello world"# encrypt the messageecrypted_text=encrypter_obj.encrypt(text)#decrypt the messagedecrypted_text=encrypter_obj.decrypt(encrypted_text)
Package: encrypter-fernet-dr
EncrypterThis package contains 2 main functions for Encrypting and Decrypting a file.  encrypt_file() creates an encrypted copy of a file using Fernet (symmetric encryption) in the working directory.
The function takes a file as main argument and a key_file as optional argument. If no key_file is given, then a key for the encryption is created using Fernet.generate_key()decrypt_file() is used for decrypting the file generated by the previous function. It requires the encrypted file and the key generated (or used) during the encryption process.InstallationTo install run the following:pipinstallencrypter-fernet-drUsagefromencrypter_fernet_drimportencrypt_file# generate key and encrypted copy of my_file in the working directoryencrypt_file('my_file')fromencrypter_fernet_drimportdecrypt_file# decrypt the file passing the key generated or used beforedecrypt_file('my_file_encrypted','my_key')Developing EncrypterTo install encrypter, along with the tools needed to develop and run tests, run the following in your virtualenv:$pipinstall-e.[dev]
Package: encrypt-file
:page_with_curl:encrypt file:lock:Encrypt or decrypt files with ONLY ONE COMAND__________________________________//_/__(_)/__/_\/__\/___/___////__\/__///_///_\/__/////__////_///_///_/__///__/\___/_//_/\___/_/\__,/.___/\__//_//_/_/\___//____/_/EncryptordecryptfileswithONLYONECOMAND----------------------------------------------------------------------
PARAMETERS
func:encrypt
password:123456file_path:tests/plain_text.txt

Encrypting...
Encryptedfileattests/plain_text.txt.enc
Executiontime:0.01secondsTheencrypt fileis aCLIfor encrypting and decrypting files.Why should I use theencrypt file?No Code: When there is no need to code something you can simply useencrypt file.Abstraction of cryptographic algorithms: you don't need to know what goes on behind the scenes inencrypt file(but if you want, just see it on github).RequirementsThis project is tested with:RequisiteVersionPython3.8.10Pip21.2.4Installpipinstallencrypt-fileUsage:lock: Encrypt :lock:encrypt-file\--funcencrypt\--fileplain_text.txt\--password123456:unlock: Decrypt :unlock:encrypt-file\--funcdecrypt\--fileplain_text.txt.enc\--password123456What is the security level?Even using low-quality passwords,encrypt filetries to make things as secure as possible because it is implemented usingPBKDF2key deviation with SHA256 hash, a 16-bit random salt and 10,000 rounds.
Package: encryptfs
A simple file system that encrypts each file individually. Designed for
use with cloud storage.DetailsQuick high-level overview:You have some filesabc,123,asdf.You make an encryptFS in a directory and add all three files. You end
up with an encrypted index file and three files with randomly
generated names (e.g.e4e90f66761a0ddf52ec47e3d9f1851e3e2304b2b9abd6ae0f818cafa26d56a0).Later, you can open the existing encryptFS and decrypt your files
back.FAQ:What do you use for the actual encryption? PyCrypto, AES-256 (32-byte
key)Why are the files encrypted separately instead of being put together
in blocks? Isn’t this a flaw in the security? For now, I’m willing to
trade off the security to simplify the code and to allow for
easier/quicker decryption of specific individual files.Does this keep my original file metadata? For now, no.UsageThis project isverynew and this API isverysubject to change.Set upgitclonehttps://github.com/csu/encryptFS.gitcdencryptFSpipinstall-rrequirements.txtExample scriptfromencryptfsimportEncryptFS# Replace `asdfasdf` with a passwordencfs=EncryptFS('asdfasdf')# This will encrypt all new files in the current directoryencfs.encrypt_all()# This will decrypt all encrypted files in the indexencfs.decrypt_all()Have questions or suggestions?Open an
issue.CLICLI requires theclickpackage.pythoncli.py<action><password>
Package: encrypticoin-etalon
encrypticoin-etalonImplementation of the Etalon Token by Encrypticoin UAB.Etalon is a BEP20 token implemented in Solidity, heavily utilizing the framework provided by the OpenZeppelin project.Etalon contractThe contract is found atencrypticoin_etalon/contract/BEP20EtalonToken.sol. Its pre-compiled ABI and binary-code is also committed that were compiled by the specified Solidity compiler version.Python packagingThe contract is wrapped in a Python package for easy development and distribution in the relevant server systems.Testing of the contract is performed in other environments, this repository is purely for the contract itself.A source distribution package is available from PyPI namedencrypticoin-etalon:pip install encrypticoin-etalon
Package: encrypticoin-ssi
encrypticoin-ssiService-Server-Integration library written in Python for use with the Etalon Token-Integration-API.The API is made to be as simple as possible, so integration from any environment would be cheap and easy. This repository demonstrates the integration procedure for both "simple" and "tracking" workflows using a tiny mocked service-server and service-client.CompatibilityThe library is tested with CPython 3.8, 3.9 and 3.10. It should work with PyPy3 as well, but there is a dependency needed for running the tests that is not available for it.UsageThe main feature of the library is theServerIntegrationClientclass. It implements a lightweight wrapper to the integration REST API usingaiohttp.NOTE: The codes in theencrypticoin_ssi_testsdirectory are purposefully kept minimalistic and simple to highlight the functional parts of the procedures. For a production environment, several changes must be made to provide the necessary security and data persistence.Theencrypticoin_ssi_tests/simpledirectory holds the example/test of the simple workflow:service_server/main.pyimplements the server-side integration and a mock API for testingservice_client.pyimplements a mock client that communicates with the service-servertest_workflow.pytakes all of them and performs a basic test procedureTheencrypticoin_ssi_tests/trackingdirectory holds the example/test of the tracking workflow:service_server/main.pyimplements the server-side integration and a mock API for testing and the token-tracking collector procedureservice_client.pyimplements a mock client that communicates with the service-servertest_workflow.pytakes all of them and performs a basic test procedureServer APIThe live server-API documentation is available athttps://etalon.cash/tia/docsInstallA source distribution package is available from PyPI namedencrypticoin-ssi:pip install encrypticoin-ssi
Package: encryptify
🌟 Encryptify: Unveil the Enigma of Binary Encryption! 🚀Welcome to the fascinating world of Encryptify! 🎉 Encrypt and decrypt your messages in a unique and captivating way using Python. With just two enchanting functions, you can transform ordinary text into mesmerizing binary patterns and decode them back to their original form.Explore more about this project onmy website, and don't miss out on other exciting projects by following me onGitHub!InstallationGet started on your journey with BinaryCrypt by installing it using pip:pipinstallencryptifyFeatures 🌈Encrypt Function 🔐Theencryptfunction takes your everyday text and turns it into a hypnotic sequence of dots and spaces. Watch your words transform into an enigmatic binary dance!fromencryptifyimportencryptdata="Hello, world!"encrypted_data=encrypt(data)print(encrypted_data)# Output: " .  .    ..  . . .. ..   .. ..   .. ....  . ..    .      ... ... .. .... ...  .  .. ..   ..  .    .    ."Decrypt Function 🔓Decipher the enigma with thedecryptfunction! It transforms dots into 1s and spaces into 0s, elegantly converting binary text back into its original form.fromencryptifyimportdecryptbinary_data=" .  .    ..  . . .. ..   .. ..   .. ....  . ..    .      ... ... .. .... ...  .  .. ..   ..  .    .    ."decrypted_data=decrypt(binary_data)print(decrypted_data)# Output: "HELLO WORLD"Note:Please ensure that you only use data with dots and spaces for decryption. Any other characters will lead to a charmingTypeError.Join the Adventure! 🌐Ready to contribute to the magic of Encryptify? If you stumble upon any enigmatic issues or have brilliant ideas, feel free to open an issue or pull request onGitHub. Let's unravel this puzzle together!Credits 🙌Encryptify is lovingly crafted by the one and onlyAkash Nath. Dive into his world of innovation by following him onGitHub!License 📜Encryptify operates under the enchanting spell of theMIT License. Your journey into the world of binary wonders has just begun! 🌌
Package: encryption-jsv
# Project description## File Encryption ToolThe File Encryption Tool is a command-line app for encrypting files using popular encryption algorithms such as AES (Advanced Encryption Standard) and DES (Data Encryption Standard).### Features- **File Encryption:**- **Choice of Encryption Algorithm:**- **Secret Key:**- **Straightforward Usage:**### UsageTo use the File Encryption Tool, follow these steps:1. **Clone or download the repository:** Get the source code for the tool by cloning the repository or downloading it as a ZIP file.2. **Install dependencies:** Ensure you have the necessary dependencies, including the `cryptography` library.```bashpip install encryption_jsv
Package: encryptme
EncryptMe LibraryEncryptMe is a simple encryption library developed by ADJEI COLLINS, a Cybersecurity student from Accra Technical University, Ghana.FeaturesEncrypt and decrypt messages using a provided key.Save encrypted messages to files.Read encrypted messages from files.Display decrypted messages.InstallationYou can install the library using pip:
pip install encryptmepipinstallencryptme

ChangeLog==========1.5.0(22/08/2023)## USAGE GUIDE# This guide demonstrates how to use the 'encryptme' library to encrypt and decrypt messages.importencryptme# Encryption key (known only to the sender)encryption_key=12345# Message to encryptmessage="Hello, this is a secret message!"# Encrypt the messageencrypted_message=encryptme.encrypt(message,encryption_key)# Save encrypted message to a fileencrypted_message.save("encrypted_message.txt")# Decrypting the message# (Importing the module again to ensure access to all functions)importencryptme# Encryption key (known only to the receiver)decryption_key=12345# Read encrypted message from the fileencrypted_message=encryptme.read("encrypted_message.txt")# Decrypt the messagedecrypted_message=encryptme.decrypt(encrypted_message,decryption_key)# Show decrypted messagedecrypted_message.show()
Package: encryptor64
# py-encryptionPython package for encryption strings by merging some key and string throw base64encode.Example:```python# coding=utf-8# Encodingfrom encryption.encryption import *some_key = "3jdg472666HJA83jJA723lL"encrypt = Encryption(key=some_key)encoded_string = encrypt.encode("my_string_for_encode")print (encoded_string)# Decodingfrom encryption.encryption import *some_key = "3jdg472666HJA83jJA723lL"encrypt = Encryption(key=some_key)decoded_string = encrypt.decode(encoded_string)print (decoded_string)```
Package: encryptos
Encryptos DescriptionGet to encrypt data easily using a unique algorithm.Getting StartedEncryptos requires secret ,which is ,secret key/passcode to decrypt or encrypt data just in simple steps.Install encryptos using pip::python -m pip install encryptosPrerequisitesNo extra modules have to be installed to use this module but only python built-in modules will be used.DeploymentAfter installation,just use this module like this::from encryptos import encrypt,decrypt

 key="secret_key"
 string_="unencrypted_string"

 encrypted=encrypt(string_,key)
 decrypted=decrypt(encrypted, key)First the string "string_" is encrypted to "encrypted" varible and then decrypted back to "string_" by "decrypt" function ,that is to "decrypted".ContributingPlease readCONTRIBUTING.mdfor details on our code of conduct, and the process for submitting pull requests to us.AuthorsBrian Musakwa-Initial work-digreatbrianSee also the list ofcontributorswho participated in this project.LicenseThis project is licensed under the Lesser General Public License - see theLICENSEfile for detailsAcknowledgmentsI hereby thank everyone who has contributed to this software as any contribution is regarded good for better performance of the software.
Package: encryptPack
encryptPack=============This project refers to a password encryptor, which also serves to encrypt and decrypt files through a password entered by users.Project Criptoto write your content.1 - Para instalar o pacote use:pip install encryptPack2 - import o modulo usando:from CryptoPwd import crypt3 - Formas de usar o pacote:from CryptoPwd import crypt

#instancia da classe FileDesc
f = crypt.FilesDec() 

# Criptografando um arquivo
f.decryptFiles('teste.txt','1234')

#Decriptografando um arquivo
f.decryptFiles('teste.txt','1234')
Package: encryptpy
简体中文Encrypt your Python projectUse Cython to compile Python code to binary and supportgit-diffto get changed files conveniently.Installation$ pip install encryptpyBasic UsageUsage: encryptpy [OPTIONS] COMMAND [ARGS]...

  Encrypt your Python code

Options:
  --config TEXT  The config file, ignore if given is invalid  [default:
                 .encryptpy.cfg]
  --help         Show this message and exit.

Commands:
  clean     Simply clean `build` and `__pycache__` directory in DIRS
  git-diff  Compile files between two COMMITS, see `git-diff`: `--name-only`
  init      Copy src to build-dir and do compile, usually used for the...
  run       Compile given Python code filesFor the subcommand info, useencryptpy <subcommand> --help.ExamplesFor example, there is a package namedpackage_a(notice the work directory):$ tree -a ..
├── .encryptpy.cfg
└── package_a
    ├── __init__.py
    ├── main.py
    ├── README.md
    ├── setup.py
    └── utils.py

1 directory, 6 filesThe.encryptpy.cfg's contents are as follow:[encryptpy]; Files will be compiledpaths=package_a; Files will be ignored when compiling, support Regexignores=setup.py; For command `init`, files will be ignored when copying, Glob-stylecopy_ignores=*.pyc*.md; The build directorybuild_dir=build; For commands `run` and `git-diff`, whether the source .py will be removedclean_py=01. Use in the first time$ encryptpy init .Look thebuilddirectory:$ tree -a buildbuild
├── .encryptpy.cfg
└── package_a
    ├── __init__.cpython-38-x86_64-linux-gnu.so
    ├── main.cpython-38-x86_64-linux-gnu.so
    ├── setup.py
    └── utils.cpython-38-x86_64-linux-gnu.so

1 directory, 5 files2. Use normally byrun$ encryptpy run package_a/main.pyThepackage_a/main.pywill be recompiled topackage_amain.cpython-38-x86_64-linux-gnu.so3. Use normally bygit-diff$ encryptpy git-diff 0.1 0.2The changed files between tag(or commit, or branch) 0.1 and 0.2 will be compiled.DefectThe defects mainly come from Cython - some Python code can not be compiled correctly. Here are known issues:Assignment Expressions:=:Implement PEP 572: Assignment Expressions #2636@dataclass:Implement @dataclass for cdef classes #2903Class method decorators combination:Combining @staticmethod with other decorators is broken #1434e.g.classC:@staticmethod@some_decoratordeff():passbut this can be rewrite tof = staticmethod(some_decorator(f)), it's ok.If you have some code like the above, you can refactor or just ignore them, it is safe enough for most projects.2022.08.10 UPDATE:It seems that the first two defects have been resolved.