Merge branch 'develop' into feature/fire_MPI

Author: mkavulich

.github/scripts/check_log_warnings_remarks.py

@@ -35,8 +35,7 @@ def call_API(self, endpoint):
       api_call = APICall(endpoint)
       response = requests.get(api_call.url, headers=api_call.header)
       if response.status_code != 200:
-         logging.warning(response)
-         print(response)
+         logging.error(f"{response}: API call failed for {api_call.url}")
          sys.exit(1)
       response = json.loads(response.text)
 
@@ -61,44 +60,37 @@ def _fetch_log_text(self, commit):
          r = requests.get(url, headers=api_call.header)
          return r.text
       except:
-         logging.error("An appropriate commit(s) was not provided. Call _get_commits() first.")
-
-   def _get_test_data(self, log_instance):
-      """For each instance of a log at a given commit, extract runtime and memory data from the log text
-         Args:
-            log_instance: Log text for a given commit
-         Returns: 
-            tests_for_log_instance: A dictionary of tests (keys) with a tuple of warnings and remarks as the value for each test
-      """
+         logging.error(f"No commit found for the ref {commit}")
+         sys.exit(1)
 
-      tests_for_log_instance = {}
+   def _get_data(self, log_text, pattern, handler, to_clean=True):
+      """Extract data on warnings, remarks, and failed compiles/tests
+      Args:
+         log_text: Text from a log file at a given commit
+         pattern: regex pattern to match
+         handler: function indicating how to handle the incoming data
+         to_clean: Flag indicating whether the data needs to be cleaned (True) or not (False)
+      """
 
-      # Use non-capturing groups in pattern to indicate warnings/remarks may or may not be present.
-      pattern = r"COMPILE \'(.*)\' \[\d+:\d+, \d+:\d+\](?: \( (?:(\d+) warnings)?\s*(?:(\d+) remarks)? \))?"
+      data = {}
 
-      log_instance = log_instance.splitlines()
+      log_text = log_text.splitlines()
 
-      for line in log_instance:
+      for line in log_text:
          test_match = re.search(pattern, line)
          if test_match:
-            test_name, warnings, remarks = test_match.groups()
-            tests_for_log_instance[test_name] = (warnings, remarks)
+            handler(data, *test_match.groups())
+         
+      if to_clean:
+         data = self._clean_data(data)
+      
+      return data
 
-      return tests_for_log_instance
+   def handle_warn_rmk(self, data_dict, test_name, warnings, remarks):
+      data_dict.update({test_name: (warnings, remarks)})
 
-   def _get_pr_data(self, commit):
-      """Extract warnings/remarks data for a particular commit.
-      Returns:
-         log_data: A dictionary of tests as the key with a tuple of (warnings, remarks) as the value
-      """
-      try:
-         log_text = self._fetch_log_text(commit)
-         log_data = self._get_test_data(log_text)
-         log_data = self._clean_data(log_data)
-         return log_data
-      except:
-         logging.error(f"No commit found for the ref {commit}")
-         sys.exit(1)
+   def handle_failures(self, data_dict, reason, test):
+      data_dict.setdefault(reason, []).append(test)
 
    def _clean_data(self, test_data):
       """Convert None values to zeros in the test_data dictionary"""
@@ -126,45 +118,99 @@ def compare_results(self, pr_log, base_log):
 
       return increases
 
-def print_html_results(dict):
-   """Print the comparison results in HTML."""
+def print_html_results(data_dict, title, file_name):
+   """Print results in HTML format.
+
+   Args:
+      data_dict: Dictionary with structure {machine: {category: tests, ...}, ...}
+                 where values can be either:
+                 - A dict with {test: count, ...} (for warnings/remarks)
+                 - A list of tests (for failures)
+      title: Title for the markdown file
+      file_name: Name for the markdown file
+   
+   Returns:
+      Formatted markdown string
+   """
+   mdFile = MdUtils(file_name=file_name, title=title)
+
+   for machine, machine_data in data_dict.items():
+      # Skip if there is no data for the machine (cases: (1) where all RTs pass on the machine or (2) there is no increase in warnings & remarks)
+      if not machine_data:
+         continue
+      
+      # Skip if all categories (warnings/remarks/failure reasons) are empty
+      if all(not category for category in machine_data.values()):
+         continue
+      
+      mdFile.write(f"\n<h3>{machine.upper()}</h3>\n")
+      
+      for category, tests in machine_data.items():
+         # Skip printing info if there are no tests listed for a given category
+         if not tests:
+            continue
+         
+         unordered_list = [f"**{category.title()}:**", []]
+         
+         # Handle both dict (warnings/remarks) and list (failures)
+         if isinstance(tests, dict):
+            for test, count in tests.items():
+               unordered_list[1].append(f"{test}: {count}")
+         else:  # list
+            for test in tests:
+               unordered_list[1].append(test)
+         
+         mdFile.new_list(unordered_list, marked_with='*')
 
