absfuyu 3.2.0__py3-none-any.whl → 3.4.0__py3-none-any.whl

absfuyu/extensions/dev/password_hash.py

@@ -1,12 +1,14 @@
+# type: ignore
+# flake8: noqa
+
 # Library
 ##############################################################
 import hashlib as __hash
 import os as __os
 from typing import Dict as __Dict
+from typing import NewType as __NewType
 from typing import TypeVar as __TypeVar
 from typing import Union as __Union
-from typing import NewType as __NewType
-
 
 # Define type
 ##############################################################

absfuyu/extensions/dev/passwordlib.py

@@ -1,3 +1,6 @@
+# type: ignore
+# flake8: noqa
+
 """
 Absfuyu: Passwordlib
 --------------------
@@ -7,7 +10,6 @@ Version: 1.0.0dev1
 Date updated: 30/11/2023 (dd/mm/yyyy)
 """
 
-
 # Library
 ###########################################################################
 # from collections import namedtuple
@@ -15,13 +17,13 @@ import hashlib
 import os
 import random
 import re
-from typing import List, Dict, Optional, Union
+from typing import List, Optional
 
 from absfuyu_res import DATA
 
-from absfuyu.logger import logger
 from absfuyu.general.data_extension import DictExt, Text
-from absfuyu.general.generator import Generator, Charset
+from absfuyu.general.generator import Charset, Generator
+from absfuyu.logger import logger
 from absfuyu.util import set_min
 from absfuyu.util.pkl import Pickler
 
@@ -237,7 +239,7 @@ class Password:
             if first_letter_cap:
                 value = value.title()
             if include_number:
-                value += str(random.choice(range(0, 10)))
+                value += str(random.choice(range(10)))
             return value
 
         if not block_divider:

absfuyu/extensions/dev/project_starter.py

@@ -1,3 +1,6 @@
+# type: ignore
+# flake8: noqa
+
 """
 Absfuyu: Project starter
 ------------------------
@@ -6,7 +9,6 @@ Version: 1.0.0dev1
 Date updated: 01/12/2023 (dd/mm/yyyy)
 """
 
-
 # Module level
 ###########################################################################
 __all__ = ["get_parser"]
@@ -14,7 +16,7 @@ __all__ = ["get_parser"]
 
 # Library
 ###########################################################################
-from argparse import ArgumentParser, ArgumentDefaultsHelpFormatter
+from argparse import ArgumentDefaultsHelpFormatter, ArgumentParser
 from typing import Optional
 
 

absfuyu/extensions/dev/shutdownizer.py

@@ -1,3 +1,6 @@
+# type: ignore
+# flake8: noqa
+
 """
 Absfuyu: Shutdownizer
 ---------------------
@@ -6,3 +9,148 @@ This shutdowns
 Version: 1.0.0dev
 Date updated: 27/11/2023 (dd/mm/yyyy)
 """
