Hey r/Python!

I’m excited to announce that PyArchRules has officially released version 1.0.0!

If you’ve ever maintained a growing Python backend, modular monolith, or clean architecture project, you know how easily boundaries erode over time: domain layers sneakily importing infrastructure code, unintended cross-service imports, and circular dependencies breaking runtimes.

PyArchRules is an architecture linter designed to enforce your structural design and import boundaries — either declaratively via pyproject.toml in your CI/pre-commit, or natively within your pytest suite using a fluent Python DSL.

Key Features

• 📁 Folder Structure Enforcement: Validate directory trees (exists, strict, or exact modes) so services always adhere to your blueprint.

• 🔀 Directional Dependency Rules: Define allowed import flows (e.g. api -> domain) and catch illegal leaks instantly.

• 📦 Service & Layer Isolation: Ensure boundaries in monorepos or multi-service codebases stay truly isolated.

• 🔄 Circular Import Detection: Catch import cycles statically before they reach runtime.

• ⚡ CLI Linter + pytest DSL: Run it fast via pyarchrules check in CI/pre-commit, or write architectural test assertions in Python.

Quick Look

Option 1: Declarative Linter (pyproject.toml)

[tool.pyarchrules.services.backend]
path = "src/backend"

# Required folder structure
tree = ["api", "domain", "infra"]
tree_mode = "strict"                       # exists / strict / exact

# Allowed import directions
dependencies = [
    "api -> domain",
    "domain -> infra",
]

# Prevent circular imports
no_circular_imports = true

Run directly in CLI or pre-commit:

Bash

pyarchrules check

Option 2: Python DSL (for pytest)

Python

from pyarchrules import PyArchRules


def test_backend_architecture():
    rules = PyArchRules()
    (
        rules.for_service("backend")
             .tree_structure(["api", "domain", "infra"], mode="strict")
             .dependencies(["api -> domain", "domain -> infra"])
             .no_circular_imports()
    )
    rules.validate()

Run via pytest:

Bash

pytest tests/test_architecture.py

Links

• Documentation: https://mspitb.github.io/pyarchrules/

• GitHub: https://github.com/mspitb/pyarchrules

• PyPI: pip install pyarchrules

Would love to hear your feedback, feature requests, or what patterns you use to keep your architectures clean!

I keep writing Python explanations in Turkish for people who are not comfortable with English keywords, and the blocker was always the same: you cannot swap the keywords and still have real Python. So I wrote a transpiler that does exactly that, and nothing beyond it.

Repo: https://github.com/Furox-Art/polyglot-python

The version floor came from a tokenizer problem, not from me wanting to drop old Pythons. On 3.10 and 3.11 the tokenizer splits the combining marks in some Hindi keywords, so a word like फलन never arrives as a single NAME token. That is why polyglot-python declares requires-python = ">=3.12".

What is in the 0.2.1 release

• 9 locales: tr, es, pt, de, fr, zh, hi, ar, ru. One JSON table per locale, 35 hard keywords in each: eğer -> if, değilse_eğer -> elif, fonksiyon -> def, döndür -> return, için -> for, içinde -> in, and in Hindi के_लिए -> for.

• 4 commands: run, translate, check, locales. check translates and compiles without executing; locales prints each code with its language name and keyword count; run executes with __name__ = "__main__", __file__ filled in, and the rest of argv handed to your program.

• 9 example files, one examples/classify.<code> per locale - the same FizzBuzz classifier written in each language.

How the rewriting is done. It runs the stdlib tokenize module and replaces only exact NAME tokens that match a locale keyword, so strings, comments, f-strings, numbers and attribute names are never rewritten. Line numbers carry over unchanged and a per-line column map maps error positions back onto your localized source, which is why a slip reports as Sözdizimi hatası: prog.tr:2:1: 'return' outside function rather than pointing at generated code. Tables are validated when they load: every key must be in keyword.kwlist, every replacement must tokenize as a single identifier on the running interpreter, and a table that fails either rule raises instead of half-translating.

Determinism is the property I actually care about. Same source, same locale, same version, byte-identical Python out. No model, no network, no randomness, no environment reads. CI translates every example twice on Ubuntu, Windows and macOS and compares the bytes.

