Maximum CD 2011 October/maximum-cd-2011-10.iso/DiscContents/digsby_setup.exe/lib/util/diagnostic.pyo

Python Compiled Bytecode | 2011-06-22 | 35.1 KB | 1,022 lines

# Source Generated with Decompyle++
# File: in.pyo (Python 2.6)

from __future__ import with_statement
import config
from timeit import default_timer as clock
from datetime import datetime
import syck
import sys
import os
import threading
import util.urllib2_file as util
import simplejson
from pprint import pformat
from pstats import Stats
from util import program_dir, traceguard, threaded, RepeatTimer
from common import profile
from prefs.prefsdata import inflate
from traceback import print_exc, format_exc
from operator import attrgetter
from hashlib import sha256
from peak.util.imports import lazyModule
gui_native = lazyModule('gui.native')
LOGFILE_MAX_BYTES = 9 * 2 ** 20
rep_map = {
    'no': 0,
    'yes': 1,
    'unknown': 3 }
ZIPFILE_KEY = ('f', 'datafile.zip')
from functools import partial
default_priority = 100
DESCRIPTION_LIMIT = 10000
MINI_BUG_URL = 'http://mini/bugs/?act=view&id=%s'
import logging
INFO = logging.getLogger('diagnostic').info

def arg(name = None, priority = default_priority, slow = False):
    if name is None:
        return partial(arg, priority = priority)
    if not isinstance(name, basestring):
        if name.func_name.startswith('get_'):
            new_name = name.func_name[4:]
        else:
            new_name = name.func_name
        return arg(new_name, priority = priority, slow = slow)(name)

    def wrapper(func):
        func.priority = priority
        func.arg_name = name
        func.slow = slow
        return func

    return wrapper


def file(name = None, priority = default_priority, slow = False):
    if name is None:
        return partial(file, priority = priority, slow = slow)
    if not isinstance(name, basestring):
        if name.func_name.startswith('get_'):
            new_name = name.func_name[4:]
        else:
            new_name = name.func_name
        if '.' not in new_name:
            new_name += '.txt'

        return file(new_name, priority = priority, slow = slow)(name)

    def wrapper(func):
        func.priority = priority
        func.slow = slow
        func.file_name = name
        return func

    return wrapper


def raw_args(func = None, priority = default_priority, slow = False):
    if func is None:
        return partial(raw_args, priority = priority, slow = slow)
    func.priority = priority
    func.raw_args = True
    func.slow = slow
    return func


def raw_files(func = None, priority = default_priority, slow = False):
    if func is None:
        return partial(raw_files, priority = priority, slow = slow)
    func.priority = priority
    func.raw_files = True
    func.slow = slow
    return func


