示例#1
0
    def convert(self, xmlroot):
        """
        :param Element xmlroot: root element of xml to convert.
        :rtype: wsag_model.Agreement
        """
        # for name, value in xmlroot.attrib.items():
        #      logger.debug('SLA xmlconverter: {} = {}'.format(name, value))

        if xmlroot.tag in self.agreement_tags:
            result = Agreement()
            agreementId = str(QName(self._namespaces["wsag"], "AgreementId"))
            result.agreement_id = xmlroot.attrib[agreementId]
        elif xmlroot.tag in self.template_tags:
            result = Template()
            templateId = str(QName(self._namespaces["wsag"], "TemplateId"))
            result.template_id = xmlroot.attrib[templateId]
        else:
            raise ValueError("Not valid root element name: " + xmlroot.tag)

        context = xmlroot.find("wsag:Context", self._namespaces)
        result.context = self._parse_context(context)

        terms = xmlroot.find("wsag:Terms/wsag:All", self._namespaces)

        properties = terms.findall("wsag:ServiceProperties", self._namespaces)
        result.variables = self._parse_properties(properties)

        guarantees = terms.findall("wsag:GuaranteeTerm", self._namespaces)
        result.guaranteeterms = self._parse_guarantees(guarantees)

        return result
示例#2
0
    def create():
        element = Element(QName(NS_SOAP, 'Reason'))

        value = Element(QName(NS_SOAP, 'Text'))
        element.append(value)

        return element
示例#3
0
def probe_metric(service_url, metric):
    '''
    Query the service at the given URL for the given metric value.

    Assumptions are made about the name of the method and output parameters
    which are only valid for the WanCommonInterfaceConfig service.
    '''
    envelope = E(
        QName(ns['s'], 'Envelope'), {
            QName(ns['s'], 'encodingStyle'):
            'http://schemas.xmlsoap.org/soap/encoding/'
        })
    body = sE(envelope, QName(ns['s'], 'Body'))
    method = sE(body, QName(ns['i'], 'Get{}'.format(metric)))
    request_tree = ET(envelope)
    with io.BytesIO() as out:
        out.write(b'<?xml version="1.0"?>')
        request_tree.write(out, encoding='utf-8')
        out.write(b'\r\n')  # or else my Belkin F5D8236-4 never responds...
        req = urllib.request.Request(service_url, out.getvalue())

    req.add_header('Content-Type', 'text/xml')
    req.add_header('SOAPAction', '"{}#{}"'.format(ns['i'],
                                                  'Get{}'.format(metric)))

    with urllib.request.urlopen(req) as result:
        result_tree = ElementTree.parse(result)
        return int(
            result_tree.findtext('.//New{}'.format(metric), namespaces=ns))
示例#4
0
    def from_xml(cls, element: Element):
        if element[1].tag != QName(FES20, "LowerBoundary") or element[2].tag != QName(
            FES20, "UpperBoundary"
        ):
            raise ExternalParsingError(
                f"{element.tag} should have 3 child nodes: "
                f"(expression), <LowerBoundary>, <UpperBoundary>"
            )

        lower = get_child(element, FES20, "LowerBoundary")
        upper = get_child(element, FES20, "UpperBoundary")

        if len(lower) != 1:
            raise ExternalParsingError(
                f"{lower.tag} should have 1 expression child node"
            )
        if len(upper) != 1:
            raise ExternalParsingError(
                f"{upper.tag} should have 1 expression child node"
            )

        return cls(
            expression=Expression.from_child_xml(element[0]),
            lowerBoundary=Expression.from_child_xml(lower[0]),
            upperBoundary=Expression.from_child_xml(upper[0]),
            _source=element.tag,
        )
 def messages(self):
     logmessages_tag = QName(XMLNS, 'LogMessages').text
     message_tag = QName(XMLNS, 'Message').text
     el = self.xml.find(logmessages_tag)
     if not el:
         return list()
     return list(m.text for m in el.findall(message_tag))
