import gi

 from .protocol import *

 __version__ = "0.9.94"

 ## c14n.py

 ##

 ## Copyright (C) 2007-2008 Brendan Taylor <whateley AT gmail.com>

                 s = s + normalise_text(node.data[cnt])

             s = s + c14n(a, is_buggy)

             cnt += 1

     if not node.kids and s.endswith('>'):

         s=s[:-1]+' />'

     else:

     if os.name == 'nt':

         # gobject.io_add_watch does not work on windows

         return SelectIdleQueue()

 class IdleObject:

     def pollin(self):

         try:

             res = self.pipe.read()

             res = ''

         if res == '':

             return self.pollend()

     def read_timeout(self):

         self.end()

             if not self.alarms[alarm_time]:

                 del self.alarms[alarm_time]

             return True

     def remove_timeout(self, fd, timeout=None):

         """

         union.update(self.error_fds)

         for fd in (union.keys()):

             try:

                 # This file descriptor is invalid. Add to list for closure.

                 bad_fds.append(fd)

         for sub in activity.getChildren():

             if sub.getName() in sub_activities:

                 return sub.getName()

     def set_activity(self, data):

         item = Node('activity', {'xmlns': NS_ACTIVITY})

         jid = item.getAttr('id')

         if jid is None:

             log.warning('No id attr found')

         try:

             jid = JID(jid)

         except Exception as error:

             log.warning('Invalid JID: %s', error)

             log.warning(item)

         conference = item.getTag('conference', namespace=NS_BOOKMARKS_2)

         if conference is None:

             log.warning('No conference node found')

             log.warning(item)

         autojoin = conference.getAttr('autojoin') in ('True', 'true', '1')

         name = conference.getAttr('name')

         if type_ == BookmarkStoreType.PRIVATE:

             log.info('Request bookmarks (Private Storage)')

             return self.get_private_request(), {'type_': type_}

     @callback

     def _bookmarks_received(self, stanza, type_):

     def _on_private_store_result(_client, stanza):

         if not isResultNode(stanza):

             return raise_error(log.info, stanza)

         media = self.getTag('media', namespace=NS_DATA_MEDIA)

         if media:

             return Media(media)

     @media.setter

     def media(self, value):

         hours, minutes = map(int, tz_string.split(':'))

     except Exception:

         log.warning('Wrong tz string: %s', tz_string)

     if hours not in range(-24, 24):

         log.warning('Wrong tz string: %s', tz_string)

     if minutes not in range(0, 59):

         log.warning('Wrong tz string: %s', tz_string)

     if hours in (24, -24) and minutes != 0:

         log.warning('Wrong tz string: %s', tz_string)

     return timezone(timedelta(hours=hours, minutes=minutes))

     def set_location(self, data):

         item = Node('geoloc', {'xmlns': NS_LOCATION})

         if data is None:

         data = data._asdict()

         for tag, value in data:

     @staticmethod

     def _parse_muc_user(muc_user):

         item = muc_user.getTag('item')

 import logging

 import json

 from gi.repository import Soup

 from nbxmpp.protocol import NS_MUCLUMBUS

                                items=results)

     def _http_search_received(self, _session, message, callback, user_data):

         soup_body = message.get_property('response-body')

         if message.status_code != 200:

             log.warning(soup_body.data)

         response = json.loads(soup_body.data)

         result = response['result']

         items = result.get('items')

         if items is None:

         results = []

         for item in items:

                               is_open=item['is_open'],

                               anonymity_mode=anonymity_mode))

     def _parse_nickname(stanza):

         nickname = stanza.getTag('nick', namespace=NS_NICK)

         if nickname is None:

         return nickname.getData() or None

     def set_nickname(self, nickname):

             return

     def _process_pubsub_openpgp(self, _client, stanza, properties):

         <item>

             <public-keys-list xmlns='urn:xmpp:openpgp:0'>

               <pubkey-metadata

                 date='1953-05-16T12:00:00Z'

                 />

             </public-keys-list>

         item = properties.pubsub_event.item

         if item is None:

             # Retract, Deleted or Purged

     pubsub_node = stanza.getTag('pubsub')

     items_node = pubsub_node.getTag('items')

     if node is not None and items_node.getAttr('node') != node:

     if items_node is not None:

         return items_node.getTags('item')

 def get_publish_options(config):

     def set_tune(self, data):

         item = Node('tune', {'xmlns': NS_TUNE})

         if data is None:

         data = data._asdict()

         for tag, value in data.items():

         if len(self._pendingExceptions) > 0:

             _pendingException = self._pendingExceptions.pop()

             sys.excepthook(*_pendingException)

         try:

             self.Stream.Parse(data)

             # end stream:stream tag received

         if len(self._pendingExceptions) > 0:

             _pendingException = self._pendingExceptions.pop()

             sys.excepthook(*_pendingException)

         if len(data) == 0:

             return '0'

         return len(data)

         log.info('Plugging %s __INTO__ %s' % (self, self._owner))

         if self.__class__.__name__ in owner.__dict__:

             log.debug('Plugging ignored: another instance already plugged.')

         self._old_owners_methods=[]

         for method in self._exported_methods:

             if method.__name__ in owner.__dict__:

         # Execute hook

         if hasattr(self, 'plugin'):

             return self.plugin(owner, *args, **kwargs)

     def PlugOut(self, *args, **kwargs):

         """

         if hasattr(self, 'plugout'):

             return self.plugout(*args, **kwargs)

         del self._owner

     @classmethod

     def get_instance(cls, *args, **kwargs):

         for tag in self.getChildren():

             if tag.getName() != 'text' and tag.getNamespace() == NS_XMPP_STREAMS:

                 return tag.getName()

     def get_text(self, pref_lang=None):

         if pref_lang is not None:

         try:

             return self['to']

         except:

     def getFrom(self):

         """

         try:

             return self['from']

         except:

     def getTimestamp(self):

         """

         """

         errtag = self.getTag('error')

         if errtag is None:

         for tag in errtag.getChildren():

             if tag.getName() != 'text' and tag.getNamespace() == NS_STANZAS:

                 return tag.getName()

     def getAppError(self):

         errtag = self.getTag('error')

         if errtag is None:

         for tag in errtag.getChildren():

             if tag.getName() != 'text' and tag.getNamespace() != NS_STANZAS:

                 return tag.getName()

     def getAppErrorNamespace(self):

         errtag = self.getTag('error')

         if errtag is None:

         for tag in errtag.getChildren():

             if tag.getName() != 'text' and tag.getNamespace() != NS_STANZAS:

                 return tag.getNamespace()

     def getErrorMsg(self):

         """

                 if tag.getName() == 'text':

                     return tag.getData()

             return self.getError()

     def getErrorCode(self):

         """

         if protocol and tag:

             if name == 'message':

                 return Message(node=tag)

         return tag

     def __setitem__(self, item, val):

         if children and self.getType() != 'error' and \

         children[0].getName() != 'error':

             return children[0]

     def getQueryNS(self):

         """

         tag = self.getQuery()

         if tag:

             return tag.getNamespace()

     def getQuerynode(self):

         """

         tag = self.getQuery()

         if tag:

             return tag.getAttr('node')

     def getQueryPayload(self):

         """

         tag = self.getQuery()

         if tag:

             return tag.getPayload()

     def getQueryChildren(self):

         """

         tag = self.getQuery()

         if tag:

             return tag.getChildren()

     def getQueryChild(self, name=None):

         """

         """

         query = self.getQuery()

         if not query:

         for node in query.getChildren():

             if name is not None:

                 if node.getName() == name:

             else:

                 if node.getName() != 'error':

                     return node

     def setQuery(self, name=None):

         """

 class Hashes(Node):

     """

     Hash elements for various XEPs as defined in XEP-300

     RECOMENDED HASH USE:

     Algorithm     Support

     MD2           MUST NOT

 class Hashes2(Node):

     """

     Hash elements for various XEPs as defined in XEP-300

     RECOMENDED HASH USE:

     Algorithm     Support

     MD2           MUST NOT

         hostname = self.getTag('hostname', namespace=NS_DOMAIN_BASED_NAME)

         if hostname is not None:

             return hostname.getData()

     def has_bind(self):

         return self.getTag('bind', namespace=NS_BIND) is not None

             self.parent = parent

         self.nsp_cache = {}

         if nsp:

         if attrs is not None:

             for attr, val in attrs.items():

                 return nodes[0]

         if not one:

             return nodes

     def iterTags(self, name, attrs=None, namespace=None):

         """

         node = self.getTags(name, attrs, namespace=namespace, one=1)

         if node:

             return node

     def setTagAttr(self, tag, attr, val, namespace=None):

         """

         if self.parent is not None:

             return self.parent.getXmlLang()

     def has_attr(self, key):

         """

     def __setattr__(self, attr, val):

         if isinstance(val, Node):

             Node.__init__(self.node.setTag(attr), node=val)

     def __delattr__(self, attr):

         return self.node.delChild(attr)

     def __setattr__(self, attr, val):

         if isinstance(val, Node):

             self.node.addChild(attr, node=val)

 class NodeBuilder:

             log.debug("Got higher than dispatch level. Stream terminated?")

         self._dec_depth()

         self.last_is_data = 0

     def handle_cdata(self, data):

         if self.last_is_data:

     def map(self, c):

         if self._in_table_function(c):

             return None

 class Profile:

             return NS_MAM_2

         if NS_MAM_1 in self.features:

             return NS_MAM_1

     @property

     def has_mam_2(self):

         if self.jid is not None:

             return self.jid.getNode()

     @property

     def muc_identity_name(self):

         for identity in self.identities:

             if identity.category == 'conference':

                 return identity.name

     @property

     def muc_room_name(self):

 def _from_linear(c):

     if c <= 0.0031308:

         return 12.92 * c

 def _to_linear(c):

     if c > 0.04045:

         return math.pow((c + 0.055) / 1.055, 2.4)

 def xyz_to_rgb(_hx_tuple):

 def _y_to_l(y):

     if y <= epsilon:

         return y / refY * kappa

 def _l_to_y(l):

     if l <= 8:

         return refY * l / kappa

 def xyz_to_luv(_hx_tuple):