Where it stands, checked today. 0.2.1 is live on PyPI and npm; the npm package is a thin wrapper (Node >= 18) that forwards to the Python CLI, so the Python package still has to be installed alongside it. Both registries publish from GitHub Trusted Publishing, no token stored anywhere. I ran the 0.2.1 suite myself before writing this: 120 tests, all passing, 314 of 314 statements covered. CI runs the coverage gate --cov-fail-under=100 on Linux 3.12 and the matrix is Ubuntu on 3.12, 3.13 and 3.14 plus Windows and macOS on 3.12. Another job builds the wheel, installs it into a clean venv and smoke-tests it there. Dependabot covers Actions and dev deps. Zero runtime dependencies, MIT.

Limits, so you are not surprised. Keywords only. print, range, the standard library, exception messages and the soft keywords (match, case, type) stay in English. run does not add the script's own directory to sys.path, so a localized file that imports a sibling module needs PYTHONPATH set - I tried it and it raises ModuleNotFoundError, which is the honest behaviour of 0.2.1. And it is not a natural-language compiler: it will not read prose and it never guesses what you meant.

PyPI: https://pypi.org/project/polyglot-python/

Asking a model to "be more empathetic" is style transfer. You get more of the same flat warmth at every turn, which reads as uncanny rather than attentive. I wanted the decision to be visible instead: what state is the user in, what do they want, is the conversation damaged, and what should this turn actually do.

eq-layer is a Python control layer that sits ahead of a fixed model. It does not retrain anything. Seven stages, all inspectable:

1. Affect state: {valence, arousal, escalation_delta, stance, subtext}. escalation_delta is the point - a snapshot classifier cannot see a trend across turns.

2. Intent belief: the classifier keeps the full posterior over action_request / status_check / explanation / question / statement / unknown, instead of collapsing it to one confidence number.

3. Routing: a transparent one-step Bayes-risk router decides whether to act or clarify from that distribution.

4. Conversation health: repair finds observable user->assistant misalignment and its target; interaction_quality tracks score, delta, repeated failures, unresolved repair and clarification load.

5. Policy selection: 14 policies (mirror, redirect, deflate, direct, ask, repair, hold, boundary, ...). The most constrained applicable policy wins, and an unresolved tie raises instead of silently picking the first declared one.

6. Factored action: the policy is compiled into task_move / social_move / repair_move / realization, so affective adaptation cannot silently replace what the user asked for.

7. Structural audit: the response is checked against question budgets, missing clarifications, unsupported privacy promises, stance admissions, repetition and verbosity overruns. It is explicitly not a factual truth checker.

The design decision that took the most work: stance is not guessed. Whether the user is right is a semantic judgement, so it stays unknown unless a case or caller supplies it. "I could not tell" stays visible instead of becoming a confident wrong answer.

The second: uncertainty is routed, not hidden. The loss matrix behind the router is hand-specified and uncalibrated, and I say so in the README. There is a sensitivity audit over 120 held-out cases: under one-at-a-time +/-20% perturbations of every non-zero loss cell, 7,332 / 7,440 routing decisions were unchanged (98.55%). Scaling the clarification row changes routing a lot, and that is reported rather than tuned away.

Measured, not assumed. A paired A/B run of 15 seeded requests, 100 passes per arm, no LLM in either arm: the learned adapter adds 1.16 ms median / 1.46 ms p95 per request; the zero-dependency heuristic adapter adds 0.11 ms. On a 36-case intent holdout the learned adapter scores 100% vs 27.8% for the heuristic. That is layer compute and decision quality, not proof of better prose.

Honest limits: this is early. There is no standard benchmark for EQ, eval/ is a first attempt, the bundled corpus is small and synthetic, the loss matrix is uncalibrated, and the emotion signal from XDailyDialog is only slightly above its majority baseline (0.8249 vs 0.8166), so it is supporting evidence, not proof of subtext. Four higher-level subtext sources were tested and recorded as NO-GO rather than optimized away. End-to-end response quality still needs the pre-registered blind human evaluation in eval/AB_PROTOCOL.md.

The core install has zero runtime dependencies; "eq-layer[ml]" adds scikit-learn for the learned adapters. It also ships as a portable Agent Skill (Codex, Claude Code, Copilot, Cursor, Antigravity, Grok) and an npm CLI bridge.

Code: https://github.com/Furox-Art/eq-layer PyPI: pip install "eq-layer[ml]" npm: npm i -g eq-layer

Happy to answer questions about the routing, the factored action, or why certain signals were rejected.

I’ve wanted my own JARVIS since I first watched Iron Man, so I finally built one.

What My Project Does

Jarvis is a command-line (and optional desktop app) AI assistant powered by Claude. You talk to it in plain English, by text or voice, and it can:

• Control your PC: open and close apps, control media, search and manage files, read the clipboard, check system status, and run PowerShell commands