示例#6
0
    def create():
        element = Element(QName(NS_SOAP, 'Subcode'))

        value = Element(QName(NS_SOAP, 'Value'))
        element.append(value)

        return element
 def tips_statuslist(self, status_list):
     el = Element(QName(XMLNS, 'EntityStatusList'), {'entity': self.entity})
     for item in status_list:
         status = EntityStatusChoices.ENABLED if item[
             'enabled'] else EntityStatusChoices.DISABLED
         subel = SubElement(el, QName(XMLNS, status))
         subel.text = item['name']
     return el
示例#8
0
 def LastChange(self):
     root = Element(QName(self._event_ns, "Event"))
     inst = SubElement(root, QName(self._event_ns, "InstanceID"),
                       {"val": "0"})
     for name, value in self._changes.items():
         SubElement(inst, QName(self._event_ns, name), {"val": value})
     misc.set_ns_prefixes(root, {"": self._event_ns})
     return ElementTree.tostring(root, encoding="utf-8").decode("utf-8")
 def addresponse(self, path, root, depth):
     e = SubElement(root, QName("DAV:", 'response'))
     href = SubElement(e, QName("DAV:", 'href'))
     href.text = path
     propstat = SubElement(e, QName("DAV:", 'propstat'))
     prop = SubElement(propstat, QName("DAV:", 'resourcetype'))
     if os.path.isdir(path):
         SubElement(prop, QName("DAV:", 'collection'))
示例#10
0
 def add_array(node, items):
     rdf_type = next(
         c.rdf_type for c in XMP_CONTAINERS if isinstance(items, c.py_type)
     )
     seq = ET.SubElement(node, QName(XMP_NS_RDF, rdf_type))
     for item in items:
         el = ET.SubElement(seq, QName(XMP_NS_RDF, 'li'))
         el.text = item.replace('\x00', '')
 def __init__(self, method, entity):
     self.path = f'{ROOT_PATH}/{method}/{entity}'
     self.entity = entity
     self.path = None
     self.xml = Element(QName(XMLNS, 'TipsApiRequest'))
     tips_header = SubElement(self.xml, QName(XMLNS, 'TipsHeader'),
                              {'version': VERSION})
     if entity in (EntityChoices.GUEST_USER, EntityChoices.ONBOARD_DEVICE):
         tips_header.set('source', 'Guest')
示例#12
0
 def parsePropElementHref(self, prop, result, is_list):
     # Grab the element data
     hrefs = tuple([URL(url=href.text, decode=True) for href in prop.findall(str(davxml.href))])
     if not is_list:
         if len(hrefs) == 1:
             hrefs = hrefs[0]
         else:
             hrefs = ""
     result.addHrefProperty(QName(prop.tag), hrefs)
     result.addNodeProperty(QName(prop.tag), prop)
示例#13
0
    def test_qualified_attrib(self):
        ns, nsa = 'http://x.y.z/ns', 'http://x.y.z/ns/a'
        fruit = self.root.find('.//%s' % QName(ns, 'fruit'))

        # default ns, not qualitifed (TODO: why?)
        self.assertEqual(fruit.get('name'), 'Apple')
        self.assertIsNone(fruit.get(QName(ns, 'name')))

        # non-default ns, qualified
        self.assertEqual(fruit.get(QName(nsa, 'name')), 'Apple (a)')
示例#14
0
 def LastChange(self):
     root = Element(QName(self._event_ns, "Event"))
     inst = SubElement(root, QName(self._event_ns, "InstanceID"),
                       {"val": "0"})
     for name, value in self._changes.items():
         SubElement(inst, QName(self._event_ns, name), {"val": value})
     misc.set_ns_prefixes(root, {"": self._event_ns})
     writer = StringIO()
     ElementTree(root).write(writer, encoding="utf-8")
     return writer.getvalue()
