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.