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

absfuyu/util/performance.py

@@ -3,48 +3,66 @@ Absfuyu: Performance
 --------------------
 Performance Check
 
-Version: 1.1.0
-Date updated: 11/12/2023 (dd/mm/yyyy)
+Version: 1.2.3
+Date updated: 05/04/2024 (dd/mm/yyyy)
 
 Feature:
 --------
 - measure_performance
+- function_debug
+- retry
 - var_check
-- source_this
+- Checker
 """
 
-
 # Module level
 ###########################################################################
 __all__ = [
     # Wrapper
+    "function_debug",
     "measure_performance",
-    # Functions
-    "var_check",
-    "source_this",
+    "retry",
+    # Class
+    "Checker",
 ]
 
 
 # Library
 ###########################################################################
-from functools import wraps as __wraps
+import time
+import tracemalloc
+from functools import wraps
 from inspect import getsource
-from time import perf_counter as __perf_counter
-import tracemalloc as __tracemalloc
-from typing import Any, Callable, List, Optional, Tuple, Union
+from typing import Any, Callable, Dict, List, Union
+
+from deprecated.sphinx import versionadded, versionchanged
 
 from absfuyu.general.data_extension import ListNoDunder
 
+# from absfuyu.logger import logger, LogLevel
+
 
 # Function
 ###########################################################################
-def measure_performance(func):
+@versionchanged(version="3.2.0", reason="Clean up code")
+def measure_performance(func: Callable) -> Callable:  # type: ignore
     r"""
     Measure performance of a function
 
+    Parameters
+    ----------
+    func : Callable
+        A callable function
+
+    Returns
+    -------
+    Callable
+        A callable function
+
+
     Usage
     -----
-    Use this as the decorator (``@measure_performance``)
+    Use this as a decorator (``@measure_performance``)
 
     Example:
     --------
@@ -52,199 +70,263 @@ def measure_performance(func):
     >>> def test():
     ...     return 1 + 1
     >>> test()
-        ----------------------------------------
+        --------------------------------------
         Function: test
         Memory usage:		 0.000000 MB
         Peak memory usage:	 0.000000 MB
         Time elapsed (seconds):	 0.000002
-        ----------------------------------------
+        --------------------------------------
     """
-    
-    @__wraps(func)
-    def wrapper(*args, **kwargs):
-        # Start memory measure
-        __tracemalloc.start()
-        # Start time measure
-        start_time = __perf_counter()
-        # Run function
-        func(*args, **kwargs)
-        # Get memory stats
-        current, peak = __tracemalloc.get_traced_memory()
-        # Get finished time
-        finish_time = __perf_counter()
-        # End memory measure
-        __tracemalloc.stop()
-        
+
+    @wraps(func)
+    def wrapper(*args, **kwargs) -> Any:
+        # Performance check
+        tracemalloc.start()  # Start memory 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 = time.perf_counter()  # Get finished time
+        tracemalloc.stop()  # End memory measure
+
         # Print output
-        # print(f'{"-"*40}')
-        # print(f'Function: {func.__name__}')
-        # #print(f'Method: {func.__doc__}')
-        # print(f"Memory usage:\t\t {current / 10**6:.6f} MB")
-        # print(f"Peak memory usage:\t {peak / 10**6:.6f} MB")
-        # print(f'Time elapsed (seconds):\t {finish_time - start_time:.6f}')
-        # print(f'{"-"*40}')
-        
-        stat = {
-            "Function": func.__name__,
-            "Memory usage": current / 10**6,
-            "Peak memory usage": peak / 10**6,
-            "Time elapsed (seconds)": finish_time - start_time,
-        }
-        out: bool = False
-        
-        print(f"""
-        {"-"*40}
-        Function: {stat["Function"]}
-        Memory usage:\t\t {stat["Memory usage"]:,.6f} MB
-        Peak memory usage:\t {stat["Peak memory usage"]:,.6f} MB
-        Time elapsed (seconds):\t {stat["Time elapsed (seconds)"]:,.6f}
-        {"-"*40}
-        """)
-        
-        if out:
-            return stat
-        
+        print(
+            f"{'-' * 38}\n"
+            f"Function: {func.__name__}\n"
+            f"Memory usage:\t\t {current / 10**6:,.6f} MB\n"
+            f"Peak memory usage:\t {peak / 10**6:,.6f} MB\n"
+            f"Time elapsed (seconds):\t {finish_time - start_time:,.6f}\n"
+            f"{'-' * 38}"
+        )
+
+        # Return
+        return output
+
     return wrapper
 
 
-def var_check(variable: Any, full: bool = False):
+@versionadded(version="3.2.0")
+def function_debug(func: Callable) -> Callable:  # type: ignore
     """
-    Check a variable
+    Print the function signature and return value
 
     Parameters
     ----------
-    variable : Any
-        Variable that needed to check
+    func : Callable
+        A callable function
 
-    full : bool
-        | ``True``: Shows full detail
-        | ``False``: Hides ``dir`` and ``docstring``
+    Returns
+    -------
+    Callable
+        A callable function
 
 
+    Usage
+    -----
+    Use this as a decorator (``@function_debug``)
+
     Example:
     --------
