iker-python-common 1.0.33__tar.gz → 1.0.34__tar.gz

{iker_python_common-1.0.33 → iker_python_common-1.0.34}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iker-python-common
-Version: 1.0.33
+Version: 1.0.34
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12

iker_python_common-1.0.34/src/iker/common/utils/argutils.py

@@ -0,0 +1,167 @@
+import argparse
+import inspect
+from collections.abc import Sequence
+from dataclasses import dataclass
+from typing import Any
+
+from iker.common.utils.typeutils import is_identical_type, type_origin
+
+__all__ = [
+    "ParserTreeNode",
+    "ParserTree",
+    "ArgParseSpec",
+    "argparse_spec",
+    "make_argparse"
+]
+
+import sys
+
+
+class ParserTreeNode(object):
+    def __init__(self, command: str, parser: argparse.ArgumentParser):
+        self.command = command
+        self.parser = parser
+        self.subparsers = None
+        self.child_nodes: list[ParserTreeNode] = []
+
+
+def construct_parser_tree(
+    root_node: ParserTreeNode,
+    command_chain: list[str],
+    command_key_prefix: str,
+    **kwargs,
+) -> list[ParserTreeNode]:
+    node_path = [root_node]
+    if len(command_chain) == 0:
+        return node_path
+
+    node = root_node
+    for depth, command in enumerate(command_chain):
+        if node.subparsers is None:
+            node.subparsers = node.parser.add_subparsers(dest=f"{command_key_prefix}:{depth}")
+        for child_node in node.child_nodes:
+            if child_node.command == command:
+                node = child_node
+                break
+        else:
+            if depth == len(command_chain) - 1:
+                child_parser = node.subparsers.add_parser(command, **kwargs)
+            else:
+                child_parser = node.subparsers.add_parser(command)
+            child_node = ParserTreeNode(command, child_parser)
+            node.child_nodes.append(child_node)
+            node = child_node
+        node_path.append(node)
+
+    return node_path
+
+
+class ParserTree(object):
+    def __init__(self, root_parser: argparse.ArgumentParser, command_key_prefix: str = "command"):
+        self.root_node = ParserTreeNode("", root_parser)
+        self.command_key_prefix = command_key_prefix
+
+    def add_subcommand_parser(self, command_chain: list[str], **kwargs) -> argparse.ArgumentParser:
+        *_, last_node = construct_parser_tree(self.root_node, command_chain, self.command_key_prefix, **kwargs)
+        return last_node.parser
+
+    def parse_args(self, args: list[str] | None = None) -> tuple[list[str], argparse.Namespace]:
+        # Before Python 3.12 the 'exit_on_error' attribute does not take effect properly
+        # if unknown arguments encountered. We have to employ this workaround
+        # TODO: remove this workaround when bumping the Python versions to above Python 3.12
+        if sys.version_info < (3, 12):
+            if self.root_node.parser.exit_on_error:
+                known_args_namespace = self.root_node.parser.parse_args(args)
+            else:
+                known_args_namespace, unknown_args = self.root_node.parser.parse_known_args(args)
+                if len(unknown_args or []) > 0:
+                    raise argparse.ArgumentError(None, f"unrecognized arguments '{unknown_args}'")
+        else:
+            known_args_namespace = self.root_node.parser.parse_args(args)
+
+        command_pairs = []
+        namespace = argparse.Namespace()
+        for key, value in dict(vars(known_args_namespace)).items():
+            if key.startswith(self.command_key_prefix) and value is not None:
+                command_pairs.append((key, value))
+            else:
+                setattr(namespace, key, value)
+
+        return list(command for _, command in sorted(command_pairs)), namespace
+
+
+@dataclass(frozen=True)
+class ArgParseSpec(object):
+    flag: str | None = None
+    name: str | None = None
+    action: str | None = None
+    default: Any = None
+    type: type = None
+    choices: list[Any] | None = None
+    required: bool | None = None
+    help: str | None = None
+
+
+argparse_spec = ArgParseSpec
+
+
+def make_argparse(func, parser: argparse.ArgumentParser = None) -> argparse.ArgumentParser:
+    if parser is None:
+        parser = argparse.ArgumentParser()
+
+    def is_type_of(t: type, *types) -> bool:
+        return any(is_identical_type(t, type_) for type_ in types)
+
+    sig = inspect.signature(func)
+    for name, param in sig.parameters.items():
+
+        if param.annotation is None:
+            param_type = str
+        elif is_type_of(param.annotation, str, str | None, list[str], Sequence[str]):
+            param_type = str
+        elif is_type_of(param.annotation, int, int | None, list[int], Sequence[int]):
+            param_type = int
+        elif is_type_of(param.annotation, float, float | None, list[float], Sequence[float]):
+            param_type = float
+        elif is_type_of(param.annotation, bool, bool | None, list[bool], Sequence[bool]):
+            param_type = bool
+        else:
+            param_type = str
+
+        param_action = "append" if type_origin(param.annotation) in {list, Sequence} else None
+        param_default = None if param.default is inspect.Parameter.empty else param.default
+
+        if not isinstance(param_default, ArgParseSpec):
+            param_name = f"--{name.replace('_', '-')}"
+
+            parser.add_argument(param_name,
+                                type=param_type,
+                                action=param_action,
+                                required=param_default is None,
+                                default=param_default)
+
+        else:
+            spec = param_default
+
+            param_flag = spec.flag
+            param_name = spec.name or f"--{name.replace('_', '-')}"
+            param_type = spec.type if spec.type is not None else param_type
+            param_action = spec.action if spec.action is not None else param_action
+
+            if param_flag is None:
+                parser.add_argument(param_name,
+                                    type=param_type,
+                                    action=param_action,
+                                    required=spec.default is None,
+                                    default=spec.default,
+                                    help=spec.help)
+            else:
+                parser.add_argument(param_flag,
+                                    param_name,
+                                    type=param_type,
+                                    action=param_action,
+                                    required=spec.default is None,
+                                    default=spec.default,
+                                    help=spec.help)
+
+    return parser

