iker-python-common 1.0.18__tar.gz → 1.0.19__tar.gz

{iker_python_common-1.0.18 → iker_python_common-1.0.19}/PKG-INFO

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

iker_python_common-1.0.19/resources/unittest/config/config.cfg

@@ -0,0 +1,10 @@
+[dummy_section_1]
+dummy_option_1 = True
+dummy_option_2 = False
+dummy_option_3 = 1
+dummy_option_4 = -1
+dummy_option_5 = 1.0
+dummy_option_6 = -1.0
+dummy_option_7 = 1.e+0
+dummy_option_8 = -1.e-0
+dummy_option_9 = dummy_value_alpha

{iker_python_common-1.0.18 → iker_python_common-1.0.19}/src/iker/common/utils/config.py

@@ -1,4 +1,5 @@
 import configparser
+import os.path
 from typing import Self
 
 from iker.common.utils import logger
@@ -25,7 +26,9 @@ class Config(object):
         if is_blank(self.config_path):
             return False
         try:
-            self.config_parser.read(self.config_path)
+            if not os.path.exists(self.config_path):
+                raise IOError("file not found")
+            self.config_parser.read(self.config_path, encoding="utf-8")
             return True
         except IOError as e:
             logger.exception("Failed to restore config from file <%s>", self.config_path)

{iker_python_common-1.0.18 → iker_python_common-1.0.19}/src/iker/common/utils/sequtils.py

@@ -234,9 +234,13 @@ class Seq(Generic[Tco], Sequence[Tco], Sized):
         return Seq(self.data + other.data)
 
     def take_left(self, n: int) -> Self:
+        if n <= 0:
+            return Seq([])
         return self[:n]
 
     def take_right(self, n: int) -> Self:
+        if n <= 0:
+            return Seq([])
         return self[-n:]
 
     take = take_left
@@ -319,14 +323,14 @@ class Seq(Generic[Tco], Sequence[Tco], Sized):
     def map_values(self, func: Callable[[Tco], U]) -> Self:
         return Seq((key, func(value)) for key, value in self.data)
 
-    def flatten(self):
+    def flat_map(self, func: Callable[[Tco], Iterable[U]]) -> "Seq[U]":
         data = []
         for d in self.data:
-            data.extend(d)
+            data.extend(func(d))
         return Seq(data)
 
-    def flat_map(self, func: Callable[[Tco], U]) -> "Seq[U]":
-        return self.flatten().map(func)
+    def flatten(self):
+        return self.flat_map(lambda x: list(x))
 
     def group_map(self, group_func: Callable[[Tco], K], map_func: Callable[[Tco], U]) -> "Seq[tuple[K, list[U]]]":
         return self.group(group_func).map_values(lambda x: list(map(map_func, x)))

{iker_python_common-1.0.18 → iker_python_common-1.0.19}/src/iker_python_common.egg-info/PKG-INFO

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

{iker_python_common-1.0.18 → iker_python_common-1.0.19}/src/iker_python_common.egg-info/SOURCES.txt

@@ -7,6 +7,7 @@ pyproject.toml
 setup.py
 .github/workflows/pr.yml
 .github/workflows/push.yml
+resources/unittest/config/config.cfg
 resources/unittest/csv/data.csv
 resources/unittest/csv/data.tsv
 resources/unittest/shutils/dir.baz/file.bar.baz

{iker_python_common-1.0.18 → iker_python_common-1.0.19}/test/iker_tests/common/utils/config_test.py

@@ -1,8 +1,10 @@
+import os.path
 import unittest
 
 import ddt
 
 from iker.common.utils.config import Config, ConfigVisitor
+from iker_tests import resources_directory
 
 
 @ddt.ddt
@@ -12,6 +14,29 @@ class ConfigTest(unittest.TestCase):
         config = Config()
         self.assertEqual(len(config), 0)
 
