Changing the variable name to metrics interval in seconds to be more exact,

Author: angelosantos4

nodestream/cli/commands/run.py

@@ -58,7 +58,7 @@ class Run(NodestreamCommand):
             flag=False,
         ),
         option(
-            "time-interval-seconds",
+            "metrics-interval-seconds",
             description="Time interval to report metrics in seconds",
             default=None,
             flag=False,

nodestream/cli/operations/run_pipeline.py

@@ -122,14 +122,14 @@ def create_progress_reporter(
         self, command: NodestreamCommand, pipeline_name: str
     ) -> PipelineProgressReporter:
         indicator = self.get_progress_indicator(command, pipeline_name)
-        time_interval_seconds = (
-            float(command.option("time-interval-seconds"))
-            if command.option("time-interval-seconds")
+        metrics_interval_in_seconds = (
+            float(command.option("metrics-interval-in-seconds"))
+            if command.option("metrics-interval-in-seconds")
             else None
         )
         return PipelineProgressReporter(
             reporting_frequency=int(command.option("reporting-frequency")),
-            time_interval_seconds=time_interval_seconds,
+            metrics_interval_in_seconds=metrics_interval_in_seconds,
             callback=indicator.progress_callback,
             on_start_callback=indicator.on_start,
             on_finish_callback=indicator.on_finish,

nodestream/pipeline/progress_reporter.py

@@ -33,7 +33,7 @@ class PipelineProgressReporter:
     """A `PipelineProgressReporter` is a utility that can be used to report on the progress of a pipeline."""
 
     reporting_frequency: int = 10000
-    time_interval_seconds: Optional[float] = None
+    metrics_interval_in_seconds: Optional[float] = None
     logger: Logger = field(default_factory=getLogger)
     callback: Callable[[int, Metrics], None] = field(default=no_op)
     on_start_callback: Callable[[], None] = field(default=no_op)
@@ -71,9 +71,9 @@ def for_testing(cls, results_list: list) -> "PipelineProgressReporter":
         )
 
     def report(self, index, metrics: Metrics):
-        if self.time_interval_seconds is not None:
+        if self.metrics_interval_in_seconds is not None:
             current_time = time.time()
-            if current_time - self.last_report_time >= self.time_interval_seconds:
+            if current_time - self.last_report_time >= self.metrics_interval_in_seconds:
                 self.callback(index, metrics)
                 self.last_report_time = current_time
         elif index % self.reporting_frequency == 0:

tests/unit/cli/operations/test_run_pipeline.py

@@ -60,7 +60,7 @@ def test_create_progress_reporter_with_time_interval_seconds(
     """Test that time_interval_seconds gets properly converted to float and passed to PipelineProgressReporter"""
     command = mocker.Mock()
     command.option.side_effect = lambda opt: {
-        "time-interval-seconds": "30.5",
+        "metrics-interval-in-seconds": "30.5",
         "reporting-frequency": "1000",
     }.get(opt)
     command.has_json_logging_set = False
@@ -75,7 +75,7 @@ def test_create_progress_reporter_with_time_interval_seconds(
     # Verify PipelineProgressReporter was called with correct time_interval_seconds
     mock_progress_reporter.assert_called_once()
     call_args = mock_progress_reporter.call_args
-    assert_that(call_args.kwargs["time_interval_seconds"], equal_to(30.5))
+    assert_that(call_args.kwargs["metrics_interval_in_seconds"], equal_to(30.5))
     assert_that(call_args.kwargs["reporting_frequency"], equal_to(1000))
 
 
@@ -85,7 +85,7 @@ def test_create_progress_reporter_without_time_interval_seconds(
     """Test that time_interval_seconds is None when not provided"""
     command = mocker.Mock()
     command.option.side_effect = lambda opt: {
-        "time-interval-seconds": None,
+        "metrics-interval-in-seconds": None,
         "reporting-frequency": "2000",
     }.get(opt)
     command.has_json_logging_set = False
@@ -100,15 +100,15 @@ def test_create_progress_reporter_without_time_interval_seconds(
     # Verify PipelineProgressReporter was called with None for time_interval_seconds
     mock_progress_reporter.assert_called_once()
     call_args = mock_progress_reporter.call_args
-    assert_that(call_args.kwargs["time_interval_seconds"], equal_to(None))
+    assert_that(call_args.kwargs["metrics_interval_in_seconds"], equal_to(None))
     assert_that(call_args.kwargs["reporting_frequency"], equal_to(2000))
 
 
 def test_create_progress_reporter_with_json_indicator(run_pipeline_operation, mocker):
     """Test that create_progress_reporter works correctly with JSON progress indicator"""
     command = mocker.Mock()
     command.option.side_effect = lambda opt: {
-        "time-interval-seconds": "15.0",
+        "metrics-interval-in-seconds": "15.0",
         "reporting-frequency": "500",
     }.get(opt)
     command.has_json_logging_set = True
@@ -123,7 +123,7 @@ def test_create_progress_reporter_with_json_indicator(run_pipeline_operation, mo
     # Verify PipelineProgressReporter was called with correct arguments
     mock_progress_reporter.assert_called_once()
     call_args = mock_progress_reporter.call_args
-    assert_that(call_args.kwargs["time_interval_seconds"], equal_to(15.0))
+    assert_that(call_args.kwargs["metrics_interval_in_seconds"], equal_to(15.0))
     assert_that(call_args.kwargs["reporting_frequency"], equal_to(500))
 
 
@@ -142,7 +142,7 @@ def test_make_run_request_with_time_interval_seconds_integration(
         "annotations": annotations,
         "step-outbox-size": "10001",
         "target": targets,
-        "time-interval-seconds": "45.0",
+        "metrics-interval-in-seconds": "45.0",
         "reporting-frequency": "5000",
     }
     command.option.side_effect = lambda opt: option_responses.get(opt)
@@ -168,7 +168,7 @@ def test_make_run_request_with_time_interval_seconds_integration(
     # Verify the progress reporter was created with correct time_interval_seconds
     mock_progress_reporter.assert_called_once()
     call_args = mock_progress_reporter.call_args
-    assert_that(call_args.kwargs["time_interval_seconds"], equal_to(45.0))
+    assert_that(call_args.kwargs["metrics_interval_in_seconds"], equal_to(45.0))
     assert_that(call_args.kwargs["reporting_frequency"], equal_to(5000))
 
     # Verify other parts of the request are still correct

tests/unit/pipeline/test_pipeline_progress_reporter.py

@@ -22,11 +22,11 @@ async def test_pipeline_progress_reporter_for_testing(mocker):
     assert_that(result.logger.name, equal_to("test"))
 
 
-def test_pipeline_progress_reporter_with_time_interval_seconds(mocker):
-    """Test that time_interval_seconds works correctly"""
+def test_pipeline_progress_reporter_with_metrics_interval_in_seconds(mocker):
+    """Test that metrics_interval_in_seconds works correctly"""
     mock_callback = Mock()
     reporter = PipelineProgressReporter(
-        time_interval_seconds=0.1, callback=mock_callback
+        metrics_interval_in_seconds=0.1, callback=mock_callback
     )
 
     mock_time = mocker.patch("nodestream.pipeline.progress_reporter.time.time")
@@ -39,11 +39,11 @@ def test_pipeline_progress_reporter_with_time_interval_seconds(mocker):
     assert_that(mock_callback.call_count, equal_to(1))
 
 
-def test_pipeline_progress_reporter_without_time_interval_uses_frequency():
-    """Test that None time_interval_seconds falls back to frequency-based reporting"""
+def test_pipeline_progress_reporter_without_metrics_interval_in_seconds_uses_frequency():
+    """Test that None metrics_interval_in_seconds falls back to frequency-based reporting"""
     mock_callback = Mock()
     reporter = PipelineProgressReporter(
-        time_interval_seconds=None, reporting_frequency=3, callback=mock_callback
+        metrics_interval_in_seconds=None, reporting_frequency=3, callback=mock_callback
     )
 
     metrics = Metrics()