semvec/pypi-packages huggingface dataset:
caketool 1.7.0
Common tools for MLOps
Requires Python: >=3.7
Keywords: cake, ds, mlops

# Caketool

- Enviroment

```bash
conda create -n caketool
conda activate caketool
pip-compile pyproject.toml
pip-sync
pip install pip-tools bumpver build twine ipykernel
```

- Publish libs

```bash
bumpver update --major # Increment the MAJOR version when you make incompatible API changes.
bumpver update --minor # Increment the MINOR version when you add functionality in a backwards compatible manner.
bumpver update --patch # Increment the PATCH version when you make backwards compatible bug fixes.
python -m pip install -e . # Install on local machine
rm ./dist/*
python -m build
twine upload -r testpypi dist/*
twine upload dist/*
pip install caketool
```
depends-tools 1.1.0
A Python dependency injection framework, it's like fastapi.Depends
Requires Python: >=3.7
Keywords: dependency, injection, di, ioc

# py-depends

A lightweight and elegant Python dependency injection framework.

## Features

- 🚀 Simple and intuitive API
- 🔄 Support for both sync and async dependencies
- 🏭 Factory pattern support
- 🎯 Type-safe dependency resolution
- 📦 Zero external dependencies
- 🧪 Comprehensive test coverage

## Installation

```bash
pip install depends-tools
```

## Quick Start

```python
from depends_tools import Depends, inject

# Define a dependency
def get_database():
    return "database_connection"

# Use the dependency
@inject
def get_user(db=Depends(get_database)):
    return f"User from {db}"

# Resolve dependencies
result = get_user()
print(result)  # Output: User from database_connection
```

## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

## Support

