# marshmallow

***

**1. Model Validation and Serialization**

```python
from marshmallow import Schema, fields

class UserSchema(Schema):
    username = fields.Str(required=True)
    email = fields.Email(required=True)

user_data = {'username': 'john', 'email': 'john@example.com'}
user_schema = UserSchema()
user_data_validated, errors = user_schema.load(user_data)
user = User(**user_data_validated)  # Create a model instance from validated data
```

**2. API Request and Response Parsing**

```python
from marshmallow import Schema, fields
from flask import request, jsonify

class UserRequestSchema(Schema):
    username = fields.Str(required=True)
    email = fields.Email(required=True)

user_request_data = request.get_json()
user_request_schema = UserRequestSchema()
user_request_data, errors = user_request_schema.load(user_request_data)

# Create response object
user_response_data = {'username': 'john', 'email': 'john@example.com'}
user_response_schema = UserResponseSchema()
user_response = user_response_schema.dump(user_response_data)
return jsonify(user_response)
```

**3. Data Transformation and Mapping**

```python
from marshmallow import Schema, fields

class UserSchema(Schema):
    username = fields.Str(required=True)
    email = fields.Email(required=True)
    full_name = fields.Function(lambda obj: f"{obj.username} {obj.email}")

user = User(username='john', email='john@example.com')
user_schema = UserSchema()
user_data = user_schema.dump(user)
assert user_data['full_name'] == 'john john@example.com'
```

**4. Nested and Hierarchical Schemas**

```python
from marshmallow import Schema, fields

class AddressSchema(Schema):
    street = fields.Str(required=True)
    city = fields.Str(required=True)

class UserSchema(Schema):
    username = fields.Str(required=True)
    email = fields.Email(required=True)
    address = fields.Nested(AddressSchema)

user = User(username='john', email='john@example.com', address=Address(street='123 Main St', city='Anytown'))
user_schema = UserSchema()
user_data = user_schema.dump(user)
```

**5. Custom Validation and Error Handling**

```python
from marshmallow import Schema, fields, ValidationError

class UserSchema(Schema):
    username = fields.Str(required=True)
    email = fields.Email(required=True)

    def validate_username(self, value):
        if not value.startswith('j'):
            raise ValidationError('Username must start with j')

user_data = {'username': 'john', 'email': 'john@example.com'}
user_schema = UserSchema()

try:
    user_data_validated, errors = user_schema.load(user_data)
except ValidationError as e:
    errors = e.messages
```

**6. Dynamic Schema Loading**

```python
from marshmallow import Schema, fields, post_load

class UserSchema(Schema):
    username = fields.Str(required=True)
    email = fields.Email(required=True)
    role = fields.Str(required=True)

    @post_load
    def make_user(self, data, **kwargs):
        role = data['role']
        if role == 'admin':
            return AdminUser(**data)
        elif role == 'user':
            return StandardUser(**data)
        else:
            raise ValueError(f'Invalid role: {role}')

user_data = {'username': 'john', 'email': 'john@example.com', 'role': 'admin'}
user_schema = UserSchema()
user = user_schema.load(user_data)
assert isinstance(user, AdminUser)
```

**7. Schema Inheritance and Extension**

```python
from marshmallow import Schema, fields

class BaseUserSchema(Schema):
    username = fields.Str(required=True)
    email = fields.Email(required=True)

class AdminUserSchema(BaseUserSchema):
    access_level = fields.Int(required=True)

class StandardUserSchema(BaseUserSchema):
    user_type = fields.Str(required=True)

admin_user_data = {'username': 'john', 'email': 'john@example.com', 'access_level': 3}
admin_user_schema = AdminUserSchema()
admin_user_data_validated, errors = admin_user_schema.load(admin_user_data)

standard_user_data = {'username': 'mary', 'email': 'mary@example.com', 'user_type': 'standard'}
standard_user_schema = StandardUserSchema()
standard_user_data_validated, errors = standard_user_schema.load(standard_user_data)
```

**8. Query String and URL Parameter Parsing**

```python
from marshmallow import Schema, fields
from werkzeug.datastructures import ImmutableMultiDict

class UserSearchSchema(Schema):
    username = fields.Str()
    email = fields.Email()

params = ImmutableMultiDict([('username', 'john'), ('email', 'john@example.com')])
user_search_schema = UserSearchSchema()
user_search_data, errors = user_search_schema.load(params.to_dict(flat=True))
```

**9. CSV and JSON File Parsing**

