class_docstr: Class which replace Operation class for AtomizedModel object 
class_docstr_tok: ["Class","which","replace","Operation","class","for","AtomizedModel","object"]
code: def metadata(self) -> OperationMetaInfo:
      root_node = self.pipeline.root_node
  
      def extract_metadata_from_pipeline(
          attr_name: str,
          node_filter: Optional[Callable[[PipelineNode], bool]] = None,
          reduce_function: Optional[Callable[[Set], Set]] = None,
      ) -> List[Any]:
          """Extract metadata from atomized pipeline
          :param attr_name: extracting metadata property
          :param node_filter: return True for nodes with extracting metadata
          :param reduce_function: function is used for combining extracted
                                  metadata in ``reduce`` function
          :return: list with extracted metadata
          """
          nodes_to_extract_metadata = self.pipeline.nodes
          if node_filter is not None:
              nodes_to_extract_metadata = [
                  node
                  for node in nodes_to_extract_metadata
                  if node_filter(node)
              ]
          data = [
              set(getattr(node.operation.metadata, attr_name))
              for node in nodes_to_extract_metadata
          ]
          return list(reduce(reduce_function or or_, data))
  
      tags = extract_metadata_from_pipeline("tags")
      input_types = extract_metadata_from_pipeline(
          "input_types",
          node_filter=lambda node: node.is_primary,
          reduce_function=and_,
      )
      output_types = root_node.operation.metadata.output_types
      presets = extract_metadata_from_pipeline("presets")
  
      operation_info = OperationMetaInfo(
          id=root_node.operation.metadata.id,
          input_types=input_types,
          output_types=output_types,
          task_type=root_node.operation.metadata.task_type,
          supported_strategies=None,
          allowed_positions=["any"],
          tags=tags,
          presets=presets,
      )
      return operation_info
  
imports: from collections import Counter
  from datetime import timedelta
  from functools import reduce
  from operator import and_, or_
  from typing import Any, Callable, Dict, List, Optional, Set, Union
  from golem.core.tuning.simultaneous import SimultaneousTuner
  from fedot.core.data.data import InputData, OutputData
  from fedot.core.operations.operation import Operation
  from fedot.core.operations.operation_parameters import OperationParameters
  from fedot.core.pipelines.node import PipelineNode
  from fedot.core.pipelines.pipeline import Pipeline
  from fedot.core.pipelines.tuning.tuner_builder import TunerBuilder
  from fedot.core.repository.metrics_repository import MetricCallable
  from fedot.core.repository.operation_types_repository import OperationMetaInfo, atomized_model_type
label_desc: Use image node_id 6 for calling the AtomizedModel obj's underlying member method code with example usage: obj.metadata() and returns: operation_info, list