heatmap_cli 0.25.2__tar.gz → 0.25.4__tar.gz

{heatmap_cli-0.25.2/src/heatmap_cli.egg-info → heatmap_cli-0.25.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: heatmap_cli
-Version: 0.25.2
+Version: 0.25.4
 Summary: A console program that generates a yearly calendar heatmap.
 Author-email: Kian-Meng Ang <kianmeng@cpan.org>
 License-Expression: AGPL-3.0-or-later

{heatmap_cli-0.25.2 → heatmap_cli-0.25.4}/pyproject.toml

@@ -25,7 +25,7 @@ classifiers = [
     "Programming Language :: Python",
     "Topic :: Scientific/Engineering :: Visualization",
 ]
-version = "0.25.2"
+version = "0.25.4"
 keywords = ["heatmap", "cli", "visualization", "calendar", "data-viz"]
 dependencies = [
     "matplotlib",

{heatmap_cli-0.25.2 → heatmap_cli-0.25.4}/src/heatmap_cli/__init__.py

@@ -31,8 +31,8 @@ import matplotlib as mpl
 import matplotlib.pyplot as plt
 import pandas as pd
 import seaborn as sns
-from PIL import Image
 
+from heatmap_cli.heatmap import _get_output_dir
 from heatmap_cli.heatmap import run as generate_heatmaps
 
 __version__ = metadata.version("heatmap_cli")
@@ -135,7 +135,9 @@ def generate_demo(config: argparse.Namespace) -> None:
     """
     random.seed(config.seed if config.seed is not None else DEFAULT_DEMO_SEED)
     config.cmap = random.sample(CMAPS, config.demo)
-    config.input_filename = str(_generate_sample_csv(config))
+    config.input_filename = str(
+        Path(config.output_dir) / DEMO_SAMPLE_FILENAME,
+    )
     generate_heatmaps(config)
 
 
@@ -162,7 +164,7 @@ def _generate_sample_csv(config: argparse.Namespace) -> Path:
     )
     df_dates["count"] = random.sample(range(DEMO_MAX_COUNT), len(df_dates))
 
-    csv_filename = Path(config.output_dir) / DEMO_SAMPLE_FILENAME
+    csv_filename = _get_output_dir(config) / DEMO_SAMPLE_FILENAME
     csv_filename.parent.mkdir(parents=True, exist_ok=True)
     df_dates.to_csv(csv_filename, sep=",", index=False, header=False)
     logger.debug("Generate sample CSV file: %s", csv_filename)
@@ -191,7 +193,7 @@ class EnvironmentAction(argparse.Action):
             for name, version in (
                 ("matplotlib", mpl.__version__),
                 ("pandas", pd.__version__),
-                ("pillow", Image.__version__),
+                ("pillow", metadata.version("pillow")),
                 ("seaborn", sns.__version__),
             )
         )

{heatmap_cli-0.25.2 → heatmap_cli-0.25.4}/src/heatmap_cli/cli.py

@@ -43,6 +43,7 @@ from heatmap_cli import (
     setup_logging,
 )
 from heatmap_cli.heatmap import (
+    _sanitize_string_for_filename,
     _weeks_in_iso_year,
 )
 from heatmap_cli.heatmap import (
@@ -208,8 +209,8 @@ def build_parser() -> argparse.ArgumentParser:
         type=_valid_date,
         default=None,
         help=(
-            "filter from the date of the year from the CSV file "
-            "(default: %(default)s)"
+            "filter from the date of the year from the CSV file and "
+            "this will overwrite -y and -w option (default: %(default)s)"
         ),
         metavar="START_DATE",
     )
@@ -424,6 +425,49 @@ def _generate_cmap_help() -> str:
     return cmap_help + cmap_default + "\n" + cmap_choices.rstrip()
 
 
+def _resolve_date_filter_overrides(
+    parsed_args: argparse.Namespace,
+) -> None:
+    """Apply --start-date/--end-date overrides to the year and week filters.
+
+    A --start-date/--end-date pair defines a self-contained calendar date
+    range that overrides the -y/--year and -w/--week cutoff, avoiding a
+    double filter between the ISO-week year column and the raw date column.
+    When only one endpoint is given it derives a partial-year view; when
+    both are given --end-date wins for the year/week since it caps the range.
+
+    Args:
+        parsed_args (argparse.Namespace): The newly parsed arguments.
+
+    Returns:
+        None
+    """
+    # Capture the user-supplied filters before --end-date/--start-date clobber
+    # them, so the overriding of -y/-w is reported instead of happening
+    # silently.
+    explicit_year = parsed_args.year
+    explicit_week = parsed_args.week
+
+    if parsed_args.end_date:
+        (year, week, _day) = parsed_args.end_date.isocalendar()
+        parsed_args.year = [year]
+        parsed_args.week = week
+    elif parsed_args.start_date:
+        if explicit_year is not None:
+            logger.warning(
+                "argument --start-date: --year is ignored when "
+                "--start-date is used.",
+            )
+        if explicit_week is not None:
+            logger.warning(
+                "argument --start-date: --week is ignored when "
+                "--start-date is used.",
+            )
+        (year, _week, _day) = parsed_args.start_date.isocalendar()
+        parsed_args.year = [year]
+        parsed_args.week = _weeks_in_iso_year(year)
+
+
 def _process_args(
     parser: argparse.ArgumentParser,
     parsed_args: argparse.Namespace,
@@ -445,14 +489,7 @@ def _process_args(
     # double filter between the ISO-week year column and the raw date column.
     # When only one endpoint is given it derives a partial-year view; when
     # both are given --end-date wins for the year/week since it caps the range.
-    if parsed_args.end_date:
-        (year, week, _day) = parsed_args.end_date.isocalendar()
-        parsed_args.year = [year]
-        parsed_args.week = week
-    elif parsed_args.start_date:
-        (year, _week, _day) = parsed_args.start_date.isocalendar()
-        parsed_args.year = [year]
-        parsed_args.week = _weeks_in_iso_year(year)
+    _resolve_date_filter_overrides(parsed_args)
 
     if (
         parsed_args.start_date
@@ -479,6 +516,10 @@ def _process_args(
     if parsed_args.cmap is None:
         parsed_args.cmap = [DEFAULT_CMAP]
 
+    # Reject titles that sanitize to an empty string, which would otherwise
+    # yield a degenerate filename like 001__<cmap>.png.
+    _validate_title(parser, parsed_args.title)
+
     # A GIF output is only ever produced by the animation path, so asking for
     # gif implies --animate-by-week; otherwise fig.savefig(format="gif") would
     # emit a single-frame still instead of an animation.
@@ -488,6 +529,23 @@ def _process_args(
     return parsed_args
 
 
+def _validate_title(
+    parser: argparse.ArgumentParser,
+    title: str | None,
+) -> None:
+    """Reject titles that would produce a degenerate filename.
+
+    Args:
+        parser (argparse.ArgumentParser): The argument parser instance.
+        title (str | None): The title value from the command line.
+
+    Returns:
+        None
+    """
+    if title is not None and not _sanitize_string_for_filename(title):
+        parser.error("argument --title: cannot be empty or symbolic only.")
+
+
 def main(args: Sequence[str] | None = None) -> None:
     """Run the main program flow.
 
@@ -510,6 +568,8 @@ def main(args: Sequence[str] | None = None) -> None:
 
         processed_args = _process_args(parser, parsed_args)
         setup_logging(processed_args)
+        if processed_args.seed is not None and not processed_args.demo:
+            logger.warning("--seed is ignored unless --demo is used")
         if processed_args.demo:
             generate_demo(processed_args)
             return

{heatmap_cli-0.25.2 → heatmap_cli-0.25.4}/src/heatmap_cli/heatmap.py

@@ -27,7 +27,7 @@ import shutil
 import webbrowser
 from datetime import date, datetime, timedelta, timezone
 from pathlib import Path
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, cast
 
 if TYPE_CHECKING:
     import argparse
@@ -106,6 +106,13 @@ def run(config: argparse.Namespace) -> None:
 
     _refresh_output_dir(config)
 
+    # For a demo the sample CSV is generated after the output directory is
+    # refreshed, so that --purge does not delete the freshly written data file.
+    if config.demo:
+        from heatmap_cli import _generate_sample_csv  # noqa: PLC0415
+
+        config.input_filename = str(_generate_sample_csv(config))
+
     base_dataframe = _read_and_prepare_data(config)
 
     for year in config.year:
@@ -183,7 +190,7 @@ def _generate_animated_heatmap(
     start_of_week = _week_start_date(config.year, config.week)
     dates_in_week = [start_of_week + timedelta(days=i) for i in range(7)]
 
-    frames = []
+    frames: list[Image.Image] = []
     for seq, day in enumerate(dates_in_week, 1):
         frame_pivoted_df = final_pivoted_df.copy()
 
@@ -210,7 +217,7 @@ def _generate_animated_heatmap(
             return_image=True,
         )
         if frame:
-            frames.append(frame)
+            frames.append(cast("Image.Image", frame))
 
     if not frames:
         logger.warning("no frames generated to create GIF animation.")
@@ -278,7 +285,14 @@ def _generate_static_heatmaps(
         initializer=_init_worker_logging,
         initargs=(config,),
     ) as pool:
-        pool.starmap(_generate_heatmap_wrapper, args)
+        generated_files = pool.starmap(_generate_heatmap_wrapper, args)
+
+    # Workers never open browsers; open the finished heatmaps from the main
+    # process instead, so -o does not spawn a tab per background worker.
+    if config.open:
+        for img_filename in generated_files:
+            if img_filename:
+                _open_heatmap(img_filename)
 
 
 def _generate_heatmap_wrapper(
@@ -286,14 +300,21 @@ def _generate_heatmap_wrapper(
     cmap: str,
     config: argparse.Namespace,
     dataframe: pd.DataFrame,
-) -> Image.Image | None:
-    """Wrapper for _generate_heatmap to handle args in Pool."""
-    return _generate_heatmap(
-        seq,
-        cmap,
-        config,
-        dataframe,
-        return_image=False,
+) -> Path | None:
+    """Wrapper for _generate_heatmap to handle args in Pool.
+
+    Workers always save to disk (``return_image=False``), so the result is a
+    file Path, never an in-memory image.
+    """
+    return cast(
+        "Path | None",
+        _generate_heatmap(
+            seq,
+            cmap,
+            config,
+            dataframe,
+            return_image=False,
+        ),
     )
 
 
@@ -400,10 +421,15 @@ def _filter_and_pivot_data(
 
     logger.debug("Last date in filtered data: %s", max(steps["date"]).date())
 
-    # the start date of the year may span across two years
-    # for example, the first monday of 2026 week 1 is 2025-12-29
+    # The ISO year spans from the Monday of its first week, which may fall in
+    # the previous calendar year, through the Sunday before week 1 of the next
+    # ISO year. Using these boundaries keeps every date inside a single ISO
+    # year, so each (weekday, week) cell maps to exactly one date. Late
+    # December days that already belong to next year's ISO week 1 are excluded,
+    # otherwise they would be averaged with the real count in the same cell and
+    # silently halve it (pivot_table default aggfunc is "mean").
     start_date = _week_start_date(config.year, 1)
-    end_date = pd.to_datetime(f"{config.year}-12-31")
+    end_date = _week_start_date(config.year + 1, 1) - timedelta(days=1)
     logger.debug("start date: %s", start_date)
     logger.debug("end date: %s", end_date)
     full_year_dates = pd.date_range(start=start_date, end=end_date, freq="D")
@@ -507,7 +533,7 @@ def _generate_heatmap(
     dataframe: pd.DataFrame,
     *,
     return_image: bool = False,
-) -> Image.Image | None:
+) -> Image.Image | Path | None:
     """Generate a heatmap.
 
     Args:
@@ -520,8 +546,8 @@ def _generate_heatmap(
         saving to disk.
 
     Returns:
-        Optional[Image.Image]: The PIL Image object if return_image is True,
-        otherwise None.
+        Optional[Image.Image | Path]: The PIL Image object if return_image is
+            True, otherwise the Path of the saved heatmap file.
     """
     fig, axis = _setup_plot_artists(cmap, config, dataframe)
 
@@ -534,10 +560,7 @@ def _generate_heatmap(
     img_filename = _save_heatmap_figure(fig, config, seq, cmap, title)
     logger.info("generate heatmap: %s", img_filename)
 
-    if config.open:
-        _open_heatmap(img_filename)
-
-    return None
+    return img_filename
 
 
 def _configure_heatmap_options(

{heatmap_cli-0.25.2 → heatmap_cli-0.25.4/src/heatmap_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: heatmap_cli
-Version: 0.25.2
+Version: 0.25.4
 Summary: A console program that generates a yearly calendar heatmap.
 Author-email: Kian-Meng Ang <kianmeng@cpan.org>
 License-Expression: AGPL-3.0-or-later

{heatmap_cli-0.25.2 → heatmap_cli-0.25.4}/tests/test_demo_option.py

@@ -100,3 +100,45 @@ def test_demo_does_not_clobber_user_sample(tmpdir, cli_runner):
 
     assert user_sample.read_text() == "user,data\n"
     assert (output_dir / DEMO_SAMPLE_FILENAME).exists()
+
+
+def test_demo_with_purge_survives(cli_runner):
+    """--demo --purge must not delete the sample CSV it just generated."""
+    ret = cli_runner("--demo", 1, "-p", "-Y", expect_error=False)
+    assert ret.returncode == 0
+    assert "Input file not found" not in ret.stderr
+
+
+def test_seed_without_demo_warns(cli_runner, csv_file):
+    csv = csv_file("sample.csv")
+    ret = cli_runner(
+        csv,
+        "-y",
+        "2024",
+        "-w",
+        "52",
+        "--seed",
+        "42",
+        expect_error=False,
+    )
+    assert ret.returncode == 0
+    assert "--seed is ignored unless --demo is used" in ret.stderr
+
+
+def test_seed_with_demo_no_warning(cli_runner):
+    ret = cli_runner("--demo", 1, "--seed", "42", expect_error=False)
+    assert ret.returncode == 0
+    assert "--seed is ignored unless --demo is used" not in ret.stderr
+
+
+def test_demo_with_tilde_output_dir(cli_runner, monkeypatch, tmpdir):
+    """--demo must expand ~ in --output-dir like the rest of the pipeline."""
+    home = Path(tmpdir, "home")
+    home.mkdir()
+    monkeypatch.setenv("HOME", str(home))
+
+    ret = cli_runner("--demo", 1, "-O", "~/demoout", expect_error=False)
+
+    assert ret.returncode == 0
+    assert (home / "demoout" / DEMO_SAMPLE_FILENAME).exists()
+    assert not Path("~/demoout").is_dir()

heatmap_cli-0.25.4/tests/test_heatmap_open.py

@@ -0,0 +1,83 @@
+# Copyright (C) 2026 Kian-Meng Ang
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published
+# by the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+import argparse
+from pathlib import Path
+from unittest.mock import patch
+
+import pandas as pd
+
+from heatmap_cli.heatmap import _generate_heatmap, _generate_static_heatmaps
+
+
+def make_heatmap_config(tmpdir, *, should_open: bool):
+    return argparse.Namespace(
+        annotate=False,
+        cbar=False,
+        cmap_min=None,
+        cmap_max=None,
+        author="Test Author",
+        title="Test Title",
+        output_dir=str(tmpdir),
+        format="png",
+        open=should_open,
+    )
+
+
+def test_generate_heatmap_returns_saved_path(tmpdir):
+    config = make_heatmap_config(tmpdir, should_open=True)
+
+    df = pd.DataFrame([[10, 20], [30, 40]], index=[1, 2], columns=["01", "02"])
+
+    result = _generate_heatmap(1, "vlag", config, df)
+    assert isinstance(result, Path)
+    assert result.exists()
+
+    output_files = list(Path(str(tmpdir)).glob("*.png"))
+    assert len(output_files) >= 1
+
+
+def test_generate_heatmap_does_not_open(tmpdir):
+    """Opening is the caller's job, so _generate_heatmap never opens."""
+    config = make_heatmap_config(tmpdir, should_open=True)
+
+    df = pd.DataFrame([[10, 20], [30, 40]], index=[1, 2], columns=["01", "02"])
+
+    with patch("heatmap_cli.heatmap._open_heatmap") as mocked_open:
+        _generate_heatmap(1, "vlag", config, df)
+        mocked_open.assert_not_called()
+
+
+def test_static_heatmaps_open_once_after_pool(tmpdir):
+    """-o opens the finished heatmaps from the main process after the pool."""
+    config = argparse.Namespace(
+        annotate=False,
+        cbar=False,
+        cmap_min=None,
+        cmap_max=None,
+        author="Test Author",
+        title="Test Title",
+        output_dir=str(tmpdir),
+        format="png",
+        open=True,
+        cmap=["vlag"],
+    )
+
+    df = pd.DataFrame([[10, 20], [30, 40]], index=[1, 2], columns=["01", "02"])
+
+    with patch("heatmap_cli.heatmap._open_heatmap") as mocked_open:
+        _generate_static_heatmaps(df, config)
+        assert mocked_open.call_count == 1
+        assert mocked_open.call_args.args[0].exists()

{heatmap_cli-0.25.2 → heatmap_cli-0.25.4}/tests/test_heatmap_wrapper.py

@@ -21,8 +21,8 @@ import pandas as pd
 from heatmap_cli.heatmap import _generate_heatmap_wrapper
 
 
-def test_generate_heatmap_wrapper(tmpdir):
-    config = argparse.Namespace(
+def _make_config(tmpdir, *, should_open: bool):
+    return argparse.Namespace(
         annotate=False,
         cbar=False,
         cmap_min=None,
@@ -31,13 +31,29 @@ def test_generate_heatmap_wrapper(tmpdir):
         title="Test Title",
         output_dir=str(tmpdir),
         format="png",
-        open=False,
+        open=should_open,
     )
 
+
+def test_generate_heatmap_wrapper(tmpdir):
+    config = _make_config(tmpdir, should_open=False)
+
     df = pd.DataFrame([[10, 20], [30, 40]], index=[1, 2], columns=["01", "02"])
 
     result = _generate_heatmap_wrapper(1, "vlag", config, df)
-    assert result is None
+    assert isinstance(result, Path)
+    assert result.exists()
 
     output_files = list(Path(str(tmpdir)).glob("*.png"))
     assert len(output_files) >= 1
+
+
+def test_wrapper_uses_opened_heatmap_path(tmpdir):
+    """The pool wrapper returns the saved filename for the caller to open."""
+    config = _make_config(tmpdir, should_open=True)
+
+    df = pd.DataFrame([[10, 20], [30, 40]], index=[1, 2], columns=["01", "02"])
+
+    result = _generate_heatmap_wrapper(1, "vlag", config, df)
+    assert isinstance(result, Path)
+    assert result.exists()

{heatmap_cli-0.25.2 → heatmap_cli-0.25.4}/tests/test_iso_53_week_year.py

@@ -81,3 +81,30 @@ def test_week_53_dropped_when_partial_year_requested():
     pivoted = _filter_and_pivot_data(df, config)
 
     assert pivoted["53"].sum() == 0
+
+
+def test_iso_year_start_counts_kept_intact():
+    """Late December days of the prior ISO week 1 must not halve counts."""
+    # ISO year 2025 runs from 2024-12-30 through 2025-12-28. The Monday of
+    # ISO week 1 (2024-12-30) used to be averaged with 2025-12-29, which
+    # already belongs to ISO 2026 week 1 and landed in the same cell as an
+    # implied zero, halving the real count.
+    df = _base_dataframe(
+        [
+            ("2024-12-30", 5000),
+            ("2025-01-06", 4000),
+            ("2025-12-28", 3000),
+        ],
+    )
+    config = argparse.Namespace(
+        year=2025,
+        week=WEEKS_IN_YEAR,
+        start_date=None,
+        end_date=None,
+    )
+
+    pivoted = _filter_and_pivot_data(df, config)
+
+    assert pivoted.loc[1, "01"] == 5000
+    assert pivoted.loc[1, "02"] == 4000
+    assert pivoted.loc[7, "52"] == 3000

{heatmap_cli-0.25.2 → heatmap_cli-0.25.4}/tests/test_start_date_option.py

@@ -76,3 +76,25 @@ def test_start_date_overrides_year_cutoff(cli_runner, csv_file):
     csv = csv_file("sample.csv")
     ret = cli_runner(csv, "-d", "-s", "2023-06-01", "--year", "2024")
     assert "year=[2023]" in ret.stderr
+
+
+def test_start_date_warns_when_year_overridden(cli_runner, csv_file):
+    """Passing -y with --start-date must warn that -y is ignored."""
+    csv = csv_file("sample.csv")
+    ret = cli_runner(csv, "-s", "2023-06-01", "--year", "2024")
+    assert "argument --start-date: --year is ignored when" in ret.stderr
+
+
+@pytest.mark.parametrize("option", ["-w", "--week"])
+def test_start_date_warns_when_week_overridden(cli_runner, csv_file, option):
+    """Passing -w with --start-date must warn that -w is ignored."""
+    csv = csv_file("sample.csv")
+    ret = cli_runner(csv, "-s", "2023-06-01", option, "20")
+    assert "argument --start-date: --week is ignored when" in ret.stderr
+
+
+def test_start_date_alone_no_override_warning(cli_runner, csv_file):
+    """--start-date used alone must not emit an override warning."""
+    csv = csv_file("sample.csv")
+    ret = cli_runner(csv, "-s", "2023-06-01")
+    assert "is ignored when --start-date" not in ret.stderr

{heatmap_cli-0.25.2 → heatmap_cli-0.25.4}/tests/test_title_option.py

@@ -25,6 +25,20 @@ def test_debug_logs(cli_runner, csv_file, option):
     assert "my title is foobar" in ret.stderr
 
 
+@pytest.mark.parametrize("option", ["-t", "--title"])
+def test_empty_title_rejected(cli_runner, csv_file, option):
+    csv = csv_file("sample.csv")
+    ret = cli_runner(csv, "-y", "2024", option, "")
+    assert "argument --title: cannot be empty or symbolic only." in ret.stderr
+
+
+@pytest.mark.parametrize("option", ["-t", "--title"])
+def test_symbols_only_title_rejected(cli_runner, csv_file, option):
+    csv = csv_file("sample.csv")
+    ret = cli_runner(csv, "-y", "2024", option, "!!!")
+    assert "argument --title: cannot be empty or symbolic only." in ret.stderr
+
+
 def test_default_title(cli_runner, csv_file):
     csv = csv_file("sample.csv")
     ret = cli_runner(csv, "-y", "2024", "-d", "-w", "42")

heatmap_cli-0.25.2/tests/test_heatmap_open.py

@@ -1,46 +0,0 @@
-# Copyright (C) 2026 Kian-Meng Ang
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU Affero General Public License as published
-# by the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU Affero General Public License for more details.
-#
-# You should have received a copy of the GNU Affero General Public License
-# along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-import argparse
-from pathlib import Path
-from unittest.mock import patch
-
-import pandas as pd
-
-from heatmap_cli.heatmap import _generate_heatmap
-
-
-def test_generate_heatmap_with_open(tmpdir):
-    config = argparse.Namespace(
-        annotate=False,
-        cbar=False,
-        cmap_min=None,
-        cmap_max=None,
-        author="Test Author",
-        title="Test Title",
-        output_dir=str(tmpdir),
-        format="png",
-        open=True,
-    )
-
-    df = pd.DataFrame([[10, 20], [30, 40]], index=[1, 2], columns=["01", "02"])
-
-    with patch("heatmap_cli.heatmap._open_heatmap") as mocked_open:
-        result = _generate_heatmap(1, "vlag", config, df)
-        assert result is None
-        mocked_open.assert_called_once()
-
-    output_files = list(Path(str(tmpdir)).glob("*.png"))
-    assert len(output_files) >= 1