tessl/pypi-pyserde

Yet another serialization library on top of dataclasses

—

Pending

Overview

Eval results

Files

Core Serialization

Name: tessl/pypi-pyserde
Author: tessl

The fundamental serialization and deserialization functionality that powers all format-specific modules in pyserde. This module provides the core @serde decorator and basic conversion functions for dictionaries and tuples.

Capabilities

The @serde Decorator

The main decorator that enables automatic serialization and deserialization for dataclasses. When applied to a class, it generates optimized serialization and deserialization functions.

def serde(
    _cls=None,
    rename_all: str | None = None,
    reuse_instances_default: bool = True,
    convert_sets_default: bool = False,
    serializer: SerializeFunc | None = None,
    deserializer: DeserializeFunc | None = None,
    tagging: Tagging = DefaultTagging,
    type_check: TypeCheck = strict,
    serialize_class_var: bool = False,
    class_serializer: ClassSerializer | None = None,
    class_deserializer: ClassDeserializer | None = None,
    deny_unknown_fields: bool = False,
) -> Any:
    """
    Main decorator that combines serialize and deserialize functionality.
    
    Parameters:
    - _cls: The class to decorate
    - rename_all: Case conversion strategy ('camelCase', 'PascalCase', 'kebab-case', 'SCREAMING_SNAKE_CASE')
    - reuse_instances_default: Whether to reuse instances during deserialization
    - convert_sets_default: Whether to convert sets to lists during serialization
    - serializer: Custom serializer function for the entire class
    - deserializer: Custom deserializer function for the entire class
    - tagging: Union tagging strategy (ExternalTagging, InternalTagging, AdjacentTagging, Untagged)
    - type_check: Type checking mode (strict, disabled, coerce)
    - serialize_class_var: Whether to serialize ClassVar fields
    - class_serializer: Custom class serializer object
    - class_deserializer: Custom class deserializer object
    - deny_unknown_fields: Whether to raise error on unknown fields during deserialization
    
    Returns:
    Decorated class with serialization/deserialization capabilities
    """

Dictionary Conversion

Convert objects to and from Python dictionaries, the foundation for all other serialization formats.

def to_dict(
    o: Any,
    c: Optional[type[Any]] = None,
    reuse_instances: Optional[bool] = None,
    convert_sets: Optional[bool] = None,
    skip_none: bool = False,
) -> dict[Any, Any]:
    """
    Serialize object to dictionary.
    
    Parameters:
    - o: Object to serialize
    - c: Optional class hint for serialization
    - reuse_instances: Whether to reuse instances (affects object identity)
    - convert_sets: Whether to convert sets to lists
    - skip_none: Whether to skip None values
    
    Returns:
    Dictionary representation of the object
    """

def from_dict(cls: type[T], o: dict[str, Any], reuse_instances: Optional[bool] = None) -> T:
    """
    Deserialize dictionary to object.
    
    Parameters:
    - cls: Target class type
    - o: Dictionary data to deserialize
    - reuse_instances: Whether to reuse instances during deserialization
    
    Returns:
    Instance of cls populated from dictionary data
    """

def asdict(v: Any) -> dict[Any, Any]:
    """
    Serialize object to dict without reuse_instances optimization.
    
    Parameters:
    - v: Object to serialize
    
    Returns:
    Dictionary representation without instance reuse
    """

Tuple Conversion

Convert objects to and from Python tuples for ordered serialization.

def to_tuple(
    o: Any,
    c: Optional[type[Any]] = None,
    reuse_instances: Optional[bool] = None,
    convert_sets: Optional[bool] = None,
    skip_none: bool = False,
) -> tuple[Any, ...]:
    """
    Serialize object to tuple.
    
    Parameters:
    - o: Object to serialize
    - c: Optional class hint for serialization
    - reuse_instances: Whether to reuse instances
    - convert_sets: Whether to convert sets to lists
    - skip_none: Whether to skip None values
    
    Returns:
    Tuple representation of the object
    """

