iker-python-common 1.0.26__tar.gz → 1.0.28__tar.gz

{iker_python_common-1.0.26 → iker_python_common-1.0.28}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: iker-python-common
-Version: 1.0.26
+Version: 1.0.28
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12

{iker_python_common-1.0.26 → iker_python_common-1.0.28}/src/iker/common/utils/argutils.py

@@ -63,7 +63,7 @@ class ParserTree(object):
         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))
+                raise argparse.ArgumentError(None, f"unrecognized arguments '{unknown_args}'")
 
         command_pairs = []
         namespace = argparse.Namespace()

{iker_python_common-1.0.26 → iker_python_common-1.0.28}/src/iker/common/utils/dockerutils.py

@@ -1,6 +1,6 @@
 import contextlib
 import re
-from collections.abc import Generator, Iterable
+from collections.abc import Generator, Iterator
 from dataclasses import dataclass
 from typing import Any
 
@@ -89,7 +89,7 @@ def docker_build_image(
     path: str,
     dockerfile: str,
     build_args: dict[str, str],
-) -> tuple[docker.models.images.Image, Iterable[Any]]:
+) -> tuple[docker.models.images.Image, Iterator[dict[str, str]]]:
     try:
         return client.images.build(tag=tag,
                                    path=path,
@@ -188,21 +188,20 @@ def docker_run_detached(
         except docker.errors.DockerException:
             raise
         finally:
-            if container_model is None:
-                return
-            try:
-                if container_model.status != "exited":
+            if container_model is not None:
+                try:
+                    if container_model.status != "exited":
+                        try:
+                            container_model.stop()
+                        except docker.errors.DockerException:
+                            pass
+                    container_model.wait()
                     try:
-                        container_model.stop()
+                        container_model.remove()
                     except docker.errors.DockerException:
                         pass
-                container_model.wait()
-                try:
-                    container_model.remove()
-                except docker.errors.DockerException:
-                    pass
-            except Exception:
-                raise
+                except Exception:
+                    raise
 
     try:
         run_args = kwargs.copy()

{iker_python_common-1.0.26 → iker_python_common-1.0.28}/src/iker/common/utils/dtutils.py

@@ -151,7 +151,7 @@ def dt_parse(dt_str: str, fmt_str: str | list[str] | tuple[str, ...]) -> datetim
                 return dt_parse(dt_str, s)
             except ValueError:
                 pass
-        raise ValueError("time data <%s> does not match the given formats" % dt_str)
+        raise ValueError(f"time data '{dt_str}' does not match the given formats")
     else:
         raise ValueError("malformed format")
 

{iker_python_common-1.0.26 → iker_python_common-1.0.28}/src/iker/common/utils/randutils.py

@@ -8,6 +8,7 @@ from typing import TypeVar
 
 from iker.common.utils.dtutils import dt_utc_max, dt_utc_min
 from iker.common.utils.funcutils import memorized, singleton
+from iker.common.utils.jsonutils import JsonType
 from iker.common.utils.sequtils import head_or_none
 
 __all__ = [
@@ -39,16 +40,16 @@ class Randomizer(object):
         return self.random.getrandbits(1) == 1
 
     def next_int(self, lo: int = 0, hi: int = max_int()) -> int:
-        assert lo < hi, "The lower bound must be smaller than the upper bound"
+        assert lo < hi, "the lower bound must be smaller than the upper bound"
         return self.random.randrange(lo, hi)
 
     def next_float(self, lo: float = 0.0, hi: float = 1.0) -> float:
-        assert lo <= hi, "The lower bound must be not greater than the upper bound"
-        assert not math.isinf(hi - lo), "The range between the lower bound and the upper bound exceeded the float range"
+        assert lo <= hi, "the lower bound must be not greater than the upper bound"
+        assert not math.isinf(hi - lo), "the range between the lower bound and the upper bound exceeded the float range"
         return lo + (hi - lo) * self.random.random()
 
     def next_fixed(self, precision: int = 7) -> float:
-        assert precision >= 0, "The precision must be non-negative"
+        assert precision >= 0, "the precision must be non-negative"
         width = 2 ** precision
         return self.next_int(0, width) / width
 
@@ -56,7 +57,7 @@ class Randomizer(object):
         return self.random.gauss(mu, sigma)
 
     def random_string(self, chars: str, length: int) -> str:
-        assert length >= 0, "Length of the random string must be non-negative"
+        assert length >= 0, "length of the random string must be non-negative"
         if length == 0:
             return ""
         return "".join(self.random.choices(chars, k=length))
@@ -75,14 +76,15 @@ class Randomizer(object):
     def random_oct(self, length: int) -> str:
         return self.random_string(string.octdigits, length).upper()
 
-    def random_unit_vector(self, dim: int) -> list[float]:
-        assert dim > 0, "Dimension of the random unit vector must be positive"
+    def random_unit_vector(self, length: int) -> list[float]:
+        assert length > 0, "length of the random unit vector must be positive"
         while True:
-            v = [self.next_gaussian() for _ in range(dim)]
+            v = [self.next_gaussian() for _ in range(length)]
             n = sum(x * x for x in v) ** 0.5
             if n < 1.0e-9:
                 continue
             return [x / n for x in v]
+        return [1.0]
 
     def random_datetime(
         self,
@@ -117,7 +119,7 @@ class Randomizer(object):
         key_length: int = 5,
         value_chars: str = string.ascii_letters,
         value_length: int = 5,
-    ) -> object:
+    ) -> JsonType:
         choices = [list, dict, int, float, bool, str, None]
         root_choices = [list, dict]
         leaf_choices = [int, float, bool, str, None]

{iker_python_common-1.0.26 → iker_python_common-1.0.28}/src/iker/common/utils/strutils.py

@@ -62,11 +62,11 @@ def parse_bool(v: Any) -> bool:
             return True
         if v.lower() in ["false", "no", "off", "0", "n"]:
             return False
-        raise ValueError("not a valid boolean literal <%s>" % v)
+        raise ValueError(f"not a valid boolean literal '{v}'")
     elif isinstance(v, bool):
         return v
     else:
-        raise ValueError("type <%s> is not convertible to bool" % type(v))
+        raise ValueError(f"type '{type(v)}' is not convertible to bool")
 
 
 def parse_bool_or(v: Any, default: bool | None = False) -> bool | None:
@@ -154,7 +154,7 @@ def parse_params_string(
                     continue
                 result[key] = str_parser(value)
             case _:
-                raise ValueError("malformed param <%s>" % param)
+                raise ValueError(f"malformed param '{param}'")
     return result
 
 

{iker_python_common-1.0.26 → iker_python_common-1.0.28}/src/iker/common/utils/testutils.py

@@ -113,42 +113,42 @@ class CalleeMock(ABC):
         return list(index for index, c in enumerate(self.calls) if c == call)
 
     def assert_not_called(self):
-        assert self.count_calls() == 0, "Failed not called"
+        assert self.count_calls() == 0, "failed not called"
 
     def assert_called(self):
-        assert self.count_calls() > 0, "Failed called"
+        assert self.count_calls() > 0, "failed called"
 
     def assert_called_once(self):
-        assert self.count_calls() == 1, "Failed called once"
+        assert self.count_calls() == 1, "failed called once"
 
     def assert_called_times(self, count: int):
-        assert self.count_calls() == count, "Failed called {} times".format(count)
+        assert self.count_calls() == count, f"failed called {count} times"
 
     def assert_not_called_with(self):
         def assertion(*args, **kwargs):
             call = (args, kwargs)
-            assert self.count_calls_with(call) == 0, "Failed not called with {}".format(call)
+            assert self.count_calls_with(call) == 0, f"failed not called with {call}"
 
         return assertion
 
     def assert_called_with(self):
         def assertion(*args, **kwargs):
             call = (args, kwargs)
-            assert self.count_calls_with(call) > 0, "Failed called with {}".format(call)
+            assert self.count_calls_with(call) > 0, f"failed called with {call}"
 
         return assertion
 
     def assert_called_once_with(self):
         def assertion(*args, **kwargs):
             call = (args, kwargs)
-            assert self.count_calls_with(call) == 1, "Failed called once with {}".format(call)
+            assert self.count_calls_with(call) == 1, f"failed called once with {call}"
 
         return assertion
 
     def assert_called_times_with(self, count: int):
         def assertion(*args, **kwargs):
             call = (args, kwargs)
-            assert self.count_calls_with(call) == count, "Failed called {} times with {}".format(count, call)
+            assert self.count_calls_with(call) == count, f"failed called {count} times with {call}"
 
         return assertion
 

{iker_python_common-1.0.26 → iker_python_common-1.0.28}/src/iker_python_common.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: iker-python-common
-Version: 1.0.26
+Version: 1.0.28
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12

{iker_python_common-1.0.26 → iker_python_common-1.0.28}/test/iker_tests/common/utils/dockerutils_test.py

@@ -189,7 +189,7 @@ class DockerUtilsTest(unittest.TestCase):
                                                   labels_callee=return_callee("dummy_labels"))
             mock_docker_client.return_value.images.build.return_value = (
                 mock_docker_image,
-                {"dummy_key": "dummy_value"},
+                [{"dummy-log-key": "dummy-log-value"}],
             )
 
             image_model, build_logs = docker_build_image(mock_docker_client.return_value,
@@ -201,7 +201,7 @@ class DockerUtilsTest(unittest.TestCase):
             self.assertEqual(image_model.id, "dummy_image")
             self.assertEqual(image_model.tags, "dummy_tags")
             self.assertEqual(image_model.labels, "dummy_labels")
-            self.assertEqual(build_logs, {"dummy_key": "dummy_value"})
+            self.assertEqual(build_logs, [{"dummy-log-key": "dummy-log-value"}])
 
             mock_docker_client.return_value.images.build.assert_called_with(tag="dummy_tag",
                                                                             path="dummy_path",
@@ -212,7 +212,7 @@ class DockerUtilsTest(unittest.TestCase):
                                                                             nocache=True)
 
     @ddt.data(
-        (docker.errors.BuildError("dummy reason", iter([{"dummy-log-key": "dummy log"}])),),
+        (docker.errors.BuildError("dummy reason", iter([{"dummy-log-key": "dummy-log-value"}])),),
         (docker.errors.APIError("dummy message"),),
         (Exception(),),
     )