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

absfuyu/logger.py

@@ -3,8 +3,8 @@ Absfuyu: Logger
 ---------------
 Custom Logger Module
 
-Version: 1.3.1
-Date updated: 23/11/2023 (mm/dd/yyyy)
+Version: 1.3.2
+Date updated: 05/04/2024 (mm/dd/yyyy)
 
 Usage:
 ------
@@ -13,28 +13,25 @@ Usage:
 >>> logger.debug("This logs!")
 """
 
-
 # Module level
 ###########################################################################
 __all__ = [
     # logger
-    "logger", "compress_for_log",
+    "logger",
+    "compress_for_log",
     # log level
-    "LogLevel"
+    "LogLevel",
 ]
 
 
 # Library
 ###########################################################################
-# from itertools import chain
 import logging
-from logging.handlers import (
-    TimedRotatingFileHandler as _TRFH,
-    RotatingFileHandler as _RFH
-)
 import math
+from logging.handlers import RotatingFileHandler as _RFH
+from logging.handlers import TimedRotatingFileHandler as _TRFH
 from pathlib import Path
-from typing import Optional, Union
+from typing import Any, Optional, Union
 
 
 # Setup
@@ -43,6 +40,7 @@ class LogLevel:
     """
     ``logging``'s log level wrapper + custom log level
     """
+
     TRACE: int = logging.DEBUG - 5
     DEBUG: int = logging.DEBUG
     INFO: int = logging.INFO
@@ -51,12 +49,15 @@ class LogLevel:
     CRITICAL: int = logging.CRITICAL
     EXTREME: int = logging.CRITICAL + 10
 
+
 class _LogFormat:
     """Some log format styles"""
-    FULL = "[%(asctime)s] [%(process)-d] [%(module)s] [%(name)s] [%(funcName)s] [%(levelname)-s] %(message)s" # Time|ProcessID|Module|Name|Function|LogType|Message
-    SHORT = "[%(module)s] [%(name)s] [%(funcName)s] [%(levelname)-s] %(message)s" # Module|Name|Function|LogType|Message
-    CONSOLE = "%(asctime)s [%(levelname)5s] %(funcName)s:%(lineno)3d: %(message)s" # Time|LogType|Function|LineNumber|Message
-    FILE = "%(asctime)s [%(levelname)5s] %(filename)s:%(funcName)s:%(lineno)3d: %(message)s" # Time|LogType|FileName|Function|LineNumber|Message
+
+    FULL = "[%(asctime)s] [%(process)-d] [%(module)s] [%(name)s] [%(funcName)s] [%(levelname)-s] %(message)s"  # Time|ProcessID|Module|Name|Function|LogType|Message
+    SHORT = "[%(module)s] [%(name)s] [%(funcName)s] [%(levelname)-s] %(message)s"  # Module|Name|Function|LogType|Message
+    CONSOLE = "%(asctime)s [%(levelname)5s] %(funcName)s:%(lineno)3d: %(message)s"  # Time|LogType|Function|LineNumber|Message
+    FILE = "%(asctime)s [%(levelname)5s] %(filename)s:%(funcName)s:%(lineno)3d: %(message)s"  # Time|LogType|FileName|Function|LineNumber|Message
+
 
 # Create a custom logger
 logger = logging.getLogger(__name__)
@@ -65,8 +66,10 @@ logger.setLevel(logging.WARNING)
 # Create handlers
 ## Console log handler
 console_handler = logging.StreamHandler()
-console_handler.setLevel(LogLevel.TRACE) # Minimum log level
-console_handler.setFormatter(logging.Formatter(_LogFormat.CONSOLE, datefmt="%Y-%m-%d %H:%M:%S"))
+console_handler.setLevel(LogLevel.TRACE)  # Minimum log level
+console_handler.setFormatter(
+    logging.Formatter(_LogFormat.CONSOLE, datefmt="%Y-%m-%d %H:%M:%S")
+)
 logger.addHandler(console_handler)
 
 
@@ -75,32 +78,33 @@ logger.addHandler(console_handler)
 def _compress_list_for_print(iterable: list, max_visible: Optional[int] = 5) -> str:
     """
     Compress the list to be more log-readable
