rimport: Add --quiet and --verbose options.

Author: samsrabin

relink.py

@@ -12,7 +12,7 @@
 import time
 from pathlib import Path
 
-from shared import DEFAULT_INPUTDATA_ROOT, DEFAULT_STAGING_ROOT
+from shared import DEFAULT_INPUTDATA_ROOT, DEFAULT_STAGING_ROOT, get_log_level
 
 # Set up logger
 logger = logging.getLogger(__name__)
@@ -397,12 +397,7 @@ def process_args(args):
         args (argparse.Namespace): Parsed command-line arguments.
     """
     # Configure logging based on verbosity flags
-    if args.quiet:
-        args.log_level = logging.WARNING
-    elif args.verbose:
-        args.log_level = logging.DEBUG
-    else:
-        args.log_level = logging.INFO
+    args.log_level = get_log_level(quiet=args.quiet, verbose=args.verbose)
 
     # Ensure that items_to_process is a list
     if hasattr(args, "items_to_process") and not isinstance(args.items_to_process, list):

rimport

@@ -89,6 +89,18 @@ def build_parser() -> argparse.ArgumentParser:
         help="Check whether file(s) is/are already published.",
     )
 
+    # Verbosity options (mutually exclusive)
+    verbosity_group = parser.add_mutually_exclusive_group()
+    verbosity_group.add_argument(
+        "-v", "--verbose", action="store_true", help="Enable verbose output (DEBUG level)"
+    )
+    verbosity_group.add_argument(
+        "-q",
+        "--quiet",
+        action="store_true",
+        help="Quiet mode (show only warnings and errors)",
+    )
+
     # Provide -help to mirror legacy behavior (in addition to -h and --help)
     parser.add_argument(
         "-h",
@@ -315,20 +327,23 @@ def print_can_file_be_downloaded(file_can_be_downloaded: bool):
         logger.info("%sFile is not (yet) available for download.", INDENT)
 
 
-def configure_logging() -> None:
+def configure_logging(log_level: int = logging.INFO) -> None:
     """Configure logging to send INFO/WARNING to stdout and ERROR/CRITICAL to stderr.
 
     Sets up two handlers:
-    - INFO handler: Sends INFO and WARNING level messages to stdout
+    - INFO handler: Sends INFO, WARNING, and DEBUG level messages to stdout
     - ERROR handler: Sends ERROR and CRITICAL level messages to stderr
 
     Both handlers use simple message-only formatting without timestamps or level names.
+
+    Args:
+        log_level: Minimum logging level (DEBUG, INFO, or WARNING). Default is INFO.
     """
-    logger.setLevel(logging.INFO)
+    logger.setLevel(log_level)
 
-    # Handler for INFO and WARNING level messages -> stdout
+    # Handler for INFO, WARNING, and DEBUG level messages -> stdout
     info_handler = logging.StreamHandler(sys.stdout)
-    info_handler.setLevel(logging.INFO)
+    info_handler.setLevel(logging.DEBUG)  # Accept all levels, filter will handle it
     info_handler.addFilter(lambda record: record.levelno < logging.ERROR)
     info_handler.setFormatter(logging.Formatter("%(message)s"))
 
@@ -365,11 +380,13 @@ def main(argv: List[str] | None = None) -> int:
         1: One or more files failed to stage (errors printed to stderr).
         2: Fatal error (missing inputdata directory, missing file list, etc.).
     """
-    configure_logging()
-
     parser = build_parser()
     args = parser.parse_args(argv)
 
+    # Configure logging based on verbosity flags
+    log_level = shared.get_log_level(quiet=args.quiet, verbose=args.verbose)
+    configure_logging(log_level)
+
     # Ensure we are running as the STAGE_OWNER account before touching the tree
     # Set env var RIMPORT_SKIP_USER_CHECK=1 if you prefer to run `sudox -u STAGE_OWNER rimport …`
     # explicitly (or for testing).

shared.py

