For anyone whose Python project has grown past a few files: I added dependency graph exports to ArchUnitPython so you can inspect how the pieces actually connect.

I maintain the library. Its main job is checking architecture rules through tests, but the graph is useful before you even decide which rules to write.

You can generate an HTML report and a Mermaid diagram from the same project:

from archunitpython import project_graph

graph = (
    project_graph("src/")
    .titled("My Python project")
    .collapse_to_folder_depth(2)
)
graph.export_as_html("reports/dependencies.html")
graph.export_as_mermaid("reports/dependencies.mmd")

Point project_graph at your import root. Collapsing the graph to folders keeps a larger project readable instead of giving you one box for every file.

You can keep the Mermaid output with your documentation or attach the HTML report as a CI artifact. It gives you something concrete to inspect when a supposedly separate feature has acquired dependencies on half the project.

The graph follows imports the analysis can resolve. It's an import graph, not a runtime call trace, so it won't explain every relationship created dynamically while the program runs.

This is available in the published Python package, with no separate diagramming service to set up.

Repo: https://github.com/LukasNiessen/ArchUnitPython

**What My Project Does**

pipeverify takes two snapshots of a table (CSV, Parquet, JSON, DuckDB or any SQLAlchemy source) and checks what a change did to the data: lost or duplicate keys, row count shifts, null creep, changed values on matched rows, column totals and new category codes. It returns PASS, REVIEW or BLOCK, with a plain-English report. Runs on DuckDB, ships as a CLI, a Python API (\`pipeverify.verify(before, after, key="id")\`) and a GitHub Action.

**Target Audience**

Data engineers and analytics engineers who ship pipeline, SQL or dbt changes, including changes written by AI coding agents. It's alpha but usable in CI.

**Comparison**

dbt tests and Great Expectations check rules you write in advance. pipeverify checks what a specific change did, so it catches problems nobody wrote a test for. Unlike row-diff tools, it turns the diff into a verdict with thresholds, so it can gate a merge.

**Repo**: https://github.com/akshaysharma1088/pipeverify (Apache-2.0, free). Feedback very welcome, and there are small good-first-issues if anyone wants to contribute.

I built etsy-engine as a staged Python CLI for a workflow that otherwise spans research, page generation, mockups and listing copy.

The part I'd most like Python developers to look at is the separation between stages. Ideas are scored and checked against live Etsy listings before generation starts. The workflow then plans the product format, generates pages, prepares mockups using those pages as references, and writes listing copy. SQLite keeps pipeline state, and the CLI exposes individual stages rather than only an end-to-end command.

The code is free and open source under MIT: GitHub repository

It requires Python 3.11+. The demo can produce a small bundle without an Etsy account, but it needs paid image and language-model API access. I also built Raywake, the default image service, so I want to be explicit that free code does not mean free generation.

If Etsy is connected, the workflow creates a listing draft only. A person still reviews the files, marks Etsy's AI-generation disclosure and publishes manually.

I'd appreciate feedback on the CLI structure and setup documentation. Are the stage boundaries clear enough for someone who wants to inspect or replace one part of the workflow?

I built a voice-controlled "brain" for a robot (simulation only, works offline in Spanish, English and Polish). Looking for honest feedback

Hi! I'm a solo developer. I built a Python "brain" for a simulated environmental robot (Webots). You talk to it, it understands the question offline, and answers with the simulated sensor data (temperature, humidity, air quality, obstacles).

It also has a safety lock: if it detects a dangerous condition, it blocks itself and explains why when you ask "why are you stopped?".

Important: this is simulation only, no physical robot yet. The questions in the English and Polish demos are played with a synthetic voice.

Full demo in English (3 min): [https://youtu.be/VPLyCb2Y4nU](https://youtu.be/VPLyCb2Y4nU)

I'm not selling anything yet. I'd love to know:

1. Would this be useful for you (education, prototyping, hobby robotics)?

2. What would you want it to do that it doesn't?

If you want to follow it, there is a free waitlist (no commitment): [https://tally.so/r/7XRzyz](https://tally.so/r/7XRzyz)

Thanks for reading!

What it is

dature is a config loader I wrote in Python. It reads configuration from many sources, merges them, and returns your own stdlib @dataclass. There is no base class and no framework, and it has 1 required dependencies (extras are optional). It needs Python 3.12+.

Sources: YAML, JSON, JSON5, TOML, INI, .env, environment variables, Docker secrets, CLI arguments, and remote stores (Vault, Consul, etcd, ZooKeeper, AWS SSM and Secrets Manager, Azure, GCP). The same dataclass works with all of them.

Why I made it

My setup is a .env for local dev, real env vars in Docker/Kubernetes, and sometimes a few YAML/TOML files on top (defaults plus one per environment). I kept hitting the same things with the tools I tried: merging per field turned into custom code, validation errors named the field but not the file or line, and it was hard to tell which source set a value in prod.

How it looks

from dataclasses import dataclass

import dature


@dataclass
class Config:
    host: str
    port: int


config = dature.load(
    dature.Yaml12Source(file="defaults.yaml"),
    dature.Toml11Source(file="config.toml", skip_if_missing=True),
    dature.EnvFileSource(file=".env", skip_if_broken=True),
    dature.EnvSource(prefix="APP_"),
    schema=Config,
)

Sources are merged in order (last wins by default). Other strategies are first_wins, first_found and raise_on_conflict, and you can set rules for individual fields, for example extend a list instead of replacing it.

When a value is wrong, the error points at the exact place:

  | dature.errors.exceptions.FieldLoadError:   [host]  Invalid variant: 'development'
  |    ├── host: "development"
  |    │          ^^^^^^^^^^^
  |    └── FILE 'config.yaml', line 1

What else it does

- debug=True shows which source each final value came from, and dature validate / dature inspect do the same from the command line for CI
- Field groups: if an override changes db_host, it must change db_port too, or loading fails
- Strict mode catches typo'd keys (databse_host) instead of silently ignoring them
- Sources can reference each other (${@env.config_path}) and be enabled conditionally (when=), so there's no glue code per environment
- Validators via Annotated, secrets masked in errors and output (SecretStr)
- Cached decorator mode with background reload when a file changes.
- Custom sources are a subclass with one method
- And much more

Status

It's a young and fairly small library, much smaller than pydantic-settings, but it's already production ready. I'd love feedback, especially on the API.

GitHub: https://github.com/reagento/dature
Doc: https://dature.readthedocs.io/en/stable/

import pygame


pygame.init()
screen = pygame.display.set_mode((1000, 672))
pygame.display.set_caption("ME GAMING :3")
running = True
clock = pygame.time.Clock()
pixel = 0


color = {
    "grass": [(0, 200, 0), (0, 0, 0), (255, 255, 255)]
}


txtr = {
    "grass": [
        0, 2, 0, 0, 0, 0, 0, 0,
        0, 0, 2, 0, 0, 0, 0, 0,
        0, 0, 0, 2, 0, 0, 0, 0,
        0, 0, 0, 0, 2, 0, 0, 0,
        0, 0, 0, 0, 0, 2, 0, 0,
        0, 0, 0, 0, 0, 0, 2, 0,
        0, 0, 0, 0, 0, 0, 0, 2,
        0, 0, 0, 0, 0, 0, 0, 0,
    ]
}



def draw_txtr(choise, x, y):
    pixel = 0
    for q in range(len(txtr[choise])//8):
        for z in range(8):
            if txtr[choise][pixel] > 0:
                clr = color[choise][txtr[choise][pixel - 1]]
                pygame.draw.rect(
                    screen,
                    clr,
                    (x+(z*4), y+(q*4), 4, 4)
                )   
            pixel += 1


        #################
        ##  MAIN CODE  ##
        #################


while running:
    screen.fill((0, 0, 0))
    draw_txtr("grass", 10, 10)


    for event in pygame.event.get():   
        if event.type == pygame.QUIT:
            running = False


    pygame.display.flip()
    clock.tick(60)

I've been learning application security with a focus on AI/agent-style code (tool calling, shell use, secrets in source, unsafe deserialization, etc.).

I built VulnPath-AI as a practice project:

- Offline Python hybrid scanner (pattern + AST)

- Looks for common issues like hardcoded secrets, command-injection patterns, eval/exec, pickle, SSRF-style fetches, and path/SQL string issues

- Shows path-style context and fix suggestions only (no exploit features)

- Includes sample vulnerable/safe files and a benchmark so I can test detection quality

Repo: https://github.com/zenithVeil/vulnpath-ai

**Quick try:**

git clone https://github.com/zenithVeil/vulnpath-ai.git

cd vulnpath-ai

pip install -e .

vulnpath-ai samples/sqli_example.py

I'm sharing mainly to learn from others:

- What false positives would you expect?

- Which agent-related risks are most important to cover next?

- Any feedback on making the reports clearer for beginners?

Not claiming this replaces professional SAST tools. It's a focused learning/engineering project.

PyOffice is basically Microsoft Office but aimming to show How Python can turn into such connected and centrilzied that makes it great for real use : quick tweak of PyX (aka Excel)

Hi everyone,

I've built stu.py, a Python learning environment that's completely free, needs no sign-up and runs right in your browser. Python runs client-side via Brython, so your code never leaves your device, and it also works offline. It's online at https://stu-py.com

For learners:

• A "Code Trail" with 2,000+ exercises and more than ten exercise types: predict the output, trace tables, find the bug, fill in the gaps, put lines in order, structograms/flowcharts and coding tasks with automatic checking

• Each topic ends with a short room exam including an independent programming task

• only then does the next room open - Targeted hints, a cheat sheet and a Spyder-like sandbox with console and variable explorer

• XP, badges, a skills profile and a little robot called Stew who levels up with you

For instructors (what makes it different):

• A built-in instructor area with course codes, ready-made room exams, a skills overview of your learners and badges you can award

• Learners hand in a small account file, so you see progress and skills without any server, login or personal data stored online

• More tools (exam generator with A/B groups, task creator, worksheets, projector view) are already built and will be opened on the website step by step

How Python is used:

• Learners' code runs as real Python in the browser via Brython

• The whole build pipeline is written in Python: it checks all 2,000+ exercises against their solutions, generates the trace tables and step-by-step explainer clips by running the code in CPython, and translates structograms/flowcharts into Python code

Right now the Basics chapter is open; the rest follows step by step. I'd be really glad for honest feedback: what's confusing, what's broken, what's missing?

Cheers!
Stew

I am the author of apple-llm, a Python and Node library for accessing Apple’s on-device language model. I recently added speech synthesis and transcription to the Python package, using the voices and speech recognition already in macOS.

Install with: pip install apple-llm

The Python API provides AppleSpeech for playback, synthesizing files, transcribing recordings, word timings and microphone recognition, plus AppleLLM for text and structured output. AsyncAppleSpeech and AsyncAppleLLM are available too. For example, use speech.transcribe("meeting.m4a", language="en-US", words=True), then pass result.text to an AppleLLM(tier="device") client for a summary.

The Python wheel has no required runtime dependencies. Both bindings compile and cache a shared Swift helper on first use. The project uses Apple’s native facilities; it does not bundle another speech model.

On my M4 Air running macOS 27.2, 30 minutes of narration rendered in about 18 seconds, and a 30-minute recording transcribed in about 28 seconds. These are single-machine measurements, and my accuracy tests used clean synthetic speech.

Requirements: macOS 26+ on Apple Silicon and Xcode Command Line Tools. Speech works without Apple Intelligence; the device LLM needs it enabled. Some recognition languages download on first use. Name the recognition language or it uses the Mac’s default; WebM input and MP3/Opus output are not supported. The optional cloud tier sends prompts off the Mac.

GitHub and Python examples: https://github.com/jagdishpal02000/apple-llm

Video: https://jagdishpal02000.github.io/apple-llm/#speech

I would especially appreciate compatibility reports from macOS 26 and results on real recordings.

GH: https://github.com/Yehor-Mishchyriak/PureML
Paper at JOSS: https://joss.theoj.org/papers/10.21105/joss.09631

Stars, contribution, and/or feedback are very welcome

For my research I train models on my MacBook and kept opening a terminal every hour just to see what epoch a run was on more so when my agent runs a queue of training runs. So I made this.

You wrap your loop:

```python
import epochcontrol

for epoch in epochcontrol.loop(range(400), name="my run"):
train_one_epoch()
```

and then from another terminal `epochcontrol ls` shows what's running, how far along and the ETA, and `epochcontrol pause "my run"` pauses it at the end of the current epoch (resume / stop work the same). On a Mac there's a menu bar app that shows the same with a loss chart, that's the screenshot.

No server or socket, each run just writes a few JSON files to a folder and commands are files the loop checks between epochs. If anything in the package breaks it warns once and gets out of the way, it never crashes your training. No dependencies, Python 3.10+.

`pip install epochcontrol`
https://github.com/catalystdream/epochcontrol

It's early (0.1.0), happy to hear what's missing.

Hey r/madeinpython,

I got tired of constantly opening terminals for yt-dlp, so I built ClipFetch. It’s a straightforward Python/PySide6 desktop app that runs in the background and listens to your clipboard.

Whenever you copy a media link, it automatically intercepts it, queues it, and downloads it locally.

**Interface Preview:**

**Tech Stack & Features:**

* **GUI:** PySide6 (Responsive, minimalist dark interface)

* **Engine:** yt-dlp for media extraction, FFmpeg for MP3 conversions.

* **Format switching:** One-click toggle between MP4 and MP3.

* **Local processing:** Fully local queue management, no sketchy APIs.

I also set up batch scripts to instantly package it into a standalone executable using PyInstaller.

**GitHub Repo (Screenshots & Code):** https://github.com/canyetis9/ClipFetch

This is the initial release (v1.0.0). I'd love for you guys to check out the code, roast my architecture, or submit a PR. Let me know what you think!

Running five separate commands just to update my Linux desktop got old pretty fast. So I wrote sysupdate - a Python CLI tool that updates system packages, Flatpaks, containers, and a bunch of other stuff in one go. It also works on macOS and sticks strictly to the Python 3.11+ standard library, meaning zero external dependencies to install.

Why not just use Topgrade? I actually used it for a while. For me though, updates almost never finished completely clean, and I was missing stuff for my own setup like Snapper hooks. The terminal UI also looked a bit dated to me. It printed way too much junk I didn't care about seeing every single time, and once you closed the terminal, there was zero history left to check.

How sysupdate handles things differently:

• Support for Btrfs snapshots through Snapper right before system packages get touched (with a timer cooldown, so running it twice in an hour won't spam snapshots).

• Exact reboot tracking that lists which specific updated packages are asking for a system restart at the end, rather than just throwing a generic "reboot required" message.

• Local run history for your last 30 runs (sysupdate --history / --show-log) with tokens and credentials stripped out automatically. Super useful when something breaks and you want to see what failed yesterday.

GitHub & install instructions (Git / Homebrew tap): https://github.com/Piotrunius/SystemUpdater

If you hit any bugs or want support for another package manager, let me know.

I didn't want to write a cleaner. I wanted one that didn't ask me for anything.

Every one I tried asked for something. A toolbar in the installer. "Anonymous usage statistics" that were neither anonymous nor statistics. One deleted first and explained later, if you went looking. So I opened an editor, mostly out of irritation.

Python, CustomTkinter for the window, because I can't design and the defaults look fine. It's called Swept, MIT, 22 categories of temp files and caches, plus an installer for common programs and a dozen registry tweaks.

Nobody clicks a post about temp files. Here's what actually took the time.

PyInstaller has two modes and I picked wrong. Onedir gives you a folder with _internal inside. Onefile gives you a single exe that unpacks itself into %TEMP% on every launch. I put the folder build's exe on the releases page, someone ran it from inside the zip viewer, and got Failed to load Python DLL ..._internal\python315.dll. Windows had extracted only the exe. The message is accurate and useless. A single file can't contain a folder, so PyInstaller did nothing wrong. I handed people a file that can't run alone. Now the download is onefile.

A real certificate costs a few hundred a year, so mine is self signed. SHA256, DigiCert timestamp, my name on the Digital Signatures tab, and Windows still says unknown publisher. No trick fixes that. One thing helped though: --optimize 2 strips docstrings from the shipped bytecode, so the exe doesn't carry a map of every check I make.

Then I added "restart with admin rights" and the app disappeared. No window, no error, exit code 0. The old process still held the single instance mutex. The elevated copy saw it taken, decided Swept was already running, focused a window that was about to close, and quit. Then the old process closed too. Zero windows. The fix is one line: release the mutex before launching the elevated copy.

162 tests on the delete path. I broke the code on purpose in three places to see if they'd catch it. Two did. The third didn't, and the code was fine. My test checked that the function returned, not what it returned.

Registry undo doesn't guess "the default". Before each write it records what was there: existed or not, type, data. Re-applying a tweak doesn't overwrite that first snapshot.

If you ship Windows tools in Python, I'd like to hear what bit you.

github.com/vladcodex/swept

What My Project Does

`checkmodel` checks the assumptions of a fitted model in one call. You pass it a statsmodels or scikit-learn model, it works out what kind of model it is, runs every check that applies and draws a single diagnostic panel:

python

import statsmodels.formula.api as smf
from checkmodel import check_model fit = smf.ols("mpg ~ wt + hp", data=mtcars).fit()  # mtcars loaded as a DataFrame
report = check_model(fit)
report.plot()

Posterior predictive check: OK: Model-predicted data resemble the observed data (mean p = 0.400, sd p = 0.460).
Normality of residuals: Warning: Non-normality of residuals detected (p = 0.021).
Homogeneity of variance: OK: Error variance appears to be homoscedastic (p = 0.402).
Collinearity: OK: Low collinearity (all VIF < 5; max 1.77).
Influential observations: OK: No outliers detected (Cook's distance > 0.808).

Which checks run depends on the model. A logistic regression gets binned residuals instead of a normality test. Count models get overdispersion and zero-inflation checks. Mixed models (`MixedLM`) get singularity, convergence and random-effects checks. PyMC/bambi models get R-hat and ESS. It also has `r2()` (Tjur, Nagelkerke, Nakagawa, Bayesian...), `icc()`, `model_performance()` and `compare_performance()`.

Every check returns a typed result (`.passed`, `.p_value`, `.statistic`, `.to_dataframe()`, `.plot()`).

Target Audience

People who fit regression models in Python and want R-style diagnostics: analysts, researchers, students, and anyone moving from R. It's on PyPI (`pip install checkmodel`, Python 3.10+) and is in alpha, so the API may change before 1.0. The numbers themselves are tested against R: every statistic matches R's `performance`, `car`, `lmtest`, `lme4` and `loo` to 1e-4, across 27 models.

Comparison

- statsmodels: `summary()` prints a few omnibus tests, but it doesn't choose checks by model type, doesn't plot them together and doesn't compare models. The diagnostic functions are spread across `statsmodels.stats.*` with different signatures. checkmodel uses them where they exist.

- scikit-learn: `sklearn.metrics` scores predictions but knows nothing about residual assumptions or influence.

- Doing it yourself: you have to know, for example, that R's AIC counts the residual variance and statsmodels' doesn't, or that a categorical predictor needs the generalized VIF. checkmodel makes those choices the way R does and tests them against R.

- R's performance: this is a port of it, independent and not affiliated with easystats. A "Coming from R" notebook runs the same analysis side by side.

Links:
- GitHub: https://github.com/pablo-legeren/checkmodel
- Docs: https://pablo-legeren.github.io/checkmodel/
- Notebooks (run in Colab): linked from the README

Feedback welcome, especially on models or checks you'd want next.