semvec/pypi-packages huggingface dataset:
elizaos-plugin-agent-orchestrator 2.0.0a4
Agent Orchestrator Plugin for ElizaOS - orchestrates tasks across agent providers
Requires Python: >=3.11
Keywords: eliza, elizaos, plugin, orchestrator, agents, tasks

# Agent Orchestrator Plugin (Python)

Python implementation of the Agent Orchestrator plugin for ElizaOS.

## Overview

This plugin orchestrates tasks across registered agent providers without performing
file I/O directly - that responsibility belongs to sub-agent workers.

## Features

- Task lifecycle management (create, pause, resume, cancel)
- Provider-based execution model
- Event system for task state changes
- Cross-platform parity with TypeScript and Rust implementations

## Installation

```bash
pip install elizaos-plugin-agent-orchestrator
```

## Usage

```python
from elizaos_plugin_agent_orchestrator import (
    configure_agent_orchestrator_plugin,
    AgentOrchestratorPluginOptions,
    plugin,
)

# Define your agent provider
class MyProvider:
    id = "my-agent"
    label = "My Agent"
    description = "Custom agent provider"

    async def execute_task(self, task, ctx):
        await ctx.append_output("Hello from my-agent")
        await ctx.update_progress(100)
        return TaskResult(
            success=True,
            summary="done",
            files_created=[],
            files_modified=[],
        )

# Configure the plugin before runtime initialization
configure_agent_orchestrator_plugin(
    AgentOrchestratorPluginOptions(
        providers=[MyProvider()],
        default_provider_id="my-agent",
        get_working_directory=lambda: os.getcwd(),
    )
)

# Register the plugin with your runtime
runtime.register_plugin(plugin)
```

## Actions

- `CREATE_TASK` - Create a new orchestrated task
- `LIST_TASKS` - List all tasks
- `SWITCH_TASK` - Switch current task context
- `SEARCH_TASKS` - Search tasks by query
- `PAUSE_TASK` - Pause a running task
- `RESUME_TASK` - Resume a paused task
- `CANCEL_TASK` - Cancel a task

## Provider Interface

Providers must implement the `AgentProvider` protocol:

```python
class AgentProvider(Protocol):
    @property
    def id(self) -> str: ...
    
    @property
    def label(self) -> str: ...
    
    @property
    def description(self) -> Optional[str]: ...
    
    async def execute_task(
        self,
        task: OrchestratedTask,
        ctx: ProviderTaskExecutionContext,
    ) -> TaskResult: ...
```

## License

MIT
elizaos-plugin-acp 2.0.0a4
elizaOS ACP Plugin - Agentic Commerce Protocol for checkout and commerce
Requires Python: >=3.11
Keywords: acp, agents, ai, checkout, commerce, elizaos

# elizaos-plugin-acp

Python implementation of the ACP (Agentic Commerce Protocol) plugin for elizaOS.

## Installation

```bash
pip install elizaos-plugin-acp
```

For development:

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

## Usage

```python
import asyncio
from elizaos_plugin_acp import AcpClient, AcpClientConfig

async def main():
    # Create client from environment variables
    config = AcpClientConfig.from_env()
    client = AcpClient(config)
    
    # Create a checkout session
    session = await client.create_checkout_session({
        "currency": "USD",
        "line_items": [
            {
                "id": "item_123",
                "name": "Widget",
                "unit_amount": 1000,
                "quantity": 2
            }
        ],
        "buyer": {
            "email": "customer@example.com"
        }
    })
    
    print(f"Session ID: {session.id}")
    print(f"Status: {session.status}")
    print(f"Total: {session.totals}")

asyncio.run(main())
```

## Environment Variables

- `ACP_MERCHANT_BASE_URL` (required): Base URL of the merchant API
- `ACP_MERCHANT_API_KEY` (optional): API key for authentication
- `ACP_REQUEST_TIMEOUT` (optional): Request timeout in seconds (default: 30)
- `ACP_API_VERSION` (optional): API version (default: 2026-01-30)

