self не имеет атрибута

import multithreading
 
import datetime
 
import json
 
from collections import namedtuple
Event = namedtuple('Event', 'window type time keyname keystate')
Event.__new__.__defaults__ = (None, None)
 
import __main__, os
file = __main__.__file__
 
import ctypes
import ctypes.wintypes as wintypes
 
kernel32 = ctypes.windll.kernel32
user32 = ctypes.windll.user32
gdi32 = ctypes.windll.gdi32
 
CW_USEDEFAULT = -2147483648
IDI_APPLICATION = 32512
WS_OVERLAPPEDWINDOW = 13565952
 
CS_HREDRAW = 2
CS_VREDRAW = 1
 
IDC_ARROW = 32512
WHITE_BRUSH = 0
 
SW_SHOWNORMAL = 1
 
counter = -1;
 
WNDPROC = ctypes.WINFUNCTYPE(
    ctypes.c_long,
    ctypes.c_int,
    ctypes.c_uint,
    ctypes.c_int,
    ctypes.c_int,
)
 
class WNDCLASS(ctypes.Structure):
    _fields_ = [('style',         ctypes.c_uint),
                ('lpfnWndProc',   WNDPROC),
                ('cbClsExtra',    ctypes.c_int),
                ('cbWndExtra',    ctypes.c_int),
                ('hInstance',     ctypes.c_int),
                ('hIcon',         ctypes.c_int),
                ('hCursor',       ctypes.c_int),
                ('hbrBackground', ctypes.c_int),
                ('lpszMenuName',  ctypes.c_wchar_p),
                ('lpszClassName', ctypes.c_wchar_p)]
 
class POINT(ctypes.Structure):
    _fields_ = [('x', ctypes.c_long),
                ('y', ctypes.c_long)]
 
class MSG(ctypes.Structure):
    _fields_ = [('hwnd',    ctypes.c_int),
                ('message', ctypes.c_uint),
                ('wParam',  ctypes.c_int),
                ('lParam',  ctypes.c_int),
                ('time',    ctypes.c_int),
                ('pt',      POINT)]
 
class __WindowMethods__():
    def show(self):
        def show():
            user32.ShowWindow(ctypes.c_int(self.__hWnd__), ctypes.c_int(8))
            user32.UpdateWindow(ctypes.c_int(self.__hWnd__))
        self.__thread__.call(show);
    def hide(self):
        def hide():
            user32.ShowWindow(ctypes.c_int(self.__hWnd__), ctypes.c_int(0))
        self.__thread__.call(hide);
