pydantic-marshmallow 1.0.0__py3-none-any.whl

pydantic_marshmallow-1.0.0.dist-info/METADATA

@@ -0,0 +1,367 @@
+Metadata-Version: 2.4
+Name: pydantic-marshmallow
+Version: 1.0.0
+Summary: Bring Pydantic's power to Marshmallow: type annotations, validators, and automatic schema generation
+Author-email: Your Name <your.email@example.com>
+License: MIT
+Project-URL: Homepage, https://github.com/mockodin/pydantic-marshmallow
+Project-URL: Documentation, https://mockodin.github.io/pydantic-marshmallow
+Project-URL: Repository, https://github.com/mockodin/pydantic-marshmallow
+Project-URL: Issues, https://github.com/mockodin/pydantic-marshmallow/issues
+Keywords: pydantic,marshmallow,validation,serialization,type-hints
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+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: 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: sqlalchemy>=2.0.30; extra == "dev"
+Requires-Dist: marshmallow-sqlalchemy>=1.1.0; extra == "dev"
+Requires-Dist: flask>=3.0.0; extra == "dev"
+Requires-Dist: flask-marshmallow>=1.2.0; extra == "dev"
+Requires-Dist: webargs>=8.5.0; extra == "dev"
+Requires-Dist: apispec>=6.5.0; extra == "dev"
+Requires-Dist: pyyaml>=6.0.1; extra == "dev"
+Requires-Dist: flask-rebar>=3.0.0; extra == "dev"
+Requires-Dist: flask-smorest>=0.44.0; extra == "dev"
+Requires-Dist: marshmallow-dataclass>=8.7.0; extra == "dev"
+Requires-Dist: marshmallow-oneofschema>=3.1.0; extra == "dev"
+Requires-Dist: connexion[flask,swagger-ui,uvicorn]>=3.1.0; extra == "dev"
+Provides-Extra: docs
+Requires-Dist: mkdocs>=1.6.0; extra == "docs"
+Requires-Dist: mkdocs-material>=9.5.0; extra == "docs"
+Requires-Dist: mkdocstrings[python]>=0.26.0; extra == "docs"
+Provides-Extra: all
+Requires-Dist: pydantic-marshmallow[dev,docs]; extra == "all"
+Dynamic: license-file
+
+# pydantic-marshmallow
+
+[![CI](https://github.com/mockodin/pydantic-marshmallow/actions/workflows/ci.yml/badge.svg)](https://github.com/mockodin/pydantic-marshmallow/actions/workflows/ci.yml)
+[![PyPI version](https://badge.fury.io/py/pydantic-marshmallow.svg)](https://badge.fury.io/py/pydantic-marshmallow)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+Bridge Pydantic's power with Marshmallow's ecosystem. Use Pydantic models for validation with full Marshmallow compatibility.
+
+📖 **[Documentation](https://mockodin.github.io/pydantic-marshmallow)** | 🐙 **[GitHub](https://github.com/mockodin/pydantic-marshmallow)**
+
+## Features
+
+- **Pydantic Validation**: Leverage Pydantic's Rust-powered validation engine
+- **Marshmallow Compatibility**: Works with Flask-Marshmallow, webargs, apispec, SQLAlchemy, and more
+- **Zero Drift**: Single source of truth - Pydantic model defines the schema
+- **Full Hook Support**: `@pre_load`, `@post_load`, `@pre_dump`, `@post_dump`
+- **Validators**: `@validates("field")` and `@validates_schema` decorators
+- **Partial Loading**: `partial=True` or `partial=('field1', 'field2')`
+- **Unknown Fields**: `unknown=RAISE/EXCLUDE/INCLUDE`
+- **Computed Fields**: Pydantic `@computed_field` support in serialization
+
+## Installation
+
+```bash
+pip install pydantic-marshmallow
+```
+
+## Quick Start
+
+### Basic Usage
+
+```python
+from pydantic import BaseModel, EmailStr, Field
+from pydantic_marshmallow import PydanticSchema
+
+class User(BaseModel):
+    name: str = Field(min_length=1)
+    email: EmailStr
+    age: int = Field(ge=0)
+
+class UserSchema(PydanticSchema[User]):
+    class Meta:
+        model = User
+
+# Use like any Marshmallow schema
+schema = UserSchema()
+user = schema.load({"name": "Alice", "email": "alice@example.com", "age": 30})
+print(user.name)  # "Alice" - it's a Pydantic User instance!
+
+# Serialize back
+data = schema.dump(user)
+# {"name": "Alice", "email": "alice@example.com", "age": 30}
+```
+
+### Using the Decorator
+
+```python
+from pydantic_marshmallow import pydantic_schema
+
+@pydantic_schema
+class User(BaseModel):
+    name: str
+    email: EmailStr
+
+# .Schema attribute is automatically added
+schema = User.Schema()
+user = schema.load({"name": "Alice", "email": "alice@example.com"})
+```
+
+### Factory Function
+
+```python
+from pydantic_marshmallow import schema_for
+
+UserSchema = schema_for(User)
+schema = UserSchema()
+```
+
+## Marshmallow Hooks
+
+All standard Marshmallow hooks work:
+
+```python
+from marshmallow import pre_load, post_load, validates
+
+class UserSchema(PydanticSchema[User]):
+    class Meta:
+        model = User
+
+    @pre_load
+    def normalize_email(self, data, **kwargs):
+        if "email" in data:
+            data["email"] = data["email"].lower().strip()
+        return data
+
+    @post_load
+    def log_user(self, user, **kwargs):
+        print(f"Loaded user: {user.name}")
+        return user
+
+    @validates("name")
+    def validate_name(self, value):
+        if value.lower() == "admin":
+            raise ValidationError("Cannot use 'admin' as name")
+```
+
+## Partial Loading
+
+```python
+# Allow all missing required fields
+user = schema.load({"name": "Alice"}, partial=True)
+
+# Allow specific missing fields
+user = schema.load({"name": "Alice"}, partial=("email", "age"))
+```
+
+## Unknown Field Handling
+
+```python
+from marshmallow import EXCLUDE, INCLUDE, RAISE
+
+# Reject unknown fields (default)
+schema = UserSchema(unknown=RAISE)
+
+# Ignore unknown fields
+schema = UserSchema(unknown=EXCLUDE)
+
+# Include unknown fields in result
+schema = UserSchema(unknown=INCLUDE)
+```
+
+## Field Filtering
+
+```python
+# Only include specific fields
+schema = UserSchema(only=("name", "email"))
+
+# Exclude specific fields
+schema = UserSchema(exclude=("age",))
+
+# Load-only fields (not in dump output)
+schema = UserSchema(load_only=("password",))
+
+# Dump-only fields (not in load input)
+schema = UserSchema(dump_only=("created_at",))
+```
+
+## Computed Fields
+
+```python
+from pydantic import computed_field
+
+class User(BaseModel):
+    first: str
+    last: str
+
+    @computed_field
+    @property
+    def full_name(self) -> str:
+        return f"{self.first} {self.last}"
+
+schema = schema_for(User)()
+user = User(first="Alice", last="Smith")
+data = schema.dump(user)
+# {"first": "Alice", "last": "Smith", "full_name": "Alice Smith"}
+```
+
+## Dump Options
+
+```python
+# Exclude None values
+schema.dump(user, exclude_none=True)
+
+# Exclude unset fields
+schema.dump(user, exclude_unset=True)
+
+# Exclude fields with default values
+schema.dump(user, exclude_defaults=True)
+```
+
+## Flask-Marshmallow Integration
+
+```python
+from flask import Flask
+from flask_marshmallow import Marshmallow
+from pydantic_marshmallow import schema_for
+
+app = Flask(__name__)
+ma = Marshmallow(app)
+
+UserSchema = schema_for(User)
+
+@app.route("/users", methods=["POST"])
+def create_user():
+    schema = UserSchema()
+    user = schema.load(request.json)
+    # user is a Pydantic User instance
+    return schema.dump(user)
+```
+
+## webargs Integration
+
+```python
+from webargs.flaskparser import use_args
+from pydantic_marshmallow import schema_for
+
+UserSchema = schema_for(User)
+
+@app.route("/users", methods=["POST"])
+@use_args(UserSchema(), location="json")
+def create_user(user):
+    # user is a Pydantic User instance
+    return {"message": f"Created {user.name}"}
+```
+
+## apispec Integration
+
+```python
+from apispec import APISpec
+from apispec.ext.marshmallow import MarshmallowPlugin
+
+spec = APISpec(
+    title="My API",
+    version="1.0.0",
+    openapi_version="3.0.0",
+    plugins=[MarshmallowPlugin()],
+)
+
+spec.components.schema("User", schema=UserSchema)
+```
+
+## HybridModel
+
+For models that need both Pydantic and Marshmallow APIs:
+
+```python
+from pydantic_marshmallow import HybridModel
+
+class User(HybridModel):
+    name: str
+    email: EmailStr
+
+# Use as Pydantic model
+user = User(name="Alice", email="alice@example.com")
+
+# Use Marshmallow-style loading
+user = User.ma_load({"name": "Alice", "email": "alice@example.com"})
+
+# Get the Marshmallow schema class
+schema_class = User.marshmallow_schema()
+```
+
+## Error Handling
+
+Validation errors are raised as `BridgeValidationError`, which extends Marshmallow's `ValidationError`:
+
+```python
+from pydantic_marshmallow import BridgeValidationError
+
+try:
+    user = schema.load({"name": "", "email": "invalid"})
+except BridgeValidationError as e:
+    print(e.messages)
+    # {'name': ['String should have at least 1 character'],
+    #  'email': ['value is not a valid email address']}
+    print(e.valid_data)
+    # {} - fields that passed validation
+```
+
+## API Reference
+
+### PydanticSchema
+
+A Marshmallow schema backed by a Pydantic model.
+
+**Class Methods:**
+- `from_model(model, **meta_options)` - Create a schema class from a Pydantic model
+
+**Instance Methods:**
+- `load(data, *, many, partial, unknown, return_instance)` - Deserialize data
+- `dump(obj, *, many, exclude_none, exclude_unset, exclude_defaults)` - Serialize data
+- `validate(data, *, many, partial)` - Validate without deserializing
+
+**Hooks:**
+- `on_bind_field(field_name, field_obj)` - Called when a field is bound
+- `handle_error(error, data, *, many)` - Custom error handling
+
+### Factory Functions
+
+- `schema_for(model, **meta_options)` - Create a schema class from a model
+- `pydantic_schema` - Decorator that adds `.Schema` to a model
+
+### HybridModel
+
+A Pydantic model with built-in Marshmallow support.
+
+**Class Methods:**
+- `marshmallow_schema()` - Get the Marshmallow schema class
+- `ma_load(data, **kwargs)` - Load using Marshmallow
+- `ma_loads(json_str, **kwargs)` - Load from JSON string
+
+**Instance Methods:**
+- `ma_dump(**kwargs)` - Dump using Marshmallow
+- `ma_dumps(**kwargs)` - Dump to JSON string
+
+## License
+
+MIT

pydantic_marshmallow-1.0.0.dist-info/RECORD

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

pydantic_marshmallow-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pydantic_marshmallow-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Michael Thomas
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pydantic_marshmallow-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pydantic_marshmallow