lightapi 0.1.3

A lightweight framework for building API endpoints using Python's native libraries.

LightAPI

A lightweight, fast, and easy-to-use web API framework for Python with automatic REST endpoint generation, built-in authentication, caching, and more.

Features

• 🚀 Zero-boilerplate REST APIs - Automatically generate CRUD operations from SQLAlchemy models
• 🔐 Built-in Authentication - JWT authentication with automatic CORS handling
• ⚡ High Performance - Built on Starlette for async support and speed
• 💾 Smart Caching - Redis-based caching with automatic invalidation
• 📊 Request Validation - Automatic request validation and error handling
• 🔍 Advanced Filtering - Query filtering, pagination, and sorting out of the box
• 📖 Auto Documentation - Automatic OpenAPI/Swagger documentation generation
• 🔧 Flexible Middleware - Easy middleware system for custom logic
• 🗄️ Database Integration - Seamless SQLAlchemy integration with automatic table creation
• ⚙️ Environment Configuration - Easy configuration management

Quick Start

Installation

pip install lightapi

Basic Usage

from lightapi import LightApi
from lightapi.database import Base
from sqlalchemy import Column, Integer, String

# Define your model
class User(Base):
    __tablename__ = "users"
    
    id = Column(Integer, primary_key=True)
    name = Column(String(50))
    email = Column(String(100))

# Create API instance
app = LightApi()

# Register your model - automatically creates CRUD endpoints
app.register(User)

# Run the server
if __name__ == "__main__":
    app.run()

That's it! You now have a fully functional REST API with:

• GET /users - List all users with filtering and pagination
• GET /users/{id} - Get user by ID
• POST /users - Create new user
• PUT /users/{id} - Update user
• DELETE /users/{id} - Delete user
• OPTIONS /users - CORS preflight support

Documentation

Visit our comprehensive documentation at: https://iklobato.github.io/lightapi/

• Getting Started Guide
• API Reference
• Examples

Advanced Features

Authentication

from lightapi.auth import JWTAuthentication

# Add JWT authentication
auth = JWTAuthentication(secret_key="your-secret-key")
app.add_middleware(auth)

# Protected endpoints automatically require valid JWT tokens

Caching

from lightapi.cache import RedisCache

# Add Redis caching
cache = RedisCache(host="localhost", port=6379)
app.register(User, cache=cache, cache_ttl=300)  # 5 minutes TTL

Validation

from lightapi.rest import Validator

class UserValidator(Validator):
    def validate_post(self, data):
        if not data.get("email"):
            raise ValueError("Email is required")
        return data

app.register(User, validator=UserValidator())

Middleware

from lightapi.core import Middleware

class LoggingMiddleware(Middleware):
    async def process(self, request, call_next):
        print(f"Request: {request.method} {request.url}")
        response = await call_next(request)
        print(f"Response: {response.status_code}")
        return response

app.add_middleware(LoggingMiddleware())

Why LightAPI?

• Rapid Development: Get REST APIs running in minutes, not hours
• Production Ready: Built-in security, caching, and error handling
• Flexible: Customize every aspect while keeping defaults simple
• Modern: Async support, type hints, and contemporary Python practices
• Well Documented: Comprehensive docs with real-world examples

Examples

Check out the examples directory for complete applications:

• Basic REST API - Simple CRUD operations
• Authentication - JWT authentication
• Caching - Redis caching implementation
• Validation - Request validation
• Middleware - Custom middleware
• Filtering & Pagination - Advanced queries

Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

License

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

---

LightAPI - Making web APIs light and fast ⚡