semvec/pypi-packages huggingface dataset:
equanimus-llm-orchestrator 1.0.0
Orchestrator of conversational flows with LLMs in multiple modes, such as copilot, clone, RAG, and transcription.
Requires Python: >=3.12
Keywords: AI agent, LLM, orchestrator, copilot, transcription, clone, RAG

# LLM Orchestrator

Orquestrador de fluxos conversacionais com Modelos de Linguagem (LLMs) em múltiplos modos, incluindo **copiloto**, **clone**, **RAG (Geração Aumentada por Recuperação)** e **transcrição**.

## 🚀 Visão Geral

`llm_orchestrator` é uma biblioteca que gerencia interações com LLMs através de uma interface unificada. Ele carrega e configura modelos de linguagem e de embedding, define modos conversacionais e executa fluxos usando pipelines baseados em agentes inteligentes.

## ✨ Funcionalidades

- ✅ Integração fácil com diversos provedores de LLM  
- 🧠 Suporte a múltiplos modos de conversa:
  - `copilot`: respostas assistivas  
  - `clone`: simula histórico de mensagens anterior  
  - `rag`: gera respostas com base em documentos recuperados  
  - `transcription`: processa e responde a áudios/textos transcritos  
- ⚙️ Orquestração de workflows com agentes  
- 🧩 Suporte a embeddings para casos de uso avançados  

## 🧰 Instalação

```bash
pip install llm_orchestrator
```

## 🧠 Modos de Conversa
| Modo            | Descrição                                        |
| --------------- | ------------------------------------------------ |
| `copilot`       | Comportamento assistivo geral                    |
| `clone`         | Responde com base no histórico de mensagens      |
| `rag`           | Usa documentos externos para melhorar a resposta |
| `transcription` | Projetado para lidar com entrada de áudio        |

## 📂 Estrutura do Projeto
```
llm_orchestrator/
├── init.py # Inicialização do pacote
├── README.md # Documentação principal do projeto
├── requirements.txt # Dependências do projeto
├── config.py # Configurações globais e carregamento de env
├── run_chat.py # Script principal para executar conversas
├── adapters/ # Integrações com LLMs e embeddings
├── agents/ # Agentes e definição dos fluxos principais
├── chat_prompts/ # Templates de prompts para os modos de chat
├── connectVDB/ # Conexões com banco de dados vetorial (VDB)
├── core/ # Utilitários centrais, constantes e helpers
├── document_loaders/ # Carregadores de documentos (PDFs, textos, etc.)
├── engine.tldr/ # Engine principal (ex: fluxo de TLDR)
├── modes_pretrained/ # Modos de comportamento pré-treinados
```
## 🤝 Contribuindo

Contribuições são bem-vindas! Sinta-se à vontade para abrir uma issue ou enviar um pull request com melhorias.

## 📄 Licença
Licença MIT
hack4u-test02726 5.1.0
Una biblioteca para consultar cursos de hack4u

# Hack4u Academy Courses Library

Una biblioteca Python pra consultar cursos de la academia Hack4u.

## Cursos disponibles:

- Introduccion a Linux
- Personalizacion de Linux
- Introduccion al Hacking

## Instalacion

Instala el paquete usando `pip3`:

```python3
pip3 install hack4u
```

## Uso Basico

### Listar todos los cursos

```python3
from hack4u import list_courses

for course in list_courses():
    print(course)
```

### Obtener un curso por nombre

```python3
from hack4u import get_course_by_name

course = get_course_by_name("Introduccion a Linux")
print(course)
```

### Calcular duracion total de los cursos

```python3
from hack4u import total_duration

print(f"Duracion total: {total_duration()} horas")
```
sv-simpleparser 0.5.2
Easy-To-Use SystemVerilog Parser
Requires Python: <4.0,>=3.10.0
Keywords: SystemVerilog, Verilog, Parser

