Maximum CD 2011 February/maximum-cd-2011-02.iso/DiscContents/digsby_setup85.exe/lib/common/notifications.pyo

Python Compiled Bytecode | 2010-11-24 | 16.4 KB | 537 lines

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

from __future__ import with_statement
import wx
import os.path as os
import config
from util.primitives import traceguard, dictadd
from util.introspect import memoize
import util.data_importer as importer
from path import path
from common.slotssavable import SlotsSavable
from os.path import exists as path_exists
from common import profile, pref
from itertools import chain
from logging import getLogger
log = getLogger('notifications')
from Queue import Queue, Empty
from weakref import ref

class cancellables(Queue):

    def __init__(self):
        Queue.__init__(self)
        self.reaction_names = set()


    def put(self, item):
        item = item()
        if item is not None:
            self.reaction_names.add(item.__class__.__name__)

        return Queue.put(self, item)


    def had_reaction(self, reaction_name):
        return reaction_name in self.reaction_names


    def cancel(self):
        n = 0

        try:
            while True:
                item = self.get(block = False)
                if isinstance(item, ref):
                    item = item()

                if item is not None:

                    try:
                        wx.CallAfter(item.cancel)
                    except wx.PyDeadObjectError:
                        pass
                    except Exception:
                        print_exc = print_exc
                        import traceback
                        print_exc()

                    n += 1
                    continue
        except Empty:
            pass

        log.info('cancelled %d notification reactions', n)



def add_reaction(notifications, notification_name, reaction_name):
    reactions = notifications[None].setdefault(notification_name, [])
    reaction = dict(reaction = reaction_name)
    if reaction not in reactions:
        reactions.append(reaction)



def add_required_notifications(nots):
    if nots and config.platform == 'mac':
        add_reaction(nots, 'message.received', 'BounceDockIcon')


from copy import deepcopy

def get_user_notifications():
    user_notifications = deepcopy(dict(profile.notifications))
    add_required_notifications(user_notifications)
    return user_notifications


def fire(topic, **info):
    if isinstance(topic, basestring):
        topic = [
            topic]

    topics = sorted(set(chain(*(lambda .0: for t in .0:
_topics_from_string(t))(topic))), reverse = True)
    log.debug('fired topics %r', topics)
    types = set()
    cancels = cancellables()
    fired = False

    try:
        notifications = get_user_notifications()
    except AttributeError:
        return log.warning('no notifications yet')

    always_show = info.get('always_show', [])
    always_show = None if always_show is not None else set()
    for topic in topics:
        always_show.update(always_fire.get(topic, []))

    if 'buddy' in info:

        try:
            idstr = info['buddy'].idstr()
            buddy_events = notifications.get(idstr, [])
        except:
            buddy_events = []

        log.debug('found %d buddy specific events', len(buddy_events))
        if buddy_events:
            fired = True
            firetopics(topics, buddy_events, types = types, cancels = cancels, **info)


    generic_events = notifications.get(None, [])
    if generic_events:
        fired = True
        firetopics(topics, generic_events, types = types, cancels = cancels, **info)

    if always_show:
        import gui.notificationview as nview
        G = globals()
        reactions = (set,)((lambda .0: for name in .0:
G[name])(always_show))
        ninfo = nview.get_notification_info()
        didFireType = set()
        for topic in topics:
            for reaction in reactions - types:
                if reaction in didFireType:
                    continue

                args = dictadd(ninfo.get(topic, { }), info)

                def doit(cancels = cancels, reaction = reaction, args = args):
                    cancellable = reaction()(**args)
                    if hasattr(cancellable, 'cancel'):
                        cancels.put(ref(cancellable))


                didFireType.add(reaction)
                wx.CallAfter(doit)
                fired = True




    try:
        on_done = info['on_done']
    except KeyError:
        pass

    return cancels