+
+# Module level
+###########################################################################
+__all__ = ["ShutDownizer"]
+
+
+# Library
+###########################################################################
+import datetime
+import os
+import random
+import subprocess
+import sys
+from pathlib import Path
+
+from absfuyu.logger import LogLevel, logger
+
+
+# Class
+###########################################################################
+class Dummy:
+    def __init__(self) -> None:
+        pass
+
+    def __str__(self) -> str:
+        return f"{self.__class__.__name__}()"
+
+    def __repr__(self) -> str:
+        return self.__str__()
+
+
+class ShutDownizer(Dummy):
+    """
+    ShutDownizer
+
+    Shutdown tool because why not
+    """
+
+    def __init__(self) -> None:
+        """doc_string"""
+        self.os: str = sys.platform
+        logger.debug(f"Current OS: {self.os}")
+
+        if self.os in ["win32", "cygwin"]:  # Windows
+            self.engine = ShutDownizerWin()
+        elif self.os == "darwin":  # MacOS
+            self.engine = ShutDownizerMac()
+        elif self.os == "linux":  # Linux
+            self.engine = ShutDownizerLinux()
+        else:  # Other (probably linux)
+            self.engine = ShutDownizerLinux()
+
+    def __str__(self) -> str:
+        return f"{self.__class__.__name__}({self.os})"
+
+    def shutdown(self):
+        """Shutdown"""
+        self.engine.shutdown()
+
+    def restart(self):
+        """Restart"""
+        self.engine.restart()
+
+    def cancel(self):
+        """Cancel"""
+        self.engine.cancel()
+
+
+class ShutDownizerEngine(Dummy):
+    """
+    Abstract class for different type of OS
+    """
+
+    def __init__(self) -> None:
+        self.shutdown_cmd = ""
+        self.restart_cmd = ""
+        self.cancel_cmd = ""
+
+    def _excute_cmd(self, cmd) -> None:
+        """Execute the cmd"""
+        try:
+            if isinstance(cmd, str):
+                subprocess.run(cmd.split())
+            elif isinstance(cmd, list):
+                subprocess.run(cmd)
+            else:
+                logger.error(f'"{cmd}" failed to run')
+        except:
+            logger.error(f'"{cmd}" failed to run')
+
+    def shutdown(self):
+        """Shutdown"""
+        try:
+            self._excute_cmd(self.shutdown_cmd)
+        except:
+            pass
+
+    def restart(self):
+        """Restart"""
+        self._excute_cmd(self.restart_cmd)
+
+    def cancel(self):
+        """Cancel shutdown/restart"""
+        self._excute_cmd(self.cancel_cmd)
+
+
+class ShutDownizerWin(ShutDownizerEngine):
+    """ShutDownizer - Windows"""
+
+    def __init__(self) -> None:
+        self.shutdown_cmd = "shutdown -f -s -t 0"
+        self.cancel_cmd = "shutdown -a"
+
+    def _punish(self):
+        """Create a `batch` script that shut down computer when boot up"""
+        try:
+            startup_folder_win = Path(os.getenv("appdata")).joinpath(
+                "Microsoft", "Windows", "Start Menu", "Programs", "Startup"
+            )
+            with open(startup_folder_win.joinpath("system.bat"), "w") as f:
+                f.write(self.shutdown_cmd)
+        except:
+            logger.error("Cannot write file to startup folder")
+
+
+class ShutDownizerMac(ShutDownizerEngine):
+    """ShutDownizer - MacOS"""
+
+    def __init__(self) -> None:
+        self.shutdown_cmd = ["osascript", "-e", 'tell app "System Events" to shut down']
+
+
+class ShutDownizerLinux(ShutDownizerEngine):
+    """ShutDownizer - Linux"""
+
+    def __init__(self) -> None:
+        self.shutdown_cmd = "shutdown -h now"
+
+
+# Run
+###########################################################################
+if __name__ == "__main__":
+    logger.setLevel(LogLevel.DEBUG)
+    test = ShutDownizer()
+    print(ShutDownizerLinux().shutdown())

absfuyu/extensions/extra/__init__.py

@@ -18,8 +18,7 @@ Date updated: 24/11/2023 (dd/mm/yyyy)
 # Function
 ###########################################################################
 
-
 # Run
 ###########################################################################
 if __name__ == "__main__":
-    pass
+    pass

absfuyu/extensions/extra/data_analysis.py

@@ -3,11 +3,10 @@ Absfuyu: Data Analysis [W.I.P]
 ------------------------------
 Extension for ``pd.DataFrame``
 
