lerna 2.0.2__tar.gz → 2.0.4__tar.gz

{lerna-2.0.2 → lerna-2.0.4}/.gitignore

@@ -11,6 +11,9 @@ __pycache__/
 *.exp
 *.lib
 
+# Rust
+target
+
 # Distribution / packaging
 .Python
 build/
@@ -55,26 +58,12 @@ junit.xml
 .hypothesis/
 .pytest_cache/
 
-# Translations
-*.mo
-*.pot
-
-# Django stuff:
+# Django
 *.log
 local_settings.py
 db.sqlite3
 db.sqlite3-journal
 
-# Flask stuff:
-instance/
-.webassets-cache
-
-# Scrapy stuff:
-.scrapy
-
-# PyBuilder
-target/
-
 # IPython
 profile_default/
 ipython_config.py
@@ -85,15 +74,12 @@ ipython_config.py
 # pipenv
 Pipfile.lock
 
-# PEP 582; used by e.g. github.com/David-OConnor/pyflow
-__pypackages__/
-
-# Celery stuff
+# Celery
 celerybeat-schedule
 celerybeat.pid
 
-# SageMath parsed files
-*.sage.py
+# Airspeed Velocity
+.asv
 
 # Environments
 .env
@@ -161,3 +147,8 @@ target
 # Hydra
 outputs/
 multirun/
+
+# AI
+ROADMAP.md
+AGENTS.md
+.github/hooks/sdlc.json

{lerna-2.0.2 → lerna-2.0.4}/Cargo.lock

