pydantic-marshmallow 1.0.0__tar.gz → 1.0.1__tar.gz

pydantic_marshmallow-1.0.1/.github/workflows/ci.yml

@@ -0,0 +1,192 @@
+name: CI
+
+on:
+  push:
+    branches: [main, develop]
+  pull_request:
+    branches: [main]
+
+permissions:
+  contents: read
+
+jobs:
+  lint:
+    name: Lint & Type Check
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+
+      - name: Set up Python
+        run: uv python install 3.11
+
+      - name: Install dependencies
+        run: uv sync --all-extras
+
+      - name: Lint with ruff
+        run: uv run ruff check src/pydantic_marshmallow/ tests/
+
+      - name: Lint with flake8
+        run: uv run flake8 src/pydantic_marshmallow/ tests/
+
+      - name: Type check with mypy
+        run: uv run mypy src/pydantic_marshmallow/
+
+  test:
+    name: Test (Py${{ matrix.python-version }}, ${{ matrix.os }}, MA${{ matrix.marshmallow-version }}, PD${{ matrix.pydantic-version }})
+    needs: [lint]  # Only run tests after lint passes
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest]
+        python-version: ['3.10', '3.11', '3.12', '3.13', '3.14']
+        marshmallow-version: ['latest']  # Default to latest Marshmallow (3.x from lock)
+        pydantic-version: ['latest']  # Default to latest Pydantic
+        include:
+          # === BASE VERSIONS (minimum supported) ===
+          # Marshmallow 3.18.0 + Pydantic 2.0.0 - minimum supported combo
+          - os: ubuntu-latest
+            python-version: '3.10'
+            marshmallow-version: '3.18.0'
+            pydantic-version: '2.0.0'
+          # Pydantic 2.0.0 with latest Marshmallow 3.x
+          - os: ubuntu-latest
+            python-version: '3.11'
+            marshmallow-version: 'latest'
+            pydantic-version: '2.0.0'
+
+          # === INTERMEDIATE VERSIONS ===
+          # Marshmallow 3.21.0 (last 3.x before 4.0) + Pydantic 2.5.x
+          - os: ubuntu-latest
+            python-version: '3.11'
+            marshmallow-version: '3.21.0'
+            pydantic-version: '2.5'
+          # Pydantic 2.5 (significant validation changes) with latest Marshmallow
+          - os: ubuntu-latest
+            python-version: '3.12'
+            marshmallow-version: 'latest'
+            pydantic-version: '2.5'
+
+          # === LATEST/BLEEDING EDGE ===
+          # Marshmallow 4.x latest on Ubuntu with Python 3.11 and 3.12
+          - os: ubuntu-latest
+            python-version: '3.11'
+            marshmallow-version: '4-latest'
+            pydantic-version: 'latest'
+          - os: ubuntu-latest
+            python-version: '3.12'
+            marshmallow-version: '4-latest'
+            pydantic-version: 'latest'
+          # Marshmallow 4.x + Pydantic 2.5 cross-version
+          - os: ubuntu-latest
+            python-version: '3.11'
+            marshmallow-version: '4-latest'
+            pydantic-version: '2.5'
+        exclude:
+          # Reduce matrix size - test all Python versions on Ubuntu, latest on others
+          - os: windows-latest
+            python-version: '3.10'
+          - os: windows-latest
+            python-version: '3.13'
+          - os: windows-latest
+            python-version: '3.14'
+          - os: macos-latest
+            python-version: '3.10'
+          - os: macos-latest
+            python-version: '3.13'
+          - os: macos-latest
+            python-version: '3.14'
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+
+      - name: Set up Python ${{ matrix.python-version }}
+        run: uv python install ${{ matrix.python-version }}
+
+      - name: Install dependencies
+        run: uv sync --all-extras
+
+      - name: Override Marshmallow to 4.x latest
+        if: matrix.marshmallow-version == '4-latest'
+        run: uv pip install --upgrade "marshmallow>=4.0.0"
+
+      - name: Override Marshmallow to specific version
+        if: matrix.marshmallow-version != 'latest' && matrix.marshmallow-version != '4-latest'
+        run: uv pip install "marshmallow==${{ matrix.marshmallow-version }}"
+
+      - name: Override Pydantic to 2.5.x
+        if: matrix.pydantic-version == '2.5'
+        run: uv pip install "pydantic>=2.5.0,<2.6.0"
+
+      - name: Override Pydantic to specific version
+        if: matrix.pydantic-version == '2.0.0'
+        run: uv pip install "pydantic>=2.0.0,<2.1.0"
+
+      - name: Run tests
+        run: uv run pytest tests/ -v --tb=short
+
+  coverage:
+    name: Coverage
+    needs: [lint]
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0  # Fetch all history for diff-cover
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+
+      - name: Set up Python
+        run: uv python install 3.11
+
+      - name: Install dependencies
+        run: uv sync --all-extras
+
+      - name: Run tests with coverage
+        run: |
+          uv run pytest tests/ --cov=src/pydantic_marshmallow --cov-report=xml --cov-report=term
+
+      - name: Upload coverage to Codecov
+        uses: codecov/codecov-action@v4
+        with:
+          files: ./coverage.xml
+          fail_ci_if_error: false  # Don't fail if Codecov is down
+          verbose: true
+        env:
+          CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+
+      - name: Check diff coverage (changed lines)
+        run: |
+          uv run diff-cover coverage.xml --compare-branch=origin/main --fail-under=80
+        continue-on-error: true  # Warn but don't fail initially
+
+  # This job is used as the required status check for branch protection
+  # Configure GitHub: Settings > Branches > Branch protection > Require "CI Passed"
+  ci-passed:
+    name: CI Passed
+    runs-on: ubuntu-latest
+    needs: [lint, test, coverage]
+    if: always()
+    steps:
+      - name: Check all jobs passed
+        run: |
+          if [[ "${{ needs.lint.result }}" != "success" ]]; then
+            echo "❌ Lint job failed"
+            exit 1
+          fi
+          if [[ "${{ needs.test.result }}" != "success" ]]; then
+            echo "❌ Test job failed"
+            exit 1
+          fi
+          if [[ "${{ needs.coverage.result }}" != "success" ]]; then
+            echo "❌ Coverage job failed"
+            exit 1
+          fi
+          echo "✅ All CI checks passed!"