iker_python_common-1.0.34/src/iker/common/utils/typeutils.py

@@ -0,0 +1,71 @@
+import types
+import typing
+
+
+def print_type(t: type):
+    def print_typing_indent(t: type, indent: int = 0):
+        origin = type_origin(t)
+        if origin:
+            print(" " * indent, t, origin)
+        else:
+            print(" " * indent, t)
+        for arg in type_args(t):
+            print_typing_indent(arg, indent + 2)
+
+    print_typing_indent(t)
+
+
+def type_origin(t: type) -> type | None:
+    return t.__origin__ if hasattr(t, "__origin__") else None
+
+
+def type_args(t: type) -> list[type]:
+    return t.__args__ if hasattr(t, "__args__") else []
+
+
+def is_union_type(t: type) -> bool:
+    return type(t) is types.UnionType or type_origin(t) in {typing.Union}
+
+
+def is_optional_type(t: type) -> bool:
+    if not is_union_type(t):
+        return False
+    return types.NoneType in type_args(t)
+
+
+def is_identical_union_type(a: type, b: type) -> bool:
+    a_args = type_args(a)
+    b_args = type_args(b)
+
+    if len(a_args) != len(b_args):
+        return False
+    for arg_a, arg_b in zip(sorted(a_args, key=str), sorted(b_args, key=str)):
+        if not is_identical_type(arg_a, arg_b):
+            return False
+    return True
+
+
+def is_identical_type(a: type, b: type) -> bool:
+    if is_union_type(a) and is_union_type(b):
+        return is_identical_union_type(a, b)
+    elif is_union_type(a) ^ is_union_type(b):
+        return False
+
+    a_origin = type_origin(a)
+    b_origin = type_origin(b)
+
+    if a_origin is not None and b_origin is not None:
+        if a_origin != b_origin:
+            return False
+    elif a != b:
+        return False
+
+    a_args = type_args(a)
+    b_args = type_args(b)
+
+    if len(a_args) != len(b_args):
+        return False
+    for arg_a, arg_b in zip(a_args, b_args):
+        if not is_identical_type(arg_a, arg_b):
+            return False
+    return True

