This repository is the **Dependency Injector** library for Python, a mature and widely-used dependency injection (DI) and inversion-of-control (IoC) framework. It provides a comprehensive set of provider types (Factory, Singleton, Resource, Configuration, etc.), declarative and dynamic containers for organizing providers, and a wiring mechanism that automatically injects dependencies into functions and methods using the `@inject` decorator and `Provide`/`Closing` markers. The library is designed to decouple application components, improve testability, and manage configuration and resource lifecycles in a structured way. The core implementation is written in Cython (`.pyx` files) for performance, with pure-Python fallbacks and type stubs. The architecture is modular: providers are composable building blocks, containers assemble them, and wiring connects them to application code. The library integrates with popular web frameworks (FastAPI, Flask, Django, Aiohttp, Sanic, Starlette) and supports both synchronous and asynchronous modes. It also includes a configuration provider that can load settings from YAML, JSON, INI, environment variables, Pydantic models, and plain dictionaries, with environment variable interpolation and type casting. Key entry points are the `Provider` hierarchy (e.g., `Factory`, `Singleton`, `Resource`), `DeclarativeContainer` and `DynamicContainer` classes, and the `inject` decorator from the wiring module. The library is primarily a development dependency used at build/import time to wire up application components. It has no runtime external dependencies beyond Python itself, though optional integrations (Flask, Aiohttp, etc.) require those frameworks. The extensive test suite and documentation make it a reliable choice for projects needing explicit dependency management.
multidict is a high-performance, dual-implementation (C extension and pure Python) multi-value mapping library for Python, designed primarily for HTTP headers and URL query strings. It provides `MultiDict`, `CIMultiDict` (case-insensitive), read-only proxy variants, and the `istr` case-insensitive string subclass. The C extension, built with hand-written C and aggressive optimization, delivers O(1) lookups, insertion-order preservation, and thread-safe lock-free readers under CPython's free-threading mode. The public C API capsule enables other C extensions to create and manipulate multidicts directly. The codebase exhibits exceptional engineering discipline: behavioral parity between the two implementations, extensive test coverage including property-based (Hypothesis), concurrency stress, memory leak, and benchmark regression tests, plus a structured changelog with towncrier. While tightly coupled to CPython internals and carrying significant maintenance burden from free-threading support, the core data structure patterns and concurrency primitives are elegantly designed and potentially reusable in other C extension projects.
maxapi is an async Python SDK and bot framework for the MAX messenger platform. It provides a high-level client (`Bot`) for all MAX Bot API endpoints, an event-driven dispatcher with router hierarchy (`Dispatcher`/`Router`), composable filters (magic filter `F`, `Command`, `StateFilter`, etc.), middleware chains, a finite state machine (FSM) with multiple backends (memory, Redis), and webhook integrations for aiohttp, FastAPI, and Litestar. The library is heavily inspired by aiogram but adapted to MAX API specifics such as attachment types, callback payloads, and deep linking. It includes extensive utility code for formatting (HTML/Markdown), inline keyboard building, VCF parsing, and time helpers. The codebase is well-structured with Pydantic v2 models for all API entities, rigorous retry logic, and a comprehensive test suite covering unit, integration, and webhook scenarios. While not a standalone application, it serves as a foundational component for building production-ready MAX bots.
LedFx is a networked LED light effect controller that synchronizes multiple addressable LED devices (e.g., WLED, LIFX, Nanoleaf, Art-Net, DDP) to real-time audio analysis. It runs as a Python asyncio application with a built-in aiohttp REST API and a prebuilt React frontend served on port 8888. The system captures audio from system loopback, microphone, or network streams (Sendspin), processes it through FFT/melbank/beat detection, and drives audio-reactive effects on virtual LED strips and matrices. It also integrates with now-playing services (MPRIS, SMTC, Sendspin) to extract album art gradients and apply them to effects. The architecture is plugin-based: effects, devices, integrations, and API endpoints are registered via a `BaseRegistry` pattern with voluptuous schema validation. The core runtime (`LedFxCore`) orchestrates device discovery, virtual management, scene/playlist systems, and configuration persistence. The codebase is well-structured with clear separation of concerns, but some modules (e.g., `core.py`, `virtuals.py`) are large and handle multiple responsibilities. The project is actively maintained with comprehensive CI/CD, extensive test coverage (including API integration tests), and detailed documentation for users and developers.
This repository is a full-stack self-hosted media download manager and library preparation layer centered on yt-dlp. The backend is implemented in Python using aiohttp, SQLite (via SQLAlchemy), and includes a structured feature-based architecture (auth, presets, tasks, conditions, downloads, streaming, notifications, ytdlp integration). The frontend is a Nuxt 3 / Vue 3 single-page application with comprehensive i18n support. Core capabilities include automated download scheduling with cron-like task definitions, conditional filtering, Cloudflare challenge solving, real-time WebSocket updates, streaming via on-the-fly HLS transcoding with hardware acceleration fallback, and a browser extension for quick URL submission. The codebase demonstrates good engineering practices: event bus for decoupled communication, singleton-based service containers, repository pattern for data access, custom migration framework, and extensive async test coverage. Notable external dependencies are yt-dlp (core downloader), ffmpeg (transcoding), curl_cffi (impersonation), and apprise (notifications). While the architecture is modular and well-organized, there is some code duplication across CRUD repositories and migration files, and tight coupling to yt-dlp internals via custom patches. The project is actively maintained with frequent commits, a large test suite, and clear containerization support.