E.size( E.width(width), E.height(height), E.depth(3), ), E.segmented(0) ) def instance_to_xml(class_label, xmin, ymin, xmax, ymax): E = objectify.ElementMaker(annotate=False) return E.object( E.name(class_label), E.bndbox( E.xmin(xmin), E.ymin(ymin), E.xmax(xmax), E.ymax(ymax), ), ) if __name__=="__main__": annotation = root("folder", "filename", 640, 480) label1 = instance_to_xml("wasabi_snack", 34, 45, 100, 100) label2 = instance_to_xml("butter_bisuco", 34, 45, 100, 100) annotation.append(label1) annotation.append(label2) etree.ElementTree(annotation).write("{}.xml".format("temp2"))
def generate_legend(colormaps, output, output_format, orientation, label_color, colorbar_only): # set ticklines out rcParams['xtick.direction'] = 'out' rcParams['ytick.direction'] = 'out' lc = len(colormaps) t = 0 has_values = False for colormap in colormaps: if colormap.title != None: t = 0.15 if colormap.legend != None: if colormap.legend.legend_type != "classification": has_values = True if orientation == 'horizontal': t = 0.15 fig = pyplot.figure(figsize=(4.2, t + 0.8 + (1 * (lc - 1)))) else: # default vertical orientation fig = pyplot.figure(figsize=(1.5 + (2 * (lc - 1)), 3.2)) colors = [] legend_entries = [] legend_count = 0 labels = [] label_index = [] for colormap in colormaps: legend_count += 1 bounds = [] ticks = [] ticklabels = [] legendcolors = [] legendlabels = [] if colormap.legend == None: entries = colormap.colormap_entries # ensure showTick and showLabel exist if no legend for idx in range(0, len(entries)): entries[idx].showtick = False entries[idx].showlabel = False else: entries = colormap.legend.legend_entries colormap.style = colormap.legend.legend_type if colormap.legend.legend_type != "classification": # clear colors if not classification colors = [] legend_entries = [] for legend_entry in entries: if legend_entry.transparent == False: if colormap.style == "classification": legendcolors.append(legend_entry.color) if legend_entry.tooltip: legendlabels.append(legend_entry.tooltip) labels.append(legend_entry.tooltip) else: legendlabels.append(legend_entry.label) labels.append(legend_entry.label) else: if legend_entry.color != None: has_values = True legend_entries.append(legend_entry) colors.append(legend_entry.color) if colormap.style != "classification": for idx in range(0, len(legend_entries)): if legend_entries[idx].showtick == True or legend_entries[ idx].showlabel == True or idx == 0 or idx == len( legend_entries) - 1: if colormap.style == "discrete": ticks.append(idx + 0.5) else: if idx == len(legend_entries) - 1: ticks.append(idx + 1) # add end label else: ticks.append(idx) if legend_entries[idx].showlabel == True: ticklabels.append(legend_entries[idx].label) labels.append(legend_entries[idx].label) elif idx == 0 and colormap.legend.min_label != None: ticklabels.append(colormap.legend.min_label) labels.append(colormap.legend.min_label) elif idx == len( legend_entries ) - 1 and colormap.legend.max_label != None: ticklabels.append(colormap.legend.max_label) labels.append(colormap.legend.max_label) else: ticklabels.append("") labels.append("") label_index.append(idx) # Handle +/- INF lowerinf = False upperinf = False if len(bounds) > 0: lowerinf = math.isinf(bounds[0]) upperinf = math.isinf(bounds[-1]) bounds = [x for x in bounds if math.isinf(x) == False] ticks = [x for x in ticks if math.isinf(x) == False] # Check for long labels longlabels = False for legendlabel in legendlabels: if len(legendlabel) > 14: longlabels = True if orientation == 'horizontal': if lc == 1: bottom = 0.6 - t else: bottom = 0.90 - ((0.9 / lc) * (legend_count - 1)) - (0.20 / lc) height = 0.20 / lc # use legend for classifications if colormap.style == "classification": if lc == 1: fig.set_figheight(3) if longlabels: fig.set_figwidth(3) else: fig.set_figwidth(1.5) else: bottom = bottom patches = [] for color in legendcolors: polygon = mpl.patches.Rectangle((0, 0), 10, 10, facecolor=color) polygon.set_linewidth(0.5) patches.append(polygon) if len(legendcolors) < 7 and has_values == False: if lc == 1: fig.set_figheight(1.5) if len(legendcolors) <= (15 / lc): col = 1 fontsize = 9 if len(legendcolors) > (15 / lc): if lc == 1: fig.set_figwidth(3) col = 2 fontsize = 8 if len(legendcolors) > (30 / lc): if lc == 1: fig.set_figwidth(4.2) col = 3 fontsize = 7 if has_values == True: if lc == 1: fig.set_figwidth(4.2) legend = fig.legend( patches, legendlabels, bbox_to_anchor=[0.025, bottom + (0.3 / lc)], loc='upper left', ncol=col, fancybox=True, prop={'size': fontsize}) legend.get_frame().set_alpha(0) else: legend = fig.legend(patches, legendlabels, bbox_to_anchor=[0.5, 0.5], loc='center', ncol=col, fancybox=True, prop={'size': fontsize}) legend.get_frame().set_alpha(0.5) for text in legend.get_texts(): text.set_color(label_color) if has_values == True and (colormap.style != "classification" or colormap.legend == None): if colorbar_only: fig.set_figheight(height) fig.set_figwidth(2.56) ax = fig.add_axes([0, 0.03, 0.995, 0.97]) else: ax = fig.add_axes([0.075, bottom, 0.85, height]) cmap = mpl.colors.ListedColormap(colors) if len(bounds) > 0: norm = mpl.colors.BoundaryNorm(bounds, cmap.N) cb = mpl.colorbar.ColorbarBase(ax, cmap=cmap, norm=norm, ticks=ticks, orientation=orientation) cb.ax.set_xticklabels(ticks) else: norm = mpl.colors.BoundaryNorm(range(len(colors) + 1), cmap.N) cb = mpl.colorbar.ColorbarBase(ax, cmap=cmap, norm=norm, ticks=ticks, orientation=orientation) cb.ax.set_xticklabels(ticklabels) cb.solids.set_edgecolor("face") for tick in cb.ax.xaxis.get_ticklabels(): tick.set_fontsize(8) tick.set_color(label_color) if colorbar_only: tick.set_alpha(0) if colorbar_only: # hide ticks if we want to show colorbar only for tickline in cb.ax.xaxis.get_ticklines(): tickline.set_alpha(0) if colormap.legend != None and len(bounds) > 0: if len(cb.ax.get_xticklabels()) > 0: xticklabels = cb.ax.get_xticklabels() xticklabels = [ label.get_text() for label in xticklabels ] # Check for infinity if lowerinf: xticklabels[0] = "<=" + xticklabels[0] if upperinf: xticklabels[-1] = ">=" + xticklabels[-1] # show only those with showLabel for idx in range(0, len(xticklabels)): try: if float(xticklabels[idx]) not in ticklabels: xticklabels[idx] = "" except ValueError: xticklabels[idx] = "" # Use min/max labels if colormap.legend.min_label != None: xticklabels[0] = colormap.legend.min_label if colormap.legend.max_label != None: xticklabels[-1] = colormap.legend.max_label # use int labels if all values are integers # xticklabels = [int(float(label)) for label in xticklabels if float(label).is_integer()] cb.ax.set_xticklabels(xticklabels) if colormap.units != None and colorbar_only == False: fig.text(0.5, bottom - height - (0.20 / lc), colormap.units, fontsize=10, horizontalalignment='center', color=label_color) if colormap.title != None and colorbar_only == False: if lc == 1: title_loc = 1 - t else: title_loc = bottom + height + (0.07 / lc) fig.text(0.5, title_loc, colormap.title, fontsize=10, horizontalalignment='center', weight='bold', color=label_color) else: # default vertical orientation left = ((1.00 / lc) * legend_count) - (0.73 / lc) width = 0.15 / lc # use legend for classifications if colormap.style == "classification": if longlabels and fig.get_figwidth() < 3: fig.set_figwidth(3.2) patches = [] for color in legendcolors: polygon = mpl.patches.Rectangle((0, 0), 10, 10, facecolor=color) polygon.set_linewidth(0.5) patches.append(polygon) if len(legendcolors) < 7 and has_values == False: if lc <= 2: fig.set_figheight(1.5) if len(legendcolors) <= 14: col = 1 fontsize = 9 if len(legendcolors) > 14: if lc <= 2: fig.set_figwidth(3.2) col = 2 fontsize = 8 if len(legendcolors) > 28: if lc <= 2: fig.set_figwidth(4.2) col = 3 fontsize = 7 if has_values == True: if lc <= 2: fig.set_figwidth(3.2) legend = fig.legend( patches, legendlabels, bbox_to_anchor=[left - (0.15 / lc), 0.9], loc='upper left', ncol=1, fancybox=True, prop={'size': fontsize}) legend.get_frame().set_alpha(0) else: legend = fig.legend(patches, legendlabels, bbox_to_anchor=[0.5, 0.5], loc='center', ncol=col, fancybox=True, prop={'size': fontsize}) legend.get_frame().set_alpha(0.5) for text in legend.get_texts(): text.set_color(label_color) if has_values == True and (colormap.style != "classification" or colormap.legend == None): if colorbar_only: fig.set_figheight(2.56) fig.set_figwidth(0.2) ax = fig.add_axes([0.02, 0.005, 0.94, 0.995]) else: ax = fig.add_axes([left, 0.1, width, 0.8]) cmap = mpl.colors.ListedColormap(colors) if len(bounds) > 0: norm = mpl.colors.BoundaryNorm(bounds, cmap.N) cb = mpl.colorbar.ColorbarBase(ax, cmap=cmap, norm=norm, ticks=ticks, orientation=orientation) cb.ax.set_yticklabels(ticks) else: norm = mpl.colors.BoundaryNorm(range(len(colors) + 1), cmap.N) cb = mpl.colorbar.ColorbarBase(ax, cmap=cmap, norm=norm, ticks=ticks, orientation=orientation) cb.ax.set_yticklabels(ticklabels) cb.solids.set_edgecolor("face") for tick in cb.ax.yaxis.get_ticklabels(): tick.set_fontsize(10) tick.set_color(label_color) if colorbar_only: tick.set_alpha(0) if colorbar_only: # hide ticks if we want to show colorbar only for tickline in cb.ax.yaxis.get_ticklines(): tickline.set_alpha(0) if colormap.legend != None and len(bounds) > 0: if len(cb.ax.get_yticklabels()) > 0: yticklabels = cb.ax.get_yticklabels() yticklabels = [ label.get_text() for label in yticklabels ] # Check for infinity if lowerinf: yticklabels[0] = "<=" + yticklabels[0] if upperinf: yticklabels[-1] = ">=" + yticklabels[-1] # show only those with showLabel for idx in range(0, len(yticklabels)): try: if float(yticklabels[idx]) not in ticklabels: yticklabels[idx] = "" else: if float(yticklabels[idx]).is_integer(): yticklabels[idx] = int( float(yticklabels[idx])) except ValueError: yticklabels[idx] = "" # Use min/max labels if colormap.legend.min_label != None: yticklabels[0] = colormap.legend.min_label if colormap.legend.max_label != None: yticklabels[-1] = colormap.legend.max_label # use int labels if all values are integers # yticklabels = [int(float(label)) for label in yticklabels if float(label).is_integer()] cb.ax.set_yticklabels(yticklabels) if colormap.units != None and colorbar_only == False: fig.text(left + (0.08 / lc), 0.01, colormap.units, fontsize=10, horizontalalignment='center', color=label_color) if colormap.title != None and colorbar_only == False: title_left = left + (0.08 / lc) title_top = 0.935 if colormap.style == "classification": if lc == 1: title_left = 0.5 #center if only one classification legend title_top = 1 - t fs = 10 if len(colormap.title) > 10: fs = 9 if len(colormap.title) > 14: fs = 8 if len(colormap.title) > 16: title_words = colormap.title.split(" ") half = (len(title_words) / 2) if len(title_words) > 2: half += 1 title = "" for word in title_words[0:half]: title = title + word + " " title = title + "\n" for word in title_words[half:len(title_words)]: title = title + word + " " colormap.title = title fig.text(title_left, title_top, colormap.title, fontsize=fs, horizontalalignment='center', weight='bold', color=label_color) fig.savefig(output, transparent=True, format=output_format) # Add tooltips to SVG if output_format == 'svg' and has_values == True: ax = fig.get_axes()[0] # only supports one axis entries = colormaps[0].legend.legend_entries for i, entry in enumerate(entries): if entry.tooltip: text = entry.tooltip if colormaps[0].units: text = text + " " + colormaps[0].units else: text = entry.label if orientation == "horizontal": position = (float(i) / float(len(entries)), 1) else: position = (1, float(i) / float(len(entries))) ax.annotate( text, xy=position, xytext=position, textcoords='offset points', color='black', ha='center', fontsize=10, gid='tooltip', bbox=dict(boxstyle='round,pad=.3', fc=(1, 1, .9, 1), ec=(.1, .1, .1), lw=1, zorder=1), ) # Set id for the annotations for i, t in enumerate(ax.texts): t.set_gid('tooltip_%d' % i) # Save the figure f = StringIO() plt.savefig(f, transparent=True, format="svg") # Create XML tree from the SVG file tree, xmlid = ET.XMLID(f.getvalue()) tree.set('onload', 'init(evt)') # Hide the tooltips for i, t in enumerate(ax.texts): try: el = xmlid['tooltip_%d' % i] el.set('visibility', 'hidden') except KeyError: None # Add mouseover events to color bar try: el = xmlid['QuadMesh_1'] elements = list(el) elements.pop(0) # remove definitions except KeyError: print "Warning: Unable to add tooltips" elements = [] for i, t in enumerate(elements): el = elements[i] el.set('onmouseover', "ShowTooltip(" + str(i) + ")") el.set('onmouseout', "HideTooltip(" + str(i) + ")") # This is the script defining the ShowTooltip and HideTooltip functions. script = """ <script type="text/ecmascript"> <![CDATA[ function init(evt) { if ( window.svgDocument == null ) { svgDocument = evt.target.ownerDocument; } } function ShowTooltip(idx) { var tip = svgDocument.getElementById('tooltip_'+idx); tip.setAttribute('visibility',"visible") } function HideTooltip(idx) { var tip = svgDocument.getElementById('tooltip_'+idx); tip.setAttribute('visibility',"hidden") } ]]> </script> """ # Insert the script at the top of the file and save it. tree.insert(0, ET.XML(script)) ET.ElementTree(tree).write(output) print "SVG tooltips added" print output + " generated successfully"
def fo_xsl(self): sheet = ET.Element(xsl.stylesheet, version="1.0", nsmap=nsmap(xsl)) ET.SubElement(sheet, xsl['import'], href=os.path.join(XSLDIR, "fo", "docbook.xsl")) return ET.ElementTree(sheet)
def main(summary_path, repos_xml_path): GITHUB_USERNAME = os.environ['GITHUB_USERNAME'] GITHUB_TOKEN_FILE = os.environ['GITHUB_TOKEN_FILE'] GITHUB_ORG = os.environ['GITHUB_ORG'] with open(summary_path) as f: repos = json.load(f) with open(GITHUB_TOKEN_FILE) as f: token = f.read().strip() g = github.Github(GITHUB_USERNAME, token, per_page=50) gu = g.get_organization(GITHUB_ORG) gh_repos = set() # check repo states for data in repos.values(): # 1. we don't add repos with broken metadata but we also don't # remove existing ones -- we hope maintainers will fix them, # or overlays team will remove them # # 2. remove repos with unsupported VCS -- this means that # upstream has switched, and there's no point in keeping # an outdated mirror # # 3. we can't update repos which are broken to the point of # being implicitly removed data['x-can-create'] = data['x-state'] in ('GOOD', 'BAD_CACHE') data['x-can-update'] = data['x-can-create'] data['x-should-remove'] = data['x-state'] in ('REMOVED', 'UNSUPPORTED') # 0. scan all repos to_remove = [] to_update = [] for i, r in enumerate(gu.get_repos()): sys.stderr.write('\r@ scanning [%-3d/%-3d]' % (i+1, gu.public_repos)) if r.name not in repos or repos[r.name]['x-should-remove']: to_remove.append(r) else: gh_repos.add(r.name) if repos[r.name]['x-can-update']: to_update.append(r) repos[r.name]['x-mirror-sources'] = gh_sources(r) sys.stderr.write('\n') # 1. delete stale repos for r in to_remove: sys.stderr.write('* removing %s\n' % r.name) r.delete() # 2. now create new repos :) for r, data in sorted(repos.items()): if r not in gh_repos and data['x-can-create']: sys.stderr.write('* adding %s\n' % r) gr = gu.create_repo(r, description = ' '.join(data.get('description', {}).get('en').split()) or github.GithubObject.NotSet, homepage = data.get('homepage') or github.GithubObject.NotSet, has_issues = False, has_wiki = False) repos[r]['x-mirror-sources'] = gh_sources(gr) to_update.append(gr) # 3. write a new repositories.xml for them root = et.Element('repositories') root.set('version', '1.0') for r, data in sorted(repos.items()): if 'x-mirror-sources' not in data: continue rel = et.Element('repo') for attr, val in sorted(data.items(), key=dtd_sort_key): if attr.startswith('x-'): continue elif attr == 'source': # replace for t, url in data['x-mirror-sources']: subel = et.Element('source') subel.set('type', t) subel.text = url rel.append(subel) elif attr in ('quality', 'status'): # attributes rel.set(attr, val) elif attr in ('name', 'homepage'): # single-value subel = et.Element(attr) subel.text = val rel.append(subel) elif attr in ('description', 'longdescription'): # lang-dict for l, v in val.items(): subel = et.Element(attr) subel.set('lang', l) subel.text = v rel.append(subel) elif attr in ('owner', 'feed'): # lists for v in val: subel = et.Element(attr) if attr == 'owner': for k, subval in v.items(): if k == 'type': subel.set(k, subval) else: subsubel = et.Element(k) subsubel.text = subval subel.append(subsubel) else: subel.text = v rel.append(subel) root.append(rel) xml = et.ElementTree(root) with open(repos_xml_path, 'wb') as f: f.write(b'<?xml version="1.0" encoding="UTF-8"?>\n') f.write(b'<!DOCTYPE repositories SYSTEM "http://www.gentoo.org/dtd/repositories.dtd">\n') xml.write(f, encoding='utf-8', xml_declaration=False) print('DELETED_REPOS = %s' % ' '.join(r.name for r in to_remove)) print('REPOS = %s' % ' '.join(r.name for r in to_update))
def instrument_host(context_dict): # Dictionary Extractions instrument_host_string_list = context_dict['instrument_host_string_list'] lidvid_reference = context_dict['lidvid_reference'] Mission = context_dict['Mission'] # Declarations count_inst = 0 count_targs = 0 instrument_host_list = [] #instrument_string_list = [] #target_string_list = [] print '\n\n crawl.instrument_host Debug -------------' print '--Debug instrument_host_string_list ---------' for instrument_host in instrument_host_string_list: print 'Instrument Host: {}'.format(instrument_host) # Clean data and make URL instrument_host = instrument_host.upper() instrument_host = replace_all(instrument_host, '::', '_') instrument_host_url = 'https://starbase.jpl.nasa.gov/pds4/context-pds4/instrument_host/Product/PDS4_host_{0}.xml'.format( instrument_host) # Starbase instrument host tree instrument_host_tree = etree.ElementTree( file=urllib2.urlopen(instrument_host_url)) instrument_host_root = instrument_host_tree.getroot() # Create InstrumentHost model h = InstrumentHostForm().save(commit=False) h.mission = Mission h.raw_data = instrument_host h.lid = instrument_host_root[0][0].text t = instrument_host_root[2][0].text h.title = t.title() # Starbase error-Title needs to be in title case. h.type_of = instrument_host_root[2][1].text h.save() # Find Associated Instruments and Targets listed in instrument host tree for element in instrument_host_tree.findall(lidvid_reference): if element.text[21:31] == 'instrument': count_inst += 1 # Clean data and make URL instrument = element.text[32:-5] instrument_cleaned = instrument.upper() instrument_cleaned = replace_all(instrument_cleaned, '.', '__') instrument_url = 'https://starbase.jpl.nasa.gov/pds4/context-pds4/instrument/Product/PDS4_inst_{0}.xml'.format( instrument_cleaned) print '{0}: {1}'.format(count_inst, instrument) # Starbase instrument tree instrument_tree = etree.ElementTree( file=urllib2.urlopen(instrument_url)) instrument_root = instrument_tree.getroot() # Create Instrument model i = InstrumentForm().save(commit=False) i.instrument_host = h i.raw_data = instrument i.lid = instrument_root[0][0].text i.title = instrument_root[2][0].text i.type_of = instrument_root[2][1].text i.save() elif element.text[21:27] == 'target': count_targs += 1 # Clean data and make URL target = element.text[28:] begin_index = target.index('.') + 1 target_cleaned = target[begin_index:] target_cleaned = target_cleaned.upper() target_cleaned = replace_all(target_cleaned, '::', '_') target_url = 'https://starbase.jpl.nasa.gov/pds4/1700/PDS4_context_bundle_20161220/target/Product/PDS4_target_{}.xml'.format( target_cleaned) print '{0}: {1}'.format(count_targs, target) # Starbase target tree target_tree = etree.ElementTree( file=urllib2.urlopen(target_url)) target_root = target_tree.getroot() # Create Target model t = TargetForm().save(commit=False) t.instrument_host = h t.raw_data = target t.lid = target_root[0][0].text t.title = target_root[0][2].text t.type_of = target_root[1][1].text t.save() print '\n\nThere are {0} instruments and {1} targets in {2}.'.format( count_inst, count_targs, h.title) # Update List instrument_host_list.append(h) context_dict['instrument_host_list'] = instrument_host_list return context_dict
def save(self, path): doc = etree.ElementTree(self.to_xml()) doc.write(open(path, 'wb'), xml_declaration=True, encoding='utf-8', pretty_print=True)
f = ET.Element("annotations") ET.SubElement(f,'filename').text = file.split(".csv")[0] + ".png" thesize = ET.SubElement(f,'size') ET.SubElement(thesize,'width').text = str(width) ET.SubElement(thesize,'height').text = str(height) ET.SubElement(thesize,'depth').text = "3" for i in range(len(xmin)): obj = ET.SubElement(f,'object') ET.SubElement(obj,'name').text = "Poma" ET.SubElement(obj,'difficult').text = "0" bbox = ET.SubElement(obj,'bbox') xmin_xml = ET.SubElement(bbox,'xmin') ymin_xml = ET.SubElement(bbox,'ymin') xmax_xml = ET.SubElement(bbox,'xmax') ymax_xml = ET.SubElement(bbox,'ymax') xmin_xml.text = str(int(xmin[i])) xmax_xml.text = str(int(xmax[i])) ymin_xml.text = str(int(ymin[i])) ymax_xml.text = str(int(ymax[i])) filename = os.path.join(save_dir,file.split(".csv")[0] + ".xml") tree = ET.ElementTree(f) tree.write(filename, pretty_print = True)
f = subprocess.Popen( ["inkscape", "--query-%s" % query, "--query-id=%s" % id, "%s" % file], stdout=subprocess.PIPE) q[query] = float(f.stdout.read()) # add some margins q['width'] = q['width'] * 1.3 q['height'] = q['height'] * 1.3 #print q root = tdoc.getroot() tout = etree.ElementTree(copy_element(root)) newroot = tout.getroot() for ch in root.getchildren(): chcopy = ch.__deepcopy__(-1) newroot.append(chcopy) if ch.tag == e_defs: for defs in fdoc.getroot().getchildren(): for fi in defs.getchildren(): ficopy = fi.__deepcopy__(-1) newroot.getchildren()[-1].append(ficopy) if ch.tag == e_g: newroot.getchildren()[-1].attrib["id"] = "original" for menu in menus: text = etree.Element(e_text, nsmap=NSS) text.attrib['x'] = str(q['x'] - q['width'] * 0.2) text.attrib['y'] = str(q['y'] + q['height'] *
def write_empty_file(filepath: str, root_tag: str) -> None: """Write an empty tasks file.""" root = etree.Element(root_tag) save_file(filepath, etree.ElementTree(root))
def createContents(self, directory): """ Create the contents.xml file. Args: directory (str): Directory path to validate existance of files. Returns: Element Tree """ if self.paths is None: self._paths = {} contents = etree.Element('contents') # Look for and add basemaps if not os.path.exists(os.path.join(directory, 'FFM.geojson')): raise FileNotFoundError('Missing FFM geojson file.') file_attrib, format_attrib = self._getAttributes( 'modelmaps', "Finite Fault Model Maps ", 'FFM.geojson', "text/plain") maps = etree.SubElement(contents, 'file', file_attrib) grid_caption = etree.SubElement(maps, 'caption') caption_str = ("Map representation of the finite fault model ") grid_caption.text = etree.CDATA(caption_str) etree.SubElement(maps, 'format', format_attrib) basemap = self._checkDownload(directory, "*base*.png") kmls = self._checkDownload(directory, "*.kml") kmzs = self._checkDownload(directory, "*.kmz") if len(kmls) > 0: self._paths['kmls'] = (kmls[0], "finite_fault.kml") file_attrib, format_attrib = self._getAttributes( '', '', "finite_fault.kml", "application/vnd.google-earth.kml+xml") etree.SubElement(maps, 'format', format_attrib) if len(kmzs) > 0: self._paths['kmzs'] = (kmzs[0], "finite_fault.kmz") file_attrib, format_attrib = self._getAttributes( '', '', "finite_fault.kmz", "application/vnd.google-earth.kmz") etree.SubElement(maps, 'format', format_attrib) if len(basemap) > 0: self._paths['basemap'] = (basemap[0], "basemap.png") file_attrib, format_attrib = self._getAttributes( 'basemap', "Base Map ", "basemap.png", "image/png") etree.SubElement(maps, 'format', format_attrib) # Look for body and surface wave plots plots = self._checkDownload(directory, "waveplots.zip") if len(plots) > 0: self._paths['waveplots'] = (plots[0], "waveplots.zip") file_attrib, format_attrib = self._getAttributes( 'waveplots', "Wave Plots ", "waveplots.zip", "application/zip") file_tree = etree.SubElement(contents, 'file', file_attrib) caption = etree.SubElement(file_tree, 'caption') caption.text = etree.CDATA("Body and surface wave plots ") etree.SubElement(file_tree, 'format', format_attrib) else: zipped = self.zip_waveplots(directory) if zipped != '': self._paths['waveplots'] = (zipped, "waveplots.zip") file_attrib, format_attrib = self._getAttributes( 'waveplots', "Wave Plots ", "waveplots.zip", "application/zip") file_tree = etree.SubElement(contents, 'file', file_attrib) caption = etree.SubElement(file_tree, 'caption') caption.text = etree.CDATA("Body and surface wave plots ") etree.SubElement(file_tree, 'format', format_attrib) # CMT solution cmt = self._checkDownload(directory, "*CMTSOLUTION*") if len(cmt) > 0: self._paths['cmtsolution'] = (cmt[0], "CMTSOLUTION") file_attrib, format_attrib = self._getAttributes( 'cmtsolution', "CMT Solution ", "CMTSOLUTION", "text/plain") file_tree = etree.SubElement(contents, 'file', file_attrib) caption = etree.SubElement(file_tree, 'caption') caption.text = etree.CDATA( "Full CMT solution for every point in finite fault " "region ") etree.SubElement(file_tree, 'format', format_attrib) # inversion files param = self._checkDownload(directory, "*.param") fsp = self._checkDownload(directory, "*.fsp") if len(fsp) > 0 or len(param) > 0: if len(param) > 0: self._paths['inpfile1'] = (param[0], "basic_inversion.param") file_attrib, format_attrib = self._getAttributes( 'inpfiles', "Inversion Parameters ", "basic_inversion.param", "text/plain") file_tree = etree.SubElement(contents, 'file', file_attrib) caption = etree.SubElement(file_tree, 'caption') caption.text = etree.CDATA( "Files of inversion parameters for the finite fault ") etree.SubElement(file_tree, 'format', format_attrib) self._paths['inpfile2'] = (fsp[0], "complete_inversion.fsp") file_attrib, format_attrib = self._getAttributes( 'inpfiles', "Inversion Parameters ", "complete_inversion.fsp", "text/plain") etree.SubElement(file_tree, 'format', format_attrib) else: self._paths['inpfile2'] = (fsp[0], "complete_inversion.fsp") file_attrib, format_attrib = self._getAttributes( 'inpfiles', "Inversion Parameters ", "complete_inversion.fsp", "text/plain") file_tree = etree.SubElement(contents, 'file', file_attrib) caption = etree.SubElement(file_tree, 'caption') caption.text = etree.CDATA( "Files of inversion parameters for the finite fault ") etree.SubElement(file_tree, 'format', format_attrib) # Coulomb inp coul = self._checkDownload(directory, "*coulomb.inp") if len(coul) > 0: self._paths['coulomb'] = (coul[0], "coulomb.inp") file_attrib, format_attrib = self._getAttributes( 'coulomb', "Coulomb Input File ", "coulomb.inp", "text/plain") file_tree = etree.SubElement(contents, 'file', file_attrib) caption = etree.SubElement(file_tree, 'caption') caption.text = etree.CDATA( "Format necessary for compatibility with Coulomb3 " "(http://earthquake.usgs.gov/research/software/coulomb/) ") etree.SubElement(file_tree, 'format', format_attrib) # Moment rate mr_plot = self._checkDownload(directory, "*mr*.png") mr_ascii = self._checkDownload(directory, "*.mr") if len(mr_ascii) > 0: self._paths['momentrate1'] = (mr_ascii[0], "moment_rate.mr") file_attrib, format_attrib = self._getAttributes( 'momentrate', "Moment Rate Function Files ", "moment_rate.mr", "text/plain") file_tree = etree.SubElement(contents, 'file', file_attrib) caption = etree.SubElement(file_tree, 'caption') caption.text = etree.CDATA( "Files of time vs. moment rate for source time " "functions ") etree.SubElement(file_tree, 'format', format_attrib) self._paths['momentrate2'] = (mr_plot[0], "moment_rate.png") file_attrib, format_attrib = self._getAttributes( 'momentrate', "Moment Rate Function Files ", "moment_rate.png", "image/png") etree.SubElement(file_tree, 'format', format_attrib) else: self._paths['momentrate2'] = (mr_plot[0], "moment_rate.png") file_attrib, format_attrib = self._getAttributes( 'momentrate', "Moment Rate Function Files ", "moment_rate.png", "image/png") file_tree = etree.SubElement(contents, 'file', file_attrib) caption = etree.SubElement(file_tree, 'caption') caption.text = etree.CDATA( "Files of time vs. moment rate for source time " "functions ") etree.SubElement(file_tree, 'format', format_attrib) # surface displacement surf = self._checkDownload(directory, "*.disp") if len(surf) > 0: self._paths['deformation'] = (surf[0], "surface_deformation.disp") file_attrib, format_attrib = self._getAttributes( 'surface', "Surface Deformation File ", "surface_deformation.disp", "text/plain") file_tree = etree.SubElement(contents, 'file', file_attrib) caption = etree.SubElement(file_tree, 'caption') caption.text = etree.CDATA( "Surface displacement resulting from finite fault, " "calculated using Okada-style deformation codes ") etree.SubElement(file_tree, 'format', format_attrib) # shakemap polygon poly = self._checkDownload(directory, "shakemap_polygon.txt") if len(poly) > 0: self._paths['shakemap_polygon'] = (poly[0], "shakemap_polygon.txt") file_attrib, format_attrib = self._getAttributes( 'shakemap_polygon', "ShakeMap Rupture Polygon File ", "shakemap_polygon.txt", "text/plain") file_tree = etree.SubElement(contents, 'file', file_attrib) caption = etree.SubElement(file_tree, 'caption') caption.text = etree.CDATA( "Geometry of finite fault slipped area ") etree.SubElement(file_tree, 'format', format_attrib) tree = etree.ElementTree(contents) self._contents = tree return tree
def xmlWrite(xmltree, xmlFileName): ET = etree.ElementTree(xmltree) ET.write(xmlFileName, encoding="UTF-8")
sys.exit(1) # Normalize for paper in root_being_added.findall('.//paper'): for oldnode in paper: process(oldnode, informat='xml') # Ingest each volume. # First, find the XML file. collection_file = os.path.join(os.path.dirname(sys.argv[0]), '..', 'data', 'xml', f'{collection_id}.xml') if os.path.exists(collection_file): existing_tree = etree.parse(collection_file) else: existing_tree = etree.ElementTree( make_simple_element('collection', attrib={'id': collection_id})) # Insert each volume for i, new_volume in enumerate(root_being_added.findall('volume')): new_volume_id = int(new_volume.attrib['id']) existing_volume = existing_tree.getroot().find( f"./volume[@id='{new_volume_id}']") if existing_volume is None: new_volume.attrib['ingest-date'] = args.ingest_date # Find the insertion point among the other volumes insertion_point = 0 for i, volume in enumerate(existing_tree.getroot()): if new_volume_id < int(volume.attrib['id']): break insertion_point = i + 1
xmlname = excelpath.split("/")[-1].split(".")[0] + "_New.xml" sf = open(savepath + xmlname, "w") sf.write(pretty_xml) sf.close() if (__name__ == "__main__"): try: path = sys.argv[1] if len(sys.argv) == 3: xmlStr = open(path).read() xmlStr = xmlStr.replace("\t", " ", 1) a = xmlStr.find('xmlns="') b = xmlStr.find('"', a + len('xmlns="')) namespace = xmlStr[a:b + 1].replace("xmlns=", "").replace('"', '') xmlStr = xmlStr.replace(" " + xmlStr[a:b + 1], "") your_tree = etree.fromstring(xmlStr) tree = etree.ElementTree(your_tree) for e in your_tree.iter(): if "vdu-depends-on" in str(tree.getpath(e)): print tree.getpath(e) else: if path.split(".")[-1] == "xml": xmlToExcel(path) elif path.split(".")[-1] == "xlsx": excelToXml(path) else: print("ERROR: Unsupported file") except: print "\n\nUSAGE: python xl_xml.py /path/to/excel_or_xml_file\n\nMake sure the file is present in path specified\n\n\n"
def create_role_test_data(orgs, branches): from lxml import etree import StringIO db = current.db s3db = current.s3db auth = current.auth s3mgr = current.manager request = current.request #---------------------------------------------------------------------- # Initialize Data & Users auth.override = True s3db.load_all_models() test_dir = os.path.join(current.request.folder, "modules", "tests", "roles", current.deployment_settings.base.template) org_file = open(os.path.join(test_dir, "org_organisation.xml"), "rb") org_template_string = org_file.read() data_file = open(os.path.join(test_dir, "data.xml"), "rb") data_template_string = data_file.read() org_resource = s3db.resource("org_organisation") org_branch_file = open( os.path.join(test_dir, "org_organisation_branch.xml"), "rb") org_branch_template_string = org_branch_file.read() org_branch_resource = s3db.resource("org_organisation_branch") user_file = open(os.path.join(test_dir, "users_template.csv"), "rb") user_template_string = user_file.read() # Ensure that the users are imported correctly s3db.configure("auth_user", onaccept=lambda form: auth.s3_link_user(form.vars)) s3db.add_component("auth_membership", auth_user="******") s3mgr.import_prep = auth.s3_membership_import_prep user_resource = s3db.resource("auth_user") hr_resource = s3db.resource("pr_person") user_file = StringIO.StringIO() user_stylesheet = os.path.join(current.request.folder, "static", "formats", "s3csv", "auth", "user.xsl") hr_stylesheet = os.path.join(current.request.folder, "static", "formats", "s3csv", "hrm", "person.xsl") for org in orgs: for branch in branches: # Get the "Other" Orgs copy_orgs = list(orgs) copy_orgs.remove(org) orgx1 = copy_orgs[0] orgx2 = copy_orgs[1] if branch: orgx = "%s-%s" % (org, branch) else: orgx = org #print orgx # Create Org & get id org_string = org_template_string % dict(org=orgx) xmltree = etree.ElementTree(etree.fromstring(org_string)) success = org_resource.import_xml(xmltree) otable = s3db.org_organisation org_id = db(otable.name == orgx).select(otable.id).first().id auth.user = Storage(organisation_id=org_id) # Create Test Data for each Organisation data_string = data_template_string % dict( org=orgx, orgx1=orgx1, orgx2=orgx2, ) xmltree = etree.ElementTree(etree.fromstring(data_string)) success = org_resource.import_xml(xmltree) # Create Users for each Organisation user_string = user_template_string % dict(org=orgx, org_lower=orgx.lower()) user_file = StringIO.StringIO(user_string) success = user_resource.import_xml(user_file, format="csv", stylesheet=user_stylesheet) user_file = StringIO.StringIO(user_string) hr_resource.import_xml(user_file, format="csv", stylesheet=hr_stylesheet) if branch: # Link Branch to Org org_branch_string = org_branch_template_string % dict( org=org, branch=branch) #print org_branch_string xmltree = etree.ElementTree( etree.fromstring(org_branch_string)) success = org_branch_resource.import_xml(xmltree) #print success # Import Test Users test_user_file = open(os.path.join(test_dir, "test_users.csv"), "rb") success = user_resource.import_xml(test_user_file, format="csv", stylesheet=user_stylesheet) test_user_file = open(os.path.join(test_dir, "test_users.csv"), "rb") hr_resource.import_xml(test_user_file, format="csv", stylesheet=hr_stylesheet) db.commit() auth.override = False
style.append(elem) color = "black" colorBackground = "#010101" prefix = f"ColorPatch.{color.capitalize()}" style = Element("style", {"name": prefix+"_Background"}) styles_root.append(style) elem = Element("item", {"name": "android:colorBackground"}) elem.text = colorBackground style.append(elem) elem = Element("item", {"name": "colorSurface"}) elem.text = colorBackground style.append(elem) objectify.deannotate(styles_root, cleanup_namespaces=True) etree.ElementTree(styles_root)\ .write(path_dest_styles_xml, encoding='utf-8', pretty_print=True, xml_declaration=True) objectify.deannotate(colors_root, cleanup_namespaces=True) etree.ElementTree(colors_root)\ .write(path_dest_colors_xml, encoding='utf-8', pretty_print=True, xml_declaration=True) # kt primaryStyles = [] secondaryStyles = [] backgroundStyles = [] for elem in styles_root.getchildren(): name = elem.get("name")
def _write_annotation(annotation_path, annotation): root = etree.Element("annotation") _recursive_create_dict_to_xml(annotation, root) # write to file: tree = etree.ElementTree(root) tree.write(annotation_path, pretty_print=True, encoding='utf-8')
def render_board( cell_size=2.0, cell_border=.5, outer_border=.75, board_rows=9, board_columns=12, stroke=.05, corner_radius_ratio=.15, text_scale=.4, text_pad=.2, #height of text relative to cell font="04b", separator_stroke=.1): board_height = board_rows * cell_size \ + (board_rows - 1) * cell_border \ + outer_border * 2 board_width = board_columns * cell_size \ + (board_columns - 1) * cell_border \ + outer_border * 2 corner_radius = cell_size * corner_radius_ratio document_height = board_height * 3 + 2 * outer_border style = "fill: none; stroke: black; stroke-width: {stroke}".format( **locals()) def piece_outlines(shape_style=style): pieces = elem("g") for row in range(board_rows): for col in range(board_columns): pieces.append( elem("rect", x=col * cell_size + col * cell_border, y=row * cell_size + row * cell_border, height=cell_size, width=cell_size, rx=corner_radius, style=shape_style)) return pieces def piece_labels(): labels = elem("g") text_height = text_scale * cell_size for row in range(board_rows): for col in range(board_columns): letter_label = elem( "text", x=col * cell_size + col * cell_border + text_pad, y=row * cell_size + row * cell_border + text_height + .5 * text_pad, font_size=text_height, font_family="{font}".format(font=font), #text_anchor="left", fill="red", dominant_baseline="top") letter_label.text = str(chr(ord('A') + row)) number_label = elem( "text", x=col * cell_size + col * cell_border + cell_size - text_pad, y=row * cell_size + row * cell_border + cell_size - text_pad, font_size=text_height, font_family="{font}".format(font=font), text_anchor="end", fill="red", #dominant_baseline="bottom" ) separator = elem( "line", style="stroke: red; stroke-width: {separator_stroke}". format(separator_stroke=separator_stroke), x1=col * cell_size + col * cell_border + .75 * cell_size, y1=row * cell_size + row * cell_border + .45 * cell_size, x2=col * cell_size + col * cell_border + .25 * cell_size, y2=row * cell_size + row * cell_border + .54 * cell_size) dot = elem( "circle", cx=col * cell_size + col * cell_border + .5 * cell_size, cy=row * cell_size + row * cell_border + .5 * cell_size, r=.05 * cell_size, style="fill: red; stroke: none") number_label.text = str(col + 1) labels.append(letter_label) labels.append(number_label) #labels.append(separator) #labels.append(dot) return labels def board_outline(): return elem("rect", width=board_width, height=board_height, rx=corner_radius, style=style) def root_node(): return elem( "svg", height="{0}cm".format(board_height), width="{0}cm".format(board_width), viewBox="0 0 {board_width} {board_height}".format(**locals()), xmlns="http://www.w3.org/2000/svg", version="1.1", baseProfile="full") lower_board = et.Element("g") lower_board.append(board_outline()) lower_labels = elem("g", transform="translate({x} {y})".format(x=outer_border, y=outer_border)) lower_labels.append(piece_labels()) #if you want engraved outlines of the piece shapes #lower_labels.append(piece_outlines("fill: none; stroke: red; stroke-width: {stroke}".format(**locals()))) lower_board.append(lower_labels) upper_board = elem("g") upper_board.append(board_outline()) upper_board_pieces = elem("g", transform="translate({x} {y})".format( x=outer_border, y=outer_border)) upper_board_pieces.append(piece_outlines()) #Don't actually want these on the upper board cutout because #the holes are going to get discarded #upper_board_pieces.append(piece_labels()) upper_board.append(upper_board_pieces) pieces = elem("g", transform="translate({x} {y})".format(x=outer_border, y=outer_border)) pieces.append(piece_outlines()) pieces.append(piece_labels()) for node, filename in [(upper_board, 'upper.svg'), (lower_board, 'lower.svg'), (pieces, 'pieces.svg')]: root = root_node() root.append(node) document = et.ElementTree(root) with open(filename, 'wb') as f: document.write(f, encoding='utf-8', xml_declaration=True)
def __init__(self): self.conf = conf.Conf() self.platform = platform.Platform() self.currentdir = os.path.dirname(os.path.abspath(__file__)) self.currentLanguage = self.conf.get('GENERAL', 'lang') self.language = language.Language(self.currentdir, 'openplotter-avnav', self.currentLanguage) if os.path.dirname(os.path.abspath(__file__))[0:4] == '/usr': v = version else: v = version.version wx.Frame.__init__(self, None, title='Avnav' + ' ' + v, size=(800, 444)) self.SetFont( wx.Font(10, wx.FONTFAMILY_DEFAULT, wx.FONTSTYLE_NORMAL, wx.FONTWEIGHT_NORMAL)) icon = wx.Icon(self.currentdir + "/data/sailboat24r.png", wx.BITMAP_TYPE_PNG) self.SetIcon(icon) self.CreateStatusBar() font_statusBar = self.GetStatusBar().GetFont() font_statusBar.SetWeight(wx.BOLD) self.GetStatusBar().SetFont(font_statusBar) self.toolbar1 = wx.ToolBar(self, style=wx.TB_TEXT) toolHelp = self.toolbar1.AddTool( 101, _('Help'), wx.Bitmap(self.currentdir + "/data/help.png")) self.Bind(wx.EVT_TOOL, self.OnToolHelp, toolHelp) if not self.platform.isInstalled('openplotter-doc'): self.toolbar1.EnableTool(101, False) toolSettings = self.toolbar1.AddTool( 102, _('Settings'), wx.Bitmap(self.currentdir + "/data/settings.png")) self.Bind(wx.EVT_TOOL, self.OnToolSettings, toolSettings) self.toolbar1.AddSeparator() toolAvnav = self.toolbar1.AddTool( 110, 'Avnav', wx.Bitmap(self.currentdir + "/data/sailboat24r.png")) self.Bind(wx.EVT_TOOL, self.OnToolAvnav, toolAvnav) toolAvnavSplit = self.toolbar1.AddTool( 111, 'Avnav split', wx.Bitmap(self.currentdir + "/data/sailboath24rs.png")) self.Bind(wx.EVT_TOOL, self.OnToolAvnavSplit, toolAvnavSplit) self.toolbar1.AddSeparator() toolApply = self.toolbar1.AddTool( 105, _('Apply Changes'), wx.Bitmap(self.currentdir + "/data/apply.png")) self.Bind(wx.EVT_TOOL, self.OnToolApply, toolApply) toolCancel = self.toolbar1.AddTool( 106, _('Cancel Changes'), wx.Bitmap(self.currentdir + "/data/cancel.png")) self.Bind(wx.EVT_TOOL, self.OnToolCancel, toolCancel) self.notebook = wx.Notebook(self) self.notebook.Bind(wx.EVT_NOTEBOOK_PAGE_CHANGED, self.onTabChange) self.apps = wx.Panel(self.notebook) self.settings = wx.Panel(self.notebook) self.systemd = wx.Panel(self.notebook) #self.output = wx.Panel(self.notebook) self.notebook.AddPage(self.settings, _('Settings')) self.notebook.AddPage(self.systemd, _('Processes')) #self.notebook.AddPage(self.output, '') self.il = wx.ImageList(24, 24) img0 = self.il.Add( wx.Bitmap(self.currentdir + "/data/settings2.png", wx.BITMAP_TYPE_PNG)) img1 = self.il.Add( wx.Bitmap(self.currentdir + "/data/process.png", wx.BITMAP_TYPE_PNG)) #img2 = self.il.Add(wx.Bitmap(self.currentdir+"/data/output.png", wx.BITMAP_TYPE_PNG)) self.notebook.AssignImageList(self.il) self.notebook.SetPageImage(0, img0) self.notebook.SetPageImage(1, img1) #self.notebook.SetPageImage(1, img2) vbox = wx.BoxSizer(wx.VERTICAL) vbox.Add(self.toolbar1, 0, wx.EXPAND) vbox.Add(self.notebook, 1, wx.EXPAND) self.SetSizer(vbox) self.appsDict = [] app = { 'name': 'AvnavUpdater', 'included': True, 'show': '', 'service': ['avnavupdater'], 'edit': True, 'install': '', 'uninstall': '', } self.appsDict.append(app) app = { 'name': 'Avnav', 'included': True, 'show': '', 'service': ['avnav'], 'edit': True, 'install': '', 'uninstall': '', } self.appsDict.append(app) self.OCHARTSport = 8082 self.AVNport = 8080 self.updatePort = 8085 self.xmlDocFile = self.conf.home + '/avnav/data/avnav_server.xml' self.xmlload = False if os.path.exists(self.xmlDocFile): self.xmlDoc = et.ElementTree(file=self.xmlDocFile) self.xmlload = True AVNHttpS = self.xmlDoc.find('.//AVNHttpServer') if AVNHttpS != None: if 'httpPort' in AVNHttpS.attrib: try: self.AVNport = int(AVNHttpS.attrib['httpPort'] or 8080) except: pass sys_ocharts = self.xmlDoc.find('.//system-ocharts') if sys_ocharts != None: if 'port' in sys_ocharts.attrib: try: self.OCHARTSport = int(sys_ocharts.attrib['port'] or 8082) except: pass output = subprocess.check_output([ 'grep', '-F', 'Environment=PORT=', '/etc/systemd/system/avnavupdater.service.d/override.conf' ]).decode("utf-8").split('=') if len(output) == 3: try: self.updatePort = int(output[2]) except: pass self.pageSettings() self.pageSystemd() #self.pageOutput() maxi = self.conf.get('GENERAL', 'maximize') if maxi == '1': self.Maximize() self.Centre()
codePoint = int(l[0], 16) if codePoint % 256 == 0: comment = ET.Comment("%X" % codePoint) characterSetNode.append(comment) character = ET.SubElement(characterSetNode, "字符", attrib={ "名稱": chr(codePoint), "註記": "U+%X" % codePoint, }) operator = l[1] if operator == "XXXX": ET.SubElement(character, "組字") elif operator == "龜": ET.SubElement(character, "組字") else: assemble = ET.SubElement(character, "組字", attrib={ "運算": operator, }) for operand in l[2:]: operandNode = ET.SubElement(assemble, "字根", attrib={ "置換": operand, }) xmlNode = ET.ElementTree(rootNode) print(ET.tounicode(xmlNode, pretty_print=True))
def to_mmd(self): """ Method for parsing content of NetCDF file, mapping discovery metadata to MMD, and writes MMD to disk. """ # Why cf_mmd_lut = self.generate_cf_acdd_mmd_lut() # Some mandatory MMD does not have equivalent in ACDD # Make one to one mapping cf_mmd_lut.update(self.generate_cf_mmd_lut_missing_acdd()) mmd_required_elements = self.required_mmd_elements() ncin = Dataset(self.netcdf_product) global_attributes = ncin.ncattrs() all_netcdf_variables = [var for var in ncin.variables] # Create XML file with namespaces ns_map = { 'mmd': "http://www.met.no/schema/mmd", 'gml': "http://www.opengis.net/gml" } root = ET.Element(ET.QName(ns_map['mmd'], 'mmd'), nsmap=ns_map) # Write MMD elements from global attributes in NetCDF for ga in global_attributes: # Check if global attribute is in the Look Up Table if ga in cf_mmd_lut.keys(): # Check if global attribute has a MMD mapping if cf_mmd_lut[ga]: all_elements = cf_mmd_lut[ga].split(',') len_elements = len(all_elements) parent_element = root for i, e in enumerate(all_elements): # Check if the element is an attribute to an element if e.startswith('attrib_'): continue # Check if we have iterated to the end of the children elif i == len_elements - 1: value_list = [ncin.getncattr(ga)] # Split some elements by comma into list if ga in 'iso_topic_category': value_list = ncin.getncattr(ga).split(',') for value in value_list: current_element = ET.SubElement( parent_element, ET.QName(ns_map['mmd'], e)) current_element.text = str(value) # Checks to avoid duplication else: # Check if parent element already exist to avoid duplication if root.findall(parent_element.tag): parent_element = root.findall( parent_element.tag)[0] # Check if current_element already exist to avoid duplication current_element = None for c in parent_element.getchildren(): if c.tag == ET.QName(ns_map['mmd'], e): current_element = c continue if current_element is None: current_element = ET.SubElement( parent_element, ET.QName(ns_map['mmd'], e)) parent_element = current_element # add MMD attribute values from CF and ACDD for ga in global_attributes: if ga in cf_mmd_lut.keys(): if cf_mmd_lut[ga]: all_elements = cf_mmd_lut[ga].split(',') len_elements = len(all_elements) parent_element = root for i, e in enumerate(all_elements): if e.startswith('attrib_'): if ga == 'keywords_vocabulary': attrib = e.split('_')[-1] for keywords_element in root.findall( ET.QName(ns_map['mmd'], 'keywords')): keywords_element.attrib[ attrib] = ncin.getncattr(ga) elif ga == 'geospatial_bounds_crs': attrib = e.split('_')[-1] for keywords_element in root.findall( ET.QName(ns_map['mmd'], 'rectangle')): keywords_element.attrib[ attrib] = ncin.getncattr(ga) elif ga == 'title_lang': attrib = e.split('_')[-1] for title_element in root.findall( ET.QName(ns_map['mmd'], 'title')): title_element.attrib[ '{http://www.w3.org/XML/1998/namespace}' + attrib] = ncin.getncattr(ga) elif ga == 'summary_lang': attrib = e.split('_')[-1] for element in root.findall( ET.QName(ns_map['mmd'], 'abstract')): element.attrib[ '{http://www.w3.org/XML/1998/namespace}' + attrib] = ncin.getncattr(ga) else: print( "Warning: don't know how to handle attrib: ", e) # Add empty/commented required MMD elements that are not found in NetCDF file for k, v in mmd_required_elements.items(): # check if required element is part of output MMD (ie. of NetCDF file) if not len(root.findall(ET.QName(ns_map['mmd'], k))) > 0: print('Did not find required element: {}.'.format(k)) if not v: root.append(ET.Comment('<mmd:{}></mmd:{}>'.format(k, k))) else: root.append( ET.Comment('<mmd:{}>{}</mmd:{}>'.format(k, v, k))) # Add OPeNDAP data_access if "netcdf_product" is OPeNDAP url if 'dodsC' in self.netcdf_product: da_element = ET.SubElement(root, ET.QName(ns_map['mmd'], 'data_access')) type_sub_element = ET.SubElement(da_element, ET.QName(ns_map['mmd'], 'type')) description_sub_element = ET.SubElement( da_element, ET.QName(ns_map['mmd'], 'description')) resource_sub_element = ET.SubElement( da_element, ET.QName(ns_map['mmd'], 'resource')) type_sub_element.text = "OPeNDAP" description_sub_element.text = "Open-source Project for a Network Data Access Protocol" resource_sub_element.text = self.netcdf_product _desc = [ 'Open-source Project for a Network Data Access Protocol.', 'OGC Web Mapping Service, URI to GetCapabilities Document.' ] _res = [ self.netcdf_product.replace('dodsC', 'fileServer'), self.netcdf_product.replace('dodsC', 'wms') ] access_list = [] _desc = [] _res = [] add_wms_data_access = True if add_wms_data_access: access_list.append('OGC WMS') _desc.append( 'OGC Web Mapping Service, URI to GetCapabilities Document.' ) _res.append(self.netcdf_product.replace('dodsC', 'wms')) add_http_data_access = True if add_http_data_access: access_list.append('HTTP') _desc.append( 'Open-source Project for a Network Data Access Protocol.') _res.append(self.netcdf_product.replace('dodsC', 'fileServer')) for prot_type, desc, res in zip(access_list, _desc, _res): dacc = ET.SubElement(root, ET.QName(ns_map['mmd'], 'data_access')) dacc_type = ET.SubElement(dacc, ET.QName(ns_map['mmd'], 'type')) dacc_type.text = prot_type dacc_desc = ET.SubElement( dacc, ET.QName(ns_map['mmd'], 'description')) dacc_desc.text = str(desc) dacc_res = ET.SubElement(dacc, ET.QName(ns_map['mmd'], 'resource')) if 'OGC WMS' in prot_type: wms_layers = ET.SubElement( dacc, ET.QName(ns_map['mmd'], 'wms_layers')) # Don't add variables containing these names to the wms layers skip_layers = ['latitude', 'longitude', 'angle'] for w_layer in all_netcdf_variables: if any(skip_layer in w_layer for skip_layer in skip_layers): continue wms_layer = ET.SubElement( wms_layers, ET.QName(ns_map['mmd'], 'wms_layer')) wms_layer.text = w_layer # Need to add get capabilities to the wms resource res += '?service=WMS&version=1.3.0&request=GetCapabilities' dacc_res.text = res # Add OGC WMS data_access as comment root.append( ET.Comment( str('<mmd:data_access>\n\t<mmd:type>OGC WMS</mmd:type>\n\t<mmd:description>OGC Web ' 'Mapping Service, URI to GetCapabilities Document.</mmd:description>\n\t' '<mmd:resource></mmd:resource>\n\t<mmd:wms_layers>\n\t\t<mmd:wms_layer>' '</mmd:wms_layer>\n\t</mmd:wms_layers>\n</mmd:data_access>' ))) # print(ET.tostring(root,pretty_print=True).decode("utf-8")) if not self.output_name.endswith('.xml'): output_file = str(self.output_path + self.output_name) + '.xml' else: output_file = str(self.output_path + self.output_name) et = ET.ElementTree(root) et = ET.ElementTree( ET.fromstring( ET.tostring(root, pretty_print=True).decode("utf-8"))) et.write(output_file, pretty_print=True)
tableElem.attrib["have_exclude_column"] = "1" else: subElem.attrib["is_exclude"] = "0" subElem.attrib["disableflag"] = "0" except BaseException, ex: exc_info = cF.getExceptionInfo() err = u"数据库执行%s后出现异常,%s" % (sql, exc_info) Logging.getLog().critical(err) crs.close() conn.rollback() conn.close() return -1, err crs.close() conn.close() doc = etree.ElementTree(root) doc.write("JZJY_column_report_scan.xml", pretty_print=True, xml_declaration=True, encoding='utf-8') Logging.getLog().info(u"扫描集中交易数据库完成") return 0, "" def CheckJZJYColumnSetting(): Logging.getLog().info(u"更新集中交易数据库配置文件开始") # 读取文件 doc = etree.ElementTree(file='JZJY_column_report.xml') root = doc.getroot() # 备份接口参数文件 doc = etree.ElementTree(root) # root 为根元素 doc.write("JZJY_column_report.xml%s.xml" % time.strftime('%Y%m%d%H%M%S'), pretty_print=True, xml_declaration=True, encoding='utf-8')
def apply_xml(df, file_path, obj_df=None, parameters=None): ret = get_python_obj(df, obj_df=obj_df, parameters=parameters) from lxml import etree prefix = "ocel:" root = etree.Element("log") global_event = etree.SubElement(root, "global") global_event.set("scope", "event") for k, v in ret[prefix + "global-event"].items(): child = etree.SubElement(global_event, "string") child.set("key", k.split(prefix)[-1]) child.set("value", v) global_object = etree.SubElement(root, "global") global_object.set("scope", "event") for k, v in ret[prefix + "global-object"].items(): child = etree.SubElement(global_object, "string") child.set("key", k.split(prefix)[-1]) child.set("value", v) global_log = etree.SubElement(root, "global") global_log.set("scope", "log") attribute_names = etree.SubElement(global_log, "list") attribute_names.set("key", "attribute-names") object_types = etree.SubElement(global_log, "list") object_types.set("key", "object-types") for k in ret[prefix + "global-log"][prefix + "attribute-names"]: subel = etree.SubElement(attribute_names, "string") subel.set("key", "attribute-name") subel.set("value", k) for k in ret[prefix + "global-log"][prefix + "object-types"]: subel = etree.SubElement(object_types, "string") subel.set("key", "object-type") subel.set("value", k) version = etree.SubElement(global_log, "string") version.set("key", "version") version.set("value", ret[prefix + "global-log"][prefix + "version"]) ordering = etree.SubElement(global_log, "string") ordering.set("key", "ordering") ordering.set("value", ret[prefix + "global-log"][prefix + "ordering"]) events = etree.SubElement(root, "events") for k, v in ret[prefix + "events"].items(): event = etree.SubElement(events, "event") event_id = etree.SubElement(event, "string") event_id.set("key", "id") event_id.set("value", str(k)) event_activity = etree.SubElement(event, "string") event_activity.set("key", "activity") event_activity.set("value", v[prefix + "activity"]) event_timestamp = etree.SubElement(event, "date") event_timestamp.set("key", "timestamp") event_timestamp.set("value", v[prefix + "timestamp"].isoformat()) event_omap = etree.SubElement(event, "list") event_omap.set("key", "omap") for k2 in v[prefix + "omap"]: obj = etree.SubElement(event_omap, "string") obj.set("key", "object-id") obj.set("value", k2) event_vmap = etree.SubElement(event, "list") event_vmap.set("key", "vmap") for k2, v2 in v[prefix + "vmap"].items(): attr = etree.SubElement(event_vmap, get_type(df["event_" + k2].dtype)) attr.set("key", k2) attr.set("value", str(v2)) objects = etree.SubElement(root, "objects") for k, v in ret[prefix + "objects"].items(): object = etree.SubElement(objects, "object") object_id = etree.SubElement(object, "string") object_id.set("key", "id") object_id.set("value", str(k)) object_type = etree.SubElement(object, "string") object_type.set("key", "type") object_type.set("value", v[prefix + "type"]) object_ovmap = etree.SubElement(object, "list") object_ovmap.set("key", "ovmap") for k2, v2 in v[prefix + "ovmap"].items(): if str(v2).lower() != "nan" and str(v2).lower() != "nat": object_att = etree.SubElement( object_ovmap, get_type(obj_df["object_" + k2].dtype)) object_att.set("key", k2) object_att.set("value", str(v2)) tree = etree.ElementTree(root) tree.write(file_path, pretty_print=True, xml_declaration=True, encoding="utf-8")
for file_comp4 in f_list: #file_comp4='budweiser22234.jpg' #if True: if os.path.splitext(file_comp4)[1] in ['.jpg', '.JPG', '.jpeg', '.JPEG']: basename = os.path.splitext(file_comp4)[0] bfind = False bmakehead = False for line in lines: line = line.strip('\r\n') line = line.strip('\n') line = line.strip(' ') name, path, xmin, ymin, objwidth, objheight, angle, sku, skuname = line.split( " ", 8) if bfind == True: if file_comp4 != name: tree = etree.ElementTree(root) savexml = savepath + os.path.splitext( file_comp4)[0] + ".xml" tree.write(savexml, encoding='utf-8', pretty_print=True) #cv2.imwrite(testpath+"test.jpg",img) #cv2.imshow("Canvas", img) break if name == file_comp4: bfind = True if bmakehead == False: bmakehead = True jpgfile = basedir + name img = cv2.imread(jpgfile) print img.shape size = img.shape height = size[0]
def main(): '''Program entry point''' knight_info = get_knight_info() knight_root = build_tree(knight_info) knight_doc = ET.ElementTree(knight_root) write_doc(knight_doc)
def run(image_path, gt_file, ann_path): classNameList = ["go","stop"] files = [] with open(gt_file) as csvfile: readCSV = csv.reader(csvfile, delimiter=' ') for row in readCSV: cols = [] for col in row: cols.append( int(col) ) files.append(cols) #obj = imageRegionOfInterest(image_path) valid_images = [".jpg",".gif",".png",".tga",".jpeg"] classes_qtd = [] images_total_qtd = 0 images_without_classes_qtd = 0 xml_list = [] for filename in os.listdir(image_path): name, ext = os.path.splitext(filename) if ext.lower() not in valid_images: continue images_total_qtd = images_total_qtd + 1 #load image image = cv2.imread(os.path.join(image_path,filename)) annotation = root(image_path, filename, int(image.shape[1]), int(image.shape[0])) #found GT numberFile = int(name) points = [] for index, item in enumerate(files): if item[0] == numberFile: points.append([item[2],item[1],item[4],item[3],0 if item[5]==2 else 1]) if len(points)>0: for point in points: annotation.append(instance_to_xml(point, classNameList)) iclass = int(point[4]) while len(classes_qtd) < iclass+1: classes_qtd.append(0) classes_qtd[iclass] = classes_qtd[iclass] + 1 else: images_without_classes_qtd = images_without_classes_qtd + 1 #create xml xmlFileName = os.path.join(ann_path,name+".xml") print(xmlFileName) etree.ElementTree(annotation).write(xmlFileName) print('Successfully converted to xml PASCAL.') print('Total Images: ', images_total_qtd) print('Images without classes: ', images_without_classes_qtd) print('Classes: ') for q in classes_qtd: print( q) return
def modify(changes, type): """ This function will take a set of changes to be applied to a document, apply the changes, and return a set of rollback instructions to be stored in the migration database entry. Right now, the following formats are assumed with this function: Volumes: [ { "barcode": "32044123321123", "changes": [{ "xpath": "(if non_casebody) //mets/blah/blah[@BLAH=666]/p[2]", "actions": { "remove": false, "create": false, "content": "love them new words", "name": "judge", "attributes": { "delete": ["name", "name", "name"], "add_update": { "id": "some identifier", "alt_id": "some other identifier" } } } }] } ] Cases: [{ "barcode": "32044123321123", "case_id": "32044123321123_002", "changes": [{ "type": "non_casebody/casebody", "element_id": "(if casebody) b-123a", "xpath": "(if non_casebody) //mets/blah/blah[@BLAH=666]/p[2]", "actions": { "remove": false, "create": false, "content": "love them new words", "name": "judge", "attributes": { "delete": ["name", "name", "name"], "add_update": { "id": "some identifier", "alt_id": "some other identifier" } } } }] }] Altos: [{ "barcode": "32044123321123", "alto_id": "32044123321123_002", "changes": [{ "type": "tag/layout/other", "element_id": "(if tag or layout) b-123a", "xpath": "(if other) //mets/blah/blah[@BLAH=666]/p[2]", "actions": { "remove": false, "create": false, "content": "love them new words", "name": "judge", "attributes": { "delete": ["name", "name", "name"], "add_update": { "id": "some identifier", "alt_id": "some other identifier" } } } } ] }] """ if type == 'volume': doc = VolumeXML.objects.get(barcode=changes['barcode']) elif type == 'case': doc = CaseXML.objects.get(barcode=changes['case_id']) elif type == 'alto': doc = PageXML.objects.get(barcode=changes['alto_id']) root = etree.fromstring(doc.orig_xml) tree = etree.ElementTree(root) element_list = defaultdict() for index, change in enumerate(changes['changes']): if 'element_id' in change: elements = tree.findall(".//*[@id='{}']".format( change['element_id']), namespaces=nsmap) if len(elements) != 1: elements = tree.findall(".//*[@ID='{}']".format( change['element_id']), namespaces=nsmap) elif 'xpath' in change: elements = tree.xpath(change['xpath'], namespaces=nsmap) if len(elements) != 1: # TODO: FIXME # print("Provided xpath must select ONE element. {} elements selected with {} in {}".format(len(elements), xpath, case_changes['case_id'])) return False element_list[index] = elements[0] rollback_list = defaultdict() #This loops through the changes and makes an array of elements to modify for index, change in enumerate(changes['changes']): element = element_list[index] rollback_list_entry = {} rollback_list_entry['complete_element'] = xmltodict.parse( etree.tostring(element)) rollback_list_entry['actions'] = {} if 'type' in change: rollback_list_entry['type'] = change['type'] if 'remove' in change['actions']: if change['actions']['remove'] is True: rollback_list_entry['actions']['create'] = True rollback_list_entry['parent_path'] = element.getparent() rollback_list_entry['parent_index'] = element.getparent( ).index(element) rollback_list.append(rollback_list_entry) element.getparent().remove(element) continue if 'name' in change['actions']: tag_breakdown = re.match('({[^}]+})(.*)', element.tag) namespace = tag_breakdown.group(1) name = tag_breakdown.group(2) if namespace is not None: element.tag = "{}{}".format(namespace, change['actions']['name']) else: element.tag = change['actions']['name'] rollback_list_entry['actions']['name'] = name if 'content' in change['actions']: rollback_list_entry['actions']['content'] = element.text element.text = change['actions']['content'] if 'attributes' in change['actions']: rollback_list_entry['actions']['attributes'] = {} if 'remove' in change['actions']['attributes']: rollback_list_entry['actions']['attributes']['add_update'] = {} for attribute in change['actions']['attributes']['remove']: #yes, I do want the whole thing to die if this fails rollback_list_entry['actions']['attributes']['add_update'][ attribute] = element.attrib[attribute] del element.attrib[attribute] if 'add_update' in change['actions']['attributes']: for attribute in change['actions']['attributes']['add_update']: if attribute in element.attrib: if 'add_update' not in rollback_list_entry['actions'][ 'attributes']: rollback_list_entry['actions']['attributes'][ 'add_update'] = {} rollback_list_entry['actions']['attributes'][ 'add_update'][attribute] = element.attrib[ attribute] else: if 'remove' not in rollback_list_entry['actions'][ 'attributes']: rollback_list_entry['actions']['attributes'][ 'remove'] = [] rollback_list_entry['actions']['attributes'][ 'remove'].append(attribute) element.attrib[attribute] = change['actions'][ 'attributes']['add_update'][attribute] rollback_list[index] = rollback_list_entry for index, change in enumerate(changes['changes']): element = element_list[index] rollback = rollback_list[index] if 'element_id' in change: for o_tag in rollback['complete_element']: if '@ID' in rollback['complete_element'][o_tag]: rollback['element_id'] = element.attrib['ID'] if '@id' in rollback['complete_element'][o_tag]: rollback['element_id'] = element.attrib['id'] elif 'xpath' in change: rollback['xpath'] = normalize_namespace( tree.getelementpath(element)) rollback['numeric_xpath'] = tree.getpath(element) if 'remove' not in change['actions']: del rollback['complete_element'] doc.orig_xml = etree.tostring(root, pretty_print=True).decode("utf-8") doc.save() return rollback_list
def _create_xml_file(self, number_of_samples, temp_dir=''): """ This function creates an xml file containing the header for the wfmx-file format using etree. """ root = ET.Element('DataFile', offset='xxxxxxxxx', version="0.1") DataSetsCollection = ET.SubElement(root, 'DataSetsCollection', xmlns="http://www.tektronix.com") DataSets = ET.SubElement(DataSetsCollection, 'DataSets', version="1", xmlns="http://www.tektronix.com") DataDescription = ET.SubElement(DataSets, 'DataDescription') NumberSamples = ET.SubElement(DataDescription, 'NumberSamples') NumberSamples.text = str(int(number_of_samples)) SamplesType = ET.SubElement(DataDescription, 'SamplesType') SamplesType.text = 'AWGWaveformSample' MarkersIncluded = ET.SubElement(DataDescription, 'MarkersIncluded') MarkersIncluded.text = 'true' NumberFormat = ET.SubElement(DataDescription, 'NumberFormat') NumberFormat.text = 'Single' Endian = ET.SubElement(DataDescription, 'Endian') Endian.text = 'Little' Timestamp = ET.SubElement(DataDescription, 'Timestamp') Timestamp.text = '2014-10-28T12:59:52.9004865-07:00' ProductSpecific = ET.SubElement(DataSets, 'ProductSpecific', name="") ReccSamplingRate = ET.SubElement(ProductSpecific, 'ReccSamplingRate', units="Hz") ReccSamplingRate.text = str(self.sample_rate) ReccAmplitude = ET.SubElement(ProductSpecific, 'ReccAmplitude', units="Volts") ReccAmplitude.text = str(0.5) ReccOffset = ET.SubElement(ProductSpecific, 'ReccOffset', units="Volts") ReccOffset.text = str(0) SerialNumber = ET.SubElement(ProductSpecific, 'SerialNumber') SoftwareVersion = ET.SubElement(ProductSpecific, 'SoftwareVersion') SoftwareVersion.text = '4.0.0075' UserNotes = ET.SubElement(ProductSpecific, 'UserNotes') OriginalBitDepth = ET.SubElement(ProductSpecific, 'OriginalBitDepth') OriginalBitDepth.text = 'EightBit' Thumbnail = ET.SubElement(ProductSpecific, 'Thumbnail') CreatorProperties = ET.SubElement(ProductSpecific, 'CreatorProperties', name='Basic Waveform') Setup = ET.SubElement(root, 'Setup') filepath = os.path.join(temp_dir, 'header.xml') ##### This command creates the first version of the file tree = ET.ElementTree(root) tree.write(filepath, pretty_print=True, xml_declaration=True) # Calculates the length of the header: # 40 is subtracted since the first line of the above created file has a length of 39 and is # not included later and the last endline (\n) is also not neccessary. # The for loop is needed to give a nine digit length: xxxxxxxxx length_of_header = '' size = str(os.path.getsize(filepath) - 40) for ii in range(9 - len(size)): length_of_header += '0' length_of_header += size # The header length is written into the file # The first line is not included since it is redundant # Also the last endline (\n) is excluded text = open(filepath, "U").read() text = text.replace("xxxxxxxxx", length_of_header) text = bytes(text, 'UTF-8') f = open(filepath, "wb") f.write(text[39:-1]) f.close()
""" s3 = """ <semantics> <cerror> <qvar name='a'></qvar> <leq/> <qvar name='b'></qvar> </cerror> </semantics> """ address = "/home/narya/Dropbox/NTCIR11-Math2-queries-participants.xml" doc = etree.parse(address) formulae = doc.xpath(".//*[local-name() = 'formula']") for f in formulae: idx = f.getparent().getparent()[0].text print idx #if "10" not in idx: continue for ann in f.xpath(".//*[local-name() = 'annotation']") + f.xpath(".//*[local-name() = 'annotation-xml']"): ann_p = ann.getparent() ann_p.remove(ann) for sem in f.xpath(".//*[local-name() = 'semantics']"): m = MathML2String() print m.convert(etree.ElementTree(sem)) print #d1 = etree.fromstring(s3.encode("utf-8")) #print m.convert(etree.ElementTree(d1))
def main(argv=None): """ Attempt to represent the differences in data records flagged with 'noupdate' between to different versions of the same OpenERP module. Print out a complete XML data file that can be loaded in a post-migration script using openupgrade::load_xml(). Known issues: - Does not detect if a deleted value belongs to a field which has been removed. - Ignores forcecreate=False. This hardly occurs, but you should check manually for new data records with this tag. Note that 'True' is the default value for data elements without this tag. - Does not take csv data into account (obviously) - Is not able to check cross module data - etree's pretty_print is not *that* pretty - Does not take translations into account (e.g. in the case of email templates) - Does not handle the shorthand records <menu>, <act_window> etc., although that could be done using the same expansion logic as is used in their parsers in openerp/tools/convert.py """ parser = argparse.ArgumentParser() parser.add_argument('olddir', metavar='older_module_directory') parser.add_argument('newdir', metavar='newer_module_directory') arguments = parser.parse_args(argv) old_update, old_noupdate = get_records(arguments.olddir) new_update, new_noupdate = get_records(arguments.newdir) data = etree.Element("data") for xml_id, record_new in new_noupdate.items(): record_old = None if xml_id in old_update: record_old = old_update[xml_id] elif xml_id in old_noupdate: record_old = old_noupdate[xml_id] if record_old is None: continue element = etree.Element("record", id=xml_id, model=record_new.attrib['model']) record_old_dict = get_node_dict(record_old) record_new_dict = get_node_dict(record_new) for key in record_old_dict.keys(): if not record_new.xpath(key): # The element is no longer present. # Overwrite an existing value with an # empty one. Of course, we do not know # if this field has actually been removed attribs = deepcopy(record_old_dict[key]).attrib for attr in ['eval', 'ref']: if attr in attribs: del attribs[attr] element.append(etree.Element(record_old_dict[key].tag, attribs)) else: oldrepr = get_node_value(record_old_dict[key]) newrepr = get_node_value(record_new_dict[key]) if oldrepr != newrepr: element.append(deepcopy(record_new_dict[key])) for key in record_new_dict.keys(): if not record_old.xpath(key): element.append(deepcopy(record_new_dict[key])) if len(element): data.append(element) openerp = etree.Element("openerp") openerp.append(data) document = etree.ElementTree(openerp) print etree.tostring(document, pretty_print=True, xml_declaration=True, encoding='utf-8')
def create_kmz(container, datadir, oceanfile, logger): # we're going to combine all these layers into one KMZ file. kmz_contents = [] # create the kml text root = etree.Element("kml") nlink = etree.SubElement(root, "NetworkLinkControl") nperiod = etree.SubElement(nlink, "minRefreshPeriod") nperiod.text = '300' document = etree.SubElement(root, 'Document') name = etree.SubElement(document, 'name') info = container.getMetadata() eid = info['input']['event_information']['event_id'] mag = info['input']['event_information']['magnitude'] timestr = info['input']['event_information']['origin_time'] namestr = 'ShakeMap %s M%s %s' % (eid, mag, timestr) name.text = namestr set_look(document, container) # create intensity overlay logger.debug('Creating intensity overlay...') overlay_image = create_overlay(container, oceanfile, datadir, document) kmz_contents += [overlay_image] logger.debug('Created intensity overlay image %s' % overlay_image) # create station kml logger.debug('Creating station KML...') triangle_file, circle_file = create_stations(container, datadir, document) kmz_contents += [triangle_file, circle_file] logger.debug('Created station KML') # create contour kml logger.debug('Creating contour KML...') create_contours(container, document) logger.debug('Created contour KML') # create epicenter KML logger.debug('Creating epicenter KML...') create_epicenter(container, document) logger.debug('Created epicenter KML') # place ShakeMap legend on the screen legend_file = place_legend(datadir, document) kmz_contents.append(legend_file) # Write the uber-kml file tree = etree.ElementTree(root) kmlfile = os.path.join(datadir, KML_FILE) tree.write(kmlfile, encoding='utf-8', xml_declaration=True) kmz_contents.append(kmlfile) # assemble all the pieces into a KMZ file, and delete source files # as we go kmzfile = os.path.join(datadir, KMZ_FILE) kmzip = zipfile.ZipFile(kmzfile, mode='w', compression=zipfile.ZIP_DEFLATED) for kfile in kmz_contents: _, arcname = os.path.split(kfile) kmzip.write(kfile, arcname=arcname) os.remove(kfile) kmzip.close() logger.debug('Wrote KMZ container file %s' % kmzfile) return kmzfile