semvec/pypi-packages huggingface dataset:
60db 1.0.8
Official 60db SDK for Python
License: MIT
Requires Python: >=3.8
Keywords: 60db, tts, stt, voice, ai

# 60db

Official 60db SDK for Python

## Installation

```bash
pip install 60db
```

## Quick Start

```python
from sixtydb import SixtyDBClient


def fetch_and_display_voices(client: SixtyDBClient) -> str:
    """
    Fetch all available voices and print their details.

    Returns:
        str: Selected voice_id
    """
    try:
        response = client.get_voices()
    except Exception as exc:
        print("Error fetching voices:", exc)
        raise

    if not response.get("success"):
        raise Exception(response.get("message"))

    voices = response["data"]["built_in_voices"]

    if not voices:
        raise Exception("No voices available.")

    print("\nAvailable Voices:\n" + "-" * 40)

    for voice in voices:
        print(
            f"Name: {voice.get('name')} | "
            f"Voice ID: {voice.get('voice_id')} | "
            f"Language: {voice.get('language_name')} | "
            f"Gender: {voice.get('gender')}"
        )

    return voices[0]["voice_id"]


def generate_speech(client: SixtyDBClient, voice_id: str) -> None:
    """
    Generate speech and save to file.
    """
    try:
        audio = client.text_to_speech(
            text="Hello, world!",
            voice_id=voice_id,
            speed=1.0
        )

        with open("output.mp3", "wb") as file:
            file.write(audio)

        print("\nAudio saved to output.mp3")

    except Exception as exc:
        print("Error generating speech:", exc)
        raise


def main() -> None:
    try:
        client = SixtyDBClient("your-api-key")
    except Exception as exc:
        print("Error creating client:", exc)
        return

    try:
        voice_id = fetch_and_display_voices(client)
        generate_speech(client, voice_id)
    except Exception as exc:
        print("Operation failed:", exc)


if __name__ == "__main__":
    main()
```

---

## API Methods

### Text-to-Speech
- `text_to_speech(text, voice_id=None, **params)` – Convert text to speech

### Speech-to-Text
- `speech_to_text(audio_file, language=None)` – Transcribe audio
- `get_languages()` – Get supported languages

### Voices
- `get_voices()` – List all voices

---

## Example: Speech to Text

```python
from sixtydb import SixtyDBClient

client = SixtyDBClient("your-api-key")

try:
    with open("output.mp3", "rb") as file:
        result = client.speech_to_text(file, language="en")

    if result.get("success"):
        print("Transcription:", result["data"]["text"])
    else:
        print("STT Error:", result.get("message"))

except Exception as exc:
    print("Error during transcription:", exc)
```

---

## License

MIT
skill-thief 0.1.0
Simple CLI to install and update Agent Skills from git or local paths
License: MIT
Requires Python: >=3.9

# Skill Thief

Skill Thief is a Python CLI for installing and updating Agent Skills from git repositories or local paths. It reads a project-local `.skill-thief.yaml`, downloads skills (optionally from subdirectories), validates them against the Agent Skills spec, and installs them into your configured skills directory.

## Features
- `skill-thief install [name ...]` — install skills defined in config (all or selected)
- `skill-thief update [name ...]` — update installed skills to latest ref
- `skill-thief list` — view configured skills and install status
- Supports git URLs (https/ssh), optional branch/tag/commit refs, and local paths
- Validates that each installed skill contains a `SKILL.md` with required YAML frontmatter
- Optional validation via `skills-ref` if available in PATH (warnings only)

## Configuration
Create a `.skill-thief.yaml` in your project root:

```yaml
version: 1
install_path: ./skills
skills:
  - name: pdf-processing
    source: git+https://github.com/acme/skills.git
    ref: main
    subdir: skills/pdf-processing
  - name: local-skill
    source: ./third_party/skills-repo
    subdir: skills/local-skill
```

Rules:
- `install_path` optional; default `./skills`.
- `skills` list entries require `name` and `source`.
- `source` accepts git URLs or local paths. `ref` optional; `subdir` optional.

## Usage
```
pip install skill-thief
skill-thief install       # installs all skills
skill-thief install foo   # installs just foo
skill-thief update        # updates all skills
skill-thief list          # shows config and status
```

## BDD Specs
All user-facing behaviors are covered by Behave scenarios in `features/`.

## License
MIT
traintrack-ai 0.1.6
TrainTrack Client: PyTorch training-time evaluation
License: MIT
Requires Python: >=3.9
Keywords: pytorch, llm, evaluation, training, ml

# TrainTrack

**Training-time evaluation and win-rate tracking for LLMs.**

TrainTrack helps you monitor model behavior during training by running automated LLM-as-a-Judge evaluations on every checkpoint.

## Features

- 🚀 **Real-time Metrics**: Get immediate feedback on conciseness, helpfulness, and reasoning quality.
- 📊 **Win-rate Tracking**: Automatically track win-rates against an anchor checkpoint (baseline) or the previous step.
- 📚 **Built-in Benchmarks**: Integrated support for GPQA, MMLU-Pro, IFEval, and TruthfulQA.
- 🛠️ **Seamless Integration**: Works with standard PyTorch loops and HuggingFace Trainer.

## Quick Installation

```bash
pip install traintrack-ai
```

## Minimal Example

```python
from traintrack import TrainTrackHook

# 1. Initialize the hook
hook = TrainTrackHook(
    model=model,
    tokenizer=tokenizer,
    run_name="my-first-run",
    datasets=["reasoning", "helpfulness"]
)

# 2. Capture a baseline (optional)
hook.capture_anchor()

# 3. Add to your training loop
for step, batch in enumerate(train_dataloader):
    # ... training logic ...

    hook.step(step)
```

## Documentation

For full documentation and advanced configuration (custom metrics, rubrics, and category-based evaluation), visit:
[github.com/traintrack/traintrack](https://github.com/traintrack/traintrack)

## Tinker Integration

TrainTrack includes a Tinker inline evaluator integration that can be used with
`evaluator_builders`:

```python
from traintrack import BuildTrainTrackTinkerEvaluator

traintrack_builder = BuildTrainTrackTinkerEvaluator(
    run_name="my-tinker-run",
    categories=["reasoning", "helpfulness"],
    model_name="Qwen/Qwen2.5-1.5B-Instruct",
    eval_every_steps=10,
)

# Add `traintrack_builder` to your Tinker `evaluator_builders` list.
```

If you're using a low-level custom training loop, call:
`evaluator.evaluate_training_step(training_client=..., step=...)`
to let TrainTrack handle scheduling + snapshot + sampling + ingest.

For a runnable single-eval smoke test, see:
`Canary/examples/tinker_sampling_evaluator_example.py`

For low blocking overhead during training, wire a small frequent evaluator into
`evaluator_builders` and larger suites into `infrequent_evaluator_builders`.

For a full training run example (real training + eval every N steps), see:
`Canary/examples/tinker_supervised_traintrack_training.py`

For a low-level Tinker quickstart-style example (Pig Latin with manual
forward/backward updates + TrainTrack eval every N steps), see:
`Canary/examples/tinker_pig_latin_with_traintrack.py`

For a real NoRobots finetune with TrainTrack evaluation on the NoRobots test set
(helpfulness metric, criteria + pairwise_anchor), see:
`Canary/examples/tinker_norobots_traintrack_finetune.py`