prozes 0.1.0

Professional Python project generator - CLI tool for scaffolding production-ready applications

Prozes

Professional Python Project Generator

A powerful CLI tool for scaffolding production-ready Python applications. Stop wasting time on boilerplate. Start building features from day one.

Installation • Quick Start • Documentation • Examples • Contributing

---

Overview

Prozes is a command-line project generator that creates production-ready Python applications with enterprise-grade architectures. Whether you're building a web application, REST API, CLI tool, or following Clean Architecture principles, Prozes provides the scaffolding you need to start coding immediately.

Type: CLI Tool / Project Generator (not a framework or library) Usage: Run prozes commands to generate project structures - no imports needed

Why Prozes?

• Battle-Tested Architectures: MVC, REST API, CLI, and Clean Architecture patterns
• Framework Agnostic: Works with Flask, FastAPI, and more
• Production-Ready: Includes logging, environment variables, real tests, and CI/CD
• Zero Configuration: Sensible defaults that work out of the box
• Best Practices Included: Testing setup, linting, Git integration, and virtual environments
• Bilingual Support: Full internationalization (English and Portuguese)
• Beautiful CLI: Rich terminal output with progress indicators and helpful messages

---

Table of Contents

• Installation
• Quick Start
• Key Features
• Architecture Types
• Usage
• Examples
• Configuration
• Development
• Roadmap
• Contributing
• License

---

Installation

Via pip (Recommended)

pip install prozes

From Source

git clone https://github.com/jaopdc11/prozes.git
cd prozes
pip install -e .

Verify Installation

prozes --version
prozes --help

---

Quick Start

Get up and running in 30 seconds:

# Create a FastAPI REST API with all bells and whistles
prozes api my_api --type fastapi --venv --git --install-deps

cd my_api
source venv/bin/activate  # or venv\Scripts\activate on Windows
uvicorn main:app --reload

That's it! Your API is running at http://localhost:8000 with auto-generated docs at /docs.

Other Quick Examples

# MVC web application with Flask
prozes mvc blog --venv --git

# CLI tool ready for distribution
prozes cli mytool --venv --git

# Clean Architecture project
prozes clean backend --type fastapi --venv --git

---

Key Features

🏗️ Multiple Architectures MVC (Model-View-Controller) REST API CLI Applications Clean Architecture ⚡ Framework Support Flask FastAPI Click (for CLI) 🔧 Development Tools Automatic virtual environment creation Git initialization Dependency installation Testing scaffolding

🌍 Internationalization English (default) Portuguese (pt) Easily extensible 📦 Production Ready Environment variables (.env.example) Logging configuration Real test cases (not placeholders) Separate dev dependencies CI/CD with GitHub Actions Configuration management 🎨 Developer Experience Beautiful CLI with Rich library Progress indicators Colored output Verbose mode for debugging

---

Architecture Types

🌐 MVC (Model-View-Controller)

Perfect for web applications with server-side rendering.

prozes mvc my_webapp --type web-flask --venv --git

Includes:

• Separate concerns: Models, Views, Controllers
• Template engine setup
• Static files organization
• Configuration management

Use cases: Traditional web apps, admin panels, dashboards

---

🔌 REST API

Lean and focused API without frontend bloat.

prozes api my_api --type fastapi --venv --git

Includes:

• RESTful route structure
• Data models and schemas
• Request/response handling
• Auto-generated API documentation (FastAPI)

Use cases: Backend services, mobile app APIs, microservices

---

💻 CLI Application

Command-line tools using Click framework.

prozes cli my_tool --venv --git

Includes:

• Command structure
• Argument parsing
• Configuration handling
• Distribution setup (setup.py)

Use cases: DevOps tools, automation scripts, data processing

---

🏛️ Clean Architecture

Enterprise-grade architecture with clear separation of concerns.

prozes clean my_project --type fastapi --venv --git

Includes:

