Move configure_logging() from rimport to shared.

Author: samsrabin

rimport

@@ -303,37 +303,6 @@ def print_can_file_be_downloaded(file_can_be_downloaded: bool):
         logger.info("%sFile is not (yet) available for download.", INDENT)
 
 
-def configure_logging(log_level: int) -> None:
-    """Configure logging to send INFO/WARNING to stdout and ERROR/CRITICAL to stderr.
-
-    Sets up two handlers:
-    - 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).
-    """
-    logger.setLevel(log_level)
-
-    # Handler for INFO, WARNING, and DEBUG level messages -> stdout
-    info_handler = logging.StreamHandler(sys.stdout)
-    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"))
-
-    # Handler for ERROR and CRITICAL level messages -> stderr
-    error_handler = logging.StreamHandler(sys.stderr)
-    error_handler.setLevel(logging.ERROR)
-    error_handler.setFormatter(logging.Formatter("%(message)s"))
-
-    # Clear any existing handlers and add our custom ones
-    logger.handlers.clear()
-    logger.addHandler(info_handler)
-    logger.addHandler(error_handler)
-
-
 def main(argv: List[str] | None = None) -> int:
     """Main entry point for the rimport tool.
 
@@ -361,7 +330,7 @@ def main(argv: List[str] | None = None) -> int:
 
     # Configure logging based on verbosity flags
     log_level = shared.get_log_level(quiet=args.quiet, verbose=args.verbose)
-    configure_logging(log_level)
+    shared.configure_logging(logger, 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 …`

shared.py

@@ -5,6 +5,7 @@
 import logging
 import argparse
 import os
+import sys
 
 DEFAULT_INPUTDATA_ROOT = "/glade/campaign/cesm/cesmdata/cseg/inputdata/"
 DEFAULT_STAGING_ROOT = (
@@ -32,6 +33,37 @@ def get_log_level(quiet: bool = False, verbose: bool = False) -> int:
     return logging.INFO
 
 
+def configure_logging(logger, log_level: int) -> None:
+    """Configure logging to send INFO/WARNING to stdout and ERROR/CRITICAL to stderr.
+
+    Sets up two handlers:
+    - 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).
+    """
+    logger.setLevel(log_level)
+
+    # Handler for INFO, WARNING, and DEBUG level messages -> stdout
+    info_handler = logging.StreamHandler(sys.stdout)
+    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"))
+
+    # Handler for ERROR and CRITICAL level messages -> stderr
+    error_handler = logging.StreamHandler(sys.stderr)
+    error_handler.setLevel(logging.ERROR)
+    error_handler.setFormatter(logging.Formatter("%(message)s"))
+
+    # Clear any existing handlers and add our custom ones
+    logger.handlers.clear()
+    logger.addHandler(info_handler)
+    logger.addHandler(error_handler)
+
+
 def add_inputdata_root(parser: argparse.ArgumentParser):
     """Add inputdata_root option to an argument parser.
 

tests/rimport/test_configure_logging.py tests/shared/test_configure_logging.pytests/rimport/test_configure_logging.py renamed to tests/shared/test_configure_logging.py

@@ -1,26 +1,14 @@
 """
-Tests for configure_logging() function in rimport script.
+Tests for shared configure_logging() function.
 """
 
-import os
-import sys
-import importlib.util
 import logging
-from importlib.machinery import SourceFileLoader
 
 import pytest
 
-# Import rimport module from file without .py extension
-rimport_path = os.path.join(
-    os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))),
-    "rimport",
-)
-loader = SourceFileLoader("rimport", rimport_path)
-spec = importlib.util.spec_from_loader("rimport", loader)
-if spec is None:
-    raise ImportError(f"Could not create spec for rimport from {rimport_path}")
-rimport = importlib.util.module_from_spec(spec)
-loader.exec_module(rimport)
+import shared
+
+logger = logging.getLogger(__name__)
 
 
 class TestConfigureLogging:
@@ -31,49 +19,49 @@ def cleanup_logger(self):
         """Clean up logger handlers after each test."""
         yield
         # Clear handlers after test
-        rimport.logger.handlers.clear()
+        logger.handlers.clear()
 
     def test_sets_logger_level_to_info(self):
         """Test that configure_logging sets the logger level to INFO."""
-        rimport.configure_logging(logging.INFO)
-        assert rimport.logger.level == logging.INFO
+        shared.configure_logging(logger, logging.INFO)
+        assert logger.level == logging.INFO
 
     def test_creates_two_handlers(self):
         """Test that configure_logging creates exactly two handlers."""
-        rimport.configure_logging(logging.INFO)
-        assert len(rimport.logger.handlers) == 2
+        shared.configure_logging(logger, logging.INFO)
+        assert len(logger.handlers) == 2
 
     def test_info_handler_goes_to_stdout(self, capsys):
         """Test that INFO level messages go to stdout."""