{pydantic_marshmallow-1.0.0 → pydantic_marshmallow-1.0.1}/.github/workflows/release.yml

@@ -1,9 +1,6 @@
 name: Release
 
 on:
-  push:
-    branches:
-      - main
   workflow_dispatch:
     inputs:
       dry_run:
@@ -39,7 +36,7 @@ jobs:
         id: semantic
         uses: cycjimmy/semantic-release-action@v4
         with:
-          dry_run: ${{ inputs.dry_run || false }}
+          dry_run: ${{ inputs.dry_run }}
           extra_plugins: |
             conventional-changelog-conventionalcommits
         env:
@@ -48,7 +45,7 @@ jobs:
   build:
     name: Build Package
     needs: release
-    if: needs.release.outputs.new_release_published == 'true' && (inputs.dry_run == false || inputs.dry_run == null)
+    if: needs.release.outputs.new_release_published == 'true' && inputs.dry_run == false
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
@@ -72,7 +69,7 @@ jobs:
   publish:
     name: Publish to PyPI
     needs: [release, build]
-    if: needs.release.outputs.new_release_published == 'true' && (inputs.dry_run == false || inputs.dry_run == null)
+    if: needs.release.outputs.new_release_published == 'true' && inputs.dry_run == false
     runs-on: ubuntu-latest
     environment: pypi  # Requires approval if configured in GitHub Settings
     permissions:

pydantic_marshmallow-1.0.1/.vscode/settings.json

