code: def _get_merge_keys(self):
      # note this function has side effects
      (left_join_keys, right_join_keys, join_names) = super(
          _AsOfMerge, self
      )._get_merge_keys()
  
      # validate index types are the same
      for i, (lk, rk) in enumerate(
          zip(left_join_keys, right_join_keys)
      ):
          if not is_dtype_equal(lk.dtype, rk.dtype):
              raise MergeError(
                  "incompatible merge keys [{i}] {lkdtype} and "
                  "{rkdtype}, must be the same type".format(
                      i=i, lkdtype=lk.dtype, rkdtype=rk.dtype
                  )
              )
  
      # validate tolerance; must be a Timedelta if we have a DTI
      if self.tolerance is not None:
          if self.left_index:
              lt = self.left.index
          else:
              lt = left_join_keys[-1]
  
          msg = (
              "incompatible tolerance {tolerance}, must be compat "
              "with type {lkdtype}".format(
                  tolerance=type(self.tolerance), lkdtype=lt.dtype
              )
          )
  
          if is_datetime64_dtype(lt) or is_datetime64tz_dtype(lt):
              if not isinstance(self.tolerance, Timedelta):
                  raise MergeError(msg)
              if self.tolerance < Timedelta(0):
                  raise MergeError("tolerance must be positive")
  
          elif is_int64_dtype(lt):
              if not is_integer(self.tolerance):
                  raise MergeError(msg)
              if self.tolerance < 0:
                  raise MergeError("tolerance must be positive")
  
          elif is_float_dtype(lt):
              if not is_number(self.tolerance):
                  raise MergeError(msg)
              if self.tolerance < 0:
                  raise MergeError("tolerance must be positive")
  
          else:
              raise MergeError(
                  "key must be integer, timestamp or float"
              )
  
      # validate allow_exact_matches
      if not is_bool(self.allow_exact_matches):
          msg = "allow_exact_matches must be boolean, passed {passed}"
          raise MergeError(msg.format(passed=self.allow_exact_matches))
  
      return left_join_keys, right_join_keys, join_names
  
imports: import copy
  import string
  import warnings
  import numpy
  from pandas._libs import hashtable, join, lib
  import pandas.compat
  from pandas.compat import filter, lzip, map, range, zip
  from pandas.errors import MergeError
  from pandas.util._decorators import Appender, Substitution
  from pandas.core.dtypes.common import ensure_float64, ensure_int64, ensure_object, is_array_like, is_bool, is_bool_dtype, is_categorical_dtype, is_datetime64_dtype, is_datetime64tz_dtype, is_datetimelike, is_dtype_equal, is_extension_array_dtype, is_float_dtype, is_int64_dtype, is_integer, is_integer_dtype, is_list_like, is_number, is_numeric_dtype, is_object_dtype, needs_i8_conversion
  from pandas.core.dtypes.missing import isnull, na_value_for_dtype
  from pandas import Categorical, DataFrame, Index, MultiIndex, Series, Timedelta
  import pandas.core.algorithms
  from pandas.core.arrays.categorical import _recode_for_categories
  import pandas.core.common
  from pandas.core.frame import _merge_doc
  from pandas.core.internals import concatenate_block_managers, items_overlap_with_suffix
  import pandas.core.sorting
  from pandas.core.sorting import is_int64_overflow_possible
label_desc: Use image node_id 4 for calling the _AsOfMerge obj's underlying member method code with example usage: obj._get_merge_keys() and returns: left_join_keys,  right_join_keys,  join_names