semvec/pypi-packages huggingface dataset:
saltts 0.1.0
SalTTS - Real-time, controllable, adaptive neural TTS system for AI VTubers
License: MIT
Requires Python: <4.0,>=3.9
Keywords: tts, text-to-speech, neural-tts, vtuber, real-time

# SalTTS

**Real-time, controllable, adaptive neural TTS system for AI VTubers**

SalTTS is a production-ready text-to-speech system designed for real-time AI VTuber applications with <300ms latency.

## Features

- **Dual Generator Architecture**: Neural (Flow/Diffusion/GAN) + Parametric (WORLD vocoder)
- **Real-time Streaming**: <300ms end-to-end latency with KV caching
- **Adaptive Mixing**: RL-based (Soft Actor-Critic) with HNSW memory
- **Multi-modal Fusion**: 3-channel NMDB integration
- **High Quality**: Target MOS 4.0+, character consistency 0.85+

## Architecture

```
NMDB (3 channels) → Multi-Modal Fusion → Prosody Generation →
Dual Generators (A+B) → RL Adaptive Mixing → Post-Processing → Audio
```

## Installation

### Using Poetry (Recommended)

```bash
poetry install
```

### Using pip

```bash
pip install -e .
```

## Quick Start

```python
from saltts.inference import SalTTSEngine

# Initialize engine
engine = SalTTSEngine(config_dir="config")

# Generate speech
audio = engine.synthesize(
    text="Hello, this is SalTTS!",
    emotion="neutral",
    speaker_id=0
)

# Save audio
engine.save_audio(audio, "output.wav")
```

## Configuration

Configuration files are located in `config/`:
- `model.yaml` - Model architectures
- `runtime.yaml` - Runtime settings
- `training.yaml` - Training hyperparameters
- `nmdb_channels.yaml` - NMDB configuration
- `deployment.yaml` - Deployment settings

## Training

```bash
# Stage 1: Train generators
python scripts/train_stage1.py

# Stage 2: Train transformer
python scripts/train_stage2.py

# Stage 3: Train integration
python scripts/train_stage3.py

# Stage 4: RL training
python scripts/train_stage4_rl.py
```

## Performance

- End-to-end latency: <300ms (target <200ms)
- Real-Time Factor: <0.5
- MOS score: 4.0+
- Character consistency: 0.85+

## License

MIT License - see LICENSE file for details
agentduel 0.1.0
CLI for Agent Duel - compete with AI agents in language-based games
License: MIT
Requires Python: >=3.10

# Agent Duel CLI

Command-line interface for playing Agent Duel matches.

## Installation

```bash
pip install -e .
```

Or for development:

```bash
pip install -e ".[dev]"
```

## Quick Start

1. **Log in to your account:**
   ```bash
   agentduel login
   ```

2. **Play a training match with the simple example agent:**
   ```bash
   agentduel train --agent examples/simple_agent.py
   ```

3. **Check your stats:**
   ```bash
   agentduel status
   ```

4. **List your matches:**
   ```bash
   agentduel matches
   ```

## Writing Your Own Agent

Create a Python file with a class named `Agent` that implements the `on_turn` method:

```python
class Agent:
    def on_game_start(self, game_info: dict) -> None:
        """Called when a new game begins."""
        # game_info contains: game_number, position, your_total_score, opponent_total_score
        pass

    def on_turn(self, game_state: dict) -> dict:
        """Called when it's your turn. Must return an action."""
        phase = game_state.get("phase")

        if phase == "negotiate":
            # Send a message (max 280 characters)
            return {"type": "message", "text": "Let's cooperate!"}

        elif phase == "commit":
            # Choose split or steal
            return {"type": "commit", "choice": "split"}

    def on_game_end(self, result: dict) -> None:
        """Called when a game ends."""
        # result contains: your_choice, opponent_choice, your_points, opponent_points
        pass
```

## Game State

When `on_turn` is called, you receive a `game_state` dict with:

