pydantic-marshmallow 1.0.0__py3-none-any.whl → 1.1.0__py3-none-any.whl

pydantic_marshmallow/__init__.py

@@ -51,16 +51,22 @@ Features:
 
 # Re-export Marshmallow's validators - these work with PydanticSchema
 # Also export hooks for convenience
+# Note: We re-export Marshmallow's @validates and @validates_schema above.
+# Our bridge's _do_load calls Marshmallow's native validator system,
+# so `from marshmallow import validates` works correctly with PydanticSchema.
+# Version is managed by setuptools-scm from git tags
+from importlib.metadata import version as _version
+
 from marshmallow import EXCLUDE, INCLUDE, RAISE, post_dump, post_load, pre_dump, pre_load, validates, validates_schema
 
 from .bridge import HybridModel, PydanticSchema, pydantic_schema, schema_for
 from .errors import BridgeValidationError
 
-# Note: We re-export Marshmallow's @validates and @validates_schema above.
-# Our bridge's _do_load calls Marshmallow's native validator system,
-# so `from marshmallow import validates` works correctly with PydanticSchema.
-
-__version__ = "0.1.0"
+try:
+    __version__ = _version("pydantic-marshmallow")
+except Exception:
+    # Fallback for development or environments without installed package metadata
+    __version__ = "0.0.0.dev0"
 __all__ = [
     "EXCLUDE",
     "INCLUDE",

pydantic_marshmallow/bridge.py

@@ -7,7 +7,10 @@ Flow: Input → Marshmallow pre_load → PYDANTIC VALIDATES → Marshmallow post
 
 from __future__ import annotations
 
+import threading
 from collections.abc import Callable, Sequence, Set as AbstractSet
+from functools import lru_cache
+from importlib.metadata import version as get_version
 from typing import Any, ClassVar, Generic, TypeVar, cast, get_args, get_origin
 
 from marshmallow import EXCLUDE, INCLUDE, RAISE, Schema, fields as ma_fields
@@ -15,22 +18,76 @@ from marshmallow.decorators import VALIDATES, VALIDATES_SCHEMA
 from marshmallow.error_store import ErrorStore
 from marshmallow.exceptions import ValidationError as MarshmallowValidationError
 from marshmallow.schema import SchemaMeta
+from marshmallow.utils import missing as ma_missing  # type: ignore[attr-defined,unused-ignore]
 from pydantic import BaseModel, ConfigDict, ValidationError as PydanticValidationError
 
 from .errors import BridgeValidationError, convert_pydantic_errors, format_pydantic_error
-from .field_conversion import convert_model_fields, convert_pydantic_field
+from .field_conversion import _get_computed_fields, convert_model_fields, convert_pydantic_field
 from .validators import cache_validators
 
+
+# Marshmallow version detection for context parameter compatibility
+# MA 4.x removes the `context` parameter from Schema.__init__
+def _parse_version(version_str: str) -> tuple[int, int]:
+    """Parse version string, handling pre-release versions like '4.0.0rc1'."""
+    import re
+    match = re.match(r'(\d+)\.(\d+)', version_str)
+    if match:
+        return (int(match.group(1)), int(match.group(2)))
+    raise ValueError(f"Cannot parse marshmallow version: {version_str}")  # pragma: no cover
+
+
+_MARSHMALLOW_VERSION = _parse_version(get_version("marshmallow"))
+_MARSHMALLOW_4_PLUS = _MARSHMALLOW_VERSION >= (4, 0)
+
+
 M = TypeVar("M", bound=BaseModel)
 
+# =============================================================================
+# Module-level Caches
+# =============================================================================
+# Thread Safety: All caches use thread-safe implementations to support both
+# GIL-enabled Python and free-threaded Python 3.14+ (PEP 703).
+# - @lru_cache: Inherently thread-safe (uses internal lock)
+# - Dict caches: Protected by threading.Lock for write operations
+#
+# Cache Invalidation: These caches assume Pydantic models are immutable after
+# definition. Dynamic model modification at runtime (monkey-patching, adding
+# fields) will result in stale cached data. This is an accepted trade-off for
+# performance gains.
+# =============================================================================
+
+# Thread lock for cache writes (supports free-threaded Python 3.14+)
+# Use RLock (reentrant) since from_model() may be called recursively
+_cache_lock = threading.RLock()
+
 # Module-level cache for HybridModel schemas
 _hybrid_schema_cache: dict[type[Any], type[PydanticSchema[Any]]] = {}
 
+# Cache for schema_for/from_model - key is (model, schema_name, frozen options)
+# This avoids recreating schema classes for the same model+options
+_schema_class_cache: dict[tuple[type[Any], str | None, tuple[tuple[str, Any], ...]], type[Any]] = {}
+
 # Field validator registry: maps (schema_class, field_name) -> list of validator functions
 _field_validators: dict[tuple[type[Any], str], list[Callable[..., Any]]] = {}
 _schema_validators: dict[type[Any], list[Callable[..., Any]]] = {}
 
 
+@lru_cache(maxsize=1024)
+def _get_model_field_names_with_aliases(model_class: type[BaseModel]) -> frozenset[str]:
+    """
+    Get cached frozenset of model field names including aliases.
+
+    Thread-safe via @lru_cache. Caches the result per model class to avoid
+    repeated computation in the load() hot path.
+    """
+    field_names = set(model_class.model_fields.keys())
+    for field_info in model_class.model_fields.values():
+        if field_info.alias:
+            field_names.add(field_info.alias)
+    return frozenset(field_names)
+
+
 class PydanticSchemaMeta(SchemaMeta):
     """
     Custom metaclass that adds Pydantic model fields BEFORE Marshmallow processes them.
@@ -130,10 +187,11 @@ class PydanticSchemaMeta(SchemaMeta):
                 attrs[field_name] = convert_pydantic_field(field_name, field_info)
 
             # Add computed fields as dump_only
-            if hasattr(model_class, 'model_computed_fields'):
+            computed_fields = _get_computed_fields(model_class)
+            if computed_fields:
                 from .field_conversion import convert_computed_field
 
-                for field_name, computed_info in model_class.model_computed_fields.items():
+                for field_name, computed_info in computed_fields.items():
                     if field_name in attrs:
                         continue
                     # If attrs has pre-filtered fields, don't add computed fields
@@ -149,7 +207,7 @@ class PydanticSchemaMeta(SchemaMeta):
         return cast(PydanticSchemaMeta, super().__new__(mcs, name, bases, attrs))
 
 
-class PydanticSchema(Schema, Generic[M], metaclass=PydanticSchemaMeta):
+class _PydanticSchema(Schema, Generic[M], metaclass=PydanticSchemaMeta):
     """
     A Marshmallow schema backed by a Pydantic model.
 
@@ -228,20 +286,27 @@ class PydanticSchema(Schema, Generic[M], metaclass=PydanticSchemaMeta):
         self._dump_only_fields: set[str] = set(dump_only) if dump_only else set()
         self._partial: bool | Sequence[str] | AbstractSet[str] | None = partial
         self._unknown_override: str | None = unknown
-        self._context = context or {}
 
-        # Pass all known kwargs to parent including context
-        super().__init__(
-            only=only,
-            exclude=exclude,
-            context=context,
-            many=many,
-            load_only=load_only,
-            dump_only=dump_only,
-            partial=partial,
-            unknown=unknown,
+        # Build kwargs for super().__init__()
+        # MA 4.x removes context parameter - only pass it for MA 3.x
+        parent_kwargs: dict[str, Any] = {
+            "only": only,
+            "exclude": exclude,
+            "many": many,
+            "load_only": load_only,
+            "dump_only": dump_only,
+            "partial": partial,
+            "unknown": unknown,
             **kwargs,
-        )
+        }
+        if not _MARSHMALLOW_4_PLUS:
+            parent_kwargs["context"] = context
+
+        super().__init__(**parent_kwargs)
+
+        # For MA 4.x, store context manually if provided
+        if _MARSHMALLOW_4_PLUS and context is not None:  # pragma: no cover
+            self.context = context
         self._model_class = self._get_model_class()
         if self._model_class:
             self._setup_fields_from_model()
@@ -250,7 +315,7 @@ class PydanticSchema(Schema, Generic[M], metaclass=PydanticSchemaMeta):
         for field_name, field_obj in self.fields.items():
             self.on_bind_field(field_name, field_obj)
 
-    def on_bind_field(self, field_name: str, field_obj: ma_fields.Field) -> None:
+    def on_bind_field(self, field_name: str, field_obj: Any) -> None:
         """
         Hook called when a field is bound to the schema.
 
@@ -300,16 +365,6 @@ class PydanticSchema(Schema, Generic[M], metaclass=PydanticSchemaMeta):
         """
         raise error
 
-    @property
-    def context(self) -> dict[str, Any]:
-        """Get the validation context."""
-        return self._context
-
-    @context.setter
-    def context(self, value: dict[str, Any]) -> None:
-        """Set the validation context."""
-        self._context = value
-
     def _get_model_class(self) -> type[BaseModel] | None:
         """Get the Pydantic model class from Meta or generic parameter."""
         # Try Meta.model first
@@ -389,6 +444,7 @@ class PydanticSchema(Schema, Generic[M], metaclass=PydanticSchemaMeta):
         data: dict[str, Any],
         partial: bool | Sequence[str] | AbstractSet[str] | None = None,
         original_data: Any | None = None,
+        skip_model_dump: bool = False,
     ) -> tuple[dict[str, Any], M | None]:
         """
         Use Pydantic to validate and coerce the input data.
@@ -396,6 +452,13 @@ class PydanticSchema(Schema, Generic[M], metaclass=PydanticSchemaMeta):
         Filters out marshmallow.missing sentinel values before Pydantic validation,
         allowing Pydantic to use its own defaults for missing fields.
 
+        Args:
+            data: Input data to validate
+            partial: Partial validation mode
+            original_data: Original input data for error reporting
+            skip_model_dump: If True and not partial, skip model_dump() and return
+                           empty dict. Use when validators don't need the dict.
+
         Returns:
             Tuple of (validated_data_dict, model_instance)
             The instance is returned to avoid redundant validation later.
@@ -404,8 +467,6 @@ class PydanticSchema(Schema, Generic[M], metaclass=PydanticSchemaMeta):
             return data, None
 
         # Filter out marshmallow.missing values - Pydantic should use its defaults
-        from marshmallow.utils import missing as ma_missing
-
         clean_data = {
             k: v for k, v in data.items()
             if v is not ma_missing
@@ -420,6 +481,9 @@ class PydanticSchema(Schema, Generic[M], metaclass=PydanticSchemaMeta):
             else:
                 # Let Pydantic do all the validation - KEEP THE INSTANCE
                 instance = self._model_class.model_validate(clean_data)
+                # OPTIMIZATION: Skip model_dump if not needed for validators
+                if skip_model_dump:
+                    return {}, cast(M, instance)
                 # Return both the dict (for validators) and instance (for result)
                 validated_data = instance.model_dump(by_alias=False)
                 # Cast to M since model_validate returns the correct model type
@@ -545,6 +609,11 @@ class PydanticSchema(Schema, Generic[M], metaclass=PydanticSchemaMeta):
 
         This ensures 100% Marshmallow hook compatibility.
         """
