bs-python-utils 0.0.1__py3-none-any.whl

bs_python_utils/bs_logging.py

@@ -0,0 +1,100 @@
+""" Utilities for logging
+"""
+import functools
+import logging
+from pathlib import Path
+from typing import Callable
+
+
+def init_logger(
+    logger_name: str,
+    log_level_for_console: str = "info",
+    log_level_for_file: str = "debug",
+    save_dir: str = None,
+) -> logging.Logger:
+    """
+    Initialize a logger
+
+    Args:
+        logger_name: name for the logger
+        log_level_for_console: minimum level of messages logged to the console logging
+        log_level_for_file:
+        save_dir:
+
+    Returns:
+        the logger
+
+    Example:
+        logger_dir = "logs"
+        logger_name = "check_log"
+        logger = init_logger(logger_name, save_dir=logger_dir)
+        logger = get_logger(logger_name)
+
+        will create two logs:
+
+        * one  printed to console where we run the code (the `StreamHandler`),
+        * and one that will be saved to file `save_dir/logger_name.txt` (the `FileHandler`).
+
+        `'logger.propagate = False'`  makes sure that the logs sent to file will not be printed to console.
+
+        We use the `Formatter` class to define the format of the logs.
+        Here:
+        * The time of the log in a human-readable format, `asctime`
+        * `levelname` is the level of the log, one out of `INFO, DEBUG, WARNING, ERROR, CRITICAL`.
+        * The name of the file, `filename`, from which the log was generated,
+        and the line number, `lineno`.
+        *  Lastly,  the message itself — `message`.
+
+        The default has only `INFO` logs and above (i.e., also `WARNING, ERROR` and `CRITICAL`)
+        displayed in the console; the file will also include `DEBUG` logs.
+    """
+    logger = logging.getLogger()
+    logger.setLevel(level=logging.DEBUG)
+    logger.propagate = False
+
+    formatter = logging.Formatter(
+        "%(asctime)s [%(levelname)s] %(filename)s %(lineno)d - %(message)s",
+        "%Y-%m-%d %H:%M:%S",
+    )
+
+    ch = logging.StreamHandler()
+    ch.setLevel(log_level_for_console.upper())
+    ch.setFormatter(formatter)
+    logger.addHandler(ch)
+
+    if save_dir is not None:
+        Path(save_dir).mkdir(exist_ok=True, parents=True)
+        fh = logging.FileHandler(save_dir + f"/{logger_name}.txt")
+        fh.setLevel(log_level_for_file.upper())
+        fh.setFormatter(formatter)
+        logger.addHandler(fh)
+
+    return logger
+
+
+def log_execution(func: Callable) -> Callable:
+    """Decorator to log the execution of a function
+    Only records entry to and exit from the function, to the console
+    """
+    loglevel = logging.info
+
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        loglevel(f"Executing {func.__name__}")
+        result = func(*args, **kwargs)
+        loglevel(f"Finished executing {func.__name__}")
+        return result
+
+    return wrapper
+
+
+def get_logger(logger_name: str) -> logging.Logger:
+    """Get a logger
+
+    Args:
+        logger_name: name you want for the logger
+
+    Returns:
+        the logger
+    """
+    return logging.getLogger(logger_name)

bs_python_utils/bs_mathstr.py