+    def test_set(self):
+        config = Config()
+
+        tuples = [
+            ("dummy_section_1", "dummy_option_1", "True"),
+            ("dummy_section_1", "dummy_option_2", "False"),
+            ("dummy_section_1", "dummy_option_3", "1"),
+            ("dummy_section_1", "dummy_option_4", "-1"),
+            ("dummy_section_1", "dummy_option_5", "1.0"),
+            ("dummy_section_1", "dummy_option_6", "-1.0"),
+            ("dummy_section_1", "dummy_option_7", "1.e+0"),
+            ("dummy_section_1", "dummy_option_8", "-1.e-0"),
+            ("dummy_section_1", "dummy_option_9", "dummy_value_alpha"),
+        ]
+
+        for section, option, value in tuples:
+            config.set(section, option, value)
+
+        for section, option, value in tuples:
+            self.assertTrue(config.has_section(section))
+            self.assertTrue(config.has(section, option))
+            self.assertEqual(config.get(section, option), value)
+
     def test_update(self):
         config = Config()
 
@@ -271,7 +296,35 @@ class ConfigTest(unittest.TestCase):
         self.assertEqual(config.get("dummy_section_1", "dummy_option_9"), "dummy_value_alpha")
 
         self.assertFalse(config.restore())
+        self.assertEqual(len(config), 0)
+
+    def test_restore__from_file(self):
+        config = Config(os.path.join(resources_directory, "unittest/config/config.cfg"))
 
+        tuples = [
+            ("dummy_section_1", "dummy_option_1", "True"),
+            ("dummy_section_1", "dummy_option_2", "False"),
+            ("dummy_section_1", "dummy_option_3", "1"),
+            ("dummy_section_1", "dummy_option_4", "-1"),
+            ("dummy_section_1", "dummy_option_5", "1.0"),
+            ("dummy_section_1", "dummy_option_6", "-1.0"),
+            ("dummy_section_1", "dummy_option_7", "1.e+0"),
+            ("dummy_section_1", "dummy_option_8", "-1.e-0"),
+            ("dummy_section_1", "dummy_option_9", "dummy_value_alpha"),
+        ]
+
+        self.assertTrue(config.restore())
+        self.assertEqual(len(config), len(tuples))
+
+        for section, option, value in tuples:
+            self.assertTrue(config.has_section(section))
+            self.assertTrue(config.has(section, option))
+            self.assertEqual(config.get(section, option), value)
+
+    def test_restore__file_not_found(self):
+        config = Config(os.path.join(resources_directory, "unittest/config/missing_config.cfg"))
+
+        self.assertFalse(config.restore())
         self.assertEqual(len(config), 0)
 
     def test_persist(self):
@@ -302,7 +355,6 @@ class ConfigTest(unittest.TestCase):
         self.assertEqual(config.get("dummy_section_1", "dummy_option_9"), "dummy_value_alpha")
 
         self.assertFalse(config.persist())
-
         self.assertEqual(len(config), len(tuples))
 
 

{iker_python_common-1.0.18 → iker_python_common-1.0.19}/test/iker_tests/common/utils/dbutils_test.py

@@ -108,15 +108,15 @@ class PostgresqlDummyRecord(PostgresqlBaseModel):
 
 @pytest.mark.skipif(sys.platform == "win32", reason="Test not applicable on Windows")
 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,
-                            ))
+    scheme = ConnectionMaker.Drivers.Mysql
+    host = "127.0.0.1"
+    port = fixture_mysql_test_proc.port
+    user = fixture_mysql_test_proc.user
+    database = "test"
+
+    maker = ConnectionMaker.from_url(scheme,
+                                     f"{scheme}://{user}@{host}:{port}/{database}",
+                                     session_opts=dict(expire_on_commit=False))
 
     maker.create_model(MysqlBaseModel)
 
@@ -220,15 +220,15 @@ def test_mysql_connection_maker(fixture_mysql_test_proc, fixture_mysql_test):
 
 @pytest.mark.skipif(sys.platform == "win32", reason="Test not applicable on Windows")
 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,
-                            ))
+    scheme = ConnectionMaker.Drivers.Postgresql
+    host = fixture_postgresql_test.info.host
+    port = fixture_postgresql_test.info.port
+    user = fixture_postgresql_test.info.user
+    database = fixture_postgresql_test.info.dbname
+
+    maker = ConnectionMaker.from_url(scheme,
+                                     f"{scheme}://{user}@{host}:{port}/{database}",
+                                     session_opts=dict(expire_on_commit=False))
 
     maker.create_model(PostgresqlBaseModel)
 