-Version: 2.1.1
-Date updated: 14/03/2024 (dd/mm/yyyy)
+Version: 2.1.3
+Date updated: 20/03/2024 (dd/mm/yyyy)
 """
 
-
 # Module level
 ###########################################################################
 __all__ = [
@@ -26,27 +25,30 @@ __all__ = [
 
 # Library
 ###########################################################################
+import random
+import string
 from collections import deque
 from datetime import datetime
-import random
 from itertools import chain, product
-import string
 from typing import Any, Dict, List, NamedTuple, Optional, Union
 
 # import matplotlib.pyplot as plt
 # from scipy import stats
 # from dateutil.relativedelta import relativedelta
-from deprecated import deprecated
 import numpy as np
 import pandas as pd
+from deprecated import deprecated
+from deprecated.sphinx import deprecated as sphinx_deprecated
+from deprecated.sphinx import versionadded
 
 from absfuyu.logger import logger
-from absfuyu.util import set_min_max, set_min
+from absfuyu.util import set_min, set_min_max
 
 
 # Function
 ###########################################################################
-@deprecated(reason="No needed", version="3.1.0")
+@deprecated(reason="Not needed", version="3.1.0")
+@sphinx_deprecated(reason="Not needed", version="3.1.0")
 def summary(data: Union[list, np.ndarray]):  # del this
     """
     Quick summary of data
@@ -95,7 +97,7 @@ def equalize_df(data: Dict[str, list], fillna=np.nan) -> Dict[str, list]:
 ## Update 05/10
 
 
-def compare_2_list(*arr: list) -> pd.DataFrame:
+def compare_2_list(*arr) -> pd.DataFrame:
     """
     Compare 2 lists then create DataFrame
     to see which items are missing
@@ -112,7 +114,7 @@ def compare_2_list(*arr: list) -> pd.DataFrame:
     """
     # Setup
     col_name = "list"
-    arr = [sorted(x) for x in arr]  # map(sorted, arr)
+    arr = [sorted(x) for x in arr]  # type: ignore # map(sorted, arr)
 
     # Total array
     tarr = sorted(list(set(chain.from_iterable(arr))))
@@ -180,33 +182,33 @@ class CityData(NamedTuple):
     area: str
 
     @staticmethod
-    def _sample_city_data(size: int = 100):
+    def _sample_city_data(size: int = 100) -> List["CityData"]:
         """
         Generate sample city data (testing purpose)
         """
         sample_range = 10 ** len(str(size))
 
         # Serial list
-        serials = []
-        while len(serials) != size: # Unique serial
+        serials: List[str] = []
+        while len(serials) != size:  # Unique serial
             serial = random.randint(0, sample_range - 1)
-            serial = str(serial).rjust(len(str(size)), "0")
-            if serial not in serials:
-                serials.append(serial)
-        
-        ss2 = deque(serials[: int(len(serials) / 2)]) # Cut half for region
+            serial = str(serial).rjust(len(str(size)), "0")  # type: ignore
+            if serial not in serials:  # type: ignore
+                serials.append(serial)  # type: ignore
+
+        ss2 = deque(serials[: int(len(serials) / 2)])  # Cut half for region
         ss2.rotate(random.randrange(1, 5))
-        [ss2.extend(ss2) for _ in range(2)] # Extend back
+        [ss2.extend(ss2) for _ in range(2)]  # type: ignore # Extend back
 
-        ss3 = deque(serials[: int(len(serials) / 4)]) # Cut forth for area
+        ss3 = deque(serials[: int(len(serials) / 4)])  # Cut forth for area
         ss3.rotate(random.randrange(1, 5))
-        [ss3.extend(ss3) for _ in range(4)] # Extend back
+        [ss3.extend(ss3) for _ in range(4)]  # type: ignore # Extend back
 
         serials = ["city_" + x for x in serials]
-        ss2 = ["region_" + x for x in ss2]
-        ss3 = ["area_" + x for x in ss3]
+        ss2 = ["region_" + x for x in ss2]  # type: ignore
+        ss3 = ["area_" + x for x in ss3]  # type: ignore
 
-        ss = list(zip(serials, ss2, ss3)) # Zip back
+        ss = list(zip(serials, ss2, ss3))  # Zip back
         out = list(map(CityData._make, ss))
 
         return out
