CLI now when given a class without methods, the class instance is returned.

Author: mauvilsa

CHANGELOG.rst

@@ -44,6 +44,8 @@ Changed
   <https://github.com/Lightning-AI/lightning/issues/17247>`__).
 - The ``signatures`` extras now installs the ``typing-extensions`` package on
   python<=3.9.
+- ``CLI`` now when given a class without methods, the class instance is
+  returned.
 
 Deprecated
 ^^^^^^^^^^

README.rst

@@ -129,7 +129,7 @@ is:
         print(f'{name} won {prize}€!')
 
     if __name__ == '__main__':
-        CLI()
+        CLI(command)
 
 Note that the ``name`` and ``prize`` parameters have type hints and are
 described in the docstring. These are shown in the help of the command line
@@ -152,11 +152,6 @@ tool. In a shell you could see the help and run a command as follows:
     shown, jsonargparse needs to be installed with the ``signatures`` extras
     require as explained in section :ref:`installation`.
 
-:func:`.CLI` without arguments searches for functions and classes defined in the
-same module and in the local context where :func:`.CLI` is called. Giving a
-single or a list of functions/classes as first argument to :func:`.CLI` skips
-the automatic search and only includes what is given.
-
 When :func:`.CLI` receives a single class, the first arguments are for
 parameters to instantiate the class, then a method name is expected (i.e.
 methods become :ref:`sub-commands`) and the remaining arguments are for
@@ -203,6 +198,37 @@ Then in a shell you could run:
     >>> CLI(Main, args=['--max_prize=1000', 'person', 'Lucky'])  # doctest: +ELLIPSIS
     'Lucky won ...€!'
 
+If the class given does not have any methods, there will be no sub-commands and
+:func:`.CLI` will return an instance of the class. For example:
+
+.. testcode::
+
+    from dataclasses import dataclass
+    from jsonargparse import CLI
+
+    @dataclass
+    class Settings:
+        name: str
+        prize: int = 100
+
+    if __name__ == '__main__':
+        print(CLI(Settings, as_positional=False))
+
+Then in a shell you could run:
+
+.. code-block:: bash
+
+    $ python example.py --name=Lucky
+    Settings(name='Lucky', prize=100)
+
+.. doctest:: :hide:
+
+    >>> CLI(Settings, as_positional=False, args=['--name=Lucky'])  # doctest: +ELLIPSIS
+    Settings(name='Lucky', prize=100)
+
+Note the use of ``as_positional=False`` to make required arguments as
+non-positional.
+
 If more than one function is given to :func:`.CLI`, then any of them can be run
 via :ref:`sub-commands` similar to the single class example above, i.e.
 ``example.py function [arguments]`` where ``function`` is the name of the
@@ -214,7 +240,7 @@ class and the second the name of the method, i.e. ``example.py class
 
 .. note::
 
-    The two examples above are extremely simple, only defining parameters with
+    The examples above are extremely simple, only defining parameters with
     ``str`` and ``int`` type hints. The true power of jsonargparse is its
     support for a wide range of types, see :ref:`type-hints`. It is even
     possible to use general classes as type hints, allowing to easily implement

jsonargparse/cli.py

@@ -114,9 +114,18 @@ def get_help_str(component, logger):
 def _add_component_to_parser(component, parser, as_positional, fail_untyped, config_help):
     kwargs = dict(as_positional=as_positional, fail_untyped=fail_untyped, sub_configs=True)
     if inspect.isclass(component):
+        subcommand_keys = [
+            k for k, v in inspect.getmembers(component)
+            if callable(v) and k[0] != '_'
+        ]
+        if not subcommand_keys:
+            added_args = parser.add_class_arguments(component, as_group=False, **kwargs)
+            if not parser.description:
+                parser.description = get_help_str(component, parser.logger)
+            return added_args
         added_args = parser.add_class_arguments(component, **kwargs)
         subcommands = parser.add_subcommands(required=True)
-        for key in [k for k, v in inspect.getmembers(component) if callable(v) and k[0] != '_']:
+        for key in subcommand_keys:
             description = get_help_str(getattr(component, key), parser.logger)
             subparser = type(parser)(description=description)
             subparser.add_argument('--config', action=ActionConfigFile, help=config_help)
@@ -137,6 +146,8 @@ def _run_component(component, cfg):
     if not inspect.isclass(component):
         return component(**cfg)
     subcommand = cfg.pop('subcommand')
+    if not subcommand:
+        return component(**cfg)
     subcommand_cfg = cfg.pop(subcommand, {})
     subcommand_cfg.pop('config', None)
     component_obj = component(**cfg)

jsonargparse_tests/test_cli.py

@@ -4,6 +4,7 @@
 import unittest
 import unittest.mock
 from contextlib import redirect_stderr, redirect_stdout
+from dataclasses import asdict, dataclass
 from io import StringIO
 from typing import Optional
 
@@ -252,6 +253,20 @@ def method1(self, m1: int):
             self.assertEqual(('a', 2), non_empty_context_2())
 
 
+    def test_class_without_methods_cli(self):
+        @dataclass
+        class SettingsClass:
+            p1: str
+            p2: int = 3
+
+        settings = CLI(SettingsClass, args=['--p1=x', '--p2=0'], as_positional=False)
+        self.assertIsInstance(settings, SettingsClass)
+        self.assertEqual(asdict(settings), {'p1': 'x', 'p2': 0})
+
+        parser = capture_parser(lambda: CLI(SettingsClass, args=[], as_positional=False))
+        self.assertEqual(parser.groups, {})
+
+
 class CLITempDirTests(TempDirTestCase):
 
     def test_subclass_type_config_file(self):