### Configure Serialization Options with OrjsonProvider.option

Source: https://context7.com/pallets-eco/flask-orjson/llms.txt

This example illustrates how to configure default orjson serialization options using the `OrjsonProvider.option` class attribute. Setting this attribute affects all subsequent `dumps` calls made through the provider instance. The example shows how to apply `orjson.OPT_INDENT_2` and `orjson.OPT_SORT_KEYS` for pretty-printed and sorted JSON output.

```python
from flask import Flask
from flask_orjson import OrjsonProvider
import orjson

app = Flask(__name__)
provider = OrjsonProvider(app)
app.json = provider

# Example 1: Set instance-level options (affects all dumps calls)
provider.option = orjson.OPT_INDENT_2 | orjson.OPT_SORT_KEYS
result = app.json.dumps({'z': 3, 'a': 1, 'b': 2})
# Result: Pretty-printed, sorted JSON:
# {
#   "a": 1,
#   "b": 2,
#   "z": 3
# }
```

--------------------------------

### Integrate OrjsonProvider with Flask

Source: https://context7.com/pallets-eco/flask-orjson/llms.txt

This snippet demonstrates the basic setup of flask-orjson by replacing Flask's default JSON provider with `OrjsonProvider`. It shows how `OrjsonProvider` automatically handles JSON parsing for incoming requests (`request.json`) and serialization for responses using the fast orjson library.

```python
from flask import Flask, request
from flask_orjson import OrjsonProvider
from datetime import datetime
from decimal import Decimal

# Basic setup - replace Flask's default JSON provider
app = Flask(__name__)
app.json = OrjsonProvider(app)

@app.route('/api/data', methods=['POST'])
def handle_data():
    # Automatically uses orjson for request.json parsing
    data = request.json

    # Automatically uses orjson for response serialization
    return {
        'received': data,
        'timestamp': datetime.now(),
        'value': Decimal('99.99')
    }

if __name__ == '__main__':
    app.run()
```

--------------------------------

### Flask Request/Response Integration with Flask-Orjson

Source: https://context7.com/pallets-eco/flask-orjson/llms.txt

A comprehensive example showcasing how Flask-Orjson seamlessly integrates with Flask's request and response cycle. It demonstrates automatic JSON deserialization of incoming requests using `request.json` and automatic JSON serialization of responses using `orjson.dumps()`. Includes routes for handling POST requests with order data and GET requests returning complex data types, along with error handling for serialization issues.

```python
from flask import Flask, request, jsonify
from flask_orjson import OrjsonProvider
from datetime import datetime, timezone, timedelta
from decimal import Decimal

app = Flask(__name__)
app.json = OrjsonProvider(app)

@app.route('/api/order', methods=['POST'])
def create_order():
    """Receives JSON order data and returns processed response"""
    # request.json automatically uses orjson.loads()
    order_data = request.json

    if not order_data:
        return {'error': 'No data provided'}, 400

    # Process and return response (automatically uses orjson.dumps())
    response = {
        'order_id': f"ORD-{order_data.get('id', '000')}",
        'items': order_data.get('items', []),
        'total': Decimal(str(order_data.get('total', '0.00'))),
        'processed_at': datetime.now(timezone.utc),
        'status': 'pending'
    }

    return response, 201

@app.route('/api/report', methods=['GET'])
def get_report():
    """Returns complex data types with automatic serialization"""
    pst = timezone(timedelta(hours=-8), 'PST')

    report = {
        'generated_at': datetime.now(timezone.utc),
        'region_time': datetime.now(pst),
        'metrics': {
            'revenue': Decimal('15234.56'),
            'cost': Decimal('8123.45'),
            'margin': Decimal('7111.11')
        },
        'items': [
            {'id': 1, 'value': Decimal('100.50')},
            {'id': 2, 'value': Decimal('250.75')}
        ]
    }

    return report

@app.errorhandler(TypeError)
def handle_serialization_error(e):
    """Catch serialization errors for unsupported types"""
    return {
        'error': 'Serialization error',
        'message': str(e)
    }, 500

if __name__ == '__main__':
    app.run(debug=True)

```

--------------------------------

### Serialize Python Objects to JSON with OrjsonProvider

Source: https://context7.com/pallets-eco/flask-orjson/llms.txt

This example showcases the `OrjsonProvider.dumps()` method for converting Python objects into JSON strings. It illustrates basic serialization, the use of `orjson.OPT_NON_STR_KEYS` for handling non-string keys, and implementing a `custom_default` handler for serializing unsupported types like custom class instances.

