Catzilla
Getting Started
Installation
Quick Installation
Verification
Python Requirements
Next Steps
Need Help?
Quickstart
Your First Catzilla App
Async/Sync Hybrid Support
Path Parameters & Validation
Query Parameters
Request Body Validation with BaseModel
Complete Example Application
Testing Your API
Performance Comparison Demo
Error Handling
What’s Next?
Why Catzilla?
Migration from FastAPI
Why Migrate to Catzilla?
Quick Migration Checklist
Step-by-Step Migration
1. Install Catzilla
2. Update Imports
3. Update App Initialization
4. Update Response Imports
Migration Examples
Basic CRUD API
Authentication & Dependencies
File Uploads
Key Differences & Improvements
Request Object
Async/Sync Handling
Dependency Injection
Performance Optimizations
Common Migration Issues & Solutions
1. Response Model Decorators
2. Status Code Responses
3. Background Tasks
Migration Testing
Performance Verification
Advanced Migration Tips
Migration Checklist
Key API Differences
Need Help?
Core Concepts
Routing
Basic Routing
Route Decorators
Multiple HTTP Methods
Path Parameters
Simple Path Parameters
Path Parameter Validation
Query Parameters
Basic Query Parameters
Optional and Required Parameters
Headers and Form Data
Header Parameters
Form Data
Router Groups
Basic Router Groups
Nested Router Groups
Group-Level Middleware
Advanced Routing Patterns
Route Priorities
Route with Multiple Parameters
Async/Sync Routing
Mix Async and Sync Handlers
Performance Considerations
Route Registration Patterns
Dynamic Route Registration
Route Validation
Error Handling in Routes
Performance Monitoring
Best Practices
Next Steps
Validation
Overview
Basic Models
Simple Model Definition
Models with Field Validation
Field Types and Constraints
String Fields
Numeric Fields
List and Collection Fields
Nested Models
Basic Nested Models
Complex Nested Structures
Custom Validation
Post-Initialization Validation
Enum Validation
Query and Path Parameter Validation
Query Parameter Models
Individual Parameter Validation
Error Handling
Automatic Validation Errors
Custom Error Handling
Performance Monitoring
Validation Performance Stats
Real-Time Performance Test
Best Practices
Model Design
Validation Strategies
Common Patterns
Testing Validation
Conclusion
Next Steps
Async/Sync Hybrid System
Why Hybrid Matters
How It Works
Automatic Handler Detection
Execution Contexts
Performance Characteristics
Practical Examples
CPU-Bound Operations (Use Sync)
I/O-Bound Operations (Use Async)
Mixed Workloads
Advanced Patterns
Concurrent Request Handling
Background Task Integration
Error Handling Across Contexts
Performance Comparison
Real-World Performance Test
Migration Strategies
From Sync-Only Code
From Async-Only Code
Best Practices
Choosing Sync vs Async
Performance Optimization Tips
Common Patterns
Debugging and Monitoring
Debug Async/Sync Execution
Performance Monitoring
Conclusion
Next Steps
Dependency Injection
Overview
Quick Start
Basic Dependency Injection
Simple Service Dependencies
Database Dependencies
Dependency Injection Approaches
Approach 1: FastAPI-Style Depends() (Recommended)
Approach 2: Manual Container Resolution (Alternative)
Advanced Dependency Injection
Service Scopes
Named Service Registration
Async Dependency Injection
Async Services
Database Connection Management
Enterprise Patterns
Health Monitoring
Service Composition
Performance and Best Practices
Memory Optimization
Migration from FastAPI
Less migration effort
Common Patterns
Configuration Injection
Testing with DI
Authentication & Authorization
Middleware
Overview
Quick Start
Basic Global Middleware
Per-Route Middleware
RouterGroup Middleware
Multiple RouterGroup Middleware
Basic Middleware Patterns
Request Logging
CORS Middleware
Error Handling Middleware
Advanced Middleware
Middleware with Priority
Async Middleware
Conditional Middleware
Middleware Composition
Combining Multiple Middleware
RouterGroup Middleware Composition
Custom Middleware Classes
Production Patterns
Request/Response Validation
Performance Monitoring
Best Practices
RouterGroup Middleware Best Practices
Middleware Order
Error Handling
Performance Tips
Features
Background Tasks
Overview
Quick Start
Basic Background Task
Async Background Tasks
Task Scheduling
Delayed Execution
Recurring Tasks
Task Monitoring
Progress Tracking
Real-Time Task Updates
Error Handling and Retry
Task Error Recovery
Custom Error Handlers
Production Patterns
Task Queues and Priorities
Graceful Shutdown
Task Result Storage
Persistent Results
Task Analytics
Best Practices
Task Design Guidelines
Performance Tips
Streaming
Overview
Quick Start
Basic Server-Sent Events
Real-Time Data Streaming
Advanced Streaming Patterns
Chunked File Streaming
Data Processing Pipeline
Connection Management
Simple Connection Tracking
Broadcasting Example
Real-Time Applications
Simple Chat System
Live Analytics Dashboard
Performance Optimization
Memory Efficient Streaming
Connection Health Monitoring
Best Practices
Client-Side JavaScript
Performance Guidelines
File Handling
Overview
Static File Serving
Basic Static Files
Advanced Static Configuration
File Upload Handling
Basic File Uploads
File Validation and Security
Image Processing
Basic Image Upload and Processing
Advanced File Operations
File Organization and Management
File Download and Serving
Secure File Downloads
File Management API
Best Practices
Security Guidelines
Performance Tips
Caching
Overview
Quick Start
Basic SmartCache Setup
Cache Decorator
Multi-Tier SmartCache
Configure Multi-Tier Cache
Cache Strategies
Performance Optimization
Cache Analytics
Cache Warming
Cache Key Design
Performance Benchmarking
Best Practices
Cache Configuration Tips
Common Patterns
Troubleshooting
Related Documentation
Guides
Real-World Recipes
Authentication Patterns
JWT Authentication
Session-Based Authentication
REST API Patterns
RESTful Resource Management
API Versioning
Error Handling Patterns
Comprehensive Error Handling
Rate Limiting and Throttling
Performance Monitoring
Examples
Basic Routing Examples
Hello World
Async/Sync Hybrid Example
URL Parameters with Auto-Validation
Query Parameters with Auto-Validation
Request Body Validation with BaseModel
HTTP Methods
Header and Form Validation
Advanced Routing Patterns
Error Handling Examples
Complete CRUD Example with Router Groups
Performance Comparison Example
Testing Your Catzilla Routes
Summary
Key Features Demonstrated
Next Steps
What’s Next?
Catzilla
Index
Index