semvec/pypi-packages huggingface dataset:
HandGestureRecSiliconM1 0.1.1
m1 macs version

# HandGestureRecSiliconM1
# Short Summary:
This is a dynamic hand gesture detection library for m1 silicon, the user can interact with the library using a GUI built using Tkinter.
## Implementation: 
The library uses the webcam as the sensor and it gives the user access to the webcam using opencv, then the handlandmarks are collected using MediaPipe.
## GUI:
The GUI is the main way for the user to interact with the toolkit. It is written in Tkinter for python wich is the default GUI library for Python. The GUI is simple and easy to use.
## The Backend:
It is comprised of:
### Data Collection:
 The data collection is done using OpenCV and MediaPipe, each gesture is composed of 80 videos each is 30 frames, with each frame containing the 42 landmarks for each hand. Each landmark is an X, Y,  Z  tupple which describes the location of that specific landmark.
### Data Storage Strategy:
No DBMS was used instead a folder tree which is composed of 3 submodules was built. The first submodule is  a  gestures folder that contains all the gestures defined by the user, the second is a datasets submodule which contains all the datasets created by the user. A single dataset is a non null subset of the gestures.
### The machine learning algorithm:
The ML. model used is an LSTM model  which was built using Tensorflow 2.X  and the Keras ApI. for tensorFlow.
# How to use:
install the library from $ pip using pip install HandGestureRecSiliconM1 and in your python project write at the terminal run 
* 1)   The user define one or more gesture using the GUI. One gesture is to be defined at a time. The gesture is defined by giving it a name and pressing create gesture then OpenCV will  give the user access to the webcam, 80 videos will be taken each is 30 frames in length so the user needs to do the gesture for 80 times. The starting time of each try of the 80 will be shown on the screen.
* 2) After the user defines 1 or more gestures, he can then use the datasets submodule to create a dataset which will then serve as an input to the ML. model. To create a dataset the user have to give it a name and choose a subset of the gestures he defiend before hand then press create dataset.
* 3)  After having one or more datasets the user can then can to the models submodule to crerate a model to a specific dataset. There is a 1:1 relation between the datasets and the models meaning that every dataset can only contribute to only one model.
* 4)  After creating one or more models the user can test his models using the testing submodule.
Samay 0.0.4
Samay
Keywords: Samay,samay,timeit,time,execution,execution time,run time,runtime,function runtime,function execution time,compare function

Samay is a powerful Python module designed to help you effectively measure the 
                      execution time of your functions, compare them side by side, and optimize their
                      performance. With Samay, you can gain valuable insights into the efficiency of 
                      your code and make informed decisions to improve its speed and effectiveness.
p3bamboo 1.0.9
Panda3D BAM file parser library
Requires Python: >=3.6

p3bamboo
========

[![PyPI version](https://img.shields.io/pypi/v/p3bamboo.svg)](https://pypi.python.org/pypi/p3bamboo/)

p3bamboo is a Python library that gives you full access to a Panda3D BAM file's inner structure.

# Getting Started

Simply install p3bamboo using `pip`:

```bash
python -m pip install p3bamboo
```

Loading a BAM file is very simple:

```python
from p3bamboo.BamFile import BamFile

bam = BamFile()

with open('myModel.bam', 'rb') as f:
    bam.load(f)
```

Writing out a BAM file is also easy:

```python
with open('newModel.bam', 'wb') as f:
    bam.write(f)
```

To automatically deserialize BAM objects, you must register your own custom BAM object types. For example, to register an object type named `Texture`:

```python
from p3bamboo.BamFactory import BamFactory
from myproject.Texture import Texture

BamFactory.register_type('Texture', Texture)
```

If you register your object types properly and load a BAM file afterwards, you'll be able to access your objects using `bam.object_map`.
canarytrap 1.0.2
A Python package to watermark text.
Requires Python: >=3.9

# CanaryTrap

CanaryTrap is a Python package that uses the concept of a "canary trap" to watermark text using unicode spaces. By converting regular spaces to unicode spaces according to a binary pattern, you can add a hidden signature to your text.

## Installation

You can install CanaryTrap using pip:
```
pip install canarytrap
```

## How to use

First, import the package:

```python
import canarytrap as canary
```

To watermark your text, use the `unicode_space_encode` function. You can either provide a binary string or let the function generate a random one:

```python
text = "Hello world this is a test"
watermarked_text, binary_str = canary.unicode_space_encode(text)
print(watermarked_text)  # Watermarked text
print(binary_str)  # Binary string used for watermarking
```

You can convert the watermarked text back to binary using the `unicode_space_to_binary_str` function:

```python
binary_str_back = canary.unicode_space_to_binary_str(watermarked_text)
print(binary_str_back)  # Should be the same as binary_str
```

To check if a text matches a given binary string, use the `unicode_space_match` function:

```python
match = canary.unicode_space_match(watermarked_text, binary_str)
print(match)  # Should be 1.0 if text is not modified
```

### Example Scenario

You have someone who is leaking private documents and want to find out who. You're about to send an email to a bunch of different employees. Let's use CanaryTrap to find out who it is.

First, let's encode our email
```Python
import canarytrap as canary

staff_email = "Hello staff, this is a test email. Please do not share this email with anyone else."

watermarked_email, binary_str = canary.unicode_space_encode(staff_email)

with open("email.txt", "w", encoding="utf-8") as f:
    f.write(watermarked_email)

with open("binary.txt", "w", encoding="utf-8") as f:
    f.write(binary_str)
```

The unicode characters will not appear (Is an empty character). Try copying that text into a code editor to see it
```
Hello‎ staff,‎ this is a test email.‎ Please do‎ not share‎ this‎ email‎ with anyone‎ else.
```

You can then check some text against the watermark:
```Python
import canarytrap as canary

watermarked_text = "Hello‎ staff,‎ this is a test email.‎ Please do‎ not share‎ this‎ email‎ with anyone‎ else."

match = canary.text.unicode_space_match(watermarked_text, binary_str)
print(match)  # Should be 1.0 if text is not modified
```

## Note

If the watermarked text is edited (spaces are added, removed, or replaced), the match percentage returned by the `unicode_space_match` function may be less than 1.0. If you get a match percentage of less than 1.0, it means that the text was likely edited after being watermarked. The match percentage gives an estimate of how much of the original watermark remains in the text.