marshmallow

---

1. Model Validation and Serialization

from marshmallow import Schema, fields

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

user_data = {'username': 'john', 'email': '[e-mail]'}
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

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': '[e-mail]'}
user_response_schema = UserResponseSchema()
user_response = user_response_schema.dump(user_response_data)
return jsonify(user_response)

3. Data Transformation and Mapping

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='[e-mail]')
user_schema = UserSchema()
user_data = user_schema.dump(user)
assert user_data['full_name'] == 'john [e-mail]'

4. Nested and Hierarchical Schemas

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='[e-mail]', address=Address(street='123 Main St', city='Anytown'))
user_schema = UserSchema()
user_data = user_schema.dump(user)

5. Custom Validation and Error Handling

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': '[e-mail]'}
user_schema = UserSchema()

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

6. Dynamic Schema Loading

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': '[e-mail]', 'role': 'admin'}
user_schema = UserSchema()
user = user_schema.load(user_data)
assert isinstance(user, AdminUser)

7. Schema Inheritance and Extension

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': '[e-mail]', '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': '[e-mail]', '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

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

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

params = ImmutableMultiDict([('username', 'john'), ('email', '[e-mail]')])
user_search_schema = UserSearchSchema()
user_search_data, errors = user_search_schema.load(params.to_dict(flat=True))

9. CSV and JSON File Parsing

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

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

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

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

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

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

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

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

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': '[e-mail]'}
user_schema = UserSchema(partial=('username', 'email'))
user_data_validated, errors = user_schema.load(user_data)

18. Nested Schemas with Embedded Objects

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': '[e-mail]',
    '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

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': '[e-mail]'}
user_data_validated, errors = user_schema.load(user_data)

20. Custom Error Handling and Validation

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': '[e-mail]'}
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

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

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': '[e-mail]', 'address': {'street': '123 Main St', 'city': 'Anytown'}}
user_schema = UserSchema()
user_data_validated, errors = user_schema.load(user_data)

23. Serialization with Conditional Fields

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

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': '[e-mail]'}
user_schema = UserSchema(partial=('username', 'email'))
user_data_validated, errors = user_schema.load(user_data)

25. Serialization with Nested Collections

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': '[e-mail]',
    '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

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': '[e-mail]'}
user_schema = UserSchema()
user_data_validated, errors = user_schema.load(user_data)
assert user_data_validated['username'] == 'JOHN'

27. Serialization with Sorted Keys

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

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': '[e-mail]', 'role': 'admin'}
user_schema = UserSchema()
user_data_validated, errors = user_schema.load(user_data)

admin_user_data = {'username': 'john', 'email': '[e-mail]', '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

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': '[e-mail]', '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

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': '[e-mail]', 'address': {'street': '123 Main St', 'city': 'Anytown'}}
user_schema = UserSchema()
user_data_validated, errors = user_schema.load(user_data)

31. Serialization with Filtered Fields

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

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': '[e-mail]'}
user_schema_en = UserSchemaEn()
user_data_validated, errors = user_schema_en.load(user_data_en, lang='en')

user_data_fr = {'nom_utilisateur': 'john', 'email': '[e-mail]'}
user_schema_fr = UserSchemaFr()
user_data_validated, errors = user_schema_fr.load(user_data_fr, lang='fr')

33. Serialization with URL Fields

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': '[e-mail]', '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

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': '[e-mail]', '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