{iker_python_common-1.0.18 → iker_python_common-1.0.19}/test/iker_tests/common/utils/sequtils_test.py

@@ -1,6 +1,7 @@
 import unittest
 
 import ddt
+import pytest
 
 from iker.common.utils.sequtils import batch_yield
 from iker.common.utils.sequtils import chunk, chunk_between, chunk_with_key, merge_chunks
@@ -789,6 +790,43 @@ class SeqUtilsTest(unittest.TestCase):
     def test_merge_chunks__drop_exclusive_end(self, data, merge_func, expect):
         self.assertEqual(expect, merge_chunks(data, merge_func=merge_func, drop_exclusive_end=True))
 
+
+@ddt.ddt
+class SeqTest(unittest.TestCase):
+
+    @ddt.data(
+        ([], []),
+        (seq([]), []),
+        (seq(seq([])), []),
+        ([0], [0]),
+        (seq([0]), [0]),
+        (seq(seq([0])), [0]),
+        ([1, 2, 3, 4, 5], [1, 2, 3, 4, 5]),
+        (seq([1, 2, 3, 4, 5]), [1, 2, 3, 4, 5]),
+        (seq(seq([1, 2, 3, 4, 5])), [1, 2, 3, 4, 5]),
+        (range(1, 6), [1, 2, 3, 4, 5]),
+        (seq(range(1, 6)), [1, 2, 3, 4, 5]),
+        (seq(seq(range(1, 6))), [1, 2, 3, 4, 5]),
+    )
+    @ddt.unpack
+    def test_builtin_init(self, data, expect):
+        self.assertEqual(seq(data).data, expect)
+
+    def test_builtin_init__unsupported_data_type(self):
+        with pytest.raises(ValueError):
+            seq(object())
+
+    @ddt.data(
+        ([], [], []),
+        ([0], [], [0]),
+        ([], [0], [0]),
+        ([1, 2, 3, 4, 5], [1, 2, 3, 4, 5], [1, 2, 3, 4, 5, 1, 2, 3, 4, 5]),
+    )
+    @ddt.unpack
+    def test_builtin_add(self, a, b, expect):
+        actual = seq(a) + seq(b)
+        self.assertEqual(actual.data, expect)
+
     @ddt.data(
         ([0], 0, [0]),
         ([1, 2, 3, 4, 5], 0, [1]),
@@ -801,17 +839,21 @@ class SeqUtilsTest(unittest.TestCase):
         ([1, 2, 3, 4, 5], slice(1, -1, 2), [2, 4]),
     )
     @ddt.unpack
-    def test_seq_builtin_getitem(self, data, item, expect):
+    def test_builtin_getitem(self, data, item, expect):
         actual = seq(data)[item]
         self.assertEqual(actual.data, expect)
 
+    def test_builtin_getitem__unsupported_index_type(self):
+        with pytest.raises(ValueError):
+            seq([])[object()]
+
     @ddt.data(
         ([], 0),
         ([0], 1),
         ([1, 2, 3, 4, 5], 5),
     )
     @ddt.unpack
-    def test_seq_builtin_len(self, data, expect):
+    def test_builtin_len(self, data, expect):
         actual = len(seq(data))
         self.assertEqual(actual, expect)
 
@@ -824,7 +866,7 @@ class SeqUtilsTest(unittest.TestCase):
         ([1, 2, 3, 4, 5], -1, False),
     )
     @ddt.unpack
-    def test_seq_builtin_contains(self, data, item, expect):
+    def test_builtin_contains(self, data, item, expect):
         actual = item in seq(data)
         self.assertEqual(actual, expect)
 
@@ -834,7 +876,7 @@ class SeqUtilsTest(unittest.TestCase):
         ([1, 2, 3, 4, 5], [1, 2, 3, 4, 5]),
     )
     @ddt.unpack
-    def test_seq_builtin_iter(self, data, expect):
+    def test_builtin_iter(self, data, expect):
         actual = list(x for x in seq(data))
         self.assertEqual(actual, expect)
 
@@ -844,7 +886,7 @@ class SeqUtilsTest(unittest.TestCase):
         ([1, 2, 3, 4, 5], [5, 4, 3, 2, 1]),
     )
     @ddt.unpack