+        # PERFORMANCE: Hoist frequently accessed attributes to local variables
+        # This avoids repeated self.__dict__ lookups in the hot path
+        model_class = self._model_class
+        hooks = self._hooks
+
         # Resolve settings
         if many is None:
             many = self.many
@@ -562,7 +631,9 @@ class PydanticSchema(Schema, Generic[M], metaclass=PydanticSchemaMeta):
         if many:
             if not isinstance(data, list):
                 raise MarshmallowValidationError({"_schema": ["Expected a list."]})
-            return [
+
+            # Process each item individually (validators run per-item with pass_many=False)
+            results = [
                 self._do_load(
                     item,
                     many=False,
@@ -574,28 +645,57 @@ class PydanticSchema(Schema, Generic[M], metaclass=PydanticSchemaMeta):
                 for item in data
             ]
 
-        # Step 1: Run pre_load hooks ONLY if they exist (PERFORMANCE OPTIMIZATION)
-        # Skipping _invoke_load_processors when empty saves ~5ms per 10k loads
-        if self._hooks.get("pre_load"):
-            processed_data = self._invoke_load_processors(
-                "pre_load",
-                data,
-                many=False,
-                original_data=data,
-                partial=partial,
-            )
-        else:
-            processed_data = data
+            # After all items processed, run @validates_schema(pass_many=True) validators
+            # These should see the FULL collection, not individual items
+            coll_error_store_cls: Callable[[], Any] = cast(Callable[[], Any], ErrorStore)
+            coll_error_store: Any = coll_error_store_cls()
+
+            # Build kwargs for collection-level validation
+            coll_pass_param = "pass_collection" if _MARSHMALLOW_4_PLUS else "pass_many"
+            coll_validator_kwargs: dict[str, Any] = {
+                "error_store": coll_error_store,
+                "data": results,
+                "original_data": data,
+                "many": True,
+                "partial": partial,
+                "field_errors": False,  # Field errors already handled per-item
+            }
+            # MA 4.x requires 'unknown' parameter
+            if _MARSHMALLOW_4_PLUS:  # pragma: no cover
+                coll_validator_kwargs["unknown"] = unknown_setting
+            # Only run pass_many=True validators (collection-level)
+            self._invoke_schema_validators(**{coll_pass_param: True, **coll_validator_kwargs})
+
+            if coll_error_store.errors:
+                error = MarshmallowValidationError(dict(coll_error_store.errors))
+                self.handle_error(error, data, many=True)
+
+            return results
+
+        # Step 1: Run pre_load hooks
+        # MA 4.x requires 'unknown' parameter, MA 3.x doesn't accept it
+        pre_load_kwargs: dict[str, Any] = {
+            "many": False,
+            "original_data": data,
+            "partial": partial,
+        }
+        if _MARSHMALLOW_4_PLUS:  # pragma: no cover
+            pre_load_kwargs["unknown"] = unknown_setting
+        processed_data_raw = self._invoke_load_processors(
+            "pre_load",
+            data,
+            **pre_load_kwargs,
+        )
 
-        # Step 2: Handle unknown fields based on setting
-        if self._model_class:
-            model_fields = set(self._model_class.model_fields.keys())
-            # Also include aliases in known fields
-            for _field_name, field_info in self._model_class.model_fields.items():
-                if field_info.alias:
-                    model_fields.add(field_info.alias)
+        # Type narrowing: at this point (many=False path), data is always a dict
+        processed_data: dict[str, Any] = cast(dict[str, Any], processed_data_raw)
 
-            unkn_fields = set(processed_data.keys()) - model_fields
+        # Step 2: Handle unknown fields based on setting
+        # PERFORMANCE: Use cached field names instead of computing every time
+        model_field_names: frozenset[str] | None = None
+        if model_class:
+            model_field_names = _get_model_field_names_with_aliases(model_class)
+            unkn_fields = set(processed_data.keys()) - model_field_names
 
             if unkn_fields:
                 if unknown_setting == RAISE:
@@ -604,17 +704,52 @@ class PydanticSchema(Schema, Generic[M], metaclass=PydanticSchemaMeta):
                 if unknown_setting == EXCLUDE:
                     # Remove unknown fields
                     processed_data = {
-                        k: v for k, v in processed_data.items() if k in model_fields
+                        k: v for k, v in processed_data.items() if k in model_field_names
                     }
                 # INCLUDE: keep unknown fields in the result (handled below)
 
         # Step 3: Pydantic validates the transformed data
         # Returns (validated_dict, instance) - instance reused to avoid double validation
-        pydantic_instance = None
-        if self._model_class:
+        pydantic_instance: M | None = None
+        validated_data: dict[str, Any]
+
+        # OPTIMIZATION: Determine if we need model_dump() for validators/result
+        # Skip expensive model_dump() when not needed
+        # Note: MA 3.x uses tuple keys ('validates', field) and ('validates_schema', pass_many)
+        # MA 4.x uses string keys ('validates', 'validates_schema')
+        # Check for any hook that starts with the validator type
+        def _has_hook(hook_type: str) -> bool:
+            """Check if any hook matches the type (handles both MA 3.x and 4.x key formats)."""
+            # Check string key (MA 4.x) - safe to access defaultdict
+            if hooks.get(hook_type):
+                return True
+            # Check tuple keys (MA 3.x) - cast to Any to avoid mypy narrowing issues
+            # across different Marshmallow versions with different key types
+            hooks_any: dict[Any, Any] = cast(dict[Any, Any], hooks)
+            for key in hooks_any:
+                if isinstance(key, tuple) and len(key) >= 1 and key[0] == hook_type and hooks_any[key]:
+                    return True
+            return False
+
+        has_validators = bool(
+            _has_hook(VALIDATES)
+            or _has_hook(VALIDATES_SCHEMA)
+            or self._field_validators_cache
+            or self._schema_validators_cache
+        )
+        needs_dict = (
+            not return_instance  # Need dict for result
+            or unknown_setting == INCLUDE  # Need dict to merge unknown fields
+            or has_validators  # Need dict for validators
+        )
+
+        if model_class:
             try:
                 validated_data, pydantic_instance = self._validate_with_pydantic(
-                    processed_data, partial=partial, original_data=data
+                    processed_data,
+                    partial=partial,
+                    original_data=data,
+                    skip_model_dump=not needs_dict,
                 )
             except MarshmallowValidationError as pydantic_error:
                 # Call handle_error for Pydantic validation errors
@@ -623,8 +758,8 @@ class PydanticSchema(Schema, Generic[M], metaclass=PydanticSchemaMeta):
                 raise
 
             # If INCLUDE, add unknown fields back to validated data
-            if unknown_setting == INCLUDE and self._model_class:
-                for field in (set(processed_data.keys()) - model_fields):
+            if unknown_setting == INCLUDE and model_field_names is not None:
+                for field in (set(processed_data.keys()) - model_field_names):
                     validated_data[field] = processed_data[field]
         else:
             validated_data = processed_data
@@ -635,13 +770,12 @@ class PydanticSchema(Schema, Generic[M], metaclass=PydanticSchemaMeta):
         error_store_cls: Callable[[], Any] = cast(Callable[[], Any], ErrorStore)
         error_store: Any = error_store_cls()
 
-        # 4a: Run Marshmallow's native @validates decorators (from _hooks)
-        if self._hooks[VALIDATES]:
-            self._invoke_field_validators(
-                error_store=error_store,
-                data=validated_data,
-                many=False,
-            )
+        # 4a: Run Marshmallow's native @validates decorators (from hooks)
+        self._invoke_field_validators(
+            error_store=error_store,
+            data=validated_data,
+            many=False,
+        )
 
         # 4b: Run our custom @validates decorators (backwards compatibility)
         try:
@@ -656,25 +790,25 @@ class PydanticSchema(Schema, Generic[M], metaclass=PydanticSchemaMeta):
 
         # Step 5: Run schema validators (BOTH Marshmallow native AND our custom)
         # 5a: Run Marshmallow's native @validates_schema decorators
-        if self._hooks[VALIDATES_SCHEMA]:
-            self._invoke_schema_validators(
-                error_store=error_store,
-                pass_many=True,
-                data=validated_data,
-                original_data=data,
-                many=False,
-                partial=partial,
-                field_errors=has_field_errors,
-            )
-            self._invoke_schema_validators(
-                error_store=error_store,
-                pass_many=False,
-                data=validated_data,
-                original_data=data,
-                many=False,
-                partial=partial,
-                field_errors=has_field_errors,
-            )
+        # MA 4.x renamed pass_many -> pass_collection
+        # Build common kwargs
+        validator_kwargs: dict[str, Any] = {
+            "error_store": error_store,
+            "data": validated_data,
+            "original_data": data,
+            "many": False,
+            "partial": partial,
+            "field_errors": has_field_errors,
+        }
+        # MA 4.x requires 'unknown' parameter
+        if _MARSHMALLOW_4_PLUS:  # pragma: no cover
+            validator_kwargs["unknown"] = unknown_setting
+        # Pass the correctly-named parameter for the marshmallow version
+        pass_param = "pass_collection" if _MARSHMALLOW_4_PLUS else "pass_many"
+
+        # Only run pass_many=False validators in per-item mode
+        # pass_many=True validators are handled at the collection level (in many=True block above)
+        self._invoke_schema_validators(**{pass_param: False, **validator_kwargs})
 
         # 5b: Run our custom @validates_schema decorators (backwards compatibility)
         try:
@@ -690,7 +824,7 @@ class PydanticSchema(Schema, Generic[M], metaclass=PydanticSchemaMeta):
             self.handle_error(error, data, many=False)
 
         # Step 6: Prepare result based on return_instance flag
-        if self._model_class and return_instance:
+        if model_class and return_instance:
             if not partial:
                 # OPTIMIZATION: Reuse the instance from _validate_with_pydantic
                 result = pydantic_instance if pydantic_instance is not None else validated_data
@@ -701,7 +835,7 @@ class PydanticSchema(Schema, Generic[M], metaclass=PydanticSchemaMeta):
                 construct_data = {}
                 fields_set = set()
 
-                for field_name, field_info in self._model_class.model_fields.items():
+                for field_name, field_info in model_class.model_fields.items():
                     if field_name in validated_data:
                         construct_data[field_name] = validated_data[field_name]
                         fields_set.add(field_name)
@@ -718,20 +852,26 @@ class PydanticSchema(Schema, Generic[M], metaclass=PydanticSchemaMeta):
                             construct_data[field_name] = None
 
                 result = cast(
-                    M, self._model_class.model_construct(_fields_set=fields_set, **construct_data)
+                    M, model_class.model_construct(_fields_set=fields_set, **construct_data)
                 )
         else:
             # Return dict instead of instance
             result = validated_data
 
-        # Step 7: Run post_load hooks ONLY if they exist (PERFORMANCE OPTIMIZATION)
-        if postprocess and self._hooks.get("post_load"):
+        # Step 7: Run post_load hooks
+        if postprocess:
+            # MA 4.x requires 'unknown' parameter, MA 3.x doesn't accept it
+            post_load_kwargs: dict[str, Any] = {
+                "many": False,
+                "original_data": data,
+                "partial": partial,
+            }
+            if _MARSHMALLOW_4_PLUS:  # pragma: no cover
+                post_load_kwargs["unknown"] = unknown_setting
             result = self._invoke_load_processors(
                 "post_load",
-                result,
-                many=False,
-                original_data=data,
-                partial=partial,
+                cast(dict[str, Any], result),
+                **post_load_kwargs,
             )
 
         return result
@@ -975,8 +1115,9 @@ class PydanticSchema(Schema, Generic[M], metaclass=PydanticSchemaMeta):
                         fields_to_exclude.add(field_name)
 
             # Extract computed field values BEFORE converting to dict
-            if include_computed and hasattr(model_class, 'model_computed_fields'):
-                for field_name in model_class.model_computed_fields:
+            computed_fields = _get_computed_fields(model_class)
+            if include_computed and computed_fields:
+                for field_name in computed_fields:
                     value = getattr(obj, field_name)
                     # Apply exclusion rules to computed fields too
                     if exclude_none and value is None:
@@ -989,7 +1130,7 @@ class PydanticSchema(Schema, Generic[M], metaclass=PydanticSchemaMeta):
             obj = obj.model_dump(by_alias=False)
 
         # Let Marshmallow handle the standard dump
-        result: dict[str, Any] = super().dump(obj, many=False)
+        result: dict[str, Any] = cast(dict[str, Any], super().dump(obj, many=False))
 
         # Apply field exclusions
         if fields_to_exclude:
@@ -1032,6 +1173,20 @@ class PydanticSchema(Schema, Generic[M], metaclass=PydanticSchemaMeta):
         Returns:
             A PydanticSchema subclass
         """
+        # Build cache key from model, schema_name, and options
+        # Sort options to ensure consistent keys
+        # Note: schema_name must be included since it affects the generated class name
+        cache_key: tuple[type[Any], str | None, tuple[tuple[str, Any], ...]] | None = None
+        try:
+            cache_key = (model, schema_name, tuple(sorted(meta_options.items())))
+            # Thread-safe read (atomic dict lookup)
+            cached = _schema_class_cache.get(cache_key)
+            if cached is not None:
+                return cached
+        except TypeError:
+            # Unhashable options (e.g., list values) - skip cache
+            cache_key = None
+
         name = schema_name or f"{model.__name__}Schema"
 
         # Extract field filtering options
@@ -1063,9 +1218,75 @@ class PydanticSchema(Schema, Generic[M], metaclass=PydanticSchemaMeta):
         class_dict: dict[str, Any] = {"Meta": Meta, **fields}
 
         schema_cls = type(name, (cls,), class_dict)
+
+        # Thread-safe cache write (supports free-threaded Python 3.14+)
+        if cache_key is not None:
+            with _cache_lock:
+                _schema_class_cache[cache_key] = schema_cls
+
         return schema_cls
 
 
+if _MARSHMALLOW_4_PLUS:  # pragma: no cover
+    class PydanticSchema(_PydanticSchema[M], Generic[M]):
+        def __init__(
+            self,
+            *,
+            only: Sequence[str] | None = None,
+            exclude: Sequence[str] = (),
+            load_only: Sequence[str] = (),
+            dump_only: Sequence[str] = (),
+            partial: bool | Sequence[str] | AbstractSet[str] | None = None,
+            unknown: str | None = None,
+            many: bool | None = None,
+            **kwargs: Any,
+        ) -> None:
+            # MA 4.x removed context parameter - reject it to match native behavior
+            if "context" in kwargs:
+                raise TypeError(
+                    "PydanticSchema.__init__() got an unexpected keyword argument 'context'. "
+                    "The context parameter was removed in Marshmallow 4.x. "
+                    "Use contextvars.ContextVar instead."
+                )
+            super().__init__(
+                only=only,
+                exclude=exclude,
+                load_only=load_only,
+                dump_only=dump_only,
+                partial=partial,
+                unknown=unknown,
+                many=many,
+                **kwargs,
+            )
+else:
+    class PydanticSchema(_PydanticSchema[M], Generic[M]):  # type: ignore[no-redef]
+        def __init__(
+            self,
+            *,
+            only: Sequence[str] | None = None,
+            exclude: Sequence[str] = (),
+            context: dict[str, Any] | None = None,
+            load_only: Sequence[str] = (),
+            dump_only: Sequence[str] = (),
+            partial: bool | Sequence[str] | AbstractSet[str] | None = None,
+            unknown: str | None = None,
+            many: bool | None = None,
+            **kwargs: Any,
+        ) -> None:
+            # Pass context to super so Marshmallow sets self.context correctly
+            super().__init__(
+                only=only,
+                exclude=exclude,
+                context=context,
+                load_only=load_only,
+                dump_only=dump_only,
+                partial=partial,
+                unknown=unknown,
+                many=many,
+                **kwargs,
+            )
+
+
 def schema_for(model: type[M], **meta_options: Any) -> type[PydanticSchema[M]]:
     """
     Shortcut to create a Marshmallow schema from a Pydantic model.
@@ -1155,10 +1376,17 @@ class HybridModel(BaseModel):
 
     @classmethod
     def marshmallow_schema(cls) -> type[PydanticSchema[Any]]:
-        """Get or create the Marshmallow schema for this model."""
-        if cls not in _hybrid_schema_cache:
-            _hybrid_schema_cache[cls] = PydanticSchema.from_model(cls)
-        return _hybrid_schema_cache[cls]
+        """Get or create the Marshmallow schema for this model (thread-safe)."""
+        # Thread-safe read
+        cached = _hybrid_schema_cache.get(cls)
+        if cached is not None:
+            return cached
+        # Thread-safe write
+        with _cache_lock:
+            # Double-check after acquiring lock
+            if cls not in _hybrid_schema_cache:
+                _hybrid_schema_cache[cls] = PydanticSchema.from_model(cls)
+            return _hybrid_schema_cache[cls]
 
     @classmethod
     def ma_load(cls, data: dict[str, Any], **kwargs: Any) -> HybridModel:

pydantic_marshmallow/field_conversion.py

@@ -10,17 +10,37 @@ from __future__ import annotations
 from types import UnionType
 from typing import Any, Union, get_args, get_origin
 
-from marshmallow import fields as ma_fields
 from pydantic import BaseModel
 from pydantic_core import PydanticUndefined
 
 from .type_mapping import type_to_marshmallow_field
 
 
+def _get_computed_fields(model_class: type[BaseModel]) -> dict[str, Any]:
+    """Get computed fields dict from a Pydantic model class.
+
+    Handles differences between Pydantic versions:
+    - Pydantic 2.0.x: model_computed_fields is a property (only works on instances)
+    - Pydantic 2.4+: model_computed_fields works directly on classes
+    """
+    # Try direct access first (works in newer Pydantic)
+    result = getattr(model_class, 'model_computed_fields', None)
+    if isinstance(result, dict):
+        return result
+
+    # For Pydantic 2.0.x: model_computed_fields is a property, call its getter
+    if isinstance(result, property) and result.fget:
+        prop_result = result.fget(model_class)
+        if isinstance(prop_result, dict):
+            return prop_result
+
+    return {}
+
+
 def convert_pydantic_field(
     field_name: str,
     field_info: Any,
-) -> ma_fields.Field:
+) -> Any:
     """
     Convert a single Pydantic FieldInfo to a Marshmallow Field.
 
@@ -70,7 +90,7 @@ def convert_pydantic_field(
 def convert_computed_field(
     field_name: str,
     computed_info: Any,
-) -> ma_fields.Field:
+) -> Any:
     """
     Convert a Pydantic computed_field to a dump-only Marshmallow Field.
 
@@ -93,7 +113,7 @@ def convert_model_fields(
     include: set[str] | None = None,
     exclude: set[str] | None = None,
     include_computed: bool = True,
-) -> dict[str, ma_fields.Field]:
+) -> dict[str, Any]:
     """
     Convert all fields from a Pydantic model to Marshmallow fields.
 
@@ -111,7 +131,7 @@ def convert_model_fields(
     Returns:
         Dict mapping field names to Marshmallow field instances
     """
