code: def _compare_eq_any(
      left: Any, right: Any, verbose: int = 0
  ) -> List[str]:
      explanation = []
      if istext(left) and istext(right):
          explanation = _diff_text(left, right, verbose)
      else:
          from _pytest.python_api import ApproxBase
  
          if isinstance(left, ApproxBase) or isinstance(
              right, ApproxBase
          ):
              # Although the common order should be obtained == expected, this ensures both ways
              approx_side = (
                  left if isinstance(left, ApproxBase) else right
              )
              other_side = (
                  right if isinstance(left, ApproxBase) else left
              )
  
              explanation = approx_side._repr_compare(other_side)
          elif type(left) == type(right) and (
              isdatacls(left) or isattrs(left) or isnamedtuple(left)
          ):
              # Note: unlike dataclasses/attrs, namedtuples compare only the
              # field values, not the type or field names. But this branch
              # intentionally only handles the same-type case, which was often
              # used in older code bases before dataclasses/attrs were available.
              explanation = _compare_eq_cls(left, right, verbose)
          elif issequence(left) and issequence(right):
              explanation = _compare_eq_sequence(left, right, verbose)
          elif isset(left) and isset(right):
              explanation = _compare_eq_set(left, right, verbose)
          elif isdict(left) and isdict(right):
              explanation = _compare_eq_dict(left, right, verbose)
  
          if isiterable(left) and isiterable(right):
              expl = _compare_eq_iterable(left, right, verbose)
              explanation.extend(expl)
  
      return explanation
  
imports: import collections.abc
  import os
  import pprint
  from typing import AbstractSet
  from typing import Any
  from typing import Callable
  from typing import Iterable
  from typing import List
  from typing import Mapping
  from typing import Optional
  from typing import Sequence
  from unicodedata import normalize
  import _pytest._code
  from _pytest import outcomes
  from _pytest._io.saferepr import _pformat_dispatch
  from _pytest._io.saferepr import saferepr
  from _pytest._io.saferepr import saferepr_unlimited
  from _pytest.config import Config
label_desc: Use image node_id 14 for calling a global function with example usage: _compare_eq_any(left, right, verbose) and returns: explanation