class Window():
    with open(os.path.split(__file__)[0] + '\\events.json') as events_json:
        __events__ = json.loads(events_json.read());
    __pressed__ = [];
    def __procedure__(self, hWnd, message, wParam, lParam):
        if message == 2:
            self.__thread__.end();
            user32.PostQuitMessage(0);
            for name in set(dir(self)) - set(dir(type('type', (), {}))):
                setattr(self, name, None);
                delattr(self, name);
            return 0;
        elif message == 256:
            keyname = Window.__events__[str(wParam)];
            if keyname not in self.__pressed__:
                self.__pressed__.append(keyname);
                for function in self.listener['ANY']:
                    function.__globals__['event'] = Event(self, 'keypress', datetime.datetime.now().time(), keyname, 'DOWN');
                    function();
                for function in self.listener[keyname]:
                    function.__globals__['event'] = Event(self, 'keypress', datetime.datetime.now().time(), keyname, 'DOWN');
                    function();
            return 0;
        elif message == 257:
            keyname = Window.__events__[str(wParam)];
            self.__pressed__.remove(keyname);
            for function in self.listener['ANY']:
                function.__globals__['event'] = Event(self, 'keypress', datetime.datetime.now().time(), keyname, 'UP');
                function();
            for function in self.listener[keyname]:
                function.__globals__['event'] = Event(self, 'keypress', datetime.datetime.now().time(), keyname, 'UP');
                function();
            return 0;
        return user32.DefWindowProcW(ctypes.c_int(hWnd), ctypes.c_int(message), ctypes.c_int(wParam), ctypes.c_int(lParam));
    
    __wndclass__ = WNDCLASS()
    __wndclass__.style          = CS_HREDRAW | CS_VREDRAW
    __wndclass__.cbClsExtra     = 0
    __wndclass__.cbWndExtra     = 0
    __wndclass__.hInstance      = kernel32.GetModuleHandleW(ctypes.c_int(0))
    __wndclass__.hIcon          = user32.LoadIconW(ctypes.c_int(0), ctypes.c_int(IDI_APPLICATION))
    __wndclass__.hCursor        = user32.LoadCursorW(ctypes.c_int(0), ctypes.c_int(IDC_ARROW))
    __wndclass__.hbrBackground  = gdi32.GetStockObject(ctypes.c_int(0))
    __wndclass__.lpszMenuName   = None
    
    def __init__(self, title):
        global counter
        counter += 1
        self.__wndclassname__ = "PyWin_" + os.path.splitext(file)[0] + "#" + str(counter);
        def CreateWin():
            self.__wndclass__.lpfnWndProc    = WNDPROC(self.__procedure__);
            self.__wndclass__.lpszClassName  = self.__wndclassname__;
            
            if not user32.RegisterClassW(ctypes.byref(self.__wndclass__)):
                raise WinError()
            
            CreateWindowEx          = user32.CreateWindowExW
            CreateWindowEx.argtypes = [
                ctypes.c_int,
                ctypes.c_wchar_p,
                ctypes.c_wchar_p,
                ctypes.c_int,
                ctypes.c_int,
                ctypes.c_int,
                ctypes.c_int,
                ctypes.c_int,
                ctypes.c_int,
                ctypes.c_int,
                ctypes.c_int,
                ctypes.c_int,
            ]
            self.__hWnd__ = CreateWindowEx(
                0,
                self.__wndclass__.lpszClassName,
                title,
                WS_OVERLAPPEDWINDOW,
                CW_USEDEFAULT,
                CW_USEDEFAULT,
                CW_USEDEFAULT,
                CW_USEDEFAULT,
                0,
                0,
                self.__wndclass__.hInstance,
                0,
            )
        self.__thread__ = multithreading.Thread(self.__wndclassname__);
        self.__thread__.start();
        self.__thread__.call(CreateWin);
        self.listener = Listener();
    def __str__(self):
        return self.__wndclassname__;
    def __repr__(self):
        return str(self.__hWnd__);
    def start(self):
        def start():
            user32.ShowWindow(ctypes.c_int(self.__hWnd__), ctypes.c_int(1))
            user32.UpdateWindow(ctypes.c_int(self.__hWnd__))
            msg = MSG()
            pMsg = ctypes.pointer(msg)
            while user32.GetMessageW(pMsg, ctypes.c_int(0), 0, 0) != 0:
                user32.TranslateMessage(pMsg)
                user32.DispatchMessageW(pMsg)
            self.start = None; del self.start;
            for name in set(dir(__WindowMethods__)) - set(dir(type('type', (), {}))):
                setattr(self, name, getattr(__WindowMethods__, name));
        self.__thread__.call(start);
    def destroy(self):
        def destroy():
            user32.DestroyWindow(ctypes.c_int(self.__hWnd__));
        self.__thread__.call(destroy);
class Listener():
    bindings = {}
    with open(os.path.split(__file__)[0] + '\\events.json') as events_json:
        __events__ = json.loads(events_json.read());
    def onpress(self, key, function):
        if key in list(Listener.__events__.values()) + ['ANY', 'ARROW', 'NUMBER', 'LETTER']:
            if key not in self.bindings:
                self.bindings[key] = [function];
            else:
                self.bindings[key].append(function);
        else:
            raise ValueError("bad keyname '" + str(key) + "'");
    def onkeydown(self, key, function):
        def func():
            if event.keystate == 'DOWN':
                function.__globals__['event'] = event;
                function();
        self.onpress(key, func);
    def onkeyup(self, key, function):
        def func():
            if event.keystate == 'UP':
                function.__globals__['event'] = event;
                function();
        self.onpress(key, func);
    def __getitem__(self, name):
        return tuple(self.bindings.get(name, ()));

class Test:
    def __init__(self):
        
        def create():
            self.__id__ = 100
            
            
            
obj = Test()
print(obj.__id__)

    def __init__(self, title):
        def CreateWin():
            self.__hWnd__ = CreateWindowEx()
        #…
        self.__thread__ = multithreading.Thread(self.__wndclassname__);
        self.__thread__.start();
        self.__thread__.call(CreateWin);