msgspec/msgspec

Features

• High-Performance Binary Serialization - Offers high-performance serialization for JSON, MessagePack, YAML, and TOML with minimal CPU and memory overhead.
• Multi-Format Serializers - Provides high-performance serialization and deserialization across multiple formats including JSON, MessagePack, YAML, and TOML.
• Complex Data Types - Supports encoding and decoding of non-scalar types like UUIDs, decimals, and datetimes using type annotations.
• TOML Parsers - Converts TOML strings or bytes into typed Python structures for application use.
• TOML Serializers - Converts Python objects into TOML format with support for transforming field names to kebab-case.
• Optimized Data Containers - Creates structured objects optimized for fast instantiation, equality comparison, and ordering compared to standard classes.
• Type-Safe Structured Data Frameworks - Integrates schema enforcement and data parsing into a single pass to achieve near-native execution speeds.
• MessagePack Serializers - Converts MessagePack binary bytes into typed structures using custom hooks and extensions.
• High-Performance Containers - Provides optimized data containers with faster instantiation and lower memory overhead than standard dataclasses.
• JSON Deserializers - Transforms JSON bytes into typed Python structures using strict type coercion and custom hooks.
• JSON Serializers - Converts Python objects into formatted JSON bytes with support for deterministic key ordering.
• Schema Validation Libraries - A validation system using standard Python type annotations to enforce structural integrity during deserialization.
• YAML Data Serialization - Converts YAML bytes into typed structures for internal application processing.
• Zero-Copy Parsing - Processes serialized byte streams by referencing memory directly to avoid creating intermediate Python objects.
• Garbage Collection Tuning - Lowers garbage collection overhead by disabling tracking for structure types that do not contain reference cycles.
• GC-Aware Memory Layouts - Lowers memory usage and shortens pause times by optimizing the internal memory layout of structured objects.
• Single-Pass Parsing - Integrates data deserialization and schema validation into a single pass to eliminate redundant processing overhead.
• JIT Routine Generation - Transforms type annotations into specialized machine routines to perform parsing and validation in a single high-performance pass.
• Python Serialization Libraries - A high-performance toolkit for encoding and decoding Python objects using JSON, MessagePack, YAML, and TOML.
• YAML Serializers - Serializes Python objects into YAML bytes for storage or transmission.
• Class-Based Data Modeling - Provides a system for modeling data using classes to encapsulate state and behavior with high-performance instantiation.
• Data Schema Validation - Enforces data integrity by verifying that incoming serialized data matches Python type annotations and constraints.
• Type-Annotation Validation - Uses standard Python type hints as the formal blueprint for generating high-performance serialization and validation logic.
• Binary Data Processing - Provides efficient binary serialization using MessagePack and zero-copy buffer parsing for high throughput.
• Typed Payload Decoders - Decodes untrusted input into typed, validated structures using Python type annotations.
• Buffer-Reusing Serializers - Reduces CPU and memory overhead by reusing encoder instances and writing into pre-allocated buffers.
• Positional Array Encodings - Increases processing speed and reduces payload size by treating data structures as ordered lists without field names.
• Serialization Hooks - Converts non-standard types into serializable formats using custom runtime hook functions.
• Data Type Serialization - Converts complex objects into simple builtin types to ensure compatibility with external serialization libraries.
• Schema Evolution - Enables exchanging messages between different schema versions without triggering errors as data formats change.
• Extension Type Management - Serializes custom objects as binary extension types using integer codes and byte buffers to maintain type information in MessagePack.
• Polymorphic Deserialization - Maps input to the correct object representation using tags to distinguish between multiple types in a union.
• Selective JSON Parsing - Parses only specific fields defined in a schema to reduce memory allocations and increase decoding speed.
• Newline-Delimited JSON Streams - Encodes and decodes sequences of objects as newline-delimited JSON for efficient stream processing.
• Configuration File Loading - Loads and validates application settings from TOML and YAML files into typed Python structures.
• Payload Minimization Strategies - Decreases the size of encoded messages by omitting default values or stripping field names from objects.
• High-Speed Type Conversion - Provides high-speed transformation of complex structured objects into plain Python builtin types.
• Object Type Transformations - Transforms input objects into specified types by extracting attributes from models or coercing keys.
• Frozen Instance Builders - Prevents attribute modification after initialization and enables hashing by marking data structures as frozen.
• Tagged Unions - Implements tagged unions by adding type identifiers to serialized data to distinguish between structures in a union.
• Custom Type Decoders - Transforms non-native types into supported values during encoding and decoding using custom callback functions.
• Union Type Validation - Decodes values into one of several possible types by identifying the single compatible type in a union.
• Default Value Omission - Decreases message size by omitting fields that match their default values during encoding.
• Forward and Backward Compatibility - Decodes messages across different versions by using default values for missing fields and skipping unknown fields.
• Deferred Decoding - Provides a view into encoded messages to decode specific fields only after others are processed.
• Memory Layout Optimizations - Implements memory layout optimizations that reduce garbage collection overhead by disabling reference tracking for non-cyclic structures.
• Object Schema Definitions - Automates the serialization of complex objects using high-performance data models like structs or dataclasses.
• Selective Decoding - Improves decoding speed and reduces memory allocations by ignoring input fields not defined in the schema.
• Type Coercion Utilities - Implements type coercion to convert incompatible types, such as strings to integers, during non-strict decoding.
• Type Constraint Enforcements - Enforces structural and value constraints including numeric ranges, string lengths, and regex patterns.
• Type-Safe API Schemas - Enables the creation of structured data models for consistent API communication and automatic schema generation.

Historique des stars