class_docstr: Associative operations, can separate noncommutative and
  commutative parts.
  
  (a op b) op c == a op (b op c) == a op b op c.
  
  Base class for Add and Mul.
  
  This is an abstract base class, concrete derived classes must define
  the attribute `identity`.
  
  .. deprecated:: 1.7
  
     Using arguments that aren't subclasses of :class:`~.Expr` in core
     operators (:class:`~.Mul`, :class:`~.Add`, and :class:`~.Pow`) is
     deprecated. See :ref:`non-expr-args-deprecated` for details.
  
  Parameters
  ==========
  
  *args :
      Arguments which are operated
  
  evaluate : bool, optional
      Evaluate the operation. If not passed, refer to ``global_parameters.evaluate``.
code: def __new__(cls, *args, evaluate=None, _sympify=True):
      # Allow faster processing by passing ``_sympify=False``, if all arguments
      # are already sympified.
      if _sympify:
          args = list(map(_sympify_, args))
  
      # Disallow non-Expr args in Add/Mul
      typ = cls._args_type
      if typ is not None:
          from .relational import Relational
  
          if any(isinstance(arg, Relational) for arg in args):
              raise TypeError(
                  "Relational cannot be used in %s" % cls.__name__
              )
  
          # This should raise TypeError once deprecation period is over:
          for arg in args:
              if not isinstance(arg, typ):
                  sympy_deprecation_warning(
                      f"""
  
  Using non-Expr arguments in {cls.__name__} is deprecated (in this case, one of
  the arguments has type {type(arg).__name__!r}).
  
  If you really did intend to use a multiplication or addition operation with
  this object, use the * or + operator instead.
  
                          """,
                      deprecated_since_version="1.7",
                      active_deprecations_target="non-expr-args-deprecated",
                      stacklevel=4,
                  )
  
      if evaluate is None:
          evaluate = global_parameters.evaluate
      if not evaluate:
          obj = cls._from_args(args)
          obj = cls._exec_constructor_postprocessors(obj)
          return obj
  
      args = [a for a in args if a is not cls.identity]
  
      if len(args) == 0:
          return cls.identity
      if len(args) == 1:
          return args[0]
  
      c_part, nc_part, order_symbols = cls.flatten(args)
      is_commutative = not nc_part
      obj = cls._from_args(c_part + nc_part, is_commutative)
      obj = cls._exec_constructor_postprocessors(obj)
  
      if order_symbols is not None:
          from sympy.series.order import Order
  
          return Order(obj, *order_symbols)
      return obj
  
imports: from __future__ import annotations
  from operator import attrgetter
  from collections import defaultdict
  from sympy.utilities.exceptions import sympy_deprecation_warning
  from .sympify import _sympify, sympify
  from .basic import Basic
  from .cache import cacheit
  from .sorting import ordered
  from .logic import fuzzy_and
  from .parameters import global_parameters
  from sympy.utilities.iterables import sift
  from sympy.multipledispatch.dispatcher import Dispatcher, ambiguity_register_error_ignore_dup, str_signature, RaiseNotImplementedError
label_desc: Use image node_id 1 for calling the AssocOp obj's underlying member method code with example usage: obj.__new__(cls) and returns: obj, obj, cls, args, Order