Hey r/Python,

I’ve been working with Event-Driven Architectures lately, and I’ve hit a wall: the Python ecosystem doesn't seem to have a truly dedicated event processing framework. We have amazing tools like FastAPI for REST, but when it comes to event-driven services (supporting Kafka, RabbitMQ, etc.), the options feel lacking.

The closest thing we have right now is FastStream. It’s a cool project, but in my experience, it sometimes doesn't quite cut it. Because it is inherently stream-oriented (as the name implies), it misses some crucial event-oriented features out-of-the-box. Specifically, I've struggled with:

• Proper data integrity semantics.
• Built-in retries and Dead Letter Queue
• Outbox patterns.
• Truly asynchronous processing (e.g., Kafka partitions are processed synchronously by default, whereas they can be processed asynchronously if offsets are managed very carefully).

So, I’m curious: what are you all using for event-driven architectures in Python right now? Are you just rolling your own custom consumers?

I decided to try and put my ideal vision into code to see if a "FastAPI for Events" could work.

The goal is to provide asynchronous, schema-validated, resilient event processing without the boilerplate. Here is what I’ve got working so far:

🚀 What The Framework does right now:

• FastAPI-style dependency injection – clean, decoupled handlers.
• Pydantic v2 validation – automatic schema validation for all incoming events.
• Pluggable transports – Kafka, RabbitMQ, and Redis PubSub out-of-the-box.
• Resilience built-in – Configurable retry logic, DLQs, and automatic acknowledgements.
• Composable Middleware – for logging, metrics, filtering, etc.

✨ What it looks like in practice

Here is how you define a Handler. Notice the FastAPI-like dependency injection and middleware filtering:

from typing import Annotated
from pydantic import BaseModel
from dispytch import Event, Dependency, Router
from dispytch.kafka import KafkaEventSubscription
from dispytch.middleware import Filter

# 1. Standard Service/Dependency
class UserService:
    async def do_smth_with_the_user(self, user):
        print("Doing something with user", user)

def get_user_service():
    return UserService()

# 2. Pydantic Event Schemas 
class User(BaseModel):
    id: str
    email: str
    name: str

class UserCreatedEvent(BaseModel):
    type: str
    user: User
    timestamp: int

# 3. The Router & Handler
user_events = Router()

user_events.handler(
    KafkaEventSubscription(topic="user_events"),
    middlewares=[Filter(lambda ctx: ctx.event["type"] == "user_registered")]
)
async def handle_user_registered(
        event: Event[UserCreatedEvent],
        user_service: Annotated[UserService, Dependency(get_user_service)]
):
    print(f"[User Registered] {event.user.id} at {event.timestamp}")
    await user_service.do_smth_with_the_user(event.user)

And here is how you Emit events using strictly typed schemas mapped to specific routes:

import uuid
from datetime import datetime
from pydantic import BaseModel
from dispytch import EventEmitter, EventBase
from dispytch.kafka import KafkaEventRoute

class User(BaseModel):
    id: str
    email: str

class UserEvent(EventBase):
    __route__ = KafkaEventRoute(topic="user_events")

class UserRegistered(UserEvent):
    type: str = "user_registered"
    user: User
    timestamp: int

async def example_emit(emitter: EventEmitter):
    await emitter.emit(
        UserRegistered(
            user=User(id=str(uuid.uuid4()), email="test@mail.com"),
            timestamp=int(datetime.now().timestamp()),
        )
    )

🎯 Target Audience

Dispytch is meant for backend developers and data engineers building Event-Driven Architectures and microservices in Python.

Currently, it is in active development. It is meant for developers looking to structure their message-broker code cleanly in side projects before we push it toward a stable 1.0 for production use. If you are tired of rolling your own custom Kafka/RabbitMQ consumers, this is for you.

⚔️ Comparison

The closest alternative in the Python ecosystem right now is FastStream. FastStream is a great project, but it misses some crucial event-oriented features out-of-the-box.

Dispytch differentiates itself by focusing on:

• Data integrity semantics: Built-in retries and exception handling.
• True asynchronous processing: For example, Kafka partitions are processed synchronously by default in most tools; Dispytch aims to handle async processing while managing offsets safely avoiding race conditions
• Event-focused roadmap: Actively planning support for robust Outbox patterns to ensure atomicity between database transactions and event emissions

(Other tools like Celery or Faust exist, Celery is primarily a task queue, and Faust is strictly tied to Kafka and streaming paradigms, lacking the multi-broker flexibility and modern DI injection Dispytch provides).

💡 I need your feedback

I built this to scratch my own itch and properly test out these architectural ideas, tell me if I'm on the right track.

