r/Python • u/AutoModerator • 18d ago
Showcase Showcase Thread
Post all of your code/projects/showcases/AI slop here.
Recycles once a month.
3
u/getting_older_1 17d ago
mimicker — a small Python-native HTTP mock server (no JVM)
What My Project Does
mimicker is a small HTTP mock server for Python tests and CI. Define stubs with a Python DSL or a YAML file, then start it in-process or via a one-line CLI call and hit it like a real API in your tests:
from mimicker.mimicker import mimicker, get
mimicker(8080).routes(
get("/hello").body({"message": "Hello, World!"}).status(200)
)
It also supports path/query params, custom headers, delayed responses (for timeout testing), rate-limit simulation, and sequenced responses — a different result on each call, useful for testing retry logic against a flaky-looking dependency.
Target Audience
Anyone testing a Python service that calls external APIs who wants to stub responses without hitting the real API (slow, flaky, rate-limited) or reaching for WireMock, which means adding a JVM to a Python CI pipeline just to answer canned HTTP requests. It's usable in real CI today — there's an official GitHub Action (mimickerhq/mimicker-action) with a stub-coverage report built in that flags stubs your tests never actually hit.
Comparison
The main alternatives are WireMock (JVM-based, a much bigger feature set — record-and-playback, fault injection, a full admin API — but heavyweight if your stack is pure Python) and Python-native tools like responses/respx/pytest-httpserver (great for mocking at the HTTP client level inside the test process, but they don't give you a real standalone server that something outside the test runner — another process, a frontend dev, a CI step — can hit). mimicker is pure Python but a real listening server, so it sits in between.
pip install mimicker — Repo: https://github.com/mimickerhq/mimicker. Feedback and issues welcome, especially on use cases it doesn't cover yet.
2
u/sheik66 14d ago
protolink: a Python-native A2A agent runtime for multi-agent systems
What my Project Does
Protolink is a Python framework for building easily autonomous agents that can talk to each other based on agent-to-agent (A2A), expose tools, call LLMs, and run over real transports like HTTP, WebSocket, gRPC, or in-memory runtime communication.
A small agent looks like this:
from protolink.agents import Agent
agent = Agent(
card={
"name": "calculator",
"description": "Adds numbers for other agents",
"url": "http://127.0.0.1:8020",
},
transport="http",
)
@agent.tool(name="add", description="Add two numbers")
async def add(a: int, b: int):
return a + b
agent.start()
It supports A2A-style agent identity and discovery, native Python tools, MCP tool adapters, LLM integration, structured flows, streaming tasks, cancellation, run reports/replay, local telemetry, and a small dashboard CLI for inspecting runtime state.
Target Audience
Python developers building multi-agent systems, coding assistants, internal automation, or agent research projects who want agents to be more than prompt chains. Each agent can own its identity, tools, transport, storage, task lifecycle, and observability without having to wire a separate server/client layer for every component.
Comparison
The closest alternatives are LangChain/LangGraph, AutoGen/CrewAI, and lower-level A2A or MCP implementations. LangChain/LangGraph are great for composing model calls and workflows, but protolink is more focused on running agents as distributed runtimes with protocol-style task messages, discovery, tools, and transports. AutoGen/CrewAI are higher-level multi-agent frameworks; protolink is more explicit and modular, so you can build your own architecture while keeping the communication, tool execution, LLM invocation, and observability pieces in one Python-native framework.
pip install protolink - Repo: https://github.com/nMaroulis/protolink. Docs: https://nmaroulis.github.io/protolink/. Feedback welcome, especially from people experimenting with A2A/MCP interoperability or building real Python agent systems.
2
u/EdwardAF-IT 5d ago
Nice scope... "agents as runtimes, not prompt chains"! Question about run reports/replay: is replay deterministic enough to use for regression testing? So if I record a multi-agent exchange, can I re-run it against a changed agent and diff the outcome — or is it more of an inspection/debugging tool? That's the piece I keep finding missing in agent frameworks: a way to pin current behavior so an upgrade can't quietly change it.
1
u/sheik66 5d ago
Great question, you caught a distinction I should make clearer in the docs. The honest answer when I posted this was that
RunReplaywas primarily an inspection/debugging tool, not deterministic re-execution. It can reconstruct recorded events, but it does not rerun models, tools, or side effects.Your comment highlighted the missing regression-testing layer, so I’ve now added it for v0.6.6. You can execute a changed agent separately against the same controlled inputs and dependencies, then compare its report with a baseline using
diff_run_reports(...)orassert_run_matches(...). The comparison normalizes ProtoLink-generated IDs, timestamps, and sequence counters, supports ignore rules and numeric tolerances, and returns path-level differences across events, actions, approvals, artifacts, metrics, and the final task.Stored reports can also be compared from CI:
protolink run diff BASELINE CANDIDATE --store runs.db --jsonExit codes are
0for a match,1for behavioral changes, and2for a missing report.So the the distinction is: replay remains safe, read-only inspection, while the new report diff provides regression testing. For reproducible results, model/tool/external dependencies still need to be mocked, captured, or pinned; live dependencies can be compared, but the framework cannot make them deterministic.
2
u/EdwardAF-IT 5d ago
Thanks for the clarification. It's still an incredible tool, though -- keep em coming!
1
u/Kaluga2026 17d ago
PgRelay: PostgreSQL-backed transactional jobs for async Python services
If you need background jobs that are committed together with your application data, PgRelay is a small PostgreSQL-backed job runner for async Python services.
It is built for the case where a service already uses PostgreSQL and SQLAlchemy async, and adding Redis, Celery, SQS, Kafka, or a workflow engine feels heavier than the problem. Jobs are stored in the same database as the application data and can be enqueued
from the same SQLAlchemy AsyncSession. If the transaction rolls back, the job rolls back with it. If the transaction commits, a worker can claim and execute the job.
Repo: https://github.com/balyakin/pgrelay
Feedback would be useful.
1
u/Octomaniac7 17d ago
I have made a very simple inline image conversion tool. It currently only converts to svg, because that is what I needed at the time. The tool is free to use on github at https://github.com/tomtom-cmd/img2svg-official
1
u/Ok-Paramedic-6169 17d ago
www.deathsheadsoftware.org This is a collection of apps written in mostly Python. 2 apps are not python.
1
u/No-Community-3626 17d ago
i just want to showcase in simple words
https://github.com/RajX-dev/N3MO
its a code intelligence engine that provide you engine the intelligence for your repo to burn less token , you can access the web hook version its a SaaS you'll understand what it does give it a visit at least that all i want to say now days i lost hope in my project its good but no audience is finding it.
1
u/Own-System-9238 17d ago
Fiz esse projeto tem uns meses, enquanto cursava o CS50 de Harvard como primeiro curso de programação, e gostaria de ter um review de pessoas/devs engajadas em Python. Saber meu nível real, e se estou num caminho interessante para tentar Júnior nos próximos meses. Dei um tempo na linguagem apenas por motivos profissionais, no momento fui contrato por uma empresa que utiliza ServiceNow, que é baseada em JS. Estou conflitado no momento? Sim, já que estou fazendo um curso para aprender JS. Vou anexar meu repositório do GitHub aqui: https://github.com/PedroResBV/projeto-cs50
O projeto seria uma base de dados de atletas de vôlei de praia, sou um atleta da modalidade em migração para ti, usando arquivo CSV criado a partir do primeiro cadastro de atleta, algo simples usando terminal. Usei um pouco de IA, para entender melhorar alguns conceitos e revisar o que poderia melhorar, mas todo código eu que escrevi.
1
u/Ill-Equivalent7859 17d ago edited 17d ago
Hey, I built something I think could be useful for the engineering and NDT communities.
**The problem:** When you're doing risk-based inspections (RBI) on oil & gas assets, plant infrastructure, or pipelines, you often have 3D point clouds or digital twins, but modern inspection tools either require expensive enterprise software or duct-tape together spreadsheets and screenshots. There's no easy way to anchor inspection findings directly onto the 3D geometry and keep everything organized.
**What I built:** A browser-based viewer that lets you:
- Drop pins/annotations directly on 3D models by clicking
- Support LAS/LAZ point clouds, PLY meshes, OBJ, FBX, Gaussian splats, and 2D images
- Keep everything local (runs 100% in the browser—no servers)
- Auto-save to localStorage or export/import annotations as JSON
- Organize findings with a comment list (add title, body, color, mark as resolved)
**Stack:** React + TypeScript + Three.js + react-three-fiber + zustand + loaders.gl
**Roadmap:** NDT data overlay (UT/RT/MT/PT readings), photogrammetry MVP, drone integration (DJI), compliance workflow templates (API 510/570/653), PostgreSQL backend option.
**Target users:** Industrial inspectors, NDT professionals, oil & gas asset managers, infrastructure engineers, anyone working with 3D digital twins who needs lightweight annotation.
1
u/CubeGamer17 17d ago
Project - pdf-redactor – Batch PDF protection, unlocking and redaction CLI
What My Project Does
pdf-redactor is a Python CLI for protecting, unlocking and permanently redacting PDF documents in batches. It supports literal text matching, regular expressions, built-in presets (email, phone, PAN, Aadhaar, URLs, IPv4), TOML configuration files, dry-run mode, JSON audit reports and Rich progress output. The tool is intended for repetitive workflows where many PDFs contain the same sensitive information and need to be sanitized consistently.
Target Audience
Production use for anyone who regularly processes batches of text-based PDFs, such as HR, legal, finance, university administration or anyone handling documents containing personally identifiable information. It works with searchable/text-based PDFs (not scanned documents requiring OCR).
Comparison
Most PDF redaction tools are GUI applications designed for editing one document at a time, while many open-source alternatives are simple one-off scripts. pdf-redactor focuses on repeatable batch workflows from the command line, combining password protection, password removal, literal and regex-based redaction, reusable presets, configuration files, dry-run support and machine-readable JSON reports in a single tool.
Repository: https://github.com/FluffySce/pdf-redactor
1
u/bezdazen 16d ago edited 16d ago
I guess this is as good a place as any.
PyNote | Tutorial | Github
(as an example, here is a learning notebook series that you can explore)
I have been working PyNote for 8 or 9 months now. Im aiming for end of year release.
What is it?
PyNote is a serverless, zero-setup python notebook environment. By serverless, I mean that your notebooks and data don't get stored in a server and more importantly, your python code is executed locally using your browser (in a sandboxed environment).
Comparison.
tldr: PyNote is less mature than competitors like Marimo and JupyterLite but uses cutting edge tech (SolidJS, CodeMirror, Milkdown, Pyodide etc), is simpler, cleaner, free, no-setup or signup, and more WYISWYG. Nothing is saved to a server.
What may inspire confidence is that I believe I have architected the core systems well (I spent the year prior implementing various prototypes). Also, behind the app is a cutting edge tech stack where each tech was landed on through research and experience building custom components for Streamlit. Suffice it to say that I am very happy with the performance and the snappiness of the interface.
The target audience?
Regardless, while PyNote has a lot of great features such as reactive execution mode (like Marimo) and a built-in native "widget" library, the aim is simplicity and presentation. This is where it stands out. PyNote tries to be as WYSIWYG as possible for a notebook. If you turn on presentation mode, you can see that the content doesn't move or change layout or even shift and the notebook straight up looks like an article or blog post! This is the whole point. The original realization that lead to this project is that notebook app UIs have really strayed from the presentation side of things. This is important for educational content, guided tutorials, data analysis walkthroughs, and technical runbooks, where the presentation layer is critical to bridging the gap between passive reading and active, hands-on learning.
So the target audience are users who want an intuitive, clean, simple, WYSIWYG notebook interface and/or are working on notebook content they want to be presentable as is (no converting, manually styling, reformatting, etc).
So what am I working on currently?
- I have added a "Files and Data" feature (
Options > Files & Data) that opens a panel or dialog that allows users to manage the internal filesystem/workspace that the python in the code cell sees. Within is a UI mini finder/explorer that lets you see folders and uploaded files. You can create folders and move folders and files around. It has two file list view modes, one that is the traditional "view contents of single folder at a time" and the other allows users to see files in a tree-like format like you would in a typical code IDE. - I have further fleshed out the theming system with many new advanced configuration options. I have also added 4 built-in theme presets (4 dark mode and one light) that are accessible
Options > Theme > Presetsand also added several syntax highlighting color schemes (Options > Theme > Syntax Highlighting) - I have also greatly improved the mobile/small screen experience, fixing many bugs and adding a simpler UI approach for cell actions. I think the app is usable on mobile which says a lot for a notebook/code environment.
What am I working on next
I will be working on exposing internal app system settings to users by adding a settings dialog. It will be an option that sits next to Theme in the Options menu. These settings already exist, but have been kept hidden because I wasn't sure what to allow to be configurable by the user and what to just fix internally. And other questions/decisions.
And then, I will continue working on the export system which is a very important system especially for the presentation aim of the app. For example, I want users to be able to export the notebook as html that can be used for articles and blogs. I also want traditional exports as well and a special proprietary pynote format that is easier to use with version control systems like git.
I would love for people to start exploring and using PyNote so I can learn about what the pain points are and what features users want most or expect a notebook environment to have.
1
u/Voyager_Ten 16d ago
CAR-TER - A fully programmable iOS app that lets developers plug their systems into a dynamic mobile frontend.
What My Project Does
pip install carterkit builds and drives layouts for the CAR-TER app. You compose a layout in Python (a flat builder with handles, or a declarative class style if you prefer), where controls like gauges, charts, maps, buttons and log consoles bind to message keys. Your script then publishes data over a WebSocket mesh and the phone renders it live, native SwiftUI, no web server or browser involved. A comparison like `cpu > 90` on a control handle becomes a real visibility condition on the device. The package also lints layouts against the control catalog before you ship them, generates a runnable server stub from a layout, can infer a whole wired layout from a sample telemetry dict, and ships a CLI plus a bundled relay so `carterkit relay --port 8765` is the entire local setup. One design decision I'm fond of: the control docs are the library. The same markdown docs the app renders are parsed at runtime for schemas and examples, so the catalog can't drift from the documentation.
Target Audience
People who write scripts, homelab services, scrapers, trainers, bots, or embedded-ish projects and want to watch or poke them from a phone without building a frontend. It's a real published package with tests and docs, but the app is pre App Store right now, I'm recruiting TestFlight testers, so treat the whole system as a late beta.
Comparison
Streamlit, Gradio and Dash give you a web page, great on a laptop, clunky as a phone remote, and they can't touch lock screen Live Activities or push notifications, which CAR-TER layouts can drive. Blynk is the closest spiritual neighbor but is IoT-hardware centric and cloud-first, while this is a general Python-to-phone bridge you can run entirely on your LAN with end to end encryption via a shared key. Pushover style tools only do notifications, this is a full two way control surface.
pip install carterkit, docs at https://carterbeaudoin.net/CAR-TER, package at
https://pypi.org/project/carterkit/. TestFlight for the app: https://testflight.apple.com/join/3NNH619Y
Repos:
Meshsocket (the pipes): https://github.com/Mariner10/MeshSocket
carterkit (the library): https://github.com/Mariner10/carterkit
carter-mcp (MCP for agent interaction): https://github.com/Mariner10/carter-mcp
The app is closed sourced - but will be free-mium on the app store. Gotta pay rent somehow!
1
u/Anxious_Classic750 16d ago
First big project
Live ISS Tracker
https://iss-tracker-gffjwtzvigsabyvqbztfbj.streamlit.app/ - Website
Code - https://github.com/berserker-stack/iss-tracker
First real project as a high schooler. What do you guys think? Any improvements I can make?
It just tracks the live position of the International Space Station
1
u/Natuworkguy 15d ago
I made a GUI game engine in pure interpreted Python. Here's how.
What My Project Does
ABS Engine is a Python game engine built on top of Pygame CE. It's entirely interpreted and distributed via git clone rather than pip. The only external dependencies are pygame-ce and colorama, everything else works out of the box with a standard Python install.
The architecture is three layers: a Game class that handles core Pygame setup and the main loop, Scene classes that manage all entities (a Game can hold multiple scenes), and Entities that each run a user script with three lifecycle functions: init (on load), update (every tick), and event (on registered events). The update flow cascades from Game to Scene to each Entity, with every entity updating its own rect through an internal update_rect function. Collision detection is currently rect-based, called through entity.get_colliding_entities(), which returns all colliding entities for the script to use. Circle and other shape support is planned.
For theming and styling, the engine uses Python's built-in TCL interpreter via Tkinter instead of pulling in a UI library, with more TCL-driven features planned.
Code quality is enforced with a heavy linting stack: Ruff, Bandit, Flake8, Pyright, mypy, Interrogate, darglint, and markdownlint.
Target Audience
Hobbyists and Python developers who want to build 2D games without a heavy toolchain, and anyone curious about game engine internals in readable, fully interpreted Python. It's under active development, so treat it as a project to build with and contribute to rather than a battle-tested production engine.
Comparison
Compared to using Pygame directly, ABS Engine gives you structure out of the box: scene management, an entity lifecycle, event propagation, and collision queries, so you write game scripts instead of boilerplate. Compared to larger engines like Godot or Unity, there's no editor, no build step, and no separate scripting layer. It's pure Python end to end, clone and run. Compared to other Python engines like Arcade, the focus is on minimal dependencies and a strict three-layer architecture with a simple three-function entity contract.
Repo: https://github.com/Natuworkguy/ABS-Engine
Would love contributors, and feedback especially on the entity lifecycle design and the dependency approach.
1
u/maniek23 15d ago
Hi!
I'm sharing a language server I've created for myself and have been using for quite a while. I've become frustrated with the state of autocompleting imports in available language servers, so I created my own - which focuses solely on that thing: preparing auto-completion for importable symbols. Some of the key features/ideas:
- works for all your Python files (workspace, virtualenv, std, stub-libs, *pyi files),
- fast - scanned symbols (classes, functions, variables) are cached in sqlite, and updated when changes are detected,
- project-Python independent - files are scanned using tree-sitter, language server can be installed in a system once (globally) and used in all the projects,
- demote hidden/private modules and their symbols,
- promote symbols from current workspace, and (coming soon) promote symbols already used throughout the workspace even more!
Since the language server focuses only on imports autocompletion, you should still keep using your regular language server for linting, and object attributes completion (e.g. jedi, ruff).
Installation is pretty easy (project is available on PyPI), just run (either in virtualenv, or globally):
pip install import-completer
Installation in your editor (example for Neovim):
vim.lsp.config('import_completer', {
cmd = {'py-import-completer-server'},
filetypes = {'python'},
root_markers = {'pyproject.toml', 'setup.py', '.git'},
})
vim.lsp.enable('import_completer')
More information available at GitHub repository (https://github.com/maniek2332/py-import-completer).
1
u/Yuta_from_JJhigh 15d ago
Hi everyone! 👋 I'm an 18-year-old BCA student from India, and I recently built Career Guardian AI, an AI-powered career guidance platform for the Kaggle AI Agents Capstone. 🚀 Features AI-powered resume analysis Career recommendations Skill gap detection Personalized learning roadmap Multi-agent AI workflow 🛠️ Tech Stack Python FastAPI React Gemini API This has been my biggest Python project so far, and I'd really appreciate feedback on the backend architecture, project structure, code organization, or ideas for improvement. GitHub: https://github.com/Samdarshil/Career-Guardian-AI� I'm not looking for stars—I genuinely want to improve as a developer. Any feedback is greatly appreciated. Thanks! 🙌
1
u/Bitter-Flamingo-3351 15d ago
Built a symbolic regression library in pure Python GP_ELITE.
Given (X, y) data it searches for a readable formula instead of training a black box. Sanity-check demo: feed it just the 8 planets (distance from sun, orbital period), it comes back with T = a^1.5, R² = 1.000000 — Kepler's third law. Not new physics, just the standard "does it actually find real relationships" test for this kind of tool. examples/kepler_demo.py if you want to run it yourself.
Recent versions added the stuff that makes it usable in practice: Levenberg-Marquardt for constant fitting (a 4π comes back as an exact 4π), multi-restart so you're not at the mercy of one lucky/unlucky seed, a Pareto front instead of one champion formula, and a guarded forecasting mode for extrapolating trends without the usual GP blow-ups.
Ran it against gplearn on 15 Feynman physics equations, same data/splits: 10/15 exact recovery vs 6/15 for gplearn. gplearn chokes as soon as a constant like 1/2 or 4π shows up no real constant optimizer. Benchmark scripts are in the repo if you want to check the numbers yourself (seeded, PYTHONHASHSEED=0).
pip install gp-elite. Pure Python/NumPy, no Julia/C++ toolchain like PySR or Operon (which are faster/better at scale, to be clear — this is for when you just want pip install and go).
Honest limits: noisy data wrecks the symbolic recovery even when the fit stays good, non-smooth targets (anything with |x|) are hard, and it degrades past ~6 variables with junk features.
1
u/Ok-Paramedic-6169 14d ago
https://sourceforge.net/projects/pyinstaller-of-death/
Pyinstaller of Death is a GUI frontend for Pyinstaller. It's helpful when you have a lot of imports or need to work with a venv.
https://sourceforge.net/projects/venv-of-death/
VENV of Death is a virtual environment manager aimed at Python coders.
1
u/KnowledgeCorrect9949 14d ago
Qué hace mi proyecto
Windows-Shutdown-Scheduler es una app de escritorio (Python + Tkinter) que programa el apagado de tu PC, con una interfaz animada en vez del típico shutdown por terminal. Incluye:
- Temporizadores rápidos (1, 5, 15, 30 min) o tiempo personalizado
- Detección de app a pantalla completa: si detecta un juego activo, avisa y permite posponer 10 min en vez de cortar la partida
- Apagado automático cuando termina una descarga (Steam, Epic, Battle.net, etc.) — no existe una API oficial para esto, así que lo resuelvo monitorizando la velocidad de red del sistema con `psutil` y confirmando el final tras un periodo sostenido de baja actividad, para evitar falsos positivos por pausas puntuales
- Bandeja del sistema (`pystray`), notificaciones nativas de Windows (`win10toast`), configuración persistente en JSON
- Detecta el idioma de Windows automáticamente (ES/EN) vía `ctypes.windll.kernel32.GetUserDefaultUILanguage()`, con toggle manual
Empaquetado como .exe standalone con PyInstaller.
Audiencia objetivo
Un proyecto personal/hobby, pensado para gente que quiere dejar una descarga larga o una partida corriendo y no quedarse esperando para apagar el PC a mano. No está pensado para producción ni entornos empresariales, es una herramienta de uso diario para PC gaming.
Comparación
A diferencia del Programador de tareas de Windows (que puede programar apagados pero sin lógica condicional), esta app añade detección activa de contexto (juego en curso, descarga en curso) en vez de solo un timer fijo. Existen herramientas similares tipo "Wise Auto Shutdown", pero suelen ser closed-source y sin la parte de detección de descargas por red.
Repo: https://github.com/ElAlehYT/Windows-Shutdown-Scheduler
1
u/Fresh_Adeptness5835 14d ago
FlowForge — database-driven pipeline orchestrator (Python/FastAPI backend)
**What My Project Does**
FlowForge lets you build and run automation pipelines — database procedures, report generation, and notifications (email via Gmail/M365/SMTP, Google Drive uploads) — all configured through a web UI instead of writing YAML or DAG code. Backend is Python (FastAPI) with PostgreSQL for storage, React frontend, and everything ships in Docker. It exposes a REST API and CLI for triggering pipelines, so it can slot into existing automation too.
**Target Audience**
Built for self-hosters, small teams, or anyone who wants scheduled DB/report/notification pipelines without standing up something as heavy as Airflow. It's a working, self-hosted tool (MIT licensed, Docker Compose install) rather than a toy demo — but it's early days, so I'd call it "production-curious" rather than "battle-tested at scale" right now.
**Comparison**
Compared to Airflow/Prefect/Dagster, FlowForge trades flexibility and scale for simplicity: no DAG-as-code, no separate scheduler infra to learn — you configure pipelines from the UI. Compared to no-code tools like n8n or Zapier, it's narrower in scope (DB jobs, reports, notifications) but self-hosted, Python-native, and free of per-task pricing.
Repo: https://github.com/jagdeepvirdi/flowforge
Full transparency on AI involvement: I wrote the core Python automation/DB logic myself, then used Claude Code to help build out the surrounding application (FastAPI backend structure, React frontend, Docker packaging, docs) around that logic. I directed the architecture and reviewed/tested what it produced.
1
u/sqjoatmon 14d ago
DocstringException: A metaclass and superclass for custom exception generation using just the class docstring.
What My Project Does
Create a custom exception whose message is simply the contents of its docstring, optionally with some substituted arguments using string.Template. E.g.:
class MyError(DocstringException):
"""There was an error."""
# Leading '++' signifies that there are placeholders to replace.
class MyErrorWithArgs(DocstringException):
"""++There was an error with args: ${first} ${second}."""
try:
raise MyError
except MyError as err:
assert err.args[0] == "There was an error."
try:
raise MyErrorWithArgs(first="abc", second=123)
except MyErrorWithArgs as err:
assert err.args[0] == "There was an error with args: abc 123."""
Target Audience
Anyone who like custom exceptions with informative messages but hates the boilerplate.
Comparison
The normal way to do this has much more boilerplate:
class MyError(Exception):
"""Raised when my error happens."""
def __init__(self) -> None:
super().__init__("There was an error.")
class MyErrorWithArgs(Exception):
"""Raised when there is an error with args."""
def __init__(self, first: str, second: int) -> None:
super().__init__(f"There was an error with args: {first} {second}")
The downside to the DocstringException version is that there is no way to statically determine if the arguments to the exception match the placeholders in the template string. I debated using the substitute() or safe_substitute() method of string.Template and eventually went with the latter as it seemed better to not raise an exception if the args are wrong.
1
u/gabor_bernat 14d ago
turbohtml — a fast, typed, C-accelerated HTML toolkit
What My Project Does
turbohtml covers the whole HTML workflow in one library: parse (WHATWG), query with CSS selectors and XPath, sanitize untrusted markup, convert to Markdown or plain text, extract articles/tables/JSON-LD/OpenGraph, detect encodings, and minify HTML/CSS/JS. The hot path is a C extension over a single arena; the Python layer is a thin, fully typed facade, and it runs on the free-threaded build.
Target Audience
Production use for anyone parsing or scraping real-world HTML who wants speed and a typed API. It parses about 280x faster than BeautifulSoup and tokenizes about 15x faster than html.parser in my benchmarks, and CSS select runs about 77x faster than BeautifulSoup.
Comparison
It is a clean break rather than a drop-in for BeautifulSoup or lxml, so existing code needs a port; the docs include migration guides for both, plus html5lib, markupsafe, and the standard library. Unlike single-purpose tools (bleach for sanitizing, markdownify for Markdown, chardet for encoding), it is one dependency for all of them.
Source: https://github.com/tox-dev/turbohtml Docs: https://turbohtml.readthedocs.io/en/stable/ How it works: https://bernat.tech/posts/blazing-fast-html-parser/
1
u/Physical_Zombie4764 13d ago
git-why — CLI that reconstructs why a line of code exists from git history, instead of just who touched it. The moment that made me build it: 11pm, a six-line guard clause that looks wrong, git blame points to someone who left three years ago, commit message just says "fix." git-why reads the commits and diffs around that line and rebuilds the story — offline, no API key — or hands the context to Claude/GPT/Gemini/Ollama for a narrated version. pip install git-why · github.com/Sameer988/git-why · MIT, v0.1.0, actively building (VS Code extension next).
1
u/vactower 13d ago
FastPrompter - A local-first desktop workspace for prompts, snippets and scratchpads (Python + PyQt6)
What My Project Does
FastPrompter is a Windows desktop application written in Python and PyQt6 that gives instant access to prompts, snippets and temporary notes through a global hotkey.
The original goal was very small: open a lightweight editor anywhere with a single keypress instead of constantly switching between applications.
Over time it evolved into a local-first workspace with:
- Persistent scratchpads ("Silos")
- Named snippets with one-key insertion
- Multiple independent projects
- Automatic SQLite persistence
- Markdown editing
- Archive system
- Portable mode (no installation required)
- Custom themes
- Global hotkeys
- Drag-and-drop support
Everything is stored locally. There are no online services, accounts or telemetry.
The project is built entirely in Python with PyQt6 and packaged as a standalone executable using Nuitka.
Repository:
https://github.com/vacterro/FastPrompter
Target Audience
This project is intended for real daily use rather than as a learning exercise.
The primary audience is people who spend a significant part of their day switching between AI tools, editors, documentation and browsers.
Typical users include:
- Python developers
- AI power users
- Prompt engineers
- Technical writers
- Anyone who frequently reuses text snippets or temporary drafts
Although I originally built it for my own workflow, it has gradually become my primary scratchpad application.
Comparison
There are several excellent tools that partially solve similar problems, but none matched the workflow I wanted.
Clipboard managers such as CopyQ or Ditto are excellent at clipboard history, but aren't designed around persistent project-based prompt collections.
Knowledge-base tools like Obsidian or Notion are great for long-term documentation, but they feel too heavyweight for hundreds of tiny interactions throughout the day.
Text expansion utilities focus on text insertion rather than editing, organizing and maintaining temporary work.
FastPrompter sits somewhere between those categories.
Instead of replacing a notes application or clipboard manager, it aims to reduce friction by providing an always-available local workspace that appears instantly, saves automatically and disappears just as quickly.
One unexpected lesson from building it was that most of the work wasn't implementing features, but refining hundreds of tiny interaction details that only become obvious after using the application every day for months.
I'd appreciate feedback from anyone who builds desktop software in Python or has solved similar UX problems.
1
u/i-like-my-cats-0 12d ago
Happyhooks: Simplified Discord webhooks with aiohttp.
What my Package does:
My package (specifically happyhooks) is a PyPi package I made that makes sending, editing, and deleting messages with Discord webhooks much easier and simpler without much problem! It is asynchronous, using the aiohttp Python library so happyhooks doesn't block your script!
Happyhooks also supports Discord embeds | rich embeds and attachments, with built-in ratelimit handling so your script doesn't get stopped by Discord's 429: Too many requests status code.
My Target Audience:
Happyhook's target audience are Discord developers who either hate how they need to use a library like requests or aiohttp to even send a message with webhooks, or just want sending messages with Discord webhooks much easier and simpler!
Comparison
Discord Python frameworks like discord.py, in my opinion, does too much to send a normal webhook text message in Discord, meanwhile happyhooks simplifies it alot when sending text messages! Here's how you can send in both discord.py and happyhooks:
discord.py: Create an aiohttp ClientSession, get your webhook with Webhook.from_str(), and finally send a text message with the .send() method.
'happyhooks': Create a webhook object via Webhook(), and send it via .send(), no aiohttp ClientSession needed!
GitHub Repo: https://github.com/FernUnreal/happyhooks
Installable via pip: pip install happyhooks
Report any issues if possible!
1
u/Prestigious_Act3077 11d ago
Velocity: a keyless FastAPI service that fuses 15 live geospatial feeds into cited incidents (and runs as an MCP server)
What My Project Does
Velocity is a self-hostable OSINT console. A FastAPI backend ingests around 15 live open feeds (ADS-B aircraft, AIS vessels, CelesTrak satellites, USGS quakes, GDELT conflict events, GPSJam-method jamming, Sentinel-1 SAR dark-vessel detection) and correlates them server-side instead of leaving you to eyeball six tabs. When signals converge, say a vessel goes AIS-dark next to a GPS-jamming cell and a spoofed track in the same place and time, it promotes that into a single incident with a cited summary. A Vite/React/CesiumJS front end renders it on a 3D globe over websockets. The whole thing runs keyless for the core feeds with one docker compose up. It also exposes a Model Context Protocol server (MCP Python SDK), so an AI agent can query the live feeds and get bounded JSON back.
Some Python-specific decisions worth discussing: there's no database in Phase 1. Live state is an in-process bounded observation store plus a disk tile cache, and only the 7-day position-track replay buffer persists (SQLite). That's what makes it a one-command run. Postgres/PostGIS/TimescaleDB is the planned Phase-2 upgrade. 940+ tests cover unit, route, and MCP-degradation paths (backend down returns a structured error; Ollama absent returns raw JSON rather than crashing the tool call).
Target Audience
A single analyst or hobbyist who wants a fused live picture on their own hardware, not a production, multi-tenant deployment. It's deliberately single-operator: one optional API key, no accounts or roles, most state in memory (restart means incident history is gone). Treat it as a serious personal/research tool, not a hardened service. The default 2D map runs on integrated graphics; the optional 3D-satellite mode is a VRAM hog.
Comparison
Single-feed sites do one thing well (Flightradar24 for planes, MarineTraffic for ships, GPSJam for jamming), but you're the one holding six tabs and correlating in your head. Velocity goes after the seam between feeds: the fusion/correlation layer is the product, not the individual layers. Versus a Grafana or Kepler.gl dashboard, it's not just plotting points; it runs cross-domain correlation rules and emits cited incidents. And unlike most "live data" MCP servers that wrap a single API, it sits on an already-correlated multi-feed picture and returns token-bounded JSON so an agent can sweep the planet in a few hundred tokens.
Keyless core, Apache-2.0, repo in comments. I'd genuinely like a critique of the in-memory-first choice and the correlation approach.
1
u/chinmay_3107 from __future__ import 4.0 11d ago
We built Talika because our Gherkin Data Tables were getting out of hand
GitHub: https://github.com/talikadev/talika
Docs: https://talikadev.github.io/talika/
We use Gherkin Data Tables a lot in our BDD tests, and the problem was not the tables themselves. The problem was everything around them.
Any time we needed more freedom in the table, like richer cell values, optional fields, validation, type conversion, or mapping rows into real objects, we ended up writing unstructured parsing logic inside step definitions.
It worked, but it did not feel clean. The same patterns kept showing up again and again, and every new complex table added more custom code.
So we built Talika to solve our own problem first, then generalized it into a reusable package for Python BDD projects.
Talika gives you a structured way to handle complex Gherkin Data Tables, with features like:
- Cell DSL for expressive values inside table cells
- Table transformers for converting raw tables into Python objects
- reusable validation and parsing rules
- type conversion without repetitive manual casting
- cleaner row and column mapping
- step definitions that stay focused on behavior instead of table parsing
It is inspired by the power of Cucumber JVM DataTables, but built around the way we wanted to work in Python.
If your Gherkin Data Tables are useful but your step definitions are slowly becoming a pile of custom parsing code, Talika might be worth checking out.
1
u/ayoub3bidi 10d ago
Built a Python automation toolkit called Swiss Knife: started as scripts I kept rewriting for myself (dedup files, bulk rename, csv↔json, password gen) and turned it into something installable.
pip install swiss-knife-py Gets you 4 CLI tools:
sk-duplicates ~/Downloads --algorithm sha256 --min-size 1MB
sk-csv data.csv --format json --pretty
sk-password --length 16 --exclude-ambiguous
sk-rename 'IMG_(\d+)' 'photo_\1' ~/Pictures --dry-run
Repo also has 28 standalone scripts (not in the pip package, kept separate on purpose), screenshot scheduler, disk analyzer, network scanner, dead code detector, that kind of thing for stuff too niche to justify a stable API.
Just shipped v0.2.0 yesterday with a 19-function utilities module (env parsing, camelCase conversion, UUID checks).
1
u/baconrancher666 10d ago
ASUS BS-BE18000 API implementation to a CLI tool. Use it to talk to your BS-BE18000 router without using the clunky UI.
Used Claude to help with parsing tcpdump and other protocol discovery.
1
u/oryste 10d ago
specllm – makes any LLM behave like a normal REST API
What My Project Does
specllm makes any LLM behave like a normal REST API. Define an OpenAPI spec, specllm serves it — validated, cached, retried automatically. The caller gets guaranteed JSON back and never knows an LLM is involved.
bash
pip install specllm
python -m specllm.demo # try it in 30 seconds, no API key needed
With a real LLM, it's one line in the spec:
yaml
info:
x-specllm-model: claude-sonnet-4-20250514
No provider class, no config. Just the spec.
Target Audience
Developers shipping LLMs into production as REST APIs.
Comparison
Unlike langchain or instructor, specllm is spec-first: the OpenAPI spec is the implementation. No glue code.
1
u/ComprehensiveBake617 9d ago
pytest-rs — a drop-in Rust reimplementation of pytest, up to 3x faster with --cov / -n
pytest-rs reimplements pytest's runtime in Rust — startup, collection, fixtures, coverage, reporting run as native code, while test bodies still execute on embedded CPython. Drop-in: same config files, same CLI flags, no changes to your tests.
uv add --dev pytest-rs
pytest-rs -n 4 --cov=mypkg
7 plugins (pytest-asyncio, anyio, pytest-mock, pytest-cov, pytest-split, pytest-benchmark, pytest-xdist) are reimplemented natively for speed; any other pytest11 plugin loads as-is through a compat shim.
1.3-1.4x faster plain, up to 3x with --cov/-n (full numbers in README). CI runs pytest's own upstream suite plus real-world projects (pandas, fastapi, scikit-learn, click, ...) unmodified — 97-100% pass rate.
Target audience: projects with test suites big enough that CI time hurts, especially with --cov or -n. Alpha stage: Unix only, no --pdb yet.
Comparison: other speedup tools work around pytest; this replaces its runtime while keeping the same config/plugin API/CLI, so existing setups mostly just work.
Built with heavy AI assistance (Claude Code) — correctness is enforced by running pytest's own upstream suite plus real-world projects' suites unmodified in CI, not just claimed.
1
u/matthew3k 7d ago
What my project Does
A python library that automatically generates filter, search, and sorting fields for any SQLAlchemy model in FastAPI, with native support for JSONB containment (contains), key presence (has_key), and case‑insensitive text search inside JSON values.
Example of usage (create your own custom filter for your orm model):
class UserFilter(DynamicFilter):
db_model = User # your model
exact_fields = ["id", "email"]
search_fields = ["name", "bio"] # generates name__ilike, bio__ilike
range_fields = ["created_at"] # generates created_at__gte, __lte
contains_fields = ["tags", "metadata"] # tags__contains (list), metadata__contains (dict) + metadata__has_key
json_search_fields = ["metadata"] # generates metadata__value_ilike
default_order_by = ["-created_at"]
And then use it in your endpoint as a dependency:
app.get("/users")
def get_users(
filter: UserFilter = Depends(UserFilter), # your filter here
):
query = filter.filter(session.query(User))
return query.all()
GitHub: https://github.com/matfatcat/fastapi-dynamic-filter/
PyPI: https://pypi.org/project/fastapi-dynamic-filter/
1
u/Beautiful-Beat-8618 6d ago
Quorum — five AI agents with conflicting incentives deliberate your decision (one is a skeptic whose only job is to attack the consensus). Emits a hash-verified "Decision Record" so you can audit the deliberation later. `pip install quorum-council`, demo runs with zero API keys. AGPL. https://github.com/minghui31/quorum-ai
1
u/Competitive-Pride280 6d ago
ghostbox: disposable, anonymous email addresses from your terminal (zero setup)
I built ghostbox, a tiny dependency-free CLI tool that spins up a temporary, anonymous email inbox in seconds; no sign-up, no API key to configure.
Usage is literally :
git clone https://github.com/01110001/ghostbox.git
cd ghostbox
python3 ghostbox.py
That's it; the address is copied to your clipboard, and you can start watching incoming mail in the same terminal.
Repo: https://github.com/01110001/ghostbox
Feedback and PRs are very welcome.
1
u/Blockpair 5d ago
Introduction
I got tired of feeling like Python was a dead end for high-performance networking. Languages like Go can handle hundreds of thousands of requests per second, scale across multiple threads, and keep running when one task stalls.
So I built the Python equivalent: Runloom, a C extension that provides a multi-threaded, stackful runtime for free-threaded Python, with networking performance comparable to Go.
What My Project Does
You dispatch functions to the runtime and it assigns them to a thread. Inside these functions you write regular blocking code. Blocking suspends to the runtime and the function resumes when results are ready. It's extremely fast as it's designed to run across real OS threads. And its been engineered to be as light-weight as possible.
Target Audience
This is mostly aimed at advanced Python engineers who understand Python's concurrency model, how it does networking, and want to explore the upper limits. Consider the runtime to be experimental.
Trying this out
Linux users can install directly from pip as I've built the wheel there.
Install pyenv
pyenv install 3.14.4t
pyenv local 3.14.4t
python -m pip install runloom
For Mac and Windows -- the software is less tested so you would have to build it yourself. Though I'd probably only stick to Linux for now!
Why is this new
The software is different compared to similar runtimes due to multi-threading support and an optional patch to CPython allows for stalled threads to have functions on them resumed on other threads.
GitHub Link
1
u/Individual-Show7812 5d ago
Solo dev here. apitap (pip install apitap) copies whole tables between databases as fast as the machines allow, in bounded memory. Rust engine, one-line Python API:
import apitap
apitap.transfer("postgres://…/src", "clickhouse://…/dst", table="events")
Routes: Postgres/MySQL → Postgres, MySQL, ClickHouse, BigQuery. It never materializes rows in Python — PG→PG relays raw binary COPY bytes, PG→ClickHouse transcodes to RowBinary in flight. 1M rows PG→CH lands in ~0.4s on stock servers, checksum-validated.
This week's 0.7.0 adds multi-table transfers: tables=[...] or a whole schema=, through ONE memory budget — big tables take many parallel range pipes, small ones take one and overlap, and peak RSS stays at the single-table ceiling no matter the table count.
The test I care most about, because it's the constraint I design for (small containers, not big warehouse boxes): 10 TPC-H tables × 5M rows (50M total, real TPC-H data) through a docker container capped at 0.5 CPU / 256MB, into stock Postgres:
- apitap (one call): 2.8 min, 53MB peak RSS, 10/10 checksums
- dlt 1.29 (native multi-table, both backends): OOM-killed in seconds, 0 rows
- ingestr 1.1 (sequential — its partition mode refuses
replaceloads): 20.6 min - ingestr, 10 parallel processes: lost 7 of 10 tables to the OOM killer, silently
To be fair to both: dlt and ingestr do far more than apitap (many connectors, schema evolution, API sources). apitap is deliberately narrow — DB→DB table copies done fast. And MySQL as a source bottlenecks everyone including me: the server's row-produce rate is the wall, apitap just idles at 13% CPU there.
Everything is reproducible: methodology, raw logs, GCP provisioning scripts, and the 256MB harness are all in benchmarks/. If any number looks unfair, tell me — I'd rather be corrected than quietly wrong.
Source: https://github.com/apitap/apitap-lib Docs: https://github.com/apitap/apitap-lib/blob/main/docs/usage.md
Built in the open with Claude Code, disclosed in the same spirit as the numbers.
1
u/Fwhenth 5d ago
Hi!! I coded an audio player in Python as other audio players(YT Music, Spotify, innertube, etc) are all too heavy to run in the background of my devices. BnuuyPlayer was designed for ease of installation on Termux, only requiring yt-dlp and requests (It plays audio using MPV, and can handle metadata write/read/searching via mutagen, although these are both optional dependencies, with yt-dlp and requests being required)
BnuuyPlayer's repository) BnuuyPlayer (more detailed install instructions, changelog, features, etc)
BnuuyPlayer's full feature list
Feature summary Audio playback Downloading(you can add your own sites to BnuuyPlayer's whitelist, although it already prepackages several sites) Streaming songs/playlists Lyric downloading (done automatically during download, or to already downloaded songs if they have metadata + mutagen is installed) BnuuyFolders(Groups of your playlists, these are stored internally within bnuuyplayer and dont interact with your file system)
Installation is 1: pkg install python 2: pip install bnuuyplayer
And to run BnuuyPlayer, enter bnuy
Optionally(if you want audio capability) pkg install mpv
And if you want to expose BnuuyPlayer's db and code(aswell as any folders you make using BnuuyPlayer) 1: pkg install git 2: cd path/to/your/dir 3: git clone https://github.com/whenth01/BnuuyPlayer.git And if you want audio playback and to use bnuuyplayer in this state; 1: pkg install python mpv 2: pip install yt-dlp requests mutagen 3: cd path/to/bnuuyplayer 4: python -m BnuuyPlayerCode
Hope you enjoy!! (if you do use it) some of the text formatting may have been messed up because of reddit getting rid of newlines:(
1
u/mr_enesim 5d ago
HTeaLeaf: A web framework with SSR and JS DSL
https://github.com/Az107/HTeaLeaf
Hi, I have some time working on this just for fun but, maybe, could be useful for someone and, in the meantime, get some feedback and opinion. HTeaLeaf is a declarative web framework where components are python functions.
from htealeaf.elements import div, h1
from htealeaf import HteaLeaf
app = HteaLeaf()
@app.route("/")
def home():
return div(h1("Hello World"))
It also had a JS DSL, to translate python to basic subset of JS, Stores (shared state between front and back), route handling, local state beside others.
To be transparent, the most of the code is handwritten but AI was used to document, review and some minor fixes.
1
u/shadow-monarch-93 4d ago
Lumen — A Hybrid Online/Offline AI Document Vault built with CustomTkinter
I got tired of clumsy AI chatbots that blindly mix up document context with generic web searches, hallucinating completely random answers when my uploaded PDFs don't actually contain the response. So, I built Lumen—a local-first, privacy-focused RAG workspace designed to strictly anchor AI intelligence to your actual files
-> What it is: A dark-themed desktop document vault designed to let you interact privately with multiple PDFs simultaneously. It ensures the AI only speaks from the data you provide—eliminating external web bias and random fabrications.
-> How it helps you: Instead of letting the AI guess or wander off-topic, Lumen restricts the context window strictly to your indexed files. If the answer isn't in your documents, the system grounded parameters prevent it from making up facts, giving you deterministic, trustworthy insights.
-> Dual Engine Architecture (Online & Offline):
Online Mode: Routes your securely filtered document context through cloud-scale APIs for maximum analytical reasoning speed.Offline Mode: Drops back entirely to fully local execution architectures (Ollama+ local embeddings) so you can parse sensitive files with zero internet connection.
-> Some Built-In Functions:
Incremental Indexing: Drops new context items dynamically into the active session without wiping or rewriting the existing vector tree.Granular Data Scrubbing: A dedicated✕button on the sidebar layout isolates and purges selective file records safely on a non-blocking UI thread loop.Maximal Marginal Relevance (MMR): An intelligent search router that penalizes topic redundancy, forcing the context engine to look across completely distinct files instead of letting one massive document crowd out smaller datasets.Smart Citation Map: Tracks exactly where your answers come from, explicitly appending the precise File Name and Page Number to the bottom of every generated text chunk.
The code is fully modular, decoupled (/core, /interface), and can be deployed instantly using a pre-compiled, zero-configuration Windows binary (.exe). I'd love to hear your thoughts on how you handle strict RAG grounding or context diversity routing!
🔗 GitHub Link: https://github.com/coder1397924/Lumen
1
u/AroraSir It works on my machine 3d ago
Hi everyone,
I wanted to share a project I just released.
GravityBridge is a local HTTP reverse proxy written entirely in Python standard library (no pip install needed for the proxy itself). It does these things:
- Dynamically discovers the local Antigravity AI agent SSL port and proxies it to mobile browsers
- Serves a wireless file explorer that uses subprocess calls to ADB for phone storage browsing
- Implements session tokens, constant-time PIN comparison, rate limiting, and a math captcha for brute force protection, all using hashlib, hmac, and secrets from stdlib
The design goal was keeping the runtime completely self-contained so anyone with Python 3.10+ can run it with just one command.
GitHub: https://github.com/Arora-Sir/Gravity-Bridge
Would appreciate any feedback on the code structure or security approach!
1
u/hirolau 3d ago
Fillx: Fill Excel templates with Python using named cells and tables
What My Project Does:
Hey everyone, I built a small Python package called Fillxl after getting tired of the usual headaches when generating Excel reports at work. The main idea is simple: you create a normal Excel template (by hand or however you like), name the cells/ranges/tables you want to fill, and then Fillxl handles the rest from Python. No more hard-coded cell references like B12 or Sheet1!A3:Z100 that break the moment someone adds a row or moves a column. I use it for:
- Populating monthly/quarterly reports with data from Python pipelines
- Debugging complex data flows by dumping intermediate results into nicely formatted Excel files
- Personal stuff where I want the output to look professional without fighting openpyxl directly
Charts, formulas, conditional formatting, and everything else you set up in the template stay intact. You just feed it data and it fills the named ranges/tables.
Target Audience:
Anyone making Excel reports from Python. For now this is beta, but I do not expect to change much unless users finds bugs.
Alternatives:
There are a few tools out there. openpyxl and xlsxwriter are great, but they are lower level and expects you to build more with code. There is also xltemplate (https://github.com/tsw-devel/excel-template) which is simliar, but it only supports openpyxl, and you still need to hard code cells. I have not found any similar package using named cells and tables.
Repo is here if anyone's interested:
https://github.com/hirolau/fillxl
Please have a look!
1
u/reddit-laa 3d ago
I built a secure Telegram Bot bridge to control my local AI coding agent (Google Antigravity SDK) from my phone
Hey everyone,
I wanted a way to interact with Google's Antigravity agent running on my Mac directly from my phone when I'm away from my desk. However, letting an AI agent execute arbitrary commands on a personal machine via a public Telegram webhook is a security nightmare.
To solve this, I built and open-sourced this Python bridge with three core safety and reliability patterns:
- Selective Safety Policies: It uses Antigravity's hook engine to deny all shell execution by default, whitelisting only read-only filesystem commands and a custom predicate check that allows
run_commandonly forgitcommands (e.g. status, diff, commit). - Workspace & Context Isolation: You can run
/project /absolute/pathin Telegram to switch repositories. The bot automatically targets the new folder and loads the conversation history specific to that directory, preventing context bleed. - Self-Healing Reconnect: Local websocket connections to the Antigravity backend can drop or time out. The bot checks socket integrity before each turn and automatically recycles dead connections transparently without losing conversation history.
It is fully open-source and ready to run.
Check it out here: https://github.com/alifarooqi/agy-telegram-bridge
I'd love to hear your thoughts on the security model, or suggestions on other safe commands I should whitelist!
1
u/maltzsama 3d ago
Sumeh: data quality validation across 14 engines — looking for testers/contributors
My Project Does
Sumeh is a data quality validation library. You define rules once (is_unique, is_complete, has_pattern, is_between, etc.) and run the same rule list against Pandas, Polars, PySpark, Dask, DuckDB, BigQuery, Snowflake, Athena, PyFlink, Ray, and more — always with the same return type, a ValidationReport object.
The technical differentiator is single-pass bifurcation: it splits good rows from bad rows (good_df, bad_df = report.split()) in the same scan that computes the metrics, without scanning the dataset twice and without calling .collect() on Spark (which causes driver OOM on large datasets — a real limitation in libraries like Deequ).
from sumeh import pandas
from sumeh.core.rules.rule_model import RuleDefinition
rules = [
RuleDefinition(field="email", check_type="is_complete", threshold=1.0),
RuleDefinition(field="age", check_type="is_between", min_value=18, max_value=120),
]
report = pandas.validate(df, rules)
good_df, bad_df = report.split()
print(f"Pass rate: {report.pass_rate:.2%}")
Target Audience
Not production-ready yet — that's what this post is for. The foundation is the complete rewrite that became v2.0 (namespace-first API, dropped the cuallee dependency, SQL generation via SQLGlot AST instead of string concatenation); v3.0, just released, added functionality on top without breaking the API. This is a good stage to find problems and shape direction: less mature engines, SQL dialect edge cases, unexpected bifurcation behavior — all fair game.
If you work with data pipelines and have been burned by Great Expectations being too heavy, or by pandera not covering aggregation/SQL, come poke holes in this and help figure out where it breaks.
Comparison
Great Expectations is a full platform (suites, checkpoints, data context) — Sumeh is just a library, you import it and go. Soda Core pushes you toward SodaCL/SodaCloud, and the open-source layer is thin. Pandera is great for schema/type checks but doesn't do aggregation or SQL engines. cuallee has a similar API (it actually inspired Sumeh) but covers fewer engines and has no SQL generation or profiler.
Where the project needs help:
- Newer/less-tested engines: Ray Data and PyFlink have weaker test coverage than Pandas/Spark — if you use those stacks, testing here is worth a lot.
- SQLGlot-based SQL compilation: every dialect (Snowflake, Trino, Doris, Athena...) has its own quirks. Running
sumeh sqlagainst a real production schema and comparing the generated SQL would help enormously. - Bifurcation at scale: tested so far on dev-sized datasets, not real production volume. Running it against something large and reporting back on memory, time, and correctness would be gold.
- Date and schema rules: the areas with the most recent coverage gaps.
Repo: https://github.com/maltzsama/sumeh Contributing: checkout develop, poetry install --with dev, poetry run pytest
Issues, PRs, and especially bug reports are very welcome — particularly in the areas above. Open an issue with a traceback and it'll get read and acted on.
1
u/TomAlborough 3d ago
A simple, Python-based data handling pattern
In order to execute some recent testing projects I have been developing a minimal, Python-based data handling pattern named gDS. I'm looking for feedback on its usability, architecture, concurrency handling and scalability.
The website https://TestingComplexSystems.com explores both testing and gDS. It presents a gDS compiler and 4 case studies housed in a GitHub repo.
1
u/SlimThiccs 3d ago
I finally stopped getting blocked every time I tried pulling Instagram data
For the longest time, my biggest problem wasn't writing Python code—it was everything around it.
I was trying to scrape , and it felt like I spent more time fighting Instagram than building my project. Between proxies, broken selectors, changing endpoints, login issues, and getting blocked or banned after , I was constantly fixing infrastructure instead of working on the actual application.
Eventually I decided to stop trying to maintain the whole scraping stack myself.
I switched to HikerAPI (hikerapi.com), which exposes Instagram data through a hosted REST API using an x-access-key header. My code became a lot simpler:
import requests
headers = {"x-access-key": "YOUR_KEY"}
user = requests.get(
"https://api.hikerapi.com/v2/user/by/username?username=apple",
headers=headers
).json()
resp = requests.get(
"https://api.hikerapi.com/gql/user/followers/chunk",
params={"user_id": user["pk"]},
headers=headers,
)
print(resp.json())
I know some people prefer rolling their own scraper, and I get why. If your use case is large enough or you enjoy maintaining that infrastructure, it can absolutely make sense.
For me, though, I realized I was spending way more time maintaining proxies and keeping everything alive than actually building . Paying from $0.001/request (with 100 free requests to try it) ended up being a tradeoff I was happy with because it let me focus on my Python code instead of constantly debugging scraping issues.
I'm still curious what the long-term balance looks like between maintaining your own scraper versus using a hosted API, but for my project this has been a much better fit.
Has anyone else here been fighting the same cycle of proxies, bans, and broken scraping setups? If so, what finally worked for you?
1
u/AverrageGod 2d ago
Anyone looking for 1:1 Python mentorship? (Backend, AI & real-world projects)
Hey everyone,
I've been thinking about doing a few one-on-one Python mentoring sessions outside of work and wanted to see if there's any interest.
I've been working with Python professionally for the past 5+ years, mainly building production backend systems with FastAPI. I've also been on the startup side of things, so I've spent a lot of time taking products from an idea to something real that people use.
A lot of learning resources teach you syntax, but not necessarily how software is actually built in production. Things like:
- structuring a project
- writing clean, maintainable code
- APIs with FastAPI
- databases
- authentication
- logging & debugging
- testing
- deployment
- working with Git
- and using Python to build AI-powered applications
If you're:
- just getting started with programming,
- switching into software engineering,
- or want to become comfortable building real Python projects,
I'd be happy to help.
The idea is to keep it completely personalized—1:1 sessions where we work toward your goals instead of following a generic course.
I'm just gauging interest for now. If this sounds useful, leave a comment or send me a DM with what you're trying to learn.
1
u/mavwolverine 2d ago
fast-agent-stack: production infra for AI agents, bring your own framework
There's no shortage of agentic AI frameworks in Python. Strands, Pydantic AI, LangGraph, CrewAI, AutoGen. They handle the agent logic well.
But every time you take one to production, you're building the same supporting layer from scratch: FastAPI setup, auth, database with migrations, vector search, background workers, rate limiting, observability. Wiring all of that together takes almost as much time as the core solution itself.
So I built fast-agent-stack. The production infrastructure layer for AI agent applications.
It gives you everything except the agent runtime:
- FastAPI + SQLAlchemy async + Alembic migrations
- JWT/session auth with RBAC and API keys
- Redis/Valkey for rate limiting, caching, sessions
- Vector stores (Qdrant, pgvector, OpenSearch, Weaviate)
- RAG pipeline (chunk, embed, store, retrieve)
- Background tasks (Dramatiq) + scheduling (Periodiq)
- OpenTelemetry tracing
- One-command scaffolder to a running project
- BYOAF
You bring your own agent framework. Strands, Pydantic AI, LangGraph. They wire into plain FastAPI routes and access the infra through normal Python imports. No bridging, no adapters.
There's also a built-in `@app.agent()` for simple single-agent endpoints. Think of it like FastAPI's `BackgroundTasks`. Convenient until you outgrow it, then you graduate to a real framework.
First alpha is live (0.1.0a1, API may still change):
- `uv pip install fast-agent-stack==0.1.0a1`
- GitHub: https://github.com/vkanwade/fast-agent-stack
- Docs: https://fast-agent-stack.readthedocs.io
Tested end-to-end with both Strands Agents and Pydantic AI. Full tutorial that builds a Document Q&A app from scratch.
Early stage, looking for feedback. What infrastructure do you keep rebuilding for every AI project?
1
u/OliMoli2137 1d ago
Swaybeing, a screentime tracker daemon for SwayWM/i3
What it does
Swaybeing monitors the time you spend in each program. It splits the day into equal time periods (3h by default) and sorts the usage stats into them. And most importantly, it has a human-written codebase
Target audience
Users of SwayWM / i3wm or forks who want a simple way to manage their screentime
Links
source code: https://codeberg.org/OliMoli/swaybeing
PyPI package: https://pypi.org/project/swaybeing
1
u/herchila6 1d ago
Kanari — CLI to catch silent Celery/Redis failures (ghost workers, config smells)
What My Project Does
Kanari is a Python CLI for teams running Celery + Redis. It connects to your broker and reports whether work is actually moving, not just whether the worker process is alive.
Typical commands: kanari audit (one-shot health + config analysis) and kanari agent (local continuous checks). It looks for things like workers that stay "online" but stop consuming after a broker blip, stuck/quiet workers, dangerous defaults (e.g. early ack / prefetch-related smells), and queue signals that depth-only monitoring misses. Privacy-first: it does not read task args/kwargs/payloads.
pip install kanari
Repo: https://github.com/getkanari/kanari-agent
Site: https://getkanari.com
Target Audience
Backend engineers on Django/FastAPI + Celery who don't have a dedicated SRE team. especially if you've been burned by "Flower green, users angry" or managed Redis reconnect stalls. Aimed at real staging/prod brokers, not a toy demo. Local mode works without a SaaS account.
Comparison
Flower is a great inspector when you're already looking; it doesn't wake you up and can show workers online while nothing is consumed. Generic APM (Datadog etc.) is powerful but expensive/noisy if all you need is Celery semantics. Hand-rolled scripts work until the next edge case. Kanari is narrow on purpose: Celery/Redis worker health and config, OSS CLI first, optional paid continuous later. Not trying to replace your whole observability stack.
Feedback welcome, especially if you've hit ghost workers or "healthy probe, dead consumer" on managed Redis. Issues/roasts on the repo are fine.
1
u/aldanlt 22h ago
sowdb – Una herramienta CLI que usa reflexión de SQLAlchemy y grafos para generar datos de prueba en Postgres que cumplan restricciones
¡Hey a todos! Sembrar (seedear) entornos de desarrollo siempre me había parecido como jugar whack-a-mole con IntegrityError excepciones. Los scripts genéricos de faker normalmente ignoran las claves foráneas, y eso termina rompiendo los inserts.
Para arreglar esto, construí sowdb, una herramienta CLI consciente del esquema escrita en Python (3.11+, con tipado usando mypy, y formateada con Ruff).
- Qué hace: Se conecta con un DSN, refleja el esquema usando SQLAlchemy, arma un grafo de dependencias a partir de las claves foráneas y hace un ordenamiento topológico para calcular un orden seguro de inserción de tablas. Luego siembra los datos usando Faker, respetando
NOT NULLyUNIQUEpara que Postgres los acepte a la primera. - A quién va dirigido: Devs y DevOps que andan buscando una alternativa ligera, sin configuración, y 100% open-source a plataformas pesadas de TDM empresarial.
Está en una etapa todavía temprana, v0.2.0. Puse un GIF de demo en el README mostrando la ejecución en la terminal. ¡Me encantaría leer sus comentarios sobre el enfoque de ordenar el grafo o la arquitectura del código!
- Repo de GitHub: https://github.com/aldanlt/sowdb
1
u/markjg 15h ago
I built a CLI that audits Python dependency licenses offline. Looking for weird edge cases. I've been building licenseproof, a CLI that scans uv.lock, poetry.lock, or requirements.txt, resolves the actual license of every dependency, and flags potential conflicts with your project's license.
It runs completely offline, never hides unknown licenses, and supports mixed Python + Node repos. I'm not trying to sell anything here.
I just want to know what weird Python packaging or licensing edge cases I've missed before I release it more broadly.
If you've been burned by bad license metadata, odd lockfiles, or packaging quirks, I'd love to hear about them.
Source-available under the Elastic License 2.0. the complete TypeScript source ships inside the npm package itself, so you can audit the zero-network-calls claim directly (npm pack licenseproof, unpack, read). Public repo lands with 1.0.
1
u/Ordinary_Narwhal8698 15h ago
bot-chassis — production plumbing for long-running Python bots
I kept rebuilding the same operational infrastructure around every Python automation, so I extracted it into a zero-dependency Python 3.11+ package.
It provides interval and timezone-aware daily scheduling, per-job exception containment, heartbeat and stale-process detection, a STOP-file kill switch, atomic JSON state, console/webhook alerts, TOML-configured process supervision, rapid-crash backoff, an independent watchdog, and a small local status dashboard.
Source: https://github.com/chrismance3-star/bot-chassis
PyPI: https://pypi.org/project/bot-chassis/
Install: pip install bot-chassis
I’d especially value blunt feedback about the boundary: which operational features belong in a small local runtime like this, and which should remain the responsibility of systemd, launchd, containers, or hosted monitoring?
1
u/Capable_Fig_1057 13h ago
Project Name - dockrx
I kept getting walls of Dockerfile lint warnings with no sense of priority, so I built a tool that scores the image and shows the highest-ROI fixes (size, cache, hardening) with copy-paste rewrites.
It's alpha and honest about it — estimates are heuristic, and auto-fix covers a subset of rules.
Free playground, no signup: https://dockrx.vercel.app
Blog (how + why): https://ankitpatil.pages.dev/blog/dockrx
GitHub: https://github.com/kiwi-07/docrx
Feedback welcome — especially where the scoring feels wrong.
1
u/FixEmergency4460 3h ago
Web CLI for AI agents (library MVP)
AI agents today burn tokens navigating messy HTML, guessing which buttons to click, and getting blocked by CAPTCHAs. Whereas site owners have no visibility into what bots are doing.
What My Project Does
I made agent-web-gate: a typed, authenticated endpoint exposed by site owners where AI agents discover capabilities, request a scoped API key, and call configured action endpoints directly.
Solves both problems: more efficient web interaction for AI agents and site owners gain visibility on bot activity.
Check out my github repo: https://github.com/devanujpatel/agent-web-gate
Up on pypi as well: https://pypi.org/project/agent-web-gate/
Comparison
OpenAI Operator, Claude for Chrome and similar tools use vision based interaction with sites which are costly, token burners and often dont work.
I am open to any feedback and if you would like to contribute feel free to dm me
1
u/ironman2606 1h ago
Building FastForge — a FastAPI + Next.js SaaS boilerplate. Basically the Python-dev equivalent of ShipFast: auth, billing, admin, email all pre-wired so you're not rebuilding the same plumbing for every new SaaS idea.
Still pre-launch, but the waitlist's live: https://fastforge.pionetix.com — early sign-ups get locked-in pricing when it ships.
Would genuinely love feedback from anyone who's used a boilerplate before (ShipFast, Bones, etc.) — what actually earned its keep vs. what you ripped out and redid yourself? Trying to nail the feature list before I lock things in.
1
u/Pytrithon 18d ago
Introduction
I have already introduced Pytrithon in its own post three times on Reddit. See:
https://www.reddit.com/r/Python/comments/1q8dwsm/pytrithon_v119_graphical_petri_net_inspired_agent/ https://www.reddit.com/r/Python/comments/1nr3qvm/pytrithon_graphical_petrinet_inspired_agent/ https://www.reddit.com/r/Python/comments/1mx9w5r/graphical_petrinet_inspired_agent_oriented/
What My Project Does
Pytrithon is a graphical Petri net inspired agent oriented programming language based on Python. It allows writing code as a two dimensional graph of interconnected elements and separates data as Places and code as Transitions. Inter Agent communication and GUI widgets are first class components of the language. Through the Monipulator, Agents can be monitored and manipulated.
Target Audience
The target audience is both experienced and novice programmers who want to try something new.
Why I Built It
I realized the power of Petri net inspired programming and the joy of having a more expressive way to specify control flow.
Comparison
There are no other visual programming languages which embed actual code into their graphs.
How To Explore
To run all included example Agents you need at least Python 3.10 installed. To install all dependencies, run the 'install' script. Then you can start up a Nexus with a Monipulator by running the 'pytrithon' script, where you can start Agents through opening them with 'crtl-o' twice and hitting the 'Open Agent' button. You can also directly specify which Agents to run through the command line by starting a Nexus, Monipulator, and Agents in one single command: 'python nexus -m <agent1> <agent2>'.
Recommended example Agents to run are: 'basic', 'prodcons', 'address', 'kata', 'calculator', 'kniffel', 'guess', 'yahtzeeserver' + multiple 'yahtzee', 'pokerserver' + multiple 'poker', 'chatserver' + multiple 'chat', 'image', 'jobapplic', and 'nethods'. As a proof of concept, I created a whole Pygame game, TMWOTY2, which is choreographed by 6 Agents as their own processes, which runs at a solid 60 frames per second. To start or open TMWOTY2 in the Monipulator, run the 'tmwoty2' or 'edittmwoty2' script. Your focus should on the 'workbench' folder, which contains all Agents and their respective Python modules; the 'Pytrithon' folder is just the backstage where the magic happens.
What Is New
Since my last post there have been numerous small fixes and improvements to the system and to several agents.
Since my penultimate post the whole system now handles Agents, Monipulators, and Nexi terminating from the network. Bookkeeping is performed, cleansing the internal structures handling all process types, making the prototype more resilient. The 'chatserver' and 'chat' Agents now show a list of Agents currently connected. This is enabled through the new 'Event' Transition, which pushes Nexus Events to all listening Agents.
Since the third last post I have added a distributed Yahtzee game which you should try out. In order to setup a server on a reachable machine and connect other machines, you need to do the following: On the machine meant to be the server, run 'python nexus yahtzeeserver' first. Then on the machines meant to be the clients through which users play, run 'python nexus -x <serveraddress> yahtzee'. The clients probe the interconnected Nexi for a server and start with a lobby mask where you can select your name and start a game with all players signed up.
GitHub Link
https://github.com/JochenSimon/pytrithon
This is the sixth post about Pytrithon on Reddit. There is a plethora of example Agents to view and run included in the repository. Please check it out and send feedback to the E-Mail address stated in the Monipulator About blurb. I plan on putting Pytrithon onto the next level soon. Be sure to check for new happenings.
3
u/smusali94 17d ago
checkOwners: infer CODEOWNERS from git history with confidence scores
What My Project Does
checkOwners is a CLI (Typer, Python 3.11+) that infers a CODEOWNERS file from git log and git blame. Ownership isn't binary: every path-owner pair gets a confidence score from commit recency, frequency, blame coverage, and optional PR review activity. It also computes per-path bus factor, detects expertise decay, infers team topology from commit co-occurrence, and runs drift detection in CI via a composite GitHub Action.
pip install checkowners, MIT.Target Audience
Production use. Teams whose CODEOWNERS is stale or nonexistent, platform and DevEx engineers who want ownership signals in CI, and anyone who wants bus-factor visibility per path. Tested against a 24k-commit production monorepo (12k active files); a full analysis runs in under 3 minutes, and generated files are always GitHub-valid (fun fact: GitHub silently ignores CODEOWNERS lines containing
[...], so hand-written files covering Next.js dynamic routes can be silently un-owned).Comparison
GitHub's own CODEOWNERS is hand-written and rots. Existing generators mostly count commits and emit binary owner lists. checkOwners scores confidence, models decay and bus factor, resolves commit emails to GitHub handles (merging same-person identities so one human with two emails isn't "bus factor 2"), and implements GitHub's real pattern-matching semantics for drift detection. No AI or LLM anywhere; the inference is deterministic git analysis.
Repo: github.com/fortyOneTech/checkOwners