```python
from flask import Flask
from flask_orjson import OrjsonProvider
from decimal import Decimal
from datetime import datetime, timezone
import orjson

app = Flask(__name__)
app.json = OrjsonProvider(app)

# Example 1: Basic serialization with default settings
data = {
    'name': 'Alice',
    'balance': Decimal('1234.56'),
    'created_at': datetime(2024, 1, 12, 9, 42)
}
json_str = app.json.dumps(data)
# Result: '{"name":"Alice","balance":"1234.56","created_at":"2024-01-12T09:42:00+00:00"}'

# Example 2: Using option flags for non-string keys
data_with_int_keys = {1: 'one', 2: 'two', 3: 'three'}
json_str = app.json.dumps(data_with_int_keys, option=orjson.OPT_NON_STR_KEYS)
# Result: '{"1":"one","2":"two","3":"three"}'

# Example 3: Custom default handler for unsupported types
class User:
    def __init__(self, name, email):
        self.name = name
        self.email = email

def custom_default(obj):
    if isinstance(obj, User):
        return {'name': obj.name, 'email': obj.email}
    raise TypeError(f'Type {type(obj)} not serializable')

user = User('Bob', 'bob@example.com')
json_str = app.json.dumps({'user': user}, default=custom_default)
# Result: '{"user":{"name":"Bob","email":"bob@example.com"}}'
```

--------------------------------

### Initialize Flask App with OrjsonProvider

Source: https://github.com/pallets-eco/flask-orjson/blob/main/docs/index.md

This snippet demonstrates how to initialize a Flask application and configure it to use the OrjsonProvider for faster JSON processing. It requires the Flask and flask_orjson libraries.

```python
from flask import Flask
from flask_orjson import OrjsonProvider

app = Flask(__name__)
json_provider = OrjsonProvider(app)
app.json = json_provider
```

--------------------------------

### Initialize OrjsonProvider in Flask

Source: https://github.com/pallets-eco/flask-orjson/blob/main/docs/api.md

Initialize the OrjsonProvider with a Flask application instance. This provider replaces Flask's default JSON handling with the faster orjson library. It accepts optional flags for orjson.dumps and a default function for handling unsupported types.

```python
from flask import Flask
from flask_orjson import OrjsonProvider

app = Flask(__name__)
app.json = OrjsonProvider(app)

# Optional: Configure default options or default function
# app.json.option = orjson.OPT_INDENT_2
# app.json.default = my_custom_default_handler
```

--------------------------------

### Initialize OrjsonProvider in Flask Application

Source: https://github.com/pallets-eco/flask-orjson/blob/main/docs/changes.md

Demonstrates how to integrate OrjsonProvider with a Flask application. This involves instantiating OrjsonProvider and assigning it to the app.json attribute. The provider can be configured using its 'option' and 'default' attributes, or by passing keyword arguments to the 'dumps' method.

```python
from flask import Flask
from flask_orjson import OrjsonProvider

app = Flask(__name__)
app.json = OrjsonProvider(app)

@app.route('/')
def index():
    return {"hello": "world"}

# Example with custom options
# app.json.option = orjson.OPT_INDENT_2
# app.json.default = lambda o: o.isoformat()

# Or passing options to dumps directly
# @app.route('/data')
# def get_data():
#     return app.json.dumps({"name": "test"}, option=orjson.OPT_SORT_REVERSE)

```

--------------------------------

### Configure OrjsonProvider in Flask

Source: https://github.com/pallets-eco/flask-orjson/blob/main/CHANGES.md

In version 2.0.0 and later, the ORJSON extension class is removed. Instead, instantiate OrjsonProvider and assign it to app.json. The provider allows configuration via 'option' and 'default' attributes or keyword arguments to 'dumps'. Naive datetime objects will default to UTC.

```python
from flask import Flask
from flask_orjson import OrjsonProvider

app = Flask(__name__)
app.json = OrjsonProvider(app)

@app.route('/')
def index():
    return {'message': 'Hello, World!'}

```

--------------------------------

### Set Orjson Options with OrjsonProvider

Source: https://github.com/pallets-eco/flask-orjson/blob/main/CHANGES.md

For advanced control over orjson's serialization behavior, use the 'option' attribute of OrjsonProvider to set orjson flags like orjson.OPT_SORT_KEYS or orjson.OPT_INDENT_2. The 'default' argument can be used for custom object serialization.

```python
import orjson
from flask import Flask
from flask_orjson import OrjsonProvider

app = Flask(__name__)
app.json = OrjsonProvider(app, option=orjson.OPT_SORT_KEYS | orjson.OPT_INDENT_2)

@app.route('/data')
def get_data():
    return {'name': 'Example', 'value': 123}

```

