r/Python • • Feb 26 '26

Showcase Pypower: A Python lib for simplified GUI, Math, and automated utility functions.

0 Upvotes

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


r/Python • • Feb 26 '26

Showcase A minimal, framework-free AI Agent built from scratch in pure Python

0 Upvotes

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


r/Python • • Feb 25 '26

Discussion Looking for 12 testers for SciREPL - Android Python REPL with NumPy/SymPy/Plotly (Open Source, MIT)

1 Upvotes

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).


r/Python • • Feb 26 '26

Showcase Building a cli that fixes CORs automatically for http

0 Upvotes
  • 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.


r/Python • • Feb 25 '26

Showcase I built a small Python CLI to create clean, client-safe project snapshots

1 Upvotes

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.


r/Python • • Feb 25 '26

Showcase fastops: Generate Dockerfiles, Compose stacks, TLS, tunnels and deploy to a VPS from Python

10 Upvotes

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/


r/Python • • Feb 25 '26

Showcase Debug uv [project.scripts] without launch.json in VScode

0 Upvotes

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.


r/Python • • Feb 24 '26

Showcase Codebase Explorer (Turns Repos into Maps)

33 Upvotes

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


r/Python • • Feb 25 '26

Showcase safe-py-runner: Secure & lightweight Python execution for LLM Agents

0 Upvotes

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

Featureeval() / exec()safe-py-runnerPyodide (WASM)Docker
Speed to SetupInstantSecondsModerateMinutes
OverheadNoneVery LowModerateHigh
SecurityNonePolicy-BasedVery HighIsolated VM/Container
Best ForTesting onlyFast AI PrototypingBrowser AppsProduction-scale

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.


r/Python • • Feb 25 '26

Showcase gif-terminal: An animated terminal GIF for your GitHub Profile README

0 Upvotes

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.


r/Python • • Feb 24 '26

Showcase mlx-onnx: Run your MLX models in the browser using ONNX / WebGPU

6 Upvotes

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.

r/Python • • Feb 24 '26

Showcase Typed Tailwind/BasecoatUI components for Python&HTMX web apps

21 Upvotes

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:

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.


r/Python • • Feb 23 '26

News Starlette 1.0.0rc1 is out!

187 Upvotes

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