napari-plugin-manager 0.1.0a2__py3-none-any.whl → 0.1.2__py3-none-any.whl

napari_plugin_manager/_tests/test_qt_plugin_dialog.py

@@ -1,4 +1,6 @@
 import importlib.metadata
+import os
+import platform
 import sys
 from typing import Generator, Optional, Tuple
 from unittest.mock import patch
@@ -9,17 +11,19 @@ import pytest
 import qtpy
 from napari.plugins._tests.test_npe2 import mock_pm  # noqa
 from napari.utils.translations import trans
+from qtpy.QtCore import QMimeData, QPointF, Qt, QUrl
+from qtpy.QtGui import QDropEvent
 
-from napari_plugin_manager import qt_plugin_dialog
-from napari_plugin_manager.qt_package_installer import InstallerActions
-
-if qtpy.API_NAME == 'PySide2' and sys.version_info[:2] == (3, 11):
+if qtpy.API_NAME == 'PySide2' and sys.version_info[:2] > (3, 10):
     pytest.skip(
-        "Known PySide2 x Python 3.11 incompatibility: "
-        "TypeError: 'PySide2.QtCore.Qt.Alignment' object cannot be interpreted as an integer",
+        "Known PySide2 x Python incompatibility: "
+        "... object cannot be interpreted as an integer",
         allow_module_level=True,
     )
 
+from napari_plugin_manager import qt_plugin_dialog
+from napari_plugin_manager.qt_package_installer import InstallerActions
+
 N_MOCKED_PLUGINS = 2
 
 
