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

npe2/_command_registry.py

@@ -1,8 +1,9 @@
 from __future__ import annotations
 
+from collections.abc import Callable
 from dataclasses import dataclass
 from functools import partial
-from typing import TYPE_CHECKING, Any, Callable, Dict, Optional, Union
+from typing import TYPE_CHECKING, Any
 
 from psygnal import Signal
 
@@ -19,8 +20,8 @@ if TYPE_CHECKING:
 @dataclass
 class CommandHandler:
     id: str
-    function: Optional[Callable] = None
-    python_name: Optional[PythonName] = None
+    function: Callable | None = None
+    python_name: PythonName | None = None
 
     def resolve(self) -> Callable:
         if self.function is not None:
@@ -50,9 +51,9 @@ class CommandRegistry:
     command_unregistered = Signal(str)
 
     def __init__(self) -> None:
-        self._commands: Dict[str, CommandHandler] = {}
+        self._commands: dict[str, CommandHandler] = {}
 
-    def register(self, id: str, command: Union[Callable, str]) -> PDisposable:
+    def register(self, id: str, command: Callable | str) -> PDisposable:
         """Register a command under `id`.
 
         Parameters

npe2/_dynamic_plugin.py

@@ -1,20 +1,17 @@
 from __future__ import annotations
 
+from collections.abc import Callable
 from typing import (
     Any,
-    Callable,
-    Dict,
     Generic,
-    List,
     Literal,
-    Optional,
-    Type,
     TypeVar,
-    Union,
     overload,
 )
 
-from npe2._pydantic_compat import BaseModel, ValidationError
+from pydantic import BaseModel, ValidationError
+
+from npe2._pydantic_util import iter_inner_types
 
 from ._plugin_manager import PluginManager
 from .manifest.contributions import (
@@ -33,12 +30,15 @@ T = TypeVar("T", bound=Callable[..., Any])
 
 # a mapping of contribution type to string name in the ContributionPoints
 # e.g. {ReaderContribution: 'readers'}
-CONTRIB_NAMES = {v.type_: k for k, v in ContributionPoints.__fields__.items()}
-for key in list(CONTRIB_NAMES):
-    if getattr(key, "__origin__", "") == Union:
-        v = CONTRIB_NAMES.pop(key)
-        for t in key.__args__:
-            CONTRIB_NAMES[t] = v
+CONTRIB_ANNOTATIONS = {
+    v.annotation: k for k, v in ContributionPoints.model_fields.items()
+}
+CONTRIB_NAMES = {}
+
+
+for key, value in CONTRIB_ANNOTATIONS.items():
+    for type_ in iter_inner_types(key):
+        CONTRIB_NAMES[type_] = value
 
 
 class DynamicPlugin:
@@ -65,8 +65,8 @@ class DynamicPlugin:
     def __init__(
         self,
         name: str = "temp-plugin",
-        plugin_manager: Optional[PluginManager] = None,
-        manifest: Optional[PluginManifest] = None,
+        plugin_manager: PluginManager | None = None,
+        manifest: PluginManifest | None = None,
     ) -> None:
         if isinstance(manifest, PluginManifest):
             self.manifest = manifest
@@ -108,12 +108,12 @@ class DynamicPlugin:
         return self._pm if self._pm is not None else PluginManager.instance()
 
     @plugin_manager.setter
-    def plugin_manager(self, pm: Optional[PluginManager]) -> None:
+    def plugin_manager(self, pm: PluginManager | None) -> None:
         """Set the plugin manager this plugin is registered in."""
         if pm is self._pm:  # pragma: no cover
             return
 
-        my_cmds: Dict[str, Callable] = {
+        my_cmds: dict[str, Callable] = {
             k: v.function
             for k, v in self.plugin_manager.commands._commands.items()
             if k.startswith(self.manifest.name) and v.function
@@ -133,8 +133,8 @@ class DynamicPlugin:
 
     def spawn(
         self,
-        name: Optional[str] = None,
-        plugin_manager: Optional[PluginManager] = None,
+        name: str | None = None,
+        plugin_manager: PluginManager | None = None,
         register: bool = False,
     ) -> DynamicPlugin:
         """Create a new DynamicPlugin instance with the same plugin manager.
