update fallback when no logging_dir found

Author: saarah815

fancylog/fancylog.py

@@ -599,22 +599,43 @@ def log_image(
     subfolder: str | None = None,
     metadata: dict | None = None,
 ):
-    """Save an image to the logging dir and record its path in the log."""
+    """Save an image to the logging dir and record its path in the log.
+
+    Parameters
+    ----------
+    image : np.ndarray
+        Image data to save.
+    name : str
+        Filename (without extension).
+    logging_dir : str or Path, optional
+        Root logging directory. If None, the default is inferred.
+    subfolder : str, optional
+        Optional subfolder within 'logging_dir/images'.
+    metadata : dict, optional
+        Optional metadata to save as a JSON file in same dir as image.
+
+    Returns
+    -------
+    Path
+        Path to the saved image file.
+
+    """
+    logger = logging.getLogger(__name__)
+
     if logging_dir is None:
         logging_dir = get_default_logging_dir()
         if logging_dir is None:
-            raise ValueError(
-                "Could not infer logging directory from active logger. "
-                "Please provide logging_dir explicitly."
+            logging_dir = Path.cwd() / "logs"
+            logger.info(
+                f"[fancylog] No default logging directory found. "
+                f"Falling back to '{logging_dir}'"
             )
 
     output_dir = Path(logging_dir)
     if subfolder:
-        image_dir = (
-            output_dir / "media" / "images" / _RUN_TIMESTAMP / subfolder
-        )
+        image_dir = output_dir / "logged_images" / _RUN_TIMESTAMP / subfolder
     else:
-        image_dir = output_dir / "media" / "images" / _RUN_TIMESTAMP
+        image_dir = output_dir / "logged_images" / _RUN_TIMESTAMP
     image_dir.mkdir(parents=True, exist_ok=True)
 
     filepath = image_dir / f"{name}.tiff"
@@ -625,7 +646,7 @@ def log_image(
         with open(meta_path, "w") as f:
             json.dump(metadata, f, indent=2)
 
-    logging.getLogger(__name__).info(f"[fancylog] Saved image: {filepath}")
+    logger.info(f"[fancylog] Saved image: {filepath}")
     return filepath
 
 
@@ -634,35 +655,54 @@ def log_data_object(
     name: str,
     logging_dir: str | Path | None = None,
     subfolder: str | None = None,
-    ext: str = "json",
 ):
-    """Save structured data (e.g., dict, list, numpy array) to disk."""
+    """Save structured data (e.g., dict, list, numpy array) to disk.
+
+    Parameters
+    ----------
+    data : dict, list, or np.ndarray
+        The data object to save. Dictionaries and lists are saved as JSON,
+        while NumPy arrays are saved as `.npy` files.
+    name : str
+        Filename (without extension).
+    logging_dir : str or Path, optional
+        Root logging directory. If None, the default is inferred.
+    subfolder : str, optional
+        Optional subfolder within 'logging_dir/data'.
+
+    Returns
+    -------
+    Path
+        Path to the saved data file.
+
+    """
+    logger = logging.getLogger(__name__)
+
     if logging_dir is None:
         logging_dir = get_default_logging_dir()
         if logging_dir is None:
-            raise ValueError(
-                "Could not infer logging directory from active logger. "
-                "Please provide logging_dir explicitly."
+            logging_dir = Path.cwd() / "logs"
+            logger.info(
+                f"[fancylog] No default logging directory found. "
+                f"Falling back to '{logging_dir}'"
             )
 
     output_dir = Path(logging_dir)
     if subfolder:
-        data_dir = output_dir / "media" / "data" / _RUN_TIMESTAMP / subfolder
+        data_dir = output_dir / "logged_data" / _RUN_TIMESTAMP / subfolder
     else:
-        data_dir = output_dir / "media" / "data" / _RUN_TIMESTAMP
+        data_dir = output_dir / "logged_data" / _RUN_TIMESTAMP
     data_dir.mkdir(parents=True, exist_ok=True)
 
-    filepath = data_dir / f"{name}.{ext}"
-
     if isinstance(data, (dict | list)):
+        filepath = data_dir / f"{name}.json"
         with open(filepath, "w") as f:
             json.dump(data, f, indent=2)
     elif isinstance(data, np.ndarray):
+        filepath = data_dir / f"{name}.npy"
         np.save(filepath, data)
     else:
         raise ValueError("Unsupported data type for logging")
 
-    logging.getLogger(__name__).info(
-        f"[fancylog] Saved data object: {filepath}"
-    )
+    logger.info(f"[fancylog] Saved data object: {filepath}")
     return filepath

pyproject.toml

@@ -45,6 +45,10 @@ image = [
     "tifffile",
 ]
 
+array = [
+    "numpy",
+]
+
 multiprocessing = ["multiprocessing-logging"]
 
 [build-system]
@@ -124,6 +128,7 @@ python =
 extras =
     dev
     image
+    array
 commands =
     pytest -v --color=yes --cov=fancylog --cov-report=xml
 """

tests/tests/test_general.py

@@ -5,6 +5,7 @@
 import subprocess
 import sys
 from importlib.metadata import distributions
+from pathlib import Path
 from unittest.mock import MagicMock, patch
 
 import numpy as np
@@ -472,6 +473,10 @@ def test_log_image_without_metadata(tmp_path, caplog):
 
     assert filepath.exists()
 
+    assert filepath.suffix == ".tiff"
+    loaded_img = tifffile.imread(filepath)
+    np.testing.assert_array_equal(img, loaded_img)
+
     # Ensure no metadata file
     meta_file = filepath.with_name("no_meta_meta.json")
     assert not meta_file.exists()
@@ -481,27 +486,24 @@ def test_log_image_without_metadata(tmp_path, caplog):
     )
 
 
-def test_log_data_object_dict_and_list(tmp_path, caplog):
+@pytest.mark.parametrize(
+    "data, name",
+    [
+        ({"a": 1, "b": 2, "c": 3}, "mydict"),
+        ([1, 2, 3], "mylist"),
+    ],
+)
+def test_log_data_object_dict_and_list(tmp_path, caplog, data, name):
     """Test logging of dict and list objects."""
 
-    data_dict = {"a": 1}
     with caplog.at_level(logging.INFO):
-        filepath_dict = fancylog.log_data_object(data_dict, "mydict", tmp_path)
-
-    assert filepath_dict.exists()
-
-    with open(filepath_dict) as f:
-        loaded = json.load(f)
-    assert loaded == data_dict
-
-    data_list = [1, 2, 3]
+        filepath = fancylog.log_data_object(data, name, tmp_path)
 
-    with caplog.at_level(logging.INFO):
-        filepath_list = fancylog.log_data_object(data_list, "mylist", tmp_path)
+    assert filepath.exists()
 
-    with open(filepath_list) as f:
+    with open(filepath) as f:
         loaded = json.load(f)
-    assert loaded == data_list
+    assert loaded == data
 
     assert any(
         "[fancylog] Saved data object:" in message
@@ -513,7 +515,7 @@ def test_log_data_object_numpy_array(tmp_path):
     """Test logging of numpy array."""
 
     arr = np.array([[1, 2], [3, 4]])
-    filepath = fancylog.log_data_object(arr, "array", tmp_path, ext="npy")
+    filepath = fancylog.log_data_object(arr, "array", tmp_path)
 
     assert filepath.exists()
     loaded = np.load(filepath)
@@ -540,19 +542,25 @@ def test_get_default_logging_dir_returns_none(monkeypatch):
         logger.handlers = old_handlers
 
 
-def test_log_image_raises_without_inferable_dir(monkeypatch):
-    """Covers ValueError when logging_dir=None and no FileHandler."""
-    logger = logging.getLogger()
-    old_handlers = logger.handlers[:]
-    logger.handlers = []
+def test_log_image_no_logging_dir(monkeypatch, tmp_path, caplog):
+    """Test that log_image logs fallback message
+    when get_default_logging_dir() returns None.
+    """
+    monkeypatch.setattr(fancylog, "get_default_logging_dir", lambda: None)
+    monkeypatch.setattr(type(Path()), "cwd", classmethod(lambda cls: tmp_path))
 
-    try:
-        with pytest.raises(
-            ValueError, match="Could not infer logging directory"
-        ):
-            fancylog.log_image(np.zeros((2, 2)), "fail")
-    finally:
-        logger.handlers = old_handlers
+    img = np.zeros((3, 3))
+    with caplog.at_level(logging.INFO):
+        filepath = fancylog.log_image(img, "no_logging_dir")
+
+    assert filepath.exists()
+
+    caplog.set_level(logging.INFO)
+    assert (
+        "[fancylog] No default logging directory found. Falling back to"
+        in message
+        for message in caplog.text
+    )
 
 
 def test_log_image_with_subfolder(tmp_path):
@@ -569,7 +577,7 @@ def test_log_data_object_with_subfolder(tmp_path):
     """Covers subfolder branch in log_data_object."""
     arr = np.array([1, 2, 3])
     filepath = fancylog.log_data_object(
-        arr, "with_sub", tmp_path, subfolder="nested", ext="npy"
+        arr, "with_sub", tmp_path, subfolder="nested"
     )
     assert "nested" in str(filepath)
     assert filepath.exists()