fastapi-payloadshield 1.0.0__py3-none-any.whl

fastapi_payloadshield/__init__.py

@@ -0,0 +1,43 @@
+"""
+FastAPI Payload Shield Package
+Provides decorators for automatic encryption/decryption of request/response payloads
+with pluggable encryption handlers (base64, AES, Fernet, etc.)
+"""
+
+# Decorators
+from .decorators import (
+    PayloadShieldEnc,
+    PayloadShieldDec,
+    PayloadShield,
+    # Backward compatibility
+    encrypt_response,
+    decrypt_request,
+    crypto_middleware,
+)
+
+# Encryption handlers and utilities
+from .crypto import (
+    EncryptionHandler,
+    Base64EncryptionHandler,
+    register_handler,
+    get_handler,
+)
+
+__version__ = "2.0.0"
+__author__ = "Ganesh Kandu"
+
+__all__ = [
+    # New decorator names
+    "PayloadShieldEnc",
+    "PayloadShieldDec",
+    "PayloadShield",
+    # Backward compatibility
+    "encrypt_response",
+    "decrypt_request",
+    "crypto_middleware",
+    # Encryption handlers
+    "EncryptionHandler",
+    "Base64EncryptionHandler",
+    "register_handler",
+    "get_handler",
+]

fastapi_payloadshield/crypto.py

@@ -0,0 +1,206 @@
+"""
+Crypto utilities with pluggable encryption handlers
+Supports multiple encryption types (base64, AES, etc.)
+"""
+
+import base64
+import json
+from abc import ABC, abstractmethod
+from typing import Any, Dict, Union
+
+
+# ============================================================================
+# Abstract Encryption Handler Interface
+# ============================================================================
+
+class EncryptionHandler(ABC):
+    """
+    Abstract base class for encryption handlers.
+    Implement this to add support for new encryption types.
+    """
+    
+    @abstractmethod
+    def encode(self, data: Any) -> str:
+        """
+        Encode data to encrypted string.
+        
+        Args:
+            data: Dictionary or JSON serializable object
+            
+        Returns:
+            Encrypted string
+        """
+        pass
+    
+    @abstractmethod
+    def decode(self, encoded_data: str) -> Any:
+        """
+        Decode encrypted string to data.
+        
+        Args:
+            encoded_data: Encrypted string
+            
+        Returns:
+            Decoded dictionary or object
+            
+        Raises:
+            ValueError: If data cannot be decoded
+        """
+        pass
+
+
+# ============================================================================
+# Base64 Encryption Handler
+# ============================================================================
+
+class Base64EncryptionHandler(EncryptionHandler):
+    """
+    Base64 encoding/decoding handler.
+    Note: Base64 is encoding, not encryption. Use for obfuscation only.
+    """
+    
+    def encode(self, data: Any) -> str:
+        """Encode data to base64 string."""
+        if isinstance(data, dict):
+            json_str = json.dumps(data)
+        else:
+            json_str = str(data)
+        
+        return base64.b64encode(json_str.encode('utf-8')).decode('utf-8')
+    
+    def decode(self, encoded_data: str) -> Any:
+        """Decode base64 string to data."""
+        try:
+            decoded_bytes = base64.b64decode(encoded_data.encode('utf-8'))
+            decoded_str = decoded_bytes.decode('utf-8')
+            return json.loads(decoded_str)
+        except Exception as e:
+            raise ValueError(f"Failed to decode base64 data: {str(e)}")
+
+
+# ============================================================================
+# Handler Registry & Factory
+# ============================================================================
+
+_HANDLERS = {
+    "base64": Base64EncryptionHandler(),
+}
+
+
+def register_handler(name: str, handler: EncryptionHandler) -> None:
+    """
+    Register a new encryption handler.
+    
+    Example:
+        from cryptography.fernet import Fernet
+        
+        class FernetEncryptionHandler(EncryptionHandler):
+            def __init__(self, key):
+                self.cipher = Fernet(key)
+            
+            def encode(self, data):
+                # implementation
+                pass
+            
+            def decode(self, encoded_data):
+                # implementation
+                pass
+        
+        key = Fernet.generate_key()
+        register_handler("fernet", FernetEncryptionHandler(key))
+    """
+    _HANDLERS[name.lower()] = handler
+
+
+def get_handler(name: str) -> EncryptionHandler:
+    """
+    Get a registered encryption handler by name.
+    
+    Args:
+        name: Name of the handler (e.g., "base64", "aes", "fernet")
+        
+    Returns:
+        EncryptionHandler instance
+        
+    Raises:
+        ValueError: If handler not found
+    """
+    handler_name = name.lower()
+    if handler_name not in _HANDLERS:
+        available = ", ".join(_HANDLERS.keys())
+        raise ValueError(
+            f"Encryption handler '{name}' not found. "
+            f"Available handlers: {available}"
+        )
+    return _HANDLERS[handler_name]
+
+
+# ============================================================================
+# Legacy Utility Functions (for backward compatibility)
+# ============================================================================
+
+def encode_base64(data: Any) -> str:
+    """
+    Encode data to base64 string.
+    
+    Args:
+        data: Dictionary or JSON serializable object
+        
+    Returns:
+        Base64 encoded string
+    """
+    handler = get_handler("base64")
+    return handler.encode(data)
+
+
+def decode_base64(encoded_data: str) -> Union[Dict, Any]:
+    """
+    Decode base64 string to data.
+    
+    Args:
+        encoded_data: Base64 encoded string
+        
+    Returns:
+        Decoded dictionary or object
+        
+    Raises:
+        ValueError: If data cannot be decoded
+    """
+    handler = get_handler("base64")
+    return handler.decode(encoded_data)
+
+
+def encode_response(data: Any, handler: EncryptionHandler = None) -> Dict[str, str]:
+    """
+    Encode response data with encryption handler.
+    
+    Args:
+        data: Response data to encode
+        handler: EncryptionHandler instance (uses base64 if None)
+        
+    Returns:
+        Dictionary with 'encrypted' key containing encoded data
+    """
+    if handler is None:
+        handler = get_handler("base64")
+    
+    return {
+        "encrypted": handler.encode(data)
+    }
+
+
+def decode_request(encoded_data: str, handler: EncryptionHandler = None) -> Any:
+    """
+    Decode request data with encryption handler.
+    
+    Args:
+        encoded_data: Encrypted request data
+        handler: EncryptionHandler instance (uses base64 if None)
+        
+    Returns:
+        Decoded request data
+    """
+    if handler is None:
+        handler = get_handler("base64")
+    
+    return handler.decode(encoded_data)

