semvec/pypi-packages huggingface dataset:
hydrakon 0.1.0
CLI tool for testing Hydrakon packages
Requires Python: >=3.10

# Hydrakon CLI

Hydrakon CLI is a diagnostic and validation tool designed for autonomous racing systems. It provides a suite of utilities to verify system health, validate ROS 2 topics against strict configurations, and visualize coordinate transform (TF) trees in real-time.

This tool simplifies the pre-race check procedure by automating the verification of hardware interfaces, sensor data streams, and software states.

## Installation

### From PyPI
To install the latest stable version:

```bash
pip install hydrakon
```

### From Source (Development)
For active development or deployment on specific hardware (e.g., NVIDIA Jetson):

```bash
git clone https://github.com/Atlas-Racing/Hydrakon-CLI.git
cd Hydrakon-CLI
pip install -e .
```

## Configuration

Hydrakon uses a `hydrakon.yaml` file in the working directory to define expected system states.

### Structure

```yaml
topics:
  - name: /scan
    type: sensor_msgs/msg/LaserScan
    hz: 10
    tolerance: 0.1  # Allow +/- 10% deviation

  - name: /odometry/filtered
    exists: true    # Only check if topic is active

frames:
  - name: map
  - name: odom
  - name: base_link
```

## Commands

### Interface Testing
Checks for the presence and operational state of specific hardware interfaces.

**Command:**
```bash
hdk test can0
```
**Behavior:**
- Verifies if the network interface `can0` exists.
- Checks if the interface state is `UP`.
- Returns an error code if the interface is missing or down.

### Topic Validation
Validates active ROS 2 topics against the `hydrakon.yaml` configuration.

**Command:**
```bash
hdk test topics
```

**Options:**
- `--all`: Lists all active topics on the system, highlighting those that are present but not configured in the YAML file.
- `--config <path>`: Specify a custom configuration file path (default: `hydrakon.yaml`).

**Checks Performed:**
1. **Existence**: Is the topic published?
2. **Type**: Does the message type match the configuration?
3. **Frequency (Hz)**: Is the publishing rate within the specified tolerance?

### TF Visualization
Captures and displays the Transform (TF) tree structure directly in the terminal.

**Command:**
```bash
hdk show tfs
```

**Options:**
- `--all`: Displays the entire TF tree found on the system, ignoring filters.
- `--duration <seconds>`: Sets the listening duration (default: 5.0s).
- `--debug`: Prints raw capture data and parsing logs for troubleshooting.

**Behavior:**
- Listens to `/tf` and `/tf_static` for the specified duration.
- Parses the transform hierarchy.
- Renders an ASCII tree view of the coordinate frames.
- By default, filters the view to show only frames listed in `hydrakon.yaml` to reduce noise.

## Release Process

To release a new version to PyPI:

1. Run the release helper script:
   ```bash
   python release_helper.py
   ```
2. Enter the new version number when prompted.
3. Select the target repository (TestPyPI or PyPI).
4. Provide credentials when requested.
vision-loom 0.2.2
Framework to create labeling data from VLM and other larger models for computer vision tasks
Requires Python: >=3.10

# Vision Loom

Leverage Vision Language Models to label images and create training data for other computer vision tasks. 

Vision Loom is an automated labeling framework designed to bridge the gap between high-reasoning Foundation Models and real-time edge deployment. Leverage the "zero-shot" capabilities of Vision-Language Models (VLMs) to generate high-fidelity training data without the manual overhead.

| Model | Task | Reference
| :--- | :---: | ---: |
Grounding Dino Tiny | Object Detection | detector_test.py
SAM-2 | Object Segmentation | segmentation_test.py

## Save detection results
  
* Install the library. Install the latest version for the updated features and comments.

```python
pip install vision-loom
```

```python 
from vision_loom.models.grounding_dino import GroundingDINO 
from vision_loom.utils.io import load_images 
```

* Enter a single image or path to a folder containing images
```python
images = "vision_loom/test_notebooks/test_images"
dataloader = load_images(images)
```

* Once the data loader is created, type in the items you want to detect and create the bounding boxes for. If your set of images has multiple objects over multiple images, I recommend giving the prompt for all the objects together to save compute.
```python
prompt = [["car", "person", "book", "bike"]]
``` 

* Run the pipeline.
```python
for img_path, image in tqdm(dataloader):
    results = model.detect(image, prompt, img_path, save_results=True)
``` 

