iker-python-common 1.0.45__tar.gz → 1.0.46__tar.gz

{iker_python_common-1.0.45 → iker_python_common-1.0.46}/PKG-INFO

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

{iker_python_common-1.0.45 → iker_python_common-1.0.46}/src/iker/common/utils/sequtils.py

@@ -558,6 +558,18 @@ class Seq(Generic[Tco], Sequence[Tco], Sized):
     def concat(self: SeqT, other: SeqT) -> SeqT:
         return type(self)(itertools.chain(self.data, other.data))
 
+    def pad_left(self: SeqT, n: int, value: Tco) -> SeqT:
+        return self if n <= 0 else type(self)(itertools.repeat(value, n)).concat(self)
+
+    def pad_right(self: SeqT, n: int, value: Tco) -> SeqT:
+        return self if n <= 0 else self.concat(type(self)(itertools.repeat(value, n)))
+
+    def pad_left_head(self: SeqT, n: int) -> SeqT:
+        return self if self.empty else self.pad_left(n, head(self.data))
+
+    def pad_right_last(self: SeqT, n: int) -> SeqT:
+        return self if self.empty else self.pad_right(n, last(self.data))
+
     def take_left(self: SeqT, n: int) -> SeqT:
         if n <= 0:
             return type(self)([])

{iker_python_common-1.0.45 → iker_python_common-1.0.46}/src/iker_python_common.egg-info/PKG-INFO

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

{iker_python_common-1.0.45 → iker_python_common-1.0.46}/test/iker_tests/common/utils/sequtils_test.py

@@ -1108,6 +1108,106 @@ class SeqTest(unittest.TestCase):
         actual = seq(data).count_if(func)
         self.assertEqual(actual, expect)
 
