Fixed timing issue for lazy inputs (#2890)

backend/src/api/lazy.py

@@ -49,6 +49,7 @@ def __init__(self, factory: Callable[[], T]):
         self._factory = _to_result(factory)
         self._value: _Result[T] | None = None
         self._evaluating = False
+        self._eval_time = 0
 
     @staticmethod
     def ready(value: T) -> Lazy[T]:
@@ -75,12 +76,17 @@ def supplier() -> T:
     @property
     def has_value(self) -> bool:
         """Returns True if the value has been computed, otherwise False."""
-        return self._value is not None
+        return self._value is not None and self._value.is_ok
 
     @property
     def has_error(self) -> bool:
         """Returns True if the value has been computed and it errored instead, otherwise False."""
-        return self._value is not None
+        return self._value is not None and not self._value.is_ok
+
+    @property
+    def evaluation_time(self) -> float:
+        """The time in seconds that it took to evaluate the value. If the value is not computed, returns 0."""
+        return self._eval_time
 
     @property
     def value(self) -> T:
@@ -94,7 +100,9 @@ def value(self) -> T:
             else:
                 self._evaluating = True
                 try:
+                    start = time.time()
                     self._value = self._factory()
+                    self._eval_time = time.time() - start
                 finally:
                     self._evaluating = False
 

backend/src/process.py

@@ -574,10 +574,15 @@ async def __process(self, node: Node) -> NodeOutput | CollectorOutput:
         inputs = await self.__gather_inputs(node)
         context = self.__get_node_context(node)
 
+        def get_lazy_evaluation_time():
+            return sum(i.evaluation_time for i in inputs if isinstance(i, Lazy))
+
         await self.progress.suspend()
         self.__send_node_start(node)
         await self.progress.suspend()
 
+        lazy_time_before = get_lazy_evaluation_time()
+
         output, execution_time = await self.loop.run_in_executor(
             self.pool,
             timed_supplier(
@@ -586,6 +591,9 @@ async def __process(self, node: Node) -> NodeOutput | CollectorOutput:
         )
         await self.progress.suspend()
 
+        lazy_time_after = get_lazy_evaluation_time()
+        execution_time -= lazy_time_after - lazy_time_before
+
         if isinstance(output, RegularOutput):
             await self.__send_node_broadcast(node, output.output)
             self.__send_node_finish(node, execution_time)