• Entities (Domain layer)
• Use Cases (Business logic)
• Adapters (Interfaces)
• Frameworks (External dependencies)

Use cases: Large applications, microservices, long-term projects

---

Usage

Command Syntax

prozes <architecture> <project_name> [options]

Common Options

All commands support these options:

Option	Description	Default
--venv	Create virtual environment	false
--git	Initialize Git repository	false
--python-version	Python version for venv	System default
--install-deps	Install dependencies	false
-v, --verbose	Verbose output	false
-L, --lang	Language (en or pt)	en

Architecture-Specific Options

MVC & API Commands

-t, --type   Framework type (web-flask, web-fastapi, flask, fastapi)

Configuration Command

prozes config --lang pt           # Set default language
prozes config --show              # Show current configuration

Generated Project Structure

MVC Project

my_webapp/
├── .github/
│   └── workflows/       # CI/CD pipelines
├── app/
│   ├── controllers/     # Request handlers
│   ├── models/          # Data models
│   ├── views/           # View logic
│   ├── templates/       # HTML templates
│   └── static/          # CSS, JS, images
├── config/
│   ├── __init__.py      # Configuration
│   └── logging.py       # Logging setup
├── tests/               # Test suite with real tests
├── main.py              # Entry point
├── requirements.txt     # Production dependencies
├── requirements-dev.txt # Development dependencies
├── pyproject.toml       # Pytest configuration
├── .env.example         # Environment variables template
└── .gitignore          # Git ignore rules

API Project

my_api/
├── .github/workflows/   # CI/CD pipelines
├── app/
│   ├── models/          # Data models
│   └── routes/          # API endpoints
├── config/
│   ├── __init__.py      # Configuration
│   └── logging.py       # Logging setup
├── tests/               # Test suite with real API tests
├── main.py              # Entry point
├── requirements.txt     # Production dependencies
├── requirements-dev.txt # Development dependencies
├── pyproject.toml       # Pytest configuration
└── .env.example         # Environment variables template

CLI Project

my_tool/
├── .github/workflows/   # CI/CD pipelines
├── my_tool/
│   ├── commands/        # CLI commands
│   └── main.py          # Entry point
├── tests/               # Test suite with Click runner tests
├── setup.py             # Distribution setup
├── pyproject.toml       # Project metadata + pytest config
├── requirements.txt     # Production dependencies
├── requirements-dev.txt # Development dependencies
└── .env.example         # Environment variables template

Clean Architecture Project

my_project/
├── .github/workflows/   # CI/CD pipelines
├── src/
│   ├── entities/        # Domain entities
│   ├── use_cases/       # Business logic
│   ├── adapters/        # Interfaces & repositories
│   └── frameworks/      # External dependencies
├── config/
│   ├── __init__.py      # Configuration
│   └── logging.py       # Logging setup
├── tests/
│   ├── unit/            # Unit tests for use cases
│   └── integration/     # Integration tests
├── main.py              # Entry point
├── requirements.txt     # Production dependencies
├── requirements-dev.txt # Development dependencies
├── pyproject.toml       # Pytest configuration
└── .env.example         # Environment variables template

---

Examples

1. Blog Application (MVC + Flask)

Build a full-featured blog with Flask:

# Generate the project
prozes mvc blog --type web-flask --venv --git --install-deps -v

# Start development
cd blog
source venv/bin/activate  # Windows: venv\Scripts\activate
python main.py

# Visit http://localhost:5000

What you get:

• MVC structure with controllers, models, and views
• Template system ready
• Static files organized
• Development server configured
• Real tests for routes and application
• Logging configured
• CI/CD pipeline ready

---

2. User Management API (FastAPI)

Create a modern API with auto-generated documentation:

# Generate the project
prozes api user_service --type fastapi --venv --git --install-deps

# Start the server
cd user_service
source venv/bin/activate
uvicorn main:app --reload

# Interactive docs at http://localhost:8000/docs

What you get:

