feat: support Pydantic2 (as well as Pydantic1) (#570)

* feat: support pydantic2

* add test

* style(pre-commit.ci): auto fixes [...]

* update pydantic test

* use headless gui

* add pyqt6 for pydantic1

* ci(pre-commit.ci): autoupdate

updates:
- [github.com/astral-sh/ruff-pre-commit: v0.0.276 → v0.0.281](astral-sh/ruff-pre-commit@v0.0.276...v0.0.281)
- [github.com/psf/black: 23.3.0 → 23.7.0](psf/black@23.3.0...23.7.0)

* style(pre-commit.ci): auto fixes [...]

* fix: fix pre-commit

* style: update pre=commit

* ci: use concurrency

* fix: backport json_schema_extra

---------

Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>

Author: tlambert03

.github/workflows/test_and_deploy.yml

@@ -56,6 +56,30 @@ jobs:
         with:
           fail_ci_if_error: false
 
+  test-pydantic1:
+    name: Test pydantic1
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v4
+        with:
+          python-version: "3.11"
+
+      - uses: tlambert03/[email protected]
+
+      - name: Install dependencies
+        run: |
+          python -m pip install -e .
+          python -m pip install pytest 'pydantic<2' attrs pytest-cov pyqt6
+
+      - name: Test
+        uses: aganders3/headless-gui@v1
+        with:
+          run: pytest tests/test_ui_field.py -v --color=yes --cov=magicgui --cov-report=xml
+
+      - uses: codecov/codecov-action@v3
+
   test_napari:
     name: napari tests
     runs-on: ubuntu-latest
@@ -163,7 +187,6 @@ jobs:
           working-directory: PartSeg
           run: python -m pytest -v --color=yes -W ignore package/tests/test_PartSeg/test_napari_widgets.py
 
-
   deploy:
     needs: test
     runs-on: ubuntu-latest

pyproject.toml

@@ -77,7 +77,7 @@ testing = [
     "toolz",
     "ipywidgets",
     "ipykernel",
-    "pydantic<2",
+    "pydantic",
     "attrs",
     "annotated_types",
 ]
@@ -97,7 +97,7 @@ dev = [
     "pillow>=4.0",
     "pint>=0.13.0",
     "pre-commit",
-    "pydantic<2",
+    "pydantic",
     "pydocstyle",
     "pyqt6",
     "pytest-cov",

src/magicgui/schema/_ui_field.py

@@ -30,7 +30,7 @@
     import pydantic
     from annotated_types import BaseMetadata
     from attrs import Attribute
-    from pydantic.fields import ModelField
+    from pydantic.fields import FieldInfo, ModelField
 
     from magicgui.widgets.bases import ContainerWidget, ValueWidget
 
@@ -534,14 +534,19 @@ def _uifield_from_attrs(field: Attribute) -> UiField:
     )
 
 
-def _uifield_from_pydantic(model_field: ModelField) -> UiField:
+def _uifield_from_pydantic1(model_field: ModelField) -> UiField:
     """Create a UiField from a pydantic ModelField."""
     from pydantic.fields import SHAPE_SINGLETON
     from pydantic.fields import Undefined as PydanticUndefined
 
     finfo = model_field.field_info
 
-    extra = {k: v for k, v in finfo.extra.items() if k in _UI_FIELD_NAMES}
+    _extra_dict = finfo.extra.copy()
+    # backport from pydantic2
+    if "json_schema_extra" in _extra_dict:
+        _extra_dict.update(_extra_dict.pop("json_schema_extra"))
+
+    extra = {k: v for k, v in _extra_dict.items() if k in _UI_FIELD_NAMES}
     const = finfo.const if finfo.const not in (None, PydanticUndefined) else Undefined
     default = (
         Undefined if finfo.default in (PydanticUndefined, Ellipsis) else finfo.default
@@ -579,6 +584,63 @@ def _uifield_from_pydantic(model_field: ModelField) -> UiField:
     )
 
 
+def _uifield_from_pydantic2(finfo: FieldInfo, name: str) -> UiField:
+    """Create a UiField from a pydantic ModelField."""
+    import annotated_types as at
+    from pydantic_core import PydanticUndefined
+
+    if isinstance(finfo.json_schema_extra, dict):
+        extra = {
+            k: v for k, v in finfo.json_schema_extra.items() if k in _UI_FIELD_NAMES
+        }
+    else:
+        extra = {}
+    default = (
+        Undefined if finfo.default in (PydanticUndefined, Ellipsis) else finfo.default
+    )
+
+    nullable = None
+    if get_origin(finfo.annotation) is Union and any(
+        i for i in get_args(finfo.annotation) if i is type(None)
+    ):
+        nullable = True
+
+    restrictions: dict = {}
+    for meta in finfo.metadata:
+        if isinstance(meta, at.Ge):
+            restrictions["minimum"] = meta.ge
+        elif isinstance(meta, at.Gt):
+            restrictions["exclusive_minimum"] = meta.gt
+        elif isinstance(meta, at.Le):
+            restrictions["maximum"] = meta.le
+        elif isinstance(meta, at.Lt):
+            restrictions["exclusive_maximum"] = meta.lt
+        elif isinstance(meta, at.MultipleOf):
+            restrictions["multiple_of"] = meta.multiple_of
+        elif isinstance(meta, at.MinLen):
+            restrictions["min_length"] = meta.min_length
+        elif isinstance(meta, at.MaxLen):
+            restrictions["max_length"] = meta.max_length
+        elif hasattr(meta, "__dict__"):
+            # PydanticGeneralMetadata
+            restrictions["pattern"] = meta.__dict__.get("pattern")
+
+    return UiField(
+        name=name,
+        title=finfo.title,
+        description=finfo.description,
+        default=default,
+        default_factory=finfo.default_factory,
+        type=finfo.annotation,
+        nullable=nullable,
+        # const=const,
+        **restrictions,
+        # format=finfo.format,
+        _native_field=finfo,
+        **extra,
+    )
+
+
 # TODO:
 class _ContainerFields:
     autofocus: str | None = field(
@@ -657,8 +719,25 @@ def _ui_fields_from_annotation(cls: type) -> Iterator[UiField]:
 
 
 def _iter_ui_fields(object: Any) -> Iterator[UiField]:
+    # check if it's a pydantic model
+    model = _get_pydantic_model(object)
+    if model is not None:
+        if hasattr(model, "model_fields"):
+            for name, field_info in model.model_fields.items():
+                yield _uifield_from_pydantic2(field_info, name)
+        else:
+            for pf in model.__fields__.values():
+                yield _uifield_from_pydantic1(pf)
+        return
+
+    if hasattr(object, "__pydantic_fields__"):
+        # pydantic2 style dataclass
+        for name, field_info in object.__pydantic_fields__.items():
+            yield _uifield_from_pydantic2(field_info, name)
+        return
+
     # check if it's a (non-pydantic) dataclass
-    if dc.is_dataclass(object) and not hasattr(object, "__pydantic_model__"):
+    if dc.is_dataclass(object):
         for df in dc.fields(object):
             yield _uifield_from_dataclass(df)
         return
@@ -669,13 +748,6 @@ def _iter_ui_fields(object: Any) -> Iterator[UiField]:
             yield _uifield_from_attrs(af)
         return
 
-    # check if it's a pydantic model
-    model = _get_pydantic_model(object)
-    if model is not None:
-        for pf in model.__fields__.values():
-            yield _uifield_from_pydantic(pf)
-        return
-
     # fallback to looking at __annotations__ (named tuple, typed dict, function)
     if hasattr(object, "__annotations__"):
         yield from _ui_fields_from_annotation(object)
@@ -768,8 +840,12 @@ def _get_values(obj: Any) -> dict | None:
         return cast(dict, attr.asdict(obj))
 
     # pydantic models
-    dict_method = getattr(obj, "dict", None)
-    return dict_method() if callable(dict_method) else None
+    if hasattr(obj, "model_dump"):
+        return cast(dict, obj.model_dump())
+    elif hasattr(obj, "dict"):
+        return cast(dict, obj.dict())
+
+    return None
 
 
 # TODO: unify this with magicgui

tests/test_ui_field.py

@@ -10,12 +10,13 @@
 EXPECTED = (
     UiField(name="a", type=int, nullable=True),
     UiField(name="b", type=str, description="the b"),
-    UiField(name="c", default=0, type=float, widget="FloatSlider"),
+    UiField(name="c", default=0.0, type=float, widget="FloatSlider"),
 )
 
 
 def _assert_uifields(cls, instantiate=True):
-    assert tuple(get_ui_fields(cls)) == EXPECTED
+    result = tuple(get_ui_fields(cls))
+    assert result == EXPECTED
     wdg = build_widget(cls)
     assert isinstance(wdg, Container)
     assert wdg.asdict() == {
@@ -58,12 +59,23 @@ class Foo:
 
 
 def test_pydantic():
-    pydantic = pytest.importorskip("pydantic")
+    pytest.importorskip("pydantic")
+    import pydantic.version
+    from pydantic import BaseModel, Field
 
-    class Foo(pydantic.BaseModel):
-        a: Optional[int]
-        b: str = pydantic.Field(description="the b")
-        c: float = pydantic.Field(0, widget="FloatSlider")
+    if pydantic.version.VERSION.startswith("1"):
+
+        class Foo(BaseModel):
+            a: Optional[int]
+            b: str = Field(description="the b")
+            c: float = Field(0.0, widget="FloatSlider")
+
+    else:
+
+        class Foo(BaseModel):
+            a: Optional[int]
+            b: str = Field(description="the b")
+            c: float = Field(0.0, json_schema_extra={"widget": "FloatSlider"})
 
     _assert_uifields(Foo)
 
@@ -75,7 +87,7 @@ def test_pydantic_dataclass():
     class Foo:
         a: Optional[int]
         b: str = pydantic.Field(description="the b")
-        c: float = pydantic.Field(0, widget="FloatSlider")
+        c: float = pydantic.Field(0.0, json_schema_extra={"widget": "FloatSlider"})
 
     _assert_uifields(Foo)