-    fields: dict[str, ma_fields.Field] = {}
+    fields: dict[str, Any] = {}
     exclude_set = exclude or set()
 
     # Convert regular model fields
@@ -125,8 +145,9 @@ def convert_model_fields(
         fields[field_name] = convert_pydantic_field(field_name, field_info)
 
     # Convert computed fields (dump-only)
-    if include_computed and hasattr(model, 'model_computed_fields'):
-        for field_name, computed_info in model.model_computed_fields.items():
+    computed_fields = _get_computed_fields(model)
+    if include_computed and computed_fields:
+        for field_name, computed_info in computed_fields.items():
             if field_name in exclude_set:
                 continue
             if include is not None and field_name not in include:

pydantic_marshmallow/type_mapping.py

@@ -4,9 +4,13 @@ Type mapping utilities for converting Python/Pydantic types to Marshmallow field
 This module provides type-to-field conversions, leveraging Marshmallow's native
 TYPE_MAPPING for basic types and adding support for generic collections.
 """
+
+from __future__ import annotations
+
 from enum import Enum as PyEnum
+from functools import lru_cache
 from types import UnionType
-from typing import Any, Literal, Union, get_args, get_origin
+from typing import Any, Literal, Union, cast, get_args, get_origin
 
 from marshmallow import Schema, fields as ma_fields
 from pydantic import BaseModel
@@ -15,7 +19,21 @@ from pydantic import BaseModel
 _processing_models: set[type[Any]] = set()
 
 
-def type_to_marshmallow_field(type_hint: Any) -> ma_fields.Field:
+# Cache for simple type -> field class lookups (str, int, datetime, etc.)
+# These are the most common types and benefit most from caching.
+# maxsize=512 handles large codebases with ~80KB memory overhead.
+@lru_cache(maxsize=512)
+def _get_simple_field_class(type_hint: type) -> type[Any]:
+    """
+    Cached lookup for simple, hashable types in Marshmallow's TYPE_MAPPING.
+
+    This avoids repeated dict lookups and isinstance checks for common types
+    like str, int, float, bool, datetime, etc.
+    """
+    return Schema.TYPE_MAPPING.get(type_hint, ma_fields.Raw)
+
+
+def type_to_marshmallow_field(type_hint: Any) -> Any:
     """
     Map a Python type to a Marshmallow field instance.
 
@@ -36,6 +54,18 @@ def type_to_marshmallow_field(type_hint: Any) -> ma_fields.Field:
     Returns:
         An appropriate Marshmallow field instance
     """
+    # FAST PATH: Simple types (str, int, float, bool, datetime, etc.)
+    # Check TYPE_MAPPING first to skip all the isinstance/origin checks.
+    # This handles ~60-80% of fields in typical models, but we must not
+    # short-circuit for Enums or Pydantic models, which have specialized handling.
+    if (
+        isinstance(type_hint, type)
+        and type_hint in Schema.TYPE_MAPPING
+        and not issubclass(type_hint, (PyEnum, BaseModel))
+    ):
+        # Cast needed for mypy: type_hint is confirmed to be a type at this point
+        return _get_simple_field_class(cast(type, type_hint))()
+
     origin = get_origin(type_hint)
     args = get_args(type_hint)
 
@@ -61,40 +91,47 @@ def type_to_marshmallow_field(type_hint: Any) -> ma_fields.Field:
         return ma_fields.Raw(allow_none=True)
 
     # Handle Enum types
-    if isinstance(type_hint, type) and issubclass(type_hint, PyEnum):
-        return ma_fields.Enum(type_hint)
+    # Use try-except because some type hints pass isinstance(x, type) but fail issubclass()
+    try:
+        if isinstance(type_hint, type) and issubclass(type_hint, PyEnum):
+            return ma_fields.Enum(type_hint)
+    except TypeError:
+        pass  # Not a valid class for issubclass check
 
     # Handle nested Pydantic models - use Nested with a dynamically created schema
-    if isinstance(type_hint, type) and issubclass(type_hint, BaseModel):
-        # Import here to avoid circular imports
-        from pydantic_marshmallow.bridge import PydanticSchema
-
-        # Check if we're already processing this model (recursion detection)
-        # Use a module-level set to track models being processed
-        if type_hint in _processing_models:
-            # Self-referential model - use Raw to avoid infinite recursion
-            # Pydantic will still handle the validation correctly
-            return ma_fields.Raw()
-
-        try:
-            _processing_models.add(type_hint)
-            # Create a nested schema class for this model
-            nested_schema = PydanticSchema.from_model(type_hint)
-            return ma_fields.Nested(nested_schema)
-        finally:
-            _processing_models.discard(type_hint)
+    try:
+        if isinstance(type_hint, type) and issubclass(type_hint, BaseModel):
+            # Import here to avoid circular imports
+            from pydantic_marshmallow.bridge import PydanticSchema
+
+            # Check if we're already processing this model (recursion detection)
+            # Use a module-level set to track models being processed
+            if type_hint in _processing_models:
+                # Self-referential model - use Raw to avoid infinite recursion
+                # Pydantic will still handle the validation correctly
+                return ma_fields.Raw()
+
+            try:
+                _processing_models.add(type_hint)
+                # Create a nested schema class for this model
+                nested_schema = PydanticSchema.from_model(type_hint)
+                return ma_fields.Nested(nested_schema)
+            finally:
+                _processing_models.discard(type_hint)
+    except TypeError:
+        pass  # Not a valid class for issubclass check
 
     # Handle list[T]
     if origin is list:
-        inner: ma_fields.Field = ma_fields.Raw()
+        inner = ma_fields.Raw()
         if args:
             inner = type_to_marshmallow_field(args[0])
         return ma_fields.List(inner)
 
     # Handle dict[K, V]
     if origin is dict:
-        key_field: ma_fields.Field = ma_fields.String()
-        value_field: ma_fields.Field = ma_fields.Raw()
+        key_field = ma_fields.String()
+        value_field = ma_fields.Raw()
         if args and len(args) >= 2:
             key_field = type_to_marshmallow_field(args[0])
             value_field = type_to_marshmallow_field(args[1])
@@ -102,7 +139,7 @@ def type_to_marshmallow_field(type_hint: Any) -> ma_fields.Field:
 
     # Handle set[T] and frozenset[T] - convert to List in Marshmallow
     if origin in (set, frozenset):
-        inner_set: ma_fields.Field = ma_fields.Raw()
+        inner_set = ma_fields.Raw()
         if args:
             inner_set = type_to_marshmallow_field(args[0])
         return ma_fields.List(inner_set)
@@ -128,11 +165,11 @@ def type_to_marshmallow_field(type_hint: Any) -> ma_fields.Field:
         if any(ut in type_name for ut in url_types):
             return ma_fields.URL()
         if 'IP' in type_name:
-            # IP field exists in marshmallow but may not have type stubs
-            return ma_fields.IP()  # type: ignore[no-untyped-call]
+            return ma_fields.IP()  # type: ignore[no-untyped-call,unused-ignore]
 
     # Use Marshmallow's native TYPE_MAPPING for basic types
     # This ensures we stay in sync with Marshmallow's type handling
     resolved = origin if origin else type_hint
-    field_cls = Schema.TYPE_MAPPING.get(resolved, ma_fields.Raw)
-    return field_cls()
+    if isinstance(resolved, type):
+        return _get_simple_field_class(resolved)()
+    return ma_fields.Raw()

{pydantic_marshmallow-1.0.0.dist-info → pydantic_marshmallow-1.1.0.dist-info}/METADATA

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: pydantic-marshmallow
-Version: 1.0.0
+Version: 1.1.0
 Summary: Bring Pydantic's power to Marshmallow: type annotations, validators, and automatic schema generation
-Author-email: Your Name <your.email@example.com>
+Author: Michael Thomas
 License: MIT
 Project-URL: Homepage, https://github.com/mockodin/pydantic-marshmallow
 Project-URL: Documentation, https://mockodin.github.io/pydantic-marshmallow
@@ -24,18 +24,17 @@ Classifier: Typing :: Typed
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: marshmallow>=3.18.0
-Requires-Dist: pydantic>=2.0.0
+Requires-Dist: marshmallow<5.0.0,>=3.18.0
+Requires-Dist: pydantic<3.0.0,>=2.0.0
 Requires-Dist: typing-extensions>=4.0.0
 Requires-Dist: orjson>=3.9.0
 Provides-Extra: dev
 Requires-Dist: pytest>=8.0.0; extra == "dev"
 Requires-Dist: pytest-cov>=5.0.0; extra == "dev"
 Requires-Dist: email-validator>=2.1.0; extra == "dev"
-Requires-Dist: mypy>=1.10.0; extra == "dev"
-Requires-Dist: ruff>=0.4.0; extra == "dev"
-Requires-Dist: flake8>=7.1.0; extra == "dev"
-Requires-Dist: flake8-pyproject>=1.2.4; extra == "dev"
+Requires-Dist: mypy==1.19.1; extra == "dev"
+Requires-Dist: ruff==0.15.0; extra == "dev"
+Requires-Dist: pre-commit>=4.2.0; extra == "dev"
 Requires-Dist: sqlalchemy>=2.0.30; extra == "dev"
 Requires-Dist: marshmallow-sqlalchemy>=1.1.0; extra == "dev"
 Requires-Dist: flask>=3.0.0; extra == "dev"
@@ -67,6 +66,40 @@ Bridge Pydantic's power with Marshmallow's ecosystem. Use Pydantic models for va
 
 📖 **[Documentation](https://mockodin.github.io/pydantic-marshmallow)** | 🐙 **[GitHub](https://github.com/mockodin/pydantic-marshmallow)**
 
+## Why pydantic-marshmallow?
+
+Get the best of both worlds: **Pydantic's speed** with **Marshmallow's ecosystem**.
+
+### Performance
+
+pydantic-marshmallow uses Pydantic's Rust-powered validation engine under the hood, delivering significant performance improvements over native Marshmallow—especially for nested data structures.
+
+#### Performance Comparison
+
+| Operation | MA 3.x | MA 4.x | Bridge (MA 3.x) | Bridge (MA 4.x) |
+|-----------|--------|--------|-----------------|-----------------|
+| Simple load | 5.3 µs | 4.8 µs | 2.9 µs | 2.9 µs |
+| Nested model | 10.9 µs | 10.5 µs | 3.4 µs | 3.2 µs |
+| Deep nested (4 levels) | 31.2 µs | 29.0 µs | 5.3 µs | 5.2 µs |
+| Batch (100 items) | 454 µs | 424 µs | 260 µs | 259 µs |
+
+#### What the Numbers Show
+
+1. **MA 3.x → MA 4.x**: Marshmallow 4.x improved ~10% over 3.x (5.3 → 4.8 µs for simple loads)
+2. **MA 3.x → Bridge**: Adding Pydantic delivers **1.8x–5.9x speedup** over pure MA 3.x
+3. **MA 4.x → Bridge**: Still **1.6x–5.6x faster** than native MA 4.x
+4. **Bridge consistency**: ~2.9 µs for simple loads regardless of Marshmallow version
+
+The bridge delegates validation to Pydantic's Rust-powered core, bypassing Marshmallow's field processing. This means bridge performance is **independent of Marshmallow version**—you get consistent speed whether you're on MA 3.x or 4.x.
+
+*Benchmarks: Python 3.11, median of 3 runs with IQR outlier removal. Run `python -m benchmarks.run_benchmarks` to reproduce.*
+
+### Why it matters
+
+- **Existing Marshmallow projects**: Incrementally adopt Pydantic validation without rewriting your API layer
+- **Flask/webargs/apispec users**: Keep your integrations, get faster validation
+- **Performance-sensitive APIs**: Nested model validation is 3-6x faster than native Marshmallow
+
 ## Features
 
 - **Pydantic Validation**: Leverage Pydantic's Rust-powered validation engine
@@ -84,6 +117,8 @@ Bridge Pydantic's power with Marshmallow's ecosystem. Use Pydantic models for va
 pip install pydantic-marshmallow
 ```
 
+**Requirements:** Python 3.10+, Pydantic 2.0+, Marshmallow 3.18+ (including 4.x)
+
 ## Quick Start
 
 ### Basic Usage
@@ -213,7 +248,7 @@ class User(BaseModel):
     first: str
     last: str
 
-    @computed_field
+    @computed_field  # type: ignore[misc]
     @property
     def full_name(self) -> str:
         return f"{self.first} {self.last}"
@@ -237,6 +272,21 @@ schema.dump(user, exclude_unset=True)
 schema.dump(user, exclude_defaults=True)
 ```
 
+## JSON Serialization
+
+Direct JSON string support:
+
+```python
+# Deserialize from JSON string
+user = schema.loads('{"name": "Alice", "email": "alice@example.com", "age": 30}')
+
+# Serialize to JSON string  
+json_str = schema.dumps(user)
+
+# Batch operations
+users = schema.loads('[{"name": "Alice", ...}, {"name": "Bob", ...}]', many=True)
+```
+
 ## Flask-Marshmallow Integration
 
 ```python
@@ -288,6 +338,99 @@ spec = APISpec(
 spec.components.schema("User", schema=UserSchema)
 ```
 
+## flask-smorest Integration
+
+Build REST APIs with automatic OpenAPI documentation:
+
+```python
+from flask import Flask
+from flask_smorest import Api, Blueprint
+from pydantic import BaseModel, Field
+from pydantic_marshmallow import schema_for
+
+app = Flask(__name__)
+app.config["API_TITLE"] = "My API"
+app.config["API_VERSION"] = "v1"
+app.config["OPENAPI_VERSION"] = "3.0.2"
+
+api = Api(app)
+blp = Blueprint("users", __name__, url_prefix="/users")
+
+class UserCreate(BaseModel):
+    name: str = Field(min_length=1)
+    email: str
+
+UserCreateSchema = schema_for(UserCreate)
+UserSchema = schema_for(User)
+
+@blp.post("/")
+@blp.arguments(UserCreateSchema)
+@blp.response(201, UserSchema)
+def create_user(data):
+    # data is a Pydantic UserCreate instance
+    user = User(id=1, name=data.name, email=data.email)
+    return UserSchema().dump(user)
+
+api.register_blueprint(blp)
+```
+
+## flask-rebar Integration
+
+Build REST APIs with automatic Swagger documentation:
+
+```python
+from flask import Flask
+from flask_rebar import Rebar, get_validated_body
+from pydantic_marshmallow import schema_for
+
+app = Flask(__name__)
+rebar = Rebar()
+registry = rebar.create_handler_registry()
+
+UserCreateSchema = schema_for(UserCreate)
+UserSchema = schema_for(User)
+
+@registry.handles(
+    rule="/users",
+    method="POST",
+    request_body_schema=UserCreateSchema(),
+    response_body_schema=UserSchema(),
+)
+def create_user():
+    data = get_validated_body()  # Pydantic UserCreate instance
+    user = User(id=1, name=data.name, email=data.email)
+    return UserSchema().dump(user)
+
+rebar.init_app(app)
+```
+
+## SQLAlchemy Pattern
+
+Use Pydantic for API validation alongside SQLAlchemy ORM:
+
+```python
+from sqlalchemy.orm import Session
+from pydantic_marshmallow import schema_for
+
+# Pydantic model for API validation
+class UserCreate(BaseModel):
+    name: str = Field(min_length=1)
+    email: str
+
+UserCreateSchema = schema_for(UserCreate)
+
+def create_user(session: Session, data: dict):
+    # Validate API input with Pydantic
+    schema = UserCreateSchema()
+    validated = schema.load(data)  # Returns Pydantic model
+    
+    # Create ORM object from validated data
+    orm_user = UserModel(name=validated.name, email=validated.email)
+    session.add(orm_user)
+    session.commit()
+    return orm_user
+```
+
 ## HybridModel
 
 For models that need both Pydantic and Marshmallow APIs:

pydantic_marshmallow-1.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+pydantic_marshmallow/__init__.py,sha256=EQON4HpiOFDtC33MrrE6WFW68GBtDlx1IqbDWxbqghU,3100
+pydantic_marshmallow/bridge.py,sha256=fBk9vv6xZd-r-rhHufl-fbWSt784SEQ-IYrlm3duzpY,58026
+pydantic_marshmallow/errors.py,sha256=slWs9m6Iid32ZUg8uxzNbFoZWFqh7ZuiG5qPlcOaBuc,5304
+pydantic_marshmallow/field_conversion.py,sha256=WaWhvpB8rLL05I_D8b9q7BCymf24L7rxOpjMJY-TtYo,4978
+pydantic_marshmallow/py.typed,sha256=GehYepOFQ5fvmwg3UbxoFj6w91p2kWD3KUBXL_rJRUI,86
+pydantic_marshmallow/type_mapping.py,sha256=XlgOH3kksrv2kratQ1B1J1AJZj2spu7izoIF58hZeJs,6751
+pydantic_marshmallow/validators.py,sha256=hg7ZTrjGHcyzfOtGy6T1LLGx4puRD3VSCLf0KN0PE8g,6686
+pydantic_marshmallow-1.1.0.dist-info/licenses/LICENSE,sha256=y1B14nDO7pR7JdBNaWTLDt9MPBVRVuKZTUiRkw_eVgg,1071
+pydantic_marshmallow-1.1.0.dist-info/METADATA,sha256=gwysXAIX0iAhRfpAe1aCzQPQEX_u5DC-YYNcMu1zghg,15021
+pydantic_marshmallow-1.1.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+pydantic_marshmallow-1.1.0.dist-info/top_level.txt,sha256=sQCtMe_dpBvCrrBM6YIz1UQmGSf-XjdoBUeA2uyuoh4,21
+pydantic_marshmallow-1.1.0.dist-info/RECORD,,

pydantic_marshmallow-1.0.0.dist-info/RECORD

@@ -1,12 +0,0 @@
-pydantic_marshmallow/__init__.py,sha256=IeZH-ZcLxyy_OMfIn-IxbPRxskOnPxY94E7FLJEEBcA,2831
-pydantic_marshmallow/bridge.py,sha256=JkDF-BozWZtzTl31RMqRHPEV_eKbeybnsuEPNdrU--Q,47688
-pydantic_marshmallow/errors.py,sha256=slWs9m6Iid32ZUg8uxzNbFoZWFqh7ZuiG5qPlcOaBuc,5304
-pydantic_marshmallow/field_conversion.py,sha256=xFQtR63DwTDq-hGA_8Xe8sO6lFW6BCZNmnk5oxz5B6w,4262
-pydantic_marshmallow/py.typed,sha256=GehYepOFQ5fvmwg3UbxoFj6w91p2kWD3KUBXL_rJRUI,86
-pydantic_marshmallow/type_mapping.py,sha256=4gFVZV7WVywyugTyiE-y7saWaHmcaPeCs0vQjBQBQ8I,5285
-pydantic_marshmallow/validators.py,sha256=hg7ZTrjGHcyzfOtGy6T1LLGx4puRD3VSCLf0KN0PE8g,6686
-pydantic_marshmallow-1.0.0.dist-info/licenses/LICENSE,sha256=y1B14nDO7pR7JdBNaWTLDt9MPBVRVuKZTUiRkw_eVgg,1071
-pydantic_marshmallow-1.0.0.dist-info/METADATA,sha256=gVyLe10AtxyW4hJ9NTe43gIyPPBwigeu_BLWyopYfdg,10556
-pydantic_marshmallow-1.0.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-pydantic_marshmallow-1.0.0.dist-info/top_level.txt,sha256=sQCtMe_dpBvCrrBM6YIz1UQmGSf-XjdoBUeA2uyuoh4,21
-pydantic_marshmallow-1.0.0.dist-info/RECORD,,