def test_postXMLEndpoint(self):
testURL = "https://api.eveonline.com/server/ServerStatus.xml.aspx"
res_cache = api.postXMLEndpoint(testURL)
self.assertIsInstance(res_cache, ET.Element)
# Test cached response
self.assertEqual(ET.tostring(api.postXMLEndpoint(testURL)), ET.tostring(res_cache))
def set_owner(conn, uuid, owner):
"""Set ON_OWNER by uuid.
@param uuid: uuid of the VM
@param owner: string representing owner
"""
vmid = get_id_by_uuid(conn, uuid)
if not vmid:
return
vm = conn.lookupByID(vmid)
domain = ET.fromstring(vm.XMLDesc(0))
metadata = domain.find('./metadata') or ET.SubElement(domain, 'metadata')
owner_e = ET.SubElement(metadata, ET.QName('urn:opennode-tui', 'owner'))
owner_e.text = owner
## TODO: cleanup
open('/etc/libvirt/qemu/%s.xml' % (vm.name()), 'w').write(ET.tostring(domain))
data = open('/etc/libvirt/qemu/%s.xml' % (vm.name()), 'r').read()
domain_n = ET.fromstring(data)
owner_e = domain_n.find('./metadata/{urn:opennode-tui}owner')
assert owner_e is not None
assert owner_e.text == owner
return owner_e.text
def test_affiliate_with_supported_seats(self):
""" Verify that endpoint returns course runs for verified and professional seats only. """
response = self.client.get(self.affiliate_url)
self.assertEqual(response.status_code, 200)
root = ET.fromstring(response.content)
self.assertEqual(1, len(root.findall('product')))
self.assert_product_xml(
root.findall('product/[pid="{}-{}"]'.format(self.course_run.key, self.seat_verified.type))[0],
self.seat_verified
)
# Add professional seat.
seat_professional = SeatFactory(course_run=self.course_run, type=Seat.PROFESSIONAL)
response = self.client.get(self.affiliate_url)
root = ET.fromstring(response.content)
self.assertEqual(2, len(root.findall('product')))
self.assert_product_xml(
root.findall('product/[pid="{}-{}"]'.format(self.course_run.key, self.seat_verified.type))[0],
self.seat_verified
)
self.assert_product_xml(
root.findall('product/[pid="{}-{}"]'.format(self.course_run.key, seat_professional.type))[0],
seat_professional
)
def fix_graphml_format_better(cls, name, gridfs):
cls._logger.info("Reformatting file to fix GDO graphml formatting using element tree")
replacements = {}
with gridfs.get_last_version(name) as f:
tree = ElementTree.parse(f)
f_id = f._id
for key_entry in tree.findall("{http://graphml.graphdrawing.org/xmlns}key"):
key_name = key_entry.attrib['attr.name']
id = key_entry.attrib['id']
key_entry.attrib['id'] = key_name
replacements[id] = key_name
# cls._logger.info("Name: %s, Key %s", key_name, key_entry)
# cls._logger.info("Dict %s", replacements)
root=tree.getroot()
for data_entry in root.iter("{http://graphml.graphdrawing.org/xmlns}data"):
found_key = data_entry.attrib['key']
data_entry.set('key', replacements[found_key])
ElementTree.register_namespace('', "http://graphml.graphdrawing.org/xmlns")
with gridfs.new_file(filename=name, content_type="text/xml") as des:
tree.write(des, encoding='utf-8', method='xml')
cls._logger.info("Deleting old version of file %s", f_id)
gridfs.delete(f_id)
def callback(results):
reactor.stop()
for success, result in results:
if success:
print ElementTree.dump(result)
else:
print result.printTraceback()
def parse_soap_enveloped_saml_thingy(text, expected_tags):
"""Parses a SOAP enveloped SAML thing and returns the thing as
a string.
:param text: The SOAP object as XML string
:param expected_tags: What the tag of the SAML thingy is expected to be.
:return: SAML thingy as a string
"""
envelope = ElementTree.fromstring(text)
# Make sure it's a SOAP message
assert envelope.tag == '{%s}Envelope' % soapenv.NAMESPACE
assert len(envelope) >= 1
body = None
for part in envelope:
if part.tag == '{%s}Body' % soapenv.NAMESPACE:
assert len(part) == 1
body = part
break
if body is None:
return ""
saml_part = body[0]
if saml_part.tag in expected_tags:
return ElementTree.tostring(saml_part, encoding="UTF-8")
else:
raise WrongMessageType("Was '%s' expected one of %s" % (saml_part.tag,
expected_tags))
def add_to_manifest(repositories, fallback_branch = None):
try:
lm = ElementTree.parse(".repo/local_manifests/du_manifest.xml")
lm = lm.getroot()
except:
lm = ElementTree.Element("manifest")
for repository in repositories:
repo_name = repository['repository']
repo_target = repository['target_path']
if exists_in_tree(lm, repo_name):
print('DirtyUnicorns/%s already exists' % (repo_name))
continue
print('Adding dependency: DirtyUnicorns/%s -> %s' % (repo_name, repo_target))
project = ElementTree.Element("project", attrib = { "path": repo_target,
"remote": "du", "name": "%s" % repo_name })
if 'branch' in repository:
project.set('revision',repository['branch'])
elif fallback_branch:
print("Using fallback branch %s for %s" % (fallback_branch, repo_name))
project.set('revision', fallback_branch)
else:
print("Using default branch for %s" % repo_name)
lm.append(project)
indent(lm, 0)
raw_xml = ElementTree.tostring(lm).decode()
raw_xml = '<?xml version="1.0" encoding="UTF-8"?>\n' + raw_xml
f = open('.repo/local_manifests/du_manifest.xml', 'w')
f.write(raw_xml)
f.close()
def multicopy():
try:
tree = ET.parse('filecopylocations.xml')
xroot = tree.getroot()
print "\nWould you like to edit the following copy desitinations?\n"
ET.dump(xroot)
edit = raw_input("\ny=yes : n=no\n")
if edit == 'y':
initMulticopy()
else:
pass
except:
initMulticopy()
tree = ET.parse('filecopylocations.xml')
xroot = tree.getroot()
print "\nPlease select the file you wish to have copied."
try:
fcpyfrom = getFileLocation()
fcpyname = getFileNameFromFilePath(fcpyfrom)
fcpyfrom = open(fcpyfrom, 'r').read()
for loc in xroot.findall('Location'):
f = open(loc.text + '/' + fcpyname, 'w')
f.write(fcpyfrom)
f.close()
print "\nFile was successfully copied!"
except:
print "\nCould not copy file!"
pass
def test_get_xml(self):
self.resModelProgram.metadata.create_element('Description', abstract="test abstract")
self.resModelProgram.metadata.create_element('Subject', value="test subject")
release_date = '2016-10-24T21:05:00.315907+00:00'
self.resModelProgram.metadata.create_element('MpMetadata',
modelVersion='5.1.011',
modelProgramLanguage='Fortran',
modelOperatingSystem='Windows',
modelReleaseDate=release_date,
modelWebsite='http://www.hydroshare.org',
modelCodeRepository='http://www.github.com',
modelReleaseNotes='releaseNote.pdf',
modelDocumentation='manual.pdf',
modelSoftware='utilities.exe',
modelEngine='sourceCode.zip')
# test if xml from get_xml() is well formed
ET.fromstring(self.resModelProgram.metadata.get_xml())
xml_doc = self.resModelProgram.metadata.get_xml()
# check to see if the specific metadata are in the xml doc
self.assertTrue('5.1.011' in xml_doc)
self.assertTrue('Fortran' in xml_doc)
self.assertTrue('Windows' in xml_doc)
self.assertTrue(release_date in xml_doc)
self.assertTrue('http://www.hydroshare.org' in xml_doc)
self.assertTrue('http://www.github.com' in xml_doc)
self.assertTrue('releaseNote.pdf' in xml_doc)
self.assertTrue('manual.pdf' in xml_doc)
self.assertTrue('utilities.exe' in xml_doc)
self.assertTrue('sourceCode.zip' in xml_doc)
def run(self):
"""Runner"""
service_path = rel_path(os.path.join("build",
"Add to BibDesk.workflow", "Contents", "document.wflow"))
app_path = rel_path(os.path.join("build", "ADS to BibDesk.app",
"Contents", "document.wflow"))
py_path = rel_path("adsbibdesk.py")
for workflow in (service_path, app_path):
with open(workflow, 'r') as fh:
xml = ElementTree.fromstring(fh.read())
for arr in xml.find('dict').find('array').getchildren():
# fetch Python code inside the xml
py = [c for c in arr.find('dict').getchildren()
if c.tag == 'dict' and
any([i.text and '/usr/bin/env' in i.text
for i in c.getchildren()])]
# rewrite with current file
if py:
logger.info("Inserting {0} into {1}".format(py_path,
workflow))
py[0].find('string').text = open(py_path).read()
logger.info("Saving {0}".format(workflow))
with open(workflow, 'wb') as fh:
fh.write(ElementTree.tostring(xml))
logger.info("Completed ADS to BibDesk build step")
def intiMulticopy(self):
fio = fIO()
fio.filePrompt("folder", "Please select folder locations to copy to.\n"
+ "These folder locations will be saved.\n"
+ "When you are done loading in locations, simply\n"
+ "press the cancel button in the file explorer.\n")
try:
tree = ET.parse('filecopylocations.xml')
xroot = tree.getroot()
for locs in xroot.findall('Location'):
xroot.remove(locs)
except:
froot = ET.Element('Directories')
tree = ET.ElementTree(froot)
tree.write('filecopylocations.xml')
tree = ET.parse('filecopylocations.xml')
xroot = tree.getroot()
locnum = 1
fio.folderLocation()
floc = fio.getFolderLocation()
while(floc != ''):
try:
loc = ET.SubElement(xroot, 'Location'.format(locnum))
loc.set('index', '{0}'.format(locnum))
locnum = locnum + 1
loc.text = floc
floc = fio.getFolderLocation()
except:
floc = ''
tree.write('filecopylocations.xml')
ET.dump(xroot)
def _create_html_file(self, sourcefile, htmlfile, errors):
name = self.generator.get_name()
root = ElementTree.fromstring(CPPCHECK_HTML_FILE)
title = root.find("head/title")
title.text = "cppcheck - report - %s" % name
body = root.find("body")
for div in body.findall("div"):
if div.get("id") == "page":
page = div
break
for div in page.findall("div"):
if div.get("id") == "header":
h1 = div.find("h1")
h1.text = "cppcheck report - %s" % name
if div.get("id") == "content":
content = div
srcnode = self.generator.bld.root.find_node(sourcefile)
hl_lines = [e["line"] for e in errors if e.has_key("line")]
formatter = CppcheckHtmlFormatter(linenos=True, style="colorful", hl_lines=hl_lines, lineanchors="line")
formatter.errors = [e for e in errors if e.has_key("line")]
css_style_defs = formatter.get_style_defs(".highlight")
lexer = pygments.lexers.guess_lexer_for_filename(sourcefile, "")
s = pygments.highlight(srcnode.read(), lexer, formatter)
table = ElementTree.fromstring(s)
content.append(table)
s = ElementTree.tostring(root, method="html")
s = CCPCHECK_HTML_TYPE + s
node = self.generator.path.get_bld().find_or_declare(htmlfile)
node.write(s)
return css_style_defs
def globalVars():
global _home_dir, _desktop_folder, _script_dir, xml_cache_root, xml_options_root, _cache_dir, _options_dir, qualityPresets
_home_dir = QtCore.QDir.homePath()
_desktop_folder = _home_dir + "/Desktop/"
_script_dir = QtCore.QDir.currentPath()
_cache_dir = _script_dir + "/cache.xml"
_options_dir = _script_dir + "/options.xml"
external_dir = _home_dir + "/.audiobookEncoder"
if not os.path.exists(external_dir):
os.makedirs(external_dir)
if not os.path.exists(external_dir + "/cache.xml"):
shutil.copy2(_cache_dir, external_dir)
if not os.path.exists(external_dir + "/options.xml"):
shutil.copy2(_options_dir, external_dir)
_cache_dir = external_dir + "/cache.xml"
_options_dir = external_dir + "/options.xml"
# xml table auslesen
xml_cache_root = ET.parse(_cache_dir).getroot()
xml_options_root = ET.parse(_options_dir).getroot()
qualityPresets = ["96 Kbps, Stereo, 48 kHz", "128 Kbps, Stereo, 48 kHz", "256 Kbps, Stereo, 48 kHz", "320 Kbps, Stereo, 48 kHz"]
def get_product_pages(static,url,logger):
logger.debug("In get_product_pages: " + url)
# Get the svr first (it's global)
lines = themortgagemeter_utils.get_page(False,'',url,logger,True).split('\n')
# Now get the mortgage data
if static:
tree = ET.parse('static_html/tesco/Products.xml')
root = tree.getroot()
else:
root = ET.fromstring(themortgagemeter_utils.get_page(False,'',url,logger,True))
term = str(25 * 12)
for purchase in ('HousePurchase','Remortgage'):
if purchase == 'HousePurchase':
eligibilities = ['NFTB','NMH']
elif purchase == 'Remortgage':
eligibilities = ['NRM']
for rate_type in ('FixedRate','TrackerRate'):
if rate_type == 'FixedRate':
mortgage_type = 'F'
elif rate_type == 'TrackerRate':
mortgage_type = 'T'
rate_set = root.find(purchase).find(rate_type)
for rate in rate_set.findall('LTV'):
ltv_percent = rate.get('max')
for mortgage in rate.findall('Mortgage'):
#ET.dump(mortgage)
#print "--------------------"
rate_percent = mortgage.find('initialRate').text
apr_percent = mortgage.find('APR').text
svr_percent = mortgage.find('variableRate').text
name = mortgage.find('name').text.split('\n')[0]
initial_period = themortgagemeter_utils.get_months(name,logger)
booking_fee = str(int(mortgage.find('bookingFee').text) + int(mortgage.find('productFee').text))
for eligibility in eligibilities:
mc_util.handle_mortgage_insert(institution_code,mortgage_type,rate_percent,svr_percent,apr_percent,ltv_percent,initial_period,booking_fee,term,'http://www.tescobank.com/personal/finance/mortgages',eligibility,logger)
def ensure_elementtree_imported(verbosity, logfile):
global ET, ET_has_iterparse
if ET is not None:
return
if "IronPython" in sys.version:
import xml.etree.ElementTree as ET
#### 2.7.2.1: fails later with
#### NotImplementedError: iterparse is not supported on IronPython. (CP #31923)
else:
try: import xml.etree.cElementTree as ET
except ImportError:
try: import cElementTree as ET
except ImportError:
try: import lxml.etree as ET
except ImportError:
try: import xml.etree.ElementTree as ET
except ImportError:
try: import elementtree.ElementTree as ET
except ImportError:
raise Exception("Failed to import an ElementTree implementation")
if hasattr(ET, 'iterparse'):
_dummy_stream = BYTES_IO(b'')
try:
ET.iterparse(_dummy_stream)
ET_has_iterparse = True
except NotImplementedError:
pass
if verbosity:
etree_version = repr([
(item, getattr(ET, item))
for item in ET.__dict__.keys()
if item.lower().replace('_', '') == 'version'
])
print(ET.__file__, ET.__name__, etree_version, ET_has_iterparse, file=logfile)
def _get_game_xml(self, steam_id, mode):
"""Get the XML list of games"""
fname = "games_{}.xml".format(steam_id)
if mode == "read":
log.info("Reading from {}".format(fname))
with open(fname, 'rb') as f:
content = f.read()
else:
url = self.userUrl.format(steam_id=steam_id)
log.debug("Requesting {}".format(url))
f = urlopen(url)
content = f.read()
if mode == "write":
log.info("Writing to {}".format(fname))
with open(fname, 'wb') as f:
f.write(content)
try:
root = ET.fromstring(content)
except UnicodeEncodeError:
root = ET.fromstring(content.encode('utf-8'))
return root
def test_remove_doubletheme(self):
context = ET.fromstring("""
<contexte xmlns="http://olst.ling.umontreal.ca/dicoenviro/">
<contexte-texte>I compare apples and oranges</contexte-texte>
<participant type="Act" role="Agent">
<fonction-syntaxique nom="Subject">
<groupe-syntaxique nom="NP">I</groupe-syntaxique>
</fonction-syntaxique>
</participant>
<lexie-att>compare</lexie-att>
<participant type="Act" role="Theme">
<fonction-syntaxique nom="Object">
<groupe-syntaxique nom="NP">apples</groupe-syntaxique>
</fonction-syntaxique>
</participant>
and
<participant type="Act" role="Theme">
<fonction-syntaxique nom="Object">
<groupe-syntaxique nom="NP">oranges</groupe-syntaxique>
</fonction-syntaxique>
</participant>
</contexte>
""")
sentence_text, frame = xmlcontext_to_frame(
"http://olst.ling.umontreal.ca/dicoenviro/", 'compare', context)
vn_frame = ET.fromstring(
"""<SYNTAX><NP value="Agent" /><VERB /><NP value="Theme" /></SYNTAX>""")
self.assertEqual(syntax_to_str(frame), syntax_to_str(vn_frame))
def _clone_menu(self, xml, name, owner=None):
"""
Hopefully temporary hack for converting UIManager XML describing the
main menubar into a rebindable popup menu. UIManager by itself doesn't
let you do this, by design, but we need a bigger menu than the little
things it allows you to build.
"""
ui_elt = ET.fromstring(xml)
rootmenu_elt = ui_elt.find("menubar")
rootmenu_elt.attrib["name"] = name
xml = ET.tostring(ui_elt)
self.app.ui_manager.add_ui_from_string(xml)
tmp_menubar = self.app.ui_manager.get_widget('/' + name)
popupmenu = gtk.Menu()
for item in tmp_menubar.get_children():
tmp_menubar.remove(item)
popupmenu.append(item)
if owner is not None:
popupmenu.attach_to_widget(owner, None)
popupmenu.set_title("MyPaint")
popupmenu.connect("selection-done", self.popupmenu_done_cb)
popupmenu.connect("deactivate", self.popupmenu_done_cb)
popupmenu.connect("cancel", self.popupmenu_done_cb)
self.popupmenu_last_active = None
return popupmenu
def open_soap_envelope(text):
"""
:param text: SOAP message
:return: dictionary with two keys "body"/"header"
"""
try:
envelope = ElementTree.fromstring(text)
except Exception as exc:
raise XmlParseError("%s" % exc)
assert envelope.tag == '{%s}Envelope' % soapenv.NAMESPACE
assert len(envelope) >= 1
content = {"header": [], "body": None}
for part in envelope:
if part.tag == '{%s}Body' % soapenv.NAMESPACE:
assert len(part) == 1
content["body"] = ElementTree.tostring(part[0], encoding="UTF-8")
elif part.tag == "{%s}Header" % soapenv.NAMESPACE:
for item in part:
_str = ElementTree.tostring(item, encoding="UTF-8")
content["header"].append(_str)
return content
def to_string(self, endpoints):
"""
Converts the given endpoint description beans into a string
:param endpoints: A list of EndpointDescription beans
:return: A string containing an XML document
"""
# Make the ElementTree
root = self._make_xml(endpoints)
tree = ElementTree.ElementTree(root)
# Force the default name space
ElementTree.register_namespace("", EDEF_NAMESPACE)
# Make the XML
for encoding in ('unicode', 'UTF-8'):
# Prepare a StringIO output
output = StringIO()
try:
# Try to write with a correct encoding
tree.write(output, encoding=encoding, xml_declaration=True,
method="xml")
break
except LookupError:
# 'unicode' is needed in Python 3, but unknown in Python 2...
continue
else:
raise LookupError("Couldn't find a valid encoding")
return output.getvalue()
def data_import(self, odm):
"""
Return result of request to import data to an instance.
Required params:
:param odm: odm xml data for import, must be utf-8 encoded and unescaped.
:type odm: str.
:returns: contents of the method response in an OrderedDict, or None.
"""
envelope_copy = et.fromstring(self.envelope)
body = [i for i in envelope_copy.iterfind(
'.//se:Body', {'se': self.ns_se})][0]
method_name = 'importRequest'
import_request = et.Element(et.QName(self.ns_data, method_name))
body.append(import_request)
odm_node = et.Element('odm')
odm_node.append(et.fromstring(odm))
import_request.append(odm_node)
envelope = et.tostring(envelope_copy)
response = self.request(
self.ocws_url, envelope, method_name, self.ns_data)
return response
def hilight(self, buttons):
""" Hilights specified button, if same ID is found in svg """
cache_id = "|".join([ "%s:%s" % (x, buttons[x]) for x in buttons ])
if not cache_id in self.cache:
# Ok, this is close to madness, but probably better than drawing
# 200 images by hand;
if len(buttons) == 0:
# Quick way out - changes are not needed
svg = Rsvg.Handle.new_from_data(self.current_svg.encode("utf-8"))
else:
# 1st, parse source as XML
tree = ET.fromstring(self.current_svg.encode("utf-8"))
# 2nd, change colors of some elements
for button in buttons:
el = SVGEditor.find_by_id(tree, button)
if el is not None:
SVGEditor.recolor(el, buttons[button])
# 3rd, turn it back into XML string......
xml = ET.tostring(tree)
# ... and now, parse that as XML again......
svg = Rsvg.Handle.new_from_data(xml.encode("utf-8"))
while len(self.cache) >= self.CACHE_SIZE:
self.cache.popitem(False)
if self.size_override:
w, h = self.size_override
self.cache[cache_id] = svg.get_pixbuf().scale_simple(
w, h, GdkPixbuf.InterpType.BILINEAR)
else:
self.cache[cache_id] = svg.get_pixbuf()
self.image.set_from_pixbuf(self.cache[cache_id])
def mount_iso(self, dev, image):
def attach_iso(dev, disk, vol):
if disk.get('device') == 'cdrom':
for elm in disk:
if elm.tag == 'target':
if elm.get('dev') == dev:
src_media = ElementTree.Element('source')
src_media.set('file', vol.path())
disk.insert(2, src_media)
return True
storages = self.get_storages()
for storage in storages:
stg = self.get_storage(storage)
if stg.info()[0] != 0:
for img in stg.listVolumes():
if image == img:
vol = stg.storageVolLookupByName(image)
tree = ElementTree.fromstring(self._XMLDesc(0))
for disk in tree.findall('devices/disk'):
if attach_iso(dev, disk, vol):
break
if self.get_status() == 1:
xml = ElementTree.tostring(disk)
self.instance.attachDevice(xml)
xmldom = self._XMLDesc(VIR_DOMAIN_XML_SECURE)
if self.get_status() == 5:
xmldom = ElementTree.tostring(tree)
self._defineXML(xmldom)
def xml(self):
"""
xml representation of the metadata.
:return: xml representation of the metadata
:rtype: ElementTree.Element
"""
root = super(ImpactLayerMetadata, self).xml
provenance_path = self._special_properties['provenance']
provenance_element = root.find(provenance_path, XML_NS)
# find the provenance parent tag
if provenance_element is not None:
# there is already a provenance tag so we remove it
provenance_parent = provenance_element.getparent()
provenance_parent.remove(provenance_element)
else:
# find the parent using the provenance path minus one level
provenance_parent = '/'.join(provenance_path.split('/')[:-1])
provenance_parent = root.find(provenance_parent, XML_NS)
# generate the provenance xml element
provenance_element = ElementTree.fromstring(self.provenance.xml)
provenance_parent.append(provenance_element)
return prettify_xml(ElementTree.tostring(root))
def isIgnored(myMedia):
ignored = False
msg = u'File: {0}'.format(myMedia.oStatus.fileName)
Debug(msg)
pchtrakt.logger.info(msg)
ignored = isKeywordIgnored(myMedia.oStatus.fileName)
if not ignored and ignored_repertory[0] != '':
for el in myMedia.oStatus.fullPath.split('/'):
if el <> '' and el in ignored_repertory:
msg = 'This video is in a ignored repertory: {0}'.format(el)
ignored = True
break
if not ignored and YamjIgnoredCategory[0] != '':
if isinstance(myMedia.parsedInfo, mp.MediaParserResultTVShow):
files = listdir(YamjPath)
for file in files:
if file.endswith('xml'):
file = unicode(file, errors='replace')
if file.find(myMedia.parsedInfo.name) >= 0:
oXml = ElementTree.parse(YamjPath + file)
ignored = isGenreIgnored(oXml.findall('.//genre'))
if ignored:
break
else:
file = unicode(myMedia.oStatus.fileName.rsplit('.',1)[0] + '.xml', errors='replace')
oXml = ElementTree.parse(YamjPath + file)
genres = oXml.findall('.//genre')
ignored = isGenreIgnored(genres)
return ignored
def setUp(self):
JSBSimTestCase.setUp(self)
self.fdm = CreateFDM(self.sandbox)
self.script_path = self.sandbox.path_to_jsbsim_file('scripts',
'c1722.xml')
# Read the time step 'dt' from the script file
self.tree = et.parse(self.script_path)
root = self.tree.getroot()
use_tag = root.find('use')
aircraft_name = use_tag.attrib['aircraft']
self.run_tag = root.find('run')
self.dt = float(self.run_tag.attrib['dt'])
# Read the date at which the trim will be run
for event in root.findall('run/event'):
if event.attrib['name'] == 'Trim':
cond_tag = event.find('condition')
self.trim_date = float(cond_tag.text.split()[-1])
break
# Read the output rate and the output file from the aircraft file
aircraft_path = self.sandbox.path_to_jsbsim_file('aircraft', aircraft_name,
append_xml(aircraft_name))
tree = et.parse(aircraft_path)
output_tag = tree.getroot().find('output')
self.output_file = output_tag.attrib['name']
self.rateHz = float(output_tag.attrib['rate'])
self.rate = int(1.0 / (self.rateHz * self.dt))
def get_bib_string(bib_xml):
"""
this function extracts the bibliographic record from
the XML string returned by ALMA's API. ALMA's
MARCXML record is enclosed by markup
<collection xmlns="http://www.loc.gov/MARC21/slim">
<record></record>
</collection>
"""
bib_string=""
outcome=1
in_string=bib_xml.replace("\n","")
try:
tree=elementTree.fromstring(in_string)
except:
sys.stderr.write("parse failed."+"\n")
return bib_string,outcome
try:
bib_element=tree.find("record")
except:
sys.stderr.write("xml parsing failed. couldn't find record element"+"\n")
return bib_string,outcome
try:
bib_string=elementTree.tostring(bib_element,encoding="utf-8",method="xml")
#sys.stderr.write(str(bib_string)+"\n"))
bib_string=bib_string.replace("<?xml version='1.0' encoding='utf-8'?>","")
#bib_string=elementTree.tostring(bib_element,method="xml")
except:
sys.stderr.write("xml parsing failed. couldn't find record element"+"\n")
return "",outcome
bib_string=bib_string.replace(" schemaLocation=\"http://www.loc.gov/MARC21/slim http://www.loc.gov/standards/marcxml/schema/MARC21slim.xsd\"","")
bib_string=bib_string.replace("</record>","")
bib_string=bib_string.replace("<leader> ","<leader>12345")
return bib_string,0
def main():
count = 1
start_title = parse_args()
print "%i. %s" % (count, start_title)
count += 1
next_page = start_title
link_list = []
next_page = next_page.replace(" ", "+").encode('utf-8')
xml = urllib2.urlopen(
'https://en.wikipedia.org/w/api.php?action=query&format=xml&prop=links&indexpageids=1&titles=' + next_page + '&plnamespace=&pllimit=5000')
root = ET.fromstring(xml.read())
for child in root.iter('pl'):
if ':' not in child.get('title'):
link_list.append(child.get('title'))
next_page = random.choice(link_list)
while next_page:
last_list = link_list
link_list = []
while not link_list:
next_page = random.choice(last_list)
print "%i. %s" % (count, next_page)
count += 1
next_page = next_page.replace(" ", "+").encode('utf-8')
xml = urllib2.urlopen(
'https://en.wikipedia.org/w/api.php?action=query&format=xml&prop=links&indexpageids=1&titles=' + next_page + '&plnamespace=&pllimit=5000')
root = ET.fromstring(xml.read())
for child in root.iter('pl'):
if ':' not in child.get('title'):
link_list.append(child.get('title'))
def limit_rdb(services_rdb, full_factory_map, full_constructor_map):
ET.register_namespace('','http://openoffice.org/2010/uno-components')
tree = ET.parse(services_rdb[0])
root = tree.getroot()
for component in root.findall('{http://openoffice.org/2010/uno-components}component'):
# direct
uri = component.get('uri')
component_name = None
if uri != None:
component_name = re.sub('^vnd.sun.star.expand:\$LO_LIB_DIR/([^.]*).so$', '\\1.a', uri)
if component_name in full_factory_map:
continue
# via a constructor - limit only to those we have
has_constructor = False
for implementation in component.findall('{http://openoffice.org/2010/uno-components}implementation'):
constructor = implementation.get('constructor')
if constructor in full_constructor_map:
has_constructor = True
else:
component.remove(implementation)
if not has_constructor:
root.remove(component)
tree.write(services_rdb[0] + '.out', xml_declaration = True, method = 'xml')
def save_element(elem, path):
if elem is None:
return
if not path or path is None:
return
parent = os.path.dirname(path)
if not os.path.isdir(parent):
os.makedirs(parent, mode=0o755, exist_ok=True)
os.chmod(parent, 0o0755)
try:
# Get the elements default namespace
namespace = getNamespace(elem)
# Pretty up the element
indent(elem)
# Register the discovered namespace as the default
ET.register_namespace("", namespace)
# Create a new ElementTree with this element as the root
elem_tree = ET.ElementTree(element=elem)
# Write the full tree to a file
elem_tree.write(path, xml_declaration=False, encoding="UTF-8", method="xml")
os.chmod(path, 0o0664)
return True
except:
print(" *** Error writing new element to path %s" % path)
print(" Exception Type: ", sys.exc_info()[0])
print(" Exception Value: ", sys.exc_info()[1])
return False