@@ -0,0 +1,130 @@
+"""Some useful strings for math formulae.
+
+Attributes:
+    str_beta0 (str): the LaTeX string `\\beta_0`
+
+    str_beta1 (str): the LaTeX string `\\beta_1`
+
+    str_pi (str): the LaTeX string `\\pi`
+
+    str_sigma (str): the LaTeX string `\\sigma`
+
+    str_sigma2 (str): the LaTeX string `\\sigma^2`
+
+    uni_beta0 (str): the Unicode string `\\beta_0`
+
+    uni_beta1 (str): the Unicode string `\\beta_1`
+
+    uni_pi (str): the Unicode string `\\pi`
+
+    uni_sigma (str): the Unicode string `\\sigma`
+
+    uni_sigma2 (str): the Unicode string `\\sigma^2`
+
+    uni_s2 (str): the Unicode string `s^2`
+
+    uni_R2 (str): the Unicode string `R^2`
+
+    sub_sub_scripts (dict): a dictionary of Unicodes for subscripts and superscripts;
+        e.g `a^b` would be `"a" + sub_sup_scripts['b'][0]`
+"""
+
+#  LaTeX strings
+str_beta0 = r"$\beta_0$"
+str_beta1 = r"$\beta_1$"
+str_pi = r"$\pi$"
+str_sigma = r"$\sigma$"
+str_sigma2 = r"$\sigma^2$"
+
+# Unicode
+uni_beta0 = "\N{GREEK SMALL LETTER BETA}\N{SUBSCRIPT ZERO}"
+uni_beta1 = "\N{GREEK SMALL LETTER BETA}\N{SUBSCRIPT ONE}"
+uni_pi = "\N{GREEK SMALL LETTER PI}"
+uni_sigma = "\N{GREEK SMALL LETTER SIGMA}"
+uni_sigma2 = "\N{GREEK SMALL LETTER SIGMA}\N{SUPERSCRIPT TWO}"
+uni_s2 = "s\N{SUPERSCRIPT TWO}"
+uni_R2 = "R\N{SUPERSCRIPT TWO}"
+
+
+sub_sup_scripts = {
+    #           superscript     subscript
+    "0": ("\u2070", "\u2080"),
+    "1": ("\u00B9", "\u2081"),
+    "2": ("\u00B2", "\u2082"),
+    "3": ("\u00B3", "\u2083"),
+    "4": ("\u2074", "\u2084"),
+    "5": ("\u2075", "\u2085"),
+    "6": ("\u2076", "\u2086"),
+    "7": ("\u2077", "\u2087"),
+    "8": ("\u2078", "\u2088"),
+    "9": ("\u2079", "\u2089"),
+    "a": ("\u1d43", "\u2090"),
+    "b": ("\u1d47", "?"),
+    "c": ("\u1d9c", "?"),
+    "d": ("\u1d48", "?"),
+    "e": ("\u1d49", "\u2091"),
+    "f": ("\u1da0", "?"),
+    "g": ("\u1d4d", "?"),
+    "h": ("\u02b0", "\u2095"),
+    "i": ("\u2071", "\u1d62"),
+    "j": ("\u02b2", "\u2c7c"),
+    "k": ("\u1d4f", "\u2096"),
+    "l": ("\u02e1", "\u2097"),
+    "m": ("\u1d50", "\u2098"),
+    "n": ("\u207f", "\u2099"),
+    "o": ("\u1d52", "\u2092"),
+    "p": ("\u1d56", "\u209a"),
+    "q": ("?", "?"),
+    "r": ("\u02b3", "\u1d63"),
+    "s": ("\u02e2", "\u209b"),
+    "t": ("\u1d57", "\u209c"),
+    "u": ("\u1d58", "\u1d64"),
+    "v": ("\u1d5b", "\u1d65"),
+    "w": ("\u02b7", "?"),
+    "x": ("\u02e3", "\u2093"),
+    "y": ("\u02b8", "?"),
+    "z": ("?", "?"),
+    "A": ("\u1d2c", "?"),
+    "B": ("\u1d2e", "?"),
+    "C": ("?", "?"),
+    "D": ("\u1d30", "?"),
+    "E": ("\u1d31", "?"),
+    "F": ("?", "?"),
+    "G": ("\u1d33", "?"),
+    "H": ("\u1d34", "?"),
+    "I": ("\u1d35", "?"),
+    "J": ("\u1d36", "?"),
+    "K": ("\u1d37", "?"),
+    "L": ("\u1d38", "?"),
+    "M": ("\u1d39", "?"),
+    "N": ("\u1d3a", "?"),
+    "O": ("\u1d3c", "?"),
+    "P": ("\u1d3e", "?"),
+    "Q": ("?", "?"),
+    "R": ("\u1d3f", "?"),
+    "S": ("?", "?"),
+    "T": ("\u1d40", "?"),
+    "U": ("\u1d41", "?"),
+    "V": ("\u2c7d", "?"),
+    "W": ("\u1d42", "?"),
+    "X": ("?", "?"),
+    "Y": ("?", "?"),
+    "Z": ("?", "?"),
+    "+": ("\u207A", "\u208A"),
+    "-": ("\u207B", "\u208B"),
+    "=": ("\u207C", "\u208C"),
+    "(": ("\u207D", "\u208D"),
+    ")": ("\u207E", "\u208E"),
+    ":alpha": ("\u1d45", "?"),
+    ":beta": ("\u1d5d", "\u1d66"),
+    ":gamma": ("\u1d5e", "\u1d67"),
+    ":delta": ("\u1d5f", "?"),
+    ":epsilon": ("\u1d4b", "?"),
+    ":theta": ("\u1dbf", "?"),
+    ":iota": ("\u1da5", "?"),
+    ":pho": ("?", "\u1d68"),
+    ":phi": ("\u1db2", "?"),
+    ":psi": ("\u1d60", "\u1d69"),
+    ":chi": ("\u1d61", "\u1d6a"),
+    ":coffee": ("\u2615", "\u2615"),
+}

bs_python_utils/bs_mem.py

