semvec/pypi-packages huggingface dataset:
ciphers-vbcd-test 0.2.0
A tool for ciphering messages using various algorithms
Requires Python: >=3.9

# Ciphers

A Python tool for ciphering messages using various algorithms.

## Installation

### Basic Installation

```bash
uv add ciphers-vbcd
```

### With RSA Support

```bash
uv add ciphers-vbcd[rsa]
```

### Locally install from wheel

```bash
# Create and activate a virtual environment with uv
uv venv
source .venv/bin/activate  # On Linux/macOS
# or
# .venv\Scripts\activate  # On Windows

# Install the package
uv add -e .

# With RSA support
uv add -e ".[rsa]"
```

## Usage

### Caesar Cipher

```bash
# Encrypt a message using Caesar cipher with a shift of 3
cipher encrypt --algorithm caesar --key 3 "Hello, World!"

# Decrypt a message using Caesar cipher with a shift of 3
cipher decrypt --algorithm caesar --key 3 "Khoor, Zruog!"
```

### RSA Cipher

First, generate an RSA key pair:

```bash
# Using OpenSSL
openssl genrsa -out private_key.pem 2048
openssl rsa -in private_key.pem -pubout -out public_key.pem
```

Then encrypt and decrypt messages:

```bash
# Encrypt a message using RSA with a public key
cipher encrypt --algorithm rsa --key public_key.pem "Secret message"

# Decrypt a message using RSA with a private key
cipher decrypt --algorithm rsa --key private_key.pem "encrypted_message_here"
```

## Development

### Installing Development Dependencies

With uv:

```bash
# Install development dependencies
uv add -e ".[dev]"
```

### Running Tests

```bash
# Run tests with pytest
pytest

# Run tests with coverage
pytest --cov=ciphers
```

### Code Formatting and Linting

```bash
# Format code with black
black .

# Sort imports with isort
isort .

# Lint with ruff
ruff check .

# Format with ruff
ruff format .

# Type checking with mypy
mypy ciphers tests
```

### Building and Publishing

Building the package with uv:

```bash
# Build both wheel and sdist
uv build .

# Or build specific formats
uv build --wheel .  # Only wheel
uv build --sdist .  # Only source distribution
```

Publishing to PyPI with uv:

```bash
# Upload to TestPyPI first to verify everything works
uv publish --index testpypi dist/*

# Upload to PyPI
uv publish dist/*
```

You can also use twine if you prefer:

```bash
# Install twine
uv add twine

# Upload to TestPyPI
python -m twine upload --repository testpypi dist/*

# Upload to PyPI
python -m twine upload dist/*
```

## Supported Algorithms

- Caesar Cipher: A simple substitution cipher where each letter is shifted by a fixed number of positions.
- RSA Cipher: A public-key cryptosystem that uses asymmetric encryption for secure data transmission.
cf-pipeline 0.0.8
A comprehensive Python API for Competitive Programming sites like Codeforces
Requires Python: >=3.10

# CF Pipeline

A command-line interface tool for automating Codeforces competitive programming workflows.

