This repository is a curated list of awesome Python testing resources, organized by category (assertions, BDD, code coverage, fake data, fixtures, mocking, property-based testing, etc.). It is not a software application or data pipeline; it is a reference list of tools, libraries, and resources for Python testing. The repository contains no executable code; its primary content is a README.md file with links and brief descriptions. The CI workflows ensure link validity and spelling. It is a well-maintained, community-driven resource that serves as a comprehensive directory for Python testing tools and practices.
FileCodeBox is a file and text sharing service built with FastAPI and Tortoise ORM. It allows users to upload files or text accessible via short codes, with features including time/count-based expiration, chunked uploads, pre-signed URLs for direct cloud storage uploads, and an admin dashboard for management. The architecture uses a modular design with separate apps for base functionality and admin, storage abstraction for multiple backends (local, S3, OneDrive, WebDAV, OpenDAL), and background tasks for cleanup. Key entry points include main.py (FastAPI setup), apps/base/views.py (public sharing endpoints), and apps/admin/views.py (admin interfaces). The service demonstrates solid engineering practices with reusable components like storage abstraction and security headers, though some areas like settings management and rate limiting show opportunities for improvement in distributed environments.
Nextflux is a modern RSS reader client designed for the Miniflux server. It is a single-page application built with React 19, Vite 6, and TailwindCSS 4, featuring a three-pane layout for browsing feeds, articles, and reading content. The application emphasizes offline capabilities through IndexedDB storage via Dexie, allowing users to read feeds without an internet connection. The architecture employs a decentralized state management approach using Nanostores, with separate stores for authentication, settings, feeds, articles, and synchronization. Data persistence is handled through a repository pattern over Dexie, providing typed access to IndexedDB collections. The application synchronizes with the Miniflux server via a background sync service that handles incremental updates, conflict resolution, and optimistic UI updates. Additional features include a global audio player for media attachments, AI-powered article summarization, and extensive customization options through a settings panel. Notable reusable components include a utility library for class merging and helper functions, a dynamic font loading hook, and a custom hook for detecting reduced motion preferences. The UI is built upon a migrating component library (transitioning from HeroUI/Radix to @base-ui/react and then to a Luma/shadcn-based system), demonstrating a commitment to modern UI practices. The codebase exhibits strong modularity and separation of concerns, with clear boundaries between UI, state management, data access, and service layers.
This repository contains the backend API for a trading platform, specifically QuantDinger. It handles strategies, indicators, and market data, and has various tests and scripts for ensuring the quality and functionality of the code.
aiomysql is an async MySQL client library for Python, built on top of PyMySQL and asyncio. It provides a full set of MySQL database operations with async/await syntax, including connection pooling (connection recycling, configurable min/max sizes), multiple cursor types (buffered, unbuffered, dict, JSON-deserializing), and optional SQLAlchemy integration via an async engine, connection, and transaction wrappers. The library is designed for production use and supports various MySQL authentication plugins. It is not a runnable application but a library to be imported into async Python projects.
easytrader is a Python library for automating Chinese stock trading. It supports multiple broker types through three parallel branches: (1) Windows desktop GUI automation using pywinauto for brokers like ιΆζ²³, εζ³°, ε½ι, etc.; (2) Web API trading for Xueqiu (ιͺη) portfolio rebalancing; (3) Official QMT SDK integration via miniqmt for θΏ ζ-based brokers. Additionally, it provides strategy following from JoinQuant, RiceQuant, and Xueqiu platforms, enabling mirroring of simulated trades into real accounts. The architecture uses a factory pattern (easytrader.use() and easytrader.follower()) to create broker-specific trader instances, with abstract base classes (ClientTrader, WebTrader, BaseFollower) implementing common operations like buy/sell/query. A Flask-based remote server mode allows separation of trading client and strategy execution machines. The code is well-structured with clear separation of concerns: config files define broker-specific UI control IDs, strategy patterns for grid data extraction (Copy, Xls) and data refresh (Switch, Toolbar) allow customization without changing core logic. The follower framework includes command expiration, slippage modeling, and multi-user/multi-strategy support. The miniqmt module wraps the proprietary xtquant SDK into the same easy-to-use interface. While the desktop GUI components are Windows-only and tightly coupled to specific broker client binaries, the web-based trader and follower modules are more portable. The library has been actively maintained for years with a large user base (10k+ stars), though some dependencies like pywinauto 0.6.6 and Python 3.6+ show signs of technical drift.
This repository implements a dual-console emulator targeting PlayStation 3 (RPCS3) and PlayStation 4 (RPCSX/Orbis). The codebase is a large C++ project with a modular architecture: kernel emulation layers for both consoles (syscalls, threads, memory management), CPU emulation (PPU/SPU for PS3, GCN for PS4), GPU emulation (RSX for PS3 with OpenGL/Vulkan backends, GCN shader compiler for PS4), audio backends (Cubeb, FAudio, ALSA), input handlers (DS3, DS4, XInput, PS Move, etc.), network emulation (RPCN, UPnP), and a custom overlay UI system. The project is under active development with frequent commits, though many PS3 firmware modules remain as stubs or placeholders. The architecture separates PS3 and PS4 emulation into distinct directories (`rpcs3/` and `rpcsx/`), sharing a common utility library (`rx/`) that provides synchronization primitives, memory management, and debugging tools. The GPU emulation is particularly sophisticated, featuring a custom shader intermediate representation (IR) for AMD GCN instructions with optimization passes and SPIR-V/GLSL backends. The codebase also includes a comprehensive serialization framework for savestates, a YAML-based configuration system, and a texture cache predictor for GPU performance. Key entry points include the main emulator executables (built from `rpcs3/` and `rpcsx/`), the kernel syscall handlers in `kernel/orbis/` and `kernel/cellos/`, the GPU renderers in `rpcs3/Emu/RSX/` and `rpcsx/gpu/`, and the PS3 firmware HLE modules in `ps3fw/`. External dependencies include Vulkan, OpenGL, FFmpeg, WolfSSL, SDL2, libusb, and several audio libraries. The project is primarily a software application for console emulation, with significant reverse-engineering and research components.
Fish Speech is a production-grade multilingual text-to-speech system with a dual-autoregressive transformer architecture (4B parameter slow AR for temporal semantics, 400M fast AR for residual codebooks). It supports real-time voice cloning from short reference audio (10-30s), multi-speaker multi-turn generation, and fine-grained prosody/emotion control via natural language tags. The system is deployed through multiple interfaces: a Gradio web UI, a React-based modern web UI, a production ASGI API server (Kui) with streaming support, and command-line tools for inference and batch processing. Its architecture is modular: a TTSInferenceEngine orchestrates reference loading, LLM inference, and VQ decoding; an RVQ audio codec (10 codebooks, ~21 Hz frame rate) compresses audio; and the dual-AR model is structurally isomorphic to standard LLMs, enabling reuse of inference optimizations like paged KV cache and RadixAttention. The repository also includes training infrastructure (Lightning + Hydra) with LoRA fine-tuning, protobuf-based dataset pipelines, and a comprehensive i18n framework. While primarily a deployable application, it retains strong research character with published papers, benchmark results, and custom model implementations.
DeepTeam is a comprehensive LLM red-teaming framework that systematically generates adversarial attacks (single-turn and multi-turn) against target AI applications and evaluates their responses for security vulnerabilities. It covers 50+ vulnerability types (bias, toxicity, PII leakage, SQL injection, jailbreaking, etc.), 20+ attack strategies (prompt injection, base64 encoding, crescendo jailbreaking, etc.), and aligns with industry frameworks (OWASP, MITRE ATLAS, NIST, EU AI Act). The system uses an LLM-as-a-judge evaluation pattern, cost tracking, and multi-turn progression logic. It also provides guardrails for runtime safety, a static code scanner for AI security issues, and trace scanning for agentic systems. The architecture follows a library pattern with an optional CLI, and integrates tightly with the deepeval framework and the Confident AI cloud platform. While the framework is functionally rich and the base abstractions are well-designed, the codebase suffers from massive copy-paste duplication across concrete vulnerability and metric implementations, leading to maintenance overhead and latent bugs.
SpecialK is a Windows DLL injection payload that enhances and fixes PC games. It intercepts graphics APIs (D3D8/9/11/12, Vulkan, OpenGL, DXGI), input (XInput, HID), system calls, and storefront overlays (Steam, Epic, GOG Galaxy) to provide performance monitoring overlays, HDR tone mapping, DLSS/NVIDIA NGX support, ReShade integration, hardware monitoring, and game-specific compatibility patches. The monolithic architecture relies on a MinHook-based hooking engine, ImGui for its control panel, and PresentMon for ETW-based frame timing analysis. It is actively maintained with recent commits and CI/CD, but carries a large vendored dependency footprint (Boost, GLM, LZMA, etc.) and includes some game-specific fragile hacks. Among the most reusable components are a thread-safe lazy global singleton (`SK_LazyGlobal`), a robust INI parser with encoding and change detection, and a command variable system with range and listener support.
Pyversity is a Python library for fast diversification of search and retrieval results, providing five algorithms (MMR, MSD, DPP, COVER, SSD) to re-rank items balancing relevance and diversity. Its core API is minimal: `diversify(embeddings, scores, k, strategy, diversity)` returns a `DiversificationResult` with selected indices and scores. The library is dependency-light (only NumPy required) and designed for easy integration into retrieval pipelines. The repository also contains a comprehensive benchmark suite evaluating strategies on real-world recommendation datasets (MovieLens-32M, Last.fm, Amazon Video Games, Goodreads), with metrics for both relevance (nDCG, MRR) and diversity (ILAD, ILMD). Benchmark results show DPP offers the best diversity gains with minimal relevance loss. While primarily a software library, the inclusion of reproducible benchmarks, research citations, and systematic evaluation makes it a hybrid application/research repository.
This repository provides a protoc plugin (`protoc-gen-go_gapic`) that generates idiomatic Go client libraries (GAPIC) from protobuf service definitions. The generator produces both gRPC and REST (REGAPIC) transport implementations, including client structs, pagination iterators, long-running operation wrappers, call options, routing headers, and example snippets. It is the primary tool used by Google to generate Go client libraries for Google Cloud APIs. The architecture is a single binary invoked by protoc, with core generation logic in `internal/gengapic/`, protobuf type utilities in `internal/pbinfo/`, an auto-indenting printer in `internal/printer/`, and golden-file test validation. It supports Bazel build rules and Docker packaging, and includes integration tests against a live `gapic-showcase` server. The codebase is well-structured with feature flags, selective generation, mix-in support (IAM, Locations, LRO), and extensive test coverage via golden files.
discrawl is a Go CLI application for archiving and searching Discord data. It syncs messages from the Discord API, imports Discord desktop cache, stores raw JSON in SQLite via sqlc-generated code, and provides subcommands for sync, publish, subscribe, share import, and remote status. It also exports/imports compressed JSONL snapshots with manifests and commits them to a Git snapshot repo using NUL-delimited path-only commits to preserve unrelated staged work. The repository is primarily an application, but it also vendors agent skills (autoreview, crabbox, discrawl) under .agents/skills, making it a hybrid monorepo.
Acorn is a PHP framework that seamlessly integrates Laravel's core components into WordPress, enabling developers to use Laravel's service container, routing, configuration, caching, and Blade templating within WordPress themes (especially Roots Sage). It provides a custom application bootstrapping process that hooks into WordPress's lifecycle, along with comprehensive asset management (supporting Vite, Bud, and Mix build systems), CLI commands via WP-CLI, exception handling with Whoops integration, and view composers with ACF field support. The codebase is a well-structured library with clean abstractions, extensive test coverage (Pest with snapshot testing), and a devcontainer for integration testing. It is actively maintained with CI workflows to track upstream Laravel foundation updates, though the forked nature introduces moderate technical drift risk.
GoInterruptPolicy is a Windows GUI utility for managing interrupt affinity (IRQ affinity) of hardware devices. It enumerates devices through the Windows SetupAPI, reads their current interrupt policy from the registry, and lets users assign interrupts to specific CPU cores, including Intel P-cores/E-cores, AMD CCDs, and NUMA nodes. The practical goal is reducing interrupt latency for real-time workloads such as gaming and audio processing. The code is Windows-only and packaged as a standalone Go executable with an icon, manifest, and version resources.
Shiori is a Flutter mobile/desktop application that serves as a comprehensive database and toolset for the game Genshin Impact. It provides detailed information on characters, weapons, artifacts, materials, and monsters, along with interactive tools such as an ascension material calculator, wish simulator with pity tracking, banner history analytics, inventory management, custom build planner, tier list builder, and notification scheduler for in-game timers. The app also includes charts and statistics derived from game data, a game code redemption tracker, and backup/restore functionality for user data. It is distributed on Android, iOS, Windows, and macOS, and is localized into over a dozen languages. The architecture follows a clean layered pattern: domain (service interfaces and models), application (BLoC state management with freezed events/states), infrastructure (implementations for file I/O, persistence, networking, and platform services), and presentation (Flutter widgets and pages). Dependency injection is handled via GetIt, and local persistence uses Hive CE. Remote resource updates are downloaded on demand from an external API. The codebase makes heavy use of the BLoC pattern with sequential event processing, and includes extensive unit and integration tests covering blocs, services, and UI flows. Although primarily an application, Shiori is heavily data-driven: all game content is loaded from JSON resource files, and the app provides analytical charts (element distribution, banner reruns, birthdays, ascension stats) that are computed from the data. This hybrid nature means the repository contains both application code and data-processing logic. The codebase demonstrates strong software engineering practices with reusable shared widgets, service abstractions, and a consistent pattern for file-based data services. The project is actively maintained with recent commits and an active issue tracker. However, there is some technical drift: the CI workflow pins Flutter 2.10.2 while the project configuration targets 3.41.6, and some localization files contain incomplete translations. Several TODO comments and commented-out code indicate areas of ongoing work. Overall, the codebase is well-structured and suitable for reuse of its isolated components.
This repository provides an 'Agent Skill' for AI coding assistants, embodying the thinking framework of Charlie Munger. The core artifact is SKILL.md, which defines a structured persona with mental models (multidisciplinary thinking, inversion, Lollapalooza effect), decision heuristics, expression rules (dry humor, blunt language), and an agentic workflow that mandates real-time web research before answering. The supporting references/ directory contains deep research on Munger's ideas, biases, and expression style. Although classified as an 'application' due to its installable skill format (via the Agent Skills protocol), it is essentially a knowledge and prompt engineering artifact, not a traditional software application. It is designed to be used within AI agent runtimes (Claude Code, Codex, Cursor, etc.) and demonstrates high craftsmanship in role-play instruction and error handling.
This is the production iOS client for Anytype, a local-first, end-to-end-encrypted knowledge-management platform. The code (not the README) shows a substantial consumer application: a block-based rich-text document editor with slash menus, markdown, mentions, and embeds; an object model with typed relations/properties; set/dataview views (table, kanban, gallery, list) with filters/sorts; spaces with sharing, invites, and participant permissions; chat/discussions with reactions, attachments, unread badges, and typing indicators; home-screen widgets; a Web-publishing flow; StoreKit membership tiers; and a share extension plus lock-screen widget. It is unmistakably an application, not a data/research repository, though it contains data-centric subscription/search infrastructure. Architecturally, this is a SwiftUI + UIKit hybrid organized as an app target plus local Swift Package Manager modules (ProtobufMessages, Services, DesignKit, AnytypeCore, AsyncTools, LayoutKit, Logger, Assets, NotificationsCore, SharedContentManager). The app is a client to a Go middleware engine ('anytype-heart') communicated over generated SwiftProtobuf RPC commands and real-time event/subscription streams. The presentation layer uses an MVVM + coordinator pattern with @Observable view models, Factory-based dependency injection (Container/@Injected), and a custom path-driven navigation system that bridges SwiftUI paths to a UIKit navigation controller. Core data flows are: middleware events -> protobuf models -> subscription storages/actors -> domain models (BlockInformation, ObjectDetails, PropertyDetails) -> SwiftUI/UIKit view models. Craftsmanship is genuinely good for a large shipping app: modern Swift concurrency (actors, async/await, @Observable, Swift 6 language mode in packages), protocol-driven service abstractions, clean pure-logic components separated for testability, and a meaningful unit-test suite (~150 test files) covering kanban reordering, markdown parsing, unread-badge math, chat threading, and event conversion. However, the codebase carries notable debt: massive generated protobuf files dominate the tree, legacy paths linger (LegacySearchView, old login flow, EditorRouterProtocol marked LEGACY), duplicated abstractions exist across packages (e.g., Weak.swift, CommonError), Swift 6 migration workarounds (@retroactive, @unchecked Sendable) are sprinkled throughout, and the middleware version is pinned to a nightly build, creating schema-drift risk. Several modules have placeholder tests and there are visible typos and half-finished renames. Reuse value is primarily in the local Swift packages rather than the app itself: AsyncTools (multi-subscriber async streams, task utilities), LayoutKit (a fluent Auto Layout DSL), and DesignKit (CachedAsyncImage, text/icon systems) could be lifted into other iOS projects with minimal adaptation. The navigation bridge and subscription-event plumbing are well-designed but too app-coupled for direct extraction. This is a well-maintained, professionally engineered client, but it is not a source of general-purpose data tooling.
xtool is a cross-platform CLI tool and Swift library that enables building, signing, and deploying iOS applications without requiring Xcode. It serves as a replacement for Xcode's build-and-deploy pipeline, supporting macOS and Linux (via Docker). The core library, XKit, provides modules for interacting with Apple Developer Services (certificates, provisioning profiles, devices), implementing Apple's GrandSlam authentication protocol (including Anisette data), code signing via zsign, and device installation via libimobiledevice. The tool also includes a packaging subsystem (PackLib) that resolves SwiftPM dependencies, builds the app, signs it, and bundles it into an .app or .ipa. It supports both free and paid developer accounts and can automatically manage capabilities and provisioning profiles. The architecture is modular, with clear separation between CLI commands (XToolSupport), core library (XKit), and packaging logic (PackLib). It uses modern Swift concurrency (async/await, actors) and dependency injection via swift-dependencies. The codebase includes generated OpenAPI client for Apple's REST API, cross-platform HTTP client abstraction, and utilities for ZIP compression, temporary files, and key-value storage. Examples and integration tests verify functionality. While primarily a developer tool for side-loading and CI/CD for iOS apps, it also exposes the underlying libraries as SwiftPM dependencies for programmatic use. The codebase demonstrates good engineering practices with protocol-oriented design, clean abstractions, and testability. However, it relies on private Apple APIs and a large number of external dependencies, which introduce maintenance risks. The generated OpenAPI client and platform-specific device interactions add fragility, but the core patterns are well-implemented.
Mythic is a full-stack, Docker-orchestrated command-and-control (C2) platform for red-team operations. The Go backend (mythic-docker) is the central server: it exposes a Gin REST/webhook API for operators and agents, maintains state in PostgreSQL, and uses RabbitMQ as an RPC/event bus to communicate with pluggable containerized services (payload type builds, C2 profile servers, translation containers, custom browsers, auth containers). The React/Material-UI frontend (MythicReactUI) consumes GraphQL/Hasura and provides the operator console: callbacks, tasking, file/process browser, payload creation wizards, search, MITRE ATT&CK mapping, reporting, and an eventing workflow engine. At runtime, agents check into C2 profiles and submit encrypted messages that are processed by RabbitMQ action handlers (checkin, get_tasking, post_response, push_c2). Task output is stored as responses and streamed live to the UI over GraphQL subscriptions. Payload builds are dispatched to payload type containers and tracked as build steps. A Go CLI (Mythic_CLI) manages the Docker Compose lifecycle, installed services, backups, database resets, and updates. The repo also contains Docker images for PostgreSQL, RabbitMQ, Hasura, nginx, Prometheus/Grafana, Jupyter, and a Hugo docs site. Architecturally the system is a message-driven monolith coordinating many external containerized services rather than a microservice mesh. The core server is a central coordinator using RabbitMQ RPC and gRPC streaming, and the platform is designed to be extended via third-party payload/C2 containers. Bundled Jupyter notebooks are eventing automation examples, not data-research assets; this is an application repository, not a data-pipeline one. Maintenance is active, with recent commits and CI. However, the codebase shows medium technical drift: copy-paste duplication in RPC handlers, hand-built SQL search strings, a few likely logic bugs, unpinned Docker image tags, and minor stale UI boilerplate. The overall architecture is solid and consistent despite these warts.