r/Python • u/AutoModerator • 11d ago
Showcase Showcase Thread
Post all of your code/projects/showcases/AI slop here.
Recycles once a month.
3
u/ertucetin 10d ago
Community-powered documentation and examples for Python
PyDocs: https://pydocs.org
2
u/Possible-Active-1903 10d ago
What My Project Does
trainlint reads Python files that train or evaluate ML models and points out bugs that run without errors and still give you a believable number. Examples: a scaler or feature selector fitted before the train/test split, model.eval() left on or never called, softmax in front of CrossEntropyLoss, y_true and y_pred swapped. There are 14 rules in total. It parses the file with the ast module and never runs your code. Standard library only, Python 3.10+.
Here is the demo. 100 samples, 5,000 random features, random labels, so nothing can beat 50%. If I pick the best 20 features on the whole dataset and then cross-validate, I get 85%. If the same selection happens inside a Pipeline, I get 48%. trainlint flags the first script.
uvx trainlint check train.pyTarget Audience
Anyone who writes PyTorch or scikit-learn training code, and CI jobs that check it. It is Beta: 14 rules, all heuristics, two releases so far.
Comparison
ruff and pylint have no rules about splits, eval mode or metrics. TorchFix looks for removed and deprecated PyTorch APIs. Deepchecks runs checks against your real data and models. trainlint only reads the source, so it needs no data or GPU, and it covers far less.
Limits
It goes by names like X_train and val_loader, reads one file at a time and has no type information, so it will get some things wrong. To get an outside check I ran it over the 93 files of pytorch/examples at a pinned commit and read every finding. There were 22: 20 real by my reading and 2 harmless. The README has the commands if you want to repeat it.
Repo: https://github.com/Satvik-jain/trainlint
Every rule with a flagged and a clean example: https://github.com/Satvik-jain/trainlint/blob/main/docs/rules.md
If it flags something it should not, or misses a bug you have hit, please open an issue with the snippet. That is the feedback I want most.
2
u/rich-iannone 10d ago
pymizu 0.1.0: lock-free shared-memory parallelism for Python (< 1 µs task round trip, drop-in concurrent.futures executor, zero-copy interop with R)
Disclosure: I work at Posit, and I'm posting this on behalf of the author, my colleague Charlie Gao (the creator of mirai, R's async framework). He wrote pymizu and will be in the thread to answer questions: u/shikokuchuo.
What it does
pymizu is a parallel and async library for Python built on libmizu, a C library for lock-free shared-memory IPC. A task is written once into memory both processes share, and the worker reads it without copying, so a trivial task round trip takes < 1 µs, against ~100 µs for ProcessPoolExecutor. Pipelined throughput is about 2.4M tasks/s against 18.5K.
PoolExecutoradapts a pool to theconcurrent.futures.Executorinterface, so code written againstProcessPoolExecutordrops in, andwait,as_completedandasyncio.wrap_futurework unchanged. Tasks and maps can be awaited in asyncio, and channels supportasync for.NumPy arrays and polars, pyarrow and pandas frames cross between processes as zero-copy views.
It has a sibling for R (mizu, on CRAN) with the same wire format, so you can launch a pool of R workers from Python, or a Python pool from R. For example, an R data frame crosses to Python workers as an Arrow-backed frame, and a polars result comes back as an R data frame, optionally read as Arrow in R.
pip install pymizuimport math
import pymizu
with pymizu.Pool.create(4) as pool:
task = pool.submit(sum, range(1, 11), 100)
print(task.collect(timeout=5))
#> 155
m = pool.map(math.sqrt, [1, 4, 9, 16, 25])
print(m.collect())
#> [1.0, 2.0, 3.0, 4.0, 5.0]Target audience
This is especially relevant to statistical modelling and machine learning workflows, where resampling can be parallelized, but is very data-heavy. It also serves as a highly performant async executor for event-loop applications in web frameworks such as Shiny. It is experimental (0.1.0) and the API may change in response to feedback, and bug reports are the most useful contribution right now.
Comparison
The numbers above are measured on an Apple M4 Pro against ProcessPoolExecutor, and the benchmark scripts are in the repository for you to run. There are no measured numbers against Ray, Dask or joblib (the docs discuss where the trade-offs lie) and those frameworks also cover multi-machine and cluster workloads, while pymizu is single machine only.
Blog post with benchmarks and examples: https://opensource.posit.co/blog/2026-11-05_mizu-0-1-0/ Code: https://github.com/shikokuchuo/pymizu docs: https://shikokuchuo.net/pymizu
2
u/shikokuchuo 7d ago
(author here) Thanks u/rich-iannone for posting this! Having been part of the R community for some time, I'm excited to make my first contribution to the Python community!
1
u/shikokuchuo 3d ago
I also just posted the first patch release - pymizu 0.1.1. This is a huge mega episode of bug fixes + performance enhancements. Task pool round trips are now at 0.6 µs!! On PyPI so enjoy!
2
u/gushmazuko 6d ago
Basira Vision: scanned book in, typeset translation out (vision OCR + translation + Typst)
What My Project Does
Basira Vision is an open-source Python CLI with a three-step pipeline:
`basira ocr book.pdf`: renders each page to an image and uses a vision model to extract text. Designed for scans with no text layer, skewed or noisy pages, and non-Latin scripts where classic OCR engines struggle.
`basira translate book.md --target-language russian`: translates page by page using a one-page sliding window. The previous page's finished translation is passed along as context for continuity. A failed page clears the window instead of polluting the next one.
`basira typst book_russian.md`: typesets the result as an A5 book using Pandoc + Typst (title page, TOC, running headers, footnotes) from an editable template (`basira export template` provides a local copy to modify).
Between steps, you get standard markdown files with `<!-- Page N -->` markers for human review and manual corrections. Progress is saved per page; `--resume` processes only missing or failed pages.
Prompts are included for Arabic, Chechen, English, French, German, and Russian. It uses the Gemini API protocol. By setting `GEMINI_BASE_URL`, you can point it to any Gemini-compatible local gateway or local vision model.
Тarget Audience
Developers, translators, small publishers, language communities, and hobbyists digitizing or republishing scanned and public-domain literature. This is a fully tested CLI package (CI, PyPI, MIT licensed).
Comparison
- Tesseract and classic OCR engines require clean scans and pre-trained language data; vision models handle noise and complex typography much better and output structured markdown.
- PDF-to-markdown tools (Marker, olmOCR, etc.) stop at extraction; Basira Vision covers the full pipeline through contextual translation and Typst typesetting.
-Pasting PDFs into web chat interfaces breaks down over long documents due to context drift, loss of page structure, and lack of resumability.
- PyPI / uv: `uv tool install basira-vision`
- GitHub: https://github.com/gushmazuko/basira-vision
2
u/uniquequename 5d ago
I built pydecide which is one client for small decision models, with a confidence gate that escalates only the questions the local model is unsure about.
Agents and support pipelines send lots of tiny classification calls ("which team gets this ticket") to chat models. pydecide answers them with a small decision model (laya on PyTorch or MLX, a CrossEncoder, or hosted Jev, OpenRouter, OpenAI Decisions) and passes only low-confidence questions to the next backend in the chain. Every answer records its route, and `decide fit` picks the threshold from recorded outcomes.
Measured on an M4 with laya-mlx: 20.9 ms median per decision, 92% on 150 AG News headlines.
uv tool install "pydecide[mlx]"
decide ask "I was charged twice" --choice billing,engineering --verbose
2
u/diogenic 5d ago
PyBrowser - A Smalltalk Class Browser for Python
https://github.com/areichow/pybrowser
What My Project Does: PyBrowser is a code browser inspired and based on the classic Smalltalk Class Browser, with dreams of becoming a more complete dynamic Smalltalk-like development environment, with the ability to pull up Smalltalk-style Inpsectors and Debugger.
Target Audience: Smalltalk heads who want a similar dynamic, iterative experience as the Smalltalk environment provides. At this stage of development, it's somewhere between a toy and a tool. I haven't used it for developing on large codebases, but I have used it for some small apps with a handful of files. I've used it to browse and understand existing Python codebases like Django.
Comparison: I'm not aware of any direct comparisons to make. There are Class Browser elements of many IDEs, but I've never found one that really captured the look, feel, and clarity of the Smalltalk Class Browser. Historically, the recommendation has been to use the Emacs Class Browser (ecb) or oo-browser. I'm not an experienced Emacs user and haven't been able to get either to run.
2
u/One_Rice_2918 4d ago
Deptho - Deptho is the tick-level reality check for crypto backtests: it replays orders from any backtester against months of real Binance trades, entirely on a local machine.
What My Project Does
deptho is an Apache-2.0 Python library that checks crypto perpetual backtests against what actually traded. Give it the orders your backtest produced (a DataFrame of time, side and quantity) and it replays each one against the Binance trades that came after it, filling at the volume-weighted price of same-side prints. It also writes an offline HTML tearsheet that charges funding to the position you actually held at each funding time, alongside fees. Data comes from Binance’s public archive; everything runs locally, with no telemetry.
pip install deptho && python -m deptho.demo
There’s also an adapter for Freqtrade backtest exports: python -m deptho.freqtrade user_data/backtest_results.
Target Audience
People backtesting crypto perpetual strategies in Python who want to know whether their fills and costs are realistic. It’s a checking tool for research, not a live trading system.
Comparison
Backtesting frameworks like backtesting.py or Freqtrade run your strategy; deptho doesn’t. It checks the orders any of them produce, so there’s nothing to rewrite. Tools built for high-frequency simulation (hftbacktest, for example) model queue position on full order book data, but you write your strategy inside their framework. deptho’s limits: fills come from trade prints, not the order book, and it’s Binance USD-M only for now.
1
u/OrneryProfit659 10d ago
Project: sharp-vawt-lab - A 2D BEM wind turbine solver with Numba and AST-normalized hashing
I built a numerical lab for a passive variable-pitch vertical-axis wind turbine (a Sharp cycloturbine).
The stack uses numba to JIT-compile the time-marching aerodynamic kernel, scipy.optimize.differential_evolution for geometry optimization, and streamlit for a telemetry dashboard.
The most interesting Python problem I had to solve was reproducibility. The repo generates 21 result JSONs, and I implemented an AST-normalized hasher (using Python's ast module) to strip docstrings before hashing. This means I can edit comments without invalidating the cryptographic stamps of my results, but behavior-bearing code changes still fail the CI.
I'm 16 and mostly self-taught, so I'd love any feedback on the architecture!
1
u/RuinWMD 10d ago
Brevi builds it through Rust into a native binary that gives the same output as CPython and runs 2 to 40 times faster, and answers anything it cannot build with one short line the agent can act on.
What makes it different#
AI-first. Every design choice is measured by what it costs a model to get a working program: tokens written, errors read, retries. The release test has Claude models solve 24 tasks in Python, run once by CPython and once by Brevi, and Brevi must cost no more.
Fast. Most Python builds into plain Rust with fixed types. Programs whose types change at run time build over dynamic values, still native.
Safe. Rust's memory safety underneath, integers that never silently overflow, and a declared sandbox for file access and native code.
Exact. A program Brevi builds gives CPython's output, or Brevi refuses at build time. It does not guess. On 591 saved agent programs, every build matched CPython byte for byte.
https://github.com/ets-public/brevi
Free and open source
1
u/Puzzleheaded_Book549 10d ago
What My Project Does: It reads your broker export, mirrors every buy into an index (VOO, VT, anything on Yahoo) on the same day, and shows what each pick added or cost. You get a terminal table, JSON or a self-contained HTML report.
Target Audience: People who buy individual stocks and want an honest scorecard. It’s a personal tool, not a trading system.
Comparison: Brokers show total return, which hides timing and the “one big winner” effect. This compares per trade, same dollars, same day.
No dependencies, MIT. Only tested on real IBKR exports so far, so feedback on other brokers is very welcome: https://github.com/erioh/picks-vs-index
1
u/parafusosaltitante 10d ago edited 10d ago
Archivey: one API for ZIP, TAR, 7z, RAR, ISO and more
Hi all! Last year I posted here an archive reading library I had started writing. It stalled for a while, but I've rewritten it from scratch and it's much better.
Reading archives in Python usually requires using a separate library for each format, each with its own methods and field names, like ZipInfo.filename and file_size versus TarInfo.name and size. Archivey gives you one API for most common archive types, with safe defaults for extraction, format detection, memory and decompression bomb limits, and errors instead of silently wrong data. It also has a one-pass reading mode that avoids hidden costs, like a solid RAR or a .tar.gz decompressing everything before each file you open.
import archivey
# Extract safely: traversal, link escapes and bombs are blocked by default
with archivey.open_archive("untrusted.zip") as reader:
reader.extract_all("out/")
# Or read every member in one pass, without re-decompression
with archivey.open_archive("photos.tar.gz") as reader:
for member, stream in reader.stream_members():
if member.is_file:
print(member.name, len(stream.read()))There's a CLI you can try with your own archives: uvx archivey-cli l photos.zip lists the contents (use x to extract, see -h for the other commands).
It has its own parsers for ZIP, TAR, 7z, RAR, ar, CPIO and SquashFS, so it isn't simply a wrapper over the format libraries. It also reads things they don't, like AES-encrypted or Deflate64 ZIPs.
Who's it for: any code that needs to read many archive types, like backup tools, upload processing or data pipelines. Python 3.11+. It only reads for now.
Trade-offs: it's slower than calling the format libraries directly, mostly on archives with many small files. RAR data still needs unrar or unar installed.
AI: almost all of the code is written by Claude Code and Cursor. I design it and make the decisions. AI is good at following specs and hunting corner cases, which makes the library safer and more compatible (it even found bugs in several of the libraries it uses, which archivey works around). I have a whole page describing the process.
Please try it out! Feedback is very welcome, especially archives it gets wrong or use cases the API doesn't cover.
1
u/ApprehensiveSkin7975 10d ago
Protect context is an MCP that helps you to understand rules, decisions, and proof-of-work an agent needs in front of it. They can review what you have asked, take a note and make it for future use. The agent would know what you may want in the future session, instead of losing content every time the context being compacted.
Github: https://github.com/XJTLUmedia/Protect-Context-Pi-Coding-Agent
1
u/p3rdy 10d ago
Flama: one Python framework for your API, your ML models and your MCP tools, driven by type hints
I've been building Flama, an open source (Apache-2.0) ASGI framework, since 2018. It started as a way to take a trained model to a production API with as little ceremony as possible, and grew into a full framework where your API, your models and your MCP tools live in the same app. Right now I'm working on the next release: Python 3.15 support, dropping 3.10, and some extras.
Type hints drive everything
import typing as t
import pydantic
from flama import Flama, types
class Quote(pydantic.BaseModel):
instances: int
monthly: float
app = Flama()
app.mcp.add_server("/mcp/", "pricing")
@app.route("/quote/", methods=["GET"])
@app.mcp.tool("quote")
def quote(instances: int, hourly_rate: float) -> t.Annotated[types.Schema, types.SchemaMetadata(Quote)]:
"""Monthly price for a number of instances."""
return {"instances": instances, "monthly": round(instances * hourly_rate * 730, 2)}The annotations are the only source of truth. As a route, GET /quote/?instances=3&hourly_rate=0.25 gets its query parameters validated from the hints (a bad value is a 400 with the field and the reason), and the OpenAPI docs list both parameters and the Quote response. As an MCP tool, the same hints become its input and output JSON schemas. One function, two interfaces, nothing to keep in sync. The same mechanism drives dependency injection: handler parameters are resolved from their types at startup, through components you can write yourself.
Models are just resources
app.models.add_model(path="/churn/", model="churn.flm", name="churn")
app.models.add_model(path="/llm/", model="assistant.flm", name="assistant", serving=("openai", "anthropic"))Each model is a single .flm file with its weights, metadata and metrics, whether it's a scikit-learn pipeline, a PyTorch network or an LLM from Hugging Face. The first line gives you /churn/predict/; the second serves the LLM behind OpenAI and Anthropic compatible endpoints, next to the rest of your API.
A Rust core under the hood
The hot paths (route matching, JSON encoding, request parsing, compression, ...) are compiled Rust, built with PyO3 and maturin. It ships as native wheels per Python version, so you get it with a plain pip install, no Rust toolchain needed.
Also in the box: Pydantic or Marshmallow schemas, CRUD resources from SQLAlchemy tables, DDD repositories and workers, JWT auth, streaming, and flama upgrade codemods between versions.
Who it's for, and how it compares
It's for teams shipping APIs that include models, classic or generative, who'd rather keep one codebase than glue a web framework to a separate model server. FastAPI and Litestar cover the same ASGI and type-hint ground for the web layer; BentoML and vLLM cover serving. Flama puts both behind one programming model, so a model is a resource next to your routes, sharing their OpenAPI docs, auth and middleware.
The whole architecture is written up in a paper with Miguel Durán-Olivencia: https://arxiv.org/abs/2608.18733
If it looks useful, a star on GitHub helps more people find it, and I'm happy to answer anything about the design.
1
u/a8691 10d ago
GitHub: https://github.com/AndreiPuchko/q2eval
What My Project Does
I made a small Python library called q2eval.
It lets you evaluate expressions using variables stored in a dictionary. You can evaluate multiple expressions with the same dictionary or reuse one expression with different dictionaries.
It uses Python's eval() with a whitelist to restrict what expressions can access.
Target Audience
This is a small experimental project, not something I'd recommend for production use yet.
I'd especially like to hear from people interested in Python security. Can you find a way around the restrictions or access something that should be blocked?
Feel free to break it!
Comparison
I know there are other projects that provide safe expression evaluation, such as simpleeval. I made q2eval to solve a specific problem in my own project, and I'm interested in how this approach compares and what I might have missed.
1
u/rehan_100gamer23 10d ago
Hey everyone,
We’ve just released MCP India Stack v0.8.0, bringing a major architecture overhaul focused on identity and statutory data verification in India.
The Core Problem Solved
Traditional verification tools often return a simple boolean (valid: true/false). For high-trust compliance or financial workflows, this doesn't tell you how trustworthy the check actually was.
In v0.8.0, every tool returns an Authenticity Envelope (A0 to A4) indicating the exact tier of attestation achieved:
A0 (Syntax/Checksum): Mod-36 GSTIN, Verhoeff Aadhaar, Luhn ISIN.
A1 (Cross-Field Rules): Embedded PAN in GSTIN, ROC jurisdiction in CIN.
A2 (Bundled Authoritative Datasets): RBI IFSC, India Post PIN codes.
A3 (Cryptographic Signatures): NIC B2B e-invoice QR codes, UIDAI Paperless Offline e-KYC.
A4 (Live Registries): Opt-in live provider verification (
verify_online=True).
Key Features in v0.8.0
Zero-Network Defaults: Pure offline-first execution with <1.0ms p95 overhead.
DPDP Act Compliance: Built-in automatic PII masking (e.g., Aadhaar redacted to
XXXXXXXX1234).Cryptographic Supply Chain: Detached Ed25519 dataset manifests with anti-rollback protection (
MCP_INDIA_STACK_REQUIRE_SIGNED_DATA=1).Resilient Registry Interface: Pluggable provider system with built-in circuit breaker, SSRF defense, and rate-limiting.
Installation & Links
Bash
pip install "mcp-india-stack[verify]"Python Compatibility: 3.10 to 3.13
Would love to get feedback from anyone working on Indian fintech, compliance, or developer tooling!Hey everyone,We’ve just released MCP India Stack v0.8.0, bringing a major architecture overhaul focused on identity and statutory data verification in India.The Core Problem SolvedTraditional verification tools often return a simple boolean (valid: true/false). For high-trust compliance or financial workflows, this doesn't tell you how trustworthy the check actually was.In v0.8.0, every tool returns an Authenticity Envelope (A0 to A4) indicating the exact tier of attestation achieved:A0 (Syntax/Checksum): Mod-36 GSTIN, Verhoeff Aadhaar, Luhn ISIN.
A1 (Cross-Field Rules): Embedded PAN in GSTIN, ROC jurisdiction in CIN.
A2 (Bundled Authoritative Datasets): RBI IFSC, India Post PIN codes.
A3 (Cryptographic Signatures): NIC B2B e-invoice QR codes, UIDAI Paperless Offline e-KYC.
A4 (Live Registries): Opt-in live provider verification (verify_online=True).Key Features in v0.8.0Zero-Network Defaults: Pure offline-first execution with <1.0ms p95 overhead.
DPDP Act Compliance: Built-in automatic PII masking (e.g., Aadhaar redacted to XXXXXXXX1234).
Cryptographic Supply Chain: Detached Ed25519 dataset manifests with anti-rollback protection (MCP_INDIA_STACK_REQUIRE_SIGNED_DATA=1).
Resilient Registry Interface: Pluggable provider system with built-in circuit breaker, SSRF defense, and rate-limiting.Installation & LinksBash
pip install "mcp-india-stack[verify]"
GitHub: https://github.com/rehan1020/MCP-India-Stack
Python Compatibility: 3.10 to 3.13Would love to get feedback from anyone working on Indian fintech, compliance, or developer tooling!
1
u/alexis-jeandet 9d ago
SciQLop Cache: a diskcache-compatible persistent cache with a C++ core, built for big numpy arrays
What My Project Does
pysciqlop-cache is a persistent key-value cache for Python. You store any picklable object under a string key, and any thread or process on the machine can read it back, safely, even at the same time.
from pysciqlop_cache import Cache
cache = Cache("/tmp/my-cache")
cache["sensor/temperature"] = {"ts": 1710000000, "values": [21.3, 21.5]}
print(cache["sensor/temperature"])Small values live in SQLite. Big ones go to files, which are memory-mapped on read. It has expiration, tags, an optional size limit with LRU eviction, transactions, and a memoize decorator.
We built it for SciQLop and speasy, tools for space physics data, where a cached value is often a 10 to 100 MB time series. That's where most of the work went:
An optional serializer stores numpy arrays next to the pickle instead of inside it. It compresses them when that pays off, and it copies them without holding the GIL, so threads loading data don't block each other.
The cache is safe with forked worker pools, crashes, and processes racing each other.
cache.check(fix=True)repairs what it finds.It runs on free-threaded Python (3.13t+) too.
Target Audience
Anyone who caches expensive results to disk and shares the cache between processes: scientific code, data pipelines, notebooks, worker pools. It's in production in speasy, and it's on PyPI with wheels for Linux, macOS and Windows (x86-64 and ARM).
Comparison
The obvious comparison is diskcache. The API is mostly the same on purpose, and one command migrates an existing diskcache directory:
python -m pysciqlop_cache.migrate /path/to/diskcache /path/to/new-cacheBenchmarks with both libraries at their default settings, on a RAM filesystem (Ryzen 7 5800X and Apple M2):
Writes are about 2x faster, and up to 6x in batched transactions.
Latency stays flat from 100 to 1M entries, and a size limit costs nothing.
numpy arrays (100 KB to 100 MB): writes ~5x faster at 100 MB, single-thread reads 3x to 14x faster below 1 MB, and multi-threaded reads keep scaling (9.6 GB/s at 16 threads vs 7.9 GB/s).
Where diskcache wins: values between 8 KB and 32 KB. We store those as files, and diskcache keeps them in SQLite, so our writes are about 1.8x slower in that range on Linux.
Methodology and all the charts: https://sciqlop-cache.readthedocs.io/en/latest/performance.html
Docs: https://sciqlop-cache.readthedocs.io
Feedback welcome, especially on the API and on workloads where it falls short.
1
u/Miserable_Run_1077 9d ago
Kayra is a free, open-source ML pipeline builder. You can use it as a Python library (pip install skyulf-core) or as a self-hosted web app with a visual canvas, training, tuning, a model registry and drift reports.
Before your pipeline trains, Kayra checks it for data leakage. If a step like an imputer, scaler or feature selector would learn from the test rows, it tells you which step and how to fix it.
When a model is ready, you can export it as a standalone project with its own API, or run your pipelines on Databricks with Kayra's bundle template.
Data scientists and ML engineers who use scikit-learn and want to keep their data on their own machine. It's still in active development (pre-1.0), so it fits research, learning and internal tools better than critical production for now.
A plain scikit-learn Pipeline gives you the estimators. Kayra adds the leakage check, run history, comparison, deployment and drift reports around them. Unlike cloud ML platforms, it runs on your own hardware and nothing is uploaded. Unlike most drag-and-drop tools, every canvas pipeline can also run as plain Python.
Website: https://kayra.skyulf.com
GitHub: https://github.com/flyingriverhorse/Kayra
You can easily try:
Demo: https://api.skyulf.com
1
u/127001-sweet-127001 7d ago
What My Project Does
I maintain ArchUnitPython, a library that lets you write dependency and architecture rules as Python tests.
Here's a small check you can add to an existing pytest suite if your project is meant to stay free of circular imports:
from archunitpython import project_files, assert_passes
def test_no_import_cycles():
rule = project_files("src/").should().have_no_cycles()
assert_passes(rule)Use your project's import root in place of src/. The check analyzes the imports it can resolve and reports detected cycles as test failures, so it can run alongside your other CI checks. You can also define rules for which layers or modules may depend on each other.
Target Audience
Python developers who already have architectural decisions they want to keep enforcing as the codebase changes. You can start with one rule for a recurring problem instead of writing a specification for the whole project.
Comparison
This complements linters and type checkers: the tests express project-specific dependency boundaries and cycle rules. Import resolution has limitations, so check it against your project's import style and keep your normal tests too. The idea is inspired by Java's ArchUnit; this is a separate Python project.
Install with pip install archunitpython. Source and examples: https://github.com/LukasNiessen/ArchUnitPython
1
u/Difficult_Finger_232 7d ago
Paperlane: self-hosted document workflows in Django - https://github.com/surenjanath/paperlane
What My Project Does: Lets a team build a form, route it through people and groups (branches, deadlines, approvals), collect e-signatures and keep a full audit trail. Bots handle the routine work, and connectors call your own APIs or read a SQLite database (a single parameterised SELECT, opened read-only and sandboxed with SQLite's authorizer). Optional AI runs locally through Ollama. It is pure Django 6 with server-rendered templates and no JS build step, with 337 tests including Playwright. The repo has a full bank loan example wired to a sample core-banking database.
Target Audience: Teams that want a self-hosted alternative to SaaS workflow and e-signature tools, and Django developers who want a large real-world codebase to read. It runs in production mode with Docker, Postgres and HTTPS, but it is young, so expect rough edges.
Comparison: Unlike SaaS tools such as DocuSign, PandaDoc or Formstack, it is self-hosted and AGPL-licensed, with the workflow engine, forms, signatures and audit trail in one app. Compared with BPMN engines like Camunda, it is aimed at business users: a visual builder and fill-in pages rather than process models and code.
AI involvement: built largely with Claude Code under my direction.
1
u/ManufacturerKey6917 7d ago
**wheelgap** – find which of your dependencies will compile from source on your target platform
It reads your lockfile (`uv.lock`, `poetry.lock`, `pylock.toml` or a pinned `requirements.txt`) and checks every package against the platforms you ship to: linux-aarch64, Alpine/musl, macOS, win-arm64, and free-threaded 3.14t. For each one you get ✓ wheel, "builds from source", or "can't install". It's handy for catching slow ARM/Alpine Docker builds before they happen.
uvx wheelgap -p 3.13 -t alpine-arm64
- Offline from the lockfile, about a second
- Respects environment markers, so Windows-only deps aren't flagged on Linux
- Exits non-zero on gaps, and there's a GitHub Action for CI
Repo (MIT): https://github.com/patrickballard/wheelgap. Feedback welcome, especially wheels it misjudges.
1
u/AddictionLord 7d ago
dims – see the shape of every variable in the VS Code debugger
What My Project Does: VS Code extension that shows the shape or length next to every value in the debugger's Variables view, e.g. images = {[8, 3, 224, 224]}, tensor(...) or boxes = {37}, [...]. NumPy, PyTorch, TensorFlow, JAX, pandas, plus lists, dicts, sets, tuples. Install and press F5, nothing to configure.
Target Audience: Anyone who steps through Python code in VS Code, Cursor or Windsurf, especially ML / data code.
Comparison: Similar extensions are PyTorch-only (and patch torch's repr, so your prints change) or need a separate sidebar. dims works in the normal Variables view and leaves your program alone.
Free, MIT: https://github.com/marekprovaznik/dims (Marketplace: provaznik.dims)
1
u/nepalidj 6d ago
finances: a free, open-source Python tool that turns your bank statement PDFs and exports into a local dashboard, with no bank login, no Plaid, and nothing leaving your machine. Every statement prints its own totals, so after reading each line it adds them up and checks they match, which makes every number provably right. You can also ask questions with Claude, OpenAI or a local model, and every amount in the answer is checked against your data.
You can try it on made-up data with `uvx finances demo && uvx finances web --db demo.db --open`.
1
u/DoctorKhru 6d ago
Solving 3D reaction-diffusion PDEs in Python: analytical Bessel K0 vs vectorized NumPy grids (benchmarks & architecture)
Hi r/Python,
When modeling continuous biophysical transport phenomena—specifically reaction-diffusion systems where a diffusing substance is cleared or metabolized in tissue—one of the main engineering challenges in Python is balancing evaluation speed, memory footprint, and geometry flexibility.
In our work modeling drug penetration across microvascular cords in computational oncology, we investigated two distinct computational strategies in Python:
**Closed-form analytical evaluation using **
scipy.special**Vectorized finite-difference numerical grids using pure **
numpy
I wanted to share the architectural trade-offs, performance differences, and open a discussion on scaling 3D array grids.
1. Analytical Evaluation with Modified Bessel Functions
For cylindrical perivascular boundaries (where diffusion occurs radially outward from a capillary at radius $r_0$ with Dirichlet condition $C(r_0) = C_0$), the steady-state PDE:
$$D \nabla2 C - k C = 0 \implies D \left( \frac{d2 C}{dr2} + \frac{1}{r} \frac{dC}{dr} \right) - k C = 0$$
admits an exact closed-form solution via the zero-order Modified Bessel function of the second kind ($K_0$):
$$C(r) = C_0 \frac{K_0\left(r \sqrt{k/D}\right)}{K_0\left(r_0 \sqrt{k/D}\right)}$$
In Python, this can be evaluated instantaneously using scipy.special.kn:
import numpy as np
from scipy.special import kn
def bessel_radial_concentration(r: np.ndarray, r0: float, c0: float, k: float, d: float) -> np.ndarray:
lambda_decay = np.sqrt(k / d)
denominator = kn(0, lambda_decay * r0)
# Mask values inside vessel core
valid_mask = r >= r0
conc = np.zeros_like(r, dtype=np.float64)
conc[valid_mask] = c0 * (kn(0, lambda_decay * r[valid_mask]) / denominator)
return concPros: Instantaneous evaluation ($O(1)$ time complexity for points), zero spatial discretization error, zero numerical stability issues.
Cons: Strictly constrained to idealized symmetric geometries.
2. Vectorized 3D Finite-Difference Grid in NumPy
For realistic heterogeneous vascular topologies from high-resolution spatial transcriptomics coordinates (e.g., Visium HD), analytical solutions break down.
We implemented a 3D explicit finite-difference diffusion operator using vectorized array slicing with periodic/Neumann boundary handling:
import numpy as np
def step_diffusion_3d(grid: np.ndarray, dt: float, dx: float, D: float, k: float) -> np.ndarray:
alpha = D * dt / (dx ** 2)
# 7-point 3D stencil using vectorized slicing
laplacian = (
np.roll(grid, 1, axis=0) + np.roll(grid, -1, axis=0) +
np.roll(grid, 1, axis=1) + np.roll(grid, -1, axis=1) +
np.roll(grid, 1, axis=2) + np.roll(grid, -1, axis=2) -
6.0 * grid
)
return grid + alpha * laplacian - dt * k * gridMemory & Scaling Bottlenecks
While np.roll is readable, it incurs internal memory copies. For a dense $1000 \times 1000 \times 1000$ 3D spatial simulation in float64, a single grid array requires ~8.0 GB of RAM. Chaining multiple temporal steps quickly runs into memory bandwidth ceilings.
The full open-source implementation and CLI suite are available here:
Reference Implementation (GitHub): https://github.com/Lukecele/spatial-continuum-oncology
Discussion Questions for the Community
JIT Compilation vs GPU Offloading: For those simulating 3D PDEs in scientific Python, have you found
numba.njit(parallel=True)with explicit memory loops more practical than offloading tocupyGPU arrays when distributing packages to users without guaranteed CUDA setups?Avoiding memory copies in array stencils: Beyond
scipy.ndimage.convolve, are there lightweight, pure-Python memory-view patterns you recommend to perform 3D stencil operations in-place without duplicating large arrays?7
1
u/n1___ 6d ago
Repository: https://gitlab.com/imn1/rug
Rug is:
Universal library for fetching Stock and ETF data from the internet - mostly unofficial APIs - no limits, more free data.
Documentation: https://rug.readthedocs.io/en/latest/
I'm open to a feedback for new features.
1
u/Fast_Entrance7839 6d ago
viajante: a python library and cli that searches google flights and hotels from your machine, no api keys
What My Project Does
viajante searches google flights, google hotels and booking.com from your own machine and gives back prices, itinerary details and links. no api keys and no account.
it started because i kept opening google flights and clicking day by day to find the cheap one. now viajante dates checks every day in a window for me.
from python it looks like this:
from viajante import get_flights
report = get_flights("JFK-LHR:2026-11-15", fetch="sweep", top=5)
for result in report.queries:
if result.status == "ok":
for offer in result.offers:
print(offer.price, report.currency, offer.airline, offer.duration)
else:
print(result.error)the plain searches are http requests with curl-cffi, and the pages are parsed with selectolax. booking.com needs the optional playwright extra.
one thing i cared about is that an empty result and a failed search aren't the same. each result says whether the provider really found nothing or the page never loaded, so a script doesn't read a blocked request as "no flights".
Target Audience
people who want flight or hotel prices in a script, a notebook or the terminal. it's a side project, MIT licensed, python 3.10+. travel sites change their pages and block requests, so it does break sometimes, and you should confirm the final fare with the airline before booking.
Comparison
compared to checking google flights by hand, it goes through a whole window of dates in one command. compared to a paid travel api, there's no key and no account, but it reads public pages, so it's less stable than an official api.
there's also a cli and an mcp server if you'd rather use it from an assistant.
1
u/VirajCreates 6d ago
Hey everyone,
Over the past few weeks I’ve been working on reducing VLM prefill latency, token consumption, and KV-cache pressure when running Video RAG over security footage and long-form recordings. Today I’m open-sourcing the full-stack application—SieveRAG (TemporalVideo-RAG)—built on top of vlm-sieve v0.3.0 (pip install vlm-sieve).
The Core Bottleneck with Naive Video RAG
Token & KV-Cache Bloat: Sampling a 5-minute video at 1 FPS sends 300 frames (~30,000+ tokens) to the VLM, even when 80% of the video is an empty room or static porch. On local models like Qwen2.5-VL-7B, unaligned resolutions and redundant frames rapidly exhaust VRAM via FP16 KV-cache growth.
Lossy Text-Only Retrieval: Most video RAG pipelines caption chunks into text once and discard the frames. If you later query a fine-grained visual detail ("What tool was the person holding at the doorway and which grid quadrant was it in?"), a text-only synthesizer cannot re-verify the pixels.
How SieveRAG (TemporalVideo-RAG) Solves This
Phase 1: CPU Motion Gatekeeper, 28px NaViT Alignment & 16kHz Audio Slicing (vlm-sieve v0.3.0)
Runs a zero-GPU OpenCV motion & structural change gatekeeper on CPU (
sample_fps=10.0,pre_roll_sec=3.5,merge_gap_sec=6.0).Disturbance Rejection: Automatically suppresses full-frame camera shake, auto-exposure jumps, and lighting flicker so they don't trigger false VLM calls.
Target VLM Profiles (
qwen-vl,local-7b**,**gemini**,**gpt-4o**):** Packs peak-preserving keyframes into adaptive composite storyboards (1x2,1x3,2x2,2x3) whose final canvas dimensions are strictly divisible by28px(e.g.,1344x504for Qwen2.5-VL's14px × 2patch merger) with0pxinternal gutters and clean outer-borderA..D/1..4spatial coordinate axes.Padded Audio Slicing: Uses
imageio-ffmpegto slice16kHzmono32kbpsMP3 audio clips strictly for active motion episodes (±0.5sboundary padding), gracefully skipping silent streams.
Phase 2: Multimodal Structured Extraction & Hybrid Vector Store
Sends each composite storyboard JPEG + sliced MP3 audio clip to the VLM (
gemini-3.8-flash) with a strict Pydantic v2response_schema(EpisodeExtractionSchema).Extracts
episode_title,narrative_summary,actors,objects_detected,audio_transcript_and_cues,severity(low | medium | high), and itemizedtile_actions(Tile #1..#6,+offset_sec,abs_time_sec, andA1..D4grid cells).Indexes dense embeddings (
gemini-embedding-001, 768-dim) into Pinecone Serverless AND/OR a zero-config Local JSON + NumPy Cosine Similarity store (storage/vector_index.json).
Phase 3 & 4: Two-Stage Visual Re-Verification RAG & Click-to-Seek UI
When you ask a question in
/api/ask,SieveRAGSynthesizerretrieves the top-$K$ episodes from the vector store and re-attaches theirevent_XXX.jpgstoryboards to the multimodal synthesis prompt for visual re-verification.Includes a zero-build dark-mode Command Center UI (
FastAPI+ vanilla JS/CSS) featuring an episode timeline scrubber, storyboard zoom inspector, audio slice player, and clickable citation chips ([Ep #3 • Tile #2 • 112.30s • Grid A2,B1]) that seek the HTML5<video>player directly to the cited timestamp.
Real Benchmark: 5m 22s Unedited Ring Home Security Footage
Direct Video Baseline:
29,463estimated tokensSieveRAG Output:
4adaptive storyboards (1camera-shake disturbance automatically suppressed)Token Reduction: 70.5% – 84.8% saved (with Qwen-7B KV-cache footprint tracked per episode)
Multimodal Grounding: On the query "What weapon or tool does the homeowner use to confront the intruder indoors, at what exact timestamp and tile does he hold it, and how does the situation resolve?", SieveRAG pinpointed the metal snow/scoop shovel at
Tile #2 (112.30s, Grid A2, B1..D2), tracked his defensive stance atTile #3 (127.90s)andTile #4 (132.60s), transcribed the verbal de-escalation from the 16kHz audio slice (identifying the intruder as a veteran in crisis), and cited both exiting peacefully byTile #6 (144.60s).
Links & Quickstart
Preprocessor Library (PyPI):
pip install vlm-sieve(https://pypi.org/project/vlm-sieve/)vlm-sieveRepo:https://github.com/Virajcreates/vlm-sieveTemporalVideo-RAG(SieveRAG) Repo: https://github.com/Virajcreates/TemporalVideo-RAG
Happy to answer any questions about the 28px NaViT patch alignment math, disturbance rejection heuristics, or the two-stage storyboard re-verification pipeline!
1
u/jokiruiz 6d ago
I built a local dashboard that tells you which of your AI API keys is out of credit or about to expire
I work with models from several providers, and over time I ended up with a drawer full of API keys: Anthropic for Claude, an OpenAI project key from something I barely remember, a Gemini key from AI Studio, an xAI one for playing with Grok and a couple from OpenRouter, spread across .env files and environment variables on different machines. Whenever something broke, usually in the middle of a demo or right before a class, I had to open five consoles to work out which key had run out of credit, which had expired and which was still fine, so I built a small tool that answers that at a glance.
What My Project Does
Mecha is a local dashboard, with a web UI and a CLI, that checks every AI credential you give it and shows a traffic light per key: whether it's valid, whether it has funds, when it expires and what kind of credential it is (API key, admin key, management key or OAuth session). Every value is labelled with where it came from, whether that's the provider's API, a response header, a JWT decoded locally, a session file, something you typed or an estimate, and "unknown" is an allowed answer, because the most surprising thing I learned while building it is how little the providers tell you. Anthropic, OpenAI and Google have no endpoint to read your remaining balance, Gemini doesn't expose key expiry at all, and only xAI (with a management key) and OpenRouter give you the balance directly. For the cases where running out of credit only shows up when a request fails, there's an opt-in probe that sends the smallest possible paid request, a single output token on the cheapest model, which costs between $0.00002 and $0.015 per thousand probes depending on the provider and is limited to once an hour per key.
If you add an admin key, Mecha uses it to fill in the expiry date and status of the regular keys in that organization, since that's the only place OpenAI and Anthropic expose them, and it flags Gemini keys starting with AIza in amber, because AI Studio has only issued the newer AQ. keys since May 28 and Google is moving away from the old ones. Subscription OAuth tokens (Claude Code, Codex, Gemini CLI) are never used to call any API; Mecha only reads their session files locally to show your plan and when the session expires.
Since the whole point is to hold every key you own, a lot of the work went into not leaking them. It only listens on 127.0.0.1, with a per-session token and a Host header check against DNS rebinding; secrets are encrypted at rest with AES-256-GCM under a key kept in your OS keychain and are never sent back to the browser; each kind of key has a closed allowlist of method, host and path, so an admin key can only make the specific read requests Mecha needs; there's no telemetry; and the README has an explicit threat model, including what it doesn't protect against, which is code already running as your user.
Target Audience
Developers who juggle keys from several AI providers, whether for side projects, teaching or a small team. It's an alpha (0.1.2) under the MIT license, built for my own keys first, so I wouldn't call it production software yet: several provider error messages are undocumented, and reports of anything that doesn't match what your console shows are the most useful feedback I can get.
Comparison
Each provider's console shows its own piece, so you need five of them open. Secret managers like 1Password or Vault store keys but don't tell you whether they still work or have credit left, and secret scanners like gitleaks or TruffleHog find leaked keys (TruffleHog can even verify they're live) but don't track balance or expiry over time. Gateways like LiteLLM can track spend, but only for traffic that goes through their proxy, while Mecha never sits in your request path and only checks the keys themselves. I didn't find anything that does this locally across providers, which is why I wrote it, but if you know of one I'd genuinely like to hear about it.
Try it
There's a web demo with made-up data that runs entirely in your browser; its Content Security Policy blocks every network request and it never asks you to paste a key: https://joaquinruiz.github.io/mecha/
To run it locally (Python 3.12+):
uvx mecha-keys serve --demo # same demo, no keys, no network
uv tool install mecha-keys # then: mecha add, mecha serveCode and threat model: https://github.com/JoaquinRuiz/mecha
Full disclosure: I built it with Claude Code from a written spec, phase by phase, reviewing every PR, with 400+ tests and CI on Linux, macOS and Windows; the spec is in the repo (in Spanish) if you're curious how it was designed. I'd especially love to hear from anyone whose account is in a state I couldn't test, like an exhausted Gemini prepay balance or an xAI team over its spending limit.
1
u/Czarek- 6d ago
CEF Python lets you embed Chromium engine in desktop applications.
We've just released v147 and are looking for testers:
https://github.com/cztomczak/cefpython/releases/tag/v147.0.dev1264
The project has come back to life. The infrastructure has been modernized. We have new CI builds via GitHub Actions and a new CMake build system. Future updates and contributions will be much easier now.
Stay tuned as we're working on a PyPI release. We need more testing, especially on macOS.
1
u/behrouzbk 6d ago
tiktoken gives you the count for one string. This splits a whole request into its parts, prices each one on 20 models, and for prompts suggests concrete fixes with the saving for each. Under the hood it does use tiktoken's encodings, bundled so it works offline.
1
u/EstablishmentAgile19
6d ago
•
Traccia — OpenTelemetry tracing for Python AI agents
I work on Traccia, an Apache-2.0 Python SDK for tracing applications that make LLM and tool calls.
The aim is to make it easier to see what happened during a run: which calls were slow, where tokens were spent, and how model and tool calls fit together.
For tracing your own functions, the basic API looks like this:
from traccia import init, observe
init()
u/observe()
def agent_step(message):
return process_message(message)Here, process_message represents your existing application code. You configure an exporter to send the traces to your chosen backend.
Traccia supports OpenTelemetry backends such as Jaeger and Grafana Tempo. Basic tracing works independently of the Traccia platform; runtime policy enforcement requires it.
Repo: https://github.com/traccia-ai/traccia-py
I’d appreciate feedback on the Python API and getting-started documentation. If you already instrument Python applications, what would you need to see before considering another tracing SDK?
1
u/Eugen_Ivanovic 6d ago
falg: prompt × model image grids on fal.ai from one JSON file
I needed kids' T-shirt designs in several illustration styles from four image models, compared side by side. The fal.ai playground got old fast, so I wrote a CLI. You describe the batch once in JSON (a prompt template, variables, models), and falg runs every combination in parallel.
Each run gets an HTML gallery with prompts as rows and models as columns, and every image gets a JSON sidecar with its prompt, seed and exact request. It asks before spending money and won't run unattended without -y or --max-cost, so scripts and agents can drive it safely. falg cutout turns the picks into print-ready transparent PNGs.
Standard library only, plus numpy, Pillow and SciPy for cutout. Unofficial, not affiliated with fal.
1
u/Longjumping_Glass852 6d ago
Twindex – proves when your data can't pin down a model's parameters
Fit a model to data (an epidemic, a drug dose, a reaction rate) and every method hands back an answer, even when a very different answer fits just as well. Twindex finds those "twins" and writes a small certificate; a checker in standard-library Python with exact fractions (no floats, no numpy) replays it and says VALID / INVALID / INCONCLUSIVE.
Example on real data: after 5 days of the 1978 boarding-school flu outbreak, R0 = 2.5 and R0 = 20 both fit every count.
Try the checker in your browser (Pyodide, no install): https://arnav-m10.github.io/Twindex/demo/
pip install twindex · https://github.com/Arnav-M10/Twindex
Feedback welcome, especially attempts to break the checker.
1
1
u/dierz-pro 5d ago
PyJWT is a library you install once and never think about. That was my problem:
I stopped noticing the microseconds it added to every request. A few million
requests later, the "tiny tax" felt personal.
So: cyjwt — same API, same tokens, Cython core.
- HS256 decode ~2.5x faster than PyJWT 2.15.1, encode ~1.7x;
- ~1 KB token: ~5.4x decode (PyJWT walks base64url in Python, ours stays in C);
- RS256 encode: 1.00x — crypto dominates, no magic there.
Zero deps for HS*, optional cryptography extra, differential tests against
PyJWT, Apache-2.0. No JWK/JWKS yet; manylinux x86_64 wheels for cp312–cp315,
otherwise sdist.
pip install cyjwt
https://github.com/ivlevdenis/cyjwt
Feedback on API gaps and parity-breaking tokens welcome.
1
u/Odd_Phone_5660 5d ago
**Murmury: a PySide6 app that answers questions from your docs during a call, with local Whisper and Ollama**
**What My Project Does**
It listens to the other side of a call on macOS, transcribes it locally with mlx-whisper, detects questions and shows a short answer from the documents you loaded (PDF, Excel, Word, PowerPoint, text). The answer comes from a local model through Ollama or LM Studio (on the same Mac or another computer on your network), or from an API key if you prefer.
**Target Audience**
People who take a lot of calls on a Mac and want their numbers and facts on screen: founders, sales, support. It's a working app (v0.1.5, out today), young (Apple Silicon only), with 9 outside contributors in its first week.
**Comparison**
Most meeting tools write notes after the call, often through a bot or the cloud. Murmury answers during the call, can run fully on your own machines, and is open source (GPL-3.0).
Stack: Python, PySide6, mlx-whisper, a small Swift helper for system audio with ScreenCaptureKit. The part I'd love Python feedback on: keeping the Qt UI responsive while transcription and the model stream in from worker threads.
1
u/Major-Ad-4196 4d ago
Thomas Bangalter produced One More Time and co-wrote Starboy. I gave a Python script three Spotify tracks and it showed me where his name appeared and what he did on each one.
I wrote the first SpotAPI at 16 and posted it on r/Python. One of the first questions was what I could build with it that I couldn’t already do with Spotipy. Two years later, I finally have a demo I’d rather show than explain.
Credit Trail finds people who worked on more than one song. It matches contributor IDs, so it can follow the same person from producer on one track to lyricist on another.
Mix Map reads a public playlist and finds tracks with compatible tempos and keys. My test run found 25 possible transitions in 40 tracks and showed how much to adjust the incoming track’s tempo.
Studio lets you go from a song to its artist or album, inspect the data behind each view, and click a timed lyric to jump there on a connected Spotify player.
The clip shows the quickest thing you can try. On Python 3.11+, run pip install spotapi, then spotapi search "Daft Punk". Public search doesn’t require a Spotify login or developer key. SpotAPI uses unofficial endpoints, so features can break when Spotify changes them.
GitHub and Studio demo · Credit Trail example · My original r/Python post
What two songs sound like they’d have nothing in common? Drop a pair and I’ll run a few through the credits.
1
u/DoctorKhru 4d ago
Why Cancers Relapse: Microvascular Sanctuaries & ctDNA Shedding 🔬🧬 #shorts #science
Radial reaction-diffusion decay creates distal hypoperfused sanctuaries where drug-tolerant persister (DTP) cells survive post-adjuvant targeted therapy. A systemic inflammatory cytokine wave awakens dormant cells into rapid clonal regrowth, remodeling collagen and shedding ctDNA fragments into circulation.
Full Study (N = 3,461): https://doi.org/10.5281/zenodo.24118328 GitHub: https://github.com/Lukecele/inflammatory-onco-physics Research Hub: https://lucacelebrano.me
cancerresearch #biophysics #liquidbiopsy #ctdna #oncology #medicalscience #mathematicaloncology #science
1
u/SAMUROJASDEV 3d ago edited 3d ago
depquiet: tells you which pip-audit / uv audit / npm audit alerts come only from your dev tooling.
What My Project Does
pip-audit has no equivalent of npm audit --omit=dev. Point it at a uv.lock and every alert looks the same, whether the package ships to production or only comes in through pre-commit.
depquiet reads the lockfile and the project's dependency groups, and filters an alert only when no production dependency, extra or non-tooling group can reach the package. On 17 projects at their current head:
| Project | pip-audit alerts | Dev-only |
|---|---|---|
| zulip | 43 | 26 |
| saleor | 16 | 14 |
| langflow | 70 | 11 |
| mlflow | 17 | 10 |
| PostHog | 255 | 8 |
Most of it is virtualenv and filelock pulled in by pre-commit, and twisted by scrapy in zulip's dev group.
I checked every filtered alert against an independent walk of each uv.lock, reading each project's groups by hand. That check caught a bug: zulip keeps its production dependencies in a group called prod, and an earlier version treated every group as dev. Groups now count as dev only when their name says so (dev, test, docs, lint...). Anything else is kept.
Target Audience
Maintainers and teams who run pip-audit, uv audit, npm audit or pnpm audit in CI and spend time on alerts that never reach production. Works with uv, Poetry, requirement files, npm, pnpm and Yarn, and scans npm and Python together when a repo has both. It is for real projects, not a toy, but it is young: I'd like to hear about layouts that break it.
Comparison
pip-audit: reports every alert and has no way to separate dev-only packages. depquiet runs it and sorts the output.
uv audit (experimental in uv 0.13): if your project is on uv,
uv audit --no-devgives you the dev-only split natively, and you should use it. depquiet also reads its output (depquiet --scanner uv) and adds what it doesn't cover: every group judged by its name rather than onlydev, Poetry, requirements files, npm/pnpm/Yarn and mixed repos in one run, plus which direct dependency brings each alert in and what to upgrade.npm audit --omit=dev: does this for npm. depquiet matches it row for row on the npm projects I tested and adds the explanation of which dependency each kept alert comes through.
Snyk / Endor Labs / Socket: go further with function-level reachability, but they are commercial services. depquiet is MIT, runs locally and offline, and only drops an alert when the lockfile proves it is dev-only.
pip install depquiet, then depquiet in the project: https://github.com/samuelrojas-dev/depquiet
1
u/SAMUROJASDEV 3d ago edited 3d ago
Update: I measured whether the fixes scanners suggest can actually be installed. On 18 uv projects, uv's resolver rejects the nearest suggested fix for 502 of 991 alerts (51%). In 81% of the blocked upgrades the culprit is the project's own pin in pyproject.toml, so "update to X" usually really means "widen your pin". `depquiet --check-fixes` now tells you which one.
Full table and raw resolver output: https://github.com/samuelrojas-dev/depquiet/tree/main/benchmarks/fixcheck_study
1
u/feodorfff 3d ago
Flet Studio: write a Python GUI app in the browser, then build and publish it for Android, iOS and desktop
I'm the creator of Flet, an open-source (Apache 2.0) framework for building desktop, mobile and web apps in Python. Flet Studio is our browser IDE for Flet apps, and version 2.0 just came out.
What My Project Does
You write a Flet app in the browser and it runs right there: the preview runs your Python under Pyodide, so NumPy, pandas and Matplotlib work, and you can switch between phone, tablet and desktop device frames. Here's a sales dashboard that loads a CSV with pandas and charts it with Matplotlib (source).
New in 2.0, Studio runs flet build for you on cloud machines: Linux and Windows VMs, and Mac minis for iOS and macOS, with a fresh VM for every build. It handles signing (it can generate an Android keystore, or create the iOS certificate and profile from an App Store Connect API key), and publishes to Google Play, the App Store and TestFlight, the Mac App Store and the Microsoft Store. Every app also gets a download page with a QR code, and can sync both ways with a GitHub repo. Studio's own UI is written in Python with Flet, on a FastAPI backend.
Target Audience
Python developers who want a mobile or desktop app without learning Swift, Kotlin or JavaScript, and especially people who need an iOS build but don't have a Mac. It's meant for production apps that go to the stores, and it's also handy for prototypes, internal tools and teaching, where a link or a QR code is enough.
Studio is a hosted service with a free plan; store publishing is on the paid plan. Studio itself isn't open source, but what it runs is: everything it builds you can build locally with Flet's flet build, for free.
Comparison
BeeWare (Briefcase) and Kivy (Buildozer) package Python apps for mobile too, but the toolchains run on your machine: Xcode on a Mac for iOS, the Android SDK for Android.
Expo's EAS Build is the closest analogue in JavaScript: cloud builds and store submission for React Native. Studio is roughly that for Python.
Streamlit Community Cloud and similar host server-side Python web apps. Studio's output is installable native apps, plus static web apps where Python runs in the browser.
1
u/Cheap_Hope_1179 3d ago
OmaDeck: turns your phone into a Stream Deck and voice remote for Hyprland/Omarchy, built on Python's standard library.
Site: https://mohsintl.is-a.dev/omadeck/ ·
GitHub: https://github.com/Mohsintl/omadeck
1
u/RevolutionarySale800 3d ago
pygame-crt - Configurable CRT effects for Pygame and pygame-ce (no shaders required)
https://github.com/mmtdgn/pygame-crt
I extracted the CRT post-processing system from my upcoming game (OVERDRILL ( https://store.steampowered.com/app/5380990/OVERDRILL )) into a standalone open-source repo. It supports curved glass, scanlines, bloom, bezel rendering, and mouse coordinate mapping directly on Pygame surfaces without needing OpenGL/GLSL shaders.
1
u/DoctorKhru 3d ago
GitHub Repository: https://github.com/Lukecele/inflammatory-onco-physics
Google Colab Demo: https://colab.research.google.com/github/Lukecele/inflammatory-onco-physics/blob/main/demo_inflammatory_onco_physics.ipynb
Preprint (Springer Nature / Research Square): https://doi.org/10.21203/rs.3.rs-11695210/v1
What My Project Does
I developed an open-source Python framework (inflammatory-onco-physics) that models how targeted cancer drugs (like osimertinib) diffuse from microvessels through solid tumor tissue, and why drug-tolerant persister cells survive in perivascular "sanctuary shells" without developing secondary resistance mutations.
It couples continuous spatial reaction-diffusion physics with longitudinal liquid biopsy (ctDNA) shedding dynamics and complete-case survival analysis across 3,461 clinical patients.
How It’s Built & Key Python Components
Analytical Transport Solver (
simulation/model.py):
Instead of computationally heavy 3D Finite Element (FEM) meshes, we solve steady-state cylindrical reaction-diffusion with clearance usingscipy.special.kn(modified Bessel function of the second kind, K₀). This calculates exact sub-therapeutic radii (r_crit = 165.9 μm) in microseconds, enabling 10,000+ Monte Carlo parameter draws in seconds.Liquid Biopsy Shedding Engine (
simulation/simulate_relapse.py):
Simulates tumor cell turnover, metabolic dormancy (G0/G1 arrest), and mononucleosomal fragment intravasation into blood capillaries. Implements an algebraic lead-time identity (Δt = Ts · log₂(100)) predicting molecular relapse ~5.5 months prior to macroscopic imaging.Biostatistical Survival Pipeline (
pipeline/):
Useslifelinesandscikit-learnfor multivariate Cox Proportional Hazards modeling, non-parametric bootstrap resampling (B = 1,000) for Concordance Index (C-index) estimation, and permutation stress-tests with strict REMARK reporting compliance.CLI Bedside Tool (
app_bedside_calculator.py):
A pure standard-library CLI interface for computing sanctuary volumes and relapse risk scores with zero external dependencies.
Target Audience
Computational biologists, biophysicists, data scientists working with clinical survival data, and anyone interested in mathematical oncology.
Code & Feedback
The repository includes a ready-to-run Google Colab notebook that executes the complete biophysical simulation, runs the Monte Carlo parameter sweep, and reproduces the figures on a free GPU/CPU instance.
I’d love any feedback on the Python architecture, performance optimizations for the Bessel parameter sweep, or the survival pipeline!
1
u/funkster047 2d ago
Hello fellow pythoners! I recently finished a game in python that I think ya'll might like! I challenged myself by making a retro style video game with environmental physics using only native modules or libraries. So I could use multi-threading without that pesky GIL, I used python 3.14.5t speicifcally. I also could only use the internet for syntax and everything theory/logic related came out of my own nogin.
1
u/hparx007 2d ago
If you do ETL or API payload normalization, you may know JOLT (Java) — spec-based JSON transformation instead of writing imperative mapping code. I ported it to pure Python: same spec format (Shift, Default, Remove, Sort, Cardinality, Modify, Chainr), spec-compatible with the reference test suite, typed, Apache-2.0, Python 3.10+, with a CLI (pyjolt) for pipeline use.
pip install jolt-pyRepo/docs: https://github.com/sthitaprajnas/pyjolt — feedback and issues welcome, especially from anyone with existing JOLT specs to try porting over.
1
u/nahuel990 2d ago
Baldanders: use Codex or Claude on real customer data without it reaching the Cloud
It sits in front of the CLI and swaps names, emails, IDs, IBANs, cards and secrets for tokens like [PERSON_1] before your message leaves the laptop, then restores them in the reply. The model only sees the tokens, the map stays local, and -v shows exactly what was sent.
1
u/Comfortable_Mall5217 2d ago
retrieve and delete items from google photos
I worked on a tool that downloads all items from google photos and then moves them to trash(or deletes them permanently). uses Playwright and works fine.
https://github.com/brighk/google-photos-cleanup
Workflow:
open Google Photos
walk visible media items
open each item
download it through the UI
store it locally
verify the resulting file exists and is non-empty
record the item URL in a local state file
if
--deleteis provided and every attempted download verified, reopen each recorded item and moves it to Trash
State is stored in:
<output>/.gphotos-cleanup-state.jsonThis lets a rerun skip items that were already downloaded.
I know there is Takeout to download the photos, but if have exceeded your Google storage and you cant even receive an email with the download link, that tool helps. Alsoo, for deleting items, there isn't any tool out there and this is manual labour - imagine deleting thousands of photos by hand. ps. I use immich now for storing any photos or videos at my home lab.
1
u/Top_Speaker_7785 1d ago edited 1d ago
https://github.com/ayushh0110/Weight-Space-Repair.git
When a local model gives a bad reply (empty, looping, cut off, wrong language), wsr works out why. You point it at a saved response, a model folder or a running server, and it goes through the file, the chat template, the request, the response and the output text, then names one cause and the fix.
pip install -e .
wsr triage --response examples/blank_reply/response.json --request examples/blank_reply/request.json
VERDICT: REQUEST
blank output explained by REASONING_EXHAUSTED: cap reached before any answer: the budget went to reasoning
next:
- raise max_tokens (currently 256) or lower the reasoning effort / thinking budget
The Python side, since that's why I'm posting here:
The core has no dependencies at all. `dependencies = []` in pyproject. HTTP is `urllib`, GGUF and safetensors headers are parsed with `struct`, streams (SSE and NDJSON) are assembled by hand, and there's a small JSON-schema checker for tool calls because I didn't want to pull one in for a single check. [Say why zero dependencies mattered to you.]
The heavy part (torch, transformers) sits behind an extra and is imported only by the commands that need it, so `wsr triage` and `wsr cache` work on a machine without torch.
It's one argparse CLI with 19 subcommands. The command reference in the guide is generated from the parser, and a test fails if the guide is out of date, if any option has no help text, or if a relative link in the docs is broken. That test has caught me more than once.
It asks before it downloads, converts or starts anything, with `--yes`, `--no` and environment variables for scripts, and distinct exit codes (0 fine, 1 failure found, 2 usage error, 3 "needed a yes it didn't get").
384 tests, about 3 minutes on my machine, ruff clean. Python 3.10+. Not on PyPI yet.
Target Audience
People running open-weight models locally with llama.cpp's server or Ollama, and anyone debugging saved LLM API responses. It's beta. The triage part is the part I'd call usable today. There's also a weight-level part (diagnosis and repair with torch) that's only tested on models up to 1.5B, on a 4 GB GPU.
Comparison
LLMDoctor, llm-output-guard, llm-stopcheck and ModelVet each cover one layer (config, output text, finish reasons, file structure). wsr ports or reimplements their checks, credited in NOTICE, runs them as one pipeline and links the symptoms to a single cause. For the weight-level part, TransformerLens and nnsight are interpretability libraries; wsr uses plain forward hooks and is a tool that ends in a verdict.
1
u/ImaginationVarious30 21h ago
Moving retries out of the hot path: an asyncio pattern that brought back proxies my checker was dropping
Alternative: My asyncio proxy checker marked flaky proxies as dead. Deferring a second try to the end of the run fixed a big part of it (A/B measured)
I maintain proxy-scraper, a Python CLI and library that checks public HTTP/SOCKS proxies and publishes the ones that pass, hourly on GitHub Actions: https://github.com/maximilianfeix/proxy-scraper
**What My Project Does**
Each candidate gets a handshake and first request, a second request to another site that must see the same exit IP, and a test page that must arrive byte for byte. Plain asyncio streams, deps are `rich` and `certifi`, Python 3.9 to 3.14.
The asyncio part I worked on this week: about 350 proxies per run passed the first request and then broke off on the second, even after an inline retry 1.5 s later. Waiting longer inline would block a worker. So a follow-up that fails in transport now records nothing and goes on a deferred list with its `loop.time()`. When the workers finish, one task per deferred proxy sleeps until at least 20 s after its try, runs both follow-ups under a semaphore, and counts whatever they end as. A real verdict (other exit IP, changed page, non-200) is never retried.
A/B on two runners with the same 150k candidates: 768 listed before, 986 after.
**Target Audience**
People who write their own checker or scrape public data. Not for logins.
**Comparison**
monosans/proxy-scraper-checker (Rust) is one fast binary. jhao104/proxy_pool is a Redis-backed pool. proxy-scraper records an outcome per check and keeps "failed" apart from "couldn't check".
Erster Kommentar:
The pattern, simplified from `pipeline.py`:
```python
deferred = [] # (loop.time(), proxy) of follow-ups that broke off in transport
async def second_chance():
gate = asyncio.Semaphore(concurrency)
async def one(item):
at, proxy = item
await asyncio.sleep(max(0.0, at + 20.0 - loop.time()))
async with gate:
await follow_up(proxy, last_try=True, item=item) # removes item once its verdict is recorded
await asyncio.gather(*(one(i) for i in list(deferred)))
```
Two things took longer than the feature. Cancellation: with `--want 50` the run stops early, so an entry has to leave `deferred` the moment its verdict is recorded, or a proxy cut off afterwards counts as working and failed. And a check-target watchdog can put basic checks back into the queue while the second phase runs, after the workers that read that queue are gone, so the main loop now repeats until both the queue and `deferred` are empty.
Since it went live, about 30 % of deferred proxies pass on the second try (236 to 363 per hourly run). Lists: https://github.com/maximilianfeix/free-proxy-list
1
u/Ravster23 10h ago
Project: https://github.com/Ravsterv/maze-generator
A small project I decided to work on overnight which makes use of stack behaviour to generate a maze.
Includes semi-smart back tracking if stuck and Growth propagation which influences which sides routes grow out during phase 2.
Epilepsy warning if you watch it generate through the terminal.
1
u/Immediate_Sky8296 4h ago
oss-backtest-kit – deflated Sharpe / PBO checks, checksum-verified Binance data, and a no-look-ahead backtest engine
What My Project Does A small, MIT-licensed library for crypto-futures backtesting research: (1) multiple-testing statistics (PSR, Deflated Sharpe Ratio, PBO via CSCV, circular block bootstrap, Wilson interval); (2) a Binance public-archive downloader that verifies each file against its published SHA-256 and reports gaps and duplicate bars; (3) a simple config-driven backtest engine with no look-ahead, fees, slippage and perpetual funding.
Target Audience Individual researchers and students who write their own strategies in Python and want a sober second opinion on a backtest. Not a trading bot; places no orders. Early release (0.1.0).
Comparison backtrader and vectorbt are much fuller engines. This is smaller on purpose and focuses on overfitting statistics and data integrity; the stats functions take any returns array, so they work with other engines too.
Python 3.9+, numpy + scipy only, 62 offline tests. pip install oss-backtest-kit
Repo: https://github.com/ww7411/oss-backtest-kit
Research and education only, not investment advice; the example chart uses synthetic data.
1
u/tom_mathews 3h ago
Attest: pytest plugin for testing AI agents on what they did, not just what they said
Source: https://github.com/attest-framework/attest (Apache-2.0, I'm the author)
Web Page: https://attest-framework.github.io/
What My Project Does
Attest is a testing framework for LLM agents. In Python it's a pytest plugin with an attest fixture and a chainable expect() API; evaluation runs in a small Go engine the SDK starts as a subprocess. Checks run cheapest first: JSON schema, cost/token/latency limits, which tools ran, in what order and with which arguments, content patterns. All of those are deterministic and free. Embedding similarity and LLM judges come last and are optional.
# refund_run: a fixture returning a recorded agent trace
def test_refund(attest, refund_run):
chain = (
expect(refund_run)
.output_matches_schema({"type": "object", "required": ["refund_id"]})
.cost_under(0.01)
.tools_called_in_order(["lookup_order", "issue_refund"])
.tool_cardinality("issue_refund", per="order_id", at_most=1)
)
attest.evaluate(chain)attest capture -- python my_agent.py records a real run (model calls, trace, secrets redacted). Tests then replay the agent's current code against it, so CI makes zero model calls. 1.1 came out on November 10; it also fails any expect() chain you built but forgot to evaluate, and pytest-xdist runs now produce a complete report.
Try it, no API key needed:
uv init --bare demo && cd demo
uv add attest-ai pytest
uv run attest init
uv run pytestTarget Audience
Teams putting agents into production or CI, in Python 3.10+ (a TypeScript/Vitest SDK exists too). The capture/replay merge gate and behavior contracts are marked stable; several other features are beta or experimental, and the README labels each one. It has no external users yet, so expect rough edges.
Comparison
DeepEval and promptfoo are strong at scoring outputs with metrics and rubrics. Attest focuses on the trace and its side effects: per-key call counts, effects on a simulated backend, record/replay with no model calls, and mutation testing that tells you what your suite misses. Compared with vcrpy or pytest-recording, the recorder understands model APIs (streaming, templated ids, redaction) and drafts contracts from the run. Most of the code was written with coding agents (Claude Code, Codex) from plans I wrote and reviewed.
1
u/angel_fts 6d ago
What My Project Does
Companies run thousands of automations: UiPath robots, SAP OData services and integration flows, BPMN processes, n8n workflows, internal APIs. Before anyone, or any AI agent, runs one, two questions matter: what will it change, and is it safe to run twice? The answers are buried in XML and JSON files nobody reads.
FlowGlyph reads those files with deterministic parsers (no model) and turns every workflow, service operation and API call into a typed capability: a pydantic model with inputs, outputs, effects (reads, mutates_state, destructive, external, each yes, no or unknown) and an idempotency mode (natural, key, conditional, none). Every value says whether it was inferred from the sources or declared by a person.
Try it on UiPath's own template, no clone needed:
pip install "flowglyph[cli]"
flowglyph idempotency https://github.com/UiPath/ReFrameWork --kind workflowIt prints 13 workflows and flags 6 to review. One of them, GetTransactionData, takes a different queue item every time you call it, so a retry is not a repeat.
The part I most wanted to show here is the planner. You give it the client's process document (PDF, Word, Excel, text) and the catalog:
flowglyph plan ./handover/supplier-invoice-pdd.docx catalog -o plan --via claude-codeA model proposes the steps; a deterministic resolver checks every one against the catalog: the capability exists, every required input is filled, each argument has the declared type, every reference points to an earlier step. A step nothing in the catalog can do comes back as missing, never as an invented function:
Step Capability Intent
validate_vendor uipath/Invoices/Steps/ValidateVendor Check that the vendor on the invoice exists in our records.
notify_purchasing missing Notify purchasing that the vendor is unknown and stop processing the invoice.
request_approval uipath/Invoices/Steps/RequestApproval Ask the finance approver for approval before booking a high-value invoice.
create_invoice openapi/Payments_API/createInvoice Create the invoice in the payments system, keyed by the invoice reference so a retry never books it twice.
archive_pdf missing Archive the invoice PDF in the document store with a 10-year retention period.--via is whatever you already have: claude-code, codex, gemini, cursor, the Anthropic API, or any OpenAI-compatible server (Ollama, vLLM). The model sees the document and a BM25 shortlist of candidate functions, never your sources.
Around it: flowglyph serve is an MCP gateway with a policy, an idempotency ledger and an audit log; flowglyph compile writes the plan as BPMN or UiPath XAML; flowglyph context writes AGENTS.md for coding agents; and import flowglyph gives you all of it as a typed API.
How it is built: Python 3.12+, pydantic 2 for the IR with generated JSON Schemas, strict pyright, ruff, 542 tests, and the core depends on pydantic and PyYAML only. Typer and rich for the CLI, the MCP SDK for the gateway, pypdf, python-docx and openpyxl for documents, all optional extras. Adapters are plugins under an entry point group, so a new format is a package, not a fork. Apache-2.0.
Target Audience
People who build or integrate RPA and SAP automations and are putting AI agents on top of them, and Python developers who like deterministic tooling around LLMs. Alpha: the IR is at 0.4 and may change, the adapters have run on vendor templates and synthetic projects, not on a real client estate yet. Use the gateway in dry-run mode, its default, until you give it a connections file.
Comparison
| Gives you | Does not | |
|---|---|---|
| Vendor agent integrations (UiPath, SAP, n8n) | deep access to one platform | one platform at a time; retry safety as a hint; their hosted service |
| OpenAPI-to-MCP converters | every API operation as a tool | nothing for UiPath, CPI, BPMN or n8n; no effects, policy, ledger or audit |
| Asking an LLM to read the sources | a plausible description, fast | not deterministic, not auditable, invents workflows that do not exist |
| FlowGlyph | one catalog for all of them, facts with provenance, a gateway you host | real execution beyond UiPath jobs and OData calls is still on the roadmap |
Want to help?
There are six issues labelled "good first issue": a Power Automate adapter, a --format json for the call tree, an n8n example, more UiPath activity packages, a --watch for the wiki, and AGENTS.md for SAP Build. Use-case ideas go to the repo's Discussions.
About me
I build GenAI platforms in Python for a living; FlowGlyph is my side project, written with the same rules I use at work: typed models, deterministic where it can be, a model only where it earns its place, and tests that replay every command shown in the README.
Source Code
GitHub: https://github.com/afernandeztem/FlowGlyph PyPI: https://pypi.org/project/flowglyph/ The planner example with its real output: https://github.com/afernandeztem/FlowGlyph/tree/main/examples/invoice-processing
Which format would you want next? Power Automate and Zapier exports are first on my list, but I would rather build what someone will run.
0
u/Pytrithon 11d ago
Pytrithon v1.2.12
Introduction
I have already introduced Pytrithon in its own post three times on Reddit. See:
https://www.reddit.com/r/Python/comments/1q8dwsm/pytrithon_v119_graphical_petri_net_inspired_agent/ https://www.reddit.com/r/Python/comments/1nr3qvm/pytrithon_graphical_petrinet_inspired_agent/ https://www.reddit.com/r/Python/comments/1mx9w5r/graphical_petrinet_inspired_agent_oriented/
What My Project Does
Pytrithon is a graphical Petri net inspired agent oriented programming language based on Python. It allows writing code as a two dimensional graph of interconnected elements and separates data as Places and code as Transitions. Inter Agent communication and GUI widgets are first class components of the language. Through the Monipulator, Agents can be monitored and manipulated.
Target Audience
The target audience is both experienced and novice programmers who want to try something new.
Why I Built It
I realized the power of Petri net inspired programming and the joy of having a more expressive way to specify control flow.
Comparison
There are no other visual programming languages which embed actual code into their graphs.
How To Explore
To run all included example Agents you need at least Python 3.10 installed. To install all dependencies, run the 'install' script. Then you can start up a Nexus with a Monipulator by running the 'pytrithon' script, where you can start Agents through opening them with 'crtl-o' twice and hitting the 'Open Agent' button. You can also directly specify which Agents to run through the command line by starting a Nexus, Monipulator, and Agents in one single command: 'python nexus -m <agent1> <agent2>'.
Recommended example Agents to run are: 'clock', 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 two posts, nothing was changed.
Since my third last post some bugfixes to the clock agent were done.
Since my fourth last post I have created a new 'clock' Agent, which I personally use all the time. It offers an analog or digital clock with a graphical blur applied. It can be configured in the 'clock.yaml' file or through keyboard keys; keys to try are: t, b, a, k, K, c, C, O, r, R, l, L, n, N, m, M, h, H, s, S, d, f, F, w, comma, and period. To run it in an isolated Nexus, run clock.bat or clock.sh.
Since my fifth last post there have been numerous small fixes and improvements to the system and to several agents.
Since my sixth 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 the seventh last post I have added a distributed Yahtzee game which you should try out. In order to setup a server on a reachable machine and connect other machines, you need to do the following: On the machine meant to be the server, run 'python nexus yahtzeeserver' first. Then on the machines meant to be the clients through which users play, run 'python nexus -x <serveraddress> yahtzee'. The clients probe the interconnected Nexi for a server and start with a lobby mask where you can select your name and start a game with all players signed up.
GitHub Link
https://github.com/JochenSimon/pytrithon
This is the tenth 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.
0
u/Nikhitha_Dev 8d ago
Hi everyone! I'd like to share my project, DejaOps – An On-Call Copilot That Remembers What Actually Fixed It.
I developed this project to help teams remember solutions to previously encountered technical problems.
GitHub: https://github.com/nikhitha-bot-1/DejaOps
I would appreciate your feedback and suggestions for improvement. Thank you!
0
u/PrinceSanchela 6d ago
Hey everyone! Over the past few months, I've been architecting **LangVoi Voice Studio Pro**, an open-source native Windows desktop workstation inspired by classic DAWs like Sound Forge Pro and Adobe Audition, but built with Python and modern speech recognition.
Key Highlights:
- Neural Whisper LID Engine: Identifies 90+ spoken languages and dialects in under 2 seconds completely in-memory (zero console flashing, zero temporary disk files).
- 8 Laboratory Acoustic Telemetry Instruments: Computes fundamental pitch ($F_0$) via autocorrelation, chromatic musical notes (C3, A4), vocal registers (Bass to Soprano), SNR, VAD speech ratio, and syllable tempo.
- Master Oscilloscope & Stereo VU Meters: Sub-millisecond scrubbing, 64-band FFT spectral analyzer, and live frequency heatmap.
- Pure Win32 Desktop App: Custom C# silent launcher that boots pythonw with High-DPI Per-Monitor scaling.
- DSP Core: 100% vectorized NumPy (autocorrelation pitch tracking & spectral FFT).
- Tested with 13 automated unit tests and GitHub Actions CI/CD.
- GitHub: https://github.com/PrinceSanchela/LangVoi
- Gumroad Store / Pro License: https://codeprince.gumroad.com/l/langvoi
Would love any feedback on the Tkinter canvas rendering or DSP audio pipeline!
0
16
u/dvgils 11d ago
https://github.com/DvGils/millwork
A UI framework for Python to easily make professional looking web applications. Lightweight/easy to maintain, browserless testing, state through pydantic models, no javascript needed. Its still early but available on PyPI.
Docs: https://millwork-ui.com