sclab 0.1.8__py3-none-any.whl → 0.2.2__py3-none-any.whl

sclab/scanpy/logging.py

@@ -0,0 +1,290 @@
+"""Logging and Profiling"""
+
+from __future__ import annotations
+
+import logging
+import sys
+import warnings
+from datetime import datetime, timedelta, timezone
+from functools import partial, update_wrapper
+from logging import CRITICAL, DEBUG, ERROR, INFO, WARNING
+from typing import TYPE_CHECKING
+
+import anndata.logging
+
+if TYPE_CHECKING:
+    from typing import IO
+
+    from ._settings import ScanpyConfig
+
+
+# This is currently the only documented API
+__all__ = ["print_versions"]
+
+HINT = (INFO + DEBUG) // 2
+logging.addLevelName(HINT, "HINT")
+
+
+class _RootLogger(logging.RootLogger):
+    def __init__(self, level):
+        super().__init__(level)
+        self.propagate = False
+        _RootLogger.manager = logging.Manager(self)
+
+    def log(
+        self,
+        level: int,
+        msg: str,
+        *,
+        extra: dict | None = None,
+        time: datetime | None = None,
+        deep: str | None = None,
+    ) -> datetime:
+        from ._settings import settings
+
+        now = datetime.now(timezone.utc)
+        time_passed: timedelta = None if time is None else now - time
+        extra = {
+            **(extra or {}),
+            "deep": deep if settings.verbosity.level < level else None,
+            "time_passed": time_passed,
+        }
+        super().log(level, msg, extra=extra)
+        return now
+
+    def critical(self, msg, *, time=None, deep=None, extra=None) -> datetime:
+        return self.log(CRITICAL, msg, time=time, deep=deep, extra=extra)
+
+    def error(self, msg, *, time=None, deep=None, extra=None) -> datetime:
+        return self.log(ERROR, msg, time=time, deep=deep, extra=extra)
+
+    def warning(self, msg, *, time=None, deep=None, extra=None) -> datetime:
+        return self.log(WARNING, msg, time=time, deep=deep, extra=extra)
+
+    def info(self, msg, *, time=None, deep=None, extra=None) -> datetime:
+        return self.log(INFO, msg, time=time, deep=deep, extra=extra)
+
+    def hint(self, msg, *, time=None, deep=None, extra=None) -> datetime:
+        return self.log(HINT, msg, time=time, deep=deep, extra=extra)
+
+    def debug(self, msg, *, time=None, deep=None, extra=None) -> datetime:
+        return self.log(DEBUG, msg, time=time, deep=deep, extra=extra)
+
+
+def _set_log_file(settings: ScanpyConfig):
+    file = settings.logfile
+    name = settings.logpath
+    root = settings._root_logger
+    h = logging.StreamHandler(file) if name is None else logging.FileHandler(name)
+    h.setFormatter(_LogFormatter())
+    h.setLevel(root.level)
+    for handler in list(root.handlers):
+        root.removeHandler(handler)
+    root.addHandler(h)
+
+
+def _set_log_level(settings: ScanpyConfig, level: int):
+    root = settings._root_logger
+    root.setLevel(level)
+    for h in list(root.handlers):
+        h.setLevel(level)
+
+
+class _LogFormatter(logging.Formatter):
+    def __init__(
+        self, fmt="{levelname}: {message}", datefmt="%Y-%m-%d %H:%M", style="{"
+    ):
+        super().__init__(fmt, datefmt, style)
+
+    def format(self, record: logging.LogRecord):
+        format_orig = self._style._fmt
+        if record.levelno == INFO:
+            self._style._fmt = "{message}"
+        elif record.levelno == HINT:
+            self._style._fmt = "--> {message}"
+        elif record.levelno == DEBUG:
+            self._style._fmt = "    {message}"
+        if record.time_passed:
+            # strip microseconds
+            if record.time_passed.microseconds:
+                record.time_passed = timedelta(
+                    seconds=int(record.time_passed.total_seconds())
+                )
+            if "{time_passed}" in record.msg:
+                record.msg = record.msg.replace(
+                    "{time_passed}", str(record.time_passed)
+                )
+            else:
+                self._style._fmt += " ({time_passed})"
+        if record.deep:
+            record.msg = f"{record.msg}: {record.deep}"
+        result = logging.Formatter.format(self, record)
+        self._style._fmt = format_orig
+        return result
+
+
+print_memory_usage = anndata.logging.print_memory_usage
+get_memory_usage = anndata.logging.get_memory_usage
+
+
+_DEPENDENCIES_NUMERICS = [
+    "anndata",  # anndata actually shouldn't, but as long as it's in development
+    "umap",
+    "numpy",
+    "scipy",
+    "pandas",
+    ("sklearn", "scikit-learn"),
+    "statsmodels",
+    "igraph",
+    "louvain",
+    "leidenalg",
+    "pynndescent",
+]
+
+
+def _versions_dependencies(dependencies):
+    # this is not the same as the requirements!
+    for mod in dependencies:
+        mod_name, dist_name = mod if isinstance(mod, tuple) else (mod, mod)
+        try:
+            imp = __import__(mod_name)
+            yield dist_name, imp.__version__
+        except (ImportError, AttributeError):
+            pass
+
+
+def print_header(*, file=None):
+    """\
+    Versions that might influence the numerical results.
+    Matplotlib and Seaborn are excluded from this.
+
+    Parameters
+    ----------
+    file
+        Optional path for dependency output.
+    """
+
+    modules = ["scanpy"] + _DEPENDENCIES_NUMERICS
+    print(
+        " ".join(f"{mod}=={ver}" for mod, ver in _versions_dependencies(modules)),
+        file=file or sys.stdout,
+    )
+
+
+def print_versions(*, file: IO[str] | None = None):
+    """\
+    Print versions of imported packages, OS, and jupyter environment.
+
+    For more options (including rich output) use `session_info.show` directly.
+
+    Parameters
+    ----------
+    file
+        Optional path for output.
+    """
+    import session_info
+
+    if file is not None:
+        from contextlib import redirect_stdout
+
+        warnings.warn(
+            "Passing argument 'file' to print_versions is deprecated, and will be "
+            "removed in a future version.",
+            FutureWarning,
+        )
+        with redirect_stdout(file):
+            print_versions()
+    else:
+        session_info.show(
+            dependencies=True,
+            html=False,
+            excludes=[
+                "builtins",
+                "stdlib_list",
+                "importlib_metadata",
+                # Special module present if test coverage being calculated
+                # https://gitlab.com/joelostblom/session_info/-/issues/10
+                "$coverage",
+            ],
+        )
+
+
+def print_version_and_date(*, file=None):
+    """\
+    Useful for starting a notebook so you see when you started working.
+
+    Parameters
+    ----------
+    file
+        Optional path for output.
+    """
+    from . import __version__
+
+    if file is None:
+        file = sys.stdout
+    print(
+        f"Running Scanpy {__version__}, on {datetime.now():%Y-%m-%d %H:%M}.",
+        file=file,
+    )
+
+
+def _copy_docs_and_signature(fn):
+    return partial(update_wrapper, wrapped=fn, assigned=["__doc__", "__annotations__"])
+
+
+def error(
+    msg: str,
+    *,
+    time: datetime = None,
+    deep: str | None = None,
+    extra: dict | None = None,
+) -> datetime:
+    """\
+    Log message with specific level and return current time.
+
+    Parameters
+    ----------
+    msg
+        Message to display.
+    time
+        A time in the past. If this is passed, the time difference from then
+        to now is appended to `msg` as ` (HH:MM:SS)`.
+        If `msg` contains `{time_passed}`, the time difference is instead
+        inserted at that position.
+    deep
+        If the current verbosity is higher than the log function’s level,
+        this gets displayed as well
+    extra
+        Additional values you can specify in `msg` like `{time_passed}`.
+    """
+    from ._settings import settings
+
+    return settings._root_logger.error(msg, time=time, deep=deep, extra=extra)
+
+
+@_copy_docs_and_signature(error)
+def warning(msg, *, time=None, deep=None, extra=None) -> datetime:
+    from ._settings import settings
+
+    return settings._root_logger.warning(msg, time=time, deep=deep, extra=extra)
+
+
+@_copy_docs_and_signature(error)
+def info(msg, *, time=None, deep=None, extra=None) -> datetime:
+    from ._settings import settings
+
+    return settings._root_logger.info(msg, time=time, deep=deep, extra=extra)
+
+
+@_copy_docs_and_signature(error)
+def hint(msg, *, time=None, deep=None, extra=None) -> datetime:
+    from ._settings import settings
+
+    return settings._root_logger.hint(msg, time=time, deep=deep, extra=extra)
+
+
+@_copy_docs_and_signature(error)
+def debug(msg, *, time=None, deep=None, extra=None) -> datetime:
+    from ._settings import settings
+
+    return settings._root_logger.debug(msg, time=time, deep=deep, extra=extra)