@@ -2,7 +2,29 @@
 Things shared between rimport and relink
 """
 
+import logging
+
 DEFAULT_INPUTDATA_ROOT = "/glade/campaign/cesm/cesmdata/cseg/inputdata/"
 DEFAULT_STAGING_ROOT = (
     "/glade/campaign/collections/gdex/data/d651077/cesmdata/inputdata/"
 )
+
+
+def get_log_level(quiet: bool = False, verbose: bool = False) -> int:
+    """Determine logging level based on quiet and verbose flags.
+
+    Args:
+        quiet: If True, show only warnings and errors (WARNING level).
+        verbose: If True, show debug messages (DEBUG level).
+
+    Returns:
+        int: Logging level (DEBUG, INFO, or WARNING).
+
+    Note:
+        If both quiet and verbose are True, quiet takes precedence.
+    """
+    if quiet:
+        return logging.WARNING
+    if verbose:
+        return logging.DEBUG
+    return logging.INFO

tests/rimport/test_build_parser.py

@@ -126,3 +126,42 @@ def test_list_with_inputdata(self):
         args = parser.parse_args(["-list", "files.txt", "-inputdata", "/my/data"])
         assert args.filelist == "files.txt"
         assert args.inputdata == "/my/data"
+
+    def test_quiet_default(self):
+        """Test that quiet defaults to False."""
+        parser = rimport.build_parser()
+        args = parser.parse_args(["-file", "test.nc"])
+        assert args.quiet is False
+
+    def test_verbose_default(self):
+        """Test that verbose defaults to False."""
+        parser = rimport.build_parser()
+        args = parser.parse_args(["-file", "test.nc"])
+        assert args.verbose is False
+
+    @pytest.mark.parametrize("quiet_flag", ["-q", "--quiet"])
+    def test_quiet_arguments_accepted(self, quiet_flag):
+        """Test that all quiet argument flags are accepted."""
+        parser = rimport.build_parser()
+        args = parser.parse_args(["-file", "test.nc", quiet_flag])
+        assert args.quiet is True
+        assert args.verbose is False
+
+    @pytest.mark.parametrize("verbose_flag", ["-v", "--verbose"])
+    def test_verbose_arguments_accepted(self, verbose_flag):
+        """Test that all verbose argument flags are accepted."""
+        parser = rimport.build_parser()
+        args = parser.parse_args(["-file", "test.nc", verbose_flag])
+        assert args.verbose is True
+        assert args.quiet is False
+
+    def test_quiet_and_verbose_mutually_exclusive(self, capsys):
+        """Test that -q and -v cannot be used together."""
+        parser = rimport.build_parser()
+        with pytest.raises(SystemExit):
+            parser.parse_args(["-file", "test.nc", "-q", "-v"])
+
+        # Check that the error message explains the problem
+        captured = capsys.readouterr()
+        stderr_lines = captured.err.strip().split("\n")
+        assert "not allowed with argument" in stderr_lines[-1]

tests/rimport/test_configure_logging.py

@@ -123,3 +123,39 @@ def test_multiple_calls_dont_duplicate_handlers(self):
 
         rimport.configure_logging()
         assert len(rimport.logger.handlers) == 2  # Still 2, not 6
+
+    def test_configure_with_debug_level(self, capsys):
+        """Test that configure_logging accepts DEBUG level."""
+        rimport.configure_logging(logging.DEBUG)
+
+        # DEBUG messages should now be logged
+        rimport.logger.debug("Debug message")
+
+        captured = capsys.readouterr()
+        assert "Debug message" in captured.out
+        assert captured.err == ""
+
+    def test_configure_with_warning_level(self, capsys):
+        """Test that configure_logging accepts WARNING level."""
+        rimport.configure_logging(logging.WARNING)
+
+        # INFO messages should be suppressed
+        rimport.logger.info("Info message")
+        # WARNING messages should be logged
+        rimport.logger.warning("Warning message")
+
+        captured = capsys.readouterr()
+        assert "Info message" not in captured.out
+        assert "Warning message" in captured.out
+        assert captured.err == ""
+
+    def test_configure_with_info_level_suppresses_debug(self, capsys):
+        """Test that INFO level suppresses DEBUG messages."""
+        rimport.configure_logging(logging.INFO)
+
+        rimport.logger.debug("Debug message")
+        rimport.logger.info("Info message")
+
+        captured = capsys.readouterr()
+        assert "Debug message" not in captured.out
+        assert "Info message" in captured.out

tests/test_shared.py

@@ -0,0 +1,35 @@
+"""
+Tests for shared.py module functions.
+"""
+
+import logging
+import shared
+
+
+class TestGetLogLevel:
+    """Test suite for get_log_level() function."""
+
+    def test_default_returns_info(self):
+        """Test that default (no flags) returns INFO level."""
+        result = shared.get_log_level()
+        assert result == logging.INFO
+
+    def test_quiet_returns_warning(self):
+        """Test that quiet=True returns WARNING level."""
+        result = shared.get_log_level(quiet=True)
+        assert result == logging.WARNING
+
+    def test_verbose_returns_debug(self):
+        """Test that verbose=True returns DEBUG level."""
+        result = shared.get_log_level(verbose=True)
+        assert result == logging.DEBUG
+
+    def test_quiet_takes_precedence_over_verbose(self):
+        """Test that quiet takes precedence when both are True."""
+        result = shared.get_log_level(quiet=True, verbose=True)
+        assert result == logging.WARNING
+
+    def test_quiet_false_verbose_false(self):
+        """Test explicit False values return INFO."""
+        result = shared.get_log_level(quiet=False, verbose=False)
+        assert result == logging.INFO