lsst-utils 29.2025.1700__tar.gz → 29.2025.1900__tar.gz

{lsst_utils-29.2025.1700/python/lsst_utils.egg-info → lsst_utils-29.2025.1900}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lsst-utils
-Version: 29.2025.1700
+Version: 29.2025.1900
 Summary: Utility functions from Rubin Observatory Data Management for the Legacy Survey of Space and Time (LSST).
 Author-email: Rubin Observatory Data Management <dm-admin@lists.lsst.org>
 License: BSD 3-Clause License
@@ -27,6 +27,7 @@ Provides-Extra: test
 Requires-Dist: pytest>=3.2; extra == "test"
 Provides-Extra: plotting
 Requires-Dist: matplotlib; extra == "plotting"
+Requires-Dist: seaborn; extra == "plotting"
 Dynamic: license-file
 
 ==========

{lsst_utils-29.2025.1700 → lsst_utils-29.2025.1900}/pyproject.toml

@@ -38,6 +38,7 @@ test = [
 ]
 plotting = [
     "matplotlib",
+    "seaborn",
 ]
 
 [tool.setuptools.packages.find]

lsst_utils-29.2025.1900/python/lsst/utils/plotting/publication_plots.py

@@ -0,0 +1,171 @@
+# This file is part of utils.
+#
+# Developed for the LSST Data Management System.
+# This product includes software developed by the LSST Project
+# (https://www.lsst.org).
+# See the COPYRIGHT file at the top-level directory of this distribution
+# for details of code ownership.
+#
+# Use of this source code is governed by a 3-clause BSD-style
+# license that can be found in the LICENSE file.
+"""Utilities for making publication-quality figures."""
+
+__all__ = [
+    "accent_color",
+    "divergent_cmap",
+    "galaxies_cmap",
+    "galaxies_color",
+    "get_band_dicts",
+    "mk_colormap",
+    "set_rubin_plotstyle",
+    "stars_cmap",
+    "stars_color",
+]
+
+import numpy as np
+
+from . import (
+    get_multiband_plot_colors,
+    get_multiband_plot_linestyles,
+    get_multiband_plot_symbols,
+)
+
+
+def set_rubin_plotstyle() -> None:
+    """
+    Set the matplotlib style for Rubin publications
+    """
+    from matplotlib import style
+
+    style.use("lsst.utils.plotting.rubin")
+
+
+def mk_colormap(colorNames):  # type: ignore
+    """Make a colormap from the list of color names.
+
+    Parameters
+    ----------
+    colorNames : `list`
+        A list of strings that correspond to matplotlib named colors.
+
+    Returns
+    -------
+    cmap : `matplotlib.colors.LinearSegmentedColormap`
+        A colormap stepping through the supplied list of names.
+    """
+    from matplotlib import colors
+
+    blues = []
+    greens = []
+    reds = []
+    alphas = []
+
+    if len(colorNames) == 1:
+        # Alpha is between 0 and 1 really but
+        # using 1.5 saturates out the top of the
+        # colorscale, this looks good for ComCam data
+        # but might want to be changed in the future.
+        alphaRange = [0.2, 1.0]
+        nums = np.linspace(0, 1, len(alphaRange))
+        r, g, b = colors.colorConverter.to_rgb(colorNames[0])
+        for num, alpha in zip(nums, alphaRange):
+            blues.append((num, b, b))
+            greens.append((num, g, g))
+            reds.append((num, r, r))
+            alphas.append((num, alpha, alpha))
+
+    else:
+        nums = np.linspace(0, 1, len(colorNames))
+        if len(colorNames) == 3:
+            alphaRange = [1.0, 0.3, 1.0]
+        elif len(colorNames) == 5:
+            alphaRange = [1.0, 0.7, 0.3, 0.7, 1.0]
+        else:
+            alphaRange = np.ones(len(colorNames))
+
+        for num, color, alpha in zip(nums, colorNames, alphaRange):
+            r, g, b = colors.colorConverter.to_rgb(color)
+            blues.append((num, b, b))
+            greens.append((num, g, g))
+            reds.append((num, r, r))
+            alphas.append((num, alpha, alpha))
+
+    colorDict = {"blue": blues, "red": reds, "green": greens, "alpha": alphas}
+    cmap = colors.LinearSegmentedColormap("newCmap", colorDict)
+    return cmap
+
+
+def divergent_cmap():  # type: ignore
+    """
+    Make a divergent color map.
+    """
+    import seaborn as sns
+    from matplotlib.colors import ListedColormap
+
+    cmap = ListedColormap(sns.color_palette("icefire", 256))
+
+    return cmap
+
+
+def stars_cmap(single_color=False):  # type: ignore
+    """Make a color map for stars."""
+    import seaborn as sns
+    from matplotlib.colors import ListedColormap
+
+    if single_color:
+        cmap = mk_colormap([stars_color()])
+    else:
+        cmap = ListedColormap(sns.color_palette("mako", 256))
+    return cmap
+
+
+def stars_color() -> str:
+    """Return the star color string for lines"""
+    return "#357BA3"
+
+
+def accent_color() -> str:
+    """Return a contrasting color for overplotting,
+    black is the best for this but if you need two colors
+    this works well on blue.
+    """
+    return "#DE8F05"
+
+
+def galaxies_cmap(single_color=False):  # type: ignore
+    """Make a color map for galaxies."""
+    if single_color:
+        cmap = mk_colormap([galaxies_color()])
+    else:
+        cmap = "inferno"
+    return cmap
+
+
+def galaxies_color() -> str:
+    """Return the galaxy color string for lines"""
+    return "#961A45"
+
+
+def get_band_dicts() -> dict:
+    """
+    Define palettes, from RTN-045. This includes dicts for colors (bandpass
+    colors for white background), colors_black (bandpass colors for
+    black background), plot symbols, and line_styles, keyed on band (ugrizy).
+
+    Returns
+    -------
+    band_dict : `dict` of `dict`
+        Dicts of colors, colors_black, symbols, and line_styles,
+        keyed on bands 'u', 'g', 'r', 'i', 'z', and 'y'.
+    """
+    colors = get_multiband_plot_colors()
+    colors_black = get_multiband_plot_colors(dark_background=True)
+    symbols = get_multiband_plot_symbols()
+    line_styles = get_multiband_plot_linestyles()
+
+    return {
+        "colors": colors,
+        "colors_black": colors_black,
+        "symbols": symbols,
+        "line_styles": line_styles,
+    }