fastapi_payloadshield/decorators.py

@@ -0,0 +1,229 @@
+"""
+Decorators for automatic payload encryption/decryption in FastAPI
+Supports multiple encryption types via pluggable EncryptionHandler interface
+"""
+
+from functools import wraps
+from typing import Callable, Any, Optional
+from fastapi import Request
+from fastapi.responses import JSONResponse
+from .crypto import (
+    EncryptionHandler,
+    get_handler,
+    encode_response,
+    decode_request,
+)
+
+
+# ============================================================================
+# PayloadShieldEnc - Response Encryption Decorator
+# ============================================================================
+
+def PayloadShieldEnc(encryption_type: str = "base64"):
+    """
+    Decorator to automatically encrypt response payload.
+    
+    The decorator intercepts the response and wraps it in a JSON object with
+    an 'encrypted' key containing the encrypted response.
+    
+    Args:
+        encryption_type: Type of encryption to use (default: "base64")
+                        Options: "base64", "aes", "fernet", etc.
+                        Register custom handlers with register_handler()
+    
+    Usage:
+        @app.get("/api/endpoint")
+        @PayloadShieldEnc("base64")
+        async def my_route():
+            return {"message": "hello", "data": "world"}
+        
+        # Response: {"encrypted": "base64_encoded_data"}
+    
+    Returns:
+        Decorator function
+    """
+    def decorator(func: Callable) -> Callable:
+        handler = get_handler(encryption_type)
+        
+        @wraps(func)
+        async def wrapper(*args, **kwargs):
+            result = await func(*args, **kwargs)
+            
+            # Handle different response types
+            if isinstance(result, dict):
+                encrypted = encode_response(result, handler)
+            else:
+                encrypted = encode_response({"data": result}, handler)
+            
+            return JSONResponse(content=encrypted)
+        
+        return wrapper
+    
+    return decorator
+
+
+# ============================================================================
+# PayloadShieldDec - Request Decryption Decorator
+# ============================================================================
+
+def PayloadShieldDec(encryption_type: str = "base64"):
+    """
+    Decorator to automatically decrypt encrypted request payload.
+    
+    The decorator expects the request body to be a JSON object with an 'encrypted' key
+    containing the encrypted data. It decodes this and passes the original data
+    to the route function.
+    
+    Args:
+        encryption_type: Type of encryption to use (default: "base64")
+                        Options: "base64", "aes", "fernet", etc.
+                        Register custom handlers with register_handler()
+    
+    Usage:
+        @app.post("/api/endpoint")
+        @PayloadShieldDec("base64")
+        async def my_route(data: dict):
+            # data will be automatically decrypted
+            return {"message": "success"}
+        
+        # Expects: {"encrypted": "encrypted_data"}
+    
+    Returns:
+        Decorator function
+    """
+    def decorator(func: Callable) -> Callable:
+        handler = get_handler(encryption_type)
+        
+        @wraps(func)
+        async def wrapper(*args, **kwargs):
+            # Check if first argument is a Request object
+            request = None
+            for arg in args:
+                if isinstance(arg, Request):
+                    request = arg
+                    break
+            
+            if request:
+                try:
+                    body = await request.json()
+                    if isinstance(body, dict) and "encrypted" in body:
+                        # Decrypt the encrypted data
+                        decrypted_data = decode_request(body["encrypted"], handler)
+                        # Replace the request body in kwargs
+                        for key, value in kwargs.items():
+                            if isinstance(value, dict) and value == body:
+                                kwargs[key] = decrypted_data
+                                break
+                except Exception as e:
+                    return JSONResponse(
+                        status_code=400,
+                        content={"error": f"Failed to decrypt request: {str(e)}"}
+                    )
+            
+            return await func(*args, **kwargs)
+        
+        return wrapper
+    
+    return decorator
+
+
+# ============================================================================
+# PayloadShield - Combined Encryption & Decryption Decorator
+# ============================================================================
+
+def PayloadShield(encryption_type: str = "base64"):
+    """
+    Combined decorator for both request decryption and response encryption.
+    
+    Automatically handles both incoming encrypted requests and outgoing encrypted responses.
+    
+    Args:
+        encryption_type: Type of encryption to use (default: "base64")
+                        Options: "base64", "aes", "fernet", etc.
+                        Register custom handlers with register_handler()
+    
+    Usage:
+        @app.post("/api/endpoint")
+        @PayloadShield("base64")
+        async def my_route(data: dict):
+            # Automatically decrypts incoming request and encrypts response
+            return {"message": "success"}
+        
+        # Expects: {"encrypted": "encrypted_data"}
+        # Returns: {"encrypted": "encrypted_data"}
+    
+    Returns:
+        Decorator function
+    """
+    def decorator(func: Callable) -> Callable:
+        handler = get_handler(encryption_type)
+        
+        @wraps(func)
+        async def wrapper(*args, **kwargs):
+            # Handle request decryption
+            request = None
+            for arg in args:
+                if isinstance(arg, Request):
+                    request = arg
+                    break
+            
+            if request:
+                try:
+                    body = await request.json()
+                    if isinstance(body, dict) and "encrypted" in body:
+                        decrypted_data = decode_request(body["encrypted"], handler)
+                        for key, value in kwargs.items():
+                            if isinstance(value, dict) and value == body:
+                                kwargs[key] = decrypted_data
+                                break
+                except Exception as e:
+                    return JSONResponse(
+                        status_code=400,
+                        content={"error": f"Failed to decrypt request: {str(e)}"}
+                    )
+            
+            # Call the original function
+            result = await func(*args, **kwargs)
+            
+            # Handle response encryption
+            if isinstance(result, dict):
+                encrypted = encode_response(result, handler)
+            else:
+                encrypted = encode_response({"data": result}, handler)
+            
+            return JSONResponse(content=encrypted)
+        
+        return wrapper
+    
+    return decorator
+
+
+# ============================================================================
+# Backward Compatibility - Old Decorator Names
+# ============================================================================
+
+def encrypt_response(func: Callable) -> Callable:
+    """
+    Deprecated: Use PayloadShieldEnc("base64") instead.
+    
+    Decorator to automatically encrypt response payload with base64.
+    """
+    return PayloadShieldEnc("base64")(func)
+
+
+def decrypt_request(func: Callable) -> Callable:
+    """
+    Deprecated: Use PayloadShieldDec("base64") instead.
+    
+    Decorator to automatically decrypt base64 encoded request payload.
+    """
+    return PayloadShieldDec("base64")(func)
+
+
+def crypto_middleware(func: Callable) -> Callable:
+    """
+    Deprecated: Use PayloadShield("base64") instead.
+    
+    Combined decorator for both request decryption and response encryption.
+    """
+    return PayloadShield("base64")(func)

