This repository is a Python library and CLI application for parsing, compiling, and calculating Excel formulas and workbooks entirely outside Microsoft Excel. It loads .xlsx, .ods, and JSON model files, builds a directed acyclic computation graph with the schedula library, and evaluates formulas cell-by-cell with support for array formulas, circular references, custom functions, LAMBDA/LET, unit conversions, and sub-model extraction. Primary APIs include ExcelModel, Parser, Ranges, and get_functions(), with additional entry points through a Click CLI (calc, build, test, serve) and a Flask-based web application. Architecturally, the project is a library with CLI and web wrappers. Formula text is tokenized and parsed into an AST, then compiled by AstBuilder into a schedula dispatch pipeline. Workbook loading, reference resolution, and cyclic reference handling are coordinated in the excel package, while hundreds of Excel function implementations are organized in categories such as math, statistics, financial, text, lookup, engineering, and date/time. The function layer relies heavily on numpy, scipy, pandas, statsmodels, and numpy-financial, and uses standardized wrappers to convert Python functions into Excel-compatible array functions with proper error propagation. Strengths include a broad data-driven test suite, an elegant range algebra class, Tarjan-based cycle detection, and a mature parser design. Weaknesses include very large function modules that mix many edge cases, incomplete Excel function categories (Automation, Cube, Database, Web), legacy Python-version conditionals, and heavy external dependencies that may lag behind current Excel behavior. Although the repo contains curated data files and spreadsheet fixtures, its dominant character is a software application rather than a data pipeline or research repository.
This repository provides a Python library for parsing human-readable time expressions into seconds. The core functionality is implemented in the `timeparse` function, which accepts strings in various formats (e.g., '32m', '2h32m', '1w3d2h32m', '4:13:02', '2 days, 4:13:02') and returns the equivalent duration in seconds as an integer or float. The library handles optional signs, fractional values, and ambiguous colon-separated values via a granularity parameter. It has no external dependencies and is designed for simplicity and reliability. The library is structured as a single module with a clear public interface. The implementation uses a series of regular expressions to match different time formats and converts the matched components to seconds using predefined multipliers. The code is well-tested with a comprehensive test suite that covers the various input formats and edge cases. Despite its simplicity, the library demonstrates careful attention to detail in handling the complexities of time expression parsing, such as supporting both written and abbreviated units, handling spaces and commas as separators, and providing control over the interpretation of colon-separated values.
glyphsLib is a Python library that provides bidirectional conversion between Glyphs.app source files (.glyphs) and the UFO (Unified Font Object) format with Designspace documents. It serves as the core bridge in font production pipelines, enabling tools like fontmake to compile variable and static OpenType fonts from Glyphs sources. The library handles the full round-trip of font metadata, glyph outlines, components, anchors, hints, guidelines, kerning, OpenType features, instances, axes, and custom parameters, supporting both Glyphs v2 and v3 file formats. Architecturally, glyphsLib employs a builder pattern with UFOBuilder and GlyphsBuilder classes that orchestrate conversion through specialized sub-modules for each font data domain (paths, components, anchors, features, etc.). Key entry points include the high-level functions `to_ufos()`, `to_designspace()`, and `to_glyphs()` in the `glyphsLib.builder` package, as well as CLI tools `glyphs2ufo` and `ufo2glyphs`. The library integrates deeply with the fontTools ecosystem, using fontTools.designspaceLib for axis definitions and ufo2ft for feature writing and filters. External dependencies include fonttools, ufoLib2, defcon, openstep-plist, and xmldiff. The library also bundles GlyphData XML files for glyph classification and production name mapping. Notable features include smart component decomposition, bracket/brace layer handling, anchor propagation, token expansion in feature code, automatic STAT table generation, and variable feature conversion from Glyphs-specific conditional syntax to feaLib variation blocks. The codebase is well-tested with extensive round-trip tests and regression tests against real font families.
MetaGPT is a multi-agent orchestration framework designed to automate software engineering workflows and complex task execution. It functions as a Python library and CLI tool where autonomous agents (Roles like Product Manager, Architect, Engineer) collaborate via a message-passing environment to generate code, designs, and documentation. The system abstracts LLM interactions, supports Retrieval-Augmented Generation (RAG) for knowledge retrieval, and includes specialized environments for simulation (Minecraft, Stanford Town) and automation (Android, Web Browsing). It is primarily an application framework rather than a data research repository, though it incorporates research-grade components like Tree of Thought planning and AutoML evaluation. The architecture is modular, separating Roles, Actions, Tools, and Environments to allow for extensibility. Key entry points include the CLI command `metagpt` and the `metagpt.software_company` module for project generation. The codebase relies heavily on external dependencies, particularly LLM APIs (OpenAI, Azure, etc.) and browser automation tools (Playwright), which introduces maintenance complexity. While the core framework is well-structured with factory patterns and serialization support, the heavy coupling to external services and the presence of complex, niche extensions (e.g., Minecraft bot integration) contribute to a medium technical drift rating.
TextBlob is a Python library for processing textual data, providing a simple, intuitive API for common natural language processing (NLP) tasks such as sentiment analysis, part-of-speech tagging, noun phrase extraction, tokenization, spelling correction, and classification. It wraps NLTK and a vendorized subset of the pattern library, offering a unified interface that feels like working with Python strings. The library is designed as a monolithic package with a pluggable architecture: abstract base classes define interfaces for taggers, tokenizers, sentiment analyzers, and parsers, allowing users to swap implementations. Core classes include TextBlob, Word, Sentence, Blobber (a factory for sharing models), and WordList. The codebase is well-structured, employs lazy loading and caching for performance, and includes a format registry for reading data files (CSV, JSON, TSV). While primarily a library for application integration, it also bundles linguistic data files (lexicons, spelling frequencies, sentiment lexicons) that are used for research-oriented tasks. The project is actively maintained, supports Python 3.10–3.14, and uses modern tooling (GitHub Actions, renovate, pre-commit).
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.
StatsForecast is a production-grade Python library for large-scale univariate time series forecasting. It provides a unified API (fit/predict/forecast/cross_validation) over 40+ statistical models including AutoARIMA, AutoETS, AutoCES, AutoTheta, MSTL, TBATS, GARCH, and intermittent-demand methods (Croston, ADIDA, IMAPA). The core algorithms are implemented in C++ via pybind11 for performance, with Python wrappers handling model selection, prediction intervals, and conformal prediction. The library supports distributed execution on Spark, Dask, and Ray through a Fugue-based backend, and integrates with pandas, Polars, and MLFlow. While primarily an application library, the repository also contains extensive benchmarking experiments against R packages, Prophet, and NeuralProphet, as well as tutorials and competition notebooks, giving it a hybrid character. The codebase is well-structured with a clear separation of concerns (core API, model implementations, distributed backends, utilities) and includes a comprehensive test suite validated against R reference values.
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).
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.
VeritasGraph is a comprehensive, governed GraphRAG and agent framework for building enterprise-grade knowledge graphs with verifiable attribution. The repository contains a core Python library (VeritasReason) for knowledge graph construction, semantic extraction, reasoning, provenance tracking, and export, along with multiple domain-specific applications: a HIPAA-safe clinical knowledge graph pipeline (clinical-kg), a floorplan extraction and validation web app (floorplan-kg), a municipality incident reporting chatbot, and a Model Context Protocol (MCP) server for IDE integration. The architecture is modular, with a plugin-based method registry pattern, unified configuration management, and a pipeline orchestration engine. While the primary character is an application framework, it also includes research-oriented components such as clinical benchmarks (MedKG-Signal) and evaluation suites, making it a hybrid project with a strong application focus.
Pydub is a mature, high-level Python library for audio manipulation. It provides an immutable `AudioSegment` class that supports slicing, concatenation, overlaying, gain changes, fading, and format conversion using ffmpeg/avconv as a backend for non-WAV formats. The library includes a variety of DSP effects (normalize, speedup, compression, filters, equalization), silence detection/splitting, signal generators (sine, square, sawtooth, white noise), and optional playback via simpleaudio, pyaudio, or ffplay. Its architecture is modular, with core functionality in `audio_segment.py` and effects registered via a decorator pattern. The codebase demonstrates clean abstractions and is well-tested, though it carries some legacy Python 2 compatibility patterns.
nbconvert is a mature, actively maintained CLI tool and Python library for converting Jupyter Notebooks (.ipynb) into a wide variety of static formats, including HTML, LaTeX, PDF, Markdown, reStructuredText, AsciiDoc, slides (Reveal.js), executable scripts, and even back to notebook format. The architecture is a pipeline: a notebook is first processed by a chain of configurable preprocessors (e.g., for executing code, removing tags, extracting attachments, converting SVG to PDF), then rendered through Jinja2 templates into the target format, and finally written to disk or stdout via a writer, with optional post-processing (e.g., serving slides). The system is highly extensible via Python entry points for custom exporters, preprocessors, and templates, and all components are configurable through traitlets, enabling both programmatic and command-line use. The codebase is well-structured with clear separation of concerns: exporters (base, template-based, and format-specific), preprocessors (over a dozen), filters (for Jinja2 templates), writers, and postprocessors. The template system supports inheritance and custom syntax for LaTeX. Notable implementation highlights include a custom Markdown parser with LaTeX math support (handling both Mistune v2 and v3), ANSI-to-HTML/LaTeX conversion, SVG-to-PDF conversion with security hardening, and a context manager for directory changes. The test suite is extensive, covering exporters, filters, preprocessors, and the CLI application, with CI testing across multiple Python versions and platforms. While the core functionality is robust, the codebase shows signs of technical drift: some modules are deprecated (e.g., lexers.py), external tool dependencies (pandoc, Inkscape, Playwright) introduce version-specific behavior, and the template system has accumulated complexity with multiple inheritance chains and legacy compatibility paths. The project is actively maintained with recent security fixes and releases, but the breadth of supported formats and external dependencies creates ongoing maintenance overhead.
PhiFlow is a Python library for differentiable physics simulation, primarily targeting fluid dynamics, particle systems, and PDE-based optimization. It provides a unified field abstraction (CenteredGrid, StaggeredGrid, PointCloud, Mesh) with automatic resampling and boundary handling, enabling seamless integration with machine learning workflows. The library supports multiple backends (NumPy, PyTorch, TensorFlow, JAX) and features a rich geometry module, physics solvers (advection, diffusion, incompressible flow, SPH, waves), and visualization tools. While its core abstractions are clean and well-tested, the codebase exhibits some technical drift due to deprecated API surface, large monolithic Dash-based web UI, and heavy reliance on the external phiml tensor library. Nonetheless, it is actively maintained with extensive test coverage and a growing research community.
fastapi-mail is a lightweight async Python library for sending emails from FastAPI/Starlette applications. It provides a clean, Pydantic-driven configuration model (ConnectionConfig), a message builder (MessageSchema) supporting HTML, plain text, Jinja2 templates, file attachments, CC/BCC/reply-to, and custom SMTP headers. The core FastMail class handles async SMTP delivery via aiosmtplib, with optional Redis-backed email validation utilities (DefaultChecker) and a WhoIsXmlApi wrapper. The architecture is simple and single-purpose: a library to be imported into FastAPI projects. It has comprehensive test coverage (22+ async tests) and modern async patterns throughout. The codebase is well-maintained with CI/CD, linting, and documentation. While the library does not exhibit groundbreaking innovation, it is a solid, production-ready solution for email sending in async Python web applications.
janus is a Python library that provides mixed sync-async queues for communication between threaded code and asyncio code. The core architecture centers on a single `Queue` class that internally manages both synchronous and asynchronous interfaces via proxy objects (`_SyncQueueProxy` and `_AsyncQueueProxy`). It uses thread-safe conditions (`threading.Condition`) for sync operations and asyncio conditions (`asyncio.Condition`) with careful cross-thread notification via `loop.call_soon_threadsafe`. The queue supports standard FIFO, LIFO (`LifoQueue`), and priority (`PriorityQueue`) variants through a template method pattern (overriding `_init`, `_put`, `_get`). Lifecycle management includes graceful and immediate shutdown with dedicated exception types (`SyncQueueShutDown`/`AsyncQueueShutDown`) compatible with Python 3.13+. The library is production-stable, has no external dependencies beyond the standard library, and is thoroughly tested across multiple Python versions and concurrency scenarios. It does not expose APIs beyond queue operations and is strictly a communication primitive.
This repository is the `lingam` Python package, a comprehensive, research-oriented library for causal discovery from observational data using LiNGAM (Linear Non-Gaussian Acyclic Model) and its numerous extensions. It implements over 20 algorithms, including DirectLiNGAM, ICALiNGAM, VAR-LiNGAM, RCD, CAM-UV, RESIT, LiM, mLiNGAM, GroupLiNGAM, MultiGroup variants, and more. The library provides a consistent API where each algorithm exposes `fit()` on a data matrix, followed by properties like `causal_order_` and `adjacency_matrix_`, and all support bootstrap-based stability analysis via a shared `BootstrapMixin`. Key contributions include handling of latent confounders, time series, missing data, mixed data types, and multiple datasets, alongside utilities for causal effect estimation, visualization, model evaluation, and synthetic data generation. The code is well-structured, uses standard scientific Python dependencies (numpy, scipy, scikit-learn, graphviz), and includes a thorough test suite and extensive Jupyter notebook tutorials.
openlibrary-client is a reference Python client library for the Open Library API, maintained by the Internet Archive. It provides object-oriented models for books, authors, editions, works, and covers, wrapping the REST endpoints behind a simple client class. The library supports cookie-based authentication, read/fetch operations, and write operations such as creating new works and editions. It also includes utilities for parsing MARC dump lines and validating book import schemas, making it useful beyond simple API access.
Pinkfish is a Python library for backtesting equity trading strategies, primarily used via Jupyter notebooks. It provides a modular framework with components for data fetching (Yahoo Finance via yfinance), trade logging, portfolio management, performance statistics, and signal generation. The core architecture revolves around a Strategy class pattern, a Portfolio class for multi-symbol backtesting, and a TradeLog class for simulating trade entries/exits with realistic open/close fills. The library includes a wide range of technical indicators (both custom and TA-Lib wrappers), comprehensive performance metrics (Sharpe, Sortino, drawdown, etc.), and support for signal notifications via Pushover/email. The codebase is well-structured with clear separation of concerns, but uses some global state in TradeLog and relies on a static stock market calendar, introducing minor maintenance risks. The examples cover diverse strategies such as momentum, moving average crossovers, and sector rotation, serving as both documentation and reusable templates.
This repository is a Python client library for the Mihomo API, which serves parsed data for the game Honkai: Star Rail. It provides a clean, async client (`MihomoAPI`) that fetches player profiles and character data, mapping the JSON responses into well-structured Pydantic models (version 1 and version 2). The codebase is tightly focused on this single external API, with no data processing or storage beyond the client. Architecture follows a typical API client pattern: a client class with request methods, Pydantic models for data representation, custom error classes, and utility functions for data manipulation (e.g., removing duplicates, merging character records, resolving icon URLs). The library is not a framework or service but a reusable component for any application that needs to consume Honkai: Star Rail player data from the Mihomo API. There are no data pipelines, notebooks, or research elements.
google-images-download is a Python application for searching and downloading images from Google Images. It functions as both a command-line tool and a library that can be imported into other Python scripts. The system uses Selenium with Chrome to handle JavaScript-heavy Google Images pages, automatically manages chromedriver via webdriver-manager, and supports extensive filtering options (size, color, format, usage rights, etc.). Key features include filename sanitization for cross-platform compatibility, metadata extraction, similar image search, and robust error handling for network issues. The architecture is monolithic with a clear separation between argument parsing, URL building, browser automation, and download execution.