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

npe2/_inspection/_visitors.py

@@ -1,10 +1,11 @@
 import ast
 import inspect
 from abc import ABC, abstractmethod
+from collections import defaultdict
 from importlib.metadata import Distribution
 from pathlib import Path
 from types import ModuleType
-from typing import TYPE_CHECKING, Any, DefaultDict, Dict, List, Tuple, Type, Union
+from typing import TYPE_CHECKING, Any
 
 from npe2.manifest import contributions
 
@@ -12,7 +13,7 @@ if TYPE_CHECKING:
     from pydantic import BaseModel
 
 
-CONTRIB_MAP: Dict[str, Tuple[Type["BaseModel"], str]] = {
+CONTRIB_MAP: dict[str, tuple[type["BaseModel"], str]] = {
     "writer": (contributions.WriterContribution, "writers"),
     "reader": (contributions.ReaderContribution, "readers"),
     "sample_data_generator": (contributions.SampleDataGenerator, "sample_data"),
@@ -43,7 +44,7 @@ class _DecoratorVisitor(ast.NodeVisitor, ABC):
     def __init__(self, module_name: str, match: str) -> None:
         self.module_name = module_name
         self._match = match
-        self._names: Dict[str, str] = {}
+        self._names: dict[str, str] = {}
 
     def visit_Import(self, node: ast.Import) -> Any:
         # https://docs.python.org/3/library/ast.html#ast.Import
@@ -68,7 +69,7 @@ class _DecoratorVisitor(ast.NodeVisitor, ABC):
     def visit_ClassDef(self, node: ast.ClassDef) -> Any:
         self._find_decorators(node)
 
-    def _find_decorators(self, node: Union[ast.ClassDef, ast.FunctionDef]):
+    def _find_decorators(self, node: ast.ClassDef | ast.FunctionDef):
         # for each in the decorator list ...
         for call in node.decorator_list:
             # https://docs.python.org/3/library/ast.html#ast.Call
@@ -116,14 +117,14 @@ class _DecoratorVisitor(ast.NodeVisitor, ABC):
                     self._process_decorated(call.func.id, node, kwargs)
         return super().generic_visit(node)
 
-    def _keywords_to_kwargs(self, keywords: List[ast.keyword]) -> Dict[str, Any]:
+    def _keywords_to_kwargs(self, keywords: list[ast.keyword]) -> dict[str, Any]:
         return {str(k.arg): ast.literal_eval(k.value) for k in keywords}
 
     @abstractmethod
     def _process_decorated(
         self,
         decorator_name: str,
-        node: Union[ast.ClassDef, ast.FunctionDef],
+        node: ast.ClassDef | ast.FunctionDef,
         decorator_kwargs: dict,
     ):
         """Process a decorated function.
@@ -159,37 +160,37 @@ class NPE2PluginModuleVisitor(_DecoratorVisitor):
     ) -> None:
         super().__init__(module_name, match)
         self.plugin_name = plugin_name
-        self.contribution_points: Dict[str, List[dict]] = {}
+        self.contribution_points: dict[str, list[dict]] = {}
 
     def _process_decorated(
         self,
         decorator_name: str,
-        node: Union[ast.ClassDef, ast.FunctionDef],
+        node: ast.ClassDef | ast.FunctionDef,
         decorator_kwargs: dict,
     ):
         self._store_contrib(decorator_name, node.name, decorator_kwargs)
 
-    def _store_contrib(self, contrib_type: str, name: str, kwargs: Dict[str, Any]):
+    def _store_contrib(self, contrib_type: str, name: str, kwargs: dict[str, Any]):
         from npe2.implements import CHECK_ARGS_PARAM  # circ import
 
         kwargs.pop(CHECK_ARGS_PARAM, None)
         ContribClass, contrib_name = CONTRIB_MAP[contrib_type]
         contrib = ContribClass(**self._store_command(name, kwargs))
-        existing: List[dict] = self.contribution_points.setdefault(contrib_name, [])
-        existing.append(contrib.dict(exclude_unset=True))
+        existing: list[dict] = self.contribution_points.setdefault(contrib_name, [])
+        existing.append(contrib.model_dump(exclude_unset=True))
 
-    def _store_command(self, name: str, kwargs: Dict[str, Any]) -> Dict[str, Any]:
+    def _store_command(self, name: str, kwargs: dict[str, Any]) -> dict[str, Any]:
         cmd_params = inspect.signature(contributions.CommandContribution).parameters
 
         cmd_kwargs = {k: kwargs.pop(k) for k in list(kwargs) if k in cmd_params}
         cmd_kwargs["python_name"] = self._qualified_pyname(name)
         cmd = contributions.CommandContribution(**cmd_kwargs)
         if cmd.id.startswith(self.plugin_name):
-            n = len(self.plugin_name)
+            n = len(self.plugin_name) + 1
             cmd.id = cmd.id[n:]
         cmd.id = f"{self.plugin_name}.{cmd.id.lstrip('.')}"
-        cmd_contribs: List[dict] = self.contribution_points.setdefault("commands", [])
-        cmd_contribs.append(cmd.dict(exclude_unset=True))
+        cmd_contribs: list[dict] = self.contribution_points.setdefault("commands", [])
+        cmd_contribs.append(cmd.model_dump(exclude_unset=True))
         kwargs["command"] = cmd.id
         return kwargs
 
@@ -203,13 +204,13 @@ class NPE1PluginModuleVisitor(_DecoratorVisitor):
     def __init__(self, plugin_name: str, module_name: str) -> None:
         super().__init__(module_name, "napari_plugin_engine.napari_hook_implementation")
         self.plugin_name = plugin_name
-        self.contribution_points: DefaultDict[str, list] = DefaultDict(list)
+        self.contribution_points: defaultdict[str, list] = defaultdict(list)
 
     def _process_decorated(
         self,
         decorator_name: str,
-        node: Union[ast.ClassDef, ast.FunctionDef],
-        decorator_kwargs: Dict[str, Any],
+        node: ast.ClassDef | ast.FunctionDef,
+        decorator_kwargs: dict[str, Any],
     ):
         self.generic_visit(node)  # do this to process any imports in the function
         hookname = decorator_kwargs.get("specname", node.name)
@@ -270,7 +271,7 @@ class NPE1PluginModuleVisitor(_DecoratorVisitor):
             )
 
         contrib: contributions.SampleDataContribution
-        for key, val in zip(return_.value.keys, return_.value.values):
+        for key, val in zip(return_.value.keys, return_.value.values, strict=True):
             if isinstance(val, ast.Dict):
                 raise NotImplementedError("npe1 sample dicts-of-dicts not supported")
 
@@ -372,7 +373,7 @@ class NPE1PluginModuleVisitor(_DecoratorVisitor):
 
 
 def find_npe2_module_contributions(
-    path: Union[ModuleType, str, Path], plugin_name: str, module_name: str = ""
+    path: ModuleType | str | Path, plugin_name: str, module_name: str = ""
 ) -> contributions.ContributionPoints:
     """Visit an npe2 module and extract contribution points.
 
@@ -401,7 +402,11 @@ def find_npe2_module_contributions(
     if "commands" in visitor.contribution_points:
         compress = {tuple(i.items()) for i in visitor.contribution_points["commands"]}
         visitor.contribution_points["commands"] = [dict(i) for i in compress]
-    return contributions.ContributionPoints(**visitor.contribution_points)
+    res = contributions.ContributionPoints(**visitor.contribution_points)
+    for name in visitor.contribution_points:
+        for command in getattr(res, name):
+            command._plugin_name = plugin_name
+    return res
 
 
 def find_npe1_module_contributions(

npe2/_plugin_manager.py

@@ -1,29 +1,18 @@
 from __future__ import annotations
 
+import builtins
 import contextlib
 import os
 import warnings
 from collections import Counter, defaultdict
+from collections.abc import Callable, Iterable, Iterator, Mapping, Sequence, Set
 from fnmatch import fnmatch
 from importlib import metadata
 from logging import getLogger
 from pathlib import Path
 from typing import (
     TYPE_CHECKING,
-    AbstractSet,
     Any,
-    Callable,
-    DefaultDict,
-    Dict,
-    Iterable,
-    Iterator,
-    List,
-    Mapping,
-    Optional,
-    Sequence,
-    Set,
-    Tuple,
-    Union,
 )
 from urllib import parse
 
@@ -47,11 +36,11 @@ if TYPE_CHECKING:
         WidgetContribution,
     )
 
-    IntStr = Union[int, str]
-    AbstractSetIntStr = AbstractSet[IntStr]
-    DictIntStrAny = Dict[IntStr, Any]
+    IntStr = int | str
+    SetIntStr = Set[IntStr]
+    DictIntStrAny = dict[IntStr, Any]
     MappingIntStrAny = Mapping[IntStr, Any]
-    InclusionSet = Union[AbstractSetIntStr, MappingIntStrAny, None]
+    InclusionSet = SetIntStr | MappingIntStrAny | None
     DisposeFunction = Callable[[], None]
 
 logger = getLogger(__name__)
@@ -62,13 +51,13 @@ PluginName = str  # this is `PluginManifest.name`
 
 class _ContributionsIndex:
     def __init__(self) -> None:
-        self._indexed: Set[str] = set()
-        self._commands: Dict[str, Tuple[CommandContribution, PluginName]] = {}
-        self._readers: List[Tuple[str, ReaderContribution]] = []
-        self._writers: List[Tuple[LayerType, int, int, WriterContribution]] = []
+        self._indexed: set[str] = set()
+        self._commands: dict[str, tuple[CommandContribution, PluginName]] = {}
+        self._readers: list[tuple[str, ReaderContribution]] = []
+        self._writers: list[tuple[LayerType, int, int, WriterContribution]] = []
 
         # DEPRECATED: only here for napari <= 0.4.15 compat.
-        self._samples: DefaultDict[str, List[SampleDataContribution]] = DefaultDict(
+        self._samples: defaultdict[str, list[SampleDataContribution]] = defaultdict(
             list
         )
 
@@ -126,7 +115,7 @@ class _ContributionsIndex:
     def get_command(self, command_id: str) -> CommandContribution:
         return self._commands[command_id][0]
 
-    def iter_compatible_readers(self, paths: List[str]) -> Iterator[ReaderContribution]:
+    def iter_compatible_readers(self, paths: list[str]) -> Iterator[ReaderContribution]:
         assert isinstance(paths, list)
         if not paths:
             return  # pragma: no cover
@@ -170,7 +159,7 @@ class _ContributionsIndex:
         # this to get candidate writers compatible with the requested count.
         counts = Counter(layer_types)
 
-        def _get_candidates(lt: LayerType) -> Set[WriterContribution]:
+        def _get_candidates(lt: LayerType) -> set[WriterContribution]:
             return {
                 w
                 for layer, min_, max_, w in self._writers
@@ -185,7 +174,7 @@ class _ContributionsIndex:
             else:
                 break
 
-        def _writer_key(writer: WriterContribution) -> Tuple[bool, int]:
+        def _writer_key(writer: WriterContribution) -> tuple[bool, int]:
             # 1. writers with no file extensions (like directory writers) go last
             no_ext = len(writer.filename_extensions) == 0
 
@@ -222,21 +211,21 @@ class PluginManagerEvents(SignalGroup):
 
 
 class PluginManager:
-    __instance: Optional[PluginManager] = None  # a global instance
+    __instance: PluginManager | None = None  # a global instance
     _contrib: _ContributionsIndex
     events: PluginManagerEvents
 
     def __init__(
-        self, *, disable: Iterable[str] = (), reg: Optional[CommandRegistry] = None
+        self, *, disable: Iterable[str] = (), reg: CommandRegistry | None = None
     ) -> None:
-        self._disabled_plugins: Set[PluginName] = set(disable)
+        self._disabled_plugins: set[PluginName] = set(disable)
         self._command_registry = reg or CommandRegistry()
-        self._contexts: Dict[PluginName, PluginContext] = {}
+        self._contexts: dict[PluginName, PluginContext] = {}
         self._contrib = _ContributionsIndex()
-        self._manifests: Dict[PluginName, PluginManifest] = {}
+        self._manifests: dict[PluginName, PluginManifest] = {}
         self.events = PluginManagerEvents(self)
-        self._npe1_adapters: List[NPE1Adapter] = []
-        self._command_menu_map: Dict[str, Dict[str, Dict[str, List[MenuCommand]]]] = (
+        self._npe1_adapters: list[NPE1Adapter] = []
+        self._command_menu_map: dict[str, dict[str, dict[str, list[MenuCommand]]]] = (
             # for each manifest, maps command IDs to menu IDs to list of MenuCommands
             # belonging to that menu
             # i.e. manifest -> command -> menu_id -> list[MenuCommand]
@@ -323,13 +312,13 @@ class PluginManager:
                 self._contrib.index_contributions(self._npe1_adapters.pop())
 
     def register(
-        self, manifest_or_package: Union[PluginManifest, str], warn_disabled=True
+        self, manifest_or_package: PluginManifest | str, warn_disabled=True
     ) -> None:
         """Register a plugin manifest, path to manifest file, or a package name.
 
         Parameters
         ----------
-        manifest_or_package : Union[PluginManifest, str]
+        manifest_or_package : PluginManifest | str
             Either a PluginManifest instance or a string. If a string, should be either
             the name of a plugin package, or a path to a plugin manifest file.
         warn_disabled : bool, optional
@@ -507,9 +496,7 @@ class PluginManager:
             raise KeyError(msg)
         return self._manifests[key]
 
-    def iter_manifests(
-        self, disabled: Optional[bool] = None
-    ) -> Iterator[PluginManifest]:
+    def iter_manifests(self, disabled: bool | None = None) -> Iterator[PluginManifest]:
         """Iterate through registered manifests.
 
         Parameters
@@ -532,12 +519,12 @@ class PluginManager:
     def dict(
         self,
         *,
-        include: Optional[InclusionSet] = None,
-        exclude: Optional[InclusionSet] = None,
-    ) -> Dict[str, Any]:
+        include: InclusionSet | None = None,
+        exclude: InclusionSet | None = None,
+    ) -> builtins.dict[str, Any]:
         """Return a dictionary with the state of the plugin manager.
 
-        `include` and `exclude` will be passed to each `PluginManifest.dict()`
+        `include` and `exclude` will be passed to each `PluginManifest.model_dump()`
         See pydantic documentation for details:
         https://pydantic-docs.helpmanual.io/usage/exporting_models/#modeldict
 
@@ -568,15 +555,16 @@ class PluginManager:
         Dict[str, Any]
             Dictionary with the state of the plugin manager.  Keys will include
 
-                - `'plugins'`: dict of `{name: manifest.dict()} for discovered plugins
+                - `'plugins'`: dict of `{name: manifest.model_dump()} for
+                  discovered plugins
                 - `'disabled'`: set of disabled plugins
                 - `'activated'`: set of activated plugins
 
         """
         # _include =
-        out: Dict[str, Any] = {
+        out: dict[str, Any] = {
             "plugins": {
-                mf.name: mf.dict(
+                mf.name: mf.model_dump(
                     include=_expand_dotted_set(include),
                     exclude=_expand_dotted_set(exclude),
                 )
@@ -619,9 +607,9 @@ class PluginManager:
         for mf in self.iter_manifests(disabled=disabled):
             yield from mf.contributions.menus.get(menu_key, ())
 
-    def menus(self, disabled=False) -> Dict[str, List[MenuItem]]:
+    def menus(self, disabled=False) -> builtins.dict[str, list[MenuItem]]:
         """Return all registered menu_key -> List[MenuItems]."""
-        _menus: DefaultDict[str, List[MenuItem]] = DefaultDict(list)
+        _menus: defaultdict[str, list[MenuItem]] = defaultdict(list)
         for mf in self.iter_manifests(disabled=disabled):
             for key, menus in mf.contributions.menus.items():
                 _menus[key].extend(menus)
@@ -633,13 +621,13 @@ class PluginManager:
             yield from mf.contributions.themes or ()
 
     def iter_compatible_readers(
-        self, path: Union[PathLike, Sequence[str]]
+        self, path: PathLike | Sequence[str]
     ) -> Iterator[ReaderContribution]:
         """Iterate over ReaderContributions compatible with `path`.
 
         Parameters
         ----------
-        path : Union[PathLike, Sequence[str]]
+        path : PathLike | Sequence[str]
             Pathlike or list of pathlikes, with file(s) to read.
         """
         if isinstance(path, (str, Path)):
@@ -666,15 +654,15 @@ class PluginManager:
 
     def iter_sample_data(
         self,
-    ) -> Iterator[Tuple[PluginName, List[SampleDataContribution]]]:
+    ) -> Iterator[tuple[PluginName, list[SampleDataContribution]]]:
         """Iterates over (plugin_name, [sample_contribs])."""
         for mf in self.iter_manifests(disabled=False):
             if mf.contributions.sample_data:
                 yield mf.name, mf.contributions.sample_data
 
     def get_writer(
-        self, path: str, layer_types: Sequence[str], plugin_name: Optional[str] = None
-    ) -> Tuple[Optional[WriterContribution], str]:
+        self, path: str, layer_types: Sequence[str], plugin_name: str | None = None
+    ) -> tuple[WriterContribution | None, str]:
         """Get Writer contribution appropriate for `path`, and `layer_types`.
 
         When `path` has a file extension, find a compatible writer that has
@@ -715,7 +703,7 @@ class PluginManager:
         # Nothing got found
         return None, path
 
-    def get_shimmed_plugins(self) -> List[str]:
+    def get_shimmed_plugins(self) -> list[str]:
         """Return a list of all shimmed plugin names."""
         return [mf.name for mf in self.iter_manifests() if mf.npe1_shim]
 
@@ -726,14 +714,14 @@ class PluginContext:
     # stores all created contexts (currently cleared by `PluginManager.deactivate`)
 
     def __init__(
-        self, plugin_key: PluginName, reg: Optional[CommandRegistry] = None
+        self, plugin_key: PluginName, reg: CommandRegistry | None = None
     ) -> None:
         self._activated = False
         self.plugin_key = plugin_key
         self._command_registry = reg or PluginManager.instance().commands
-        self._imports: Set[str] = set()  # modules that were imported by this plugin
+        self._imports: set[str] = set()  # modules that were imported by this plugin
         # functions to call when deactivating
-        self._disposables: Set[DisposeFunction] = set()
+        self._disposables: set[DisposeFunction] = set()
 
     def _dispose(self):
         while self._disposables:
@@ -742,7 +730,7 @@ class PluginContext:
             except Exception as e:
                 logger.warning(f"Error while disposing {self.plugin_key}; {e}")
 
-    def register_command(self, id: str, command: Optional[Callable] = None):
+    def register_command(self, id: str, command: Callable | None = None):
         """Associate a callable with a command id."""
 
         def _inner(command):
@@ -787,7 +775,7 @@ def _expand_dotted_set(inclusion_set: InclusionSet) -> InclusionSet:
     ):
         return inclusion_set
 
-    result: Dict[IntStr, Any] = {}
+    result: dict[IntStr, Any] = {}
     # sort the strings based on the number of dots,
     # so that higher level keys take precedence
     # e.g. {'a.b', 'a.d.e', 'a'} -> {'a'}

npe2/_pydantic_util.py

@@ -0,0 +1,53 @@
+from types import NoneType, UnionType
+from typing import Annotated, Dict, List, Union, get_args, get_origin  # noqa
+
+
+def iter_inner_types(type_):
+    origin = get_origin(type_)
+    args = get_args(type_)
+    if origin in (list, List):  # noqa
+        yield from iter_inner_types(args[0])
+    elif origin in (dict, Dict):  # noqa
+        yield from iter_inner_types(args[1])
+    elif origin is Annotated:
+        yield from iter_inner_types(args[0])
+    elif origin in (UnionType, Union):
+        for arg in args:
+            yield from iter_inner_types(arg)
+    elif type_ is not NoneType:
+        yield type_
+
+
+def get_inner_type(type_):
+    """Roughly replacing pydantic.v1 Field.type_"""
+    return Union[tuple(iter_inner_types(type_))]  # noqa
+
+
+def get_outer_type(type_):
+    """Roughly replacing pydantic.v1 Field.outer_type_"""
+    origin = get_origin(type_)
+    args = get_args(type_)
+    if origin in (UnionType, Union):
+        # filter args to remove optional None
+        args = tuple(filter(lambda t: t is not NoneType, get_args(type_)))
+        if len(args) == 1:
+            # it was just optional, pretend there was no None
+            return get_outer_type(args[0])
+        # It's an actual union of types, so there's no "outer type"
+        return None
+    if origin is not None:
+        return origin
+    return type_
+
+
+def is_list_type(type_):
+    """Roughly replacing pydantic.v1 comparison to SHAPE_LIST"""
+    return get_outer_type(type_) is list
+
+
+__all__ = (
+    "get_inner_type",
+    "get_outer_type",
+    "is_list_type",
+    "iter_inner_types",
+)

npe2/_pytest_plugin.py

@@ -1,6 +1,5 @@
 import logging
 import warnings
-from typing import Optional, Union
 from unittest.mock import patch
 
 import pytest
@@ -23,9 +22,9 @@ class TestPluginManager(PluginManager):
 
     def tmp_plugin(
         self,
-        manifest: Optional[Union[PluginManifest, str]] = None,
-        package: Optional[str] = None,
-        name: Optional[str] = None,
+        manifest: PluginManifest | str | None = None,
+        package: str | None = None,
+        name: str | None = None,
     ) -> DynamicPlugin:
         """Create a DynamicPlugin instance using this plugin manager.
 

npe2/_setuptools_plugin.py

@@ -13,16 +13,16 @@ import os
 import re
 import sys
 import warnings
-from typing import TYPE_CHECKING, Optional, Tuple, cast
+from typing import TYPE_CHECKING, cast
 
 from setuptools import Distribution
 from setuptools.command.build_py import build_py
 
 if TYPE_CHECKING:
     from distutils.cmd import Command
-    from typing import Any, Union
+    from typing import Any
 
-    PathT = Union["os.PathLike[str]", str]
+    PathT = "os.PathLike[str]" | str
 
 NPE2_ENTRY = "napari.manifest"
 DEBUG = bool(os.environ.get("SETUPTOOLS_NPE2_DEBUG"))
@@ -54,7 +54,7 @@ def _read_dist_name_from_setup_cfg() -> str | None:
     return parser.get("metadata", "name", fallback=None)
 
 
-def _check_absolute_root(root: PathT, relative_to: PathT | None) -> str:
+def _check_absolute_root(root: PathT, relative_to: PathT | None) -> str:  # type: ignore
     trace("abs root", repr(locals()))
     if relative_to:
         if (
@@ -85,9 +85,9 @@ class Configuration:
 
     def __init__(
         self,
-        relative_to: PathT | None = None,
-        root: PathT = ".",
-        write_to: PathT | None = None,
+        relative_to: PathT | None = None,  # type: ignore
+        root: PathT = ".",  # type: ignore
+        write_to: PathT | None = None,  # type: ignore
         write_to_template: str | None = None,
         dist_name: str | None = None,
         template: str | None = None,
@@ -109,7 +109,7 @@ class Configuration:
         return self._root
 
     @root.setter
-    def root(self, value: PathT) -> None:
+    def root(self, value: PathT) -> None:  # type: ignore
         self._absolute_root = _check_absolute_root(value, self._relative_to)
         self._root = os.fspath(value)
         trace("root", repr(self._absolute_root))
@@ -152,7 +152,7 @@ class Configuration:
         return cls(dist_name=dist_name, **section, **kwargs)
 
 
-def _mf_entry_from_dist(dist: Distribution) -> Optional[Tuple[str, str]]:
+def _mf_entry_from_dist(dist: Distribution) -> tuple[str, str] | None:
     """Return (module, attr) for a distribution's npe2 entry point."""
     eps: dict = getattr(dist, "entry_points", {})
     if napari_entrys := eps.get(NPE2_ENTRY, []):