pylinac is a Python library for performing TG-142 QA tasks on linear accelerators. It provides high-level analysis modules for common radiotherapy QA tests—VMAT, Winston-Lutz, PIPS, field analysis, planar imaging, log analysis, CT, and star shot—plus lower-level core modules for image handling, gamma analysis, ROI calculations, and structured results. The library is used as a dependency in clinical QA workflows and exposes a consistent API: instantiate an analysis class with a DICOM/log file path, call `.analyze(...)`, then access `.results_data()`, `.publish_pdf()`, or `.plot_analyzed_image()`.
PythonRobotics is a large collection of robotics algorithms implemented in Python, designed primarily for educational purposes and as a companion to a textbook. It covers a wide range of robotics domains including localization (EKF, particle filter, histogram filter), mapping (grid maps, NDT, clustering), SLAM (EKF SLAM, FastSLAM, GraphSLAM), path planning (A*, Dijkstra, RRT variants, PRM, DWA, Frenet, etc.), path tracking (Stanley, LQR, MPC, pure pursuit), arm navigation (inverse kinematics, RRT for arms), aerial navigation (drone trajectory, rocket landing), bipedal walking, inverted pendulum control, and mission planning (state machines, behavior trees). Each algorithm is implemented as a standalone script with a main() function that runs a simulation and visualizes results using matplotlib. The code is not packaged as a library and is not intended for production use; it is a learning resource with clear, readable implementations that reference academic papers. The repository includes extensive documentation in Sphinx RST format, CI/CD pipelines, and a test suite that runs each demo without animation.
XianyuAutoAgent is an AI-powered customer service bot for the Chinese second-hand marketplace platform Xianyu (闲鱼). It connects via WebSocket to Xianyu's messaging service, receives user messages, and generates intelligent replies using a Large Language Model (LLM) with multi-expert routing. The system features intent classification (price negotiation, technical support, general query), dynamic pricing negotiation with gradual concessions and adaptive LLM temperature, context-aware conversation management via SQLite, and a manual takeover mode. It handles authentication via cookies, token refresh, heartbeat, and captcha-triggered cookie re-entry. The bot operates as a long-running async process, suitable for deployment via Docker.
This repository is a well-established Python library (`SpeechRecognition`) that provides a unified interface for multiple speech recognition engines, including Google Speech, CMU Sphinx (PocketSphinx), Vosk, OpenAI Whisper (both local and API), Groq, Cohere, and several others. The architecture follows a facade pattern via a central `Recognizer` class, which handles audio capture (microphone, files) and delegates recognition to pluggable backends – each implemented as a standalone function in the `recognizers/` subpackage and attached to the `Recognizer` instance at import time. The library bundles FLAC encoder binaries for audio conversion, offers a CLI tool for model downloads, and includes comprehensive test suites with audio fixtures in multiple formats. While the code is well-structured and features clean abstractions (e.g., `AudioData` for format conversion, `OpenAICompatibleRecognizer` base class), it exhibits some technical drift: bundled FLAC binaries are outdated (v1.3.2 from 2014), it depends on `audioop` (deprecated in Python 3.13+), and several backend APIs are at risk of deprecation. The library is production-grade (v3.17.0) and widely used, but its reliance on hardcoded API keys and legacy workarounds for old Python versions suggests maintenance is ongoing but with moderate lag. Overall, it is a solid, reusable codebase with several components that could be extracted independently.
Mage is an open-source data pipeline orchestration platform that combines a visual notebook-style editor with a production-grade scheduling and execution engine. The system enables users to build, run, and monitor data pipelines composed of Python, SQL, R, and dbt blocks. Architecturally, it is a full-stack web application with a Python backend (Tornado-based server, SQLAlchemy ORM, REST API) and a Next.js/React frontend with a custom component library. Key entry points include the CLI (`mage` command), the web UI served by `mage_ai/server/server.py`, and the API layer at `mage_ai/api/` which exposes CRUD resources for pipelines, blocks, runs, schedules, users, and integrations. Data flows center around pipeline execution: blocks are connected in a DAG, each block can be a data loader, transformer, or exporter. Execution is handled by a configurable executor (local, K8s, EMR, PySpark) and scheduled via a built-in scheduler or external triggers. The platform integrates with dozens of data sources and destinations through a Singer-based integration framework, supports streaming pipelines, and includes advanced features like RBAC, version control, AI-assisted pipeline generation, and a command center for global search. It depends heavily on external services such as cloud storage (S3, GCS, Azure), databases (PostgreSQL, BigQuery, Snowflake, etc.), and authentication providers (OAuth, LDAP, OIDC).
yewtube is a terminal-based YouTube player and downloader, forked from mps-youtube. It provides a full-featured CLI for searching, streaming, downloading, and managing YouTube content without requiring a YouTube API key. The application uses yt-dlp and youtube-search-python as backends for video extraction and search. It supports multiple media players (mpv, mplayer, VLC), MPRIS integration for desktop media control, Last.fm scrobbling, playlist management (local and YouTube), and various download/transcoding options. The architecture is a monolithic Python application with a command-loop pattern, global state management via a dedicated module, and a plugin-like player abstraction. While the codebase shows its age with some tightly coupled modules and global variables, it contains well-designed components such as a config system with validation, an abstract player interface, and a command registration decorator. The project is actively maintained with recent commits and releases.
FastRTC is a Python library that enables developers to build real-time audio/video streaming applications with minimal code. It provides a high-level `Stream` class that integrates with Gradio for automatic UI generation and supports both WebRTC and WebSocket protocols. The library includes built-in handlers for voice activity detection (VAD) via Silero, speech-to-text via Moonshine, text-to-speech via Kokoro/Cartesia, and turn-taking logic. It also offers TURN credential helpers for Cloudflare, Twilio, and Hugging Face. The architecture revolves around defining a handler function that processes media chunks, wrapping it with turn-taking decorators, and creating a Stream object that handles signaling, connection management, and UI rendering. The codebase is actively maintained with frequent commits and an extensive set of demos integrating with various LLMs and AI services.
DeepTeam is a production-oriented Python library and CLI for red-teaming LLM applications. It does not merely document vulnerabilities; it executes automated adversarial campaigns against a user-supplied model callback, generating attack prompts through LLM-driven templates (single-turn, multi-turn, tree/crescendo jailbreaks), scoring target responses with LLM-as-judge metrics, and aggregating outcomes into risk assessments with CVSS scoring. It also ships a code scanner for static AI-security review, a trace scanner for agent executions, and deployable input/output guardrails. Main entry points are the red_team() Python API and the deepteam CLI (login, run, scan), with YAML configuration driving model selection, vulnerability types, and attack budgets. Architecturally, the repo is a modular Python package built on deepeval: vulnerabilities inherit from BaseVulnerability, all metrics inherit from BaseRedTeamingMetric, attacks implement configurable templates and schemas, and frameworks (OWASP, MITRE ATLAS, NIST, EU AI Act, BeaverTails, Aegis) map risks to pre-built categories. Results flow through RTTestCase objects and can be saved locally as JSON or pushed to the Confident AI platform. The library is dual sync/async and includes progress reporting, cost accumulation, and retry logic. Although it embeds research-style synthetic data generation and dataset-driven framework integrations, the dominant character is an application library/CLI rather than a data research project. Strengths include broad vulnerability and attack coverage, clear base-class contracts, a substantial test suite, and active CI. Weaknesses include heavy copy-paste duplication across 30+ vulnerability, metric, and template modules, tight coupling to deepeval internals, reliance on hardcoded model defaults such as gpt-3.5-turbo-0125, and a known logic bug where is_successful in the metric base class compares instead of assigns, always returning False unless an error is set. Telemetry code also contains hardcoded service keys. Overall, it is a functional, well-documented framework with real reuse value, but it would benefit from deduplication and dependency hardening.
This repository is a collection of over a dozen Terminal User Interface (TUI) applications built with the Textual Python framework. The apps serve educational and recreational purposes: interactive exercises for learning CLI tools (awk, sed, grep), Python regular expressions, Python programming fundamentals, and two original grid-based games (Connect Square, Square Tic Tac Toe). Each app is self-contained, with a similar architectural pattern: an App subclass defines widgets, binds keys, and handles user input. The exercise apps execute user commands via subprocess and compare output to expected results; the regex playground and Python exercises evaluate Python expressions in a sandbox; the games implement AI opponents using weight-based heuristics. The code is clean, well-structured, and consistently styled, though the exercise apps share a large amount of boilerplate. The repository is actively maintained (1015 stars, 0 open issues, recent commits) and demonstrates solid craftsmanship, particularly in the game AI algorithms and custom Textual widget subclasses.
de4py is a comprehensive Python deobfuscation and reverse engineering tool designed primarily for Windows environments. It combines a native PySide6 GUI with a CLI interface to analyze, unpack, and clean obfuscated Python scripts and PyInstaller executables. The core functionality relies on a modular engine architecture that supports multiple deobfuscation strategies, including legacy regex-based detection and the newer 'Onyx' engine which utilizes AST manipulation and local LLM integration for semantic recovery. It also features native C++ components for process injection and behavior monitoring, allowing users to hook into running Python processes for dynamic analysis. The architecture is split between high-level Python logic for AST transformation and low-level C++ code for system interaction. The Python side manages the deobfuscation pipeline, UI rendering, and plugin management, while the C++ side handles DLL injection, API hooking via Detours, and named pipe communication. This hybrid approach provides powerful capabilities but introduces significant platform coupling and dependency on specific Windows APIs and Python versions. The tool is licensed under CC BY-NC-4.0, restricting commercial use. While the codebase demonstrates sophisticated engineering in areas like VM lifting and AST optimization, it carries risks associated with external API dependencies (telemetry, updates), brittle regex signatures for obfuscation detection, and heavy reliance on Windows-specific system calls. It is best suited for security researchers and malware analysts working in Windows environments who require a unified static and dynamic analysis platform.
This repository is a community-driven collection of Streamlit 'extras' — custom components and utilities that extend Streamlit's functionality. It is a Python library (package `streamlit-extras`) that provides over 40 self-contained subpackages, each implementing a specific UI widget, layout helper, or data exploration tool. The architecture is modular: each extra is a subpackage under `src/streamlit_extras/` with a standardized metadata convention (`__title__`, `__desc__`, etc.) and a central `@extra` decorator for registration. Some extras are pure Python wrappers around Streamlit's native APIs (e.g., `grid`, `stateful_button`, `stoggle`), while others are full Custom Components v2 (CCv2) with React/TypeScript frontends built with Vite (e.g., `three_viewer`, `json_editor`, `sigma_graph`). The build system uses Hatch with a custom build hook to compile React frontends during wheel packaging. The gallery app (`gallery/streamlit_app.py`) serves as a demo and documentation explorer. The codebase is well-organized but has several deprecated extras that rely on private Streamlit APIs, and test coverage is limited to metadata validation. Overall, it is a solid, actively maintained library with reusable patterns for Streamlit component development.
Deep Forest (DF21) is a Python library implementing the Deep Forest ensemble learning algorithm, which serves as an alternative to deep neural networks for tabular data. The system provides both classification (CascadeForestClassifier) and regression (CascadeForestRegressor) capabilities through a cascade of decision tree ensembles. Each cascade layer consists of multiple estimators (Random Forest and Extra Trees) whose out-of-bag predictions serve as augmented features for subsequent layers. The architecture includes feature binning for efficiency, early stopping mechanisms, support for custom estimators/predictors, and a partial mode for memory-efficient training on large datasets. The codebase is organized into modular components with clear separation of concerns, including dedicated modules for binning, estimation, layer management, tree implementation, and I/O operations.
This repository implements an automated trading bot for Kalshi prediction markets, leveraging AI models (primarily via OpenRouter) to make directional trading decisions. The system is built as an async Python application with a CLI entry point (`cli.py`), a Streamlit dashboard, and a paper trading mode. It supports multiple strategies: an AI-driven directional strategy using a multi-agent debate pipeline (bull/bear researchers, risk manager, trader), a conservative NO-side safe compounder, market making, and a unified trading system that dynamically allocates capital. The core data flow involves ingesting market data from the Kalshi REST and WebSocket APIs, persisting to SQLite, running AI inference through OpenRouter with fallback chains and cost tracking, executing trades via Kalshi's signed REST API, and monitoring positions with stop-loss/take-profit logic. Risk management is enforced through Kelly criterion position sizing, edge filtering, category scoring, portfolio enforcer, and cash reserves. The codebase also includes performance analysis jobs, a paper trading signal tracker with static HTML dashboard, and a comprehensive test suite. External dependencies include Kalshi API, OpenRouter (with optional xAI and Grok models), SQLite, Streamlit, and various async libraries (httpx, aiohttp, websockets).
Handwrite is a CLI application that converts a scanned handwriting sample into a TrueType font. The pipeline consists of three stages: SHEETtoPNG uses OpenCV to detect and extract individual character images from a grid-based form; PNGtoSVG uses Potrace to convert the PNG images to SVG vector outlines; and SVGtoTTF uses FontForge to compile the SVGs into a font file with configurable metrics, kerning, and bearings. The architecture is a simple sequential pipeline orchestrated by the CLI entry point. External dependencies include OpenCV, Pillow, Potrace, and FontForge. The codebase is well-structured with unit tests, CI, and modern Python packaging (uv, Python 3.14). The character detection module in `sheettopng.py` demonstrates reusable grid-based contour extraction logic.
wrf-python is a specialized Python library for computing over 30 diagnostic meteorological variables from WRF-ARW (Weather Research and Forecasting) model output. It provides a high-level `getvar()` interface that dispatches to Fortran and C computational kernels wrapped via f2py, with OpenMP parallelization for performance. The library handles NetCDF input, staggered grids, map projections, moving nests, and supports multiple plotting backends (Cartopy, Basemap, PyNGL). It is built with scikit-build-core and CMake, requires a Fortran compiler, and includes extensive unit tests comparing results against NCL reference data. The architecture follows a consistent decorator pattern for argument handling, iteration over leftmost dimensions, type casting, and metadata injection, making it a production-grade tool for atmospheric research and operational meteorology.
This is a Python CLI tool for exporting fitness data from Garmin Connect. It authenticates via OAuth (using the garth library), retrieves activity lists, downloads activity files (GPX, TCX, original FIT, JSON), and writes a configurable CSV summary. The architecture is a single monolithic script (gcexport.py) with a small helper module (filtering.py) for tracking downloaded IDs and excluding activities. It supports session persistence, date filtering, activity type filtering, and subdirectory organization. The code is well-structured with unit tests, CI/CD (GitHub Actions), linting (flake8, pylint, black), and a Dockerfile. However, the project is effectively broken due to Garmin's TLS fingerprinting introduced in March 2026, and the maintainer has indicated they will not work on it further. The codebase itself is clean and demonstrates good Python practices, but its utility is currently zero unless Garmin changes its stance.
ChefBoost is a Python library implementing decision tree algorithms (ID3, C4.5, CART, CHAID, regression) and ensemble methods (AdaBoost, Gradient Boosting, Random Forest). It provides a simple API for building models from pandas DataFrames and making predictions. The library handles both categorical and numerical features without requiring preprocessing. Architecture consists of modular components: main interface (Chefboost.py), utilities (commons/), core training algorithms (training/), and ensemble methods (tuning/). Key strengths include proper packaging, unit tests, documentation, and solutions to technical challenges like recursive multiprocessing. The implementation correctly follows standard ML algorithms while providing a usable framework for developers.
This repository contains solutions to Harvard's CS50P (Introduction to Programming with Python) course problem sets, organized by week from Week0 to Week9. Each week features multiple standalone Python scripts that solve specific programming exercises, such as calculating tips, validating license plates, converting time formats, processing CSV files, and generating images or PDFs. The scripts are designed to be run from the command line, typically taking user input via `input()` and producing output via `print()`, with some utilizing external libraries for specialized tasks like emoji conversion, figure generation, or image manipulation. While many scripts are simple and focused on teaching basic programming concepts, several components demonstrate reusable, well-crafted patterns worthy of highlighting. Notable examples include the time-parsing function in Week1/meal.py (converting strings like '7:30 AM' to float hours), the license plate validation logic in Week2/plates.py (enforcing rules on length, character types, and number placement), the CSV transformation script in Week6/scourgify/scourgify.py (splitting 'Last, First' names into separate columns), the Jar class in Week8/jar/jar.py (modeling a container with deposit/withdraw operations), and the time-range conversion function in Week7/working/working.py (converting '9:00 AM to 5:00 PM' to 24-hour format). These components are isolated, self-contained, and could be extracted for reuse in other projects with minimal modification. The repository is actively maintained, with the most recent commit dated 2026-06-04. It relies on a few external libraries (such as `inflect`, `emoji`, `pyfiglet`, `tabulate`, `Pillow`, `validators`, and `fpdf`) for specific functionalities, but the core logic of the highlighted components uses only the standard library. There is no evidence of significant technical debt or outdated dependencies, indicating a low level of technical drift. The codebase serves as an excellent educational resource for beginner to intermediate Python programmers, showcasing practical problem-solving techniques.
This repository is a collection of Odoo Community Association (OCA) addons focused on extending accounting and invoicing functionality in Odoo. It provides over 50 modules that automate invoice processing, manage taxes and discounts, handle refunds and returns, integrate stock operations with invoicing, and enhance partner-specific invoicing workflows. Each module follows standard Odoo module structure with models, views, wizards, and data files, extending core Odoo models like account.move, sale.order, and stock.picking via inheritance. The modules are loosely coupled but may have interdependencies declared in their manifests. The system is designed to be installed within an Odoo instance, with entry points defined in each module's __init__.py and __manifest__.py files. Recent activity (last commit 2026-09-25) and active maintenance indicate a healthy project, though the wide version support (some modules targeting Odoo 9.0c-18.0) requires careful dependency management.
This is the OCA/social repository, a collection of 15 Odoo addon modules for Odoo 18.0 that extend the Odoo Discuss and mail systems with external messaging integrations and social profile features. The core module, `mail_gateway`, provides an abstract framework for integrating external chat platforms (Telegram, WhatsApp, Instagram) into Odoo Discuss via webhooks, enabling bidirectional communication. Concrete gateway modules (`mail_gateway_telegram`, `mail_gateway_whatsapp`, `mail_gateway_instagram`, and `mail_gateway_telegram_standalone`) implement provider-specific APIs, including message sending, template management (WhatsApp), and webhook verification. Additional modules add social media profile fields to partners and companies (LinkedIn, Mastodon), audit activity cancellations and unlinks, control mention suggestions, route unhandled emails to a default thread, and extend marketing campaigns with budget tracking. The repository follows standard OCA addon structure with Python models, XML views, OWL/JavaScript component patches, wizards, security rules, and translations. It is not a standalone application but a set of modules designed to be installed in an Odoo instance.