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.
Dublin Traceroute is a NAT-aware multipath traceroute tool that extends the Paris-traceroute technique to enumerate ECMP load-balanced paths and detect NATs. It forges UDP packets with custom payloads to control the UDP checksum, which is used as a per-flow identifier and embedded in the IP ID field for NAT correlation. The system listens for ICMP Time Exceeded and Destination Unreachable responses, matches them to sent probes using IP ID (IPv4) or payload length (IPv6), and computes a NAT ID from checksum differences. Output is provided in JSON or DOT format for visualization. The repository contains two independent implementations: a primary C++ library/CLI using libtins and jsoncpp, and an experimental Go implementation with IPv6 support and additional tooling (routest for integration testing). The Go implementation demonstrates cleaner separation of concerns with reusable network protocol modules (ICMP, UDP, IPv6) and a layered protocol abstraction.
The hyperlink library is a pure-Python implementation of immutable URLs, designed for correctness and compliance with RFC 3986 and RFC 3987. It provides two main classes: the low-level `URL` class, which requires explicit handling of encoding and decoding, and the high-level `DecodedURL` class, which automatically handles encoding and decoding for ease of use. The library supports parsing, manipulating, and unparsing URLs, including operations on query strings, path segments, and internationalized domain names (IDNA). It is designed to be a drop-in replacement for Twisted's URL type and is tested across a wide range of Python versions (2.6 to 3.9 and PyPy). The architecture centers around the `_url.py` module, which contains the core parsing logic, the `URL` and `DecodedURL` classes, and helper functions for encoding and decoding. The library also includes a compatibility module (`_socket.py`) that provides a cross-platform implementation of `inet_pton` for older Python versions, particularly on Windows. Testing is facilitated by hypothesis strategies in `hypothesis.py` for generating valid URL components. The library has minimal external dependencies, relying only on the `idna` package for IDNA support and conditionally on `typing` for older Python versions. It is well-maintained with a comprehensive test suite and continuous integration setup, though it continues to support legacy Python versions, which introduces some maintenance overhead.
Rivulet is an interpreter for an esoteric programming language of the same name, where code is written using semigraphic characters that form flowing strands. The system parses these visual programs into executable glyphs, interprets them according to unique semantics involving lists, strands, and conditional rollbacks, and can output results as text, numbers, or SVG visualizations. The architecture separates parsing, interpretation, and visualization concerns into distinct modules. While primarily a language implementation, the SVG generator demonstrates reusable visualization techniques.
Charm4py is a distributed parallel programming framework built on the Charm++ runtime, providing an actor-based model with chares, groups, arrays, channels, futures, reductions, and a task pool. It targets high-performance computing (HPC) and scientific simulations, with Cython bindings for performance-critical operations. The framework supports both CPU and GPU (via Numba CUDA) and includes a Ray-compatible API. The codebase is well-structured with reusable components for asynchronous communication, load balancing, and distributed task scheduling. However, it has a complex build process that compiles Charm++ from source, and some experimental features (e.g., pool, object store) may be incomplete. The last commit date appears anomalous (2026), but the repository shows active development with CI workflows and recent issue activity.
TraceAI is a multi-language (Python, TypeScript, Java, C#) OpenTelemetry-based instrumentation SDK for AI/LLM applications. It provides drop-in auto-instrumentation for 50+ LLM providers, agent frameworks (LangChain, LlamaIndex, CrewAI, AutoGen, etc.), and vector databases (Pinecone, ChromaDB, Qdrant, etc.). The core library wraps SDK calls to capture structured spans with semantic attributes (tokens, model, messages, tool calls) and exports them via OTLP to any OpenTelemetry-compatible backend, with a default hosted backend at Future AGI. The architecture is a monorepo with per-framework packages that follow a consistent instrumentor pattern: register a tracer provider, instrument the target library, then make API calls. Key entry points are `register()` (Python/TypeScript), `TraceAI.init()` (Java), and `TraceAI.Register()` (C#). The SDK also includes context attribute propagation, PII redaction, evaluation tags, and configurable masking. While the codebase is well-structured and actively maintained, there is significant duplication across framework instrumentors and some tests rely on heavy mocking, which limits reusability of individual components.
fakesnow is a Python library that provides a local, in-memory fake implementation of the Snowflake database connector. It uses DuckDB as the underlying SQL engine and sqlglot to transpile Snowflake SQL dialect into DuckDB-compatible queries. The library monkey-patches `snowflake.connector.connect` and `snowflake.connector.pandas_tools.write_pandas`, enabling developers to run Snowflake-dependent code entirely locally without a real Snowflake account. It also includes an optional HTTP server that mimics Snowflake's REST API, allowing non-Python clients (JDBC, Go, .NET) to connect. The project is primarily a test double and development tool, with a strong emphasis on behavior equivalence to real Snowflake. It supports a wide range of Snowflake SQL features, including DDL, DML, COPY INTO, MERGE, semi-structured data (JSON), sequences, stages, file formats, and session variables. The codebase is well-structured with a modular transform pipeline, extensive tests, and CI/CD pipelines for release. However, some features are partially implemented or marked as not yet supported, and the project is tightly coupled to evolving dependencies (DuckDB, sqlglot) which may cause drift.
This repository provides a set of command-line tools (gvm-cli, gvm-script, gvm-pyshell) for remotely controlling Greenbone Vulnerability Management (GVM) installations via the Greenbone Management Protocol (GMP) and Open Scanner Protocol (OSP). The tools allow administrators to send raw XML commands, execute Python scripts that interact with the GMP/OSP API, and run an interactive Python shell with pre-configured connection objects. The architecture is modular: a parser module handles argument parsing and connection creation, a config module reads user configuration, a helper module provides utilities like authentication prompting and table formatting, and separate modules implement each CLI tool. The primary data flow is from the user (via CLI arguments or script) through the connection layer to the GVM daemon, with responses returned as XML or formatted output. External dependencies include the python-gvm library for protocol handling, and optionally SSH keys for SSH connections. The codebase is well-structured with clear separation of concerns, comprehensive test coverage, and extensive example scripts demonstrating common administrative tasks such as listing tasks, creating targets, exporting reports, and managing alerts. The project follows semantic versioning, uses modern Python packaging with pyproject.toml and uv, and includes CI/CD pipelines for testing, linting, and deployment to PyPI and container registries. While primarily a management tool, it also includes reusable components like a table formatter, connection factory, and authentication helper that could be extracted for other projects.
HydroShare is a Django-based web application for sharing, managing, and publishing hydrologic data and models. It provides a rich resource management system with support for various file types (NetCDF, GeoTIFF, timeseries, etc.), fine-grained access control (groups, communities, privileges), metadata extraction, and discovery via a Vue.js frontend. The system uses PostgreSQL, Redis, Celery, MinIO (S3-compatible storage), and MongoDB for indexing. It exposes REST APIs for programmatic access and includes background tasks for bag creation, metadata extraction, and DOI registration. While primarily an application, it incorporates data engineering patterns for scientific metadata handling and file type aggregation.
ClawBench is a rigorous execution-first benchmarking framework for evaluating AI agents (particularly OpenClaw) on multi-step tasks. The system orchestrates agent runs through a gateway or containerized native evaluation, scores performance across four axes (completion, trajectory, behavior, advisory judge), and generates detailed diagnostic reports. Its architecture includes a job queue with HuggingFace Dataset persistence, a Gradio web app for interactive leaderboards, and a comprehensive CLI for running evaluations and analyzing results. The framework supports multiple agent runtimes via a pluggable adapter pattern (OpenClaw, Hermes, Claude Code, Codex) and provides a canonical task schema for agent-agnostic task definitions. Beyond basic scoring, ClawBench applies dynamical-systems and statistical methods to agent behavior: trajectory regime classification (trapped, limit-cycle, diffusive), Kaplan-Meier survival analysis, constraint index computation, and variance decomposition. It includes a configuration-space benchmarking system (v0.5) that fingerprints plugin profiles for cold-start prediction and fANOVA factor analysis. The codebase is well-tested with over 60 test files, uses Docker for reproducibility, and includes CI/CD pipelines for automated evaluation campaigns. However, the system is complex and has some hardcoded paths and environment variables tied to specific deployment contexts (Crabbox, OpenClaw gateway), and its heavy dependency on external services introduces maintenance risk. Overall, it is a production-grade benchmark with sophisticated analysis capabilities.
Made With ML is an educational data science project that implements an end-to-end ML pipeline for classifying GitHub repositories into categories (NLP, computer vision, MLOps, other) based on their titles and descriptions. The core data lineage flows from raw CSV datasets (dataset.csv, holdout.csv) through text cleaning, tokenization via SciBERT, and stratified splitting into train/val/test sets, followed by distributed training with PyTorch and Ray Train, hyperparameter tuning via HyperOpt, evaluation with slice-based metrics using Snorkel, and serving through a FastAPI/Ray Serve deployment. The project demonstrates MLOps patterns including MLflow experiment tracking, data validation with Great Expectations, behavioral model testing, and CI/CD via GitHub Actions with Anyscale for cloud execution. The codebase is well-structured with clear separation of concerns across data.py, train.py, tune.py, evaluate.py, predict.py, serve.py, models.py, and utils.py. It includes comprehensive tests at the code, data, and model levels. However, the project shows signs of staleness with pinned dependencies from 2023 (Ray 2.7.0, transformers 4.28.1, torch 2.0.0) that have known security vulnerabilities and compatibility issues with current Python versions. The data pipeline components—particularly the CustomPreprocessor, stratified splitting, and text cleaning—are genuinely reusable patterns. The evaluation framework with slice-based metrics and behavioral tests (invariance, directional expectations, minimum functionality) represents solid ML engineering practice. The deployment configuration is tightly coupled to Anyscale's proprietary platform, limiting portability.
OneForAll is a comprehensive subdomain enumeration and reconnaissance tool designed for security researchers and penetration testers. It aggregates subdomains from over 60 passive sources (certificate transparency logs, DNS datasets, search engines, threat intelligence feeds, and web crawlers), performs active brute-forcing via massdns, and enriches results with DNS resolution, HTTP probing, CDN detection, wildcard filtering, and subdomain takeover risk assessment. The tool is built as a modular Python CLI application, with each data source implemented as an independent plugin inheriting from base classes in `common/`. Output is stored in a SQLite database and can be exported to CSV, JSON, XLSX, and other formats. While primarily an application, the repository also includes curated data files (subdomain wordlists, CDN CIDR ranges, cloud service fingerprints) that are valuable for security research.
Chisel is a collection of LLDB commands for debugging iOS and macOS applications. It provides a rich set of commands to inspect and manipulate the UI hierarchy, view controllers, accessibility, auto layout, animations, and memory. The project consists of Python scripts that define LLDB commands using a custom base class (FBCommand) and a native C/Objective-C framework (Chisel.framework) that enables heap scanning for Objective-C instances. The Python layer evaluates Objective-C expressions in the debugged process, while the native framework uses malloc zone enumeration to find live objects. The architecture is a plugin for LLDB, with commands loaded dynamically from a directory. Key entry points are the LLDB commands themselves (e.g., pviews, pvc, visualize, border, findinstances). External dependencies include LLDB, the iOS/OS X runtime, UIKit, CoreAnimation, and Foundation. The codebase is well-structured but shows some technical drift (Python 2 usage, deprecated imp module, old Xcode project settings).
This is a mature Python library for global optimization of expensive black-box functions using Bayesian optimization. It provides the `BayesianOptimization` class that iteratively fits a Gaussian process regressor (via scikit-learn) to observed function evaluations and uses an acquisition function (Upper Confidence Bound, Expected Improvement, Probability of Improvement, or combined) to propose the next point to evaluate. The library supports constrained optimization, domain reduction, mixed continuous/integer/categorical parameters, asynchronous/parallel optimization, and state persistence. Its architecture is modular: acquisition functions are organized in a strategy pattern, parameters are polymorphic with a base class for custom types, constraints are modeled with separate GPs, and domain reduction is implemented as a transformer. The core algorithm is well-tested and documented, with examples ranging from toy functions to hyperparameter tuning. It is not a research notebook collection or data pipeline; it is a production-grade library intended for integration into optimization workflows.
AutoRest is a production-grade code generation tool that transforms OpenAPI (Swagger) specifications into client SDKs for multiple programming languages, including C#, Java, Python, Ruby, Go, and Node.js. It is the primary tool used by Azure to generate SDKs for Azure services, but it can be used for any REST API. The system ingests OpenAPI 2.0/3.0 documents, validates them, and processes them through a plugin-based pipeline to produce language-specific client libraries. The architecture is built around a directed acyclic graph of pipeline plugins, each responsible for a specific transformation stage (modeling, flattening, naming, emitting). The core engine orchestrates the pipeline, manages configuration loading and merging, and handles extension lifecycle. A virtual file system with source mapping tracks the provenance of generated code back to original spec positions, enabling accurate error reporting and blame tracking. Key entry points include the CLI application at packages/apps/autorest/src/app.ts, the core processing engine at packages/extensions/core/src/lib/autorest-core.ts, and the modelerfour extension that converts OpenAPI to an intermediate code model. The system also includes an experimental path to convert OpenAPI to TypeSpec via the openapi-to-typespec extension. External dependencies include npm for extension management and runtime environments (Java, Python, .NET) for generated code validation. The data flow begins with loading and parsing OpenAPI specs, followed by validation, conversion to a language-agnostic code model, and finally emission of language-specific SDK code. The pipeline supports caching, configuration merging with interpolation, and directive-based customization (e.g., removing operations, renaming components). The codebase is a large monorepo with many interdependent packages, showing signs of long-term evolution and some technical debt.
aiomysql is a pure-Python MySQL/MariaDB client library for asyncio. It is effectively a port of PyMySQL's blocking driver with async I/O, plus an optional SQLAlchemy integration layer ported from aiopg. The primary programmatic entry points are `aiomysql.connect()` and `aiomysql.create_pool()`, which produce `Connection` and `Pool` objects used through `connection.cursor()`, `cursor.execute()`, and async context managers. A secondary entry point is `aiomysql.sa.create_engine()`, which wraps async pools with a SQLAlchemy engine/dialect facade for expression-based queries. The library implements MySQL protocol packet handling, authentication plugins, TLS, `LOAD DATA LOCAL INFILE`, server-side cursors, and result-set decoding. It has no web endpoints, CLI, or data pipelines; it is a dependency library, not an end-user application.
This repository (OSGL) is a curated catalog of open‑source games, game engines, frameworks and tools. It ingests metadata from external APIs (GitHub, GitLab, SourceForge, LibreGameWiki) and transforms them into a collection of structured Markdown files (over 1800 entries). A static site generator (Python + Jinja2 + Bulma) produces a browsable website with alphabetical, genre, platform and inspiration indices. The project provides maintenance scripts (Qt UI, batch validation, screenshot management) and synchronisation modules for keeping the catalog up‑to‑date. It is primarily a data curation and publishing project rather than a runnable application, but its Python tooling demonstrates good engineering for a data pipeline.
ghstack is a Python CLI tool that enables developers to work with stacked pull requests on GitHub. It manages a stack of diffs as separate PRs using a specific branch naming convention (gh/username/N/{base,head,orig}). The tool provides subcommands for submitting, landing, checking out, pulling, cherry-picking, logging, syncing, unlinking, and managing stacked PRs. It interacts with GitHub via both GraphQL and REST APIs asynchronously (aiohttp) and relies heavily on git operations for branch and commit management. The codebase is modular with abstract endpoint classes for testability, a fake GitHub endpoint for offline testing, and a comprehensive test suite using custom pytest collection of .py.test files. Its primary value is enabling the 'stacked diff' workflow on GitHub, which is common in large engineering organizations but poorly supported natively.
SuperCoder is a local-first, open-source AI coding agent with a desktop application (Tauri + Rust + React) and a suite of backend services. The core agent (Rust crate) provides an LLM-driven loop with tool execution (file editing, bash, git, code search), subagent spawning, and an 'Auto' mode where an orchestrator LLM generates plans executed by worker agents. The desktop app offers a rich UI for agent interaction, diff review, file exploration, and permission management. A separate Go-based 'Context Engine' service indexes codebases into vector (Qdrant), graph (FalkorDB), and text stores, enabling semantic code search, dependency analysis, and automated PR review with risk scoring. The repository also includes a legacy v1 backend (Go) with workflow executors for Django/Flask/Next.js code generation and a workspace service for managing isolated development environments. While primarily an application, the context engine introduces data/research elements through its indexing pipelines, retrieval strategies, and code review analytics.
This repository provides a Python CLI tool and Makefile pipeline to scrape all essays from Paul Graham's website (paulgraham.com), convert them to Markdown, and produce an EPUB ebook. The core logic resides in a single script (`graham.py`) that uses `requests`, `BeautifulSoup`, `html2text`, and `htmldate` to download, parse, and date-stamp each essay. A `Makefile` orchestrates the full build: creating a virtual environment, fetching essays, merging them with `pandoc`, and generating the final EPUB with a custom CSS and an iBooks dark-mode patch. The CI workflow (GitHub Actions) runs daily, detects new essays by comparing article counts, and automatically creates a release with the updated EPUB and metadata CSV. The architecture is straightforward—no web server, database, or tests—but the pipeline is robust and well-documented for its single purpose. While the scraper is tightly coupled to Paul Graham's site structure, several components (the iBooks patcher, the footnote conversion function, and the EPUB stylesheet) are cleanly isolated and reusable in other EPUB generation projects.