{lsst_utils-29.2025.1700 → lsst_utils-29.2025.1900}/python/lsst/utils/plotting/rubin.mplstyle

@@ -1,19 +1,19 @@
 axes.labelweight: normal
 figure.titleweight : normal
 axes.labelsize : large
-axes.linewidth: 2
+axes.linewidth: 1
 axes.titleweight: normal
 axes.titlesize : small
 figure.titlesize: small
 errorbar.capsize: 3.0
 
-lines.linewidth : 3
+lines.linewidth : 2
 lines.markersize : 10
 
-xtick.labelsize : large
-ytick.labelsize : large
+xtick.labelsize : small
+ytick.labelsize : small
 
-figure.dpi : 150.0
+figure.dpi : 300.0
 figure.facecolor: White
 figure.figsize : 6.4, 4.8
 
@@ -24,16 +24,16 @@ patch.facecolor: 006BA4
 font.size : 14
 legend.fontsize: x-small
 
-xtick.major.width: 2.0
-xtick.minor.width: 1.5
+xtick.major.width: 1.0
+xtick.minor.width: 0.5
 xtick.major.size: 7
 xtick.minor.size: 4
 xtick.minor.visible: True
 xtick.direction: in
 xtick.top: True
 xtick.bottom: True
-ytick.major.width: 2.0
-ytick.minor.width: 1.5
+ytick.major.width: 1.0
+ytick.minor.width: 0.5
 ytick.major.size: 7
 ytick.minor.size: 4
 ytick.minor.visible: True

{lsst_utils-29.2025.1700 → lsst_utils-29.2025.1900}/python/lsst/utils/timer.py