If you encounter any issues or have questions, please [open an issue](https://github.com/JokerCrying/py-depends-tools/issues) on GitHub.
gmri2fem 0.2.8
Processing pipeline for glymphatic MRI.
Requires Python: <3.13,>=3.11

# gMRI2FEM
`gmri2fem` is a python package for processing of human glymphatic MRI-images, i.e. contrast-enhanced brain images, with special focus on concentration-estimation and conversion into `dolfin` for mathematical modelling of brain tracer transport using the finite element method.
The data functionality was developed for the MRI processing workflow for the GRIP-project. 
The package both provide a library of useful functions as well as a CLI for processing different types of images.


## Installation
### Dependencies
`gmri2fem` has some python- and non-python dependencies which are not easily installable through `pip`:
- FreeSurfer
- greedy
- FEniCS
- SVMTK

Instructions for how to install these may be found on their websites. 
It is, however, possible to `gmri2fem` and run large portions of the pipeline whithout these dependencies.
To install the python package gmri2fem, clone this repository and run 
```bash
pip install . 
```
from the root directory. 
This will install the python packages and the CLI. 


## Example usage
For a rough documentation on how to use the various exposed CLI-commands, we recommend looking at the Snakefiles for the Gonzo data pipeline at (https://github.com/jorgenriseth/gonzo).
The CLI has several levels of subcommands.
To run the main entrypoint:
```bash
$ gmri2fem --help
Usage: gmri2fem [OPTIONS] COMMAND [ARGS]...

Options:
  --help  Show this message and exit.

Commands:
  brainmeshing
  dcm2nii-ll
  dcm2nii-mixed
  dti
  i2m
  mri
  seg
```

#### MRI
```bash
Usage: gmri2fem mri [OPTIONS] COMMAND [ARGS]...

Options:
  --help  Show this message and exit.

Commands:
  concentration
  hybrid-t1map
  looklocker-t1-postprocessing
  looklocker-t1map
  mixed-t1map
  reslice4d
  t1-to-r1
  t1w-normalize
  t1w-sigdiff
```

Example command:
```bash
Usage: gmri2fem mri looklocker-t1map [OPTIONS]

Options:
  --input PATH       [required]
  --timestamps PATH  [required]
  --output PATH      [required]
  --help             Show this message and exit.
```
modbusim 0.1.7
A Modbus RTU/ASCII/TCP device simulator for testing and development
Requires Python: <3.14,>=3.8.1

# ModbusIM - Modbus Device Simulator

A Python package for simulating Modbus RTU/ASCII/TCP devices for testing and development purposes.

[![PyPI version](https://badge.fury.io/py/modbusim.svg)](https://badge.fury.io/py/modbusim)
[![Python Version](https://img.shields.io/badge/python-3.8.1+-blue.svg)](https://www.python.org/downloads/)
[![License: Apache 2.0 ](https://img.shields.io/badge/License-Apache 2.0 -yellow.svg)](https://opensource.org/licenses/Apache 2.0 )

## Features

- Simulate Modbus RTU/ASCII/TCP devices
- Support for all standard Modbus function codes
- Easy-to-use CLI interface
- Programmatic API for integration with tests
- Configurable device behavior
- Docker support for easy deployment

## Installation

### Using pip

```bash
pip install modbusim
```

### Using Poetry (for development)

```bash
git clone https://github.com/yourusername/modbusim.git
cd modbusim
poetry install
```

### Using Docker

```bash
# Build the image
docker build -t modbusim .

# Run the Modbus TCP simulator
docker run -p 5020:5020 modbusim
```

Or using Docker Compose:

```bash
docker-compose up -d
```

## Usage

### Command Line Interface

Start a Modbus RTU simulator:

```bash
modbusim rtu --port /tmp/ptyp0 --baudrate 9600
```

Start a Modbus TCP simulator:

```bash
modbusim tcp --host 0.0.0.0 --port 5020
```

### Python API

```python
from modbusim import ModbusSimulator

# Create a simulator instance
simulator = ModbusSimulator(
    mode="rtu",  # or "tcp"
    port="/tmp/ptyp0",  # or host="0.0.0.0" for TCP
    baudrate=9600
)

# Start the simulator
simulator.start()

try:
    # Your test code here
    while True:
        # Keep the simulator running
        pass
except KeyboardInterrupt:
    # Stop the simulator
    simulator.stop()
```

## Development

### Running Tests

```bash
make test
```

### Linting and Formatting

```bash
make lint    # Run linters
make format  # Format code
```

### Building and Publishing

```bash
make build    # Build the package
make publish  # Publish to PyPI
```

## Docker Development

### Build the development image

```bash
docker-compose -f docker-compose.dev.yml build
```

### Run tests in Docker

```bash
docker-compose -f docker-compose.dev.yml run --rm modbusim make test
```

### Start a development shell

```bash
docker-compose -f docker-compose.dev.yml run --rm --service-ports modbusim bash
```

## License

Apache 2.0  - See [LICENSE](LICENSE) for more information.
livekit-plugins-reverie 1.0.0
Agent Framework plugin for services using Reverie's API.
Requires Python: >=3.9.0
Keywords: ASR, STT, audio, hindi, indic languages, livekit, realtime, video, webrtc

# LiveKit Reverie Plugin

This plugin provides Indic language speech-to-text capabilities using [Reverie's STT API](https://docs.reverieinc.com/api-reference/speech-to-text-streaming).

Signup [here](https://revup.reverieinc.com/login) to create API keys.

## Installation

```bash
pip install livekit-plugins-reverie
```

## Configuration

You need to set the following environment variables:

- `REVERIE_API_KEY`: Your Reverie API key
- `REVERIE_APP_ID`: Your Reverie App ID


## Usage

```python
from livekit.plugins import reverie
from livekit.agents import stt

# Create STT instance with all available options
reverie_stt = reverie.STT(
    language="hi_en",       # Language code (default: "hi_en")
    domain="generic",       # Domain context (default: "generic")
    continuous=True,        # Continuous streaming (default: True)
    silence=0.5,           # Return final after silence in seconds (default: 0.5, max: 30)
    format="16k_int16",    # Audio format (default: "16k_int16")
    punctuate=False,       # Enable punctuation (default: False)
)

```

## Supported Languages

Reverie supports multiple Indian languages. Common language codes include:

- `hi_en` - Hinglish
- `hi` - Hindi
- `en` - English
- `bn` - Bengali
- `ta` - Tamil
- `te` - Telugu
- `mr` - Marathi
- `gu` - Gujarati
- `kn` - Kannada
- `ml` - Malayalam
- `pa` - Punjabi
- `or` - Odia
- `as` - Assamese

## Configuration Parameters

### Core Parameters
- `language`: Language code for recognition (e.g., "hi_en", "hi", "en", "bn") - Default: "hi_en"
- `domain`: Context domain for transcription (e.g., "generic") - Default: "generic"

### Audio & Format
- `format`: Audio format specification - Default: "16k_int16"
- `sample_rate`: Audio sample rate in Hz - Default: 16000
md2lobster 0.1.0
Read a markdown file to create some lobster traceing
Requires Python: >=3.9

# md2lobster

This is a small tool that takes a markdown file
and produces a lobster tracking file for the markdown
file.

It takes links to requiremnts and traces those.
It's intended for free text test reports or manual
 analysis reports to ensure the lobster tracing is
in place.


---
[![status-badge](https://ci.codeberg.org/api/badges/14974/status.svg)](https://ci.codeberg.org/repos/14974)
mcp-predictor 1.0.0
Simple Time Series Prediction Library
Requires Python: >=3.8

# MCP Predictor

진짜 간단한 시계열 예측 라이브러리입니다.

## 특징

- ✅ **진짜 간단한 사용법**
- ✅ **여러 config 파일로 여러 예측**
- ✅ **DB2, PostgreSQL, MongoDB 지원**
- ✅ **Prophet + LightGBM 시계열 예측**

## 설치

```bash
pip install mcp-predictor
```

## 사용법

### **진짜 간단한 사용법**

```python
from mcp_predictor import predict

# 한 줄로 예측
predict("config.yaml")
predict("config1.yaml")
predict("config2.yaml")
predict("config3.yaml")
```

### **설정 파일 예시**

```yaml
# config.yaml
input:
  source_type: "db"
  db_type: "db2"
  connection:
    host: "192.168.106.35"
    port: 25010
    user: "db2inst1"
    password: "mobigen01!"
    database: "EOTD"
  table: "DSTDM.T_PBAF3103S"
  features: ["RGN_CD", "CRTR_YR"]
  target: ["GRDR1_STDNT_NOPE", "GRDR2_STDNT_NOPE"]

prediction:
  task_type: "timeseries"
  future_steps: 5
  time_col: "CRTR_YR"
  group_key: "RGN_CD"

output:
  source_type: "db"
  db_type: "db2"
  connection:
    host: "192.168.106.35"
    port: 25010
    user: "db2inst1"
    password: "mobigen01!"
    database: "EOTD"
  table: "DSTDM.T_PBAF3103S_FCST"
```

## 프로젝트 구조

```
mcp-predictor/
├── core/
│   └── predictor.py          # 핵심 예측 로직
├── data/
│   ├── csv.py               # CSV 데이터 처리
│   ├── data.py              # 데이터 전처리
│   └── db.py                # 데이터베이스 연결
├── model/
│   └── model.py             # Prophet + LightGBM 모델
├── config/
│   └── config.py            # 설정 파일 로더
├── mcp_predictor.py         # 진짜 간단한 라이브러리
├── main.py                  # 직접 실행용
├── config.yaml              # 설정 파일
└── requirements.txt         # 의존성
```

## 라이브러리 배포

```bash
# PyPI에 업로드
pip install build twine
python -m build
twine upload dist/*
```

## 라이센스

MIT License
geometry-toolkit-anas 0.1.0
A toolkit for basic geometric calculations
Requires Python: >=3.6

# Geometry Toolkit
`geometry_toolkit` is a simple Python package for basic geometric calculations.
## Installation
Install the package with pip:
pip install geometry_toolkit

Usage
from geometry_toolkit import (
 rectangle_area,
 rectangle_perimeter,
 square_area,
 square_perimeter,
 circle_area,
 circle_circumference,
)
# Rectangle
print(rectangle_area(5, 3)) # Output: 15
print(rectangle_perimeter(5, 3)) # Output: 16
# Square
print(square_area(4)) # Output: 16
print(square_perimeter(4)) # Output: 16
# Circle
print(circle_area(3)) # Output: 28.274333882308138
print(circle_circumference(3)) # Output: 18.84955592153876# geometry_toolkit
spoofyarchiver 1.0.2
Add your description here
Requires Python: >=3.12

# Spoofy Archiver

[![Check](https://github.com/kism/spoofy-archiver/actions/workflows/check.yml/badge.svg)](https://github.com/kism/spoofy-archiver/actions/workflows/check.yml)
[![CheckType](https://github.com/kism/spoofy-archiver/actions/workflows/check_types.yml/badge.svg)](https://github.com/kism/spoofy-archiver/actions/workflows/check_types.yml)
[![Test](https://github.com/kism/spoofy-archiver/actions/workflows/test.yml/badge.svg)](https://github.com/kism/spoofy-archiver/actions/workflows/test.yml)
[![codecov](https://codecov.io/gh/kism/spoofy-archiver/graph/badge.svg?token=aXeqc3G5Rp)](https://codecov.io/gh/kism/spoofy-archiver)

## Install

Install via [uv](https://docs.astral.sh/uv/getting-started/installation/) or [pipx](https://pipx.pypa.io/stable/installation/):

```bash
uv tool install git+https://github.com/kism/spoofy-archiver
```

```bash
pipx install git+https://github.com/kism/spoofy-archiver
```

If your system default python is not 3.12+

```bash
pipx install --python python3.12 git+https://github.com/kism/spoofy-archiver
```

## Run

```bash
spoofyarchiver --help
```

Download your liked albums to a directory, if you don't specify a directory it will default to `<current dir>/output`:

```bash
spoofyarchiver -o /path/to/your/dir
```

Download a an item from a URL:

```bash
spoofyarchiver -o /path/to/your/dir <url>
```

Run the cli in interactive mode:

```bash
spoofyarchiver --interactive -o /path/to/your/dir
```

## Uninstall

```bash
uv tool uninstall spoofyarchiver
```

```bash
pipx uninstall spoofyarchiver
```
nor1029-controller 0.5.0
Programmatically control Norsonic Nor1029
Requires Python: >=3.11

# nor1029-controller

> Programmatically control the [Norsonic Nor265 microphone boom / turntable](https://www.norsonic.com/products/noise-sources/nor265a-microphone-boom/)

# Install

```sh
pip install nor1029-controller
```

# Usage

```py
from nor1029_controller import Nor265

with Nor265('/dev/serial.0') as nor:
    nor.rotate(180, speed=10, acceleration=2)
```

# API

## Nor265(port)

### port

The serial port to connect to.

## nor

`Nor265` instance.

### .angle

*readonly*

Optional parameters will default to whatever was previously set.

### .rotate(angle, speed?, acceleration?)

### .rotate_relative(angle, speed?, acceleration?)

### .start_sweep(start_angle, stop_angle, period, acceleration?)

Oscillate between two angles.

### .start_continuous_rotation(direction, speed?, acceleration?)

```py
from nor1029_controller import Nor265, RotationDirection
import time

with Nor265() as nor:
    nor.start_continuous_rotation(
        direction=RotationDirection.CLOCKWISE,
        speed=10,
        acceleration=2
    )

    # Rotate for 5 seconds
    time.sleep(5)

    nor.stop()
```

### .start_rotate(angle, speed?, acceleration?)

### .start_rotate_relative(angle, speed?, acceleration?)

The `start_*` methods will return when the movement starts, while the regular methods will also wait for the movement to finish.

### .stop()

Stop any ongoing movement.

### .go_home()

Rotate back to the home position.

### .is_moving

*readonly*

### .close()

If you're not using a context manager, you should instead call this method when you are done.

```py
from nor1029_controller import Nor265

nor = Nor265('/dev/serial.0')

nor.rotate(180, speed=10, acceleration=2)

nor.close()
```

### .wait_stopped(timeout?, poll_interval?)

Wait until it is not moving.

`.rotate()` and `.rotate_relative()` do this automatically.

#### timeout

The maximum time to wait in seconds.

Default: `None` (no timeout)

#### poll_interval

The interval between each check in seconds.

Default: `0.01` (10 milliseconds)

```py
from nor1029_controller import Nor265

with Nor265('/dev/serial.0') as nor:
    nor.start_rotate(180, speed=10, acceleration=2)
    
    # ...
    
    nor.wait_stopped(timeout=10)
```

## list_ports()

Scan for available serial ports (according to their description).

```py
from nor1029_controller import Nor265, list_ports

# Pick first serial port
port = list_ports()[0].device

with Nor265(port) as nor:
    nor.rotate(180, speed=10, acceleration=2)
```

## RotationDirection

*Enum*

- `CLOCKWISE`
- `COUNTER_CLOCKWISE`
mcp-http-tool 0.1.1
An MCP server that provides AI with robust HTTP request capabilities.
Requires Python: >=3.10

# MCP HTTP Tool

[![PyPI version](https://badge.fury.io/py/mcp-http-tool.svg?icon=si%3Apython)](https://badge.fury.io/py/mcp-http-tool)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

An MCP server that provides AI with robust HTTP request capabilities.

## Features

- Supports GET, POST (JSON/form), file upload, custom headers, authentication, error/redirect handling
- AI-driven tool selection for common HTTP tasks
- Secure, Pythonic, and easy to use

## Installation

```bash
pip install mcp-http-tool
```

> Requires Python 3.10+ and `mcp[cli]`.

## Usage

Add to your MCP-compatible client (e.g., VS Code) configuration:
```json
{
  "mcpServers": {
    "http-tool": {
      "command": "mcp-http-tool"
    }
  }
}
```

## Tool Documentation

### `ai_driven_http_request`

Intelligently performs a web request based on a goal. Selects the correct low-level tool (GET, POST JSON, upload, etc.).

### Specialized tools

- `http_get`: GET request
- `http_post_json`: POST JSON
- `http_post_form`: POST form
- `http_upload_file`: File upload

## License

MIT