```python
from marshmallow import Schema, fields
from marshmallow_csv import CSVSchema

class UserSchema(Schema):
    username = fields.Str(required=True)
    email = fields.Email(required=True)

# CSV-specific schema
class UserCSVSchema(CSVSchema):
    username = fields.Str()
    email = fields.Email()

with open('users.csv', 'r') as f:
    user_csv_data = list(csv.DictReader(f))

with open('users.json', 'r') as f:
    user_json_data = json.load(f)

user_csv_schema = UserCSVSchema()
user_csv_data_validated, errors = user_csv_schema.load(user_csv_data, many=True)

user_json_schema = UserSchema()
user_json_data_validated, errors = user_json_schema.load(user_json_data, many=True)
```

**10. XML Parsing and Serialization**

```python
from marshmallow import Schema, fields
from marshmallow_xmlrpc import XMLRPCSchema

class UserSchema(Schema):
    username = fields.Str(required=True)
    email = fields.Email(required=True)

# XML-specific schema
class UserXMLRPCSchema(XMLRPCSchema):
    username = fields.Str()
    email = fields.Email()

with open('users.xml', 'r') as f:
    user_xml_data = xmlrpc.loads(f.read())

user_xml_schema = UserXMLRPCSchema()
user_xml_data_validated, errors = user_xml_schema.load(user_xml_data, many=True)

user_xml_data_serialized = user_xml_schema.dump(user_xml_data_validated, many=True)
```

**11. Automatic Data Extraction from HTTP Requests**

```python
from marshmallow import Schema, fields
from flask_marshmallow import Marshmallow

app = Flask(__name__)
marshmallow = Marshmallow(app)

class UserSchema(marshmallow.Schema):
    username = fields.Str(required=True)
    email = fields.Email(required=True)

@app.route('/users', methods=['POST'])
def create_user():
    user_data = request.get_json()
    user_schema = UserSchema()
    user_data_validated, errors = user_schema.load(user_data)
    if errors:
        return jsonify({'errors': errors}), 400
    user = User(**user_data_validated)
    user.save()
    return jsonify({'success': True}), 201
```

**12. Validation of Data from Forms**

```python
from marshmallow import Schema, fields
from wtforms import Form, StringField, EmailField

class UserForm(Form):
    username = StringField('Username', validators=[validators.Required()])
    email = EmailField('Email', validators=[validators.Required()])

class UserSchema(marshmallow.Schema):
    username = fields.Str(required=True)
    email = fields.Email(required=True)

def validate_user(form):
    user_schema = UserSchema()
    user_data, errors = user_schema.load(form.data)
    if errors:
        return False, errors
    return True, user_data
```

**13. Data Conversion and Manipulation**

```python
from marshmallow import Schema, fields
from marshmallow.validate import Range

class UserSchema(Schema):
    username = fields.Str(required=True)
    age = fields.Int(required=True, validate=Range(min=18, max=99))
    points = fields.Int(required=False, missing=0)

user_data = {'username': 'john', 'age': 30, 'points': 100}
user_schema = UserSchema()
user_data_validated, errors = user_schema.load(user_data)
assert user_data_validated['points'] == 100
```

**14. Data Contextualization and Enrichment**

```python
from marshmallow import Schema, fields
from marshmallow_sqlalchemy import SQLAlchemyAutoSchema

class User(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(80), unique=True, nullable=False)
    email = db.Column(db.String(120), unique=True, nullable=False)

class UserSchema(SQLAlchemyAutoSchema):
    class Meta:
        model = User
        load_instance = True

    # Add additional context or enrich data here
    num_posts = fields.Method('get_num_posts')

    def get_num_posts(self, obj):
        return obj.posts.count()

user = User.query.get(1)
user_schema = UserSchema()
user_data = user_schema.dump(user)
assert user_data['num_posts'] == user.posts.count()
```

**15. Advanced Data Manipulation with Functions**

```python
from marshmallow import Schema, fields

class UserSchema(Schema):
    username = fields.Str()
    email = fields.Email()
    is_admin = fields.Function(lambda obj: obj.role == 'admin')

# Or, use a custom function
def is_admin_func(obj):
    return obj.role == 'admin'

class UserSchema(Schema):
    username = fields.Str()
    email = fields.Email()
    is_admin = fields.Function(is_admin_func)
```

**16. Custom Serializers and Deserializers**

```python
from marshmallow import Schema, fields, post_load, pre_dump

class UserSchema(Schema):
    username = fields.Str(required=True)
    email = fields.Email(required=True)

    # Custom deserializer (load)
    @post_load
    def make_user(self, data, **kwargs):
        return User(**data)

    # Custom serializer (dump)
    @pre_dump
    def hide_sensitive_data(self, data, **kwargs):
        data.pop('password', None)
        return data
```

**17. Partial Data Loading and Dumping**

```python
from marshmallow import Schema, fields, partial

class UserSchema(Schema):
    username = fields.Str(required=True)
    email = fields.Email(required=True)
    address = fields.Str()

user_data = {'username': 'john', 'email': 'john@example.com'}
user_schema = UserSchema(partial=('username', 'email'))
user_data_validated, errors = user_schema.load(user_data)
```

