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

absfuyu/util/performance.py

@@ -3,8 +3,8 @@ Absfuyu: Performance
 --------------------
 Performance Check
 
-Version: 1.2.0
-Date updated: 14/03/2024 (dd/mm/yyyy)
+Version: 1.2.3
+Date updated: 05/04/2024 (dd/mm/yyyy)
 
 Feature:
 --------
@@ -15,7 +15,6 @@ Feature:
 - Checker
 """
 
-
 # Module level
 ###########################################################################
 __all__ = [
@@ -23,8 +22,6 @@ __all__ = [
     "function_debug",
     "measure_performance",
     "retry",
-    # Functions
-    "var_check",
     # Class
     "Checker",
 ]
@@ -32,20 +29,23 @@ __all__ = [
 
 # Library
 ###########################################################################
+import time
+import tracemalloc
 from functools import wraps
 from inspect import getsource
-from time import perf_counter, sleep
-import tracemalloc
 from typing import Any, Callable, Dict, List, Union
 
-from deprecated import deprecated
+from deprecated.sphinx import versionadded, versionchanged
 
 from absfuyu.general.data_extension import ListNoDunder
+
 # from absfuyu.logger import logger, LogLevel
 
+
 # Function
 ###########################################################################
-def measure_performance(func: Callable) -> Callable:
+@versionchanged(version="3.2.0", reason="Clean up code")
+def measure_performance(func: Callable) -> Callable:  # type: ignore
     r"""
     Measure performance of a function
 
@@ -77,18 +77,18 @@ def measure_performance(func: Callable) -> Callable:
         Time elapsed (seconds):	 0.000002
         --------------------------------------
     """
-    
+
     @wraps(func)
     def wrapper(*args, **kwargs) -> Any:
         # Performance check
         tracemalloc.start()  # Start memory measure
-        start_time = perf_counter()  # Start time measure
+        start_time = time.perf_counter()  # Start time measure
         output = func(*args, **kwargs)  # Run function and save result into a variable
         current, peak = tracemalloc.get_traced_memory()  # Get memory stats
-        finish_time = perf_counter()  # Get finished time
+        finish_time = time.perf_counter()  # Get finished time
         tracemalloc.stop()  # End memory measure
-        
-        # Print output 
+
+        # Print output
         print(
             f"{'-' * 38}\n"
             f"Function: {func.__name__}\n"
@@ -100,11 +100,12 @@ def measure_performance(func: Callable) -> Callable:
 
         # Return
         return output
-        
+
     return wrapper
 
 
-def function_debug(func: Callable) -> Callable:
+@versionadded(version="3.2.0")
+def function_debug(func: Callable) -> Callable:  # type: ignore
     """
     Print the function signature and return value
 
@@ -132,13 +133,14 @@ def function_debug(func: Callable) -> Callable:
     Calling test(6, 8)
     test() returned 14
     """
+
     @wraps(func)
     def wrapper(*args, **kwargs) -> Any:
         # Get all parameters inputed
         args_repr = [repr(a) for a in args]
         kwargs_repr = [f"{k}={repr(v)}" for k, v in kwargs.items()]
         signature = ", ".join(args_repr + kwargs_repr)
-        
+
         # Output
         print(f"Calling {func.__name__}({signature})")
         # logger.debug(f"Calling {func.__name__}({signature})")
@@ -146,10 +148,12 @@ def function_debug(func: Callable) -> Callable:
         print(f"{func.__name__}() returned {repr(value)}")
         # logger.debug(f"{func.__name__}() returned {repr(value)}")
         return value
+
     return wrapper
 
 
-def retry(retries: int = 3, delay: float = 1) -> Callable:
+@versionadded(version="3.2.0")
+def retry(retries: int = 3, delay: float = 1) -> Callable:  # type: ignore
     """
     Attempt to call a function, if it fails, try again with a specified delay.
 
@@ -191,11 +195,10 @@ def retry(retries: int = 3, delay: float = 1) -> Callable:
     if retries < 1 or delay <= 0:
         raise ValueError("retries must be >= 1, delay must be >= 0")
 
-    def decorator(func: Callable) -> Callable:
+    def decorator(func: Callable) -> Callable:  # type: ignore
         @wraps(func)
         def wrapper(*args, **kwargs) -> Any:
             for i in range(1, retries + 1):
