semvec/pypi-packages huggingface dataset:
kellanb-cryptography 1.2.3
encryption libray
Keywords: python,encryption,aes,chacha20,hmac

# kellanb-cryptography 

## an easy-to-use wrapper ontop of pycryptodome

### installation
`pip install kellanb-cryptography`

### use 
### kellanb-cryptography easy 

a tool for quick and simple encryption

`from kellanb-cryptography import easy`


`encrypted = easy.encrypt(data,key)   `<br>
data: string<br>
key: string

`decrypted = easy.decrypt(encrypted,key) `<br>
encrypted: string<br>
key: string

### kellanb-cryptography key
generate a key from password

`from kellanb_cryptography import key`

`key = key.gen_key_from_password(password, length=256)`<br>

password: string<br>
length in bits: int

### kellanb-cryptography aes
encrypt in aes
`from kellanb_cryptography import aes`

`encrypted = aes.encrypt_aes(data, key,mode='GCM')`<br>
data: string<br>
key: string, length 16,24,or 32
mode: 'GCM','EAX',or 'CCM', shows mode of operation

`decrypted = aes.decrypt_aes(encrypted, key)`<br>
encrypted: string<br>
key: string, length 16,24,or 32


### kellanb-cryptography chacha20
encrypt in chacha20
`from kellanb_cryptography import chacha20`

`encrypted = chacha20.encrypt_chacha_20(data, key)`<br>
data: string<br>
key: string, 32 <br>

`decrypted = aes.decrypt_chacha20(encrypted, key)`<br>
encrypted: string<br>
key: string, length 32


### kellanb-cryptography hash
generate a key from password

`from kellanb_cryptography import hash`


`hash.sha256(data)`
data: string, data to be hashed 

`hash.sha256(data)`  
data: string, data to be hashed 

`hash.512(data)`  
data: string, data to be hashed 

`hash.sha3_256(data)`  
data: string, data to be hashed 

`hash.sha3_512(data)`  
data: string, data to be hashed 


### kellanb-cryptography hmac
tamper-proof your messages

`from kellanb_cryptography import hmac`

`mac = hmac.create_hmac(data,password)`

data: string,
password: password to verify with

### NOTE: THIS WILL NOT ENCRYPT YOUR DATA

`hmac.verify_hmac(data,mac,password)`
returns 1 for not tampered, a zero for check fail (data tampered)

data: data to verify
mac: HMAC code
password: password to verify with
rlstatsdb 0.0.4
A simple and pythonic system to store, retrieve, and analyze Rocket League replay stats as returned from ballchasing.com's API
Requires Python: >=3.11

# Install
`pip install rlstatsdb`

# Description
`rlstatsdb` is a simple and easy-to-implement SQLite database manager equipped for storing and fetching Rocket League replay data (as returned from ballchasing.com's API). When fetching data from the database (through the manager) is incredibly easy to navigate, meaning you don't need to memorize the entire dictionary structure of ballchasing's get-replay response.

# Usage
For the below example, `replay_data` is the response dict from `https://ballchasing.com/api/replays/<replay_id>`. In reality, this can be acquired through various means, such as `requests` and `aiohttp`, or through API wrappers such as `pychasing` and `python-ballchasing`. 
```py
import rlstatsdb

# The database file needs to either be non-existant, empty, or a valid
# SQLite database. If the file is non-existant, a new file will be created
sdb = rlstatsdb.Manager("path_to_database_file")

manifest_id = sdb.add(replay_data)
game = sdb.get(manifest_id)

game.replay_id
game.max_rank.division
game.orange.players[0].stats.core.goals
game.blue.color
# etc.
```
mlbands 1.0.1
A Python package that implements automatic prediction of electronic band gaps for a set of materials based on training data
Requires Python: >=3.8,<4.0

# ML Band Gaps (Materials)

> Ideal candidate: skilled ML data scientist with solid knowledge of materials science.

# Overview

The aim of this task is to create a python package that implements automatic prediction of electronic band gaps for a set of materials based on training data.

# User story

As a user of this software I can predict the value of an electronic band gap after passing training data and structural information about the target material.

# Requirements

- suggest the bandgap values for a set of materials designated by their crystallographic and stoichiometric properties
- the code shall be written in a way that can facilitate easy addition of other characteristics extracted from simulations (forces, pressures, phonon frequencies etc)

# Expectations

- the code shall be able to suggest realistic values for slightly modified geometry sets - eg. trained on Si and Ge it should suggest the value of bandgap for Si49Ge51 to be between those of Si and Ge
- modular and object-oriented implementation
- commit early and often - at least once per 24 hours

# Timeline

We leave exact timing to the candidate. Must fit Within 5 days total.

# Notes

- use a designated github repository for version control
- suggested source of training data: materialsproject.org
boa-api 0.1.14
Client API for using the Boa infrastructure
Requires Python: >=3.5

# About Boa Python Client API

The Boa Python Client API provides programmatic access to the Boa language and infrastructure from Python.

## About Boa

For more information about Boa, please see the main website: https://boa.cs.iastate.edu/

## Creating a client

The main entry point for the API is a `BoaClient` object.  You use this to log in, submit queries, find datasets, log out, etc.  To instantiate this object, you must provide the API endpoint's URL.  The API has several constants for common endpoints:

- `BOA_API_ENDPOINT` - for the Boa MSR endpoint
- `BOAC_API_ENDPOINT` - for the Boa CORD-19 endpoint

For example if you want a client for the CORD-19 endpoint, you do the following:

`client = BoaClient(endpoint=BOAC_API_ENDPOINT)`

If you don't specify an endpoint, it will default to the MSR endpoint.

## Example Use (using MSR endpoint)

````python
import getpass
import time

from boaapi.boa_client import BoaClient, BOA_API_ENDPOINT
from boaapi.status import CompilerStatus, ExecutionStatus

client = BoaClient(endpoint=BOA_API_ENDPOINT)
user = input("Username [%s]: " % getpass.getuser())
if not user:
    user = getpass.getuser()
client.login(user, getpass.getpass())
print('successfully logged in to Boa API')

query = """# Counting the 10 most used programming languages
p: Project = input;
counts: output top(10) of string weight int;

foreach (i: int; def(p.programming_languages[i]))
    counts << p.programming_languages[i] weight 1;"""

# query using a specific dataset
job = client.query(query, client.get_dataset('2019 October/GitHub'))
print('query submitted')

while job.is_running():
    job.refresh()
    print('job ' + str(job.id) + ' still running, waiting 10s...')
    time.sleep(10)

if job.compiler_status is CompilerStatus.ERROR:
    print('job ' + str(job.id) + ' had compile error')
elif job.exec_status is ExecutionStatus.ERROR:
    print('job ' + str(job.id) + ' had exec error')
else:
    try:
        print('output:')
        print(job.output())
    except:
        pass

client.close()
print('client closed')
````