code: def assertrepr_compare(config, op, left, right):
      """Return specialised explanations for some operators/operands"""
      width = (
          80 - 15 - len(op) - 2
      )  # 15 chars indentation, 1 space around op
      left_repr = saferepr(left, maxsize=int(width // 2))
      right_repr = saferepr(right, maxsize=width - len(left_repr))
  
      summary = "%s %s %s" % (ecu(left_repr), op, ecu(right_repr))
  
      verbose = config.getoption("verbose")
      explanation = None
      try:
          if op == "==":
              if istext(left) and istext(right):
                  explanation = _diff_text(left, right, verbose)
              else:
                  if 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
                      )
                  elif type(left) == type(right) and (
                      isdatacls(left) or isattrs(left)
                  ):
                      type_fn = (isdatacls, isattrs)
                      explanation = _compare_eq_cls(
                          left, right, verbose, type_fn
                      )
                  elif verbose > 0:
                      explanation = _compare_eq_verbose(left, right)
                  if isiterable(left) and isiterable(right):
                      expl = _compare_eq_iterable(left, right, verbose)
                      if explanation is not None:
                          explanation.extend(expl)
                      else:
                          explanation = expl
          elif op == "not in":
              if istext(left) and istext(right):
                  explanation = _notin_text(left, right, verbose)
      except outcomes.Exit:
          raise
      except Exception:
          explanation = [
              "(pytest_assertion plugin: representation of details failed.  "
              "Probably an object has a faulty __repr__.)",
              six.text_type(_pytest._code.ExceptionInfo.from_current()),
          ]
  
      if not explanation:
          return None
  
      return [summary] + explanation
  
imports: from __future__ import absolute_import
  from __future__ import division
  from __future__ import print_function
  import pprint
  import six
  import _pytest._code
  from ..compat import Sequence
  from _pytest import outcomes
  from _pytest._io.saferepr import saferepr
  from _pytest.compat import ATTRS_EQ_FIELD
label_desc: Use image node_id 12 for calling a global function with example usage: assertrepr_compare(config, op, left, right) and returns: unknown, None