semvec/pypi-packages huggingface dataset:
murd 0.0.5.8
Matrix: update, read, delete. A data store with a sorted, key:value store model

# Murd
Python Management of Matrix-like Key-Value store memories across disparate backends. Murd is the lowest level, pure python implementation backed by JSON. See [murdaws](gitlab.com/musingsole/murdaws) for AWS implementations.

## Data Model

It is best to think of a Murd as a simple key-value store, but with a mysterious dark past utterly at odds with its outwardly waify-bookishness. Much like a goodly priest knowing too much about guns and the criminal underworld, Murds allow a few tricks for segmenting data and searching within those segments. Dirty tricks no JSON object was meant know.

**Murd can be a footgun.** But used with a bit of cleverness for its keys and how to search them, Murds allow a network of distributed data stores backed by a variety of technologies including JSON, SQLite^, DynamoDB, and S3^.

^ Not yet implemented 

## Instantiate

my_murd = Murd()

### Open from file

my_murd = Murd("/home/me/my_murd.json")

## Update

murd.update([{"GROUP": "TEST": "SORT": "0": "DATA": 42}])

## Read

murd.read(group='TEST')

## Delete

murd.update([{"GROUP": "TEST": "SORT": "0": "DATA": 42}])

## Save to file

my_murd.write_murd("/home/me/my_murd.json")
flask-jwt-persistency 0.0.3
Changes standard flask and jwt errors format
Requires Python: >=3.6

# Flask JWT Persistency
This extension was developed to add additional features to JWT like revoke a single token or all tokens issued to a specific user. These features are implemented by persisting the tokens in a database, so JWT looses its stateless property.

Installing
----------

Install and update using pip:

```bash
$ pip install flask-jwt-persistency
```

Full working example (also available at examples folder)
----------------

```python
from flask import Flask, request, jsonify
from flask_sqlalchemy import SQLAlchemy
from flask_jwt_extended import JWTManager, create_access_token, jwt_required, get_jti, get_jwt, get_jwt_identity

from flask_jwt_persistency import JWTPersistency

app = Flask(__name__)
app.config["JWT_SECRET_KEY"] = "super-secret"  # Change this!
app.config["JWTP_DATABASE_URL"] = "sqlite:///jwtptokens.db"  # DB to store the tokens
db = SQLAlchemy(app)
jwt = JWTManager(app)
jwtp = JWTPersistency(app, jwt, db)


@app.route("/auth/login", methods=["POST"])
def login():
    username = request.json.get("username", None)
    password = request.json.get("password", None)
    if username != "test" or password != "test":
        return jsonify({"msg": "Bad username or password"}), 401

    access_token = create_access_token(identity=username)
    jti = get_jti(encoded_token=access_token)

    # Persist the jti in the database
    jwtp.new_token(jti, username)

    return jsonify(access_token=access_token)


# Access a protected route
@app.route("/protected", methods=["GET"])
@jwt_required()
def protected():
    return jsonify({"msg": "You got access to the protected route"})


# Revoke token used in the request
@app.route("/auth/logout", methods=["DELETE"])
@jwt_required()
def logout():
    """Revoke access token"""
    jti = get_jwt()['jti']
    jwtp.revoke_token(jti)


# Revoke all tokens that have been issued to the user that is making the request
@app.route("/auth/logout-from-all-devices", methods=["DELETE"])
@jwt_required()
def logout_from_all_devices():
    """Revoke all tokens"""
    username = get_jwt_identity()
    jwtp.revoke_all_tokens(username)


if __name__ == "__main__":
    app.run(debug=True)

```
image-processing-rbiegelmeyer 0.0.2
My second package
Requires Python: >=3.8

# image_processing

Description.
The package image_processing is used to:

Processing:
- Histogram Matching
- Structural Similarity
- Resize Image

Utils:
- Read Image
- Save Image
- Plot Image
- Plot Result
- plot Histrogram



## Installation

Use the package manager [pip](https://pip.pypa.io/en/stable/) to install image_processing

```bash
pip install image_processing
```

## Usage
```python
from image_processing_rbiegelmeyer.utils import io, plot
from image_processing_rbiegelmeyer.processing import combination, transformation

image1 = io.read_image('./data/image1.jpg')
image2 = io.read_image('./data/image2.jpg')

# plot.plot_image(image1)
# plot.plot_image(image2)

result_image = combination.transfer_histrogram(image1, image2)

plot.plot_result(image1, image2, result_image)
```

![alt text](https://github.com/rbiegelmeyer/image_processing/blob/master/doc/Figure_1.png?raw=true)

## Author
Roberto Biegelmeyer
rbiegelmeyer

## License
[MIT](https://choosealicense.com/licenses/mit/)
popcorngl 4
Simple graphics language for python.
Requires Python: >=3.9

# PopcornGL
A Python module based on my custom graphics engine.

This project is in open Alpha, and will improve depending on the attention it gets.

# Requirements
Python versions tested: 3.9.6

Python modules needed:
 - operator
 - math
 - copy

# How to Install
To install PopcornGL you need to run the command `pip install popcorngl` in your command prompt. If the command does not work, create an issue relating the problem and I'll see if I can help you.

# Documentation
## Classes
### Camera(x_rotation, y_rotation, z_rotation, fov, center, distance)
This class is responsible for the camera in the scene.

**Class Functions:**  
*rotate_x(amount)*: rotates the camera a certain amount on the X axis around the center of the scene.  
*rotate_y(amount)*: rotates the camera a certain amount on the Y axis around the center of the scene.  
*rotate_z(amount)*: rotates the camera a certain amount on the Z axis around the center of the scene.  
*change_distance(amount)*: moves the camera further away from the object by a certain amount.  

**Class Variables:**  
*x_rotation*: the cameras rotation on the X axis.  
*y_rotation*: the cameras rotation on the Y axis.  
*z_rotation*: the cameras rotation on the Z axis.  
*fov*: the cameras fov. (not actually the FOV I just didnt know what else to call it)  
*center*: the center of the screen.  
*distance*: the distance from the object in the scene.  

### Light(position, intensity, radius)
This class is responsible for the lighting in the scene. It's not necessary if you're not going to use it.

**Class Variables:**  
*position*: The position of the light in the scene.  
*intensity*: The intensity of the light.  
*radius*: The range of the light.  

### Engine()
This class is responsible for functions that do math.

**Class Functions:**  
*do_3d_math(points, camera)*: This function returns the X and Y values of the points with 3D coords passed in it.  
*do_light_math(faces, points, light)*: This function returns the faces list with modification to the color based on the light.  
*sort_faces(faces)*: This function returns a sorted list of faces based on the depth of them in the scene (for painter's algorithm).