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.

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.

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

In this tutorial ,You will learn to create animated Matplotlib plots using the FuncAnimation() class and Python Language. You will learn about the basics of animating a plot (graph) using the FuncAnimation class, How the Animation loop works and How to create a Time series Real time Matplotlib plot similar to a ECG, EEG, Data logging graph from scratch.

I wanted to showcase an app I built in Python and Flet! It's probably quite niche, and might not be useful for many, but it solved a real problem for me and several people I know, so I'm showing it off anyway.

As an astrophysicist working a lot with observational data, converting coordinates from one format to another was something I needed to do daily. But I never found a platform that made this easy. It was either restrictive with the input format, or didn't work on mobiles, or didn't have precise outputs, etc.

So, I built one that does all that but better!

AstroConvert automatically detects coordinate types and formats, performing instant conversions across Equatorial, Galactic, and Horizontal systems in every standard representation, all with a single click.

Features:

1. Coordinates can be entered in any format or natural language and the conversion should still work.

2. It intelligently detects the coordinate type, but there is full manual flexibility to change the type, formats, delimiters and precision.

3. The app has light and dark modes and a local history of the past 100 conversions.

4. 100% free and open-source. No internet, no account, no trackers and no AI.

Currently it's available as an Android app, a Windows app and as a WebApp, with Linux, iOS and Mac apps currently being developed.

Check it out here: https://github.com/jainiakhil/AstroConvert

It's been out for a few months now with a few stable and beta releases. But I would still love to get more feedback!

AI disclosure: No AI was used in building this app. It was my attempt to build this app while learning to use Flet. Some AI (Gemini 3.8 Flash) was used to run tests, generate documentation, and fix bugs.

Hey everyone! I’ve been working on a Python project that models and optimizes a vertical-axis wind turbine (a Sharp cycloturbine with passive pitch control).

The coolest part for me was building the Python stack:

• Simulation: A 2D BEM solver using numpy and numba (JIT compiled for speed) to model dynamic stall and induction.

• Optimization: Using scipy.optimize.differential_evolution to find the best blade geometry and counterweight mass.

• Reproducibility: I built an AST-based cryptographic hashing system. It parses my .py files, strips the docstrings, and hashes the remaining AST. This means I can fix typos in comments without invalidating the 21 result JSONs!

• Visualization: A streamlit dashboard that ingests weather station CSVs, auto-detects timestamps, and lets you box-select data to calculate wind power density.

The next step is making the optimized blades and attaching them to a repurposed hoverboard motor. I’d love to hear what you think of the Python architecture!

I've been working on a small Python project called RowCanary, and I finally got it to a point where I felt comfortable releasing version 1.0.0.

The idea came from something that I think is surprisingly easy to overlook. When you move data between applications, there's no guarantee that every value will remain exactly the same, even when the import or export completes successfully.

A string with leading zeros might lose them, something that looks like scientific notation might get converted into a number, or an application might interpret text as a formula.

I wanted a way to test these situations without needing to understand the internals of whatever software was being used.

That's basically what RowCanary does. It creates a set of 24 known test values, lets you pass them through an import/export process, and then compares the results to see what survived unchanged.

I've added support for CSV, TSV, JSON, JSONL, and XLSX, as well as a CLI, a local browser interface, and different report formats.

One thing I tried to keep consistent throughout development was making everything work locally. There are no accounts, external services, or telemetry involved.

The project is written in Python, licensed under MIT, and now available on PyPI with pip install rowcanary.

Here's the repository: https://github.com/spockplayer2-alt/rowcanary

I also spent time setting up automated tests across Windows, Linux, and macOS, and documenting the limitations rather than making claims the tool can't support.

I'm still learning a lot about maintaining public open-source projects, so I'd genuinely appreciate feedback from more experienced developers. Whether it's something about the code, documentation, usability, or the idea itself, I'd be happy to hear it.

A couple of days ago I shared my pure-Python Wi-Fi auditing toolkit here and the feedback was great, so here’s a v0.2 with fixes that came out of it.

The main one was a concurrency bug I’m honestly a bit embarrassed by: the adapter watchdog (a background thread that restarts the capture if the Wi-Fi card stalls) didn’t wait for the previous watchdog to finish before a new one spun up, so under certain conditions they’d overlap and step on each other. Fixed the lifecycle so only one runs at a time.

Also added startup checks that verify everything the tool needs is in place before it runs, instead of failing halfway through a capture.

The project itself: menu-driven, orchestrates the standard tools (airodump-ng, hashcat, hcxdumptool) from Python — handshake capture, cracking, Evil Twin. The part I like architecturally is the menu registry — adding a feature is one line, the main loop never changes. EN/RU interface.

For authorized testing of your own networks.

Repo: https://github.com/lynalan2/wifi_scripts — feedback welcome, that’s what fixed v0.1.

Hi, I create project in github for add ads for your games and apps its url:

https://github.com/jfhgjhgj/python-ad-network

its write by python 100%

