tessl/pypi-marshmallow

A lightweight library for converting complex datatypes to and from native Python datatypes

—

Pending

Overview

Eval results

Files

Field Types

Name: tessl/pypi-marshmallow
Author: tessl

Marshmallow provides comprehensive field types for handling data conversion, validation, and transformation during serialization and deserialization. Each field type is specialized for specific data formats and use cases.

Capabilities

Base Field Class

All field types inherit from the base Field class, which provides common functionality and configuration options.

class Field:
    def __init__(self, *, dump_default=missing, load_default=missing, data_key=None, 
                 attribute=None, validate=None, required=False, allow_none=None, 
                 load_only=False, dump_only=False, error_messages=None, metadata=None):
        """
        Base field class for all field types.

        Parameters:
        - dump_default: default value when serializing if attribute is missing
        - load_default: default value when deserializing if key is missing
        - data_key: key name in serialized data (different from attribute name)
        - attribute: attribute name on the object (different from field name)
        - validate: validator or list of validators to apply
        - required: bool, whether field is required during deserialization
        - allow_none: bool, whether None values are allowed
        - load_only: bool, skip field during serialization
        - dump_only: bool, skip field during deserialization
        - error_messages: dict, custom error message overrides
        - metadata: dict, additional metadata for the field
        """

class Raw(Field):
    """
    Field that applies no formatting - outputs values as-is.
    """

String and Text Fields

Fields for handling text data with various validation and formatting options.

class String(Field):
    """
    String field for text data.

    Parameters:
    - allow_empty: bool, whether to allow empty strings (default: True)
    """

# Alias for String
Str = String

class Email(Field):
    """
    Email address field with built-in email validation.
    """

class URL(Field):
    """
    URL field with validation.

    Parameters:
    - relative: bool, allow relative URLs (default: False)
    - schemes: set, valid URL schemes (default: http, https, ftp, ftps)
    - require_tld: bool, require top-level domain (default: True)
    """

# Alias for URL
Url = URL

class UUID(Field):
    """
    UUID field that serializes to string and deserializes to uuid.UUID objects.
    """

Numeric Fields

Fields for handling various numeric data types with validation and precision control.

class Number(Field):
    """
    Base class for numeric fields.
    """

class Integer(Field):
    """
    Integer field.

    Parameters:
    - strict: bool, whether to disallow non-integer numeric types (default: False)
    """

# Alias for Integer
Int = Integer

class Float(Field):
    """
    Floating point number field.

    Parameters:
    - allow_nan: bool, whether to allow NaN values (default: True)
    """

class Decimal(Field):
    """
    Decimal field using decimal.Decimal for precise decimal arithmetic.

    Parameters:
    - places: int, number of decimal places for quantization
    - rounding: decimal rounding mode (ROUND_HALF_EVEN, etc.)
    - allow_nan: bool, whether to allow NaN values (default: True)
    """

Boolean Fields

Fields for handling boolean values with flexible truth/falsy value mapping.

class Boolean(Field):
    """
    Boolean field with configurable truthy/falsy values.

    Parameters:
    - truthy: set, values that evaluate to True (default: {True, 1, '1', 'true', 'True'})
    - falsy: set, values that evaluate to False (default: {False, 0, '0', 'false', 'False'})
    """

# Alias for Boolean
Bool = Boolean

Date and Time Fields

Fields for handling various date and time formats with flexible serialization options.

class DateTime(Field):
    """
    DateTime field for datetime objects.

    Parameters:
    - format: str, datetime format string, 'timestamp', 'iso8601', or None for ISO format
    """

class NaiveDateTime(Field):
    """
    Naive datetime field that requires timezone-naive datetime objects.
    """

class AwareDateTime(Field):
    """
    Timezone-aware datetime field that requires timezone-aware datetime objects.
    """

class Date(Field):
    """
    Date field for date objects.

    Parameters:
    - format: str, date format string or None for ISO format
    """

class Time(Field):
    """
    Time field for time objects.

    Parameters:
    - format: str, time format string or None for ISO format
    """

class TimeDelta(Field):
    """
    TimeDelta field for duration values.

    Parameters:
    - precision: str, serialization precision ('days', 'seconds', 'microseconds', 'milliseconds')
    """

Container Fields

Fields for handling collections and nested data structures.

class List(Field):
    """
    List field containing items of a specific type.

    Parameters:
    - inner: Field instance, field type for list items
    """

