let TimeTrigger determine starting time from outside

src/finam/modules/control.py

@@ -59,19 +59,36 @@ class TimeTrigger(TimeComponent):
         self._start_from_input = start_from_input
 
     def _initialize(self):
-        if self._ini_in_info is None and self._ini_out_info is None:
-            with ErrorLogger(self.logger):
+        with ErrorLogger(self.logger):
+            if self._ini_in_info is None and self._ini_out_info is None:
                 raise FinamMetaDataError(
                     "At least one of input or output info must be given."
                 )
+            if self._start is None:
+                if self._start_from_input and self._ini_in_info is None:
+                    raise FinamMetaDataError(
+                        "Can't get starting time from the input without an input info."
+                    )
+                if not self._start_from_input and self._ini_out_info is None:
+                    raise FinamMetaDataError(
+                        "Can't get starting time from the output without an output info."
+                    )
 
         if self._ini_in_info is not None:
-            self._ini_in_info.time = self.time
+            self._ini_in_info.time = self._start
         if self._ini_out_info is not None:
-            self._ini_out_info.time = self.time
-
-        self.inputs.add(name="In", info=self._ini_in_info)
-        self.outputs.add(name="Out", info=self._ini_out_info)
+            self._ini_out_info.time = self._start
+
+        if self._start is None:
+            if self._start_from_input:
+                self.inputs.add(name="In", info=self._ini_in_info)
+                self.outputs.add(name="Out")
+            else:
+                self.inputs.add(name="In")
+                self.outputs.add(name="Out", info=self._ini_out_info)
+        else:
+            self.inputs.add(name="In", info=self._ini_in_info)
+            self.outputs.add(name="Out", info=self._ini_out_info)
 
         self.create_connector(pull_data=["In"])
 
@@ -79,18 +96,34 @@ class TimeTrigger(TimeComponent):
         in_infos = {}
         out_infos = {}
 
-        if self._ini_out_info is None:
+        if self._ini_out_info is None or (
+            self._start is None and self._start_from_input
+        ):
             in_info = self.connector.in_infos["In"]
             if in_info is not None:
                 self._in_info = in_info
-                self._out_info = in_info
+                if self._start is None:
+                    self.time = in_info.time
+                if self._ini_out_info is None:
+                    self._out_info = in_info
+                else:
+                    self._ini_out_info.time = in_info.time
+                    self._out_info = self._ini_out_info
                 out_infos["Out"] = self._out_info
 
-        if self._ini_in_info is None:
+        if self._ini_in_info is None or (
+            self._start is None and not self._start_from_input
+        ):
             out_info = self.connector.out_infos["Out"]
             if out_info is not None:
-                self._in_info = out_info
                 self._out_info = out_info
+                if self._start is None:
+                    self.time = out_info.time
+                if self._ini_in_info is None:
+                    self._in_info = out_info
+                else:
+                    self._ini_in_info.time = out_info.time
+                    self._in_info = self._ini_in_info
                 in_infos["In"] = self._in_info
 
         out_data = {}
@@ -101,7 +134,7 @@ class TimeTrigger(TimeComponent):
             out_data["Out"] = self.connector.in_data["In"]
 
         self.try_connect(
-            self.time, exchange_infos=in_infos, push_infos=out_infos, push_data=out_data
+            exchange_infos=in_infos, push_infos=out_infos, push_data=out_data
         )
 
     def _validate(self):

tests/modules/test_control.py

@@ -34,8 +34,93 @@ class TestTimeTrigger(unittest.TestCase):
         composition.connect()
         composition.run(datetime(2000, 1, 5))
 
-    def test_time_trigger_from_target(self):
+    def test_time_trigger_from_source(self):
+        time = datetime(2000, 1, 1)
+        out_info = fm.Info(
+            time=None,
+            grid=fm.NoGrid(),
+            units="m",
+        )
+
+        source = fm.modules.CallbackGenerator(
+            callbacks={
+                "Out": (
+                    lambda t: t.day,
+                    fm.Info(time=None, grid=fm.NoGrid(), units="m"),
+                ),
+            },
+            start=time,
+            step=timedelta(days=1),
+        )
+        trigger = fm.modules.TimeTrigger(
+            in_info=fm.Info(time=None, grid=None, units=None),
+            out_info=None,
+            start=None,
+            step=timedelta(days=1),
+            start_from_input=True,
+        )
+        sink = fm.modules.DebugConsumer(
+            {"Input": out_info},
+            start=datetime(2000, 1, 1),
+            step=timedelta(days=1),
+        )
+
+        composition = fm.Composition([source, trigger, sink])
+        composition.initialize()
+
+        source.outputs["Out"] >> trigger.inputs["In"]
+        trigger.outputs["Out"] >> sink.inputs["Input"]
+
+        composition.connect()
+
+        self.assertEqual(trigger._time, datetime(2000, 1, 1))
+
+        composition.run(datetime(2000, 1, 5))
+
+    def test_time_trigger_from_source_with_info(self):
         time = datetime(2000, 1, 1)