@@ -33,11 +37,10 @@ def _iter_napari_pypi_plugin_info(
     This will mock napari.plugins.pypi.iter_napari_plugin_info` for pypi.
 
     It will return two fake plugins that will populate the available plugins
-    list (the bottom one). The first plugin will not be available on
-    conda-forge so will be greyed out ("test-name-0"). The second plugin will
-    be available on conda-forge so will be enabled ("test-name-1").
+    list (the bottom one).
     """
     # This mock `base_data`` will be the same for both fake plugins.
+    packages = ['pyzenhub', 'requests', 'my-plugin', 'my-test-old-plugin-1']
     base_data = {
         "metadata_version": "1.0",
         "version": "0.1.0",
@@ -46,28 +49,31 @@ def _iter_napari_pypi_plugin_info(
         "author": "test author",
         "license": "UNKNOWN",
     }
-    for i in range(N_MOCKED_PLUGINS):
-        yield npe2.PackageMetadata(name=f"test-name-{i}", **base_data), bool(
+    for i in range(len(packages)):
+        yield npe2.PackageMetadata(name=f"{packages[i]}", **base_data), bool(
             i
         ), {
             "home_page": 'www.mywebsite.com',
-            "pypi_versions": ['3'],
-            "conda_versions": ['4.5'],
+            "pypi_versions": ['2.31.0'],
+            "conda_versions": ['2.32.1'],
+            'display_name': packages[i].upper(),
         }
 
 
 class PluginsMock:
     def __init__(self):
         self.plugins = {
-            'test-name-0': True,
-            'test-name-1': True,
+            'requests': True,
+            'pyzenhub': True,
             'my-plugin': True,
         }
 
 
 class OldPluginsMock:
     def __init__(self):
-        self.plugins = [('test-1', False, 'test-1')]
+        self.plugins = [
+            ('my-test-old-plugin-1', False, 'my-test-old-plugin-1')
+        ]
         self.enabled = [True]
 
 
@@ -85,6 +91,9 @@ class WarnPopupMock:
     def __init__(self, text):
         self._is_visible = False
 
+    def show(self):
+        self._is_visible = True
+
     def exec_(self):
         self._is_visible = True
 
@@ -97,6 +106,9 @@ class WarnPopupMock:
     def close(self):
         self._is_visible = False
 
+    def width(self):
+        return 100
+
 
 @pytest.fixture(params=[True, False], ids=["constructor", "no-constructor"])
 def plugin_dialog(
@@ -177,7 +189,10 @@ def plugin_dialog(
     monkeypatch.setattr(
         qt_plugin_dialog, "running_as_constructor_app", lambda: request.param
     )
-
+    monkeypatch.setattr(
+        qt_plugin_dialog, "IS_NAPARI_CONDA_INSTALLED", request.param
+    )
+    monkeypatch.setattr(qt_plugin_dialog, "ON_BUNDLE", request.param)
     monkeypatch.setattr(
         napari.plugins, 'plugin_manager', OldPluginManagerMock()
     )
@@ -187,6 +202,7 @@ def plugin_dialog(
     monkeypatch.setattr(npe2, 'PluginManager', PluginManagerMock())
 
     widget = qt_plugin_dialog.QtPluginDialog()
+    # monkeypatch.setattr(widget, '_tag_outdated_plugins', lambda: None)
     widget.show()
     qtbot.waitUntil(widget.isVisible, timeout=300)
 
@@ -201,17 +217,15 @@ def plugin_dialog(
     assert not widget._add_items_timer.isActive()
 
 
-def test_filter_not_available_plugins(plugin_dialog):
+def test_filter_not_available_plugins(request, plugin_dialog):
     """
     Check that the plugins listed under available plugins are
     enabled and disabled accordingly.
-
-    The first plugin ("test-name-0") is not available on conda-forge and
-    should be disabled, and show a tooltip warning.
-
-    The second plugin ("test-name-1") is available on conda-forge and
-    should be enabled without the tooltip warning.
     """
+    if "no-constructor" in request.node.name:
+        pytest.skip(
+            reason="This test is only relevant for constructor-based installs"
+        )
     item = plugin_dialog.available_list.item(0)
     widget = plugin_dialog.available_list.itemWidget(item)
     if widget:
@@ -231,14 +245,14 @@ def test_filter_available_plugins(plugin_dialog):
     """
     plugin_dialog.filter("")
     assert plugin_dialog.available_list.count() == 2
-    assert plugin_dialog.available_list._count_visible() == 2
+    assert plugin_dialog.available_list.count_visible() == 2
 
     plugin_dialog.filter("no-match@123")
-    assert plugin_dialog.available_list._count_visible() == 0
+    assert plugin_dialog.available_list.count_visible() == 0
 
     plugin_dialog.filter("")
-    plugin_dialog.filter("test-name-0")
-    assert plugin_dialog.available_list._count_visible() == 1
+    plugin_dialog.filter("requests")
+    assert plugin_dialog.available_list.count_visible() == 1
 
 
 def test_filter_installed_plugins(plugin_dialog):
@@ -247,10 +261,10 @@ def test_filter_installed_plugins(plugin_dialog):
     list (the top one).
     """
     plugin_dialog.filter("")
-    assert plugin_dialog.installed_list._count_visible() >= 0
+    assert plugin_dialog.installed_list.count_visible() >= 0
 
     plugin_dialog.filter("no-match@123")
-    assert plugin_dialog.installed_list._count_visible() == 0
+    assert plugin_dialog.installed_list.count_visible() == 0
 
 
 def test_visible_widgets(request, plugin_dialog):
@@ -258,26 +272,29 @@ def test_visible_widgets(request, plugin_dialog):
     Test that the direct entry button and textbox are visible
     """
     if "no-constructor" not in request.node.name:
-        # the plugin_dialog fixture has this id
-        # skip for 'constructor' variant
-        pytest.skip()
+        pytest.skip(
+            reason="Tested functionality not available in constructor-based installs"
+        )
     assert plugin_dialog.direct_entry_edit.isVisible()
     assert plugin_dialog.direct_entry_btn.isVisible()
 
 
-def test_version_dropdown(qtbot, plugin_dialog):
+def test_version_dropdown(plugin_dialog, qtbot):
     """
     Test that when the source drop down is changed, it displays the other versions properly.
     """
-    widget = plugin_dialog.available_list.item(1).widget
-    assert widget.version_choice_dropdown.currentText() == "3"
-    # switch from PyPI source to conda one.
-    widget.source_choice_dropdown.setCurrentIndex(1)
-    assert widget.version_choice_dropdown.currentText() == "4.5"
+    # qtbot.wait(10000)
+    widget = plugin_dialog.available_list.item(0).widget
+    count = widget.version_choice_dropdown.count()
+    if count == 2:
+        assert widget.version_choice_dropdown.currentText() == "2.31.0"
+        # switch from PyPI source to conda one.
+        widget.source_choice_dropdown.setCurrentIndex(1)
+        assert widget.version_choice_dropdown.currentText() == "2.32.1"
 
 
 def test_plugin_list_count_items(plugin_dialog):
-    assert plugin_dialog.installed_list._count_visible() == 2
+    assert plugin_dialog.installed_list.count_visible() == 2
 
 
 def test_plugin_list_handle_action(plugin_dialog, qtbot):
@@ -285,7 +302,7 @@ def test_plugin_list_handle_action(plugin_dialog, qtbot):
     with patch.object(qt_plugin_dialog.PluginListItem, "set_busy") as mock:
         plugin_dialog.installed_list.handle_action(
             item,
-            'test-name-1',
+            'my-test-old-plugin-1',
             InstallerActions.UPGRADE,
         )
         mock.assert_called_with(
@@ -295,16 +312,17 @@ def test_plugin_list_handle_action(plugin_dialog, qtbot):
     with patch.object(qt_plugin_dialog.WarnPopup, "exec_") as mock:
         plugin_dialog.installed_list.handle_action(
             item,
-            'test-name-1',
+            'my-test-old-plugin-1',
             InstallerActions.UNINSTALL,
         )
         assert mock.called
 
     item = plugin_dialog.available_list.item(0)
     with patch.object(qt_plugin_dialog.PluginListItem, "set_busy") as mock:
+
         plugin_dialog.available_list.handle_action(
             item,
-            'test-name-1',
+            'my-test-old-plugin-1',
             InstallerActions.INSTALL,
             version='3',
         )
@@ -313,17 +331,10 @@ def test_plugin_list_handle_action(plugin_dialog, qtbot):
         )
 
         plugin_dialog.available_list.handle_action(
-            item, 'test-name-1', InstallerActions.CANCEL, version='3'
-        )
-        mock.assert_called_with(
-            trans._("cancelling..."), InstallerActions.CANCEL
+            item, 'my-test-old-plugin-1', InstallerActions.CANCEL, version='3'
         )
+        mock.assert_called_with("", InstallerActions.CANCEL)
 
-    # Wait for refresh timer, state and worker to be done
-    qtbot.waitUntil(
-        lambda: not plugin_dialog._add_items_timer.isActive()
-        and plugin_dialog.refresh_state == qt_plugin_dialog.RefreshState.DONE
-    )
     qtbot.waitUntil(lambda: not plugin_dialog.worker.is_running)
 
 
@@ -347,8 +358,12 @@ def test_on_enabled_checkbox(plugin_dialog, qtbot, plugins, old_plugins):
     assert old_plugins.enabled[0] is False
 
 
-def test_add_items_outdated(plugin_dialog):
-    """Test that a plugin is tagged as outdated (a newer version is available), the update button becomes visible."""
+def test_add_items_outdated_and_update(plugin_dialog, qtbot):
+    """
+    Test that a plugin is tagged as outdated (a newer version is available), the update button becomes visible.
+
+    Also check that after doing an update the update button gets hidden.
+    """
 
     # The plugin is being added to the available plugins list.  When the dialog is being built
     # this one will be listed as available, and it will be found as already installed.
@@ -360,15 +375,209 @@ def test_add_items_outdated(plugin_dialog):
         True,
         {
             "home_page": 'www.mywebsite.com',
-            "pypi_versions": ['0.4.0'],
-            "conda_versions": ['0.4.0'],
+            "pypi_versions": ['0.4.0', '0.1.0'],
+            "conda_versions": ['0.4.0', '0.1.0'],
         },
     )
-
-    plugin_dialog._plugin_data = [new_plugin]
-
+    plugin_dialog._plugin_data_map["my-plugin"] = new_plugin
+    plugin_dialog._plugin_queue = [new_plugin]
     plugin_dialog._add_items()
     item = plugin_dialog.installed_list.item(0)
     widget = plugin_dialog.installed_list.itemWidget(item)
-
+    initial_version = "0.1.0"
+    mod_initial_version = initial_version.replace('.', '․')  # noqa: RUF001
     assert widget.update_btn.isVisible()
+    assert widget.version.text() == mod_initial_version
+    assert widget.version.toolTip() == initial_version
+
+    # Trigger process finished handler to simulated that an update was done
+    plugin_dialog._on_process_finished(
+        {
+            'exit_code': 1,
+            'exit_status': 0,
+            'action': InstallerActions.UPGRADE,
+            'pkgs': ['my-plugin==0.4.0'],
+        }
+    )
+    updated_version = "0.4.0"
+    mod_updated_version = updated_version.replace('.', '․')  # noqa: RUF001
+    assert not widget.update_btn.isVisible()
+    assert widget.version.text() == mod_updated_version
+    assert widget.version.toolTip() == updated_version
+
+
+@pytest.mark.skipif(
+    qtpy.API_NAME.lower().startswith('pyside')
+    and sys.version_info[:2] > (3, 10)
+    and platform.system() == "Darwin",
+    reason='pyside specific bug',
+)
+def test_refresh(qtbot, plugin_dialog):
+    with qtbot.waitSignal(plugin_dialog._add_items_timer.timeout, timeout=500):
+        plugin_dialog.refresh(clear_cache=False)
+
+    with qtbot.waitSignal(plugin_dialog._add_items_timer.timeout, timeout=500):
+        plugin_dialog.refresh(clear_cache=True)
+
+    with qtbot.waitSignal(plugin_dialog._add_items_timer.timeout, timeout=500):
+        plugin_dialog._refresh_and_clear_cache()
+
+
+@pytest.mark.skipif(
+    qtpy.API_NAME.lower().startswith('pyside')
+    and sys.version_info[:2] > (3, 10)
+    and platform.system() == "Darwin",
+    reason='pyside specific bug',
+)
+def test_toggle_status(plugin_dialog):
+    plugin_dialog.toggle_status(True)
+    assert plugin_dialog.stdout_text.isVisible()
+    plugin_dialog.toggle_status(False)
+    assert not plugin_dialog.stdout_text.isVisible()
+
+
+@pytest.mark.skipif(
+    qtpy.API_NAME.lower().startswith('pyside')
+    and sys.version_info[:2] > (3, 10)
+    and platform.system() == "Darwin",
+    reason='pyside specific bug',
+)
+def test_exec(plugin_dialog):
+    plugin_dialog.exec_()
+
+
+@pytest.mark.skipif(
+    qtpy.API_NAME.lower().startswith('pyside')
+    and sys.version_info[:2] > (3, 10)
+    and platform.system() == "Darwin",
+    reason='pyside specific bug',
+)
+def test_search_in_available(plugin_dialog):
+    idxs = plugin_dialog._search_in_available("test")
+    assert idxs == [0, 1, 2, 3]
+    idxs = plugin_dialog._search_in_available("*&%$")
+    assert idxs == []
+
+
+def test_drop_event(plugin_dialog, tmp_path):
+    path_1 = tmp_path / "example-1.txt"
+    path_2 = tmp_path / "example-2.txt"
+    url_prefix = 'file:///' if os.name == 'nt' else 'file://'
+    data = QMimeData()
+    data.setUrls(
+        [QUrl(f'{url_prefix}{path_1}'), QUrl(f'{url_prefix}{path_2}')]
+    )
+    event = QDropEvent(
+        QPointF(5.0, 5.0), Qt.CopyAction, data, Qt.LeftButton, Qt.NoModifier
+    )
+    plugin_dialog.dropEvent(event)
+    assert plugin_dialog.direct_entry_edit.text() == str(path_1)
+
+
+@pytest.mark.skipif(
+    qtpy.API_NAME.lower().startswith('pyside'), reason='pyside specific bug'
+)
+def test_installs(qtbot, tmp_virtualenv, plugin_dialog, request):
+    if "[constructor]" in request.node.name:
+        pytest.skip(
+            reason="This test is only relevant for constructor-based installs"
+        )
+
+    plugin_dialog.set_prefix(str(tmp_virtualenv))
+    item = plugin_dialog.available_list.item(1)
+    widget = plugin_dialog.available_list.itemWidget(item)
+    with qtbot.waitSignal(
+        plugin_dialog.installer.processFinished, timeout=60_000
+    ) as blocker:
+        widget.action_button.click()
+
+    process_finished_data = blocker.args[0]
+    assert process_finished_data['action'] == InstallerActions.INSTALL
+    assert process_finished_data['pkgs'][0].startswith("requests")
+    qtbot.wait(5000)
+
+
+@pytest.mark.skipif(
+    qtpy.API_NAME.lower().startswith('pyside'), reason='pyside specific bug'
+)
+def test_cancel(qtbot, tmp_virtualenv, plugin_dialog, request):
+    if "[constructor]" in request.node.name:
+        pytest.skip(
+            reason="This test is only relevant for constructor-based installs"
+        )
+
+    plugin_dialog.set_prefix(str(tmp_virtualenv))
+    item = plugin_dialog.available_list.item(1)
+    widget = plugin_dialog.available_list.itemWidget(item)
+    with qtbot.waitSignal(
+        plugin_dialog.installer.processFinished, timeout=60_000
+    ) as blocker:
+        widget.action_button.click()
+        widget.cancel_btn.click()
+
+    process_finished_data = blocker.args[0]
+    assert process_finished_data['action'] == InstallerActions.CANCEL
+    assert process_finished_data['pkgs'][0].startswith("requests")
+    assert plugin_dialog.available_list.count() == 2
+    assert plugin_dialog.installed_list.count() == 2
+
+
+@pytest.mark.skipif(
+    qtpy.API_NAME.lower().startswith('pyside'), reason='pyside specific bug'
+)
+def test_cancel_all(qtbot, tmp_virtualenv, plugin_dialog, request):
+    if "[constructor]" in request.node.name:
+        pytest.skip(
+            reason="This test is only relevant for constructor-based installs"
+        )
+
+    plugin_dialog.set_prefix(str(tmp_virtualenv))
+    item_1 = plugin_dialog.available_list.item(0)
+    item_2 = plugin_dialog.available_list.item(1)
+    widget_1 = plugin_dialog.available_list.itemWidget(item_1)
+    widget_2 = plugin_dialog.available_list.itemWidget(item_2)
+    with qtbot.waitSignal(plugin_dialog.installer.allFinished, timeout=60_000):
+        widget_1.action_button.click()
+        widget_2.action_button.click()
+        plugin_dialog.cancel_all_btn.click()
+
+    assert plugin_dialog.available_list.count() == 2
+    assert plugin_dialog.installed_list.count() == 2
+
+
+@pytest.mark.skipif(
+    qtpy.API_NAME.lower().startswith('pyside'), reason='pyside specific bug'
+)
+def test_direct_entry_installs(qtbot, tmp_virtualenv, plugin_dialog, request):
+    if "[constructor]" in request.node.name:
+        pytest.skip(
+            reason="This test is only relevant for constructor-based installs"
+        )
+
+    plugin_dialog.set_prefix(str(tmp_virtualenv))
+    with qtbot.waitSignal(
+        plugin_dialog.installer.processFinished, timeout=60_000
+    ) as blocker:
+        plugin_dialog.direct_entry_edit.setText('requests')
+        plugin_dialog.direct_entry_btn.click()
+
+    process_finished_data = blocker.args[0]
+    assert process_finished_data['action'] == InstallerActions.INSTALL
+    assert process_finished_data['pkgs'][0].startswith("requests")
+    qtbot.wait(5000)
+
+
+def test_shortcut_close(plugin_dialog, qtbot):
+    qtbot.keyClicks(
+        plugin_dialog, 'W', modifier=Qt.KeyboardModifier.ControlModifier
+    )
+    qtbot.wait(200)
+    assert not plugin_dialog.isVisible()
+
+
+def test_shortcut_quit(plugin_dialog, qtbot):
+    qtbot.keyClicks(
+        plugin_dialog, 'Q', modifier=Qt.KeyboardModifier.ControlModifier
+    )
+    qtbot.wait(200)
+    assert not plugin_dialog.isVisible()

napari_plugin_manager/_tests/test_utils.py

@@ -0,0 +1,27 @@
+import sys
+from unittest.mock import patch
+
+import pytest
+
+from napari_plugin_manager.utils import is_conda_package
+
+
+@pytest.mark.parametrize(
+    "pkg_name,expected",
+    [
+        ("some-package", True),
+        ("some-other-package", False),
+        ("some-package-other", False),
+        ("other-some-package", False),
+        ("package", False),
+        ("some", False),
+    ],
+)
+def test_is_conda_package(pkg_name, expected, tmp_path):
+    mocked_conda_meta = tmp_path / 'conda-meta'
+    mocked_conda_meta.mkdir()
+    mocked_package = mocked_conda_meta / 'some-package-0.1.1-0.json'
+    mocked_package.touch()
+
+    with patch.object(sys, 'prefix', tmp_path):
+        assert is_conda_package(pkg_name) is expected

napari_plugin_manager/_version.py

@@ -1,4 +1,16 @@
 # file generated by setuptools_scm
 # don't change, don't track in version control
-__version__ = version = '0.1.0a2'
-__version_tuple__ = version_tuple = (0, 1, 0)
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple, Union
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '0.1.2'
+__version_tuple__ = version_tuple = (0, 1, 2)

napari_plugin_manager/npe2api.py

@@ -0,0 +1,131 @@
+"""
+These convenience functions will be useful for searching pypi for packages
+that match the plugin naming convention, and retrieving related metadata.
+"""
+
+import json
+from collections.abc import Iterator
+from concurrent.futures import ThreadPoolExecutor
+from functools import lru_cache
+from typing import (
+    Optional,
+    TypedDict,
+    cast,
+)
+from urllib.error import HTTPError, URLError
+from urllib.request import Request, urlopen
+
+from napari.plugins.utils import normalized_name
+from napari.utils.notifications import show_warning
+from npe2 import PackageMetadata
+from typing_extensions import NotRequired
+
+PyPIname = str
+
+
+@lru_cache
+def _user_agent() -> str:
+    """Return a user agent string for use in http requests."""
+    import platform
+
+    from napari import __version__
+    from napari.utils import misc
+
+    if misc.running_as_constructor_app():
+        env = 'constructor'
+    elif misc.in_jupyter():
+        env = 'jupyter'
+    elif misc.in_ipython():
+        env = 'ipython'
+    else:
+        env = 'python'
+
+    parts = [
+        ('napari', __version__),
+        ('runtime', env),
+        (platform.python_implementation(), platform.python_version()),
+        (platform.system(), platform.release()),
+    ]
+    return ' '.join(f'{k}/{v}' for k, v in parts)
+
+
+class _ShortSummaryDict(TypedDict):
+    """Objects returned at https://npe2api.vercel.app/api/extended_summary ."""
+
+    name: NotRequired[PyPIname]
+    version: str
+    summary: str
+    author: str
+    license: str
+    home_page: str
+
+
+class SummaryDict(_ShortSummaryDict):
+    display_name: NotRequired[str]
+    pypi_versions: NotRequired[list[str]]
+    conda_versions: NotRequired[list[str]]
+
+
+@lru_cache
+def plugin_summaries() -> list[SummaryDict]:
+    """Return PackageMetadata object for all known napari plugins."""
+    url = 'https://npe2api.vercel.app/api/extended_summary'
+    with urlopen(Request(url, headers={'User-Agent': _user_agent()})) as resp:
+        return json.load(resp)
+
+
+@lru_cache
+def conda_map() -> dict[PyPIname, Optional[str]]:
+    """Return map of PyPI package name to conda_channel/package_name ()."""
+    url = 'https://npe2api.vercel.app/api/conda'
+    with urlopen(Request(url, headers={'User-Agent': _user_agent()})) as resp:
+        return json.load(resp)
+
+
+def iter_napari_plugin_info() -> Iterator[tuple[PackageMetadata, bool, dict]]:
+    """Iterator of tuples of ProjectInfo, Conda availability for all napari plugins."""
+    try:
+        with ThreadPoolExecutor() as executor:
+            data = executor.submit(plugin_summaries)
+            _conda = executor.submit(conda_map)
+
+        conda = _conda.result()
+        data_set = data.result()
+    except (HTTPError, URLError):
+        show_warning(
+            'Plugin manager: There seems to be an issue with network connectivity. '
+            'Remote plugins cannot be installed, only local ones.\n'
+        )
+        return
+
+    conda_set = {normalized_name(x) for x in conda}
+    for info in data_set:
+        info_copy = dict(info)
+        info_copy.pop('display_name', None)
+        pypi_versions = info_copy.pop('pypi_versions')
+        conda_versions = info_copy.pop('conda_versions')
+        info_ = cast(_ShortSummaryDict, info_copy)
+
+        # TODO: use this better.
+        # this would require changing the api that qt_plugin_dialog expects to
+        # receive
+
+        # TODO: once the new version of npe2 is out, this can be refactored
+        # to all the metadata includes the conda and pypi versions.
+        extra_info = {
+            'home_page': info_.get('home_page', ''),
+            'display_name': info.get('display_name', ''),
+            'pypi_versions': pypi_versions,
+            'conda_versions': conda_versions,
+        }
+        info_['name'] = normalized_name(info_['name'])
+        meta = PackageMetadata(**info_)  # type:ignore[call-arg]
+
+        yield meta, (info_['name'] in conda_set), extra_info
+
+
+def cache_clear():
+    """Clear the cache for all cached functions in this module."""
+    plugin_summaries.cache_clear()
+    conda_map.cache_clear()
+    _user_agent.cache_clear()