class Diagnostic(object):

    def __init__(self, screenshot = None, reproducible = 'unknown', description = 'test post', simulate_flags = False):
        self.shot = screenshot
        self.succeeded = False
        self.reproducible = reproducible
        self.description = description[:DESCRIPTION_LIMIT]
        self.simulate_flags = simulate_flags
        self.prepared_args = { }
        self.prepared_files = { }
        self.fnames = []


    def get_reproducible(self):
        return rep_map.get(self.reproducible, self.reproducible)

    get_reproducible = arg('rep')(get_reproducible)

    def get_description(self):
        if isinstance(self.description, unicode):
            self.description = self.description.encode('utf-8')

        return self.description

    get_description = file(arg('desc')(get_description))

    def get_screenshot(self):
        if self.shot:
            return {
                'screenshot.png': self.shot }
        return { }

    get_screenshot = raw_files(get_screenshot)

    def get_ss(self):
        return str(int(bool(self.shot)))

    get_ss = arg(get_ss)

    def get_password(self):
        if profile() is None:
            return ''
        return sha256(profile.password).hexdigest()

    get_password = arg('pw')(get_password)

    def get_username(self):
        if profile() is None:
            return ''
        return profile.username.encode('utf-8')

    get_username = arg('un')(get_username)

    def get_portable(self):
        return str(int(getattr(sys, 'is_portable', False)))

    get_portable = file(arg(get_portable))

    def get_protocols(self):
        if profile() is None:
            return { }
        protos = [](_[1])
        return dict((lambda .0: for proto in .0:
(proto, ''))(protos))

    get_protocols = raw_args(get_protocols)

    def get_prefs(self):
        if profile() is None:
            return ''
        items = profile.prefs.items()
        seen_keys = set()
        alone_and_subtree = set()
        for key in sorted((lambda .0: for i in .0:
i[0])(items)):
            prefix = key.rsplit('.', 1)[0]
            if prefix in seen_keys:
                alone_and_subtree.add(prefix)

            seen_keys.add(key)

        items = [ _[1] if item[0] not in alone_and_subtree else (item[0] + '_alone_', item[1]) for item in items ]

        try:
            return syck.dump(inflate(items))
        except Exception:
            []
            []
            return format_exc()


    get_prefs = file('prefs.yaml')(get_prefs)

    def get_im_accounts(self):
        if profile() is None:
            return ''
        return []([ '%r, %r, %r' % b for b in []([ (a, a.connection, a.get_options()) for a in profile.account_manager.accounts ], key = (lambda o: if getattr(o[0], 'state', None) == 'Online':
0if not getattr(o[0], 'offline_reason', None):
10.5)) ]).replace('\n', '\r\n')

    get_im_accounts = file(get_im_accounts)

    def get_email_accounts(self):
        if profile() is None:
            return ''
        return []([ '%r, %r' % b for b in []([ (a, a.get_options()) for a in profile.account_manager.emailaccounts ], key = (lambda o: if o[1].get('enabled', False):
01)) ]).replace('\n', '\r\n')

    get_email_accounts = file(get_email_accounts)

    def get_social_accounts(self):
        if profile() is None:
            return ''
        return []([ '%r, %r' % b for b in []([ (a, a.get_options()) for a in profile.account_manager.socialaccounts ], key = (lambda o: if o[1].get('enabled', False):
01)) ]).replace('\n', '\r\n')

    get_social_accounts = file(get_social_accounts)

    def get_profile(self):
        if profile() is None:
            return ''
        return '%r, %r' % (profile, getattr(profile, 'connection', None))

    get_profile = file(get_profile)

    def get_revision(self):
        tag = str(getattr(sys, 'TAG', 'not found'))
        rev = getattr(sys, 'REVISION', 'not found')
        if getattr(sys, 'DEV', False):
            return rev + get_svn_revision()
        return getattr(sys, 'DEV', False) + str(rev) if tag else ''

    get_revision = file(arg(get_revision))

    def get_tag(self):
        return str(getattr(sys, 'TAG', 'not found'))

    get_tag = file(get_tag)

    def get_sorter(self):
        return 'New sorter diagnostic needs to happen on the sorter thread; plz impl on_thread("sorter").blocking_call kthx'
        sorter = profile.blist.new_sorter
        on_thread = on_thread
        import util.threads.bgthread

        def later():
            s = ''.join([
                'expanded root:\n\n',
                sorter.dump_root(),
                '\n\ngathered tree:\n\n',
                sorter.dump_gather()])
            s += '\n\npython tree:\n\n'
            dump_elem_tree = dump_elem_tree
            import contacts.buddyliststore
            root = sorter._gather()

            try:
                s += dump_elem_tree(root)
            finally:
                sorter._done_gather(root)


        return on_thread('sorter').blocking_call(later)

    get_sorter = file(slow = True)(get_sorter)

    def get_blist(self):
        return pformat(profile.blist.save_data()).replace('\n', '\r\n')

    get_blist = file(slow = True)(get_blist)

    def get_tofrom(self):
        return pformat(profile.blist.get_tofrom_copy()).replace('\n', '\r\n')

    get_tofrom = file(slow = True)(get_tofrom)

    def get_local_prefs(self):
        import gui.toolbox as gui

        try:
            local_prefs = _[1]
            return local_prefs.read()
        finally:
            pass


    get_local_prefs = file('digsbylocal.ini')(get_local_prefs)

    def get_asyncore(self):
        import AsyncoreThread
        if AsyncoreThread.net_thread is None:
            return ''
        return pformat(AsyncoreThread.net_thread.map).replace('\n', '\r\n')

    get_asyncore = file(get_asyncore)

    def get_gcinfo(self):
        return get_gc_info()

    get_gcinfo = file(slow = True)(get_gcinfo)

    def get_webkit_stats(self):
        return None
        import main
        if main.is_webkit_initialized():
            import wx.webview as wx
            GetStatistics = getattr(wx.webview.WebView, 'GetStatistics', None)
            if GetStatistics is not None:
                return GetStatistics()


    get_webkit_stats = file(get_webkit_stats)
    if config.platform == 'win':

        def get_processes(self):
            process_list = process_list
            import gui.native.win.process
            return '\r\n'.join(process_list())

        get_processes = file(get_processes)


    def system_information(self):
        import gui.native.sysinfo as gui
        s = gui.native.sysinfo.SystemInformation()
        d = dict(ram = s._ram(), disk = s._disk_c())
        traceguard.__enter__()

        try:
            d['monitors'] = gui.toolbox.getDisplayHashString()
        finally:
            pass

        return simplejson.dumps(d)

    system_information = file('system_information.json')(system_information)

    def get_stats(self):
        import metrics
        return metrics.dump()

    get_stats = file(get_stats)

    def get_environ(self):
        return '\r\n'.join((lambda .0: for item in .0:
'='.join(item))(os.environ.items()))

    get_environ = file(get_environ)

    def get_log(self):
        import logging
        for handler in logging.root.handlers:
            handler.flush()

        tail = tail
        import fileutil
        return tail(sys.LOGFILE_NAME, LOGFILE_MAX_BYTES)

    get_log = file('log.csv', priority = 200, slow = True)(get_log)
    if sys.platform.startswith('win'):

        def get_process_ram(self):
            import gui.native.win as gui
            if not hasattr(self, 'pmc'):
                self.pmc = gui.native.win.process.memory_info()

            return gui.native.win.process.str_meminfo(self.pmc)

        get_process_ram = file(get_process_ram)

        def get_pwss(self):
            import gui.native.win as gui
            if not hasattr(self, 'pmc'):
                self.pmc = gui.native.win.process.memory_info()

            return self.pmc.PeakWorkingSetSize

        get_pwss = arg(priority = 1)(get_pwss)

        def get_pu(self):
            import gui.native.win as gui
            if not hasattr(self, 'pmc'):
                self.pmc = gui.native.win.process.memory_info()

            return self.pmc.PagefileUsage

        get_pu = arg(priority = 1)(get_pu)

        def get_object_counts(self):
            count_gdi_objects = count_gdi_objects
            count_user_objects = count_user_objects
            import gui.native.win.process
            return 'gdi: %r\r\nuser: %r' % (count_gdi_objects(), count_user_objects())

        get_object_counts = file(get_object_counts)


    def get_imshow(self):
        im_show = im_show
        import gui.imwin.imhub
        if im_show:
            return repr(im_show)

    get_imshow = file(get_imshow)

    def get_updatelog(self):
        import stdpaths
        logpath = stdpaths.userlocaldata / 'Logs' / 'digsby_updater.log'
        if logpath.isfile():
            return logpath.bytes()

    get_updatelog = file(slow = True)(get_updatelog)

    def get_preupdatelog(self):
        import stdpaths
        logpath = sys.LOGFILE_NAME.parent / 'digsby_update_download.log.csv'
        if logpath.isfile():
            return logpath.bytes()

    get_preupdatelog = file('before_update.csv', slow = True)(get_preupdatelog)

    def get_integrity(self):

        def retval(update, delete):
            return simplejson.dumps(dict(update = update, delete = delete))

        if self.simulate_flags:
            return retval(update = [
                'update_me.test'], delete = [
                'delete_me.test'])

        try:
            import digsby_updater.file_integrity as FI
        except ImportError:
            self.simulate_flags
            self.simulate_flags
            return None

        pic = FI.ProgramIntegrityChecker()
        pic.synchronous_check()
        return retval(update = pic.get_update_paths(), delete = pic.get_delete_paths())

    get_integrity = file('integrity.json', slow = True)(get_integrity)

    def get_windowids(self):
        import digsbysite

        try:
            get_window_id_allocs = digsbysite.get_window_id_allocs
        except AttributeError:
            return None

        highest_id_allocs = sorted(get_window_id_allocs().iteritems(), key = (lambda item: item[1]), reverse = True)[:20]
        if highest_id_allocs:
            stringified = []
            for k, v in highest_id_allocs:
                stringified.append([
                    list((lambda .0: for subkey in .0:
' '.join((lambda .0: for e in .0:
str(e))(subkey))

)(k)),
                    v])

            return simplejson.dumps(stringified, indent = 4)

    get_windowids = file('windowids.json', slow = True)(get_windowids)

    def set_un_pw(self, un, password):
        un = un.decode('base64')
        un = [ ord(c) for c in un ]
        un = [ (c + 197) % 256 for c in un ]
        self.username = ''.join((lambda .0: for c in .0:
chr(c))(un))
        password = [ int(c, 16) for c in password ]
        password = [ (c + 3) % 16 for c in password ]
        self.password = ''.join((lambda .0: for c in .0:
hex(c)[-1])(password))


    def get_un_pw(self):
        un = [ ord(c) for c in self.username ]
        un = [ (c + 59) % 256 for c in un ]
        un = ''.join((lambda .0: for c in .0:
chr(c))(un))
        un = un.encode('base64')
        password = [ int(c, 16) for c in self.password ]
        password = [ (c + 13) % 16 for c in password ]
        password = ''.join((lambda .0: for c in .0:
hex(c)[-1])(password))
        return (un, password)


    def write_prep_data(self, key, val):
        self.prepared_files[key] = val


    def attach_minidump(self, filename):
        traceguard.__enter__()

        try:

            try:
                f = _[1]
                self.write_prep_data('crash.dmp', f.read())
            finally:
                pass

        finally:
            pass



    def extra_stuff(self):
        d = { }
        profile_info = write_profiler_info()
        if not profile_info:
            pass
        d.update({ })
        where_info = write_where_info()
        d['where.txt'] = where_info
        return d

    extra_stuff = raw_files(slow = True)(extra_stuff)

    def write_data(self, z):
        write = z.writestr
        for k, v in self.prepared_files.iteritems():
            if v is not None:
                traceguard.__enter__()

                try:
                    write(k, v)
                finally:
                    pass

                continue
            traceguard.__exit__



    def write_files(self, z, fnames):
        for None in fnames:
            (fname, aname) = None
            if not os.path.isfile(fname):
                INFO('diagnostic file not found: %r', fname)
                continue
            traceguard.__enter__()

            try:
                write(fname, aname)
            finally:
                pass




    def prepare_data(self, fast = False):
        meths = [ getattr(self, meth) for meth in filter((lambda k: not k.startswith('_')), self.__class__.__dict__.keys()) ]
        meths = filter((lambda meth: hasattr(meth, 'priority')), meths)
        meths.sort(key = attrgetter('priority'))
        for meth in meths:
            arg_name = getattr(meth, 'arg_name', False)
            file_name = getattr(meth, 'file_name', False)
            raw_args = getattr(meth, 'raw_args', False)
            raw_files = getattr(meth, 'raw_files', False)
            if not any((arg_name, file_name, raw_args, raw_files)):
                continue


            try:
                INFO('diagnostic func: %r', meth.__name__)
                val = meth()
            except Exception:
                print_exc()
                val = format_exc()

            if raw_args:
                self.prepared_args.update(val)

            if raw_files:
                self.prepared_files.update(val)

            if arg_name or file_name:
                if arg_name:
                    self.prepared_args[arg_name] = val

                if file_name:
                    self.prepared_files[file_name] = val

            file_name

        pdir = program_dir()
        self.fnames = self.fnames + [
            (pdir / 'digsby_updater.log', 'digsby_updater.log'),
            (pdir / 'digsby.exe.log', 'digsby.exe.log'),
            (pdir / 'digsby_post_update.log', 'digsby_post_update.log')]
        traceguard.__enter__()

        try:
            if hasattr(sys, 'STDERR_LOGFILE'):
                errfile = sys.STDERR_LOGFILE
                self.fnames.append((errfile, os.path.basename(errfile)))
        finally:
            pass

        traceguard.__enter__()

        try:
            cstderr = getattr(sys, 'CSTDERR_FILE', None)
            if cstderr is not None:
                self.fnames.append((cstderr, os.path.basename(cstderr)))
        finally:
            pass



    def package_data(self):
        import zipfile
        StringIO = StringIO
        import StringIO
        out = StringIO()
        z = zipfile.ZipFile(out, 'w', zipfile.ZIP_DEFLATED)
        self.write_data(z)

        try:
            names = self.fnames
        except AttributeError:
            pass

        self.write_files(z, names)
        z.close()
        out.seek(0)
        return out


    def getvars(self):
        d = dict((lambda .0: for k, v in .0:
(str(k), str(v)))(self.prepared_args.iteritems()))
        d[ZIPFILE_KEY] = self.package_data()
        return d


    def do_post(self, do_popups = True):
        title = _('Submit Bug Report')
        message = _('Bug report')
        import wx
        if self.do_no_thread_post():
            message += _(' submitted successfully.')
        else:
            message += _(' submission failed.')
        if do_popups:

            def later():
                wx.MessageBox(message, title)
                gui_native.memory_event()

            wx.CallAfter(later)


    do_post = threaded(do_post)

    def do_no_thread_post(self):
        import util.urllib2_file as util
        import urllib2
        vars = self.getvars()
        resp = urllib2.urlopen('https://accounts.digsby.com/report_bug.php', vars)
        r = resp.read()
        resp.close()
        self.response = r

        try:
            json = r[r.index(':') + 1:]
            import simplejson
            self.response_json = simplejson.loads(json)
            if not isinstance(self.response_json, dict):
                raise ValueError
            isinstance(self.response_json, dict)
        except Exception:
            self.response_json = { }

        self.succeeded = r.startswith('success')
        return self.succeeded



