Welcome to Rick

Rick is a comprehensive plumbing library for building microframework-based Python applications. It provides essential building blocks and utilities for constructing robust, maintainable applications without imposing architectural constraints.

What Rick Is: - A collection of battle-tested utilities and components - Foundation for building custom frameworks and applications - Lightweight and modular with minimal dependencies - Python 3.10+ compatible

What Rick Is Not: - Not a web framework (no HTTP/WSGI/ASGI functionality) - Not a database ORM (use RickDb for database operations) - Not opinionated about application structure

Core Philosophy

Rick follows these principles:

Modularity - Use only what you need
Simplicity - Clear, straightforward APIs
Flexibility - Adapt to your architecture, not the other way around
Reliability - Comprehensive test coverage and type support
Performance - Efficient implementations with minimal overhead

Quick Start

Installation

pip install rick

Basic Example

from rick.base import Di
from rick.form import RequestRecord, Field
from rick.resource.config import EnvironmentConfig
from rick.resource.redis import RedisCache

# Dependency Injection
di = Di()
di.add('cache', RedisCache(host='localhost'))
cache = di.get('cache')

# Form Validation
class UserForm(RequestRecord):
    def __init__(self):
        super().__init__()
        self.field('email', validators='required|email')
        self.field('password', validators='required|minlen:8')

form = UserForm()
if form.is_valid({'email': 'user@example.com', 'password': 'secret123'}):
    print("Valid!")

# Configuration
class AppConfig(EnvironmentConfig):
    DB_HOST = 'localhost'
    DB_PORT = 5432
    DEBUG = False

config = AppConfig().build()

Components

Core Components

Base Classes

Dependency Injection (Di) - Service container with singleton and factory patterns
Container Classes - Immutable and mutable data containers
Registry - Thread-safe class registration and retrieval
MapLoader - Dynamic class loading and instantiation

Forms and Validation

RequestRecord - Request validation with nested record support
Form - Full-featured forms with fieldsets and controls
Field - Field definitions with validators and filters
30+ Validators - Email, IP, UUID, numeric, string validators
Filters - Input transformation and sanitization

Serialization

Serializers

JSON Serializer - Extended JSON encoding with Python type support
ExtendedJsonEncoder for standard serialization
CamelCaseJsonEncoder for JavaScript compatibility
Supports datetime, Decimal, UUID, dataclasses
MessagePack Serializer - Binary serialization with full type preservation
Bidirectional encoding/decoding
30-50% smaller than JSON
2-4x faster serialization
Full support for custom objects and dataclasses

Resources

Configuration Management

EnvironmentConfig - Environment variable loading with type conversion
JsonFileConfig - JSON configuration files
TomlFileConfig - TOML configuration files
HybridFileConfig - Auto-detect JSON or TOML
Custom validation functions
StrOrFile wrapper for loading secrets from files

Caching

RedisCache - Redis caching with pickle serialization
CryptRedisCache - Encrypted Redis cache with Fernet256
Custom serialization support (pickle, JSON, MessagePack)
Key prefixing for namespace isolation
TTL support for automatic expiration
Full Redis client access for advanced operations

Console Output

AnsiColor - ANSI color formatting with 16 colors
ConsoleWriter - High-level console writer
Semantic output methods (success, error, warning, header)
Text attributes (bold, dim, underline, reversed)
Separate stdout and stderr streams

Other Resources

Event Manager - Event dispatching and handling
Stream Processing - MultiPartReader for multipart/form-data
File Operations - File handling utilities

Security and Cryptography

Crypto

Fernet256 - 256-bit encryption (adapted from cryptography library)
MultiFernet256 - Multi-key encryption support
BCrypt - Password hashing
Buffer Utilities - Hash functions (SHA1, SHA256, SHA512)

Mixins

Injectable - Dependency injection integration
Runnable - Runnable interface for services
Translator - Internationalization and localization support

Feature Highlights

Dependency Injection

from rick.base import Di

# Create DI container
di = Di()

# Register singleton
di.add('config', config_instance)

# Register factory
def create_logger(di_instance):
    return {'name': 'logger'}

di.add('logger', create_logger)

# Retrieve services
config = di.get('config')
logger = di.get('logger')

Form Validation

from rick.form import RequestRecord

class RegistrationForm(RequestRecord):
    def __init__(self):
        super().__init__()
        self.field('username', validators='required|alphanum|minlen:3')
        self.field('email', validators='required|email')
        self.field('password', validators='required|minlen:8')
        self.field('age', validators='required|int|between:18,120')

    def validate_username(self, data, field):
        # Custom validation
        if data['username'] in ['admin', 'root']:
            self.add_error('username', 'Username not allowed')
            return False
        return True