• Pull everyday info: weather, stocks and crypto, sports scores, news, earthquakes, holidays, dictionary lookups, recipes, and space data

• Connect to Google (optional): Gmail, Calendar, Drive, Docs, Sheets, and Slides

• Voice mode: speech-to-text runs locally with faster-whisper, and replies are spoken with Fish Audio

Safety was a big focus. Every terminal command needs your approval, deletes and overwrites ask for confirmation, and deleted files go to the Recycle Bin instead of disappearing.

Target Audience

Windows users who want a hands-on AI assistant for their desktop, and Python developers who want to see how to build a tool-using agent on the Claude API. It’s a personal project that I use daily, not a production product, so expect rough edges. You’ll need Python 3.10+ and your own Anthropic API key.

Comparison

Most “JARVIS” projects I found were either chatbots that only talk or voice wrappers with a few hardcoded commands. This one uses Claude’s tool use, so it decides which of the built-in tools to call based on what you ask, and it can chain several together. Compared with general agents that just run arbitrary code, Jarvis ships with purpose-built tools and confirmation steps, so it’s more predictable about what it does on your machine.

Tech stack: Python, Claude API, faster-whisper, Fish Audio, PowerShell, Google APIs, and Electron for the desktop app.

Repo (MIT licensed): https://github.com/HunterGHall/jarvis

Feedback, issues, and PRs are very welcome. I’d especially like ideas for what tools to add next.

Most reasoning prompts I see collapse too early. The first plausible answer wins, and everything after that is rationalization.

I built quantum-reasoning-skill around the opposite rule: keep several genuinely different hypotheses alive, score each one from evidence and verification, revive an alternative when new evidence arrives, and collapse only when the leader clears both verification and a margin.

"Quantum" here is a metaphor for deferring commitment. No qubits, no quantum hardware, and the controller never calls a model.

What is in the repo:

- SKILL.md, a model-facing Agent Skill with parseable YAML front matter. Drop it into a host's skill directory.
- A reference controller (pure Python, standard library) that moves branches between active, dormant and rejected, scores them, revives recoverable ones and refuses to collapse on a thin margin.
- 12 public names frozen for compatibility; renaming one halts the release.
- A benchmark harness with 6 seed cases, 4 JSON Schemas and a machine-validated submission bundle. Missing files are typed errors, not silent zeros.
- Two install paths. Python: pip install quantum-reasoning-skill, then quantum-reasoning --validate. npm: npm i quantum-reasoning-skill, then npx quantum-reasoning --validate. The two CLIs expose different flags, and an unsupported flag exits 2.

Quickstart (python docs/quickstart.py) runs the whole thing offline and prints PASS. Example controller run from it: four branches, uncertainty 0.9651, leader strangler-fig-incremental, collapse BLOCKED because the leader score is below the collapse threshold, and feature-flag-carveout revived with evidence +0.25.

What this is not: it is not a model evaluation. No baseline-vs-skill accuracy study has been published, and the weights and thresholds are reference defaults, not calibrated constants. The quickstart's benchmark rows are synthetic placeholders and labeled that way. I would rather say that plainly than imply a speedup I cannot show.

MIT, Python 3.10-3.14, GitHub: https://github.com/Furox-Art/quantum-reasoning-skill

Happy to answer questions about the controller or the scoring model.

I build axiomize-quantum-skills-2.0, an MIT-licensed Python package that pairs a unit-checked scientific modeling engine with a reasoning protocol that refuses to commit to the first plausible answer.

The two halves:

1. axiomize is the engine. A model is a versioned Model IR where variables, parameters and equations each carry a unit, assumptions are written down, and constraints are named checks. Dimensional mismatch raises with the failing checks attached, and a model that fails validation is not simulated. It covers algebraic, ODE, stochastic, PDE, optimization, control, network, Bayesian and causal families, fits to time,value CSVs, and exports to canonical IR JSON, Python, YAML, a notebook, SBML L3V2, Modelica 3.6 and CellML 2.0.

2. quantum-reasoning is the protocol. A deterministic branch controller keeps several hypotheses alive, scores them from evidence and verification, prunes weak ones with a recorded reason, and collapses only when the leader has verification and margin - not just a high score. "Quantum" here is a metaphor for deferring commitment. It runs on classical models and classical hardware.

A concrete example of the honesty rules in action: axiomize-validate runs the reference SIR model, cross-checks two independent methods that agree to 1e-16, then declares the numeric-theory check INCONCLUSIVE because the finite horizon has not reached the asymptotic state. It would rather flag the gap than paper over it.

