pydantic-marshmallow 1.0.0__py3-none-any.whl → 1.0.1__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,9 @@ 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 typing import Any, ClassVar, Generic, TypeVar, cast, get_args, get_origin
 
 from marshmallow import EXCLUDE, INCLUDE, RAISE, Schema, fields as ma_fields
@@ -15,6 +17,7 @@ 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 pydantic import BaseModel, ConfigDict, ValidationError as PydanticValidationError
 
 from .errors import BridgeValidationError, convert_pydantic_errors, format_pydantic_error
@@ -23,14 +26,51 @@ from .validators import cache_validators
 
 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.
@@ -389,6 +429,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 +437,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 +452,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 +466,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 +594,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
@@ -576,8 +630,8 @@ class PydanticSchema(Schema, Generic[M], metaclass=PydanticSchemaMeta):
 
         # 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(
+        if hooks.get("pre_load"):
+            processed_data_raw = self._invoke_load_processors(
                 "pre_load",
                 data,
                 many=False,
@@ -585,17 +639,17 @@ class PydanticSchema(Schema, Generic[M], metaclass=PydanticSchemaMeta):
                 partial=partial,
             )
         else:
-            processed_data = data
+            processed_data_raw = data
 
-        # 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 +658,36 @@ 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
+        has_validators = bool(
+            hooks[VALIDATES]
+            or hooks[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 +696,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,8 +708,8 @@ 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]:
+        # 4a: Run Marshmallow's native @validates decorators (from hooks)
+        if hooks[VALIDATES]:
             self._invoke_field_validators(
                 error_store=error_store,
                 data=validated_data,
@@ -656,7 +729,7 @@ 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]:
+        if hooks[VALIDATES_SCHEMA]:
             self._invoke_schema_validators(
                 error_store=error_store,
                 pass_many=True,
@@ -690,7 +763,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 +774,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,14 +791,14 @@ 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"):
+        if postprocess and hooks.get("post_load"):
             result = self._invoke_load_processors(
                 "post_load",
                 result,
@@ -989,7 +1062,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 +1105,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,6 +1150,12 @@ 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
 
 
@@ -1155,10 +1248,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/type_mapping.py

@@ -5,8 +5,9 @@ This module provides type-to-field conversions, leveraging Marshmallow's native
 TYPE_MAPPING for basic types and adding support for generic collections.
 """
 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,6 +16,20 @@ from pydantic import BaseModel
 _processing_models: set[type[Any]] = set()
 
 
+# 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[ma_fields.Field]:
+    """
+    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) -> ma_fields.Field:
     """
     Map a Python type to a Marshmallow field instance.
@@ -36,6 +51,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)
 
@@ -134,5 +161,6 @@ def type_to_marshmallow_field(type_hint: Any) -> ma_fields.Field:
     # 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.0.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydantic-marshmallow
-Version: 1.0.0
+Version: 1.0.1
 Summary: Bring Pydantic's power to Marshmallow: type annotations, validators, and automatic schema generation
 Author-email: Your Name <your.email@example.com>
 License: MIT
@@ -24,8 +24,8 @@ 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
@@ -67,6 +67,29 @@ 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:
+
+| 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** |
+
+*Benchmarks run on Python 3.11. 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
@@ -213,7 +236,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 +260,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 +326,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.0.1.dist-info/RECORD

@@ -0,0 +1,12 @@
+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,,

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,,