![Detector Pipeline V1](https://raw.githubusercontent.com/leonbora167/vision-loom/main/documentation/Detector_Pipeline_V1.jpg)

## 📦 Releases
See [CHANGELOG](./CHANGELOG.md) for version history.

## Roadmap 

- [ ] Add Image Classification Support
- [ ] Options for export to classical SOTA formats like YOLO, COCO etc.
ttsdb_f5_tts 0.1.4
F5-TTS model for TTSDB
Requires Python: <=3.14,>=3.10

# F5-TTS

The model description is sourced from `config.yaml` (`metadata.description`).

## Installation

```bash
just setup f5-tts
```

## Usage

```python
from ttsdb_f5_tts import F5TTS

model = F5TTS(model_id="ttsds/f5-tts")
audio, sr = model.synthesize(
    text="Hello, world!",
    reference_audio="path/to/reference.wav"
)
```

## Audio Examples

Generated audio samples from integration tests:

| Language | Text | Audio |
|----------|------|-------|
| English | "With tenure, Suzie'd have all the more leisure for yachting, but her publications are no good." | [audio_examples/en_test_001.wav](audio_examples/en_test_001.wav) |
| Chinese | "視野無限廣，窗外有藍天" | [audio_examples/zh_test_001.wav](audio_examples/zh_test_001.wav) |

To regenerate examples, run:
```bash
just test-integration f5-tts
```
cmeta 0.21.16
cMeta (aka cX) is a common meta-framework for unifying, interconnecting and reusing code, data, models, agents, and knowledge across projects and domains.
Requires Python: >=3.9

[![License](https://img.shields.io/badge/License-Apache%202.0-green)](LICENSE.md)
[![PyPI version](https://badge.fury.io/py/cmeta.svg)](https://pepy.tech/project/cmeta)
[![Python Version](https://img.shields.io/badge/python-3.9%2B-blue.svg)](https://github.com/ctuninglabs/cmeta)
[![Test cMeta core](https://github.com/cTuningLabs/cmeta/actions/workflows/test-core.yml/badge.svg)](https://github.com/cTuningLabs/cmeta/actions/workflows/test-core.yml)

# cMeta (Common Meta Framework)

cMeta (aka cX) is a common meta-framework for unifying, interconnecting and reusing code, data, 
models, agents, and knowledge across projects and domains.

## License

Apache 2.0

## Copyright

Copyright (C) 2025-2026 [Grigori Fursin](https://cTuning.ai/@gfursin) and [cTuning Labs](https://cTuning.ai).

This project may include minor functionality reused from [MLCommons CK](https://github.com/mlcommons/ck), 
developed by the same author and licensed under the same Apache 2.0 terms.

## Installation

### Simple PIP

```bash
pip install cmeta
cmeta --version
```

### UV + PIP


```bash
uv venv
uv pip install cmeta
uv run cmeta --version
```

### UV + GIT


```bash
uv venv
uv pip install --force-reinstall git+ssh://git@github.com/ctuninglabs/cmeta.git@main#egg=cmeta
uv run cmeta --version
```

## Command line

```bash
cmeta --help
cmeta --version
```
or
```bash
cx --help
cx --version
```

## Python interface

```python
from cmeta import CMeta
cm = CMeta()
r = cm.access({'category':'repo', 'command':'list'})
print (r)
```


## Status

*Under active development.*
pulya 0.2.1
Tiny web framework based on msgspec and dependency-injector
Requires Python: >=3.12

<p align="center"><b>pulya</b> is a tiny python web framework focused on performance and new python features.</p>
<div style="text-align: center;">
    <img src="/logos/horizontal-2.png">
</div>
<p></p>

Features:

- **msgspec** for validation and serialization
- **dependency-injector** as the main and the only DI framework
- **RSGI** and first-class **granian** support
- **free-threading** / **no-gil** python support
- zero-cost routing with **python-matchit**

Minimal supported python version 3.12.

# Quick start

Installation:

```shell
pip install pulya
```

Simple application (`main.py`:

```python
from typing import Any
from pulya import Pulya, RequestContainer
from dependency_injector import containers, providers

class Container(containers.DeclarativeContainer):
    # Wiring configuration.
    # RequestContainer will also use this wiring config.
    wiring_config = containers.WiringConfiguration(
        modules=[__name__],
    )

    # Specially named dependency providing access to active request.
    # Must have exact name `request`, actual container will be injected
    # by the application on startup.
    request = providers.Container(RequestContainer)

app = Pulya(Container)

@app.get("/")
def home() -> dict[str, Any]:
    return {"success": True}
```

Run using granian:

```shell
granian --interface rsgi main:app
```

Check:

```shell
curl http://localhost:8000/
```