class_docstr: Base class used for composite model structure definition
  
  Args:
      nodes: :obj:`PipelineNode` object(s)
      use_input_preprocessing: whether to do input preprocessing or not, ``True`` by default.
docstr: Runs training process in all the pipeline nodes starting with root with time limit.
  
  Todo:
      unresolved sentence
  
  Args:
      input_data: data used for operations training
      time: time constraint for operations fitting process (in minutes)
  
  Returns:
      OutputData: values predicted on the provided ``input_data``
docstr_tok: ["Runs","training","process","in","all","the","pipeline","nodes","starting","with","root","with","time","limit",".","Todo",":","unresolved","sentence","Args",":","input_data",":","data","used","for","operations","training","time",":","time","constraint","for","operations","fitting","process","(","in","minutes",")","Returns",":","OutputData",":","values","predicted","on","the","provided","``","input_data","``"]
code: def _fit_with_time_limit(
      self, input_data: Optional[InputData], time: timedelta
  ) -> OutputData:
      """Runs training process in all the pipeline nodes starting with root with time limit.
  
      Todo:
          unresolved sentence
  
      Args:
          input_data: data used for operations training
          time: time constraint for operations fitting process (in minutes)
  
      Returns:
          OutputData: values predicted on the provided ``input_data``
      """
  
      time = int(time.total_seconds())
      process_state_dict = {}
      fitted_operations = []
      try:
          func_timeout.func_timeout(
              time,
              self._fit,
              args=(input_data, process_state_dict, fitted_operations),
          )
      except func_timeout.FunctionTimedOut:
          raise TimeoutError(
              f"Pipeline fitness evaluation time limit is expired (more then {time} seconds)"
          )
  
      self.computation_time = process_state_dict[
          "computation_time_in_seconds"
      ]
      for node_num, _ in enumerate(self.nodes):
          self.nodes[node_num].fitted_operation = fitted_operations[
              node_num
          ]
      return process_state_dict["train_predicted"]
  
imports: from copy import deepcopy
  from datetime import timedelta
  from os import PathLike
  from typing import Optional, Tuple, Union, Sequence, List, Dict
  import func_timeout
  from golem.core.dag.graph import Graph
  from golem.core.dag.graph_delegate import GraphDelegate
  from golem.core.dag.graph_node import GraphNode
  from golem.core.dag.graph_utils import distance_to_primary_level, graph_structure
  from golem.core.dag.linked_graph import LinkedGraph
  from golem.core.log import default_log
  from golem.core.optimisers.timer import Timer
  from golem.core.paths import copy_doc
  from golem.utilities.serializable import Serializable
  from golem.visualisation.graph_viz import NodeColorType
  from fedot.core.caching.pipelines_cache import OperationsCache
  from fedot.core.caching.preprocessing_cache import PreprocessingCache
  from fedot.core.data.data import InputData, OutputData
  from fedot.core.data.multi_modal import MultiModalData
  from fedot.core.operations.data_operation import DataOperation
  from fedot.core.operations.model import Model
  from fedot.core.pipelines.node import PipelineNode
  from fedot.core.pipelines.template import PipelineTemplate
  from fedot.core.repository.tasks import TaskTypesEnum
  from fedot.core.visualisation.pipeline_specific_visuals import PipelineVisualizer
  from fedot.preprocessing.dummy_preprocessing import DummyPreprocessor
  from fedot.preprocessing.preprocessing import DataPreprocessor
label_desc: Use image node_id 3 for calling the Pipeline obj's underlying member method code with example usage: obj._fit_with_time_limit(input_data, time) and returns: process_state_dict