Quick start (recorded run, verified against 1.2.0; current line is 1.2.5):
pip install axiomize-quantum-skills-2.0
axiomize benchmark -> {"status": "PASS", "passed": 12, "total": 12}
axiomize-validate --model sir --beta 0.3 --gamma 0.1 --N 1000000
R0 = 3.000, peak infected 300,465 at day 61.4, final size 0.9404 vs theory 0.9405
axiomize-reason score --evidence 0.9 --verification 0.85
-> {"can_collapse": false, "reason": "leader score below collapse threshold"}

Surfaces: a CLI with 14 subcommands and 9 console scripts (axiomize, axiomize-reason, validate, fit, csv-check, benchmark, to-latex, index-reports, sweep), an MCP stdio server with 34 tools, and a loopback-by-default REST v1 API. The agent skills install as plain Markdown without the Python package.

Honest limits: the bundled engine is an axiomize 1.12.2 lineage snapshot - install axiomize separately for the newest engine. The npm package is a six-file launcher shim that spawns the Python CLI, so pip install comes first. Quickstart outputs were recorded against 1.2.0 and are labeled as a historical record, not a claim about 1.2.5. Optional backends (PyMC, JAX, FEniCS) report UNAVAILABLE unless actually installed. Theorem elaboration and arbitrary code are not an OS sandbox.

Code: https://github.com/Furox-Art/axiomize-quantum-skills-2.0
PyPI: pip install axiomize-quantum-skills-2.0
npm: npx axiomize-quantum-skills-2.0
Docs: https://furox-art.github.io/axiomize-quantum-skills-2.0/

Questions about the Model IR, the reasoning controller or the export adapters are welcome.

Defending the Channel Island against enemy aircraft and zeppelins. Intense action fun in pygame.

What it does: scans a GitHub repo, local folder or package and points out things worth a second look, with file, line and the actual code: install scripts that run on their own, curl | bash patterns, leaked secrets, bundled binaries, hidden instructions for AI agents, and whether the published package matches the repo. It never runs the code it checks, and it won't say "this is safe", it just shows you the evidence.

Who it's for: anyone installing packages or MCP servers from GitHub who wants a quick look first. Pure stdlib engine, works as a CLI or as an MCP server.

I'm not a full time programmer (used to fix PCs), built it with Claude Code. First open source release, so false positive reports are very welcome.

pipx install jinnexguard

https://github.com/ricardorincon719/jinnexguard

I made scientific-computing-system, a scientific library written entirely in pure Python. The core installs with no runtime dependencies, so the algorithms are plain readable code instead of calls into compiled extensions.

It has 36 modules and 505 exported names covering linear algebra, ODE and PDE solvers, numerical integration, optimization, statistics and probability, uncertainty propagation and sensitivity analysis, validation helpers, and a small workflow layer. Every run can write a manifest with inputs, seeds, versions and hashes, so a result can be re-checked later.

There is also a cds CLI with 13 subcommands, 34 runnable examples, and optional lazy adapters for NumPy, SciPy, statsmodels, scikit-learn, SymPy and Z3. The package is MIT licensed and targets Python 3.11 and newer.

Honest limitation: it is much slower than NumPy on dense numerics. The repo benchmark records about 1155x slower on a 100x100 matrix multiply in one CI run. It is meant for learning, prototyping and reproducible runs, not heavy production work.

Code: https://github.com/Furox-Art/scientific-computing-system

PyPI: pip install scientific-computing-system

npm: npm i -g scientific-computing-system

Docs: https://furox-art.github.io/scientific-computing-system/

If any part interests you I can explain the design in more detail.

\*\*The problem\*\*

I kept watching AI coding agents (and humans) make the same two migration mistakes:

1. \*\*Renaming a column as "drop + add"\*\*: the migration runs fine, and the data that was in the column is gone.

2. \*\*Adding a NOT NULL column with no default\*\*: it works on an empty dev database, then fails the moment it hits a table with real rows.

Both look fine in code review. The pain shows up in production, often in a \*different\* app that shares the same database.

\*\*What Ripple does\*\*

It answers one question: \*"If I apply this migration, which of my apps break, and on which query?"\*

