import sys
from inspect import getsource
from textwrap import dedent

class ImplicitThisPrivateSingletonType(type):

    def __new__(metaclass, name, bases, attrs):
        context = globals()
        func_type = type(metaclass.__new__)
        private = {'object': None}

        class ContextWrapper(dict):

            __getitem__ = context.__getitem__
            __setitem__ = context.__setitem__
            __delitem__ = context.__delitem__

        context = ContextWrapper()
        for key, val in attrs.iteritems():
            if isinstance(val, func_type):
                try:
                    saved = context[key]
                    restore = True
                except KeyError:
                    restore = False
                exec compile(dedent(getsource(val)).replace('(', '(this,', 1), metaclass.__name__, 'exec') in context
                attrs[key] = context[key]
                if restore:
                    context[key] = saved
                else:
                    del context[key]

        def new_object(cls, *args, **kwargs):
            if private['object'] is None:
                private['object'] = bases[0].__new__(cls)
                private['attrs'] = {}
                if hasattr(private['object'], 'new'):
                    private['object'].new(*args, **kwargs)
            return private['object']

        def check_access():
            frame = sys._getframe(2)
            code = frame.f_code
            if (frame.f_globals is not context or code.co_filename != metaclass.__name__ or code.co_firstlineno != 1 or
                code.co_name not in attrs or not code.co_varnames or code.co_varnames[0] != 'this'):
                raise AttributeError('private')

        def get_attr(self, attr):
            if attr in private['attrs']:
                check_access()
                return private['attrs'][attr]
            return bases[0].__getattribute__(self, attr)

        def set_attr(self, attr, val):
            check_access()
            private['attrs'][attr] = val

        attrs['__slots__'] = ()
        attrs['__new__'] = new_object
        attrs['__getattribute__'] = get_attr
        attrs['__setattr__'] = set_attr
        return super(ImplicitThisPrivateSingletonType, metaclass).__new__(metaclass, name, bases, attrs)


class ObfuscatedImplicitThisPrivateSingletonType(type):
    def __new__(m,n,b,a):
        c,p=globals(),{}
        c=type('',(dict,),{'__getitem__':c.__getitem__,'__setitem__':c.__setitem__,'__delitem__':c.__delitem__})()
        for k,v in a.items():
            if isinstance(v,type(m.__new__)):
                s,r=(c[k],1) if k in c else 0,0
                exec compile(dedent(getsource(v)).replace('(','(this,',1),m.__name__,'exec')in c
                a.__setitem__(k,c[k])or(c.__setitem__(k,s)if r else c.__delitem__(k))
        def o(z,*x,**y):
            if 0 not in p:
                p[0],p[1]=b[0].__new__(z),{}
                if hasattr(p[0],'new'):p[0].new(*x,**y)
            return p[0]
        def q():
            f=sys._getframe(2)
            if f.f_globals is not c or f.f_code.co_filename!=m.__name__ or f.f_code.co_firstlineno!=1 or f.f_code.co_name not in a or not f.f_code.co_varnames or f.f_code.co_varnames[0]!='this':raise AttributeError('private')
        a['__slots__'],a['__new__'],a['__getattribute__'],a['__setattr__']=(),o,lambda s,a:q()or p[1][a] if a in p[1] else b[0].__getattribute__(s,a),lambda s,a,v:q() or p[1].__setitem__(a,v)
        return type(n,b,a)