home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2011 October / maximum-cd-2011-10.iso / DiscContents / digsby_setup.exe / lib / pyxmpp / jabber / disco.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2011-06-22  |  18.1 KB  |  610 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.6)
  3.  
  4. __revision__ = '$Id: disco.py 714 2010-04-05 10:20:10Z jajcus $'
  5. __docformat__ = 'restructuredtext en'
  6. import warnings
  7. import libxml2
  8. from pyxmpp.xmlextra import common_doc, common_root
  9. from pyxmpp.jid import JID
  10. from pyxmpp import cache
  11. from pyxmpp.utils import to_utf8
  12. from pyxmpp.objects import StanzaPayloadWrapperObject
  13. from pyxmpp.exceptions import ProtocolError
  14. DISCO_NS = 'http://jabber.org/protocol/disco'
  15. DISCO_ITEMS_NS = DISCO_NS + '#items'
  16. DISCO_INFO_NS = DISCO_NS + '#info'
  17.  
  18. class DiscoItem(StanzaPayloadWrapperObject):
  19.     
  20.     def __init__(self, disco, xmlnode_or_jid, node = None, name = None, action = None):
  21.         self.disco = disco
  22.         if isinstance(xmlnode_or_jid, JID):
  23.             if disco:
  24.                 self.xmlnode = disco.xmlnode.newChild(None, 'item', None)
  25.             else:
  26.                 self.xmlnode = common_root.newChild(None, 'item', None)
  27.                 ns = self.xmlnode.newNs(DISCO_ITEMS_NS, None)
  28.                 self.xmlnode.setNs(ns)
  29.             self.set_jid(xmlnode_or_jid)
  30.             self.set_name(name)
  31.             self.set_node(node)
  32.             self.set_action(action)
  33.         elif disco is None:
  34.             self.xmlnode = xmlnode_or_jid.copyNode(1)
  35.         else:
  36.             self.xmlnode = xmlnode_or_jid
  37.         if name:
  38.             self.set_name(name)
  39.         
  40.         if node:
  41.             self.set_node(node)
  42.         
  43.         if action:
  44.             self.set_action(action)
  45.         
  46.         self.xpath_ctxt = common_doc.xpathNewContext()
  47.         self.xpath_ctxt.setContextNode(self.xmlnode)
  48.         self.xpath_ctxt.xpathRegisterNs('d', DISCO_ITEMS_NS)
  49.  
  50.     
  51.     def __del__(self):
  52.         if self.disco is None:
  53.             if self.xmlnode:
  54.                 self.xmlnode.unlinkNode()
  55.                 self.xmlnode.freeNode()
  56.                 self.xmlnode = None
  57.             
  58.         
  59.         if self.xpath_ctxt:
  60.             self.xpath_ctxt.xpathFreeContext()
  61.         
  62.  
  63.     
  64.     def __str__(self):
  65.         return self.xmlnode.serialize()
  66.  
  67.     
  68.     def remove(self):
  69.         if self.disco is None:
  70.             return None
  71.         self.xmlnode.unlinkNode()
  72.         oldns = self.xmlnode.ns()
  73.         ns = self.xmlnode.newNs(oldns.getContent(), None)
  74.         self.xmlnode.replaceNs(oldns, ns)
  75.         common_root.addChild(self.xmlnode())
  76.         self.disco = None
  77.  
  78.     
  79.     def get_name(self):
  80.         name = self.xmlnode.prop('name')
  81.         if name is None:
  82.             return None
  83.         return name.decode('utf-8')
  84.  
  85.     
  86.     def set_name(self, name):
  87.         if name is None:
  88.             if self.xmlnode.hasProp('name'):
  89.                 self.xmlnode.unsetProp('name')
  90.             
  91.             return None
  92.         name = unicode(name)
  93.         self.xmlnode.setProp('name', name.encode('utf-8'))
  94.  
  95.     name = property(get_name, set_name)
  96.     
  97.     def get_node(self):
  98.         node = self.xmlnode.prop('node')
  99.         if node is None:
  100.             return None
  101.         return node.decode('utf-8')
  102.  
  103.     
  104.     def set_node(self, node):
  105.         if node is None:
  106.             if self.xmlnode.hasProp('node'):
  107.                 self.xmlnode.unsetProp('node')
  108.             
  109.             return None
  110.         node = unicode(node)
  111.         self.xmlnode.setProp('node', node.encode('utf-8'))
  112.  
  113.     node = property(get_node, set_node)
  114.     
  115.     def get_action(self):
  116.         action = self.xmlnode.prop('action')
  117.         if action is None:
  118.             return None
  119.         return action.decode('utf-8')
  120.  
  121.     
  122.     def set_action(self, action):
  123.         if action is None:
  124.             if self.xmlnode.hasProp('action'):
  125.                 self.xmlnode.unsetProp('action')
  126.             
  127.             return None
  128.         if action not in ('remove', 'update'):
  129.             raise ValueError, "Action must be 'update' or 'remove'"
  130.         action not in ('remove', 'update')
  131.         action = unicode(action)
  132.         self.xmlnode.setProp('action', action.encode('utf-8'))
  133.  
  134.     action = property(get_action, set_action)
  135.     
  136.     def get_jid(self):
  137.         jid = self.xmlnode.prop('jid')
  138.         return JID(jid.decode('utf-8'))
  139.  
  140.     
  141.     def set_jid(self, jid):
  142.         self.xmlnode.setProp('jid', jid.as_unicode().encode('utf-8'))
  143.  
  144.     jid = property(get_jid, set_jid)
  145.  
  146.  
  147. class DiscoIdentity(StanzaPayloadWrapperObject):
  148.     
  149.     def __init__(self, disco, xmlnode_or_name, item_category = None, item_type = None, replace = False):
  150.         self.disco = disco
  151.         if disco and replace:
  152.             old = disco.xpath_ctxt.xpathEval('d:identity')
  153.             if old:
  154.                 for n in old:
  155.                     n.unlinkNode()
  156.                     n.freeNode()
  157.                 
  158.             
  159.         
  160.         if isinstance(xmlnode_or_name, libxml2.xmlNode):
  161.             if disco is None:
  162.                 self.xmlnode = xmlnode_or_name.copyNode(1)
  163.             else:
  164.                 self.xmlnode = xmlnode_or_name
  165.         elif not item_category:
  166.             raise ValueError, 'DiscoInfo requires category'
  167.         elif not item_type:
  168.             raise ValueError, 'DiscoInfo requires type'
  169.         elif disco:
  170.             self.xmlnode = disco.xmlnode.newChild(None, 'identity', None)
  171.         else:
  172.             self.xmlnode = common_root.newChild(None, 'identity', None)
  173.             ns = self.xmlnode.newNs(DISCO_INFO_NS, None)
  174.             self.xmlnode.setNs(ns)
  175.         self.set_name(xmlnode_or_name)
  176.         self.set_category(item_category)
  177.         self.set_type(item_type)
  178.         self.xpath_ctxt = common_doc.xpathNewContext()
  179.         self.xpath_ctxt.setContextNode(self.xmlnode)
  180.         self.xpath_ctxt.xpathRegisterNs('d', DISCO_INFO_NS)
  181.  
  182.     
  183.     def __del__(self):
  184.         if self.disco is None:
  185.             if self.xmlnode:
  186.                 self.xmlnode.unlinkNode()
  187.                 self.xmlnode.freeNode()
  188.                 self.xmlnode = None
  189.             
  190.         
  191.         if self.xpath_ctxt:
  192.             self.xpath_ctxt.xpathFreeContext()
  193.         
  194.  
  195.     
  196.     def __str__(self):
  197.         return self.xmlnode.serialize()
  198.  
  199.     
  200.     def remove(self):
  201.         if self.disco is None:
  202.             return None
  203.         self.xmlnode.unlinkNode()
  204.         oldns = self.xmlnode.ns()
  205.         ns = self.xmlnode.newNs(oldns.getContent(), None)
  206.         self.xmlnode.replaceNs(oldns, ns)
  207.         common_root.addChild(self.xmlnode())
  208.         self.disco = None
  209.  
  210.     
  211.     def get_name(self):
  212.         var = self.xmlnode.prop('name')
  213.         if not var:
  214.             var = ''
  215.         
  216.         return var.decode('utf-8')
  217.  
  218.     
  219.     def set_name(self, name):
  220.         if not name:
  221.             raise ValueError, 'name is required in DiscoIdentity'
  222.         name
  223.         name = unicode(name)
  224.         self.xmlnode.setProp('name', name.encode('utf-8'))
  225.  
  226.     name = property(get_name, set_name)
  227.     
  228.     def get_category(self):
  229.         var = self.xmlnode.prop('category')
  230.         if not var:
  231.             var = '?'
  232.         
  233.         return var.decode('utf-8')
  234.  
  235.     
  236.     def set_category(self, category):
  237.         if not category:
  238.             raise ValueError, 'Category is required in DiscoIdentity'
  239.         category
  240.         category = unicode(category)
  241.         self.xmlnode.setProp('category', category.encode('utf-8'))
  242.  
  243.     category = property(get_category, set_category)
  244.     
  245.     def get_type(self):
  246.         item_type = self.xmlnode.prop('type')
  247.         if not item_type:
  248.             item_type = '?'
  249.         
  250.         return item_type.decode('utf-8')
  251.  
  252.     
  253.     def set_type(self, item_type):
  254.         if not item_type:
  255.             raise ValueError, 'Type is required in DiscoIdentity'
  256.         item_type
  257.         item_type = unicode(item_type)
  258.         self.xmlnode.setProp('type', item_type.encode('utf-8'))
  259.  
  260.     type = property(get_type, set_type)
  261.  
  262.  
  263. class DiscoItems(StanzaPayloadWrapperObject):
  264.     
  265.     def __init__(self, xmlnode_or_node = None):
  266.         self.xmlnode = None
  267.         self.xpath_ctxt = None
  268.         if isinstance(xmlnode_or_node, libxml2.xmlNode):
  269.             ns = xmlnode_or_node.ns()
  270.             if ns.getContent() != DISCO_ITEMS_NS:
  271.                 raise ValueError, 'Bad disco-items namespace'
  272.             ns.getContent() != DISCO_ITEMS_NS
  273.             self.xmlnode = xmlnode_or_node.docCopyNode(common_doc, 1)
  274.             common_root.addChild(self.xmlnode)
  275.             self.ns = self.xmlnode.ns()
  276.         else:
  277.             self.xmlnode = common_root.newChild(None, 'query', None)
  278.             self.ns = self.xmlnode.newNs(DISCO_ITEMS_NS, None)
  279.             self.xmlnode.setNs(self.ns)
  280.             self.set_node(xmlnode_or_node)
  281.         self.xpath_ctxt = common_doc.xpathNewContext()
  282.         self.xpath_ctxt.setContextNode(self.xmlnode)
  283.         self.xpath_ctxt.xpathRegisterNs('d', DISCO_ITEMS_NS)
  284.  
  285.     
  286.     def __del__(self):
  287.         if self.xmlnode:
  288.             self.xmlnode.unlinkNode()
  289.             self.xmlnode.freeNode()
  290.             self.xmlnode = None
  291.         
  292.         if self.xpath_ctxt:
  293.             self.xpath_ctxt.xpathFreeContext()
  294.             self.xpath_ctxt = None
  295.         
  296.  
  297.     
  298.     def get_node(self):
  299.         node = self.xmlnode.prop('node')
  300.         if not node:
  301.             return None
  302.         return node.decode('utf-8')
  303.  
  304.     
  305.     def set_node(self, node):
  306.         if node is None:
  307.             if self.xmlnode.hasProp('node'):
  308.                 self.xmlnode.unsetProp('node')
  309.             
  310.             return None
  311.         node = unicode(node)
  312.         self.xmlnode.setProp('node', node.encode('utf-8'))
  313.  
  314.     node = property(get_node, set_node)
  315.     
  316.     def get_items(self):
  317.         ret = []
  318.         l = self.xpath_ctxt.xpathEval('d:item')
  319.         if l is not None:
  320.             for i in l:
  321.                 ret.append(DiscoItem(self, i))
  322.             
  323.         
  324.         return ret
  325.  
  326.     
  327.     def set_items(self, item_list):
  328.         for item in self.items:
  329.             item.remove()
  330.         
  331.         for item in item_list:
  332.             
  333.             try:
  334.                 self.add_item(item.jid, item.node, item.name, item.action)
  335.             continue
  336.             except AttributeError:
  337.                 self.add_item(*item)
  338.                 continue
  339.             
  340.  
  341.         
  342.  
  343.     items = property(get_items, set_items, doc = 'List of `DiscoItems`')
  344.     
  345.     def invalidate_items(self):
  346.         warnings.warn('DiscoItems.invalidate_items() is deprecated and not needed any more.', DeprecationWarning, stacklevel = 1)
  347.  
  348.     
  349.     def add_item(self, jid, node = None, name = None, action = None):
  350.         return DiscoItem(self, jid, node, name, action)
  351.  
  352.     
  353.     def has_item(self, jid, node = None):
  354.         l = self.xpath_ctxt.xpathEval('d:item')
  355.         if l is None:
  356.             return False
  357.         for it in l:
  358.             di = DiscoItem(self, it)
  359.             if di.jid == jid and di.node == node:
  360.                 return True
  361.         
  362.         return False
  363.  
  364.  
  365.  
  366. class DiscoInfo(StanzaPayloadWrapperObject):
  367.     
  368.     def __init__(self, xmlnode_or_node = None, parent = None, doc = None):
  369.         self.xmlnode = None
  370.         self.xpath_ctxt = None
  371.         if not doc:
  372.             doc = common_doc
  373.         
  374.         if not parent:
  375.             parent = common_root
  376.         
  377.         if isinstance(xmlnode_or_node, libxml2.xmlNode):
  378.             ns = xmlnode_or_node.ns()
  379.             if ns.getContent() != DISCO_INFO_NS:
  380.                 raise ValueError, 'Bad disco-info namespace'
  381.             ns.getContent() != DISCO_INFO_NS
  382.             self.xmlnode = xmlnode_or_node.docCopyNode(doc, 1)
  383.             parent.addChild(self.xmlnode)
  384.         else:
  385.             self.xmlnode = parent.newChild(None, 'query', None)
  386.             self.ns = self.xmlnode.newNs(DISCO_INFO_NS, None)
  387.             self.xmlnode.setNs(self.ns)
  388.             self.set_node(xmlnode_or_node)
  389.         self.xpath_ctxt = doc.xpathNewContext()
  390.         self.xpath_ctxt.setContextNode(self.xmlnode)
  391.         self.xpath_ctxt.xpathRegisterNs('d', DISCO_INFO_NS)
  392.  
  393.     
  394.     def __del__(self):
  395.         if self.xmlnode:
  396.             self.xmlnode.unlinkNode()
  397.             self.xmlnode.freeNode()
  398.             self.xmlnode = None
  399.         
  400.         if self.xpath_ctxt:
  401.             self.xpath_ctxt.xpathFreeContext()
  402.             self.xpath_ctxt = None
  403.         
  404.  
  405.     
  406.     def get_node(self):
  407.         node = self.xmlnode.prop('node')
  408.         if not node:
  409.             return None
  410.         return node.decode('utf-8')
  411.  
  412.     
  413.     def set_node(self, node):
  414.         if node is None:
  415.             if self.xmlnode.hasProp('node'):
  416.                 self.xmlnode.unsetProp('node')
  417.             
  418.             return None
  419.         node = unicode(node)
  420.         self.xmlnode.setProp('node', node.encode('utf-8'))
  421.  
  422.     node = property(get_node, set_node)
  423.     
  424.     def get_features(self):
  425.         l = self.xpath_ctxt.xpathEval('d:feature')
  426.         ret = []
  427.         for f in l:
  428.             if f.hasProp('var'):
  429.                 ret.append(f.prop('var').decode('utf-8'))
  430.                 continue
  431.         
  432.         return ret
  433.  
  434.     
  435.     def set_features(self, features):
  436.         for var in self.features:
  437.             self.remove_feature(var)
  438.         
  439.         for var in features:
  440.             self.add_feature(var)
  441.         
  442.  
  443.     features = property(get_features, set_features)
  444.     
  445.     def has_feature(self, var):
  446.         if not var:
  447.             raise ValueError, 'var is None'
  448.         var
  449.         if '"' not in var:
  450.             expr = u'd:feature[@var="%s"]' % (var,)
  451.         elif "'" not in var:
  452.             expr = u"d:feature[@var='%s']" % (var,)
  453.         else:
  454.             raise ValueError, 'Invalid feature name'
  455.         l = ('"' not in var).xpath_ctxt.xpathEval(to_utf8(expr))
  456.         if l:
  457.             return True
  458.         return False
  459.  
  460.     
  461.     def invalidate_features(self):
  462.         warnings.warn('DiscoInfo.invalidate_features() is deprecated and not needed any more.', DeprecationWarning, stacklevel = 1)
  463.  
  464.     
  465.     def add_feature(self, var):
  466.         if self.has_feature(var):
  467.             return None
  468.         n = self.xmlnode.newChild(None, 'feature', None)
  469.         n.setProp('var', to_utf8(var))
  470.  
  471.     
  472.     def remove_feature(self, var):
  473.         if not var:
  474.             raise ValueError, 'var is None'
  475.         var
  476.         if '"' not in var:
  477.             expr = 'd:feature[@var="%s"]' % (var,)
  478.         elif "'" not in var:
  479.             expr = "d:feature[@var='%s']" % (var,)
  480.         else:
  481.             raise ValueError, 'Invalid feature name'
  482.         l = ('"' not in var).xpath_ctxt.xpathEval(expr)
  483.         if not l:
  484.             return None
  485.         for f in l:
  486.             f.unlinkNode()
  487.             f.freeNode()
  488.         
  489.  
  490.     
  491.     def get_identities(self):
  492.         ret = []
  493.         l = self.xpath_ctxt.xpathEval('d:identity')
  494.         if l is not None:
  495.             for i in l:
  496.                 ret.append(DiscoIdentity(self, i))
  497.             
  498.         
  499.         return ret
  500.  
  501.     
  502.     def set_identities(self, identities):
  503.         for identity in self.identities:
  504.             identity.remove()
  505.         
  506.         for identity in identities:
  507.             
  508.             try:
  509.                 self.add_identity(identity.name, identity.category, identity.type)
  510.             continue
  511.             except AttributeError:
  512.                 self.add_identity(*identity)
  513.                 continue
  514.             
  515.  
  516.         
  517.  
  518.     identities = property(get_identities, set_identities)
  519.     
  520.     def identity_is(self, item_category, item_type = None):
  521.         if not item_category:
  522.             raise ValueError, 'bad category'
  523.         item_category
  524.         if not item_type:
  525.             type_expr = u''
  526.         elif '"' not in item_type:
  527.             type_expr = u' and @type="%s"' % (item_type,)
  528.         elif "'" not in type:
  529.             type_expr = u" and @type='%s'" % (item_type,)
  530.         else:
  531.             raise ValueError, 'Invalid type name'
  532.         if item_type not in item_category:
  533.             expr = u'd:identity[@category="%s"%s]' % (item_category, type_expr)
  534.         elif "'" not in item_category:
  535.             expr = u"d:identity[@category='%s'%s]" % (item_category, type_expr)
  536.         else:
  537.             raise ValueError, 'Invalid category name'
  538.         l = (item_type not in item_category).xpath_ctxt.xpathEval(to_utf8(expr))
  539.         if l:
  540.             return True
  541.         return False
  542.  
  543.     
  544.     def invalidate_identities(self):
  545.         warnings.warn('DiscoInfo.invalidate_identities() is deprecated and not needed any more.', DeprecationWarning, stacklevel = 1)
  546.  
  547.     
  548.     def add_identity(self, item_name, item_category = None, item_type = None):
  549.         return DiscoIdentity(self, item_name, item_category, item_type)
  550.  
  551.  
  552.  
  553. class DiscoCacheFetcherBase(cache.CacheFetcher):
  554.     stream = None
  555.     disco_class = None
  556.     
  557.     def fetch(self):
  558.         Iq = Iq
  559.         import pyxmpp.iq
  560.         (jid, node) = self.address
  561.         iq = Iq(to_jid = jid, stanza_type = 'get')
  562.         disco = self.disco_class(node)
  563.         iq.add_content(disco.xmlnode)
  564.         self.stream.set_response_handlers(iq, self._DiscoCacheFetcherBase__response, self._DiscoCacheFetcherBase__error, self._DiscoCacheFetcherBase__timeout)
  565.         self.stream.send(iq)
  566.  
  567.     
  568.     def __response(self, stanza):
  569.         
  570.         try:
  571.             d = self.disco_class(stanza.get_query())
  572.             self.got_it(d)
  573.         except ValueError:
  574.             e = None
  575.             self.error(e)
  576.  
  577.  
  578.     
  579.     def __error(self, stanza):
  580.         
  581.         try:
  582.             self.error(stanza.get_error())
  583.         except ProtocolError:
  584.             StanzaErrorNode = StanzaErrorNode
  585.             import pyxmpp.error
  586.             self.error(StanzaErrorNode('undefined-condition'))
  587.  
  588.  
  589.     
  590.     def __timeout(self, stanza):
  591.         pass
  592.  
  593.  
  594.  
  595. def register_disco_cache_fetchers(cache_suite, stream):
  596.     tmp = stream
  597.     
  598.     class DiscoInfoCacheFetcher((DiscoCacheFetcherBase,)):
  599.         stream = tmp
  600.         disco_class = DiscoInfo
  601.  
  602.     
  603.     class DiscoItemsCacheFetcher((DiscoCacheFetcherBase,)):
  604.         stream = tmp
  605.         disco_class = DiscoItems
  606.  
  607.     cache_suite.register_fetcher(DiscoInfo, DiscoInfoCacheFetcher)
  608.     cache_suite.register_fetcher(DiscoItems, DiscoItemsCacheFetcher)
  609.  
  610.