Saravanan666/pypi-org huggingface dataset:
Package: keystore
Keystore - keeps your keys in one place.----------------------------------------THIS IS AN EXPERIMENT. DO NOT USE IN PRODUCTION.================================================Prerequisites=============Python 3.4+.Install=======You can install straight from `pip`.pip install keystoreBefore using it for the first time, you will need to setup a `~/.keystorerc` inyour home directory.{"keystore": "~/Dropbox/keystore","files": ["~/.ssh","~/.gnupg/gpg-agent.conf","~/.gnupg/gpg.conf","~/.gnupg/private-keys-v1.d","~/.gnupg/pubring.gpg","~/.gnupg/secring.gpg","~/.gnupg/trustdb.gpg",],"verbose": true}Example usage=============**Saving keys:**$ keystore-saveInspecting ~/.ssh:Adding /Users/spaxe/.ssh/id_rsa ...Adding /Users/spaxe/.ssh/id_rsa.pub ...Adding /Users/spaxe/.ssh/known_hosts ...Added 3 key(s) to keystore.This passphrase is used to decrypt your keystore. Please remember it.Please enter a passphrase:Please verify your passphrase:Passphrase accepted. Encrypting ...Keyring successfully created:AwGd2MtDWRkOFdyJoRZTdFApvKnoBQ2PXsqqE[...]**Loading keys:**$ keystore-loadLocated encrypted keystore at ~/Dropbox/keystore:Please enter the passphrase:Keyring decrypted successfully.File /Users/spaxe/.ssh/id_rsa exists. Are you sure you want to overwrite? (y)/n:Writing key to /Users/spaxe/.ssh/id_rsa ...File /Users/spaxe/.ssh/id_rsa.pub exists. Are you sure you want to overwrite? (y)/n:Writing key to /Users/spaxe/.ssh/id_rsa.pub ...File /Users/spaxe/.ssh/known_hosts exists. Are you sure you want to overwrite? (y)/n:Writing key to /Users/spaxe/.ssh/known_hosts ...Keyring loaded. Restored 3 keys.**Loading keys to the same directory (useful for a new machine):**$ mkdir keys$ keystore-load --copy-to keysLocated encrypted keystore at ~/Dropbox/keystore:Please enter the passphrase:Keyring decrypted successfully.Writing key to /Users/spaxe/keys/id_rsa ...Writing key to /Users/spaxe/keys/id_rsa.pub ...Writing key to /Users/spaxe/keys/known_hosts ...Keyring loaded. Restored 3 keys.**Running tests:**python3 test.pyLicense=======© Xavier Ho <contact@xavierho.com>License under MIT License.
Package: key-stroke
README - Welcome to key_stroke - The Python MP Master Librarykey_strokeis the python key stroke module for all platforms. It can be
used to easily interrupt a running loop by pressing a user defined key or key combination.
It comes with a simple and intuitive API and can be used on Linux, Mac as well Windows Systems.InstallationFor a simple and painless installation of the key stroke module in your system, please refer to the documentation. You will find what you are looking for under the heading "Installation of the key_stroke module".Module Requirementsxxx (will be installed during the pip install process)Coding hintsNix.How to build the PackageTo build the packet, simply runmake buildand enjoy a café.To give the documentation a new shine, simply runmake doc.Build RequirementsFor details see:https://packaging.python.org/en/latest/tutorials/packaging-projects/python3and a ton of packages specified in requirements.txt
to install them run: pip install -r requirements.txt -U
Package: keysymdef
This Python package contains the X11 and XF86 keysym definitions as lists of tuples:>>> from keysymdef import keysymdef, xf86keysym
>>> print(keysymdef[1])
('BackSpace', 65288, None)
>>> print(xf86keysym[1])
('MonBrightnessUp', 269025026, None)The elements of each tuple are:The mnemonic name (str)The integer value (int)The unicode code point, if any (intorNone)This data is hard-coded; consequently this package has no dependencies (onpython-xlibor others).
Package: keys-yocto
Yocto KeysMake licence keys using RSA signature verificationInstallationpipinstallkeys-yoctoUsageYou'll be prompted to make new RSA keys the first time you run the app. If you need to make new keys later, you can do it in the Keys menu.The app will remember where you saved the last private key you made. If you need to use a different key than the last one you made or if you moved it, you can change the location of the key in the Keys menu.Fill in the user's details and click Sign. Then copy the licence key and send it to the user.How to verify licence keys in your appfromkeysimportkeyifkey.valid(user,licence_key,pub_key):# licence_key is validelse:# licence_key is invalidSupportEmaildelvian.valentine@gmail.comfor helpContributingPull requests are welcome. For major changes, please open an issue first to discuss what you'd like to change.AcknowledgementsMaterial IconsPyInstallerPython-RSAQt for PythonUXWingThis app was inspired bythis articleLicenceCopyright © 2024Delvian ValentineThis program comes with ABSOLUTELY NO WARRANTY.This is free software, and you are welcome to redistribute it under certain conditions.See theGNU General Public Licensefor details.
Package: keyt
keytkeyt is a stateless password manager and generator.Derive don't store.The intent of this program is to have a password manager and generator without storing any data anywhere in any form. The password is derived from a master password.⚠️ Every passwords are derived from your master password, if you loose it you will lose access to all your account, be carreful.Install CLIpipinstallkeytUsageusage: keyt [domain] [username] [master_password] [options]

