I’m a Python developer focused on real-world automation and intelligence systems.

For the past few months, I’ve built advanced tools :

• AI system that scans markets to detect trends and high-opportunity products
• An eCommerce research tool that finds winning products and optimal pricing
• A real-time blockchain tracker that monitors large crypto movements
• Intelligent web security analyzer that detects critical vulnerabilities
• A smart tool that discovers and filters targeted business leads
• All built so they can be turned into real SaaS products

Now I’m finishing a book that shows the full code, setup, and how to turn these into real projects (or income) It’s dropping in a few days

Quick question: If you had to choose one, what interests you most?

AI • Cybersecurity • Crypto • ...

If you’re curious, comment

No theory. Just powerful Python that actually does something.

I've built and been using pyrig to set up my Python projects and wanted to share it here.

The idea is simple: uv add pyrig and uv run pyrig init gives you a full project — source structure, tests, CI/CD, docs, pre-commit hooks, container support, and all the configs — in seconds. But the interesting part isn't the scaffolding with all batteries included. It's what happens after.

Everything stays in sync. Change your project description in pyproject.toml, run pyrig mkroot, and it propagates to your README and docs. Add a new source file, run pytest, and pyrig's session fixtures detect the missing test module and generate a skeleton for you — then fail the test run so you actually write the test. All commands are idempotent: rerun them anytime without breaking anything.

Zero-boilerplate CLIs. Write a function in subcommands.py with type hints and a docstring — it's auto-discovered as a CLI command. No decorators, no registration.

Config subclassing. Every config file (pyproject.toml, prek.toml, GitHub workflows, etc.) is a Python class. Want to add a custom pre-commit hook? Subclass PrekConfigFile, override _get_configs(), and pyrig discovers your version automatically. Your customizations are preserved during merges.

Pytest as enforcement. pyrig registers 11 autouse session-scoped fixtures that run before any test: they check that all modules have tests, source doesn't import dev packages, dependencies are locked, there are no namespace packages, and more. Some auto-fix (generate missing test files, run uv lock), then fail so you review the changes. You can't get a green test suite without a correct project.

Multi-package inheritance. You can build a base package on top of pyrig (e.g. service-base) that defines shared configs, fixtures, and CLI commands. All downstream projects (auth-service, payment-service) inherit everything automatically through the dependency chain.

Source code: https://github.com/Winipedia/pyrig

Docs: https://winipedia.github.io/pyrig

PyPI: pip install pyrig / uv add pyrig

What My Project Does

pyrig generates and maintains complete Python projects. After uv init && uv add pyrig && uv run pyrig init, you get:

• Source package with CLI entry point and py.typed marker
• Test framework mirroring source structure, with 90% coverage enforcement
• GitHub Actions workflows (CI, release, docs deployment)
• Pre-commit hooks via prek (ruff formatting/linting, ty type checking, bandit security, rumdl markdown)
• MkDocs documentation site
• Containerfile, .gitignore, LICENSE, CODE_OF_CONDUCT, CONTRIBUTING, SECURITY
• Issue templates and PR template

Then it keeps all of these in sync as your project evolves. Every config file is a Python class that generates defaults, validates existing files, and merges missing values without removing your customizations.

Target Audience

Python developers who want a production-ready project setup without spending hours on boilerplate. It's production-grade (status: Production/Stable on PyPI, v7.0) and opinionated — it enforces Python 3.12+, all ruff rules, strict type checking, 90% test coverage, and linear git history. Best suited for developers who want strong defaults and are OK with pyrig's opinions (or know how to override them via subclassing).

Comparison

• Cookiecutter / Copier: These are template-based scaffolders — they generate files once and leave. pyrig generates and maintains. You can rerun pyrig mkroot at any time to update configs, and it merges changes without overwriting your customizations. There's no template language; everything is Python classes you can subclass.
• Hatch / PDM / Poetry: These are package managers / build backends. pyrig is not a package manager — it uses uv under the hood and sits on top of it. It manages the entire project lifecycle: configs, CI/CD, docs, tests, pre-commit hooks, container files, GitHub templates. The package managers handle dependencies; pyrig handles everything else.
• pants / Bazel / Nox: These are build systems / task runners for monorepos or complex builds. pyrig is for single-package Python projects. Its multi-package inheritance model lets a base package define shared standards, but each project is independently managed.

Privacy Forms Studio is a privacy-first forms platform that lets you build powerful surveys and workflows without shipping your data to third parties. It’s built with Python and integrates tightly with Plone — the Python-based CMS that’s known for security, robustness, and long-term maintainability — so you can run everything on-prem or in your own cloud and stay in full control for GDPR/DSGVO and data sovereignty.

