This is the official Heroku buildpack for Python applications. It implements the standard buildpack lifecycle (detect, compile, release, report) to install a Python runtime and manage dependencies using pip, pipenv, poetry, or uv. It handles Django collectstatic, NLTK corpora downloads, user-supplied hooks (pre/post compile), and Heroku CI. The codebase is a collection of modular shell scripts with a consistent library pattern, extensive integration tests via Hatchet/RSpec, and support for multiple Heroku stacks. It is actively maintained, with Dependabot for dependency updates and CI workflows for every commit. The architecture is straightforward: each lifecycle phase is a standalone script that sources reusable libraries from lib/. While the core logic is specific to Heroku's platform, the library functions (e.g., caching, version resolution, build data reporting) demonstrate good shell scripting practices and could be adapted for other build systems.
Word-Formatter-Pro is a cross-platform desktop application and CLI tool for automatically formatting Word documents (.docx, .doc, .wps, .txt, .md) into a consistent Chinese government/official document style. It is built with Python, uses Tkinter for the GUI, python-docx for document manipulation, and integrates with WPS/Word COM on Windows or LibreOffice on macOS/Linux for legacy format conversion. The application features intelligent detection of headings (four levels), title/subtitle, figure/table captions, attachments, and can perform conservative symbol normalization, table auto-formatting, and blank line compression for text sources. The architecture is well-separated: a core formatting engine independent of GUI, a CLI interface, a configuration module, and a bundled Agent Skill. The code is actively maintained, with regular version releases and built-in unit tests covering critical logic.
chubbyskills is a personal knowledge management CLI toolkit that ingests content from over a dozen platforms (YouTube, Bilibili, X, Xiaohongshu, WeChat, Douyin, Podcasts, etc.), transcribes audio/video locally or via cloud providers, and outputs structured Markdown notes with YAML frontmatter (schema v1). The system is architected as a collection of modular "skills" (one per platform) orchestrated by a unified CLI (`tools/chubby.py`), with shared utilities in `chubby_common/`. It includes an incremental knowledge base indexer using SQLite FTS5 and optional semantic embeddings, an MCP server exposing six tools for AI agent integration, and a deterministic evidence brief generator with integrity validation. Operation is local-first: transcription uses SenseVoice and faster-whisper, video downloading uses yt-dlp, and all processing is designed to work offline. Cloud transcription (Atlas/MuAPI) and LLM enrichment (DeepSeek) are optional extensions. The repository also provides a skill installer, platform smoke testing, output validation, and retry mechanisms with credential redaction. Despite the breadth, the codebase maintains clean separation of concerns, with the shared library standing out as a reusable zero-dependency core.
The conda/constructor repository is a CLI tool for building cross-platform installers from conda packages. It reads a `construct.yaml` configuration file, solves package specifications via conda's API, fetches packages, and generates installer artifacts: shell archives (`.sh`) for Linux/macOS, macOS `.pkg`, Windows `.exe` via NSIS, experimental Windows `.msi` via Briefcase, and Docker images. The architecture is modular with dedicated modules for each installer type, configuration validation (Pydantic + JSON Schema), signing abstraction, and utility functions. Production data flows: construct.yaml → validation → spec solving → package download → payload staging → installer generation + signing + hash outputs. External dependencies include conda, NSIS, Apple pkgbuild, signtool/AzureSignTool/codesign, and Docker. The codebase shows clear separation of concerns, automated CI/CD across platforms, and comprehensive example recipes, though it exhibits moderate coupling to conda internals and some deprecated configuration options.
This repository is a Serverless Framework plugin that enables deploying Python WSGI applications (Flask, Django, Pyramid, etc.) to AWS Lambda via API Gateway or ALB. It automatically converts API Gateway events (v1, v2) and ALB requests into WSGI environ dictionaries, invokes the application, and transforms the response back into the appropriate Lambda proxy format. The plugin also provides a local development server (`sls wsgi serve`), automated dependency packaging from `requirements.txt`, and remote execution commands for Python code, shell commands, Django management commands, and Flask CLI commands. The codebase is split into a Node.js plugin (`index.js`) that hooks into Serverless lifecycle events (packaging, deployment, invoke local) and a set of Python modules (`serverless_wsgi.py`, `wsgi_handler.py`, `serve.py`, `requirements.py`) that handle the actual WSGI conversion, local serving, and dependency installation. The core WSGI adapter (`serverless_wsgi.py`) is a standalone, reusable library that can be used independently of the Serverless framework for any Lambda function needing to handle API Gateway events. The plugin is well-tested with both JavaScript and Python test suites, and follows a clean, modular architecture.
Memo is a Python CLI tool for managing Apple Notes and Apple Reminders directly from the terminal. It uses Click for command-line interface and AppleScript (via osascript) to interact with macOS's Notes and Reminders applications. The application provides commands to list, view, add, edit, delete, move, search, and export notes, as well as manage reminders (list, complete, add, delete, edit). Notes are fetched as HTML from Apple Notes, converted to Markdown for display and editing, and images are handled via a placeholder mechanism to preserve inline images through edit cycles. The architecture is a standard CLI application with helper modules for each operation, caching for notes, and validation for flag combinations. It is well-tested with pytest, uses modern Python 3.13, and has a professional CI/CD pipeline and documentation site.
TheAnimeScripter (TAS) is a production-grade AI video enhancement toolkit specialized for anime content. It performs frame interpolation (RIFE 4.15-4.25 variants, GMFSS, DistilDRBA), super-resolution (30+ architectures via a vendored spandrel fork), restoration, frame deduplication, monocular depth estimation (Depth Anything V2/V3, Video Depth Anything, Limbo), scene-change detection, stabilization, segmentation, and object detection. It ships as a CLI tool (main.py), an Adobe After Effects plugin (src/server/aeComms.py via Socket.IO), and a standalone desktop build (build.py + tools/build_support/). The pipeline is: decode video via FFmpeg or the custom nelux library, stream frames through a FrameWindow sliding buffer, apply dedup → restore → upscale → interpolate stages, then re-encode with configurable codecs, bit depths, and BT.709/BT.2020 color spaces.
This repository is a collection of Odoo modules extending financial reporting capabilities in the Odoo ERP system. It provides standardized financial reports (aged partner balance, general ledger, trial balance, VAT report, etc.), partner statements (activity, outstanding, detailed), tax balance reports, cash flow forecasting, and export functionality in multiple formats (PDF, HTML, XLSX). The architecture follows Odoo's modular pattern with models, views, reports, wizards, and data files. Key entry points are wizard-driven interfaces that collect user parameters and generate reports via QWeb templates or XLSX generators. The system relies on Odoo's core accounting models and reporting infrastructure, with data flowing from user input through ORM queries to report presentation. The codebase demonstrates good reuse through abstract base classes for reports and wizards, reducing duplication across report types.
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).
Framefox is a full-stack Python web framework built on FastAPI and SQLModel, designed for building modern web applications with a focus on developer productivity. It follows an MVC architecture with clean separation of concerns, featuring a robust dependency injection container, comprehensive security system (including JWT, OAuth, CSRF protection, and brute force prevention), form handling and validation, session management, and a powerful CLI for code generation. The framework includes built-in profiling and debugging tools, task queuing capabilities, and email services. Its architecture emphasizes SOLID principles, with well-defined layers for controllers, services, repositories, and entities, making it suitable for both traditional web applications and API-driven projects.
OpenBB is an open-source financial data platform that provides a unified, multi-interface access layer to over 20 data providers (FMP, FRED, CBOE, Yahoo Finance, Intrinio, etc.) through a modular provider-extension architecture. The core library (`openbb_core`) defines a standardized Fetcher pattern (transform_query -> extract_data -> transform_data), Pydantic-based standard models for equities, derivatives, fixed income, economics, and more, and a command routing system exposed via a Python SDK (OBBject), a REST API (FastAPI), a CLI (argparse translator), a desktop app (Tauri + React), and an MCP (Model Context Protocol) server for AI agents. The platform includes domain-specific extensions (equity, crypto, economy, quantitative, technical analysis, charting) and a cookiecutter template for scaffolding new providers or OBBject extensions. While the codebase is large and actively maintained, there is notable technical drift in the form of hardcoded API URLs, mixed sync/async extraction, deprecated endpoints, and code duplication across many provider implementations. The charting extension's plugin-based technical indicator system, the country/exchange validation utilities, and the LRU cache with TTL are high-craftsmanship, reusable components that demonstrate non-obvious software engineering skill.
MediaCrawler is a multi-platform social media data collection tool targeting Chinese platforms: Xiaohongshu, Douyin, Kuaishou, Bilibili, Weibo, Baidu Tieba, and Zhihu. It uses Playwright browser automation to log in (QR code, phone, cookie) and then scrapes posts, comments, and media files based on search keywords, specific post IDs, or creator IDs. The architecture is a monolith with modular platform-specific crawlers, a shared abstract base layer, and a FastAPI backend that provides a WebUI for visual control. Data can be stored in multiple formats (CSV, JSON, JSONL, SQLite, MySQL, PostgreSQL, MongoDB, Excel). Additional features include a robust media downloader with DASH support, proxy rotation, word cloud generation, and privacy-focused anonymization. The codebase demonstrates solid engineering with design patterns (factory, abstract base, mixin), good test coverage, and a clean separation of concerns, though there is some duplication across platform implementations.
This repository is a comprehensive Python tutorial (28k+ stars) covering beginner to advanced topics, with content written in Markdown and published as a static documentation site via MkDocs. The codebase includes a custom tool (`tools/example_runner.py`) that extracts and executes Python code blocks from the Markdown files to verify correctness, integrated into CI. The project also uses modern Python tooling (uv, ruff, pytest) and provides an interactive learning site at learn-py.org. While primarily educational content, the repository demonstrates solid engineering practices with automated testing of examples, dependency management, and CI/CD pipelines.
js-beautify is a production-grade code formatter for JavaScript, CSS, and HTML, available as both a Node.js library/CLI and a Python package. The core architecture is a tokenizer-pipeline: source text is scanned by an InputScanner, tokenized by language-specific tokenizers (JavaScript, CSS, HTML), and then processed by a Beautifier that manages indentation, line wrapping, brace styles, and operator positioning via a stateful flag system. The Output class provides efficient indentation caching and wrap-point management. The tool supports a wide range of configuration options (indent size, brace style, attribute wrapping, template languages) and includes built-in unpackers for obfuscated scripts (P.A.C.K.E.R, JavascriptObfuscator, etc.). A web interface is also provided, built with CodeMirror and RequireJS. The project maintains near-identical JavaScript and Python implementations, sharing test data generated from Mustache templates to ensure parity. The codebase is well-structured with clear separation of concerns (core, language-specific, CLI, web), extensive test coverage (including regression tests for hundreds of GitHub issues), and a mature build/release pipeline. However, the dual-codebase requirement increases maintenance burden, and some parts (e.g., the web UI, Debian packaging) show signs of drift. The large test data files and complex matrix-based test generation add brittleness.
This repository provides `claude-monitor`, a privacy-first CLI application for real-time monitoring of Claude Code usage. It reads local JSONL session logs, computes token consumption, costs, and burn rates, and displays them via a Rich-based terminal UI. The tool supports multiple subscription plans (Pro, Max5, Max20, Custom), integrates with Claude Code's official rate limits via statusline capture, and offers an opt-in persistent usage warehouse for historical analysis. It is distributed as a PyPI package with command aliases `cmonitor` and `ccm`. The architecture is modular, with separate packages for CLI, core logic, data ingestion/analysis, monitoring, output formatting, terminal management, UI components, and utilities. Key entry points include the CLI main module (`cli/main.py`), snapshot builder (`output/snapshots.py`), and monitoring orchestrator (`monitoring/orchestrator.py`). The application is well-tested with over 700 tests covering snapshot, trust-layer, warehouse, UI, timezone, and CLI paths. While primarily an application, it incorporates data engineering patterns such as sessionization, percentile-based limit estimation, and a versioned JSON warehouse. The codebase demonstrates strong craftsmanship with reusable components like the P90Calculator, PricingCalculator, TimezoneHandler, and UsageWarehouse. However, it has some technical drift risks due to hardcoded pricing rates, dependency on Claude Code's internal log format, and experimental API features that may change.
Mouser is an open-source, cross-platform (Windows, macOS, Linux) Logitech mouse remapper that serves as a local, telemetry-free alternative to Logitech Options+. It is a desktop application built with PySide6 and Qt Quick (QML) for the user interface, with platform-specific low-level mouse hooks (WH_MOUSE_LL on Windows, CGEventTap on macOS, evdev+uinput on Linux) to intercept and remap button presses and gestures. The core engine orchestrates per-app profile auto-switching, gesture recognition (swipe detection), a radial actions ring, DPI/SmartShift/haptic feedback control via HID++ protocol, and cross-platform shortcut injection. The application also includes an auto-updater, system tray integration, multi-language support (English, Simplified/Traditional Chinese), and a comprehensive test suite. While primarily a desktop application, it contains some research-like elements such as detailed HID++ protocol reverse engineering and a community-driven device catalog.
DefectDojo is a Django-based vulnerability management platform that aggregates, deduplicates, and tracks security findings from over 200 security scanners (SAST, DAST, SCA, container, cloud, infrastructure). The system ingests scan reports via a standardized parser interface, normalizes findings into a core data model (Product, Engagement, Test, Finding, Location), and provides advanced features such as risk-based prioritization, SLA management, JIRA/GitHub integration, notifications (Slack, Teams, email), role-based access control, and customizable reporting. The architecture is a Django monolith with a REST API (v2 using DRF, v3 using Ninja in alpha), Celery for async task processing (imports, deduplication, JIRA sync, SLA expiry), PostgreSQL with full-text search and audit logging via pghistory, and a containerized deployment with Docker Compose. Key entry points include the parser factory (dojo/tools/factory.py), API viewsets, and management commands. The codebase demonstrates strong software engineering patterns such as a modular parser contract, an abstract location manager for feature-flag-driven migration, and an authorization filter registry, but carries technical debt from a dual API surface and an incomplete migration to a new location model.
Mistral Vibe is a production-grade terminal-based AI coding agent by Mistral AI. It provides an interactive CLI powered by Textual for multi-turn LLM conversations, file editing, shell execution, and subagent delegation. The system is architected around a core agent loop that orchestrates tool calls with a permission system, session management (resume, rewind, fork), and an event-driven checkpointing mechanism for file state snapshots. It integrates with multiple LLM providers (Mistral, Anthropic, OpenAI, Vertex) via a backend adapter pattern, and supports external integrations through MCP (Model Context Protocol) servers, custom hooks, and a skill system. The codebase heavily employs layered configuration, ports/adapters for audio, notifications, and update checking, and includes an app server for IDE integration via the ACP (Agent Communication Protocol). It also features telemetry via OpenTelemetry and GrowthBook-based experiments. The repository is actively maintained with recent commits, a comprehensive test suite (>1400 tests), and CI/CD pipelines for PyPI releases and PyInstaller binaries.
This repository implements a multi-agent AI system for generating comprehensive company research reports. The backend is a FastAPI application that orchestrates a LangGraph-based pipeline of specialized research agents: a grounding node that optionally crawls the company's website, parallel research nodes (company, industry, financial, news) that use Tavily search and LLM-generated queries to gather data, a curator that filters documents by relevance score, an enricher that fetches raw content, a briefing node that generates category-specific summaries using Gemini, and an editor that compiles the final report using GPT-4o. The frontend is a React application with TypeScript and Tailwind CSS that communicates via SSE streaming. The system is primarily a web application with a modular agent pipeline, not a data analysis project.
The Video Autopilot Kit is a Python-based framework for automating the creation of vertical shorts (YouTube Shorts, Reels, TikTok) and long-form videos. It provides three isomorphic production lines (teaching long-form, vertical shorts, interview show) each built as a knowledge layer → mechanical gate → one-command driver. The system centers around an Editkin v4 durable workflow contract that serves as the single source of truth for planning, evidence binding, audit, atomic apply, and render. Key features include an image-first material system requiring verified source media, a unified filter library of 38 reusable presets, and privacy-first design that avoids storing personal data in the repository. The architecture is modular, with specialized modules for asset management, color grading, audio processing, motion assets, art direction, scene auditing, and quality assurance. Entry points include CLI-driven pipelines for shorts (`src/shorts_autopilot.py`), interviews (`src/interview_autopilot.py`), long-form (`src/longform_maker/`), publishing (`src/publish_hub_cli.py`), and competitor teardown (`src/teardown.py`). The system relies on external tools like `ffmpeg`/`ffprobe` for video processing and optional OCR libraries for competitor analysis, with cross-platform compatibility handled via `src/platform_compat.py`. Despite its strengths, the kit faces maintenance challenges due to hardcoded assumptions about directory structures and platform specifications, as well as dependency drift risks from external tools like ffmpeg and OCR libraries. However, the inclusion of a release manager and self-updater helps mitigate some of these risks by providing deterministic builds and update mechanisms.