fastapi_payloadshield-1.0.0.dist-info/METADATA

@@ -0,0 +1,364 @@
+Metadata-Version: 2.4
+Name: fastapi_payloadshield
+Version: 1.0.0
+Summary: FastAPI decorators for automatic base64 encryption/decryption of request/response payloads
+Home-page: https://github.com/PayloadShield/FastAPIPS
+Author: Ganesh Kandu
+Author-email: Ganesh Kandu <kanduganesh@gmail.com>
+License: Apache-2.0
+Project-URL: Homepage, https://github.com/PayloadShield/FastAPIPS
+Project-URL: Repository, https://github.com/PayloadShield/FastAPIPS.git
+Project-URL: Issues, https://github.com/PayloadShield/FastAPIPS/issues
+Keywords: fastapi,base64,crypto,encryption,decorator
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Framework :: FastAPI
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: fastapi>=0.68.0
+Requires-Dist: starlette>=0.19.0
+Provides-Extra: dev
+Requires-Dist: pytest>=6.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.18.0; extra == "dev"
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# FastAPI Payload Shield
+
+Lightweight FastAPI decorators for automatic encryption/decryption of request and response payloads. **Supports pluggable encryption handlers** - easily add new encryption types like AES, Fernet, or custom algorithms!
+
+## 🎯 Key Features
+
+- 🔒 **Flexible Encryption**: Multiple encryption types (base64, AES, Fernet, custom)
+- 🔓 **Automatic Decryption**: Decrypt incoming requests automatically
+- 📝 **JSON-Friendly**: Works seamlessly with JSON requests and responses
+- 🎯 **Route-Agnostic**: No changes needed to your existing route logic
+- ⚡ **Lightweight**: Minimal dependencies and overhead
+- 🚀 **Easy Integration**: Just add decorators to your routes
+- 🧩 **Pluggable**: Create custom encryption handlers easily
+
+## Installation
+
+### From Local Development
+```bash
+cd FastAPIPS
+pip install -e .
+```
+
+### From PyPI (when published)
+```bash
+pip install fastapi_payloadshield
+```
+
+## Quick Start
+
+### Basic Usage with Base64
+
+```python
+from fastapi import FastAPI
+from fastapi_payloadshield import PayloadShieldEnc, PayloadShieldDec, PayloadShield
+
+app = FastAPI()
+
+# Encrypt response only
+@app.get("/api/data")
+@PayloadShieldEnc("base64")
+async def get_data():
+    return {"message": "hello", "data": "world"}
+
+# Decrypt request only
+@app.post("/api/process")
+@PayloadShieldDec("base64")
+async def process_data(data: dict):
+    return {"received": data, "status": "success"}
+
+@app.post("/api/secure")
+@PayloadShield("base64")
+async def secure_endpoint(data: dict):
+    return {"processed": data}
+```
+
+## Decorators
+
+### `@PayloadShieldEnc(encryption_type)`
+
+Encrypts the response payload.
+
+```python
+@app.get("/api/users")
+@PayloadShieldEnc("base64")
+async def get_users():
+    return [{"id": 1, "name": "Alice"}]
+
+# Response: {"encrypted": "W3siaWQiOiAxLCAibmFtZSI6ICJBbGljZSJ9XQ=="}
+```
+
+### `@PayloadShieldDec(encryption_type)`
+
+Decrypts the request payload.
+
+```python
+@app.post("/api/login")
+@PayloadShieldDec("base64")
+async def login(credentials: dict):
+    return {"status": "success"}
+
+# Expects: {"encrypted": "base64_encoded_json"}
+```
+
+### `@PayloadShield(encryption_type)`
+
+Combined encryption and decryption
+
+```python
+@app.post("/api/secure")
+@PayloadShield("base64")
+async def secure_endpoint(data: dict):
+    return {"processed": data}
+
+# Expects: {"encrypted": "encrypted_data"}
+# Returns: {"encrypted": "encrypted_data"}
+```
+
+## Advanced Example: Multiple Encryption Types
+
+```python
+from fastapi import FastAPI
+from fastapi_payloadshield import PayloadShield, register_handler, EncryptionHandler
+from cryptography.fernet import Fernet
+import json
+
+app = FastAPI()
+
+# Create Fernet handler
+class FernetHandler(EncryptionHandler):
+    def __init__(self, key):
+        self.cipher = Fernet(key)
+    
+    def encode(self, data):
+        return self.cipher.encrypt(json.dumps(data).encode()).decode()
+    
+    def decode(self, encoded_data):
+        return json.loads(self.cipher.decrypt(encoded_data.encode()))
+
+# Register
+key = Fernet.generate_key()
+register_handler("fernet", FernetHandler(key))
+
+# Use different encryption for different endpoints
+@app.post("/api/public")
+@PayloadShield("base64")  # Light encryption
+async def public_endpoint(data: dict):
+    return data
+
+@app.post("/api/private")
+@PayloadShield("fernet")  # Strong encryption
+async def private_endpoint(data: dict):
+    return data
+```
+
+## How It Works
+
+### Request Decryption Flow
+1. Client sends: `{"encrypted": "encrypted_data"}`
+2. `@PayloadShieldDec` decorator intercepts
+3. Decrypts using specified handler
+4. Route receives: `{"key": "value"}` (normal dict)
+
+### Response Encryption Flow
+1. Route returns: `{"key": "value"}`
+2. `@PayloadShieldEnc` decorator intercepts
+3. Encrypts using specified handler
+4. Client receives: `{"encrypted": "encrypted_data"}`
+
+## Testing
+
+### Run Example Application
+```bash
+python examples/example_app.py
+```
+
+### Run Test Client
+```bash
+python examples/test_client.py
+```
+
+### Manual Test with cURL
+
+```bash
+# Encrypt test data
+echo '{"username":"admin"}' | base64
+# eyJ1c2VybmFtZSI6ImFkbWluIn0=
+
+# Send encrypted request
+curl -X POST http://localhost:8000/api/login \
+  -H "Content-Type: application/json" \
+  -d '{"encrypted":"eyJ1c2VybmFtZSI6ImFkbWluIn0="}'
+```
+
+### Testing with Python
+```python
+import requests
+import json
+import base64
+
+# Encode request
+data = {"username": "admin", "password": "secret"}
+json_str = json.dumps(data)
+encrypted = base64.b64encode(json_str.encode()).decode()
+
+# Send request
+response = requests.post(
+    "http://localhost:8000/api/login",
+    json={"encrypted": encrypted}
+)
+
+# Decode response
+encrypted_response = response.json()["encrypted"]
+decrypted = json.loads(base64.b64decode(encrypted_response).decode())
+print(decrypted)
+# {'status': 'success', 'token': 'abc123'}
+```
+
+## Creating Custom Encryption Handlers
+
+See [CUSTOM_HANDLERS.md](CUSTOM_HANDLERS.md) for detailed guide on:
+
+- Creating custom handlers
+- Fernet encryption example
+- AES encryption example
+- Best practices
+- Performance tips
+- Security considerations
+
+## Backward Compatibility
+
+Old decorator names still work:
+
+```python
+from fastapi_payloadshield import encrypt_response, decrypt_request, crypto_middleware
+
+# These are equivalent to:
+# PayloadShieldEnc("base64")
+# PayloadShieldDec("base64")
+# PayloadShield("base64")
+
+@app.get("/api/data")
+@encrypt_response
+async def get_data():
+    return {"data": "value"}
+```
+
+## API Reference
+
+### Decorators
+
+| Decorator | Purpose |
+|-----------|---------|
+| `PayloadShieldEnc(type)` | Encrypt response |
+| `PayloadShieldDec(type)` | Decrypt request |
+| `PayloadShield(type)` | Both encrypt & decrypt |
+
+### Functions
+
+| Function | Purpose |
+|----------|---------|
+| `register_handler(name, handler)` | Register custom encryption handler |
+| `get_handler(name)` | Get handler by name |
+| `EncryptionHandler` | Base class for handlers |
+
+### Built-in Handlers
+
+| Handler | Type | Security | Use Case |
+|---------|------|----------|----------|
+| `base64` | Encoding | None | Obfuscation, development |
+
+## Error Handling
+
+The decorators include built-in error handling:
+
+```python
+# Invalid encrypted data
+# Response: {"error": "Failed to decrypt request: ..."}
+
+# Missing encryption handler  
+# Response: ValueError: Encryption handler 'xyz' not found. Available: base64, fernet
+```
+
+## Performance Considerations
+
+- **Caching**: Handler instances are cached
+- **Compression**: Consider compressing before encryption for large payloads
+- **Async**: All operations are async-friendly
+
+## Requirements
+
+- Python 3.7+
+- FastAPI 0.68+
+- Starlette 0.19+
+
+## Files Included
+
+- `fastapi_payloadshield/` - Main package
+  - `__init__.py` - Exports decorators and handlers
+  - `crypto.py` - Encryption handlers
+  - `decorators.py` - FastAPI decorators
+- `examples/` - Working examples
+  - `example_app.py` - Full-featured demo
+  - `test_client.py` - Test/client script
+- `README.md` - This file
+- `QUICKSTART.md` - Quick start guide
+- `CUSTOM_HANDLERS.md` - Creating custom handlers
+- `DEVELOPMENT.md` - Development guide
+
+## License
+
+Apache-2.0 - See LICENSE file for details
+
+## Contributing
+
+Contributions welcome! Areas for contribution:
+
+1. New encryption handlers (AES, Fernet, etc.)
+2. Performance optimizations
+3. Documentation improvements
+4. Test coverage
+5. Examples
+
+## Support
+
+- 📖 Full guide: [README.md](README.md)
+- ⚡ Quick start: [QUICKSTART.md](QUICKSTART.md)
+- 🧩 Custom handlers: [CUSTOM_HANDLERS.md](CUSTOM_HANDLERS.md)
+- 🛠️ Development: [DEVELOPMENT.md](DEVELOPMENT.md)
+
+---
+
+**Happy encrypting!** 🔒
+
+## Why Payload Shield?
+
+This package was designed with extensibility in mind. Unlike static encryption libraries, Payload Shield lets you:
+
+- Mix and match encryption types in the same app
+- Add new encryption types without touching core code
+- Keep route logic clean and simple
+- Support multiple security levels
+
+Perfect for:
+- Building multi-tier security APIs
+- Migrating from one encryption to another
+- Testing different encryption strategies
+- Production systems requiring flexible crypto