-    def test_seq_builtin_reversed(self, data, expect):
+    def test_builtin_reversed(self, data, expect):
         actual = list(x for x in reversed(seq(data)))
         self.assertEqual(actual, expect)
 
@@ -859,7 +901,7 @@ class SeqUtilsTest(unittest.TestCase):
         ([1, 2, 3, 4, 5], -1, 0),
     )
     @ddt.unpack
-    def test_seq_count(self, data, item, expect):
+    def test_count(self, data, item, expect):
         actual = seq(data).count(item)
         self.assertEqual(actual, expect)
 
@@ -879,10 +921,65 @@ class SeqUtilsTest(unittest.TestCase):
         ([1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5], lambda x: x % 2 == 1, 9),
     )
     @ddt.unpack
-    def test_seq_count_if(self, data, func, expect):
+    def test_count_if(self, data, func, expect):
         actual = seq(data).count_if(func)
         self.assertEqual(actual, expect)
 
+    @ddt.data(
+        ([], 0, []),
+        ([], 1, []),
+        ([0], 0, []),
+        ([0], 1, [0]),
+        ([0], 2, [0]),
+        ([1, 2, 3, 4, 5], 0, []),
+        ([1, 2, 3, 4, 5], 1, [1]),
+        ([1, 2, 3, 4, 5], 5, [1, 2, 3, 4, 5]),
+        ([1, 2, 3, 4, 5], 6, [1, 2, 3, 4, 5]),
+    )
+    @ddt.unpack
+    def test_take_left(self, data, n, expect):
+        actual = seq(data).take_left(n)
+        self.assertEqual(actual.data, expect)
+
+    @ddt.data(
+        ([], 0, []),
+        ([], 1, []),
+        ([0], 0, []),
+        ([0], 1, [0]),
+        ([0], 2, [0]),
+        ([1, 2, 3, 4, 5], 0, []),
+        ([1, 2, 3, 4, 5], 1, [5]),
+        ([1, 2, 3, 4, 5], 5, [1, 2, 3, 4, 5]),
+        ([1, 2, 3, 4, 5], 6, [1, 2, 3, 4, 5]),
+    )
+    @ddt.unpack
+    def test_take_right(self, data, n, expect):
+        actual = seq(data).take_right(n)
+        self.assertEqual(actual.data, expect)
+
+    @ddt.data(
+        ([], []),
+        ([0], [0]),
+        ([0, 0, 0], [0, 0, 0]),
+        ([1, 2, 3, 4, 5], [5, 4, 3, 2, 1]),
+    )
+    @ddt.unpack
+    def test_reverse(self, data, expect):
+        actual = seq(data).reverse()
+        self.assertEqual(actual.data, expect)
+
+    @ddt.data(
+        ([], []),
+        ([0], [0]),
+        ([0, 0, 0], [0]),
+        ([1, 2, 3, 4, 5], [1, 2, 3, 4, 5]),
+        ([1, 2, 3, 4, 5, 1, 2, 3, 4, 1, 2, 3, 1, 2, 1], [1, 2, 3, 4, 5]),
+    )
+    @ddt.unpack
+    def test_distinct(self, data, expect):
+        actual = seq(data).distinct()
+        self.assertEqual(actual.data, expect)
+
     @ddt.data(
         ([], 0, lambda x, y: x, []),
         ([], None, lambda x, y: x, []),
@@ -892,7 +989,7 @@ class SeqUtilsTest(unittest.TestCase):
         ([1, 2, 3, 4, 5], 0, lambda x, y: x * 10 + y, [1, 12, 123, 1234, 12345]),
     )
     @ddt.unpack
-    def test_seq_scan_left(self, data, zero, func, expect):
+    def test_scan_left(self, data, zero, func, expect):
         actual = seq(data).scan_left(zero, func)
         self.assertEqual(actual.data, expect)
 
@@ -905,7 +1002,7 @@ class SeqUtilsTest(unittest.TestCase):
         ([1, 2, 3, 4, 5], 0, lambda x, y: x * 10 + y, [54321, 5432, 543, 54, 5]),
     )
     @ddt.unpack
