def dict_to_xml( self, root_elm, dict_data ):
for key in dict_data.keys():
_data = dict_data[key]
_elm = SubElement(root_elm, key)
_list_data = (isinstance(_data, list) or isinstance(_data, tuple))
_is_plural = (key[len(key)-1] == "s")
_plural_name = key[:len(key)-1]
if isinstance(_data, dict):
_elm = self.dict_to_xml(_elm, _data)
elif _list_data and not _is_plural:
for _d in _data:
__elm = self.dict_to_xml(_elm, _d)
elif _list_data:
for _d in _data:
_plural_name = self.PLURAL_EXCEPTIONS.get(_plural_name, _plural_name)
__elm = self.dict_to_xml(SubElement(_elm, _plural_name), _d)
else:
_elm.text = str(_data)
return root_elm
def _commit_blocks(self, object_path, chunks, lease):
"""
Makes a final commit of the data.
:param object_path: Server side object path.
:type object_path: ``str``
:param upload_id: A list of (chunk_number, chunk_hash) tuples.
:type upload_id: ``list``
"""
root = Element('BlockList')
for block_id in chunks:
part = SubElement(root, 'Uncommitted')
part.text = str(block_id)
data = tostring(root)
params = {'comp': 'blocklist'}
headers = {}
lease.update_headers(headers)
lease.renew()
response = self.connection.request(object_path, data=data,
params=params, headers=headers,
method='PUT')
if response.status != httplib.CREATED:
raise LibcloudError('Error in blocklist commit', driver=self)
def makeXML(self, work_directory):
# </Artifact>
TheArtifact = Element( 'Artifact')
TheArtifact.attrib['xmlns']="http://geni.net/schema"
TheArtifact.attrib['xmlns:xsi']="http://www.w3.org/2001/XMLSchema-instance"
TheArtifact.attrib['xsi:schemaLocation']="http://geni.net/schema GENIObject.xsd"
# <Artifact><Type/>
Type = SubElement( TheArtifact, 'Type')
# <Artifact><Type><Primary/>
Primary = SubElement( Type, 'Primary')
Primary.text = self.art_type_prime
# <Artifact><Interpretation/>
Interpretation = SubElement( TheArtifact, 'Interpretation')
# <Artifact><Interpretation><Interpretation_read_me_text/>
Read_me_text = SubElement( Interpretation, 'Interpretation_read_me_text')
Read_me_text.text = self.interpretation_read_me
#To print to file
Test = ElementTree()
Test._setroot(TheArtifact)
root = Test.getroot()
self.indent(root)
Test.write(work_directory+'/artifact.xml')
def _prepare_xml_request(self, module, leads):
root = Element(module)
# Row counter
no = 1
for lead in leads:
row = Element("row", no=str(no))
root.append(row)
assert type(lead) == dict, "Leads must be dictionaries inside a list, got:" + str(type(lead))
for key, value in lead.items():
# <FL val="Lead Source">Web Download</FL>
# <FL val="First Name">contacto 1</FL>
fl = Element("FL", val=key)
if type(value) == dict: # If it's an attached module, accept multiple groups
mod_attach_no = 1
for module_key, module_value in value.items(): # The first group defines the module name, yank that and iterate through the contents
for mod_item in module_value:
mod_fl = SubElement(fl, module_key, no=str(mod_attach_no))
for mod_item_key, mod_item_value in mod_item.items():
attach_fl = SubElement(mod_fl, "FL", val=mod_item_key)
attach_fl.text = mod_item_value
mod_attach_no += 1
elif type(value) not in [str, unicode]:
fl.text = str(value)
else:
fl.text = value
row.append(fl)
no += 1
return root
def addDataToForm(form, element, subelement):
print form
elem = SubElement(person, element)
for key in form.keys():
for value in form.getlist(key):
subelem = SubElement(elem, subelement)
subelem.text = value
def brandsCatalogXML(brand_id):
if 'username' not in login_session:
response = make_response(json.dumps("You are not authorized, Login is required"), 401)
response.headers['Content-Type'] = 'application/json'
return response
else:
brand = session.query(Brand).filter_by(id=brand_id).one()
items = session.query(Item).filter_by(brand_id=brand_id).all()
root = Element('html')
for i in items:
body = SubElement(root, 'body')
ID = SubElement(body, 'ID')
ID.text = str(i.id)
name = SubElement(body, 'name')
name.text = i.name
price = SubElement(body, 'price')
price.text = i.price
description = SubElement(body, 'description')
description.text = i.description
image = SubElement(body, 'image')
image.text = i.image
print tostring(root)
return app.response_class(tostring(root), mimetype='application/xml')
def _create_update_feed(self, cell_list):
feed = Element('feed', {'xmlns': ATOM_NS,
'xmlns:batch': BATCH_NS,
'xmlns:gs': SPREADSHEET_NS})
id_elem = SubElement(feed, 'id')
id_elem.text = construct_url('cells', self)
for cell in cell_list:
entry = SubElement(feed, 'entry')
SubElement(entry, 'batch:id').text = cell.element.find(_ns('title')).text
SubElement(entry, 'batch:operation', {'type': 'update'})
SubElement(entry, 'id').text = cell.element.find(_ns('id')).text
edit_link = finditem(lambda x: x.get('rel') == 'edit',
cell.element.findall(_ns('link')))
SubElement(entry, 'link', {'rel': 'edit',
'type': edit_link.get('type'),
'href': edit_link.get('href')})
SubElement(entry, 'gs:cell', {'row': str(cell.row),
'col': str(cell.col),
'inputValue': unicode(cell.value)})
return feed
def mergeLogs(fromFilePath, toFilePath, outputFilePath):
utf8open = lambda s: open(s, 'r', 'utf8')
outputDoc = E('html')
with utf8open(fromFilePath) as fromFile, utf8open(toFilePath) as toFile:
# the body and HTML tags are left open so the app can just append
# when a new message comes in. we have to close them.
# note: this could also be taken care of by BeautifulSoup or
# perhaps lxml.html
fromDoc = fromstring(fromFile.read() + '</BODY></HTML>')
toDoc = fromstring(toFile.read() + '</BODY></HTML>')
# copy the head tag so formatting and stuff is preserved in our new doc
outputDoc.append(fromDoc.find('HEAD').copy())
fromMessages = fromDoc.findall('./BODY/div')
toMessages = toDoc.findall('./BODY/div')
allMessages = list(fromMessages) + list(toMessages)
allMessages.sort(key = lambda e: time.strptime(e.attrib['timestamp'], '%Y-%m-%d %H:%M:%S'))
body = SE(outputDoc, 'BODY', attrib = fromDoc.find('BODY').attrib)
body.extend(x.copy() for x in allMessages)
ElementTree(outputDoc).write(outputFilePath, 'utf8')
def createAndWriteXML(upload_id, writeToDB):
completeVase = Element('vase')
for i in range(len(finalRight)):
pointpair = SubElement(completeVase, 'pointpair')
left = SubElement(pointpair, 'left')
right = SubElement(pointpair, 'right')
t = SubElement(pointpair, 't')
xRight = SubElement(right, 'x')
xLeft = SubElement(left, 'x')
yRight = SubElement(right, 'y')
yLeft = SubElement(left, 'y')
t.text = "0"
xRight.text = str(finalRight[i][0])
xLeft.text = str(finalLeft[i][0])
yRight.text = str(finalRight[i][1])
yLeft.text = str(finalLeft[i][1])
if writeToDB == 'True':
writeToDB(upload_id, tostring(completeVase))
#print "Content-type: text/html"
#print
print tostring(completeVase)
def process_text(parent, style_node, style_macros, reference):
"""
When given a style node and a reference, return an evaludated cs:text.
"""
formatting = style_node.attrib
variable = style_node.get('variable')
macro = style_node.get('macro')
if variable:
if variable in reference:
content = reference.pop(style_node.get('variable'))
else:
content = None
if content:
node = SubElement(parent, "span", attrib=formatting)
node.set('property', get_property(node.attrib.pop('variable')))
node.text = content
return(node)
elif macro:
macro_result = process_macro(parent,
get_macro(macro, style_macros),
style_macros,
reference)
return(macro_result)
else:
pass
def modify_vrt(vrt, scale):
"""
Makes modifications to the vrt file to fix the values.
:param vrt: VRT file to be processed
:param scale: Scale value from get_metadata_item function
:return: None
"""
doc = parse(vrt)
root = doc.getroot()
# Fix the datatype if it is wrong
raster_band = root.find('VRTRasterBand')
raster_band.set('dataType', 'Float32')
# Add the scale to the vrt file
source = root.find('VRTRasterBand').find('ComplexSource')
scale_ratio = SubElement(source, 'ScaleRatio')
scale_ratio.text = scale
# Write the scale input
# vrt files are overwritten with the same name
doc.write(vrt, xml_declaration=True)
def dict_to_xml(self, root_elm, data):
for key in data.keys():
sub_data = data[key]
elm = SubElement(root_elm, key)
is_list = isinstance(sub_data, list) or isinstance(sub_data, tuple)
is_plural = key[len(key)-1] == "s"
plural_name = key[:len(key)-1]
# Key references a dict. Unroll the dict
# as it's own XML node with subnodes
if isinstance(sub_data, dict):
self.dict_to_xml(elm, sub_data)
# Key references a list/tuple
elif is_list:
# key name is a plural. This means each item
# in the list needs to be wrapped in an XML
# node that is a singular version of the list name.
if is_plural:
for d in sub_data:
plural_name = self.PLURAL_EXCEPTIONS.get(plural_name, plural_name)
self.dict_to_xml(SubElement(elm, plural_name), d)
# key name isn't a plural. Just insert the content
# as an XML node with subnodes
else:
for d in sub_data:
self.dict_to_xml(elm, d)
# Normal element - just inser the data.
else:
elm.text = str(sub_data)
return root_elm
def updateLine(firstrow, method, attr):
root, body = getBaseXML()
action = SubElement(body, 'ns:' + method)
for i in range(len(attr)):
if '-' in firstrow[i]:
# pattern;partition;altnum-nummask;altnum-partition
#<altnum>
# <nummask>XXXX</nummask>
# <partition>CLUSTERDN</partition>
#</altnum>
parentchild = firstrow[i].split('-')
#altnum
parent = parentchild[0]
#nummask
child = parentchild[1]
#<altnum>
l1 = SubElement(action, parent)
#<altnum><nummask>
l2 = SubElement(l1, child)
#<altnum><nummask>XXXX
l2.text = attr[i]
else:
l1 = SubElement(action, firstrow[i])
l1.text = attr[i]
xmldata = ElementTree.tostring(root, encoding='utf-8')
logger.info('Updating Line ' + attr[0])
for i in range(len(firstrow)):
logger.debug(firstrow[i] + ': ' + attr[i])
result = runAxl(method, xmldata)
logger.info(result)
def topology_list():
logger.info('GET topology list.')
try:
#open DB connection.
tpldb_setup()
#create <topology_list>
xml_topology_list = Element(const.XML_TAG_TOPOL_LIST)
nw_list = Network.query.all()
for nw in nw_list:
#add <topology type='slice' last_update_time='xxx' name='xxx' owner='xxx'>
xml_topology = SubElement(xml_topology_list, const.XML_TAG_TOPOL,
{const.XML_ATTR_TYPE:nw.type,
const.XML_ATTR_LAST_UPD_TIME:str(nw.last_update_time),
const.XML_ATTR_NAME:nw.network_name
})
if nw.type == const.TYPE_NW_SLICE:
xml_topology.set(const.XML_ATTR_OWN,nw.user)
except Exception:
logger.exception('GET topology list error.')
return HTTPResponse("GET topology list error.", status=500)
finally:
#close DB connection.
tpldb_close()
return util.prettify(xml_topology_list)
def compile_while(tree, tok_type, tok):
subR = SubElement(tree, 'whileStatement')
# while
temp = SubElement (subR, tok_type)
temp.text = tok
tok_type, tok = next(token_it)
# '('
temp = SubElement (subR, tok_type)
temp.text = tok
# ( INSIDE )
tok_type, tok = compile_expression(subR)
# ')'
temp = SubElement (subR, tok_type)
temp.text = tok
tok_type, tok = next(token_it)
# '{'
temp = SubElement (subR, tok_type)
temp.text = tok
tok_type, tok = next(token_it)
tok_type, tok = statements(subR, tok_type, tok)
# '}'
temp = SubElement (subR, tok_type)
temp.text = tok
def create_container(self, container_name):
if self.ex_location_name:
root = Element('CreateBucketConfiguration')
child = SubElement(root, 'LocationConstraint')
child.text = self.ex_location_name
if PY3:
encoding = 'unicode'
else:
encoding = None
data = tostring(root, encoding=encoding)
else:
data = ''
response = self.connection.request('/%s' % (container_name),
data=data,
method='PUT')
if response.status == httplib.OK:
container = Container(name=container_name, extra=None, driver=self)
return container
elif response.status == httplib.CONFLICT:
raise InvalidContainerNameError(value='Container with this name ' +
'already exists. The name must be unique among '
'all the containers in the system',
container_name=container_name, driver=self)
elif response.status == httplib.BAD_REQUEST:
raise InvalidContainerNameError(value='Container name contains ' +
'invalid characters.',
container_name=container_name,
driver=self)
raise LibcloudError('Unexpected status code: %s' % (response.status),
driver=self)
def story_feed(request, story):
story = Story.objects.get(slug=story)
rss = Element('rss')
rss.set("version","2.0")
channel = SubElement(rss,'channel')
title = SubElement(channel,'title')
title.text = story.title
link = SubElement(channel,'link')
link.text = request.build_absolute_uri(reverse("story"))
desc = SubElement(channel,'description')
desc.text = story.description
chapters = story.chapters.all()
for index in chapters:
item = SubElement(channel,'item')
title_c = SubElement(item,'title')
title_c.text = index.title
link = SubElement(item,'link')
link.text = request.build_absolute_uri(index.get_absolute_url())
return HttpResponse(tostring(rss, encoding='UTF-8'))
def compile_if(tree, tok_type, tok):
subR = SubElement(tree, "ifStatement")
# if
temp = SubElement(subR, tok_type)
temp.text = tok
tok_type, tok = next(token_it)
# '('
temp = SubElement(subR, tok_type)
temp.text = tok
# ( INSIDE )
tok_type, tok = compile_expression(subR)
# ')'
temp = SubElement(subR, tok_type)
temp.text = tok
tok_type, tok = next(token_it)
# '{'
temp = SubElement(subR, tok_type)
temp.text = tok
tok_type, tok = next(token_it)
tok_type, tok = statements(subR, tok_type, tok)
# '}'
temp = SubElement(subR, tok_type)
temp.text = tok
def export_opml(user):
"""
Generate a minimal OPML export of the user's feeds.
:param user: Django User object
:param stream: writable file-like object to which the XML is written
"""
root = Element('opml', {'version': '1.0'})
head = SubElement(root, 'head')
title = SubElement(head, 'title')
title.text = u'{0} subscriptions'.format(user.username)
body = SubElement(root, 'body')
for feed in user.feed_set.all():
item = SubElement(body, 'outline', {
'type': 'rss',
'text': feed.title,
'title': feed.title,
'xmlUrl': feed.feed_url,
})
if feed.site_url:
item.set('htmlUrl', feed.site_url)
buf = StringIO()
ElementTree(root).write(buf, encoding="UTF-8")
return buf.getvalue()
def get_database_deployment(dbid, sid=0):
deployment_top = Element('deployment')
deployment = HTTPListener.Global.DEPLOYMENT[dbid]
value = copy.deepcopy(deployment)
db = HTTPListener.Global.DATABASES[dbid]
if not sid == 0:
server = HTTPListener.Global.SERVERS.get(sid)
value = DeploymentConfiguration.get_specific_directories(value, server, dbid)
host_count = len(db['members'])
value['cluster']['hostcount'] = host_count
# Add users
addTop = False
for key, duser in HTTPListener.Global.DEPLOYMENT_USERS.items():
if duser['databaseid'] == dbid:
# Only create subelement if users have anything in this database.
if addTop != True:
users_top = SubElement(deployment_top, 'users')
addTop = True
uelem = SubElement(users_top, "user")
uelem.attrib["name"] = duser["name"]
uelem.attrib["password"] = duser["password"]
uelem.attrib["roles"] = duser["roles"]
plaintext = str(duser["plaintext"])
if isinstance(duser["plaintext"], bool):
if duser["plaintext"] == False:
plaintext = "false"
else:
plaintext = "true"
uelem.attrib["plaintext"] = plaintext
handle_deployment_dict(deployment_top, dbid, value, True)
xmlstr = tostring(deployment_top,encoding='UTF-8')
return xmlstr
def addToWorkingSet(newProjectPath):
workingSetFilePath = os.path.expanduser("~") + os.sep + ".colt" + os.sep + "workingset.xml"
projectsList = []
# Populate projects list
if os.path.exists(workingSetFilePath) :
workingSetElement = parse(workingSetFilePath).getroot()
for projectElement in workingSetElement :
projectPath = projectElement.attrib["path"]
if projectPath :
projectsList.append(projectPath)
# Remove project path from the list
projectsList = filter(lambda projectPath : projectPath != newProjectPath, projectsList)
# Push new project
projectsList.insert(0, newProjectPath)
# Save the list
workingSetElement = Element("workingset")
workingSetElement.set("openRecent", "true")
for projectPath in projectsList :
projectElement = SubElement(workingSetElement, "project")
projectElement.set("path", projectPath)
workingSetFile = open(workingSetFilePath, "w")
workingSetFile.write(tostring(workingSetElement))
workingSetFile.close()
def egressports_getConfig(fileName, portList):
global egrPorts
global egrPLst
crossconnects = Element('opsw:cross-connects', {'xmlns:plts':"http://www.polatis.com/yang/polatis-switch",
'xmlns:opsw':"http://www.polatis.com/yang/optical-switch"})
egrSymbol = re.split(r'[\d]', portList)
if str(egrSymbol[1]) == ',' or str(egrSymbol[1]) == '':
egrPLst = portList.split(',')
if str(ingSymbol[2]) == '-' or str(ingSymbol[1]) == '-':
egrPLst = []
egrPLst1 = portList.split('-')
for i in range(int(egrPLst1[0]), int(egrPLst1[1])+1):
egrPLst.append(i)
logger.info('egress port list: %s' % egrPLst)
else:
logger.error('Give for example comma or hypen seperated values ...\n\n')
l = len(egrPLst)
for i in range(0, l):
a = egrPLst[i]
if a in egrPorts:
pairs = SubElement(crossconnects, 'opsw:pairs')
egress = SubElement(pairs, 'opsw:egress')
egress.text = str(a)
else:
pairs = SubElement(crossconnects, 'opsw:pairs')
egress = SubElement(pairs, 'opsw:egress')
egress.text = str(a)
xmlstr = tostring(crossconnects)
getConfig('getConfig - Query given egress ports', xmlstr, fileName)
def sendXML(self):
root = self.tree.getroot()
if self.comboBox1.Value in self.runCollection:
bob = self.tree.getiterator("hrun")
for i in bob:
if i.attrib["runName"] == self.comboBox1.Value:
i.find("target").text = self.cTarget.Value
i.find("targid").text = self.cTargID.Value
i.find("targkey").text = self.cTargKey.Value
i.find("targlength").text = self.cTargLength.Value
i.find("buffid").text = self.cBuffID.Value
i.find("buffer").text = self.cBuffer.Value
i.find("buffkey").text = self.cBuffKey.Value
i.find("rootfolder").text = self.cRoot.Value
i.find("waterbody").text = self.cWater.Value
i.find("wabodyid").text = self.cWabodyid.Value
i.find("subsett").text = self.cSubsetT.Value
i.find("subsetc").text = self.cSubsetC.Value
else:
hrun = SubElement(root, "hrun")
hrun.attrib["runName"] = self.comboBox1.Value
SubElement(hrun, "target").text = self.cTarget.Value
SubElement(hrun, "targid").text = self.cTargID.Value
SubElement(hrun, "targkey").text = self.cTargKey.Value
SubElement(hrun, "targlength").text = self.cTargLength.Value
SubElement(hrun, "buffid").text = self.cBuffID.Value
SubElement(hrun, "buffer").text = self.cBuffer.Value
SubElement(hrun, "buffkey").text = self.cBuffKey.Value
SubElement(hrun, "rootfolder").text = self.cRoot.Value
SubElement(hrun, "waterbody").text = self.cWater.Value
SubElement(hrun, "wabodyid").text = self.cWabodyid.Value
SubElement(hrun, "subsett").text = self.cSubsetT.Value
SubElement(hrun, "subsetc").text = self.cSubsetC.Value
ElementTree(root).write(file=os.getcwd() + "\\xmltest.xml")
self.comboRefresh()
def _dispatchSoapRequest(self, request):
try:
try:
envelope = XML(request.soap_data)
body = envelope.find("{http://schemas.xmlsoap.org/soap/envelope/}Body")
# determine UPnP action
action = body.find("{%s}%s" % (request.soap_ns, request.soap_action))
# look up the action in the service
upnp_action = self.service._actions[request.soap_action]
# build a list of the action arguments
in_args = {}
for arg in action:
in_args[arg.tag] = arg.text
# execute the UPnP action
logger.log_debug("executing %s#%s" % (self.service.serviceID, request.soap_action))
out_args = upnp_action(request, self.service, in_args)
# return the action response
env = Element("s:Envelope")
env.attrib['xmlns:s'] = "http://schemas.xmlsoap.org/soap/envelope/"
env.attrib['s:encodingStyle'] = "http://schemas.xmlsoap.org/soap/encoding/"
env.attrib['xmlns:i'] = "http://www.w3.org/1999/XMLSchema-instance"
body = SubElement(env, "s:Body")
resp = SubElement(body, "u:%sResponse" % request.soap_action)
resp.attrib['xmlns:u'] = request.soap_ns
for (name,type,value) in out_args:
arg = SubElement(resp, name)
arg.attrib["i:type"] = type
arg.text = value
output = xmlprint(env)
return HttpResponse(200, headers={'EXT': ''}, stream=output)
except UPNPError, e:
raise e
except Exception, e:
logger.log_error("caught unhandled exception: %s" % e)
raise UPNPError(500, "Internal server error")
def GET(self, dados):
now = datetime.datetime.now()
weekend = set([6, 7])
retorno = Element('compra')
aprovada = SubElement(retorno , 'aprovada')
mensagem = SubElement(retorno, 'mensagem')
splitados = dados.split('|')
emp = splitados[0]
vlr = float(splitados[1])
qtd = splitados[2]
if float(qtd).__mod__(100) == 0: #and now.hour >= 18:
minimo , maximo = self.verifica_compra(emp)
if vlr > float(minimo) and vlr > float(maximo):
aprovada.text = 'Nao'
mensagem.text = 'Valor Invalido!(Abaixo do minimo ' + str(minimo) + ' ou maior que o maximo ' + str(maximo) + ')'
else:
if now.isoweekday() not in weekend:
aprovada.text = 'Sim'
mensagem.text = 'Compra Aprovada'
else:
aprovada.text = 'Pendente'
mensagem.text = "Pregao Fechado!"
else:
aprovada.text = 'Nao'
mensagem.text = 'Qtd Invalida'
return prettify(retorno);
def __init__(self, id, route, chunk):
((rfrom, rdest),) = route
chunk, (cnum, maxc, fname, totalbsize) = chunk
cont = Element('content')
idtag = SubElement(cont, 'id')
idtag.text = id
rattrs = {
'from': rfrom,
'to': rdest,
}
routetag = SubElement(cont, 'route', rattrs)
cattrs = {
'number': cnum,
'maxchunk': maxc,
'filename': fname,
'totalbsize': totalbsize,
}
chunktag = SubElement(cont, 'chunk', cattrs)
chunktag.text = chunk
props = {
'type': 'file_chunk',
}
MMessage.__init__(self, TYPE, cont, props)
def create_proppatch(setprops, delprops, namespaces=None):
"""Construct and return XML string for PROPPATCH.
setprops -- Mapping with properties to set.
delprops -- Iterable with element names to remove.
namespaces -- Mapping (prefix->namespace) with additional namespaces,
if necessary.
"""
# RFC 2518, 12.13 propertyupdate XML element
# <!ELEMENT propertyupdate (remove | set)+ >
propertyupdate = Element("propertyupdate", _NS)
if namespaces:
_addnamespaces(propertyupdate, namespaces)
# RFC 2518, 12.13.2 set XML element
# <!ELEMENT set (prop) >
if setprops:
set_ = SubElement(propertyupdate, "set")
prop = SubElement(set_, "prop")
items_iterator = iter(list(setprops.items())) if PYTHON2 else list(setprops.items())
for (propname, propvalue) in items_iterator:
prop = SubElement(prop, propname)
prop.text = propvalue
# RFC 2518, 12.13.1 set XML element
# <!ELEMENT remove (prop) >
if delprops:
remove = SubElement(propertyupdate, "remove")
prop = SubElement(remove, "prop")
for propname in delprops:
prop = SubElement(prop, propname)
return tostring(propertyupdate, "UTF-8")
def getConfig(self):
"""Generates a configuration file for this projection"""
tree = Element('projection')
SubElement(tree, 'id').text = self.id
SubElement(tree, 'title').text = self.title
SubElement(tree, 'startyear').text = self.getProjection()[0]['year']
SubElement(tree, 'endyear').text = self.getProjection()[-1]['year']
SubElement(tree, 'graph').text = self.absolute_url() + '/getGraph'
SubElement(tree, 'layer').text = self.zone.absolute_url() + \
'/at_download/simImage'
SubElement(tree, 'redevelopment').text = str(self.redevelopment)
e = SubElement(tree, 'pop_density')
if self.pop_density:
e.text = self.pop_density.absolute_url() + '/at_download/simImage'
e = SubElement(tree, 'emp_density')
if self.emp_density:
e.text = self.emp_density.absolute_url() + '/at_download/simImage'
self.REQUEST.RESPONSE.setHeader('Content-Type', 'text/plain')
self.REQUEST.RESPONSE.setHeader('Content-Disposition',
'attachment; filename="%s_demand.xml"' % self.title)
return tostring(tree, encoding='UTF-8')
def mergePopulationData(populationFile, regionFile, mergedFile):
csvReader = csv.reader(open(populationFile), delimiter=',', quotechar='"')
inhabDict = {}
for entry in csvReader:
if csvReader.line_num <= 3:
continue
while(len(entry[0]) < 2):
entry[0] = '0' + entry[0]
while(len(entry[2]) < 2):
entry[2] = '0' + entry[2]
while(len(entry[3]) < 4):
entry[3] = '0' + entry[3]
while(len(entry[4]) < 3):
entry[4] = '0' + entry[4]
inhabDict["".join(entry[:5])] = str(entry[6]).replace(' ', '')
root = ET.ElementTree(file=regionFile).getroot()
for parents in root.findall("./*"):
for elem in parents.findall("param[7]"):
RSValue = str(elem.attrib)[11:23]
inhabitants = SubElement(parents, 'param')
if RSValue in inhabDict:
inhabitants.clear()
inhabitants.attrib = {
'key': "INHABITANTS", 'value': inhabDict[RSValue]}
outstr = minidom.parseString(ET.tostring(root)).toprettyxml(indent=" ")
with open(mergedFile, 'w') as out:
out.write(outstr.encode('utf-8'))
def set(self, index, values):
for key, value in values.items():
item = self._root[index].find(key)
if item is None:
item = SubElement(self._root[index], key)
item.text = value
def validSoup(cls):
for svcaction in SvcaddTestCase, SvcchgTestCase, SvcdelTestCase:
root = Element("ACCTRQ")
root.append(svcaction.etree)
SubElement(root, "SVC").text = "BANKSVC"
yield root
def set_attributes(rroot, elem, ttitle, ssession_t):
'''new course to add'''
ccourse = SubElement(rroot, "att", course=ttitle, time=ssession_t)
'''new time to add'''
for e in root.iter():
if e.get('course') is not None:
# print "%s%-20s" % (e.get('course'), e.get('time'))
print '->' + e.get('course')
print ' --Hours: ' + e.get('time')
else:
course_title = get_title(index, course_opts)
i = 0
'''updates hours instead of creating new or setting other attributes'''
for c in root.iter():
if c.get('course') == course_title:
timess = str(float(c.get('time')) + float(session_t))
root.remove(c)
elem_tmp = SubElement(root,
"att",
course=course_title,
time=timess)
i = 1
break
'''if there is new class then create new SubElement setting all its attributes'''
if not i:
course = Element('course')
set_attributes(root, course, course_title, session_t)
tree.write(str(this_dir + '/db.xml'))
print 'Added: ' + session_t + ' hour(s) invested to ' + course_title
except IOError as e:
'''When there is no file created, create new file and set attributes'''
i, time, opts = take_input()
def etree(cls):
root = Element("CHGUSERINFORQ")
SubElement(root, "FIRSTNAME").text = "Mary"
SubElement(root, "MIDDLENAME").text = "J."
SubElement(root, "LASTNAME").text = "Blige"
SubElement(root, "ADDR1").text = "3717 N Clark St"
SubElement(root, "ADDR2").text = "Dugout Box, Aisle 19"
SubElement(root, "ADDR3").text = "Seat A1"
SubElement(root, "CITY").text = "Chicago"
SubElement(root, "STATE").text = "IL"
SubElement(root, "POSTALCODE").text = "60613"
SubElement(root, "COUNTRY").text = "USA"
SubElement(root, "DAYPHONE").text = "(773) 309-1027"
SubElement(root, "EVEPHONE").text = "867-5309"
SubElement(root, "EMAIL").text = "*****@*****.**"
return root
def etree(cls):
root = Element("OTHERENROLL")
SubElement(root, "MESSAGE").text = "Mail me $99.99"
return root
def etree(cls):
root = Element("ACCTRS")
root.append(SvcaddTestCase.etree)
SubElement(root, "SVC").text = "BANKSVC"
SubElement(root, "SVCSTATUS").text = "AVAIL"
return root
def etree(cls):
root = Element("WEBENROLL")
SubElement(root, "URL").text = "http://www.ameritrade.com"
return root
def etree(cls):
root = Element("ENROLLRS")
SubElement(root, "TEMPPASS").text = "t0ps3kr1t"
SubElement(root, "USERID").text = "bacon2b"
SubElement(root, "DTEXPIRE").text = "20160705000000.000[0:GMT]"
return root
def etree(cls):
root = Element("ACCTINFORS")
SubElement(root, "DTACCTUP").text = "20120314000000.000[0:GMT]"
acctinfo = AcctinfoTestCase.etree
root.append(acctinfo)
return root
def etree(cls):
root = Element("CLIENTENROLL")
SubElement(root, "ACCTREQUIRED").text = "Y"
return root
def elements_add(root):
phone = SubElement(root, 'phone')
phone.set('id', 'result_' + str(16))
model_name = SubElement(phone, 'model_name')
model_name.text = 'Xiaomi Redmi Note 8 Pro 6/128'
company_name = SubElement(phone, 'company_name')
company_name.text = 'Xiaomi'
price = SubElement(phone, 'price')
price.set('currency', 'euro')
price.text = str(300)
rating = SubElement(phone, 'rating')
rating.text = str(5)
amount_of_customers = SubElement(phone, 'amount_of_customers')
amount_of_customers.set('currency', 'people')
amount_of_customers.text = '10,785'
for phone in root.iter('phone'):
country = SubElement(phone, 'country')
country.set('format', 'iso-3166')
name = SubElement(country, 'name')
code = SubElement(country, 'code')
if phone.find('company_name').text == 'Samsung':
name.text = 'South Korea'
code.text = 'KR'
elif phone.find('company_name').text == 'Xiaomi':
name.text = 'China'
code.text = 'CN'
else:
name.text = 'USA'
code.text = 'US'
return root
def emptyBase(cls):
root = Element("ENROLLRQ")
SubElement(root, "FIRSTNAME").text = "Porky"
SubElement(root, "MIDDLENAME").text = "D."
SubElement(root, "LASTNAME").text = "Pig"
SubElement(root, "ADDR1").text = "3717 N Clark St"
SubElement(root, "ADDR2").text = "Dugout Box, Aisle 19"
SubElement(root, "ADDR3").text = "Seat A1"
SubElement(root, "CITY").text = "Chicago"
SubElement(root, "STATE").text = "IL"
SubElement(root, "POSTALCODE").text = "60613"
SubElement(root, "COUNTRY").text = "USA"
SubElement(root, "DAYPHONE").text = "(773) 309-1027"
SubElement(root, "EVEPHONE").text = "867-5309"
SubElement(root, "EMAIL").text = "*****@*****.**"
SubElement(root, "USERID").text = "bacon2b"
SubElement(root, "TAXID").text = "123456789"
SubElement(root, "SECURITYNAME").text = "Petunia"
SubElement(root, "DATEBIRTH").text = "20160705000000.000[0:GMT]"
return root
def create_netfs_pool(netfs_server, resource_path, name):
"""
Create a libvirt netfs based storage pool.
The target of the newly created pool is /oci-<pool name>
Parameters
----------
netfs_server : str
IP or hostname of the netFS server
resource_path : str
the resource path
Returns
-------
int
return 0 on success, 1 otherwise
"""
poolXML = Element('pool', type='netfs')
pname = SubElement(poolXML, 'name')
pname.text = name
psource = SubElement(poolXML, 'source')
SubElement(psource, 'host', name=netfs_server)
SubElement(psource, 'dir', path=resource_path)
SubElement(psource, 'format', type='nfs')
ptarget = SubElement(poolXML, 'target')
ppath = SubElement(ptarget, 'path')
ppath.text = '/oci-%s' % name
conn = libvirt.open(None)
if conn is None:
_logger.error('Failed to open connection to qemu:///system')
return 1
pool = conn.storagePoolDefineXML(ElementTree.tostring(poolXML), 0)
if pool is None:
_logger.error('Failed to create StoragePool object.')
return 1
try:
pool.setAutostart(1)
pool.build()
pool.create()
except libvirt.libvirtError as e:
pool.undefine()
_logger.error('Failed to setup the pool: %s' % e.get_error_message())
return 1
finally:
conn.close()
return 0
def etree(cls):
root = Element("ACCTINFORQ")
SubElement(root, "DTACCTUP").text = "20120314000000.000[0:GMT]"
return root
#!/usr/bin/env python3
# encoding: utf-8
#
# Copyright (c) 2010 Doug Hellmann. All rights reserved.
#
"""Creating XML documents with lists of nodes
"""
#end_pymotw_header
from xml.etree.ElementTree import (
Element, SubElement, tostring, XML,
)
from ElementTree_pretty import prettify
top = Element('top')
parent = SubElement(top, 'parent')
children = XML(
'<root><child num="0" /><child num="1" />'
'<child num="2" /></root>'
)
parent.extend(children)
print(prettify(top))
def create_virtual_network(**kargs):
"""
Creates a libvirt network on a secondary OCI vNIC
Parameters
----------
kargs: dict
arguments
expected keys:
network : str
The ip address of the VNIC
network_name : str
The name for the new virtual network
ip_bridge :
The bridge IP of virtual network
ip_start
The first IP of virtual network IP range dedicated to guest
ip_end
The last IP of virtual network IP range dedicated to guest
ip_prefix
The IP netmask of virtual network
Returns
-------
0 on success , 1 otherwise
"""
try:
_metadata = InstanceMetadata().refresh()
except IOError as e:
_logger.error("Cannot fetch instance metadata: %s" % str(e))
return 1
_instance_shape = _metadata['instance']['shape']
_is_bm_shape = _instance_shape.startswith('BM')
# get the given IP used to find vNIC to use
_vnic_ip_to_use = kargs['network']
_logger.debug('in create_virtual_network, given IP : %s ' %
_vnic_ip_to_use)
# get all vNIC of the current system
_all_vnics = _metadata['vnics']
# get all current system network interfaces
_all_system_interfaces = get_interfaces()
vf_dev = None
if _is_bm_shape:
free_vnics = find_free_vnics(_all_vnics, _all_system_interfaces)
# based on given IP address, find free VF.
vnic, vf, vf_num = test_vnic_and_assign_vf(_vnic_ip_to_use, free_vnics)
if not vnic:
_logger.debug('choosen vNIC is not free')
return 1
_logger.debug('ready to write network configuration for (%s, %s, %s)' %
(vnic, vf, vf_num))
vf_dev = get_interface_by_pci_id(vf, _all_system_interfaces)
_logger.debug('vf device for %s: %s' % (vf, vf_dev))
if not create_networking(vf_dev, vnic['vlanTag'], vnic['macAddr'],
vnic['privateIp'],
int(vnic['subnetCidrBlock'].split('/')[1])):
_logger.error('cannot create networking')
destroy_networking(vf_dev, vnic['vlanTag'])
return 1
else:
# vm shape: use vnic as it is
# find the device of that vnic
vnic = None
for v in _all_vnics:
if v['privateIp'] == _vnic_ip_to_use:
vnic = v
break
if vnic is None:
_logger.error('vNIC with address [%s] not found' % _vnic_ip_to_use)
return None
for intf_name, attrs in _all_system_interfaces.items():
if attrs['mac'].upper() == vnic['macAddr'].upper(
) and attrs['physical']:
vf_dev = intf_name
if vf_dev is None:
_logger.error(
'cannot find network interface matching vNIC with ip [%s]' %
_vnic_ip_to_use)
return 1
_logger.debug(' device for nework %s' % vf_dev)
if not create_networking(vf_dev, None, vnic['macAddr'],
vnic['privateIp'],
int(vnic['subnetCidrBlock'].split('/')[1])):
_logger.error('cannot create networking')
destroy_networking(vf_dev)
return 1
_logger.debug('Networking succesfully created')
# define a routing table for the new VF.
_logger.debug('add new routing table [%s]' % vf_dev)
add_route_table(vf_dev)
# deduce KVMnetwork
_net = str(
IPNetwork('%s/%s' % (kargs['ip_bridge'], kargs['ip_prefix'])).network)
_kvm_addr_space = '%s/%s' % (_net, kargs['ip_prefix'])
kvm_sysd_svc = SystemdServiceGenerator(
'kvm_net_%s' % kargs['network_name'], "KVM network")
svc_envs = [('__KVM_NETWORK_NAME__', kargs['network_name']),
('__KVM_NET_ADDRESS_SPACE__', _kvm_addr_space),
('__KVM_NET_BRIDGE_NAME__', '%s0' % kargs['network_name']),
('__VNIC_DEFAULT_GW__', vnic['virtualRouterIp']),
('__RT_TABLE_NAME__', vf_dev),
('__VNIC_PRIVATE_IP__', vnic['privateIp'])]
if _is_bm_shape:
svc_envs.append(('__NET_DEV__', '%s.%s' % (vf_dev, vnic['vlanTag'])))
else:
svc_envs.append(('__NET_DEV__', vf_dev))
kvm_sysd_svc.setEnvironment(svc_envs)
# define the libvirt network
netXML = Element('network')
SubElement(netXML, 'name').text = kargs['network_name']
if _is_bm_shape:
SubElement(netXML,
'forward',
dev='%s.%s' % (vf_dev, vnic['vlanTag']),
mode='route')
else:
SubElement(netXML, 'forward', dev='%s' % vf_dev, mode='route')
SubElement(netXML,
'bridge',
name='%s0' % kargs['network_name'],
stp='on',
delay='0')
ip = SubElement(netXML,
'ip',
address=kargs['ip_bridge'],
prefix=kargs['ip_prefix'])
dhcp = SubElement(ip, 'dhcp')
SubElement(dhcp, 'range', start=kargs['ip_start'], end=kargs['ip_end'])
_logger.debug('defining network as [%s]' % ElementTree.tostring(netXML))
tf = tempfile.NamedTemporaryFile(mode='w', delete=False)
os.chmod(tf.name, 0o644)
ElementTree.ElementTree(netXML).write(tf.name)
(code, _, stderr) = sudo_utils.execute(
[VIRSH_CMD, '--quiet', 'net-define', tf.name])
if code != 0:
_logger.error('Failed to define the network: %s' % stderr)
os.remove(tf.name)
delete_route_table(vf_dev)
destroy_networking(vf_dev, vnic['vlanTag'])
return 1
os.remove(tf.name)
kvm_sysd_svc.addRequiredDependency('libvirtd')
try:
kvm_sysd_svc.generate()
except Exception as e:
_logger.error('Failed to generate the init script : %s' % str(e))
delete_route_table(vf_dev)
destroy_networking(vf_dev, vnic['vlanTag'])
return 1
try:
SystemdServiceManager('kvm_net_%s' % kargs['network_name']).start()
except Exception as e:
_logger.error('Failed to start the network init script')
delete_route_table(vf_dev)
destroy_networking(vf_dev, vnic['vlanTag'])
return 1
def generate_metadata(self):
root = Element("dublin_core")
authors = self.data["author"].split(';')
for n in authors:
new_au_el = SubElement(root, 'dcvalue')
new_au_el.set("element", "contributor")
new_au_el.set("qualifier", "author")
title_el = SubElement(root, 'dcvalue')
title_el.set("element", "title")
title_el.set("qaulifier", "none")
mimetype_el = SubElement(root, "dcvalue")
mimetype_el.set("element", "format")
mimetype_el.set("qualifier", "mimetype")
mimetype_el.text = "application/pdf"
mimetype_el = SubElement(root, "dcvalue")
mimetype_el.set("element", "date")
mimetype_el.set("qualifier", "copyright")
rights_url_el = SubElement(root, "dcvalue")
rights_url_el.set("element", "rights")
rights_url_el.set("qualifier", "url")
source_el = SubElement(root, "dcvalue")
source_el.set("element", "source")
source_el.set("qualifier", "none")
rights_state_el = SubElement(root, "dcvalue")
rights_state_el.set("element", "rights")
rights_state_el.set("qualifier", "rightsStatement")
if self.type == 'article':
is_part_of = SubElement(root, "dcvalue")
rights_state_el.set("element", "relation")
rights_state_el.set("qualifier", "isPartOf")
if self.type == 'volume':
is_format_of = SubElement(root, "dcvalue")
is_format_of.set("element", "relation")
is_format_of.set("qualifier", "isFormatOf")
source = SubElement(root, "dcvalue")
source.set("element", "source")
source.set("qualifier", "none")
def handle_xml(self, xml: Element) -> bytes:
""" Handles <get_version> command.
Return:
Response string for <get_version> command.
"""
protocol = Element('protocol')
for name, value in [
('name', 'OSP'),
('version', self._daemon.get_protocol_version()),
]:
elem = SubElement(protocol, name)
elem.text = value
daemon = Element('daemon')
for name, value in [
('name', self._daemon.get_daemon_name()),
('version', self._daemon.get_daemon_version()),
]:
elem = SubElement(daemon, name)
elem.text = value
scanner = Element('scanner')
for name, value in [
('name', self._daemon.get_scanner_name()),
('version', self._daemon.get_scanner_version()),
]:
elem = SubElement(scanner, name)
elem.text = value
content = [protocol, daemon, scanner]
vts_version = self._daemon.get_vts_version()
if vts_version:
vts = Element('vts')
elem = SubElement(vts, 'version')
elem.text = vts_version
content.append(vts)
return simple_response_str('get_version', 200, 'OK', content)
def generateDataSet(Set, descriptionText, versionText, kindText, serialText):
dataSet = SubElement(Set, 'DATA_SET')
description = SubElement(dataSet, 'COMMENT_DESCRIPTION')
description.text = descriptionText
version = SubElement(dataSet, 'VERSION')
version.text = versionText
part = SubElement(dataSet, "PART")
kind = SubElement(part, "KIND_OF_PART")
kind.text = kindText
serial = SubElement(part, "SERIAL_NUMBER")
serial.text = serialText
return dataSet
def _save_project(self, file_name):
""" Save the project to the given file. Raise a UserException if there
was an error.
"""
root = Element('Project', attrib={
'version': str(self.version),
'usingdefaultlocations': str(int(self.using_default_locations))})
attrib = {
'platformpython': ' '.join(self.python_use_platform),
'major': str(self.python_target_version[0]),
'minor': str(self.python_target_version[1]),
'patch': str(self.python_target_version[2])}
if not self.using_default_locations:
attrib['hostinterpreter'] = self.python_host_interpreter
attrib['sourcedir'] = self.python_source_dir
attrib['targetincludedir'] = self.python_target_include_dir
attrib['targetlibrary'] = self.python_target_library
attrib['targetstdlibdir'] = self.python_target_stdlib_dir
SubElement(root, 'Python', attrib=attrib)
application = SubElement(root, 'Application', attrib={
'entrypoint': self.application_entry_point,
'ispyqt5': str(int(self.application_is_pyqt5)),
'isconsole': str(int(self.application_is_console)),
'isbundle': str(int(self.application_is_bundle)),
'name': self.application_name,
'script': self.application_script,
'syspath': self.sys_path})
if self.qmake_configuration != '':
SubElement(application, 'QMakeConfiguration').text = self.qmake_configuration
if self.application_package.name is not None:
self._save_package(application, self.application_package)
for pyqt_module in self.pyqt_modules:
SubElement(root, 'PyQtModule', attrib={
'name': pyqt_module})
for stdlib_module in self.standard_library:
SubElement(root, 'StdlibModule', attrib={
'name': stdlib_module})
for target, external_libs in self.external_libraries.items():
for external_lib in external_libs:
SubElement(root, 'ExternalLib', attrib={
'target': target,
'name': external_lib.name,
'defines': external_lib.defines,
'includepath': external_lib.includepath,
'libs': external_lib.libs})
for package in self.other_packages:
self._save_package(root, package)
for extension_module in self.other_extension_modules:
SubElement(root, 'ExtensionModule', attrib={
'name': extension_module.name,
'qt': extension_module.qt,
'config': extension_module.config,
'sources': extension_module.sources,
'defines': extension_module.defines,
'includepath': extension_module.includepath,
'libs': extension_module.libs})
tree = ElementTree(root)
try:
tree.write(QDir.toNativeSeparators(file_name), encoding='utf-8',
xml_declaration=True)
except Exception as e:
raise UserException(
"There was an error writing the project file.", str(e))
self.modified = False
def generateXMLData6b(dataSetTag, vmon_equ_vltText, imon_equ_uaText,
vmon_g3b_vltText, imon_g3b_uaText, vmon_g3t_vltText,
imon_g3t_uaText, vmon_g2b_vltText, imon_g2b_uaText,
vmon_g2t_vltText, imon_g2t_uaText, vmon_g1b_vltText,
imon_g1b_uaText, vmon_g1t_vltText, imon_g1t_uaText,
vmon_drift_vltText, imon_drift_uaText):
data = SubElement(dataSetTag, 'DATA')
VMON_EQU_VLT = SubElement(data, 'VMON_EQU_VLT')
VMON_EQU_VLT.text = vmon_equ_vltText
IMON_EQU_UA = SubElement(data, 'IMON_EQU_UA')
IMON_EQU_UA.text = imon_equ_uaText
VMON_G3B_VLT = SubElement(data, 'VMON_G3B_VLT')
VMON_G3B_VLT.text = vmon_g3b_vltText
IMON_G3B_UA = SubElement(data, 'IMON_G3B_UA')
IMON_G3B_UA.text = imon_g3b_uaText
VMON_G3T_VLT = SubElement(data, 'VMON_G3T_VLT')
VMON_G3T_VLT.text = vmon_g3t_vltText
IMON_G3T_UA = SubElement(data, 'IMON_G3T_UA')
IMON_G3T_UA.text = imon_g3t_uaText
VMON_G2B_VLT = SubElement(data, 'VMON_G2B_VLT')
VMON_G2B_VLT.text = vmon_g2b_vltText
IMON_G2B_UA = SubElement(data, 'IMON_G2B_UA')
IMON_G2B_UA.text = imon_g2b_uaText
VMON_G2T_VLT = SubElement(data, 'VMON_G2T_VLT')
VMON_G2T_VLT.text = vmon_g2t_vltText
IMON_G2T_UA = SubElement(data, 'IMON_G2T_UA')
IMON_G2T_UA.text = imon_g2t_uaText
VMON_G1B_VLT = SubElement(data, 'VMON_G1B_VLT')
VMON_G1B_VLT.text = vmon_g1b_vltText
IMON_G1B_UA = SubElement(data, 'IMON_G1B_UA')
IMON_G1B_UA.text = imon_g1b_uaText
VMON_G1T_VLT = SubElement(data, 'VMON_G1T_VLT')
VMON_G1T_VLT.text = vmon_g1t_vltText
IMON_G1T_UA = SubElement(data, 'IMON_G1T_UA')
IMON_G1T_UA.text = imon_g1t_uaText
VMON_DRIFT_VLT = SubElement(data, 'VMON_DRIFT_VLT')
VMON_DRIFT_VLT.text = vmon_drift_vltText
IMON_DRIFT_UA = SubElement(data, 'IMON_DRIFT_UA')
IMON_DRIFT_UA.text = imon_drift_uaText
def generateXMLDatafastamb(dataSetTag, HumidityText):
data = SubElement(dataSetTag, 'DATA')
Humidity = SubElement(data, 'HUMIDITY_PERCENT')
Humidity.text = HumidityText
def generateXMLDataStandGeoConf(dataSetTag, ch_serialText, positionText,
flowmeterText, gemnumberText, chtypeText,
flipText, amcText, ohText):
data = SubElement(dataSetTag, 'DATA')
ch_serial_number = SubElement(data, 'CH_SERIAL_NUMBER')
ch_serial_number.text = ch_serialText
position = SubElement(data, 'POSITION')
position.text = positionText
flowmeter = SubElement(data, 'FLOW_METER')
flowmeter.text = flowmeterText
gemnumber = SubElement(data, 'GEM_NUMBER')
gemnumber.text = gemnumberText
chtype = SubElement(data, 'CH_TYPE')
chtype.text = chtypeText
flip = SubElement(data, 'FLIP')
flip.text = flipText
amc = SubElement(data, 'AMC')
amc.text = amcText
oh = SubElement(data, 'OH')
oh.text = ohText
def generateXMLData6c(dataSetTag, test_dateText, filenameText, elogText,
commentText):
data = SubElement(dataSetTag, 'DATA')
test_date = SubElement(data, 'TEST_DATE')
test_date.text = test_dateText
filename = SubElement(data, 'FILE_NAME')
filename.text = filenameText
elog = SubElement(data, 'ELOG_LINK')
elog.text = elogText
comment = SubElement(data, 'COMMENTS')
comment.text = commentText
def generateXMLDataQC8DeadStrips(dataSetTag, ch_serial_numberText,
gem_numberText, positionText, vfatText,
channelText, stripText):
data = SubElement(dataSetTag, 'DATA')
ch_serial_number = SubElement(data, 'CH_SERIAL_NUMBER')
ch_serial_number.text = ch_serial_numberText
gem_number = SubElement(data, 'GEM_NUMBER')
gem_number.text = gem_numberText
position = SubElement(data, 'POSITION')
position.text = positionText
vfat = SubElement(data, 'VFAT')
vfat.text = vfatText
channel = SubElement(data, 'CHANNEL')
channel.text = channelText
strip = SubElement(data, 'STRIP')
strip.text = stripText
def generateXMLData6a(dataSetTag, reqText):
data = SubElement(dataSetTag, 'DATA')
req = SubElement(data, 'REQUIV_MOHM_MSRD')
req.text = reqText
def generateXMLDataStrips(dataSetTag, sectorText, depthText, positionText,
chText, hot_chText, fit_failedText, dead_chText,
high_noiseText, high_effText):
data = SubElement(dataSetTag, 'DATA')
sector = SubElement(data, 'SECTOR')
sector.text = sectorText
depth = SubElement(data, 'DEPTH')
depth.text = depthText
position = SubElement(data, 'VFAT_POSN')
position.text = positionText
ch = SubElement(data, 'VFAT_CHAN')
ch.text = chText
hot_ch = SubElement(data, 'HOT_CHAN')
hot_ch.text = hot_chText
fit_failed = SubElement(data, 'FIT_FAILED')
fit_failed.text = fit_failedText
dead_ch = SubElement(data, 'DEAD_CHAN')
dead_ch.text = dead_chText
high_noise = SubElement(data, 'HIGH_NOISE')
high_noise.text = high_noiseText
high_eff = SubElement(data, 'HIGH_EFF_PED')
high_eff.text = high_effText
def generateXMLDataChVfatEfficiency(dataSetTag, vfat_posnText, efficiencyText,
efficiency_errorText, cluster_size_avgText,
cluster_size_sigmaText,
percent_maskedText):
data = SubElement(dataSetTag, 'DATA')
vfat_posn = SubElement(data, 'VFAT_POSN')
vfat_posn.text = vfat_posnText
efficiency = SubElement(data, 'EFFICIENCY')
efficiency.text = efficiencyText
efficiency_error = SubElement(data, 'EFFICIENCY_ERROR')
efficiency_error.text = efficiency_errorText
cluster_size_avg = SubElement(data, 'CLUSTER_SIZE_AVG')
cluster_size_avg.text = cluster_size_avgText
cluster_size_sigma = SubElement(data, 'CLUSTER_SIZE_SIGMA')
cluster_size_sigma.text = cluster_size_sigmaText
percent_masked = SubElement(data, 'PERCENT_MASKED')
percent_masked.text = percent_maskedText
def generateXMLData6s(dataSetTag, testperformText, VmaxText, CurrVmaxText,
VdrftText, ReqmsrdText, ReqslpText, diffText, sprsglText,
tripText, filenameText, elogText, commentText):
data = SubElement(dataSetTag, 'DATA')
testperform = SubElement(data, 'STARTING_TIME')
testperform.text = testperformText
Vmax = SubElement(data, 'ENDING_TIME')
Vmax.text = VmaxText
CurrVmax = SubElement(data, 'STABILITY_TIME_HR')
CurrVmax.text = CurrVmaxText
Vdrft = SubElement(data, 'STABILITY_VSET_VLT')
Vdrft.text = VdrftText
Reqmsrd = SubElement(data, 'STABILITY_VMON_VLT')
Reqmsrd.text = ReqmsrdText
Reqslp = SubElement(data, 'STABILITY_ISET_UA')
Reqslp.text = ReqslpText
diff = SubElement(data, 'STABILITY_IMON_UA')
diff.text = diffText
Sprsgl = SubElement(data, 'STABILITY_VDRFT_VLT')
Sprsgl.text = SprsglText
trip = SubElement(data, 'TRIP_TIME_SEC')
trip.text = tripText
filename = SubElement(data, 'FILE_NAME')
filename.text = filenameText
elog = SubElement(data, 'ELOG_LINK')
elog.text = elogText
comment = SubElement(data, 'COMMENTS')
comment.text = commentText
def generateXMLDataAlignment(dataSetTag, positionText, dxText, dyText, dzText,
rxText, ryText, rzText):
data = SubElement(dataSetTag, 'DATA')
position = SubElement(data, 'POSITION')
position.text = positionText
dx = SubElement(data, 'DX')
dx.text = dxText
dy = SubElement(data, 'DY')
dy.text = dyText
dz = SubElement(data, 'DZ')
dz.text = dzText
rx = SubElement(data, 'RX')
rx.text = rxText
ry = SubElement(data, 'RY')
ry.text = ryText
rz = SubElement(data, 'RZ')
rz.text = rzText
