Sunday Daily Thread: What's everyone working on this week?

[u/AutoModerator]

Weekly Thread: What's Everyone Working On This Week? 🛠️

Hello r/Python! It's time to share what you've been working on! Whether it's a work-in-progress, a completed masterpiece, or just a rough idea, let us know what you're up to!

How it Works:

1. Show & Tell: Share your current projects, completed works, or future ideas.
2. Discuss: Get feedback, find collaborators, or just chat about your project.
3. Inspire: Your project might inspire someone else, just as you might get inspired here.

Guidelines:

• Feel free to include as many details as you'd like. Code snippets, screenshots, and links are all welcome.
• Whether it's your job, your hobby, or your passion project, all Python-related work is welcome here.

Example Shares:

1. Machine Learning Model: Working on a ML model to predict stock prices. Just cracked a 90% accuracy rate!
2. Web Scraping: Built a script to scrape and analyze news articles. It's helped me understand media bias better.
3. Automation: Automated my home lighting with Python and Raspberry Pi. My life has never been easier!

Let's build and grow together! Share your journey and learn from others. Happy coding! 🌟

[u/keithcu]

My LibrePy project is feeling quite complete, to let you run =PY() (NumPy) scripts inside LibreOffice Calc and Writer. I also just got Jupyter notebook working.

Here's a spreadsheet that demos some of the capabilities: https://github.com/KeithCu/writeragent/blob/master/tests/fixtures/python_showcase_demo.xlsx.

If anyone wants to try it out, the link is here: https://github.com/KeithCu/writeragent. There's a possibility LibrePy becomes a default LibreOffice extension, the Engineering Steering Committee has given positive reception to the idea, but knowing that there are happy users is helpful before rolling out to millions.

[u/Acrobatic-Compote606]

domonic 1.3 released with a new compatibility layer for bs4 https://domonic.readthedocs.io/packages/bs4/

In most cases it will be much faster than bs4 and gives you a complete DOM

[u/Pale_Champion3841]

Been three weeks since i started Python. Today i'm writing a scraper for a demo website called BooksToScrape

[u/greg_d128]

I’ve been hacking on Caretaker, a Python project that includes behavioral analysis of what each function (including from imported libraries) does at runtime. Think supply chain verification. It does have functionality to inject repairs at runtime, do A/B testing of proposed repairs, analyze incidents, etc.

Curious what other Python developers think: https://beyondparanoia.org/caretaker/promo.html

[u/Goldziher]

Spent this week on poly, a linter and formatter I have been writing in Rust. The Python side embeds ruff's linter and formatter as libraries rather than shelling out, so a mixed repo gets ruff on the .py files, oxc on the .ts files, taplo on the .toml files and rumdl on the markdown in a single pass with one config. Django's tree is 3,113 files in about 0.8 seconds on my machine.

It also replaces pre-commit as the hook runner, which is what started the whole thing, and poly migrate will fold an existing [tool.ruff] section out of your pyproject.toml for you.

Mine, MIT: github.com/Goldziher/poly. The PyPI package is polylint because poly was taken, but the executable is still poly.

[u/WarmAd6505]

Been working on Violin 🎻, a Python-based supervised pentesting profile for Hermes.

Violin for Hermes

The engineering problem I’ve been most interested in is treating the LLM as an untrusted planner rather than the thing enforcing its own safety.

Target commands go through a Python execution guard that checks scope, engagement phase, active task, hypothesis state and execution history before anything touches the target. Findings also need reproducible evidence rather than model confidence. The current surface is deliberately small: 11 model-facing tools with methodology routed through 35 playbooks / 7 skills.

I’d be interested in feedback from Python developers on the architecture, especially where you’d draw the boundary between flexible model reasoning and deterministic Python checks.

[u/Rogue_Kernel]

Still in development — a work in progress, not a finished game.

First-person POV raycaster that renders in a terminal. Truecolor drawn with sextant and octant block characters. No game engine and no graphics library: one Python file, 154,716 lines, standard library only. The audio is real recordings, including voice acting.

Full 4-minute run, unedited: https://vimeo.com/1222466576

No public build or repo yet, and I'm not taking requests. Just wanted to show it moving while it's still being built for some traction. This was my escape but maybe someone else would want to escape into the dungeon too.

[u/nez_har]