+        out_info = fm.Info(
+            time=None,
+            grid=fm.NoGrid(),
+            units="m",
+        )
+
+        source = fm.modules.CallbackGenerator(
+            callbacks={
+                "Out": (
+                    lambda t: t.day,
+                    fm.Info(time=None, grid=fm.NoGrid(), units="m"),
+                ),
+            },
+            start=time,
+            step=timedelta(days=1),
+        )
+        trigger = fm.modules.TimeTrigger(
+            in_info=fm.Info(time=None, grid=None, units=None),
+            out_info=fm.Info(time=None, grid=None, units=None),
+            start=None,
+            step=timedelta(days=1),
+            start_from_input=True,
+        )
+        sink = fm.modules.DebugConsumer(
+            {"Input": out_info},
+            start=datetime(2000, 1, 1),
+            step=timedelta(days=1),
+        )
+
+        composition = fm.Composition([source, trigger, sink])
+        composition.initialize()
+
+        source.outputs["Out"] >> trigger.inputs["In"]
+        trigger.outputs["Out"] >> sink.inputs["Input"]
+
+        composition.connect()
+
+        self.assertEqual(trigger._time, datetime(2000, 1, 1))
+
+        composition.run(datetime(2000, 1, 5))
+
+    def test_time_trigger_from_target(self):
         out_info = fm.Info(
             time=None,
             grid=fm.UniformGrid((20, 15)),
@@ -45,8 +130,42 @@ class TestTimeTrigger(unittest.TestCase):
         source = fm.modules.SimplexNoise()
         trigger = fm.modules.TimeTrigger(
             out_info=fm.Info(time=None, grid=None, units=None),
-            start=time,
+            start=None,
+            step=timedelta(days=1),
+            start_from_input=False,
+        )
+        sink = fm.modules.DebugConsumer(
+            {"Input": out_info},
+            start=datetime(2000, 1, 1),
+            step=timedelta(days=1),
+        )
+
+        composition = fm.Composition([source, trigger, sink])
+        composition.initialize()
+
+        source.outputs["Noise"] >> trigger.inputs["In"]
+        trigger.outputs["Out"] >> sink.inputs["Input"]
+
+        composition.connect()
+
+        self.assertEqual(trigger._time, datetime(2000, 1, 1))
+
+        composition.run(datetime(2000, 1, 5))
+
+    def test_time_trigger_from_target_with_info(self):
+        out_info = fm.Info(
+            time=None,
+            grid=fm.UniformGrid((20, 15)),
+            units="m",
+        )
+
+        source = fm.modules.SimplexNoise()
+        trigger = fm.modules.TimeTrigger(
+            in_info=out_info.copy_with(),
+            out_info=fm.Info(time=None, grid=None, units=None),
+            start=None,
             step=timedelta(days=1),
+            start_from_input=False,
         )
         sink = fm.modules.DebugConsumer(
             {"Input": out_info},
@@ -61,12 +180,32 @@ class TestTimeTrigger(unittest.TestCase):
         trigger.outputs["Out"] >> sink.inputs["Input"]
 
         composition.connect()
+
+        self.assertEqual(trigger._time, datetime(2000, 1, 1))
+
         composition.run(datetime(2000, 1, 5))
 
     def test_time_trigger_fail(self):
         time = datetime(2000, 1, 1)
 
         trigger = fm.modules.TimeTrigger(start=time, step=timedelta(days=1))
+        with self.assertRaises(fm.FinamMetaDataError):
+            trigger.initialize()
 
+        trigger = fm.modules.TimeTrigger(
+            out_info=fm.Info(time=None, grid=None, units=None),
+            start=None,
+            step=timedelta(days=1),
+            start_from_input=True,
+        )
+        with self.assertRaises(fm.FinamMetaDataError):
+            trigger.initialize()
+
+        trigger = fm.modules.TimeTrigger(
+            in_info=fm.Info(time=None, grid=None, units=None),
+            start=None,
+            step=timedelta(days=1),
+            start_from_input=False,
+        )
         with self.assertRaises(fm.FinamMetaDataError):
             trigger.initialize()