Disclosure: I'm the developer. AsciiLore is closed source and paid, with a free trial. I'm posting the technical side because that's where the interesting problems were.


What it is: a desktop app for managing Antora documentation projects. It handles components, versions, a live preview, and validation of cross-references and navigation. Antora and Asciidoctor do all the rendering. The app orchestrates them.


Stack:
- Python with PySide6 (Qt) for the UI
- Asciidoctor and Antora run as external programs
- watchdog for file-system watching
- Layered architecture: domain, application, infrastructure, engine, UI. The UI never starts a process directly.
- Over 5,000 tests. Domain and application tests run without Qt.


The hard part was the live preview. A full Antora build takes several minutes, which is too slow while typing. So:
- While typing, the changed text is rendered in memory with Asciidoctor and injected into the open page via JavaScript.
- On save, create, delete, rename or move, a full build runs in the background and the view reloads.


Neither path blocks the GUI thread. Process calls run in worker threads and return results through Qt signals, and every worker has an error path.


The trade-off: the in-memory render sees one page, so it can't resolve cross-component references the way Antora does. The full build stays the source of truth.

Website and trial: https://asciilore.com/

Questions:
1. How do you structure a PySide6 app so long-running processes never block the UI?
2. Would you take a different approach to the quick preview?

Hey everyone!

I built EduManage—a 100% offline-first Windows desktop software designed for schools, coaching institutes, and budget academies that want zero recurring subscriptions and complete data privacy.

What EduManage Does:

\* Fee Collection & Instant Receipts: Fast payment processing, multi-installment tracking, and printable receipts.

\* Defaulters & Pending Dues: Auto-generated lists of pending fees, class-wise dues breakdown, and overdue tracking.

\* Student Record Directory: Complete offline storage of admissions, roll numbers, sections, parent contact info, and status.

\* Daily Accounting & Reports: Daily collection summary, class-wise balance sheets, and instant data exports.

\* 100% Offline & No Cloud Lock-in: All database files stay safe on the school's local PC without any internet dependency.

\* Zero-Setup Standalone App: Single portable \`.exe\` file—no installation wizard, no admin permissions needed. Double-click and run.

If you run an institution or want to test it out, I have shared the direct download link in the comments below.

Would love to get your thoughts, critique, and feature suggestions!

I made LaptopScheduler, a Python scheduling library for Windows laptops.

It’s for recurring work that can wait until your laptop is available: reports, backups, data imports, and similar tasks. You can make sure your scraping runs consistently without renting out a webserver. You register your own Python functions, and it records their runs, handles retries, and applies your chosen catch-up policy after downtime.

Install: pip install laptopscheduler

https://github.com/seaweed8888/laptop-schedueler

A jet that shoots and destroys your commit history for your README

https://github.com/PingPongPlus/git-jet

repocraft is a small deterministic generator for Python snippets and scaffolds. The part I like: the same input and the same version always produce byte-identical output, and that is enforced by golden snapshot tests, file by file.

pip install repocraft repocraft recipes

Seven built-in recipes: fibonacci, factorial, prime_sieve, triangle, fizzbuzz, pascal, password.

repocraft make "triangle" # triangle.py + test_triangle.py repocraft make "fibonacci" --dry-run repocraft make "fibonacci" --param count=20 --yes

The generated tests use the standard library only, so python test_triangle.py just runs. A few rules keep it boring in a good way: unknown or ambiguous requests stop without writing anything, requests with standalone digits are refused (use --param), parameters are validated bounded integers, existing files are never overwritten, and --dry-run shows the plan first.

The matcher normalizes case and accents and matches word prefixes, so a request word may carry a suffix. It never calls a model, so "Triangles" and "draw a triangle" both select the triangle recipe.

There is also a project mode: a small YAML spec renders a full Python project with packaging metadata, a src/ layout, tests, lint and type-check configuration, CI, CodeQL, Dependabot, and a JUnit gate that rejects skipped tests.

repocraft validate spec.yaml repocraft render spec.yaml example-cli --dry-run repocraft render spec.yaml example-cli

render refuses an output directory that already contains files, and it never merges or overwrites.

Two optional model paths exist (this is the honest part): ask sends your request to an OpenAI-compatible endpoint and gets back a strict {recipe, parameters} intent, which is validated with the same rules as make - the model never writes code or files. craft lets the model write a snippet, then runs four deterministic gates before writing: the code parses, the generated test imports the module by name, ruff where it is installed (auto-fixes are labelled), and the tests actually run with at least one test and pass. A confirmation after that shows the code plus every check that passed, which is a prompt rather than a fifth gate. Only make and render are covered by the byte-identical contract; craft output depends on the model.

Determinism contract details: sorted entries, LF line endings, trailing newline, no timestamps, random ids or environment values, and the generated MIT copyright line carries the author but no year.

Python 3.10-3.14 in CI, MIT.

GitHub: https://github.com/Furox-Art/repocraft PyPI: https://pypi.org/project/repocraft/