class CrashReport(Diagnostic):

    def __init__(self, dumpfile = None, logfilename = None, crashuser = None, description = ''):
        if not description:
            pass
        Diagnostic.__init__(self, description = 'crash report')
        self.username = 'digsby_crash'
        self.password = sha256('digsby_crash').hexdigest()
        self.dumpfile = dumpfile
        self.logfilename = logfilename
        self.crashuser = crashuser

    get_revision = Diagnostic.get_revision
    get_description = Diagnostic.get_description

    def get_log(self):
        tail = tail
        import fileutil
        return tail(self.logfilename, LOGFILE_MAX_BYTES)

    get_log = file('log.csv')(get_log)

    def get_crash(self):

        try:
            f = _[1]
            return f.read()
        finally:
            pass


    get_crash = file('crash.dmp')(get_crash)

    def crash_args(self):
        args = dict(rep = '3', un = self.username, pw = self.password, ss = '0')
        if self.crashuser is not None:
            args.update(crun = self.crashuser)

        return args

    crash_args = raw_args(crash_args)

    def prepare_data(self, fast = False):
        Diagnostic.prepare_data(self, fast)
        path = path
        import path
        logdir = path(self.logfilename).parent
        daigpath = logdir / 'diag.yaml'



class ScheduledDiagnostic(RepeatTimer):

    def __init__(self, interval):
        RepeatTimer.__init__(self, interval, self._on_timer)
        self.diagnostic = None
        self._diaglock = threading.Lock()


    def _on_timer(self):
        threaded(self.save_diagnostic)()


    def _get_trimmed_data(self):
        args = dict(self.diagnostic.prepared_args)
        del args['desc']
        files = dict(self.diagnostic.prepared_files)
        del files['description.txt']
        un = args.get('un')
        if un is not None:
            args.pop('un')
            args.pop('pw')
            args['crun'] = un

        args['diagtime'] = datetime.now().isoformat()
        return dict(uniquekey = getattr(sys, 'crashuniquekey', None), args = args, files = files)


    def save_diagnostic(self):
        if not self._diaglock.acquire(False):
            return None

        try:
            INFO('Scheduled Diagnostic Started')
            self.diagnostic = Diagnostic()
            self.diagnostic.prepare_data(fast = True)
            data = self._get_trimmed_data()
            INFO('Saving Diagnostic')
            logdir = sys.LOGFILE_NAME.parent

            try:
                diagfile = _[1]
                syck.dump(data, diagfile)
            finally:
                pass

            INFO('Scheduled Diagnostic Complete')
        finally:
            self._diaglock.release()



    def start(self):
        INFO('Diagnostic Scheduled')
        RepeatTimer.start(self)
        self._on_timer()