{iker_python_common-1.0.33 → iker_python_common-1.0.34}/src/iker_python_common.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iker-python-common
-Version: 1.0.33
+Version: 1.0.34
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12

{iker_python_common-1.0.33 → iker_python_common-1.0.34}/src/iker_python_common.egg-info/SOURCES.txt

@@ -40,6 +40,7 @@ src/iker/common/utils/shutils.py
 src/iker/common/utils/span.py
 src/iker/common/utils/strutils.py
 src/iker/common/utils/testutils.py
+src/iker/common/utils/typeutils.py
 src/iker_python_common.egg-info/PKG-INFO
 src/iker_python_common.egg-info/SOURCES.txt
 src/iker_python_common.egg-info/dependency_links.txt
@@ -66,4 +67,5 @@ test/iker_tests/common/utils/sequtils_test.py
 test/iker_tests/common/utils/shutils_test.py
 test/iker_tests/common/utils/span_test.py
 test/iker_tests/common/utils/strutils_test.py
-test/iker_tests/common/utils/testutils_test.py
+test/iker_tests/common/utils/testutils_test.py
+test/iker_tests/common/utils/typeutils_test.py

{iker_python_common-1.0.33 → iker_python_common-1.0.34}/test/iker_tests/common/utils/argutils_test.py

@@ -1,9 +1,12 @@
 import argparse
 import unittest
+from typing import List, Optional, Union
 
 import ddt
 
 from iker.common.utils.argutils import ParserTree
+from iker.common.utils.argutils import make_argparse
+from iker.common.utils.sequtils import seq
 
 
 def dummy_parser_tree():
@@ -155,3 +158,100 @@ class ArgUtilsTest(unittest.TestCase):
     def test_parser_tree__exception(self, args):
         with self.assertRaises(argparse.ArgumentError):
             dummy_parser_tree().parse_args(args)