-
                 try:
                     print(f"Running ({i}): {func.__name__}()")
                     return func(*args, **kwargs)
@@ -207,14 +210,16 @@ def retry(retries: int = 3, delay: float = 1) -> Callable:
                         break
                     else:
                         print(f"Error: {repr(e)} -> Retrying...")
-                        sleep(delay)  # Add a delay before running the next iteration
+                        time.sleep(
+                            delay
+                        )  # Add a delay before running the next iteration
 
         return wrapper
 
     return decorator
 
 
-def _deprecated_warning(func: Callable):
+def _deprecated_warning(func: Callable):  # type: ignore
     """
     Notice that the function is deprecated and should not be used
 
@@ -227,82 +232,14 @@ def _deprecated_warning(func: Callable):
     -----
     Use this as the decorator (``@deprecated_warning``)
     """
+
     @wraps(func)
     def wrapper(*args, **kwargs) -> Any:
         print(f"[WARNING] {func.__name__}() is deprecated")
         value = func(*args, **kwargs)
         return value
-    return wrapper
-
-
-@deprecated(reason="Implemented into absfuyu.util.performance.Checker()", version="3.2.0")
-def var_check(variable: Any, full: bool = False):  # del soon
-    """
-    Check a variable [Deprecated]
 
-    Parameters
-    ----------
-    variable : Any
-        Variable that needed to check
-
-    full : bool
-        | ``True``: Shows full detail
-        | ``False``: Hides ``dir`` and ``docstring``
-
-
-    Example:
-    --------
-    >>> test = "test"
-    >>> var_check(test)
-    {'value': 'test', 'class': str, 'id': ...}
-    """
-    
-    # Check class
-    try:
-        clss = [variable.__name__, type(variable)]
-    except:
-        clss = type(variable)
-
-    output = dict()
-    try:
-        output = {
-            "value": variable,
-            "class": clss,
-            "id": id(variable),
-        }
-    except:
-        return None
-
-    # Docstring
-    try:
-        lc = [ # list of Python data types
-            str,
-            int, float, complex,
-            list, tuple, range,
-            dict,
-            set, frozenset,
-            bool,
-            bytes, bytearray, memoryview,
-            type(None),
-        ]
-        if type(variable) in lc:
-            pass
-        else:
-            docs = variable.__doc__
-            if full:
-                output["docstring"] = docs
-    except:
-        pass
-
-    # Dir
-    try:
-        if full:
-            output["dir"] = ListNoDunder(variable.__dir__())
-    except:
-        pass
-
-    # Output
-    return output
+    return wrapper
 
 
 # Class
@@ -323,11 +260,12 @@ class Checker:
     >>> Checker(test).check()
     {'name': None, 'value': 'test', 'class': <class 'str'>, 'id': ...}
     """
+
     def __init__(self, variable: Any) -> None:
         self.item_to_check = variable
 
     def __str__(self) -> str:
-        return self.item_to_check.__str__()
+        return self.item_to_check.__str__()  # type: ignore
 
     def __repr__(self) -> str:
         return f"{self.__class__.__name__}({self.item_to_check})"
@@ -337,7 +275,7 @@ class Checker:
         """``__name__`` of variable (if any)"""
         try:
             return self.item_to_check.__name__
-        except:
+        except Exception:
             return None
 
     @property
@@ -348,7 +286,7 @@ class Checker:
     @property
     def docstring(self) -> Union[str, None]:
         """``__doc__`` of variable (if any)"""
-        return self.item_to_check.__doc__
+        return self.item_to_check.__doc__  # type: ignore
 
     @property
     def class_(self) -> Any:
@@ -365,13 +303,13 @@ class Checker:
         """``dir()`` of variable"""
         # return self.item_to_check.__dir__()
         return ListNoDunder(self.item_to_check.__dir__())
-    
+
     @property
     def source(self) -> Union[str, None]:
         """Source code of variable (if available)"""
         try:
             return getsource(self.item_to_check)
-        except:
+        except Exception:
             return None
 
     def check(self, full: bool = False) -> Dict[str, Any]:
@@ -406,4 +344,4 @@ class Checker:
 # Run
 ###########################################################################
 if __name__ == "__main__":
-    pass
+    pass

absfuyu/util/pkl.py

@@ -7,18 +7,15 @@ Version: 1.0.2
 Last update: 24/11/2023 (dd/mm/yyyy)
 """
 
