home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2011 February / maximum-cd-2011-02.iso / DiscContents / digsby_setup85.exe / lib / common / Conversation.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-11-24  |  13.6 KB  |  401 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.6)
  3.  
  4. from __future__ import with_statement
  5. from logging import getLogger
  6. from actions import ActionMeta
  7. from Buddy import get_bname
  8. from common import pref, profile, netcall
  9. from datetime import datetime
  10. from util.observe import Observable, ObservableList, observable_dict
  11. from util import traceguard
  12. log = getLogger('common.conversation')
  13. AUTORESP = _('[Auto-Response] ')
  14.  
  15. class Conversation(Observable):
  16.     __metaclass__ = ActionMeta
  17.     AUTORESP = AUTORESP
  18.     
  19.     def __init__(self, protocol):
  20.         Observable.__init__(self)
  21.         self.room_list = ObservableList()
  22.         self.protocol = protocol
  23.         self.autoresponded = False
  24.         self.typing_status = observable_dict()
  25.         self.just_had_error = False
  26.         self.pending_contacts_callbacks = set()
  27.         self.start_time_utc = datetime.utcnow()
  28.         self._bind_reconnect()
  29.         self.protocol.add_observer(self._Conversation__on_proto_state, 'state')
  30.  
  31.     
  32.     def _bind_reconnect(self):
  33.         if self.protocol is not None:
  34.             self.protocol.when_reconnect(self._Conversation__on_account_reconnect)
  35.         
  36.  
  37.     
  38.     def __on_proto_state(self, src, attr, old, new):
  39.         if new == src.Statuses.OFFLINE and self.ischat:
  40.             import wx
  41.             wx.CallLater((500,), (lambda : self.system_message(_('Disconnected'))))
  42.             self.protocol.remove_observer(self._Conversation__on_proto_state, 'state')
  43.         
  44.  
  45.     
  46.     def conversation_reconnected(self):
  47.         
  48.         try:
  49.             d = self._conversation_reconnected
  50.         except AttributeError:
  51.             Delegate = Delegate
  52.             import util.primitives.funcs
  53.             d = self._conversation_reconnected = Delegate()
  54.  
  55.         return d
  56.  
  57.     conversation_reconnected = property(conversation_reconnected)
  58.     
  59.     def __on_account_reconnect(self, new_connection):
  60.         
  61.         def foo():
  62.             log.warning('on_account_reconnect - connection: %r', new_connection)
  63.             log.warning('  ischat: %r', self.ischat)
  64.             if self.ischat:
  65.                 
  66.                 def success(convo):
  67.                     log.warning('rejoin_chat success: %r', convo)
  68.                     self.conversation_reconnected(convo)
  69.  
  70.                 log.warning('rejoin_chat')
  71.                 new_connection.rejoin_chat(self, success = success)
  72.             
  73.  
  74.         
  75.         def later():
  76.             netcall(foo)
  77.  
  78.         import wx
  79.         wx.CallLater(1000, later)
  80.  
  81.     
  82.     def add_pending_contacts(self, contacts):
  83.         for cb in self.pending_contacts_callbacks:
  84.             cb(contacts)
  85.         
  86.  
  87.     
  88.     def maybe_send_typing_status(self, status):
  89.         if pref('privacy.send_typing_notifications', False):
  90.             self.send_typing_status(status)
  91.         
  92.  
  93.     
  94.     def icon(self):
  95.         if self.ischat:
  96.             skin = skin
  97.             import gui
  98.             return skin.get('serviceicons.digsby')
  99.         return self.buddy.icon
  100.  
  101.     icon = property(icon)
  102.     
  103.     def send_plaintext_message(self, message):
  104.         return self._send_message(default_formatted_text(message))
  105.  
  106.     
  107.     def send_message(self, message, *args, **kwargs):
  108.         import hooks
  109.         message = hooks.reduce('digsby.im.msg.send', message)
  110.         echonow = pref('messaging.echo_immediately', type = bool, default = True)
  111.         
  112.         def error(e = (None, None)):
  113.             log.info('Error sending message: %r', message.format_as('plaintext'))
  114.             log.info('Message error callback received %r: %r', type(e), e)
  115.             if self.just_had_error:
  116.                 return None
  117.             emsg = getattr(e, 'error_message', '')
  118.             if emsg:
  119.                 self.system_message(emsg, content_type = 'text/plain')
  120.             else:
  121.                 self.system_message(_('Some of the messages you sent may not have been received.'), content_type = 'text/plain')
  122.             self.just_had_error = True
  123.  
  124.         
  125.         def message_sent():
  126.             self.just_had_error = False
  127.  
  128.         
  129.         def echo_message(msg = (None, (None,), None)):
  130.             if not msg:
  131.                 pass
  132.             echomsg = message
  133.             if kwargs.get('auto', False):
  134.                 if 'has_autotext' not in kwargs:
  135.                     kwargs.update(has_autotext = True)
  136.                 
  137.             
  138.             self.sent_message(echomsg, **kwargs)
  139.  
  140.         if echonow:
  141.             
  142.             def success(msg = (None,)):
  143.                 message_sent()
  144.  
  145.             echo_message()
  146.         else:
  147.             
  148.             def success(msg = (None, None)):
  149.                 message_sent()
  150.                 echo_message(msg)
  151.  
  152.         conn = profile.connection
  153.         if conn is not None:
  154.             conn.send_message_intercept(self.buddy, message.format_as('plaintext'))
  155.         
  156.         (None, None, None, None, None, netcall)((lambda : self._send_message(message, success = success, error = error, *args, **kwargs)))
  157.         if not self.ischat:
  158.             b = self.buddy
  159.             if b is not None and b is not self.protocol.self_buddy:
  160.                 profile.blist.add_tofrom('im', b, self.protocol)
  161.             
  162.         
  163.  
  164.     
  165.     def system_message(self, message, **opts):
  166.         log.debug('System message: message=%r, opts=%r', message, opts)
  167.         opts['buddy'] = None
  168.         opts['type'] = 'status'
  169.         return self._message(message = message, **opts)
  170.  
  171.     
  172.     def buddy_says(self, buddy, message, **options):
  173.         if not isinstance(message, unicode):
  174.             raise TypeError, 'buddy_says needs unicode got type %r: %r' % (type(message), message)
  175.         isinstance(message, unicode)
  176.         
  177.         try:
  178.             timestamp = options.get('timestamp', None)
  179.             if timestamp is None:
  180.                 timestamp = datetime.utcnow()
  181.             
  182.             content_type = options.pop('content_type', 'text/plain')
  183.             Message = Message
  184.             import common.message
  185.             messageobj = Message(buddy = buddy, message = message, timestamp = timestamp, content_type = content_type)
  186.             plugin_hub = plugin_hub
  187.             import plugin_manager
  188.             msgtype = options.get('type', None)
  189.             plugin_hub.act('digsby.im.msg.pre', messageobj, msgtype)
  190.             if messageobj.message != '':
  191.                 return self._message(buddy, messageobj.message, content_type = messageobj.content_type, **options)
  192.         except Exception:
  193.             e = None
  194.             log.error('Failed to parse message %r', e)
  195.             return self._message(buddy, message, **options)
  196.  
  197.  
  198.     
  199.     def _message(self, buddy, message, **options):
  200.         if not options.get('offline', True):
  201.             options.pop('timestamp', None)
  202.         
  203.         if options.get('offline', False):
  204.             self.autoresponded = True
  205.         
  206.         timestamp = options.pop('timestamp', None)
  207.         if timestamp is None:
  208.             timestamp = datetime.utcnow()
  209.         
  210.         Message = Message
  211.         import common.message
  212.         messageobj = Message(buddy = buddy, message = message, timestamp = timestamp, conversation = self, **options)
  213.         plugin_hub = plugin_hub
  214.         import plugin_manager
  215.         plugin_hub.act('digsby.im.msg.async', self, messageobj, options.get('type', None))
  216.         profile = profile
  217.         import common
  218.         return profile.on_message(messageobj) is not profile.on_message.VETO
  219.  
  220.     
  221.     def received_message(self, buddy, message, **options):
  222.         if not isinstance(message, unicode):
  223.             raise TypeError('message argument must be unicode')
  224.         isinstance(message, unicode)
  225.         return self.buddy_says(buddy, message, type = 'incoming', **options)
  226.  
  227.     
  228.     def sent_message(self, message, **options):
  229.         buddy = self.self_buddy
  230.         traceguard.__enter__()
  231.         
  232.         try:
  233.             message = message.format_as('xhtml')
  234.             options['content_type'] = 'text/xhtml'
  235.         finally:
  236.             pass
  237.  
  238.         self.autoresponded = True
  239.         return self.buddy_says(buddy, message, type = 'outgoing', **options)
  240.  
  241.     
  242.     def incoming_message(self, autoresp = True):
  243.         status = profile.status.for_account(self.protocol)
  244.         StatusMessage = StatusMessage
  245.         import common
  246.         if all((autoresp, status.away, not (status.invisible), status != StatusMessage.Offline, pref('messaging.when_away.autorespond', False), not (self.autoresponded))):
  247.             if status.message:
  248.                 self.autoresponded = True
  249.                 import wx
  250.                 
  251.                 def later():
  252.                     if getattr(status, '_a_href', False):
  253.                         content_type = 'text/html'
  254.                     else:
  255.                         content_type = 'text/plain'
  256.                     self.autorespond(status.message, content_type = content_type)
  257.  
  258.                 later = (None, wx.CallAfter)(later)
  259.             
  260.         
  261.  
  262.     
  263.     def __contains__(self, buddy):
  264.         bname = get_bname(buddy)
  265.         buddy = self.buddies[bname]
  266.         return buddy in self.room_list
  267.  
  268.     
  269.     def tingle(self):
  270.         self.system_message('Your digsby sense is tingling!')
  271.  
  272.     
  273.     def buddy(self):
  274.         r = self.other_buddies
  275.         if len(r) == 1:
  276.             return r[0]
  277.         if self.room_list:
  278.             return self.room_list[0]
  279.         return self.self_buddy
  280.  
  281.     buddy = property(buddy)
  282.     
  283.     def other_buddies(self):
  284.         r = self.room_list[:]
  285.         while True:
  286.             
  287.             try:
  288.                 r.remove(self.self_buddy)
  289.             continue
  290.             except ValueError:
  291.                 break
  292.                 continue
  293.             
  294.  
  295.             None<EXCEPTION MATCH>ValueError
  296.         return r
  297.  
  298.     other_buddies = property(other_buddies)
  299.     
  300.     def chat_member_count(self):
  301.         if self.protocol.connected:
  302.             return len(self.room_list)
  303.         return 0
  304.  
  305.     chat_member_count = property(chat_member_count)
  306.     
  307.     def send_typing_status(self, status):
  308.         raise NotImplementedError
  309.  
  310.     did_explicit_exit = False
  311.     
  312.     def exit(self):
  313.         pass
  314.  
  315.     
  316.     def explicit_exit(self):
  317.         self.did_explicit_exit = True
  318.         self.exit()
  319.  
  320.     
  321.     def autorespond(self, msg, format = None, **kws):
  322.         if not self.ischat:
  323.             if self.buddy.isbot:
  324.                 log.info('Not sending autoresponse to bot: %r', self.buddy)
  325.                 return None
  326.             if 'has_autotext' not in kws:
  327.                 kws.update(has_autotext = True)
  328.             
  329.             self.send_message(default_formatted_text(AUTORESP + msg), auto = True, **kws)
  330.         
  331.  
  332.     _inwindow = False
  333.     
  334.     def queued_system_messages(self):
  335.         
  336.         try:
  337.             return self._queued_system_messages
  338.         except AttributeError:
  339.             self._queued_system_messages = []
  340.             return self._queued_system_messages
  341.  
  342.  
  343.     queued_system_messages = property(queued_system_messages)
  344.     
  345.     def play_queued_messages(self):
  346.         self._inwindow = True
  347.         if hasattr(self, '_queued_system_messages'):
  348.             
  349.             try:
  350.                 for kws in self._queued_system_messages:
  351.                     traceguard.__enter__()
  352.                     
  353.                     try:
  354.                         self.system_message(**kws)
  355.                     finally:
  356.                         pass
  357.  
  358.             finally:
  359.                 del self._queued_system_messages[:]
  360.  
  361.         
  362.  
  363.     
  364.     def buddy_join(self, buddy):
  365.         if self.ischat:
  366.             self._presence_message(_(u'%s joined the group chat') % buddy.name)
  367.         
  368.  
  369.     
  370.     def buddy_leave(self, buddy):
  371.         if self.ischat and buddy is not self.protocol.self_buddy:
  372.             self._presence_message(_(u'%s left the group chat') % buddy.name)
  373.         
  374.  
  375.     
  376.     def _presence_message(self, msg):
  377.         kws = dict(message = msg, content_type = 'text/plain', linkify = False)
  378.         if self._inwindow:
  379.             self.system_message(**kws)
  380.         else:
  381.             self.queued_system_messages.append(kws)
  382.  
  383.  
  384.  
  385. def default_formatted_text(msg):
  386.     fmtstr = fmtstr
  387.     import util.primitives.fmtstr
  388.     get_default_format = get_default_format
  389.     import gui.uberwidgets.formattedinput
  390.     return fmtstr.singleformat(msg, get_default_format())
  391.  
  392. if __name__ == '__main__':
  393.     convo = Conversation()
  394.     
  395.     def convo_changed(source, attr, old, new):
  396.         print attr, old, new
  397.  
  398.     convo.add_observer(convo_changed)
  399.     convo.last_message = 'test message'
  400.  
  401.