code: def test_order_by_data_flow_len_correct():
      """The function checks whether the current version of data flow length
      counters can allow for decompose implementation to determine how the nodes
      in the graph are located
      """
      input_data = get_iris_data()
      input_data = DataPreprocessor().obligatory_prepare_for_fit(
          input_data
      )
  
      data_operations = [
          "scaling",
          "normalization",
          "pca",
          "poly_features",
      ]
      model_operations = ["lda", "knn", "logit"]
      list_with_operations = list(
          product(data_operations, model_operations)
      )
  
      for data_operation, model_operation in list_with_operations:
          # Generate pipeline with different operations in the nodes with decomposition
          pipeline = generate_pipeline_with_decomposition(
              data_operation, model_operation
          )
          pipeline.fit(input_data)
  
          # Get one node with decompose operation in it
          decompose_nodes = pipeline.get_nodes_by_name(
              "class_decompose"
          )
          decompose_node = decompose_nodes[0]
          # Predict from decompose must be the same as predict from Data parent
          dec_output = decompose_node.predict(input_data)
  
          # Get data parent operation for node
          data_node = pipeline.get_nodes_by_name(data_operation)[0]
          data_output = data_node.predict(input_data)
  
          if tuple(data_output.predict.shape) != tuple(
              dec_output.predict.shape
          ):
              raise ValueError(
                  "Data parent is not identified correctly for the decompose operation"
              )
  
imports: from itertools import product
  import numpy
  from examples.simple.classification.classification_with_tuning import get_classification_dataset
  from examples.advanced.decompose.refinement_forecast_example import get_refinement_pipeline
  from fedot.core.data.data import InputData
  from fedot.core.pipelines.node import PipelineNode
  from fedot.core.pipelines.pipeline import Pipeline
  from fedot.core.repository.dataset_types import DataTypesEnum
  from fedot.core.repository.tasks import Task, TaskTypesEnum
  from fedot.preprocessing.preprocessing import DataPreprocessor
  from test.unit.tasks.test_classification import get_iris_data
  from test.unit.tasks.test_forecasting import get_ts_data
  from test.unit.preprocessing.test_preprocessors import data_with_complicated_types
label_desc: Use image node_id 7 for calling a global function with example usage: test_order_by_data_flow_len_correct() without return types