npe2 0.7.9rc0__py3-none-any.whl → 0.8.0__py3-none-any.whl

npe2/cli.py

@@ -1,10 +1,12 @@
 import builtins
 import warnings
+from collections.abc import Iterator, Sequence
 from enum import Enum
 from pathlib import Path
-from typing import TYPE_CHECKING, Iterator, List, Optional, Sequence
+from typing import TYPE_CHECKING
 
 import typer
+from pydantic import ValidationError
 
 from npe2 import PluginManager, PluginManifest, __version__
 
@@ -26,7 +28,7 @@ def _show_version_and_exit(value: bool) -> None:
 
 @app.callback()
 def _main(
-    version: Optional[bool] = typer.Option(
+    version: bool | None = typer.Option(
         None,
         "-v",
         "--version",
@@ -132,13 +134,13 @@ def validate(
     ),
 ):
     """Validate manifest for a distribution name or manifest filepath."""
-    err: Optional[Exception] = None
+    err: Exception | None = None
     try:
         pm = PluginManifest._from_package_or_name(name)
         msg = f"✔ Manifest for {(pm.display_name or pm.name)!r} valid!"
         if imports:
             pm.validate_imports()
-    except PluginManifest.ValidationError as e:
+    except ValidationError as e:
         msg = f"🅇 Invalid! {e}"
         err = e
     except Exception as e:
@@ -171,14 +173,14 @@ def parse(
     format: Format = typer.Option(
         "yaml", "-f", "--format", help="Markdown format to use."
     ),
-    indent: Optional[int] = typer.Option(
+    indent: int | None = typer.Option(
         None,
         "--indent",
         help="Number of spaces to indent (for json)",
         min=0,
         max=10,
     ),
-    output: Optional[Path] = typer.Option(
+    output: Path | None = typer.Option(
         None,
         "-o",
         "--output",
@@ -197,7 +199,7 @@ def parse(
         _pprint_formatted(manifest_string, fmt)
 
 
-def _make_rows(pm_dict: dict, normed_fields: Sequence[str]) -> Iterator[List]:
+def _make_rows(pm_dict: dict, normed_fields: Sequence[str]) -> Iterator[list]:
     """Cleanup output from pm.dict() into rows for table.
 
     outside of just extracting the fields we care about, this also:
@@ -231,8 +233,8 @@ def _make_rows(pm_dict: dict, normed_fields: Sequence[str]) -> Iterator[List]:
         yield row
 
 
-@app.command()
-def list(
+@app.command(name="list")
+def list_(
     fields: str = typer.Option(
         "name,version,npe2,contributions",
         help="Comma seperated list of fields to include in the output."
@@ -302,7 +304,9 @@ def list(
 
     # standard records format used for the other formats
     # [{column -> value}, ... , {column -> value}]
-    data: List[dict] = [dict(zip(requested_fields, row)) for row in rows]
+    data: builtins.list[dict] = [
+        dict(zip(requested_fields, row, strict=False)) for row in rows
+    ]
 
     if format == ListFormat.json:
         import json
@@ -321,9 +325,9 @@ def list(
 
 @app.command()
 def fetch(
-    name: List[str],
-    version: Optional[str] = None,
-    include_package_meta: Optional[bool] = typer.Option(
+    name: builtins.list[str],
+    version: str | None = None,
+    include_package_meta: bool | None = typer.Option(
         False,
         "-m",
         "--include-package-meta",
@@ -332,14 +336,14 @@ def fetch(
     format: Format = typer.Option(
         "yaml", "-f", "--format", help="Markdown format to use."
     ),
-    indent: Optional[int] = typer.Option(
+    indent: int | None = typer.Option(
         None,
         "--indent",
         help="Number of spaces to indent (for json)",
         min=0,
         max=10,
     ),
-    output: Optional[Path] = typer.Option(
+    output: Path | None = typer.Option(
         None,
         "-o",
         "--output",
@@ -379,7 +383,7 @@ def convert(
         "package is provided instead of a directory, the new manifest will simply be "
         "printed to stdout.",
     ),
-    dry_run: Optional[bool] = typer.Option(
+    dry_run: bool | None = typer.Option(
         False,
         "--dry-runs",
         "-n",
@@ -433,16 +437,16 @@ def convert(
 
 @app.command()
 def cache(
-    clear: Optional[bool] = typer.Option(
+    clear: bool | None = typer.Option(
         False, "--clear", "-d", help="Clear the npe1 adapter manifest cache"
     ),
-    names: List[str] = typer.Argument(
+    names: builtins.list[str] = typer.Argument(
         None, help="Name(s) of distributions to list/delete"
     ),
-    list_: Optional[bool] = typer.Option(
+    list_: bool | None = typer.Option(
         False, "--list", "-l", help="List cached manifests"
     ),
-    verbose: Optional[bool] = typer.Option(False, "--verbose", "-v", help="verbose"),
+    verbose: bool | None = typer.Option(False, "--verbose", "-v", help="verbose"),
 ):
     """Cache utils"""
     from npe2.manifest._npe1_adapter import ADAPTER_CACHE, clear_cache
@@ -481,7 +485,7 @@ def cache(
 @app.command()
 def compile(
     src_dir: str,
-    output: Optional[Path] = typer.Option(
+    output: Path | None = typer.Option(
         None,
         "-o",
         "--output",

npe2/implements.py

@@ -1,8 +1,9 @@
 import contextlib
+from collections.abc import Callable, Sequence
 from inspect import Parameter, Signature
-from typing import Any, Callable, List, Sequence, Type, TypeVar
+from typing import Any, TypeVar
 
-from npe2._pydantic_compat import BaseModel
+from pydantic import BaseModel
 
 from .manifest import contributions
 
@@ -22,7 +23,7 @@ T = TypeVar("T", bound=Callable[..., Any])
 CHECK_ARGS_PARAM = "ensure_args_valid"
 
 
-def _build_decorator(contrib: Type[BaseModel]) -> Callable:
+def _build_decorator(contrib: type[BaseModel]) -> Callable:
     """Create a decorator (e.g. `@implements.reader`) to mark an object as a contrib.
 
     Parameters
@@ -32,24 +33,26 @@ def _build_decorator(contrib: Type[BaseModel]) -> Callable:
     """
     # build a signature based on the fields in this contribution type, mixed with
     # the fields in the CommandContribution
-    contribs: Sequence[Type[BaseModel]] = (contributions.CommandContribution, contrib)
-    params: List[Parameter] = []
+    contribs: Sequence[type[BaseModel]] = (contributions.CommandContribution, contrib)
+    params: list[Parameter] = []
     for contrib in contribs:
         # iterate over the fields in the contribution types
-        for field in contrib.__fields__.values():
+        for name, field in contrib.model_fields.items():
             # we don't need python_name (since that will be gleaned from the function
             # we're decorating) ... and we don't need `command`, since that will just
             # be a string pointing to the contributions.commands entry that we are
             # creating here.
-            if field.name not in {"python_name", "command"}:
+            if name not in {"python_name", "command"}:
                 # ensure that required fields raise a TypeError if they are not provided
-                default = Parameter.empty if field.required else field.get_default()
+                default = (
+                    Parameter.empty if field.is_required() else field.get_default()
+                )
                 # create the parameter and add it to the signature.
                 param = Parameter(
-                    field.name,
+                    name,
                     Parameter.KEYWORD_ONLY,
                     default=default,
-                    annotation=field.outer_type_ or field.type_,
+                    annotation=field.annotation,
                 )
                 params.append(param)
 

npe2/implements.pyi

@@ -1,6 +1,7 @@
-from typing import Any, Callable, TypeVar
+from collections.abc import Callable
+from typing import Any, TypeVar
 
-from npe2._pydantic_compat import BaseModel as BaseModel
+from pydantic import BaseModel as BaseModel
 
 from .manifest import PluginManifest as PluginManifest
 from .manifest import contributions as contributions

npe2/io_utils.py

@@ -1,13 +1,9 @@
 from __future__ import annotations
 
+from collections.abc import Sequence
 from typing import (
     TYPE_CHECKING,
-    List,
     Literal,
-    Optional,
-    Sequence,
-    Tuple,
-    Union,
     cast,
     overload,
 )
@@ -23,8 +19,8 @@ if TYPE_CHECKING:
 
 
 def read(
-    paths: List[str], *, stack: bool, plugin_name: Optional[str] = None
-) -> List[LayerData]:
+    paths: list[str], *, stack: bool, plugin_name: str | None = None
+) -> list[LayerData]:
     """Try to read file at `path`, with plugins offering a ReaderContribution.
 
     Parameters
@@ -53,11 +49,11 @@ def read(
 
 
 def read_get_reader(
-    path: Union[str, Sequence[str]],
+    path: str | Sequence[str],
     *,
-    plugin_name: Optional[str] = None,
-    stack: Optional[bool] = None,
-) -> Tuple[List[LayerData], ReaderContribution]:
+    plugin_name: str | None = None,
+    stack: bool | None = None,
+) -> tuple[list[LayerData], ReaderContribution]:
     """Variant of `read` that also returns the `ReaderContribution` used."""
     if stack is None:
         # "npe1" old path
@@ -75,10 +71,10 @@ def read_get_reader(
 
 def write(
     path: str,
-    layer_data: List[Union[FullLayerData, napari.layers.Layer]],
+    layer_data: list[FullLayerData | napari.layers.Layer],
     *,
-    plugin_name: Optional[str] = None,
-) -> List[str]:
+    plugin_name: str | None = None,
+) -> list[str]:
     """Write layer_data tuples to `path`.
 
     Parameters
@@ -107,10 +103,10 @@ def write(
 
 def write_get_writer(
     path: str,
-    layer_data: List[Union[FullLayerData, napari.layers.Layer]],
+    layer_data: list[FullLayerData | napari.layers.Layer],
     *,
-    plugin_name: Optional[str] = None,
-) -> Tuple[List[str], WriterContribution]:
+    plugin_name: str | None = None,
+) -> tuple[list[str], WriterContribution]:
     """Variant of write that also returns the `WriterContribution` used."""
     return _write(path, layer_data, plugin_name=plugin_name, return_writer=True)
 
@@ -120,34 +116,34 @@ def write_get_writer(
 
 @overload
 def _read(
-    paths: Union[str, Sequence[str]],
+    paths: str | Sequence[str],
     *,
     stack: bool,
-    plugin_name: Optional[str] = None,
+    plugin_name: str | None = None,
     return_reader: Literal[False] = False,
     _pm=None,
-) -> List[LayerData]: ...
+) -> list[LayerData]: ...
 
 
 @overload
 def _read(
-    paths: Union[str, Sequence[str]],
+    paths: str | Sequence[str],
     *,
     stack: bool,
-    plugin_name: Optional[str] = None,
+    plugin_name: str | None = None,
     return_reader: Literal[True],
     _pm=None,
-) -> Tuple[List[LayerData], ReaderContribution]: ...
+) -> tuple[list[LayerData], ReaderContribution]: ...
 
 
 def _read(
-    paths: Union[str, Sequence[str]],
+    paths: str | Sequence[str],
     *,
     stack: bool,
-    plugin_name: Optional[str] = None,
+    plugin_name: str | None = None,
     return_reader: bool = False,
-    _pm: Optional[PluginManager] = None,
-) -> Union[Tuple[List[LayerData], ReaderContribution], List[LayerData]]:
+    _pm: PluginManager | None = None,
+) -> tuple[list[LayerData], ReaderContribution] | list[LayerData]:
     """Execute the `read...` functions above."""
     if _pm is None:
         _pm = PluginManager.instance()
@@ -157,9 +153,9 @@ def _read(
     chosen_compatible_readers = _get_compatible_readers_by_choice(
         plugin_name, paths, _pm
     )
-    assert (
-        chosen_compatible_readers
-    ), "No readers to try. Expected an exception before this point."
+    assert chosen_compatible_readers, (
+        "No readers to try. Expected an exception before this point."
+    )
 
     for rdr in chosen_compatible_readers:
         read_func = rdr.exec(
@@ -179,7 +175,7 @@ def _read(
 
 
 def _get_compatible_readers_by_choice(
-    plugin_name: Union[str, None], paths: Union[str, Sequence[str]], pm: PluginManager
+    plugin_name: str | None, paths: str | Sequence[str], pm: PluginManager
 ):
     """Returns compatible readers filtered by validated plugin choice.
 
@@ -263,39 +259,39 @@ def _get_compatible_readers_by_choice(
 @overload
 def _write(
     path: str,
-    layer_data: List[Union[FullLayerData, napari.layers.Layer]],
+    layer_data: list[FullLayerData | napari.layers.Layer],
     *,
-    plugin_name: Optional[str] = None,
+    plugin_name: str | None = None,
     return_writer: Literal[False] = False,
-    _pm: Optional[PluginManager] = None,
-) -> List[str]: ...
+    _pm: PluginManager | None = None,
+) -> list[str]: ...
 
 
 @overload
 def _write(
     path: str,
-    layer_data: List[Union[FullLayerData, napari.layers.Layer]],
+    layer_data: list[FullLayerData | napari.layers.Layer],
     *,
-    plugin_name: Optional[str] = None,
+    plugin_name: str | None = None,
     return_writer: Literal[True],
-    _pm: Optional[PluginManager] = None,
-) -> Tuple[List[str], WriterContribution]: ...
+    _pm: PluginManager | None = None,
+) -> tuple[list[str], WriterContribution]: ...
 
 
 def _write(
     path: str,
-    layer_data: List[Union[FullLayerData, napari.layers.Layer]],
+    layer_data: list[FullLayerData | napari.layers.Layer],
     *,
-    plugin_name: Optional[str] = None,
+    plugin_name: str | None = None,
     return_writer: bool = False,
-    _pm: Optional[PluginManager] = None,
-) -> Union[List[str], Tuple[List[str], WriterContribution]]:
+    _pm: PluginManager | None = None,
+) -> list[str] | tuple[list[str], WriterContribution]:
     if not layer_data:
         raise ValueError("Must provide layer data")
     if _pm is None:
         _pm = PluginManager.instance()
 
-    _layer_tuples: List[FullLayerData] = [
+    _layer_tuples: list[FullLayerData] = [
         (
             cast("napari.layers.Layer", x).as_layer_data_tuple()
             if hasattr(x, "as_layer_data_tuple")

npe2/manifest/_bases.py

@@ -1,11 +1,10 @@
 import json
+from collections.abc import Callable
 from contextlib import contextmanager
 from pathlib import Path
-from typing import Callable, Dict, Optional, Union
 
 import yaml
-
-from npe2._pydantic_compat import BaseModel, PrivateAttr
+from pydantic import BaseModel, PrivateAttr
 
 
 class ImportExportModel(BaseModel):
@@ -17,7 +16,7 @@ class ImportExportModel(BaseModel):
             some_field: str = Field(..., always_export=True)
     """
 
-    _source_file: Optional[Path] = PrivateAttr(None)
+    _source_file: Path | None = PrivateAttr(None)
 
     def toml(self, pyproject=False, **kwargs) -> str:
         """Generate serialized `toml` string for this model.
@@ -28,7 +27,7 @@ class ImportExportModel(BaseModel):
             If `True`, output will be in pyproject format, with all data under
             `tool.napari`, by default `False`.
         **kwargs
-            passed to `BaseModel.json()`
+            passed to `BaseModel.model_dump_json()`
         """
         import tomli_w
 
@@ -43,12 +42,12 @@ class ImportExportModel(BaseModel):
         Parameters
         ----------
         **kwargs
-            passed to `BaseModel.json()`
+            passed to `BaseModel.model_dump_json()`
         """
         return yaml.safe_dump(self._serialized_data(**kwargs), sort_keys=False)
 
     @classmethod
-    def from_file(cls, path: Union[Path, str]):
+    def from_file(cls, path: Path | str):
         """Parse model from a metadata file.
 
         Parameters
@@ -101,20 +100,22 @@ class ImportExportModel(BaseModel):
         """using json encoders for all outputs"""
         kwargs.setdefault("exclude_unset", True)
         with self._required_export_fields_set():
-            return json.loads(self.json(**kwargs))
+            return json.loads(self.model_dump_json(**kwargs))
 
     @contextmanager
     def _required_export_fields_set(self):
-        fields = self.__fields__.items()
-        required = {k for k, v in fields if v.field_info.extra.get("always_export")}
+        field_schemas = self.model_json_schema()["properties"]
+        required = {
+            k for k, v in field_schemas.items() if v.get("always_export", False)
+        }
 
-        was_there: Dict[str, bool] = {}
+        was_there: dict[str, bool] = {}
         for f in required:
-            was_there[f] = f in self.__fields_set__
-            self.__fields_set__.add(f)
+            was_there[f] = f in self.model_fields_set
+            self.model_fields_set.add(f)
         try:
             yield
         finally:
             for f in required:
                 if not was_there.get(f):
-                    self.__fields_set__.discard(f)
+                    self.model_fields_set.discard(f)

npe2/manifest/_npe1_adapter.py

@@ -3,10 +3,10 @@ import logging
 import os
 import site
 import warnings
+from collections.abc import Sequence
 from importlib import metadata
 from pathlib import Path
 from shutil import rmtree
-from typing import List, Sequence
 
 from platformdirs import user_cache_dir
 
@@ -20,7 +20,7 @@ ADAPTER_CACHE = Path(user_cache_dir("napari", "napari")) / "npe2" / "adapter_man
 NPE2_NOCACHE = "NPE2_NOCACHE"
 
 
-def clear_cache(names: Sequence[str] = ()) -> List[Path]:
+def clear_cache(names: Sequence[str] = ()) -> list[Path]:
     """Clear cached NPE1Adapter manifests.
 
     Parameters
@@ -33,7 +33,7 @@ def clear_cache(names: Sequence[str] = ()) -> List[Path]:
     List[Path]
         List of filepaths cleared
     """
-    _cleared: List[Path] = []
+    _cleared: list[Path] = []
     if ADAPTER_CACHE.exists():
         if names:
             for f in ADAPTER_CACHE.glob("*.yaml"):