keyt stateless password manager and generator.

positional arguments:
  domain                Domain name/IP/service.
  username              Username/Email/ID.
  master_password       Master password used during the password generation.

optional arguments:
  -h, --help            show this help message and exit
  --version
  -c COUNTER, --counter COUNTER
                        An integer that can be incremented to change our the
                        password. default=0.
  -f FORMAT, --format FORMAT
                        Password format can be: 'max', 'high', 'mid', 'pin' or
                        'pin6'. default=max.
  -o, --output          Output the password, by default copy it to the
                        clipboard.
  -t [TIMER], --timer [TIMER]
                        Time before flushing the clipboard. default=20s.Examples$ keyt
domain: example.com
username: admin
master password:
Password copied to the clipboard for 20s.

$ keyt example.com admin admin
Password copied to the clipboard for 20s.

$ keyt example.com admin admin -o
Fg0XjW@a=vWi@3qGBjo|Vlic7Wo9`zVKp!{Vl_Bp

$ keyt example.com admin admin -o -f mid
5w8Hv23ZUvJCRt2t

$ keyt example.com admin admin -o -f pin
3070>>>fromkeytimportgen_password>>>gen_password(d="example.com",u="admin",m="admin")'Fg0XjW@a=vWi@3qGBjo|Vlic7Wo9`zVKp!{Vl_Bp'TroubleshootingIf you get an error on pyperclip it's probably because you need to install additionnal packages.For example on Ubuntu:sudoapt-getinstallxclipMore infos on pyperclip description:pypi pyperclip.Licensekeyt is licensed under MIT.
Package: keytime
Keytimeinstall keytimeLinux/MacOS:pip3 install keytimeorpython3 -m install keytimeWindows:pip install keytimeorpy -m pip install keytimerun keytimedefault:$ python3
>>> from keytime.keytime import run
>>> run()interactive:$ python3
>>> from keytime.keytime import run
>>> run(interactive=True)keytime will now read your keyboard input. By pressing 'Escape', keytime will stop reading your input and display
collected data as a table. Keytime also writes a.csv-file named 'output.csv' if you selected corresponding
settings.update 0.1.2Reset the collected data after eachrun()callAdding an interactive environment for saving output.csv
Package: keytitan
KeyTitan Password Generator and ValidatorThe provided Python code defines a class calledKeyTitanthat serves as a password generator and validator. It generates random passwords that meet certain criteria and validates passwords against specific rules.KeyTitan ClassTheKeyTitanclass has the following methods:__init__(self, length=12)This is the constructor method for theKeyTitanclass. It allows you to initialize an instance of the class with an optional password length, with a default length of 12 characters.generate_password(self)This method generates a random password based on specified criteria. The criteria for the generated password are as follows:The password must be at least 8 characters long.It must include at least one uppercase letter, one lowercase letter, one digit, and one special character.The remaining characters are randomly chosen from all character sets.The order of characters in the password is randomized.If the password length is less than 8, aValueErroris raised. Otherwise, a password is generated and returned.validate_password(self, password)This method validates a given password against specific criteria, including:The password must be at least 8 characters long.It must include at least one uppercase letter, one lowercase letter, one digit, and one special character.If the password meets these criteria, the method returnsTrue. If not, it prints error messages for the specific criteria that the password does not meet and returnsFalse.Example UsageThe code provides an example of how to use theKeyTitanclass:An instance of theKeyTitanclass is created with a specified password length of 10 characters.A random password is generated using thegenerate_passwordmethod and printed to the console.The generated password is then validated using thevalidate_passwordmethod against the same criteria. If the password is valid, it prints "Password is valid." Otherwise, it prints error messages for the criteria that are not met.SummaryTheKeyTitanclass provides a simple and customizable way to generate and validate passwords based on specific criteria. It ensures that generated passwords meet security standards by requiring a minimum length and including a mix of character types. The code can be easily integrated into applications or scripts that require secure password generation and validation.
Package: keytotext
keytotextIdea is to build a model which will take keywords as inputs and generate sentences as outputs.Potential use case can include:MarketingSearch Engine OptimizationTopic generation etc.Fine tuning of topic modeling modelsModel:Keytotext is based on the Amazing T5 Model:k2t:Modelk2t-base:Modelmrm8488/t5-base-finetuned-common_gen(by Manuel Romero):ModelTraining Notebooks can be found in theTraining NotebooksFolderNote: To add your own model to keytotext Please readModels DocumentationUsage:Example usage:Example Notebooks can be found in theNotebooksFolderpipinstallkeytotextTrainer:Keytotext now has a trainer class than be used to train and finetune any T5 based model on new data. Updated Trainer docs here:DocsTrainer example here:fromkeytotextimporttrainerUI:UI:pipinstallstreamlit-tagsThis uses a custom streamlit component built by me:GitHubAPI:API:The API is hosted in the Docker container and it can be run quickly.
Follow instructions below to get starteddockerpullgagan30/keytotext

dockerrun-dp8000:8000gagan30/keytotextThis will start the api at port 8000 visit the url below to get the results as below:http://localhost:8000/api?data=["India","Capital","New Delhi"]Note: The Hosted API is only available on demandBibTex:To quote keytotext please use this citation@misc{bhatia,title={keytotext},url={https://github.com/gagan3012/keytotext},journal={GitHub},author={Bhatia, Gagan}}Referenceshttps://github.com/Shivanandroy/simpleT5(Shivanand Roy)https://github.com/patil-suraj/question_generation(Suraj Patil)https://github.com/MathewAlexander/T5_nlg(Mathew Alexander)Articles about keytotext:https://towardsdatascience.com/data-to-text-generation-with-t5-building-a-simple-yet-advanced-nlg-model-b5cce5a6df45(Mathew Alexander)Amazing Video by1LittleCoderhere:https://www.youtube.com/watch?v=I0iBzP-SxFYabout keytotexthttps://medium.com/mlearning-ai/generating-sentences-from-keywords-using-transformers-in-nlp-e89f4de5cf6b(Prakhar Mishra)
Package: key-train
Keyboard Training Software (for linux)
A keyboard training program which I’m designing for my 8 year old son.
This is a keyboard training program (i.e. typing tutor) for touch typing, still in it’s early days.
Goals:
Open source and open community.
Various languages supported (although not right to left nor logographic writing systems = ex. Kanji) (todo)
Various international keyboards supported and probably dvorak keyboards as well. (todo)
Attractive interface. (todo)
Scalable graphics, make the window as small or as large as you like.
Show the beginner typist where they should place their fingers. (todo)
Interesting text for advanced users instead of just random gibberish. Will pull in text from Wikipedia entries, for
various languages. (todo)
Beginner levels will have random text, however, and they should focus on common bi=grams and trigrams of the language in
question, to build up muscle memory for common key combinations. (todo)
Random text should also start with very simple letter combinations, like two keys close together for training the first
time. (todo)
Stats and progression. (todo)
Heatmap of trouble keys for the student. (todo)
Auto build lessons to work on the trouble keys. (todo)
Lessons for the number keys and punctuation marks. (todo)
Start off without the space bar or the backspace key, add these keys later.
Package: keytree
Keytree provides functions for reading and writing KML using the ElementTree
API.Reading KMLKML Placemark elements can be adapted to the Python geo interface and then used
with packages likeShapely:>>> data = """<?xml version="1.0" encoding="UTF-8"?>
... <kml xmlns="http://www.opengis.net/kml/2.2">
...   <Document>
...     <Placemark id="pm_1">
...       <name>point</name>
...       <Snippet>Point test</Snippet>
...       <Point>
...         <coordinates>
...           -122.364383,37.824664,0
...         </coordinates>
...       </Point>
...     </Placemark>
...   </Document>
... </kml>
... """
>>> from xml.etree import ElementTree
>>> doc = ElementTree.fromstring(data)
>>> kmlns = doc.tag.split('}')[0][1:]
>>> placemarks = doc.findall('*/{%s}Placemark' % kmlns)
>>> p0 = placemarks[0]
>>> import keytree
>>> f = keytree.feature(p0)
>>> print f.id, f.properties.name, f.properties.snippet
pm_1, point, Point test
>>>
>>> from shapely.geometry import shape
>>> s = shape(f.geometry)
>>> print s.buffer(1.5).exterior.length
9.4209934708642571Writing KMLObjects that provide the Python geo interface can also be converted to
ElementTree API Elements:>>> f = {
...     'id': 'pm_2',
...     'geometry': {
...         'type': 'Point',
...         'coordinates': (-122.364383, 37.824663999999999) },
...     'properties': {
...         'title': 'Feature 2',
...         'description': 'The second feature', }The first argument to the keytree.element function is an XML context, the
created element will have the same namespace as that element:>>> data = """<?xml version="1.0" encoding="UTF-8"?>
... <kml xmlns="http://www.opengis.net/kml/2.2">
...   <Document>
...   </Document>
... </kml>
... """
>>> doc = ElementTree.fromstring(data)
>>> elem = element(doc, f)
>>> print elem
<Element {http://www.opengis.net/kml/2.2}Placemark at ...>
>>> pprint(list(elem))
[<Element {http://www.opengis.net/kml/2.2}name at ...>,
 <Element {http://www.opengis.net/kml/2.2}Snippet at ...>,
 <Element {http://www.opengis.net/kml/2.2}description at ...>,
 <Element {http://www.opengis.net/kml/2.2}Point at ...>]The created element is not automatically added to the KML context and must be
appended to its proper Document or Folder:>>> doc[0].append(elem)
>>> print etree.tostring(doc)
<ns0:kml xmlns:ns0="http://www.opengis.net/kml/2.2">
  <ns0:Document>
    <ns0:Placemark id="pm_2">
      <ns0:name>Number 2</ns0:name>
      <ns0:Snippet>Placemark number 2</ns0:Snippet>
      <ns0:description />
      <ns0:Point>
        <ns0:coordinates>0.000000,0.000000,0.0</ns0:coordinates>
      </ns0:Point>
    </ns0:Placemark>
  </ns0:Document>
</ns0:kml>KML HelpersThe keytree.kml module contains a few useful utility functions:>>> from keytree.kml import kml_ns, findall_placemarks
>>> print kml_ns(doc)
{http://www.opengis.net/kml/2.2}
>>> findall_placemarks(doc)
[<Element {http://www.opengis.net/kml/2.2}Placemark at ...>]
Package: keyup
PACKAGE:  keyupkeyupautomates IAM user access key rotation from the cli by allowing ad hoc or
scheduled renewal of your access key credentials via the Amazon API’s.keyup:A safe and reliable way to rotate (renew) access keys to Amazon Web Services as frequently as you wish, with minimal effort and risk.requires only the profile name of your IAM user in your localawscli configurationFeatures:access key rotation via the Amazon APIskey rotation includes:creation of new access keysautomated installation in the localawscli configurationdeprecated key deletionautomated, unattended key rotationrotate keys as frequently as you wish (daily, for example)
Package: keyutils
python-keyutils is a set of python bindings for keyutils (available fromhttp://people.redhat.com/~dhowells/keyutils), a key management suite that
leverages the infrastructure provided by the Linux kernel for safely storing
and retrieving sensitive infromation in your programs.UsageThe C extension module follows closely the C API (seeadd_key(2),request_key(2),keyctl_read_alloc(2)).Exceptions also follow the C API. The only notable difference is forrequest_key: when the key is not present,Noneis returned, instead of
raising an exception (which is usually a more expensive operation).Note that the function parameters are passed as bytes not strings! On python 3
this usually requires an explicitparam.encode()call.For example:importkeyutils# NOTE: only pass `bytes` to the keyutils API:name=b'foo'value=b'bar'ring=keyutils.KEY_SPEC_PROCESS_KEYRINGkey_id=keyutils.add_key(name,value,ring)assertkeyutils.request_key(name,ring)==key_idassertkeyutils.read_key(key_id)==value# set timeout to 5 seconds, wait and then... it's gone:keyutils.set_timeout(key_id,5)fromtimeimportsleepsleep(6)assertkeyutils.request_key(name,ring)==NoneFurther examples can be found in thetestsubfolder.
Package: key-value-ds
key-value-dsFile based Key-Value datastoreSupports basic CRD (Create, Read, Delete)Functionalities:It can be initialized using an optional file path. If one is not provided, it will reliably create itself usinguuid.Key string capped at 32 characters and Value must be a JSON object capped at 16KB. (These values can be changed in config.py)Every key supports setting a Time-To-Live property when it is created. This property is optional. If provided, it will be evaluated as an integer defining the number of seconds. Once the Time-To-Live for a key has expired, the key will no longer be available for Read or Delete operations.Only one process can access the datastore (local file) at a time.Thread safe.Usage:Creating an instanceimport key_value_ds
ds_instance = key_value_ds.get_instance()Note: Iffile_pathis provided in theget_instance()call, it will obtain lock on that file usingfcntl. If object is created for the same file path twice,BlockingIOErroris thrown.Creating an datadata_key = 'test_key'
data_value = {"value": 1}  # must be a JSON
time_to_live = 5*1000  # in milliseconds
ds_instance.create(data_key, data_value, ttl=time_to_live)Retrieving dataretrieve_key = 'test_key'
ds_instance.get(retrieve_key)   # returns {"value": 1} if retrieved within 5 seconds else ValueErrorDeleting datakey_to_delete = 'test_key'
ds_instance.delete(key_to_delete)  # key-value is removed from the datastoreDelete all datads_instance.delete_all()
Package: keyvalues1
KeyValues1Parser forversion 1 of Valve's KeyValues format.The focus of this particular library is parsing of relevantsteamcmdoutput.Installationpipinstallkeyvalues1Usagefromkeyvalues1importKeyValues1text=""""570"{"common"{"name" "Dota 2""oslist" "windows,macos,linux""type" "game"}}"""data=KeyValues1.parse(text)print(data["570"]["common"]["name"])
Package: keyvalues3
keyvalues3KeyValues3 is a Valve developed data format. It is similar in structure to JSON, but supports binary encodings, versioning, and data annotations. The text syntax also has some minor ergonomic improvements (support for single- and multi-line comments, trailing commas, and multi-line strings.)Usageimportkeyvalues3askv3bt_config=kv3.read("tests/documents/bt_config.kv3")>>>bt_config.keys()dict_keys(['default','low','fair','normal','tough','hard','very_hard','expert','elite'])>>>bt_config["elite"]["reaction_time"]0.12# The root value is most of the time a dict>>>type(bt_config.value)<class'dict'>>>>bt_config.original_encodingEncoding(name='text',version=UUID('e21c7f3c-8a33-41c5-9977-a76d3a32aa0d'))>>>bt_config.formatFormat(name='generic',version=UUID('7412167c-06e9-4698-aff2-e63eb59037e7'))# To write it back>>>kv3.write(bt_config,"tests/documents/bt_config.kv3",use_original_encoding=True)# Write to a stream>>>importsys>>>kv3.write({"key":[1,2,3]},sys.stdout)<!--kv3encoding:text:version{e21c7f3c-8a33-41c5-9977-a76d3a32aa0d}format:generic:version{7412167c-06e9-4698-aff2-e63eb59037e7}-->{key=[1,2,3]}Installpipinstallkeyvalues3Supported encodingsEncoding 👩‍💻Read 📖Write ✍️Text UTF-8Yes ✔️Yes ✔️Text UTF-8 HeaderlessYes ✔️Yes ✔️Binary UncompressedNo ⛔Yes ✔️Binary LZ4No ⛔Yes ✔️Binary (Other newer)No ⛔No ⛔CreditsValve Corporation for making KeyValues3.SteamDatabase/ValveResourceFormatfor reversing the binary formats.
Package: keyvalue-sqlite
KeyValueSqliteSuper easy drop in replacement for python dictionary, which stores
it's key-value to an sqlite database.APIfromkeyvalue_sqliteimportKeyValueSqliteDB_PATH='/path/to/db.sqlite'db=KeyValueSqlite(DB_PATH,'table-name')# Now use standard dictionary operatorsdb.set_default('0','1')actual_value=db.get('0')assert'1'==actual_valuedb.set_default('0','2')assert'1'==db.get('0')New in 1.0.4: atomic integers.fromkeyvalue_sqliteimportKeyValueSqliteDB_PATH='/path/to/db.sqlite'db=KeyValueSqlite(DB_PATH,'table-name')# Now use standard dictionary operatorsdb.set_default('atomic_var','1')db.atomic_add('atomic_var','2')val=db.get('atomic_var')assert'3'==actual_valueThis datastructure is not going to win any performance races, but it
is super simple to use with just a few lines of code. This is a great
option for one of those small web apps which doesn't have enough load
to justify mysql or postgres, or a file that will be used by multiple
processes, or to store a file that can't be corrupted during a power
failure.When fetching large amounts of data try to use get_many() or dict_range().Linkshttps://pypi.org/project/keyvalue-sqlitehttps://github.com/zackees/keyvalue_sqliteVersions1.0.7: Don't use "default" as the default table name, sqlite doesn't like it.1.0.6: Allow setting default timeout in the constructor1.0.5: Makes table name optional.1.0.4: Adds atomic_add to allow atomic int operations.