semvec/pypi-packages huggingface dataset:
asldatacollector 0.0.6
Package for collecting data and transforming to dataset
Requires Python: <4.0,>=3.9

# asldatacollector

`asldatacollector` is a CLI tool designed for managing and processing hand image datasets, as well as uploading files to Google Storage. It allows you to collect images, transform them into datasets, and manage files in Google Drive storage efficiently.

## Table Of Contents

- [asldatacollector](#asldatacollector)
  - [Table Of Contents](#table-of-contents)
  - [Features](#features)
  - [Installation](#installation)
  - [Usage](#usage)
    - [Collecting Hand Images](#collecting-hand-images)
      - [Example Command](#example-command)
    - [Uploading Files](#uploading-files)
    - [Listing Files](#listing-files)
    - [Downloading Files](#downloading-files)
    - [Instruction](#instruction)
    - [Caching the Encryption Key](#caching-the-encryption-key)
  - [Contributing](#contributing)
  - [License](#license)

## Features

- **Collect hand images** with real-time landmark detection for multiple classes.
- **Upload files** to Google Storage.
- **Download files** or list files from Google Storage.

## Installation

To install `asldatacollector`, run:

```bash
pipx install asldatacollector
```

## Usage

### Collecting Hand Images

To collect images, run:

```bash
asldatacollector collect --data-dir /path/to/save/images --classes-number 26 --samples-number 100
```

The command will take images for 26 different classes (such as the alphabet in sign language) and store them in the specified directory. Each class will have by default 100 images collected using landmark detection.
The collection will continue until all images are gathered for each class.
The image collection uses real-time landmark detection to capture high-quality images. For reference, the classes are aligned with the alphabet as demonstrated in this example image:

![img](https://github.com/sqoshi/asldatacollector/raw/master/asldatacollector/assets/alphabet.png)

#### Example Command

```bash
asldatacollector collect --data-dir ./images --classes-number 26 --samples-number 100
```

This command will continuously capture images for 26 classes (each corresponding to a letter of the alphabet) until 100 samples per class are collected.

### Uploading Files

To upload a zip file to Google Storage, use:

```bash
asldatacollector upload --key <API_KEY>
```

Make sure the key is already set before running the upload command. If the key is not set, use the asldatacollector set-key command as described earlier.

### Listing Files

To list files in Google Storage, use:

```bash
asldatacollector list
```

### Downloading Files

To download a file from Google Storage, you can specify a file ID:

```bash
asldatacollector download --file-id <FILE_ID>
```

Or download all files:

```bash
asldatacollector download
```

### Instruction

Firsly collect the data with

```bash
asldatacollector collect
```

then upload files to server:

```bash
asldatacollector upload
```

### Caching the Encryption Key

It is possible


## Contributing

Feel free to open issues or contribute by submitting pull requests.

## License

This project is licensed under the MIT License.
xprpy 1.0.1
Interact with XPR Network blockchain
Requires Python: <4.0,>=3.8

<div align="center">
    
*Minimalist python library to interact with "XPR Network" blockchain also known as "XPR" or "XPRNetwork"*


</div>

# What is it?
**xprpy** is a python library to interact with XPR Network, an XPR Network.  
Its main focus are server side applications.  
This library is heavily influenced by µEOSIO and forked from FACINGS pyntelope. Many thanks to them for the astonishing job!  


# Main features
- Send transactions
Its main usage today is to send transactions to the blockchain
- Statically typed
This library enforces and verifies types and values.
- Serialization
**xprpy** serializes the transaction before sending to the blockchain. 
- Paralellization
Although python has the [GIL](https://realpython.com/python-gil/) we try to make as easier as possible to paralellize the jobs.  
All data is as immutable and all functions are as pure as we can make them.  


# Stability
This work is in alpha version. That means that we make constant breaking changes to its api.


# Using
## How to Use the `transfer.py` Function

The `transfer.py` script allows you to transfer XPR tokens between accounts via the command line.

### Command-Line Arguments

- `sender`: The account sending the XPR tokens.
- `receiver`: The account receiving the XPR tokens.
- `amount`: The amount of XPR to send (e.g., "55.0000 XPR").
- `--memo`: (Optional) A memo to include with the transaction.
- `--testnet`: (Optional) Use this flag to run the transaction on the XPR Testnet. If not provided, the transaction will be sent to the XPR Mainnet.

### Example Usage

See the examples folder for transfer.py
Use environment variables:
XPRNETWORK_ACCOUNT=your_account
XPRNETWORK_PRIVATE_KEY=your_private_key

1. **Transfer on Mainnet:**

   To send 55.0000 XPR from the account `a.babyagi` to `paul` on the XPR Mainnet with an optional memo:

   ```bash
   python transfer.py a.babyagi paul "55.0000 XPR" --memo "Mainnet transaction"

2. **Transfer on Testnet:**

   To send 55.0000 XPR from the account `a.babyagi` to `paul` on the XPR Testnet with an optional memo:

   ```bash
   python transfer.py a.babyagi paul "55.0000 XPR" --memo "Testnet transaction" --testnet
bloxnickgenerator 0.1.2
A simple nickname generator for Roblox
Requires Python: >=3.6

# BloxNickGenerator
## Introduction
BloxNickGenerator is a Python package that allows you to generate available usernames for Roblox. It checks the availability of usernames and ensures that the generated usernames do not contain profanity.

## Features
- Generate a specified number of usernames.
- Check for profanity using an external API.
- Verify if usernames are already taken on Roblox.
- Customize generated usernames with optional prefixes, suffixes, and length constraints.


# Usage
You can generate nicknames with various customization options. Here are some examples:

### Basic Usage
Generate a specified number of nicknames:

```python
from bloxnickgenerator.generator import genNicknames

generated_nicks = genNicknames(3) # Generate 3 nicknames
print("Generated Nicknames:", generated_nicks)
```

### Using Prefixes and Suffixes
You can add prefixes and suffixes to the generated nicknames:

```python
generated_nicks = genNicknames(3, prefix='Cool_', suffix='_2024') # Generate nicknames with a prefix and suffix 
print("Generated Nicknames:", generated_nicks)
```

### Length Constraints
Set minimum and maximum lengths for the nicknames:

```python
generated_nicks = genNicknames(3, min_length=5, max_length=16) # Generate nicknames within specific length constraints 
print("Generated Nicknames:", generated_nicks)
```

### Example
```python
nicks = genNicknames(3, prefix='Xx_', suffix='_Xx', min_length=5, max_length=16) 
print("Generated Nicknames:", nicks) 
# Result: Xx_examplee_xX
```

- Note: Depending on the number of nicknames you want to generate, it may take a while.

## Installation
# You can install BloxNickGenerator using pip:

```bash
pip install bloxnickgenerator
```

- https://pypi.org/project/bloxnickgenerator/0.1.1/

## License
This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
SidewinderFFB2 0.0.1
Bindings for a Microsoft Sidewinder Force Feedback 2 joystick.
Requires Python: >=3.8

SidewinderFFB2
==============

C binding for reading the state of, and sending forces to, a Microsoft Sidwinder 
Force Feedback 2.

It currently supports two forces,  a constant force and a "buzzer".
The constant force pull the joystick to specific location. You can adjust the 
power of the pull with the gain on the force. 
The buzzer is just a simple buzzer to notify the user.

This currently only works on win32 platforms.

Usage:

```
import time
import SidewinderFFB2

SidewinderFFB2.init()
SidewinderFFB2.acquire()

# Make sure your holding the joystick to cover the sensor.
# Otherwise the joystick doesn't do the effects.
buzz = SidewinderFFB2.BuzzForce()
buzz.start()

x_y_force = SidewinderFFB2.ConstantForce()
# This will make the forces stronger/weaker.
# The default/mas is SidewinderFFB2.DI_FFNOMINALMAX, which is 10000.
x_y_force.set_gain(7000)

x_y_force.set_direction(SidewinderFFB2.DI_FFNOMINALMAX, SidewinderFFB2.DI_FFNOMINALMAX//2)

time.sleep(2.0)

joy_state = SidewinderFFB2.poll()

print(f"button 5 is pressed : {joy_state.buttons[5]}")
print(f"Joystick X:{joy_state.x} Y:{joy_state.y} throttle: {joy_state.throttle}")
print(f"The hat is pointing : {joy_state.pov}")

# This resets all the force effects loaded on the joystick.
SidewinderFFB2.reset()

SidewinderFFB2.release()
```