-    >>> test = "test"
-    >>> var_check(test)
-    {'value': 'test', 'class': str, 'id': ...}
+    >>> @function_debug
+    >>> def test(a: int, b: int):
+    ...     return a + b
+    >>> test(6, 8)
+    Calling test(6, 8)
+    test() returned 14
     """
-    
-    # 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
+    @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})")
+        value = func(*args, **kwargs)
+        print(f"{func.__name__}() returned {repr(value)}")
+        # logger.debug(f"{func.__name__}() returned {repr(value)}")
+        return value
+
+    return wrapper
 
 
-def source_this(function: Callable) -> str:
+@versionadded(version="3.2.0")
+def retry(retries: int = 3, delay: float = 1) -> Callable:  # type: ignore
     """
-    Show the source code of a function
+    Attempt to call a function, if it fails, try again with a specified delay.
 
     Parameters
     ----------
-    function : Callable
-        Just put in the function name
+    retries : int
+        The max amount of retries you want for the function call
+
+    delay : int
+        The delay (in seconds) between each function retry
 
     Returns
     -------
-    str
-        Source code
+    Callable
+        A callable function
+
+
+    Usage
+    -----
+    Use this as a decorator (``@retry``)
+
+    Example:
+    --------
+    >>> @retry(retries=3, delay=1)
+    >>> def test() -> None:
+    ...     time.sleep(1)
+    ...     raise Exception("Function error")
+    >>> test()
+    Running (1): test()
+    Error: Exception('Function error') -> Retrying...
+    Running (2): test()
+    Error: Exception('Function error') -> Retrying...
+    Running (3): test()
+    Error: Exception('Function error').
+    "test()" failed after 3 retries.
+    """
+
+    # Condition
+    if retries < 1 or delay <= 0:
+        raise ValueError("retries must be >= 1, delay must be >= 0")
+
+    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)
+                except Exception as e:
+                    # Break out of the loop if the max amount of retries is exceeded
+                    if i == retries:
+                        print(f"Error: {repr(e)}.")
+                        print(f'"{func.__name__}()" failed after {retries} retries.')
+                        break
+                    else:
+                        print(f"Error: {repr(e)} -> Retrying...")
+                        time.sleep(
+                            delay
+                        )  # Add a delay before running the next iteration
+
+        return wrapper
+
+    return decorator
+
+
+def _deprecated_warning(func: Callable):  # type: ignore
+    """
+    Notice that the function is deprecated and should not be used
+
+    Parameters
+    ----------
+    func : Callable
+        A callable function
+
+    Usage
+    -----
+    Use this as the decorator (``@deprecated_warning``)
     """
-    return getsource(function)
+
+    @wraps(func)
+    def wrapper(*args, **kwargs) -> Any:
+        print(f"[WARNING] {func.__name__}() is deprecated")
+        value = func(*args, **kwargs)
+        return value
+
+    return wrapper
 
 
 # Class
 ###########################################################################
 class Checker:
-    """Check a variable"""
-    def __init__(self, checker: Any) -> None:
-        self.item_to_check = checker
+    """
+    Check a variable
+
+    Parameters
+    ----------
+    variable : Any
+        Variable that needed to check
+
+
+    Example:
+    --------
+    >>> test = "test"
+    >>> 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})"
 
     @property
     def name(self) -> Union[Any, None]:
+        """``__name__`` of variable (if any)"""
         try:
             return self.item_to_check.__name__
-        except:
+        except Exception:
             return None
 
     @property
     def value(self) -> Any:
+        """Value of the variable"""
         return self.item_to_check
 
     @property
     def docstring(self) -> Union[str, None]:
-        """:returns: ``self.item_to_check.__doc__``"""
-        return self.item_to_check.__doc__
+        """``__doc__`` of variable (if any)"""
+        return self.item_to_check.__doc__  # type: ignore
 
     @property
     def class_(self) -> Any:
+        """``class()`` of variable"""
         return type(self.item_to_check)
 
     @property
     def id_(self) -> int:
+        """``id()`` of variable"""
         return id(self.item_to_check)
 
     @property
     def dir_(self) -> List[str]:
-        """:returns: ``dir(self.item_to_check)``"""
+        """``dir()`` of variable"""
         # return self.item_to_check.__dir__()
         return ListNoDunder(self.item_to_check.__dir__())
-    
+
     @property
     def source(self) -> Union[str, None]:
-        """:returns: Source code"""
+        """Source code of variable (if available)"""
         try:
             return getsource(self.item_to_check)
-        except:
+        except Exception:
             return None
 
-    def check(self, full: bool = False):
+    def check(self, full: bool = False) -> Dict[str, Any]:
         """
-        Check
+        Check the variable
+
+        Parameters
+        ----------
+        full : bool
+            | ``True``: Shows full detail
+            | ``False``: Hides ``dir``, ``docstring`` and source code
+            | Default: ``False``
+
+        Returns
+        -------
+        dict[str, Any]
+            Check result
         """
         out = {
             "name": self.name,

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)