home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2011 February / maximum-cd-2011-02.iso / DiscContents / digsby_setup85.exe / lib / pyxmpp / jabber / muc.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-11-24  |  16.4 KB  |  494 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.6)
  3.  
  4. __revision__ = '$Id: muc.py 714 2010-04-05 10:20:10Z jajcus $'
  5. __docformat__ = 'restructuredtext en'
  6. import logging
  7. from pyxmpp.presence import Presence
  8. from pyxmpp.message import Message
  9. from pyxmpp.iq import Iq
  10. from pyxmpp.jid import JID
  11. from pyxmpp.xmlextra import xml_element_ns_iter
  12. from pyxmpp.jabber.muccore import MucPresence, MucUserX, MucItem, MucStatus
  13. from pyxmpp.jabber.muccore import MUC_OWNER_NS
  14. from pyxmpp.jabber.dataforms import DATAFORM_NS, Form
  15. import weakref
  16.  
  17. class MucRoomHandler:
  18.     
  19.     def __init__(self):
  20.         self.room_state = None
  21.         self._MucRoomHandler__logger = logging.getLogger('pyxmpp.jabber.MucRoomHandler')
  22.  
  23.     
  24.     def assign_state(self, state_obj):
  25.         self.room_state = state_obj
  26.  
  27.     
  28.     def room_created(self, stanza):
  29.         _unused = stanza
  30.         self.room_state.request_instant_room()
  31.  
  32.     
  33.     def configuration_form_received(self, form):
  34.         pass
  35.  
  36.     
  37.     def room_configured(self):
  38.         pass
  39.  
  40.     
  41.     def user_joined(self, user, stanza):
  42.         pass
  43.  
  44.     
  45.     def user_left(self, user, stanza):
  46.         pass
  47.  
  48.     
  49.     def role_changed(self, user, old_role, new_role, stanza):
  50.         pass
  51.  
  52.     
  53.     def affiliation_changed(self, user, old_aff, new_aff, stanza):
  54.         pass
  55.  
  56.     
  57.     def nick_change(self, user, new_nick, stanza):
  58.         pass
  59.  
  60.     
  61.     def nick_changed(self, user, old_nick, stanza):
  62.         pass
  63.  
  64.     
  65.     def presence_changed(self, user, stanza):
  66.         pass
  67.  
  68.     
  69.     def subject_changed(self, user, stanza):
  70.         pass
  71.  
  72.     
  73.     def message_received(self, user, stanza):
  74.         pass
  75.  
  76.     
  77.     def room_configuration_error(self, stanza):
  78.         self.error(stanza)
  79.  
  80.     
  81.     def error(self, stanza):
  82.         err = stanza.get_error()
  83.         self._MucRoomHandler__logger.debug('Error from: %r Condition: %r' % (stanza.get_from(), err.get_condition))
  84.  
  85.  
  86.  
  87. class MucRoomUser:
  88.     
  89.     def __init__(self, presence_or_user_or_jid):
  90.         if isinstance(presence_or_user_or_jid, MucRoomUser):
  91.             self.presence = presence_or_user_or_jid.presence
  92.             self.role = presence_or_user_or_jid.role
  93.             self.affiliation = presence_or_user_or_jid.affiliation
  94.             self.room_jid = presence_or_user_or_jid.room_jid
  95.             self.real_jid = presence_or_user_or_jid.real_jid
  96.             self.nick = presence_or_user_or_jid.nick
  97.             self.new_nick = None
  98.         else:
  99.             self.affiliation = 'none'
  100.             self.presence = None
  101.             self.real_jid = None
  102.             self.new_nick = None
  103.             if isinstance(presence_or_user_or_jid, JID):
  104.                 self.nick = presence_or_user_or_jid.resource
  105.                 self.room_jid = presence_or_user_or_jid
  106.                 self.role = 'none'
  107.             elif isinstance(presence_or_user_or_jid, Presence):
  108.                 self.nick = None
  109.                 self.room_jid = None
  110.                 self.role = 'participant'
  111.                 self.update_presence(presence_or_user_or_jid)
  112.             else:
  113.                 raise TypeError, 'Bad argument type for MucRoomUser constructor'
  114.             return isinstance(presence_or_user_or_jid, JID)
  115.  
  116.     
  117.     def update_presence(self, presence):
  118.         self.presence = MucPresence(presence)
  119.         t = presence.get_type()
  120.         if t == 'unavailable':
  121.             self.role = 'none'
  122.             self.affiliation = 'none'
  123.         
  124.         self.room_jid = self.presence.get_from()
  125.         self.nick = self.room_jid.resource
  126.         mc = self.presence.get_muc_child()
  127.         if isinstance(mc, MucUserX):
  128.             items = mc.get_items()
  129.             for item in items:
  130.                 if not isinstance(item, MucItem):
  131.                     continue
  132.                 
  133.                 if item.role:
  134.                     self.role = item.role
  135.                 
  136.                 if item.affiliation:
  137.                     self.affiliation = item.affiliation
  138.                 
  139.                 if item.jid:
  140.                     self.real_jid = item.jid
  141.                 
  142.                 if item.nick:
  143.                     self.new_nick = item.nick
  144.                 
  145.             
  146.         
  147.  
  148.     
  149.     def same_as(self, other):
  150.         return self.room_jid == other.room_jid
  151.  
  152.  
  153.  
  154. class MucRoomState:
  155.     
  156.     def __init__(self, manager, own_jid, room_jid, handler):
  157.         self.own_jid = own_jid
  158.         self.room_jid = room_jid
  159.         self.handler = handler
  160.         self.manager = weakref.proxy(manager)
  161.         self.joined = False
  162.         self.subject = None
  163.         self.users = { }
  164.         self.me = MucRoomUser(room_jid)
  165.         self.configured = None
  166.         self.configuration_form = None
  167.         handler.assign_state(self)
  168.         self._MucRoomState__logger = logging.getLogger('pyxmpp.jabber.MucRoomState')
  169.  
  170.     
  171.     def get_user(self, nick_or_jid, create = False):
  172.         if isinstance(nick_or_jid, JID):
  173.             if not nick_or_jid.resource:
  174.                 return None
  175.             for u in self.users.values():
  176.                 if nick_or_jid in (u.room_jid, u.real_jid):
  177.                     return u
  178.             
  179.             if create:
  180.                 return MucRoomUser(nick_or_jid)
  181.             return None
  182.         isinstance(nick_or_jid, JID)
  183.         return self.users.get(nick_or_jid)
  184.  
  185.     
  186.     def set_stream(self, stream):
  187.         _unused = stream
  188.         if self.joined and self.handler:
  189.             self.handler.user_left(self.me, None)
  190.         
  191.         self.joined = False
  192.  
  193.     
  194.     def join(self, password = None, history_maxchars = None, history_maxstanzas = None, history_seconds = None, history_since = None):
  195.         if self.joined:
  196.             raise RuntimeError, 'Room is already joined'
  197.         self.joined
  198.         p = MucPresence(to_jid = self.room_jid)
  199.         p.make_join_request(password, history_maxchars, history_maxstanzas, history_seconds, history_since)
  200.         self.manager.stream.send(p)
  201.  
  202.     
  203.     def leave(self):
  204.         if self.joined:
  205.             p = MucPresence(to_jid = self.room_jid, stanza_type = 'unavailable')
  206.             self.manager.stream.send(p)
  207.         
  208.  
  209.     
  210.     def send_message(self, body):
  211.         m = Message(to_jid = self.room_jid.bare(), stanza_type = 'groupchat', body = body)
  212.         self.manager.stream.send(m)
  213.  
  214.     
  215.     def set_subject(self, subject):
  216.         m = Message(to_jid = self.room_jid.bare(), stanza_type = 'groupchat', subject = subject)
  217.         self.manager.stream.send(m)
  218.  
  219.     
  220.     def change_nick(self, new_nick):
  221.         new_room_jid = JID(self.room_jid.node, self.room_jid.domain, new_nick)
  222.         p = Presence(to_jid = new_room_jid)
  223.         self.manager.stream.send(p)
  224.  
  225.     
  226.     def get_room_jid(self, nick = None):
  227.         if nick is None:
  228.             return self.room_jid
  229.         return JID(self.room_jid.node, self.room_jid.domain, nick)
  230.  
  231.     
  232.     def get_nick(self):
  233.         return self.room_jid.resource
  234.  
  235.     
  236.     def process_available_presence(self, stanza):
  237.         fr = stanza.get_from()
  238.         if not fr.resource:
  239.             return None
  240.         nick = fr.resource
  241.         user = self.users.get(nick)
  242.         if user:
  243.             old_user = MucRoomUser(user)
  244.             user.update_presence(stanza)
  245.             user.nick = nick
  246.         else:
  247.             old_user = None
  248.             user = MucRoomUser(stanza)
  249.             self.users[user.nick] = user
  250.         self.handler.presence_changed(user, stanza)
  251.         if fr == self.room_jid and not (self.joined):
  252.             self.joined = True
  253.             self.me = user
  254.             mc = stanza.get_muc_child()
  255.             if self.configured is None:
  256.                 self.configured = True
  257.             
  258.         
  259.         if not old_user or old_user.role == 'none':
  260.             self.handler.user_joined(user, stanza)
  261.         elif old_user.nick != user.nick:
  262.             self.handler.nick_changed(user, old_user.nick, stanza)
  263.             if old_user.room_jid == self.room_jid:
  264.                 self.room_jid = fr
  265.             
  266.         
  267.         if old_user.role != user.role:
  268.             self.handler.role_changed(user, old_user.role, user.role, stanza)
  269.         
  270.         if old_user.affiliation != user.affiliation:
  271.             self.handler.affiliation_changed(user, old_user.affiliation, user.affiliation, stanza)
  272.         
  273.  
  274.     
  275.     def process_unavailable_presence(self, stanza):
  276.         fr = stanza.get_from()
  277.         if not fr.resource:
  278.             return None
  279.         nick = fr.resource
  280.         user = self.users.get(nick)
  281.         if user:
  282.             old_user = MucRoomUser(user)
  283.             user.update_presence(stanza)
  284.             self.handler.presence_changed(user, stanza)
  285.             if user.new_nick:
  286.                 mc = stanza.get_muc_child()
  287.                 if isinstance(mc, MucUserX):
  288.                     renames = _[1]
  289.                     if renames:
  290.                         self.users[user.new_nick] = user
  291.                         del self.users[nick]
  292.                         return None
  293.                 
  294.             
  295.         else:
  296.             old_user = None
  297.             user = MucRoomUser(stanza)
  298.             self.users[user.nick] = user
  299.             self.handler.presence_changed(user, stanza)
  300.         if fr == self.room_jid and self.joined:
  301.             self.joined = False
  302.             self.handler.user_left(user, stanza)
  303.             self.manager.forget(self)
  304.             self.me = user
  305.         elif old_user:
  306.             self.handler.user_left(user, stanza)
  307.         
  308.  
  309.     
  310.     def process_groupchat_message(self, stanza):
  311.         fr = stanza.get_from()
  312.         user = self.get_user(fr, True)
  313.         s = stanza.get_subject()
  314.         if s:
  315.             self.subject = s
  316.             self.handler.subject_changed(user, stanza)
  317.         else:
  318.             self.handler.message_received(user, stanza)
  319.  
  320.     
  321.     def process_error_message(self, stanza):
  322.         self.handler.error(stanza)
  323.  
  324.     
  325.     def process_error_presence(self, stanza):
  326.         self.handler.error(stanza)
  327.  
  328.     
  329.     def process_configuration_form_success(self, stanza):
  330.         if stanza.get_query_ns() != MUC_OWNER_NS:
  331.             raise ValueError, 'Bad result namespace'
  332.         stanza.get_query_ns() != MUC_OWNER_NS
  333.         query = stanza.get_query()
  334.         form = None
  335.         for el in xml_element_ns_iter(query.children, DATAFORM_NS):
  336.             form = Form(el)
  337.         
  338.         if not form:
  339.             raise ValueError, 'No form received'
  340.         form
  341.         self.configuration_form = form
  342.         self.handler.configuration_form_received(form)
  343.  
  344.     
  345.     def process_configuration_form_error(self, stanza):
  346.         self.handler.error(stanza)
  347.  
  348.     
  349.     def request_configuration_form(self):
  350.         iq = Iq(to_jid = self.room_jid.bare(), stanza_type = 'get')
  351.         iq.new_query(MUC_OWNER_NS, 'query')
  352.         self.manager.stream.set_response_handlers(iq, self.process_configuration_form_success, self.process_configuration_form_error)
  353.         self.manager.stream.send(iq)
  354.         return iq.get_id()
  355.  
  356.     
  357.     def process_configuration_success(self, stanza):
  358.         _unused = stanza
  359.         self.configured = True
  360.         self.handler.room_configured()
  361.  
  362.     
  363.     def process_configuration_error(self, stanza):
  364.         self.handler.room_configuration_error(stanza)
  365.  
  366.     
  367.     def configure_room(self, form):
  368.         if form.type == 'cancel':
  369.             return None
  370.         if form.type != 'submit':
  371.             raise ValueError, "A 'submit' form required to configure a room"
  372.         form.type != 'submit'
  373.         iq = Iq(to_jid = self.room_jid.bare(), stanza_type = 'set')
  374.         query = iq.new_query(MUC_OWNER_NS, 'query')
  375.         form.as_xml(query)
  376.         self.manager.stream.set_response_handlers(iq, self.process_configuration_success, self.process_configuration_error)
  377.         self.manager.stream.send(iq)
  378.         return iq.get_id()
  379.  
  380.     
  381.     def request_instant_room(self):
  382.         if self.configured:
  383.             raise RuntimeError, 'Instant room may be requested for unconfigured room only'
  384.         self.configured
  385.         form = Form('submit')
  386.         return self.configure_room(form)
  387.  
  388.  
  389.  
  390. class MucRoomManager:
  391.     
  392.     def __init__(self, stream):
  393.         self.rooms = { }
  394.         (self.stream, self.jid) = (None, None)
  395.         self.set_stream(stream)
  396.         self._MucRoomManager__logger = logging.getLogger('pyxmpp.jabber.MucRoomManager')
  397.  
  398.     
  399.     def set_stream(self, stream):
  400.         self.jid = stream.me
  401.         self.stream = stream
  402.         for r in self.rooms.values():
  403.             r.set_stream(stream)
  404.         
  405.  
  406.     
  407.     def set_handlers(self, priority = 10):
  408.         self.stream.set_message_handler('groupchat', self._MucRoomManager__groupchat_message, None, priority)
  409.         self.stream.set_message_handler('error', self._MucRoomManager__error_message, None, priority)
  410.         self.stream.set_presence_handler('available', self._MucRoomManager__presence_available, None, priority)
  411.         self.stream.set_presence_handler('unavailable', self._MucRoomManager__presence_unavailable, None, priority)
  412.         self.stream.set_presence_handler('error', self._MucRoomManager__presence_error, None, priority)
  413.  
  414.     
  415.     def join(self, room, nick, handler, password = None, history_maxchars = None, history_maxstanzas = None, history_seconds = None, history_since = None):
  416.         if not (room.node) or room.resource:
  417.             raise ValueError, 'Invalid room JID'
  418.         room.resource
  419.         room_jid = JID(room.node, room.domain, nick)
  420.         cur_rs = self.rooms.get(room_jid.bare().as_unicode())
  421.         if cur_rs and cur_rs.joined:
  422.             raise RuntimeError, 'Room already joined'
  423.         cur_rs.joined
  424.         rs = MucRoomState(self, self.stream.me, room_jid, handler)
  425.         self.rooms[room_jid.bare().as_unicode()] = rs
  426.         rs.join(password, history_maxchars, history_maxstanzas, history_seconds, history_since)
  427.         return rs
  428.  
  429.     
  430.     def get_room_state(self, room):
  431.         return self.rooms.get(room.bare().as_unicode())
  432.  
  433.     
  434.     def forget(self, rs):
  435.         
  436.         try:
  437.             del self.rooms[rs.room_jid.bare().as_unicode()]
  438.         except KeyError:
  439.             pass
  440.  
  441.  
  442.     
  443.     def __groupchat_message(self, stanza):
  444.         fr = stanza.get_from()
  445.         key = fr.bare().as_unicode()
  446.         rs = self.rooms.get(key)
  447.         if not rs:
  448.             self._MucRoomManager__logger.debug('groupchat message from unknown source')
  449.             return False
  450.         rs.process_groupchat_message(stanza)
  451.         return True
  452.  
  453.     
  454.     def __error_message(self, stanza):
  455.         fr = stanza.get_from()
  456.         key = fr.bare().as_unicode()
  457.         rs = self.rooms.get(key)
  458.         if not rs:
  459.             return False
  460.         rs.process_error_message(stanza)
  461.         return True
  462.  
  463.     
  464.     def __presence_error(self, stanza):
  465.         fr = stanza.get_from()
  466.         key = fr.bare().as_unicode()
  467.         rs = self.rooms.get(key)
  468.         if not rs:
  469.             return False
  470.         rs.process_error_presence(stanza)
  471.         return True
  472.  
  473.     
  474.     def __presence_available(self, stanza):
  475.         fr = stanza.get_from()
  476.         key = fr.bare().as_unicode()
  477.         rs = self.rooms.get(key)
  478.         if not rs:
  479.             return False
  480.         rs.process_available_presence(MucPresence(stanza))
  481.         return True
  482.  
  483.     
  484.     def __presence_unavailable(self, stanza):
  485.         fr = stanza.get_from()
  486.         key = fr.bare().as_unicode()
  487.         rs = self.rooms.get(key)
  488.         if not rs:
  489.             return False
  490.         rs.process_unavailable_presence(MucPresence(stanza))
  491.         return True
  492.  
  493.  
  494.