示例#15
0
    def test_deserialize(self):
        convert = self.converter.deserialize

        invalid = ["a:b", "", " ", "{a}1b", "{a} b", "{|}b", "a a"]

        for inv in invalid:
            with self.assertRaises(ConverterError):
                convert(inv)

        self.assertEqual(QName("{a}b"), convert("{a}b"))
        self.assertEqual(QName("a"), convert("a", ns_map={}))
        self.assertEqual(QName("aa", "b"), convert("a:b", ns_map={"a": "aa"}))
示例#16
0
    def create():
        client = Element(QName(NS_CEP, 'client'))

        last_update = Element(QName(NS_CEP, 'lastUpdate'))
        last_update.attrib[ATTR_NIL] = 'true'
        client.append(last_update)

        preferred_language = Element(QName(NS_CEP, 'preferredLanguage'))
        preferred_language.attrib[ATTR_NIL] = 'true'
        client.append(preferred_language)

        return client
示例#17
0
    def test_find_qname(self):
        ns, nsa = 'http://x.y.z/ns', 'http://x.y.z/ns/a'

        # default namespace
        color = self.root.find('.//%s' % QName(ns, 'color'))
        self.assertEqual(color.tag, '{http://x.y.z/ns}color')  # Clark notation

        self.assertIsNone(self.root.find('.//color'))

        # another namespace
        color_a = self.root.find('.//%s' % QName(nsa, 'color'))
        self.assertEqual(color_a.tag, '{http://x.y.z/ns/a}color')
示例#18
0
 def from_element(cls, element):
     type = URI(QName(element.tag))
     uri = URI(element.get(QName(RDF, 'about')))
     type_class = cls.TYPE_MAP.get(type, cls)
     if cls is type_class:
         test = cls(type, uri)
         test.status = cls._status(element)
         test.description = cls._description(element)
         test.warning = cls._warning(element)
     else:
         test = type_class.from_element(element)
     return test
示例#19
0
    def __setitem__(self, key, val):
        if not self._updating:
            raise RuntimeError("Metadata not opened for editing, use with block")

        def add_array(node, items):
            rdf_type = next(
                c.rdf_type for c in XMP_CONTAINERS if isinstance(items, c.py_type)
            )
            seq = ET.SubElement(node, QName(XMP_NS_RDF, rdf_type))
            for item in items:
                el = ET.SubElement(seq, QName(XMP_NS_RDF, 'li'))
                el.text = item.replace('\x00', '')

        try:
            # Locate existing node to replace
            node, attrib, _oldval, parent = next(self._get_elements(key))
            if attrib:
                if not isinstance(val, str):
                    raise TypeError(val)
                node.set(attrib, val)
            elif isinstance(val, (list, set)):
                for child in node.findall('*'):
                    node.remove(child)
                add_array(node, val)
            elif isinstance(val, str):
                for child in node.findall('*'):
                    node.remove(child)
                node.text = val
            else:
                raise TypeError(val)
        except StopIteration:
            # Insert a new node
            rdf = self._xmp.find('.//rdf:RDF', self.NS)
            if isinstance(val, (list, set)):
                rdfdesc = ET.SubElement(
                    rdf, QName(XMP_NS_RDF, 'Description'),
                    attrib={
                        QName(XMP_NS_RDF, 'about'): '',
                    },
                )
                node = ET.SubElement(rdfdesc, self._qname(key))
                add_array(node, val)
            elif isinstance(val, str):
                rdfdesc = ET.SubElement(
                    rdf, QName(XMP_NS_RDF, 'Description'),
                    attrib={
                        QName(XMP_NS_RDF, 'about'): '',
                        self._qname(key): val
                    },
                )
            else:
                raise TypeError(val)