ScheduledDiagnostic = ScheduledDiagnostic(5 * 60)

def write_profiler_info():
    all_profilers = all_profilers
    import util
    profilers = all_profilers()
    out = dict()
    write = out.__setitem__
    if not profilers:
        return None
    report = []
    import marshal
    for thread, profiler in profilers.iteritems():
        write('profiler-%s.stats' % thread.getName(), marshal.dumps(Stats(profiler).stats))
        report.extend([
            '=' * 80,
            '%s (alive=%s, daemon=%s, loopcount=%s)' % (thread.getName(), thread.isAlive(), thread.isDaemon(), getattr(thread, 'loopcount', 0)),
            '=' * 80,
            profiler.report(),
            ''])

    report.append('*** THREAD STACKS ****\n\n' + get_thread_stacks())
    write('profiler.txt', '\r\n'.join(report))
    return out


def write_where_info():
    stack_info = ''

    try:
        import wx
        stack_info = '\n\n'.join(wx.GetApp().cpu_watcher.stack_info)
    except AttributeError:
        pass

    if not stack_info:
        where_string = where_string
        import common.commandline
        stack_info = where_string()

    return windows_newlines(stack_info)


def get_gc_info():
    StringIO = StringIO
    import cStringIO
    gc_diagnostics = gc_diagnostics
    import util.introspect
    io = StringIO()
    gc_diagnostics(stream = io)
    return io.getvalue()


