absfuyu 3.3.3__tar.gz → 3.4.0__tar.gz

{absfuyu-3.3.3 → absfuyu-3.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: absfuyu
-Version: 3.3.3
+Version: 3.4.0
 Summary: A small collection of code
 Project-URL: Homepage, https://github.com/AbsoluteWinter/absfuyu-public
 Project-URL: Documentation, https://absolutewinter.github.io/absfuyu-docs/

{absfuyu-3.3.3 → absfuyu-3.4.0}/pyproject.toml

@@ -84,7 +84,6 @@ only-include = ["src", "tests", "docs", "images", "dev_requirements.txt"]
 # Set up virtual env: use hatch env show
 [tool.hatch.envs.default]
 dependencies = ["coverage[toml]", "pytest-cov", "pytest"]
-features = ["full"]
 description = """
 Default environment
 
@@ -102,6 +101,7 @@ cov = ["test-cov", "cov-report"]                                    # use this
 cov2 = "pytest --cov-report=term-missing --cov=absfuyu --cov=tests" # use this
 
 [tool.hatch.envs.all]
+features = ["full"]
 description = """
 All python version to test:
 hatch run all:test
@@ -125,6 +125,7 @@ check = "mypy --install-types --non-interactive {args:src/absfuyu}"
 # check = "mypy --install-types --non-interactive {args:src/absfuyu tests}"
 
 [tool.hatch.envs.docs]
+features = ["full"]
 dependencies = [
     "sphinx>=7.0.0",
     "sphinx_rtd_theme",

{absfuyu-3.3.3 → absfuyu-3.4.0}/src/absfuyu/__init__.py

@@ -22,7 +22,7 @@ Using in cmd (`absfuyu[cli]` required):
 __title__ = "absfuyu"
 __author__ = "AbsoluteWinter"
 __license__ = "MIT License"
-__version__ = "3.3.3"
+__version__ = "3.4.0"
 __all__ = [
     "core",
     "config",

{absfuyu-3.3.3 → absfuyu-3.4.0}/src/absfuyu/cli/__init__.py

@@ -26,7 +26,7 @@ colorama.init(autoreset=True)
 
 @click.command()
 def version() -> None:
-    """Check current version"""
+    """Show current version"""
     ver_msg = f"{__title__} v{__version__}"
     click.echo(
         f"{COLOR['green']}{ver_msg}{COLOR['reset']}\n"

{absfuyu-3.3.3 → absfuyu-3.4.0}/src/absfuyu/cli/do_group.py

@@ -3,8 +3,8 @@ ABSFUYU CLI
 -----------
 Do
 
-Version: 1.0.0
-Date updated: 14/04/2024 (dd/mm/yyyy)
+Version: 1.1.0
+Date updated: 15/08/2024 (dd/mm/yyyy)
 """
 
 __all__ = ["do_group"]
@@ -16,6 +16,7 @@ import click
 from absfuyu import __title__
 from absfuyu.cli.color import COLOR
 from absfuyu.core import __package_feature__
+from absfuyu.general.human import Human2
 from absfuyu.version import PkgVersion
 
 
@@ -65,6 +66,25 @@ def advice() -> None:
     click.echo(f"{COLOR['green']}{im_bored()}")
 
 
+@click.command(name="fs")
+@click.argument("date", type=str)
+@click.argument("number_string", type=str)
+def fs(date: str, number_string: str) -> None:
+    """Feng-shui W.I.P"""
+
+    instance = Human2(date)
+    print(instance.fs(number_string))
+
+
+@click.command(name="info")
+@click.argument("date", type=str)
+def info(date: str) -> None:
+    """Day info"""
+
+    instance = Human2(date)
+    print(instance.info())
+
+
 @click.group(name="do")
 def do_group() -> None:
     """Perform functionalities"""
@@ -74,3 +94,5 @@ def do_group() -> None:
 do_group.add_command(update)
 do_group.add_command(install)
 do_group.add_command(advice)
+do_group.add_command(fs)
+do_group.add_command(info)

{absfuyu-3.3.3 → absfuyu-3.4.0}/src/absfuyu/general/data_extension.py

@@ -3,8 +3,8 @@ Absfuyu: Data extension
 -----------------------
 Extension for data type such as ``list``, ``str``, ``dict``, ...
 
-Version: 1.14.3
-Date updated: 05/04/2024 (dd/mm/yyyy)
+Version: 1.15.0
+Date updated: 27/04/2024 (dd/mm/yyyy)
 
 Features:
 ---------
@@ -61,9 +61,9 @@ from typing import (
 )
 
 if _python_version.minor >= 11:
-    from typing import NotRequired
+    from typing import NotRequired, Self
 else:
-    from typing_extensions import NotRequired  # type: ignore
+    from typing_extensions import NotRequired, Self  # type: ignore
 
 from deprecated.sphinx import versionadded, versionchanged
 
@@ -256,7 +256,7 @@ class Text(str):
         split_size: int = 60,
         split_var_len: int = 12,
         custom_var_name: Optional[str] = None,
-    ) -> list:
+    ) -> List[str]:
         """
         Divide long string into smaller size,
         then assign a random variable to splited
@@ -277,7 +277,7 @@ class Text(str):
 
         Returns
         -------
-        list
+        list[str]
             A list in which each item is a smaller
             string with the size of ``split_size``
             and a way to concaternate them (when using ``print()``)
@@ -398,7 +398,7 @@ class Text(str):
 
         return detail
 
-    def reverse(self) -> "Text":
+    def reverse(self) -> Self:
         """
         Reverse the string
 
@@ -489,7 +489,7 @@ class Text(str):
         else:
             return hex_str
 
-    def random_capslock(self, probability: int = 50) -> "Text":
+    def random_capslock(self, probability: int = 50) -> Self:
         """
         Randomly capslock letter in string
 
@@ -522,7 +522,7 @@ class Text(str):
         logger.debug(temp)
         return self.__class__("".join(temp))
 
-    def reverse_capslock(self) -> "Text":
+    def reverse_capslock(self) -> Self:
         """
         Reverse capslock in string
 
@@ -934,7 +934,7 @@ class IntNumber(int):
         except Exception:
             return False
 
-    def reverse(self) -> "IntNumber":
+    def reverse(self) -> Self:
         """
         Reverse a number. Reverse ``abs(number)`` if ``number < 0``
 
@@ -983,7 +983,7 @@ class IntNumber(int):
 
     # calculation stuff
     @versionchanged(version="3.3.0", reason="Fix bug")
-    def lcm(self, with_number: int) -> "IntNumber":
+    def lcm(self, with_number: int) -> Self:
         """
         Least common multiple of ``self`` and ``with_number``
 
@@ -1010,7 +1010,7 @@ class IntNumber(int):
             return self.__class__((self * with_number) // math.gcd(self, with_number))
 
     @versionchanged(version="3.3.0", reason="Fix bug")
-    def gcd(self, with_number: int) -> "IntNumber":
+    def gcd(self, with_number: int) -> Self:
         """
         Greatest common divisor of ``self`` and ``with_number``
 
@@ -1033,7 +1033,7 @@ class IntNumber(int):
         """
         return self.__class__(math.gcd(self, with_number))
 
-    def add_to_one_digit(self, master_number: bool = False) -> "IntNumber":
+    def add_to_one_digit(self, master_number: bool = False) -> Self:
         """
         Convert ``self`` into 1-digit number
         by adding all of the digits together
@@ -1220,7 +1220,7 @@ class ListExt(list):
     ``list`` extension
     """
 
-    def stringify(self) -> "ListExt":
+    def stringify(self) -> Self:
         """
         Convert all item in ``list`` into string
 
@@ -1278,7 +1278,7 @@ class ListExt(list):
         )
         return self[::-1][:number_of_items][::-1]
 
-    def sorts(self, reverse: bool = False) -> "ListExt":
+    def sorts(self, reverse: bool = False) -> Self:
         """
         Sort all items (with different type) in ``list``
 
@@ -1458,7 +1458,7 @@ class ListExt(list):
         """
         return [self.pick_one() for _ in range(number_of_items)]
 
-    def len_items(self) -> "ListExt":
+    def len_items(self) -> Self:
         """
         ``len()`` for every item in ``list[str]``
 
@@ -1499,7 +1499,7 @@ class ListExt(list):
         logger.debug(out)
         return out
 
-    def apply(self, func: Callable) -> "ListExt":
+    def apply(self, func: Callable) -> Self:
         """
         Apply function to each entry
 
@@ -1523,7 +1523,7 @@ class ListExt(list):
         # return __class__(func(x) for x in self)
         return self.__class__(map(func, self))
 
-    def unique(self) -> "ListExt":
+    def unique(self) -> Self:
         """
         Remove duplicates
 
@@ -1541,7 +1541,7 @@ class ListExt(list):
         """
         return self.__class__(set(self))
 
-    def group_by_unique(self) -> "ListExt":
+    def group_by_unique(self) -> Self:
         """
         Group duplicated elements into list
 
@@ -1624,7 +1624,7 @@ class ListExt(list):
 
         return list(x for x, _ in groupby(iter))
 
-    def flatten(self) -> "ListExt":
+    def flatten(self) -> Self:
         """
         Flatten the list
 
@@ -1646,7 +1646,7 @@ class ListExt(list):
             temp = list(map(lambda x: x if isinstance(x, list) else [x], self))
             return ListExt(chain(*temp))
 
-    def numbering(self, start: int = 0) -> "ListExt":
+    def numbering(self, start: int = 0) -> Self:
         """
         Number the item in list
         (``enumerate`` wrapper)
@@ -1744,7 +1744,7 @@ class DictExt(dict):
             logger.error(err_msg)
             raise ValueError(err_msg)  # noqa: B904
 
-    def swap_items(self) -> "DictExt":
+    def swap_items(self) -> Self:
         """
         Swap ``dict.keys()`` with ``dict.values()``
 
@@ -1762,7 +1762,7 @@ class DictExt(dict):
         """
         return self.__class__(zip(self.values(), self.keys()))
 
-    def apply(self, func: Callable, apply_to_value: bool = True) -> "DictExt":
+    def apply(self, func: Callable, apply_to_value: bool = True) -> Self:
         """
         Apply function to ``DictExt.keys()`` or ``DictExt.values()``
 
@@ -1795,6 +1795,19 @@ class DictExt(dict):
             v = self.values()  # type: ignore
         return self.__class__(zip(k, v))
 
+    @versionadded(version="3.4.0")
+    def aggregate(
+        self,
+        other_dict: Dict[Any, Union[int, float]],
+        default_value: Union[int, float] = 0,
+    ) -> Self:
+        """Dict with value type int or float"""
+        out = {
+            k: self.get(k, default_value) + other_dict.get(k, default_value)
+            for k in set(self | other_dict)
+        }
+        return self.__class__(out)
+
 
 # Run
 ###########################################################################

{absfuyu-3.3.3 → absfuyu-3.4.0}/src/absfuyu/general/human.py

@@ -3,8 +3,8 @@ Absfuyu: Human
 --------------
 Human related stuff
 
-Version: 1.3.1
-Date updated: 05/04/2024 (dd/mm/yyyy)
+Version: 1.4.0
+Date updated: 15/08/2024 (dd/mm/yyyy)
 """
 
 # Module level
@@ -14,13 +14,16 @@ __all__ = ["Human", "Person"]
 
 # Library
 ###########################################################################
+import re
 from datetime import datetime, time
 from typing import Optional, Union
+from urllib.parse import urlencode
 
 from dateutil.relativedelta import relativedelta
 
 from absfuyu.fun import zodiac_sign
 from absfuyu.general.data_extension import IntNumber
+from absfuyu.tools.web import soup_link
 from absfuyu.version import Version  # type: ignore
 
 
@@ -349,7 +352,78 @@ class Person(Human):
         return IntNumber(temp).add_to_one_digit(master_number=True)
 
 
+class Human2:
+    """W.I.P for cli"""
+
+    def __init__(self, birthday_string: str, is_male: bool = True) -> None:
+        """
+        :param birthday_string: Format ``<yyyymmddhhmm>`` or ``<yyyymmdd>``
+        """
+        if len(birthday_string) == 12:
+            day = datetime(
+                year=int(birthday_string[:4]),
+                month=int(birthday_string[4:6]),
+                day=int(birthday_string[6:8]),
+                hour=int(birthday_string[8:10]),
+                minute=int(birthday_string[10:]),
+            )
+        else:
+            day = datetime(
+                year=int(birthday_string[:4]),
+                month=int(birthday_string[4:6]),
+                day=int(birthday_string[6:]),
+            )
+        self._date_str = birthday_string[:8]
+        self.day = day
+        self.is_male = is_male
+
+    def __str__(self) -> str:
+        class_name = self.__class__.__name__
+        return f"{class_name}({str(self.day)})"
+
+    def __repr__(self) -> str:
+        class_name = self.__class__.__name__
+        return f"{class_name}({str(self.day)})"
+
+    def numerology(self) -> int:
+        # numerology
+        return IntNumber(self._date_str).add_to_one_digit(master_number=True)
+
+    def _make_fengshui_check_query(self) -> str:
+        """
+        Generate query to check Feng-shui
+        """
+        params = {
+            "ngay": self.day.day.__str__().rjust(2, "0"),
+            "thang": self.day.month.__str__().rjust(2, "0"),
+            "nam": self.day.year,
+            "gio": self.day.hour.__str__().rjust(2, "0"),
+            "phut": self.day.minute.__str__().rjust(2, "0"),
+            "gioitinh": "nam" if self.is_male else "nu",
+        }
+        output = urlencode(params)
+        return output
+
+    def fs(self, number_string: str) -> float:
+        # fengshui
+        base = "https://thanglongdaoquan.vn/boi-so-tai-khoan/?taikhoan="
+        link = f"{base}{number_string}&{self._make_fengshui_check_query()}"
+        soup = soup_link(link)
+        val = soup.find_all(class_="total_point")[0].get_text()
+        pattern = r"([0-9.]{1,3})/10"
+        res = re.findall(pattern, val)[0]
+        return float(res)
+
+    def info(self) -> dict:
+        out = {
+            "numerology": self.numerology(),
+            "zodiac": zodiac_sign(self.day.day, self.day.month),
+        }
+        return out
+
+
 # Run
 ###########################################################################
 if __name__ == "__main__":
-    print(Person.JohnDoe().__dict__)
+    # print(Person.JohnDoe().__dict__)
+    pass

absfuyu-3.4.0/tests/test_beautiful.py

@@ -0,0 +1,13 @@
+import pytest
+
+try:  # [beautiful] feature
+    import rich  # type: ignore
+except ImportError:
+    rich = pytest.importorskip("rich")
+
+from absfuyu.extensions import beautiful as bu
+
+
+class TestBeautiful:
+    def test_beau(self):
+        assert bu.demo() is None

absfuyu-3.4.0/tests/test_data_analysis.py

@@ -0,0 +1,157 @@
+"""
+Test: Data Analysis
+
+Version: 1.2.1
+Date updated: 19/04/2024 (dd/mm/yyyy)
+"""
+
+import random
+
+import pytest
+
+try:  # [extra] feature
+    import numpy as np
+    import pandas as pd
+except ImportError:
+    np = pytest.importorskip("numpy")
+    pd = pytest.importorskip("pandas")
+
+from absfuyu.extensions.extra.data_analysis import DADF, CityData, SplittedDF
+from absfuyu.general.generator import Charset, Generator
+
+SAMPLE_SIZE = 100
+sample_city_data = CityData._sample_city_data(size=SAMPLE_SIZE)
+
+# MARK: fixture
+@pytest.fixture
+def sample_df() -> DADF:
+    # Number of columns generated
+    num_of_cols: int = random.randint(5, 10)
+    # List of column name
+    col_name: list = Generator.generate_string(
+        Charset.LOWERCASE, unique=True, times=num_of_cols
+    )
+    # Create DataFrame
+    df = pd.DataFrame(
+        np.random.randn(random.randint(5, 100), num_of_cols), columns=col_name
+    )
+    out = DADF(df)
+    return out
+
+
+@pytest.fixture
+def sample_df_2() -> DADF:
+    return DADF.sample_df()
+
+
+@pytest.fixture
+def sample_df_3():
+    sample = DADF.sample_df(size=SAMPLE_SIZE)
+    sample["city"] = [x.city for x in sample_city_data]
+    return sample
+
+
+# MARK: test
+class TestDADF:
+    """absfuyu.extensions.extra.data_analysis.DADF"""
+
+    # Drop cols
+    def test_drop_rightmost(self, sample_df: DADF) -> None:
+        num_of_cols_drop = random.randint(1, 4)
+
+        num_of_cols_current = sample_df.shape[1]
+        sample_df.drop_rightmost(num_of_cols_drop)
+        num_of_cols_modified = sample_df.shape[1]
+
+        condition = (num_of_cols_current - num_of_cols_modified) == num_of_cols_drop
+        assert condition
+
+    # Add blank column
+    def test_add_blank_column(self, sample_df: DADF) -> None:
+        original_num_of_cols = sample_df.shape[1]
+        sample_df.add_blank_column("new_col", 0)
+        new_num_of_cols = sample_df.shape[1]
+
+        condition = (new_num_of_cols - original_num_of_cols) == 1 and sum(
+            sample_df["new_col"]
+        ) == 0
+        assert condition
+
+    # Add date column
+    def test_add_date_from_month(self, sample_df_2: DADF) -> None:
+        sample_df_2.add_detail_date("date", mode="m")
+        original_num_of_cols = sample_df_2.shape[1]
+        sample_df_2.add_date_from_month("month", col_name="mod_date")
+        new_num_of_cols = sample_df_2.shape[1]
+
+        original_month = sample_df_2["month"][0]
+        modified_month = sample_df_2["mod_date"][0].month
+
+        # assert original_month == modified_month
+        condition = (
+            new_num_of_cols - original_num_of_cols
+        ) == 1 and original_month == modified_month
+        assert condition
+
+    def test_add_date_column(self, sample_df_2: DADF) -> None:
+        # Get random mode
+        mode_list = ["d", "w", "m", "y"]
+        test_mode = list(
+            map(lambda x: "".join(x), Generator.combinations_range(mode_list))
+        )
+        random_mode = random.choice(test_mode)
+        num_of_new_cols = len(random_mode)
+
+        # Convert
+        original_num_of_cols = sample_df_2.shape[1]
+        sample_df_2.add_detail_date("date", mode=random_mode)
+        new_num_of_cols = sample_df_2.shape[1]
+        assert (new_num_of_cols - original_num_of_cols) == num_of_new_cols
+
+    # Join and split
+    def test_split_df(self, sample_df_2: DADF) -> None:
+        test = sample_df_2.split_na("missing_value")
+        assert len(test) > 1
+
+    def test_split_df_2(self, sample_df_2: DADF) -> None:
+        test = SplittedDF.divide_dataframe(sample_df_2, "number_range")
+        assert len(test) > 1
+
+    def test_join_df(self, sample_df_2: DADF) -> None:
+        test = sample_df_2.split_na("missing_value")
+        out = test.concat()
+        assert out.shape[0] == 100
+
+    def test_join_df_2(self, sample_df_2: DADF) -> None:
+        """This test static method"""
+        test = SplittedDF.divide_dataframe(sample_df_2, "number_range")
+        out = SplittedDF.concat_df(test)
+        assert out.shape[0] == 100
+
+    # Threshold filter
+    def test_threshold_filter(self, sample_df_2: DADF) -> None:
+        original_num_of_cols = sample_df_2.shape[1]
+        sample_df_2.threshold_filter("number_range", 11)
+        new_num_of_cols = sample_df_2.shape[1]
+
+        # Check new column
+        assert (new_num_of_cols - original_num_of_cols) == 1
+
+        # Check filler value
+        test: list = sample_df_2["number_range_filtered"].unique().tolist()
+        try:
+            test.index("Other")
+            assert True
+        except Exception:
+            pass
+
+        # Check len
+        test1 = sample_df_2["number_range"].unique().tolist()
+        assert (len(test1) - len(test)) >= 1
+
+    # Convert city
+    def test_convert_city(self, sample_df_3: DADF) -> None:
+        original_num_of_cols = sample_df_3.shape[1]
+        sample_df_3.convert_city("city", city_list=sample_city_data)
+        new_num_of_cols = sample_df_3.shape[1]
+        assert (new_num_of_cols - original_num_of_cols) == 2

{absfuyu-3.3.3 → absfuyu-3.4.0}/tests/test_everything.py

@@ -9,6 +9,11 @@ Date updated: 14/04/2024 (dd/mm/yyyy)
 ###########################################################################
 import pytest
 
+try:  # [beautiful] feature
+    import rich  # type: ignore
+except ImportError:
+    rich = pytest.importorskip("rich")
+
 from absfuyu import __author__, __license__, __title__, __version__
 from absfuyu import everything as ab
 from absfuyu.config import (

{absfuyu-3.3.3 → absfuyu-3.4.0}/tests/test_passwordlib.py

@@ -1,21 +1,22 @@
 """
 Test: Passwordlib
 
-Version: 1.1.0
-Date updated: 30/11/2023 (dd/mm/yyyy)
+Version: 1.1.1
+Date updated: 19/04/2024 (dd/mm/yyyy)
 """
 
-# Library
-###########################################################################
 from itertools import combinations_with_replacement
 
 import pytest
 
+try:  # [res] feature
+    import absfuyu_res
+except ImportError:
+    absfuyu_res = pytest.importorskip("absfuyu_res")
+
 from absfuyu.extensions.dev.passwordlib import Password
 from absfuyu.general.data_extension import Text
 
-# Test
-###########################################################################
 # def test_generate_password():
 #     test = [password_check(Password.generate_password()) for _ in range(100)]
 #     assert all(test)

absfuyu-3.3.3/tests/test_beautiful.py

@@ -1,7 +0,0 @@
-import pytest
-
-from absfuyu.extensions import beautiful as bu
-
-
-def test_beau():
-    assert bu.demo() is None

absfuyu-3.3.3/tests/test_data_analysis.py

@@ -1,159 +0,0 @@
-"""
-Test: Data Analysis
-
-Version: 1.2.0
-Date updated: 08/03/2024 (dd/mm/yyyy)
-"""
-
-# Library
-###########################################################################
-import random
-
-import numpy as np
-import pandas as pd
-import pytest
-
-from absfuyu.extensions.extra.data_analysis import DADF, CityData, SplittedDF
-from absfuyu.general.generator import Charset, Generator
-
-# Test
-###########################################################################
-SAMPLE_SIZE = 100
-sample_city_data = CityData._sample_city_data(size=SAMPLE_SIZE)
-
-
-@pytest.fixture
-def sample_df() -> DADF:
-    # Number of columns generated
-    num_of_cols: int = random.randint(5, 10)
-    # List of column name
-    col_name: list = Generator.generate_string(
-        Charset.LOWERCASE, unique=True, times=num_of_cols
-    )
-    # Create DataFrame
-    df = pd.DataFrame(
-        np.random.randn(random.randint(5, 100), num_of_cols), columns=col_name
-    )
-    out = DADF(df)
-    return out
-
-
-@pytest.fixture
-def sample_df_2() -> DADF:
-    return DADF.sample_df()
-
-
-@pytest.fixture
-def sample_df_3():
-    sample = DADF.sample_df(size=SAMPLE_SIZE)
-    sample["city"] = [x.city for x in sample_city_data]
-    return sample
-
-
-# Drop cols
-def test_drop_rightmost(sample_df: DADF):
-    num_of_cols_drop = random.randint(1, 4)
-
-    num_of_cols_current = sample_df.shape[1]
-    sample_df.drop_rightmost(num_of_cols_drop)
-    num_of_cols_modified = sample_df.shape[1]
-
-    condition = (num_of_cols_current - num_of_cols_modified) == num_of_cols_drop
-    assert condition
-
-
-# Add blank column
-def test_add_blank_column(sample_df: DADF):
-    original_num_of_cols = sample_df.shape[1]
-    sample_df.add_blank_column("new_col", 0)
-    new_num_of_cols = sample_df.shape[1]
-
-    condition = (new_num_of_cols - original_num_of_cols) == 1 and sum(
-        sample_df["new_col"]
-    ) == 0
-    assert condition
-
-
-# Add date column
-def test_add_date_from_month(sample_df_2: DADF):
-    sample_df_2.add_detail_date("date", mode="m")
-    original_num_of_cols = sample_df_2.shape[1]
-    sample_df_2.add_date_from_month("month", col_name="mod_date")
-    new_num_of_cols = sample_df_2.shape[1]
-
-    original_month = sample_df_2["month"][0]
-    modified_month = sample_df_2["mod_date"][0].month
-
-    # assert original_month == modified_month
-    condition = (
-        new_num_of_cols - original_num_of_cols
-    ) == 1 and original_month == modified_month
-    assert condition
-
-
-def test_add_date_column(sample_df_2: DADF):
-    # Get random mode
-    mode_list = ["d", "w", "m", "y"]
-    test_mode = list(map(lambda x: "".join(x), Generator.combinations_range(mode_list)))
-    random_mode = random.choice(test_mode)
-    num_of_new_cols = len(random_mode)
-
-    # Convert
-    original_num_of_cols = sample_df_2.shape[1]
-    sample_df_2.add_detail_date("date", mode=random_mode)
-    new_num_of_cols = sample_df_2.shape[1]
-    assert (new_num_of_cols - original_num_of_cols) == num_of_new_cols
-
-
-# Join and split
-def test_split_df(sample_df_2: DADF):
-    test = sample_df_2.split_na("missing_value")
-    assert len(test) > 1
-
-
-def test_split_df_2(sample_df_2: DADF):
-    test = SplittedDF.divide_dataframe(sample_df_2, "number_range")
-    assert len(test) > 1
-
-
-def test_join_df(sample_df_2: DADF):
-    test = sample_df_2.split_na("missing_value")
-    out = test.concat()
-    assert out.shape[0] == 100
-
-
-def test_join_df_2(sample_df_2: DADF):
-    """This test static method"""
-    test = SplittedDF.divide_dataframe(sample_df_2, "number_range")
-    out = SplittedDF.concat_df(test)
-    assert out.shape[0] == 100
-
-
-# Threshold filter
-def test_threshold_filter(sample_df_2: DADF):
-    original_num_of_cols = sample_df_2.shape[1]
-    sample_df_2.threshold_filter("number_range", 11)
-    new_num_of_cols = sample_df_2.shape[1]
-
-    # Check new column
-    assert (new_num_of_cols - original_num_of_cols) == 1
-
-    # Check filler value
-    test: list = sample_df_2["number_range_filtered"].unique().tolist()
-    try:
-        test.index("Other")
-        assert True
-    except Exception:
-        pass
-
-    # Check len
-    test1 = sample_df_2["number_range"].unique().tolist()
-    assert (len(test1) - len(test)) >= 1
-
-
-# Convert city
-def test_convert_city(sample_df_3: DADF):
-    original_num_of_cols = sample_df_3.shape[1]
-    sample_df_3.convert_city("city", city_list=sample_city_data)
-    new_num_of_cols = sample_df_3.shape[1]
-    assert (new_num_of_cols - original_num_of_cols) == 2