semvec/pypi-packages huggingface dataset:
average-face 0.6.0
Face averaging in Python made simple.
License: MIT
Requires Python: <4.0,>=3.9

# Facer

Face detection, alignment, and averaging using OpenCV and `dlib`.

Facer draws heavily on [this tutorial](https://www.learnopencv.com/average-face-opencv-c-python-tutorial/) from [Satya Mallick](https://github.com/spmallick). I had to update the code pretty heavily to get the project to work, so I thought I'd share my modifications.

## Example

The image below is an example of Facer's output for one of my posts on [`r/dataisbeautiful`](https://www.reddit.com/r/dataisbeautiful/comments/crxrud/the_average_faces_of_rap_rock_and_country/).

[![Average faces of rap, rock, and country music](assets/average_face_example.png)](https://www.reddit.com/r/dataisbeautiful/comments/crxrud/the_average_faces_of_rap_rock_and_country/)

## Installation

You have my 100% money-back guarantee that the most difficult part of using this package is installing its requirements. Once you've got OpenCV installed, the rest ~~will~~ should be smooth sailing. I've had the best luck with the OpenCV using the `opencv-python` package from PyPI.


The `requirements.txt` file lists the Python packages Facer depends on. Install the packages using `pip`:

```bash
pip install -r requirements.txt
```

### Pre-trained detection model

The face landmark detection relies on a pre-trained model that must be downloaded separately from the `dlib` package itself.

```shell
wget http://dlib.net/files/shape_predictor_68_face_landmarks.dat.bz2
```

Unzip the compressed file after it finishes downloading and move it into the `./Facer/model` directory.

## Usage

```python
from facer import facer
import matplotlib.pyplot as plt


# Load face images
path_to_images = "./face_images"  # Put your images here
images = facer.load_images(path_to_images)

# Detect landmarks for each face
landmarks, faces = facer.detect_face_landmarks(images)

# Use  the detected landmarks to create an average face
average_face = facer.create_average_face(faces, landmarks, save_image=True)

# View the composite image
plt.imshow(average_face)
plt.show()
```

Facer also supports creating animated GIFs of the averaging process:

```python
from facer import facer

path_to_images = "./face_images"
gif, average_face = facer.create_animated_gif(path_to_images)
```
python-rekor-monitor 0.1.1
Based on Rekor-Monitor
License: MIT
Requires Python: <4.0,>=3.12

# Python Rekor Monitor
## Usage
- To fetch the latest checkpoint from the rekor server: `python main.py -c`
 or `python main.py --checkpoint`
- To verify that a particular log index is included in the transparency log as
 of now and verify the signature on that artifact stored in the transparency
 log: `python main.py --inclusion <logIndex> --artifact <artifactFilePath>`
- To verify that an older checkpoint is consistent with the latest checkpoint
 on the rekor server: `python main.py --consistency --tree-id <treeID>
 --tree-size <treeSize> --root-hash <rootHash>`
 Tree ID, tree size and root hash from the older checkpoint.

## Flow
1. Add an artifact to the Rekor transparency log using the cosign tool.
    Verify that the entry was successfully included in the transparency log.
2. Verify the consistency of the rekor transparency log, i.e that the new
    entry that was append only to the log.

## Steps
1. Create an artifact (binary) that will be signed with entry being stored in
    the rekor log.
2. Use the `cosign` tool to sign the artifact using your email id and store
    the signature and certificate that was used to sign it. (bundle command)
3. Get checkpoint of the rekor public instance transparency log.
    "--checkpoint"
4.  a. Verify that the artifact is in the transparency log by getting a merkle proof
    and verifying it offline (use `merkle_proof` api)
    "--inclusion <logIndex>"
    b. Verify that the artifact signature is correct (use `crypto` api)
5. At any point in time, can verify that the consistency of the checkpoint which had our entry added and the latest checkpoint by verifying the consistency proof.
    Just need the old checkpoint details: tree id, tree size, and root hash.
    Verifying consistency of a checkpoint till the latest checkpoint.


## Required data
- For consistency verification, you need the old and new checkpoint details (treeSize, rootHash, treeID) and the hashes to generate a merkle proof to show that the old checkpoint exists in the new checkpoint.
- For inclusion verification, you need the

### Global Flags
- `--debug` to dump intermediate files and print verbose output
Qbluetoothctl-helper 0.0.2
Python bluetoothctl helper for QT.
License: MIT
Requires Python: >=3.6
Keywords: bluetooth, bluetoothctl, Qt, pyQt

# Qbluetoothctl Helper

Python Qt interface to the linux **bluetoothctl** program.

This class provides methods to perform 
  - pairing / removing
  - connecting / disconnecting 
  - scanning
  - trusting / distrusting
  - getting device info
  - finding device by name or mac

Many of these methods are not available in other bluetooth libraries.

## Install
Download the library and ```pip3 install -e .``` or omit the -e switch to install into python's site packages.

## Testing
The main file ```Qbluetoothctl_helper.py``` can be run and will conduct a couple of test.
User will need to update them to fit their device and test needs.

## Dependencies
- PyQt 5
- PyQt 6 untested