+
+    def test_make_argparse(self):
+        args = [
+            ("--param-int", "1", 1),
+            ("--param-float", "2.0", 2.0),
+            ("--param-str", "dummy", "dummy"),
+            ("--param-int-or-none", "11", 11),
+            ("--param-float-or-none", "22.0", 22.0),
+            ("--param-str-or-none", "dummy-dummy", "dummy-dummy"),
+            ("--param-none-or-int", "111", 111),
+            ("--param-none-or-float", "222.0", 222.0),
+            ("--param-none-or-str", "dummy-dummy-dummy", "dummy-dummy-dummy"),
+            ("--param-typing-optional-int", "1111", 1111),
+            ("--param-typing-optional-float", "2222.0", 2222.0),
+            ("--param-typing-optional-str", "dummy-dummy-dummy-dummy", "dummy-dummy-dummy-dummy"),
+            ("--param-typing-union-int-none", "11111", 11111),
+            ("--param-typing-union-float-none", "22222.0", 22222.0),
+            ("--param-typing-union-str-none", "dummy-dummy-dummy-dummy-dummy", "dummy-dummy-dummy-dummy-dummy"),
+            ("--param-typing-union-none-int", "111111", 111111),
+            ("--param-typing-union-none-float", "222222.0", 222222.0),
+            ("--param-typing-union-none-str",
+             "dummy-dummy-dummy-dummy-dummy-dummy",
+             "dummy-dummy-dummy-dummy-dummy-dummy"),
+            ("--param-list-int", "1111111", [1111111]),
+            ("--param-list-float", "2222222.0", [2222222.0]),
+            ("--param-list-str",
+             "dummy-dummy-dummy-dummy-dummy-dummy-dummy",
+             ["dummy-dummy-dummy-dummy-dummy-dummy-dummy"]),
+            ("--param-typing-list-int", "11111111", [11111111]),
+            ("--param-typing-list-float", "22222222.0", [22222222.0]),
+            ("--param-typing-list-str",
+             "dummy-dummy-dummy-dummy-dummy-dummy-dummy-dummy",
+             ["dummy-dummy-dummy-dummy-dummy-dummy-dummy-dummy"]),
+        ]
+
+        def dummy_function(
+            param_int: int,
+            param_float: float,
+            param_str: str,
+            param_int_or_none: int | None,
+            param_float_or_none: float | None,
+            param_str_or_none: str | None,
+            param_none_or_int: None | int,
+            param_none_or_float: None | float,
+            param_none_or_str: None | str,
+            param_typing_optional_int: Optional[int],
+            param_typing_optional_float: Optional[float],
+            param_typing_optional_str: Optional[str],
+            param_typing_union_int_none: Union[int, None],
+            param_typing_union_float_none: Union[float, None],
+            param_typing_union_str_none: Union[str, None],
+            param_typing_union_none_int: Union[None, int],
+            param_typing_union_none_float: Union[None, float],
+            param_typing_union_none_str: Union[None, str],
+            param_list_int: list[int],
+            param_list_float: list[float],
+            param_list_str: list[str],
+            param_typing_list_int: List[int],
+            param_typing_list_float: List[float],
+            param_typing_list_str: List[str],
+        ):
+            params = (
+                param_int,
+                param_float,
+                param_str,
+                param_int_or_none,
+                param_float_or_none,
+                param_str_or_none,
+                param_none_or_int,
+                param_none_or_float,
+                param_none_or_str,
+                param_typing_optional_int,
+                param_typing_optional_float,
+                param_typing_optional_str,
+                param_typing_union_int_none,
+                param_typing_union_float_none,
+                param_typing_union_str_none,
+                param_typing_union_none_int,
+                param_typing_union_none_float,
+                param_typing_union_none_str,
+                param_list_int,
+                param_list_float,
+                param_list_str,
+                param_typing_list_int,
+                param_typing_list_float,
+                param_typing_list_str,
+            )
+
+            for param, (arg_name, arg_str_value, arg_value) in zip(params, args):
+                self.assertEqual(param, arg_value, arg_name)
+
+        parser = make_argparse(dummy_function)
+        parsed_args = parser.parse_args(
+            seq(args).map(lambda x: (lambda name, str_value, _: [name, str_value])(*x)).flatten().map(str),
+        )
+
+        dummy_function(**vars(parsed_args))

iker_python_common-1.0.34/test/iker_tests/common/utils/typeutils_test.py