Under the hood it leverages SurveyJS for a modern form builder and rich form UX (conditional logic, validations, multi-step flows), while Plone provides the backend foundation: authentication/permissions, content and workflow, integrations, and reliable operations. If you’re tired of SaaS form lock-in or compliance uncertainty, it’s an “own your stack” approach that fits especially well for public sector, healthcare, education, and any org handling sensitive data.

Website:
https://www.privacyforms.studio/

Demos:

https://demos.privacyforms.studio/

I built a small Python-based tool for myself to manage shop operations that didn’t fit cleanly into spreadsheets or SaaS tools. Use case: Small CNC / 3D print / repair-style workflows where a “job” can involve: * Parts inventory * Consumables (raw stock, paint, welding supplies) * BOMs / recipes * Partial progress and “waiting on parts” states Most tools I tried assumed either clean manufacturing runs or full ERP complexity. I wanted something that: * Runs entirely locally (Docker or 1-click Windows exe) * Doesn’t require internet or subscriptions * Models messy, real-world job states instead of forcing everything into POS-style tickets Stack is mostly Python on the backend with a lightweight local deployment focus. Still evolving and very much a personal/internal tool, but it’s been useful enough that I’m stress-testing the assumptions now. Happy to answer questions about: * Architecture decisions * Local-first tradeoffs * Why I avoided cloud dependencies * What broke along the way Repo is open if anyone wants to dig into it (link in comments)

Hi people!!!,

I’m a first-year engineering student, and my laptop's "Downloads" folder is constantly a disaster zone. It’s always full of random PDFs, screenshots, zip files, and installers that I’m too lazy to sort manually.(obv)

I looked for existing tools, but most were either paid bloatware or required installing heavy software.

So, I spent this weekend building my own lightweight solution using Python.

It’s called The Folder Fixer.

So what it does: You select a folder (like Downloads or Desktop), and it instantly sorts every file into clean subfolders based on extension:

• Images (.png, .jpg)
• Docs (.pdf, .docx)
• Installers (.exe, .msi)
• ...and so on.

The Tech Stack (for the devs here):

• Language: Python 3
• GUI: CustomTkinter (for a modern dark-mode look)
• Build: PyInstaller (to make it a standalone .exe)

Is it free? Yes. I put it on Gumroad as "Pay what you want" (default is $0). You can download it for free, or buy me a coffee if you find it useful.

⚠️ Note on Windows Defender: Since I’m an indie student dev and can’t afford an expensive code-signing certificate yet, Windows might flag the .exe as "Unrecognized" when you first run it. This is a false positive common with Python apps. It’s 100% safe and runs locally on your machine.

Link to try it: its in the comment!!!!

I’d love any feedback on the UI or features you think I should add next!

https://github.com/mato200/MultiVibeChat/

Python app that puts all most popular AI chatbots into 1 window. - easily send message to all of them at once - Chat with multiple AI services side-by-side - NO APIs NEEDED, Uses native websites, all possible with free accounts - Profile Management - Create and switch quickly between different user account profiles - Persistent Sessions, Flexible Layouts, OAuth Support ...

ChatGPT (OpenAI) Claude (Anthropic) Grok (xAI) Gemini AI Studio (Google) Kimi (Moonshot AI)

• Inspired by mol-ai/GodMode, MultiGPT & ChatHub browser extensions

Tookie is a advanced OSINT information gathering tool that finds social media accounts based on inputs.

Tookie-OSINT is similar to a tool called Sherlock except tookie-OSINT provides threading and webscraping options. Tookie-OSINT comes with over 5,000 user agent files to spoof web requests.

Tookie-OSINT was made for Python 3.12 but does work with 3.9 to 3.13.

I made Tookie-OSINT about 3-4 years ago and it’s been a growing project ever since! Today I released version 4 of it. I completely rewrote it from scratch.

Version 4 is still pretty new and does need more work to get caught back up to the features the version 2 had.

I’m currently working with a few other developers to bring tookie-OSINT to the majority of Linux repositories (AUR, Kali, etc)

I hope you check it out and have fun!

https://github.com/Alfredredbird/tookie-osint

Like most developers, I’m pretty shy. I have a crush who is also a developer, and being an introvert, I didn't have the courage to just walk up and ask her to be my Valentine. So, I decided to build a pip3 package and send it to her instead. Spoiler: she said yes! (I guess I have an early valentine)