-
 # Module level
 ###########################################################################
-__all__ = [
-    "Pickler"
-]
+__all__ = ["Pickler"]
 
 
 # Library
 ###########################################################################
-from pathlib import Path
 import pickle
+from pathlib import Path
 from typing import Any
 
 
@@ -26,10 +23,13 @@ from typing import Any
 ###########################################################################
 class Pickler:
     """Save and load pickle file"""
+
     def __init__(self) -> None:
         pass
+
     def __str__(self) -> str:
         return f"{self.__class__.__name__}()"
+
     def __repr__(self) -> str:
         return self.__str__()
 
@@ -37,7 +37,7 @@ class Pickler:
     def save(location: Path, data: Any) -> None:
         """
         Save to pickle format
-        
+
         :param location: Save location
         :type location: Path
         :param data: Data want to be saved
@@ -50,7 +50,7 @@ class Pickler:
     def load(location: Path) -> Any:
         """
         Load pickled file
-        
+
         :param location: Load location
         :type location: Path
         :returns: Loaded data
@@ -64,4 +64,4 @@ class Pickler:
 # Run
 ###########################################################################
 if __name__ == "__main__":
-    pass
+    pass

absfuyu/util/zipped.py

@@ -1,26 +1,23 @@
 """
 Absfuyu: Zipped
 ---------------
-Zipping stuff
+Zipping stuff (deprecated soon, most features already in absfuyu.util.path.Directory)
 
 Version: 1.0.1
 Date updated: 24/11/2023 (dd/mm/yyyy)
 """
 
-
 # Module level
 ###########################################################################
-__all__ = [
-    "Zipper"
-]
+__all__ = ["Zipper"]
 
 
 # Library
 ###########################################################################
-from pathlib import Path
 import shutil
-from typing import Union
 import zipfile
+from pathlib import Path
+from typing import Union
 
 from absfuyu.logger import logger
 
@@ -28,11 +25,10 @@ from absfuyu.logger import logger
 ###########################################################################
 class Zipper:
     """Zip file or folder"""
+
     def __init__(
-            self,
-            path_to_zip: Union[str, Path],
-            name: Union[str, None] = None
-        ) -> None:
+        self, path_to_zip: Union[str, Path], name: Union[str, None] = None
+    ) -> None:
         """
         path_to_zip: source location
         name: zipped file name
@@ -43,11 +39,13 @@ class Zipper:
         else:
             self.name = name
         self.destination = self.source_path.parent.joinpath(self.name)
+
     def __str__(self) -> str:
         return f"{self.__class__.__name__}({self.name})"
+
     def __repr__(self) -> str:
         return self.__str__()
-    
+
     def zip_stuff(self, delete_after_zip: bool = False) -> None:
         """
         Zip file/folder
@@ -57,25 +55,25 @@ class Zipper:
         """
 
         # Zip
-        logger.debug(f"Zipping...")
-        if self.source_path.is_dir(): # zip entire folder
+        logger.debug("Zipping...")
+        if self.source_path.is_dir():  # zip entire folder
             try:
                 with zipfile.ZipFile(self.destination, "w", zipfile.ZIP_DEFLATED) as f:
                     for file in self.source_path.rglob("*"):
                         f.write(file, file.relative_to(self.source_path))
-            except:
+            except Exception:
                 logger.error("Zip failed!")
                 # shutil.make_archive(zip_file, format="zip", root_dir=zip_path) # Method 2
-        else: # zip a file
+        else:  # zip a file
             # Implement later
             pass
 
         # Delete folder
         if delete_after_zip:
             try:
-                logger.debug(f"Deleting unused folder...")
+                logger.debug("Deleting unused folder...")
                 shutil.rmtree(self.source_path)
-                logger.debug(f"Files deleted")
+                logger.debug("Files deleted")
             except OSError as e:
                 logger.error(f"Error: {e.filename} - {e.strerror}.")
 
@@ -83,4 +81,4 @@ class Zipper:
 # Run
 ###########################################################################
 if __name__ == "__main__":
-    logger.setLevel(10)
+    logger.setLevel(10)