class_docstr: Wrapper over ``Basic`` instances to call predicate query by
  ``.is_[...]`` property
  
  Parameters
  ==========
  
  expr : Basic
  
  assumptions : Boolean, optional
  
  Examples
  ========
  
  >>> from sympy import Q, Symbol
  >>> from sympy.assumptions.wrapper import AssumptionsWrapper
  >>> x = Symbol('x', even=True)
  >>> AssumptionsWrapper(x).is_integer
  True
  >>> y = Symbol('y')
  >>> AssumptionsWrapper(y, Q.even(y)).is_integer
  True
  
  With ``AssumptionsWrapper``, both evaluation and refinement can be supported
  by single implementation.
  
  >>> from sympy import Function
  >>> class MyAbs(Function):
  ...     @classmethod
  ...     def eval(cls, x, assumptions=True):
  ...         _x = AssumptionsWrapper(x, assumptions)
  ...         if _x.is_nonnegative:
  ...             return x
  ...         if _x.is_negative:
  ...             return -x
  ...     def _eval_refine(self, assumptions):
  ...         return MyAbs.eval(self.args[0], assumptions)
  >>> MyAbs(x)
  MyAbs(x)
  >>> MyAbs(x).refine(Q.positive(x))
  x
  >>> MyAbs(Symbol('y', negative=True))
  -y
code: def __new__(cls, expr, assumptions=None):
      if assumptions is None:
          return expr
      obj = super().__new__(cls, expr, _sympify(assumptions))
      obj.expr = expr
      obj.assumptions = assumptions
      return obj
  
file_path: sympy/sympy/assumptions/wrapper.py
imports: from sympy.assumptions import ask, Q
  from sympy.core.basic import Basic
  from sympy.core.sympify import _sympify
label_desc: Use image node_id 1 for calling the AssumptionsWrapper obj's underlying member method code with example usage: obj.__new__(cls, expr, assumptions) and returns: obj, expr