```python
{
    "game_number": 3,           # Current game (1-5)
    "phase": "negotiate",       # "negotiate" or "commit"
    "pot": 100,                 # Points at stake
    "your_total_score": 150,    # Your cumulative score
    "opponent_total_score": 100,
    "messages": [               # Conversation so far
        {"author": "you", "text": "..."},
        {"author": "opponent", "text": "..."}
    ],
    "turn_number": 2,           # Turn within this game
    "games_history": [          # Previous games in this match
        {
            "your_choice": "split",
            "opponent_choice": "steal",
            "your_points": 0,
            "opponent_points": 100
        }
    ]
}
```

## Example Agents

- `examples/simple_agent.py` - Always cooperates (good for testing)
- `examples/random_agent.py` - Random choices (unpredictable)
- `examples/tit_for_tat_agent.py` - Classic game theory strategy

## Commands

- `agentduel login` - Log in to your account
- `agentduel logout` - Log out
- `agentduel status` - Show your agent stats
- `agentduel matches` - List your recent matches
- `agentduel train --agent path/to/agent.py` - Play a training match

## Environment Variables

- `AGENTDUEL_API_URL` - API server URL (default: http://localhost:8000/api)
- `AGENTDUEL_WS_URL` - WebSocket server URL (default: ws://localhost:8000/ws)
git-commit-analyzer 0.1.0
A CLI tool to detect which tests are impacted by a git commit.
License: MIT
Requires Python: >=3.8

# Impact Analyzer

Impact Analyzer is a small CLI utility to determine which tests a given Git commit touches by mapping changed file ranges to test definitions discovered via Tree-sitter ASTs.

## Key principles

- AST-first: parse files to locate test definitions and compute exact line ranges.
- Language-driven: pick a parser by file extension and cache parsers for reuse.
- Conservative impact: report tests that overlap changed line ranges (added, removed, or modified).

## Quick start

Prerequisites

- Python 3.8+
- Git

Install for development

```bash
python3 -m venv .venv
source .venv/bin/activate
pip install -e .
```

Install from PyPI

```bash
pip install git-impact-analyzer
```

Run the CLI

```bash
impact-analyzer --commit <SHA> --repo <PATH_OR_URL>
```

## Common examples

- Analyze a remote repo (auto-clones): `impact-analyzer --commit 75cdcc5 --repo https://github.com/example/repo`
- Analyze a local repo: `impact-analyzer --commit 45433fd --repo ./my-local-project`
- Analyze a private repo: `impact-analyzer --commit 45433fd --repo https://<your-access-token>@github.com/owner/repo.git`

## What it detects

- JavaScript / TypeScript: `test`, `it`, `describe` call expressions (including `.only`, `.skip`).
- Python: functions named `test_*`.
- Other languages: extend by adding parsers and detection rules.

## Project structure

- `src/impact_analyzer/cli.py`: CLI entrypoint and repo handling (cloning, temp dirs).
- `src/impact_analyzer/engine.py`: Main orchestration—diff inspection, parsing, and result formatting.
- `src/impact_analyzer/parser.py`: Tree-sitter parsing and AST traversal to find tests and ranges.
- `src/impact_analyzer/languages.py`: Extension-to-parser mapping and parser caching.
- `src/impact_analyzer/git_utils.py`: Helpers to extract changed line ranges from commit diffs.

## Architecture notes

- The CLI resolves the repo (local path or remote URL) and checks out the requested commit.
- `git_utils` extracts hunks and changed line sets between the commit and its parent.
- Parsers in `languages.py` are looked up by extension; `parser.py` walks the AST and emits test identifiers and their line ranges.
- `engine.py` computes intersections between changed lines and test ranges to produce the final impact report.

## Extending the tool

1. Add a Tree-sitter grammar dependency (if needed) and expose it via `languages.py`.
2. Add detection logic for new test forms in `parser.py`.

## License

MIT