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.
This is a production-grade Kubernetes CSI (Container Storage Interface) driver for JuiceFS, a cloud-native distributed POSIX filesystem. It enables dynamic and static provisioning of JuiceFS volumes as Kubernetes PersistentVolumes. The system consists of multiple microservices running in a Kubernetes cluster: a CSI Controller (StatefulSet) that handles volume creation, deletion, expansion, and snapshots; a CSI Node (DaemonSet) that manages mount and unmount operations; an optional webhook component for sidecar injection and validation; and a Dashboard (Deployment+React frontend) for management and troubleshooting. It supports three mount modes: default mount-pod (dedicated pod for JuiceFS client), sidecar (inject into application pod via mutating webhook), and process (deprecated). The codebase demonstrates a strong command of Kubernetes controller patterns, with sophisticated features like graceful upgrade of mount pods via FUSE file descriptor passing, time-ordered caching for dashboard APIs, and a builder pattern for mount pod creation. The architecture is well-modularized but has a large configuration surface.
Mollusk is a lightweight test harness for Solana programs, designed to execute program ELFs in a minified Solana Virtual Machine (SVM) without a full validator runtime. It provisions Agave's program cache, transaction context, and invoke context directly, enabling fast, deterministic testing of single instructions, instruction chains, and full transactions. The repository is organized as a Cargo workspace with core harness logic (mollusk-svm), a result validation crate (mollusk-svm-result), a benchmarking crate (mollusk-svm-bencher), a CLI tool (mollusk-svm-cli), fuzz fixture infrastructure, and bundled SPL program helpers (memo, token, token-2022). Key architectural patterns include a pluggable AccountStore trait for stateful testing, a flexible Check builder for result validation, and a Compare enum for cross-version execution comparison. The CLI supports fixture replay, benchmarking, and generating compute unit reports. The harness also supports fuzz fixture generation (both Mollusk and Firedancer formats) via protobuf schemas, enabling regression testing and cross-implementation comparison. While primarily a testing library, the inclusion of fuzz fixture infrastructure and benchmarking tools gives it a hybrid character similar to data research pipelines for test generation and analysis.
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.
This repository provides PyTorch implementations of Google Research's MetNet family of models for short-term weather forecasting, including MetNet, MetNet-2, MetNet-3, MetNetPV (photovoltaic), and MetNetSingleShot. The codebase is structured as a Python package with modular layers (ConvGRU, ConvLSTM, CoordConv, FiLM conditioning, MaxViT, partition attention, etc.) and data preprocessing utilities (Gaussian satellite merging, point-to-grid translation, MRMS normalization). The models are designed to ingest satellite imagery and radar data and output precipitation or other weather variables. The repository also includes pretrained weights hosted on HuggingFace Hub and a test suite covering layers, data utilities, and model forward/backward passes. While primarily an application library, it contains reusable data engineering components for geospatial data fusion.
Local Browser is a Chrome extension that enables on-device AI-powered web automation using WebLLM. The system implements a two-agent architecture (Planner + Navigator) where users enter natural language tasks in the popup UI, which are then executed through a loop of DOM observation, action planning, and browser interaction. All AI processing occurs locally on the device with no cloud APIs or API keys required. The extension features site-specific state machines for common tasks like Amazon shopping and YouTube navigation (minimizing LLM calls), obstacle detection for login requirements/CAPTCHAs/out-of-stock items, and robust action execution with retry logic and semantic selectors. Built with React, TypeScript, Vite, and CRXJS for MV3 Chrome extension architecture.
git-backup is a CLI tool written in Go that backs up all Git repositories from GitHub and GitHub Enterprise (including GitLab) to local storage. It uses the go-git library to perform bare or non-bare clones without requiring the git CLI. The configuration is driven by a YAML file that supports Go templating for environment variable injection. The tool discovers repositories via the provider APIs using configurable filters (owned, starred, collaborator, org member) and excludes specific repos or namespaces. Pagination is handled automatically. It supports Docker deployment with UID/GID mapping. The code is well-structured with clear separation of providers (GitHub, GitLab) behind a common RepositorySource interface. It is a focused, standalone backup solution that does not require external dependencies beyond the binary itself.
SAIL-Recon is a feed-forward Transformer-based system for large-scale Structure-from-Motion (SfM) and visual localization. It processes input images or video to estimate camera poses, depth maps, and generate 3D point clouds without iterative optimization. The architecture combines a Vision Transformer backbone with an alternating attention aggregator for temporal modeling and specialized heads for camera, depth, and track predictions. The system includes both command-line and Gradio-based demo interfaces for end-to-end 3D reconstruction, along with evaluation scripts for standard benchmarks (TUM, 7Scenes, Tank&Temple, etc.). While research-oriented, it is packaged as a usable application with clear entry points and modular components.
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.
gd-plug is a plugin manager for Godot 4.x, inspired by vim-plug. It provides a command-line interface to install, update, and uninstall Godot plugins (Git repositories) based on declarations in a `plug.gd` configuration file. The tool supports parallel operations, version freezing (by branch, tag, or commit), development vs. production modes, and clean uninstallation. The architecture centers around a single script (`plug.gd`) that extends Godot's SceneTree, processing command-line arguments and managing plugin lifecycle through Git operations and file system manipulations. Key features include dependency tracking via a local configuration file, threaded parallelism for efficient operations, and robust file handling with safety checks to prevent overwriting user files.
This is the official ActiveAdmin demo application, a Ruby on Rails 8.1 monolith deployed on Render that showcases ActiveAdmin 4.0.0.beta23 capabilities. The application manages a conference domain (venues, rooms, conferences, sessions, speakers, and session-speaker assignments) entirely through an ActiveAdmin admin panel mounted at /admin, with Devise authentication for admin users and a catch-all route rendering a static 404 page. There is no public-facing API or customer-facing UI beyond a redirect from root to the admin panel; the app's entire purpose is to demonstrate ActiveAdmin's feature set in a realistic domain.
This Laravel package provides GDPR compliance features for applications. It includes an endpoint for users to download their personal data (after re-authentication), traits for automatic encryption and decryption of model attributes, and a mechanism for exporting model data in a portable JSON format. Additionally, it offers a command to clean up inactive users based on a configurable retention period, using a strategy pattern to allow customization of the cleanup logic. The package is designed to be framework-agnostic within Laravel, relying on Eloquent models and standard Laravel features.
The system is a Home Assistant addon that enables backup creation and synchronization with OneDrive. Built with ASP.NET Core and Blazor Server, it provides a web UI for configuration and monitoring, scheduled backups with retention policies, file synchronization, and exposes Home Assistant sensor entities for status monitoring. The architecture follows a layered design with separate services for backup management, file synchronization, and external API integrations (Home Assistant and Microsoft Graph). Key entry points include Program.cs for application startup and the Orchestrator for coordinating scheduled tasks. Data flows involve creating backups via the Home Assistant API, uploading to OneDrive via GraphHelper, and synchronizing file changes bidirectionally.
This repository contains a single PHP file (index.php) that implements a minimalistic file hosting service. It allows users to upload files via HTTP POST (e.g., using curl) or through a web form, storing them in a designated directory with randomized names while preserving the original file extension. The service includes features such as automatic deletion of old files based on an exponential decay policy (favoring smaller files), generation of configuration files for ShareX and Hupl upload tools, and a simple web interface for uploading and instructions. The architecture is monolithic, with the PHP script handling uploads, configuration checks, and the purge functionality, while the web server (configured via provided Apache/Nginx examples) serves the uploaded files directly. Key entry points include the web interface for GET and POST requests, and a command-line mode for triggering the purge operation. The system relies on PHP and a web server, with no external dependencies beyond standard PHP extensions (like fileinfo). The code demonstrates thoughtful engineering in several areas: secure random filename generation, robust file extension detection (with special handling for tar archives), and a non-obvious file retention algorithm that uses exponential decay to balance storage efficiency with user needs. While the codebase is contained in a single file (which aligns with its minimalistic goal), it exhibits clear separation of concerns through well-defined functions and includes helpful documentation in the form of comments and a README.
Sequelize UI is a browser-based code generation tool that allows users to visually design database schemas and generate a complete Node.js/TypeScript project using the Sequelize ORM. The application is built as a Next.js static export (client-side only) with React and Tailwind CSS, storing schemas and user preferences in localStorage. It provides a rich UI for defining models, fields, and associations, and then generates a full project scaffold including model classes, migrations, configuration files, and a minimal server. The codebase is well-structured with a clear separation between core domain logic (schema types, file tree, code generation utilities), a pluggable framework interface for code generation, and a comprehensive set of UI components. It includes extensive unit tests and end-to-end migration tests against real databases. While primarily an application, it also contains example schemas and snapshot-based test fixtures that serve as data for verifying code generation correctness.
psc is a CLI tool that uses eBPF iterators to scan processes and file descriptors with Google CEL for filtering. It provides container context for processes by integrating with Docker, containerd, CRI-O, and Podman runtimes. The architecture is modular with separate packages for BPF data unmarshaling, container management, CEL filtering, and output formatting (table/tree). Key strengths include its efficient kernel-level access via eBPF, expressive CEL-based filtering, and intelligent container context propagation to child processes.
ruby-nmap is a Ruby library that provides programmatic access to the nmap network scanning tool. It consists of two main components: 1) A command-line interface builder (Nmap::Command) that allows Ruby programs to configure and execute nmap scans with full access to nmap's options through a Ruby DSL, and 2) An XML parser (Nmap::XML) that converts nmap's XML output into navigable Ruby objects representing hosts, ports, services, OS detection results, and script output. The library acts as a bridge between Ruby applications and the nmap executable, handling the complexity of command-line argument construction and XML parsing while providing an idiomatic Ruby interface. The project is actively maintained with recent commits, comprehensive test coverage, and support for multiple Ruby versions.
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.
This repository contains a Tailwind CSS plugin that adds 3D transform capabilities. The plugin provides utility classes for 3D transformations (scale, rotate, translate on X, Y, Z axes) and 3D animations (bounce, spin, bounce-and-spin). It supports both modern CSS properties (rotate, scale, translate) and legacy transform syntax for backward compatibility. The architecture follows Tailwind's plugin pattern, with modular organization separating animations, utilities, and helper functions. The plugin integrates with Tailwind's configuration system to allow customization of values and works by registering utility classes and animations that generate appropriate CSS when processed by Tailwind.