def firetopics(topics, events, types, cancels, **info):
    import gui.notificationview as nview
    if types is None:
        types = set()

    ninfo = nview.get_notification_info()
    for topic in topics:
        for event in events.get(topic, []):
            (reaction, eventinfo) = getReaction(event, topic)
            if reaction in types or reaction is None:
                continue

            template_info = ninfo.get(topic, { })

            def doit(cancels = cancels, reaction = reaction, args = dictadd(template_info, info), eventinfo = eventinfo):
                cancellable = reaction(**eventinfo)(**args)
                if hasattr(cancellable, 'cancel'):
                    cancels.put(ref(cancellable))


            wx.CallAfter(doit)
            types.add(reaction)


    return types


def getReaction(mapping, topic):
    mapping = dict(mapping)
    reaction = mapping.pop('reaction')
    if isinstance(reaction, basestring):
        reaction = globals().get(reaction, None)

    if reaction not in reactions_set:
        return (None, None)
    if reaction is Sound:
        active_soundset = active_soundset
        SoundsetException = SoundsetException
        import gui.notifications.sounds

        try:
            soundset = active_soundset()
        except SoundsetException:
            reaction not in reactions_set
            reaction not in reactions_set
            soundset = { }
        except:
            reaction not in reactions_set


        try:
            sound_filename = soundset[topic]
        except KeyError:
            reaction not in reactions_set
            reaction not in reactions_set
            return (None, None)

        mapping.update(soundfile = sound_filename)

    return (reaction, mapping)


class Reaction(object):

    def preview(self):
        pass


    def allowed(self):
        cname = type(self).__name__.lower()

        try:
            away = profile.status.away
        except AttributeError:
            return True

        if pref('notifications.enable_%s' % cname, True):
            if away:
                pass
        return bool(not pref('messaging.when_away.disable_%s' % cname, False))

    allowed = property(allowed)


class Sound(Reaction):
    desc = 'Play sound %(filename)s'

    def __init__(self, soundfile):
        self.soundfile = soundfile


    def __call__(self, **k):
        if not self.allowed:
            return None
        import gui.native.helpers as helpers
        if pref('fullscreen.disable_sounds', False) and helpers.FullscreenApp():
            return None


    def preview(self):
        self()


    def __repr__(self):
        return '<Sound %s>' % path(self.filename).basename()



class Alert(Reaction):
    desc = 'Show alert "%(msg)s"'

    def __init__(self, msg):
        self.msg = msg


    def __call__(self, **info):
        if not self.allowed:
            return None
        wx.MessageBox(self.msg)



class Popup(Reaction):

    def desc(cls, info):
        return 'Show a popup notification'

    desc = classmethod(desc)

    def __init__(self, sticky = False):
        self.sticky = sticky


    def __call__(self, **info):
        import gui.native.helpers as helpers
        if pref('fullscreen.disable_popups', True) and helpers.FullscreenApp():
            return None
        if self.allowed or info.get('always_show', False):
            popup = popup
            import gui.toast
            cpy = vars(self).copy()
            cpy.update(info)
            return popup(**cpy)



class ShowContactList(Reaction):
    DEFAULT_DURATION_SEC = 3
    desc = 'Show the contact list for %(duration)s seconds'

    def __init__(self, duration):
        self.duration = duration


    def __call__(self):
        print 'do buddylist stuff for', self.duration, 'sec'



class LogMessage(Reaction):

    def __init__(self, msg):
        self.msg = msg


    def __call__(self, **info):
        if self.msg.find('%') != -1 and info.get('buddy', None) is not None:
            log.info(self.msg, info['buddy'])
        else:
            log.info(self.msg)



class StartCommand(Reaction):
    desc = 'Start external command "%(path)s"'

    def __init__(self, path):
        self.path = path


    def __call__(self, **info):
        os.startfile(self.path)


    def preview(self):
        self()



def get_notification_info(_cache = []):

    try:
        nots = _cache[0]
    except IndexError:
        skin = skin
        import gui
        mod = importer.yaml_import('notificationview', loadpath = [
            skin.resourcedir()])
        nots = _process_notifications_list(mod.__content__)
        _cache.append(nots)

    import hooks
    hooks.notify('digsby.notifications.get_topics', nots)
    return nots