-        rimport.configure_logging(logging.INFO)
-        rimport.logger.info("Test info message")
+        shared.configure_logging(logger, logging.INFO)
+        logger.info("Test info message")
 
         captured = capsys.readouterr()
         assert "Test info message" in captured.out
         assert captured.err == ""
 
     def test_warning_handler_goes_to_stdout(self, capsys):
         """Test that WARNING level messages go to stdout."""
-        rimport.configure_logging(logging.INFO)
-        rimport.logger.warning("Test warning message")
+        shared.configure_logging(logger, logging.INFO)
+        logger.warning("Test warning message")
 
         captured = capsys.readouterr()
         assert "Test warning message" in captured.out
         assert captured.err == ""
 
     def test_error_handler_goes_to_stderr(self, capsys):
         """Test that ERROR level messages go to stderr."""
-        rimport.configure_logging(logging.INFO)
-        rimport.logger.error("Test error message")
+        shared.configure_logging(logger, logging.INFO)
+        logger.error("Test error message")
 
         captured = capsys.readouterr()
         assert captured.out == ""
         assert "Test error message" in captured.err
 
     def test_critical_handler_goes_to_stderr(self, capsys):
         """Test that CRITICAL level messages go to stderr."""
-        rimport.configure_logging(logging.INFO)
-        rimport.logger.critical("Test critical message")
+        shared.configure_logging(logger, logging.INFO)
+        logger.critical("Test critical message")
 
         captured = capsys.readouterr()
         assert captured.out == ""
@@ -84,20 +72,20 @@ def test_clears_existing_handlers(self):
         # Add a dummy handler
         from io import StringIO
         dummy_handler = logging.StreamHandler(StringIO())
-        rimport.logger.addHandler(dummy_handler)
-        assert len(rimport.logger.handlers) >= 1
+        logger.addHandler(dummy_handler)
+        assert len(logger.handlers) >= 1
 
         # Configure logging
-        rimport.configure_logging(logging.INFO)
+        shared.configure_logging(logger, logging.INFO)
 
         # Verify old handlers were cleared and new ones added
-        assert len(rimport.logger.handlers) == 2
-        assert dummy_handler not in rimport.logger.handlers
+        assert len(logger.handlers) == 2
+        assert dummy_handler not in logger.handlers
 
     def test_formatter_uses_message_only(self, capsys):
         """Test that the formatter outputs only the message without level/timestamp."""
-        rimport.configure_logging(logging.INFO)
-        rimport.logger.info("Simple message")
+        shared.configure_logging(logger, logging.INFO)
+        logger.info("Simple message")
 
         captured = capsys.readouterr()
         output = captured.out.strip()
@@ -106,34 +94,34 @@ def test_formatter_uses_message_only(self, capsys):
 
     def test_multiple_calls_dont_duplicate_handlers(self):
         """Test that calling configure_logging multiple times doesn't duplicate handlers."""
-        rimport.configure_logging(logging.INFO)
-        assert len(rimport.logger.handlers) == 2
+        shared.configure_logging(logger, logging.INFO)
+        assert len(logger.handlers) == 2
 
-        rimport.configure_logging(logging.INFO)
-        assert len(rimport.logger.handlers) == 2  # Still 2, not 4
+        shared.configure_logging(logger, logging.INFO)
+        assert len(logger.handlers) == 2  # Still 2, not 4
 
-        rimport.configure_logging(logging.INFO)
-        assert len(rimport.logger.handlers) == 2  # Still 2, not 6
+        shared.configure_logging(logger, logging.INFO)
+        assert len(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)
+        shared.configure_logging(logger, logging.DEBUG)
 
         # DEBUG messages should now be logged
-        rimport.logger.debug("Debug message")
+        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)
+        shared.configure_logging(logger, logging.WARNING)
 
         # INFO messages should be suppressed
-        rimport.logger.info("Info message")
+        logger.info("Info message")
         # WARNING messages should be logged
-        rimport.logger.warning("Warning message")
+        logger.warning("Warning message")
 
         captured = capsys.readouterr()
         assert "Info message" not in captured.out
@@ -142,10 +130,10 @@ def test_configure_with_warning_level(self, capsys):
 
     def test_configure_with_info_level_suppresses_debug(self, capsys):
         """Test that INFO level suppresses DEBUG messages."""
-        rimport.configure_logging(logging.INFO)
+        shared.configure_logging(logger, logging.INFO)
 
-        rimport.logger.debug("Debug message")
-        rimport.logger.info("Info message")
+        logger.debug("Debug message")
+        logger.info("Info message")
 
         captured = capsys.readouterr()
         assert "Debug message" not in captured.out