Dataclass Factory

A comprehensive Python library that provides bidirectional conversion between dictionaries and dataclass instances. It fills the gap left by Python's standard asdict() method by enabling conversion from dictionaries back to dataclass objects with flexible parsing capabilities, custom type handling, and naming policy support.

Package Information

• Package Name: dataclass_factory
• Package Type: Library
• Language: Python
• Installation: pip install dataclass_factory

Core Imports

from dataclass_factory import ParserFactory, SerializerFactory, NameStyle

For simple use cases, you can use the convenience function:

from dataclass_factory import parse

For legacy compatibility with dataclasses.asdict():

from dataclass_factory import dict_factory

Basic Usage

from dataclasses import dataclass
from dataclass_factory import ParserFactory, SerializerFactory

@dataclass
class User:
    name: str
    age: int
    email: str = "unknown@example.com"

# Create parser and serializer factories
parser_factory = ParserFactory()
serializer_factory = SerializerFactory()

# Convert dict to dataclass
user_data = {
    "name": "John Doe",
    "age": 30
}

user = parser_factory.get_parser(User)(user_data)
# Result: User(name="John Doe", age=30, email="unknown@example.com")

# Convert dataclass back to dict
user_dict = serializer_factory.get_serializer(User)(user)
# Result: {"name": "John Doe", "age": 30, "email": "unknown@example.com"}

Architecture

The library uses a factory pattern with caching for optimal performance:

• ParserFactory: Creates and caches parsers for converting dicts to dataclass instances
• SerializerFactory: Creates and caches serializers for converting dataclass instances to dicts
• Type Detection: Automatically handles complex types including Optional, Union, collections, and custom classes
• Naming Policies: Supports different field naming conventions (snake_case, camelCase, kebab-case)
• Custom Type Factories: Extensible system for handling custom types and complex parsing scenarios

Capabilities

Data Parsing

Convert dictionaries and other data structures into dataclass instances with support for complex nested types, Optional fields, Union types, collections, and custom parsing logic.

class ParserFactory:
    def __init__(
        self,
        trim_trailing_underscore: bool = True,
        debug_path: bool = False,
        type_factories: Dict[Type, Parser] = None,
        name_styles: Dict[Type, NameStyle] = None,
    ): ...
    
    def get_parser(self, cls: ClassVar) -> Parser: ...

def parse(
    data,
    cls,
    trim_trailing_underscore: bool = True,
    type_factories: Dict[Any, Callable] = None,
): ...

Data Parsing

Data Serialization

Convert dataclass instances back to dictionaries with performance optimization (up to 10x faster than standard asdict), custom serializers, and naming policy support.

class SerializerFactory:
    def __init__(
        self,
        trim_trailing_underscore: bool = True,
        debug_path: bool = False,
        type_serializers: Dict[Type, Serializer] = None,
        name_styles: Dict[Type, NameStyle] = None,
    ): ...
    
    def get_serializer(self, cls: Any) -> Serializer: ...

Data Serialization

Naming Policies

Convert between different field naming conventions when parsing and serializing dataclasses, supporting snake_case, camelCase, kebab-case, and CamelCase transformations.

class NameStyle(Enum):
    snake = "snake_case"
    kebab = "kebab-case"
    camel_lower = "camelCaseLower"
    camel = "CamelCase"

def convert_name(
    name: str,
    trim_trailing_underscore: bool = True,
    naming_policy: NameStyle = None
) -> str: ...

Naming Policies

Types

from typing import Callable, Any, Dict, Type

# Note: These type aliases are used internally but not officially exported
Parser = Callable[[Any], Any]
Serializer = Callable[[Any], Any]

Supported Data Types

The library supports parsing and serialization for:

• Dataclasses: Primary target type with full field support
• Basic Types: int, float, complex, bool, str, bytes, bytearray
• Decimal: decimal.Decimal with string parsing
• Enums: Parsed from and serialized to values
• Collections: List, Set, FrozenSet, Deque with typed elements
• Tuples: Both typed tuples and ellipsis syntax
• Dictionaries: Dict with typed keys and values
• Optional: Optional types with None handling
• Union: Union types with ordered parsing attempts
• Any: Pass-through for untyped data
• Custom Classes: Based on init method signatures