def from_tuple(cls: type[T], o: Any, reuse_instances: Optional[bool] = None) -> T:
    """
    Deserialize tuple to object.
    
    Parameters:
    - cls: Target class type
    - o: Tuple data to deserialize
    - reuse_instances: Whether to reuse instances during deserialization
    
    Returns:
    Instance of cls populated from tuple data
    """

def astuple(v: Any) -> tuple[Any, ...]:
    """
    Serialize object to tuple without reuse_instances optimization.
    
    Parameters:
    - v: Object to serialize
    
    Returns:
    Tuple representation without instance reuse
    """

Serialization Control

Functions to control and customize the serialization behavior.

def serialize(
    _cls: Optional[type[T]] = None,
    rename_all: Optional[str] = None,
    reuse_instances_default: bool = False,
    convert_sets_default: bool = False,
    serializer: Optional[SerializeFunc] = None,
    tagging: Tagging = DefaultTagging,
    type_check: TypeCheck = strict,
    serialize_class_var: bool = False,
    class_serializer: Optional[ClassSerializer] = None,
    **kwargs: Any,
) -> Any:
    """
    Decorator to make a class serializable.
    
    Parameters:
    - _cls: Class to make serializable
    - rename_all: Case conversion strategy
    - reuse_instances_default: Default reuse_instances setting
    - convert_sets_default: Default convert_sets setting
    - serializer: Custom serializer function
    - tagging: Union tagging strategy
    - type_check: Type checking mode
    - serialize_class_var: Whether to serialize ClassVar fields
    - class_serializer: Custom class serializer
    - **kwargs: Additional arguments
    
    Returns:
    Class with serialization capability
    """

def deserialize(
    _cls: Optional[type[T]] = None,
    rename_all: Optional[str] = None,
    reuse_instances_default: bool = True,
    convert_sets_default: bool = False,
    deserializer: Optional[DeserializeFunc] = None,
    tagging: Tagging = DefaultTagging,
    type_check: TypeCheck = strict,
    class_deserializer: Optional[ClassDeserializer] = None,
    deny_unknown_fields: bool = False,
    **kwargs: Any,
) -> Any:
    """
    Decorator to make a class deserializable.
    
    Parameters:
    - _cls: Class to make deserializable
    - rename_all: Case conversion strategy
    - reuse_instances_default: Default reuse_instances setting
    - convert_sets_default: Default convert_sets setting
    - deserializer: Custom deserializer function
    - tagging: Union tagging strategy
    - type_check: Type checking mode
    - class_deserializer: Custom class deserializer
    - deny_unknown_fields: Whether to raise error on unknown fields
    - **kwargs: Additional arguments
    
    Returns:
    Class with deserialization capability
    """

def is_serializable(instance_or_class: Any) -> bool:
    """
    Test if instance or class is serializable.
    
    Parameters:
    - instance_or_class: Object instance or class to test
    
    Returns:
    True if serializable, False otherwise
    """

def is_deserializable(instance_or_class: Any) -> bool:
    """
    Test if instance or class is deserializable.
    
    Parameters:
    - instance_or_class: Object instance or class to test
    
    Returns:
    True if deserializable, False otherwise
    """

Usage Examples

Basic Usage

from serde import serde, to_dict, from_dict

@serde
class Person:
    name: str
    age: int
    email: str | None = None

person = Person("Alice", 30, "alice@example.com")
data = to_dict(person)  # {'name': 'Alice', 'age': 30, 'email': 'alice@example.com'}
person_copy = from_dict(Person, data)

Case Conversion

@serde(rename_all='camelCase')
class UserProfile:
    user_name: str
    first_name: str
    last_name: str

profile = UserProfile("alice123", "Alice", "Smith")
data = to_dict(profile)  # {'userName': 'alice123', 'firstName': 'Alice', 'lastName': 'Smith'}

Custom Serializers

def custom_date_serializer(obj):
    return obj.isoformat()

def custom_date_deserializer(cls, data):
    return cls.fromisoformat(data)

@serde(
    serializer=custom_date_serializer,
    deserializer=custom_date_deserializer
)
class Event:
    name: str
    date: datetime.date

Install with Tessl CLI