## Running Tests

```bash
pytest
```

With coverage:

```bash
pytest --cov=elizaos_plugin_acp
```

## License

MIT
lifx-async 5.2.0
A modern, type-safe, async Python library for controlling LIFX lights
Requires Python: >=3.10

# lifx-async

A modern, type-safe, async Python library for controlling LIFX smart devices over the local network.

[![CI](https://github.com/Djelibeybi/lifx-async/workflows/CI/badge.svg)](https://github.com/Djelibeybi/lifx-async/actions/workflows/ci.yml)
[![Codecov](https://codecov.io/gh/Djelibeybi/lifx-async/branch/main/graph/badge.svg)](https://codecov.io/gh/Djelibeybi/lifx-async)
[![Docs](https://github.com/Djelibeybi/lifx-async/workflows/Documentation/badge.svg)](https://Djelibeybi.github.io/lifx-async/)

[![Python](https://img.shields.io/badge/python-3.11%20|%203.12%20|%203.13%20|%203.14-blue)](https://www.python.org)
[![PyPI](https://img.shields.io/pypi/v/lifx-async)](https://pypi.org/project/lifx-async/)
[![License](https://img.shields.io/badge/license-UPL--1.0-blue)](https://opensource.org/license/UPL)



## Features

- **📦 No Runtime Dependencies**: only Python standard libraries required
- **🎯 Type-Safe**: Full type hints with strict Pyright validation
- **⚡ Async Context Managers**: Provides `async with` and `await` usage patterns
- **🔌 Connection Pooling**: Efficient reuse with LRU cache
- **🏗️ Layered Architecture**: Protocol → Network → Device → API
- **🔄 Protocol Generator**: generates LIFX protocol `Packets`, `Fields` and `Enum` classes from LIFX public protocol definition
- **🌈 Comprehensive Support**: supports all LIFX smart lighting products including Color, White, Warm to White, Filament, Clean, Night Vision, Z, Beam, String, Neon, Permanent Outdoor, Tile, Candle, Ceiling, Path, Spot, and Luna.


## License

Licensed under the [Universal Permissive License v1.0](https://opensource.org/license/UPL).

Copyright &copy; 2025 Avi Miller &lt;me@dje.li&gt;
shivays-hybrid-recommender-v1 1.0.0
Hybrid ML recommendation engine
Requires Python: >=3.9

# ML Recommendation Engine - Hybrid

[![Python 3.11+](https://img.shields.io/badge/python-3.11+-blue.svg)](https://www.python.org/)
[![PyTorch](https://img.shields.io/badge/PyTorch-2.1-red.svg)](https://pytorch.org/)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)

A **production-grade hybrid recommendation engine** combining collaborative filtering, content-based filtering, and deep learning approaches.

## 🚀 Features

- **Collaborative Filtering**: Matrix factorization, Neural CF
- **Content-Based**: TF-IDF, embeddings
- **Deep Learning**: Two-tower architecture, attention
- **Real-time Serving**: FastAPI inference service
- **A/B Testing**: Experiment framework

## 📁 Structure

```
ml-recommendation-engine-hybrid/
├── src/
│   ├── models/           # ML models
│   ├── data/             # Data processing
│   ├── training/         # Training logic
│   ├── serving/          # API server
│   └── evaluation/       # Metrics
├── tests/
├── notebooks/
└── configs/
```

## 🛠️ Installation

```bash
pip install -r requirements.txt
python -m src.training.train --config configs/hybrid.yaml
python -m src.serving.app
```

## 📄 License

MIT License
shivays-fastapi-gateway-v1 1.0.0
High-performance FastAPI gateway for microservices
Requires Python: >=3.9

# High-Performance FastAPI Gateway

[![Python 3.11+](https://img.shields.io/badge/python-3.11+-blue.svg)](https://www.python.org/)
[![FastAPI](https://img.shields.io/badge/FastAPI-0.109-009688.svg)](https://fastapi.tiangolo.com/)
[![Redis](https://img.shields.io/badge/Redis-7.2-red.svg)](https://redis.io/)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)

A **production-grade API Gateway** built with FastAPI, designed for high throughput, low latency, and ease of extensibility.

## 🚀 Features

- **High Performance**: Built on Starlette and Pydantic for maximum speed.
- **Rate Limiting**: Redis-backed distributed rate limiting (Token Bucket).
- **Caching**: Smart response caching with Redis.
- **Async Architecture**: Fully asynchronous capability for IO-bound operations.
- **Middleware**: Request tracking, unique IDs, structured logging.
- **Scalable**: Dockerized and ready for Kubernetes orchestration.

## 📁 Project Structure

```
backend-fastapi-high-performance-gateway/
├── app/
│   ├── api/          # API Route Controllers
│   ├── core/         # Config, Security, Events
│   ├── middleware/   # Custom Middleware (Rate Limit, Logging)
│   ├── schemas/      # Pydantic Models
│   ├── services/     # Business Logic & External Calls
│   └── main.py       # Application Entrypoint
├── tests/            # Pytest Suite
├── Dockerfile        # Production Docker Image
├── docker-compose.yml# Local Dev Environment
└── pyproject.toml    # Dependency Management
```

## 🛠️ Quick Start

```bash
# Clone the repository
git clone https://github.com/Shivay00001/backend-fastapi-high-performance-gateway.git

# Run with Docker Compose (includes Redis)
docker-compose up --build

# Access Documentation
# Swagger UI: http://localhost:8000/docs
# ReDoc: http://localhost:8000/redoc
```

## ⚡ Benchmarks

Designed to handle 10k+ req/sec on modest hardware with proper tuning.

## 📄 License

MIT License
supabase-ai-app 1.0.0
Production-grade AI application integrated with Supabase
Requires Python: >=3.9

# supabase_app

A new Flutter project.

## Getting Started

This project is a starting point for a Flutter application.

A few resources to get you started if this is your first Flutter project:

- [Lab: Write your first Flutter app](https://docs.flutter.dev/get-started/codelab)
- [Cookbook: Useful Flutter samples](https://docs.flutter.dev/cookbook)

For help getting started with Flutter development, view the
[online documentation](https://docs.flutter.dev/), which offers tutorials,
samples, guidance on mobile development, and a full API reference.
supersearch-db 0.1.1
Python SDK for the SuperSearch Product API
Requires Python: >=3.8

# SuperSearch Python SDK

A simple Python client for the SuperSearch Product API.

## Installation

```bash
pip install supersearch-db
```

## Quick Start

```python
from supersearch import SuperSearch

# Initialize client with your API key
client = SuperSearch(api_key="YOUR_API_KEY")

# Search for products
results = client.search("blue cotton hoodie under 2000 for men", limit=10)

for product in results:
    print(f"{product['title']} - ₹{product['price']}")
```

## API Reference

### `SuperSearch(api_key, base_url=None)`

Initialize the client.

- `api_key` (str): Your SuperSearch API key
- `base_url` (str, optional): Custom API base URL

### `search(query, limit=10)`

Search products using natural language.

- `query` (str): Natural language search query
- `limit` (int): Maximum results (default: 10, max: 250)
- Returns: List of product dictionaries

### `pdp_search(query, limit=10)`

AEO-optimized search for AI agents.

- `query` (str): Natural language search query  
- `limit` (int): Maximum results (default: 10, max: 250)
- Returns: List of detailed product dictionaries

### `suggestions()`

Get example search queries.

- Returns: List of example query strings

## Example Queries

```python
# Filter by attributes
results = client.search("red nike running shoes for women")

# Price filtering
results = client.search("cotton t-shirt under 1500")

# Material + gender
results = client.search("leather jacket for men")

# Get suggestions
suggestions = client.suggestions()
```

## Need an API Key?

Contact us at supersearch00@gmail.com to request access.

## Links

- **PyPI:** https://pypi.org/project/supersearch-db/
iflow-mcp_michaelfromorg-nhl 0.1.0
An MCP server for NHL data.
Requires Python: >=3.11

# MCP NHL

An MCP server to getting NHL data.

Connect to this server via.

```jsonc
// MacOS
{
    "mcpServers": {
        "nhl": {
            "command": "uv",
            "args": [
                "--directory",
                "/ABSOLUTE/PATH/TO/PARENT/FOLDER/nhl",
                "run",
                "nhl"
            ]
        }
    }
}
// Windows
{
    "mcpServers": {
        "nhl": {
            "command": "uv",
            "args": [
                "--directory",
                "C:\\ABSOLUTE\PATH\TO\PARENT\FOLDER\nhl",
                "run",
                "nhl"
            ]
        }
    }
}
```
satellite-telemetry-decoder 1.0.0
Production-grade satellite-telemetry-decoder component
Requires Python: >=3.9

# Space Satellite Telemetry Decoder

[![Python 3.11+](https://img.shields.io/badge/python-3.11+-blue.svg)](https://www.python.org/)
[![Construct](https://img.shields.io/badge/Construct-2.10-red.svg)](https://construct.readthedocs.io/)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)

A **production-grade telemetry decoder** for satellite ground stations. Designed to parse raw binary data streams into structured, human-readable formats using declarative binary structures.

## 🚀 Features

- **Binary Parsing**: Declarative schemas for complex binary data using the `Construct` library.
- **Multi-Frame Support**: Handles CCSDS-like packets and custom telemetry frames.
- **Validation**: CRC and checksum verification for data integrity.
- **Extensible**: Easily add new packet definitions for different satellite subsystems (EPS, ADCS, OBC).
- **Exporting**: Supports exporting decoded data to JSON or CSV for further analysis.
- **Containerized**: Ready-to-use Docker environment.

## 📁 Project Structure

```
space-satellite-telemetry-decoder/
├── src/
│   ├── models/       # Binary definitions (Subsystems, Frames)
│   ├── core/         # Decoder engine and validation logic
│   ├── utils/        # Converters and hex processing
│   └── cli.py        # Command-line interface
├── data/             # Sample telemetry binary files
├── tests/            # Unit and integration tests
├── Dockerfile
├── docker-compose.yml
└── requirements.txt
```

## 🛠️ Quick Start

```bash
# Clone
git clone https://github.com/Shivay00001/space-satellite-telemetry-decoder.git

# Install
pip install -r requirements.txt

# Decode a sample file
python src/cli.py decode data/sample_telem.bin
```

## 📄 License

MIT License
basepak 0.0.114
Iguazio CLI SDK
Requires Python: >=3.9

# basepak

[![PyPI - Version](https://img.shields.io/pypi/v/basepak.svg)](https://pypi.org/project/basepak)
[![Security: Bandit](https://img.shields.io/badge/security-bandit-green.svg)](https://bandit.readthedocs.io/en/latest/)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/basepak.svg)](https://pypi.org/project/basepak)
[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/tomaDev/basepak)
-----

Basepak provides a toolset to simplify CLI utility creation for the Iguazio environment

## Installation

```console
uv pip install basepak
```

### Core Capabilities
- **Task Runner**: Simple framework for execution, retries, error handling, logging and monitoring
- **Kubernetes Operations**: Resource management, file transfer, job orchestration, and template generation
- **Iguazio Platform client**: HTTP API client with session management and retry logic
- **Logging module**: Centralized logging with rich output formatting and sensitive data masking
- **Data Types & Utilities**: Custom types for units, ranges, IP addresses, CLI parameters etc.

### Main Modules
- `tasks`: The task framework.
- `k8s_utils`: Kubernetes resource management and operations
- `platform_api`: Iguazio platform HTTP API abstract class
- `igz_mgmt_handler`: context manager for [Iguazio Management SDK](https://iguazio.github.io/igz-mgmt-sdk/)
- `log`: Enhanced logging with security features
- `units`: Data types for measurements and CLI parameters
- `stats`: Task monitoring and system validation
- `locks`: Run lock functionality to prevent unwanted concurrent script runs


## Quick Start

```python
from basepak import log

logger = log.get_logger()
logger.info('hello from basepak!')
```

## Development

### Setup Development Environment

The project uses `hatch` for management

### Available Scripts
- `hatch run lock`: Update dependency lockfile
- `hatch run upgrade`: Upgrade dependencies
- `hatch run release`: Create and push version tag

### Testing 

Run tests across multiple Python versions:
```bash
hatch test --cover --randomize --all --durations=5
```

### Code Quality

- **Security scanning**: `hatch run scan:scan`
- **Type checking**: `hatch run types:check` (WIP)
- **Coverage reporting**: Integrated with pytest

## Release Process

Releases are automated through GitHub Actions when version tags are pushed. The release workflow validates versions, builds packages, and publishes to both GitHub Releases and PyPI.

## License

`basepak` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.
microservices-core 1.0.0
Production-grade microservices-core component
Requires Python: >=3.9

# Flask Microservices Core

[![Python 3.11+](https://img.shields.io/badge/python-3.11+-blue.svg)](https://www.python.org/)
[![Flask](https://img.shields.io/badge/Flask-3.0-green.svg)](https://flask.palletsprojects.com/)
[![SQLAlchemy](https://img.shields.io/badge/SQLAlchemy-2.0-red.svg)](https://www.sqlalchemy.org/)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)

A **production-ready foundation** for building scalable microservices with Flask.

## 🚀 Features

- **Application Factory**: Modular and testable application setup.
- **Database ORM**: SQLAlchemy 2.0 with migration support (Alembic).
- **Serialization**: Marshmallow for complex object serialization/deserialization.
- **Async Tasks**: Integrated Celery worker for background processing.
- **Containerization**: Docker and Docker Compose ready.
- **Testing**: Comprehensive Pytest suite.

## 📁 Structure

```
backend-flask-microservices-core/
├── app/
│   ├── api/          # API Blueprints
│   ├── models/       # Database Models
│   ├── schemas/      # Marshmallow Schemas
│   ├── services/     # Business Logic
│   └── tasks/        # Celery Tasks
├── migrations/       # Database Migrations
├── tests/            # Test Suite
├── config.py         # Configuration
├── wsgi.py           # Entry Point
├── Dockerfile
└── docker-compose.yml
```

## 🛠️ Quick Start

```bash
# Clone
git clone https://github.com/Shivay00001/backend-flask-microservices-core.git

# Run with Docker
docker-compose up --build

# Run locally
pip install -r requirements.txt
flask db upgrade
flask run
```

## 📄 License

MIT License
animated-pystyle 0.3.1
Animated colored gradient text for ANSI terminals
Requires Python: >=3.8
Keywords: ansi, terminal, animation, gradient, text

# animated_pystyle

`animated_pystyle` is a lightweight Python library for rendering animated, colored text in a terminal using 24-bit ANSI escape codes.

## Install

From PyPI:

```bash
pip install animated_pystyle
```

Or directly from GitHub:

```bash
pip install git+https://github.com/zalcus/animated_pystyle.git
```

## Quick start

```python
from animated_pystyle import animate_text

animate_text(
    text="Animated gradient text!",
    colors=[(255, 0, 255), (0, 255, 255), (255, 255, 0)],
    duration=3,
    speed=2.2,
    spacing=0.35,
    fps=30,
)
```

## Class-based API

```python
from animated_pystyle import AnimatedGradient

animator = AnimatedGradient(
    text="Hello from animated_pystyle",
    colors=[(255, 80, 80), (80, 80, 255), (80, 255, 180)],
    speed=2.0,
    spacing=0.3,
    fps=20,
)

animator.animate(duration=2)
```

## Publish to PyPI

If you maintain this package and want it downloadable via `pip install animated_pystyle`:

```bash
python -m pip install --upgrade build twine
python -m build
python -m twine check dist/*
python -m twine upload dist/*
```

## Notes

- Requires a terminal with true-color support.
- Press `Ctrl+C` to stop long-running animations.
ai-voice-synthesis 1.0.0
Production-grade ai-voice-synthesis component
Requires Python: >=3.9

# AI Voice Synthesis Service

[![Python 3.11+](https://img.shields.io/badge/python-3.11+-blue.svg)](https://www.python.org/)
[![FastAPI](https://img.shields.io/badge/FastAPI-0.109-009688.svg)](https://fastapi.tiangolo.com/)
[![TTS](https://img.shields.io/badge/CoquiTTS-0.22-green.svg)](https://github.com/coqui-ai/TTS)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)

A **production-grade Text-to-Speech (TTS) service** providing high-quality voice synthesis via a robust API. Designed for low-latency synthesis and easy integration into applications.

## 🚀 Features

- **High Fidelity**: Leverages state-of-the-art TTS models (VITS, YourTTS).
- **Multiple Voices**: Support for various speakers and languages.
- **RESTful API**: Simple endpoints for synthesis and voice listing.
- **Real-time Streaming**: Support for streaming audio output.
- **Caching**: Intelligent caching of synthesized audio for repeated text.
- **Containerized**: Ready for deployment with Docker.

## 📁 Project Structure

```
ai-voice-synthesis-service/
├── app/
│   ├── api/          # API route handlers
│   ├── core/         # Configuration and logger
│   ├── services/     # TTS engine integration
│   └── main.py       # Application entrypoint
├── tests/            # Unit and functional tests
├── Dockerfile        # Production build
├── docker-compose.yml# Local development setup
└── requirements.txt  # Project dependencies
```

## 🛠️ Quick Start

```bash
# Clone
git clone https://github.com/Shivay00001/ai-voice-synthesis-service.git

# Set up environment
python -m venv venv
source venv/bin/activate
pip install -r requirements.txt

# Run the service
uvicorn app.main:app --host 0.0.0.0 --port 8000
```

## 📄 License

MIT License
ai-sentiment-platform 1.0.0
Production-grade ai-sentiment-platform component
Requires Python: >=3.9

# AI Sentiment Analysis Platform

[![Python 3.11+](https://img.shields.io/badge/python-3.11+-blue.svg)](https://www.python.org/)
[![FastAPI](https://img.shields.io/badge/FastAPI-0.109-009688.svg)](https://fastapi.tiangolo.com/)
[![Transformers](https://img.shields.io/badge/Transformers-4.37-yellow.svg)](https://huggingface.co/docs/transformers/index)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)

A **production-grade NLP platform** for real-time and batch sentiment analysis. Powered by state-of-the-art transformer models (BERT, RoBERTa) and optimized for high-throughput enterprise use cases.

## 🚀 Features

- **Hybrid Analysis**: Choice of lightweight VADER/TextBlob or heavy-duty Transformer models.
- **Async Processing**: Celery-backed batch processing for large datasets.
- **RESTful API**: Fast and well-documented API endpoints.
- **Observability**: Prometheus metrics and structured logging.
- **Caching**: Redis integration for frequent query results.
- **Scalability**: Designed for horizontal scaling with Docker.

## 📁 Project Structure

```
ai-sentiment-analysis-platform/
├── src/
│   ├── api/          # FastAPI routes and middleware
│   ├── core/         # Model loading, Processing logic
│   ├── models/       # NLP model abstractions
│   ├── tasks/        # Celery worker tasks
│   └── main.py       # Application entrypoint
├── tests/            # Unit and integration tests
├── Dockerfile
├── docker-compose.yml
└── requirements.txt
```

## 🛠️ Quick Start

```bash
# Clone
git clone https://github.com/Shivay00001/ai-sentiment-analysis-platform.git

# Run with Docker
docker-compose up --build
```

## 📄 License

MIT License