This is a bit vague, I'm afraid, but is there any way for me to take
code like:

   a = Foo()
   beta = Bar()

and somehow attach the string "a" to the Foo instance and "beta" to
the Bar instance.  At some later point in the program I want to be
able to look at the Bar instance and say to the user "this was called
beta in your routine".

The motivation is debugging an embedded domain specific language and
the solution has to be cross platform for Python 3+ (bonus points for
Python 2 too).

Obviously I can parse the code, but I was wondering if there was some
other (no doubt terribly hacky) approach.  Even some idea of what to
google for would be a help...

For example, I assume it's possible to somehow access the dictionary
for the current block, but I can't see how to do this after
assignment.  If I do it in the Foo constructor, for example, "a" will
not yet be bound.

On Sep 23, 8:15 pm, andrew cooke <and...@acooke.org> wrote:

class Foo(object):
   def __init__(self, name):
     self.name = name
     # ...and anything else

a = Foo('a')

The problem is that objects can have more than one name at a time,
and that assignment targets can be more than simple names.  What
would you want to say about:

eggs[42] = Foo()
beans['spam'] = Foo()
chips.spam = Foo()
spam[eggs.beans['chips']] = Foo()
spam.append(Foo())

and so on.

The thing to google for is Python's assignment model, because it's
probably not what you think it is.

I'm not sure you can access the namespace dictionary of the "current
block" (module?), that's the problem.  Oh, except via locals(), which
might do exactly what you're after depending.  Excuse me, I'm being
very dim tonight.

You could write a function that the user could voluntarily call at the
end of his function, that would find all symbols of a specified kind,
and store the kind of information you're asking about.  But of course,
some class instances should not be added to, and some cannot.  So you'd
need some form of filter to indicate which ones to do.

In the sample below, I'll assume you want to do this for all classes
derived from Mybase.

(untested):

def label_stuff(symbols):
    for symbol in symbols:
        if  isinstance(symbols[symbol], Mybase):
            symbols[symbol].bind_name = symbol

And the user would simply make a call at the end of each such function,
like:

import sys

class Foo(object):

    def __rlshift__(self, name):
        try:
            raise Exception()
        except:
            locals = sys.exc_traceback.tb_frame.f_back.f_locals
            locals[name] = self

if __name__ == '__main__':
    foo = Foo()
    'a' << foo
    print(a)

There's few things worse than unreliable tools that break just when
you've come to rely on them.

@contextlib.contextmanager
def capture_changed_bindings():
    before = sys._getframe(2).f_locals.copy()
    changed = {}
    yield changed
    after = sys._getframe(2).f_locals
    for key,value in after.iteritems():
        if value is changed:
            continue
        if key not in before or value is not before[key]:
            changed[key] = value

def test():
    a = 2
    b = 3
    c = 4
    with capture_changed_bindings() as changed:
        b = 5
        c = 4
        d = 6
    print changed

test()

Quick and dirty, not robust at all.  But you get the idea.

BTW, if you are desperate to do this then I'd say you lack good
perspective.  You are subverting some of the most basic behavior of
Python here for something of marginal and only occasional usefulness.
If you are that desperate just retype the name, it won't be the end of
the world.

a = Foo('a')

The reason I asked for "unreliable half-baked" solutions is that I am
exploring what might be possible and, in my experience, this group
prefers to lecture me on what they think I should do rather than
answer the damn question.  I was hoping that by explicitly saying that
reliability is not important, people might feel more free to give
"wild" ideas that I could learn from and improve on.

It's significant, depressing, and not at all surprising that every
person who replied to this thread told me, in one way or another, that
was I was asking was wrong or impossible or foolhardy.

If I want your advice on how to write popular tools, you can be sure I
will come and ask you for it.  That is not what I asked for here.

But since we're all passing round unsolicited advice, here's some from
me.

Being an anal retentive will get you a long way in programming.
Dotting the "i"s and crossing the "t"s is 99% of what it's all about.
I agree.  But the last 1% requires a little bit of imagination.  You
should try it one day.

If you want always friendly, enabling advice I'm sure there are good
support services out there who would be happy not to second-guess you
for a fee.

Otherwise, grow thicker skin.