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

pydantic_marshmallow/bridge.py

@@ -10,6 +10,7 @@ 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
@@ -17,13 +18,29 @@ 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
+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)
 
 # =============================================================================
@@ -170,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
@@ -189,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.
 
@@ -268,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()
@@ -290,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.
 
@@ -340,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
@@ -616,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,
@@ -628,18 +645,47 @@ 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 hooks.get("pre_load"):
-            processed_data_raw = self._invoke_load_processors(
-                "pre_load",
-                data,
-                many=False,
-                original_data=data,
-                partial=partial,
-            )
-        else:
-            processed_data_raw = 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,
+        )
 
         # 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)
@@ -669,9 +715,25 @@ class PydanticSchema(Schema, Generic[M], metaclass=PydanticSchemaMeta):
 
         # 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(
-            hooks[VALIDATES]
-            or hooks[VALIDATES_SCHEMA]
+            _has_hook(VALIDATES)
+            or _has_hook(VALIDATES_SCHEMA)
             or self._field_validators_cache
             or self._schema_validators_cache
         )
@@ -709,12 +771,11 @@ class PydanticSchema(Schema, Generic[M], metaclass=PydanticSchemaMeta):
         error_store: Any = error_store_cls()
 
         # 4a: Run Marshmallow's native @validates decorators (from hooks)
-        if hooks[VALIDATES]:
-            self._invoke_field_validators(
-                error_store=error_store,
-                data=validated_data,
-                many=False,
-            )
+        self._invoke_field_validators(
+            error_store=error_store,
+            data=validated_data,
+            many=False,
+        )
 
         # 4b: Run our custom @validates decorators (backwards compatibility)
         try:
@@ -729,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 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:
@@ -797,14 +858,20 @@ class PydanticSchema(Schema, Generic[M], metaclass=PydanticSchemaMeta):
             # Return dict instead of instance
             result = validated_data
 
-        # Step 7: Run post_load hooks ONLY if they exist (PERFORMANCE OPTIMIZATION)
-        if postprocess and 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
@@ -1048,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:
@@ -1159,6 +1227,66 @@ class PydanticSchema(Schema, Generic[M], metaclass=PydanticSchemaMeta):
         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.

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,6 +4,9 @@ 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
@@ -20,7 +23,7 @@ _processing_models: set[type[Any]] = set()
 # 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[ma_fields.Field]:
+def _get_simple_field_class(type_hint: type) -> type[Any]:
     """
     Cached lookup for simple, hashable types in Marshmallow's TYPE_MAPPING.
 
@@ -30,7 +33,7 @@ def _get_simple_field_class(type_hint: type) -> type[ma_fields.Field]:
     return Schema.TYPE_MAPPING.get(type_hint, ma_fields.Raw)
 
 
-def type_to_marshmallow_field(type_hint: Any) -> ma_fields.Field:
+def type_to_marshmallow_field(type_hint: Any) -> Any:
     """
     Map a Python type to a Marshmallow field instance.
 
@@ -88,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])
@@ -129,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)
@@ -155,8 +165,7 @@ 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

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

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: pydantic-marshmallow
-Version: 1.0.1
+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
@@ -32,10 +32,9 @@ 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"
@@ -73,16 +72,27 @@ 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:
+pydantic-marshmallow uses Pydantic's Rust-powered validation engine under the hood, delivering significant performance improvements over native Marshmallow—especially for nested data structures.
 
-| Operation | pydantic-marshmallow | Marshmallow | Speedup |
-|-----------|---------------------|-------------|---------|
-| Simple load | 3.0 µs | 5.3 µs | **1.8x faster** |
-| Nested model | 3.5 µs | 11.6 µs | **3.3x faster** |
-| Deep nested (4 levels) | 5.6 µs | 32.3 µs | **5.8x faster** |
-| Batch (100 items) | 255 µs | 474 µs | **1.9x faster** |
+#### Performance Comparison
 
-*Benchmarks run on Python 3.11. Run `python -m benchmarks.run_benchmarks` to reproduce.*
+| 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
 
@@ -107,6 +117,8 @@ pydantic-marshmallow uses Pydantic's Rust-powered validation engine under the ho
 pip install pydantic-marshmallow
 ```
 
+**Requirements:** Python 3.10+, Pydantic 2.0+, Marshmallow 3.18+ (including 4.x)
+
 ## Quick Start
 
 ### Basic Usage

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.1.dist-info/RECORD

@@ -1,12 +0,0 @@
-pydantic_marshmallow/__init__.py,sha256=EQON4HpiOFDtC33MrrE6WFW68GBtDlx1IqbDWxbqghU,3100
-pydantic_marshmallow/bridge.py,sha256=MOBwr0casMgaPjP5GAcYjnG8bGgNpmpEa-zagjkClEY,52147
-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=NYTJdmTVL-EjNW93ysb2KN9ASAj0mQu8rQpa_vOgqbU,6529
-pydantic_marshmallow/validators.py,sha256=hg7ZTrjGHcyzfOtGy6T1LLGx4puRD3VSCLf0KN0PE8g,6686
-pydantic_marshmallow-1.0.1.dist-info/licenses/LICENSE,sha256=y1B14nDO7pR7JdBNaWTLDt9MPBVRVuKZTUiRkw_eVgg,1071
-pydantic_marshmallow-1.0.1.dist-info/METADATA,sha256=yNbwhXPJSg0WZAc8tfFo4U6fy57gX0eVNRf4JPLHO4g,14302
-pydantic_marshmallow-1.0.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-pydantic_marshmallow-1.0.1.dist-info/top_level.txt,sha256=sQCtMe_dpBvCrrBM6YIz1UQmGSf-XjdoBUeA2uyuoh4,21
-pydantic_marshmallow-1.0.1.dist-info/RECORD,,