-    
+
     iterable: list
     max_visible: Maximum items can be printed on screen (Minimum: 3)
     """
 
     if max_visible is None or max_visible <= 2:
         max_visible = 5
-    
+
     if len(iterable) <= max_visible:
         return str(iterable)
-    else:        
+    else:
         # logger.debug(f"Max vis: {max_visible}")
         if max_visible % 2 == 0:
-            cut_idx_1 = math.floor(max_visible/2) - 1
-            cut_idx_2 = math.floor(max_visible/2)
+            cut_idx_1 = math.floor(max_visible / 2) - 1
+            cut_idx_2 = math.floor(max_visible / 2)
         else:
-            cut_idx_1 = cut_idx_2 = math.floor(max_visible/2)
-        
+            cut_idx_1 = cut_idx_2 = math.floor(max_visible / 2)
+
         # logger.debug(f"Cut pos: {(cut_idx_1, cut_idx_2)}")
         # temp = [iterable[:cut_idx_1], ["..."], iterable[len(iterable)-cut_idx_2:]]
         # out = list(chain.from_iterable(temp))
         # out = [*iterable[:cut_idx_1], "...", *iterable[len(iterable)-cut_idx_2:]] # Version 2
-        out = f"{str(iterable[:cut_idx_1])[:-1]}, ...,{str(iterable[len(iterable)-cut_idx_2:])[1:]}" # Version 3
+        out = f"{str(iterable[:cut_idx_1])[:-1]}, ...,{str(iterable[len(iterable)-cut_idx_2:])[1:]}"  # Version 3
         # logger.debug(out)
         return f"{out} [Len: {len(iterable)}]"
 
+
 def _compress_string_for_print(text: str, max_visible: Optional[int] = 120) -> str:
     """
     Compress the string to be more log-readable
@@ -108,13 +112,13 @@ def _compress_string_for_print(text: str, max_visible: Optional[int] = 120) -> s
     text: str
     max_visible: Maximum text can be printed on screen (Minimum: 5)
     """
-    
+
     if max_visible is None or max_visible <= 5:
         max_visible = 120
-    
-    text = text.replace("\n", " ") # Remove new line
+
+    text = text.replace("\n", " ")  # Remove new line
     # logger.debug(text)
-    
+
     if len(text) <= max_visible:
         return str(text)
     else:
@@ -122,7 +126,8 @@ def _compress_string_for_print(text: str, max_visible: Optional[int] = 120) -> s
         temp = f"{text[:cut_idx]}...{text[len(text)-cut_idx:]}"
         return f"{temp} [Len: {len(text)}]"
 
-def compress_for_log(object_, max_visible: Optional[int] = None) -> str:
+
+def compress_for_log(object_: Any, max_visible: Optional[int] = None) -> str:
     """
     Compress the object to be more log-readable
 
@@ -131,25 +136,25 @@ def compress_for_log(object_, max_visible: Optional[int] = None) -> str:
     :returns: Compressed log output
     :rtype: str
     """
-    
+
     if isinstance(object_, list):
         return _compress_list_for_print(object_, max_visible)
-    
-    elif isinstance(object_, set) or isinstance(object_, tuple):
+
+    elif isinstance(object_, (set, tuple)):
         return _compress_list_for_print(list(object_), max_visible)
-    
+
     elif isinstance(object_, dict):
         temp = [{k: v} for k, v in object_.items()]
         return _compress_list_for_print(temp, max_visible)
-    
+
     elif isinstance(object_, str):
         return _compress_string_for_print(object_, max_visible)
-    
+
     else:
         try:
             return _compress_string_for_print(str(object_), max_visible)
-        except:
-            return object_
+        except Exception:
+            return object_  # type: ignore
 
 
 # Class
@@ -157,22 +162,23 @@ def compress_for_log(object_, max_visible: Optional[int] = None) -> str:
 class _CustomLogger:
     """
     Custom logger [W.I.P]
-    
-    Create a custom logger 
+
+    Create a custom logger
     *Useable but maybe unstable*
     """
+
     def __init__(
-            self,
-            name: str,
-            cwd: Union[str, Path] = ".",
-            log_format: Optional[str] = None,
-            *,
-            save_log_file: bool = False,
-            separated_error_file: bool = False,
-            timed_log: bool = False,
-            date_log_format: Optional[str] = None,
-            error_log_size: int = 1_000_000 # 1 MB
-        ) -> None:
+        self,
+        name: str,
+        cwd: Union[str, Path] = ".",
+        log_format: Optional[str] = None,
+        *,
+        save_log_file: bool = False,
+        separated_error_file: bool = False,
+        timed_log: bool = False,
+        date_log_format: Optional[str] = None,
+        error_log_size: int = 1_000_000,  # 1 MB
+    ) -> None:
         """
         :param name: Custom logger name
         :param cwd: Current working directory
