code: def test_secondary_nodes_is_invariant_to_inputs_order(data_setup):
      data = data_setup
      # Preprocess data - determine features columns
      data = DataPreprocessor().obligatory_prepare_for_fit(data)
      train, test = train_test_data_setup(data)
  
      first = PipelineNode(operation_type="logit")
      second = PipelineNode(operation_type="lda")
      third = PipelineNode(operation_type="knn")
      final = PipelineNode(
          operation_type="logit", nodes_from=[first, second, third]
      )
  
      pipeline = Pipeline()
      for node in [first, second, third, final]:
          pipeline.add_node(node)
  
      first = deepcopy(first)
      second = deepcopy(second)
      third = deepcopy(third)
  
      final_shuffled = PipelineNode(
          operation_type="logit", nodes_from=[third, first, second]
      )
  
      pipeline_shuffled = Pipeline()
      # change order of nodes in list
      for node in [final_shuffled, third, first, second]:
          pipeline_shuffled.add_node(node)
  
      train_predicted = pipeline.fit(input_data=train)
  
      train_predicted_shuffled = pipeline_shuffled.fit(input_data=train)
  
      # train results should be invariant
      assert (
          pipeline.root_node.descriptive_id
          == pipeline_shuffled.root_node.descriptive_id
      )
      assert np.equal(
          train_predicted.predict, train_predicted_shuffled.predict
      ).all()
  
      test_predicted = pipeline.predict(input_data=test)
      test_predicted_shuffled = pipeline_shuffled.predict(
          input_data=test
      )
  
      # predict results should be invariant
      assert np.equal(
          test_predicted.predict, test_predicted_shuffled.predict
      ).all()
  
      # change parents order for the nodes fitted pipeline
      nodes_for_change = pipeline.nodes[3].nodes_from
      pipeline.nodes[3].nodes_from = [
          nodes_for_change[2],
          nodes_for_change[0],
          nodes_for_change[1],
      ]
      pipeline.nodes[3].unfit()
      pipeline.fit(train)
      test_predicted_re_shuffled = pipeline.predict(input_data=test)
  
      # predict results should be invariant
      assert np.equal(
          test_predicted.predict, test_predicted_re_shuffled.predict
      ).all()
  
imports: import datetime
  import os
  import platform
  import time
  from copy import deepcopy
  from multiprocessing import set_start_method
  import numpy
  import pytest
  from sklearn.datasets import load_iris
  from fedot.core.data.data import InputData
  from fedot.core.data.data_split import train_test_data_setup
  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, TsForecastingParams
  from fedot.core.utils import probs_to_labels
  from fedot.preprocessing.preprocessing import DataPreprocessor
  from test.integration.composer.test_composer import to_categorical_codes
  from test.integration.models.test_model import classification_dataset_with_redundant_features
  from test.unit.dag.test_graph_operator import get_pipeline
  from test.unit.pipelines.test_pipeline_comparison import pipeline_first
  from test.unit.tasks.test_forecasting import get_ts_data
label_desc: Use image node_id 8 for calling a global function with example usage: test_secondary_nodes_is_invariant_to_inputs_order(data_setup) without return types