class_docstr: The class defines the interface of nodes modifying tha data flow in the :class:`Pipeline`
  
  Args:
      operation_type: operation defined in the operation repository
      nodes_from: parent nodes where data comes from
      node_data: ``dict`` with :class:`InputData` for fit and predict stage
      kwargs: optional arguments (i.e. logger)
code: def __init__(
      self,
      operation_type: Optional[Union[str, Operation]] = None,
      nodes_from: Optional[List[PipelineNode]] = None,
      node_data: Optional[dict] = None,
      **kwargs,
  ):
      if node_data is None:
          self._node_data = {}
          self.direct_set = False
      else:
          self._node_data = node_data
          # Was the data passed directly to the node or not
          self.direct_set = True
  
      passed_content = kwargs.get("content")
      if passed_content:
          # Define operation, based on content dictionary
          operation = self._process_content_init(passed_content)
          params = passed_content.get("params", {})
          self.metadata = passed_content.get("metadata", NodeMetadata())
      else:
          # There is no content for node
          operation = self._process_direct_init(operation_type)
  
          # Define operation with default parameters
          params = {}
          self.metadata = NodeMetadata()
  
      self.fit_time_in_seconds = 0
      self.inference_time_in_seconds = 0
  
      super().__init__(
          content={"name": operation}, nodes_from=nodes_from
      )
      # use parameters.setter to process input parameters correctly
      self.parameters = params
  
      self.log = default_log(self)
      self._fitted_operation = None
      self.rating = None
  
imports: from __future__ import annotations
  from dataclasses import dataclass
  from typing import Any, List, Optional, Tuple, Union
  import numpy
  from golem.core.dag.linked_graph_node import LinkedGraphNode
  from golem.core.log import default_log
  from golem.core.optimisers.timer import Timer
  from golem.serializers.serializer import register_serializable
  from fedot.core.data.data import InputData, OutputData
  from fedot.core.data.merge.data_merger import DataMerger
  from fedot.core.operations.factory import OperationFactory
  from fedot.core.operations.operation import Operation
  from fedot.core.operations.operation_parameters import OperationParameters
  from fedot.core.repository.operation_types_repository import OperationTypesRepository
  from fedot.core.utils import DEFAULT_PARAMS_STUB, NESTED_PARAMS_LABEL
label_desc: Use image node_id 1 to create a new PipelineNode object from inherited base classes: LinkedGraphNode with example: obj = PipelineNode(operation_type, nodes_from, node_data)