Private name mangling function

Is there a function in the Python standard library to reproduce Python's name mangling scheme with a "private" attribute name? It seems like there would be, but I can't find it for the life of me.

I wrote this, but if there's a better way I'm all ears.

def mangle_name (cls, attrname) :
    prefix = '_' + cls.__name__.lstrip('_')

    if not attrname.startswith('__') :
        attrname = '__' + attrname

    if not attrname.endswith('__') :
        return prefix + attrname
    else :
        return attrname

class Foo :
    __some_such = 3

name = mangle_name(Foo, '__some_such')
print name
print hasattr(Foo(), name)

It looks like the compiler module has a Python implementation for this, the signature is mangle(name, klass) where klass is the class name, not the object itself.

Here is how you can access and use it:

>>> from compiler.misc import mangle
>>> mangle('__some_such', 'Foo')
'_Foo__some_such'

Note that the compiler module is deprecated since Python 2.6 and does not exist in Python 3.0.

Here is the function itself (from Python 2.7 source code) in case you just want to copy it into your source or verify that your version is equivalent:

MANGLE_LEN = 256 # magic constant from compile.c

def mangle(name, klass):
    if not name.startswith('__'):
        return name
    if len(name) + 2 >= MANGLE_LEN:
        return name
    if name.endswith('__'):
        return name
    try:
        i = 0
        while klass[i] == '_':
            i = i + 1
    except IndexError:
        return name
    klass = klass[i:]

    tlen = len(klass) + len(name)
    if tlen > MANGLE_LEN:
        klass = klass[:MANGLE_LEN-tlen]

    return "_%s%s" % (klass, name)