@@ -197,7 +197,7 @@ class ContributionDecorator(Generic[C]):
     of a specific `contrib_type` to a temporary plugin.
     """
 
-    def __init__(self, plugin: DynamicPlugin, contrib_type: Type[C]) -> None:
+    def __init__(self, plugin: DynamicPlugin, contrib_type: type[C]) -> None:
         self.plugin = plugin
         self.contrib_type = contrib_type
         self._contrib_name = CONTRIB_NAMES[self.contrib_type]
@@ -207,12 +207,10 @@ class ContributionDecorator(Generic[C]):
 
     @overload
     def __call__(
-        self, func: Optional[Literal[None]] = None, **kwargs
+        self, func: Literal[None] | None = None, **kwargs
     ) -> Callable[[T], T]: ...
 
-    def __call__(
-        self, func: Optional[T] = None, **kwargs
-    ) -> Union[T, Callable[[T], T]]:
+    def __call__(self, func: T | None = None, **kwargs) -> T | Callable[[T], T]:
         """Decorate function as providing this contrubtion type.
 
         This is the actual decorator used when one calls, eg.
@@ -263,7 +261,7 @@ class ContributionDecorator(Generic[C]):
         cmd_kwargs = {
             k: kwargs.pop(k)
             for k in list(kwargs)
-            if k in CommandContribution.__fields__
+            if k in CommandContribution.model_fields
         }
         cmd = CommandContribution(**cmd_kwargs)
         self.commands.append(cmd)
@@ -277,14 +275,14 @@ class ContributionDecorator(Generic[C]):
         return self.plugin.manifest
 
     @property
-    def contribution_list(self) -> List[C]:
+    def contribution_list(self) -> list[C]:
         """Return contributions of this type in the associated manifest."""
         if not getattr(self._mf.contributions, self._contrib_name):
             setattr(self._mf.contributions, self._contrib_name, [])
         return getattr(self._mf.contributions, self._contrib_name)
 
     @property
-    def commands(self) -> List[CommandContribution]:
+    def commands(self) -> list[CommandContribution]:
         """Return the CommandContributions in the associated manifest."""
         if not self._mf.contributions.commands:
             self._mf.contributions.commands = []

npe2/_inspection/_compile.py

@@ -1,5 +1,6 @@
+from collections.abc import Iterator, Sequence
 from pathlib import Path
-from typing import Iterator, List, Sequence, Tuple, Union, cast
+from typing import cast
 
 from npe2.manifest import PluginManifest, contributions
 from npe2.manifest.utils import merge_contributions, merge_manifests
@@ -8,21 +9,21 @@ from ._setuputils import get_package_dir_info
 from ._visitors import find_npe2_module_contributions
 
 
-def find_packages(where: Union[str, Path] = ".") -> List[Path]:
+def find_packages(where: str | Path = ".") -> list[Path]:
     """Return all folders that have an __init__.py file"""
     return [p.parent for p in Path(where).resolve().rglob("**/__init__.py")]
 
 
