This is a single-file Python application that provides a menu-driven interface (via dmenu, rofi, wofi, bemenu, etc.) for managing NetworkManager connections on Linux. It allows users to connect to WiFi, VPN, Wireguard, GSM, Bluetooth, Ethernet, and VLANs; enable/disable networking, WiFi, WWAN, and Bluetooth; delete connections; rescan WiFi; show WiFi passwords; and launch the connection editor. The script uses PyGObject to interact with NetworkManager over D-Bus, with asynchronous callbacks and a GLib main loop. Configuration is stored in an INI file, and the script supports multiple launchers with per-launcher flags for passphrase entry and highlighting. The code is well-structured, with clear separation of concerns (action creation, menu display, async callbacks), and includes workarounds for older library versions. It is a mature, actively maintained tool with a Nix flake for development and a GitHub release workflow.
VolSync is a Kubernetes operator for asynchronous replication of persistent volumes between clusters, supporting multiple data mover backends (rsync, rclone, restic, syncthing, rsync-tls, diskrsync). It defines CustomResourceDefinitions (ReplicationSource, ReplicationDestination) and uses a state machine to manage the synchronization lifecycle. The operator is deployed via Helm chart and includes a kubectl plugin for CLI management. The codebase is primarily Go, with shell scripts for mover containers. It vendors full copies of restic (backup tool) and minio-go (S3 client) for backup and cloud storage support. The architecture follows a pluggable mover pattern with a builder registry, and includes extensive test coverage for controllers, movers, and utilities. While the core operator is well-structured, the vendored dependencies and multiple mover implementations increase maintenance complexity.
Textract is a text extraction library and command-line tool that extracts text from over 30 file formats including PDF, DOC, DOCX, images, audio, email, and structured data formats. The architecture centers around a parser registry that routes files to format-specific parsers based on extension, with a unified Source abstraction handling file paths, bytes, and streams as input. Key entry points are the Python API (textract.process()) and CLI interface (textract.bin.textract). The system relies on external tools like Poppler, Tesseract, and LibreOffice for certain formats while using pure Python parsers for others. The codebase demonstrates strong engineering practices with a clean plugin architecture, comprehensive test suite, and modern tooling (uv, ruff, pytest).
tsfresh is a Python library for automatic time series feature extraction and selection, grounded in the FRESH (FeatuRe Extraction based on Scalable Hypothesis tests) algorithm. It provides over 700 feature calculators spanning statistics, signal processing, and nonlinear dynamics, along with hypothesis-testing-based feature selection using Benjamini-Hochberg or Benjamini-Yekutieli FDR control. The library is designed for integration into scikit-learn pipelines via transformers like FeatureAugmenter and RelevantFeatureAugmenter, and supports parallel/distributed execution via multiprocessing, Dask, or Spark. While primarily a software library (application), it has strong research roots with academic publications and example notebooks demonstrating classification, regression, and forecasting tasks. The codebase is well-structured with clean abstractions for data input normalization (adapters), pluggable parallelization (distributors), and feature settings reconstruction, making it a robust tool for time series feature engineering in production ML workflows.
Telemirror is a Telegram message mirroring application that uses the client API (Telethon) to forward messages between channels, chats, and topics in real-time. It supports one-to-one, many-to-one, and many-to-many mappings with per-direction filter pipelines. The system handles new messages, edits, deletions, and albums, and can operate with either an in-memory cache (backed by an LRU dict) or a PostgreSQL database for persisting message ID mappings. It includes a plugin-based filter system for message transformation (URL removal, keyword replacement, forward formatting, content skipping) and patches Telethon's sending functions to support topic replies. The application is designed to run as a long-lived service with a health endpoint for PaaS deployment (Heroku, Docker). The codebase is well-structured with clean separation of concerns, async-first design, and modern Python features (dataclasses, protocols, enums, pattern matching).
This repository provides a library and tools for training and deploying CNN models (RotNet, RotNetR) to predict the rotation angle of images, primarily designed for cracking rotate captchas. The system includes a training pipeline with customizable dataset preprocessing (random rotations, cropping, normalization), model definitions using ResNet50 and RegNet_Y backbones, a loss function optimized for angular classification (Circular Smooth Label), and an HTTP server for inference. The codebase is well-structured as a Python package with clean separation of concerns, showcasing advanced patterns like generic pipe operators for data transformation composition and context-managed training loops. It is actively maintained and demonstrates solid software engineering practices.
The fabric8io/docker-maven-plugin is a mature Maven plugin that integrates Docker container management into the Maven build lifecycle. It provides a comprehensive set of goals for building Docker images (via Dockerfile, assembly, BuildX, or Jib), pushing/pulling images, starting/stopping containers, and managing volumes, networks, and logs. The architecture follows a layered design with Mojo classes as entry points, a service layer (BuildService, RunService, RegistryService) orchestrating operations, and a low-level DockerAccess abstraction communicating with the Docker daemon via HTTP (Apache HttpClient) over Unix sockets, Windows named pipes, or WSL transports. Configuration is handled through a rich model with builders, property-based resolution, and external handlers (Docker Compose). Authentication supports multiple sources: Maven settings, Docker config, AWS ECR, OpenShift, credential helpers, and system properties. The plugin is widely used in CI/CD pipelines for integration tests and deployment. It is actively maintained with frequent releases and extensive documentation, though some legacy configuration options and disabled integration tests indicate technical debt.
This is the Shadowsocks Android client, a secure proxy/VPN application for circumventing internet censorship. It operates as a multi-module Android project with a core library providing the proxy engine, VPN service, and plugin management, plus separate mobile and TV UI modules. The application routes traffic through a remote SOCKS5 proxy, supporting multiple service modes (VPN, proxy, transproxy), per-app routing via ACL (Access Control List) rules, and native binaries (tun2socks, shadowsocks-rust) compiled via NDK or Rust. Key features include QR code import/export, subscription-based server list updates, and a plugin system that allows third-party native executables (e.g., v2ray, kcptun) to be integrated. The architecture follows Android best practices with Room for persistence, Coroutines for async work, and AIDL for inter-process communication between the UI and foreground services. The codebase is well-organized with extensive testing, CI/CD (CircleCI, GitHub Actions), and localization in over a dozen languages, but shows some technical drift with deprecated APIs and complex native build scripts.
JavaCV is a Java wrapper library for computer vision and multimedia processing, providing bindings to OpenCV, FFmpeg, and other native libraries via JavaCPP Presets. It offers a unified abstraction layer for video capture (FrameGrabber), recording (FrameRecorder), filtering (FrameFilter), and frame conversion (FrameConverter), with concrete implementations for file, stream, camera, and depth sensor sources. The library also includes advanced computer vision capabilities such as geometric and color calibration, image alignment (Gauss-Newton), projective transformations, blob analysis, marker detection for augmented reality, and OpenCL-accelerated image processing. It is primarily a library (not a standalone application), with sample programs demonstrating real-time video streaming, face detection, object tracking, and projector-camera systems. The codebase is large and well-structured, with abstract base classes and reusable patterns, but shows signs of technical drift due to reliance on deprecated OpenCV APIs (IplImage) and legacy native SDKs. Maintenance is active, with frequent updates to keep pace with upstream library versions.
graphql-scalars is a comprehensive library of custom GraphQL scalar types maintained by The Guild. It provides over 50 standardized scalars such as DateTime, EmailAddress, UUID, IP, IBAN, GeoJSON, and many more, each with validation conforming to relevant international standards (ISO, RFC, etc.). The library exports resolvers, type definitions, and mock values for easy integration into GraphQL servers, and supports both CJS and ESM. Each scalar is implemented as a GraphQLScalarType with serialize, parseValue, and parseLiteral methods, ensuring robust runtime validation. The codebase is well-structured, thoroughly tested, and includes tooling for code generation and JSON Schema output. While it is a library rather than an application, its architecture exemplifies a modular, pattern-based approach to building reusable GraphQL schema components.
Config4k is a lightweight Kotlin library that wraps Typesafe Config (HOCON), providing seamless conversion between Config objects and Kotlin types. It offers extension functions `Config.extract<T>` and `Any.toConfig` for deserialization and serialization, supporting data classes, enums, collections, value classes, and a wide range of primitive and JDK types. The library integrates with kotlinx.serialization for HOCON format handling and includes a plugin system (CustomType interface) for extending supported types. It is well-tested, has CI/CD pipelines, and publishes to Maven Central. The architecture is modular with separate readers and serializers per type, making it extensible and maintainable.
Praat is a cross-platform desktop application for phonetic analysis, speech manipulation, and linguistic research. It provides a rich GUI with interactive editors for viewing and editing sounds, spectrograms, pitch, formants, text annotations, and more. The core architecture is a monolithic C++ application built on a custom object system (Thing/oo_* macros) with automatic serialization, a comprehensive preferences framework, and a scriptable interface. The codebase bundles many external libraries (GSL, eSpeak, FLAC, Opus, LAME, PortAudio, WhisperCPP, etc.) for numerical computing, audio I/O, speech synthesis, and machine learning. It includes modules for linear predictive coding (LPC), cepstral analysis, neural networks (FFNet), optimality theory grammar, multidimensional scaling, and EEG/ERP processing. While the code is well-structured and domain-specific, the heavy reliance on external libraries, custom object system, and platform-specific ifdefs introduce maintenance complexity and moderate technical drift.
AnythingLLM is a full-stack, self-hosted AI chat platform designed for Retrieval-Augmented Generation (RAG) over private documents. It provides a web interface where users create workspaces, upload documents (PDF, DOCX, images with OCR, audio, etc.), which are then chunked, embedded, and stored in a vector database (default LanceDB, with support for PGVector, Pinecone, Qdrant, and others). Chat queries retrieve relevant document chunks and feed them to an LLM of choice (supporting 30+ providers including OpenAI, Anthropic, Ollama, and local models via KoboldCPP). The platform also features an extensible agent system (aibitat) with plugins for file system operations, SQL databases, Gmail, Google Calendar, web scraping, image generation, and scheduled jobs. A separate 'collector' microservice handles document ingestion and format conversion, while the 'open-computer' subproject provides a QEMU-based virtual machine for autonomous browser automation. The frontend is a React SPA with multi-user support, role-based access, internationalization, embeddable chat widgets, and a community hub for sharing agent skills, system prompts, and slash commands. The architecture is a monolith (Express server) with the collector as an isolated service, and the open-computer as a standalone CLI/service. It relies on external AI APIs, vector databases, and local storage, making it suitable for both cloud and on-premises deployment.
This is a Go library providing error handling primitives with stack trace capture, wrapping, and cause retrieval. The primary functions are `New`, `Errorf`, `Wrap`, `Wrapf`, `WithStack`, `WithMessage`, and `Cause`. It implements the `fmt.Formatter` interface for detailed error formatting and includes compatibility with Go 1.13's `errors.Is`, `As`, and `Unwrap`. The library is self-contained with no external dependencies beyond the standard library. It is in maintenance mode as the Go standard library has adopted similar functionality, but it remains widely used for its stack trace capabilities. The architecture is a single package with a few types: `fundamental`, `withStack`, `withMessage`, and `Frame`/`StackTrace` for stack representation. The code is well-tested, well-documented, and demonstrates idiomatic Go patterns.
This repository contains Dreamhouse, a Salesforce sample application for real estate property management built with Lightning Web Components (LWC) and Apex. It demonstrates key Salesforce platform capabilities including custom objects (Property__c, Broker__c), flexible page layouts, Lightning Message Service for inter-component communication, and mobile features like barcode scanning and geolocation. The application provides a property explorer with filtering, pagination, map visualization (using Leaflet), and a property creation flow with geocoding via OpenStreetMap. It also includes sample data import, accessibility testing, and comprehensive CI/CD pipelines. The codebase is well-structured with separate Apex controllers, reusable LWC components, and Jest unit tests, representing a professional implementation of Salesforce development best practices. While primarily an application, it includes sample data (JSON files) that could be considered a minor data aspect, but the dominant character is application.
This repository is the Jenkins Job DSL Plugin, a Jenkins plugin that allows users to define Jenkins jobs, folders, views, and configuration files programmatically using a Groovy-based domain-specific language (DSL). The DSL is executed as a build step (the "Process Job DSL Scripts" step) or via Configuration as Code (JCasC), and it generates the corresponding Jenkins XML configuration, which is then applied to the Jenkins instance. The plugin manages the lifecycle of generated items, tracking which jobs/views/config files were created by a seed job and handling updates, renames, and deletions when the DSL script changes. The architecture is a multi-module Maven project: job-dsl-core contains the DSL implementation with a hierarchy of context classes (e.g., StepContext, PublisherContext, ScmContext, WrapperContext) that build XML node trees using Groovy's NodeBuilder. job-dsl-plugin integrates with Jenkins, providing the build step descriptor, script loaders (sandboxed, secure, approval-based), job management (creating/updating jobs via Jenkins API), and actions for tracking generated items. job-dsl-ast provides AST transformations for plugin version checks and deprecation warnings. The DSL is extensible via ContextExtensionPoint, allowing other Jenkins plugins to contribute DSL methods. Key entry points include the DslFactory class (top-level DSL methods like job(), folder(), listView()), the ExecuteDslScripts build step, and the ScriptRequestGenerator that resolves DSL script sources. The primary data flow is: DSL script text → GroovyShell execution → context objects generate XML nodes → JobManagement writes config to Jenkins (or filesystem for testing). External dependencies include the Jenkins core API, numerous optional Jenkins plugins (git, subversion, email-ext, etc.), and the structs plugin for dynamic DSL generation. The plugin is widely used in the Jenkins ecosystem for automating job creation and maintaining configuration as code. It includes a built-in API viewer (JavaScript web app) for browsing available DSL methods and their documentation. The codebase is mature with extensive Spock test coverage, but it carries some technical debt due to its long history and the need to support many Jenkins plugin versions.
Sacremoses is a Python 3 library and CLI tool that reimplements the Moses tokenizer, detokenizer, and truecaser for natural language preprocessing. It provides exact, deterministic text segmentation and normalization for over 30 languages, with specific handling for non‑breaking prefixes, Unicode character properties, and protected patterns. The code is structured as a standard Python package with a `click`‑based CLI entry point, modular tokenization/truecasing modules, and a robust test suite that includes security regression tests. The repository also contains an `audit/` directory documenting a formal security review, with attack scripts and fixed vulnerabilities — a sign of strong engineering discipline for a language‑processing library. A notable architectural decision is the `data‑as‑code` pattern: instead of reading non‑breaking prefix lists and Perl Unicode property files at runtime, the package ships auto‑generated Python modules (`_data_nonbreaking_prefixes.py`, `_data_perluniprops.py`) that contain the same data as dictionary and set literals. This eliminates file‑I/O attack surfaces and simplifies distribution. The generation tool (`tools/generate_data_modules.py`) is itself a clean, reusable script that could be adapted to embed any tabular linguistic resource into a library without runtime file access. The library has undergone a security audit, and several fixes (dependency floors tied to CVEs, bounds on protected patterns, safe temp‑file creation) are baked into the codebase. While the core tokenization logic is a direct port of the Moses Perl script, the implementation shows careful attention to edge cases, concurrency support via `joblib`/`tqdm`, and compatibility with both Python 2 (last supported version) and Python 3. The main technical drift risk comes from static Unicode property snapshots that may lag behind the Unicode standard, but the architecture makes updates straightforward by regenerating the modules. Overall, Sacremoses is a well‑engineered, security‑conscious, production‑ready NLP preprocessing library. It is actively maintained (497 stars, no unresolved Dependabot alerts, recent commits), follows modern packaging conventions, and provides a drop‑in replacement for the Moses tokenizer in Python native code. Its reusable patterns — especially the data‑as‑code embedding and the security audit harness — are valuable for any library that must distribute static linguistic data without introducing file‑I/O vulnerabilities.
jinzhu/now is a lightweight, zero-dependency Go library for time manipulation. It provides comprehensive functions to compute the beginning and end of various time units (minute, hour, day, week, month, quarter, year, half-year), parse flexible date/time strings into Go `time.Time` values, and handle configurable week start days (e.g., Monday vs Sunday) and time zones. The core pattern is a `Now` struct wrapping `time.Time` with a `Config` for customization, enabling fluent calls like `now.With(t).BeginningOfMonth()`. The library is widely used (4.7k stars) and thoroughly tested, with careful DST handling and a clever partial-date parser that merges string components with contextual current time. It is a pure library without external dependencies, targeting Go 1.12+ and suitable for any Go project needing robust time calculations or flexible date parsing.
Vim-R is a Vim plugin that transforms Vim into a full-featured integrated development environment for the R language. It provides interactive R console integration (via built-in terminal or external tmux), omni-completion for R objects and function arguments, an object browser, PDF preview with SyncTeX forward/backward search, and support for R Markdown, Rnoweb, and Quarto documents. The plugin communicates with R through a custom TCP/IP server (vimrserver) written in C and a companion R package (vimcom). While the plugin is superseded by R.nvim for Neovim users, the codebase demonstrates high craftsmanship in its multi-language architecture (VimL, C, R, Python) and remains functional for Vim users. It is not a data analysis tool but an editor enhancement for R development.
pythonocc-core is a Python binding layer for the OpenCASCADE Technology (OCCT) 3D CAD kernel, built around SWIG-generated wrappers. The repository exposes nearly the entire OCCT C++ API to Python through OCC.Core.* modules, covering geometric modeling (BRep, Geom, TopoDS), boolean and fillet operations, STEP/IGES/STL/glTF data exchange, meshing/tessellation, OCAF document persistence, and interactive 3D visualization. On top of the generated bindings, hand-written Python modules in src/Display and src/Extend provide a user-friendly entry point: multi-backend GUI viewers (Qt, wx, tkinter), offscreen rendering, WebGL/Jupyter rendering, topology iterators, shape factories, and high-level file I/O helpers. The repo also contains custom C++ components including a shape tessellator and an OpenGL display wrapper that SWIG alone cannot express. In production, this is a library rather than a standalone application: users import OCC.Core and the high-level helpers to script CAD workflows, convert between file formats, analyze geometry, or build custom visualization tools. The dominant character is clearly an application/library for computational geometry and CAD interoperability, though it carries a data-exchange flavor because STEP/IGES/mesh I/O is a first-class capability. The project is actively maintained, with a recent 8.0.1.2 release targeting OCCT 8.0.1, CI for Windows/macOS/Linux, and a substantial test suite covering geometry, topology, display backends, data exchange, and tessellation. Technical drift is moderate: most of the codebase is generated SWIG surface with occasional OCCT 7.9.0 documentation links, incomplete type stubs, and a legacy WebGL template using unpinned CDN assets, but the core bindings track the current OCCT release and engineering workarounds are actively patched.