fastapi_payloadshield-1.0.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+fastapi_payloadshield/__init__.py,sha256=LmGDsOSDmwkN-pSmS20ei92RT0W2AS0w7FVeok3BzHU,969
+fastapi_payloadshield/crypto.py,sha256=O-AjgJUlywp4f2tK4Fg-hBOT1Ouz_Y-gsTe_R28UTkM,5811
+fastapi_payloadshield/decorators.py,sha256=D8ph3Wq0E1PT58htsshJHI2W5fodXvYcOglU403lGVQ,8214
+fastapi_payloadshield-1.0.0.dist-info/licenses/LICENSE,sha256=y-lTKIS0jHHMx0Q3zimWoYF-2snYD1e3QVQUuMBzoC0,6535
+fastapi_payloadshield-1.0.0.dist-info/METADATA,sha256=72-RPyFq7iiXPt0VP-Wg_ATcqzsps_DF2ipsIlbS7KY,9950
+fastapi_payloadshield-1.0.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+fastapi_payloadshield-1.0.0.dist-info/top_level.txt,sha256=eebO3hvNAOw8hutul4CiOt2sXRq-YqgULWFWM-Lxd94,22
+fastapi_payloadshield-1.0.0.dist-info/RECORD,,

fastapi_payloadshield-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

fastapi_payloadshield-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,133 @@
+Apache License
+Version 2.0, January 2004
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined in Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity exercising
+   permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or Object
+   form, made available under the License, including but not limited to
+   the software source code, documentation source, and configuration files.
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications thereof
+   or derivative works thereof.
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+   "Licensed Patents" shall mean the patent claims licensable by Licensor
+   that are necessarily infringed by the use or sale of either the Work
+   or Contribution alone or by combination with the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in the License) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work; and
+
+   (d) If the Work includes a "NOTICE" text file, then any
+       Derivative Works that You distribute must include a readable
+       copy of the attribution notices contained within such NOTICE file.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+   or implied, including, without limitation, any warranties or
+   conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or
+   FITNESS FOR A PARTICULAR PURPOSE.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this License.
+
+END OF TERMS AND CONDITIONS
+
+Copyright 2024 FastAPI Payload Shield Contributors
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

fastapi_payloadshield-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+fastapi_payloadshield