-   pr_num = os.environ.get('PR_NUM')
-   mdFile = MdUtils(file_name='summary.md', title=f'Increased Warnings/Remarks for PR #{pr_num}')
-
-   for machine, results in dict.items():
-      for category in results.keys():
-         if results[category]:
-            mdFile.write(f"\n<h3>{machine.upper()}</h3>\n")
-            unordered_list = [f"**{category.title()}:**", []]
-            for test, value in dict[machine][category].items():
-               unordered_list[1].append(f"{test}: {value}")
-            mdFile.new_list(unordered_list, marked_with='*')
    return mdFile.get_md_text()
 
 def main():
    """For each machine, create a log object, get current PR data, and determine 
    which tests increase warnings and/or remarks on each machine.""" 
 
    machines = os.environ.get('MACHINES').split()
+   # Use non-capturing groups in pattern to indicate warnings/remarks may or may not be present.
+   compile_pattern = r"COMPILE \'(.*)\' \[\d+:\d+, \d+:\d+\](?: \( (?:(\d+) warnings)?\s*(?:(\d+) remarks)? \))?"
+   # failure_pattern = r"^(?:FAILED|SKIPPED): (?!UNABLE TO (?:COMPLETE COMPARISON|START TEST))(.+?) -- (?:TEST|COMPILE) '([^']+)"
+   failure_pattern = r"^(?:FAILED|SKIPPED): (.+?) -- (?:TEST|COMPILE) '([^']+)"
+      
 
-   # For each machine, tests where warnings and/or remarks increase
+   # For each machine, increased_warnings_remarks records where warnings and/or remarks increase
    increased_warnings_remarks = {}
+   # For each machine, failures records which tests fail by reason
+   failures = {}
 
    for machine in machines:
       log = Log(machine)
       log._get_commits()
-      log.pr_log_data = log._get_pr_data(log.pr_head_commit)
-      log.base_log_data = log._get_pr_data(log.pr_base_commit)
-      
-      increased_warnings_remarks[machine] = log.compare_results(log.pr_log_data, log.base_log_data)
+      log.pr_log_text = log._fetch_log_text(log.pr_head_commit)
+      log.pr_warn_rmk = log._get_data(log.pr_log_text, compile_pattern, log.handle_warn_rmk)
+      log.pr_failures = log._get_data(log.pr_log_text, failure_pattern, log.handle_failures, to_clean=False)
 
-   results = print_html_results(increased_warnings_remarks)
+      log.base_log_text = log._fetch_log_text(log.pr_base_commit)
+      log.base_warn_rmk = log._get_data(log.base_log_text, compile_pattern, log.handle_warn_rmk)
+      
+      increased_warnings_remarks[machine] = log.compare_results(log.pr_warn_rmk, log.base_warn_rmk)
+      failures[machine] = log.pr_failures
 
-   if len(results) > 81: # Length of HTML header
-      print(results)
+   pr_num = os.environ.get('PR_NUM')
+   warn_rmk_results = print_html_results(increased_warnings_remarks, 
+                                     f"Increased Warnings/Remarks for PR #{pr_num}",
+                                     "warn_rmk.md")
+   failure_results = print_html_results(failures, 
+                                    f"Compile and Test Failures for PR #{pr_num}", 
+                                    "failures.md")
+
+   if len(warn_rmk_results.splitlines()) > 3: # HTML header is 3 lines long
+      print(warn_rmk_results)
+      if len(failure_results.splitlines()) > 3:
+         print(failure_results)
       sys.exit(1)
+   elif len(failure_results.splitlines()) > 3:
+      print(failure_results)
+      sys.exit(0)
    else:
+      print(f"No increase in warnings or remarks. All RTs passed.")
       sys.exit(0)
 
 if __name__ == "__main__": # pragma: no coverage

.gitignore

@@ -82,3 +82,7 @@ tests/logs/log_*
 compile_0_time.log	
 tests/modules.ufs_model.lua
 tests/ufs_common.lua
+
+# Backup logs for local regression tests
+tests/logs/RegressionTests_*.log.bak
+

UFSATM

@@ -1 +1 @@
-export BL_DATE=20260406
+export BL_DATE=20260417

tests/bl_date.conf

@@ -1662,12 +1662,11 @@ export_fire_behavior() {
 }
 
 
-# Defaults for the coupled 5-component
+# Defaults for the global coupled
 export_cmeps() {
-  export UFS_CONFIGURE=ufs.configure.s2swa_fast.IN
+  export UFS_CONFIGURE=ufs.configure.s2sw_fast.IN
   export med_model=cmeps
   export atm_model=fv3
-  export chm_model=gocart
   export ocn_model=mom6
   export ice_model=cice6
   export wav_model=ww3
@@ -1860,7 +1859,7 @@ export CPL=.true.
 export CPLWAV=.true.
 export CPLWAV2ATM=.true.
 export USE_MED_FLUX=.false.
-export CPLCHM=.true.
+export CPLCHM=.false.
 export CPLLND=.false.
 
 # for FV3: default values will be changed if doing a warm-warm restart