sclab/scanpy/plotting/_rcmod.py

@@ -0,0 +1,73 @@
+"""Set the default matplotlib.rcParams."""
+
+from __future__ import annotations
+
+import matplotlib as mpl
+from cycler import cycler
+from matplotlib import rcParams
+
+from . import palettes
+
+
+def set_rcParams_scanpy(fontsize=14, color_map=None):
+    """Set matplotlib.rcParams to Scanpy defaults.
+
+    Call this through `settings.set_figure_params`.
+    """
+
+    # figure
+    rcParams["figure.figsize"] = (4, 4)
+    rcParams["figure.subplot.left"] = 0.18
+    rcParams["figure.subplot.right"] = 0.96
+    rcParams["figure.subplot.bottom"] = 0.15
+    rcParams["figure.subplot.top"] = 0.91
+
+    rcParams["lines.linewidth"] = 1.5  # the line width of the frame
+    rcParams["lines.markersize"] = 6
+    rcParams["lines.markeredgewidth"] = 1
+
+    # font
+    rcParams["font.sans-serif"] = [
+        "Arial",
+        "Helvetica",
+        "DejaVu Sans",
+        "Bitstream Vera Sans",
+        "sans-serif",
+    ]
+    fontsize = fontsize
+    rcParams["font.size"] = fontsize
+    rcParams["legend.fontsize"] = 0.92 * fontsize
+    rcParams["axes.titlesize"] = fontsize
+    rcParams["axes.labelsize"] = fontsize
+
+    # legend
+    rcParams["legend.numpoints"] = 1
+    rcParams["legend.scatterpoints"] = 1
+    rcParams["legend.handlelength"] = 0.5
+    rcParams["legend.handletextpad"] = 0.4
+
+    # color cycle
+    rcParams["axes.prop_cycle"] = cycler(color=palettes.default_20)
+
+    # lines
+    rcParams["axes.linewidth"] = 0.8
+    rcParams["axes.edgecolor"] = "black"
+    rcParams["axes.facecolor"] = "white"
+
+    # ticks
+    rcParams["xtick.color"] = "k"
+    rcParams["ytick.color"] = "k"
+    rcParams["xtick.labelsize"] = fontsize
+    rcParams["ytick.labelsize"] = fontsize
+
+    # axes grid
+    rcParams["axes.grid"] = True
+    rcParams["grid.color"] = ".8"
+
+    # color map
+    rcParams["image.cmap"] = rcParams["image.cmap"] if color_map is None else color_map
+
+
+def set_rcParams_defaults():
+    """Reset `matplotlib.rcParams` to defaults."""
+    rcParams.update(mpl.rcParamsDefault)