![Version](https://img.shields.io/badge/version-0.0.8-blue)
![Status](https://img.shields.io/badge/status-alpha-orange)

## Overview

CF Pipeline is a CLI application that streamlines interaction with the Codeforces competitive programming platform. Built with a "plumbing and porcelain" architecture (inspired by Git), it provides a set of composable commands for automating common Codeforces tasks.

## Features

- **Problem retrieval**: Download contest problems directly to your local environment
- **Solution testing**: Test your solutions against sample test cases before submission
- **Workflow automation**: Combine commands to create custom workflows
- **Framework extensibility**: Build your own commands on top of the core framework

## Installation

from github:

 - fork and pull repository
 - navigate to project in terminal
 - from the top level of project, run

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

or get it straight from pypi with

```bash
pip install cf-pipeline
```

## Usage

Basic commands:

```bash
# Get a specific problem
cf-getproblem <contest-id> <problem-index>

# Test your solution against problem test cases
cf-testproblem <solution-file> <contest-id> <problem-index>

# plus many more.
```

for a complete list of commands, see [here](https://github.com/lifeModder19135/cf-pipeline/blob/dev-master/ABOUT_THE_APPS.md)

## Architecture

CF Pipeline follows a modular approach:

- **Core modules**: Problem representation, contest data, and configuration management
- **Commands**: Single-purpose tools that can be combined into workflows
- **API utilities**: Tools for interacting with the Codeforces API

## Why Use CF Pipeline?

- **Save time**: Automate repetitive tasks in the competitive programming workflow
- **Focus on coding**: Reduce time spent on administrative tasks
- **Integration**: Use from your terminal without switching to the browser
- **Customization**: Build and extend with your own commands and workflows

## Development Status

This project is in early alpha development (version 0.0.5 "AlmostAlpha"). Many planned features are still in progress.

## Contributing

Contributions are welcome! See our contribution guidelines for details.

## License

See the [LICENSE](RESOURCES/LICENSE) file for details.
nom 0.1.0b3
A python parser combinator library, inspired by Nom for Rust
Requires Python: >=3.10

# Nompy

A Python [parser combinator](https://en.wikipedia.org/wiki/Parser_combinator) library inspired by the [Nom](https://github.com/rust-bakery/nom) library in Rust. This project is in no way affiliated with the original Nom Rust project.

## Examples

### Parse Name

Parse a name and apply a simple transformation.

```python
from nom.combinators import succeeded, tag, take_rest, take_until, tuple_
from nom.modifiers import apply

to_parse = "john doe"

parser = tuple_(
    apply(succeeded(take_until(" "), tag(" ")), str.capitalize),
    apply(take_rest(), str.capitalize),
)
result, remaining = parser(to_parse)
firstname, lastname = result
print(firstname, lastname)  # John Doe
```


### Parse Phone Number

Parse an MSISDN with preceeding `+`

```python
from nom.combinators import preceeded, tag, take_while

to_parse = "+1234567890"

parser = preceeded(take_while(str.isnumeric), tag("+"))
result, remaining = parser(to_parse)
print(result)
```
monkez-video-input 0.1.1
A Python class for streaming video from a camera or a video file. It supports frame resizing, FPS control, and automatic restart of the video stream in case of errors.
Requires Python: >=3.6


# Video Streamer

A Python class for streaming video from a camera or a video file. It supports frame resizing, FPS control, and automatic restart of the video stream in case of errors.

## Features

- Stream video from a given source (camera or video file).
- Control the FPS of the video stream.
- Option to resize the video frames.
- Automatic restart of the video stream if the source becomes unavailable.
- Multi-threaded streaming for asynchronous video frame retrieval.

## Installation

To install the required dependencies, you need to install OpenCV:

```bash
pip install opencv-python
```

## Usage

Here is an example of how to use the `VideoStreamer` class:

```python
from video_streamer import VideoStreamer
import cv2

# Set your video source (camera index 0 or a video file path)
video_source = "1.avi"  # Change this to your video source (0 for webcam, or a video file path)

# Create a VideoStreamer instance
streamer = VideoStreamer(video_source)

# Start the video stream in a separate thread
streamer.start()

# Continuously display the video stream
while True:
    frame = streamer.get_frame()
    if frame is None:
        continue
    cv2.imshow("Video Stream", frame)
    
    # Press 'q' to quit the video stream
    if cv2.waitKey(300) & 0xFF == ord('q'):
        break

# Stop the video stream
streamer.stop_thread()
cv2.destroyAllWindows()
```

### Arguments:

- `video_source`: The source of the video, which could be a file path or a camera index (`0` for webcam).
- `fps` (optional): Frames per second for the video stream. If not provided, the default FPS of the video source is used (or `30` if unavailable).
- `resolution` (optional): A tuple specifying the width and height for resizing the video frames. If not provided, the original resolution of the video source is used.
- `auto_restart` (optional): If set to `True`, the video stream will automatically restart if the video source becomes unavailable. Default is `False`.

## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
velum 0.1.4
a python project template
Requires Python: <4.0,>=3.10
Keywords: python

# velum

[![Build status](https://img.shields.io/github/actions/workflow/status/shaneholloman/velum/main.yml?branch=main)](https://github.com/shaneholloman/velum/actions/workflows/main.yml?query=branch%3Amain)
[![validate-codecov-config](https://github.com/shaneholloman/velum/actions/workflows/validate-codecov-config.yml/badge.svg)](https://github.com/shaneholloman/velum/actions/workflows/validate-codecov-config.yml)
[![Commit activity](https://img.shields.io/github/commit-activity/m/shaneholloman/velum)](https://img.shields.io/github/commit-activity/m/shaneholloman/velum)

A python project template with a focus on simplicity and ease of use. It includes a CI/CD pipeline, pre-commit hooks, and a set of tools to help you get started quickly.

- **Github repository**: <https://github.com/shaneholloman/velum/>
- **Documentation** <https://shaneholloman.github.io/velum/>

## Getting started with your project

### 1. Create a New Repository

First, create a repository on GitHub with the same name as this project, and then run the following commands:

```bash
git init -b main
git add .
git commit -m "init commit"
git remote add origin git@github.com:shaneholloman/velum.git
git push -u origin main
```

### 2. Set Up Your Development Environment

Then, install the environment and the pre-commit hooks with

```bash
make install
```

This will also generate your `uv.lock` file

### 3. Run the pre-commit hooks

Initially, the CI/CD pipeline might be failing due to formatting issues. To resolve those run:

```bash
uv run pre-commit run -a
```

### 4. Commit the changes

Lastly, commit the changes made by the two steps above to your repository.

```bash
git add .
git commit -m 'Fix formatting issues'
git push origin main
```

You are now ready to start development on your project!
The CI/CD pipeline will be triggered when you open a pull request, merge to main, or when you create a new release.

To finalize the set-up for publishing to PyPI, see [here](https://shaneholloman.github.io/uvi/features/publishing/#set-up-for-pypi).
For activating the automatic documentation with MkDocs, see [here](https://shaneholloman.github.io/uvi/features/mkdocs/#enabling-the-documentation-on-github).
To enable the code coverage reports, see [here](https://shaneholloman.github.io/uvi/features/codecov/).

## Releasing a new version

- Create an API Token on [PyPI](https://pypi.org/).
- Add the API Token to your projects secrets with the name `PYPI_TOKEN` by visiting [this page](https://github.com/shaneholloman/velum/settings/secrets/actions/new).
- Create a [new release](https://github.com/shaneholloman/velum/releases/new) on Github.
- Create a new tag in the form `*.*.*`.

For more details, see [here](https://shaneholloman.github.io/uvi/features/cicd/#how-to-trigger-a-release).

---

Repository initiated with [shaneholloman/uvi](https://github.com/shaneholloman/uvi).
monkez-image-resizer 0.1.0
A Python class for streaming video from a camera or a video file. It supports frame resizing, FPS control, and automatic restart of the video stream in case of errors.
Requires Python: >=3.6


# Video Streamer

A Python class for streaming video from a camera or a video file. It supports frame resizing, FPS control, and automatic restart of the video stream in case of errors.

## Features

- Stream video from a given source (camera or video file).
- Control the FPS of the video stream.
- Option to resize the video frames.
- Automatic restart of the video stream if the source becomes unavailable.
- Multi-threaded streaming for asynchronous video frame retrieval.

## Installation

To install the required dependencies, you need to install OpenCV:

```bash
pip install opencv-python
```

## Usage

Here is an example of how to use the `VideoStreamer` class:

```python
from video_streamer import VideoStreamer
import cv2

# Set your video source (camera index 0 or a video file path)
video_source = "1.avi"  # Change this to your video source (0 for webcam, or a video file path)

# Create a VideoStreamer instance
streamer = VideoStreamer(video_source)

# Start the video stream in a separate thread
streamer.start()

# Continuously display the video stream
while True:
    frame = streamer.get_frame()
    if frame is None:
        continue
    cv2.imshow("Video Stream", frame)
    
    # Press 'q' to quit the video stream
    if cv2.waitKey(300) & 0xFF == ord('q'):
        break

# Stop the video stream
streamer.stop_thread()
cv2.destroyAllWindows()
```

### Arguments:

- `video_source`: The source of the video, which could be a file path or a camera index (`0` for webcam).
- `fps` (optional): Frames per second for the video stream. If not provided, the default FPS of the video source is used (or `30` if unavailable).
- `resolution` (optional): A tuple specifying the width and height for resizing the video frames. If not provided, the original resolution of the video source is used.
- `auto_restart` (optional): If set to `True`, the video stream will automatically restart if the video source becomes unavailable. Default is `False`.

## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.