示例#20
0
    def getIMDBids(self):

        movies = []

        enablers = [
            tryInt(x) for x in splitString(self.conf('automation_urls_use'))
        ]
        urls = splitString(self.conf('automation_urls'))

        namespace = 'http://www.w3.org/2005/Atom'
        namespace_im = 'http://itunes.apple.com/rss'

        index = -1
        for url in urls:

            index += 1
            if len(enablers
                   ) == 0 or len(enablers) < index or not enablers[index]:
                continue

            try:
                cache_key = 'itunes.rss.%s' % md5(url)
                rss_data = self.getCache(cache_key, url)

                data = XMLTree.fromstring(rss_data)

                if data is not None:
                    entry_tag = str(QName(namespace, 'entry'))
                    rss_movies = self.getElements(data, entry_tag)

                    for movie in rss_movies:
                        name_tag = str(QName(namespace_im, 'name'))
                        name = self.getTextElement(movie, name_tag)

                        releaseDate_tag = str(
                            QName(namespace_im, 'releaseDate'))
                        releaseDateText = self.getTextElement(
                            movie, releaseDate_tag)
                        year = datetime.datetime.strptime(
                            releaseDateText,
                            '%Y-%m-%dT00:00:00-07:00').strftime("%Y")

                        imdb = self.search(name, year)

                        if imdb and self.isMinimalMovie(imdb):
                            movies.append(imdb['imdb'])

            except:
                log.error('Failed loading iTunes rss feed: %s %s',
                          (url, traceback.format_exc()))

        return movies
示例#21
0
 def _on_play(self):
     if self.source is None or self.state == "PLAYING":
         return
     if self._timer:
         self._timer.unregister()
     from cocy.upnp import DIDL_LITE_NS
     duration = self.source_meta_dom.find(
         str(QName(DIDL_LITE_NS, "item")) + "/" + str(QName(DIDL_LITE_NS, "res"))) \
         .get("duration")
     self.current_track_duration = duration_to_secs(duration)
     self._timer = Timer(self.current_track_duration,
                         end_reached()).register(self)
     self.state = "PLAYING"
    def __init__(self, geopackage_path, log=None):
        """
        :param geopackage_path: the file path for the geopackaging we are working on
        :param srs_name: The code value for the SRS (CODE: 4326 in EPSG:4326)
        :param srs_org: The organization specifying the SRS (ORG: EPSG in EPSG:4326)
        :param log: an optional log file passed through from an outer context
        """
        self.geopackage_path = geopackage_path
        self.log = log

        existing_metadata = self.__load_metadata()
        self.existing_metadata = dict()
        for _entry in existing_metadata:
            self.existing_metadata[_entry["id"]] = _entry

        # register the namespaces we will be using as we manipulate the data
        [
            register_namespace(namespace.value[0], namespace.value[1])
            for namespace in NameSpaces
        ]
        # check to see if there is existing data or not
        if len(self.existing_metadata):
            try:
                self.tree = ElementTree.fromstring(
                    self.existing_metadata[1]["metadata"].encode(
                        "ascii", "ignore"))
            except Exception:  # metadata is invalid or not what we want
                self.tree = ElementTree.parse(
                    source=MD_TREE).getroot()  # Load base MD XML
                # set the creation date
                self.tree.set(QName(NameSpaces.ISM.value[1], "createDate"),
                              datetime.date.today().isoformat())
        else:
            self.tree = ElementTree.parse(
                source=MD_TREE).getroot()  # Load base MD XML
            # set the creation date
            self.tree.set(QName(NameSpaces.ISM.value[1], "createDate"),
                          datetime.date.today().isoformat())

        # Fill out our DateStamp elem
        date_element = self.__build_tag(namespace=NameSpaces.GMD.value[1],
                                        tag=Tags.DATE_STAMP)
        self.__build_tag(
            namespace=NameSpaces.GCO.value[1],
            tag="Date",
            parent=date_element,
            text=str(datetime.date.today().isoformat()),
        )
        # insert as the 3rd element bc spec
        self.tree.insert(3, date_element)
