Added run_nday to param.nml as a property. Also neatened the writer to preserve blank lines preceding comments.

Author: Eli

schimpy/nml.py

@@ -4,76 +4,145 @@ def parse(file_content):
     If there's a line starting with !, the parser will store it as the full_line_comment and attach it to the next key-value pair it encounters.
     If there's an inline comment starting with !, it will be stored as inline_comment.
 
-    For the most part this parser is comment preserving; you might notice some whitespace and blank line(s) being eliminated in the round trip through write method below
+    For the most part this parser is comment preserving; you might notice some whitespace and blank line(s) being eliminated in the round trip through write method below.
+    NOTE: If a comment block is preceded by a blank line, this fact is now preserved and used when writing back out.
     """
     namelists = {}
     current_namelist = None
+
     full_line_comment = ""
-    for line in file_content.splitlines():
-        line = line.strip()
-        if line.startswith("!"):
+    full_line_comment_leading_blank = False  # NEW: did a blank line precede this comment block?
+    prev_blank = False  # NEW: was the previous raw line blank?
+
+    for raw_line in file_content.splitlines():
+        stripped = raw_line.strip()
+
+        # Track blanks explicitly
+        if stripped == "":
+            prev_blank = True
+            continue
+
+        if stripped.startswith("!"):
+            # Full-line comment, possibly spanning multiple lines
             if len(full_line_comment) == 0:
-                full_line_comment = line[1:]
+                full_line_comment = stripped[1:]
+                full_line_comment_leading_blank = prev_blank
             else:
-                full_line_comment = full_line_comment + "\n" + line[1:]
-        elif line.startswith("&"):
-            current_namelist = line[1:].strip()
-            namelists[current_namelist] = {"comment": full_line_comment}
+                full_line_comment = full_line_comment + "\n" + stripped[1:]
+                # keep whatever leading_blank state we already had
+            prev_blank = False
+
+        elif stripped.startswith("&"):
+            current_namelist = stripped[1:].strip()
+            namelists[current_namelist] = {
+                "comment": full_line_comment,
+            }
+            # NEW: remember if the namelist comment was preceded by a blank line
+            if len(full_line_comment) != 0:
+                namelists[current_namelist]["comment_leading_blank"] = full_line_comment_leading_blank
             full_line_comment = ""
-        elif line.startswith("/"):
+            full_line_comment_leading_blank = False
+            prev_blank = False
+
+        elif stripped.startswith("/"):
             current_namelist = None
+            full_line_comment = ""
+            full_line_comment_leading_blank = False
+            prev_blank = False
+
         elif current_namelist is not None:
-            line_parts = line.split("!", maxsplit=1)
+            # Key/value line (possibly with inline comment)
+            line_parts = stripped.split("!", maxsplit=1)
             key_value_pair = line_parts[0].strip()
             inline_comment = line_parts[1] if len(line_parts) == 2 else ""
             if not key_value_pair:
+                prev_blank = False
                 continue
+
             key, value = key_value_pair.split("=")
             key = key.strip()
             value = value.strip()
 
             try:
                 value = int(value)
-            except:
+            except Exception:
                 try:
                     value = float(value)
-                except:
+                except Exception:
                     pass
 
-            namelists[current_namelist][key] = {
+            entry = {
                 "value": value,
                 "full_line_comment": full_line_comment,
                 "inline_comment": inline_comment,
             }
+            # NEW: remember if the key's full-line comment was preceded by a blank line
+            if len(full_line_comment) != 0:
+                entry["full_line_comment_leading_blank"] = full_line_comment_leading_blank
+
+            namelists[current_namelist][key] = entry
+
+            full_line_comment = ""
+            full_line_comment_leading_blank = False
+            prev_blank = False
+
+        else:
+            # Outside any namelist and not a comment; just reset flags
             full_line_comment = ""
+            full_line_comment_leading_blank = False
+            prev_blank = False
+
     return namelists
 
 
 def write(namelist_data):
     """
-    writes out the namelist dictionary from the parse method to a string. The comments are preserved but not the whitespace or indentations
+    writes out the namelist dictionary from the parse method to a string. The comments are preserved but not the whitespace or indentations.
+
+    If a comment block (either namelist-level or per-key full-line comment) was preceded by a blank line in the original file,
+    a single blank line is written before that comment block.
     """
     lines = []
     for namelist_name, namelist_values in namelist_data.items():
         comment = namelist_values.get("comment")
+        comment_leading_blank = namelist_values.get("comment_leading_blank", False)
+
+        # Namelist-level comment (possibly multi-line)
         if comment and len(comment) != 0:
+            if comment_leading_blank:
+                lines.append("")  # restore the blank line before the comment
             lines.append("!{}".format(comment.replace("\n", "\n!")))
+
         lines.append("&{}".format(namelist_name))
+
         for key, value_data in namelist_values.items():
-            if key == "comment":  # already taken care of above
-                continue
-            if "full_line_comment" in value_data:  # do this first
-                full_line_comment = value_data.get("full_line_comment")
+            if key in ("comment", "comment_leading_blank"):
+                continue  # handled above
+
+            # Handle per-key full-line comment
+            if isinstance(value_data, dict) and "full_line_comment" in value_data:
+                full_line_comment = value_data.get("full_line_comment", "")
                 if len(full_line_comment) != 0:
+                    leading_blank = value_data.get("full_line_comment_leading_blank", False)
+                    if leading_blank:
+                        lines.append("")  # restore blank before the comment
                     lines.append("!{}".format(full_line_comment.replace("\n", "\n!")))
-            if key == "full_line_comment":
-                continue  # took care of it above
+
+            if key in ("full_line_comment", "full_line_comment_leading_blank"):
+                continue  # internal metadata, not an actual namelist key
+
+            if not isinstance(value_data, dict) or "value" not in value_data:
+                continue  # skip any non-standard entries
+
+            # Key/value line
             lines.append("  {} = {}".format(key, value_data["value"]))
+
             inline_comment = value_data.get("inline_comment")
             if inline_comment and len(inline_comment) != 0:
                 lines[-1] = lines[-1] + (
                     " !{}".format(inline_comment.replace("\n", ""))
                 )
+
         lines.append("/")
     return "\n".join(lines)
 

schimpy/param.py

@@ -122,6 +122,25 @@ def set_run_start(self, run_start):
 
     run_start = property(get_run_start, set_run_start)
 
+
+    # NEW: getter/setter for total run length (days), stored in CORE::rnday
+    def get_run_nday(self):
+        """
+        Return total run length (in days) as an int, based on CORE::rnday.
+        """
+        core = self._require_section_keys("CORE", ("rnday",))
+        return int(core["rnday"]["value"])
+
+    def set_run_nday(self, nday):
+        """
+        Set total run length (in days), writing CORE::rnday as an int.
+        """
+        core = self._require_section_keys("CORE", ("rnday",))
+        core["rnday"]["value"] = int(nday)
+
+    run_nday = property(get_run_nday, set_run_nday)
+
+
     def set_interval(self, name, freq):
         """Set binary output frequency using Pandas offset or string that evaluates as offset"""
         dt = int(self["dt"])