**18. Nested Schemas with Embedded Objects**

```python
from marshmallow import Schema, fields

class AddressSchema(Schema):
    street = fields.Str(required=True)
    city = fields.Str(required=True)

class UserSchema(Schema):
    username = fields.Str(required=True)
    email = fields.Email(required=True)
    address = fields.Nested(AddressSchema)

user_data = {
    'username': 'john',
    'email': 'john@example.com',
    'address': {
        'street': '123 Main St',
        'city': 'Anytown',
    }
}
user_schema = UserSchema()
user_data_validated, errors = user_schema.load(user_data)
```

**19. Dynamic Schema Creation with FieldsFactory**

```python
from marshmallow import Schema, fields, fields_factory

class FieldsFactory(fields_factory.Factory):
    def create_for_field_type(self, field_name, field_type, **kwargs):
        if field_type == 'email':
            return fields.Email(required=True)
        return super().create_for_field_type(field_name, field_type, **kwargs)

class UserSchema(Schema):
    Meta = {
        'fields': FieldsFactory(),
    }

user_fields = {
    'username': 'str',
    'email': 'email',
}
user_schema = UserSchema(**user_fields)
user_data = {'username': 'john', 'email': 'john@example.com'}
user_data_validated, errors = user_schema.load(user_data)
```

**20. Custom Error Handling and Validation**

```python
from marshmallow import Schema, fields, ValidationError

class UserSchema(Schema):
    username = fields.Str(required=True)
    email = fields.Email(required=True)

    def validate_username(self, value):
        if not value.isalnum():
            raise ValidationError('Username must be alphanumeric')

user_data = {'username': 'john!', 'email': 'john@example.com'}
user_schema = UserSchema()
try:
    user_data_validated, errors = user_schema.load(user_data)
except ValidationError as e:
    errors = e.messages
```

**21. Serialization with Additional Metadata**

```python
from marshmallow import Schema, fields

class UserSchema(Schema):
    username = fields.Str(required=True)
    email = fields.Email(required=True)
    meta = fields.Dict(dump_only=True)

    def dump(self, obj, **kwargs):
        data = super().dump(obj, **kwargs)
        data['meta'] = {'created_at': obj.created_at}
        return data
```

**22. Deserialization with Embedded Objects**

```python
from marshmallow import Schema, fields

class AddressSchema(Schema):
    street = fields.Str(required=True)
    city = fields.Str(required=True)

class UserSchema(Schema):
    username = fields.Str(required=True)
    email = fields.Email(required=True)
    address = fields.Nested(AddressSchema, allow_none=True)

user_data = {'username': 'john', 'email': 'john@example.com', 'address': {'street': '123 Main St', 'city': 'Anytown'}}
user_schema = UserSchema()
user_data_validated, errors = user_schema.load(user_data)
```

**23. Serialization with Conditional Fields**

```python
from marshmallow import Schema, fields

class UserSchema(Schema):
    username = fields.Str(required=True)
    email = fields.Email(required=True)
    is_admin = fields.Bool(dump_only=True)

    def dump(self, obj, **kwargs):
        data = super().dump(obj, **kwargs)
        if obj.role == 'admin':
            data['is_admin'] = True
        return data
```

**24. Deserialization with Partial Data**

```python
from marshmallow import Schema, fields, partial

class UserSchema(Schema):
    username = fields.Str(required=True)
    email = fields.Email(required=True)
    address = fields.Str(required=False)

user_data = {'username': 'john', 'email': 'john@example.com'}
user_schema = UserSchema(partial=('username', 'email'))
user_data_validated, errors = user_schema.load(user_data)
```

**25. Serialization with Nested Collections**

```python
from marshmallow import Schema, fields

class AddressSchema(Schema):
    street = fields.Str(required=True)
    city = fields.Str(required=True)

class UserSchema(Schema):
    username = fields.Str(required=True)
    email = fields.Email(required=True)
    addresses = fields.List(fields.Nested(AddressSchema))

user_data = {
    'username': 'john',
    'email': 'john@example.com',
    'addresses': [
        {'street': '123 Main St', 'city': 'Anytown'},
        {'street': '456 Elm St', 'city': 'Anytown2'},
    ]
}
user_schema = UserSchema()
user_data_validated, errors = user_schema.load(user_data)
```

**26. Deserialization with Custom Fields**

```python
from marshmallow import Schema, fields, post_load

class CustomField(fields.Field):
    def _deserialize(self, value, attr, data, **kwargs):
        return value.upper()

class UserSchema(Schema):
    username = CustomField(required=True)
    email = fields.Email(required=True)

user_data = {'username': 'john', 'email': 'john@example.com'}
user_schema = UserSchema()
user_data_validated, errors = user_schema.load(user_data)
assert user_data_validated['username'] == 'JOHN'
```