@@ -0,0 +1,206 @@
+import unittest
+from typing import Dict, List, Optional, Union
+
+import ddt
+
+from iker.common.utils.typeutils import is_identical_type, is_optional_type
+
+
+class DummyClass(object):
+    pass
+
+
+@ddt.ddt
+class TypeUtilsTest(unittest.TestCase):
+
+    @ddt.data(
+        (int, False),
+        (float, False),
+        (str, False),
+        (bool, False),
+        (DummyClass, False),
+        (int | None, True),
+        (float | None, True),
+        (str | None, True),
+        (bool | None, True),
+        (DummyClass | None, True),
+        (None | int, True),
+        (None | float, True),
+        (None | str, True),
+        (None | bool, True),
+        (None | DummyClass, True),
+        (Optional[int], True),
+        (Optional[float], True),
+        (Optional[str], True),
+        (Optional[bool], True),
+        (Optional[DummyClass], True),
+        (int | object | None, True),
+        (float | object | None, True),
+        (str | object | None, True),
+        (bool | object | None, True),
+        (DummyClass | object | None, True),
+        (list[int], False),
+        (list[float], False),
+        (list[str], False),
+        (list[bool], False),
+        (list[DummyClass], False),
+        (list[int | None], False),
+        (list[float | None], False),
+        (list[str | None], False),
+        (list[bool | None], False),
+        (list[DummyClass | None], False),
+        (list[int] | None, True),
+        (list[float] | None, True),
+        (list[str] | None, True),
+        (list[bool] | None, True),
+        (list[DummyClass] | None, True),
+        (dict[int, int], False),
+        (dict[float, float], False),
+        (dict[str, str], False),
+        (dict[bool, bool], False),
+        (dict[DummyClass, DummyClass], False),
+        (dict[int, int | None], False),
+        (dict[float, float | None], False),
+        (dict[str, str | None], False),
+        (dict[bool, bool | None], False),
+        (dict[DummyClass, DummyClass | None], False),
+        (dict[int, int] | None, True),
+        (dict[float, float] | None, True),
+        (dict[str, str] | None, True),
+        (dict[bool, bool] | None, True),
+        (dict[DummyClass, DummyClass] | None, True),
+    )
+    @ddt.unpack
+    def test_is_optional_type(self, t, expect):
+        self.assertEqual(is_optional_type(t), expect)
+
+    @ddt.data(
+        (int, int, True),
+        (float, float, True),
+        (str, str, True),
+        (bool, bool, True),
+        (DummyClass, DummyClass, True),
+        (int | None, int | None, True),
+        (float | None, float | None, True),
+        (str | None, str | None, True),
+        (bool | None, bool | None, True),
+        (DummyClass | None, DummyClass | None, True),
+        (None | int, int | None, True),
+        (None | float, float | None, True),
+        (None | str, str | None, True),
+        (None | bool, bool | None, True),
+        (None | DummyClass, DummyClass | None, True),
+        (Optional[int], int | None, True),
+        (Optional[float], float | None, True),
+        (Optional[str], str | None, True),
+        (Optional[bool], bool | None, True),
+        (Optional[DummyClass], DummyClass | None, True),
+        (Union[int, None], int | None, True),
+        (Union[float, None], float | None, True),
+        (Union[str, None], str | None, True),
+        (Union[bool, None], bool | None, True),
+        (Union[DummyClass, None], DummyClass | None, True),
+        (Union[None, int], int | None, True),
+        (Union[None, float], float | None, True),
+        (Union[None, str], str | None, True),
+        (Union[None, bool], bool | None, True),
+        (Union[None, DummyClass], DummyClass | None, True),
+        (list[int], list[int], True),
+        (list[float], list[float], True),
+        (list[str], list[str], True),
+        (list[bool], list[bool], True),
+        (list[DummyClass], list[DummyClass], True),
+        (List[int], list[int], True),
+        (List[float], list[float], True),
+        (List[str], list[str], True),
+        (List[bool], list[bool], True),
+        (List[DummyClass], list[DummyClass], True),
+        (List[Optional[int]], list[int | None], True),
+        (List[Optional[float]], list[float | None], True),
+        (List[Optional[str]], list[str | None], True),
+        (List[Optional[bool]], list[bool | None], True),
+        (List[Optional[DummyClass]], list[DummyClass | None], True),
+        (dict[int, int], dict[int, int], True),
+        (dict[float, float], dict[float, float], True),
+        (dict[str, str], dict[str, str], True),
+        (dict[bool, bool], dict[bool, bool], True),
+        (dict[DummyClass, DummyClass], dict[DummyClass, DummyClass], True),
+        (Dict[int, int], dict[int, int], True),
+        (Dict[float, float], dict[float, float], True),
+        (Dict[str, str], dict[str, str], True),
+        (Dict[bool, bool], dict[bool, bool], True),
+        (Dict[DummyClass, DummyClass], dict[DummyClass, DummyClass], True),
+        (Dict[int, List[Optional[int]]], dict[int, list[int | None]], True),
+        (Dict[float, List[Optional[float]]], dict[float, list[float | None]], True),
+        (Dict[str, List[Optional[str]]], dict[str, list[str | None]], True),
+        (Dict[bool, List[Optional[bool]]], dict[bool, list[bool | None]], True),
+        (Dict[DummyClass, List[Optional[DummyClass]]], dict[DummyClass, list[DummyClass | None]], True),
+
+        (int, int | None, False),
+        (float, float | None, False),
+        (str, str | None, False),
+        (bool, bool | None, False),
+        (DummyClass, DummyClass | None, False),
+        (int, Optional[int], False),
+        (float, Optional[float], False),
+        (str, Optional[str], False),
+        (bool, Optional[bool], False),
+        (DummyClass, Optional[DummyClass], False),
+
+        (List[int], List[DummyClass], False),
+        (List[float], List[DummyClass], False),
+        (List[str], List[DummyClass], False),
+        (List[bool], List[DummyClass], False),
+        (List[int], list[DummyClass], False),
+        (List[float], list[DummyClass], False),
+        (List[str], list[DummyClass], False),
+        (List[bool], list[DummyClass], False),
+
+        (List[Optional[int]], list[int], False),
+        (List[Optional[float]], list[float], False),
+        (List[Optional[str]], list[str], False),
+        (List[Optional[bool]], list[bool], False),
+        (List[Optional[DummyClass]], list[DummyClass], False),
+        (List[Optional[int]], list[int] | None, False),
+        (List[Optional[float]], list[float] | None, False),
+        (List[Optional[str]], list[str] | None, False),
+        (List[Optional[bool]], list[bool] | None, False),
+        (List[Optional[DummyClass]], list[DummyClass] | None, False),
+
+        (Dict[int, int], Dict[int, DummyClass], False),
+        (Dict[float, float], Dict[float, DummyClass], False),
+        (Dict[str, str], Dict[str, DummyClass], False),
+        (Dict[bool, bool], Dict[bool, DummyClass], False),
+        (Dict[int, int], Dict[DummyClass, int], False),
+        (Dict[float, float], Dict[DummyClass, float], False),
+        (Dict[str, str], Dict[DummyClass, str], False),
+        (Dict[bool, bool], Dict[DummyClass, bool], False),
+        (Dict[int, int], dict[int, DummyClass], False),
+        (Dict[float, float], dict[float, DummyClass], False),
+        (Dict[str, str], dict[str, DummyClass], False),
+        (Dict[bool, bool], dict[bool, DummyClass], False),
+        (Dict[int, int], dict[DummyClass, int], False),
+        (Dict[float, float], dict[DummyClass, float], False),
+        (Dict[str, str], dict[DummyClass, str], False),
+        (Dict[bool, bool], dict[DummyClass, bool], False),
+
+        (Dict[int, List[Optional[int]]], dict[int, list[int]], False),
+        (Dict[float, List[Optional[float]]], dict[float, list[float]], False),
+        (Dict[str, List[Optional[str]]], dict[str, list[str]], False),
+        (Dict[bool, List[Optional[bool]]], dict[bool, list[bool]], False),
+        (Dict[DummyClass, List[Optional[DummyClass]]], dict[DummyClass, list[DummyClass]], False),
+        (Dict[int, List[Optional[int]]], dict[int, list[int] | None], False),
+        (Dict[float, List[Optional[float]]], dict[float, list[float] | None], False),
+        (Dict[str, List[Optional[str]]], dict[str, list[str] | None], False),
+        (Dict[bool, List[Optional[bool]]], dict[bool, list[bool] | None], False),
+        (Dict[DummyClass, List[Optional[DummyClass]]], dict[DummyClass, list[DummyClass] | None], False),
+        (Dict[int, List[Optional[int]]], dict[int, list[int]] | None, False),
+        (Dict[float, List[Optional[float]]], dict[float, list[float]] | None, False),
+        (Dict[str, List[Optional[str]]], dict[str, list[str]] | None, False),
+        (Dict[bool, List[Optional[bool]]], dict[bool, list[bool]] | None, False),
+        (Dict[DummyClass, List[Optional[DummyClass]]], dict[DummyClass, list[DummyClass]] | None, False),
+    )
+    @ddt.unpack
+    def test_is_identical_type(self, a, b, expect):
+        self.assertEqual(is_identical_type(a, b), expect)
+        self.assertEqual(is_identical_type(b, a), expect)