• RESTful endpoints structure
• Pydantic models for validation (FastAPI) or Flask blueprints
• Automatic OpenAPI documentation (FastAPI)
• Real API tests with test client
• Health check endpoint
• Logging configured
• CI/CD pipeline ready

---

3. DevOps CLI Tool

Build a distributable command-line tool:

# Generate the project
prozes cli devops-tools --venv --git --install-deps

# Install in development mode
cd devops-tools
pip install -e .

# Use your CLI
devops-tools --help
devops-tools deploy --env production

What you get:

• Click framework integrated
• Command structure ready
• Configuration management
• Package ready for PyPI
• Tests with Click runner
• CI/CD pipeline ready

---

4. Microservice (Clean Architecture + FastAPI)

Enterprise-grade microservice with Clean Architecture:

# Generate the project
prozes clean payment-service --type fastapi --venv --git --install-deps

# Run tests
cd payment-service
pytest tests/ -v

# Start the service
uvicorn main:app --reload

What you get:

• Separated layers (entities, use cases, adapters, frameworks)
• Dependency injection examples
• Testability built-in (unit + integration tests)
• Dependency inversion principle applied
• Repository pattern implemented
• Ready for complex business logic

---

Configuration

Global Configuration

Set your preferences globally:

# Set default language to Portuguese
prozes config --lang pt

# View current configuration
prozes config --show

Per-Project Configuration

Each generated project includes:

• config/ directory for environment-specific settings
• .env.example for environment variables (where applicable)
• requirements.txt with pinned dependencies

---

Documentation

• Full Documentation: [Coming Soon]
• API Reference: [Coming Soon]
• Tutorials: [Coming Soon]
• Examples Gallery: [Coming Soon]

For now, use prozes --help and prozes <command> --help for detailed command information.

---

Roadmap

We have ambitious plans for Prozes. Check out our ROADMAP.md to see what's coming:

• 🔌 Plugin system for custom templates
• 🐳 Docker integration
• 🗄️ Database templates (PostgreSQL, MongoDB, etc.)
• 🔐 Authentication scaffolding
• 🌐 More frameworks (Django, Tornado, Sanic)
• 🏗️ More architectures (Hexagonal, CQRS, Event-Driven)

View Full Roadmap →

---

Development

Setup Development Environment

# Clone the repository
git clone https://github.com/jaopdc11/prozes.git
cd prozes

# Create virtual environment
python -m venv venv
source venv/bin/activate  # Windows: venv\Scripts\activate

# Install in development mode with all dependencies
pip install -e ".[dev]"

# Install pre-commit hooks
pre-commit install

Run Tests

# Run all tests
pytest

# Run with coverage
pytest --cov=prozes --cov-report=html

# Run specific test file
pytest tests/test_core.py -v

Code Quality

# Format code
black prozes tests

# Lint code
ruff check prozes tests

# Type checking
mypy prozes

# Run all checks (what CI runs)
pre-commit run --all-files

See CONTRIBUTING.md for detailed guidelines.

---

Contributing

We welcome contributions! Here's how you can help:

• 🐛 Report bugs via GitHub Issues
• 💡 Suggest features through GitHub Discussions
• 📝 Improve documentation
• 🔧 Submit pull requests

Please read our Contributing Guide before submitting PRs.

Contributors

Thanks to all our contributors!

---

Community

• GitHub Discussions: Ask questions and share ideas
• Issues: Report bugs
• Discord: [Coming Soon]
• Twitter: [Coming Soon]

---

License

This project is licensed under the MIT License - see the LICENSE file for details.

---

Acknowledgments

Built with:

• Click - Command line interface
• Rich - Beautiful terminal output
• Flask & FastAPI - Web frameworks

Inspired by:

• Cookiecutter
• Vue CLI
• Create React App

---

⬆ Back to Top

Made with ❤️ by jaopdc11 & mednick-sys

If you find this project useful, please consider giving it a ⭐️