code: def default_sort_key(item, order=None):
      """Return a key that can be used for sorting.
  
      The key has the structure:
  
      (class_key, (len(args), args), exponent.sort_key(), coefficient)
  
      This key is supplied by the sort_key routine of Basic objects when
      ``item`` is a Basic object or an object (other than a string) that
      sympifies to a Basic object. Otherwise, this function produces the
      key.
  
      The ``order`` argument is passed along to the sort_key routine and is
      used to determine how the terms *within* an expression are ordered.
      (See examples below) ``order`` options are: 'lex', 'grlex', 'grevlex',
      and reversed values of the same (e.g. 'rev-lex'). The default order
      value is None (which translates to 'lex').
  
      Examples
      ========
  
      >>> from sympy import S, I, default_sort_key, sin, cos, sqrt
      >>> from sympy.core.function import UndefinedFunction
      >>> from sympy.abc import x
  
      The following are equivalent ways of getting the key for an object:
  
      >>> x.sort_key() == default_sort_key(x)
      True
  
      Here are some examples of the key that is produced:
  
      >>> default_sort_key(UndefinedFunction('f'))
      ((0, 0, 'UndefinedFunction'), (1, ('f',)), ((1, 0, 'Number'),
          (0, ()), (), 1), 1)
      >>> default_sort_key('1')
      ((0, 0, 'str'), (1, ('1',)), ((1, 0, 'Number'), (0, ()), (), 1), 1)
      >>> default_sort_key(S.One)
      ((1, 0, 'Number'), (0, ()), (), 1)
      >>> default_sort_key(2)
      ((1, 0, 'Number'), (0, ()), (), 2)
  
      While sort_key is a method only defined for SymPy objects,
      default_sort_key will accept anything as an argument so it is
      more robust as a sorting key. For the following, using key=
      lambda i: i.sort_key() would fail because 2 does not have a sort_key
      method; that's why default_sort_key is used. Note, that it also
      handles sympification of non-string items likes ints:
  
      >>> a = [2, I, -I]
      >>> sorted(a, key=default_sort_key)
      [2, -I, I]
  
      The returned key can be used anywhere that a key can be specified for
      a function, e.g. sort, min, max, etc...:
  
      >>> a.sort(key=default_sort_key); a[0]
      2
      >>> min(a, key=default_sort_key)
      2
  
      Notes
      =====
  
      The key returned is useful for getting items into a canonical order
      that will be the same across platforms. It is not directly useful for
      sorting lists of expressions:
  
      >>> a, b = x, 1/x
  
      Since ``a`` has only 1 term, its value of sort_key is unaffected by
      ``order``:
  
      >>> a.sort_key() == a.sort_key('rev-lex')
      True
  
      If ``a`` and ``b`` are combined then the key will differ because there
      are terms that can be ordered:
  
      >>> eq = a + b
      >>> eq.sort_key() == eq.sort_key('rev-lex')
      False
      >>> eq.as_ordered_terms()
      [x, 1/x]
      >>> eq.as_ordered_terms('rev-lex')
      [1/x, x]
  
      But since the keys for each of these terms are independent of ``order``'s
      value, they do not sort differently when they appear separately in a list:
  
      >>> sorted(eq.args, key=default_sort_key)
      [1/x, x]
      >>> sorted(eq.args, key=lambda i: default_sort_key(i, order='rev-lex'))
      [1/x, x]
  
      The order of terms obtained when using these keys is the order that would
      be obtained if those terms were *factors* in a product.
  
      Although it is useful for quickly putting expressions in canonical order,
      it does not sort expressions based on their complexity defined by the
      number of operations, power of variables and others:
  
      >>> sorted([sin(x)*cos(x), sin(x)], key=default_sort_key)
      [sin(x)*cos(x), sin(x)]
      >>> sorted([x, x**2, sqrt(x), x**3], key=default_sort_key)
      [sqrt(x), x, x**2, x**3]
  
      See Also
      ========
  
      ordered, sympy.core.expr.Expr.as_ordered_factors, sympy.core.expr.Expr.as_ordered_terms
  
      """
      from .basic import Basic
      from .singleton import S
  
      if isinstance(item, Basic):
          return item.sort_key(order=order)
  
      if iterable(item, exclude=str):
          if isinstance(item, dict):
              args = item.items()
              unordered = True
          elif isinstance(item, set):
              args = item
              unordered = True
          else:
              # e.g. tuple, list
              args = list(item)
              unordered = False
  
          args = [default_sort_key(arg, order=order) for arg in args]
  
          if unordered:
              # e.g. dict, set
              args = sorted(args)
  
          cls_index, args = 10, (len(args), tuple(args))
      else:
          if not isinstance(item, str):
              try:
                  item = sympify(item, strict=True)
              except SympifyError:
                  # e.g. lambda x: x
                  pass
              else:
                  if isinstance(item, Basic):
                      # e.g int -> Integer
                      return default_sort_key(item)
                  # e.g. UndefinedFunction
  
          # e.g. str
          cls_index, args = 0, (1, (str(item),))
  
      return (
          (cls_index, 0, item.__class__.__name__),
          args,
          S.One.sort_key(),
          S.One,
      )
  
imports: from collections import defaultdict
  from .sympify import sympify, SympifyError
  from sympy.utilities.iterables import iterable, uniq
label_desc: Use image node_id 1 for calling a global function with example usage: default_sort_key(item, order) and returns: cls_index,  int,  item,  args,  S,  S, item, default_sort_key