def _get_build_metadata(self, dir_name): if os.path.exists(os.path.join(dir_name, 'jenkins_build.tar.gz')): raise Skip('the build has already been archived', dir_name) # Read the build.xml metadata file that Jenkins generates build_metadata = os.path.join(dir_name, 'build.xml') if not os.access(build_metadata, os.R_OK): self.log.debug("Can't read build file at %s" % (build_metadata)) raise Exception("Can't access build.xml at %s" % (build_metadata)) else: tree = ElementTree() tree.parse(build_metadata) keys = ['result', 'number', 'duration'] kv_pairs = ((k, tree.find(k)) for k in keys) d = dict([(k, v.text) for k, v in kv_pairs if v is not None]) try: d['branch'] = tree.find('actions') \ .find('hudson.plugins.git.util.BuildData') \ .find('buildsByBranchName') \ .find('entry') \ .find('hudson.plugins.git.util.Build') \ .find('revision') \ .find('branches') \ .find('hudson.plugins.git.Branch') \ .find('name') \ .text except Exception: pass return d
def _get_article_contrib_authors(tree): """ Given an ElementTree, returns article authors in a format suitable for citation. """ authors = [] front = ElementTree(tree).find('front') for contrib in front.iter('contrib'): if contrib.attrib['contrib-type'] != 'author': continue contribTree = ElementTree(contrib) try: surname = contribTree.find('name/surname').text except AttributeError: # author is not a natural person try: citation_name = contribTree.find('collab').text if citation_name is not None: authors.append(citation_name) continue except AttributeError: # name has no immediate text node continue try: given_names = contribTree.find('name/given-names').text citation_name = ' '.join([surname, given_names[0]]) except AttributeError: # no given names citation_name = surname except TypeError: # also no given names citation_name = surname if citation_name is not None: authors.append(citation_name) return ', '.join(authors)
class SchemeReader: def __init__(self, file_name): f = open(file_name); """ self.xml = f.read(); self.parse(); """ self.root = ElementTree(file=f); self.parse(); f.close(); def parse(self): """ bs = BeautifulSoup.BeautifulSoup(self.xml, "xml"); print bs date_tag = bs.find("Date"); print date_tag self.date = DateScheme(date_tag); text_tag = bs.find("Text"); self.text = TextScheme(text_tag); """ date_tag = self.root.find("Date"); self.date = DateScheme(date_tag); text_tag = self.root.find("Text"); self.text = TextScheme(text_tag);
class TreeReader: """Reads Decision Tree from XML file""" def __init__(self, fileName): self.__xmltree = ElementTree() self.__xmltree.parse(fileName) self.__NTrees = int(self.__xmltree.find("Weights").get('NTrees')) def getNTrees(self): return (self.__NTrees) def __getBinaryTree(self, itree): if self.__NTrees<=itree: print( "to big number, tree number must be less then %s"%self.__NTrees ) return 0 return self.__xmltree.find("Weights").find("BinaryTree["+str(itree+1)+"]") def __readTree(self, binaryTree, tree={}, depth=0): nodes = binaryTree.findall("Node") if len(nodes)==0: return if len(nodes)==1 and nodes[0].get("pos")=="s": info = { "IVar": nodes[0].get("IVar"), "Cut" : nodes[0].get("Cut"), "purity": nodes[0].get("purity"), "pos": 0 } tree["info"] = info tree["children"] = [] self.__readTree(nodes[0], tree, 1) return for node in nodes: info = { "IVar": node.get("IVar"), "Cut" : node.get("Cut"), "purity": node.get("purity"), "pos": node.get("pos") } tree["children"].append({ "info": info, "children": [] }) self.__readTree(node, tree["children"][-1], depth+1) def getTree(self, itree): binaryTree = self.__getBinaryTree(itree) if binaryTree==0: return {} tree = {} self.__readTree(binaryTree, tree) return tree def getVariables(self): variables = [] varstree = self.__xmltree.find("Variables").findall("Variable") variables = [None]*len(varstree) for v in varstree: variables[int(v.get('VarIndex'))] = v.get('Expression') return variables
def getVersion(self): if os.path.exists(self.options.versionxmlfile): tree = ElementTree(file=self.options.versionxmlfile) LastVersionNode = tree.find(".//LastVersion") if LastVersionNode == None: print("LastVersion element not found in version XML file!") exit(1) lastVersionText = "".join(LastVersionNode.itertext()) self.newversion = lastVersionText ServerBranchNode = tree.find(".//LocalBranchPath") if ServerBranchNode == None: print("Local branch path element not found in version XML file!") exit(1) serverBranchText = "".join(ServerBranchNode.itertext()) serverBranchText = serverBranchText.replace("${LastVersion}", lastVersionText) serverBranchText = serverBranchText.replace("${Year}", str(datetime.date.today().year)) serverBranchText = serverBranchText.replace("${Integration_Root}", self.options.integrationroot) self.branchPath = serverBranchText else: print("Version XML file not found!") exit(1) # If a version is passed in, it overrides the version in the version.xml file if not self.options.version == None: self.newversion = self.options.version self.branchPath = None
def get_service_data(self,service,**kwargs): """" Makes a call to a webservice endpoint and extracts the relevant fields into instances of the item type for the collection """ #TODO memoization broken, needs to account for args if not hasattr(self,'_items'): url_base = "%s/%s" % (METRO_API_URL,service) params = {'api_key':MetroAPI.api_key} if len(kwargs): params.update(kwargs) qs = urlencode(params) url = "%s?%s" % (url_base,qs) print url response = urlopen(url) et = ET() et.parse(response) count = et.find('metadata').find('records_found') results = [] if int(count.text) > 0: items = et.find(self.list_elem) for item in items.findall('item'): item_args = {} for field in self.fields: item_args.update({field:item.find(field).text}) results.append(self.item_type(**item_args)) setattr(self,'_items',results) return self._items
def test_service_validate_view_success(self): """ When called with correct parameters, a ``GET`` request to the view should return a validation success and the ``ServiceTicket`` should be consumed and invalid for future validation attempts. """ query_str = "?service=%s&ticket=%s" % (self.service_url, self.st.ticket) response = self.client.get(reverse('cas_service_validate') + query_str) tree = ElementTree(fromstring(response.content)) elem = tree.find(XMLNS + 'authenticationSuccess/' + XMLNS + 'user') self.assertIsNotNone(elem) self.assertEqual(elem.text, 'ellen') self.assertEqual(response.status_code, 200) self.assertEqual(response.get('Content-Type'), 'text/xml') # This should fail as the ticket was consumed in the preceeding test response = self.client.get(reverse('cas_service_validate') + query_str) tree = ElementTree(fromstring(response.content)) elem = tree.find(XMLNS + 'authenticationFailure') self.assertIsNotNone(elem) self.assertEqual(elem.get('code'), 'INVALID_TICKET') self.assertEqual(response.status_code, 200) self.assertEqual(response.get('Content-Type'), 'text/xml')
def test_proxy_validate_view_pgturl(self): """ When called with correct parameters and a ``pgtUrl`` parameter, a ``GET`` request to the view should return a validation success and also attempt to create a ``ProxyGrantingTicket``. NOTE: this test will fail unless ``pgt_url`` is configured with a valid proxy callback URL. """ if self.pgt_url == 'https://www.example.com/': raise ImproperlyConfigured("Set pgt_url to a valid HTTPS URL " "to successfully run this test") query_str = "?service=%s&ticket=%s&pgtUrl=%s" % (self.service_url, self.pt.ticket, self.pgt_url) response = self.client.get(reverse('cas_proxy_validate') + query_str) tree = ElementTree(fromstring(response.content)) elem = tree.find(XMLNS + 'authenticationSuccess/' + XMLNS + 'user') self.assertIsNotNone(elem) self.assertEqual(elem.text, 'ellen') self.assertEqual(response.status_code, 200) self.assertEqual(response.get('Content-Type'), 'text/xml') elem = tree.find(XMLNS + 'authenticationSuccess/' + XMLNS + 'proxyGrantingTicket') self.assertIsNotNone(elem)
def test_proxy_validate_view_proxies(self): """ When a successful ``ProxyTicket`` validation occurs, the response should include a ``proxies`` block containing all of the proxies involved. When authentication has proceeded through multiple proxies, they must be listed in reverse order of being accessed. """ pgt2 = ProxyGrantingTicket.objects.create_ticket(self.service_url, validate=False, user=self.user, granted_by_pt=self.pt) ticket_info2 = {'service': 'http://ww2.example.com/', 'user': self.user} pt2 = ProxyTicket.objects.create_ticket(granted_by_pgt=pgt2, **ticket_info2) query_str = "?service=%s&ticket=%s" % ('http://ww2.example.com/', pt2) response = self.client.get(reverse('cas_proxy_validate') + query_str) tree = ElementTree(fromstring(response.content)) elem = tree.find(XMLNS + 'authenticationSuccess/' + XMLNS + 'user') self.assertIsNotNone(elem) self.assertEqual(elem.text, 'ellen') self.assertEqual(response.status_code, 200) self.assertEqual(response.get('Content-Type'), 'text/xml') elem = tree.find(XMLNS + 'authenticationSuccess/' + XMLNS + 'proxies') proxy = list(elem.getiterator(XMLNS + 'proxy')) self.assertEqual(len(proxy), 2) self.assertEqual(proxy[0].text, 'http://ww2.example.com') self.assertEqual(proxy[1].text, 'http://www.example.com')
def test_proxy_validate_view_pt_success(self): """ When called with a valid ``ProxyTicket``, a ``GET`` request to the view should return a validation success and the ``ProxyTicket`` should be consumed and invalid for future validation attempts. """ query_str = "?service=%s&ticket=%s" % (self.service_url, self.pt.ticket) response = self.client.get(reverse('cas_proxy_validate') + query_str) tree = ElementTree(fromstring(response.content)) elem = tree.find(XMLNS + 'authenticationSuccess/' + XMLNS + 'user') self.assertIsNotNone(elem) self.assertEqual(elem.text, 'ellen') self.assertEqual(response.status_code, 200) self.assertEqual(response.get('Content-Type'), 'text/xml') elem = tree.find(XMLNS + 'authenticationSuccess/' + XMLNS + 'proxies') proxy = list(elem.getiterator(XMLNS + 'proxy')) self.assertEqual(len(proxy), 1) self.assertEqual(proxy[0].text, 'http://www.example.com') # This second validation request attempt should fail as the # ticket was consumed in the preceeding test response = self.client.get(reverse('cas_proxy_validate') + query_str) tree = ElementTree(fromstring(response.content)) elem = tree.find(XMLNS + 'authenticationFailure') self.assertIsNotNone(elem) self.assertEqual(elem.get('code'), 'INVALID_TICKET') self.assertEqual(response.status_code, 200) self.assertEqual(response.get('Content-Type'), 'text/xml')
def set_initial_fields(process, run_dir, run_id): process.udf['Operator'] = process.technician.username for ide, name in INSTRUMENT_NAME_MAP.items(): if re.match("\\d{6}_%s_.*" % (ide), run_id): process.udf['Instrument Name'] = name break else: print "The run ID", run_id, "did not match any of the known instruments, Instrument Name not set." if process.type_name.startswith("MiSeq Run"): rp_tree = ElementTree() try: rp_tree.parse(os.path.join(run_dir, "RunParameters.xml")) except IOError: # Fallback to previous version MiSeq software rp_tree.parse(os.path.join(run_dir, "runParameters.xml")) process.udf['Chemistry Version'] = rp_tree.find( "ReagentKitVersion").text.replace("Version", "") ri_tree = ElementTree() ri_tree.parse(os.path.join(run_dir, "RunInfo.xml")) num_tiles = ri_tree.find("Run/FlowcellLayout").attrib['TileCount'] if num_tiles == "4": typ = "v2 Micro" elif num_tiles == "2": typ = "v2 Nano" elif num_tiles == "14": typ = "v2" elif num_tiles == "19": typ = "v3" else: typ = "Unknown ({})".format(num_tiles) process.udf['Reagent Kit Type'] = typ process.udf['Run started'] = datetime.datetime.now().strftime( "%Y-%m-%d %H:%M") process.put()
def parse_format(xml_file): """Parse the xml file to create types, scaling factor types, and scales. """ tree = ElementTree() tree.parse(xml_file) for param in tree.find("parameters").getchildren(): VARIABLES[param.get("name")] = param.get("value") types_scales = {} for prod in tree.find("product"): ascii = prod.tag in ["mphr", "sphr"] res = [] for i in prod: lres = CASES[i.tag](i, ascii) if lres is not None: res.append(lres) types_scales[(prod.tag, int(prod.get("subclass")))] = res types = {} stypes = {} scales = {} for key, val in types_scales.items(): types[key] = to_dtype(val) stypes[key] = to_scaled_dtype(val) scales[key] = to_scales(val) return types, stypes, scales
def get_package_from_spec(pom_file) -> Package: """Create MavenPackage object from pom.xml file.""" tree = ElementTree(file=pom_file) root = tree.getroot() # get xml namespace namespace = re.search(r"({.*})(.*)", root.tag) namespace = namespace.group(1) if namespace else '' attributes = [ 'groupId', 'artifactId', 'name', 'version', 'description', 'url' ] package_spec = dict() for attr in attributes: try: val = tree.find(namespace + attr).text except AttributeError: # try to look the attr up in the parent tag parent = tree.find(namespace + 'parent') if parent: try: val = parent.find(namespace + attr).text except AttributeError: val = None else: val = None package_spec[attr] = val package = MavenPackage(**package_spec) return package
def __init__(self,node,name,converter=None): self.name=name node = ElementTree(file=fileName) node = node.getroot() node = node.find("drawing").find("library") if converter==None: converter=Converter() symConverter=SchemConverter() self.modules=[] self.symbols=[] packages=node.find("packages").findall("package") symbols=node.find("symbols").findall("symbol") if packages !=None: for package in packages: self.modules.append(Module(package,converter)) if symbols!=None: for symbol in symbols: self.symbols.append(Symbol(symbol,symConverter))
def parse_format(xml_file): global VARIABLES tree = ElementTree() tree.parse(xml_file) products = tree.find("product") params = tree.find("parameters") for param in params.getchildren(): VARIABLES[param.get("name")] = param.get("value") types = {} for prod in products: ascii = (prod.tag in ["mphr", "sphr"]) res = [] for i in prod: lres = CASES[i.tag](i, ascii) if lres is not None: res.append(lres) types[(prod.tag, int(prod.get("subclass")))] = np.dtype(res) return types
def vm_read_config(self): """ This method parses the libvirt xml config file and fills the cfg_details dictionary. This method returns the dictionary or raise exception if xml is not valid. """ domain = ET().parse(self.cfg_file) vm_type = domain.get('type') self.cfg_details['vm_type'] = HVM_LIBVIRT_NAMEMAP[vm_type] self.cfg_details['vm_type_str'] = vm_type self.cfg_details['displayName'] = domain.find('name').text self.cfg_details['memsize'] = int(domain.find('memory').text) >> 10 primary_disk_list = [] for disk in domain.findall('devices/disk'): disk_details = self.get_disk_details(disk) if disk.get('type') == 'file' and \ disk.get('device') == 'disk' and \ disk_details['dev'] in ('sda', 'hda', 'vda') and \ disk_details['bus'] in ('ide', 'scsi', 'virtio'): primary_disk_list.append(os.path.basename(disk_details['file'])) break self.cfg_details['primary_disk'] = primary_disk_list self.cfg_details['primary_disk_str'] = ','.join(primary_disk_list) if not self.cfg_details: raise config_file_invalid() else: return self.cfg_details
def __init__(self): self.dialog = {} self.color = pygame.color.Color("white") self.layer = [] xml_file = ElementTree().parse(os.path.join( CONFIG.system_path, "gui", CONFIG.general.THEME, "theme.xml")) if xml_file.find("color") is not None: self.color = pygame.color.Color( xml_file.find("color").attrib["value"]) if xml_file.find("dialog") is not None: conf_d = xml_file.find("dialog") w, h = CONFIG.general.WIDTH, CONFIG.general.HEIGHT self.dialog["sizex"] = int(conf_d.attrib["sizex"]) * w / 100 self.dialog["sizey"] = int(conf_d.attrib["sizey"]) * h / 100 self.dialog["posx"] = int(conf_d.attrib["posx"]) * w / 100 self.dialog["posy"] = int(conf_d.attrib["posy"]) * h / 100 for node in xml_file.findall("layer"): self.layer.append(Layer(node))
def test_proxy_validate_view_pt_success(self): """ When called with a valid ``ProxyTicket``, a ``GET`` request to the view should return a validation success and the ``ProxyTicket`` should be consumed and invalid for future validation attempts. """ query_str = "?service=%s&ticket=%s" % (self.service_url, self.pt.ticket) response = self.client.get(reverse("cas_proxy_validate") + query_str) tree = ElementTree(fromstring(response.content)) elem = tree.find(XMLNS + "authenticationSuccess/" + XMLNS + "user") self.assertIsNotNone(elem) self.assertEqual(elem.text, "ellen") self.assertEqual(response.status_code, 200) self.assertEqual(response.get("Content-Type"), "text/xml") elem = tree.find(XMLNS + "authenticationSuccess/" + XMLNS + "proxies") proxy = list(elem.getiterator(XMLNS + "proxy")) self.assertEqual(len(proxy), 1) self.assertEqual(proxy[0].text, "http://www.example.com") # This request should fail as the ticket was consumed in the preceeding test response = self.client.get(reverse("cas_proxy_validate") + query_str) tree = ElementTree(fromstring(response.content)) elem = tree.find(XMLNS + "authenticationFailure") self.assertIsNotNone(elem) self.assertEqual(elem.get("code"), "INVALID_TICKET") self.assertEqual(response.status_code, 200) self.assertEqual(response.get("Content-Type"), "text/xml")
def _get_build_metadata(self, dir_name): if os.path.exists(os.path.join(dir_name, 'jenkins_build.tar.gz')): raise Skip('the build has already been archived', dir_name) # Read the build.xml metadata file that Jenkins generates build_metadata = os.path.join(dir_name, 'build.xml') if not os.access(build_metadata, os.R_OK): self.log.debug("Can't read build file at %s" % (build_metadata)) raise Exception("Can't access build.xml at %s" % (build_metadata)) else: tree = ElementTree() tree.parse(build_metadata) keys = ['result', 'number', 'duration'] kv_pairs = ((k, tree.find(k)) for k in keys) d = dict([(k, v.text) for k, v in kv_pairs if v is not None]) try: d['branch'] = tree.find('actions') \ .find('hudson.plugins.git.util.BuildData') \ .find('buildsByBranchName') \ .find('entry') \ .find('hudson.plugins.git.util.Build') \ .find('revision') \ .find('branches') \ .find('hudson.plugins.git.Branch') \ .find('name') \ .text except Exception: # nosec pass return d
def parse_fzp(self, fzp_file): """ Parse the Fritzing component file """ tree = ElementTree(file=fzp_file) try: prefix = tree.find('label').text except AttributeError: pass else: self.component.add_attribute('_prefix', prefix) symbol = Symbol() self.component.add_symbol(symbol) self.body = Body() symbol.add_body(self.body) self.cid2termid.update(self.parse_terminals(tree)) self.terminals.update(self.cid2termid.values()) layers = tree.find('views/schematicView/layers') if layers is None: self.image = None else: self.image = layers.get('image')
def __init__(self, f): """Data parsing""" self.trackers = [] #: tracker properties and data self.groups = [] #: groups [] self.priorities = [] #: priorities used self.resolutions = [] #: resolutions (index, name) self.tickets = [] #: all tickets self.statuses = [] #: status (idx, name) self.used_resolutions = {} #: id:name self.used_categories = {} #: id:name # id '100' means no category self.used_categories['100'] = None self.users = {} #: id:name root = ElementTree().parse(f) self.users = dict([(FlatXML(u).userid, FlatXML(u).username) for u in root.find('referenced_users')]) for tracker in root.find('trackers'): tr = Tracker(tracker) self.trackers.append(tr) # groups-versions for grp in tr.groups: # group ids are tracker-specific even if names match g = (grp.id, grp.group_name) if g not in self.groups: self.groups.append(g) # resolutions for res in tr.resolutions: r = (res.id, res.name) if r not in self.resolutions: self.resolutions.append(r) # statuses self.statuses = [(s.id, s.name) for s in tr.statuses] # tickets for tck in tr.tracker_items: if type(tck) == str: print repr(tck) self.tickets.append(tck) if int(tck.priority) not in self.priorities: self.priorities.append(int(tck.priority)) res_id = getattr(tck, "resolution_id", None) if res_id is not None and res_id not in self.used_resolutions: for idx, name in self.resolutions: if idx == res_id: break self.used_resolutions[res_id] = dict(self.resolutions)[res_id] # used categories categories = dict(self.get_categories(tr, noowner=True)) if tck.category_id not in self.used_categories: self.used_categories[tck.category_id] = categories[tck.category_id] # sorting everything self.trackers.sort(key=lambda x:x.name) self.groups.sort() self.priorities.sort()
def parse_format(xml_file): """Parse the xml file to create types, scaling factor types, and scales. """ tree = ElementTree() tree.parse(xml_file) for param in tree.find("parameters").getchildren(): VARIABLES[param.get("name")] = param.get("value") types_scales = {} for prod in tree.find("product"): ascii = (prod.tag in ["mphr", "sphr"]) res = [] for i in prod: lres = CASES[i.tag](i, ascii) if lres is not None: res.append(lres) types_scales[(prod.tag, int(prod.get("subclass")))] = res types = {} stypes = {} scales = {} for key, val in types_scales.items(): types[key] = to_dtype(val) stypes[key] = to_scaled_dtype(val) scales[key] = to_scales(val) return types, stypes, scales
def replace_information_in_xml_file_flame9(Subdir, XMLFileName): if Subdir == None: return "unable to replace information in a file located in a nonexistent directory\n" elif XMLFileName == None: return "unable to replace information in a nonexistent file!\n" else: tree = ElementTree() tree.parse(XMLFileName) xml.etree.ElementTree.register_namespace( "", "http://PlatformGroup.efi.com/Fiery/SubsystemSetup") p = tree.find( ".//{http://PlatformGroup.efi.com/Fiery/SubsystemSetup}RecoveryFiles" ) newp = [p.remove(item) for item in p[1:]] srcNode = tree.find( ".//{http://PlatformGroup.efi.com/Fiery/SubsystemSetup}RecoverySetupFileCopy" ) srcNode[0].text = '\\' + Subdir p = tree.findall( ".//{http://PlatformGroup.efi.com/Fiery/SubsystemSetup}ExternalTaskInfo" ) for item in p: temp = item.attrib['MediaMountPoint'] print(temp) item.attrib['MediaMountPoint'] = "\\" + Subdir + temp xml.etree.ElementTree.dump(tree) tree.write(XMLFileName + ".new", xml_declaration=True, method='xml', encoding='UTF-8')
class SchemeReader: def __init__(self, file_name=None, text=None): """ self.xml = f.read(); self.parse(); """ if (file_name): f = open(file_name); self.root = ElementTree(file=f); self.parse(); f.close(); elif (text): self.root = fromstring(text); self.parse(); def parse(self): """ bs = BeautifulSoup.BeautifulSoup(self.xml, "xml"); print bs date_tag = bs.find("Date"); print date_tag self.date = DateScheme(date_tag); text_tag = bs.find("Text"); self.text = TextScheme(text_tag); """ date_tag = self.root.find("Date"); self.date = DateScheme(date_tag); text_tag = self.root.find("Text"); self.text = TextScheme(text_tag); nextpage_tag = self.root.find("NextPage"); if (nextpage_tag): self.has_nextpage = True; self.nextpage = NextPageScheme(nextpage_tag); else: self.has_nextpage = False;
def parse_fzp(self, fzp_file): """ Parse the Fritzing component file """ tree = ElementTree(file=fzp_file) try: prefix = tree.find('label').text except AttributeError: pass else: self.component.add_attribute('_prefix', prefix) symbol = Symbol() self.component.add_symbol(symbol) self.body = SBody() symbol.add_body(self.body) self.cid2termid.update(self.parse_terminals(tree)) self.terminals.update(self.cid2termid.values()) layers = tree.find('views/schematicView/layers') if layers is None: self.image = None else: self.image = layers.get('image')
def __init__(self, ttx_path, px_step=200, font_height=4): with open(ttx_path) as f: elem_tree = ElementTree(file=f) self.glyphs = elem_tree.find("glyf") self.hmtx = elem_tree.find("hmtx") self.cmap = elem_tree.find("cmap") self.px_step = px_step self.font_height = font_height
def _get_statement_el(self, tree: ET.ElementTree) -> ET.Element: if self.version == CamtVersion.CAMT053: stmt = tree.find("./s:BkToCstmrStmt/s:Stmt", self.xmlns) else: assert self.version == CamtVersion.CAMT052 stmt = tree.find("./s:BkToCstmrAcctRpt/s:Rpt", self.xmlns) assert stmt is not None return stmt
def isFormat(self, f): """Check if the necessary nodes to match can be extracted from the xml""" try: tree = ElementTree() tree.parse(f) elem = tree.find("hoomd_xml/position") elem = tree.find("hoomd_xml/type") except Exception, e: return False
def load(self, path): if not os.path.exists(path): return tree = ElementTree() tree.parse(path) self.schema_seq = int(tree.find("schema_seq").text) self.replication_seq = int(tree.find("replication_seq").text) self.last_replication_time = parse_time(tree.find("last_updated").text) self.last_finished_time = parse_time(tree.find("last_finished").text)
def xmlFileParse(xmlFile): "Use xml.etree parse XML doc." tree = ElementTree() tree.parse(open(xmlFile)) systemInfo = tree.find('SystemInformation') computerName = getValue(systemInfo.findtext('ComputerName')) files = tree.find('Files') fileList = {} for file in files.iter('File'): f = File() f.id = file.get('Id') f.path = getValue(list(file)[0].text) f.size = getValue(list(file)[1].text) f.attributes = getValue(list(file)[2].text) f.signer = getValue(list(file)[3].text) f.productName = getValue(list(file)[4].text) f.productVersion = getValue(list(file)[5].text) f.companyName = getValue(list(file)[6].text) f.fileDescription = getValue(list(file)[7].text) f.originalFilename = getValue(list(file)[8].text) f.fileVersionLabel = getValue(list(file)[9].text) f.fileVersionNumber = getValue(list(file)[10].text) f.sha1 = getValue(list(file)[11].text) f.md5 = getValue(list(file)[12].text) f.rootkitInfo = getValue(list(file)[13].text) f.createTime = getValue(list(file)[14].text) f.lastAccessTime = getValue(list(file)[15].text) f.lastWriteTime = getValue(list(file)[16].text) fileList[f.id] = f autoruns = tree.find('Autoruns') autorunList = {} for autorun in autoruns.iter('Autorun'): a = Autorun() a.id = autorun.get('Id') a.fileId = getValue(list(autorun)[0].text) a.location = getValue(list(autorun)[1].text) a.itemName = getValue(list(autorun)[2].text) a.launchString = getValue(list(autorun)[3].text) a.groupId = getValue(list(autorun)[4].text) autorunList[a.id] = a processes = tree.find('Processes') processList = {} for process in processes.iter('Process'): p = Process() p.id = process.get('Id') p.pid = getValue(list(process)[0].text) p.parentPid = getValue(list(process)[1].text) p.commandLine = getValue(list(process)[2].text) p.userName = getValue(list(process)[3].text) p.fileId = getValue(list(process)[4].text) for i in range(0, len(list(process)[5])): p.dlls.append(getValue(list(process)[5][i][0].text)) processList[p.id] = p return (computerName, fileList, autorunList, processList)
def getSession(self): #api_response = self.get("SetSession") api_response = open('gapython/tree.xml') if api_response is None: raise("Could not connect to Global Agenda API") tree = ElementTree(file=api_response) if tree.find('rec_cd').text is not "0": raise("Error returned on response" + tree.find('ret_msg').text)
def get_mi_nextseq_container(run_dir): tree = ElementTree() try: tree.parse(os.path.join(run_dir, "runParameters.xml")) # MiSeq return tree.find("ReagentKitRFIDTag/SerialNumber").text except IOError: tree.parse(os.path.join(run_dir, "RunParameters.xml")) # NextSeq return tree.find("ReagentKitRfidTag/SerialNumber").text except xml.parsers.expat.ExpatError: pass # This happens
def _extract_prices_to_csv(self, fullpath, store_name, csv_output_folder): logging.info("Starting to process file: " + fullpath) input_file = gzip.open(fullpath, "rb") strdata = input_file.read() root = ElementTree(fromstring(strdata)) itemscount = root.find(".//Items") num = itemscount.attrib.get("Count") if num > 0: csv_lines = [] store_id = root.find(".//StoreId").text chain_id = root.find(".//ChainId").text sub_chain_id = root.find(".//SubChainId").text items_elem = root.findall(".//Items/Item") for item in items_elem: try: price_update_date = item.find("PriceUpdateDate") if price_update_date is not None and price_update_date.text is not None: price_update_date = price_update_date.text item_code = item.find("ItemCode") if item_code is not None and item_code.text is not None: item_code = item_code.text.encode('utf-8') item_name = item.find("ItemName") if item_name is not None and item_name.text is not None: item_name = item_name.text.replace("#", "-").encode('utf-8') manufacture_name = item.find("ManufacturerName") if manufacture_name is not None and manufacture_name.text is not None: manufacture_name = manufacture_name.text.replace("#", "-").encode('utf-8') manufacture_country = item.find("ManufactureCountry") if manufacture_country is not None and manufacture_country.text is not None: manufacture_country = manufacture_country.text.replace("#", "-").encode('utf-8') manufacture_item_desc = item.find("ManufacturerItemDescription") if manufacture_item_desc is not None and manufacture_item_desc.text is not None: manufacture_item_desc = manufacture_item_desc.text.replace("#", "-").encode('utf-8') qty = item.find("Quantity") if qty is not None and qty.text is not None: qty = qty.text.encode('utf-8') item_price = item.find("ItemPrice") if item_price is not None and item_price.text is not None: item_price = item_price.text.encode('utf-8') item_id = item.find("ItemId") if item_id is not None and item_id.text is not None: item_id = item_id.text.encode('utf-8') the_line = chain_id+self.csv_line_sep+sub_chain_id+self.csv_line_sep+store_id +\ self.csv_line_sep+item_id + self.csv_line_sep + item_price + self.csv_line_sep + \ qty + self.csv_line_sep + manufacture_name + self.csv_line_sep + manufacture_country + \ self.csv_line_sep + manufacture_item_desc + self.csv_line_sep + item_name + \ self.csv_line_sep + item_code + self.csv_line_sep + price_update_date csv_lines.append(the_line.decode('utf-8').split(self.csv_line_sep)) except TypeError, e: logging.error( "Got problem with one of the xml elements... Error: " + str(e)) except AttributeError, e: logging.error( "Got problem with one of the xml elements and couldnt perform an action... Error: " + str(e))
def get_interval_sizes(dtatcfdir, time_boundaries, freq_words, tagset, join_sign): """ Get token frequency in specific time intervals of dta. :param dtatcfdir: path to directory with dta tcf files :param time_boundaries: list of time boundaries seperating intervals :param freq_words: list of words with sufficient frequency :param tagset: list of POS-tags to include :param join_sign: sign to join lemma + first char of POS :return: dictionary, mapping file boundaries to token frequencies """ interval_size_dict = defaultdict(int) print "Getting interval sizes..." # get the corpus size of each time interval speciified in the input for root, dirs, files in os.walk(dtatcfdir): for filename in files: if ".tcf" in filename: dta_file = os.path.join(root, filename) file_boundary = get_file_boundary(time_boundaries, tree) if file_boundary == 0: continue tree = ElementTree() tree.parse(dta_file) lemmas = tree.find( "{http://www.dspin.de/data/textcorpus}TextCorpus/{http://www.dspin.de/data/textcorpus}lemmas" ) POStags = tree.find( "{http://www.dspin.de/data/textcorpus}TextCorpus/{http://www.dspin.de/data/textcorpus}POStags" ) for i, lemma_elem in enumerate(lemmas): try: lemma = lemma_elem.text pos = POStags[i].text target = lemma + join_sign + pos[ 0] # lemma + first char of POS, e.g. run-v / run-n # only count lemmas which are frequent enough and have the respective POS-tags if not target in freq_words or not (pos.startswith(x) for x in tagset): continue interval_size_dict[file_boundary] += 1 except: pass print "token skipped..." print interval_size_dict logging.info(interval_size_dict) return interval_size_dict
def elevationAntennaPattern(self, burst): eta_anx = burst.ascendingNodeTime Ns = burst.numberOfSamples fs = burst.rangeSampleRate eta_start = burst.sensingStart tau0 = burst.slantRangeTime tau_sub = np.array(burst.slantRangeTimeSub) theta_sub = np.array(burst.elevationAngle) ########################################### #Reading the 2 way EAP (Elevation Antenna Pattern from AUX_CAL file) fp = open(burst.auxFile, 'r') xml_root = ElementTree(file=fp).getroot() res = xml_root.find('calibrationParamsList/calibrationParams') paramsList = xml_root.find('calibrationParamsList') for par in (paramsList.getchildren()): if par.find('swath').text == burst.swath and par.find( 'polarisation').text == burst.polarization: print(par.find('swath').text) print(par.find('polarisation').text) delta_theta = float( par.find('elevationAntennaPattern/elevationAngleIncrement' ).text) Geap_IQ = [ float(val) for val in par.find( 'elevationAntennaPattern/values').text.split() ] I = np.array(Geap_IQ[0::2]) Q = np.array(Geap_IQ[1::2]) Geap = I[:] + Q[:] * 1j # Complex vector of Elevation Antenna Pattern Nelt = np.shape(Geap)[0] ######################### # Vector of elevation angle in antenna frame theta_AM = np.arange(-(Nelt - 1.) / 2, (Nelt - 1.) / 2 + 1) * delta_theta ######################## delta_anx = (eta_start - eta_anx).total_seconds() theta_offnadir = anx2roll(delta_anx) theta_eap = theta_AM + theta_offnadir ######################## #interpolate the 2-way complex EAP tau = tau0 + np.arange(Ns) / fs from scipy.interpolate import interp1d # f = interp1d(tau_sub,theta_sub) # theta = f(tau) theta = np.interp(tau, tau_sub, theta_sub) # theta = interpolate(theta_sub,tau_sub,tau) f2 = interp1d(theta_eap, Geap) Geap_interpolated = f2(theta) # interpolate(Geap,theta_eap,theta) # Geap_interpolated = np.interp(theta, theta_eap, Geap) phi_EAP = np.angle(Geap_interpolated) cJ = np.complex64(1.0j) GEAP = np.exp(cJ * phi_EAP) return GEAP
class xbmcScraper(scraper): """ the xbmcScraper class provides a generic ground foundation, which is required for all XBMC scrapers. """ xml = ElementTree() # holds the scraper regex xml tree addonxml = ElementTree() # xml tree of addon.xml settingsxml= ElementTree() # xml tree of resources/settings.xml path = None # filesystem path to scraper basepath = None # the path which contains the scraper requires = [] # an array of dicts with the keys: scrpaer, version deps = [] # contains the dependencies of the scraper as Scraper object def __init__(self, scraperPath = None): self.xml = ElementTree() self.addonxml = ElementTree() self.settingsxml= ElementTree() self.requires = [] self.deps = [] if scraperPath: scraperPath = os.path.normpath(scraperPath) self.addonxml.parse( os.path.join(scraperPath, "addon.xml") ) xmlpath = self.addonxml.find("extension").attrib["library"] self.xml.parse( os.path.join(scraperPath, xmlpath) ) if os.path.exists(os.path.join(scraperPath, "resources/settings.xml")): self.settingsxml.parse( os.path.join(scraperPath, "resources/settings.xml") ) requires = self.addonxml.find("requires") if requires: for require in requires.findall("import"): self.requires.append({}) self.requires[-1]["scraper"] = require.attrib["addon"] self.requires[-1]["version"] = require.attrib["version"] else: logging.warning("could not find <requires> in %s/addon.xml" % scraperPath) self.basepath = os.path.split(scraperPath)[0] self.path = scraperPath if hasattr(self, "__stage2__"): self.__stage2__() def __stage2__(self): """ a customizable appendix to __init__ """ def __resolve_deps__(self): """ resolve import dependencies of the scraper """ for require in self.requires: if not require["scraper"] in ["xbmc.metadata",]: # some deps are for xbmc only and are not scraper relevant logging.info("importing scraper %s as dependency." % require["scraper"]) scraper = getScraper(os.path.join(self.basepath, require["scraper"])) scraper.__resolve_deps__() self.xml._setroot( mergeEtree( self.xml.getroot(), scraper.xml.getroot() ) ) def search(self, name): """ dummy """
def parse(filename): info = dict() with zipfile.ZipFile(unicode(filename, 'utf-8')) as zf: for name in zf.namelist(): if os.path.basename(name) == 'module.xml': et = ElementTree(file=zf.open(name)) info['name'] = et.find('name').text info['version'] = et.find('version').text info['desc'] = et.find('description').text break return info
def configure(self, config_tree: ElementTree): self.name = config_tree.get('name') config_pins = config_tree.find('pins') pins = config_pins.findall('pin') self.extra = config_tree.find('extra') logging.debug("Found %i pins for %s.", len(pins), self.__class__.__name__) for cpin in pins: self.pins.append(Pin(cpin)) self._post_config()
def remove_trkpt_namespaces(trkpt: ET.ElementTree, namespaces: Dict[str, str]) -> None: ''' By default the each trkpt and their sub-elements would have an "ns0:" prefix on them. We don't want that, so we set the tag manually. ''' trkpt.tag = 'trkpt' ele = trkpt.find('gpx:ele', namespaces) ele.tag = 'ele' time = trkpt.find('gpx:time', namespaces) time.tag = 'time'
def create(self): assert (self.type in ['A', 'CNAME', 'MX', 'AAAA']) assert (self.data) if self._id: raise AlreadyExists(self.fqdn) # it works like in Zone.create() url = Zerigo._url_api \ + Host._url_template.substitute(zone_id=self.__zone._id) Zerigo._logger.debug('retrieving ' + url) template = self._conn.get(url) tree = ElementTree() tree.parse(template.body_file) type = tree.find('host-type') hostname = tree.find('hostname') data = tree.find('data') if type is None or hostname is None or data is None: raise ParseError() type.text = self.type if 'nil' in hostname.attrib: del hostname.attrib['nil'] hostname.text = self.hostname if 'nil' in data.attrib: del data.attrib['nil'] data.text = self.data form = StringIO.StringIO() tree.write(form) form = form.getvalue() url = Zerigo._url_api + Host._url_create.substitute( zone_id=self.__zone._id) # exact same block in Zone; we should find a way to factore this try: Zerigo._logger.debug('posting ' + url) host = self._conn.post(url, body=form) except restkit.RequestFailed as errors: errors = StringIO.StringIO(errors) tree = ElementTree() tree.parse(errors) errors = [err.text for err in tree.findall('error')] raise CreateError(self.fqdn, ', '.join(errors)) # read the id tree = ElementTree() tree.parse(host.body_file) id = tree.find('id') if id is None or not id.text: raise ParseError() self._id = id.text Zerigo._logger.debug('host ' + self.fqdn + ' created with id: ' + self._id)
def create(self): assert(self.type in ['A', 'CNAME', 'MX', 'AAAA']) assert(self.data) if self._id: raise AlreadyExists(self.fqdn) # it works like in Zone.create() url = Zerigo._url_api \ + Host._url_template.substitute(zone_id=self.__zone._id) Zerigo._logger.debug('retrieving ' + url) template = self._conn.get(url) tree = ElementTree() tree.parse(template.body_file) type = tree.find('host-type') hostname = tree.find('hostname') data = tree.find('data') if type is None or hostname is None or data is None: raise ParseError() type.text = self.type if 'nil' in hostname.attrib: del hostname.attrib['nil'] hostname.text = self.hostname if 'nil' in data.attrib: del data.attrib['nil'] data.text = self.data form = StringIO.StringIO() tree.write(form) form = form.getvalue() url = Zerigo._url_api + Host._url_create.substitute(zone_id=self.__zone._id) # exact same block in Zone; we should find a way to factore this try: Zerigo._logger.debug('posting ' + url) host = self._conn.post(url, body=form) except restkit.RequestFailed as errors: errors = StringIO.StringIO(errors) tree = ElementTree() tree.parse(errors) errors = [err.text for err in tree.findall('error')] raise CreateError(self.fqdn, ', '.join(errors)) # read the id tree = ElementTree() tree.parse(host.body_file) id = tree.find('id') if id is None or not id.text: raise ParseError() self._id = id.text Zerigo._logger.debug('host ' + self.fqdn + ' created with id: ' + self._id)
def _parseconf(self, filename): """Parse the configuration file.""" try: etree = ElementTree(file=filename) except Exception: err = sys.exc_info()[1] raise ConfigurationError(filename, str(err)) if etree.getroot().tag != "bakonf": raise ConfigurationError(filename, "XML file root is not bakonf") self._cur_cfgfile = filename if self.options.statefile is None: vpath = etree.find("/config/statefile") if vpath is None: self.fs_statefile = DEFAULT_VPATH else: self.fs_statefile = vpath.text else: self.fs_statefile = self.options.statefile msize = etree.find("/config/maxsize") if msize is not None: try: self.fs_maxsize = int(msize.text) except (ValueError, TypeError): err = sys.exc_info()[1] raise ConfigurationError(filename, "Invalid maxsize" " value: %s" % err) tlist = self._get_extra_sources(filename, etree) # process scanning targets for cfile, conft in tlist: self._cur_cfgfile = cfile for scan_path in conft.findall("/filesystem/scan"): self._check_val(scan_path.text, "Invalid scan element") paths = [os.path.abspath(i) for i in glob.glob(scan_path.text)] self.fs_include += [ensure_text(i) for i in paths] # process noscan targets for noscan_path in conft.findall("/filesystem/noscan"): self._check_val(noscan_path.text, "Invalid noscan element") self.fs_exclude.append(ensure_text(noscan_path.text)) # command output for cmdouts in conft.findall("/commands/storeoutput"): cmd_line = ensure_text(cmdouts.text) cmd_dest = ensure_text(cmdouts.get("destination")) self._check_val(cmd_line, "Invalid storeoutput command") self.cmd_outputs.append(CmdOutput(cmd_line, cmd_dest))
def convert_svg(filename, varbase, groupcount, scalefactor=256): from xml.etree.ElementTree import ElementTree tree = ElementTree() tree.parse(filename) # if whichchars: # whichchars = unicode(whichchars) # F**K YOU XML!!!!!!!!!!!!!!!!!!!! ns = re.match("\{.*\}", tree.find(".").tag).group(0) path = tree.find("%sg/%spath" % (ns, ns)) d = path.get("d") bezierdata = makebezier(d) print len(d), len(bezierdata) # write out data to headerfile fd = file("%s.c" % varbase, "wb") fd.write('#include "fontheader.h"\n\n') # data fd.write("const bezier_t %s_data[] = {\n" % varbase) first = True for b in bezierdata: if not first: fd.write(",\n") first = False a = tuple( map(lambda x: int(x * scalefactor), (b[0][0], b[0][1], b[1][0], b[1][1], b[2][0], b[2][1]))) fd.write("\t{%s, %s, %s, %s, %s, %s}" % a) fd.write("};\n\n") # glyphs fd.write("const glyph_t %s_glyph = " % varbase) first = True cumlen = 0 fd.write("{%s, %s, &%s_data[0], %s, " % ("' '", 0, varbase, len(bezierdata))) groupdata = sort_glyph_to_groups(bezierdata, groupcount) if groupdata: starts, lens, pathlens = zip(*groupdata) else: starts, lens, pathlens = [], [], [] pathlens = map(lambda x: int(x * scalefactor), pathlens) fd.write( list_to_C(starts, maxgroups) + ", " + list_to_C(lens, maxgroups) + "," + "}") fd.write(";\n\n")
def _get_supplementary_material(tree, sup): """ Given an ElementTree returns supplementary materials as a dictionary containing url, mimetype and label and caption. """ result = {} sup_tree = ElementTree(sup) label = sup_tree.find('label') result['label'] = '' if label is not None: result['label'] = label.text title = sup_tree.find('caption/title') result['title'] = '' if title is not None: title = _strip_whitespace(' '.join(title.itertext())) result['title'] = title caption = sup_tree.find('caption') result['caption'] = '' if caption is not None: caption_without_title = [] for node in caption: if node.tag != 'title': caption_without_title.append(''.join(node.itertext())) caption = _strip_whitespace('\n'.join(caption_without_title)) # remove file size and type information, e.g. “(1.3 MB MPG)” lastline = caption.split('\n')[-1] if lastline.startswith('(') and lastline.endswith(')'): caption = ' '.join(caption.split('\n')[:-1]) assert 'Click here' not in caption result['caption'] = caption media = sup_tree.find('media') if media is not None: try: result['mimetype'] = media.attrib['mimetype'] result['mime-subtype'] = media.attrib['mime-subtype'] result['href'] = media.attrib['{http://www.w3.org/1999/xlink}href'] except KeyError: result['mimetype'] = '' result['mime-subtype'] = '' result['href'] = '' result['url'] = _get_supplementary_material_url( _get_pmcid(tree), result['href'] ) return result
class Settings: SETTINGS_FILENAME = "settings.xml" OAUTH_CONSUMER_KEY_PATH = "oauth/consumerKey" OAUTH_CONSUMER_SECRET_PATH = "oauth/consumerSecret" OAUTH_ACCESS_TOKEN_PATH = "oauth/accessToken" OAUTH_ACCESS_TOKEN_SECRET_PATH = "oauth/accessTokenSecret" def __init__(self, filename=SETTINGS_FILENAME): self.settings = ElementTree() self.settings.parse(filename) def consumer_secret(self): consumer_secret = self.settings.find(self.OAUTH_CONSUMER_SECRET_PATH) if consumer_secret is not None: return consumer_secret.text return None def consumer_key(self): consumer_key = self.settings.find(self.OAUTH_CONSUMER_KEY_PATH) if consumer_key is not None: return consumer_key.text return None def access_token(self): access_token = self.settings.find(self.OAUTH_ACCESS_TOKEN_PATH) if access_token is not None: return access_token.text return None def access_token_secret(self): access_token_secret = self.settings.find(self.OAUTH_ACCESS_TOKEN_SECRET_PATH) if access_token_secret is not None: return access_token_secret.text return None def has_token(self): return self.access_token() is not None def write_access(self, access_token, access_token_secret): xml_oauth = self.settings.find("oauth") xml_access_token = SubElement(xml_oauth, "accessToken") xml_access_token.text = access_token xml_access_token_secret = SubElement(xml_oauth, "accessTokenSecret") xml_access_token_secret.text = access_token_secret self.settings.write(self.SETTINGS_FILENAME)
def adaptPARAMS(setName, runNumber, num_classes, runType): ''' Adapt the parameter file and copy it to STYLENE. ''' modPARAMS = os.path.splitext(PARAMS)[0] + '-mod.xml' tree = ElementTree() tree.parse(PARAMS) tree.find('run-type').text = str(runType) tree.find('run-number').text = str(runNumber) tree.find('set-name').text = str(setName) tree.find('number-of-classes').text = str(num_classes) tree.write(modPARAMS, encoding='utf-8') file_util.copy_file(modPARAMS, newPARAMS)
def add_to_datatypes_conf_xml(datatypes_conf_tree: ET.ElementTree, consumer_name): display_tag = ET.Element( 'display', {'file': get_display_app_xml_filename(consumer_name)}) for dt in datatypes_conf_tree.find('registration').findall('datatype'): if dt.attrib['extension'] == 'json': dt.append(display_tag)
def build_app_info(self, project_dir): tiapp = ElementTree() assets_tiappxml = os.path.join(project_dir, 'build', 'android', 'bin', 'assets', 'tiapp.xml') self.app_info = {'fullscreen': 'false', 'navbar-hidden': 'false'} self.app_properties = {} if not os.path.exists(assets_tiappxml): shutil.copy(os.path.join(project_dir, 'tiapp.xml'), assets_tiappxml) tiapp.parse(open(assets_tiappxml, 'r')) for key in [ 'id', 'name', 'version', 'publisher', 'url', 'copyright', 'description', 'icon', 'analytics', 'guid', 'navbar-hidden', 'fullscreen' ]: el = tiapp.find(key) if el != None: self.app_info[key] = el.text for property_el in tiapp.findall("property"): name = property_el.get("name") type = property_el.get("type") value = property_el.text if name == None: continue if type == None: type = "string" if value == None: value = "" self.app_properties[name] = {"type": type, "value": value}
def _is_error_page(page_file): doc = ElementTree(file=page_file) title = doc.find("head/title") page_file.seek(0) ## reset file's current position if title.text.find("not available") != -1: return True return False
def get_pars_from_xml(xmlpath): assert os.path.exists(xmlpath) root = ElementTree().parse(xmlpath) acquisitionSystem = root.find('acquisitionSystem') n_channels = int(acquisitionSystem.find('nChannels').text) sample_rate = np.float32(acquisitionSystem.find('samplingRate').text) return n_channels, sample_rate
def _getTVDBThumbnail(self): import os, time if self.id: # check if the file already exists if os.path.isfile(Config['tmpdir']+self.id+'-'+Config['tvdblang']+'.xml'): # if it is older than config['cacherenew'] days, delete the files and download again if os.path.getctime(Config['tmpdir']+self.id+'-'+Config['tvdblang']+'.xml') < time.time()-(Config['cacherenew']*86400): os.remove(Config['tmpdir']+self.id+'-'+Config['tvdblang']+'.xml') if not os.path.isfile(Config['tmpdir']+self.id+'-'+Config['tvdblang']+'.xml'): URL('http://www.thetvdb.com/api/'+Config['tvdbapikey']+'/series/'+self.id+'/all/'+Config['tvdblang']+'.xml').download(Config['tmpdir']+self.id+'-'+Config['tvdblang']+'.xml') from xml.etree.ElementTree import ElementTree tree = ElementTree() try: tree.parse(Config['tmpdir']+self.id+'-'+Config['tvdblang']+'.xml') if Config['posterforpilot'] == True and self.season == 1 and self.episode == 1: series = tree.find('Series') if series.find('poster').text: self.thumbnail = 'http://www.thetvdb.com/banners/'+series.find('poster').text return True for episode in tree.findall('Episode'): if int(episode.find('SeasonNumber').text) == self.season and int(episode.find('EpisodeNumber').text) == self.episode: if episode.find('filename').text: self.thumbnail = 'http://www.thetvdb.com/banners/'+episode.find('filename').text return True except: pass return False
def getSvgGroupElement(tree: ET.ElementTree, key: str) -> ET.Element: query = f".//default:g[@id='{key}']" e = tree.find(query, SVGNamespace) if e is None: raise Exception("Not Found in SVG.", key) return e
def update_show_indexer_metadata(self, show_obj): if self.show_metadata and show_obj and self._has_show_metadata(show_obj): sickrage.app.log.debug( "Metadata provider " + self.name + " updating show indexer info metadata file for " + show_obj.name) nfo_file_path = self.get_show_file_path(show_obj) try: with io.open(nfo_file_path, 'rb') as xmlFileObj: showXML = ElementTree(file=xmlFileObj) indexerid = showXML.find('id') root = showXML.getroot() if indexerid is not None: indexerid.text = str(show_obj.indexerid) else: SubElement(root, "id").text = str(show_obj.indexerid) # Make it purdy indentXML(root) showXML.write(nfo_file_path, encoding='UTF-8') chmodAsParent(nfo_file_path) return True except IOError as e: sickrage.app.log.error( "Unable to write file to " + nfo_file_path + " - are you sure the folder is writable? {}".format( e.message))
def convert_from_xml(self, f): print(f) glob.glob(f) os.chdir(f) for file in glob.glob("*.xml"): with open(file, 'r') as f: xcontent = ElementTree() xcontent.parse(file) doc = [ xcontent.find("title").text, xcontent.find("content").text, xcontent.find("keywords").text ] out = open(file + ".txt", "w") out.write("\n\n".join(doc)) return True
def install_drp_flag(self): flag_disk_path = os.path.join(rcEnv.paths.pathvar, 'drp_flag.vdisk') from xml.etree.ElementTree import ElementTree, SubElement tree = ElementTree() try: tree.parse(self.cf) except Exception as exc: raise ex.excError("container config parsing error: %s" % exc) # create the vdisk if it does not exist yet if not os.path.exists(flag_disk_path): with open(flag_disk_path, 'w') as f: f.write('') f.close() # check if drp flag is already set up for disk in tree.getiterator("disk"): e = disk.find('source') if e is None: continue (dev, path) = e.items()[0] if path == flag_disk_path: self.log.info("flag virtual disk already exists") return # add vdisk to the vm xml config self.log.info("install drp flag virtual disk") devices = tree.find("devices") e = SubElement(devices, "disk", {'device': 'disk', 'type': 'file'}) SubElement(e, "driver", {'name': 'qemu'}) SubElement(e, "source", {'file': flag_disk_path}) SubElement(e, "target", {'bus': 'virtio', 'dev': 'vdosvc'}) tree.write(self.cf)
def populateIPFVersion(self): ''' Get IPF version from the manifest file. ''' if self.manifest is None: return nsp = "{http://www.esa.int/safe/sentinel-1.0}" try: fp = open(self.manifest, 'r') root = ElementTree(file=fp).getroot() fp.close() elem = root.find('.//metadataObject[@ID="processing"]') rdict = elem.find('.//xmlData/' + nsp + 'processing/' + nsp + 'facility/' + nsp + 'software').attrib self.IPFversion = rdict['version'] print('Setting IPF version to : ', self.IPFversion) except: print( 'Could not read version number successfully from manifest file: ', self.manifest) pass return
def _load_commands(self, cfg: ET.ElementTree) \ -> List[Tuple[str, Union[str, Dict]]]: commands = cfg.find("commands") if commands is None: return for cmd in commands: if cmd.tag == "zfs": yield ("zfs", cmd.text) continue if cmd.tag == "sudo": yield ("sudo", cmd.text) continue name = cmd.attrib["name"] command = cmd.find("command") if command is None: self._log.error("Could not load command %s: Missing <command>", name) argcfg = cmd.find("arguments") arguments = ([] if argcfg is None else list( [a.text for a in argcfg.findall("arg")])) yield (name, { "command": command.text, "args": arguments, "use_sudo": cmd.find("sudo") is not None, "readonly": cmd.find("readonly") is not None, })
def getInfo(xmlfile, propertyName): from xml.etree.ElementTree import ElementTree xmlfp = None content = None try: xmlfp = open(xmlfile, 'r') xmlx = ElementTree(file=xmlfp).getroot() #search each possible propertyName propertyNameList = [ propertyName, propertyName.lower(), propertyName.upper(), propertyName.capitalize() ] for propertyNameX in propertyNameList: route = "property[@name='{}']/value".format(propertyNameX) contentAll = xmlx.find(route) if contentAll != None: content = contentAll.text content = content.strip( "'") #remove the leading and trailing quote content = content.strip( '"') #remove the leading and trailing quote #print("{}: {}".format(propertyName, content)) break except (IOError, OSError) as strerr: print("IOError: %s" % strerr) return None finally: if xmlfp is not None: xmlfp.close() return content