@@ -267,7 +269,7 @@ class SplittedDF(NamedTuple):
         DataFrame
             Joined DataFrame
         """
-        return self.concat_df(self, join=join)
+        return self.concat_df(self, join=join)  # type: ignore
 
     @staticmethod
     def divide_dataframe(df: pd.DataFrame, by_column: str) -> List[pd.DataFrame]:
@@ -320,10 +322,10 @@ class _DictToAtrr:
         if key_as_atrribute:
             # temp = list(map(self._remove_space, self._data.keys()))
             temp = [self._remove_space(x, remove_char) for x in self._data.keys()]
-            [self.__setattr__(k, v) for k, v in zip(temp, self._data.values())]
+            [self.__setattr__(k, v) for k, v in zip(temp, self._data.values())]  # type: ignore
         else:
             temp = [self._remove_space(x, remove_char) for x in self._data.values()]
-            [self.__setattr__(k, v) for k, v in zip(temp, self._data.keys())]
+            [self.__setattr__(k, v) for k, v in zip(temp, self._data.keys())]  # type: ignore
         self._keys = temp
 
     def __str__(self) -> str:
@@ -337,7 +339,7 @@ class _DictToAtrr:
         """
         Remove special characters and replace space with underscore
         """
-        remove_char = remove_char.split(" ")
+        remove_char = remove_char.split(" ")  # type: ignore
         logger.debug(remove_char)
         for x in remove_char:
             value = value.replace(x, "")
@@ -400,15 +402,15 @@ class MatplotlibFormatString:
     @staticmethod
     def all_format_string() -> List[PLTFormatString]:
         fmt_str = [
-            __class__.MARKER_LIST,
-            __class__.LINE_STYLE_LIST,
-            __class__.COLOR_LIST,
+            __class__.MARKER_LIST,  # type: ignore
+            __class__.LINE_STYLE_LIST,  # type: ignore
+            __class__.COLOR_LIST,  # type: ignore
         ]
         return [PLTFormatString._make(x) for x in list(product(*fmt_str))]
 
     @staticmethod
     def get_random(alt: bool = False) -> str:
-        temp = random.choice(__class__.all_format_string())
+        temp = random.choice(__class__.all_format_string())  # type: ignore
         if alt:
             return f"{temp.marker}{temp.line_style}{temp.color}"
         else:
@@ -418,9 +420,9 @@ class MatplotlibFormatString:
 # Class - DA
 ###########################################################################
 class DataAnalystDataFrame(pd.DataFrame):
-    """Data Analyst ``pd.DataFrame``"""
-
-    _DADF_Version = (1, 3, 0)  # internal check
+    """
+    Data Analyst ``pd.DataFrame``
+    """
 
     # Support
     # ================================================================
@@ -443,14 +445,14 @@ class DataAnalystDataFrame(pd.DataFrame):
             Modified DataFrame
         """
         cols = self.columns.to_list()  # List of columns
-        num_of_cols = set_min_max(num_of_cols, min_value=1, max_value=len(cols))
+        num_of_cols = int(set_min_max(num_of_cols, min_value=1, max_value=len(cols)))
         col_index = cols.index(insert_to_col)
         cols = (
             cols[: col_index + 1]
             + cols[-num_of_cols:]
             + cols[col_index + 1 : len(cols) - num_of_cols]
         )
-        self = __class__(self[cols])
+        self = self.__class__(self[cols])
         return self
 
     # Drop a list of column
@@ -471,7 +473,7 @@ class DataAnalystDataFrame(pd.DataFrame):
         for column in columns:
             try:
                 self.drop(columns=[column], inplace=True)
-            except:
+            except Exception:
                 logger.debug(f"{column} column does not exist")
                 # pass
         return self
@@ -496,7 +498,9 @@ class DataAnalystDataFrame(pd.DataFrame):
         #     num_of_cols = 1
         # if num_of_cols > self.shape[1]:
         #     num_of_cols = self.shape[1]
