semvec/pypi-packages huggingface dataset:
mouse-movement 0.1
A library for controlling mouse and keyboard via ctypes on Windows


### 4. License
Itâ€™s also a good idea to include a `LICENSE` file (such as MIT or GPL) that specifies the terms of usage and distribution.

### 5. Publishing
Once everything is ready, you can publish your package on [PyPI](https://pypi.org/), which allows anyone to install your package using pip.

If you haven't already set up a PyPI account, you can create one at [https://pypi.org/account/register/](https://pypi.org/account/register/). Then you can use `twine` to upload your package:

1. Install Twine if you donâ€™t have it:
chavatte-image-processing 0.1.0
Biblioteca para processamento de imagens
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 histogram

## Installation

Use the package manager [pip](https://pip.pypa.io/en/stable/) to install `image_processing`

```bash
pip install image_processing
```

## Usage

```python
from package_name.module1_name import file1_name
file1_name.my_function()
```

## Author
João Carlos Chavatte

## License
[MIT](https://choosealicense.com/licenses/mit/)
cdef-parquet-scanner 0.1.0
Tool for scanning and analyzing Parquet schema structures
Requires Python: >=3.8

# CDEF Parquet Scanner

A tool for scanning Parquet files, analyzing their schema structures, and generating reports about schema patterns and data characteristics.

## Features

- Scans directories recursively for Parquet files
- Groups files by schema similarity
- Analyzes column characteristics (types, compression, cardinality)
- Detects potentially sensitive columns with high cardinality
- Generates detailed reports on schema patterns

## Installation

```bash
pip install cdef-parquet-scanner
```

## Usage

```bash
# As a module
python -m cdef_parquet_scanner.schema <directory_path> [output_file]

# As a command-line tool
cdef-parquet-scanner <directory_path> [output_file]
```

If no output file is specified, the report will be saved as `parquet_schema_report.txt` in the current directory.

## Example

```bash
cdef-parquet-scanner /path/to/data/directory report.txt
```

## License

MIT
apiseek 0.3
A custom API dashboard for FastAPI endpoints.

# APISEEK

APISEEK is a one-stop shop for every FastAPI request, providing essential metrics and insights for each API endpoint. It’s ideal for individuals and organizations looking to easily monitor API usage, performance, and user interactions.

## Features

- **Real-time Metrics**: Track every FastAPI request as it happens.
- **Comprehensive Dashboard**: View data such as:
  - Request Name
  - Request Type (HTTP Method)
  - Total Requests (since server startup)
  - Successful Requests
  - Failed Requests
  - Average Response Time
  - Minimum Response Time
  - Median Response Time
  - Maximum Response Time
  - Most Recent Call (Timestamp & Response Time)

## Installation and Setup

### Prerequisites

- Python 3.7+
- FastAPI
- Uvicorn

### Step 1: Prepare Your FastAPI Application

Ensure you have FastAPI and Uvicorn installed and your API endpoints are up and running. For example, you can install them via:

```bash
pip install fastapi uvicorn
```
### Step 3: Integrate APISKEEK into Your Application
Install apiseek

```bash
pip install apiseek==0.2
```

Add the following code to your FastAPI application (e.g., in your main.py):
```bash
from fastapi import FastAPI
from apiseek import init_app

app = FastAPI()

# Initialize APISKEEK (dashboard will be available at /apiseek)
init_app(app)

# Define your API endpoints below
@app.get("/hello")
def hello():
    return {"message": "Hello, world!"}
```

### Dashboard
Run your application using Uvicorn:
```bash
uvicorn main:app --reload
```
Then, open your browser and navigate to
```bash
http://127.0.0.1:8000/apiseek
```
or
```bash
localhost:8000/apiseek
```
You'll see the clean, intuitive dashboard displaying all the key metrics for your API endpoints.

![apiseek1](https://github.com/user-attachments/assets/da022cd2-7276-4042-98da-05f44f490da1)

### Data Shown
Currently, the dashboard displays the following data for each API endpoint:

Request Name
Request Type
Total Requests (from server startup)
Successful Requests
Failed Requests
Average Response Time
Minimum Response Time
Median Response Time
Maximum Response Time
Most Recent Call
Response Time

### How to Contribute
Contributions are welcome! If you have suggestions, improvements, or bug fixes, please reach out:

Email: vikrant.th2014@gmail.com
LinkedIn: [Programming Vikrant](https://www.linkedin.com/in/programming-vikrant/)
Let's discuss new features and improvements that can take APISKEEK from version 0.2 to 0.5 and beyond. Once we reach a larger user base, we'll set up proper community channels and governance to further develop this project.

### License
APISEEK is released under the MIT License.
rezka-api-sdk 0.1.0
It is a library that allows you to interact with unofficial HDRezka API
Requires Python: >=3.10
Keywords: rezka, hdrezka, films, series

# Rezka API SDK

[![PyPI Version](https://img.shields.io/pypi/v/rezka_api_sdk.svg)](https://pypi.org/project/rezka_api_sdk/)
[![Python Version](https://img.shields.io/pypi/pyversions/rezka_api_sdk.svg)](https://pypi.org/project/rezka_api_sdk/)

SDK for unofficial Rezka API.
Details about API [at Telegram](https://t.me/aryn_dev/138).


## Installation

You can install `rezka_api_sdk` using pip:

```bash
pip install rezka_api_sdk
```


## Usage

```python
from rezka_api_sdk import RezkaAPI, models

# Init API client
rezka_api = RezkaAPI("<your API key>")

# Get me, returns `models.UserModel`
await rezka_api.get_me()

# Search items, returns `list[SearchResultModel]`
await rezka_api.search("Top Gun: Maverick")

# Get short info about item and available translators, returns `tuple[ShortInfoModel, list[TranslatorInfoModel]]`
await rezka_api.get_info_and_translators("http://hdrezka1tqbbd.org/films/action/47946-top-gan-meverik-2022.html")


# Get direct urls
# NOTE: allowed to pass item's ID or URL
# Acceptable key arguments:
# 
# translator_id: int; required;
# is_film: bool; required;
# translator_additional_arguments: dict;  required; you can get it from `models.TranslatorInfoModel.additional_arguments`


# For films:
await rezka_api.get_direct_urls(
    id = 47946,
    translator_id = 56,
    is_film = True,
    translator_additional_arguments = {}
)


# For series:
await rezka_api.get_direct_urls(
    id = 646, # Breaking bad
    translator_id = 56,
    is_film = False,
    translator_additional_arguments = {},
    season_id = "1",
    episode_id = "1"
)
```

For user-friendly CLI example see [cli_example.py](cli_example.py).


## Stay updated

For the latest news and updates, follow my [Telegram Channel](https://t.me/aryn_dev).
autiobooks 1.1.0
Automatically convert epubs to audiobooks
Requires Python: >=3.10

# Autiobooks: Automatically convert epubs to audiobooks
[![Installing via pip and running](https://github.com/plusuncold/autiobooks/actions/workflows/pip-install.yaml/badge.svg)](https://github.com/plusuncold/autiobooks/actions/workflows/pip-install.yaml)
![PyPI - Python Version](https://img.shields.io/pypi/pyversions/autiobooks)
![PyPI - Version](https://img.shields.io/pypi/v/autiobooks)

Autiobooks generates `.m4b` audiobooks from regular `.epub` e-books, using Kokoro's high-quality speech synthesis.

![Demo of Autiobooks in action](rec.gif)

[Kokoro](https://huggingface.co/hexgrad/Kokoro-82M) is an open-weight text-to-speech model with 82 million parameters. It yields natural sounding output while being able to run on consumer hardware.

It supports American, British English, French, Korean, Japanese and Mandarin (though we only-support English, for now) and a wide range of different [voices](https://huggingface.co/hexgrad/Kokoro-82M/blob/main/VOICES.md) with different accents and prosody.

PRs are welcome!

## Changelog

#### 1.1.0 

- Fix race condition - @Thabian

#### 1.0.9

- Fix issue with output file containing multiple audio stream [10](https://github.com/plusuncold/autiobooks/issues/10) - @tomhense
- Add an entrypoint for pipx - @tomhense

#### 1.0.7

- Uptick kokoro package

#### 1.0.6

- Fix chapter index - @tomhense

#### 1.0.5
- Fix pip installs

#### 1.0.3
- Fix bug causing errors on some linux installs
- Read epub files with chapters not marked as ITEM_DOCUMENT
- Select all chapters if none are selected

#### 1.0.2
- Window can be resized

#### 1.0.1
- Initial release


## How to install and run

(Note that pip installs are currently not working - we are looking
into the cause of this, but in the meantime, please download the 
repo and run directly)

If you have Python 3 on your computer, you can install it with pip.
Be aware that it won't work with Python 3.13.

```bash
pip install autiobooks
```

You will require `ffmpeg` and `tkinter` installed:

Linux:
```bash
sudo apt install ffmpeg python3-tkinter
```
MacOS:
```bash
brew install ffmpeg python-tk
```

Also recommended is `espeak-ng` for better processing of unknown words.

To start the program, run:

```bash
python3 -m autiobooks
```

The program creates .wav files for each chapter, then combines them into a .m4b file for playing using an audiobook player.

## Author
by David Nesbitt, distributed under MIT license.
KDE-diffusion 1.0.5
Kernel density estimation via diffusion in 1d and 2d
Requires Python: >=3.6
Keywords: kernel density estimation, statistics

﻿*Kernel density estimation via diffusion in 1d and 2d*

Provides the fast, adaptive kernel density estimator based on linear
diffusion processes for one-dimensional and two-dimensional input data
as outlined in the [2010 paper by Botev et al.][paper] The reference
implementation for [1d] and [2d], in Matlab, was provided by the paper's
first author, Zdravko Botev. This is a re-implementation in Python,
with added test coverage.

Find the full [documentation on Read-the-Docs][docs].

[paper]: https://dx.doi.org/10.1214/10-AOS799
[1d]:    https://mathworks.com/matlabcentral/fileexchange/14034
[2d]:    https://mathworks.com/matlabcentral/fileexchange/17204
[docs]:  https://kde-diffusion.readthedocs.io
dnawave 0.1.0
Official Python client for the DNAWave API
Requires Python: >=3.7

# DNAWave Python Client

The official Python client for the DNAWave API. This package provides a simple and intuitive way to interact with DNAWave's services.

## Installation

```bash
pip install dnawave
```

## Quick Start

```python
from dnawave import DNAWaveClient, Dataset, Workflow

# Initialize the client
client = DNAWaveClient(api_key="your-api-key")
Dataset.set_client(client)
Workflow.set_client(client)

# Create a dataset
dataset = Dataset.create(
    name="My Dataset",
    bucket_key="s3-bucket-key",
    description="My dataset description",
    keywords=["gene", "sequence"],
    tags=[{"id": "tag-id", "name": "tag-name"}]
)

# List datasets
datasets = Dataset.list()
for dataset in datasets:
    print(dataset.name)

# Get a specific dataset
dataset = Dataset.get("dataset-id")

# Update a dataset
dataset.description = "Updated description"
dataset.save()

# Delete a dataset
dataset.delete()

# Work with workflows
workflow = Workflow.create(
    name="My Workflow",
    engine="nextflow",
    parameter_template={"param1": "value1"}
)

workflows = Workflow.list()
```

## Features

- Full support for DNAWave API endpoints
- Easy-to-use object-oriented interface
- Automatic request retries and error handling
- Type hints for better IDE support

## Error Handling

```python
from dnawave import DNAWaveError, AuthenticationError

try:
    dataset = Dataset.get("non-existent-id")
except AuthenticationError:
    print("Invalid API key")
except DNAWaveError as e:
    print(f"API error: {str(e)}")
```

## Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

## License

This project is licensed under the MIT License - see the LICENSE file for details.
airflow-wingman 0.4.0
Airflow plugin to enable LLMs chat
Requires Python: >=3.9

# Airflow Wingman
Airflow plugin to enable LLMs chat in Airflow Webserver.

Internally uses [Airflow MCP Server](https://pypi.org/project/airflow-mcp-server) in safe mode. Only has access to 52 tools which are GET requests as per latest release of Airflow OpenAPI Spec (_i.e. 2.10.0_)


## Usage

Install using pip:

```bash
pip install airflow-wingman
```

## Demo Video

https://github.com/user-attachments/assets/6a459071-dddc-43cb-8e2a-87104d67cf29

## Supported Models

- OpenAI
    - GPT-4o
- Google Gemini
    - Gemini 2.0 Flash
- Anthropic
    - Claude 3.7 Sonnet
    - Claude 3.5 Haiku
- Openrouter
    - Any model but context length is limited to 128K.

## Resources

Pypi: https://pypi.org/project/airflow-wingman
inmailer 0.1.4
A Python package that offers email utilities.
Requires Python: >=3.6

# Inmailer

Pymailer is a Python package that provides email utilities, including CSS inlining for HTML emails.

## Features
- Convert in-file CSS (inside `<style>` tags) into inline styles
- Retain non-inlineable styles (e.g., `@media`, `:hover`) in `<style>`
- Maintain HTML structure while applying styles efficiently

## Installation
```sh
pip install inmailer
```

## Usage

```python
from inmailer import inline_css

html_content = """<html><head><style>h1 { color: red; }</style></head><body><h1>Hello</h1></body></html>"""
processed_html = inline_css(html_content)
print(processed_html)
```

## Contributing
Contributions are welcome! 

To contribute:
1. Fork the repository
2. Create a new branch (`git checkout -b feature-branch`)
3. Commit your changes (`git commit -m 'Add new feature'`)
4. Push to the branch (`git push origin feature-branch`)
5. Open a Pull Request

## License
This project is licensed under the MIT License.