**27. Serialization with Sorted Keys**

```python
from marshmallow import Schema, fields

class UserSchema(Schema):
    username = fields.Str(required=True)
    email = fields.Email(required=True)

    def dump(self, obj, **kwargs):
        data = super().dump(obj, **kwargs)
        return dict(sorted(data.items()))
```

**28. Deserialization with Multiple Schemas**

```python
from marshmallow import Schema, fields, post_load, pre_load

class BaseUserSchema(Schema):
    username = fields.Str(required=True)
    email = fields.Email(required=True)

    def pre_load(self, data, **kwargs):
        role = data.pop('role', None)
        if role == 'admin':
            return {'username': data['username'], 'email': data['email'], 'is_admin': True}
        elif role == 'user':
            return {'username': data['username'], 'email': data['email'], 'is_admin': False}
        else:
            raise ValidationError('Invalid role')

class UserSchema(BaseUserSchema):
    is_admin = fields.Bool(required=True)

class AdminUserSchema(BaseUserSchema):
    access_level = fields.Int(required=True)

user_data = {'username': 'john', 'email': 'john@example.com', 'role': 'admin'}
user_schema = UserSchema()
user_data_validated, errors = user_schema.load(user_data)

admin_user_data = {'username': 'john', 'email': 'john@example.com', 'role': 'admin', 'access_level': 3}
admin_user_schema = AdminUserSchema()
admin_user_data_validated, errors = admin_user_schema.load(admin_user_data)
```

**29. Serialization with Skipped Fields**

```python
from marshmallow import Schema, fields

class UserSchema(Schema):
    username = fields.Str(required=True)
    email = fields.Email(required=True)
    password = fields.Str(required=True, skip_on_dump=True)

user_data = {'username': 'john', 'email': 'john@example.com', 'password': 'secret'}
user_schema = UserSchema()
user_data_serialized = user_schema.dump(user_data)
assert 'password' not in user_data_serialized
```

**30. Deserialization with Nested Schemas**

```python
from marshmallow import Schema, fields

class AddressSchema(Schema):
    street = fields.Str(required=True)
    city = fields.Str(required=True)

class UserSchema(Schema):
    username = fields.Str(required=True)
    email = fields.Email(required=True)
    address = fields.Nested(AddressSchema)

user_data = {'username': 'john', 'email': 'john@example.com', 'address': {'street': '123 Main St', 'city': 'Anytown'}}
user_schema = UserSchema()
user_data_validated, errors = user_schema.load(user_data)
```

**31. Serialization with Filtered Fields**

```python
from marshmallow import Schema, fields

class UserSchema(Schema):
    username = fields.Str(required=True)
    email = fields.Email(required=True)
    is_admin = fields.Bool(required=True)

    def dump(self, obj, **kwargs):
        data = super().dump(obj, **kwargs)
        if not current_user.is_admin:
            data.pop('is_admin', None)
        return data
```

**32. Deserialization with Multiple Languages**

```python
from marshmallow import Schema, fields

class UserSchemaEn(Schema):
    username = fields.Str(required=True)
    email = fields.Email(required=True)

class UserSchemaFr(Schema):
    nom_utilisateur = fields.Str(required=True)
    email = fields.Email(required=True)

user_data_en = {'username': 'john', 'email': 'john@example.com'}
user_schema_en = UserSchemaEn()
user_data_validated, errors = user_schema_en.load(user_data_en, lang='en')

user_data_fr = {'nom_utilisateur': 'john', 'email': 'john@example.com'}
user_schema_fr = UserSchemaFr()
user_data_validated, errors = user_schema_fr.load(user_data_fr, lang='fr')
```

**33. Serialization with URL Fields**

```python
from marshmallow import Schema, fields

class UserSchema(Schema):
    username = fields.Str(required=True)
    email = fields.Email(required=True)
    website = fields.Url()

user_data = {'username': 'john', 'email': 'john@example.com', 'website': 'https://example.com'}
user_schema = UserSchema()
user_data_serialized, errors = user_schema.dump(user_data)
assert user_data_serialized['website'] == 'https://example.com'
```

**34. Deserialization with Read-Only Fields**

```python
from marshmallow import Schema, fields

class UserSchema(Schema):
    username = fields.Str(required=True)
    email = fields.Email(required=True)
    created_at = fields.DateTime(required=True, dump_only=True)

user_data = {'username': 'john', 'email': 'john@example.com', 'created_at': '2023-03-08 12:34:56'}
user_schema = UserSchema()
user_data_validated, errors = user_schema.load(user_data)
assert 'created_at' not in user_data_validated
```

**35. Serialization with Embedded**