--------------------------------

### Configure orjson Options with Bitwise OR

Source: https://context7.com/pallets-eco/flask-orjson/llms.txt

Demonstrates how to combine multiple orjson serialization options using the bitwise OR operator for fine-grained control over the JSON output. Options like NAIVE_UTC, NON_STR_KEYS, and SERIALIZE_NUMPY can be enabled simultaneously. The default behavior can also be reset by setting the option to None.

```python
provider.option = (
    orjson.OPT_NAIVE_UTC |  # Treat naive datetime as UTC
    orjson.OPT_NON_STR_KEYS |  # Allow non-string keys
    orjson.OPT_SERIALIZE_NUMPY  # Support NumPy arrays
)

provider.option = None
```

--------------------------------

### Custom Type Serialization with `OrjsonProvider.default`

Source: https://context7.com/pallets-eco/flask-orjson/llms.txt

Shows how to define a custom default handler for serializing types not natively supported by orjson. This static method can be overridden to add support for custom classes like dataclasses or types that require specific formatting, such as Decimals or objects with an `__html__` method. Per-call overrides are also possible.

```python
from flask import Flask
from flask_orjson import OrjsonProvider
from decimal import Decimal
from dataclasses import dataclass
from typing import Any

app = Flask(__name__)
provider = OrjsonProvider(app)
app.json = provider

class HTMLWidget:
    def __html__(self):
        return '<div>Widget</div>'

data = {
    'price': Decimal('19.99'),
    'widget': HTMLWidget()
}
result = app.json.dumps(data)

@dataclass
class Product:
    id: int
    name: str
    price: float

def custom_default(obj: Any) -> Any:
    if isinstance(obj, Product):
        return {
            'id': obj.id,
            'name': obj.name,
            'price': obj.price,
            'type': 'product'
        }
    elif isinstance(obj, Decimal):
        return float(obj)  # Convert to float instead of string
    elif hasattr(obj, '__html__'):
        return str(obj.__html__())
    raise TypeError(f'Object of type {type(obj).__name__} is not JSON serializable')

provider.default = custom_default

product = Product(id=1, name='Laptop', price=999.99)
result = app.json.dumps({'item': product, 'tax': Decimal('50.00')})

def minimal_default(obj: Any) -> Any:
    return str(obj)  # Convert everything to string

complex_data = {'value': complex(1, 2)}
result = app.json.dumps(complex_data, default=minimal_default)
```

--------------------------------

### Override Instance JSON Options Per-Call

Source: https://context7.com/pallets-eco/flask-orjson/llms.txt

Illustrates how to override the default JSON serialization options set on a Flask-orjson provider instance for a specific JSON dump call. This allows for flexibility, such as generating compact JSON even if the instance is configured with indentation.

```python
data = {'key': 'value', 'number': 42}
# Instance has INDENT_2, but this call overrides it
compact = app.json.dumps(data, option=None)
```

--------------------------------

### Serialize Data to JSON with OrjsonProvider

Source: https://github.com/pallets-eco/flask-orjson/blob/main/docs/api.md

Serialize Python objects into JSON strings using the OrjsonProvider's dumps method. This method leverages orjson.dumps for high performance. It supports passing specific `option` flags and a `default` function for custom type handling, overriding the provider's default settings if necessary.

```python
from flask import Flask
from flask_orjson import OrjsonProvider
import orjson

app = Flask(__name__)
app.json = OrjsonProvider(app)

data = {"name": "example", "value": 123}

# Using provider's default settings
json_string = app.json.dumps(data)

# Using specific options and default function
def custom_serializer(obj):
    if isinstance(obj, datetime.date):
        return obj.isoformat()
    return str(obj)

json_string_custom = app.json.dumps(data, option=orjson.OPT_SORT_KEYS, default=custom_serializer)
```

--------------------------------

### Deserialize JSON to Python Objects with OrjsonProvider

Source: https://github.com/pallets-eco/flask-orjson/blob/main/docs/api.md

Deserialize JSON strings or bytes into Python objects using the OrjsonProvider's loads method. This method utilizes orjson.loads for efficient parsing. It accepts keyword arguments that are passed directly to orjson.loads, although most are silently ignored by the provider itself.

```python
from flask import Flask
from flask_orjson import OrjsonProvider

app = Flask(__name__)
app.json = OrjsonProvider(app)

json_data = b'{"name": "example", "value": 123}'

# Deserialize JSON data
python_object = app.json.loads(json_data)
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.