@@ -16,6 +16,7 @@ from __future__ import annotations
 
 __all__ = ["duration_from_timeMethod", "logInfo", "profile", "timeMethod", "time_this"]
 
+import dataclasses
 import datetime
 import functools
 import logging
@@ -338,6 +339,18 @@ def timeMethod(
         return decorator_timer(_func)
 
 
+@dataclasses.dataclass
+class _TimerResult:
+    duration: float = 0.0
+    """Duration of context in seconds."""
+    mem_current_usage: float | None = None
+    """Memory usage at end of context in requested units."""
+    mem_peak_delta: float | None = None
+    """Peak differential between entering and leaving context."""
+    mem_current_delta: float | None = None
+    """Difference in usage between entering and leaving context."""
+
+
 @contextmanager
 def time_this(
     log: LsstLoggers | None = None,
@@ -349,7 +362,8 @@ def time_this(
     mem_child: bool = False,
     mem_unit: u.Quantity = u.byte,
     mem_fmt: str = ".0f",
-) -> Iterator[None]:
+    force_mem_usage: bool = False,
+) -> Iterator[_TimerResult]:
     """Time the enclosed block and issue a log message.
 
     Parameters
@@ -372,7 +386,8 @@ def time_this(
         written to ``msg``.
     mem_usage : `bool`, optional
         Flag indicating whether to include the memory usage in the report.
-        Defaults, to False.
+        Defaults, to False. Does nothing if the log message will not be
+        generated.
     mem_child : `bool`, optional
         Flag indication whether to include memory usage of the child processes.
     mem_unit : `astropy.units.Unit`, optional
@@ -380,6 +395,16 @@ def time_this(
     mem_fmt : `str`, optional
         Format specifier to use when displaying values related to memory usage.
         Defaults to '.0f'.
+    force_mem_usage : `bool`, optional
+        If `True` memory usage is always calculated even if the log message
+        will not be delivered. Use this if you want the information recorded
+        by the context manager.
+
+    Yields
+    ------
+    timer_result : `_TimerResult`
+        Simple data class containing the duration of the block in seconds via
+        the ``duration`` property.
     """
     if log is None:
         log = logging.getLogger()
@@ -391,14 +416,17 @@ def time_this(
 
     if mem_usage and not log.isEnabledFor(level):
         mem_usage = False
+    if force_mem_usage:
+        mem_usage = True
 
     if mem_usage:
         current_usages_start = get_current_mem_usage()
         peak_usages_start = get_peak_mem_usage()
 
+    timer_result = _TimerResult()
     errmsg = ""
     try:
-        yield
+        yield timer_result
     except BaseException as e:
         frame, lineno = list(traceback.walk_tb(e.__traceback__))[-1]
         errmsg = f"{e!r} @ {frame.f_code.co_filename}:{lineno}"
@@ -416,9 +444,12 @@ def time_this(
         # mypy stop complaining when additional parameters will be added below.
         params = list(args) if args else []
 
+        duration = end - start
+        timer_result.duration = duration
+
         # Specify stacklevel to ensure the message is reported from the
         # caller (1 is this file, 2 is contextlib, 3 is user)
-        params += (": " if msg else "", end - start)
+        params += (": " if msg else "", duration)
         msg += "%sTook %.4f seconds"
         if errmsg:
             params += (f" (timed code triggered exception of {errmsg!r})",)
@@ -442,10 +473,18 @@ def time_this(
                 _LOG.warning("Invalid memory unit '%s', using '%s' instead", mem_unit, u.byte)
                 mem_unit = u.byte
 
+            current_usage = current_usage.to(mem_unit)
+            current_delta = current_delta.to(mem_unit)
+            peak_delta = peak_delta.to(mem_unit)
+
+            timer_result.mem_current_usage = float(current_usage.value)
+            timer_result.mem_current_delta = float(current_delta.value)
+            timer_result.mem_peak_delta = float(peak_delta.value)
+
             msg += (
-                f"; current memory usage: {current_usage.to(mem_unit):{mem_fmt}}"
-                f", delta: {current_delta.to(mem_unit):{mem_fmt}}"
-                f", peak delta: {peak_delta.to(mem_unit):{mem_fmt}}"
+                f"; current memory usage: {current_usage:{mem_fmt}}"
+                f", delta: {current_delta:{mem_fmt}}"
+                f", peak delta: {peak_delta:{mem_fmt}}"
             )
         log.log(level, msg, *params, stacklevel=3)
 

lsst_utils-29.2025.1900/python/lsst/utils/version.py

@@ -0,0 +1,2 @@
+__all__ = ["__version__"]
+__version__ = "29.2025.1900"

{lsst_utils-29.2025.1700 → lsst_utils-29.2025.1900/python/lsst_utils.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lsst-utils
-Version: 29.2025.1700
+Version: 29.2025.1900
 Summary: Utility functions from Rubin Observatory Data Management for the Legacy Survey of Space and Time (LSST).
 Author-email: Rubin Observatory Data Management <dm-admin@lists.lsst.org>
 License: BSD 3-Clause License
@@ -27,6 +27,7 @@ Provides-Extra: test
 Requires-Dist: pytest>=3.2; extra == "test"
 Provides-Extra: plotting
 Requires-Dist: matplotlib; extra == "plotting"
+Requires-Dist: seaborn; extra == "plotting"
 Dynamic: license-file
 
 ==========

{lsst_utils-29.2025.1700 → lsst_utils-29.2025.1900}/python/lsst_utils.egg-info/requires.txt

@@ -7,6 +7,7 @@ threadpoolctl
 
 [plotting]
 matplotlib
+seaborn
 
 [test]
 pytest>=3.2

{lsst_utils-29.2025.1700 → lsst_utils-29.2025.1900}/tests/test_matplotlib_figures.py

@@ -23,12 +23,19 @@ import unittest
 
 import lsst.utils.tests
 from lsst.utils.plotting import (
+    accent_color,
+    divergent_cmap,
+    galaxies_cmap,
+    galaxies_color,
     get_band_dicts,
     get_multiband_plot_colors,
     get_multiband_plot_linestyles,
     get_multiband_plot_symbols,
     make_figure,
+    mk_colormap,
     set_rubin_plotstyle,
+    stars_cmap,
+    stars_color,
 )
 
 try:
@@ -90,3 +97,40 @@ class PublicationPlotsTestCase(unittest.TestCase):
         self.assertEqual(bands_dict["colors_black"]["r"], "#ff7e00")
         self.assertEqual(bands_dict["symbols"]["r"], "v")
         self.assertEqual(bands_dict["line_styles"]["r"], "-")
+
+    def testStarColors(self):
+        with lsst.utils.tests.getTempFilePath(".png") as tmpFile:
+            fig = make_figure()
+            ax = fig.add_subplot(111)
+            xs = [0, 1]
+            ys = [0, 1]
+            for cmap in [stars_cmap(), stars_cmap(single_color=True)]:
+                ax.hexbin(xs, ys, cmap=cmap)
+            ax.axhline(0, color=stars_color())
+            fig.savefig(tmpFile)
+
+    def testGalaxyColor(self):
+        with lsst.utils.tests.getTempFilePath(".png") as tmpFile:
+            fig = make_figure()
+            ax = fig.add_subplot(111)
+            xs = [0, 1]
+            ys = [0, 1]
+            for cmap in [galaxies_cmap(), galaxies_cmap(single_color=True)]:
+                ax.hexbin(xs, ys, cmap=cmap)
+            ax.axhline(0, color=galaxies_color())
+            fig.savefig(tmpFile)
+
+    def testDivergentColor(self):
+        with lsst.utils.tests.getTempFilePath(".png") as tmpFile:
+            fig = make_figure()
+            ax = fig.add_subplot(111)
+            xs = [0, 1]
+            ys = [0, 1]
+            ax.hexbin(xs, ys, cmap=divergent_cmap())
+            ax.axhline(0, color=accent_color())
+            fig.savefig(tmpFile)
+
+    def testMkColormap(self):
+        mk_colormap(["#fde725", "#21918c", "#440154"])
+        mk_colormap(["#fde725", "#5ec962", "#21918c", "#3b528b"])
+        mk_colormap(["#fde725", "#5ec962", "#21918c", "#3b528b", "#440154"])

{lsst_utils-29.2025.1700 → lsst_utils-29.2025.1900}/tests/test_timer.py

@@ -342,6 +342,38 @@ class TimerTestCase(unittest.TestCase):
         self.assertIn("A problem %s", cm.records[0].message)
         self.assertEqual(cm.records[0].levelname, "DEBUG")
 
+    def test_time_this_return(self):
+        """Test that the context manager returns the duration."""
+        # Return duration but not memory usage.
+        with self.assertNoLogs(level="INFO"):
+            with time_this(level=logging.DEBUG, prefix=None, mem_usage=False) as timer:
+                time.sleep(0.01)
+        self.assertGreater(timer.duration, 0.0)
+        self.assertIsNone(timer.mem_current_usage)
+
+        # Ask for memory usage that will be calculated.
+        with self.assertLogs(level="DEBUG"):
+            # mem usage will be requested but not calculated.
+            with time_this(level=logging.DEBUG, prefix=None, mem_usage=True) as timer:
+                time.sleep(0.01)
+        self.assertGreater(timer.duration, 0.0)
+        self.assertGreaterEqual(timer.mem_current_delta, 0.0)
+
+        # Ask for memory usage but will not be calculated.
+        with self.assertNoLogs(level="WARNING"):
+            # mem usage will be requested but not calculated.
+            with time_this(level=logging.DEBUG, prefix=None, mem_usage=True) as timer:
+                time.sleep(0.01)
+        self.assertGreater(timer.duration, 0.0)
+        self.assertIsNone(timer.mem_current_usage)
+
+        # Require memory usage is returned in context manager.
+        with self.assertNoLogs(level="WARNING"):
+            with time_this(level=logging.DEBUG, prefix=None, force_mem_usage=True) as timer:
+                time.sleep(0.01)
+        self.assertGreater(timer.duration, 0.0)
+        self.assertGreater(timer.mem_current_usage, 0.0)
+
 
 class ProfileTestCase(unittest.TestCase):
     """Test profiling decorator."""

lsst_utils-29.2025.1700/python/lsst/utils/plotting/publication_plots.py

@@ -1,56 +0,0 @@
-# This file is part of utils.
-#
-# Developed for the LSST Data Management System.
-# This product includes software developed by the LSST Project
-# (https://www.lsst.org).
-# See the COPYRIGHT file at the top-level directory of this distribution
-# for details of code ownership.
-#
-# Use of this source code is governed by a 3-clause BSD-style
-# license that can be found in the LICENSE file.
-"""Utilities for making publication-quality figures."""
-
-__all__ = [
-    "get_band_dicts",
-    "set_rubin_plotstyle",
-]
-
-from . import (
-    get_multiband_plot_colors,
-    get_multiband_plot_linestyles,
-    get_multiband_plot_symbols,
-)
-
-
-def set_rubin_plotstyle() -> None:
-    """
-    Set the matplotlib style for Rubin publications
-    """
-    from matplotlib import style
-
-    style.use("lsst.utils.plotting.rubin")
-
-
-def get_band_dicts() -> dict:
-    """
-    Define palettes, from RTN-045. This includes dicts for colors (bandpass
-    colors for white background), colors_black (bandpass colors for
-    black background), plot symbols, and line_styles, keyed on band (ugrizy).
-
-    Returns
-    -------
-    band_dict : `dict` of `dict`
-        Dicts of colors, colors_black, symbols, and line_styles,
-        keyed on bands 'u', 'g', 'r', 'i', 'z', and 'y'.
-    """
-    colors = get_multiband_plot_colors()
-    colors_black = get_multiband_plot_colors(dark_background=True)
-    symbols = get_multiband_plot_symbols()
-    line_styles = get_multiband_plot_linestyles()
-
-    return {
-        "colors": colors,
-        "colors_black": colors_black,
-        "symbols": symbols,
-        "line_styles": line_styles,
-    }

lsst_utils-29.2025.1700/python/lsst/utils/version.py

@@ -1,2 +0,0 @@
-__all__ = ["__version__"]
-__version__ = "29.2025.1700"