+    data_pad_left = [
+        ([], 0, -1, []),
+        ([], -1, -1, []),
+        ([], 1, -1, [-1]),
+        ([], 5, -1, [-1, -1, -1, -1, -1]),
+        ([0], 0, -1, [0]),
+        ([0], -1, -1, [0]),
+        ([0], 1, -1, [-1, 0]),
+        ([0], 5, -1, [-1, -1, -1, -1, -1, 0]),
+        ([0, 0, 0], 0, -1, [0, 0, 0]),
+        ([0, 0, 0], -1, -1, [0, 0, 0]),
+        ([0, 0, 0], 1, -1, [-1, 0, 0, 0]),
+        ([0, 0, 0], 5, -1, [-1, -1, -1, -1, -1, 0, 0, 0]),
+        ([1, 2, 3, 4, 5], 0, -1, [1, 2, 3, 4, 5]),
+        ([1, 2, 3, 4, 5], -1, -1, [1, 2, 3, 4, 5]),
+        ([1, 2, 3, 4, 5], 1, -1, [-1, 1, 2, 3, 4, 5]),
+        ([1, 2, 3, 4, 5], 5, -1, [-1, -1, -1, -1, -1, 1, 2, 3, 4, 5]),
+    ]
+
+    @ddt.idata(data_pad_left)
+    @ddt.unpack
+    def test_pad_left(self, data, n, value, expect):
+        actual = seq(data).pad_left(n, value)
+        self.assertEqual(actual.data, expect)
+
+    data_pad_right = [
+        ([], 0, -1, []),
+        ([], -1, -1, []),
+        ([], 1, -1, [-1]),
+        ([], 5, -1, [-1, -1, -1, -1, -1]),
+        ([0], 0, -1, [0]),
+        ([0], -1, -1, [0]),
+        ([0], 1, -1, [0, -1]),
+        ([0], 5, -1, [0, -1, -1, -1, -1, -1]),
+        ([0, 0, 0], 0, -1, [0, 0, 0]),
+        ([0, 0, 0], -1, -1, [0, 0, 0]),
+        ([0, 0, 0], 1, -1, [0, 0, 0, -1]),
+        ([0, 0, 0], 5, -1, [0, 0, 0, -1, -1, -1, -1, -1]),
+        ([1, 2, 3, 4, 5], 0, -1, [1, 2, 3, 4, 5]),
+        ([1, 2, 3, 4, 5], -1, -1, [1, 2, 3, 4, 5]),
+        ([1, 2, 3, 4, 5], 1, -1, [1, 2, 3, 4, 5, -1]),
+        ([1, 2, 3, 4, 5], 5, -1, [1, 2, 3, 4, 5, -1, -1, -1, -1, -1]),
+    ]
+
+    @ddt.idata(data_pad_right)
+    @ddt.unpack
+    def test_pad_right(self, data, n, value, expect):
+        actual = seq(data).pad_right(n, value)
+        self.assertEqual(actual.data, expect)
+
+    data_pad_left_head = [
+        ([], 0, []),
+        ([], -1, []),
+        ([], 1, []),
+        ([], 5, []),
+        ([0], 0, [0]),
+        ([0], -1, [0]),
+        ([0], 1, [0, 0]),
+        ([0], 5, [0, 0, 0, 0, 0, 0]),
+        ([0, 0, 0], 0, [0, 0, 0]),
+        ([0, 0, 0], -1, [0, 0, 0]),
+        ([0, 0, 0], 1, [0, 0, 0, 0]),
+        ([0, 0, 0], 5, [0, 0, 0, 0, 0, 0, 0, 0]),
+        ([1, 2, 3, 4, 5], 0, [1, 2, 3, 4, 5]),
+        ([1, 2, 3, 4, 5], -1, [1, 2, 3, 4, 5]),
+        ([1, 2, 3, 4, 5], 1, [1, 1, 2, 3, 4, 5]),
+        ([1, 2, 3, 4, 5], 5, [1, 1, 1, 1, 1, 1, 2, 3, 4, 5]),
+    ]
+
+    @ddt.idata(data_pad_left_head)
+    @ddt.unpack
+    def test_pad_left_head(self, data, n, expect):
+        actual = seq(data).pad_left_head(n)
+        self.assertEqual(actual.data, expect)
+
+    data_pad_right_last = [
+        ([], 0, []),
+        ([], -1, []),
+        ([], 1, []),
+        ([], 5, []),
+        ([0], 0, [0]),
+        ([0], -1, [0]),
+        ([0], 1, [0, 0]),
+        ([0], 5, [0, 0, 0, 0, 0, 0]),
+        ([0, 0, 0], 0, [0, 0, 0]),
+        ([0, 0, 0], -1, [0, 0, 0]),
+        ([0, 0, 0], 1, [0, 0, 0, 0]),
+        ([0, 0, 0], 5, [0, 0, 0, 0, 0, 0, 0, 0]),
+        ([1, 2, 3, 4, 5], 0, [1, 2, 3, 4, 5]),
+        ([1, 2, 3, 4, 5], -1, [1, 2, 3, 4, 5]),
+        ([1, 2, 3, 4, 5], 1, [1, 2, 3, 4, 5, 5]),
+        ([1, 2, 3, 4, 5], 5, [1, 2, 3, 4, 5, 5, 5, 5, 5, 5]),
+    ]
+
+    @ddt.idata(data_pad_right_last)
+    @ddt.unpack
+    def test_pad_right_last(self, data, n, expect):
+        actual = seq(data).pad_right_last(n)
+        self.assertEqual(actual.data, expect)
+
     data_take_left = [
         ([], 0, []),
         ([], 1, []),
@@ -1299,8 +1399,16 @@ class SeqTest(unittest.TestCase):
          lambda xs: "".join(xs),
          (True, True),
          ["1", "12", "123", "234", "345", "45", "5"]),
-        (["1", "2", "3", "4", "5"], 3, lambda xs: "".join(xs), (True, False), ["1", "12", "123", "234", "345"]),
-        (["1", "2", "3", "4", "5"], 3, lambda xs: "".join(xs), (False, True), ["123", "234", "345", "45", "5"]),
+        (["1", "2", "3", "4", "5"],
+         3,
+         lambda xs: "".join(xs),
+         (True, False),
+         ["1", "12", "123", "234", "345"]),
+        (["1", "2", "3", "4", "5"],
+         3,
+         lambda xs: "".join(xs),
+         (False, True),
+         ["123", "234", "345", "45", "5"]),
         (["1", "2", "3", "4", "5"],
          5,
          lambda xs: "".join(xs),
@@ -1466,8 +1574,16 @@ class SeqTest(unittest.TestCase):
          lambda xs: "".join(xs),
          (True, True),
          ["5", "45", "345", "234", "123", "12", "1"]),
-        (["1", "2", "3", "4", "5"], 3, lambda xs: "".join(xs), (True, False), ["345", "234", "123", "12", "1"]),
-        (["1", "2", "3", "4", "5"], 3, lambda xs: "".join(xs), (False, True), ["5", "45", "345", "234", "123"]),
+        (["1", "2", "3", "4", "5"],
+         3,
+         lambda xs: "".join(xs),
+         (True, False),
+         ["345", "234", "123", "12", "1"]),
+        (["1", "2", "3", "4", "5"],
+         3,
+         lambda xs: "".join(xs),
+         (False, True),
+         ["5", "45", "345", "234", "123"]),
         (["1", "2", "3", "4", "5"],
          5,
          lambda xs: "".join(xs),