-def get_package_name(where: Union[str, Path] = ".") -> str:
+def get_package_name(where: str | Path = ".") -> str:
     return get_package_dir_info(where).package_name
 
 
 def compile(
-    src_dir: Union[str, Path],
-    dest: Union[str, Path, None] = None,
+    src_dir: str | Path,
+    dest: str | Path | None = None,
     packages: Sequence[str] = (),
     plugin_name: str = "",
-    template: Union[str, Path, None] = None,
+    template: str | Path | None = None,
 ) -> PluginManifest:
     """Compile plugin manifest from `src_dir`, where is a top-level repo.
 
@@ -75,7 +76,7 @@ def compile(
     if not plugin_name:
         plugin_name = get_package_name(src_path)
 
-    contribs: List[contributions.ContributionPoints] = []
+    contribs: list[contributions.ContributionPoints] = []
     for pkg_path in _packages:
         top_mod = pkg_path.name
         # TODO: add more tests with more complicated package structures
@@ -103,7 +104,7 @@ def compile(
     return mf
 
 
-def _iter_modules(path: Path) -> Iterator[Tuple[Path, str]]:
+def _iter_modules(path: Path) -> Iterator[tuple[Path, str]]:
     """Return all python modules in path"""
     for p in path.glob("*.py"):
         yield p, "" if p.name == "__init__.py" else p.stem

npe2/_inspection/_fetch.py

@@ -4,21 +4,16 @@ import io
 import json
 import os
 import subprocess
+import sys
 import tempfile
-from contextlib import contextmanager
+from collections.abc import Iterator
+from contextlib import AbstractContextManager, contextmanager
 from functools import lru_cache
 from importlib import metadata
 from logging import getLogger
 from pathlib import Path
 from typing import (
     TYPE_CHECKING,
-    Any,
-    ContextManager,
-    Dict,
-    Iterator,
-    List,
-    Optional,
-    Union,
 )
 from unittest.mock import patch
 from urllib import error, request
@@ -36,7 +31,6 @@ NPE1_ENTRY_POINT = "napari.plugin"
 NPE2_ENTRY_POINT = "napari.manifest"
 __all__ = [
     "fetch_manifest",
-    "get_hub_plugin",
     "get_pypi_url",
 ]
 
@@ -118,7 +112,7 @@ def _guard_cwd() -> Iterator[None]:
         os.chdir(current)
 
 
-def _build_wheel(src: Union[str, Path]) -> Path:
+def _build_wheel(src: str | Path) -> Path:
     """Build a wheel from a source directory and extract it into dest."""
     from build.__main__ import build_package
 
@@ -148,7 +142,7 @@ def get_manifest_from_wheel(src: str) -> PluginManifest:
             return _manifest_from_extracted_wheel(Path(td))
 
 
-def _build_src_and_extract_manifest(src_dir: Union[str, Path]) -> PluginManifest:
+def _build_src_and_extract_manifest(src_dir: str | Path) -> PluginManifest:
     """Build a wheel from a source directory and extract the manifest."""
     return _manifest_from_extracted_wheel(_build_wheel(src_dir))
 
@@ -162,7 +156,7 @@ def _get_manifest_from_zip_url(url: str) -> PluginManifest:
     """
     from npe2.manifest import PluginManifest
 
-    def find_manifest_file(root: Path) -> Optional[Path]:
+    def find_manifest_file(root: Path) -> Path | None:
         """Recursively find a napari manifest file."""
         # Check current directory for manifest files
         for filename in ["napari.yaml", "napari.yml"]:
@@ -251,9 +245,7 @@ def _get_manifest_from_git_url(url: str) -> PluginManifest:
         return _build_src_and_extract_manifest(td)
 
 
-def fetch_manifest(
-    package_or_url: str, version: Optional[str] = None
-) -> PluginManifest:
+def fetch_manifest(package_or_url: str, version: str | None = None) -> PluginManifest:
     """Fetch a manifest for a pypi package name or URL to a wheel or source.
 
     Parameters
@@ -307,7 +299,7 @@ def fetch_manifest(
 
 
 def _manifest_from_pypi_sdist(
-    package: str, version: Optional[str] = None
+    package: str, version: str | None = None
 ) -> PluginManifest:
     """Extract a manifest from a source distribution on pypi."""
     with _tmp_pypi_sdist_download(package, version) as td:
@@ -322,7 +314,7 @@ def _pypi_info(package: str) -> dict:
 
 
 def get_pypi_url(
-    package: str, version: Optional[str] = None, packagetype: Optional[str] = None
+    package: str, version: str | None = None, packagetype: str | None = None
 ) -> str:
     """Get URL for a package on PyPI.
 
