magicli 2.1.2__tar.gz → 2.1.3__tar.gz

{magicli-2.1.2 → magicli-2.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: magicli
-Version: 2.1.2
+Version: 2.1.3
 Summary: Automatically generates a CLI from functions.
 Author-email: Patrick Elmer <patrick@elmer.ws>
 License-Expression: GPL-3.0-or-later

{magicli-2.1.2 → magicli-2.1.3}/magicli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: magicli
-Version: 2.1.2
+Version: 2.1.3
 Summary: Automatically generates a CLI from functions.
 Author-email: Patrick Elmer <patrick@elmer.ws>
 License-Expression: GPL-3.0-or-later

{magicli-2.1.2 → magicli-2.1.3}/magicli.py

@@ -73,8 +73,10 @@ def call(function, argv, module=None, name=None):
 
     try:
         args, kwargs = parse_argv(argv, parameters, docstring)
-    except ParseArgvError:
-        raise SystemExit(help_message(help_from_function, function, name))
+    except ParseArgvError as exc:
+        message = exc.args[0] + "\n\n" if exc.args else ""
+        message += help_message(help_from_function, function, name)
+        raise SystemExit(message)
 
     function(*args, **kwargs)
 
@@ -92,8 +94,8 @@ def parse_argv(argv, parameters, docstring):
             parse_short_options(key[1:], docstring, iter_argv, parameters, kwargs)
         else:
             if (index := len(args)) >= len(parameter_list):
-                raise ParseArgvError
-            args.append(get_type(parameter_list[index])(key))
+                raise ParseArgvError(f"{key}: unknown command")
+            args.append(cast_value(key, get_type(parameter_list[index])))
 
     check_all_args_present(len(args), parameter_list)
 
@@ -108,7 +110,9 @@ def check_all_args_present(len_args, parameter_list):
     if len_args < len(parameter_list):
         parameter = parameter_list[len_args]
         if parameter.default is parameter.empty:
-            raise ParseArgvError
+            raise ParseArgvError(
+                f"{parameter_list[len_args].name}: positional argument missing"
+            )
 
 
 def parse_kwarg(key, argv, parameters):
@@ -119,16 +123,36 @@ def parse_kwarg(key, argv, parameters):
     """
     key, value = key.split("=", 1) if "=" in key else (key, None)
     key = key.replace("-", "_")
-    cast_to = get_type(parameters.get(key))
+
+    if key not in parameters:
+        raise ParseArgvError(f"--{key}: unknown long option")
+
+    cast_to = get_type(parameters[key])
 
     if value is None:
         if cast_to is bool:
             return key, not parameters[key].default
         if cast_to is type(None):
             return key, True
-        value = next(argv)
+        value = next_arg(argv)
+
+    return key, cast_value(value, cast_to)
+
 
-    return key, value if cast_to is str else cast_to(value)
+def next_arg(argv):
+    """Return the next command-line argument or raise a parser error."""
+    try:
+        return next(argv)
+    except StopIteration:
+        raise ParseArgvError("error: missing option value")
+
+
+def cast_value(value, cast_to):
+    """Cast a command-line argument value or raise a parser error."""
+    try:
+        return value if cast_to is str else cast_to(value)
+    except ValueError as exc:
+        raise ParseArgvError(exc.args[0]) if exc.args else ParseArgvError from exc
 
 
 def parse_short_options(short_options, docstring, iter_argv, parameters, kwargs):
@@ -137,7 +161,7 @@ def parse_short_options(short_options, docstring, iter_argv, parameters, kwargs)
         long = short_to_long_option(short, docstring)
 
         if long not in parameters:
-            raise SystemExit(f"--{long}: invalid long option")
+            raise ParseArgvError(f"--{long}: invalid long option")
 
         cast_to = get_type(parameters[long])
 
@@ -146,9 +170,9 @@ def parse_short_options(short_options, docstring, iter_argv, parameters, kwargs)
         elif cast_to is type(None):
             kwargs[long] = True
         elif i == len(short_options) - 1:
-            kwargs[long] = cast_to(next(iter_argv))
+            kwargs[long] = cast_value(next_arg(iter_argv), cast_to)
         else:
-            raise SystemExit(f"-{short}: invalid type")
+            raise ParseArgvError(f"-{short}: invalid type")
 
 
 def short_to_long_option(short, docstring):
@@ -160,7 +184,7 @@ def short_to_long_option(short, docstring):
             chars = [" ", "\n", "]"]
             indices = (i for char in chars if (i := docstring.find(char, start)) != -1)
             return docstring[start : min(indices, default=None)]
-    raise SystemExit(f"-{short}: invalid short option")
+    raise ParseArgvError(f"-{short}: invalid short option")
 
 
 def get_type(parameter):

{magicli-2.1.2 → magicli-2.1.3}/tests/test_magicli.py

@@ -59,8 +59,9 @@ def test_command_called(mocked, caplog):
 @mock.patch("importlib.import_module", side_effect=module)
 def test_wrong_command_not_called(mocked):
     sys.argv = ["name", "wrong_command"]
-    with pytest.raises(SystemExit):
+    with pytest.raises(SystemExit) as error:
         magicli()
+    assert error.value.code.startswith("wrong_command: unknown command")
 
 
 @mock.patch("importlib.import_module", side_effect=module_empty)
@@ -87,8 +88,9 @@ def test_module_is_magicli(pyproject):
 @mock.patch("importlib.import_module", side_effect=module)
 def test_short_option_with_wrong_type(mocked):
     sys.argv = ["name", "-ab"]
-    with pytest.raises(SystemExit):
+    with pytest.raises(SystemExit) as error:
         magicli()
+    assert error.value.code.startswith("-a: invalid short option")
 
 
 @mock.patch("importlib.import_module", side_effect=module_version)
@@ -103,7 +105,7 @@ def test_version(mocked, caplog):
     sys.argv = ["name", "-v"]
     with pytest.raises(SystemExit) as error:
         magicli()
-    assert error.value.code == "-v: invalid short option"
+    assert error.value.code.startswith("-v: invalid short option")
 
 
 @mock.patch("importlib.import_module", side_effect=module_version)

{magicli-2.1.2 → magicli-2.1.3}/tests/test_parse_kwarg.py

@@ -3,7 +3,7 @@ from inspect import Parameter, _ParameterKind
 
 import pytest
 
-from magicli import get_type, parse_argv, parse_kwarg, ParseArgvError
+from magicli import ParseArgvError, get_type, parse_argv, parse_kwarg
 
 PK = _ParameterKind.POSITIONAL_OR_KEYWORD
 
@@ -44,8 +44,6 @@ def test_parse_argv():
         ["a"],
         {"kwarg": 2},
     )
-    with pytest.raises(ParseArgvError):
-        parse_argv([], parameters, docstring="")
 
 
 def test_parse_argv_with_underscore():
@@ -58,3 +56,37 @@ def test_parse_argv_with_underscore():
         ["a"],
         {"kwarg_1": 2},
     )
+
+
+@pytest.mark.parametrize(
+    ("command", "error_message"),
+    [
+        (["a", "--unknown=2"], "--unknown: unknown long option"),
+        (["a", "--kwarg"], "error: missing option value"),
+        ([], "arg: positional argument missing"),
+    ],
+)
+def test_parse_argv_errors(command, error_message):
+    parameters = inspect.signature(lambda arg, kwarg=1: None).parameters
+    with pytest.raises(ParseArgvError) as error:
+        parse_argv(command, parameters, docstring="")
+    assert error.value.args[0] == error_message
+
+
+@pytest.mark.parametrize(
+    ("command", "result"),
+    [
+        (["--kwarg", "''"], "''"),
+        (["--kwarg="], ""),
+    ],
+)
+def test_parse_argv_empty_kwarg(command, result):
+    parameters = inspect.signature(lambda kwarg="1": None).parameters
+    res = parse_argv(command, parameters, docstring="")
+    assert res == ([], {"kwarg": result})
+
+
+def test_parse_argv_with_invalid_type_raises_parse_error():
+    with pytest.raises(ParseArgvError) as error:
+        parse_argv(["not-an-int"], {"arg": Parameter("arg", PK, annotation=int)}, "")
+    assert error.value.args[0] == "invalid literal for int() with base 10: 'not-an-int'"

{magicli-2.1.2 → magicli-2.1.3}/tests/test_parse_short_options.py

@@ -2,7 +2,7 @@ from inspect import Parameter, _ParameterKind
 
 import pytest
 
-from magicli import parse_short_options, short_to_long_option
+from magicli import ParseArgvError, parse_short_options, short_to_long_option
 
 
 @pytest.mark.parametrize(
@@ -29,21 +29,21 @@ def test_parse_short_options(default, result):
 
 
 def test_parse_short_options_failures():
-    _kwargs = {
+    kwargs = {
         "short_options": "a",
         "docstring": "-a, --abc",
         "iter_argv": iter(["b"]),
         "parameters": {"abc": Parameter("abc", _ParameterKind.KEYWORD_ONLY)},
         "kwargs": {},
     }
-    for args in [
-        {"parameters": {}},
-        {"docstring": ""},
-        {"short_options": "aa", "iter_argv": iter(["aa"])},
+    for args, err in [
+        ({"parameters": {}}, ("--abc: invalid long option",)),
+        ({"docstring": ""}, ("-a: invalid short option",)),
+        ({"short_options": "aa", "iter_argv": iter(["aa"])}, ("-a: invalid type",)),
     ]:
-        with pytest.raises(SystemExit):
-            parse_short_options(**(_kwargs | args))
-        _kwargs["kwargs"] = {}
+        with pytest.raises(ParseArgvError) as error:
+            parse_short_options(**(kwargs | args))
+        assert error.value.args == err
 
 
 @pytest.mark.parametrize(
@@ -68,5 +68,6 @@ def test_short_to_long_option(docstring):
     ],
 )
 def test_short_to_long_option_failures(docstring):
-    with pytest.raises(SystemExit):
+    with pytest.raises(ParseArgvError) as error:
         short_to_long_option("a", docstring)
+    assert error.value.args[0] == "-a: invalid short option"