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.
nodriver is an asynchronous Python library for browser automation that communicates directly with Chrome/Chromium via the Chrome DevTools Protocol (CDP), bypassing Selenium and WebDriver. It provides a high-level API (Browser, Tab, Element) for navigating pages, finding and interacting with DOM elements, managing cookies, proxies, and taking screenshots, with built-in anti-detection measures to evade bot blockers like Cloudflare. The codebase includes auto-generated low-level bindings for all CDP domains, a custom async WebSocket connection manager, a dict wrapper with attribute access (ContraDict), and a sofisticated async TCP proxy forwarder for authenticated proxies. The library is alpha-stage but actively maintained, though some CDP domain messagers are depreicated and the generated code requires periodic regeneration to stay in sync with Chrome updates.
redis-plus-plus is a production-grade C++ Redis client library built on hiredis, providing synchronous, asynchronous (libuv), and experimental coroutine (C++20) APIs. It covers the full Redis command surface including strings, hashes, lists, sets, sorted sets, streams, geospatial, hyperloglog, pub/sub, scripting, transactions, pipelines, and server commands. The architecture separates low-level connection management (connection pools, shard pools for clusters, sentinel discovery) from high-level facade classes (Redis, RedisCluster, AsyncRedis, AsyncRedisCluster, QueuedRedis for pipelined/transactional usage). Key entry points include the main sync header `redis++.h`, async header `async_redis++.h`, and coroutine header `co_redis++.h`. Data flows involve constructing Redis commands via `CmdArgs` and `cmd_formatter.h`, sending them through `Connection` objects (optionally pooled), and parsing replies with `reply.h`. The library depends on hiredis for raw Redis protocol, libuv for async I/O, and optionally Boost or OpenSSL for advanced features. It includes a comprehensive test suite covering all commands, multi-threading, cluster, sentinel, and distributed locking patterns (Redlock).
This is a CLI-based web scraper for Sina Weibo (微博) user data and posts. It scrapes user profiles, weibo contents, images, and videos from the mobile version of Weibo (weibo.cn) using a combination of synchronous (requests, lxml) and asynchronous (aiohttp) HTTP requests. The architecture is a pipeline: parsers extract structured data from HTML, downloaders asynchronously fetch media files, and writers persist results to multiple formats (CSV, TXT, JSON, MySQL, MongoDB, SQLite, Kafka, HTTP POST). The spider is driven by a config file (config.json) that controls user id lists, date ranges, filtering, and download options. It supports retry logic, random delays, and global wait periods to avoid rate limiting. External dependencies include requests, lxml, aiohttp, browser_cookie3, and absl-py; optional dependencies add database and message queue support. The codebase is modular with clear separation of concerns, includes unit tests with mocked HTML fixtures, and demonstrates solid engineering practices for a data collection tool.
This repository is the `pyTelegramBotAPI` Python library, providing both synchronous (`TeleBot`) and asynchronous (`AsyncTeleBot`) implementations for building Telegram bots. It acts as a wrapper around the Telegram Bot API, handling all message types, inline queries, payments, webhooks, polling, and more. The library's architecture is layered: a user-facing bot class that exposes method calls to a core API helper module (`apihelper.py` / `asyncio_helper.py`), which performs HTTP requests to Telegram servers. Bot logic is structured via message handlers (decorator-based), custom filters, middleware hooks, and a state machine with pluggable storage backends (memory, Redis, pickle). Key entry points include `TeleBot` and `AsyncTeleBot` classes, with webhook support via `SyncWebhookListener` and `AsyncWebhookListener` in the `ext` module. The library relies on `requests` (sync) and `aiohttp` (async) for HTTP, with optional dependencies `redis`, `Pillow`, `fastapi`, `uvicorn`, and `watchdog`. It is extensively tested and documented, with over 50 examples covering typical bot patterns. While the codebase is mature and well-maintained, it exhibits some technical drift: duplicated sync/async helper modules, deprecated API parameters maintained for backward compatibility, and incomplete localization files. Overall, it is a solid, production-ready library for Telegram bot development.
Fuso is a Rust-based intranet penetration and port forwarding tool that enables exposing local services behind NAT to the public internet via a relay server. It implements a client-server architecture with support for TCP forwarding, SOCKS5 proxy (including UDP association), KCP protocol for reliable UDP transport, LZ4 compression, and RSA+AES encryption. The system is built on a custom async runtime abstraction (supporting tokio and smol), with a modular design using provider and builder patterns. The server (fus) manages client connections and public listeners, while the client (fuc) registers port mappings and forwards traffic. Additional features include bridge mode for cascading proxies, heartbeat health checks, observer hooks for external notifications, and a configuration API. The codebase demonstrates strong Rust async patterns, protocol implementation skills, and a clean separation between core abstractions and runtime specifics.
O! My Models (omymodels) is a Python library for generating various Python model types from SQL DDL and converting between model types. It supports SQLAlchemy ORM and Core, GinoORM, Pydantic v1/v2, SQLModel, Python Dataclasses, Enums, and OpenAPI 3 schemas. The architecture follows a pipeline: SQL DDL parsing → normalization → type conversion → model generation → Jinja2 template rendering. Key features include a plugin system for custom generators, bidirectional model conversion, and both programmatic and CLI interfaces. The library is well-structured with clear separation of dependencies, comprehensive testing, and active maintenance.
This repository is a comprehensive, async-first CLI application for downloading content from Douyin (TikTok China) without watermarks. It also powers a desktop application (Douzy) via a shared Python backend and offers an optional FastAPI REST server. The architecture follows a modular design: URL parsing dispatches to concrete downloader classes (video, music, live, user, mix) via a factory pattern; user-mode downloads employ a strategy pattern for posts, likes, mixes, and collections. Heavy emphasis is placed on anti-bot circumvention—X-Bogus and A-Bogus signature generation, browser fallback via Playwright, and risk-control retry logic—reflecting the adversarial nature of Douyin's API. The codebase is well-structured with distinct layers (auth, config, core, storage, control, utils) and extensive test coverage (>80 test modules). It demonstrates strong engineering practices: async I/O throughout (aiohttp, aiosqlite, aiofiles), configurable concurrency with rate limiting and retry backoff, incremental downloads via disk and database checks, structured progress reporting, and manifest logging. However, the project shows signs of technical drift: some dependencies are out of sync between requirements.txt and pyproject.toml, bundled msToken configuration may become stale, and the desktop-sidecar integration introduces coupling risks. Despite these, the code is actively maintained and functionally robust for its specific domain.
aiomysql is a pure-Python MySQL/MariaDB client library for asyncio. It is effectively a port of PyMySQL's blocking driver with async I/O, plus an optional SQLAlchemy integration layer ported from aiopg. The primary programmatic entry points are `aiomysql.connect()` and `aiomysql.create_pool()`, which produce `Connection` and `Pool` objects used through `connection.cursor()`, `cursor.execute()`, and async context managers. A secondary entry point is `aiomysql.sa.create_engine()`, which wraps async pools with a SQLAlchemy engine/dialect facade for expression-based queries. The library implements MySQL protocol packet handling, authentication plugins, TLS, `LOAD DATA LOCAL INFILE`, server-side cursors, and result-set decoding. It has no web endpoints, CLI, or data pipelines; it is a dependency library, not an end-user application.
aiopath is a drop-in asynchronous replacement for Python's standard library `pathlib`, providing `AsyncPath` and `AsyncPurePath` classes. It replicates the complete `pathlib` API but makes all I/O-bound methods (like `.exists()`, `.read_text()`, `.glob()`, `.mkdir()`) awaitable, allowing non-blocking filesystem operations in asyncio or trio applications. The library builds on `anyio.to_thread` for executing blocking OS calls off the event loop and `aiofile` for async file handles. It strictly inherits from `pathlib.Path` and `PurePath`, preserving method signatures, docstrings (via a metadata decorator), and class hierarchy. The implementation is clean and type-annotated throughout, requiring Python 3.12+ and using modern syntax like `type` aliases. Old compatibility layers (for Python 3.9-) are kept in `src/aiopath/old/` alongside stale backup files, indicating an ongoing renovation to drop legacy support.
This is the playit.gg tunnel agent, a production-grade client-side daemon that exposes local servers (e.g., Minecraft, game servers, web services) to the internet through the playit.gg tunnel network. The system is organized as a Rust multi-package workspace comprising five main crates: `agent_core` (tunnel state machine, TCP/UDP proxying, control connection), `playitd` (background daemon with IPC server, stats, log rotation), `playit-cli` (CLI and TUI frontend using ratatui), `playit-ipc` (local IPC protocol with version negotiation), and `playitd-tray` (Windows system tray controller). It supports Linux, Windows, macOS, and FreeBSD, with platform-specific path handling (Unix sockets, named pipes, Windows service management). The architecture centers on a UDP control connection to playit.gg servers: the agent authenticates via HMAC-SHA256, receives tunnel assignments, then proxies TCP and UDP traffic between tunnel ingress points and local origin servers. The daemon runs as a background service (systemd, OpenRC, Windows service) and exposes a local IPC endpoint for the CLI/TUI to monitor logs, stats, and lifecycle status. Key entry points include `packages/playitd/src/bin/playitd.rs` (daemon binary), `packages/playitd/src/bin/playitd-service.rs` (Windows service host), `packages/playit-cli/src/main.rs` (CLI with attach/start/stop/claim commands), and `packages/playitd-tray/src/main.rs` (Windows tray application). External dependencies include tokio (async runtime), ratatui (TUI), crossterm (terminal), serde (serialization), reqwest (REST client), and ring (HMAC). The codebase demonstrates strong craftsmanship in low-level networking (zero-copy UDP packet pools, PROXY protocol, statically-sized control messages) and state machine design (connection recovery, MTU probing, address selection). However, it suffers from some production debt: panics in critical paths (UDP channel shutdown, flow invariants), duplicated code between `playitd-tray` and `playitd-windows-setup` startup shortcuts, and hardcoded configuration values (control port, protocol version). The build and release infrastructure is extensive (nfpm, WiX, Docker, Arch PKGBUILD, code signing) but shows signs of fragility (stale binary name in mac-deploy.sh, sed-based version overrides).
This repository is neo4rs, a production-grade asynchronous Rust driver for the Neo4j graph database. It implements the Bolt binary protocol (versions 4.x with partial 5.x support) and provides a complete client library for querying, transaction management, connection pooling, cluster routing, and serialization of Neo4j's rich data types (nodes, relationships, paths, temporal and spatial values). The architecture is modular: a connection layer handles TCP/TLS handshakes and chunked message framing; a PackStream serializer/deserializer converts between Rust types and the Bolt wire format; a routing module manages cluster membership and load balancing; and a high-level API (Graph, Session, Txn, RowStream) offers async query execution with automatic retry on transient errors. The codebase includes two parallel Bolt protocol implementations—a legacy one and a newer feature-gated version—which introduces maintenance overhead. Despite this, the project is actively maintained with extensive integration tests against multiple Neo4j versions and a robust CI pipeline. The library is suitable for any Rust application that needs to interact with Neo4j, offering both a high-level ergonomic API and low-level control over the protocol.
This repository is a Python client library for the Alpha Vantage financial data API. It provides synchronous and asynchronous wrappers for accessing stock/cryptocurrency time series, technical indicators, foreign exchange rates, commodities, economic indicators, fundamental data, options, and news sentiment. The library is designed as a straightforward SDK with a decorator-based architecture that handles API key injection, URL construction, and output formatting (JSON, pandas DataFrame, CSV). The codebase includes a comprehensive test suite with mock data and integration tests. However, it exhibits technical drift: declared support for Python 2.7 (EOL), an outdated CI configuration (Travis on Ubuntu Xenial), a hardcoded version number in documentation that differs from the library version, and duplication of core logic between synchronous and async modules. The library is functional and widely used, but not exemplary in terms of modern Python practices or maintainability.
Tina is a header-only library providing lightweight user-space threading through coroutines and fibers, along with a fiber-based job system for task scheduling. The core library (tina.h) implements symmetric and asymmetric coroutine APIs with platform-specific assembly for context switching. Tina Jobs (tina_jobs.h) builds on this to create a job scheduler featuring work-stealing via queue chaining, memory pooling, and fiber-based job execution to avoid OS thread overhead. The repository includes examples (e.g., Mandelbrot renderer using Sokol graphics) and tests demonstrating usage, but the project has migrated to Codeberg due to philosophical opposition to AI training, indicating the GitHub repository is no longer actively maintained. While the Sokol dependencies in extras are third-party, the Tina core showcases strong craftsmanship in low-level concurrency primitives.
The C++ REST SDK (cpprestsdk) is a cross-platform, asynchronous C++ library for building cloud-based client-server applications. It provides a comprehensive set of APIs for HTTP client and server communication, JSON parsing and serialization, URI manipulation, WebSocket client support, OAuth 1.0 and 2.0 authentication, and asynchronous stream I/O. The library is built on a custom task-based concurrency model (PPLX) that abstracts platform-specific threading and synchronization, enabling portable async operations across Windows, Linux, macOS, iOS, and Android. The architecture is modular: HTTP client and server implementations use a pipeline stage pattern for middleware (e.g., compression, authentication), and the stream buffer abstraction decouples data sources from I/O operations. The codebase includes extensive functional tests using a bundled UnitTest++ framework, along with sample applications demonstrating real-world usage (BlackJack game, OAuth flows, file search). However, the repository is officially archived and no longer maintained; it exhibits significant technical drift, including deprecated APIs, platform-specific conditional compilation, and dependencies on older library versions (Boost, OpenSSL). Despite this, many components—such as the PPLX task system, URI builder, JSON value, and stream buffers—are well-crafted and could be extracted for reuse in new projects with minimal adaptation.
This repository provides a deprecated Docker image for running Starlette applications with Uvicorn managed by Gunicorn. The image includes auto-tuning of worker processes based on CPU cores. However, the project is explicitly deprecated in favor of using Uvicorn with the `--workers` option directly, as the need for Gunicorn as a process manager has been eliminated by recent Uvicorn features. The repository contains Dockerfiles for Python 3.10 and 3.11 (slim and non-slim) that build upon the `tiangolo/uvicorn-gunicorn` base image, and installs Starlette. It includes a minimal example application and tests to verify the image behavior.