[![PyPI Version](https://badge.fury.io/py/sv-simpleparser.svg)](https://badge.fury.io/py/sv-simpleparser)
[![Python Build](https://github.com/ericsmacedo/sv-simpleparser/actions/workflows/main.yml/badge.svg)](https://github.com/ericsmacedo/sv-simpleparser/actions/workflows/main.yml)
[![Documentation](https://readthedocs.org/projects/sv-simpleparser/badge/?version=stable)](https://sv-simpleparser.readthedocs.io/en/stable/)
[![Coverage Status](https://coveralls.io/repos/github/ericsmacedo/sv-simpleparser/badge.svg?branch=main)](https://coveralls.io/github/ericsmacedo/sv-simpleparser?branch=main)
[![python-versions](https://img.shields.io/pypi/pyversions/sv-simpleparser.svg)](https://pypi.python.org/pypi/sv-simpleparser)
[![semantic-versioning](https://img.shields.io/badge/semver-2.0.0-green)](https://semver.org/)

[![Downloads](https://img.shields.io/pypi/dm/sv-simpleparser.svg?label=pypi%20downloads)](https://pypi.python.org/pypi/sv-simpleparser)
[![Contributors](https://img.shields.io/github/contributors/ericsmacedo/sv-simpleparser.svg)](https://github.com/ericsmacedo/sv-simpleparser/graphs/contributors/)
[![PRs welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat-square)](https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/proposing-changes-to-your-work-with-pull-requests/creating-a-pull-request)
[![Issues](https://img.shields.io/github/issues/ericsmacedo/sv-simpleparser)](https://github.com/ericsmacedo/sv-simpleparser/issues)
[![PRs open](https://img.shields.io/github/issues-pr/ericsmacedo/sv-simpleparser.svg)](https://github.com/ericsmacedo/sv-simpleparser/pulls)
[![PRs done](https://img.shields.io/github/issues-pr-closed/ericsmacedo/sv-simpleparser.svg)](https://github.com/ericsmacedo/sv-simpleparser/pulls?q=is%3Apr+is%3Aclosed)


# Easy-To-Use SystemVerilog Parser

* [Documentation](https://sv-simpleparser.readthedocs.io/en/stable/)
* [PyPI](https://pypi.org/project/sv-simpleparser/)
* [Sources](https://github.com/ericsmacedo/sv-simpleparser)
* [Issues](https://github.com/ericsmacedo/sv-simpleparser/issues)

## Features

* Extract Port Lists
* Extract Parameters
* Extract Submodule Instances and their connections
* `ifdef` support
* Standards: `IEEE 1800-2009 SystemVerilog`

## Limitations

* **No Syntax Checks** - Source Code files must be syntactically correct
* **No Full Parser** - This parser intends to be simple and just extract some information from the source code. **Fast and Simple.**

## Installation

Installing it is pretty easy:

```bash
pip install sv-simpleparser
```

## Authors

* [Eric Macedo](mailto:ericsmacedo@gmail.com)
* [Daniel Jakschik](mailto:iccode17@gmail.com)

## Usage

See [Usage Documentation](https://sv-simpleparser.readthedocs.io/en/stable/usage/)
axonode 0.0.0a0
Work-in-progress graph-memory engine
Requires Python: >=3.9

# Axonode

> **Graph-structured long-term memory layer for Retrieval-Augmented LLMs**  
> _Work-in-progress — API not yet stable_

[![PyPI version](https://img.shields.io/pypi/v/axonode?color=informational)](https://pypi.org/project/axonode/)
[![License](https://img.shields.io/github/license/AXONODE-DEV/axonode)](LICENSE)

---

## Why Axonode?

* **Neural–style graph storage** – typed nodes & edges mimic axons/dendrites, not flat key–value blobs.  
* **Token-budget optimisation** – automatic chunking, clustering and summarisation keep context windows small.  
* **Pluggable RAG pipeline** – slot in OpenAI, Anthropic, Llama 2/3, etc., behind a single retrieval interface.  
* **Embeddings-agnostic** – use any vector backend (Faiss, PGVector, Pinecone, etc.).  
* **Python-first** – minimal deps, zero-config `pip install axonode` to get started.

---

## Quick start

```bash
pip install axonode==0.0.0a0   # placeholder version

python -m axonode.cli ingest ./docs/*.pdf
python -m axonode.cli chat
```

> ⚠️ **Alpha quality** – the commands and import paths will change.

---

## Roadmap

| Milestone | Status |
|-----------|--------|
| MVP graph schema & local storage | ✅ DONE |
| PDF + ChatGPT ingest | ⏳ IN PROGRESS |
| REST / WebSocket API | 🔜 |
| Cloud-hosted demo | 🔜 |
| 1.0 stable release | 🛣️ |

---

## How it works (30 seconds)

```
┌── Ingest ──┐   ┌──────── Graph store ───────┐   ┌─ Retrieval + Context ┐
│  Files     │ → │  Nodes: Chunk | Concept   │ → │  Prompt w/ citations │
│  Chat logs │   │  Edges: TAGS | RELATES_TO │   └──────────────────────┘
└────────────┘   └───────────────────────────┘
```

---

## Contributing

1. Clone the repo and `poetry install` / `pip -e .`  
2. Run `make test` (pytest + coverage).  
3. Open a PR against **main**.

See **CONTRIBUTING.md** for coding-style & commit-message guidelines.

---

## License

This project is licensed under the **MIT License** – see [`LICENSE`](LICENSE).

---

## Citation

If Axonode helped your research, please cite:

```bibtex
@software{axonode_2025,
  author       = {Erez Azaria},
  title        = {Axonode},
  year         = 2025,
  url          = {https://github.com/AXONODE-DEV/axonode},
  version      = {0.0.0a0}
}
```

---

> _Questions? Open an [issue](../../issues) or join our Discord: **discord.gg/XXXXXX**_
speech-server 0.1.1
FastAPI wrapper for Chatterbox TTS
Requires Python: <3.13,>=3.10
Keywords: speech, tts, fastapi, chatterbox-tts, kokoro-onnx

# 🗣️ Speech Server – TTS API with Chatterbox & Kokoro

<!-- start intro -->
This project provides a FastAPI-based HTTP server for generating speech audio using [Chatterbox TTS](https://github.com/chatterbox-voice/chatterbox-tts) or [Kokoro ONNX](https://huggingface.co/kokoro-ai).
<!-- end intro -->

---

<!-- start quick_start -->
## 🚀 Quick Start

### 1. Clone the Repo

```bash
git clone https://github.com/Ladvien/speech_server.git
cd speech_server
```

### 2. Install Dependencies

We use [Poetry](https://python-poetry.org/) for managing dependencies.

```bash
poetry install
```

### 3. Run the Server

```bash
poetry run speech-server
```

Or:

```bash
poetry run uvicorn speech_server.server.app:app --host 0.0.0.0 --port 8000
```

Access:

- API: http://localhost:8000
- Docs: http://localhost:8000/docs
<!-- end quick_start -->

---

<!-- start usage -->
## 🧪 Example Usage

### Generate Audio from Text

```bash
curl -X POST http://localhost:8000/tts \
     -H "Content-Type: application/json" \
     -d '{"text": "Hello, world!", "voice": "default"}' \
     --output hello.wav
```

### List Voices

```bash
curl http://localhost:8000/voices
```
<!-- end usage -->

---

<!-- start config -->
## ⚙️ Configuration

Use `config.yaml`, environment variables, or Python config classes like `TTSServerConfig`.

```yaml
tts_service: chatterbox  # or 'kokoro'
voice: default
log_level: info
sample_rate: 24000
```
<!-- end config -->

---

<!-- start features -->
## 🧠 Features

- ✅ Chatterbox TTS (PyTorch)
- ✅ Kokoro ONNX (lightweight, GPU-ready)
- ✅ Voice cloning support
- ✅ Streaming endpoint
- ✅ `/voices` API
- ✅ YAML config support
- ✅ Ready for Docker or cloud deployment
<!-- end features -->

---

<!-- start extension -->
## 🧩 Extend It

To add a new TTS engine, subclass:

```
speech_server.common.base_tts_service.TTSService
```

Then register it via your config loader.
<!-- end extension -->

---

<!-- start dev -->
## 🛠 Dev Tools

### Lint, Format, Test

```bash
poetry run black .
poetry run isort .
poetry run pytest
```

### Type Check

```bash
poetry run mypy src/
```
<!-- end dev -->

---

<!-- start docs -->
## 📚 Documentation

Build local docs:

```bash
cd docs
make html
```

Docs live in `/docs/source/` and are rendered via [ReadTheDocs](https://readthedocs.org/).
<!-- end docs -->

---

<!-- start license -->
## 📄 License

MIT © C. Thomas Brittain
<!-- end license -->
threadtools 1.0.2
Tools for synchronizing threads using better locks and signals.
Requires Python: >=3.13

# threadtools
Support for signals and better locks in native Python.

# Inspiration
PyQt lets you "emit" signals that have function callbacks tied to them. Why shouldn't we have that in native Python?

# Typical Usage
## Signals
```python
import time
from threading import Thread

from threadtools import Signal, process_events


class ThreadedProcess:
    """Mimics a long-running process that updates its progress."""

    def __init__(self):
        self.somethingHappened = Signal[str]()
        self.countChanged = Signal[int]()
        self.finished = Signal()  # no typing implies no arguments to `emit()`

    def run(self):
        for i in range(1, 6):
            time.sleep(1)
            self.countChanged.emit(i)
            if i == 3:
                self.somethingHappened.emit("Something happened!")
        self.finished.emit()


threaded_process = ThreadedProcess()
thread = Thread(target=threaded_process.run)
# connect signals
threaded_process.countChanged.connect(print)
threaded_process.somethingHappened.connect(print)
threaded_process.finished.connect(lambda: print("Done!"))
# run the thread
thread.start()
# you must call `process_events()` to receive signals from other threads
# `emit()` was called from a different thread than `connect()`, so the callbacks are queued
while thread.is_alive():
    process_events()

# prints:
# 1
# 2
# 3
# Something happened!
# 4
# 5
# Done!
```
## DataLock
```python
from threading import Thread

from threadtools import DataLock

# DataLocks are generic; they support any type
LOCKED_INTEGER = DataLock(0)
LOCKED_STRING = DataLock("Hello, World!")


class DataAccessor:
    """Accesses and mutates data that is behind a lock."""

    def __init__(self, int_value: int):
        self.int_value = int_value

    def run(self):
        # using a context manager locks the lock and returns the stored data
        with LOCKED_INTEGER as locked_int:
            # reading data
            print(locked_int)

            # writing data
            
            # BAD!!
            # this does not change the value inside the lock
            # (Python references don't work that way)
            locked_int = self.int_value
            
            # good
            # DataLocks are reentrant; this will not cause a deadlock
            LOCKED_INTEGER.set(self.int_value)

            # you can also get the data inside the lock using `get()`
            print(LOCKED_INTEGER.get())
        # the lock is unlocked here, at the end of the context


first_accessor = DataAccessor(1)
first_thread = Thread(target=first_accessor.run)

second_accessor = DataAccessor(2)
second_thread = Thread(target=second_accessor.run)

first_thread.start()
second_thread.start()

first_thread.join()
second_thread.join()

# if `first_thread` is started first, prints:
# 0
# 1
# 1
# 2
```

# Thread Safety
`Signal`s are thread-safe as long as they are connected correctly. See the `connect()` method for more details.