form = RegistrationForm()
if form.is_valid(request_data):
    # Process valid data
    user_data = form.get_data()
else:
    # Handle errors
    errors = form.get_errors()

Configuration Management

from rick.resource.config import EnvironmentConfig, StrOrFile

class ProductionConfig(EnvironmentConfig):
    # Database settings
    DB_HOST = 'localhost'
    DB_PORT = 5432
    DB_PASSWORD = StrOrFile(None)  # Load from file

    # Application settings
    DEBUG = False
    SECRET_KEY = StrOrFile(None)
    MAX_WORKERS = 4

    def validate_database(self, data: dict):
        """Ensure database is properly configured"""
        if not data.get('db_host'):
            raise ValueError("Database host is required")

# Environment variables override defaults
# export DB_HOST=production-server
# export DB_PASSWORD=/secrets/db-password.txt

config = ProductionConfig().build()

Redis Caching

from rick.resource.redis import RedisCache, CryptRedisCache
from rick.serializer.msgpack import msgpack

# Standard cache with MessagePack
cache = RedisCache(
    host='localhost',
    serializer=msgpack.packb,
    deserializer=msgpack.unpackb,
    prefix='myapp:'
)

cache.set('user:123', user_data, ttl=3600)
user = cache.get('user:123')

# Encrypted cache for sensitive data
secure_cache = CryptRedisCache(
    key='your-64-character-encryption-key-here-must-be-exactly-64ch',
    host='localhost'
)

secure_cache.set('api_token', {'token': 'secret123'})

Serialization

from rick.serializer.json.json import ExtendedJsonEncoder, CamelCaseJsonEncoder
from rick.serializer.msgpack import msgpack
import json
from datetime import datetime
from decimal import Decimal

# JSON serialization
data = {
    'timestamp': datetime.now(),
    'amount': Decimal('123.45'),
    'status': 'active'
}

# Standard JSON
json_str = json.dumps(data, cls=ExtendedJsonEncoder)

# CamelCase for JavaScript
json_str = json.dumps(data, cls=CamelCaseJsonEncoder)

# MessagePack - faster and smaller
packed = msgpack.packb(data)
restored = msgpack.unpackb(packed)  # Full type preservation

Console Output

from rick.resource.console import ConsoleWriter, AnsiColor

# High-level semantic output
console = ConsoleWriter()
console.header('Application Startup')
console.success('Database connected')
console.warn('Cache disabled')
console.error('Plugin failed to load')

# Low-level color formatting
color = AnsiColor()
print(color.red('Error:', attr='bold') + ' Operation failed')
print(color.green('Success', 'white', ['bold', 'underline']))

Architecture Pattern

Rick follows a modular architecture where each component is independent:

rick/
├── base/          # DI, Registry, Containers
├── form/          # Forms and RequestRecord
├── validator/     # Validation rules
├── filter/        # Input filters
├── serializer/    # JSON and MessagePack
├── resource/      # External resources
│   ├── config/    # Configuration loaders
│   ├── redis/     # Redis caching
│   ├── console/   # Console output
│   └── stream/    # Stream processing
├── crypto/        # Encryption utilities
├── event/         # Event system
├── mixin/         # Reusable mixins
└── util/          # General utilities

Documentation Structure

Forms - Form handling and request validation
Validators - Available validation rules
Serializers - JSON and MessagePack serialization
Resources - Caching, configuration, console, and more
Mixins - Translation and other mixins

RickDb - Database abstraction layer
Flask - Web framework (recommended for HTTP functionality)

Rick is released under an open-source license. See the LICENSE file for details.

Getting Started

Request Validation - Validate incoming requests
Configuration Management - Load and validate configuration
Redis Caching - Implement caching strategies
Serialization - Efficient data encoding
Console Output - Build beautiful CLI applications

Welcome to Rick

Core Philosophy

Quick Start

Installation

Basic Example

Components

Core Components

Base Classes

Forms and Validation

Serialization

Serializers

Resources

Configuration Management

Caching

Console Output

Other Resources

Security and Cryptography

Crypto

Mixins

Feature Highlights

Dependency Injection

Form Validation

Configuration Management

Redis Caching

Serialization

Console Output

Architecture Pattern

Documentation Structure

Related Projects

Getting Started