I will continue to work on VibePod, many new features have been added lately and I'm super excited about the ACP integration which was proposed by a contributor.

The project itself is targeted for running all sorts of agents in isolated containers and track all the requests: https://github.com/VibePod/vibepod-cli

The telemetry part is also being extended, besides the token calculation there will be an estimate consumption price 

[u/kavee-core141]

Built Plexavo, an open-source AWS Cloud Security tool accounts for misconfigurations and privilege escalation paths open security groups, stale keys, unencrypted storage and returns a plain-English report with the exact fix for each finding.

Detection is pure Python/boto3 deliberately kept AI out of the actual finding logic, just an optional layer for turning findings into plainer language if you want it. Someone ran it against their own account last week and it caught a security group they'd genuinely forgotten was wide open, which was a good feeling to see happen.

Just launched on Product Hunt too if anyone's curious: https://www.producthunt.com/products/plexavo?utm_source=other&utm_medium=social

Repo: https://github.com/plexavo/Plexavo

[u/Mysterious_Shoe2260]

I've been working on AgentMesh, a multi-agent execution runtime where the performance-critical execution layer is implemented in C++20 while the developer-facing API remains Python.

The project started from an AI-agent problem, but the part I'm interested in showing here is the Python ↔ C++ boundary.

Current architecture

Python:

• agent definitions
• application logic
• configuration
• user-facing API

C++:

• DAG scheduling
• execution coordination
• communication primitives
• concurrency
• runtime state handling

The two layers communicate through Pybind11.

I've also paid particular attention to releasing the Python GIL around blocking I/O so Python threads aren't unnecessarily held while the native runtime is waiting.

I'm benchmarking the native runtime against the Python implementation using repeated paired runs rather than presenting a single benchmark number.

The project is still evolving, so I'm particularly interested in feedback on the extension design:

What would you change about the Python/C++ boundary?

Repository:

https://github.com/DevrG03/AgentMesh

Documentation:

https://github.com/DevrG03/AgentMesh/wiki

[u/CatalonianBookseller]

Finishing my PySide6 book. Three chapters to go, yay. Ten months, lots of code, lots and lots of revisions, many lessons learned. Took me on deep dives into signals&slots, events, model/view and multithreading. It turned out okay for a first writing endeavor I think.

[u/PeithonKing]

Wanted to get back into robotics this weekend after missing it since college days. Built a quick warm-up project to test modern tools and get my hands dirty, a little EMO desk buddy clone!

CAD & Sim: Modeled everything in FreeCAD and exported straight to MuJoCo. The workflow between the two turned out to be surprisingly smooth.

Control: Walking motion in the clip is just hard-coded/programmed.

Takeaway: Didn't bother with RL here since it felt overkill for a simple desk toy, but the project served its purpose: learned MuJoCo and got the full pipeline down.

Now moving on to the actual goal: reviving our college project, training a 6-wheel differential-drive rocker-bogie Mars rover (Curiosity style) over rough/weird terrains using RL.

Repo (docs are sparse, just pip install -r requirements.txt and python server.py): https://github.com/PeithonKing/myEMO

[u/Kind_Bench_2359]

Been rewriting a duplicate cleanup script for a client's Google Sheet of leads this week, went from six inconsistent tabs down to one clean sheet, way more satisfying than it should be

[u/Diapolo10]

I've been prototyping using mise and task to make my projects have a more reproducible and cross-platform build system, as well as experimenting with better formatting Git hooks to format (and add) only the staged changes. Little luck on the latter so far, but I know it's a difficult problem.

(Yes, I'm sure both Lefthook and Pre-commit already have some kind of solutions for that, but I'm deliberately working with plain old Git hooks that call task format and leave the rest to my task files.)

[u/heikkitoivonen]

In January I started a project to document Big-O time and space complexity of all Python builtins and stdlib: https://pythoncomplexity.com/ (GH https://github.com/heikkitoivonen/python-time-space-complexity). I am working towards a 1.0 release.

A little earlier I fixed most accessibility, performance etc. technical issues with the site. I also made it possible to localize the site, and picked three pilot languages and machine translated a small list of pages: Finnish, Chinese and Japanese.

The language work inspired a contributor for the Chinese version, and I have merged all of their PRs so far.

I have switched back to correctness work myself, and I am adding unit tests to validate the Big-O claims.