@@ -59,7 +59,7 @@ dependencies = [
 
 [[package]]
 name = "lerna"
-version = "2.0.2"
+version = "2.0.4"
 dependencies = [
  "rand",
  "serde",
@@ -68,7 +68,7 @@ dependencies = [
 
 [[package]]
 name = "lerna_py"
-version = "2.0.2"
+version = "2.0.4"
 dependencies = [
  "lerna",
  "pyo3",

{lerna-2.0.2 → lerna-2.0.4}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "lerna_py"
-version = "2.0.2"
+version = "2.0.4"
 edition = "2021"
 publish = false
 

{lerna-2.0.2 → lerna-2.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lerna
-Version: 2.0.2
+Version: 2.0.4
 Summary: Lerna is a framework for elegantly configuring complex applications
 Project-URL: Repository, https://github.com/1kbgz/lerna
 Project-URL: Homepage, https://github.com/1kbgz/lerna
@@ -351,6 +351,10 @@ my-plugin = "my_package.plugin_module"
 # For package-style config directories:
 [project.entry-points."hydra.lernaplugins"]
 my-plugin = "pkg:my_package.hydra"
+
+# If only using lerna, you can also register under lerna.plugins:
+[project.entry-points."lerna.plugins"]
+my-plugin = "my_package.plugin_module"
 ```
 
 **Module-style entry points** (like `my_package.plugin_module`) are imported and scanned for `SearchPathPlugin` subclasses.

{lerna-2.0.2 → lerna-2.0.4}/README.md

@@ -307,6 +307,10 @@ my-plugin = "my_package.plugin_module"
 # For package-style config directories:
 [project.entry-points."hydra.lernaplugins"]
 my-plugin = "pkg:my_package.hydra"
+
+# If only using lerna, you can also register under lerna.plugins:
+[project.entry-points."lerna.plugins"]
+my-plugin = "my_package.plugin_module"
 ```
 
 **Module-style entry points** (like `my_package.plugin_module`) are imported and scanned for `SearchPathPlugin` subclasses.

{lerna-2.0.2 → lerna-2.0.4}/hydra_plugins/lerna/searchpath.py

@@ -11,7 +11,6 @@ work with hydra-core installations.
 """
 
 import sys
-import warnings
 from importlib import import_module
 
 from hydra.core.config_search_path import ConfigSearchPath
@@ -25,7 +24,8 @@ else:
 
 # NOTE: use `lernaplugins` instead of `plugins`
 # for https://github.com/facebookresearch/hydra/pull/3052
-_discovered_plugins = entry_points(group="hydra.lernaplugins")
+_discovered_plugins = list(entry_points(group="hydra.lernaplugins"))
+_discovered_plugins.extend(list(entry_points(group="lerna.plugins")))
 _searchpaths_pkg = {}
 _discovered_plugin_names = []
 for entry_point in _discovered_plugins:
@@ -37,10 +37,9 @@ for entry_point in _discovered_plugins:
     # Otherwise, it's a module style entry point
     try:
         mod = import_module(entry_point.value)
-    except ImportError as e:
-        # Use warnings instead of logging during module import to avoid
-        # issues with logging handlers that may be in an invalid state
-        warnings.warn(f"Failed to import entry point {entry_point.name} from {entry_point.value}: {e}")
+    except ImportError:
+        # Silently skip entry points that fail to import. These are optional
+        # third-party plugins and their absence should not disrupt the system.
         continue
     for attr in dir(mod):
         thing = getattr(mod, attr)

{lerna-2.0.2 → lerna-2.0.4}/lerna/__init__.py

@@ -1,7 +1,7 @@
 # Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
 
 # Source of truth for Lerna's version (Hydra-compatible API)
-__version__ = "2.0.2"
+__version__ = "2.0.4"
 
 # Callback support from Rust
 from lerna import lerna as _rust, utils

{lerna-2.0.2 → lerna-2.0.4}/lerna/_internal/core_plugins/file_config_source.py

@@ -51,12 +51,14 @@ class FileConfigSource(ConfigSource):
                     cfg = OmegaConf.create(raw_config)
                 except Exception:
                     # Fall back to Python YAML parser on errors
-                    raw = yaml.safe_load(content)
+                    f.seek(0)
+                    raw = yaml.safe_load(f)
                     if raw is None:
                         raw = {}
                     cfg = OmegaConf.create(raw)
             else:
-                raw = yaml.safe_load(content)
+                f.seek(0)
+                raw = yaml.safe_load(f)
                 if raw is None:
                     raw = {}
                 cfg = OmegaConf.create(raw)

{lerna-2.0.2 → lerna-2.0.4}/lerna/core/plugins.py

@@ -3,6 +3,7 @@ import importlib
 import importlib.util
 import inspect
 import pkgutil
+import re
 import sys
 import warnings
 from collections import defaultdict
@@ -23,6 +24,11 @@ from lerna.plugins.sweeper import Sweeper
 from lerna.types import HydraContext, TaskFunction
 from lerna.utils import instantiate
 
+if sys.version_info < (3, 10):
+    from importlib_metadata import entry_points
+else:
+    from importlib.metadata import entry_points
+
 PLUGIN_TYPES: List[Type[Plugin]] = [
     Plugin,
     ConfigSource,
@@ -71,6 +77,7 @@ class Plugins(metaclass=Singleton):
         self.class_name_to_class = {}
 
         scanned_plugins, self.stats = self._scan_all_plugins(modules=top_level)
+        scanned_plugins.extend(_scan_entrypoint_search_path_plugins())
         for clazz in scanned_plugins:
             self._register(clazz)
 
@@ -256,3 +263,94 @@ class Plugins(metaclass=Singleton):
 
 def _is_concrete_plugin_type(obj: Any) -> bool:
     return inspect.isclass(obj) and issubclass(obj, Plugin) and not inspect.isabstract(obj)
+
+
+def _sanitize_entrypoint_name(name: str) -> str:
+    return re.sub(r"[^0-9a-zA-Z_]", "_", name)
+
+
+def _is_pkg_path_available(pkg_path: str) -> bool:
+    """Check whether a pkg:// path refers to an importable Python package."""
+    # Convert path separators to dots for importlib
+    module_path = pkg_path.replace("/", ".")
+    try:
+        spec = importlib.util.find_spec(module_path)
+        return spec is not None
+    except (ModuleNotFoundError, ValueError):
+        return False
+
+
+def _scan_entrypoint_search_path_plugins() -> List[Type[Plugin]]:
+    """
+    Discover SearchPathPlugin classes registered via the ``hydra.lernaplugins``
+    and ``lerna.plugins`` entry-point groups so that they are available when
+    lerna is used directly (without hydra-core).
+
+    Two flavours of entry point are supported:
+
+    * **pkg / file** – value starts with ``pkg:`` or ``file:``.  A dynamic
+      SearchPathPlugin is synthesised that appends the path.  The package is
+      validated first; if it cannot be imported the entry point is silently
+      skipped (avoids warnings under ``-Werror``).
+
+    * **module** – value is a dotted Python module path.  The module is
+      imported and any concrete *lerna* ``SearchPathPlugin`` subclasses found
+      inside are registered.  Hydra-only ``SearchPathPlugin`` subclasses are
+      intentionally skipped here because the hydra bridge plugin
+      (``hydra_plugins.lerna.searchpath``) already handles them.
+    """
+    scanned_plugins: List[Type[Plugin]] = []
+
+    discovered: List[Any] = []
+    for group in ("hydra.lernaplugins", "lerna.plugins"):
+        try:
+            discovered.extend(entry_points(group=group))
+        except TypeError:
+            discovered.extend(entry_points().get(group, []))  # type: ignore[arg-type]
+
+    for entry_point in discovered:
+        if entry_point.value.startswith(("pkg:", "file:")):
+            kind, path = entry_point.value.split(":", 1)
+            entrypoint_path = f"{kind}://{path}"
+            provider = entry_point.name
+
+            # Validate that the package actually exists before registering –
+            # otherwise an unavailable source warning is emitted which turns
+            # into a hard error under ``python -Werror``.
+            if kind == "pkg" and not _is_pkg_path_available(path):
+                continue
+
+            sanitized_name = _sanitize_entrypoint_name(provider)
+
+            def manipulate_search_path(self: Any, search_path: Any, provider: str = provider, entrypoint_path: str = entrypoint_path) -> None:
+                search_path.append(provider=provider, path=entrypoint_path)
+
+            dynamic_plugin = type(
+                f"EntryPointSearchPathPlugin_{sanitized_name}",
+                (SearchPathPlugin,),
+                {
+                    "__module__": __name__,
+                    "manipulate_search_path": manipulate_search_path,
+                },
+            )
+            scanned_plugins.append(dynamic_plugin)
+            continue
+
+        # Module-style entry point
+        try:
+            module = importlib.import_module(entry_point.value)
+        except ImportError as e:
+            warnings.warn(
+                f"Failed to import entry point {entry_point.name} from {entry_point.value}: {e}",
+                category=UserWarning,
+            )
+            continue
+
+        # Only register lerna-native SearchPathPlugin subclasses.
+        # Hydra SearchPathPlugin subclasses are handled by the hydra bridge
+        # (hydra_plugins/lerna/searchpath.py) and should not be double-registered.
+        for _, obj in inspect.getmembers(module):
+            if _is_concrete_plugin_type(obj) and issubclass(obj, SearchPathPlugin):
+                scanned_plugins.append(obj)
+
+    return scanned_plugins

lerna-2.0.4/lerna/tests/test_discover.py

@@ -0,0 +1,89 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
+"""
+Tests for plugin discovery via hydra-core when using lerna plugins.
+
+This tests the bridge functionality that allows plugins registered via lerna's
+entrypoint system (hydra.lernaplugins) to be discovered by hydra-core.
+"""
+
+from pathlib import Path
+from subprocess import check_call
+
+import pytest
+from hydra.core.plugins import Plugins as HydraPlugins
+
+
+@pytest.fixture(scope="module", autouse=True)
+def install_fake_packages():
+    """Install fake test packages that register plugins via entry points."""
+    folder = (Path(__file__).parent / "fake_package").resolve()
+    check_call(["pip", "install", str(folder)])
+
+    folder = (Path(__file__).parent / "fake_package2").resolve()
+    check_call(["pip", "install", str(folder)])
+
+
+class TestSearchpathPlugin:
+    """Tests for the LernaGenericSearchPathPlugin bridge."""
+
+    def test_discover_self(self):
+        """Test that hydra-core can discover lerna's bridge plugin and plugins registered via lerna."""
+        p = HydraPlugins()
+        all_ps = [_.__name__ for _ in p.discover()]
+        # The bridge plugin itself should be discovered
+        assert "LernaGenericSearchPathPlugin" in all_ps
+        # The fake_package plugin (registered via module entry point) should be discovered
+        assert "FakePackageSearchPathPlugin" in all_ps
+        # The fake_package2 (registered via pkg: style entry point) should be in searchpaths
+        import hydra_plugins.lerna.searchpath
+
+        # At least the fake_package2 should be registered
+        assert "fake-package2" in hydra_plugins.lerna.searchpath._searchpaths_pkg
+        assert hydra_plugins.lerna.searchpath._searchpaths_pkg["fake-package2"] == "pkg://fake_package2.hydra"
+
+
+class TestLernaSearchpathEntryPoints:
+    """Tests for lerna-side discovery of entrypoint search path plugins."""
+
+    def test_lerna_skips_unavailable_entrypoint_search_paths(self):
+        """
+        Entrypoint-registered search paths whose packages are not importable
+        (e.g. test fixtures without __init__.py) must be silently skipped so
+        that they don't produce warnings that crash under ``-Werror``.
+        """
+        from lerna._internal.utils import create_config_search_path
+        from lerna.core.plugins import Plugins as LernaPlugins
+        from lerna.core.singleton import Singleton
+
+        Singleton._instances.pop(LernaPlugins, None)
+
+        search_path = create_config_search_path(None)
+        entries = {(entry.provider, entry.path) for entry in search_path.get_path()}
+
+        # fake-package2 has pkg:fake_package2.hydra but fake_package2/hydra has
+        # no __init__.py, so the package is not importable – must be skipped.
+        assert ("fake-package2", "pkg://fake_package2.hydra") not in entries
+
+        # fake-package is a module-style entry point with a hydra-only
+        # SearchPathPlugin.  Lerna intentionally does not wrap hydra plugins
+        # (the bridge handles them), so it must not appear here either.
+        assert ("fake-package", "pkg://fake_package/hydra") not in entries
+
+    def test_lerna_discovers_native_search_path_plugins_from_entrypoints(self):
+        """
+        If a lerna-native SearchPathPlugin is registered via entrypoints,
+        lerna's Plugins system should discover it.
+        """
+        from lerna.core.plugins import Plugins as LernaPlugins
+        from lerna.core.singleton import Singleton
+        from lerna.plugins.search_path_plugin import SearchPathPlugin as LernaSearchPathPlugin
+
+        Singleton._instances.pop(LernaPlugins, None)
+
+        plugins = LernaPlugins.instance()
+        discovered = plugins.discover(LernaSearchPathPlugin)
+        discovered_names = [cls.__name__ for cls in discovered]
+
+        # The hydra-only FakePackageSearchPathPlugin should NOT be in lerna's
+        # discovered list (it doesn't subclass lerna.plugins.SearchPathPlugin).
+        assert "FakePackageSearchPathPlugin" not in discovered_names

{lerna-2.0.2 → lerna-2.0.4}/pyproject.toml

@@ -13,7 +13,7 @@ authors = [
 description = "Lerna is a framework for elegantly configuring complex applications"
 readme = "README.md"
 license = { text = "Apache-2.0" }
-version = "2.0.2"
+version = "2.0.4"
 requires-python = ">=3.10"
 keywords = []
 
@@ -65,7 +65,7 @@ Repository = "https://github.com/1kbgz/lerna"
 Homepage = "https://github.com/1kbgz/lerna"
 
 [tool.bumpversion]
-current_version = "2.0.2"
+current_version = "2.0.4"
 commit = true
 tag = true
 commit_args = "-s"
@@ -121,6 +121,7 @@ branch = true
 omit = [
     "lerna/tests/integration/",
 ]
+
 [tool.coverage.report]
 exclude_also = [
     "raise NotImplementedError",

{lerna-2.0.2 → lerna-2.0.4}/rust/Cargo.lock

@@ -66,7 +66,7 @@ dependencies = [
 
 [[package]]
 name = "lerna"
-version = "2.0.2"
+version = "2.0.4"
 dependencies = [
  "rand",
  "serde",

{lerna-2.0.2 → lerna-2.0.4}/rust/Cargo.toml

@@ -1,12 +1,12 @@
 [package]
 name = "lerna"
-version = "2.0.2"
+version = "2.0.4"
 authors = ["the lerna authors <dev@1kbgz.com>"]
 edition = "2021"
 license = "Apache-2.0"
 readme = "../README.md"
 repository = "https://github.com/1kbgz/lerna"
-description = ""
+description = "Lerna is a framework for elegantly configuring complex applications"
 
 [lib]
 name = "lerna"