-    def test_seq_scan_right(self, data, zero, func, expect):
+    def test_scan_right(self, data, zero, func, expect):
         actual = seq(data).scan_right(zero, func)
         self.assertEqual(actual.data, expect)
 
@@ -916,7 +1013,7 @@ class SeqUtilsTest(unittest.TestCase):
         ([1, 2, 3, 4, 5], lambda x: x ** 2, [1, 4, 9, 16, 25]),
     )
     @ddt.unpack
-    def test_seq_map(self, data, func, expect):
+    def test_map(self, data, func, expect):
         actual = seq(data).map(func)
         self.assertEqual(actual.data, expect)
 
@@ -929,7 +1026,7 @@ class SeqUtilsTest(unittest.TestCase):
         ([1, 2, 3, 4, 5], 0, lambda x, y: x * 10 + y, [12345]),
     )
     @ddt.unpack
-    def test_seq_fold_left(self, data, zero, func, expect):
+    def test_fold_left(self, data, zero, func, expect):
         actual = seq(data).fold_left(zero, func)
         self.assertEqual(actual.data, expect)
 
@@ -941,7 +1038,7 @@ class SeqUtilsTest(unittest.TestCase):
         ([1, 2, 3, 4, 5], 0, lambda x, y: x * 10 + y, [54321]),
     )
     @ddt.unpack
-    def test_seq_fold_right(self, data, zero, func, expect):
+    def test_fold_right(self, data, zero, func, expect):
         actual = seq(data).fold_right(zero, func)
         self.assertEqual(actual.data, expect)
 
@@ -952,7 +1049,7 @@ class SeqUtilsTest(unittest.TestCase):
         ([1, 2, 3, 4, 5], lambda x, y: y, [5]),
     )
     @ddt.unpack
-    def test_seq_reduce(self, data, func, expect):
+    def test_reduce(self, data, func, expect):
         actual = seq(data).reduce(func)
         self.assertEqual(actual.data, expect)
 
@@ -964,7 +1061,7 @@ class SeqUtilsTest(unittest.TestCase):
         ([1, 2, 3, 4, 5], lambda x, y: False, [5]),
     )
     @ddt.unpack
-    def test_seq_max(self, data, func, expect):
+    def test_max(self, data, func, expect):
         actual = seq(data).max(func)
         self.assertEqual(actual.data, expect)
 
@@ -976,7 +1073,7 @@ class SeqUtilsTest(unittest.TestCase):
         ([1, 2, 3, 4, 5], lambda x, y: False, [5]),
     )
     @ddt.unpack
-    def test_seq_min(self, data, func, expect):
+    def test_min(self, data, func, expect):
         actual = seq(data).min(func)
         self.assertEqual(actual.data, expect)
 
@@ -987,7 +1084,7 @@ class SeqUtilsTest(unittest.TestCase):
         ([1, 2, 3, 4, 5], lambda x: x * 2, [(2, [1]), (4, [2]), (6, [3]), (8, [4]), (10, [5])]),
     )
     @ddt.unpack
-    def test_seq_group(self, data, func, expect):
+    def test_group(self, data, func, expect):
         actual = seq(data).group(func)
         self.assertEqual(actual.data, expect)
 
@@ -997,7 +1094,7 @@ class SeqUtilsTest(unittest.TestCase):
         ([(1, "a"), (2, "b"), (3, "c"), (4, "d"), (5, "e")], [1, 2, 3, 4, 5]),
     )
     @ddt.unpack
-    def test_seq_keys(self, data, expect):
+    def test_keys(self, data, expect):
         actual = seq(data).keys()
         self.assertEqual(actual.data, expect)
 
@@ -1007,7 +1104,7 @@ class SeqUtilsTest(unittest.TestCase):
         ([(1, "a"), (2, "b"), (3, "c"), (4, "d"), (5, "e")], ["a", "b", "c", "d", "e"]),
     )
     @ddt.unpack
-    def test_seq_values(self, data, expect):
+    def test_values(self, data, expect):
         actual = seq(data).values()
         self.assertEqual(actual.data, expect)
 
@@ -1017,10 +1114,64 @@ class SeqUtilsTest(unittest.TestCase):
         ([(1, "a"), (2, "b"), (3, "c"), (4, "d"), (5, "e")], [("a", 1), ("b", 2), ("c", 3), ("d", 4), ("e", 5)]),
     )
     @ddt.unpack