@@ -0,0 +1,148 @@
+import linecache
+import sys
+import tracemalloc
+
+import pandas as pd
+
+from bs_python_utils.bsutils import print_stars
+
+
+def _obj_size_fmt(num: int) -> str:
+    """
+    format sizes from bytes to appropriate strings depending on size
+
+    Args:
+        num: size of object in bytes
+
+    Returns:
+        its formatted size
+    """
+    if num < 10**3:
+        return "{:.2f}{}".format(num, "B")
+    elif (num >= 10**3) & (num < 10**6):
+        return "{:.2f}{}".format(num / (1.024 * 10**3), "KB")
+    elif (num >= 10**6) & (num < 10**9):
+        return "{:.2f}{}".format(num / (1.024 * 10**6), "MB")
+    else:
+        return "{:.2f}{}".format(num / (1.024 * 10**9), "GB")
+
+
+def memory_usage(n: int | None = 10) -> None:
+    """
+    dataframe of the top `n` largest global items in memory
+
+    Args:
+        n: we report the size of the largest `n` global items
+
+    Returns:
+        nothing
+    """
+    memory_usage_by_variable = pd.DataFrame(
+        {k: sys.getsizeof(v) for (k, v) in globals().items()}, index=["Size"]
+    )
+    memory_usage_by_variable = memory_usage_by_variable.T
+    total_usage = _obj_size_fmt(memory_usage_by_variable["Size"].sum())
+    memory_usage_by_variable = memory_usage_by_variable.sort_values(
+        by="Size", ascending=False
+    ).head(n)
+    memory_usage_by_variable["Size"] = memory_usage_by_variable["Size"].apply(
+        lambda x: _obj_size_fmt(x)
+    )
+    print_stars(
+        f"Currently used memory = {total_usage}\n\t\t\t\t Top {n} global objects:"
+    )
+    print(memory_usage_by_variable)
+
+    return
+
+
+def memory_display_top(
+    snapshot: tracemalloc.Snapshot, key_type: str = "lineno", limit: int | None = 5
+) -> None:
+    """
+    prints out the lines with the top `limit` allocations of memory since tracemalloc.start()
+
+    Args:
+        snapshot: obtained from tracemalloc.take_snapshot()
+        key_type: 'lineno' gives file and line number; 'traceback' gives all
+        limit: how many top allocations we want
+
+    Returns:
+        just prints
+
+    Example:
+       tracemalloc.start()
+       .... execute ...
+       snapshot = tracemalloc.take_snapshot()
+       memory_display_top(snapshot)
+    """
+
+    top_stats = snapshot.statistics(key_type)
+
+    print_stars(f"Top {limit} memory allocations")
+    for index, stat in enumerate(top_stats[:limit], 1):
+        frame = stat.traceback[0]
+        print(
+            "#%s: %s:%s: %.1f KiB"
+            % (index, frame.filename, frame.lineno, stat.size / 1024)
+        )
+        line = linecache.getline(frame.filename, frame.lineno).strip()
+        if line:
+            print("    %s" % line)
+
+    other = top_stats[limit:]
+    if other:
+        size = sum(stat.size for stat in other)
+        print(f"{len(other)} other: {size / 1024:.1f} KiB")
+    total = sum(stat.size for stat in top_stats)
+    print("Total allocated size: %.1f KiB" % (total / 1024))
+
+
+def memory_display_top_diffs(
+    snapshot1: tracemalloc.Snapshot,
+    snapshot2: tracemalloc.Snapshot,
+    key_type: str = "lineno",
+    limit: int = 5,
+) -> None:
+    """
+    prints out the lines with the top `limit` allocations \
+     between the two snapshots
+    
+    Args:
+        snapshot1: previous snapshot
+        snapshot2: new snapshot
+        key_type: 'lineno' gives file and line number; 'traceback' gives all
+        limit: how many top allocations we want
+
+    Returns: 
+        just prints
+
+    Example:
+       tracemalloc.start()
+       .... execute ...
+       snapshot1 = tracemalloc.take_snapshot()
+       .... execute ...
+       snapshot2 = tracemalloc.take_snapshot()
+       memory_display_top_diffs(snapshot1, snapshot2)
+
+    """
+
+    top_stats = snapshot2.compare_to(snapshot1, key_type)
+
+    print_stars(f"Top {limit} new memory allocations")
+    for index, stat in enumerate(top_stats[:limit], 1):
+        frame = stat.traceback[0]
+        print(
+            "#%s: %s:%s: %.1f KiB"
+            % (index, frame.filename, frame.lineno, stat.size / 1024)
+        )
+        line = linecache.getline(frame.filename, frame.lineno).strip()
+        if line:
+            print("    %s" % line)
+
+    other = top_stats[limit:]
+    if other:
+        size = sum(stat.size for stat in other)
+        print(f"{len(other)} other: {size / 1024:.1f} KiB")
+    total = sum(stat.size for stat in top_stats)
+    print("Total allocated size: %.1f KiB" % (total / 1024))