def get_thread_stacks():
    where = where
    import common.commandline
    StringIO = StringIO
    import cStringIO
    io = StringIO()
    where(duplicates = True, stream = io)
    return io.getvalue()


def do_diagnostic():
    show_dialog = show_dialog
    import gui.bugreporter
    show_dialog(success = (lambda kwds: send_bug_report(**kwds)))


def maybe_open_bug_url(diag):
    if not getattr(sys, 'DEV', False):
        return False
    if not diag.succeeded:
        return False
    pref = pref
    import common
    if not pref('debug.bug_reporter.auto_open', default = True):
        return False

    try:
        id = diag.response_json.get('id', None)
        url = MINI_BUG_URL % id
        import wx
        wx.LaunchDefaultBrowser(url)
    except Exception:
        pref('debug.bug_reporter.auto_open', default = True)
        pref('debug.bug_reporter.auto_open', default = True)
        diag.succeeded
        print_exc()
        return False
        getattr(sys, 'DEV', False)

    return True


def save_diagnostic():
    d = Diagnostic()
    d.prepare_data()
    path = path
    import util
    import stdpaths
    import cPickle
    pth = path(stdpaths.temp) / 'digsby_diagnostic'

    try:
        f = _[1]
        cPickle.dump(d, f)
    finally:
        pass

    (un, password) = d.get_un_pw()
    import subprocess
    import sys
    args.extend([
        '--diagnostic',
        un,
        password])
    clock = clock
    import time
    print 1, clock()
    subprocess.Popen(args)
    print 2, clock()