@@ -185,17 +191,19 @@ class _CustomLogger:
         """
         self._cwd = Path(cwd)
         self.log_folder = self._cwd.joinpath("logs")
-        self.log_folder.mkdir(exist_ok=True) # Does not throw exception when folder existed
+        self.log_folder.mkdir(
+            exist_ok=True, parents=True
+        )  # Does not throw exception when folder existed
         self.name = name
         self.log_file = self.log_folder.joinpath(f"{name}.log")
 
         # Create a custom logger
         try:
             self.logger = logging.getLogger(self.name)
-        except:
+        except Exception:
             try:
                 self.logger = logging.getLogger(__name__)
-            except:
+            except Exception:
                 self.logger = logging.getLogger()
         self.logger.setLevel(logging.DEBUG)
 
@@ -207,16 +215,20 @@ class _CustomLogger:
         ## Console log handler
         if log_format is None:
             # Time|LogType|Function|LineNumber|Message
-            _log_format = "%(asctime)s [%(levelname)5s] %(funcName)s:%(lineno)3d: %(message)s"
+            _log_format = (
+                "%(asctime)s [%(levelname)5s] %(funcName)s:%(lineno)3d: %(message)s"
+            )
         else:
             _log_format = log_format
         console_handler = logging.StreamHandler()
-        console_handler.setLevel(logging.DEBUG) # Minimum log level
-        _console_log_format = _log_format # Create formatters and add it to handlers
-        _console_formatter = logging.Formatter(_console_log_format, datefmt=_date_format)
+        console_handler.setLevel(logging.DEBUG)  # Minimum log level
+        _console_log_format = _log_format  # Create formatters and add it to handlers
+        _console_formatter = logging.Formatter(
+            _console_log_format, datefmt=_date_format
+        )
         console_handler.setFormatter(_console_formatter)
         self._console_handler = console_handler
-        self.logger.addHandler(self._console_handler) # Add handlers to the logger
+        self.logger.addHandler(self._console_handler)  # Add handlers to the logger
 
         ## Log file handler
         if save_log_file:
@@ -225,18 +237,24 @@ class _CustomLogger:
                 _log_format = "%(asctime)s [%(levelname)5s] %(filename)s:%(funcName)s:%(lineno)3d: %(message)s"
             else:
                 _log_format = log_format
-            file_handler = logging.FileHandler(self.log_file, mode="a", encoding="utf-8")
+            file_handler = logging.FileHandler(
+                self.log_file, mode="a", encoding="utf-8"
+            )
             file_handler.setLevel(logging.DEBUG)
             _file_log_format = _log_format
             _file_formatter = logging.Formatter(_file_log_format, datefmt=_date_format)
             file_handler.setFormatter(_file_formatter)
             self._file_handler = file_handler
             self.logger.addHandler(self._file_handler)
-            
+
             if timed_log:
                 ## Time handler (split log every day)
-                time_handler = _TRFH(self.log_folder.joinpath(f"{self.name}_timed.log"),
-                                     when="midnight", interval=1, encoding="utf-8")
+                time_handler = _TRFH(
+                    self.log_folder.joinpath(f"{self.name}_timed.log"),
+                    when="midnight",
+                    interval=1,
+                    encoding="utf-8",
+                )
                 time_handler.setLevel(logging.DEBUG)
                 time_handler.setFormatter(_file_formatter)
                 self._time_handler = time_handler
@@ -257,20 +275,27 @@ class _CustomLogger:
                 _log_format = "%(asctime)s [%(levelname)5s] %(filename)s:%(funcName)s:%(lineno)3d: %(message)s"
             else:
                 _log_format = log_format
-            error_handler = _RFH(self.log_folder.joinpath(f"{self.name}_error.log"),
-                                 maxBytes=error_log_size, backupCount=1, encoding="utf-8")
+            error_handler = _RFH(
+                self.log_folder.joinpath(f"{self.name}_error.log"),
+                maxBytes=error_log_size,
+                backupCount=1,
+                encoding="utf-8",
+            )
             error_handler.setLevel(logging.ERROR)
-            error_handler.setFormatter(_log_format)
+            error_handler.setFormatter(_log_format)  # type: ignore
             self._error_handler = error_handler
             self.logger.addHandler(self._error_handler)
 
     def __str__(self) -> str:
         return f"{self.__class__.__name__}({self.name})"
+
     def __repr__(self) -> str:
         return self.__str__()
 
     @staticmethod
-    def _add_logging_level(level_name: str, level_num: int, method_name: str = None):
+    def _add_logging_level(
+        level_name: str, level_num: int, method_name: Optional[str] = None
+    ):
         """
         Comprehensively adds a new logging level to the `logging` module and the
         currently configured logging class.
@@ -302,6 +327,7 @@ class _CustomLogger:
         def logForLevel(self, message, *args, **kwargs):
             if self.isEnabledFor(level_num):
                 self._log(level_num, message, args, **kwargs)