示例#23
0
    def _apply_changes(self):
        """Serialize our changes back to the PDF in memory

        Depending how we are initialized, leave our metadata mark and producer.
        """
        if self.mark:
            self[QName(XMP_NS_XMP, 'MetadataDate')] = datetime.now().isoformat()
            self[QName(XMP_NS_PDF, 'Producer')] = 'pikepdf ' + pikepdf_version
        xml = self._get_xml_bytes()
        self._pdf.Root.Metadata = Stream(self._pdf, xml)
        self._pdf.Root.Metadata[Name.Type] = Name.Metadata
        self._pdf.Root.Metadata[Name.Subtype] = Name.XML
        if self.sync_docinfo:
            self._update_docinfo()
示例#24
0
    def getIMDBids(self):

        movies = []

        rss_movies = self.getRSSData(self.urls['theater'])
        rating_tag = str(QName(self.urls['namespace'], 'tomatometer_percent'))

        for movie in rss_movies:

            value = self.getTextElement(movie, "title")
            result = re.search('(?<=%\s).*', value)

            if result:

                log.info2('Something smells...')
                rating = tryInt(self.getTextElement(movie, rating_tag))
                name = result.group(0)

                if rating < tryInt(self.conf('tomatometer_percent')):
                    log.info2('%s seems to be rotten...', name)
                else:

                    log.info2('Found %s fresh enough movies, enqueuing: %s',
                              (rating, name))
                    year = datetime.datetime.now().strftime("%Y")
                    imdb = self.search(name, year)

                    if imdb:
                        movies.append(imdb['imdb'])

        return movies
示例#25
0
 def test_from_value(self):
     self.assertEqual(DataType.BOOLEAN, DataType.from_value(True))
     self.assertEqual(DataType.INT, DataType.from_value(1))
     self.assertEqual(DataType.FLOAT, DataType.from_value(1.1))
     self.assertEqual(DataType.DECIMAL, DataType.from_value(Decimal(1.1)))
     self.assertEqual(DataType.QNAME, DataType.from_value(QName("a")))
     self.assertEqual(DataType.STRING, DataType.from_value("a"))
示例#26
0
    def parsePropElement(self, prop, result, badstatus):
        # Here we need to detect the type of element and dispatch accordingly
        if badstatus:
            result.addBadProperty(QName(prop.tag), badstatus)

        # Determine what type of content we have
        else:
            children = prop.getchildren()
            children_length = len(children)
            if children_length == 0:
                self.parsePropElementText(prop, result)
            elif prop.text is None or not prop.text.strip():
                if children_length == 1:
                    if children[0].tag == davxml.href:
                        self.parsePropElementHref(prop, result, False)
                    else:
                        self.parsePropElementUnknown(prop, result)
                else:
                    allHref = True
                    for child in children:
                        if child.tag != davxml.href:
                            allHref = False
                    if allHref:
                        self.parsePropElementHref(prop, result, True)
                    else:
                        self.parsePropElementUnknown(prop, result)
            else:
                self.parsePropElementUnknown(prop, result)
示例#27
0
    def create():
        element = Element(QName(NS_CEP, 'requestFilter'))

        policy_oids = Element(QName(NS_CEP, 'policyOIDs'))
        policy_oids.attrib[ATTR_NIL] = 'true'
        element.append(policy_oids)

        client_version = Element(QName(NS_CEP, 'clientVersion'))
        client_version.attrib[ATTR_NIL] = 'true'
        element.append(client_version)

        server_version = Element(QName(NS_CEP, 'serverVersion'))
        server_version.attrib[ATTR_NIL] = 'true'
        element.append(server_version)

        return element
