Is it possible to get locals() and globals() from an upper stack frame?

If I eval something in Python:

eval("a + b")

This will evaluate the expression using the current scope (both locals and globals).

What I am developing requires that an expression be evaluated "later". Such word implies that I want to keep the current scope (i.e. locals() and globals()). But I want to pass such values... transparently, or fetch them from an upper stack frame. Consider this implementation (actually, this one exists):

def __eval(self, expr):
    if isinstance(expr, (list, tuple, set, frozenset, dict, Expression)):
        return Expression.eval(expr, self)
    elif callable(expr):
        try:
            return expr(self)
        except (AttributeError, IndexError, KeyError, TypeError):
            return UNDEFINED
    else:
        try:
            return eval(expr, {}, {'self': self})
        except (AttributeError, IndexError, KeyError, TypeError):
            return UNDEFINED

This implementation is explained as follows:

• If I use an expression object (I actually developed such object), then I evaluate such expression using the current object (after all, this function is a method). This part needs not help, it is fully developed.
• If I use a callable, I execute the callable (e.g. a lambda expression).
• If I use a string, that will be a python expression, and I want such evaluation be performed using the call-time locals() and globals().

I know I could explicitly call:

o._O__eval("self.a + self.b", globals(), locals())
#THIS WOULD REQUIRE to alter the method to allow two additional dict parameters
#NO, I will not call this function directly, but lets follow the example

But I'd like to get such globals() and locals without the user passing it explicitly and make use of such values in the eval.

Question: Is it possible to get the locals() and globals() from an upper stack frame?