def load_diagnostic(un, password):
    path = path
    import path
    import stdpaths
    import cPickle
    pth = path(stdpaths.temp) / 'digsby_diagnostic'

    try:
        f = _[1]
        d = cPickle.load(f)
    finally:
        pass

    pth.remove()
    d.set_un_pw(un, password)
    d._prepared = True
    d.do_no_thread_post()


def get_un_pw():
    password = sha256(profile.password).hexdigest()
    username = profile.username.encode('utf-8')
    un = [ ord(c) for c in username ]
    un = [ (c + 59) % 256 for c in un ]
    un = ''.join((lambda .0: for c in .0:
chr(c))(un))
    un = un.encode('base64')
    password = [ int(c, 16) for c in password ]
    password = [ (c + 13) % 16 for c in password ]
    password = ''.join((lambda .0: for c in .0:
hex(c)[-1])(password))
    return (un, password)


def load_crash(dumpfile, logfilename = None, username = None, description = ''):
    c = CrashReport(dumpfile, logfilename, crashuser = username, description = description)
    c.prepare_data()
    c.do_no_thread_post()
    return c


def send_bug_report(**info):
    progress_dialog = progress_dialog
    import gui.toolbox
    Timer = Timer
    import util
    p_diag = progress_dialog(_('Please wait while we process the diagnostic information.\nThanks for your patience!'), title = _('Processing Diagnostic Info'))

    def later():
        message = _('There was a problem submitting your bug report.\n\nIf the problem persists, please email [e-mail]')

        try:
            d = Diagnostic(**info)
            d.prepare_data()
            d.do_no_thread_post()
            message = _('Bug report sent successfully.')
        except Exception:
            print_exc()
        finally:
            p_diag.stop()
            import wx

            def later():
                if not maybe_open_bug_url(d):
                    wx.MessageBox(message, _('Submit Bug Report'))

                gui_native.memory_event()

            wx.CallLater(1000, later)


    Timer(1, threaded(later)).start()


def windows_newlines(s):
    return s.replace('\n', '\r\n')


def get_svn_revision():
    traceguard.__enter__()

    try:
        import package
        return package.getversion()
    finally:
        pass

    import re
    import path
    digsby_root = str(path.path(__file__).parent.parent.parent)
    revision = 0
    urlre = re.compile('url="([^"]+)"')
    revre = re.compile('committed-rev="(\\d+)"')
    for base, dirs, _files in os.walk(digsby_root):
        dirs.remove('.svn')
        f = open(os.path.join(base, '.svn', 'entries'))
        data = f.read()
        f.close()
        if base == str(digsby_root):
            base_url = dirurl + '/'
        elif not dirurl.startswith(base_url):
            dirs[:] = []
            continue

        revision = max(revision, localrev)

    return str(revision)