feat(launcher): update _plugins.py

Author: jorgepiloto

src/ansys/tools/common/launcher/_plugins.py

@@ -24,59 +24,86 @@
 
 import importlib.metadata
 from importlib.metadata import entry_points
-from typing import Any
+from functools import lru_cache
+from typing import Any, Type
 
 from .interface import FALLBACK_LAUNCH_MODE_NAME, DataclassProtocol, LauncherProtocol
 
 LAUNCHER_ENTRY_POINT = "ansys.tools.local_product_launcher.launcher"
 
 
 def get_launcher(*, product_name: str, launch_mode: str) -> type[LauncherProtocol[DataclassProtocol]]:
-    """Get the launcher plugin for a given product and launch mode."""
+    """Get the launcher plugin class for a given product and launch mode."""
     ep_name = f"{product_name}.{launch_mode}"
     for entrypoint in _get_entry_points():
         if entrypoint.name == ep_name:
             return entrypoint.load()  # type: ignore
-    else:
-        raise KeyError(f"No plugin found for '{ep_name}'.")
+    raise KeyError(f"No plugin found for '{ep_name}'.")
 
 
 def get_config_model(*, product_name: str, launch_mode: str) -> type[DataclassProtocol]:
-    """Get the configuration model for a given product and launch mode."""
+    """Get the configuration model class for a given product and launch mode."""
     return get_launcher(product_name=product_name, launch_mode=launch_mode).CONFIG_MODEL
 
 
-def get_all_plugins(hide_fallback: bool = True) -> dict[str, dict[str, LauncherProtocol[Any]]]:
-    """Get mapping {"<product_name>": {"<launch_mode>": Launcher}} containing all plugins."""
-    res: dict[str, dict[str, LauncherProtocol[Any]]] = dict()
+def get_all_plugins(hide_fallback: bool = True) -> dict[str, dict[str, type[LauncherProtocol[Any]]]]:
+    """Get mapping {"<product_name>": {"<launch_mode>": LauncherClass}} containing all launcher plugins.
+
+    Parameters
+    ----------
+    hide_fallback : bool, default=True
+        If True, skip launch modes marked as fallback.
+
+    Returns
+    -------
+    dict[str, dict[str, type[LauncherProtocol[Any]]]]
+        Mapping of product names to launch mode to launcher classes.
+    """
+    res: dict[str, dict[str, type[LauncherProtocol[Any]]]] = dict()
     for entry_point in _get_entry_points():
-        product_name, launch_mode = entry_point.name.split(".")
+        try:
+            product_name, launch_mode = entry_point.name.split(".")
+        except ValueError:
+            # skip malformed entry point names
+            continue
+
         if hide_fallback and launch_mode == FALLBACK_LAUNCH_MODE_NAME:
             continue
+
+        try:
+            launcher_class = entry_point.load()  # type: ignore
+        except Exception:
+            # skip broken plugins
+            continue
+
         res.setdefault(product_name, dict())
-        res[product_name][launch_mode] = entry_point.load()
+        res[product_name][launch_mode] = launcher_class
+
     return res
 
 
 def has_fallback(product_name: str) -> bool:
-    """Return ``True`` if the given product has a fallback launcher."""
+    """Return True if the given product has a fallback launcher."""
     for entry_point in _get_entry_points():
-        ep_product_name, ep_launch_mode = entry_point.name.split(".")
+        try:
+            ep_product_name, ep_launch_mode = entry_point.name.split(".")
+        except ValueError:
+            continue
         if product_name == ep_product_name and ep_launch_mode == FALLBACK_LAUNCH_MODE_NAME:
             return True
     return False
 
 
 def get_fallback_launcher(product_name: str) -> type[LauncherProtocol[DataclassProtocol]]:
-    """Get the fallback launcher for a given product."""
+    """Get the fallback launcher plugin class for a given product."""
     ep_name = f"{product_name}.{FALLBACK_LAUNCH_MODE_NAME}"
     for entrypoint in _get_entry_points():
         if entrypoint.name == ep_name:
             return entrypoint.load()  # type: ignore
-    else:
-        raise KeyError(f"No fallback plugin found for '{product_name}'.")
+    raise KeyError(f"No plugin found for '{ep_name}'.")
 
 
+@lru_cache
 def _get_entry_points() -> tuple[importlib.metadata.EntryPoint, ...]:
     """Get all Local Product Launcher plugin entrypoints for launchers."""
     try: