class_docstr: Determines which tensors will be ready when running the graph.
  
  Determines which tensors from `fetches` are ready to run, using following
  algorithm.
  
  1. Determine which table initializers are ready to run.  A table initializer
     is an element of the TABLE_INITIALIZERS collection and it is ready to run
     if all the tensors it depends on are set to ready in
     `replaced_tensors_ready`.
  
  2. Determine which of `fetches` are ready to run.  A fetch is ready to run if
     it only depends on tensors in `feeds` and tensors that are set to ready in
     `replaced_tensors_ready`.
docstr: Get a tuple of table init op and keys for its input ops.
docstr_tok: ["Get","a","tuple","of","table","init","op","and","keys","for","its","input","ops","."]
code: def _get_table_init_op_and_inputs(self, table_init_op_or_tensor):
      """Get a tuple of table init op and keys for its input ops."""
      # If a TF2 exported SavedModel with a table is loaded inside the
      # preprocessing_fn, the TABLE_INITIALIZERS collection of the outer graph
      # contains a Tensor whose parent op is of type StatefulPartitionedCall.
      # The nested func graph for this StatefulPartitionedCall contains the
      # table initializer.
      if (
          isinstance(table_init_op_or_tensor, tf.Tensor)
          and table_init_op_or_tensor.op.type
          == "StatefulPartitionedCall"
      ):
          result = (
              table_init_op_or_tensor.op,
              [
                  input_t.op
                  for input_t in table_init_op_or_tensor.op.inputs
              ],
          )
      else:
          assert isinstance(table_init_op_or_tensor, tf.Operation)
          # We are using the table init op information and the table op information,
          # since that is a unique description of the table op.
          table_ops = []
          for input_t in table_init_op_or_tensor.inputs:
              # One of the inputs to the initializer op should be the table op. If
              # no table op is found, (as in the case of a StatefulPartitionedCall)
              # all inputs are added to the source dict.
              if input_t.dtype == tf.resource:
                  table_ops.append(input_t.op)
          assert len(table_ops) == 1
          result = (table_init_op_or_tensor, [table_ops[0]])
      return result
  
imports: import collections
  import copy
  import hashlib
  import itertools
  from typing import Iterable, List, Mapping, Optional, Set, Union
  import uuid
  from absl import logging
  import tensorflow
  from tensorflow_transform import analyzer_nodes
  from tensorflow_transform import common_types
  from tensorflow_transform import nodes
  from tensorflow_transform import tf_utils
  from tfx_bsl.types import tfx_namedtuple
  from tensorflow.python.framework import composite_tensor
  from tensorflow.python.framework import func_graph
  from tensorflow.python.framework import function_def_to_graph
  from tensorflow.python.util import object_identity
label_desc: Use image node_id 3 for calling the InitializableGraphAnalyzer obj's underlying member method code with example usage: obj._get_table_init_op_and_inputs(table_init_op_or_tensor) and returns: result