-        num_of_cols = set_min_max(num_of_cols, min_value=1, max_value=self.shape[1])
+        num_of_cols = int(
+            set_min_max(num_of_cols, min_value=1, max_value=self.shape[1])
+        )
 
         # Logic
         for _ in range(num_of_cols):
@@ -530,9 +534,9 @@ class DataAnalystDataFrame(pd.DataFrame):
     def convert_city(
         self,
         city_column: str,
-        city_list: List[CityData] = None,
+        city_list: List[CityData],
         *,
-        mode: str = "ra"
+        mode: str = "ra",
     ):
         """
         Get ``region`` and ``area`` of a city
@@ -559,21 +563,25 @@ class DataAnalystDataFrame(pd.DataFrame):
         """
 
         # Support function
-        def _convert_city_support(value: str):
+        def _convert_city_support(value: str) -> CityData:
             for x in city_list:
                 if x.city.lower().startswith(value.lower()):
                     return x
-            return CityData(city=value, region=np.nan, area=np.nan)
+            return CityData(city=value, region=np.nan, area=np.nan)  # type: ignore
 
         # Convert
         col_counter = 0
         if mode.find("r") != -1:
             logger.debug("Mode: 'region'")
-            self["region"] = self[city_column].apply(lambda x: _convert_city_support(x).region)
+            self["region"] = self[city_column].apply(
+                lambda x: _convert_city_support(x).region
+            )
             col_counter += 1
         if mode.find("a") != -1:
             logger.debug("Mode: 'area'")
-            self["area"] = self[city_column].apply(lambda x: _convert_city_support(x).area)
+            self["area"] = self[city_column].apply(
+                lambda x: _convert_city_support(x).area
+            )
             col_counter += 1
 
         # Rearrange
@@ -731,7 +739,7 @@ class DataAnalystDataFrame(pd.DataFrame):
         """
         try:
             self[column_name] = self[column_name].fillna(fill)
-        except:
+        except Exception:
             self.add_blank_column(column_name, fill_when_not_exist)
         return self
 
@@ -759,6 +767,7 @@ class DataAnalystDataFrame(pd.DataFrame):
         return out
 
     # Threshold filter
+    # @versionchanged(version="3.2.0", reason="Optimized the code")
     def threshold_filter(
         self,
         destination_column: str,
@@ -799,7 +808,7 @@ class DataAnalystDataFrame(pd.DataFrame):
             self[destination_column] = self[
                 destination_column
             ].str.strip()  # Remove trailing space
-        except:
+        except Exception:
             pass
 
         # Logic
@@ -814,7 +823,7 @@ class DataAnalystDataFrame(pd.DataFrame):
             )
             # logger.debug(list_of_keep)
         else:
-            list_of_keep: list = col_df[col_df["percentage"] >= threshold][
+            list_of_keep = col_df[col_df["percentage"] >= threshold][
                 destination_column
             ].to_list()  # values that will not be renamed
         self[f"{destination_column}_filtered"] = self[destination_column].apply(
@@ -828,11 +837,13 @@ class DataAnalystDataFrame(pd.DataFrame):
     # ================================================================
     # Total observation
     @property
+    @versionadded(version="3.2.0")
     def total_observation(self) -> int:
         """Returns total observation of the DataFrame"""
-        return self.shape[0] * self.shape[1]
+        return self.shape[0] * self.shape[1]  # type: ignore
 
     # Quick info
+    @versionadded(version="3.2.0")
     def qinfo(self) -> str:
         """
         Show quick infomation about DataFrame
@@ -850,6 +861,7 @@ class DataAnalystDataFrame(pd.DataFrame):
         return info
 
     # Quick describe