sclab/scanpy/plotting/palettes.py

@@ -0,0 +1,221 @@
+"""Color palettes in addition to matplotlib's palettes."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from matplotlib import cm, colors
+
+if TYPE_CHECKING:
+    from collections.abc import Mapping, Sequence
+
+# Colorblindness adjusted vega_10
+# See https://github.com/scverse/scanpy/issues/387
+vega_10 = list(map(colors.to_hex, cm.tab10.colors))
+vega_10_scanpy = vega_10.copy()
+vega_10_scanpy[2] = "#279e68"  # green
+vega_10_scanpy[4] = "#aa40fc"  # purple
+vega_10_scanpy[8] = "#b5bd61"  # kakhi
+
+# default matplotlib 2.0 palette
+# see 'category20' on https://github.com/vega/vega/wiki/Scales#scale-range-literals
+vega_20 = list(map(colors.to_hex, cm.tab20.colors))
+
+# reorderd, some removed, some added
+vega_20_scanpy = [
+    # dark without grey:
+    *vega_20[0:14:2],
+    *vega_20[16::2],
+    # light without grey:
+    *vega_20[1:15:2],
+    *vega_20[17::2],
+    # manual additions:
+    "#ad494a",
+    "#8c6d31",
+]
+vega_20_scanpy[2] = vega_10_scanpy[2]
+vega_20_scanpy[4] = vega_10_scanpy[4]
+vega_20_scanpy[7] = vega_10_scanpy[8]  # kakhi shifted by missing grey
+# TODO: also replace pale colors if necessary
+
+default_20 = vega_20_scanpy
+
+# https://graphicdesign.stackexchange.com/questions/3682/where-can-i-find-a-large-palette-set-of-contrasting-colors-for-coloring-many-d
+# update 1
+# orig reference https://research.wu.ac.at/en/publications/escaping-rgbland-selecting-colors-for-statistical-graphics-26
+zeileis_28 = [
+    "#023fa5",
+    "#7d87b9",
+    "#bec1d4",
+    "#d6bcc0",
+    "#bb7784",
+    "#8e063b",
+    "#4a6fe3",
+    "#8595e1",
+    "#b5bbe3",
+    "#e6afb9",
+    "#e07b91",
+    "#d33f6a",
+    "#11c638",
+    "#8dd593",
+    "#c6dec7",
+    "#ead3c6",
+    "#f0b98d",
+    "#ef9708",
+    "#0fcfc0",
+    "#9cded6",
+    "#d5eae7",
+    "#f3e1eb",
+    "#f6c4e1",
+    "#f79cd4",
+    # these last ones were added:
+    "#7f7f7f",
+    "#c7c7c7",
+    "#1CE6FF",
+    "#336600",
+]
+
+default_28 = zeileis_28
+
+# from https://godsnotwheregodsnot.blogspot.com/2012/09/color-distribution-methodology.html
+godsnot_102 = [
+    # "#000000",  # remove the black, as often, we have black colored annotation
+    "#FFFF00",
+    "#1CE6FF",
+    "#FF34FF",
+    "#FF4A46",
+    "#008941",
+    "#006FA6",
+    "#A30059",
+    "#FFDBE5",
+    "#7A4900",
+    "#0000A6",
+    "#63FFAC",
+    "#B79762",
+    "#004D43",
+    "#8FB0FF",
+    "#997D87",
+    "#5A0007",
+    "#809693",
+    "#6A3A4C",
+    "#1B4400",
+    "#4FC601",
+    "#3B5DFF",
+    "#4A3B53",
+    "#FF2F80",
+    "#61615A",
+    "#BA0900",
+    "#6B7900",
+    "#00C2A0",
+    "#FFAA92",
+    "#FF90C9",
+    "#B903AA",
+    "#D16100",
+    "#DDEFFF",
+    "#000035",
+    "#7B4F4B",
+    "#A1C299",
+    "#300018",
+    "#0AA6D8",
+    "#013349",
+    "#00846F",
+    "#372101",
+    "#FFB500",
+    "#C2FFED",
+    "#A079BF",
+    "#CC0744",
+    "#C0B9B2",
+    "#C2FF99",
+    "#001E09",
+    "#00489C",
+    "#6F0062",
+    "#0CBD66",
+    "#EEC3FF",
+    "#456D75",
+    "#B77B68",
+    "#7A87A1",
+    "#788D66",
+    "#885578",
+    "#FAD09F",
+    "#FF8A9A",
+    "#D157A0",
+    "#BEC459",
+    "#456648",
+    "#0086ED",
+    "#886F4C",
+    "#34362D",
+    "#B4A8BD",
+    "#00A6AA",
+    "#452C2C",
+    "#636375",
+    "#A3C8C9",
+    "#FF913F",
+    "#938A81",
+    "#575329",
+    "#00FECF",
+    "#B05B6F",
+    "#8CD0FF",
+    "#3B9700",
+    "#04F757",
+    "#C8A1A1",
+    "#1E6E00",
+    "#7900D7",
+    "#A77500",
+    "#6367A9",
+    "#A05837",
+    "#6B002C",
+    "#772600",
+    "#D790FF",
+    "#9B9700",
+    "#549E79",
+    "#FFF69F",
+    "#201625",
+    "#72418F",
+    "#BC23FF",
+    "#99ADC0",
+    "#3A2465",
+    "#922329",
+    "#5B4534",
+    "#FDE8DC",
+    "#404E55",
+    "#0089A3",
+    "#CB7E98",
+    "#A4E804",
+    "#324E72",
+]
+
+default_102 = godsnot_102
+
+
+def _plot_color_cycle(clists: Mapping[str, Sequence[str]]):
+    import matplotlib.pyplot as plt
+    import numpy as np
+    from matplotlib.colors import BoundaryNorm, ListedColormap
+
+    fig, axes = plt.subplots(nrows=len(clists))  # type: plt.Figure, plt.Axes
+    fig.subplots_adjust(top=0.95, bottom=0.01, left=0.3, right=0.99)
+    axes[0].set_title("Color Maps/Cycles", fontsize=14)
+
+    for ax, (name, clist) in zip(axes, clists.items()):
+        n = len(clist)
+        ax.imshow(
+            np.arange(n)[None, :].repeat(2, 0),
+            aspect="auto",
+            cmap=ListedColormap(clist),
+            norm=BoundaryNorm(np.arange(n + 1) - 0.5, n),
+        )
+        pos = list(ax.get_position().bounds)
+        x_text = pos[0] - 0.01
+        y_text = pos[1] + pos[3] / 2.0
+        fig.text(x_text, y_text, name, va="center", ha="right", fontsize=10)
+
+    # Turn off all ticks & spines
+    for ax in axes:
+        ax.set_axis_off()
+    fig.show()
+
+
+if __name__ == "__main__":
+    _plot_color_cycle(
+        {name: colors for name, colors in globals().items() if isinstance(colors, list)}
+    )