-    def test_seq_swap(self, data, expect):
+    def test_swap(self, data, expect):
         actual = seq(data).swap()
         self.assertEqual(actual.data, expect)
 
+    @ddt.data(
+        ([], lambda x: x, []),
+        ([(0, "0")], lambda x: x * 2, [(0, "0")]),
+        ([(0, "0")], str, [("0", "0")]),
+        (
+            [(1, "1"), (2, "2"), (3, "3"), (4, "4"), (5, "5")],
+            lambda x: x * 2,
+            [(2, "1"), (4, "2"), (6, "3"), (8, "4"), (10, "5")],
+        ),
+        (
+            [(1, "1"), (2, "2"), (3, "3"), (4, "4"), (5, "5")],
+            str,
+            [("1", "1"), ("2", "2"), ("3", "3"), ("4", "4"), ("5", "5")],
+        ),
+    )
+    @ddt.unpack
+    def test_map_keys(self, data, func, expect):
+        actual = seq(data).map_keys(func)
+        self.assertEqual(actual.data, expect)
+
+    @ddt.data(
+        ([], lambda x: x, []),
+        ([(0, "0")], lambda x: x * 2, [(0, "00")]),
+        ([(0, "0")], int, [(0, 0)]),
+        (
+            [(1, "1"), (2, "2"), (3, "3"), (4, "4"), (5, "5")],
+            lambda x: x * 2,
+            [(1, "11"), (2, "22"), (3, "33"), (4, "44"), (5, "55")],
+        ),
+        (
+            [(1, "1"), (2, "2"), (3, "3"), (4, "4"), (5, "5")],
+            int,
+            [(1, 1), (2, 2), (3, 3), (4, 4), (5, 5)],
+        ),
+    )
+    @ddt.unpack
+    def test_map_values(self, data, func, expect):
+        actual = seq(data).map_values(func)
+        self.assertEqual(actual.data, expect)
+
+    @ddt.data(
+        ([], lambda x: x, []),
+        ([[]], lambda x: x, []),
+        ([[0]], lambda x: x, [0]),
+        ([[1, 2, 3, 4, 5]], lambda x: x, [1, 2, 3, 4, 5]),
+        ([[], [1], [2], [3], [4], [5], []], lambda x: x, [1, 2, 3, 4, 5]),
+        ([[], [1, 2, 3, 4, 5], []], lambda x: x, [1, 2, 3, 4, 5]),
+        ([1, 2, 3, 4, 5], lambda x: list(range(x)), [0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4]),
+    )
+    @ddt.unpack
+    def test_flat_map(self, data, func, expect):
+        actual = seq(data).flat_map(func)
+        self.assertEqual(actual.data, expect)
+
     @ddt.data(
         ([], []),
         ([[]], []),
@@ -1030,10 +1181,76 @@ class SeqUtilsTest(unittest.TestCase):
         ([[], [1, 2, 3, 4, 5], []], [1, 2, 3, 4, 5]),
     )
     @ddt.unpack
-    def test_seq_flatten(self, data, expect):
+    def test_flatten(self, data, expect):
         actual = seq(data).flatten()
         self.assertEqual(actual.data, expect)
 