iker_python_common-1.0.33/src/iker/common/utils/argutils.py

@@ -1,81 +0,0 @@
-import argparse
-
-__all__ = [
-    "ParserTreeNode",
-    "ParserTree",
-]
-
-import sys
-
-
-class ParserTreeNode(object):
-    def __init__(self, command: str, parser: argparse.ArgumentParser):
-        self.command = command
-        self.parser = parser
-        self.subparsers = None
-        self.child_nodes: list[ParserTreeNode] = []
-
-
-def construct_parser_tree(
-    root_node: ParserTreeNode,
-    command_chain: list[str],
-    command_key_prefix: str,
-    **kwargs,
-) -> list[ParserTreeNode]:
-    node_path = [root_node]
-    if len(command_chain) == 0:
-        return node_path
-
-    node = root_node
-    for depth, command in enumerate(command_chain):
-        if node.subparsers is None:
-            node.subparsers = node.parser.add_subparsers(dest=f"{command_key_prefix}:{depth}")
-        for child_node in node.child_nodes:
-            if child_node.command == command:
-                node = child_node
-                break
-        else:
-            if depth == len(command_chain) - 1:
-                child_parser = node.subparsers.add_parser(command, **kwargs)
-            else:
-                child_parser = node.subparsers.add_parser(command)
-            child_node = ParserTreeNode(command, child_parser)
-            node.child_nodes.append(child_node)
-            node = child_node
-        node_path.append(node)
-
-    return node_path
-
-
-class ParserTree(object):
-    def __init__(self, root_parser: argparse.ArgumentParser, command_key_prefix: str = "command"):
-        self.root_node = ParserTreeNode("", root_parser)
-        self.command_key_prefix = command_key_prefix
-
-    def add_subcommand_parser(self, command_chain: list[str], **kwargs) -> argparse.ArgumentParser:
-        *_, last_node = construct_parser_tree(self.root_node, command_chain, self.command_key_prefix, **kwargs)
-        return last_node.parser
-
-    def parse_args(self, args: list[str] | None = None) -> tuple[list[str], argparse.Namespace]:
-        # Before Python 3.12 the 'exit_on_error' attribute does not take effect properly
-        # if unknown arguments encountered. We have to employ this workaround
-        # TODO: remove this workaround when bumping the Python versions to above Python 3.12
-        if sys.version_info < (3, 12):
-            if self.root_node.parser.exit_on_error:
-                known_args_namespace = self.root_node.parser.parse_args(args)
-            else:
-                known_args_namespace, unknown_args = self.root_node.parser.parse_known_args(args)
-                if len(unknown_args or []) > 0:
-                    raise argparse.ArgumentError(None, f"unrecognized arguments '{unknown_args}'")
-        else:
-            known_args_namespace = self.root_node.parser.parse_args(args)
-
-        command_pairs = []
-        namespace = argparse.Namespace()
-        for key, value in dict(vars(known_args_namespace)).items():
-            if key.startswith(self.command_key_prefix) and value is not None:
-                command_pairs.append((key, value))
-            else:
-                setattr(namespace, key, value)
-
-        return list(command for _, command in sorted(command_pairs)), namespace