iker-python-common 1.0.6__tar.gz → 1.0.8__tar.gz

{iker_python_common-1.0.6 → iker_python_common-1.0.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: iker-python-common
-Version: 1.0.6
+Version: 1.0.8
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12

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

@@ -0,0 +1,76 @@
+import argparse
+
+__all__ = [
+    "ParserTreeNode",
+    "ParserTree",
+]
+
+
+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 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, "unrecognized arguments: %s" % " ".join(unknown_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

{iker_python_common-1.0.6 → iker_python_common-1.0.8}/src/iker/common/utils/dbutils.py

@@ -13,6 +13,7 @@ from iker.common.utils.sequtils import head_or_none
 from iker.common.utils.strutils import is_blank
 
 __all__ = [
+    "ConnectionMaker",
     "DBAdapter",
     "orm_to_dict",
     "orm_clone",
@@ -21,9 +22,9 @@ __all__ = [
 ]
 
 
-class DBAdapter(object):
+class ConnectionMaker(object):
     """
-    Database adapter
+    Provides utilities that make it easier to establish database connections and sessions
     """
 
     class Drivers:
@@ -56,19 +57,19 @@ class DBAdapter(object):
         url: str | urllib.parse.ParseResult,
         engine_opts: dict[str, Any] | None = None,
         session_opts: dict[str, Any] | None = None,
-    ) -> "DBAdapter":
+    ) -> "ConnectionMaker":
         if isinstance(url, str):
-            return DBAdapter.from_url(driver, urllib.parse.urlparse(url), engine_opts, session_opts)
+            return ConnectionMaker.from_url(driver, urllib.parse.urlparse(url), engine_opts, session_opts)
         if isinstance(url, urllib.parse.ParseResult):
-            return DBAdapter(driver,
-                             url.hostname,
-                             url.port,
-                             url.username,
-                             url.password,
-                             url.path.strip("/"),
-                             engine_opts,
-                             session_opts)
-        raise ValueError("illegal parameter 'url'")
+            return ConnectionMaker(driver,
+                                   url.hostname,
+                                   url.port,
+                                   url.username,
+                                   url.password,
+                                   url.path.strip("/"),
+                                   engine_opts,
+                                   session_opts)
+        raise ValueError("malformed parameter 'url'")
 
     @property
     def connection_string(self) -> str:
@@ -129,6 +130,9 @@ class DBAdapter(object):
         return head_or_none(self.query_all(sql, **params))
 
 
+DBAdapter = ConnectionMaker
+
+
 def orm_to_dict(orm: sqlalchemy.orm.DeclarativeBase, exclude: set[str] = None) -> dict[str, Any]:
     if not isinstance(orm, sqlalchemy.orm.DeclarativeBase):
         raise TypeError('not a SQLAlchemy ORM declarative base')

{iker_python_common-1.0.6 → iker_python_common-1.0.8}/src/iker/common/utils/sequtils.py

@@ -101,7 +101,7 @@ def deduped(ms: Sequence[T], comp_func: Callable[[T, T], bool]) -> list[T]:
     return deduped_ms
 
 
-def batch_yield(ms: Iterable[T], batch_size: int) -> Generator[list[T]]:
+def batch_yield(ms: Iterable[T], batch_size: int) -> Generator[list[T], None, None]:
     """
     Splits the given input sequence into batches according to the specific batch size
 

{iker_python_common-1.0.6 → iker_python_common-1.0.8}/src/iker/common/utils/strutils.py

@@ -131,7 +131,7 @@ def parse_params_string(s: str, delimiter: str = ",", kv_delimiter: str = "=") -
 
     result = {}
     for param in s.split(delimiter):
-        segments = param.split(kv_delimiter)
+        segments = param.split(kv_delimiter, 1)
         if len(segments) == 1:
             result[head(segments)] = str(True)
         elif len(segments) == 2:

{iker_python_common-1.0.6 → iker_python_common-1.0.8}/src/iker_python_common.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: iker-python-common
-Version: 1.0.6
+Version: 1.0.8
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12

{iker_python_common-1.0.6 → iker_python_common-1.0.8}/src/iker_python_common.egg-info/SOURCES.txt

@@ -19,6 +19,7 @@ resources/unittest/shutils/dir.foo/dir.foo.bar/file.foo.baz
 resources/unittest/shutils/dir.foo/dir.foo.bar/dir.foo.bar.baz/file.foo.bar.baz
 src/iker/common/__init__.py
 src/iker/common/utils/__init__.py
+src/iker/common/utils/argutils.py
 src/iker/common/utils/config.py
 src/iker/common/utils/dbutils.py
 src/iker/common/utils/dockerutils.py
@@ -43,6 +44,7 @@ src/iker_python_common.egg-info/top_level.txt
 test/iker_tests/__init__.py
 test/iker_tests/docker_fixtures.py
 test/iker_tests/iker_test.py
+test/iker_tests/common/utils/argutils_test.py
 test/iker_tests/common/utils/config_test.py
 test/iker_tests/common/utils/dbutils_test.py
 test/iker_tests/common/utils/dockerutils_test.py

iker_python_common-1.0.8/test/iker_tests/common/utils/argutils_test.py

@@ -0,0 +1,158 @@
+import argparse
+import unittest
+
+import ddt
+import pytest
+
+from iker.common.utils.argutils import ParserTree
+
+
+def dummy_parser_tree():
+    parser_tree = ParserTree(argparse.ArgumentParser(description="dummy argument parser", exit_on_error=False))
+
+    for command_chain in [
+        [],
+        ["foo"],
+        ["foo", "bar"],
+        ["foo", "baz"],
+        ["bar"],
+        ["bar", "foo"],
+        ["bar", "baz"],
+        ["baz", "foo"],
+        ["baz", "bar"],
+        ["baz", "bar", "foo"],
+    ]:
+        parser = parser_tree.add_subcommand_parser(command_chain, exit_on_error=False)
+
+        option_infix = "-".join(command_chain)
+        if len(option_infix) == 0:
+            option_infix = "x"
+
+        parser.add_argument(f"--option-{option_infix}-str", type=str, default="")
+        parser.add_argument(f"--option-{option_infix}-int", type=int, default=0)
+        parser.add_argument(f"--option-{option_infix}-float", type=float, default=0.0)
+        parser.add_argument(f"--option-{option_infix}-switch", action="store_true")
+        parser.add_argument(f"--option-{option_infix}-nargs", type=str, action="append", default=[])
+
+    return parser_tree
+
+
+@ddt.ddt
+class ArgUtilsTest(unittest.TestCase):
+
+    @ddt.data(
+        (
+            [],
+            [],
+            [
+                ("option_x_str", ""),
+                ("option_x_int", 0),
+                ("option_x_float", 0.0),
+                ("option_x_switch", False),
+                ("option_x_nargs", []),
+            ],
+        ),
+        (
+            [
+                "--option-x-str", "dummy",
+                "--option-x-int", "1",
+                "--option-x-float", "1e6",
+                "--option-x-switch",
+                "--option-x-nargs", "dummy_1",
+                "--option-x-nargs", "dummy_2",
+            ],
+            [],
+            [
+                ("option_x_str", "dummy"),
+                ("option_x_int", 1),
+                ("option_x_float", 1e6),
+                ("option_x_switch", True),
+                ("option_x_nargs", ["dummy_1", "dummy_2"]),
+            ],
+        ),
+        (
+            ["foo"],
+            ["foo"],
+            [
+                ("option_foo_str", ""),
+                ("option_foo_int", 0),
+                ("option_foo_float", 0.0),
+                ("option_foo_switch", False),
+                ("option_foo_nargs", []),
+            ],
+        ),
+        (
+            [
+                "foo", "baz",
+                "--option-foo-baz-str", "dummy",
+                "--option-foo-baz-int", "1",
+                "--option-foo-baz-float", "1e6",
+                "--option-foo-baz-switch",
+                "--option-foo-baz-nargs", "dummy_1",
+                "--option-foo-baz-nargs", "dummy_2",
+            ],
+            ["foo", "baz"],
+            [
+                ("option_foo_baz_str", "dummy"),
+                ("option_foo_baz_int", 1),
+                ("option_foo_baz_float", 1e6),
+                ("option_foo_baz_switch", True),
+                ("option_foo_baz_nargs", ["dummy_1", "dummy_2"]),
+            ],
+        ),
+        (
+            [
+                "baz", "foo",
+                "--option-baz-foo-str", "dummy",
+                "--option-baz-foo-int", "1",
+                "--option-baz-foo-float", "1e6",
+                "--option-baz-foo-switch",
+                "--option-baz-foo-nargs", "dummy_1",
+                "--option-baz-foo-nargs", "dummy_2",
+            ],
+            ["baz", "foo"],
+            [
+                ("option_baz_foo_str", "dummy"),
+                ("option_baz_foo_int", 1),
+                ("option_baz_foo_float", 1e6),
+                ("option_baz_foo_switch", True),
+                ("option_baz_foo_nargs", ["dummy_1", "dummy_2"]),
+            ],
+        ),
+        (
+            [
+                "baz", "bar", "foo",
+                "--option-baz-bar-foo-str", "dummy",
+                "--option-baz-bar-foo-int", "1",
+                "--option-baz-bar-foo-float", "1e6",
+                "--option-baz-bar-foo-switch",
+                "--option-baz-bar-foo-nargs", "dummy_1",
+                "--option-baz-bar-foo-nargs", "dummy_2",
+            ],
+            ["baz", "bar", "foo"],
+            [
+                ("option_baz_bar_foo_str", "dummy"),
+                ("option_baz_bar_foo_int", 1),
+                ("option_baz_bar_foo_float", 1e6),
+                ("option_baz_bar_foo_switch", True),
+                ("option_baz_bar_foo_nargs", ["dummy_1", "dummy_2"]),
+            ],
+        ),
+    )
+    @ddt.unpack
+    def test_parser_tree(self, args, expect_commands, expect_options):
+        commands, args = dummy_parser_tree().parse_args(args)
+        self.assertEqual(commands, expect_commands)
+        for key, value in expect_options:
+            self.assertEqual(getattr(args, key), value)
+
+    @ddt.data(
+        (["foo", "foo"],),
+        (["foo", "--option-x-switch"],),
+        (["foo", "bar", "--option-bar-foo-switch"],),
+        (["baz", "foo", "bar"],),
+    )
+    @ddt.unpack
+    def test_parser_tree__exception(self, args):
+        with pytest.raises(argparse.ArgumentError):
+            dummy_parser_tree().parse_args(args)

{iker_python_common-1.0.6 → iker_python_common-1.0.8}/test/iker_tests/common/utils/dbutils_test.py

@@ -12,7 +12,7 @@ from sqlalchemy.exc import IntegrityError
 from sqlalchemy.orm import DeclarativeBase, Mapped, MappedAsDataclass
 from sqlalchemy.orm.exc import FlushError
 
-from iker.common.utils.dbutils import DBAdapter
+from iker.common.utils.dbutils import ConnectionMaker
 from iker.common.utils.dbutils import mysql_insert_ignore, postgresql_insert_on_conflict_do_nothing
 from iker.common.utils.dbutils import orm_clone
 from iker.common.utils.funcutils import unique_returns
@@ -107,18 +107,18 @@ class PostgresqlDummyRecord(PostgresqlBaseModel):
 
 
 @pytest.mark.skipif(sys.platform == "win32", reason="Test not applicable on Windows")
-def test_mysql_adapter(fixture_mysql_test_proc, fixture_mysql_test):
-    adapter = DBAdapter(DBAdapter.Drivers.Mysql,
-                        "127.0.0.1",
-                        fixture_mysql_test_proc.port,
-                        fixture_mysql_test_proc.user,
-                        None,
-                        "test",
-                        session_opts=dict(
-                            expire_on_commit=False,
-                        ))
-
-    adapter.create_model(MysqlBaseModel)
+def test_mysql_connection_maker(fixture_mysql_test_proc, fixture_mysql_test):
+    maker = ConnectionMaker(ConnectionMaker.Drivers.Mysql,
+                            "127.0.0.1",
+                            fixture_mysql_test_proc.port,
+                            fixture_mysql_test_proc.user,
+                            None,
+                            "test",
+                            session_opts=dict(
+                                expire_on_commit=False,
+                            ))
+
+    maker.create_model(MysqlBaseModel)
 
     rng = randomizer()
 
@@ -144,28 +144,28 @@ def test_mysql_adapter(fixture_mysql_test_proc, fixture_mysql_test):
             dummy_unique_string=dummy_unique_string(),
         )
 
-    with adapter.make_session() as session:
+    with maker.make_session() as session:
         original_records = [random_record() for _ in range(0, 1000)]
         session.bulk_save_objects(original_records, return_defaults=True)
         session.commit()
 
-    with adapter.make_session() as session:
+    with maker.make_session() as session:
         count = session.query(sqlalchemy.func.count()).select_from(MysqlDummyRecord).scalar()
 
     assert count == 1000
 
-    with adapter.make_session() as session:
+    with maker.make_session() as session:
         delete_rows = session.query(MysqlDummyRecord).order_by(MysqlDummyRecord.dummy_id).offset(500).all()
         for delete_row in delete_rows:
             session.delete(delete_row)
         session.commit()
 
-    with adapter.make_session() as session:
+    with maker.make_session() as session:
         count = session.query(sqlalchemy.func.count()).select_from(MysqlDummyRecord).scalar()
 
     assert count == 500
 
-    with adapter.make_session() as session:
+    with maker.make_session() as session:
         records = session.query(MysqlDummyRecord).order_by(MysqlDummyRecord.dummy_id).all()
 
     for expect, actual in zip(original_records[:count], records[:count]):
@@ -189,12 +189,12 @@ def test_mysql_adapter(fixture_mysql_test_proc, fixture_mysql_test):
 
     mysql_insert_ignore()
 
-    with adapter.make_session() as session:
+    with maker.make_session() as session:
         # PK violation, but suppressed by the compiler plugin
         session.add(orm_clone(result))
         session.commit()
 
-    with adapter.make_session() as session:
+    with maker.make_session() as session:
         # Unique index violation, but suppressed by the plugin
         # Unlike the Postgresql implementation, MySQL will not raise a 'FlushError'.
         # Instead, it will fill the auto increment column with zero
@@ -203,34 +203,34 @@ def test_mysql_adapter(fixture_mysql_test_proc, fixture_mysql_test):
 
     mysql_insert_ignore(enabled=False)
 
-    with adapter.make_session() as session:
+    with maker.make_session() as session:
         # PK violation, which causes 'IntegrityError'
         with pytest.raises(IntegrityError):
             session.add(orm_clone(result))
             session.commit()
 
-    with adapter.make_session() as session:
+    with maker.make_session() as session:
         # Unique index violation, which causes 'IntegrityError'
         with pytest.raises(IntegrityError):
             session.add(orm_clone(result, no_autoincrement=True))
             session.commit()
 
-    adapter.drop_model(MysqlBaseModel)
+    maker.drop_model(MysqlBaseModel)
 
 
 @pytest.mark.skipif(sys.platform == "win32", reason="Test not applicable on Windows")
-def test_postgresql_adapter(fixture_postgresql_test_proc, fixture_postgresql_test):
-    adapter = DBAdapter(DBAdapter.Drivers.Postgresql,
-                        fixture_postgresql_test.info.host,
-                        fixture_postgresql_test.info.port,
-                        fixture_postgresql_test.info.user,
-                        None,
-                        fixture_postgresql_test.info.dbname,
-                        session_opts=dict(
-                            expire_on_commit=False,
-                        ))
-
-    adapter.create_model(PostgresqlBaseModel)
+def test_postgresql_connection_maker(fixture_postgresql_test_proc, fixture_postgresql_test):
+    maker = ConnectionMaker(ConnectionMaker.Drivers.Postgresql,
+                            fixture_postgresql_test.info.host,
+                            fixture_postgresql_test.info.port,
+                            fixture_postgresql_test.info.user,
+                            None,
+                            fixture_postgresql_test.info.dbname,
+                            session_opts=dict(
+                                expire_on_commit=False,
+                            ))
+
+    maker.create_model(PostgresqlBaseModel)
 
     rng = randomizer()
 
@@ -260,28 +260,28 @@ def test_postgresql_adapter(fixture_postgresql_test_proc, fixture_postgresql_tes
             dummy_unique_string=dummy_unique_string(),
         )
 
-    with adapter.make_session() as session:
+    with maker.make_session() as session:
         original_records = [random_record() for _ in range(0, 1000)]
         session.bulk_save_objects(original_records, return_defaults=True)
         session.commit()
 
-    with adapter.make_session() as session:
+    with maker.make_session() as session:
         count = session.query(sqlalchemy.func.count()).select_from(PostgresqlDummyRecord).scalar()
 
     assert count == 1000
 
-    with adapter.make_session() as session:
+    with maker.make_session() as session:
         delete_rows = session.query(PostgresqlDummyRecord).order_by(PostgresqlDummyRecord.dummy_id).offset(500).all()
         for delete_row in delete_rows:
             session.delete(delete_row)
         session.commit()
 
-    with adapter.make_session() as session:
+    with maker.make_session() as session:
         count = session.query(sqlalchemy.func.count()).select_from(PostgresqlDummyRecord).scalar()
 
     assert count == 500
 
-    with adapter.make_session() as session:
+    with maker.make_session() as session:
         records = session.query(PostgresqlDummyRecord).order_by(PostgresqlDummyRecord.dummy_id).all()
 
     for expect, actual in zip(original_records[:count], records[:count]):
@@ -309,12 +309,12 @@ def test_postgresql_adapter(fixture_postgresql_test_proc, fixture_postgresql_tes
 
     postgresql_insert_on_conflict_do_nothing()
 
-    with adapter.make_session() as session:
+    with maker.make_session() as session:
         # PK violation, but suppressed by the compiler plugin
         session.add(orm_clone(result))
         session.commit()
 
-    with adapter.make_session() as session:
+    with maker.make_session() as session:
         # Unique index violation, but suppressed by the plugin
         # However, since insertion is not performed, it fails to return and
         # flush the auto-generated primary key of the ORM, which raises 'FlushError'
@@ -324,16 +324,16 @@ def test_postgresql_adapter(fixture_postgresql_test_proc, fixture_postgresql_tes
 
     postgresql_insert_on_conflict_do_nothing(enabled=False)
 
-    with adapter.make_session() as session:
+    with maker.make_session() as session:
         # PK violation, which causes 'IntegrityError'
         with pytest.raises(IntegrityError):
             session.add(orm_clone(result))
             session.commit()
 
-    with adapter.make_session() as session:
+    with maker.make_session() as session:
         # Unique index violation, which causes 'IntegrityError'
         with pytest.raises(IntegrityError):
             session.add(orm_clone(result, no_autoincrement=True))
             session.commit()
 
-    adapter.drop_model(PostgresqlBaseModel)
+    maker.drop_model(PostgresqlBaseModel)

{iker_python_common-1.0.6 → iker_python_common-1.0.8}/test/iker_tests/common/utils/strutils_test.py

@@ -206,21 +206,28 @@ class StrUtilsTest(unittest.TestCase):
         (" \t", {}),
         ("foo=bar", {"foo": "bar"}),
         (
-            "dummy_key_1=dummy_value,dummy_key_2=dummy_value_2",
-            {"dummy_key_1": "dummy_value", "dummy_key_2": "dummy_value_2"},
+            "dummy_key_1=dummy_value_1,dummy_key_2=dummy_value_2",
+            {"dummy_key_1": "dummy_value_1", "dummy_key_2": "dummy_value_2"},
         ),
         (
-            "dummy_key_1=dummy_value,dummy_key_2=dummy_value_2,dummy_key_3",
-            {"dummy_key_1": "dummy_value", "dummy_key_2": "dummy_value_2", "dummy_key_3": "True"},
+            "dummy_key_1=dummy_value_1,dummy_key_2=dummy_value_2,dummy_key_3",
+            {"dummy_key_1": "dummy_value_1", "dummy_key_2": "dummy_value_2", "dummy_key_3": "True"},
         ),
         (
-            "dummy_key_1=dummy_value,dummy_key_2=dummy_value_2,dummy_key_3=do not use spaces in strings CLI",
+            "dummy_key_1=dummy_value_1,dummy_key_2=dummy_value_2,dummy_key_3=do not use spaces in strings CLI",
             {
-                "dummy_key_1": "dummy_value",
+                "dummy_key_1": "dummy_value_1",
                 "dummy_key_2": "dummy_value_2",
                 "dummy_key_3": "do not use spaces in strings CLI",
             },
         ),
+        (
+            "dummy_key_1=dummy_value_1_key=dummy_value_1_value,dummy_key_2=dummy_value_2_key=dummy_value_2_value",
+            {
+                "dummy_key_1": "dummy_value_1_key=dummy_value_1_value",
+                "dummy_key_2": "dummy_value_2_key=dummy_value_2_value",
+            },
+        ),
     )
     @ddt.unpack
     def test_parse_params_string(self, s, params_dict):