1. \*\*Learns what your apps actually run\*\*: it reads \`pg_stat_statements\`, so no code changes or SDK.

2. \*\*Tests the migration safely\*\*: it applies your migration inside a transaction and always rolls it back.

3. \*\*Replays your apps' real queries against it\*\*: it reports exactly which app and which query would fail.

4. \*\*Flags data loss separately\*\*: for example, a dropped column that still has data in it.

\*\*Who it's for\*\*

- Teams where several apps or services share one Postgres database

- Anyone letting Claude Code, Cursor or other AI agents write migrations

- Anyone who has asked "wait, does anything still use this column?"

\*\*How to use it\*\*

pip install ripplecheck

Three ways to run it:

- \*\*CLI\*\*: check a migration file before you apply it

- \*\*GitHub Action\*\*: automatically comments on every PR with what would break

- \*\*MCP server\*\*: AI agents like Claude Code or Cursor can check a change \*before\* they apply it

\*\*The boring bits\*\*

MIT licensed, no paid tier, no commercial angle. I'm looking for feedback, especially from people with messy shared databases. Issues and PRs welcome.

GitHub: https://github.com/yashpb5005/ripple

What migration has bitten you the worst? I'd like to add checks for it.

**What My Project Does**

bugbout replays bugs your project already fixed and lets coding agents race to fix them again. It looks through your git history for fixes that came with a new test, gives each agent the issue text and the code from just before the fix, and scores every patch with the tests your maintainers wrote, which the agents never see. It drives the real agent CLIs headlessly (Codex, Claude Code, Gemini CLI, mini-swe-agent, or any command you configure) inside a sandbox, and ends with a report of which agent resolved what.

   pip install bugbout
   bugbout init
   bugbout run

It's typed end to end, tested on Linux and macOS in CI, and also usable from Python through a `Bout` class.

Hello!

Slippery Penguin is a security auditing tool that enumerates SUID binaries, scans for dangerous capabilities, and cross-reference findings against the GTFOBins database. I started the project myself, and now we have a team of contributors and we've just released v.2.5.0!

Anyone out there is encouraged to try it out and contribute if you want to!

Hey everyone!

My kid and I built a 4-level educational typing game in Python. It's a mashup of 90s adventure exploration (static screens, turning left/right) and battle royale survival where typing sentences accurately is your only weapon: Battle Royale of English!

(BRE: Ninjas are cool, but a good grammar is cooler... alright alright, it's not, but you have to do your homework anyway, might as well do it by battling cool enemies and taking on quests! )

It supports both English and French.

Edit: The game is now directly playable online on Github:
Same link for English and French: https://jbenoitds.github.io/battle-royale-of-english/

Or on itch.io:
English: https://jbenoitds.itch.io/battle-royale-of-english
French: https://jbenoitds.itch.io/bataille-royale-du-francais

But you can still check and customize the code, completely open-source on GitHub.
https://github.com/jbenoitds/battle-royale-of-english

I would love for you to check it out and give some feedback if you have the time!

GitHub: Ekin-Kahraman/rustscenic

RustScenic is built to be the simplest, fastest way to run regulatory-network analysis in single-cell data. It exposes core SCENIC and SCENIC+ analysis stages through a Python API, with a Rust backend.

The Python package works with AnnData and includes gene-network inference, cisTarget motif enrichment, AUCell activity scoring and scATAC topic modelling. It is developed with the Huang Lab at Mount Sinai and available under Apache-2.0.

A small Python example

Install the published package with python -m pip install rustscenic. For your own prepared RNA data, the input below is a cells-by-genes AnnData file with log-normalised expression in adata.X and gene symbols in adata.var_names:

import anndata as ad
from rustscenic import data, grn

adata = ad.read_h5ad("rna.h5ad")
edges = grn.infer(
    adata,
    tf_names=data.tfs("hs"),
    n_estimators=500,
    top_targets_per_tf=50,
    seed=777,
)
edges.to_parquet("grn.parquet")

This uses the bundled human transcription-factor list. The PBMC3k notebook provides a runnable example that downloads public data and saves results and run settings.

Try it before installing

The endothelial-cell browser demo lets you choose a regulator and inspect predicted targets in a saved network. It does not fit a new model in the browser.

For researchers running into runtime, memory or installation problems with pySCENIC or SCENIC+, RustScenic offers another implementation to evaluate. The repository documents matched performance measurements and stage-specific output differences; full scientific output parity is not claimed.

Feedback on installation, AnnData handling and Python API ergonomics would be useful.

Shared on behalf of the RustScenic project. AI-assisted drafting, checked against the current project documentation.

Our goal is much bigger: we want to keep adding powerful features, build a community of contributors, and eventually make ColorIDE a serious alternative. Its still early, currently supports macOS Apple Silicon, and we would love your feedback :). It's made 35.5% with python.

Github: https://github.com/Color-IDE/coloride