+    @ddt.data(
+        ([], lambda x: x % 2, lambda x: x ** 2, []),
+        ([0], lambda x: x % 2, lambda x: x ** 2, [(0, [0])]),
+        ([1, 2, 3, 4, 5], lambda x: x % 2, lambda x: x ** 2, [(0, [4, 16]), (1, [1, 9, 25])]),
+        ([1, 2, 3, 4, 5], lambda x: x, lambda x: x ** 2, [(1, [1]), (2, [4]), (3, [9]), (4, [16]), (5, [25])]),
+    )
+    @ddt.unpack
+    def test_group_map(self, data, group_func, map_func, expect):
+        actual = seq(data).group_map(group_func, map_func)
+        self.assertEqual(actual.data, expect)
+
+    @ddt.data(
+        ([], lambda x: True, []),
+        ([0], lambda x: True, [0]),
+        ([0], lambda x: False, []),
+        ([0], lambda x: x % 2 == 0, [0]),
+        ([0], lambda x: x % 2 == 1, []),
+        ([0, 0, 0], lambda x: True, [0, 0, 0]),
+        ([0, 0, 0], lambda x: False, []),
+        ([0, 0, 0], lambda x: x % 2 == 0, [0, 0, 0]),
+        ([0, 0, 0], lambda x: x % 2 == 1, []),
+        ([1, 2, 3, 4, 5], lambda x: x % 2 == 0, [2, 4]),
+        ([1, 2, 3, 4, 5], lambda x: x % 2 == 1, [1, 3, 5]),
+        ([1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5], lambda x: x % 2 == 0, [2, 2, 4, 4, 4, 4]),
+        ([1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5], lambda x: x % 2 == 1, [1, 3, 3, 3, 5, 5, 5, 5, 5]),
+    )
+    @ddt.unpack
+    def test_filter(self, data, func, expect):
+        actual = seq(data).filter(func)
+        self.assertEqual(actual.data, expect)
+
+    @ddt.data(
+        ([], lambda x: True, []),
+        ([0], lambda x: True, []),
+        ([0], lambda x: False, [0]),
+        ([0], lambda x: x % 2 == 0, []),
+        ([0], lambda x: x % 2 == 1, [0]),
+        ([0, 0, 0], lambda x: True, []),
+        ([0, 0, 0], lambda x: False, [0, 0, 0]),
+        ([0, 0, 0], lambda x: x % 2 == 0, []),
+        ([0, 0, 0], lambda x: x % 2 == 1, [0, 0, 0]),
+        ([1, 2, 3, 4, 5], lambda x: x % 2 == 0, [1, 3, 5]),
+        ([1, 2, 3, 4, 5], lambda x: x % 2 == 1, [2, 4]),
+        ([1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5], lambda x: x % 2 == 0, [1, 3, 3, 3, 5, 5, 5, 5, 5]),
+        ([1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5], lambda x: x % 2 == 1, [2, 2, 4, 4, 4, 4]),
+    )
+    @ddt.unpack
+    def test_filter_not(self, data, func, expect):
+        actual = seq(data).filter_not(func)
+        self.assertEqual(actual.data, expect)
+
+    @ddt.data(
+        ([], lambda x: x, []),
+        ([0], lambda x: x, [0]),
+        ([0, 0, 0], lambda x: x, [0, 0, 0]),
+        ([1, 2, 3, 4, 5], lambda x: x, [1, 2, 3, 4, 5]),
+        ([5, 4, 3, 2, 1], lambda x: x, [1, 2, 3, 4, 5]),
+        ([1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5], lambda x: x, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5]),
+        ([1, 2, 3, 4, 5, 2, 3, 4, 5, 3, 4, 5, 4, 5, 5], lambda x: x, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5]),
+        ([1, 2, 3, 4, 5, 2, 3, 4, 5, 3, 4, 5, 4, 5, 5], lambda x: -x, [5, 5, 5, 5, 5, 4, 4, 4, 4, 3, 3, 3, 2, 2, 1]),
+    )
+    @ddt.unpack
+    def test_sort(self, data, func, expect):
+        actual = (seq(data).sort(func))
+        self.assertEqual(actual.data, expect)
+
     @ddt.data(
         ([], [], []),
         ([0], [], []),
@@ -1047,7 +1264,7 @@ class SeqUtilsTest(unittest.TestCase):
         (["a", "b", "c", "d", "e"], [1, 2, 3, 4, 5], [("a", 1), ("b", 2), ("c", 3), ("d", 4), ("e", 5)]),
     )
     @ddt.unpack
-    def test_seq_zip(self, a, b, expect):
+    def test_zip(self, a, b, expect):
         actual = seq(a).zip(seq(b))
         self.assertEqual(actual.data, expect)
 
@@ -1096,6 +1313,6 @@ class SeqUtilsTest(unittest.TestCase):
         ),
     )
     @ddt.unpack
-    def test_seq_zip_fill(self, a, b, fill, expect):
+    def test_zip_fill(self, a, b, fill, expect):
         actual = seq(a).zip_fill(seq(b), fill)
         self.assertEqual(actual.data, expect)