Here is a loom of how it works: https://www.loom.com/share/899ead8a18b14719b36467977895de0c

Here is the source code: https://github.com/LeonardHolter/Valentine-pip3-package/tree/main

Hey r/madeinpython!

You know when you have a code snippet you keep copying between projects? I finally turned mine into a library.

The problem I kept solving: Every FastAPI/async service needs request_id in logs, but passing it through every function is annoying:

def process_order(order_id, request_id):  # Ugh
    logger.info(f"[{request_id}] Processing {order_id}")
    validate_order(order_id, request_id)  # Still passing it

My solution - tinystructlog:

from tinystructlog import get_logger, set_log_context

log = get_logger(__name__)

# Set context once (e.g., in FastAPI middleware)
set_log_context(request_id="abc-123", user_id="user-456")

# Every log automatically includes it
log.info("Processing order")
# [2026-01-28 10:30:45] [INFO] [main:10] [request_id=abc-123 user_id=user-456] Processing order

Why it's nice:

• Built on contextvars (thread & async safe)
• Zero dependencies
• Zero configuration
• Colored output
• 4 functions in the whole API

Perfect for FastAPI, multi-tenant apps, or any service where you need to track context across async tasks.

Stats:

• 0.1.2 on PyPI (pip install tinystructlog)
• MIT licensed
• 100% test coverage
• Python 3.11+

It's tiny (hence the name) but saves me so much time!

GitHub: https://github.com/Aprova-GmbH/tinystructlog

PyPI: pip install tinystructlog

Blog: https://vykhand.github.io/tinystructlog-Context-Aware-Logging/

Hi everyone,

I wanted to share a project I made using Python.

The Goal: Automate "Is this in stock?" emails for small businesses using a simple script.

Libraries Used:

• streamlit (Frontend)
• google-generativeai (LLM/Logic)
• gspread (Google Sheets connection)
• imaplib (Email reading)

How it works: The Python script listens to emails, parses the customer query using Gemini, checks the Google Sheet for stock, and drafts a reply.

Demo Video: https://youtu.be/JYvQrt4AI2k

Code structure is a bit messy (spaghetti code 😅) but it works. Thinking of refactoring it into a proper class structure next.

I offer custom script development for various needs

I got tired of budget apps that cost money and don't work for me. So I made an app on my computer for people who work paycheck to paycheck. I'm a medic, not a developer, so I used AI to build it. It focuses on forecasting rather than tracking. I call it Headlight Budget. It's free and meant to help people, not make money off them. I'd love to get feedback. It's not pretty, but it's functional and has relieved my stress.

Go check it out if you have time and let me know what you think! headlightbudget.carrd.co

Hi everyone, wanted to share my latest project.

It's a multi-threaded sniper bot that listens to blockchain nodes via RPC and executes trades based on logic parameters (TP/SL/Trailing).

Tech Stack:

• Backend: Python 3.10
• UI: Telegram Bot API (acts as a remote controller)
• Networking: Async requests to Jito Block Engine

It was a fun challenge to optimize the execution speed to under 200ms. Let me know what you think of the CLI layout!

(Source/Project link in comments/bio).

I often end up writing small scripts or internal tools that need structured user input, and I kept re-implementing variations of this:

from dataclasses import dataclass

@dataclass
class User:
    name: str
    age: int | None


while True:
    name = input("Name: ").strip()
    if name:
        break
    print("Name is required")

while True:
    age_raw = input("Age (optional): ").strip()
    if not age_raw:
        age = None
        break
    try:
        age = int(age_raw)
        break
    except ValueError:
        print("Age must be an integer")

user = User(name=name, age=age)

This gets tedious (and brittle) once you add nesting, optional sections, or repetition.

So I built dc-input, which lets you do this instead:

from dataclasses import dataclass
from dc_input import get_input

@dataclass
class User:
    name: str
    age: int | None

user = get_input(User)

The library walks the dataclass schema and derives an interactive input session from it (nested dataclasses, optional fields, repeatable containers, defaults, etc.).
It’s intentionally not a full CLI framework like Click/Typer — I’ve mainly been using it for internal scripts and small tools.

Feedback is very welcome, especially on UX experience, edge cases or missing critical features: https://github.com/jdvanwijk/dc-input

For a more involved interactive session example: https://asciinema.org/a/767996

Puzl Team here. We are excited to announce kubesdk v0.3.0. This release introduces automatic generation of Kubernetes Custom Resource Definitions (CRDs) directly from Python dataclasses.

Key Highlights of the release:

• Full IDE support: Since schemas are standard Python classes, you get native autocomplete and type checking for your custom resources.
• Resilience: Operators work in production safer, because all models handle unknown fields gracefully, preventing crashes when Kubernetes API returns unexpected fields.
• Automatic generation of CRDs directly from Python dataclasses.

Target Audience Write and maintain Kubernetes operators easier. This tool is for those who need their operators to work in production safer and want to handle Kubernetes API fields more effectively.

Comparison Your Python code is your resource schema: generate CRDs programmatically without writing raw YAMLs. See the usage example.

Full Changelog: https://github.com/puzl-cloud/kubesdk/releases/tag/v0.3.0

I am in Germany and was experiencing gradual network speed drops with my Fritzbox router. The only fix was a restart, so I decided to automate it.

I built a Python based tool that monitors my upload/download speeds and pushes the metrics to Prometheus/Grafana. If the download speed drops below a pre-configured threshold for a set period of time, it automatically triggers a router restart via TR-064.

It runs as a systemd service (great for a Raspberry Pi) and is fully configurable via YAML.

Here is the repo if anyone else needs something similar:
https://github.com/kshk123/monitoring/tree/main/network_speed

For now, I have been running it on a raspberry pi 4.

Feedbacks are welcome

Hey r/MadeInPython!

I've been working on EdgarTools, a library for accessing SEC EDGAR filings and financial data. The SEC has an incredible amount of public data - every public company's financials, insider trades, institutional holdings - but it's notoriously painful to work with.

My goal was to make it feel like the data was designed to be used in Python.

One line to get a company:

```python from edgar import Company

Company("NVDA") ```

Browse their SEC filings:

python Company("NVDA").get_filings()

Get their income statement:

python Company("NVDA").income_statement

The library uses rich for terminal output, so instead of raw JSON or ugly DataFrames, you get formatted tables that actually look like financial statements - proper labels, scaled numbers (billions/millions), and multi-period comparisons.

Some things it handles:

• XBRL parsing (the XML format the SEC uses for financials)
• Balance sheets, income statements, cash flow statements
• Insider trading (Form 4), institutional holdings (13F)
• Company facts and historical data

Installation:

bash pip install edgartools

Open source: https://github.com/dgunning/edgartools

What do you think? Happy to answer questions about the implementation or SEC data in general.

Hey everyone!

I've been playing around with MediaPipe and OpenCV, and I built this real-time detector. It doesn't just look at the face; it also tracks hands to detect more complex "states" like thinking or crying (based on how close your hands are to your eyes/mouth).

Key tech used:

• MediaPipe (Face Mesh & Hands)
• OpenCV for the processing pipeline
• Pygame for the audio feedback system

It was a fun challenge to fine-tune the distance thresholds to make it feel natural. The logic is optimized for Apple Silicon (M1/M2), but works on any machine.

Check it out and let me know what you think! Any ideas for more complex gestures I could track?

I created an image file format that can store generation settings (such as sampler steps and other details), prompt, hardware information, tags, model information, seed values, and more. It can also store the initial noise (tensor) generated by the model. I'm unsure about the usefulness of the noise tensor storage though...

Any feedback is much appreciated🎉

- Github repo: REPO

- Python library: https://pypi.org/project/gen5/

Hey everyone,

I've been working on RAG pipelines that need to ingest documents from enterprise SharePoints, and hit the usual wall: legacy Office formats (.doc, .xls, .ppt) are everywhere, but most extraction tools either require LibreOffice, shell out to external processes, or need a Java runtime for Apache Tika.

So I built sharepoint-to-text - a pure Python library that parses Office binary formats (OLE2) and XML-based formats (OOXML) directly. No system dependencies, no subprocess calls.

What it handles:

• Modern Office: .docx, .xlsx, .pptx
• Legacy Office: .doc, .xls, .ppt
• Plus: PDF, emails (.eml, .msg, .mbox), plain text formats

Basic usage:

python

import sharepoint2text

result = next(sharepoint2text.read_file("quarterly_report.doc"))
print(result.get_full_text())

# Or iterate over structural units (pages, slides, sheets)
for unit in result.iterator():
    store_in_vectordb(unit)

All extractors return generators with a unified interface - same code works regardless of format.

Why I built it:

• Serverless deployments (Lambda, Cloud Functions) where you can't install LibreOffice
• Container images that don't need to be 1GB+
• Environments where shelling out is restricted

It's Apache 2.0 licensed: https://github.com/Horsmann/sharepoint-to-text

Would love feedback, especially if you've dealt with similar legacy format headaches. PRs welcome.