added end_date_print parameter

Author: zepholus

pySWATPlus/sensitivity_analyzer.py

@@ -308,7 +308,7 @@ def simulation_by_sobol_sample(
                 simulation_data = {
                     'channel_sd_mon.txt': {
                         'has_units': True,
-                        'start_date': '01-Jun-2014',
+                        'begin_date': '01-Jun-2014',
                         'end_date': '01-Oct-2016',
                         'apply_filter': {'gis_id': [561], 'yr': [2015, 2016]},
                         'usecols': ['gis_id', 'flo_out']

pySWATPlus/txtinout_reader.py

@@ -463,33 +463,46 @@ def set_print_interval(
 
         return None
 
-    def set_start_date_print(
+    def set_print_period(
         self,
-        start_date: str,
+        begin_date: str,
+        end_date: str,
     ) -> None:
         '''
-        Set the start date in the `print.prt` file to define when output files begin recording simulation results.
+        Set the start and end date in the `print.prt` file to define when output files begin recording simulation results.
 
         Args:
-            start_date (str): Start date in `DD-Mon-YYYY` format (e.g., 01-Jun-2010).
+            begin_date (str): Start date in `DD-Mon-YYYY` format (e.g., 01-Jun-2010).
+            end_date (str): End date in `DD-Mon-YYYY` format (e.g., 31-Dec-2020).
         '''
 
         # Check input variables type
         validators._variable_origin_static_type(
             vars_types=typing.get_type_hints(
-                obj=self.set_start_date_print
+                obj=self.set_print_period
             ),
             vars_values=locals()
         )
 
         # Convert date string to datetime.date object
-        start_dt = utils._date_str_to_object(
-            date_str=start_date
+        begin_dt = utils._date_str_to_object(
+            date_str=begin_date
+        )
+        end_dt = utils._date_str_to_object(
+            date_str=end_date
+        )
+
+        # Check begin date is earlier than end date
+        validators._date_begin_earlier_end(
+            begin_date=begin_dt,
+            end_date=end_dt
         )
 
         # Extract years and Julian days
-        start_day = start_dt.timetuple().tm_yday
-        year_year = start_dt.year
+        start_day = begin_dt.timetuple().tm_yday
+        start_year = begin_dt.year
+        end_day = end_dt.timetuple().tm_yday
+        end_year = end_dt.year
 
         # File path of print.prt
         print_prt_path = self.root_folder / 'print.prt'
@@ -500,7 +513,7 @@ def set_start_date_print(
 
             nth_line = 3
             columns = lines[nth_line - 1].split()
-            lines[nth_line - 1] = f"{columns[0]:<12}{start_day:<11}{year_year:<11}{columns[3]:<10}{columns[4]:<10}{columns[5]}\n"
+            lines[nth_line - 1] = f"{columns[0]:<12}{start_day:<11}{start_year:<11}{end_day:<10}{end_year:<10}{columns[5]}\n"
 
         # Modify print.prt file
         with open(print_prt_path, 'w') as file:
@@ -722,40 +735,44 @@ def _apply_swat_configuration(
         simulation_timestep: typing.Optional[int] = None,
         warmup: typing.Optional[int] = None,
         print_prt_control: typing.Optional[dict[str, dict[str, bool]]] = None,
-        start_date_print: typing.Optional[str] = None,
+        begin_date_print: typing.Optional[str] = None,
+        end_date_print: typing.Optional[str] = None,
         print_interval: typing.Optional[int] = None
     ) -> None:
         '''
         Set begin and end year for the simulation, the warm-up period, and toggles the elements in print.prt file
         '''
 
-        # Ensure both begin and end dates are provided together
-        if (begin_date is None) != (end_date is None):
-            raise ValueError(
-                "Both 'begin_date' and 'end_date' must be provided together, "
-                f"got begin_date={begin_date}, end_date={end_date}"
-            )
+        validators._ensure_together(begin_date=begin_date, end_date=end_date)
+        validators._ensure_together(begin_date_print=begin_date_print, end_date_print=end_date_print)
 
-        if start_date_print is not None and (begin_date is None or end_date is None):
+        # Validate dependencies between simulation and print periods
+        if (begin_date_print or end_date_print) and not (begin_date and end_date):
             raise ValueError(
-                "'start_date_print' cannot be set unless both 'begin_date' and 'end_date' are also provided. "
-                f"got start_date_print={start_date_print}, begin_date={begin_date}, end_date={end_date}"
+                "'begin_date_print'/'end_date_print' cannot be set unless "
+                "'begin_date' and 'end_date' are also provided."
             )
 
         # Validate date relationships
-        if start_date_print is not None and begin_date is not None and end_date is not None:
+        if begin_date_print and end_date_print and begin_date and end_date:
             begin_dt = utils._date_str_to_object(begin_date)
             end_dt = utils._date_str_to_object(end_date)
-            start_print_dt = utils._date_str_to_object(start_date_print)
+            start_print_dt = utils._date_str_to_object(begin_date_print)
+            end_print_dt = utils._date_str_to_object(end_date_print)
 
             validators._date_within_range(
                 date_to_check=start_print_dt,
                 begin_date=begin_dt,
                 end_date=end_dt
             )
+            validators._date_within_range(
+                date_to_check=end_print_dt,
+                begin_date=begin_dt,
+                end_date=end_dt
+            )
 
         # Set simulation range time
-        if begin_date is not None and end_date is not None:
+        if begin_date and end_date:
             self.set_simulation_period(
                 begin_date=begin_date,
                 end_date=end_date
@@ -809,9 +826,10 @@ def _apply_swat_configuration(
                         **key_dict
                     )
 
-        if start_date_print is not None:
-            self.set_start_date_print(
-                start_date=start_date_print
+        if begin_date_print and end_date_print:
+            self.set_print_period(
+                begin_date=begin_date_print,
+                end_date=end_date_print
             )
 
         if print_interval is not None:
@@ -871,7 +889,8 @@ def run_swat(
         simulation_timestep: typing.Optional[int] = None,
         warmup: typing.Optional[int] = None,
         print_prt_control: typing.Optional[dict[str, dict[str, bool]]] = None,
-        start_date_print: typing.Optional[str] = None,
+        begin_date_print: typing.Optional[str] = None,
+        end_date_print: typing.Optional[str] = None,
         print_interval: typing.Optional[int] = None,
         skip_validation: bool = False
     ) -> pathlib.Path:
@@ -947,7 +966,9 @@ def run_swat(
                 }
                 ```
 
-            start_date_print (str): Number of years at the beginning of the simulation to not print output
+            begin_date_print (str): The start date for printing the output
+
+            end_date_print (str): The end date for printing the output
 
             print_interval (int): Print interval within the period. For example, if interval = 2, output will be printed for every other day.
 
@@ -993,7 +1014,8 @@ def run_swat(
             simulation_timestep=simulation_timestep,
             warmup=warmup,
             print_prt_control=print_prt_control,
-            start_date_print=start_date_print,
+            begin_date_print=begin_date_print,
+            end_date_print=end_date_print,
             print_interval=print_interval
         )
 

pySWATPlus/validators.py

@@ -322,3 +322,23 @@ def _json_extension(
         )
 
     return None
+
+
+def _ensure_together(**kwargs: typing.Any) -> None:
+    """
+    Ensure that either all or none of the given arguments are provided (not None).
+
+    Example:
+        _ensure_together(begin_date=begin, end_date=end)
+    """
+    total = len(kwargs)
+    provided = [name for name, value in kwargs.items() if value is not None]
+
+    # If some (but not all) values are provided → inconsistent input
+    if 0 < len(provided) < total:
+        missing = [name for name in kwargs if name not in provided]
+        all_args = ", ".join(kwargs.keys())
+        raise ValueError(
+            f"Arguments [{all_args}] must be provided together. "
+            f"Missing: {missing}, Provided: {provided}"
+        )

tests/test_txtinout_reader.py

@@ -79,7 +79,8 @@ def test_run_swat(
                     'channel_sd': {'daily': False},
                     'basin_wb': {}
                 },
-                start_date_print='01-Feb-2010',
+                begin_date_print='01-Feb-2010',
+                end_date_print='31-Dec-2011',
                 print_interval=1
             )
             assert os.path.samefile(target_dir, tmp2_dir)
@@ -263,7 +264,7 @@ def test_set_simulation_timestep(
     assert 'Received invalid step: 7' in exc_info.value.args[0]
 
 
-def test_set_start_date_print(
+def test_set_print_period(
     txtinout_reader
 ):
 
@@ -280,19 +281,31 @@ def test_set_start_date_print(
         parts = original_lines[2].split()
         parts[1] = str(74)
         parts[2] = str(2010)
+        parts[3] = str(365)
+        parts[4] = str(2021)
+
         expected_line = f"{parts[0]:<12}{parts[1]:<11}{parts[2]:<11}{parts[3]:<10}{parts[4]:<10}{parts[5]}\n"
 
         target_reader = pySWATPlus.TxtinoutReader(target_dir)
 
-        target_reader.set_start_date_print(
-            start_date='15-Mar-2010'
+        target_reader.set_print_period(
+            begin_date='15-Mar-2010',
+            end_date='31-Dec-2021'
         )
 
         # Read the line in print.prt again
         with open(target_dir / 'print.prt', 'r') as f:
             lines = f.readlines()
         assert lines[2] == expected_line, f'Expected:\n{expected_line}\nGot:\n{lines[2]}'
 
+        # Error: begin date earlier than end date
+        with pytest.raises(ValueError) as exc_info:
+            target_reader.set_print_period(
+                begin_date='01-Jan-2016',
+                end_date='01-Jan-2012'
+            )
+        assert exc_info.value.args[0] == 'begin_date 01-Jan-2016 must be earlier than end_date 01-Jan-2012'
+
 
 def test_set_print_interval(
     txtinout_reader
@@ -334,28 +347,54 @@ def test_error_run_swat(
         txtinout_reader.run_swat(
             begin_date='01-Jan-2010'
         )
-    assert "Both 'begin_date' and 'end_date' must be provided together" in exc_info.value.args[0]
+    assert "must be provided together" in exc_info.value.args[0]
 
     # Error: end_date set but no begin_date
     with pytest.raises(ValueError) as exc_info:
         txtinout_reader.run_swat(
             end_date='31-Dec-2013'
         )
-    assert "Both 'begin_date' and 'end_date' must be provided together" in exc_info.value.args[0]
+    assert "must be provided together" in exc_info.value.args[0]
+
+    # Error: begin_date_print set but no end_date_print
+    with pytest.raises(ValueError) as exc_info:
+        txtinout_reader.run_swat(
+            begin_date_print='01-Jan-2010'
+        )
+    assert "must be provided together" in exc_info.value.args[0]
 
-    # Error: start_date_print set without begin_date and end_date
+    # Error: end_date_print set but no begin_date_print
     with pytest.raises(ValueError) as exc_info:
         txtinout_reader.run_swat(
-            start_date_print='01-Jan-2010'
+            end_date_print='31-Dec-2013'
         )
-    assert "'start_date_print' cannot be set unless both 'begin_date' and 'end_date'" in exc_info.value.args[0]
+    assert "must be provided together" in exc_info.value.args[0]
+
+    # Error: begin_date_print and end_date_print set without begin_date and end_date
+    with pytest.raises(ValueError) as exc_info:
+        txtinout_reader.run_swat(
+            begin_date_print='01-Jan-2010',
+            end_date_print='01-Jan-2011'
+        )
+    assert "'begin_date_print'/'end_date_print' cannot be set unless 'begin_date' and 'end_date' are also provided." == exc_info.value.args[0]
+
+    # Error: begin_date_print out of range
+    with pytest.raises(ValueError) as exc_info:
+        txtinout_reader.run_swat(
+            begin_date='01-Jan-2010',
+            end_date='31-Dec-2010',
+            begin_date_print='31-Dec-2011',
+            end_date_print='31-Dec-2012'
+        )
+    assert "must be between" in exc_info.value.args[0]
 
-    # Error: start_date_print out of range
+    # Error: end_date_print out of range
     with pytest.raises(ValueError) as exc_info:
         txtinout_reader.run_swat(
             begin_date='01-Jan-2010',
             end_date='31-Dec-2010',
-            start_date_print='31-Dec-2011'
+            begin_date_print='15-Jan-2010',
+            end_date_print='31-Dec-2012'
         )
     assert "must be between" in exc_info.value.args[0]