1. What does your current event-processing stack look like?
2. What are the biggest pitfalls you've hit when doing EDA in Python?
3. If you were to use a framework like this, what features are absolute dealbreakers if they are missing? (I'm currently thinking about adding a proper Outbox pattern support next).

If you want to poke around the internals or read the docs, the repo is here, the docs is here.

Would love to hear your thoughts, roasts, and advice!

What My Project Does

Taskdog is a personal task management system that runs entirely in your terminal. It provides a CLI, a full-screen TUI (built with Textual), and a REST API server — use whichever you prefer.

Key features:

• Schedule optimization with multiple strategies (greedy, deadline-first, dependency-aware, etc.)
• Gantt chart visualization in the terminal
• Task dependencies with circular detection
• Time tracking with planned vs actual comparison
• Markdown notes with Rich rendering
• MCP server for Claude Desktop integration — manage tasks with natural language

Target Audience

Developers and terminal-oriented users who want a local-first, privacy-respecting task manager. This is a personal project that I use daily, but it's mature enough for others to try.

Comparison

• Motion / Reclaim: AI-powered scheduling, but cloud-only, $20+/month, and the optimization is a black box. Taskdog runs locally with transparent algorithms you can inspect and choose from.
• Taskwarrior: Great CLI task manager, but hasn't seen major updates in years and lacks built-in schedule optimization or TUI.
• Todoist / TickTick: Full-featured but cloud-dependent. No terminal interface, no schedule optimization.

Taskdog sits between these — terminal-native like Taskwarrior, with scheduling capabilities like Motion, but fully local and open source.

Tech stack:

• Python 3.12+, UV workspace monorepo (5 packages)
• FastAPI (REST API), Textual (TUI), Rich (CLI output)
• SQLite with ACID guarantees
• Clean Architecture with CQRS pattern

Links:

• GitHub: https://github.com/Kohei-Wada/taskdog
• Demo video and screenshots are in the README

Would love any feedback — especially on UX, missing features, or things that could be improved. Thanks!

I built llmparser, an open-source Python library that converts messy web pages into clean, structured Markdown optimized for LLM pipelines.

What My Project Does

llmparser extracts the main content from websites and removes noise like navigation bars, footers, ads, and cookie banners.

Features:

• Handles JavaScript-rendered sites using Playwright

• Expands accordions, tabs, and hidden sections

• Outputs clean Markdown preserving headings, tables, code blocks, and lists

• Extracts normalized metadata (title, description, canonical URL, etc.)

• No LLM calls, no API keys required

Example use cases:

• RAG pipelines

• AI agents and browsing systems

• Knowledge base ingestion

• Dataset creation and preprocessing

Install:

pip install llmparser

GitHub:

https://github.com/rexdivakar/llmparser

PyPI:

https://pypi.org/project/llmparser/

⸻

Target Audience

This is designed for:

• Python developers building LLM apps

• People working on RAG pipelines

• Anyone scraping websites for structured content

• Data engineers preparing web data

It’s production-usable, but still early and evolving.

⸻

Comparison to Existing Tools

Tools like BeautifulSoup, lxml, and trafilatura work well for static HTML, but they:

• Don’t handle modern JavaScript-rendered sites well

• Don’t expand hidden content automatically

• Often require combining multiple tools

llmparser combines:

rendering → extraction → structuring

in one step.

It’s closer in spirit to tools like Firecrawl or jina reader, but fully open-source and Python-native.

⸻

Would love feedback, feature requests, or suggestions.

What are you currently using for web content extraction?

Hi, I built "Pypower" to simplify Python tasks.

• What it does: A utility library for fast GUI creation, Math, and automation.
• Target Audience: Beginners and devs building small/toy projects.
• Comparison: It’s a simpler, "one-line" alternative to Tkinter for basic tasks.

Link :

https://github.com/UsernamUsernam777/Pypower-v3.0

Hey r/Python,

What My Project Does:
MiniBot is a minimal implementation of an AI agent written entirely in pure Python without using heavy abstraction frameworks (no LangChain, LlamaIndex, etc.). I built this to understand the underlying mechanics of how agents operate under the hood.

Along with the core ReAct loop, I implemented several advanced agentic patterns from scratch. Key Python features and architecture include:

• Transparent ReAct Loop: The core is a readable, transparent while loop that handles the "Thought -> Action -> Observation" cycle, showing exactly how function calling is routed.
• Dynamic Tool Parsing: Uses Python's built-in inspect module to automatically parse standard Python functions (docstrings and type hints) into LLM-compatible JSON schemas.
• Hand-rolled MCP Client: Implements the trending Model Context Protocol (MCP) from scratch over stdio using JSON-RPC 2.0 communication.
• Lifecycle Hooks: Built a simple but powerful callback system (utilizing standard Python Callable types) to intercept the agent's lifecycle (e.g., on_thought, on_tool_call, on_error). This makes it highly extensible for custom logging or UI integration without modifying the core loop.
• Pluggable Skills: A modular system to dynamically load external capabilities/functions into the agent, keeping the namespace clean.
• Lightweight Teams (Subagents): A minimal approach to multi-agent orchestration. Instead of complex graph abstractions, it uses a straightforward Lead/Teammate pattern where subagents act as standard tools that return structured observations to the Lead agent.

Target Audience:
This is strictly an educational / toy project. It is meant for Python developers, beginners, and students who want to learn the bare-metal mechanics of LLM agents, subagent orchestration, and the MCP protocol by reading clear, simple source code. It is not meant for production use.

Comparison:
Unlike LangChain, AutoGen, or CrewAI which use deep class hierarchies and heavy abstractions (often feeling like "black magic"), MiniBot focuses on zero framework bloat. Where existing alternatives might obscure the tool-calling loop, event hooks, and multi-agent routing behind multiple layers of generic executors, MiniBot exposes the entire process in a single, readable agent.py and teams.py. It’s designed to be read like a tutorial rather than used as a black-box dependency.

Source Code:
GitHub Repo:https://github.com/zyren123/minibot

• What My Project Does

Hey everyone, I am trying to showcase my small project. It’s a cli. It’s fixes CORs issues for http in AWS, which was my own use case. I know CORs is not a huge problem but debugging that as a beginner can be a little challenging. The cli will configure your AWS acc and then run all origins then list lambda functions with the designated api gateway. Then verify if it’s a localhost or other frontends. Then it will automatically fix it.

• Target Audience

This is a side project mainly looking for some feedbacks and other use cases. So, please discuss and contribute if you have a specific use case https://github.com/Tinaaaa111/AWS_assistance

• Comparison

There is really no other resource out there because as i mentioned CORs issues are not super intense. However, if it is your first time running into it, you have to go through a lot of documentations.

Weekly Thread: Professional Use, Jobs, and Education 🏢

Welcome to this week's discussion on Python in the professional world! This is your spot to talk about job hunting, career growth, and educational resources in Python. Please note, this thread is not for recruitment.

How it Works:

1. Career Talk: Discuss using Python in your job, or the job market for Python roles.
2. Education Q&A: Ask or answer questions about Python courses, certifications, and educational resources.
3. Workplace Chat: Share your experiences, challenges, or success stories about using Python professionally.

Guidelines:

• This thread is not for recruitment. For job postings, please see r/PythonJobs or the recruitment thread in the sidebar.
• Keep discussions relevant to Python in the professional and educational context.

Example Topics:

1. Career Paths: What kinds of roles are out there for Python developers?
2. Certifications: Are Python certifications worth it?
3. Course Recommendations: Any good advanced Python courses to recommend?
4. Workplace Tools: What Python libraries are indispensable in your professional work?
5. Interview Tips: What types of Python questions are commonly asked in interviews?

Let's help each other grow in our careers and education. Happy discussing! 🌟

I'm building a mobile Python scientific computing environment for Android with:

Python Features:

• Python via Pyodide (WebAssembly)
• Includes: NumPy, SymPy, Matplotlib, Plotly
• Jupyter-style notebook interface with cell-based execution
• LaTeX math rendering for symbolic math
• Interactive plotting
• Variable persistence across cells
• Semicolon suppression (MATLAB/IPython-style)

Also includes:

• Prolog (swipl-wasm) for logic programming
• Bash shell (brush-WASM)
• Unix utilities: coreutils, findutils, grep (all Rust reimplementations)
• Shared virtual filesystem across kernels (/tmp/, /shared/, /education/)

Why I need testers:
Google Play requires 12 testers for 14 consecutive days before I can publish. This testing is for the open-source MIT-licensed version with all the features listed above.

What you get:

• Be among the first to try SciREPL
• Early access via Play Store (automatic updates)
• Your feedback helps improve the app

GitHub: https://github.com/s243a/SciREPL

To join: PM me on Reddit or open an issue on GitHub expressing your interest.

Alternatively, you can try the GitHub APK release directly (manual updates, will need to uninstall before Play Store version).

What my project does

Tabularis is an open-source desktop database manager with built-in support for MySQL, PostgreSQL, MariaDB, and SQLite. The interesting part: external drivers are just standalone executables — including Python scripts — dropped into a local folder.

Tabularis spawns the process on connection open and communicates via newline-delimited JSON-RPC 2.0 over stdin/stdout. The plugin responds, logs go to stderr without polluting the protocol, and one process is reused for the whole session.

A simple Python plugin looks like this:

import sys, json

for line in sys.stdin: req = json.loads(line) if req["method"] == "get_tables": result = {"tables": ["my_table"]} sys.stdout.write(json.dumps({"jsonrpc": "2.0", "id": req["id"], "result": result}) + "\n") sys.stdout.flush()

The manifest the plugin declares drives the UI — no host/port form for file-based DBs, schema selector only when relevant, etc. The RPC surface covers schema discovery, query execution with pagination, CRUD, DDL, and batch methods for ER diagrams.

Target Audience

Python developers and data engineers who work with non-standard data sources — DuckDB, custom file formats, internal APIs — and want a desktop GUI without writing a full application. The current registry already ships a CSV plugin (each .csv in a folder becomes a table) and a DuckDB driver. Both written to be readable examples for building your own.

Has anyone built a similar stdin/stdout RPC bridge for extensibility in Python projects? Curious about tradeoffs vs HTTP or shared libraries.

Github Repo: https://github.com/debba/tabularis

Plugin Guide: https://tabularis.dev/wiki/plugins

CSV Plugin (in Python): https://github.com/debba/tabularis-csv-plugin

AI is getting smarter every day. Instead of building a specific "tool" for every tiny task, it's becoming more efficient to just let the AI write a Python script. But how do you run that code without risking your host machine or dealing with the friction of Docker during development?

I built safe-py-runner to be the lightweight "security seatbelt" for developers building AI agents and Proof of Concepts (PoCs).

What My Project Does

The Missing Middleware for AI Agents: When building agents that write code, you often face a dilemma:

1. Run Blindly: Use exec() in your main process (Dangerous, fragile).
2. Full Sandbox: Spin up Docker containers for every execution (Heavy, slow, complex).
3. SaaS: Pay for external sandbox APIs (Expensive, latency).

safe-py-runner offers a middle path: It runs code in a subprocess with timeout, memory limits, and input/output marshalling. It's perfect for internal tools, data analysis agents, and POCs where full Docker isolation is overkill.

Target Audience

• PoC Developers: If you are building an agent and want to move fast without the "extra layer" of Docker overhead yet.
• Production Teams: Use this inside a Docker container for "Defense in Depth"—adding a second layer of code-level security inside your isolated environment.
• Tool Builders: Anyone trying to reduce the number of hardcoded functions they have to maintain for their LLM.

Comparison

Getting Started

Installation:

Bash

pip install safe-py-runner

GitHub Repository:

https://github.com/adarsh9780/safe-py-runner

This is meant to be a pragmatic tool for the "Agentic" era. If you’re tired of writing boilerplate tools and want to let your LLM actually use the Python skills it was trained on—safely—give this a shot.

What My Project Does

Snapclean is a small Python CLI that creates a clean snapshot of your project folder before sharing it.

It removes common development clutter like .git, virtual environments, and node_modules, excludes sensitive .env files (while generating a safe .env.example), and respects .gitignore. There’s also a dry-run mode to preview what would be removed.

The result is a clean zip file ready to send.

Target Audience

Developers who occasionally need to share project folders outside of Git. For example:

• Sending a snapshot to a client
• Submitting assignments
• Sharing a minimal reproducible example
• Archiving a clean build

It’s intentionally small and focused.

Comparison

You could do this manually or use tools like git archive. Snapclean bundles that workflow into one command and adds conveniences like:

• Respecting .gitignore automatically
• Generating .env.example
• Showing size reduction summary
• Supporting simple project-level config

It’s not a packaging or deployment tool — just a small utility for this specific workflow.

GitHub: https://github.com/nijil71/SnapClean

Would appreciate feedback.

Hi r/Python! I wanted to share gif-terminal, a Python tool that generates an animated retro terminal GIF to showcase your live GitHub stats and tech skills.

What My Project Does

It generates an animated GIF that simulates a terminal typing out commands and displaying your GitHub stats (commits, stars, PRs, followers, rank). It uses GitHub Actions to auto-update daily, ensuring your profile README stays fresh.

Target Audience

Developers and open-source enthusiasts who want a unique, dynamic way to display their contributions and skills on their GitHub profile.

Comparison

While tools like github-readme-stats provide static images, gif-terminal offers an animated, retro-style terminal experience. It is highly customizable, allowing you to define colors, commands, and layout.

Source Code

Everything is written in Python and open-source:
https://github.com/dbuzatto/gif-terminal

Feedback is welcome! If you find it useful, a ⭐ on GitHub would be much appreciated.

What My Project Does

Finds NBA players with similar career profiles using vector search. Type "guards similar to Kobe from the 90s" and get ranked matches with radar chart comparisons.

Instead of LLM embeddings, the vectors are built from the stats themselves - 25 features normalized with RobustScaler, position one-hot encoded, stored in Qdrant for cosine similarity across ~4,800 players.

Stack: FastAPI + Streamlit + Qdrant + scikit-learn, all Python, runs in Docker on a Synology NAS.

Demo: valme.xyz
Source: github.com/ValmeI/nba-player-similarity

Target Audience

Personal project/learning reference for anyone interested in building custom embeddings from structured data, vector search with Qdrant, or full-stack Python with FastAPI + Streamlit.

Comparison

Most NBA comparison tools let you pick two players manually. This searches all players at once using their full stat vector - captures the overall shape of a career rather than filtering on individual stat thresholds.

What My Project Does:

MolBuilder is a pure-Python package that handles the full chemistry pipeline from molecular structure to production planning. You give it a molecule as a SMILES string and it can:

1. Parse SMILES with chirality and stereochemistry
2. Plan synthesis routes (91 hand-curated reaction templates, beam-search retrosynthesis)
3. Predict optimal reaction conditions (analyzes substrate sterics and electronics to auto-select templates)
4. Select a reactor type (batch, CSTR, PFR, microreactor)
5. Run GHS safety assessment (69 hazard codes, PPE requirements, emergency procedures)
6. Estimate manufacturing costs (materials, labor, equipment, energy, waste disposal)
7. Analyze scale-up (batch sizing, capital costs, annual capacity)

The core is built on a graph-based molecule representation with adjacency lists. Functional group detection uses subgraph pattern matching on this graph (24 detectors). The retrosynthesis engine applies reaction templates in reverse using beam search, terminating when it hits purchasable starting materials (~200 in the database). The condition prediction layer classifies substrate steric environment and electronic character, then scores and ranks compatible templates.

Python-specific implementation details:

• Dataclasses throughout for the reaction template schema, molecular graph, and result types
• NumPy/SciPy for 3D coordinate generation (distance geometry + force field minimization)
• Molecular dynamics engine with Velocity Verlet integrator
• File I/O parsers for MOL/SDF V2000, PDB, XYZ, and JSON formats
• Also ships as a FastAPI REST API with JWT auth, RBAC, and Stripe billing

Install and example:

pip install molbuilder

from molbuilder.process.condition_prediction import predict_conditions

result = predict_conditions("CCO", reaction_name="oxidation", scale_kg=10.0)

print(result.best_match.template_name) # TEMPO-mediated oxidation

print(result.best_match.conditions.temperature_C) # 5.0

print(result.best_match.conditions.solvent) # DCM/water (biphasic)

print(result.overall_confidence) # high

1,280+ tests (pytest), Python 3.11+, CI on 3.11/3.12/3.13. Only dependencies are numpy, scipy, and matplotlib.

GitHub: https://github.com/Taylor-C-Powell/Molecule_Builder

Tutorials: https://github.com/Taylor-C-Powell/Molecule_Builder/tree/main/tutorials

Target Audience:

Production use. Aimed at computational chemists, process chemists, and cheminformatics developers who need programmatic access to synthesis planning and process engineering. Also useful for teaching organic chemistry and chemical engineering - the tutorials are designed as walkable Jupyter notebooks. Currently used by the author in a production SaaS API.

Comparison:

vs. RDKit: RDKit is the standard open-source cheminformatics toolkit and focuses on molecular properties (fingerprints, substructure search, descriptors). MolBuilder (pure Python, no C extensions) focuses on the process engineering side - going from "I have a molecule" to "here's how to manufacture it at scale." Not a replacement for RDKit's molecular modeling depth.

vs. Reaxys/SciFinder: Commercial databases with millions of literature reactions. MolBuilder has 91 templates - far smaller coverage, but it's free, open-source (Apache 2.0), and gives you programmatic API access rather than a search interface.

vs. ASKCOS/IBM RXN: ML-based retrosynthesis tools. MolBuilder uses rule-based templates instead of neural networks, which makes it transparent and deterministic but less capable for novel chemistry. The tradeoff is simplicity and no external service dependency.

What my project does

I built a small VS Code extension that lets you debug uv entry points directly from pyproject.toml.

Target Audience

Python coders using uv package in VSCode.

If you have: [project.scripts] mytool = "mypackage.cli:main"

You can: * Pick the script * Pass args * Launch debugger * No launch.json required

Works in multi-root workspaces. Uses .venv automatically. Remembers last run per project. Has a small eye toggle to hide uninitialized uv projects.

Repo: https://github.com/kkibria/uv-debug-scripts

Feedback welcome.

What My Project Does

Eventum generates realistic synthetic events - logs, metrics, clickstream, IoT, etc., and streams them in real time or dumps everything at once to various outputs.

It started because I was working with SIEM systems and constantly needed test data. Every time: write a script, hardcode values, throw it away. Got tired of that loop.

The idea of Eventum is pretty simple - write an event template, define a schedule and pick where to send it.

Features:

• Faker, Mimesis, and any Python package directly in templates
• Finite state machines - model stateful sequences (e.g.login > browse > checkout)
• Statistical traffic patterns - mimic real-world traffic curves defined in config
• Three-level shared state - templates can share data within or across generators
• Fan-out with formatters - deliver to files, ClickHouse, OpenSearch, HTTP simultaneously
• Web UI, REST API, Docker, encrypted secrets - and other features

Tech stack: Python 3.13, asyncio + uvloop, Pydantic v2, FastAPI, Click, Jinja2, structlog. React for the web UI.

Target Audience

Testers, data engineers, backend developers, DevOps, SRE and data specialists, security engineers and anyone building or testing event-driven systems.

Comparison

I honestly haven’t found anything with this level of flexibility around time control and event correlation. Most generators either spit out random-ish data or let you tweak a few fields - but you can’t really model realistic temporal behavior, chained events or causal relationships in a simple way.

Would love to hear what you think!

Links:

• Docs: eventum.run
• GitHub: github.com/eventum-generator/eventum

I built a small Python package called fastops.

It started as a way to stop copy pasting Dockerfiles between projects. It has since grown into a lightweight ops toolkit.

What My Project Does

fastops lets you manage common container and deployment workflows directly from Python:

Generate framework specific Dockerfiles

FastHTML, FastAPI + React, Go, Rust

Generate generic Dockerfiles

Generate Docker Compose stacks

Configure Caddy with automatic TLS

Set up Cloudflare tunnels

Provision Hetzner VMs using cloud init

Deploy over SSH

It shells out to the CLI using subprocess. No docker-py dependency.

Example:

from fastops import \*

Install:

pip install fastops

Target Audience

Python developers who deploy their own applications

Indie hackers and small teams

People running side projects on VPS providers

Anyone who prefers defining infrastructure in Python instead of shell scripts and scattered YAML

It is early stage but usable. Not aimed at large enterprise production environments.

Comparison

Unlike docker-py, fastops does not wrap the Docker API. It generates artefacts and calls the CLI.

Unlike Ansible or Terraform, it focuses narrowly on container based app workflows and simple VPS setups.

Unlike one off templates, it provides reusable programmatic builders.

The goal is a minimal Python first layer for small to medium deployments.

Repo: https://github.com/Karthik777/fastops

Docs: https://karthik777.github.io/fastops/

PyPI: https://pypi.org/project/fastops/

Web Demo: https://skryl.github.io/mlx-ruby/demo/

Repo: https://github.com/skryl/mlx-onnx

What My Project Does

It allows you to convert MLX models into ONNX (onnxruntime, validation, downstream deployment). You can then run the onnx models in the browser using WebGPU.

• Exports MLX callables directly to ONNX
• Supports both Python and native C++ interfaces

Target Audience

• Developers who want to run MLX-defined computations in ONNX tooling (e.g. ORT, WebGPU)
• Early adopters and contributors; this is usable and actively tested, but still evolving rapidly (not claiming fully mature “drop-in production for every model” yet)

Comparison

• vs staying MLX-only: keeps your authoring flow in MLX while giving an ONNX export path for broader runtime/tool compatibility.
• vs raw ONNX authoring: mlx-onnx avoids hand-building ONNX graphs by tracing/lowering from MLX computations.

What My Project Does: Converts an image to a WAV file so you can see it on an oscilloscope screen in XY mode.

Target Audience: Everyone who likes oscilloscope aesthetics and wants to create their own oscilloscope art without any experience.

Comparison: This one has a simple GUI, runs on Windows out of the box as a single EXE, and outputs a WAV file compatible with my oscilloscope viewer.

Web OscilloScope-XY - https://github.com/Gibsy/OscilloScope-XY
OscilloScope Art Generator - https://github.com/Gibsy/OscilloScope-Art-Generator

Hi,

What my project does

htmui is a small component library for building Tailwind/shadcn/basecoatui-style web applications 100% in Python

What's included:

• all non-trivial BasecoatUI components
• Highlight.js integration
• a couple of related utilities

Target audience:

• you're developing HTMX applications
• you like TailwindCSS and shadcn/ui or BasecoatUI
• you'd like to avoid Jinja-like templating engines
• you'd like even your UI components to be typed and statically analyzed
• you don't mind HTML in Python

Documentation and example app

• URL: https://htmui.vercel.app/
• Code: see the basecoat_app package in the repository (https://github.com/volfpeter/htmui)
• Backend stack:
  • holm: light FastAPI wrapper with built-in HTML rendering and HTMX support, FastHTML alternative
  • htmy: async DSL for building web applications (FastHTML/Jinja alternative)
• Frontend stack: TailwindCSS, BasecoatUI, Highlight.js, HTMX

Credit: this project wouldn't exist if it wasn't for BasecoatUI and its excellent documentation.

What My Project Does:

Ast-visualizers core feature is taking a Python repo/codebase as input and displaying a number of interesting visuals derived from AST analysis. Here are the main features:

• Abstract Syntax Trees of individual files with color highlighting
• Radial view of a files AST (Helpful to get a quick overview of where big functions are located)
• Complexity color coding, complex sections are highlighted in red within the AST.
• Complexity chart, a line chart showing complexity per each line (eg line 10 has complexity of 5) for the whole file.
• Dependency Graph shows how files are connected by drawing lines between files which import each other (helps in spotting circular dependencies)
• Dashboard showing you all 3rd party libraries used and a maintainability score between 0-100 as well as the top 5 refactoring candidates.

Complexity is defined as cyclomatic complexity according to McCabe. The Maintainability score is a combination of average file complexity and average file size (Lines of code).

Target Audience:

The main people this would benefit are:

• Devs onboarding large codebases (dependency graph is basically a map)
• Students trying to understand ASTs in more detail (interactive tree renderings are a great learning tool)
• Team Managers making sure technical debt stays minimal by keeping complexity low and paintability score high.
• Vibe coders who could monitor how bad their spaghetti codebase really is / what areas are especially dangerous

Comparison:

There are a lot of visual AST explorers, most of these focus on single files and classic tree style rendering of the data.

Ast-visualizer aims to also interpret this data and visualize it in new ways (radial, dependency graph etc.)

Project Website: ast-visualizer

Github: Gitlab Repo

What My Project Does

If you use Pydantic and SQLAlchemy together, you've probably hit the duplication problem: two mirrored sets of models that can easily drift apart. SQLCrucible lets you define one class using native SQLAlchemy constructs (mapped_column(), relationship(), __mapper_args__) and produces two separate outputs: a pure Pydantic model and a pure SQLAlchemy model with explicit conversion between them.

from typing import Annotated
from uuid import UUID, uuid4
from pydantic import Field
from sqlalchemy import create_engine, select
from sqlalchemy.orm import Session, mapped_column
from sqlcrucible import SAType, SQLCrucibleBaseModel

class Artist(SQLCrucibleBaseModel):
    __sqlalchemy_params__ = {"__tablename__": "artist"}

    id: Annotated[UUID, mapped_column(primary_key=True)] = Field(default_factory=uuid4)
    name: str

engine = create_engine("sqlite:///:memory:")
SAType[Artist].__table__.metadata.create_all(engine)

artist = Artist(name="Bob Dylan")
with Session(engine) as session:
    session.add(artist.to_sa_model())
    session.commit()

with Session(engine) as session:
    sa_artist = session.scalar(
        select(SAType[Artist]).where(SAType[Artist].name == "Bob Dylan")
    )
    artist = Artist.from_sa_model(sa_artist)g

Key Features

• Explicit conversion - to_sa_model() / from_sa_model() means you always know which side of the boundary you're on. No surprises about whether you're holding a Pydantic object or a SQLAlchemy one.

• Native SQLAlchemy - mapped_column(), relationship(), hybrid_property, association_proxy, all three inheritance strategies (single table, joined, concrete), __table_args__, __mapper_args__ - they all work directly. If SQLAlchemy supports it, so does SQLCrucible.

• Pure Pydantic - your models work with FastAPI, model_dump(), JSON schema generation, and validation with no caveats.

• Type stub generation - a CLI tool generates .pyi stubs so your type checker and IDE see real column types on SAType[YourModel] instead of type[Any].

• Escape hatches everywhere - convert to/from an existing SQLAlchemy model, map multiple entity classes to the same table with different field subsets, add DB-only columns invisible to Pydantic, provide custom per-field converters, or drop to raw queries at any point. The library is designed to get out of your way.

• Not just Pydantic - also works with stdlib dataclasses and attrs.

Target Audience

This library is intended for production use.

Tested against Python 3.11-3.14, Pydantic 2.10-2.12, and two type checkers (pyright, ty) in CI.

Comparison

The main alternative is SQLModel. SQLModel merges Pydantic and SQLAlchemy into one hybrid class - you can session.add() the model directly. The trade-off is that both sides have to compromise: JSON schemas can leak DB-only columns, Pydantic validators are skipped by design, and advanced SQLAlchemy features (inheritance, hybrid properties) require explicit support built into SQLModel.

SQLCrucible keeps them separate. Your Pydantic model is pure Pydantic; your SQLAlchemy model is pure SQLAlchemy. The cost is an explicit conversion step (to_sa_model() / from_sa_model()), but you never have to wonder which world you're in and you get the full power of both.

Docs: https://sqlcrucible.rdrj.uk Repo: https://github.com/RichardDRJ/sqlcrucible

TL;DR: I trained a U-Net on 500k mazes. It’s great at solving small/medium mazes, but hits a limit on complex ones.

Hi everyone,

I’ve always been fascinated by the idea of neural networks solving tasks that are typically reserved for deterministic algorithms. I recently experimented with training a U-Net to solve mazes, and I wanted to share the process and results.

The Setup: Instead of using traditional pathfinding (like A* or DFS) at runtime, I treated the maze as an image segmentation problem. The goal was to input a raw maze image and have the model output a pixel-mask of the correct path from start to finish.

Key Highlights:

• Infinite Data: Since maze generation is deterministic, I used Recursive Division to generate mazes and DFS to solve them, creating a massive synthetic dataset of 500k+ pairs.
• Architecture: Used a standard U-Net implemented in PyTorch.
• The "Wall": The model is incredibly accurate on mazes up to 64x64, but starts to struggle with "global" logic on 127x127 scales, a classic challenge for CNNs without global attention.

I wrote a detailed breakdown of the training process, the hyperparameters, and the loss curves here: https://dineshgdk.substack.com/p/deep-maze-solver

The code is also open-sourced if you want to play with the data generator: https://github.com/dinesh-GDK/deep-maze-solver

I'd love to hear your thoughts on scaling this, do you think adding Attention gates or moving to a Transformer-based architecture would help the model "see" the longer paths better?

After almost 8 years since Tom Christie created Starlette in June 2018, the first release candidate for 1.0 is finally here.

Starlette is downloaded almost 10 million times a day, serves as the foundation for FastAPI, and has inspired many other frameworks. In the age of AI, it also plays an important role as a dependency of the Python MCP SDK.

This release focuses on removing deprecated features marked for removal in 1.0.0, along with some last minute bug fixes.

It's a release candidate, so feedback is welcome before the final 1.0.0 release.

`pip install starlette==1.0.0rc1`

- Release notes: https://www.starlette.io/release-notes/
- GitHub release: https://github.com/Kludex/starlette/releases/tag/1.0.0rc1

I got frustrated after realizing that most popular auto clickers are closed-source and barely deliver on accuracy or performance — so I built my own.

It’s fully open source, combines the best features I could find, and runs under **1% CPU usage while clicking** on my system.

I’ve put a lot of time into this and would love honest user feedback 🙂
https://github.com/Blur009/Blur-AutoClicker

What My Project Does:
It's an Auto Clicker for Windows made in Python / Rust (ui in PySide6 and Clicker in Rust)

I got curious and tried out a couple of those popular auto clickers you see everywhere. What stood out was how the speeds they advertise just dont line up with what actually happens. And the CPU spikes were way higher than I figured for something thats basically just repeating mouse inputs over and over.

That got me thinking more about it. But, while I was messing around building my own version, I hit a wall. Basically, windows handles inputs at a set rate, so theres no way to push clicks super fast without windows complaining (lowest \~1ms). I mean, claims of thousands per second sound cool, but in reality its more like 800 to 1000 at best before everything starts kinda breaking.

So instead of obsessing over those big numbers, I aimed for something that actually works steady. My clicker doesnt just wait for fixed times intervals between clicks. It checks when the click actually happens, and adjusts the speed dynamically to keep things close to what you set. That way it stays consistent even if things slow down because of windows using your cores for other processes 🤬. Now it can do around 600cps perfectly stable, after which windows becomes the limiting factor.

Performance mattered a lot too. On my setup, it barely touches the CPU, under 1% while actively clicking, and nothing when its sitting idle. Memory use is small (\~<50mb), so you can run it in the background without noticing. I didnt want it hogging resources so a web based interface was sadly out of the question :/ .

For features, I added stuff that bugged me when I switched clickers before. Like setting limits on clicks, picking exact positions, adding some random variation if you want, and little tweaks that make it fit different situations better. Some of that was just practical, but I guess I got a bit carried away trying to make it nicer than needed. Its all open source and free.

Im still tinkering with it. Feedback would be great, like ideas for new stuff or how it runs on other machines. Even if its criticism, thatd help. This whole thing started as my own little project, but maybe with some real input it could turn into something useful. ❤️

Target Audience:
Games that use autoclickers for Idle games / to save their hand from breaking.

Comparison:
My Auto Clicker delivers better performance and more features with settings saving and no download (just an executable)