+
         def logToRoot(message, *args, **kwargs):
             logging.log(level_num, message, *args, **kwargs)
 
@@ -311,7 +337,7 @@ class _CustomLogger:
         setattr(logging, method_name, logToRoot)
 
     def add_log_level(self, level_name: str, level_num: int):
-        __class__._add_logging_level(level_name, level_num)
+        __class__._add_logging_level(level_name, level_num)  # type: ignore
         if level_num < logging.DEBUG:
             self._console_handler.setLevel(level_num)
             self.logger.setLevel(level_num)

absfuyu/pkg_data/__init__.py

@@ -7,35 +7,31 @@ Version: 2.2.2
 Date updated: 30/11/2023 (dd/mm/yyyy)
 """
 
-
 # Module level
 ###########################################################################
-__all__ = [
-    "PkgData"
-]
+__all__ = ["PkgData"]
 
 
 # Library
 ###########################################################################
+import zlib
 from ast import literal_eval
 from importlib.resources import read_binary
 from pathlib import Path
+from sys import version_info as _python_version
 from typing import List, Union
-import zlib
-import sys
 
-if sys.version_info.minor >= 10:
+if _python_version.minor >= 10:
     from importlib.resources import files
 else:
     try:
-        from importlib_resources import files
-    except:
-        raise ImportError("Please install importlib-resources")
+        from importlib_resources import files  # type: ignore
+    except Exception:
+        raise ImportError("Please install importlib-resources")  # noqa: B904
 
 from absfuyu.core import DATA_PATH
 from absfuyu.logger import logger
 
-
 # External Data
 ###########################################################################
 _EXTERNAL_DATA = {
@@ -55,14 +51,16 @@ class DataList:
 
 class PkgData:
     """Package data maker/loader"""
+
     def __init__(self, data_name: str) -> None:
         self.name = data_name
-    
+
     def __str__(self) -> str:
         return f"{self.__class__.__name__}({self.name})"
+
     def __repr__(self) -> str:
         return self.__str__()
-    
+
     def _make_dat(self, data: str, name: Union[str, Path]):
         """
         data: string data
@@ -71,11 +69,11 @@ class PkgData:
         compressed_data = zlib.compress(str(data).encode(), zlib.Z_BEST_COMPRESSION)
         with open(name, "wb") as file:
             file.write(compressed_data)
-    
+
     def load_dat_data(self, evaluate: bool = False):
         """
         Load ``.dat`` data from package resource
-        
+
         :param evaluate: use ``ast.literal_eval()`` to evaluate string data
         :type evaluate: bool
         :returns: Loaded data
@@ -98,45 +96,51 @@ class PkgData:
 
 class _ManagePkgData:
     """Manage this package data"""
+
     def __init__(self, pkg_data_loc: Union[str, Path]) -> None:
         """
         pkg_data_loc: Package data location
         """
         self.data_loc = Path(pkg_data_loc)
-    
+
     def __str__(self) -> str:
         return f"{self.__class__.__name__}({self.data_loc.name})"
+
     def __repr__(self) -> str:
         return self.__str__()
-    
+
     def get_data_list(self, *, pattern: str = "*") -> List[Path]:
         """Get a list of data available"""
-        excludes = [x for x in self.data_loc.glob("*.[pP][yY]")] # exclude python scripts
-        return [x for x in self.data_loc.glob(pattern) if x not in excludes and x.is_file()]
-    
+        excludes = [
+            x for x in self.data_loc.glob("*.[pP][yY]")
+        ]  # exclude python scripts
+        return [
+            x for x in self.data_loc.glob(pattern) if x not in excludes and x.is_file()
+        ]
+
     @property
     def data_list(self) -> List[str]:
         """List of available data"""
         return [x.name for x in self.get_data_list()]
-    
+
     def download_all_data(self):
         """
         Download all external data
         """
-        
+
         logger.debug("Downloading data...")
         try:
             from absfuyu.util.api import APIRequest
-            
+
             for data_name, data_link in _EXTERNAL_DATA.items():
                 logger.debug(f"Downloading {data_name}...")
                 data = APIRequest(data_link, encoding="utf-8")
                 data.fetch_data(update=True, json_cache=DATA_PATH.joinpath(data_name))
                 logger.debug(f"Downloading {data_name}...DONE")
             logger.debug("Downloading data...DONE")
-        except:
+        except Exception:
             logger.debug("Downloading data...FAILED")
-    
+
     def clear_data(self) -> None:
         """Clear data in data list"""
         for x in self.get_data_list():