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``.
docstr: Create new instance of own class with args exactly as provided by
  caller but returning the self class identity if args is empty.
  
  Examples
  ========
  
     This is handy when we want to optimize things, e.g.
  
         >>> from sympy import Mul, S
         >>> from sympy.abc import x, y
         >>> e = Mul(3, x, y)
         >>> e.args
         (3, x, y)
         >>> Mul(*e.args[1:])
         x*y
         >>> e._new_rawargs(*e.args[1:])  # the same as above, but faster
         x*y
  
     Note: use this with caution. There is no checking of arguments at
     all. This is best used when you are rebuilding an Add or Mul after
     simply removing one or more args. If, for example, modifications,
     result in extra 1s being inserted they will show up in the result:
  
         >>> m = (x*y)._new_rawargs(S.One, x); m
         1*x
         >>> m == x
         False
         >>> m.is_Mul
         True
  
     Another issue to be aware of is that the commutativity of the result
     is based on the commutativity of self. If you are rebuilding the
     terms that came from a commutative object then there will be no
     problem, but if self was non-commutative then what you are
     rebuilding may now be commutative.
  
     Although this routine tries to do as little as possible with the
     input, getting the commutativity right is important, so this level
     of safety is enforced: commutativity will always be recomputed if
     self is non-commutative and kwarg `reeval=False` has not been
     passed.
docstr_tok: ["Create","new","instance","of","own","class","with","args","exactly","as","provided","by","caller","but","returning","the","self","class","identity","if","args","is","empty",".","Examples","========","This","is","handy","when","we","want","to","optimize","things",",","e.g",".",">",">",">","from","sympy","import","Mul",",","S",">",">",">","from","sympy.abc","import","x",",","y",">",">",">","e","=","Mul","(","3",",","x",",","y",")",">",">",">","e.args","(","3",",","x",",","y",")",">",">",">","Mul","(","*","e.args","[","1",":","]",")","x","*","y",">",">",">","e._new_rawargs","(","*","e.args","[","1",":","]",")","#","the","same","as","above",",","but","faster","x","*","y","Note",":","use","this","with","caution",".","There","is","no","checking","of","arguments","at","all",".","This","is","best","used","when","you","are","rebuilding","an","Add","or","Mul","after","simply","removing","one","or","more","args",".","If",",","for","example",",","modifications",",","result","in","extra","1s","being","inserted","they","will","show","up","in","the","result",":",">",">",">","m","=","(","x","*","y",")","._new_rawargs","(","S.One",",","x",")",";","m","1","*","x",">",">",">","m","==","x","False",">",">",">","m.is_Mul","True","Another","issue","to","be","aware","of","is","that","the","commutativity","of","the","result","is","based","on","the","commutativity","of","self",".","If","you","are","rebuilding","the","terms","that","came","from","a","commutative","object","then","there","will","be","no","problem",",","but","if","self","was","non-commutative","then","what","you","are","rebuilding","may","now","be","commutative",".","Although","this","routine","tries","to","do","as","little","as","possible","with","the","input",",","getting","the","commutativity","right","is","important",",","so","this","level","of","safety","is","enforced",":","commutativity","will","always","be","recomputed","if","self","is","non-commutative","and","kwarg","`","reeval=False","`","has","not","been","passed","."]
code: def _new_rawargs(self, *args, reeval=True, **kwargs):
      """Create new instance of own class with args exactly as provided by
      caller but returning the self class identity if args is empty.
  
      Examples
      ========
  
         This is handy when we want to optimize things, e.g.
  
             >>> from sympy import Mul, S
             >>> from sympy.abc import x, y
             >>> e = Mul(3, x, y)
             >>> e.args
             (3, x, y)
             >>> Mul(*e.args[1:])
             x*y
             >>> e._new_rawargs(*e.args[1:])  # the same as above, but faster
             x*y
  
         Note: use this with caution. There is no checking of arguments at
         all. This is best used when you are rebuilding an Add or Mul after
         simply removing one or more args. If, for example, modifications,
         result in extra 1s being inserted they will show up in the result:
  
             >>> m = (x*y)._new_rawargs(S.One, x); m
             1*x
             >>> m == x
             False
             >>> m.is_Mul
             True
  
         Another issue to be aware of is that the commutativity of the result
         is based on the commutativity of self. If you are rebuilding the
         terms that came from a commutative object then there will be no
         problem, but if self was non-commutative then what you are
         rebuilding may now be commutative.
  
         Although this routine tries to do as little as possible with the
         input, getting the commutativity right is important, so this level
         of safety is enforced: commutativity will always be recomputed if
         self is non-commutative and kwarg `reeval=False` has not been
         passed.
      """
      if reeval and self.is_commutative is False:
          is_commutative = None
      else:
          is_commutative = self.is_commutative
      return self._from_args(args, is_commutative)
  
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 3 for calling the AssocOp obj's underlying member method code with example usage: obj._new_rawargs() and returns: self