proserve 2.0.4

Professional Service Framework - Revolutionary modular microservice framework with zero-config API

🚀 ProServe - Modern Microservices Framework

Build production-ready microservices with minimal code - Python decorators or YAML manifests!

🎯 98% Less Boilerplate • 5-Minute Start • Production Ready

ProServe is a revolutionary microservices framework that combines the simplicity of Flask with the power of modern architecture. Create APIs, static sites, real-time chat, and more with just a few lines of code.

🚀 Fully Modular Architecture: All components are now modular, testable, and follow SOLID principles
🧪 Comprehensive E2E Testing: 8+ test suites covering real-world scenarios, security, performance, and integrations

⚡ Quick Start (3 Lines of Code!)

# app.py
from proserve import Service

app = Service("my-api")

@app.endpoint("/", method="GET")
async def hello(request):
    return {"message": "Hello World! 🚀"}

if __name__ == "__main__":
    app.run(port=8080)

python app.py
# Open: http://localhost:8080

That's it! You have a production-ready API running.

🎓 New to microservices? Check out our Junior Quick Start Guide - "ProServe in 5 minutes"

🏗️ Manifest-Driven Development

Note: Manifests are not outdated. They are a core feature of ProServe, providing a declarative way to define microservices using YAML. The newer decorator-based approach complements manifests, offering flexibility for developers who prefer coding over configuration. Both approaches are fully supported and production-ready.

With tools like SELLM, you can even generate manifests using AI from simple text descriptions, making it incredibly easy to create complex services without manual configuration.

Example 1: Basic Manifest

# manifest.yml
name: my-service
port: 8080

endpoints:
  - path: /api/status
    method: GET
    response:
      status: "ok"
      version: "1.0.0"
  
  - path: /api/hello/{name}
    method: GET
    response:
      message: "Hello {{name}}!"

static:
  enabled: true
  path: ./public

proserve run
# Automatically creates API from manifest.yml
# Open: http://localhost:8080/api/status
# Try: http://localhost:8080/api/hello/World

Example 2: Advanced Manifest with WebSocket

# advanced_manifest.yml
name: chat-service
port: 8081

endpoints:
  - path: /api/chat/info
    method: GET
    response:
      status: "Chat Service Running"
      users: 0

websockets:
  - path: /ws/chat
    handler: chat_handler
    on_connect:
      message: "User connected"
    on_disconnect:
      message: "User disconnected"

static:
  enabled: true
  path: ./chat_ui

proserve run advanced_manifest.yml
# Starts a chat service with WebSocket support
# Open: http://localhost:8081/api/chat/info
# Connect WebSocket: ws://localhost:8081/ws/chat

📖 Documentation

All detailed documentation is available in the docs folder:

• Architecture Guide - Understand the modular design of ProServe
• API Documentation - Complete API reference
• Quick Start Guide - Get started in minutes
• Junior Quick Start - Beginner-friendly guide
• Deployment Checklist - Prepare for production
• E2E Testing Guide - Comprehensive testing suite
• Ecosystem Overview - Integration with other tools
• Modular Architecture - Design principles
• Future Roadmap - Upcoming features
• Release Notes v2.0.0 - Latest updates
• YAML Driven Showcase - Manifest examples

Python Packages

Explore the ecosystem of Python packages related to ProServe:

• ProServe - Core microservices framework
• Servos - Environment isolation and orchestration
• wmlog - Centralized structured logging
• SELLM - AI-powered manifest generator
• EDPMT - Hardware control framework for IoT

💡 Why ProServe?

• Zero-Config APIs: Build REST endpoints in 3 lines of code
• Manifest-Driven: Define services in YAML, like docker-compose
• Multi-Environment: Run anywhere - local, Docker, Kubernetes, embedded
• Full-Stack: HTTP, WebSocket, background tasks, static hosting
• Production-Ready: Logging, monitoring, security built-in

Start building microservices today with ProServe!