示例#28
0
def find_weather():
    for i in locationcode:
        url = WEATHER_URL % i
        url = url + METRIC_PARAMETER
        xml = ET.parse(urllib.urlopen(url))
        root = xml.getroot()
        ns = "http://xml.weather.yahoo.com/ns/rss/1.0"
        site = root[0][0].text.split(' - ')[1]
        print "Current location is:", site
        # print "Current date is:", root[0][4].text
        # for condition in root.findall('yweather:condition'):
        # 	print "get it"
        # 	print condition.attrib

        body_tag = str(QName(ns, 'condition'))
        body = root[0][12].findall(body_tag)
        # print body[0].attrib['date']
        dicweather = body[0].attrib
        # print ' -->',dicweather['date']
        # print ' -->',dicweather['low']
        # print ' -->',dicweather['high']
        # print ' -->',dicweather['text']
        # head = ['date','text','temp','low','location']

        # write_file(filename,
        # 	head,dicweather['date'].split(',')[1].split('AEDT')[0],dicweather['text'],dicweather['temp'],site.split(',')[0])

        store_db(dicweather['date'].split(',')[1].split('AEDT')[0],
                 dicweather['text'], dicweather['temp'])
示例#29
0
    def _update_docinfo(self):
        """Update the PDF's DocumentInfo dictionary to match XMP metadata

        The standard mapping is described here:
            https://www.pdfa.org/pdfa-metadata-xmp-rdf-dublin-core/
        """
        self._pdf.docinfo  # Touch object to ensure it exists
        for uri, element, docinfo_name, converter in self.DOCINFO_MAPPING:
            qname = QName(uri, element)
            try:
                value = self[qname]
            except KeyError:
                if docinfo_name in self._pdf.docinfo:
                    del self._pdf.docinfo[docinfo_name]
                continue
            if converter:
                value = converter.docinfo_from_xmp(value)
            if value is None:
                del self._pdf.docinfo[docinfo_name]
                continue
            try:
                # Try to save pure ASCII
                self._pdf.docinfo[docinfo_name] = value.encode('ascii')
            except UnicodeEncodeError:
                # qpdf will serialize this as a UTF-16 with BOM string
                self._pdf.docinfo[docinfo_name] = value
示例#30
0
    def create_response(self,
                        action_name: str,
                        arguments: dict,
                        encoding=None,
                        envelope_attrib=None,
                        typed=None):
        """
            Creates a Soap response to the action with the specified arguments.
        """
        register_namespace('', None)

        if encoding is None:
            encoding = self._encoding
        if envelope_attrib is None:
            envelope_attrib = self._envelope_attrib
        if typed is None:
            typed = self._typed

        envelope = Element("s:Envelope")
        if envelope_attrib:
            for eakey, eaval in envelope_attrib:
                envelope.attrib.update({eakey: eaval})
        else:
            envelope.attrib.update({'xmlns:s': NS_SOAP_ENV})
            envelope.attrib.update({'s:encodingStyle': encoding})

        body = SubElement(envelope, "s:Body")

        action_name_tag_name = action_name + "Response"
        methElement = SubElement(body, action_name_tag_name)
        if encoding:
            methElement.set(NS_SOAP_ENV + "encodingStyle", encoding)

        if arguments:
            for arg_name, arg_val in arguments.items():
                py_type = type(arg_val)
                soap_type = PYTHON_TO_SOAP_TYPE_MAP[py_type]

                if soap_type == 'xsd:string':
                    arg_val = arg_val  # pylint: disable=self-assigning-variable
                elif soap_type == 'xsd:int' or soap_type == 'xsd:float':
                    arg_val = str(arg_val)
                elif soap_type == 'xsd:boolean':
                    arg_val = "1" if arg_val else "0"

                argElement = SubElement(methElement, arg_name)
                if typed and soap_type:
                    if not isinstance(type, QName):
                        arg_type = QName(NS_XSD, soap_type)
                    argElement.set(NS_XSI + "type", soap_type)

                argElement.text = arg_val
        else:
            methElement.text = ""

        envelope_content = xml_tostring(envelope, short_empty_elements=False)
        content = XML_DOCUMENT_DECLARATION + "\n" + str_cast(envelope_content)

        return content