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

Python Compiled Bytecode | 2011-06-22 | 6.7 KB | 214 lines

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

import traceback
from util import callsback
import common.actions as common
action = common.actions.action
ObservableActionMeta = common.actions.ObservableActionMeta
from common import profile
from logging import getLogger
log = getLogger('Contact')
objget = object.__getattribute__
CONTACT_ATTRS = set([
    'id',
    'buddy',
    'remove',
    'watched',
    '__repr__',
    'rename_gui',
    'rename',
    'edit_alerts',
    'alias',
    'get_group',
    'move_to_group__getattr__',
    '__hash__',
    '__cmp__',
    'sort',
    '_notify_dirty'])

class Contact(object):
    watched = 'online '.split()
    __metaclass__ = ObservableActionMeta

    def __init__(self, buddy, id):
        self.buddy = buddy
        self.id = id
        self._metacontact = None


    def remove(self):
        self.protocol.remove_buddy(self.id)


    def _compatible_accounts(self):
        is_compatible = is_compatible
        import common.protocolmeta
        result = []
        for account in profile.connected_accounts:
            if is_compatible(account.protocol, self.buddy.service):
                result.append(account)
                continue

        return result


    def _all_buddies(self, check_if_has = False):
        result = []
        for account in self._compatible_accounts():
            connection = account.connection
            if connection:
                if not check_if_has or connection.has_buddy(self.buddy.name):
                    buddy = connection.get_buddy(self.buddy.name)
                    if buddy is not None:
                        result.append(buddy)


            connection.has_buddy(self.buddy.name)

        return result


    def _is_blocked(self):
        buddies = [ buddy.blocked for buddy in self._all_buddies(check_if_has = True) ]
        if buddies:
            pass
        return bool(all(buddies))

    blocked = property(_is_blocked)

    def _block_pred(self, block = True, **k):
        if bool(block) ^ self._is_blocked():
            return True


    def _unblock_pred(self, *a, **k):
        if self._is_blocked():
            return True


    def block(self, block = True, **k):
        for buddy in self._all_buddies():
            if bool(block) ^ bool(buddy.blocked):
                buddy.block(block, **k)
                continue


    block = action(_block_pred)(block)

    def unblock(self, *a, **k):
        self.block(False, *a, **k)

    unblock = action(_unblock_pred)(unblock)

    def get_notify_dirty(self):
        return self.buddy._notify_dirty


    def set_notify_dirty(self, value):
        self.buddy._notify_dirty = value

    _notify_dirty = property(get_notify_dirty, set_notify_dirty)

    def rename_gui(self):
        GetTextFromUser = GetTextFromUser
        import gui.toolbox
        localalias = self.alias
        if localalias is None:
            localalias = ''

        s = GetTextFromUser(_('Enter an alias for %s:') % self.name, caption = _('Rename %s') % self.name, default_value = localalias)
        if s is not None:
            if s == '' or s.strip():
                None(self.rename if s else None)
                return s


    rename_gui = action()(rename_gui)

    def rename(self, new_alias):
        log.info('setting alias for %r to %r', self, new_alias)
        profile.set_contact_info(self, 'alias', new_alias)
        self.buddy.notify('alias')


    def edit_alerts(self):
        import gui.pref.prefsdialog as prefsdialog
        prefsdialog.show('notifications')

    edit_alerts = action()(edit_alerts)

    def alias(self):
        a = profile.get_contact_info(self, 'alias')
        if a:
            return a
        for attr in ('local_alias', 'remote_alias', 'nice_name'):

            try:
                a = getattr(self, attr, None)
            except Exception:
                a
                a
                traceback.print_exc()
                continue
            except:
                a

            if a:
                return a

        return self.name

    alias = property(alias)

    def get_group(self):
        g = self.protocol.group_for(self)
        return g


    def move_to_group(self, groupname, index = 0, callback = None):
        if not isinstance(groupname, basestring):
            raise TypeError, 'groupname must be a string: %r' % groupname
        isinstance(groupname, basestring)
        self.protocol.move_buddy_creating_group(self, groupname, self.get_group(), index, callback = callback)

    move_to_group = callsback(move_to_group)

    def __getattr__(self, attr):
        if attr in CONTACT_ATTRS:
            return objget(self, attr)
        return getattr(objget(self, 'buddy'), attr)


    def __repr__(self):
        return '<%s %s>' % (self.__class__.__name__, self.buddy)


    def __hash__(self):
        b = self.buddy
        id = self.id
        if isinstance(id, bytes):
            id = id.decode('fuzzy utf-8')

        return hash(u'/'.join((b.protocol.name, b.protocol.username, b.name, unicode(id))))


    def __cmp__(self, other):
        if self is other:
            return 0
        return cmp((self.buddy, self.id), (getattr(other, 'buddy', None), getattr(other, 'id', None)))



class ContactCapabilities:
    INFO = 'INFO'
    IM = 'IM'
    FILES = 'FILES'
    PICTURES = 'PICTURES'
    SMS = 'SMS'
    BLOCKABLE = 'BLOCKABLE'
    EMAIL = 'EMAIL'
    BOT = 'BOT'
    VIDEO = 'VIDEO'