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

absfuyu/tools/web.py

@@ -3,15 +3,14 @@ Absfuyu: Web
 ------------
 Web, ``request``, ``BeautifulSoup`` stuff
 
-Version: 1.0.1
-Date updated: 24/11/2023 (dd/mm/yyyy)
+Version: 1.0.2
+Date updated: 05/04/2024 (dd/mm/yyyy)
 """
 
-
 # Library
 ###########################################################################
-from bs4 import BeautifulSoup
 import requests
+from bs4 import BeautifulSoup
 
 from absfuyu.logger import logger
 
@@ -37,21 +36,23 @@ def soup_link(link: str) -> BeautifulSoup:
         soup = BeautifulSoup(page.content, "html.parser")
         logger.debug("Soup completed!")
         return soup
-    except:
+    except Exception:
         logger.error("Can't soup")
-        raise SystemExit("Something wrong")
+        raise SystemExit("Something wrong")  # noqa: B904
 
 
 def gen_random_commit_msg() -> str:
     """
     Generate random commit message
 
-    :returns: Random commit message
-    :rtype: str
+    Returns
+    -------
+    str
+        Random commit message
     """
     out = soup_link("https://whatthecommit.com/").get_text()[34:-20]
     logger.debug(out)
-    return out
+    return out  # type: ignore
 
 
 # Run

absfuyu/util/__init__.py

@@ -3,17 +3,15 @@ Absufyu: Utilities
 ------------------
 Some random utilities
 
-Version: 1.5.0
-Date updated: 12/03/2024 (dd/mm/yyyy)
+Version: 1.5.1
+Date updated: 05/04/2024 (dd/mm/yyyy)
 """
 
-
 # Library
 ###########################################################################
-from datetime import datetime
 import pkgutil
-# import sys
-from typing import Union
+from datetime import datetime
+from typing import Optional, Union
 
 from absfuyu.logger import logger
 
@@ -29,17 +27,17 @@ def get_installed_package():
     list[str]
         List of installed packages
     """
-    iter_modules = list({module.name for module in pkgutil.iter_modules() if module.ispkg})
-    # builtin = sys.builtin_module_names
-    # return set.union(iter_modules, builtin)
+    iter_modules = list(
+        {module.name for module in pkgutil.iter_modules() if module.ispkg}
+    )
     return sorted(iter_modules)
 
 
 def set_min(
-        current_value: Union[int, float],
-        *,
-        min_value: Union[int, float] = 0,
-    ) -> Union[int, float]:
+    current_value: Union[int, float],
+    *,
+    min_value: Union[int, float] = 0,
+) -> Union[int, float]:
     """
     Return ``min_value`` when ``current_value`` < ``min_value``
 