@@ -358,7 +350,7 @@ def get_pypi_url(
     if version:
         version = version.lstrip("v")
         try:
-            _releases: List[dict] = data["releases"][version]
+            _releases: list[dict] = data["releases"][version]
         except KeyError as e:  # pragma: no cover
             raise ValueError(f"{package} does not have version {version}") from e
     else:
@@ -391,28 +383,24 @@ def _tmp_targz_download(url: str) -> Iterator[Path]:
 
     with tempfile.TemporaryDirectory() as td, request.urlopen(url) as f:
         with tarfile.open(fileobj=f, mode="r:gz") as tar:
-            tar.extractall(td)
+            if sys.version_info >= (3, 11):
+                tar.extractall(td, filter="data")
+            else:
+                tar.extractall(td)
             yield Path(td)
 
 
 def _tmp_pypi_wheel_download(
-    package: str, version: Optional[str] = None
-) -> ContextManager[Path]:
+    package: str, version: str | None = None
+) -> AbstractContextManager[Path]:
     url = get_pypi_url(package, version=version, packagetype="bdist_wheel")
     logger.debug(f"downloading wheel for {package} {version or ''}")
     return _tmp_zip_download(url)
 
 
 def _tmp_pypi_sdist_download(
-    package: str, version: Optional[str] = None
-) -> ContextManager[Path]:
+    package: str, version: str | None = None
+) -> AbstractContextManager[Path]:
     url = get_pypi_url(package, version=version, packagetype="sdist")
     logger.debug(f"downloading sdist for {package} {version or ''}")
     return _tmp_targz_download(url)
-
-
-@lru_cache
-def get_hub_plugin(plugin_name: str) -> Dict[str, Any]:
-    """Return hub information for a specific plugin."""
-    with request.urlopen(f"https://api.napari-hub.org/plugins/{plugin_name}") as r:
-        return json.load(r)

npe2/_inspection/_from_npe1.py

@@ -3,6 +3,8 @@ import inspect
 import re
 import sys
 import warnings
+from collections import defaultdict
+from collections.abc import Callable, Iterator
 from configparser import ConfigParser
 from functools import lru_cache, partial
 from importlib import import_module, metadata
@@ -11,14 +13,6 @@ from pathlib import Path
 from types import ModuleType
 from typing import (
     Any,
-    Callable,
-    DefaultDict,
-    Dict,
-    Iterator,
-    List,
-    Optional,
-    Tuple,
-    Union,
     cast,
 )
 
@@ -48,8 +42,8 @@ class HookImplementation:
     def __init__(
         self,
         function: Callable,
-        plugin: Optional[ModuleType] = None,
-        plugin_name: Optional[str] = None,
+        plugin: ModuleType | None = None,
+        plugin_name: str | None = None,
         **kwargs,
     ):
         self.function = function
@@ -68,7 +62,7 @@ class HookImplementation:
 
 
 def iter_hookimpls(
-    module: ModuleType, plugin_name: Optional[str] = None
+    module: ModuleType, plugin_name: str | None = None
 ) -> Iterator[HookImplementation]:
     # yield all routines in module that have "{self.project_name}_impl" attr
     for name in dir(module):
