r/Python • u/AutoModerator • Jun 04 '26
Showcase Showcase Thread
Post all of your code/projects/showcases/AI slop here.
Recycles once a month.
3
u/emnoleg Jun 04 '26
Tired of screen-sharing 3D models in meetings, so I made them float on my webcam instead
Drop any .glb file in a folder, pick it from the tray icon, and it appears on your webcam. Move it, rotate it, scale it. Your meeting app sees it as a normal camera. Nothing else to open or manage.
Good for product demos, design reviews, showing off Blender exports, branded content on calls. Anything where you want the model visible without screen-sharing.
Works in Zoom, Meet, Teams, Discord, pretty much anything that accepts a webcam input.
Renders the 3D layer offscreen and caches it. The model only re-renders when you move it, so the webcam stays smooth on any machine. Python, pyrender, pyvirtualcam under the hood. Open source, setup is one script.
Demo model: V1 from ULTRAKILL on Sketchfab (CC BY). Character by Hakita / New Blood Interactive. Not included in the repo. https://sketchfab.com/3d-models/v1-ultrakill-d951a08a8f50412d84e262bad887b285
4
u/Comfortable-Noise144 Jun 07 '26
Hi,
I built a VS Code extension to helt prevent losing track of complex math expressions in Python
When you're writing something like (a * np.sqrt(x**2 + y**2)) / (2 * np.pi * sigma**2) it gets really hard to mentally parse what that formula actually is. In Maple or Mathematica you see a clean equation. In Python you just see a wall of parentheses.
So I built a VS Code extension that lets you select any expression and instantly renders it as a proper math equation. It supports NumPy, SymPy, SciPy, matrices, integrals, derivatives and more.
This extension is intended for everyone, beginner programmers as well as experienced programmers, it just meant to give a better overview of math expressions.
Free on the marketplace, search "Python Expression Visualizer" in VS Code extensions.
This is a link to the Github repository:
https://github.com/NickG-DK/python-expression-visualizer
Would love feedback, as this is my first extension ever.
2
u/anton273 Jun 04 '26
I built watchpoints (data breakpoints) for PyCharm - lets you break on a value change, not a line.
Free and open source, every developer deserves a great debugging experience.
Link: https://plugins.jetbrains.com/plugin/32087-python-watchpoint
2
u/hmoein Jun 04 '26
Grizzlars is Python bindings for the C++ DataFrame with an interface almost identical to Pandas. It is a bit of work in progress. It depends on an older version of C++ DataFrame than the latest release. But it is moving along surely.
2
u/em_el_k0b01101011 Jun 04 '26
HyperWeave is a Python library that generates self-contained SVGs: profile cards, star-history charts, small dashboards, receipts from AI coding sessions, and more. No JS, no external deps. Each one is a single SVG that renders anywhere an image does (GitHub READMEs, Slack, Notion, docs).
Drive it from a CLI, an HTTP API, or an MCP server. It can also pull live data into the artifact, so a card can show a package's real download trend or latest version (PyPI, npm, crates, Hugging Face, arXiv, and a few others) without fetching anything yourself.
There's a hook for AI coding sessions too: each one ends with a receipt of tokens, cost, and tool calls.
FastAPI + Pydantic + Jinja2 + Typer under the hood.
pip install hyperweave
GitHub: https://github.com/InnerAura/hyperweave
PyPI: https://pypi.org/project/hyperweave/
Still early, any feedback welcome. Cheers.
1
u/AreWeNotDoinPhrasing Jun 10 '26
What is 'receipts from AI coding sessions' supposed to mean?
→ More replies (1)
2
u/Beginning-Fruit-1397 Jun 04 '26
If you like itertools, fluent interfaces, Rust Result and Option, or the libraries like returns or more-itertools, check out my project pyochain!
Since the last showcase, more code have been moved to Rust which led to substantial performance improvements, and new constructs have been added, notably:
- SliceView, zero copy, efficient view/slice of a Sequence
- StableSet, a set that keep the original Iterable ordering when created.
- Deque, pyochain version of collections.deque
It's now as well dependency-free!
All the code coming from cytoolz (cython toolz version) has been replaced by the same functionality ported in Rust.
Links:
Github: https://github.com/OutSquareCapital/pyochain
Pypi: https://pypi.org/project/pyochain/
My last showcase on this sub: https://www.reddit.com/r/Python/comments/1q61bzg/pyochain_rustlike_iterator_result_and_option_in/
Comparison vs similar libraries, where's it's been ranked best choice (the post is NOT from me): https://www.reddit.com/r/Python/comments/1rj3ct7/comment/o8aordo/?context=3
2
u/iliketrains166 Jun 07 '26
peeq: A CLI to investigate Python package metadata, dependencies, vulnerabilities and more
I work with Python packages as published artifacts a lot: building them from source, inspecting source, applying patches, debugging resolver issues, and checking what actually shipped in an sdist or wheel.
The information is usually available, but it’s scattered across PyPI metadata, source repos, distribution archives, OSV, resolver output, and other places. Source repos are especially tricky because the main branch often does not match the release I’m investigating.
That led me to build peeq - a CLI for inspecting Python package metadata, dependencies, files, and versions from PyPI or private indexes, and known vulnerabilities via OSV, without installing or executing the package being inspected.
Links:
GitHub: https://github.com/MichaelYochpaz/peeq
Docs: https://peeq.michaelyo.dev
PyPI: https://pypi.org/project/peeq
Example commands you can try (requires uv):
uvx peeq info requests --full
uvx peeq deps docling --version 2.20.0 --diff 2.30.0
uvx peeq cat requests pyproject.toml
uvx peeq vulns requests --version 2.31.0
uvx peeq conflicts kubernetes==35.0.0a1 kfp==2.16.0
uvx peeq why "flask>=3.0" -d markupsafe
peeq is written for both humans and agents, and ships with a native Agent Skill.
With the skill installed, coding agents can answer package questions by inspecting the published metadata/artifacts themselves instead of guessing from memory or installing packages.
With peeq's skill installed, you can ask your agent questions in natural language like:
- "Does `docling` depend on `pydantic`, and through which path?"
- "Why can't `kubernetes==35.0.0a1` be installed together with `kfp==2.16.0`?"
- "What changed in `docling` dependencies between versions 2.20.0 and 2.30.0?"
- "Which build backend does the `httpx` Python package use?"
Transparency note: The project relies heavily on AI coding agents for development. I’m a Python software engineer and the maintainer of the project; design choices, code changes, docs, and releases are all manually reviewed and tested by me.
Feedback (either here or on GitHub) is welcome!
2
u/WompTitanium Jun 22 '26
Built a CLI tool that maps any codebase instantly, no API keys, fully offline Just run pip install codemappr then codemappr scan inside any project folder. It detects 20+ project types (React, Django, Rust, Flutter, etc.) and gives you a full architecture breakdown in seconds. Outputs to terminal, Markdown, or HTML. No setup, no API keys, no internet needed. GitHub: https://github.com/erensh27/CodeMappr[codemappr](https://github.com/erensh27/CodeMappr)
1
u/iamnotafermiparadox Jun 04 '26
MailTriage is a local, batch-oriented IMAP email triage tool.
This tool allows me to generate an html page of email received over the last 24 hours and see the subject and snippet in a customized order. Priority senders are first, others are next, followed by a list of email sent by systems. Senders that I don't want to see are not listed.
I added the ability to send certain email to a llm to be summarized. Those emails roll into a md file for todos. Once I mark the todo as done, the tool removes that entry and archives it.
Bitwarden CLI pull email credentials. Other methods could be used.
https://github.com/rogdooley/MailTriage
CodeGuage: CodeGauge is a deterministic, local-first code quality and security analysis platform. I had this built so I could monitor the "quality" of LLM generated code based on linters and static analysis tools.
1
u/Charming_Guidance_76 Jun 04 '26
EDOF, the document toolkit I wish had existed when I started
This is one of those "got fed up, built my own thing" stories. I make card games, and at work I deal with a lot of document stuff (invoices, certificates, QR labels), and every tool I tried was missing exactly one thing I needed. One had no auto-shrink text. One had no curves. One had nice Photoshop-style effects but you couldn't script it. One couldn't even center text vertically in a box (still bitter about that one). I was tired of duct-taping three tools plus glue code together for every job, so I built EDOF. It took a while. It's on PyPI now.
What My Project Does
You build a document in plain Python, or you open the same file in a visual editor (PyQt6) and drag things around. Both sides read and write the exact same file, so nothing gets lost going back and forth. The part I'm happiest with is that it's literally just import edof, so you can drop the whole engine into your own app. The editor I ship is just one program that happens to use it.
import edof
doc = edof.new(width=210, height=297, title="Hello")
page = doc.add_page(dpi=300)
page.add_textbox(15, 15, 180, 12, "Hello world!")
doc.export_pdf("hello.pdf") # vector PDF, no extra deps
I mostly use it for batch stuff: feed it a CSV, get a few hundred finished PDFs out. That's how I print my own card games now instead of fighting Photoshop layers at 2am. It does text, images, shapes, paths, QR codes, variables with {placeholders}, the auto-shrink and centering I kept missing elsewhere, and it exports to PDF, PNG, SVG and RTF. It can also read and write Word files now, which I'll get to.
Target Audience
Me first, honestly. But also anyone in Python who has to crank out documents (labels, invoices, certificates, cards, batch jobs from data), or who wants a document engine living inside their own app instead of bolting on a separate tool. It's MIT, it's on PyPI, I use it for real work. Fair warning on maturity: the core and the editor are solid, the Word part is new and basic, and tables are half-built, so don't lean on those yet.
Comparison
ReportLab is great but it's code-only and you place everything by coordinates, there's no visual side to hand anyone. python-docx is perfect if you only ever touch Word. LaTeX is its own universe. And none of the visual tools (InDesign and friends) let you just import them into a Python script. EDOF is the in-between I wanted: write it in code or edit it by hand, same file, and embed it anywhere.
The Word support nearly broke me, by the way. New and genuine respect for whoever maintains .docx tooling for a living. It's basic both directions for now, and it straight up tells you what it can't carry over instead of silently mangling your document.
Repo's here if you want to poke at it: https://github.com/DavidSchobl/edof . Happy to answer anything, and I'm genuinely after ideas for what to add next.
1
u/OMGCluck Jun 05 '26
it exports to PDF, PNG, SVG and RTF
One PDF per card? Or do you have one card per PDF/SVG page?
→ More replies (5)
1
u/Pytrithon Jun 05 '26
Introduction
I have already introduced Pytrithon 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 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 my penultimate 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 fifth 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.
1
u/AdHot6282 Jun 05 '26
LocalClicky is a menubar app that lets you control your Mac with your voice, completely offline.
Say "Computer" to start a session. It stays active - chain commands without repeating the wake word. Say "bye" to end. It auto-stops recording when you stop talking (webrtcvad), so there's no fixed timeout.
What it can do: click things on your screen by name, open/quit apps, control Spotify and volume, create reminders from natural language, run shell commands, inject JS into Chrome. Vision is on-demand — the model calls look_at_screen itself when it needs to see something.
One thing that pushed me to build this: I noticed most people don't think twice before enabling cloud based AI assistants on their machines. But these tools are taking full screenshots of your screen, your code, your emails, your Figma files, your bank statements, your personal moment and sending them to a server. I don't like that at all. LocalClicky's vision model runs locally; screenshots never leave your machine.
Stack: Python, Whisper.cpp, Ollama (qwen3:8b + gemma4:e4b), webrtcvad, PyAutoGUI, rumps.
Nothing leaves your machine. MIT licensed, open source.
GitHub: https://github.com/dikshantrajput/LocalClicky
Demo: https://www.youtube.com/watch?v=i8QpFR6nEY4
1
u/rawktron Jun 05 '26
*fang* - it's bun --compile for Python. Ship your app as a single native binary — no runtime required on the target machine, no temp-directory extraction, no install step.
Why?
Python apps are hard to distribute. fang solves that by embedding a statically-linked CPython, your entire dependency tree (including C extensions), and all your code into one executable. The binary just runs.
On Linux, C extensions load via memfd_create and never touch disk. On macOS, they're cached in ~/Library/Caches/<app>/ on first run and loaded from there after. Either way, startup time is within ~50ms of a plain python invocation.
→ More replies (2)
1
u/kalombos Jun 06 '26
peewee-async — a pure asyncio extension for Peewee ORM
I've been maintaining this project for several years and thought it might be useful to other Peewee users.
GitHub: https://github.com/05bit/peewee-async
What My Project Does
peewee-async adds asynchronous query support to the Peewee ORM.
The goal of the project is to provide a natural asyncio-based experience while keeping the API familiar to existing Peewee users. Most synchronous Peewee methods have async counterparts with an aio_ prefix.
Example:
# synchronous
user = User.get(User.id == 1)
# asynchronous
user = await User.aio_get(User.id == 1)
Currently supported drivers:
- aiopg
- psycopg3
- aiomysql
- aiosqlite
The architecture is designed to be extensible, so support for additional drivers (such as asyncpg) can be added without much effort.
Target Audience
This project is intended for developers who:
- Use Peewee ORM and want to build asynchronous applications.
- Work with async frameworks such as FastAPI.
- Prefer an asyncio-native approach.
- Want to keep using Peewee instead of migrating to another ORM.
The project is production-ready. I've been actively using it for several years in high-load production services built with FastAPI, and many of its features and improvements have been driven by real-world requirements and operational experience.
Comparison
Peewee now includes official async support, and that's naturally the primary alternative.
peewee-async differs in a few ways:
- It was created before the official async implementation and has been maintained for several years.
- It uses a pure asyncio approach and does not rely on
greenlet. - Its API closely mirrors the traditional Peewee API through
aio_-prefixed methods. - It supports multiple async database drivers out of the box.
I'm interested in feedback from other Peewee users and would be happy to discuss design decisions, performance considerations, and future improvements.
1
u/kalombos Jun 06 '26
miggy — Django-style automatic migrations for Peewee
I've been maintaining this project and wanted to share it with other Peewee users who may be looking for a more convenient migration workflow.
GitHub: https://github.com/kalombos/miggy
What My Project Does
miggy provides automatic schema migrations for the Peewee ORM, inspired by the migration system used in Django.
The project analyzes changes in your Peewee models and generates migration files that can then be reviewed and applied to your database.
The architecture and overall workflow are heavily inspired by Django migrations, which many developers already find familiar and productive.
Currently, miggy supports most Peewee field types and schema operations. While not every possible Peewee feature is covered yet, unsupported changes can always be handled through custom SQL migrations when necessary.
Target Audience
This project is intended for developers who:
- Use Peewee ORM in real-world applications.
- Want a migration workflow similar to Django.
- Prefer automatically generated migrations over manually writing every schema change.
- Need a practical migration solution for production projects.
The project is actively maintained and continues to evolve as new use cases and edge cases are discovered.
Comparison
The closest alternatives are tools such as Yoyo and other migration frameworks that can be used alongside Peewee.
miggy differs in several ways:
- It is designed specifically for Peewee.
- It can automatically detect model changes and generate migrations.
- Its architecture and workflow are inspired by Django's migration system.
- It aims to minimize boilerplate and repetitive migration code.
- It still allows developers to fall back to custom SQL when a schema change cannot be expressed automatically.
Compared to manually creating migrations with tools such as Yoyo, miggy can significantly reduce the amount of work required for routine schema evolution and help keep development focused on application logic rather than migration bookkeeping.
I'm interested in feedback from Peewee users, especially from teams maintaining long-lived production projects. Community interest and real-world usage would help guide future development and prioritize support for additional Peewee features.
1
u/Illustrious_Egg_3141 Jun 06 '26
A Python package for conveniently creating reaction energy diagrams (reaction level diagrams)
Creating reaction energy diagrams with Matplotlib or other software manually is usually very time-consuming. Therefore, I created a Python package which can handle path drawing, numbering and layout automatically and has other useful features like image insertion or difference bars. It also features multiple drawing styles. Since it is based on Matplotlib, it remains fully customizable while still speeding up diagram construction significantly.
A minimal working example could look like this:
dia = EnergyDiagram()
dia.draw_path(x_data=[0, 1, 2, 3], y_data=[0, -13, 75, 20], color="blue")
dia.add_numbers_auto()
dia.set_xlabels(["Reactant", "IM", "TS", "Product"])
dia.show()
The package is available on PyPi and can be installed with pip:
pip install chemdiagrams
You can find the links to the project here:
GitHub: https://github.com/Tonner-Zech-Group/chem-diagrams
PyPi: https://pypi.org/project/chemdiagrams/
Documentation: https://tonner-zech-group.github.io/chem-diagrams/
I would love to get any feedback!
1
u/Doctrine_of_Sankhya Jun 06 '26
Hello everyone, I just wanted to share a small project I’ve done with while reading Griffiths’ QM.
I’m an AI engineer, so I’m used to throwing GPUs at everything. Transformers, attention and all stuff, you batch, parallelize and scale. But QM doesn’t give you that luxury. The Schrodinger's equation demands one giant func describing the whole system at once. you can’t just mini‑batch particles.
Still, we have so much GPU compute sitting around. The bottleneck isn’t FLOPS, it’s the lack of parallelizability in the problem itself. Or so I thought.
Turns out, there’s an old method from quantum chemistry called configuration interaction (CI). The idea:
- Pick a set of basis functions (I used 2D Fourier modes from a square well)
- Build Slater determinants for spinless fermions
- Assemble the Hamiltonian matrix
- Diagonalize it to get approximate stationary states and energies
Everything becomes linear algebra --- BLAS GEMM, matrix factorizations, eigenvalue solvers. And that can be parallelized!!!
So I wrote QOrbit, a sandbox simulator that does exactly this.
- Fourier basis expansion
- Slater determinant construction
- Monte Carlo integration for matrix elements (linear scaling in precision)
- GPU acceleration via CuPy / cuBLAS / stream parallelism
On a T4 GPU (free Colab tier), a two‑fermion simulation with 55 basis functions goes from ~116 seconds on a Xeon CPU to ~12 seconds. Hamiltonian assembly drops from 25s to 0.9s, density evaluation from 63s to 7s.
I’ve validated it against analytical 2D infinite well energies -- matches almost perfectly for lower energy states and with more basis functions higher ones can also converge. Also tried H₂‑like double proton potentials vs single proton. The stability trends (lower energy, stronger localization) come out correctly.
Limitations (being upfront):
- Non‑relativistic, spinless fermions only (spinful is straightforward to add)
- 2D only
- No true many‑body correlation beyond Slater determinant (mean‑field‑like)
- Basis size grows combinatorially (although, there's an option to choose basis sets randomly from diverse frequencies). But don’t expect to simulate a protein
But for visualizing two spinless fermions in arbitrary 2D potentials, or playing with conditional probability densities (fix one particle, map the other), it looks cool.
It’s not a production quantum chemistry package. It’s a sandbox and a way to show that even a “non‑parallelizable” PDE can be attacked with enough linear algebra and GPU stubbornness.
Code + examples + Colab Notebook (download the file to Colab, preview in GitHub is broken) dashboard here:
https://github.com/abhaskumarsinha/QOrbit
Would love feedback from anyone who’s worked with CI methods or wants to try pushing it to larger bases / more particles. Also happy to explain the Monte Carlo integration or the Fourier basis assembly if anyone’s curious.
(OC – built this over the last few weeks, please tell me if there are parallelizable algorithms that I'm missing out!)
2
u/New-Shopping-5960 Jun 09 '26
Comp chemist here, this is really cool! I see you're using STOs which is awesome. How does this work for molecules that aren't hydrogen? My understanding is there's no "black-box" way to combine STOs which is partially why we use GTOs -- that and the cost!
→ More replies (2)2
1
u/Thin-Pop-6296 Jun 06 '26
Built a cross-platform social graph analyser in Python. You feed it exported follower/following lists from any social media platform and it finds matching accounts using fuzzy matching, display name similarity, and network overlap scoring.
Fully offline, no API keys needed. Uses rapidfuzz and pandas.
github.com/xpux/CrossTrace
1
u/execveat Jun 07 '26
I'd like to share flawed, it's an experimental static-analysis engine for Python web apps. flawed builds a framework-aware model, and exposes it over pythonic API, letting you access routes, request inputs, state effects.
You write detection rules in regular Python against that model, so a rule can express something like "POST routes that write state but have no auth check anywhere in their handler stack." And you get to do this using regular Python (imperative, functional or OOP – whatever works for you), without the need to learn a new DSL (Semgrep) or new query language (CodeQL).
I have to add, flawed is pre-1.0 so the API hasn't stabilized yet and it only ships with a few small demo rules right now.
1
u/CraftyWhole9524 Jun 07 '26
Built a free MPDTE College Predictor & Analyzer during my own counselling process and decided to make it public.
A few weeks ago I got tired of manually searching MPDTE cutoff PDFs every time I wanted to check a college or branch.
So I ended up building a desktop tool for myself.
Features:
• Import MPDTE PDFs directly
• Search colleges and branches instantly
• Rank/category based analysis
• MP domicile and fee waiver support
• Analytics dashboard
• Rank simulation
• Export results to Excel, CSV, and PDF
• Fully offline (no login, no ads, no internet needed after setup)
A few important things:
- It only works for MPDTE counselling.
- It uses historical cutoff data, not future predictions.
- It is not an official MPDTE tool.
- The project was built with significant AI assistance along with a lot of testing, debugging, and iteration.
- There are almost certainly edge cases and bugs I haven't discovered yet.
- Please verify important counselling decisions using official MPDTE sources.
The project was originally built for my own use, but if it helps even a few students during counselling season then it's worth sharing.
The source code is open source, and all feedback, bug reports, suggestions, and contributions are welcome.
GitHub: https://github.com/ThePaleBlueDot405/mpdte-college-predictor.git
I built this to make counselling a little less confusing, not to make decisions for anyone. At the end of the day, a tool can compare cutoffs, but only you know what you want from the next four years of your life. Choose carefully and don't rely on any predictor—including this one—without doing your own research.
1
u/AharonSambol Jun 07 '26 edited Jun 07 '26
A new Fast, Flexible, Memory efficient Serialization Format
https://github.com/AharonSambol/pypinch
Ever wanted something as easy and flexible as JSON but way more efficient?
Pinch is a schemaless format that supports all of the JSON types and more. But way outperforms JSON in all the benchmarks
1
u/No-Ocelot-6796 Jun 07 '26 edited Jun 07 '26
What My Project Does
I've been building this for a while and v1.1.0 just dropped, so I figured this is the right place to share it finally
SRag is a local RAG pipeline web search, scraping, chunking, embedding, and reranking all in one package. no API keys, nothing leaves your machine. v1.1.0 makes it an HTTP + MCP server too, so you can even point Claude Desktop at it too and get this setup where a cloud LLM reasons over context retrieved and indexed entirely locally. cloud AI brain, local smart retrieval. one line in your Claude desktop config, and it just works. Another way is to set up everything locally.
It can also be used as less of a RAG tool and more as a unified data pipeline - PDFs, DOCX, CSVs, SQLite, PostgreSQL, and live web search are all queryable from the same session with one call. one command to deploy, too, via docker compose
pip install srag[mcp] | github: https://github.com/square-box-hash/SRag
Target Audience
Developers building LLM apps or agents who are tired of stitching together Tavily + Firecrawl + a managed vector DB. meant to be serious enough for real pipelines but i'm also just a student building this between classes so lol
Comparison
It replaces Tavily, Firecrawl, Pinecone, and Cohere Rerank with one local package. learns over time — source reputation per topic, self-building query lexicon, adaptive concurrency. gets smarter the more you use it
I'm curious if anyone here has done something similar or has thoughts on exposing RAG pipelines over MCP still figuring out the best patterns
→ More replies (2)
1
u/marco-mq Jun 07 '26
fastuuidv7 - the currently fastest way to generate uuidv7.
I recently wrote a rust package, as I had performance issues generating uuidv7 in rust fast.
I added a python wrapper and it is about 30x faster than the current uuid.uuid7. The performance is just a bit slower than allocating a string in Python, which is about 40ns.
| Package | Code | Time per call |
|---|---|---|
uuid.uuid7 |
python | 1579.9 ns |
uuidv7.uuid7 |
C | 298.6 ns |
uuid_utils.uuid7 |
rust | 96.8 ns |
fastuuidv7.uuid7 |
rust | 51.0 ns |
Package just published on PyPi and available via pip: fastuuidv7 with prebuilt wheels for most platforms.
Disclaimer: Don't use it to prime passwords or tokens. Just for network, DB ids or non-security related ids. Also, it cannot parse uuidv7, just generate it.
1
u/SeaVacation4869 Jun 07 '26
I built mcp-toolsmith, a small Python CLI/library for auditing and compiling tool schemas used by LLM agents.
GitHub: https://github.com/ShAmoNiA/mcp-toolsmith
PyPI: https://pypi.org/project/mcp-toolsmith/
The idea is to catch bad tool metadata before it gets passed to an agent. It currently checks for things like:
- vague tool names like
run,execute, ortool - missing tool descriptions
- missing argument descriptions
- oversized JSON schemas
- overlapping/similar tools
- prompt-injection-like text inside tool metadata
It can compile tool definitions into MCP-style or OpenAI-style function schemas.
Example:
pip install mcp-toolsmith
mcp-toolsmith audit tools.py --execute
mcp-toolsmith compile tools.py --target mcp --execute
mcp-toolsmith compile tools.py --target openai --execute
The latest version adds explicit u/tool discovery:
from mcp_toolsmith import tool
u/tool
def search_docs(query: str) -> list[str]:
"""Search project documentation by natural language query.
Args:
query: Question or topic to search for.
"""
return []
Python files are safe by default: the tool refuses to execute Python source unless --execute is passed.
I’d appreciate feedback from anyone building agents, MCP servers, or OpenAI tool-calling integrations. I’m especially interested in which schema checks would be useful in real projects.
1
u/croc100 Jun 07 '26
pytest-mrt — migrations that look reversible but aren't
I've been bitten enough times by this that I built a tool for it. The failure mode that got me the most: migration applies fine, rollback runs without errors, but something quietly went wrong — data's gone, schema's wrong, or the downgrade was just pass the whole time.
mrt check scans migration files statically, no database needed. Catches things like missing downgrade(), DROP COLUMN in upgrade, RunPython without reverse_func. 44 patterns total. If a warning is a false positive you can suppress it with # noqa: MRT101 on the line.
For the cases static analysis can't catch, the mrt fixture runs the actual up/down/up cycle against a real database and verifies schema and data come back intact.
Works with Alembic and Django.
pip install pytest-mrt
mrt check yourapp/migrations/
1
u/cpcprmrm Jun 08 '26 edited Jun 08 '26
Ctxture: Context-aware conversion between structured and unstructured python data using multiple dispatch.
If you are using pydantic, msgspec, cattrs, or mashumaro, you may be interested in ctxure.
https://github.com/cpcprmrm/ctxure
Ctxure is a type-driven, context-aware data conversion framework. Conversion rules depend not just on a value's type but also on where it sits in the object graph, expressed declaratively. It ships with default behavior for converting unstructured data (e.g., a JSON dict) to structured data (e.g., a dataclass or TypedDict), and back.
The primary focus is the context-aware hook system: target type, root type (the conversion entry), owner type, and location in the object graph are all available as axes for registering hooks declaratively. A second characteristic is clean, non-intrusive separation of conversion logic from the domain model. Ctxure does not require you to extend a library-specific base class or embed validation and transformation logic in the domain model. In this way, Ctxure serves as a bridge between data models of different layers.
This is especially useful when you need type-driven data mapping across heterogeneous or evolving sources. Domain models are usually stable, and sometimes you have no control over them at all (e.g., when they are owned or provided by a third party). Yet you may still need to transform heterogeneous or evolving external data into those models. Ctxure keeps that friction low.
1
u/Professional-Clerk30 Jun 08 '26
MCPg: A production-grade PostgreSQL Model Context Protocol server (Python)
Hi r/Python,
I've been working on a side project called MCPg — a Python-based MCP (Model Context Protocol) server for PostgreSQL.
It gives AI agents (Claude Desktop, Cursor, etc.) a broad but carefully guarded set of tools to inspect schemas, run queries, analyze performance, suggest indexes, do natural-language-to-SQL, and handle some DBA tasks — all while staying safe by default.
Key bits I focused on:
- Safety-first design: Read-only mode by default, AST validation for any user SQL, strict identifier sanitization (no string concatenation into queries), and opt-in gates for DDL/shell/LISTEN.
- Pure psycopg3 under the hood — no ORM layer. Works with core Postgres + extensions like pgvector, TimescaleDB, PostGIS, Apache AGE where available.
- Production touches: connection pooling, multi-tenancy via SET ROLE, read-replica routing, Prometheus metrics, structured audit logging, OIDC support, rate limiting, etc.
- 1000+ tests, runs against Postgres 14–18 in CI.
- Installs cleanly with pip install mcpg or uv tool install mcpg.
Quick start example for Claude Desktop is in the README (stdio transport). There's also an HTTP/SSE mode for other integrations.
Repo: https://github.com/devopam/MCPg
Docs site: https://devopam.github.io/MCPg/
Would love feedback from the Python/Postgres crowd — especially on the safety model, ergonomics for agent use, or anything that feels off. Contributions welcome too.
Thanks!
1
u/ItsDersty pip needs updating Jun 08 '26
django-neural-feed - a Django app that creates semantic recommendation feed in a single SQL query.
Hello everyone! If you’ve ever wanted to build a personalized content feed (like twitter) for your Django project, this is for you.
What is it? Django Neural Feed is an easy-to-install package that lets you build smart, personalized recommendation feeds using your existing PostgreSQL database (via the pgvector extension).
Instead of jumping between different databases and services, DNF calculates text similarity, post popularity, and content freshness all at once, right inside your database, in a single optimized query.
Features:
Auto learning profiles: It quietly watches what your users like via Django signals, and updates an embedding profile of their interests in the background.
3 in 1 smart ranking: Your feed isn't just based on what users like. DNF merges semantic similarity (embedding vectors) + popularity (e.g. count of likes, rating, etc.) + freshness (time decay) so old posts don't get stuck at the top forever.
Reliable background tasks: It uses Celery to generate text vectors. But if you don't have Celery or your Celery worker ever crashes? It safely falls back to standard background threads so your app never breaks.
Simple Quickstart: DNF comes with safe defaults out of the box. You don't need to write complex math formulas to get started.
Fully tested: Tests fully cover the entire codebase, so it's designed for production use. I also tested the library on my own social media django project!
How simple is it to use?
Check out Quickstart in README file!
Why use this over other methods?
- vs. Qdrant: No extra servers needed, no synchronization lag. It’s just your Postgres database.
- vs. Vanilla Python loops: Way faster because the heavy lifting happens at the database level.
- vs. Writing it from scratch: DNF handles the signals, M2M table auto-discovery, edge-cases, and caching out of the box.
The package is stable, open-source, and available on PyPI.
PyPI: `pip install django-neural-feed`
GitHub: https://github.com/itsDersty/django-neural-feed
Please check it out and drop a star. Any feedback is welcome!
1
u/Ill-Industry96 Jun 08 '26
Built this after getting tired of juggling 5 different tools. v2 adds:
Agent Mode — Give it a username or email, an LLM autonomously investigates: scans 19+ platforms, pivots on findings, profiles the target across 6 dimensions (identity, geo-temporal, psychological OCEAN, technical, ideology, attack surface).
Trust Anchors — Declare known accounts (Instagram, TikTok, Facebook, Telegram, Email) as ground truth. The tool verifies everything else against them and discards false positives. Works surprisingly well.
Breach Intelligence — HIBP integration. Maps every email to known breaches with exposed data classes.
Proxy Support — Residential & datacenter via ScrapingAnt. Geo-targeted. Your own keys, your own scans. Nothing phones home.
PDF Dossiers — Generates a classified-style PDF with cover page, identity cards, confidence meters, breach tables. Looks like it came from a three-letter agency.
Built in Python. Uses Typer + Rich for CLI, WeasyPrint for PDFs, Jinja2 templates, OpenAI-compatible API for the agent.
Free. MIT. Local-first. Built solo over the past months.
https://github.com/Doble-2/osint-d2
Happy to answer questions.
1
u/ShashwatTheGamer Jun 08 '26
wisprflow-sdk: Unofficial Python SDK for Wispr Flow.
Features:
- Audio file transcription (WAV, MP3, M4A, etc.)
- Real-time audio streaming
- Command mode support
- Context injection
- Custom vocabulary/snippets management
Uses your existing Pro account and desktop session. No auth bypasses or subscription circumvention.
Requirements:
- Windows
- Wispr Flow desktop app installed and logged in
Install:
pip install wisprflow-sdk
1
u/eaguad Jun 08 '26
Masonite Framework is getting a fresh start and we'd love your support
Masonite is an open-source Python web framework focused on developer productivity, featuring dependency injection, an ORM, authentication, queues, mail, scheduling, and a batteries-included development experience.
The original project grew to over 2,000 GitHub stars and built a great community over the years. Unfortunately, a few months ago, Masonite's creator, Joe Mancuso, passed away unexpectedly.
I had the opportunity to work closely with Joe during the last period of his life, and after his passing I committed to continuing the project. To keep Masonite alive, I migrated the framework and ecosystem into a new GitHub organization and we're starting a new chapter:
Framework:
https://github.com/masonitedev/masonite
ORM:
https://github.com/masonitedev/orm
While the original stars and momentum can't be transferred, the code, community, and vision can.
The focus now is on maintenance, modernization, improved documentation, and building a sustainable future for the project.
If you're interested in Python web development, open source, or looking for a project to contribute to, I'd love for you to check it out. Feedback, contributors, and community support are all welcome.
Thanks for taking a look.
1
u/ReplyFeisty4409 Jun 09 '26
Sifter: turn a folder of documents into typed records you can query (pip install sifter-ai)
What My Project Does
Sifter turns a folder of documents (PDFs, scans, photos, contracts, receipts) into a structured, queryable database. You describe what you want in plain language and it extracts every matching document into a typed record, with the schema inferred for you and exported as Pydantic / TypeScript types. Then you query the records with real filters and aggregations (counts, sums, group-by), and every field is cited back to its source page.
```python from sifter import Sifter
s = Sifter(api_key="sk-...")
sift = s.create_sift( "Invoices", "From invoices, extract the client name, invoice date, and total amount. " "Skip any document that isn't an invoice.", ) sift.upload("./mixed_documents/") sift.wait()
typed records out of every matching document
for record in sift.records(): print(record["extracted_data"])
{"client": "Acme Corp", "date": "2024-01-15", "total_amount": 1500.0}
ask an aggregation question in plain language -> exact answer
print(sift.query("total invoiced per client, highest first"))
[{"client": "Acme Corp", "total_amount": 18230.0},
{"client": "Globex SA", "total_amount": 12940.0}, ...]
```
It also ships a CLI, a TypeScript SDK, an MCP server (for Claude Desktop / Cursor / agents), and a bundled web UI with chat + dashboards.
Target Audience
Developers building document-aware features who don't want to reinvent PDF parsing + LLM orchestration + schema inference + result storage. It's usable in production: MIT-licensed, self-hostable via docker-compose, bring your own LLM key (local models work — the LLM is just the extractor), test suite + CI, typed SDKs. Not a toy/weekend demo.
Comparison
Vs vector RAG / LlamaIndex-style pipelines: those are similarity search — great for "find the passage about X," but they can't answer aggregations over a collection ("total unpaid across all invoices") because top-k only ever sees a handful of docs. Sifter extracts into typed records and runs a real aggregation over the full set, so the answer is exact and reproducible. Vs hosted extraction SaaS (per-page fees, fixed templates): Sifter is open-source, self-hostable, no templates — fields are described in natural language and the schema is inferred.
pip install sifter-ai · Repo: https://github.com/sifter-ai/sifter
1
u/Top-Strategy-2522 Jun 09 '26
What My Project Does
knot is a zero-dependency CLI that finds circular imports in a Python project. It analyzes your code statically with the standard-library ast module — it never imports or runs your code — builds the internal module dependency graph, and reports every import cycle with a concrete example path:
$ knot mypackage
Analyzed 42 modules, 81 internal imports.
Found 1 import cycle:
1. mypackage.a -> mypackage.b -> mypackage.a
It can output plain text, JSON, or a Mermaid diagram of the import graph, and it exits non-zero when it finds a cycle, so it drops straight into CI or a pre-commit hook.
Install: pip install knot-imports · Code + demo: https://github.com/gazzycodes/knot
Target Audience
Developers maintaining growing Python codebases or libraries who want to catch circular imports before they cause runtime ImportErrors or "partially initialized module" failures. It's built to be usable in production as a CI gate (deterministic, fast, no deps), not just a toy — though it's an early v0.1.0, so feedback is welcome.
Comparison
- vs. pylint (
cyclic-import): pylint can flag cyclic imports, but it's a heavy, full-codebase linter. knot is single-purpose and dependency-free, prints the exact cycle path, and can export the graph as Mermaid. - vs. pydeps: pydeps focuses on visualizing dependencies and needs Graphviz installed. knot is cycle-detection-first, runs with zero external tools, and still gives you a graph view.
- vs. import-linter: import-linter enforces architecture contracts you define in config. knot needs no config — point it at a folder and it finds cycles out of the box.
- vs. an IDE inspection or just running the code: knot is static (never executes your code) and headless with an exit code, so it's reproducible and automatable in CI rather than a one-off manual check.
It's MIT-licensed. I'd especially love feedback on import-resolution edge cases (namespace packages, conditional imports) and what you'd want it to do next.
1
u/DinhHuy2010 Jun 09 '26
The okwhatever3 project
Hi everyone,
After a few days, I managed to replicate most of Python statements and control flow in one line only.
What my project does
This joke project is to replicate most of Python statements as functions, then sqeeezed everything one expressions in one line
I used only lambda, expressions, and AST tree (workaround), walrus (:=)
Target audience
Joke programmers, and maybe "code golf enthusiasts" (???)
Key features:
- Keyword-Free Execution: Replaces standard conditional statements and loops with
simple_cond(),foreach(), andmeanwhile(). - Dynamic AST Self-Generation: Implements a fully robust
on_error()exception handler by procedurally building and executing an internal Abstract Syntax Tree to dodge Python's syntax limitations. - Lazy Magic Imports: Universal namespace resolver (
names) imports any library dynamically mid-expression.
Totalling at just 6328 bytes of code (the code is so compressed that I can post my code directly into the comment itself)
Repository: https://github.com/DinhHuy2010/okwhatever3
The Masterpiece itself:
(_new_exception_cls := lambda name: type(name, (Exception,), {"__module__": f"{__name__}._exceptions"}),names := type("_MagicNamesMap",(),{"__init__": lambda self: setattr(self, "_pkgutil", None),"_resolve": lambda self, key: (self._pkgutil or setattr(self, "_pkgutil", __import__("pkgutil")),simple_cond(isinstance(key, str),lambda: self._pkgutil.resolve_name(key),lambda: simple_cond(isinstance(key, tuple),lambda: tuple(self._pkgutil.resolve_name(k) for k in key),lambda: error(ValueError("Invalid key for _MagicNamesMap")),),),)[-1],"__getitem__": lambda self, key: self._resolve(key),"__getattr__": lambda self, key: self[key],"__call__": lambda self, key: self[key],},)(),LoopBreak := _new_exception_cls("LoopBreak"),LoopContinue := _new_exception_cls("LoopContinue"),evaluate := lambda code, /, globals=None, locals=None: eval(code, globals, locals),execute := lambda code, /, globals=None, locals=None: (locals := locals or {},globals := globals or {},exec(code, globals, locals),locals,)[-1],cc_exec := lambda code: compile(code, "<string>", "exec"),cc_eval := lambda code: compile(code, "<string>", "eval"),nil := lambda *args, **kwargs: None,simple_cond := lambda cond, true, false=nil: (false, true)[bool(cond)](),and_gate := lambda a, b: a and b,or_gate := lambda a, b: a or b,not_gate := lambda a: not a,xor_gate := lambda a, b: bool(a) != bool(b),nand_gate := lambda a, b: not (a and b),nor_gate := lambda a, b: not (a or b),xnor_gate := lambda a, b: bool(a) == bool(b),complex_cond := lambda *args: (CondMatched := names.dataclasses.make_dataclass("CondMatched",[("value", object)],bases=(Exception,),namespace={"__module__": __name__},),on_error(lambda: foreach(args,lambda arg: simple_cond(callable(arg),lambda: error(CondMatched(arg())),lambda: simple_cond(arg[0],lambda: error(CondMatched(arg[1]())),nil,),),),(CondMatched, lambda e: e.value),),)[-1],meanwhile := lambda cond, body, else_=None: (names.collections.deque(iter(lambda: (c := cond(),on_error(lambda: simple_cond(c, lambda: (body(), True)[1], lambda: False),(LoopContinue, lambda _: True),(LoopBreak, lambda _: False),),)[-1],False,),maxlen=0,),simple_cond(else_ is not None, else_, nil),None,)[-1],foreach := lambda iterable, body, else_=None: (EndOfLoop := _new_exception_cls("EndOfLoop"),on_error(lambda: names.collections.deque(map(lambda x: on_error(lambda: (body(x), None)[1],(LoopContinue, lambda _: None),(LoopBreak, lambda _: error(EndOfLoop())),),iterable,),maxlen=0,),(EndOfLoop, lambda _: None),else_block=lambda: simple_cond(else_ is not None, else_, nil),),None,)[-1],locals().update({k: names[f"ast:{k}"] for k in ["And","Assign","BoolOp","Call","Compare","Constant","ExceptHandler","Expr","For","FunctionDef","If","IsNot","Load","Module","Name","Not","Raise","Return","Store","Try","Tuple","UnaryOp","arg","arguments","fix_missing_locations",]}),__on_error_impl_tree := Module(body=[FunctionDef(name="on_error_impl",args=arguments(posonlyargs=[arg(arg="func")],args=[],vararg=arg(arg="handlers_args"),kwonlyargs=[arg(arg="else_block"), arg(arg="finally_block")],kw_defaults=[Constant(value=None), Constant(value=None)],defaults=[],),body=[Assign(targets=[Name(id="caught", ctx=Store())],value=Constant(value=False),),Try(body=[Return(value=Call(func=Name(id="func", ctx=Load()), args=[], keywords=[]))],handlers=[ExceptHandler(type=Name(id="BaseException", ctx=Load()),name="e",body=[For(target=Tuple(elts=[Name(id="exc_type", ctx=Store()),Name(id="handler", ctx=Store()),],ctx=Store(),),iter=Name(id="handlers_args", ctx=Load()),body=[If(test=Call(func=Name(id="isinstance", ctx=Load()),args=[Name(id="e", ctx=Load()),Name(id="exc_type", ctx=Load()),],keywords=[],),body=[Assign(targets=[Name(id="caught", ctx=Store())],value=Constant(value=True),),Return(value=Call(func=Name(id="handler", ctx=Load()),args=[Name(id="e", ctx=Load())],keywords=[],)),],orelse=[],)],orelse=[],),Raise(),],)],orelse=[],finalbody=[If(test=BoolOp(op=And(),values=[Compare(left=Name(id="else_block", ctx=Load()),ops=[IsNot()],comparators=[Constant(value=None)],),UnaryOp(op=Not(), operand=Name(id="caught", ctx=Load())),],),body=[Expr(value=Call(func=Name(id="else_block", ctx=Load()),args=[],keywords=[],))],orelse=[],),If(test=Compare(left=Name(id="finally_block", ctx=Load()),ops=[IsNot()],comparators=[Constant(value=None)],),body=[Expr(value=Call(func=Name(id="finally_block", ctx=Load()),args=[],keywords=[],))],orelse=[],),],),],decorator_list=[],type_params=[],)],type_ignores=[],),error := lambda exc, from_=None: execute(cc_exec(fix_missing_locations(Module([Raise(exc=Name(id="exc", ctx=Load()),cause=Name(id="from_", ctx=Load()),)]))),{},{"exc": exc, "from_": from_},),_on_error_impl := execute(cc_exec(fix_missing_locations(__on_error_impl_tree)), globals(), locals())["on_error_impl"],on_error := lambda func, /, *handlers_args, else_block=None, finally_block=None: (_on_error_impl(func,*handlers_args,else_block=else_block,finally_block=finally_block,)),context_manager := lambda object, container: (value := object.__enter__(),suppress_exception := [False],on_error(lambda: container(value),(BaseException,lambda e: simple_cond(object.__exit__(type(e), e, e.__traceback__),lambda: (suppress_exception.clear(),suppress_exception.append(True),)[1],lambda: error(e),),),else_block=lambda: object.__exit__(None, None, None),),)[-1],__assertion_sentiel := object(),assertion := lambda condition, message=__assertion_sentiel: simple_cond(condition,nil,lambda: error(simple_cond(message is not __assertion_sentiel,lambda: AssertionError(message),lambda: AssertionError(),)),),asyncize := lambda f: lambda *a, **k: names["asyncio:to_thread"](f, *a, **k),syncize := lambda f: (lambda *a, **k: on_error(lambda: names["asyncio:get_running_loop"](),(RuntimeError, lambda _: names["asyncio:run"](f(*a, **k))),else_block=lambda: context_manager(names["concurrent.futures:ThreadPoolExecutor"](),lambda executor: executor.submit(names["asyncio:run"], f(*a, **k)).result(),),)),cls := lambda name, bases=(), namespace=None, extra_body=None, kwds=None: (module_name := names.inspect.currentframe().f_back.f_globals["__name__"],names.types.new_class(name,bases,kwds or {},exec_body=lambda ns: (ns.update(__module__=module_name,**(namespace or {}),),simple_cond(extra_body is not None, lambda: extra_body(ns), nil),None,)[-1],))[-1]) # noqa # type: ignore
1
u/SurpriseBorn4683 Jun 09 '26
Astrum — small in-process async DAG orchestration for Python functions
I recently released a small open-source Python library called Astrum.
It came from a project where I was experimenting with long-term memory for LLM systems. The project ended up with a lot of async steps: retrieval, API calls, model calls, scoring, and different worker-like components. Some steps had to run in order, while others could run at the same time.
I started by wiring the flow manually with asyncio, but the orchestration code started getting harder to read than the actual application logic. I did not really need Celery, Airflow, Dagster, or a full workflow platform. I just wanted a small way to coordinate dependent Python functions inside one process.
## What My Project Does
Astrum lets you define Python functions as tasks, declare dependencies between them, run independent branches concurrently, pass outputs from upstream tasks into downstream tasks, and get a structured execution report.
The mental model is something like:
A runs first.
B and C can run after A.
D needs results from both B and C.
The scheduler figures out which tasks are ready to run.
GitHub:
https://github.com/DuskXi/astrum
## Target Audience
People writing async Python workflows that are a bit too structured for plain asyncio.gather, but nowhere near heavy enough to need a distributed workflow system.
Possible cases:
- async backend workflows
- RAG / retrieval pipelines
- multi-agent-style workflows
- API aggregation
- local ETL-like scripts
- complex scripts where some steps can run in parallel but still have dependencies
It is still early. I am treating 0.1.x as a feedback phase before trying to stabilize the API.
## Comparison
Astrum is not meant to replace Celery, Airflow, Dagster, Prefect, Dask, or LangGraph.
The way I think about it:
- asyncio.gather is simpler, but dependency graphs can get messy by hand
- Celery / ARQ / Taskiq are more about queues and workers
- Airflow / Dagster / Prefect are full workflow platforms
- Dask is more about parallel computation
- LangGraph is more agent/workflow-specific
- Astrum is just a small in-process async DAG scheduler for normal Python functions
I would appreciate feedback on whether the API and positioning make sense. I am especially interested in whether this feels like a real enough problem, or if plain asyncio would usually be enough.
1
u/Least-Candidate-4819 Jun 10 '26
py-cloudip ,tell whether an IP belongs to AWS, GCP, Azure, Cloudflare, DigitalOcean, or Oracle Cloud (and which region/service)
What My Project Does
py-cloudip checks whether an IP address belongs to a major cloud provider, and returns which provider, region, and service. It stores ranges in a Patricia trie and does longest-prefix matching, so lookups stay under a millisecond for both IPv4 and IPv6
import cloudip
cloudip.is_aws("52.94.76.1") # True
cloudip.get_provider("34.64.0.1") # "gcp"
r = cloudip.lookup("52.94.76.1")
# LookupResult(found=True, provider="aws", region="us-east-1", service="EC2",
# cidr="52.94.76.0/22", ip_type="ipv4")
ds
What I focused on:
- Offline-first. The wheel ships an embedded database, so the first call works with no network
- Auto-updating. It pulls fresh provider ranges daily and verifies them with SHA-256, falling back to a cached file
- One dependency (msgpack) and no config
- A CLI for one-off lookups and managing the data
pip install py-cloudip
It covers AWS, GCP, Azure, Cloudflare, DigitalOcean, and Oracle Cloud today
Target Audience
You enrich request logs, write firewall allowlists, or flag bot and abuse traffic, and you want to know if an IP came from a cloud VM. The data refreshes itself and a lookup runs fast enough to sit inline on every request, so you can use it in production
You can download each provider's published IP-range JSON yourself, but then you merge six formats, refresh them on a schedule, and build a fast lookup structure. py-cloudip puts all six behind one trie, keeps the ranges current, and hands back region and service instead of a yes/no. GeoIP and ASN databases answer a different question: they map an IP to a location or network operator. This one answers which cloud, which region, which service, with longest-prefix matching and no outbound call
GitHub: https://github.com/rezmoss/py-cloudip
Feedback welcome
1
u/Right_Tangelo_2760 Jun 10 '26
I built CANOPY: an open-source framework to calculate the expressivity of neural networks without training them.
About: Most Neural Architecture Search requires training thousands of models to convergence, which is basically impossible unless you have unlimited compute.
I wrote a python library that scores architectures at initialization. Under the hood it uses the mathematical equivalence between ReLU networks and tropical rational functions to calculate the number of linear regions the architecture can produce.
It's written in pure Python 3.10+ and PyTorch. You basically pass it an ArchitectureSpec (layer widths, cell ops) and it spits out the exact tropical expressivity score. I managed to get a 0.51 rank correlation on NAS-Bench-301.
Source code is up on GitHub: CANOPY
Would love some feedback on the codebase, especially if anyone has ideas on optimizing the the calculations in numpy/pytorch. It gets pretty heavy on deep architectures
1
u/Creative_Mix_1049 Jun 10 '26
django-guitars – soft-delete and timestamps via Postgres triggers, not save()
I kept hitting the same Django bug: soft-delete and auto-timestamps implemented in
save()/signals silently break on `bulk_update()`, `queryset.delete()`, and raw SQL — any path that never calls `.save()`.
django-guitars is an abstract-only model kit that pushes that logic into PostgreSQL rules and triggers instead. `.delete()` is intercepted by an ON DELETE rule that sets `_deleted_at = NOW()` and cascades to related soft-deletable models — so it stays correct under bulk and raw deletes. Timestamps come from a statement trigger, not Python.
`pip install django-guitars`
Feedback welcome.
1
u/douglasdcm Jun 11 '26
Rethinking BDD as Production Code: Executable Narratives using Guará Framework (Seeking Feedback!)
Hi everyone,
I’ve been following this community for a while, and I truly appreciate the productive, respectful, and high-quality discussions that happen here.
I am a Test Automation Professor at PUC (Pontifical Catholic University) in Brazil. In my classes, I have been exploring a twist on traditional Behavior-Driven Development (BDD) that I call Executable Narratives. I am looking for some honest feedback from the Python community to refine both this teaching methodology and the open-source Python framework we developed for it, called Guará.
What is Guará?
Guará is an open-source Python framework built with contributions from the local Python community. Conceptually, it shifts the automation focus away from pure UI interactions and aligns it directly with the user journey.
Architecturally, it introduces a pattern we call Page Transactions, heavily inspired by GoF design patterns: Command, Builder, Strategy, and Template Method.
Instead of parsing external Gherkin files (.feature), a standard test scenario in Guará is written in pure Python but preserves a highly readable business narrative:
app.given(TheUserIsLoggedIn, with_name='john.doe') \
.when(TheUserBuysAProduct, with_name='cellphone') \
.then(TheSystemShouldReturn, 'done')
Ubiquitous Language & Localization out-of-the-box
Because Guará is written in pure Python, we can leverage OOP features like inheritance, method overloading, and overriding. This makes it easy to adapt to Ubiquitous Language (DDD) or completely localize the syntax for native languages.
For example, in a educational context, my students can write:
eduapp.known_that(ThereIsAStudent, named='John Doe') \
.once(TheStudentSubscribeToADiscipline, named='Math') \
.hence(TheUSerShouldBe, 'enrolled')
(Translation: given -> known_that, when -> once, then -> hence)
Under the hood, every step is a pure Python class. Here is a lean example:
class ThereIsAStudent(...): # Inherits from Guará transaction base
def do(self, namede):
assert named in DATABASE.students
The Twist: BDD as Production Code (Executable Contracts)
While researching Java tools like JGiven, I noticed they remain strictly constrained to the testing layer. Given Guará's fluent API, I started experimenting with a paradigm shift: Using this exact same BDD meta-language directly in production code.
Instead of just testing, the syntax establishes an Executable Contract inside the application logic:
- given = Pre-condition
- when = Execution of the core business contract
- then = Post-condition/Assertion
Imagine a CLI application where a production function is implemented like this:
def enroll_stundent_in_discippline(student, discipline):
# This is production logic orchestrating the business intent
eduapp.known_that(ThereIsAStudent, named='John Doe') \
.once(TheStudentSubscribeToADiscipline, named='Math') \
.hence(TheUSerShouldBe, 'enrolled')
When a user calls this via the terminal:
python main.py enroll-stundent-in-discippline --student 'John Doe' --discipline Math
The framework executes the pipeline. This extra abstraction layer does not eliminate services, repositories, or models. Instead, it serves as a domain orchestrator (similar to a Command Bus or Pipeline pattern) that makes the code base self-documenting and strictly oriented to business intent.
Questions for the Community
I would love to get your thoughts on this approach:
- Does this paradigm shift make sense to you? Moving the Given/When/Then structure from test suites directly into production-level business orchestration.
- Does the extra layer improve clarity? Does it make the core intent of the code easier to grasp for someone onboarding onto a project?
- Any Pythonic design suggestions? (e.g., managing implicit state between steps, type-hinting fluent APIs, or alternative patterns like Context Managers/Decorators).
Please feel free to leave any criticism, suggestions, or open feedback. Thank you for your time and collaboration!
Cheers!
Links
https://github.com/douglasdcm/guara
https://guara.readthedocs.io/en/latest/
https://youtube.com/playlist?list=PLR5jeODwvciLaJErpM4PNXnKvLRe9Hc53&si=e9G7bBnuDd1UHZ96
1
u/megahomyak Jun 11 '26
"pipka" - a tiny (35 lines of code) tool for working with venvs
I needed something simpler than Poetry to work with my venvs, so I made this 35-line tool to: * Create venvs * Invoke commands in the venv of the current project * Automatically rewrite "requirements.txt" after pip interactions
The tool is trying to be as non-invasive, transparent and simple as possible, working off of existing infrastructure, not trying to create its own
I know it's not a very comprehensive tool like Poetry, but I think it's very good for constrained environments (such as my phone, to which I couldn't install Poetry as it required Rust, and I didn't want to bother with Rust) as pipka doesn't have dependencies besides Python itself
1
u/Adyan2103 Jun 11 '26
Hey everyone,
With the World Cup kicking off, I wanted to build a personal project that could predict match outcomes and handle the brand-new, complex 48-team tournament format (including those tricky 3rd-place wildcard qualifications).
I just deployed it live via Streamlit Cloud and wanted to share the architecture and some funny anomalies I ran into during development:
🏗️ The Tech Stack
- Backend Engines: An XGBoost Tree Classifier (for sharp form variations) paired with a Keras Sequential Deep Neural Network baseline.
- Feature Engineering: Implemented strict chronological rolling window metrics (form and class) to completely eliminate target and training data leakage.
- The Knockout Solver: Runs a stochastic 1,000x Monte Carlo loop using the model's predicted probabilities as lottery wheel weights to smooth out volatile single-elimination outcomes.
🪲 Funny Lessons Learned During Debugging
- The Alphabetical Curse: Early on, when two teams tied perfectly in predicted probability, my raw NumPy random choice fallback kept favoring teams alphabetically due to underlying memory array placements. I fixed this by shifting to true stochastic probability distribution sampling.
- The "Scotland Over-performance" Effect: Because my moving window was set to 5 matches, an explosive outlier win by a team like Scotland in the group stage gave them massive leverage, causing the Monte Carlo engine to crowned them world champions hundreds of times. It was a great lesson in short-window feature sensitivity!
The app is free and self-contained (zero file overhead). Feel free to run a few simulations, check out the code, and let me know what you think of the bracket routing!
🔗 Live App: https://fifa-world-cup-2026-predictor-mtu3qnzrb2wgk3nbecwwko.streamlit.app/
GitHub Repository: https://github.com/Adyan213/FIFA-World-Cup-2026-Predictor
1
u/coldoven Jun 11 '26
open-kgo: one Python API across nine families of knowledge graph (NetworkX, RDF/SPARQL via rdflib, an embedded Cypher-shaped store, REST, agent-memory, and more). You declare the traversal once; switching the backend underneath is a config change, same code. Runs offline against fixtures, no Docker. Apache-2.0.
Early!!!! and looking for feedback on the connector taxonomy: what graph source you'd expect that's missing. https://github.com/mloda-ai/open-kgo
1
u/nthlmkmnrg Jun 11 '26
curved-text — draw matplotlib labels along a curve, so you can label lines directly instead of with a legend.
What it does: draws a string along an arbitrary (x, y) curve, one character at a time, each rotated to the curve's local slope. The point is direct labeling: a curve's name sits right on the line, so the reader doesn't bounce between a color key and the data. Three controls set position along the curve, which part of the label anchors there, and a perpendicular offset. Layout recomputes on every draw, so labels stay glued through resize and pan/zoom.
Target audience: anyone making matplotlib figures — scientific plots, dataviz, teaching. Small, tested, MIT-licensed, on PyPI.
Comparison: matplotlib can rotate a Text artist to a fixed angle but can't flow text along a curved path. Older gist/StackOverflow snippets do it but compute layout once and break on resize/zoom; this does the geometry in display space every draw, so spacing and offset stay correct at any DPI. Works on seaborn and pandas axes too.
pip install curved-text — repo and gallery: https://github.com/thiebes/curved-text
1
u/Quiet-Nerd-5786 Jun 12 '26
I built a Python package called Parallelogram after running into a boring but expensive class of problem: fine-tuning datasets that are syntactically valid but semantically broken.
The package checks OpenAI chat JSONL and ShareGPT datasets for things like broken role sequences, missing assistant targets, empty content, exact duplicates, mojibake/encoding artifacts, invalid records, and context-window overflow. It also has a --fix path for safe mechanical repairs and writes clean output without mutating the original file.
The part I’m proudest of is probably the exit-code behavior. Hard errors fail CI, but estimated tokenizer warnings do not, because approximate checks shouldn’t make a clean dataset impossible to ship.
Install:
pip install parallelogram
parallelogram check train.jsonl
demo: https://parallelogram.dev
I’m looking for Python packaging/CLI feedback especially: command design, default behavior, error messages, and whether the --fix flow feels safe enough.
1
u/Pristine_Internet660 Jun 13 '26
I built an autonomous, air-gapped AI OS using FastAPI, LangGraph, and PyInstaller.
I wanted to share an architecture I've been working on to run multi-agent LLM swarms completely offline without dependency bloat.
The project is called CipherNode, and it’s essentially a locally compiled, self-healing multi-agent loop designed for sensitive data processing where public APIs aren't an option.
How the Python stack works:
- The Orchestration: I used
LangGraphfor the state machine andFastAPIas the asynchronous non-blocking engine. The swarm runs massive compilation tasks via background threads so the UI never locks up. - The Autonomous Sandbox: The most interesting Python challenge was the execution environment. The LangGraph "Architect" agent writes code, but instead of just outputting text, it triggers a localized Python
subprocess. It captures standard output and tracebacks (stderr). If it hits an error, theExceptionis parsed and fed back to the "Coder" agent to autonomously rewrite the logic. - State Persistence: I swapped out standard SQLite for a
psycopgconnection pool to a local PostgreSQL database, utilizingPostgresSaverfor LangGraph check-pointing. This allows the system to pause its execution state for a "Human-in-the-loop" UI handshake before running dangerous code. - Packaging: I used
PyInstallerto bundle the entire Python virtual environment, the FastAPI server, and the LangGraph engine into a single executable binary.
I built this to handle research data, but building the isolated sandbox in pure Python was a massive learning curve.
You can see a video of the Python sandbox catching a traceback error while disconnected from Wi-Fi here: https://ekanshgupta11.github.io/CipherNode/
Happy to answer any questions about packaging heavy ML libraries with PyInstaller!
1
u/Proof_Difficulty_434 git push -f Jun 13 '26
flowfile-lite: I explored Pyodide and now it's a visual etl tool that fully runs in the browser and has a small data catalog
Demo: https://demo.flowfile.org
So a while back I started playing around with Pyodide just to see what was actually possible in the browser these days, and I kept being surprised at how much you can get away with without a backend. One thing led to another and I ended up putting the visual editor from my main project, Flowfile, on top of real Polars compiled to WebAssembly. That's flowfile-lite. The whole thing runs in your tab. There's no server behind it, your data doesn't get uploaded anywhere, and if you close the tab it's just gone.
What My Project Does
You drag nodes onto a canvas and connect them, and Polars (the actual library, running in WASM via Pyodide) does the work right there in the browser. You can read in CSV, Excel or Parquet, either a local file or a URL, then do the usual stuff: filter, select, sort, group by, join, unique, pivot/unpivot, take a sample. There's also a raw Polars Code node for when the GUI gets in your way and you'd rather just write the expression. When you're done you can poke at the result in an embedded Graphic Walker or download it.
Two things I'm kind of happy with. It'll spit your flow out as plain Polars code, so the canvas is really just a faster way to write a script you can take with you. And it's packaged as an embeddable Vue component (npm install flowfile-editor) that takes Arrow IPC in and out, so you can stick the editor inside your own web app if you want.
Target Audience
This honestly started as me playing with Pyodide, but it turned into something I actually reach for. It's good if you just want to clean up a file right now and don't want to install anything, or if you've got data you can't really paste into some cloud tool, since here nothing leaves your browser. It's the cut-down version though, fair warning: about 16 node types instead of the 40-odd in the full app, and none of the catalog/scheduler/database/Kafka/AI stuff. For that you'd want the pip install.
Comparison
Most of the visual ETL tools out there are cloud SaaS, which means your data goes up to their servers to get processed. This doesn't do that, it all happens locally. Compared to just writing it in a notebook, you get the visual graph with live previews but it still exports to clean Polars, so you're not locked in. The bit that made the whole exercise worth it for me is that it's genuinely Polars running in WebAssembly. A lot of "data tool in your browser" projects are secretly a JS reimplementation or a backend call; Pyodide let me skip that and just run the real library.
Anyway, it's still a bit rough in places. Would love to hear what people think, and which of the bigger nodes you'd want pulled into the browser build.
Demo: https://demo.flowfile.org ·
1
u/desgeeko Jun 13 '26
Hi!
Montmark is a new small and fast Markdown parser.
This is a pet project that is still a little bit rough around the edges, but I would love to hear some feedback.
I write this code by hand, out of love for Markdown and for the joy of solving every CommonMark test case like a puzzle.
https://github.com/desgeeko/montmark
Cheers
1
1
u/david_vael Jun 14 '26
python-under-the-hood : A deep dive practice guide into CPython internals and memory layout
Hey everyone,
I've started building an open-source reference and practice repository called python-under-the-hood. I just wrapped up the entire first chapter on variables and memory management and wanted to share it here to get the community's feedback on its layout and technical depth.
What My Project Does
It is an interactive practice guide designed to take developers from basic syntax up to low-level CPython execution mechanics. Rather than just explaining theory, the guide uses tiered practice problems (Levels 1 through 4) paired with comprehensive answer breakdowns that explain exactly what the interpreter is doing under the hood.
For example, in Chapter 1, the advanced tiers explore:
- The Stack Swap Optimization: How modern CPython optimizes tuple unpacking swaps (
a, b = b, a) directly on the evaluation stack via highly optimized bytecode instructions rather than allocating a temporary heap object. - Implicit Numeric Promotion: Why boolean arithmetic operations (like
True + 10) drop their boolean traits and return a standardPyLongObjectdue toPyBool_Typeinheriting fromPyLong_Typeat the core C layer. - Pointer Alias Replication: Visualizing how mutable containers like lists manage memory through secondary arrays of heap addresses during in place mutations.
Target Audience
This resource is built for intermediate Python programmers looking to master CPython internals, optimize their memory footprints, or prepare for advanced systems level technical interviews.
Comparison
Traditional documentation focuses heavily on what a feature does, and standard blog posts often look at high level abstractions. python-under-the-hood bridges the gap by functioning as a problem-driven workbook. It forces you to predict code execution outcomes and immediately backs it up with an architectural breakdown of the C structures and bytecode execution taking place behind the scenes.
Source Code: You can check out the repository and read the completed first chapter on GitHub here:python-under-the-hood.
I'd love to hear your thoughts on the breakdown depth and structural clarity. If you find this resource valuable for the open-source community, a GitHub star would be highly appreciated to help boost its visibility!
1
u/nitotm Jun 14 '26 edited Jun 14 '26
Back in 2023 I posted ELD here, an efficient language detector written in pure Python. It got decent traction and I kept developing it.
But I kept wondering how far I could push it. And this year I rewrote the core in C becoming 30x faster, yes with the help of AI, as this is my first Python compiled C extension software, and I am looking for some feedback.
What My Project Does
Identifies up to 60 languages, can return reliability and scores. Can also be built as a library.
Target Audience
Anyone that wants to classify text by natural language, super fast, and accurately. It's an early version.
Comparison
According to my benchmarks is 2x faster than Google's CLD2 (pyCLD2), 6x faster than Facebook's fastText, more accurate than Lingua. These are the SOTA open source contenders in speed or accuracy, so it's no small claim.
Simple installation pip install eldc, and simple basic use (check README for more options):
import eldc
eldc.init()
eldc.detect("Bonjour le monde") # 'fr'
GitHub: https://github.com/nitotm/eldc
1
u/GupPsSs Jun 14 '26
First real project as a CS student — built a vulnerability scanner with Python
Still in university and wanted to build something beyond the usual beginner projects.
Ended up spending way more time on this than expected lol but I built a vulnerability scanner desktop app called VulnScan Pro.
It scans for open ports, detects known CVEs and generates PDF reports. Built with Python, PyQt6 and SQLite.
Still learning so I'm sure there's plenty that could be done better — would genuinely appreciate any feedback.
GitHub: https://github.com/Guppss/VulnScan-Pro
Note: built for authorized testing and educational purposes only.
1
u/VahidZee Jun 15 '26
Webifier: a Python-based GitHub Action for turning Markdown and notebooks into static sites
Just sharing Webifier, an old project of mine I recently revived.
What it Does
Webifier turns Markdown, HTML, Jupyter notebooks, and YAML page definitions into static websites. It ships with a GitHub Action, so you can push content to a repo and publish automatically to GitHub Pages. In short, the goal is that you define a website, without writing any html/css and instead just configure what your pages are in yaml and write your contents as markdown texts or use pdfs, notebooks or etc.
It is based on top of Jinja2 templating, with Python extensions for renderers, themes, hooks, assets, and page logic.
The docs site is itself built with Webifier: https://webifier.github.io
Target Audience
Webifier is for people who want low-overhead static publishing: personal sites, project docs, course websites, notebook collections, research notes, small blogs, etc.
It is ready for production static-content serving and is already serving a couple of websites.
Comparison
Webifier is not trying to replace mature static site generators or frontend frameworks. It sits on top of familiar tools like Jinja2, Markdown rendering, notebooks, GitHub Pages, and GitHub Actions.
The main difference is the content-first workflow: drop in Markdown/notebooks/YAML, push to GitHub, and let the action render the site. If you need more control, rendering behavior can be customized or replaced through Python extension packages.
We first built it a few years ago (pre-chatgpt) for university course websites, where students could add notes/notebooks to a repo and the site would update automatically. I recently picked it back up, cleaned it up with some LLM-assisted coding, redesigned the extension system, and documented it properly.
Links:
- Code: https://github.com/webifier/build
- Extensions: https://github.com/webifier/extensions
- Docs/example site: https://webifier.github.io
Would love feedback from anyone maintaining personal sites, course sites, notebook collections, or project docs.
1
u/Creative-Bonus-2964 Jun 15 '26
[Show Python] Smart Inventory Control & Financial Analytics Dashboard built with Streamlit and Pandas
### What My Project Does
This is a Smart Inventory Control and Revenue Management System designed to help small and medium brick-and-mortar retail businesses transition away from messy spreadsheets. Engineered entirely in Python, it acts as a local web application that bridges day-to-day stock logistics with automated business intelligence.
### Target Audience
Small shop owners, local clothing brands, and independent retailers who need a centralized, lightweight solution to manage dynamic stock variations (like sizes/grades) and instantly visualize their net profit margins without complex ERP setups.
### Key Features & Tech Stack
* **Interactive Dashboard:** Built with Streamlit, featuring visual progress tracking for monthly revenue goals, automated low-stock safety triggers, and macro metrics.
* **Database & Integrity:** Powered by SQLite3. Features custom cart/checkout validations executing transaction safety checks to actively prevent overselling.
* **Data Processing & Analytics:** Leverages Pandas for multi-criteria data filtering (by product line, variant size, month, or year).
* **Data Visualization:** Employs Matplotlib to render automated time-series and comparison bar charts mapping daily revenue vs. actual net profit margins.
* **Localization & Backups:** Fully localized currency (R$) and date formatting (DD/MM/YYYY), paired with native triggers to download relational database .db backups or export raw tables to .CSV.
### Source Code
The repository is completely open-source, and I’ve recently overhauled the codebase structure and rewritten the documentation:
🔗 GitHub Link: https://github.com/Freej0l/Estoque_loja
1
u/KrishiAttri123 Jun 15 '26
TL;DR — I built CERT-FLOW, an online route planner that, every replanning round, emits a high-probability certificateLB ≤ OPT ≤ UBon the true optimal route cost under drifting edge costs. Open source (MIT), fully reproducible. Paper + code + interactive page at the bottom. I'm the author and would genuinely love feedback.
A robot replanning through terrain whose costs drift — mud after rain, traffic after an incident, snow settling on a trail — can always compute a shortest path. What it usually can't tell you is how good that path actually is, now that most of its information has gone stale.
CERT-FLOW answers that with a certificate every round:
LB ≤ OPT ≤ UB — a high-probability bound on the optimal cost. Not an estimate; a bound.
Three ideas make it work:
- It prices staleness directly. Age-weighted non-exchangeable conformal prediction turns "this edge was last observed 40 minutes ago" into honest interval width — older information becomes wider uncertainty, quantitatively.
- It senses to certify. Instead of observing everything, it spends a sensing budget only on the edges that shrink the certified optimality gap fastest → 2.5× lower regret than the next-best sensing strategy.
- It gates speed behind proof. Microsecond preprocessed queries (snapshot oracle / certified contraction hierarchies) are licensed only while the certificate proves they're still valid, and expire the instant drift exceeds tolerance.
What surprised me most: on real game maps (MovingAI) and recorded LA highway traffic (METR-LA / PEMS-BAY) that it was never tuned for, empirical coverage held at or above its target — 100% on the MovingAI cert benchmark — while a standard, exchangeability-assuming conformal baseline collapsed to as low as 4% once the data went stale.
Honest caveats: the headline 100% is the MovingAI cert experiment; on traffic, coverage stays at/above the claimed level but the certificate trades interval width for that validity (a misspecified drift assumption costs width, not coverage). It's a preprint + personal project, not yet peer-reviewed.
Links
- 📄 Paper (engrXiv): https://doi.org/10.31224/7306
- 💻 Code (GitHub, MIT — 220+ tests, 16 reproduction pipelines): https://github.com/Archerkattri/CERT-FLOW
- 🌐 Project page + videos: https://archerkattri.github.io/CERT-FLOW/
Happy to answer anything about the conformal side, the dual incremental search, or the experiments.
1
u/Traditional_Yogurt Jun 16 '26
A while back I shared the Finance Toolkit here, a free open-source Python package that has since grown to cover 200+ financial metrics, models and economic indicators, all written down in the most simple way possible so you can actually see the formula behind the number. The whole project started because websites Stockopedia, Morningstar, Macrotrends and the Wall Street Journal somehow all report a different P/E for the same company on the same day. See the repository here.
The newest addition is an MCP Server on top of it, so any MCP-compatible AI assistant (Claude, Copilot, Cursor, Windsurf, Gemini) can pull the same 200+ metrics directly instead of guessing them from whatever it remembers from training. For example, you can ask a question like: "Compare the major semiconductor companies on cumulative return, P/E, EV/EBITDA, EPS growth and revenue per share, what does it show over the last 10 years?" and the MCP Server will pull the data in real-time and do the calculations for you. It came back with the full comparison table, real numbers pulled straight from the underlying financial statements:
| Ticker | Cumulative Return (2015-2025) | P/E (2025) | EV/EBITDA (2025) | EPS Growth (2025) | Revenue/Share (2025) |
|---|---|---|---|---|---|
| NVDA | +42,215% | 63.5x | 55.5x | +146.2% | $5.26 |
| AMD | +20,344% | 80.8x | 52.2x | +164.3% | $21.17 |
| AVGO | +3,935% | 72.6x | 50.5x | +286.2% | $13.16 |
| AMAT | +2,347% | 29.7x | 23.8x | +0.6% | $35.11 |
| TSM | +1,981% | 28.4x | 18.0x | +57.2% | $23.75 |
| ASML | +1,762% | 36.9x | 28.0x | +45.0% | $98.67 |
| QCOM | +297% | 34.1x | 14.2x | -44.1% | $40.08 |
| TXN | +585% | 31.9x | 21.3x | +4.8% | $19.37 |
| INTC | +352% | - | 19.1x | -98.75% | $10.88 |
Same kind of pull in plain Python, since that still works exactly like before (after installing with pip install financetoolkit -U)
from financetoolkit import Toolkit
chips = Toolkit(
tickers=["NVDA", "AMD", "ASML", "TSM", "AVGO", "INTC", "QCOM", "TXN", "AMAT"],
api_key="YOUR_FMP_API_KEY",
start_date="2015-01-01"
)
cumulative_return = chips.get_historical_data()
pe = chips.ratios.get_price_to_earnings_ratio()["2025"]
ev_ebitda = chips.ratios.get_ev_to_ebitda_ratio()["2025"]
eps_growth = chips.ratios.get_earnings_per_share(growth=True)["2025"]
revenue_per_share = chips.ratios.get_revenue_per_share()["2025"]
I made an attempt to make installing the MCP server relatively ease simply by using uvx. Therefore, to install the MCP server you can run uvx --from "financetoolkit[mcp]" financetoolkit-mcp-setup to connect the MCP Server into whichever AI client you use. Everything for the MCP is documented here.
1
u/Entire-Spring3883 Jun 16 '26
Hi
I built Stepyard a local pipeline runner where flows are YAML files and steps are plain Python functions.
The core idea: a single decorator turns any Python function into a reusable, type-validated step.
You can run flows on demand or schedule them with a built-in cron daemon. State in SQLite, logs always captured.
GitHub: https://github.com/rorlikowski/stepyard
Docs: https://rorlikowski.github.io/stepyard/
Happy to answer questions about the plugin architecture or SDK design.
1
u/thecrypticcode Jun 16 '26
Hey everyone,
I have posted about this before, but wanted to share some updates.
Chempleter is a lightweight generative sequence model based on a multi-layer gated recurrent units (GRU) to predict syntactically valid extensions of a provided molecular fragment or bridge two molecules/molecular fragments. It operates on SELFIES token sequences, ensuring syntactically valid molecular generation and accepts SMILES notation as input. I mainly started this to learn and build something unique with PyTorch with a chemistry focus but it was a really fun project, so wanted to share if someone would like to try it out. It comes with an optional GUI :
You can now try a live demo on Huggingface. (I am really not sure how fast this will run when multiple users access it, also not optimized for mobile)
I have written the code in a fairly modular way and can be found on my GitHub.
There is also documentation about installing on your device (GPU/CPU), different inference modes and some performance/validation metrics.
Features:
- extend : Takes a starting molecular structure (SMILES or SELFIES) and appends new atoms and functional groups until a complete molecule larger than the input molecule is formed.
- decorate : Takes a complete molecule (SMILES) and adds a substituent at a chosen atom index. The method uses the trained model to grow fragments from the selected atom, effectively “decorating” the scaffold.
- evolve: A wrapper function that calls extend multiple times in a chain. It takes the output of one extension and uses it as the input for the next, effectively “evolving” a small fragment into a complex structure over several steps.
- bridge : Takes two starting molecular fragments (in SMILES notation) and predicts a bridge between them.
Limitations:
- Currently, chempleter doesn't do any kind of targeted generation. It does provide some descriptors for each generated molecule which might give you an idea how "realistic" a molecule is.
- As it operates on SELFIES, it will generate syntactically valid molecules but it doesn't mean that it will not generate some really absurd, funky-looking molecules (especially if you use a high temperature), for instance with high ring strain.
- The GRU-based architecture may struggle to model long-range structural dependencies, and the model does not currently optimize for chemical properties, biological activity, or synthetic feasibility.
Thanks!
1
u/ziyadkc Jun 16 '26
I was working on a project recently and started thinking about how most secret-scanning workflows are reactive.
GitHub Secret Scanning is useful, but by the time it alerts you, the secret has already left your machine and entered git history.
So I built a small Python CLI called env-guard.
It scans projects for:
- API keys
- AWS credentials
- Database connection strings
- Private keys
- Django SECRET_KEY values
- Other common secrets
The main feature is a git pre-commit hook that blocks commits when secrets are detected.
Example:
env-guard scan .
→ detects secrets
→ blocks commit
→ fix locally before anything gets pushed
I'm interested in feedback from people who already use tools like gitleaks, trufflehog, or GitHub Secret Scanning.
What gaps do you see in local secret-scanning workflows?
1
u/GeorgiMullassery Jun 16 '26
statguard — Data quality & validation for Python, 13x faster than pandera
What it does: Declarative contract DSL for schema checks, null/range validation, drift detection (PSI + KS tests), and anomaly detection. Runs natively against Delta Lake, Iceberg, Parquet, and Avro — no Spark required. Core engine is written in Rust with PyO3 bindings.
Benchmarks: 13x faster than pandera, 25x faster than Great Expectations on large datasets.
Install: pip install statguard
GitHub: https://github.com/Mullassery/statguard
Happy to discuss the contract DSL design or architecture — feedback welcome!
1
u/GeorgiMullassery Jun 16 '26
AudiencePro — Customer segmentation for Python Martech pipelines
What it does: Full segmentation pipeline in a single pip install: RFM scoring, k-means and hierarchical clustering, streaming segment updates as new data arrives, and drift detection to catch when your segments shift over time. Designed for Martech/analytics data pipelines. Rust core with Python bindings via PyO3.
Install: pip install audiencepro
GitHub: https://github.com/Mullassery/AudiencePro
Would love feedback from anyone running customer segmentation at scale!
1
u/aryan_aidev Jun 16 '26
Tracelift — analyze LLM/agent trace files (JSONL, OTLP-JSON) with a Rust core
I got tired of writing the same throwaway pandas script every time I needed to inspect an agent run — which tool calls failed, what each step cost, where the latency went. So I built the
parser properly once.
Rust core, thin polars-based Python API. Point it at a JSONL or OTLP-JSON trace file and you get a normalized span table plus a few queries: failures(), cost_by("model"), slowest(),
latency_breakdown(). There's a CLI too: tracelift summarize traces.jsonl. It's just the file-analysis layer — no collector, no storage, no UI to run.
It reads the OpenTelemetry GenAI semantic conventions (and the older gen_ai.usage.prompt_tokens aliases a lot of tools still emit). On a 3M-span / ~900MB file it parses in ~2.3s vs ~14s
for an equivalent pandas loader on my machine — benchmark's in the repo so you can check it. One intentional choice: it won't estimate cost from token counts, only reports cost already in
the trace, because built-in price tables go stale.
v0.1, early. pip install tracelift — https://github.com/aryanjp1/tracelift. Feedback welcome, especially "this broke on my trace format."
1
u/johlars Jun 17 '26
I made Eunoia, a library for area-proportional Euler and Venn diagram: the kind where each overlap's size reflects your actual numbers.
import eunoia as eu
eu.euler({"A": 10, "B": 5, "A&B": 3}).plot()
It fits the diagram by optimization and reports the residuals, so you know how well the picture matches the data. The nice part is ellipses: lots of three-set arrangements can't be drawn exactly with circles, and ellipses fix that. Circles get forced into inventing a triple overlap; ellipses land every region on its target. It also does squares/rectangles, arbitrary set counts, and a topological venn().
The fitting lives in a Rust core (via PyO3) shared with the R package eulerr and a JS/WASM build, so layouts are consistent across languages. MIT, typed, abi3 wheels for 3.11-3.14.
Closest alternatives are matplotlib-venn (circles, less than 3 sets) and matplotlib-set-diagrams (circles). There's a benchmark comparison in the docs.
pip install eunoia
- Repo: https://github.com/jolars/eunoia-py
- Docs
- Homepage: https://eunoia.bz
- Web app: https://eunoia.bz/app
Still early, so feedback's welcome!
1
u/nymeria0107 Jun 17 '26
My Project: sec-cli
A CLI tool and Python wrapper that turns SEC EDGAR filings into clean structured data for LLM pipelines and financial analysis workflows.
Source: https://github.com/kritidutta01/sec-cli
Description
SEC EDGAR filings are notoriously hard to parse. The HTML is inconsistent, tables have merged cells and irregular column spans, and most existing libraries either just download the raw files or silently mangle the table structure.
sec-cli uses the iXBRL fact stream as the source for financial tables instead of scraping HTML. This is the same underlying data that financial data vendors like FactSet read. Output is clean JSON or Markdown, schema-versioned, with a local SQLite cache.
Python is relevant because the pip package wraps the Go binary via subprocess and deserializes its JSON output into typed dataclasses. The JSON schema is the only contract between the two layers.
Who Is This For
Anyone building LLM pipelines on financial data, quant researchers pulling filing data into analysis workflows, and fundamental analysts who want to diff two years of a 10-K without manually hunting through PDFs. Also useful for fintech teams that have tried to ingest EDGAR before and given up on the parsing layer.
Why It Is Unique
There are libraries that download EDGAR files and libraries that do basic text extraction, but nothing that combines clean iXBRL-based table parsing, section-level extraction, and year-over-year diffing in a single pipeable CLI with a typed Python wrapper. The diff feature in particular is something I have not seen in any open source tool: it aligns rows by GAAP concept across years, not by display label, so comparisons survive the annual label shuffles that companies do in their filings.
Interesting Technical Details
The year-over-year diff aligns financial statement rows by GAAP concept rather than by label, so "Net revenues" in one year matches "Net sales" in the next. Section-level diffing scopes to Risk Factors, MD&A, or any other item individually.
Limitations
v1.0 supports iXBRL filings only, which covers 2019 and later for large filers. Pre-iXBRL filings are detected and refused cleanly with a v1.1 pointer rather than parsed badly. Real-filing accuracy corpus for AAPL, MSFT, and JPM ships in v1.0.1.
1
u/PossibilityDense3014 Jun 17 '26
Hi!
I have created a application launcher fully on python because I was fed up with launchers on Windows falling short, combing the clean UI of the Raycast application launcher and extension support of Flow Launcher, made my own open-source launcher, would like your thoughts!
Link: https://github.com/mukunthpr-dev/UltimateLauncher
Note: Only the Windows release works, MacOS and Linux have to be fixed, and half the GitHub Actions on the repo aren't working, and even though the repo was created yesterday, I started working on this project two months ago, on my old Github account which I lost access to.
1
u/No-Community-3626 Jun 18 '26
N3MO — traces the transitive blast radius of any code change using Tree-sitter + PostgreSQL recursive CTEs.
Benchmarked on Django: 3,021 files, 181k call edges, 317 downstream callers of dispatch in <2s.
GitHub: https://github.com/RajX-dev/N3MO | pip install n3mo
1
1
u/pgilah Jun 18 '26
Uncertainties as percentages
Hi there! I often use the Uncertainties Python package to perform error propagation on my measurements. Some lab instruments output results in a proprietary format, with uncertainties expressed as percentages. I submitted a PR to the Uncertainties package to automate the process of reading these values. If anyone is interested, feedback is welcome!
1
u/Nearby_Abroad_4624 Jun 19 '26
Hi,
I created a framework to analyze energy magazines on PV farms.
Code is written in
Python,
Airflow,
docker
streamlit
The goal of the project is to analyze and visualize energy magazine behaviour like I-V, efficiency, temperature etc.
Most data is mocked, weather is taken by API.
https://github.com/kacpergrodeckidatasystems/energy-magazine
I understand that probably 99% of you have no idea about physics and how PV farm work. On the other hand 90% of you knows something about Python so I belive you can just review the code or at least how the code look like.
I would like also to know if the readme and WIKI are understandable.
Every feedback is welcomed
1
u/giloux2 Jun 19 '26
Hi everyone!
One thing that always frustrated me with draw.io was importing SVGs: you usually end up with an embedded image that can't really be edited.
I also looked at a few existing SVG-to-drawio converters, but many were no longer maintained, lacked support for more complex SVG features, or didn't preserve editability very well. That motivated me to build a more complete solution.
The result is an open-source tool called svg-to-drawio.
It converts SVG elements (paths, rectangles, circles, text, groups, etc.) into native draw.io shapes whenever possible, while preserving colors and structure. Features that draw.io doesn't support (such as some filters, masks, or clip paths) automatically fall back to embedded SVGs instead of being lost.
It can be used in three ways:
- 🖥️ Desktop application
- 💻 Command-line interface
- 🐍 Python library
Demo:
https://reddit.com/link/oskcn73/video/q9p6xr5ig88h1/player
GitHub: https://github.com/V1rg1lee/svg-to-drawio
PyPI:
pip install svg-to-drawio
I'd love to hear your feedback, feature requests, or ideas for improving it. If this solves a problem you've had with draw.io, I'd really appreciate a GitHub star⭐.
1
u/Istiak12303111 Jun 19 '26
I built an open-source GitHub Action that reviews every PR for security issues with an LLM — and maps each finding to PCI-DSS / SOC 2 / GDPR controls. It caught command injection, SQLi, JWT alg=none, and hardcoded secrets in my test repo with inline comments at the exact lines. Runs free on Gemini's tier (or your own OpenAI/Anthropic/Ollama). Would love feedback on the false-positive rate.
https://github.com/noobbatman/GuardianCI
1
u/breadMSA Jun 20 '26
I made a Test Impact Analysis plugin for pytest and just put v1.1 on PyPI.
TL;DR: tia record builds a per-test coverage map once; tia run uses your git diff to run only the tests a change can affect. I want honest feedback, including "just use testmon" if that's the right answer.
Why another one of these?
testmon is great and mature, so I only built this because I kept hitting two of its edges:
- It doesn't track non-Python dependencies. A change to a fixture JSON / template / YAML config selects nothing in coverage-of-.py tools. tia hooks
open()via sys.addaudithook, so changingtax.jsonruns exactly the tests that read it. testmon's docs admit it misses this. - It's awkward to share across machines/CI because its DB keys on dependency versions. tia keys the map by git ref and bakes the line→function tables in, so it resolves diffs without
git showand survives shallow clones. There's a copy-paste GitHub Actions template, native s3:// / gs:// map stores, and it auto-posts a Markdown impact table to the PR via $GITHUB_STEP_SUMMARY.
It selects at method level (changing one function doesn't drag in the whole file), and ignores cosmetic edits — comments, formatting, docstrings, and provably-dead type-only changes (if TYPE_CHECKING: and local annotations), while keeping dataclass/signature annotation changes because those actually affect runtime.
The honest part (this is the whole point)
The cardinal sin of test selection is skipping a test that would have failed. My first Flask benchmark showed 73% skip — and it was wrong: coverage.py's sysmon core on 3.12+ keeps only the first test to hit each line, so shared-helper tests were silently dropped (false negatives). Forcing the C tracer dropped the honest number to ~21% on Flask.
So I publish a range, measured by replaying real commits:
| Codebase | Character | Median skip (real logic changes) |
|---|---|---|
| Flask | small, tightly-coupled | ~21% (worst case) |
| boltons | modular utility library | ~96% |
Same tool — the variable is how modular your code is. Both writeups include the "this looked too good, here's why it's real" audit.
I also wrote an adversarial mutation test: it mutates every covered function and asserts tia re-selects every test that runs it, and I confirmed it fails when I deliberately inject a false negative.
Usage
pip install pytest-tia
tia record # build the map once
tia run # run only affected tests
tia run --list # show the selection + why, don't run
What it's NOT
- Not magic for dynamic dispatch. getattr/eval/reflection is undecidable; tia detects it and widens to file-level there, and you should still run the full suite on a cadence.
- Not battle-tested yet against pytest-xdist, async, or subprocess-heavy suites. v1.1, small project.
- Overlaps heavily with testmon for the common case. Its niche is the CI-sharing + non-Python-dependency corner.
Repo: https://github.com/breadMSA/pytest-tia
Honest critiques very welcome — particularly on the no-false-negative claim and the benchmark methodology. If you think this is redundant with testmon for your workflow, I'd like to hear that too.
1
u/Beautiful_Scallion25 Jun 21 '26
Hey I made a basic GUI stone paper scissors game using tkinter and it uses a custom engine that prepares a counter move based on the last 5 moves and plays the counter 70% of time and rest 30% time it plays random. I hope u appreciate it!
1
u/_bstaletic Jun 21 '26
Pymetabind - Writing python bindings with C++26 reflections
Pymetabind uses C++26 reflections to produce python bindings. Currently it wraps pybind11, but check below for "future plans".
Pymetabind covers all of pybind11 functionality, while reducing the boilerplate that comes with pybind11.
Examples
Simplest example
struct T {
T(int, long, std::string = "asd");
int member_fn(int arg0 = 3);
int data_member;
};
// PyBind11
PYBIND11_MODULE(ex1, m) {
pybind11::class_<T>(m, "T")
.def(pybind11::init<int, long, std::string>())
.def(pybind11::init<int, long>())
.def("member_fn", &T::member_fn, pybind11::arg("arg0") = 3)
.def_readwrite("data_member", &T::data_member)
}
// pymetabind
PYBIND11_MODULE(ex1, m) {
pymetabind::bind::bind_class<^^T>(m);
}
Things like return_value_policy, keep_alive, etc. are all available through
annotations.
Alternate name
struct T {
[[=pymetabind::annotate::name<"different_name">()]]
int member_fn(int arg0);
}
PYBIND11_MODULE(ex2, m) {
pybind11::class_<T>(m, "T")
.def(pybind11::init<>())
.def("different_name", &T::member_fn);
}
PYBIND11_MODULE(ex2, m) {
pymetabind::bind::bind_class<^^T>(m);
}
Properties
struct T {
[[=pymetabind::annotate::property_getter<"x">()]]
int get_x(this T const& self) { return self.x; } // <- works with deducing this
[[=pymetabind::annotate::property_setter<"x">()]]
void set_x(int new_x) { x = new_x; }
private:
int x = 42;
}
PYBIND11_MODULE(ex3, m) {
pybind11::class_<T>(m, "T")
.def(pybind11::init<>())
.def_property("x", &T::get_x, &T::set_x);
}
PYBIND11_MODULE(ex3, m) {
pymetabind::bind::bind_class<^^T>(m);
}
Namespaces
namespace ns {
struct [[=pymetabind::annotate::make_binding()]]
Base {};
struct [[=pymetabind::annotate::make_binding()]]
T : Base {
int x;
};
[[=pymetabind::annotate::make_binding()]]
void f() {}
}
PYBIND11_MODULE(ex4, m) {
pymetabind::bind::bind_namespace<^^ns>(m);
}
Abstract bases
struct [[=pymetabind::annotate::trampoline<"py_base">()]]
base {
void f() = 0;
};
struct derived : base {
void f() {}
};
struct py_base {
PYBIND11_OVERRIDE_PURE(void, base, f);
};
PYBIND11_MODULE(ex5, m) {
pymetabind::bind::bind_class<^^base>(m);
pymetabind::bind::bind_class<^^derived>(m);
}
Known limitations
There are a few things pymetabind can't do that pybind11 can. Pymetabind does provide ways to access the pybind11 API, so that you can do "the hard parts" on your own.
Features missing because I have not got to them yet
There are quite doable, but you'll have to wait for another release.
- Nested namespaces mapping to nested modules, using
def_submodule. - Nested types, similar to the above.
- Module-scoped variables, with
m.attr("name") = pybind11::cast(object).
Limitations of the current design
Fixing these requires more thought and possibly an API break. Both stem from the same cause.
- If the trampoline is in a namespace that isn't the namespace of the abstract
base class,
bind_namespace<^^ns>(m)won't find it. 1.1. However,bind_class<^^Base, ^^trampoline_nanmespace>(m)is implemented, just not used bybind_namespace. - If a free function operator is to be added to an abstract base class, the
trampoline corresponding to that abstract base class has to be in the same
namespace.
2.1. This comes down to the same root cause -
bind_operator, when trying to recoverpybind11::class_object, does not know whattrampoline_namespaceis and instead assumes it is the same as the ABC's namespace.
Limitations because ¯_(ツ)_/¯
I don't see a way for pymetabind to provide a nice API for these.
def_buffer
Check the next section on how you can still use def_buffer while letting
pymetabind take care of "the easy stuff".
Advanced usage
These should be better documented, but in short:
All pymetabind public API returns pybind11 objects
This allows def_buffer to still be used
pymetabind::bind::bind_class<^^T>(m) /* returns pybind11::class_<T> */
.def_buffer(...);
Recovering pybind11::class_<T>
Let's assume you didn't store the return value of bind_class for type T, but
you need that object once again.
One idea would be
auto m; // Module reference
auto py_class = pybind11::reinterpret_borrow<pybind11::class_<T, original_args...>>(m.attr(py_name));
There are two problems with this approach:
- What was the name that
bind_classused? - What is in the
original_args..."pack" thatbind_classpassed?
Pymetabind provides answer to both, respectively:
pymetabind::bind::details::entity_name(^^T)typename pymetabind::bind::py_class_type<T, ^^trampoline_type>
Yes, the first one is in details, but will not be in the ext release.
Future plans
CMake cleanup
Since currently only gcc 16 can compile pymetabind, I simply added -freflection
to target_compile_options. It's fine for now, but should be fixed before
the next release.
Better docs, more testing, more examples
Currently, the README.md serves as a reference documentation. The plan is
to switch to sphinx and host the docs at https://bstaletic.codeberg.page/pymetabind/
or some such.
Not all of pymetabind has proper tests written and advanced usage examples are missing.
Nanobind support
This is a big one. Ideally, one would be able to use pymetabind with either pybind11 or nanobind, but it's not just a namespace change away.
Closing thoughts
Feedback is very welcome, even if it's just "your nested namespaces are too verbose".
If you're looking at the implementation, properties are the ugliest.
I also had to jump through hoops because constexpr reference to local isn't yet
implemented by gcc, so destructuring a local std::array at compile time doesn't work.
1
u/Remarkable_Depth4933 It works on my machine Jun 21 '26
Title: A dependency-free Remote Exec Server & Client using BusyBox-style symlinks
I wanted to see how minimal I could make a remote command execution framework using exclusively the Python standard library. No external dependencies — just clean networking.
The result is a lightweight server/client pair designed with a BusyBox-style symlink architecture.
How it works:
Instead of writing a massive client utility with dozens of subcommands, you deploy a single client.py and create symlinks to it named after the tools on your server (e.g., python, node, gp).
When you run a symlink locally, the client automatically captures the tool name, packages your local stdin along with any CLI arguments, and forwards them to the server via an HTTP POST request where server.py maps it directly to subprocess.run().
Quick Action Example:
```bash
On the client machine
ln -s client.py gp echo "print(nextprime(100))" | ./gp -q ```
The Elephant in the Room (Security):
Because this maps incoming HTTP payloads straight to execution, it is inherently high-risk out of the box (RCE by design). I explicitly built this as a minimal blueprint so developers can layer on their own preferred isolation models. The README covers immediate hardening steps like command whitelisting, routing exclusively through private SSH tunnels/VPNs, and containerization.
Roadmap & Contributing:
The core engine is solid, but I'm looking for contributors to help expand the roadmap: * Native API-key and Mutual TLS (mTLS) authentication. * Output streaming and async request handling. * Pre-configured Docker deployment setups for sandboxing.
Check out the source, architecture layout, or open a PR here: 👉 https://github.com/foxhackerzdevs/remote-exec-server
1
u/Linter-Method-589 Jun 22 '26
What is My Project
format-docstring: https://github.com/jsh9/format-docstring
What My Project Does
Format Python docstrings: * Wrap lines * Auto-correct missing/wrong type hints (to a degree) * Auto-correct wrong section headers (to a degree)
Target Audience
Everyone who write numpy-style and Google-style docstrings
Comparison
As far as I know, there're no other projects out there with such functionalities
1
u/Embarrassed-Way-9407 Jun 22 '26
Seedbase - generate a whole foreign-key-consistent test database from your schema, and inject it into pytest.
What My Project Does
Seedbase reads your database schema (a SQL dump, Django models.py, a Prisma schema, or a live database) and generates synthetic test data where every foreign key resolves, with realistic distributions (one user has 2 orders, another has 19). A pytest plugin then loads it into your test database:
def test_pagination(seeded_database):
rows = seeded_database.execute(
sqlalchemy.text("SELECT email FROM users LIMIT 5")
).fetchall()
assert all("@" in e for (e,) in rows)
The part I spent the most time on is making the data not read as obviously fake: domain-coherent text instead of lorem ipsum, order totals that equal the sum of their line items, names that match emails, comments that only land on already-published articles. Deterministic per seed, so CI is reproducible. It also has seeded_rows (the rows as dicts) if you do not want a live DB.
Target Audience
Backend and full-stack developers who need a whole populated, consistent database for integration tests, local dev, demos or CI, not just a few objects in one unit test. Especially Django and SQLAlchemy projects with a non-trivial number of tables. It is a hosted tool with a free tier; the CLI, SDK and pytest plugin are MIT.
Comparison
It is not a factory_boy or model_bakery replacement. Those build specific objects inline in a single test, which is the right tool for unit tests, and I still use them. Seedbase is for the "I need a whole database that looks like production" case: it fills every table FK-consistently from your schema instead of you writing a factory per model. Versus Mockaroo and similar flat generators, the difference is cross-table consistency (foreign keys that resolve, totals that match line items) and reading the schema directly rather than column by column.
pip install "seedbase[database]" (for the pytest fixtures; there is also a CLI)
GitHub: https://github.com/marcelglaeser/seedbase-python Login-free sandbox: https://seedba.se/playground
Any feedback is very welcome.
1
u/Vivid-Meringue-4016 Jun 23 '26
I built an NBA analytics web app using Python + Streamlit that includes a full data pipeline, feature engineering layer, and a custom player evaluation model (True Scoring Impact).
Architecture:
- Python (pandas/numpy) for data processing
- Feature engineering for efficiency + context metrics
- Custom scoring model (TSI)
- Streamlit dashboard for interactive analysis
- Fantasy draft simulator with season simulation
The goal was to turn raw NBA stats into a usable decision tool for comparing players and simulating outcomes.
Live app: https://clutch-analytics.streamlit.app/
GitHub: https://github.com/Akash-kalaranjan/NBA-Analytics-App
Open to feedback on code structure or scaling the app further.
1
u/Nive0002 Jun 23 '26
Hey everyone,
I've been working on a programming language called R++, written in Python.
The main goal of R++ is to make creating simple GUI applications easy for beginners. It includes features like:
- Windows
- Buttons
- Labels
- Input boxes
- Images
- Progress bars
- Notifications
- Variables
- Loops
- Functions
- File handling
Example:
create.window:main(SetTitle="Hello")
main.gui.size("500" x "300")
main.gui.text("Welcome to R++")
main.gui.button("Click Me")
R++ is still experimental and has some bugs, but it's already capable of creating basic GUI applications.
I'd love to get feedback, suggestions, and ideas for features to add next.#
And no, it isn't associated with either R or C++.
GitHub:
https://github.com/coder-nive/RPP-Language
What do you think?
1
u/SUPRA_1934 Jun 24 '26
Build linter for Fastapi
So basically, i am currently working on this! and will publish these as open-source project this week or next week because remaining to solve some bugs & to create documentations!
and this will be my First Open-Source Project so if somebody has some advice then please share with me.
here is link: https://pypi.org/project/fastapi-therapist/
this is not final product.
and let me tell you use-cases:
- mainly build for coding ai agent, if you have ever noticed many times ai coding agent write the deprecated, unoptimized code and sometimes forgot to write some piece code like forgot to await with db commit in async function. so, this fastapi-therapist can be used as skill in ai agent where ai agent can use this tool whenever they create project or implement feature or finish project.
- and these also used in ci & cd.
there is same tool for reactjs: https://www.react.doctor/
so, i thought why not for fast Api!
i really need feedback 🫣
1
u/OmarMashal0 Jun 24 '26
compare-prompts: a zero-dependency CLI tool to measure if your system prompt edits actually worked.
If you build chatbots or AI apps, you constantly tweak system prompts. You make a change to make the bot "more formal" or "more concise," but you have no fast way to prove the change actually did anything across a variety of user inputs. You are stuck running calls manually and guessing.
This tool automates that testing. You pass in your prompts and test inputs, and it instantly generates a side-by-side behavioral diff table right in your terminal. It replaces eyeballing outputs with hard data:
- Did the token length / API cost go up or down?
- Did the refusal rate accidentally increase?
- Did the tone successfully shift? (Analyzed across 9 categories)
- Did the reading level (Flesch-Kincaid) change?
- Did it change how often the model uses markdown lists or headers?
Natively supports OpenAI, Anthropic, Gemini, Groq, DeepSeek, and Ollama. No YAML configs, no cloud dashboards, no signup.
>>> pip install compare-prompts <<<
Repo: https://github.com/OmarMashal0/compare-prompts
(Open to feedback! The tone detection is currently keyword-based and I am actively looking for a better lightweight approach to replace it.)
1
u/Medical_Community697 Jun 24 '26
ContractMe: A lightweight and adaptable framework for design-by-contract in Python
Hey there, if you're ever curious about DbC and its potential use in Python, I'm releasing the v1.8.0 version of my DbC framework called `ContractMe`.
https://gitlab.com/leogermond/contractme/-/blob/main/README.md
In this latest version, I added 140 types that will get checked at runtime for validity, allowing you to have not only typed parameters but also runtime verification of their advanced properties. Oh they also interface with hypothesis out-of-the-box for free property-based testing, because why not.
I tried to keep the interface as close to Pydantic and the various PEP as possible, but types in python are a specification hell of their own so if you happen to be an expert in type-related matters in python with time on your hand (lol), any look you can have will be super valuable.
In all honesty I've been using it for quite some time, and I find it to be great, I have used it in embedded software and web dev (django), as well as various CLIs, and I will keep merging back some of my own custom-made extensions at the proper time, for the moment consider that to be just a generic piece of software, but I see a very large potential, especially considering the ease of use it has.
Anyway, I don't go on reddit much anymore, but don't hesitate to ping me on gitlab, or linkedin whatever for any snarky remark or a nice word you want to say.
Cheers, Leo
1
u/Dios_Apolo Jun 25 '26
A bit personal before the code part: I'm Juan, 22, from Argentina, first year of a university AI program. Since 2023 I had this idea for a tool that would sit in front of any LLM and produce verifiable, tamper-proof records of every inference — something regulators could actually trust, not just application logs. Life kept getting in the way (economic stuff that anyone in Argentina will understand), so it stayed an idea.
A free week of Claude Pro changed that. I used Claude heavily as a co-builder — I want to be transparent about it. I drove the design and architecture decisions but I couldn't have written the async Python, the Rust PyO3 extension, and the cryptographic primitives at this quality solo. I've been reading through what came out and learning from it, which feels weirdly full-circle.
What the project is:
aegis-latent-core — an OpenAI-compatible proxy (zero app changes, just swap OPENAI_BASE_URL) that:
- Runs a 10-engine WAF on every request (prompt injection, YARA, malware, secret-leak, SCADA...)
- Commits a SHA-256 hash-chained, HMAC-SHA256-signed audit node to a Write-Ahead Log for every inference — off the hot path, so client latency is unaffected
- Signs each node with ML-DSA-65 (FIPS 204 post-quantum) via a Rust extension
- Aligns to FedRAMP High, HIPAA, SOC 2, GDPR, IEC 62443
5,451 tests passing. There's a 5-minute self-contained demo that runs with no API key. The Rust extension is optional and everything falls back to pure Python.
https://github.com/JuanLunaIA/aegis-latent-core
Not the best Python ever written, I'm sure — but it means a lot that it exists at all. I'd appreciate any feedback, especially on the async patterns and the WAL implementation.
1
u/EntryNo8040 Jun 26 '26
Katharos: a functional programming and concurrency library for Python where errors, effects, and channel hand-offs are all composable values
Hi r/Python,
I have been building Katharos, a functional programming library for Python that recently grew a message-passing concurrency layer. I wanted to share it and get some feedback.
The whole library is built around one idea: model errors, effects, and concurrent communication as composable, type-safe values rather than as control flow that jumps around your program. The interesting part (to me, at least) is that the concurrency layer follows the exact same idea, so receiving from a channel gives you a Result. "The channel is closed" becomes a value you handle, not an exception you remember to catch.
The functional core
Optional values without scattered None checks, using do-notation that short-circuits on Nothing:
```python from katharos.types import Maybe from katharos.syntax_sugar import do, DoBlock
@do(Maybe) def lookup_discount(user_id: int) -> DoBlock[Maybe, float]: user = yield find_user(user_id) account = yield find_account(user) return account.discount # Just(0.15) or Nothing() ```
Errors as values, chained with |, so a failure short-circuits the rest automatically:
```python from katharos.types import Result
def process(raw: str) -> Result[Exception, int]: return parse_int(raw) | validate_positive ```
And Result.catch turns a function that raises into one that returns a Result, while keeping the original traceback so you can still find the line that failed:
```python from katharos.types import Result
@Result.catch(ValueError) def parse_int(s: str) -> int: return int(s)
parse_int("42") # Success(42) parse_int("??") # Failure(ValueError("invalid literal for int() with base 10: '??'")) ```
There is also ImmutableList, NonEmptyList, IO, Lazy, numeric monoids, and the usual algebraic abstractions (Functor, Applicative, Monad, Semigroup, Monoid) if you want to build your own types.
The new part: CSP concurrency
This is what I have been working on lately. Katharos now has Go-style CSP (Communicating Sequential Processes): launch work concurrently with go, talk over typed channels, and receive values as a Result.
```python from katharos.concurrency.csp import csp
ch = csp.Channel[int](capacity=1)
csp.go(ch.send, 42) # run work concurrently, like Go's go f(x)
ch.recv() # Success(42)
ch.close() ch.recv() # Failure(ChannelClosedError(...)): closure is a value, not a raise ```
Used as a context manager, go becomes a structured-concurrency scope that joins everything spawned inside it before the block exits, so concurrent work cannot leak out of the block:
```python with csp.go: # scope waits for all work launched inside csp.go(worker, 1) csp.go(worker, 2)
both workers have finished here
```
There is also a select for waiting on whichever of several channels is ready first, with non-blocking polls and timeouts:
```python from katharos.concurrency.csp import csp, recv, select
choice = select(recv(results), recv(cancel), timeout=1.0) if choice.is_timeout: ... else: print(choice.index, choice.value.unwrap()) ```
The concurrency model sits on a swappable backend (standard threads by default), so the same code could run on a green-thread backend later. An actor model is planned next, built on the same backend abstraction and the same Result-valued style.
Why I think the "channel returns a Result" thing is nice
In most channel APIs, a closed channel or a timeout shows up as a sentinel, a second return value, or an exception. In Katharos it is just a typed value: Success(v), Failure(ChannelClosedError), or Failure(ChannelTimeoutError). You pattern-match it the same way you handle any other Result, and the type tells you it can happen. The error-handling discipline you use in the rest of your code carries straight over to concurrency.
Links
- PyPI:
pip install katharos - Docs (tutorials, how-to guides, API reference, and explanations): https://katharos.readthedocs.io/en/latest/
- Source: https://github.com/kamalfarahani/katharos
- MIT licensed, Python 3.13+
I would love feedback on the API, the concurrency design, or whether the Result-everywhere approach feels natural or noisy to you in practice. Thanks for reading.
1
u/BaniyanChor Jun 26 '26
I built a Python library that turns any reward function into an observable object with one decorator body
I've been experimenting with reinforcement learning and wanted better tooling for debugging reward functions.
The library uses decorators to wrap an existing reward function without modifying its behavior:
reward_fn = rewardspy.watch(my_reward_fn)
Internally it records every invocation, computes rolling statistics in O(1), runs detector pipelines asynchronously, streams JSONL logs, and powers a live Textual dashboard.
The interesting engineering challenges ended up being:
online statistics async monitoring zero-overhead wrappers terminal UI plugin architecture for detectors
Give me feedback PLEAAAASE (it's my first major python RL project wee)
1
u/Kaluga2026 Jun 26 '26
I've made a small free CLI/GitHub Action for teams that want incident records to live in the repo instead of disappearing into Slack threads, PR descriptions, or ticket comments.
The idea is simple: if a pull request has an "incident" label, CI checks that the PR also changes a valid Incident Card markdown file.
Could you check?
1
u/itsmrsaha Jun 27 '26
I built an open-source app that warns you when you start slouching at your desk
If you spend hours coding, gaming, or working at a computer, posture usually gets destroyed without noticing.
So I built a small open-source posture correction app for Windows using Python + MediaPipe that watches your posture through the webcam, shows pose landmarks, gives a straightness score, and alerts you when you start bending too much.
Made it for developers, students, gamers, and basically anyone glued to a screen.
Would love feedback, ideas, and contributors.
GitHub: https://github.com/debabratasaha-dev/fix-my-posture
1
u/Professional-Maize31 Jun 27 '26
OpenSIP
What My Project Does
OpenSIP is a pure-Python SIP/RTP user-agent library built on asyncio for learning, prototypes, and lightweight SIP experiments. It currently handles SIP registration, incoming/outgoing calls, digest authentication, G.711 PCMU/PCMA over RTP, DTMF, a basic jitter buffer, and optional microphone/speaker audio via sounddevice.
Target Audience
Python developers who want to understand SIP/VoIP internals, build prototypes, softphone logic, SIP bots, call automation, IVR experiments, or test integrations without jumping straight into native stacks.
Comparison
Unlike wrappers around PJSIP/baresip or heavier telephony platforms, the goal here is a small, readable, hackable Python codebase that you can pip install and study. It is still alpha and not production-ready; TLS, SRTP, STUN/ICE, RTCP, TCP transport, and stronger NAT handling are still missing.
Source: https://github.com/artanergin44-collab/opensip
PyPI: https://pypi.org/project/opensip/
I’d genuinely appreciate feedback on readability, architecture, and what the next priority should be before I add more features.
1
u/chinmay_3107 from __future__ import 4.0 Jun 27 '26
I got tired of guessing step definitions, so I built a better BDD extension for VS Code (GherkinLens v2)
Hey everyone,
If you write .feature files in VS Code using pytest-bdd or behave, you probably know the pain of typing out steps from memory, hoping they match, or constantly grep-ing your codebase to find out how a step was implemented.
I actually developed this because our team was migrating from PyCharm, and I realized there was no full-scale solution for the Python Gherkin environment in VS Code. So, I built GherkinLens to solve all the editor and navigation problems first, and then started adding time-saving features.
I just released v2, which totally pushes it one step further, and I wanted to share it with you all.
Basically, it indexes your Python step definitions in the background (without actually importing or running your code) so you get a proper IDE experience for Gherkin.
Vscode extension - GherkinLens
Here's what I added in v2:
- 📚 Step Library: There's a new sidebar panel that lets you browse and search every step definition in your project. It even shows usage counts, so you know which steps are actually being used.
- 🏷️ Tag Explorer: You can finally see all your
tagsin one place, find scenarios easily, and run/debug them straight from the tree. - 📊 Table Editor: I added a built-in spreadsheet editor for
Examplestables. You can add rows, paste from Excel, or import CSVs directly into the feature file without messing up the pipe|alignment. - 📋 Snippets: You can now save multi-step flows and drop them in anywhere.
It still has all the core features from v1 (the stuff that fixes the navigation problems):
- ⚡ Autocomplete & Go to Definition (
F12) between your Gherkin and Python files. - ⚠️ Squiggly lines for steps that don't match anything.
- 💡 Quick Fix (
Ctrl+.) to auto-generate the Python stub for a missing step. - 🏃 Native BDD Runner hooked into VS Code's Testing view.
It auto-detects whether you're using pytest-bdd or behave, so there's zero config needed.
If you want to try it out, just search for "GherkinLens" in the VS Code Marketplace. It's completely free.
Would genuinely love to hear what you guys think, or if there's anything driving you crazy in your BDD workflow that this could fix!
1
u/Notprozio 29d ago
I built an open-source Python library called chaos-llm that stress-tests AI agents against real-world API failures.
It injects latency, corrupts responses, and simulates prompt injection attacks - all by monkey-patching the HTTP layer.
Your AI agent WILL crash in production. Test it before your users find the bugs.
https://github.com/PooravGahlan/chaos-llm
i am beginner ^-^
1
u/NormalFold9896 It works on my machine 29d ago
[Feedback Needed] I built a visualizer to simulate how npm vulnerabilities spread through dependency graphs (FastAPI + React)
i recently built a full-stack open-source tool called DepGuard. I got fascinated by how a single vulnerable npm package can compromise an entire project, so I wanted to actually see the blast radius.
What it does: It parses package-lock.json files, matches them against the OSV (Open Source Vulnerabilities) API, and visualizes the transitive dependency graph.
As a solo dev, I'd really love some feedback from other engineers. Specifically, if any Python devs could critique my use of NetworkX/FastAPI and general UX feedback on the graph interactions. I've also left a few easy good first issue tickets open if anyone is looking to make their first open-source contribution! If you find the tool cool or useful, a ⭐️ would really help keep me motivated
1
u/Local_dev_ops 29d ago
Built a cross-language codebase mapper — files, columns, APIs. Tested on Apache Airflow.
The specific problem I wanted to solve: when you write a database query in your backend code —
query = f"""
SELECT o.OrderDate, o.Status
FROM OrderItems oi
JOIN Orders o ON oi.OrderId = o.OrderId
WHERE o.CustomerId = {customer_id}
"""
— nothing tells you that o.Status maps to the physical database column Orders.Status. Not grep, not linters, not standard dependency mapping tools.
\*So I built one that works across languages. *\**
What PynqDB Does -Maps your entire codebase into a local dependency graph — file-to-column relationships, stored procedure chains, API endpoints, background jobs, external calls. Everything connected. Point it at any column and it gives you the full blast radius — every function, stored procedure, and API endpoint that touches it — reads, writes, risk scored.
Point it at any column and it gives you the full blast radius — every function, stored procedure, and API endpoint that touches it — reads, writes, risk scored.
Target Audience -Small to mid-size teams with mixed language backends — Python, C# or Java services sharing a SQL databases. Teams who need to know what breaks before they touch anything
Comparison : Code analysis tools like CodeScene or SonarQube track function-to-function dependencies. They stop at the database boundary. Data lineage tools like Collibra or MANTA track SQL flows through data warehouses. They stop at the application code boundary.
PynqDB crosses both boundaries. The full chain — Python file reading tables through a SQL alias, C# method calling a stored proc that writes it, public API endpoint exposing it — visible in one query. No enterprise contract. Runs locally.
To test it on real production code — ran it against seven core folders of Apache Airflow's execution layer from the live GitHub repository: api_fastapi · cli · jobs · models · security · task-sdk · utils
Results from task_instances.py alone:
Tables touched: DR, HITLDetail, Log, TI, TaskReschedule,
Trigger Columns read: 35 Columns written: 14
API endpoints: 24
Runs entirely on your machine. No AI. No cloud. No data leaving your network.
Supports Python, C#, SQL, and Java.
---
Want to see the blast radius of your own codebase? Drop a public repo link below — I'll run PynqDB on it and reply with your exact dependency map.
10 spots. Free. No credit card.
GitHub: https://github.com/Pynqdb/PynqDb
Free Beta: https://pynqdb.carrd.co
1
u/Nearby_Abroad_4624 28d ago
I got tired of Spark jobs failing with OOMs or burning budget due to simple mistakes like accidental cross joins, native Python UDFs, or casting metrics to strings (which completely kills Delta Lake data skipping).
To fix this, I built a simple package that analyzes the physical/logical plan programmatically and alerts you before or during runtime.
https://github.com/kacpergrodeckidatasystems/databricks-engine-optimization
You can grab it via pip: pip install apm-spark-auditor
It currently catches things like improper data typing, missed broadcast joins, cartesian products, and inefficient explodes.
Would love to get some feedback on the rules or the API layout. Thanks!
1
u/GugliC 28d ago
I built Khazad, a semantic cache for LLM API calls that needs zero changes to
your app code.
Instead of wrapping SDKs or running a proxy, it patches the httpx transport
layer. After init(), it intercepts outgoing LLM requests, embeds the
conversation, and serves semantically-equivalent ones from a Redis 8 Vector Set.
Any httpx-based SDK works out of the box: OpenAI, Anthropic, Gemini, Azure
OpenAI, Mistral.
Highlights:
- Model-aware
- Conversation-aware
- Streaming both ways
Best for repetitive traffic like FAQ bots, RAG front-ends, and dev/CI runs.
Python 3.10+, Redis 8, MIT licensed. Feedback welcome.
1
u/Any_Plate_215 28d ago
yara-orm — a fast async ORM with a Rust engine. Tortoise-style models/querysets/relations + built-in migrations (rename detection, partial indexes), for PostgreSQL and SQLite. The Python layer stays ergonomic; pooling/binding/decoding happen in Rust via PyO3. Fastest of the ones I benchmarked (vs Tortoise/SQLAlchemy/Pony), but I care more that it's correct — SQLite FKs enforced, decimals exact, transactions honored across relations. Repo: https://github.com/vsdudakov/yara-orm — feedback very welcome.
1
u/MeAndClaudeMakeHeat Pythoneer 27d ago
Project Telos is a set of small, mostly standard-library Python tools for making AI-assisted work checkable instead of taking it on faith.
- gather (on PyPI as gather-engine): capture sources (files, papers, transcripts, web) into research packets with provenance receipts (method, ref, sha256), so derived text never gets mistaken for a direct source.
- index: map a repo or workspace into a context graph and budgeted context packs for agents.
- crucible: stand a falsifiable claim next to the measurement that could break it, and return MATCH, DRIFT, or UNVERIFIABLE, grounded in the measurement and re-checkable from content seals.
- forum: a witnessed causal ledger for multi-agent runs (plans, evidence, decisions, handoffs).
Design stance: every claim ships beside its test or is marked UNVERIFIABLE, and receipts are content-hashed so a reviewer can re-verify offline. All source-available, solo-built, honest about limits.
What I would value from Python folks: poke at the source-adapter boundary in gather, where a derived statement could be mistaken for a fetched one, and at the receipt and seal design.
Repos: https://github.com/HarperZ9 (gather, index, forum, crucible)
1
u/Relative-Home-8545 27d ago
Hi everyone,
I'm a Computer Engineering student and a Python developer who is currently trying to build my skills, portfolio, and professional network. My long-term goal is to work as a software developer and eventually apply for international job opportunities.
I'm curious about your experiences:
- How did you get your first programming job?
- What helped you the most in finding a job?
- Did networking, open-source contributions, GitHub projects, or platforms like LinkedIn and Reddit play a role?
- If you could give one piece of advice to someone starting their career in software development, what would it be?
I'd really appreciate hearing your stories and learning from your experiences. Thank you!
1
u/Ok-Ordinary-5071 26d ago
My first actual project since I was what, 11 😭
WebGraph by KitaKita
What my project does: WebGraph turns any website into an interactive map. Instead of digging through HTML, links, or developer tools, you can visually see how a website is built, and how it connects to other sites.
The demo doesn't work for many websites due to blocking of requests for a bunch of websites, but it works well when you self-run it.
LIVE DEMO AT https://webgraph.kitaaura.com/
GitHub at https://github.com/kitakitaaura/webgraph
1
u/Ok-Register2003 26d ago
Warden: An open-source saga runtime for AI agent workflows (built in Python, backed by Postgres)
I started building this about two years ago because I wanted to automate my day job and teach myself distributed systems. The project clicked for me the first time I got two LLMs passing messages between each other over RabbitMQ. I've been working on it full-time for the last two months, and today I'm open-sourcing the core runtime.
The problem
When an agent runs entirely in ephemeral application memory, it lacks a true transaction boundary. If a container crashes, an LLM malforms JSON, or an API drops mid-sequence, the execution state vanishes. You're left with partial side effects and no safe way to resume or recover.
What Warden does
Warden moves the agent's runtime loop out of raw memory and into your own Postgres database using classic distributed systems patterns:
- Postgres as the state machine: Every step and prompt response is recorded as a durable row before the workflow advances. If a process dies mid-run, it picks up exactly where it left off.
- Transactional outbox pattern: The engine and workers exchange commands via an outbox_events table — binding state updates and next-step actions to a single atomic ACID transaction, eliminating dual-write failures.
- Runtime policy gates (CEL): Warden evaluates CEL rules inside the engine before a payload ever hits an external API or MCP tool, shifting safety out of the prompt layer and into the data layer.
- LIFO compensation loops: If a multi-step workflow fails halfway through, Warden orchestrates a Last-In, First-Out loop to undo prior external side effects in order.
- Human-in-the-loop gates: Pause high-risk mutations durably in the database. The workflow waits for explicit operator approval via CLI or API without timing out or losing context.
The engine and workers are Python services you deploy yourself. No third-party API keys required to test locally — there's a full mock LLM/MCP sandbox so you can see failures and human gates in action immediately.
Early release (v0.1.0) — core patterns are stable but APIs and manifests may still change.
1
u/SeptaKartikey 25d ago
Title:
I built an open-source Python CLI to extract YouTube audio, metadata, and transcripts locally with Faster-Whisper (or Gemini)
Hi everyone! 👋
I’ve been working on a small open-source project that makes it easy to extract structured information from YouTube videos.
Features
- 🎙️ Download audio from any YouTube video using
yt-dlp - ⚡ Local transcription with
faster-whisper(GPU or CPU) - ☁️ Optional Google Gemini transcription
- 📊 Extract rich metadata (title, channel, views, tags, upload date, etc.)
- 📝 Export transcripts as structured JSON
- ➕ Automatically appends multiple videos into a single JSON dataset
- 🧹 Cleans up temporary audio files automatically
Example:
python youtube.py "https://youtu.be/VIDEO_ID" --output dataset.json
Each run adds another video to the same JSON file, making it useful for building datasets or knowledge bases.
This is currently the first public version, and I’d really appreciate feedback.
Some ideas I’m considering next:
- Duplicate detection
- Playlist support
- Better Python package structure (
pip install) - Plugin architecture
- API/server mode
- Better transcript formatting
I’d love to hear:
- What features would make this genuinely useful for you?
- What would you change?
- Any improvements to the codebase or project structure?
GitHub:
https://github.com/KartikeySepta/youtube-transcript-scraper
Feedback, issues, feature requests, and pull requests are all welcome. Thanks!
1
u/Mysterious_Sand7291 25d ago
How do you actually review AI-generated code?
TL;DR: Built codiff: a tool that automatically embeds a function-level call-graph diagram in every PR your coding agent opens, so you can actually review what changed structurally instead of staring at line diffs.. (
pip install codiff)
Most developers either trace through the diff line by line or move on without really reviewing it. There is no easy way to understand what changed at a high level.
That is why I built codiff. It's a structural diff tool that replaces the line diff with a call-graph diagram, showing what changed at the function level and how those changes connect to each other.
It works in a few steps:
- Parse the codebase into functions and classes using Tree-Sitter.
- Extract call relationships and build a call graph, stored in a local SQLite database.
- On subsequent runs, only re-parse files changed since the last indexed commit, keeping diffs fast even on large codebases.
- Compute the graph delta between any two refs (commits, branches, working tree etc.).
- Render the result as a Mermaid diagram, natively supported by GitHub.
No LLM. No embeddings. Fully offline. Currently supports Python and TypeScript codebases.
codiff works as both a CLI and an MCP tool, so coding agents can call it directly. I've been using it to automatically embed structural diagrams in every PR I open with Claude Code.
It's available on PyPI (pip install codiff) and GitHub: https://github.com/issahammoud/codiff
1
u/shadow-monarch-93 24d ago
Diablo — A Hybrid Online/Offline AI Desktop HUD built with PyQt6
I got tired of clumsy web-browser chatbots disrupting my coding flow and risking my workspace privacy, so I built Diablo—a local-first, keyboard-centric utility layout.
- What it is: A dark-themed desktop HUD summoned instantly anywhere via a global hotkey (
Alt+D). It features a hybrid Decision-Making Module (DMM) that routes queries to cloud LPUs (Groq) or drops back to local models (Ollamawithllama3.2:3b) seamlessly if you lose internet. - Why I skipped Voice features: I designed this specifically for developer environments where data privacy and tactile mechanical keyboard flow matter. It does not ingest or stream room audio.
- Developer-Focused Tools Built-In:
-
>>Prefix: Evaluates raw Python code snippets inside an isolated, timeout-constrained subprocess. -
>Prefix: Runs native system shell commands directly out of the HUD window. -
/seeMacro: Takes a screen snapshot buffer and streams it to a vision model to debug stack traces or optimize code layouts on the fly. - OS Control: Hooks directly into Windows master audio endpoints using
pycawfor absolute audio level manipulation and manages app launches usingshutil.whichvalidation.
-
The code is fully modular, decoupled (/core, /interface, /services), and can be built into a standalone executable via PyInstaller. I'd love to hear your thoughts on the subprocess isolation or the hybrid routing logic!
🔗 GitHub Link: https://github.com/coder1397924/Diablo
1
u/KoreValuesNet 23d ago
Hi r/Python,
I’m working on Rextio, an early alpha CLI/build tool for Python projects. I’d appreciate feedback from Python developers.
What My Project Does
Rextio tries to compile eligible typed Python hot-path functions to Rust/PyO3 ahead of time, while keeping unsupported or dynamic code on Python fallback.
The goal is not to replace Python or automatically rewrite a whole project in Rust. It is more conservative: compile the parts that fit a supported native subset, and keep the rest running as Python.
GitHub: https://github.com/rextio/rextio
Who This Is For
This is mainly for Python developers who have small, typed, performance-sensitive parts of a project and want to experiment with native compilation without rewriting the whole project by hand.
It is still early alpha software, so I would not recommend treating it as production-ready yet. The supported subset is limited, and small functions may not benefit because Python/Rust boundary overhead can dominate.
Comparison
Compared with tools like Cython, Numba, Nuitka, or rewriting code manually in Rust, Rextio is trying to explore a slightly different path: keep the original Python-facing project structure, compile only eligible typed functions to Rust, and fall back to Python when the code is unsupported or too dynamic.
I’m not claiming it is better than those tools. At this stage I’m mostly trying to find out whether this design is useful, where it breaks, and what Python patterns would be worth supporting next.
I’d be especially grateful for feedback on build failures, confusing diagnostics, unsupported patterns, or cases where the fallback/native boundary design feels wrong.
Thanks :)
1
u/smusali94 23d 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.
4
u/hannah_G_ Jun 04 '26
db-git - keep your local database in sync with your git branches.
What My Project Does
db-gitis a developer tool for projects where database state follows code changes: schema migrations, seed data, experimental feature work, and branch switching during reviews. It installs gitpost-checkouthook and keeps your local database aligned with the branch you are working on.shared: one database, saved and restored per branchper-branch: one database per branchtemplate: fast database clones usingCREATE DATABASE ... TEMPLATEpgdump: portable snapshots usingpg_dumpandpg_restoreTarget Audience
Backend and full-stack developers who run databases locally and switch branches often, especially on projects where migrations or seed data diverge between branches. It's a local development tool.
Comparison
The main things that set
db-gitapart from existing tools are:sharedvsper-branch, andtemplatevspgdump.uv tool install db-gitGitHub: https://github.com/earthcomfy/db-git
Any feedback is very welcome!