@@ -47,11 +45,11 @@ def set_min(
     ----------
     current_value : int | float
         Current value
-    
+
     min_value : int | float
-        Minimum value 
+        Minimum value
         (Default: ``0``)
-    
+
     Returns
     -------
     int | float
@@ -67,11 +65,12 @@ def set_min(
         current_value = min_value
     return current_value
 
+
 def set_max(
-        current_value: Union[int, float],
-        *,
-        max_value: Union[int, float] = 100,
-    ) -> Union[int, float]:
+    current_value: Union[int, float],
+    *,
+    max_value: Union[int, float] = 100,
+) -> Union[int, float]:
     """
     Return ``max_value`` when ``current_value`` > ``max_value``
 
@@ -79,11 +78,11 @@ def set_max(
     ----------
     current_value : int | float
         Current value
-    
+
     max_value : int | float
-        Maximum value 
+        Maximum value
         (Default: ``100``)
-    
+
     Returns
     -------
     int | float
@@ -99,12 +98,13 @@ def set_max(
         current_value = max_value
     return current_value
 
+
 def set_min_max(
-        current_value: Union[int, float],
-        *,
-        min_value: Union[int, float] = 0,
-        max_value: Union[int, float] = 100
-    ) -> Union[int, float]:
+    current_value: Union[int, float],
+    *,
+    min_value: Union[int, float] = 0,
+    max_value: Union[int, float] = 100,
+) -> Union[int, float]:
     """
     Return ``min_value`` | ``max_value`` when ``current_value``
     is outside ``[min_value, max_value]``
@@ -113,15 +113,15 @@ def set_min_max(
     ----------
     current_value : int | float
         Current value
-    
+
     min_value : int | float
-        Minimum value 
+        Minimum value
         (Default: ``0``)
-    
+
     max_value : int | float
-        Maximum value 
+        Maximum value
         (Default: ``100``)
-    
+
     Returns
     -------
     int | float
@@ -139,12 +139,10 @@ def set_min_max(
 
 
 def stop_after_day(
-        year: int = None, 
-        month: int = None, 
-        day: int = None
-    ) -> None:
+    year: Optional[int] = None, month: Optional[int] = None, day: Optional[int] = None
+) -> None:
     """
-    Stop working after specified day. 
+    Stop working after specified day.
     Put the function at the begining of the code is recommended.
 
     Parameters
@@ -169,7 +167,7 @@ def stop_after_day(
         month = now.month
     if day is None:
         day = now.day + 1
-    
+
     # Logic
     end_date = datetime(year, month, day)
     result = end_date - now
@@ -180,4 +178,4 @@ def stop_after_day(
 # Run
 ###########################################################################
 if __name__ == "__main__":
-    logger.setLevel(10)
+    logger.setLevel(10)

absfuyu/util/api.py

@@ -1,14 +1,12 @@
-# -*- coding: utf-8 -*-
 """
 Absufyu: API
 ------------
 Fetch data stuff
 
-Version: 1.1.2
-Date updated: 24/11/2023 (dd/mm/yyyy)
+Version: 1.2.0
+Date updated: 05/04/2024 (dd/mm/yyyy)
 """
 
-
 # Module level
 ###########################################################################
 __all__ = [
@@ -20,58 +18,72 @@ __all__ = [
 # Library
 ###########################################################################
 import json
-from pathlib import Path
 import re
 import subprocess
-from typing import List, Optional, Union
+from pathlib import Path
+from typing import List, NamedTuple, Optional, Union
 
 import requests
+from deprecated.sphinx import versionchanged
 
 from absfuyu.logger import logger
 
 
 # Function
 ###########################################################################
-def ping_windows(host: List[str], ping_count: int = 3) -> list:
+class PingResult(NamedTuple):
+    """
+    :param host: Host name/IP
+    :param result: Ping result in ms
+    """
+
+    host: str
+    result: str
+
+
+@versionchanged(version="3.4.0", reason="Change function's return")
+def ping_windows(host: List[str], ping_count: int = 3) -> List[PingResult]:
     """
     Ping web
-    
+
     Parameters
     ----------
     host : list[str]
         List of host to ping
-    
+
     ping_count : int
-        Number of time to ping to take average 
+        Number of time to ping to take average
         (Default: ``3``)
-    
+
     Returns
     -------
     list
         List of host with pinged value
-    
-        
+
+
     Example:
     --------
     >>> ping_windows(["1.1.1.1", "google.com"])
     ['1.1.1.1 : xxms', 'google.com : xxms']
     """
-    out = []
-    
+    out: List[PingResult] = []
+
     for ip in host:
-        output = subprocess.Popen(
+        output = subprocess.run(
             f"ping {ip.strip()} -n {ping_count}",
-            stdout=subprocess.PIPE,
-            encoding="utf-8"
+            encoding="utf-8",
+            capture_output=True,
+            text=True,
         )
+        logger.debug(output)
 
-        data = "".join(output.stdout)
+        data: str = "".join(output.stdout)
         res = re.findall(r"Average = (.*)", data)
         if res:
-            out.append(f"{ip} : {res[0]}")
+            out.append(PingResult(ip, res[0]))
         else:
-            out.append(f"{ip} : FAILED")
-    
+            out.append(PingResult(ip, "FAILED"))
+
     return out
 
 
@@ -79,51 +91,49 @@ def ping_windows(host: List[str], ping_count: int = 3) -> list:
 ###########################################################################
 class APIRequest:
     """API data with cache feature"""
+
     def __init__(
-            self,
-            api_url: str,
-            *, # Use "*" to force using keyword in function parameter | Example: APIRequest(url, encoding="utf-8")
-            encoding: Optional[str] = "utf-8"
-        ) -> None:
+        self,
+        api_url: str,
+        *,  # Use "*" to force using keyword in function parameter | Example: APIRequest(url, encoding="utf-8")
+        encoding: Optional[str] = "utf-8",
+    ) -> None:
         """
         :param api_url: api link
         :param encoding: data encoding (Default: utf-8)
         """
         self.url = api_url
         self.encoding = encoding
+
     def __str__(self) -> str:
         return f"{self.__class__.__name__}({self.url})"
+
     def __repr__(self) -> str:
         return self.__str__()
 
-    def fetch_data(
-            self,
-            *,
-            update: bool = False,
-            json_cache: Union[str, Path]
-        ):
+    def fetch_data(self, *, update: bool = False, json_cache: Union[str, Path]):
         """
         Fetch data from an API then cache it for later use
 
         Parameters
         ----------
-        update : 
-            Refresh the cache when ``True`` 
+        update :
+            Refresh the cache when ``True``
             (Default: ``False``)
-        
+
         json_cache : Path | str
             Name of the cache
-        
+
         Returns
         -------
         Any
            Data
 
         None
-            No data fetched/unable to fetch data 
+            No data fetched/unable to fetch data
         """
         if update:
-            json_data=None
+            json_data = None
         else:
             try:
                 with open(json_cache, "r", encoding=self.encoding) as file:
@@ -132,7 +142,7 @@ class APIRequest:
             except (FileNotFoundError, json.JSONDecodeError) as e:
                 logger.debug(f"No local cache found... ({e})")
                 json_data = None
-        
+
         if not json_data:
             logger.debug("Fetching new json data... (Creating local cache)")
             try:
@@ -143,11 +153,11 @@ class APIRequest:
                 logger.error(f"Can't create cache due to Path error - {e}")
 
         return json_data
-    
+
     def fetch_data_only(self) -> requests.Response:
         """
         Fetch data without cache
-        
+
         Returns
         -------
         Response
@@ -159,4 +169,4 @@ class APIRequest:
 # Run
 ###########################################################################
 if __name__ == "__main__":
-    logger.setLevel(10)
+    logger.setLevel(10)

absfuyu/util/json_method.py

@@ -3,29 +3,27 @@ Absfuyu: Json Method
 --------------------
 ``.json`` file handling
 
-Version: 1.1.1
-Date updated: 24/11/2023 (dd/mm/yyyy)
+Version: 1.1.3
+Date updated: 05/04/2024 (dd/mm/yyyy)
 """
 
-
 # Module level
 ###########################################################################
-__all__ = [
-    "JsonFile"
-]
+__all__ = ["JsonFile"]
 
 
 # Library
 ###########################################################################
 import json
 from pathlib import Path
-from typing import Optional, Union
+from typing import Any, Dict, Optional, Union
 
 
 # Function
 ###########################################################################
-def load_json(json_file_location: Path): # Depreciated
+def load_json(json_file_location: Path):  # Deprecated
     """Load JSON file"""
+    print("This function is deprecated as of version 3.0.0")
     with open(Path(json_file_location), "r") as json_file:
         data = json.load(json_file)
     return data
@@ -37,14 +35,15 @@ class JsonFile:
     """
     ``.json`` file handling
     """
+
     def __init__(
-            self,
-            json_file_location: Union[str, Path],
-            *,
-            encoding: Optional[str] = "utf-8",
-            indent: Union[int, str, None] = 4,
-            sort_keys: bool = True
-        ) -> None:
+        self,
+        json_file_location: Union[str, Path],
+        *,
+        encoding: Optional[str] = "utf-8",
+        indent: Union[int, str, None] = 4,
+        sort_keys: bool = True,
+    ) -> None:
         """
         json_file_location: json file location
         encoding: data encoding (Default: utf-8)
@@ -55,17 +54,18 @@ class JsonFile:
         self.encoding = encoding
         self.indent = indent
         self.sort_keys = sort_keys
-        self.data = {}
-    
+        self.data: Dict[Any, Any] = {}
+
     def __str__(self) -> str:
         return f"{self.__class__.__name__}({self.json_file_location.name})"
+
     def __repr__(self) -> str:
         return self.__str__()
-    
-    def load_json(self) -> dict:
+
+    def load_json(self) -> Dict[Any, Any]:
         """
         Load ``.json`` file
-        
+
         :returns: ``.json`` data
         :rtype: dict
         """
@@ -75,16 +75,14 @@ class JsonFile:
 
     def save_json(self) -> None:
         """Save ``.json`` file"""
-        json_data = json.dumps(
-            self.data, indent=self.indent, sort_keys=self.sort_keys
-        )
+        json_data = json.dumps(self.data, indent=self.indent, sort_keys=self.sort_keys)
         with open(self.json_file_location, "w", encoding=self.encoding) as file:
             file.writelines(json_data)
-    
-    def update_data(self, data: dict) -> None:
+
+    def update_data(self, data: Dict[Any, Any]) -> None:
         """
         Update ``.json`` data without save
-        
+
         :param data: ``.json`` data
         :type data: dict
         """
@@ -94,4 +92,4 @@ class JsonFile:
 # Run
 ###########################################################################
 if __name__ == "__main__":
-    pass
+    pass

absfuyu/util/lunar.py

@@ -1,10 +1,11 @@
+# flake8: noqa
 """
 Absfuyu: Lunar calendar
 -----------------------
 Convert to lunar calendar
 
-Version: 1.0.1
-Date updated: 24/11/2023 (dd/mm/yyyy)
+Version: 1.0.2
+Date updated: 05/04/2024 (dd/mm/yyyy)
 
 Source:
 -------
@@ -19,11 +20,9 @@ __all__ = ["LunarCalendar"]
 
 # Library
 ###########################################################################
-from datetime import date, datetime
 import math
-from typing import Union
-
-# from absfuyu.logger import logger
+from datetime import date, datetime
+from typing import Optional, Union
 
 
 # Class
@@ -57,9 +56,9 @@ class LunarCalendar:
     def _julian_day_from_date(
         self,
         *,
-        overwrite_year: int = None,
-        overwrite_month: int = None,
-        overwrite_day: int = None,
+        overwrite_year: Optional[int] = None,
+        overwrite_month: Optional[int] = None,
+        overwrite_day: Optional[int] = None,
     ) -> int:
         """
         Compute the (integral) Julian day number of `self.date`
@@ -171,23 +170,23 @@ class LunarCalendar:
         julian_day_noon: The number of days since `1/1/4713 BC noon`.
         """
         T = (julian_day_noon - 2451545.0) / 36525.0
-        ## Time in Julian centuries
-        ## from 2000-01-01 12:00:00 GMT
+        # Time in Julian centuries
+        # from 2000-01-01 12:00:00 GMT
         T2 = math.pow(T, 2)
         T3 = math.pow(T, 3)
-        dr = math.pi / 180.0  ## degree to radian
+        dr = math.pi / 180.0  # degree to radian
         M = 357.52910 + 35999.05030 * T - 0.0001559 * T2 - 0.00000048 * T3
-        ## mean anomaly, degree
+        # mean anomaly, degree
         L0 = 280.46645 + 36000.76983 * T + 0.0003032 * T2
-        ## mean longitude, degree
+        # mean longitude, degree
         DL = (1.914600 - 0.004817 * T - 0.000014 * T2) * math.sin(dr * M)
         DL += (0.019993 - 0.000101 * T) * math.sin(dr * 2 * M) + 0.000290 * math.sin(
             dr * 3 * M
         )
-        L = L0 + DL  ## true longitude, degree
+        L = L0 + DL  # true longitude, degree
         L = L * dr
         L = L - math.pi * 2 * (int(L / (math.pi * 2)))
-        #### Normalize to (0, 2*math.pi)
+        # Normalize to (0, 2*math.pi)
         return L
 
     def _get_sun_longitude(self, day_number: int) -> int:
@@ -201,9 +200,7 @@ class LunarCalendar:
         From the day after March equinox and the 1st major term after March equinox, 0 is returned. After that, return 1, 2, 3 ...
         """
         return int(
-            __class__._sun_longitude(day_number - 0.5 - self.time_zone / 24.0)
-            / math.pi
-            * 6
+            self._sun_longitude(day_number - 0.5 - self.time_zone / 24.0) / math.pi * 6
         )
 
     def _get_new_moon_day(self, k: int) -> int:
@@ -212,9 +209,9 @@ class LunarCalendar:
 
         The time zone if the time difference between local time and UTC: 7.0 for UTC+7:00.
         """
-        return int(__class__._new_moon(k) + 0.5 + self.time_zone / 24.0)
+        return int(self._new_moon(k) + 0.5 + self.time_zone / 24.0)
 
-    def _get_lunar_month_11(self, *, overwrite_year: int = None) -> int:
+    def _get_lunar_month_11(self, *, overwrite_year: Optional[int] = None) -> int:
         """
         Find the day that starts the luner month 11
         of the given year for the given time zone.
@@ -295,7 +292,7 @@ class LunarCalendar:
             lunar_month = lunar_month - 12
         if lunar_month >= 11 and diff < 4:
             lunar_year -= 1
-        return __class__(
+        return self.__class__(
             lunar_year, lunar_month, lunar_day, lunar_leap=self._lunar_leap
         )
 
@@ -337,7 +334,7 @@ class LunarCalendar:
                 off += 1
         monthStart = self._get_new_moon_day(k + off)
         out = self._julian_day_to_date(monthStart + lunarD - 1)
-        return __class__(out.year, out.month, out.day, lunar_leap=self._lunar_leap)
+        return self.__class__(out.year, out.month, out.day, lunar_leap=self._lunar_leap)
 
     def convert_all(self) -> dict:
         """
@@ -409,5 +406,4 @@ class LunarCalendar:
 # Run
 ###########################################################################
 if __name__ == "__main__":
-    # logger.setLevel(10)
     pass