Fix regression when using old CLI and inferring components from the local context (#676)

Author: mauvilsa

CHANGELOG.rst

@@ -34,6 +34,8 @@ Fixed
 - String parsing regressions (`#673
   <https://github.com/omni-us/jsonargparse/pull/673>`__, `#674
   <https://github.com/omni-us/jsonargparse/pull/674>`__).
+- Regression when using old ``CLI`` and inferring components from the local
+  context (`#676 <https://github.com/omni-us/jsonargparse/pull/676>`__).
 
 
 v4.36.0 (2025-01-17)

jsonargparse/_cli.py

@@ -41,7 +41,7 @@ def auto_cli(
     arguments and runs one of the functions or class methods depending on what
     was parsed. If the 'components' parameter is not given, then the components
     will be all the locals in the context and defined in the same module as from
-    where CLI is called.
+    where auto_cli is called.
 
     Args:
         components: One or more functions/classes to include in the command line interface.
@@ -58,14 +58,12 @@ def auto_cli(
     """
     return_parser = kwargs.pop("return_parser", False)
     stacklevel = kwargs.pop("_stacklevel", 2)
-    caller = inspect.stack()[1][0]
 
     if components is None:
-        module = inspect.getmodule(caller).__name__  # type: ignore[union-attr]
+        caller = inspect.stack()[stacklevel - 1][0]
+        module = inspect.getmodule(caller)
         components = [
-            v
-            for v in caller.f_locals.values()
-            if ((inspect.isclass(v) or callable(v)) and getattr(inspect.getmodule(v), "__name__", None) == module)
+            v for v in vars(module).values() if ((inspect.isclass(v) or callable(v)) and inspect.getmodule(v) is module)
         ]
         if len(components) == 0:
             raise ValueError(

jsonargparse_tests/test_cli.py

@@ -4,10 +4,12 @@
 import json
 import os
 import sys
-from contextlib import redirect_stderr, redirect_stdout, suppress
+from contextlib import contextmanager, redirect_stderr, redirect_stdout, suppress
 from dataclasses import asdict, dataclass
+from inspect import getmodule as inspect_getmodule
 from io import StringIO
 from pathlib import Path
+from types import ModuleType
 from typing import Callable, Literal, Optional
 from unittest.mock import patch
 
@@ -29,10 +31,11 @@ def get_cli_stdout(*args, **kwargs) -> str:
 # failure cases
 
 
+@pytest.mark.parametrize("cli_fn", [CLI, auto_cli])
 @pytest.mark.parametrize("components", [0, [], {"x": 0}])
-def test_unexpected_components(components):
+def test_unexpected_components(cli_fn, components):
     with pytest.raises(ValueError):
-        auto_cli(components)
+        cli_fn(components)
 
 
 class ConflictingSubcommandKey:
@@ -340,40 +343,63 @@ def test_function_and_class_function_without_parameters():
 # automatic components tests
 
 
-def test_automatic_components_empty_context():
+@contextmanager
+def mock_getmodule_locals(parent_fn, locals_list=[]):
+    module_name = "_" + parent_fn.__name__
+
+    mock_module = ModuleType(module_name)
+    for obj in locals_list + [CLI, auto_cli]:
+        setattr(mock_module, obj.__name__, obj)
+    sys.modules[module_name] = mock_module
+
+    for obj in locals_list:
+        obj.__module__ = module_name
+
+    def patched_getmodule(obj, *args):
+        if obj in locals_list or (parent_fn.__name__ in str(obj)):
+            return mock_module
+        return inspect_getmodule(obj, *args)
+
+    with patch("inspect.getmodule", side_effect=patched_getmodule):
+        yield
+        del sys.modules[module_name]
+
+
+@pytest.mark.parametrize("cli_fn", [CLI, auto_cli])
+def test_automatic_components_empty_context(cli_fn):
     def empty_context():
-        auto_cli()
+        cli_fn()
 
-    with patch("inspect.getmodule") as mock_getmodule:
-        mock_getmodule.return_value = sys.modules["jsonargparse._core"]
-        pytest.raises(ValueError, empty_context)
+    with mock_getmodule_locals(empty_context):
+        with pytest.raises(ValueError, match="Either components parameter must be given or"):
+            empty_context()
 
 
-def test_automatic_components_context_function():
-    def non_empty_context_function():
-        def function(a1: float):
-            return a1
+@pytest.mark.parametrize("cli_fn", [CLI, auto_cli])
+def test_automatic_components_context_function(cli_fn):
+    def function(a1: float):
+        return a1
 
-        return auto_cli(args=["6.7"])
+    def non_empty_context_function():
+        return cli_fn(args=["6.7"])
 
-    with patch("inspect.getmodule") as mock_getmodule:
-        mock_getmodule.return_value = sys.modules["jsonargparse._core"]
+    with mock_getmodule_locals(non_empty_context_function, [function]):
         assert 6.7 == non_empty_context_function()
 
 
-def test_automatic_components_context_class():
-    def non_empty_context_class():
-        class ClassX:
-            def __init__(self, i1: str):
-                self.i1 = i1
+@pytest.mark.parametrize("cli_fn", [CLI, auto_cli])
+def test_automatic_components_context_class(cli_fn):
+    class ClassX:
+        def __init__(self, i1: str):
+            self.i1 = i1
 
-            def method(self, m1: int):
-                return self.i1, m1
+        def method(self, m1: int):
+            return self.i1, m1
 
-        return auto_cli(args=["a", "method", "2"])
+    def non_empty_context_class():
+        return cli_fn(args=["a", "method", "2"])
 
-    with patch("inspect.getmodule") as mock_getmodule:
-        mock_getmodule.return_value = sys.modules["jsonargparse._core"]
+    with mock_getmodule_locals(non_empty_context_class, [ClassX]):
         assert ("a", 2) == non_empty_context_class()