def _process_notifications_list(nots_list):
    odict_from_dictlist = odict_from_dictlist
    import util.primitives.mapping
    nots = odict_from_dictlist(nots_list)
    ordered_underscores_to_dots(nots)
    update_always_fire(nots)
    return nots


def add_notifications(nots_list):
    to_update = get_notification_info()
    mynots = _process_notifications_list(nots_list)
    for k in mynots:
        to_update[k] = mynots[k]

    error = to_update.pop('error', None)
    if error is not None:
        to_update['error'] = error



def add_default_notifications(not_defaults):
    default_notifications[None].update(not_defaults)

always_fire = { }

def update_always_fire(nots):
    always_fire.clear()
    for name, info in nots.iteritems():
        if 'always_show' in info:
            reactions = info.get('always_show')
            if isinstance(reactions, basestring):
                reactions = [
                    reactions]

            always_fire[name] = reactions
            continue



def ordered_underscores_to_dots(d):
    ordered_keys = d._keys[:]
    for i, key in enumerate(list(ordered_keys)):
        if key and '_' in key:
            new_key = key.replace('_', '.')
            d[new_key] = d.pop(key)
            ordered_keys[i] = new_key
            continue

    d._keys = ordered_keys

from common.message import StatusUpdateMessage

class IMWinStatusUpdate(Reaction):

    def __init__(self, **info):
        self.info = info


    def __call__(self, **info):
        self.info.update(info)
        on_done = info.pop('on_done', (lambda : pass))
        on_status = on_status
        import gui.imwin.imhub
        wx.CallAfter(on_status, StatusUpdateMessage(**self.info), on_done)


reactions = [
    Popup,
    Alert,
    Sound,
    ShowContactList,
    StartCommand,
    IMWinStatusUpdate]
if 'wxMac' in wx.PlatformInfo:

    class BounceDockIcon(Reaction):

        def __call__(self, **info):
            tlw = wx.GetApp().GetTopWindow()
            if tlw:
                tlw.RequestUserAttention(wx.USER_ATTENTION_ERROR)



    reactions.extend([
        BounceDockIcon])

reactions_set = set(reactions)
default_notifications = {
    None: {
        'contact.returnsfromidle': [],
        'email.new': [
            {
                'reaction': 'Popup' }],
        'error': [
            {
                'reaction': 'Popup' }],
        'filetransfer.ends': [
            {
                'reaction': 'Popup' }],
        'filetransfer.error': [
            {
                'reaction': 'Popup' }],
        'filetransfer.request': [
            {
                'reaction': 'Popup' }],
        'message.received.background': [
            {
                'reaction': 'Popup' }],
        'message.received.initial': [
            {
                'reaction': 'Sound' }],
        'message.received.hidden': [
            {
                'reaction': 'Popup' }],
        'myspace.alert': [
            {
                'reaction': 'Popup' }],
        'myspace.newsfeed': [
            {
                'reaction': 'Popup' }],
        'twitter.newdirect': [
            {
                'reaction': 'Popup' }],
        'twitter.newtweet': [
            {
                'reaction': 'Popup' }] } }
for topic in [
    'contact.signon',
    'contact.signoff',
    'contact.available',
    'contact.away',
    'contact.returnsfromidle',
    'contact.idle']:
    seq = default_notifications[None].setdefault(topic, [])
    seq += [
        {
            'reaction': 'IMWinStatusUpdate' }]


class Notification(SlotsSavable):
    pass

TOPIC_SEP = '.'

def _topics_from_string(topic):
    _check_topic_string(topic)
    topiclist = topic.split(TOPIC_SEP)
    topics = []([ TOPIC_SEP.join(topiclist[:x]) for x in xrange(1, len(topiclist) + 1) ])
    return list(topics)

_topics_from_string = memoize(_topics_from_string)

def _check_topic_string(topic):
    if not isinstance(topic, basestring):
        raise TypeError('topic must be a string')
    isinstance(topic, basestring)
    if topic.find('..') != -1:
        raise ValueError('consecutive periods not allowed in topic')
    topic.find('..') != -1
    if topic.startswith('.') or topic.endswith('.'):
        raise ValueError('topic cannot start or end with a topic')
    topic.endswith('.')