class Tuple(Field):
    """
    Tuple field with items of specific types.

    Parameters:
    - tuple_fields: sequence, field types for each tuple position
    """

class Dict(Field):
    """
    Dictionary field with optional key/value type validation.

    Parameters:
    - keys: Field instance, field type for dictionary keys
    - values: Field instance, field type for dictionary values
    """

class Mapping(Field):
    """
    Generic mapping field (base class for Dict).
    """

Relationship Fields

Fields for handling relationships between objects and nested schemas.

class Nested(Field):
    """
    Field for nesting schemas within schemas.

    Parameters:
    - schema: Schema class or instance for nested object
    - many: bool, whether this field represents a collection
    - unknown: str, how to handle unknown fields in nested schema
    """

class Pluck(Field):
    """
    Field that plucks a single value from a nested object.

    Parameters:
    - schema: Schema class for the nested object
    - field_name: str, name of field to pluck from nested object
    """

IP Address Fields

Fields for handling various IP address formats with validation.

class IP(Field):
    """
    IPv4 or IPv6 address field that accepts both formats.
    """

class IPv4(Field):
    """
    IPv4 address field with validation.
    """

class IPv6(Field):
    """
    IPv6 address field with validation.
    """

class IPv4Interface(Field):
    """
    IPv4 network interface field (IP address with subnet).
    """

# Alias for IPv4Interface
IPInterface = IPv4Interface

class IPv6Interface(Field):
    """
    IPv6 network interface field (IP address with subnet).
    """

Special Purpose Fields

Fields for specialized use cases and dynamic value generation.

class Enum(Field):
    """
    Field for Python enum values.

    Parameters:
    - enum: Enum class to validate against
    - by_value: bool, whether to serialize by value (True) or by name (False)
    """

class Method(Field):
    """
    Field that gets its value from a schema method.

    Parameters:
    - serialize: str, method name to call for serialization
    - deserialize: str, method name to call for deserialization
    """

class Function(Field):
    """
    Field that gets its value from a function.

    Parameters:
    - serialize: callable, function to call for serialization
    - deserialize: callable, function to call for deserialization
    """

class Constant(Field):
    """
    Field that always serializes to the same constant value.

    Parameters:
    - constant: the constant value to serialize
    """

Usage Examples

Basic Field Usage

from marshmallow import Schema, fields

class PersonSchema(Schema):
    name = fields.Str(required=True)
    age = fields.Int(validate=lambda x: x >= 0)
    email = fields.Email()
    website = fields.URL(schemes=['http', 'https'])
    uuid = fields.UUID()
    active = fields.Bool()

Date and Time Fields

class EventSchema(Schema):
    name = fields.Str()
    start_date = fields.Date()
    start_time = fields.DateTime(format='%Y-%m-%d %H:%M:%S')
    duration = fields.TimeDelta(precision='seconds')
    created_at = fields.DateTime(format='timestamp')  # Unix timestamp

Container Fields

class ArticleSchema(Schema):
    title = fields.Str()
    tags = fields.List(fields.Str())  # List of strings
    metadata = fields.Dict(keys=fields.Str(), values=fields.Raw())  # String keys, any values
    coordinates = fields.Tuple([fields.Float(), fields.Float()])  # Lat/lon pair

Nested Relationships

class AuthorSchema(Schema):
    name = fields.Str()
    email = fields.Email()

class BookSchema(Schema):
    title = fields.Str()
    author = fields.Nested(AuthorSchema)
    authors = fields.Nested(AuthorSchema, many=True)  # Multiple authors
    primary_author_name = fields.Pluck(AuthorSchema, 'name')  # Just the name

Advanced Field Configuration

class UserSchema(Schema):
    # Custom data key mapping
    user_id = fields.Int(data_key='id')
    
    # Default values
    status = fields.Str(dump_default='active')
    join_date = fields.DateTime(load_default=lambda: datetime.now())
    
    # Load/dump only fields
    password = fields.Str(load_only=True)
    full_name = fields.Method('get_full_name', dump_only=True)
    
    # Custom validation
    username = fields.Str(validate=[Length(min=3, max=20), Regexp(r'^[a-zA-Z0-9_]+$')])
    
    def get_full_name(self, obj):
        return f"{obj.first_name} {obj.last_name}"

Install with Tessl CLI