@@ -0,0 +1,40 @@
+{
+    "python.analysis.extraPaths": [
+        "src"
+    ],
+    "python.analysis.include": [
+        "src/**/*.py"
+    ],
+    "python.analysis.exclude": [
+        "tests/**",
+        "benchmarks/**",
+        "examples/**",
+        "**/__pycache__/**",
+        ".venv/**"
+    ],
+    "python.analysis.ignore": [
+        "tests/**",
+        "benchmarks/**",
+        "examples/**"
+    ],
+    "python.analysis.diagnosticMode": "workspace",
+    "mypy-type-checker.args": [
+        "src/pydantic_marshmallow"
+    ],
+    "flake8.args": [
+        "src/pydantic_marshmallow"
+    ],
+    "[python]": {
+        "editor.defaultFormatter": "charliermarsh.ruff",
+        "editor.formatOnSave": true,
+        "editor.codeActionsOnSave": {
+            "source.organizeImports": "explicit",
+            "source.fixAll.autopep8": "never",
+            "source.fixAll.ruff": "explicit"
+        }
+    },
+    "autopep8.enable": false,
+    "python.formatting.provider": "none",
+    "ruff.format.args": [],
+    "ruff.organizeImports": true
+}

{pydantic_marshmallow-1.0.0/src/pydantic_marshmallow.egg-info → pydantic_marshmallow-1.0.1}/PKG-INFO

@@ -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.0 → pydantic_marshmallow-1.0.1}/README.md

@@ -9,6 +9,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
@@ -155,7 +178,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}"
@@ -179,6 +202,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
@@ -230,6 +268,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/SECURITY.md

@@ -0,0 +1,15 @@
+# Security Policy
+
+## Supported Versions
+
+| Version | Supported          |
+| ------- | ------------------ |
+| 1.0.x   | :white_check_mark: |
+
+## Reporting a Vulnerability
+
+Please report security vulnerabilities by opening a 
+[private security advisory](https://github.com/mockodin/pydantic-marshmallow/security/advisories/new)
+or emailing the maintainers directly.
+
+Do not open public issues for security vulnerabilities.

{pydantic_marshmallow-1.0.0 → pydantic_marshmallow-1.0.1}/benchmarks/benchmark_framework.py

@@ -362,7 +362,7 @@ class BenchmarkSuite:
         """
         results: dict[str, BenchmarkResult] = {}
 
-        benchmarks = self._benchmarks.items()
+        benchmarks = list(self._benchmarks.items())
         if filter_pattern:
             benchmarks = [(n, b) for n, b in benchmarks if filter_pattern in n]
 

{pydantic_marshmallow-1.0.0 → pydantic_marshmallow-1.0.1}/benchmarks/run_benchmarks.py

@@ -21,6 +21,7 @@ Usage:
 from __future__ import annotations
 
 import argparse
+import contextlib
 import sys
 from enum import Enum
 from pathlib import Path
@@ -87,7 +88,7 @@ class UserWithComputedField(BaseModel):
     last: str
     age: int
 
-    @computed_field
+    @computed_field  # type: ignore[misc]
     @property
     def full_name(self) -> str:
         return f"{self.first} {self.last}"
@@ -696,20 +697,16 @@ def create_error_suite() -> BenchmarkSuite:
 
     @suite.add("validation_error_bridge")
     def bench_error_bridge():
-        try:
+        with contextlib.suppress(Exception):
             bridge_schema.load(INVALID_DATA)
-        except Exception:
-            pass
 
     # Marshmallow validation error
     ma_schema = SimpleUserMarshmallow()
 
     @suite.add("validation_error_marshmallow")
     def bench_error_marshmallow():
-        try:
+        with contextlib.suppress(Exception):
             ma_schema.load(INVALID_DATA)
-        except Exception:
-            pass
 
     return suite
 

pydantic_marshmallow-1.0.1/codecov.yml

@@ -0,0 +1,31 @@
+# Codecov configuration
+# https://docs.codecov.com/docs/codecov-yaml
+
+coverage:
+  status:
+    # Overall project coverage
+    project:
+      default:
+        target: 80%      # Minimum overall coverage
+        threshold: 2%    # Allow up to 2% drop from base
+        
+    # Coverage for changed lines only (enforces new code coverage)
+    patch:
+      default:
+        target: 90%      # New/changed code must have 90% coverage
+        
+  # Don't wait for all CI jobs
+  precision: 2
+  round: down
+  
+# Ignore test files and benchmarks from coverage
+ignore:
+  - "tests/**/*"
+  - "benchmarks/**/*"
+  - "docs/**/*"
+  
+# Comment on PRs with coverage report
+comment:
+  layout: "reach,diff,flags,files"
+  behavior: default
+  require_changes: true