class_docstr: A combiner generator built from ConstituentStatsGenerators.
  
  Typical usage involves overriding the __init__, to provide a set of
  constituent generators, and extract_composite_output, to process the outputs
  of those constituent generators. As a toy example, consider:
  
      class ExampleCompositeStatsGenerator(
          stats_generator.CompositeStatsGenerator):
  
        def __init__(self,
                     schema: schema_pb2.Schema,
                     name: Text = 'ExampleCompositeStatsGenerator'
                     ) -> None:
          # custom logic to build the set of relevant constituents
          self._paths = [types.FeaturePath(['f1']), types.FeaturePath(['f2'])]
          constituents = [CountMissingCombiner(p) for p in self._paths]
  
          # call super class init with constituents
          super(ExampleCompositeStatsGenerator, self).__init__(
             name, constituents, schema)
  
        def extract_composite_outputs(self, accumulator):
          # custom logic to convert constituent outputs to stats proto
          stats = statistics_pb2.DatasetFeatureStatistics()
          for path in self._paths:
            # lookup output from a particular combiner using the key() function,
            # which typically takes the same args as __init__.
            num_missing = accumulator[CountMissingCombiner.key(path)]
            stats.features.add(path=path).custom_stats.add(
                name='num_missing', num=count_missing)
  
  This class is very similar to the SingleInputTupleCombineFn and adds two small
  features:
    1) The input value passed to add_inputs is wrapped in an InputBatch object
       before being passed on to the constituent generators.
    2) The API for providing constituents and retrieving their outputs is a dict
       rather than a tuple, which makes it easier to keep track of which output
       came from which constituent generator.
code: def add_input(
      self,
      accumulator: List[CONSTITUENT_ACCTYPE],
      input_record_batch: pa.RecordBatch,
  ) -> List[CONSTITUENT_ACCTYPE]:
      batch = input_batch.InputBatch(input_record_batch)
      return [
          c.add_input(a, batch)
          for c, a in zip(self._constituents, accumulator)
      ]
  
imports: from __future__ import absolute_import
  from __future__ import division
  from __future__ import print_function
  import abc
  from typing import Any, Dict, Generic, Hashable, Iterable, List, Optional, Text, TypeVar
  import apache_beam
  import pyarrow
  from tensorflow_data_validation import types
  from tensorflow_data_validation.statistics.generators import input_batch
  from tensorflow_metadata.proto.v0 import schema_pb2
  from tensorflow_metadata.proto.v0 import statistics_pb2
label_desc: Use image node_id 4 for calling the CompositeStatsGenerator obj's underlying member method code with example usage: obj.add_input(accumulator, input_record_batch) and returns: unknown