+    @versionadded(version="3.2.0")
     def qdescribe(self) -> pd.DataFrame:
         """
         Quick ``describe()`` that exclude ``object`` and ``datetime`` dtype
@@ -887,7 +899,9 @@ class DataAnalystDataFrame(pd.DataFrame):
         else:
             out = df_na.to_frame()
         out.rename(columns={0: "Num of N/A"}, inplace=True)
-        out["Percentage"] = (out["Num of N/A"] / self.shape[0] * 100).round(percentage_round_up)
+        out["Percentage"] = (out["Num of N/A"] / self.shape[0] * 100).round(
+            percentage_round_up
+        )
 
         # logger.debug(
         #     f"Percentage of N/A over entire DF: "
@@ -896,13 +910,14 @@ class DataAnalystDataFrame(pd.DataFrame):
         return out
 
     # Show distribution
+    @versionadded(version="3.2.0")
     def show_distribution(
-        self, 
-        column_name: str, 
+        self,
+        column_name: str,
         dropna: bool = True,
-        *, 
+        *,
         show_percentage: bool = True,
-        percentage_round_up: int = 2
+        percentage_round_up: int = 2,
     ) -> pd.DataFrame:
         """
         Show distribution of a column
@@ -928,12 +943,31 @@ class DataAnalystDataFrame(pd.DataFrame):
         -------
         DataFrame
             Distribution DataFrame
+
+
+        Example:
+        --------
+        >>> DataAnalystDataFrame.sample_df().show_distribution("number_range")
+          number_range  count  percentage
+        0          900     16        16.0
+        1          700     15        15.0
+        2          300     12        12.0
+        3          200     12        12.0
+        4          400     11        11.0
+        5          600     11        11.0
+        6          800     10        10.0
+        7          100      9         9.0
+        8          500      4         4.0
         """
         out = self[column_name].value_counts(dropna=dropna).to_frame().reset_index()
         if show_percentage:
-            out["percentage"] = (out["count"] / self.shape[0] * 100).round(percentage_round_up)
+            out["percentage"] = (out["count"] / self.shape[0] * 100).round(
+                percentage_round_up
+            )
         else:
-            out["percentage"] = (out["count"] / self.shape[0]).round(percentage_round_up)
+            out["percentage"] = (out["count"] / self.shape[0]).round(
+                percentage_round_up
+            )
         return out
 
     # Help
@@ -942,7 +976,7 @@ class DataAnalystDataFrame(pd.DataFrame):
         """
         Show all available method of DataAnalystDataFrame
         """
-        list_of_method = list(set(dir(__class__)) - set(dir(pd.DataFrame)))
+        list_of_method = list(set(dir(__class__)) - set(dir(pd.DataFrame)))  # type: ignore
         return sorted(list_of_method)
 
     # Sample DataFrame
@@ -962,9 +996,27 @@ class DataAnalystDataFrame(pd.DataFrame):
         DataAnalystDataFrame
             DataFrame with these columns:
             [number, number_big, number_range, missing_value, text, date]
+
+
+        Example:
+        --------
+        >>> DataAnalystDataFrame.sample_df()
+              number  number_big number_range  missing_value      text       date
+        0  -2.089770         785          700            NaN  vwnlqoql 2013-11-20
+        1  -0.526689         182          100           24.0  prjjcvqc 2007-04-13
+        2  -1.596514         909          900            8.0  cbcpzlac 2023-05-24
+        3   2.982191         989          900           21.0  ivwqwuvd 2022-04-28
+        4   1.687803         878          800            NaN  aajtncum 2005-10-05
+        ..       ...         ...          ...            ...       ...        ...
+        95 -1.295145         968          900           16.0  mgqunkhi 2016-04-12
+        96  1.296795         255          200            NaN  lwvytego 2014-05-10
+        97  1.440746         297          200            5.0  lqsoykun 2010-04-03
+        98  0.327702         845          800            NaN  leadkvsy 2005-08-05
+        99  0.556720         981          900           36.0  bozmxixy 2004-02-22
+        [100 rows x 6 columns]
         """
         # Restrain
-        size = set_min(size, min_value=1)
+        size = int(set_min(size, min_value=1))
 
         # Number col
         df = pd.DataFrame(np.random.randn(size, 1), columns=["number"])