@@ -80,14 +74,14 @@ def iter_hookimpls(
 
 
 @lru_cache
-def plugin_packages() -> List[PackageInfo]:
+def plugin_packages() -> list[PackageInfo]:
     """List of all packages with napari entry points.
 
     This is useful to help resolve naming issues (due to the terrible confusion
     around *what* a npe1 plugin name actually was).
     """
 
-    packages: List[PackageInfo] = []
+    packages: list[PackageInfo] = []
     for dist in metadata.distributions():
         packages.extend(
             PackageInfo(package_name=dist.metadata["Name"], entry_points=[ep])
@@ -99,8 +93,8 @@ def plugin_packages() -> List[PackageInfo]:
 
 
 def manifest_from_npe1(
-    plugin: Union[str, metadata.Distribution, None] = None,
-    module: Optional[Any] = None,
+    plugin: str | metadata.Distribution | None = None,
+    module: Any | None = None,
     adapter=False,
 ) -> PluginManifest:
     """Return manifest object given npe1 plugin or package name.
@@ -109,7 +103,7 @@ def manifest_from_npe1(
 
     Parameters
     ----------
-    plugin : Union[str, metadata.Distribution, None]
+    plugin : str | metadata.Distribution | None
         Name of package/plugin to convert.  Or a `metadata.Distribution` object.
         If a string, this function should be prepared to accept both the name of the
         package, and the name of an npe1 `napari.plugin` entry_point. by default None
@@ -122,7 +116,7 @@ def manifest_from_npe1(
         python_names that are not supported natively by npe2. by default False
     """
     if module is not None:
-        modules: List[str] = [module]
+        modules: list[str] = [module]
         package_name = "dynamic"
         plugin_name = getattr(module, "__name__", "dynamic_plugin")
     elif isinstance(plugin, str):
@@ -152,7 +146,7 @@ def manifest_from_npe1(
     else:
         raise ValueError("one of plugin or module must be provided")  # pragma: no cover
 
-    manifests: List[PluginManifest] = []
+    manifests: list[PluginManifest] = []
     for mod_name in modules:
         logger.debug(
             "Discovering contributions for npe1 plugin %r: module %r",
@@ -192,7 +186,7 @@ class HookImplParser:
         """
         self.package = package
         self.plugin_name = plugin_name
-        self.contributions: DefaultDict[str, list] = DefaultDict(list)
+        self.contributions: defaultdict[str, list] = defaultdict(list)
         self.adapter = adapter
 
     def manifest(self) -> PluginManifest:
@@ -211,8 +205,8 @@ class HookImplParser:
                     )
 
     def napari_experimental_provide_theme(self, impl: HookImplementation):
-        ThemeDict = Dict[str, Union[str, Tuple, List]]
-        d: Dict[str, ThemeDict] = impl.function()
+        ThemeDict = dict[str, str | tuple | list]
+        d: dict[str, ThemeDict] = impl.function()
         for name, theme_dict in d.items():
             colors = ThemeColors(**theme_dict)
             clr = colors.background or colors.foreground
@@ -240,9 +234,9 @@ class HookImplParser:
     def napari_provide_sample_data(self, impl: HookImplementation):
         module = sys.modules[impl.function.__module__.split(".", 1)[0]]
 
-        samples: Dict[str, Union[dict, str, Callable]] = impl.function()
+        samples: dict[str, dict | str | Callable] = impl.function()
         for idx, (key, sample) in enumerate(samples.items()):
-            _sample: Union[str, Callable]
+            _sample: str | Callable
             if isinstance(sample, dict):
                 display_name = sample.get("display_name")
                 _sample = sample.get("data")  # type: ignore
@@ -273,7 +267,7 @@ class HookImplParser:
             self.contributions["sample_data"].append(s)
 
     def napari_experimental_provide_function(self, impl: HookImplementation):
-        items: Union[Callable, List[Callable]] = impl.function()
+        items: Callable | list[Callable] = impl.function()
         items = [items] if not isinstance(items, list) else items
 
         for idx, item in enumerate(items):
@@ -303,8 +297,8 @@ class HookImplParser:
                 warnings.warn(msg, stacklevel=2)
 
     def napari_experimental_provide_dock_widget(self, impl: HookImplementation):
-        WidgetCallable = Union[Callable, Tuple[Callable, dict]]
-        items: Union[WidgetCallable, List[WidgetCallable]] = impl.function()
+        WidgetCallable = Callable | tuple[Callable, dict]
+        items: WidgetCallable | list[WidgetCallable] = impl.function()
         if not isinstance(items, list):
             items = [items]  # pragma: no cover
 
@@ -419,7 +413,7 @@ def _is_magicgui_magic_factory(obj):
 
 
 def _python_name(
-    obj: Any, hook: Optional[Callable] = None, hook_idx: Optional[int] = None
+    obj: Any, hook: Callable | None = None, hook_idx: int | None = None
 ) -> str:
     """Get resolvable python name for `obj` returned from an npe1 `hook` implentation.
 
@@ -446,8 +440,8 @@ def _python_name(
     AttributeError
         If a resolvable string cannot be found
     """
-    obj_name: Optional[str] = None
-    mod_name: Optional[str] = None
+    obj_name: str | None = None
+    mod_name: str | None = None
     # first, check the global namespace of the module where the hook was declared
     # if we find `obj` itself, we can just use it.
     if hasattr(hook, "__module__"):
@@ -505,7 +499,7 @@ def _camel_to_spaces(val):
     return _camel_to_spaces_pattern.sub(r" \1", val)
 
 
-def get_top_module_path(package_name, top_module: Optional[str] = None) -> Path:
+def get_top_module_path(package_name, top_module: str | None = None) -> Path:
     dist = metadata.distribution(package_name)
     if not top_module:
         top_mods = (dist.read_text("top_level.txt") or "").strip().splitlines()
@@ -528,8 +522,8 @@ def get_top_module_path(package_name, top_module: Optional[str] = None) -> Path:
 
 
 def convert_repository(
-    path: Union[Path, str], mf_name: str = "napari.yaml", dry_run=False
-) -> Tuple[PluginManifest, Path]:
+    path: Path | str, mf_name: str = "napari.yaml", dry_run=False
+) -> tuple[PluginManifest, Path]:
     """Convert repository at `path` to new npe2 style."""
     path = Path(path)
 

npe2/_inspection/_setuputils.py

@@ -4,7 +4,7 @@ from dataclasses import dataclass, field
 from functools import cached_property
 from importlib.metadata import EntryPoint
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Union
+from typing import Any
 
 NPE1_EP = "napari.plugin"
 NPE2_EP = "napari.manifest"
@@ -12,23 +12,23 @@ NPE2_EP = "napari.manifest"
 
 @dataclass
 class PackageInfo:
-    src_root: Optional[Path] = None
+    src_root: Path | None = None
     package_name: str = ""
-    entry_points: List[EntryPoint] = field(default_factory=list)
-    setup_cfg: Optional[Path] = None
-    setup_py: Optional[Path] = None
-    pyproject_toml: Optional[Path] = None
+    entry_points: list[EntryPoint] = field(default_factory=list)
+    setup_cfg: Path | None = None
+    setup_py: Path | None = None
+    pyproject_toml: Path | None = None
 
     # @property
     # def packages(self) -> Optional[List[Path]]:
     #     return Path(self.top_module)
 
     @cached_property
-    def _ep1(self) -> Optional[EntryPoint]:
+    def _ep1(self) -> EntryPoint | None:
         return next((ep for ep in self.entry_points if ep.group == NPE1_EP), None)
 
     @cached_property
-    def _ep2(self) -> Optional[EntryPoint]:
+    def _ep2(self) -> EntryPoint | None:
         return next((ep for ep in self.entry_points if ep.group == NPE2_EP), None)
 
     @property
@@ -48,7 +48,7 @@ class PackageInfo:
         return ""  # pragma: no cover
 
 
-def get_package_dir_info(path: Union[Path, str]) -> PackageInfo:
+def get_package_dir_info(path: Path | str) -> PackageInfo:
     """Attempt to *statically* get plugin info from a package directory."""
     path = Path(path).resolve()
     if not path.is_dir():  # pragma: no cover
@@ -94,8 +94,8 @@ class _SetupVisitor(ast.NodeVisitor):
 
     def __init__(self) -> None:
         super().__init__()
-        self._names: Dict[str, Any] = {}
-        self._setup_kwargs: Dict[str, Any] = {}
+        self._names: dict[str, Any] = {}
+        self._setup_kwargs: dict[str, Any] = {}
 
     def visit_Assign(self, node: ast.Assign) -> Any:
         if len(node.targets) == 1:
@@ -110,7 +110,7 @@ class _SetupVisitor(ast.NodeVisitor):
                 value = self._get_val(k.value)
                 self._setup_kwargs[str(key)] = value
 
-    def _get_val(self, node: Optional[ast.expr]) -> Any:
+    def _get_val(self, node: ast.expr | None) -> Any:
         if isinstance(node, ast.Constant):
             return node.value
         if isinstance(node, ast.Name):
@@ -120,12 +120,12 @@ class _SetupVisitor(ast.NodeVisitor):
         if isinstance(node, ast.Dict):
             keys = [self._get_val(k) for k in node.keys]
             values = [self._get_val(k) for k in node.values]
-            return dict(zip(keys, values))
+            return dict(zip(keys, values, strict=True))
         if isinstance(node, ast.List):
             return [self._get_val(k) for k in node.elts]
         if isinstance(node, ast.Tuple):  # pragma: no cover
             return tuple(self._get_val(k) for k in node.elts)
         return str(node)  # pragma: no cover
 
-    def get(self, key: str, default: Optional[Any] = None) -> Any:
+    def get(self, key: str, default: Any | None = None) -> Any:
         return self._setup_kwargs.get(key, default)