def __init__(self, filename, shortXMLfilename):
self.filename = filename
self.shortXMLfilename = shortXMLfilename
try:
self.tableFile = parse(filename)
except:
impl = getDOMImplementation()
self.tableFile = impl.createDocument(None, "table", None)
self.tableFile.getElementsByTagName("table")[0].setAttribute("class", "sortable")
self.tableFile.getElementsByTagName("table")[0].setAttribute("id", "xeplist")
self.tableFile.getElementsByTagName("table")[0].setAttribute("cellspacing", "0")
self.tableFile.getElementsByTagName("table")[0].setAttribute("cellpadding", "3")
self.tableFile.getElementsByTagName("table")[0].setAttribute("border", "1")
header = parseString(
'''<tr class='xepheader'>
<th align='left'>Number</th>
<th align='left'>Name</th>
<th align='left'>Type</th>
<th align='left'>Status</th>
<th align='left'>Date</th>
</tr>''')
self.tableFile.getElementsByTagName("table")[0].appendChild(header.getElementsByTagName("tr")[0])
try:
self.botsFile = parse(shortXMLfilename)
except:
impl = getDOMImplementation()
self.botsFile = impl.createDocument(None, "xeps", None)
def test_create_sliver(server, slice_urn, slice_credential, dom, api_version=2):
if api_version < 3:
print "Testing CreateSliver...",
else:
print "Testing Allocate...",
options = None
if api_version >= 2:
options = dict()
# FIXME: Build up a request_rspec for real
nodes = dom.getElementsByTagName("node")
dom_impl = minidom.getDOMImplementation()
request_rspec = dom_impl.createDocument("http://www.geni.net/resources/rspec/3", "rspec", None)
top = request_rspec.documentElement
top.setAttribute("xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance")
top.setAttribute(
"xsi:schemaLocation",
"http://www.geni.net/resources/rspec/3 http://www.geni.net/resources/rspec/3/request.xsd",
)
top.setAttribute("xmlns", "http://www.geni.net/resources/rspec/3")
top.setAttribute("type", "request")
if nodes.length == 0:
print "failed: no nodes available"
return
elif nodes.length == 1:
top.appendChild(nodes.item(0).cloneNode(True))
else:
# pick two at random
indices = range(nodes.length)
for _ in range(2):
index = random.choice(indices)
indices.remove(index)
top.appendChild(nodes.item(index).cloneNode(True))
else:
resources = dom.getElementsByTagName("resource")
dom_impl = minidom.getDOMImplementation()
request_rspec = dom_impl.createDocument(None, "rspec", None)
top = request_rspec.documentElement
if resources.length == 0:
print "failed: no resources available"
return
elif resources.length == 1:
top.appendChild(resources.item(0).cloneNode(True))
else:
# pick two at random
indices = range(resources.length)
for _ in range(2):
index = random.choice(indices)
indices.remove(index)
top.appendChild(resources.item(index).cloneNode(True))
users = [{"key": ""}]
if options is not None:
try:
if api_version < 3:
result = server.CreateSliver(slice_urn, slice_credential, request_rspec.toxml(), users, options)
else:
result = server.Allocate(slice_urn, slice_credential, request_rspec.toxml(), options)
except Exception, e:
print "failed: %s" % e
return
def __init__(self, document=None, node=None, root=None):
self.document = document
if self.document is None and node is not None:
impl = minidom.getDOMImplementation()
self.resource = impl.createDocument(None, None, None)
self.resource.appendChild(node)
elif self.document is None:
impl = minidom.getDOMImplementation()
self.resource = impl.createDocument(None, root, None)
def Load(self,file,type):
if os.path.exists(file):
source=open(file)
try:
dom1=minidom.parse(source)
except:
impl=minidom.getDOMImplementation()
dom1=impl.createDocument(None,type,None)
return dom1
else:
impl=minidom.getDOMImplementation()
doc=impl.createDocument(None, type,None)
return doc
def makeLibrary(self, monomers, curatedonly=True):
self.child.all().delete()
if not self.construct.processed:
for j in self.construct.process():
pass
impl = getDOMImplementation()
xml = impl.createDocument(None, 'nrp', None)
root = xml.documentElement
monomersnode = xml.createElement('monomers')
varpos = -1
i = 0
for monomer in monomers:
monomernode = xml.createElement('monomer')
if len(monomer) > 1:
varpos = i
i += 1
for aa in monomer:
idnode = xml.createElement("id")
aanode = xml.createTextNode(str(aa))
idnode.appendChild(aanode)
monomernode.appendChild(idnode)
monomersnode.appendChild(monomernode)
root.appendChild(monomersnode)
nrpsnode = xml.createElement('nrps')
domains = self.getDomainSequence()
for domain in domains:
domainnode = xml.createElement('domain')
idnode = xml.createElement('id')
idtext = xml.createTextNode(str(domain))
idnode.appendChild(idtext)
domainnode.appendChild(idnode)
nrpsnode.appendChild(domainnode)
root.appendChild(nrpsnode)
xmlstr = xml.toxml("utf-8")
args = ['-n', '-', '-s', '-']
if curatedonly:
args.extend(["--curated-only", "--curation-group", settings.CURATION_GROUP])
xmlout = self._runNrpsDesigner(args, xmlstr)
designerDom = parseString(xmlout)
nrpsList = designerDom.getElementsByTagName('s:component')
i = 1
for nrps in nrpsList:
description = self.description
if description is not None and len(description) > 0:
description += "\n"
varname = Substrate.objects.get(pk=monomers[varpos][i]).name
nrp = NRP.objects.create(owner = self.owner, name="%s %s" % (self.name, varname), description=description + "library variant %d: %s" % (i, varname), indigoidineTagged=self.indigoidineTagged, parent=self)
for j, monomerId in enumerate(monomers):
index = 0
if j == varpos:
index = i
monomer = Substrate.objects.get(pk=monomerId[index])
SubstrateOrder.objects.create(nrp=nrp, substrate=monomer, order=j)
nrp._design(self._parseNrps(nrps))
for j,cf in enumerate(self.construct.cf.order_by('order')):
if cf.fragment.origin != 'ND':
nrp.construct.add_fragment(cf.fragment, j, cf.direction)
for j in nrp.construct.process():
pass
i += 1
def build_xml(self):
impl = minidom.getDOMImplementation()
self.doc = impl.createDocument(None, "updates", None)
updates = self.doc.documentElement
update = self.doc.createElement("update")
updates.appendChild(update)
update.setAttribute("type", self.update_type)
update.setAttribute("appVersion", self.app_version)
update.setAttribute("version", self.platform_version)
update.setAttribute("buildID", self.build_id)
update.setAttribute("licenseURL", self.license_url)
update.setAttribute("detailsURL", self.details_url)
if self.is_fota_update:
update.setAttribute("isOSUpdate", "true")
if self.complete_mar:
complete_patch = self.build_patch("complete", self.complete_mar)
update.appendChild(complete_patch)
if self.partial_mar:
partial_patch = self.build_patch("partial", self.partial_mar)
update.appendChild(partial_patch)
return self.doc.toprettyxml()
def generate_cobertura_xml(coverage_data, options):
'''Given a list of lines of lcov input, return a String cobertura XML
representation'''
dom_impl = minidom.getDOMImplementation()
doctype = dom_impl.createDocumentType("coverage", None, "http://cobertura.sourceforge.net/xml/coverage-03.dtd")
document = dom_impl.createDocument(None, "coverage", doctype)
root = document.documentElement
summary = coverage_data['summary']
root.setAttribute('branch-rate', '0')
root.setAttribute('branches-covered', '0')
root.setAttribute('branches-valid', '0')
root.setAttribute('complexity', '0')
root.setAttribute('line-rate', compute_line_rate(summary['lines-total'], summary['lines-covered']))
root.setAttribute('lines-valid', str(summary['lines-total']))
root.setAttribute('timestamp', str(int(time.time())))
root.setAttribute('version', '1.9')
sources = document.createElement('sources')
root.appendChild(sources)
packages_element = document.createElement('packages')
packages = coverage_data['packages']
for package_name, package_data in packages.items():
# TODO: make more robust
if package_name in options.excludes:
continue
package_element = document.createElement('package')
package_element.setAttribute('line-rate', package_data['line-rate'])
package_element.setAttribute('name', package_name)
classes_element = document.createElement('classes')
for class_name, class_data in package_data['classes'].items():
class_element = document.createElement('class')
class_element.setAttribute('branch-rate', '0')
class_element.setAttribute('complexity', '0')
class_element.setAttribute('filename', class_name)
class_element.setAttribute('line-rate', compute_line_rate(class_data['lines-total'], class_data['lines-covered']))
class_element.setAttribute('name', class_data['name'])
lines_element = document.createElement('lines')
lines = class_data['lines'].keys()
lines.sort()
for line_number in lines:
line_element = document.createElement('line')
line_element.setAttribute('branch', '0')
line_element.setAttribute('hits', str(class_data['lines'][line_number]))
line_element.setAttribute('number', str(line_number))
lines_element.appendChild(line_element)
class_element.appendChild(lines_element)
classes_element.appendChild(class_element)
package_element.appendChild(classes_element)
packages_element.appendChild(package_element)
root.appendChild(packages_element)
return document.toprettyxml()
def models_to_xml(self, request, model_name, model_handler, models,
list_props=None):
"""Returns a string of xml of the given models (may be list or
single instance)."""
impl = minidom.getDOMImplementation()
doc = None
try:
if isinstance(models, (types.ListType, types.TupleType)):
doc = impl.createDocument(None, LIST_EL_NAME, None)
list_el = doc.documentElement
if ((list_props is not None) and \
(list_props.has_key(QUERY_OFFSET_PARAM))):
list_el.attributes[QUERY_OFFSET_PARAM] = \
list_props[QUERY_OFFSET_PARAM]
for model in models:
model_el = append_child(list_el, model_name)
model_handler.write_xml_value(model_el, model)
else:
doc = impl.createDocument(None, model_name, None)
model_handler.write_xml_value(doc.documentElement, models)
return self.doc_to_output(request, doc)
finally:
if doc:
doc.unlink()
def generate(self, fileName):
# Once all records have been calculated, create the XML structure itself
self.document = getDOMImplementation().createDocument(None, 'data', None)
topNode = self.document.documentElement
for record in self.data['records']:
recordNode = self.document.createElement('record')
topNode.appendChild( recordNode )
for field, value in record.iteritems():
fieldNode = self.document.createElement( field )
recordNode.appendChild( fieldNode )
# The rest of field types must be converted into str
if value == False:
value = ''
elif isinstance(value, str):
value = unicode(value, 'utf-8')
elif not isinstance(value, unicode):
value = unicode(value)
valueNode = self.document.createTextNode( value )
fieldNode.appendChild( valueNode )
# Once created, the only missing step is to store the XML into a file
f = codecs.open( fileName, 'wb+', 'utf-8' )
try:
topNode.writexml( f )
finally:
f.close()
def metadata(self, request, model_name=None):
impl = minidom.getDOMImplementation()
doc = None
try:
if model_name:
model_handler = self.get_model_handler(model_name)
if(not model_handler):
return None
self.check_authority(request, OP_LIST, obj=None,
model_name=model_name, prop_name=None)
doc = impl.createDocument(XSD_NS, XSD_SCHEMA_NAME, None)
doc.documentElement.attributes[XSD_ATTR_XMLNS] = XSD_NS
model_handler.write_xsd_metadata(doc.documentElement,
model_name)
else:
self.check_authority(request, OP_LIST, obj=None,
model_name=None, prop_name=None)
doc = impl.createDocument(None, TYPES_EL_NAME, None)
types_el = doc.documentElement
for model_name in self.model_handlers.iterkeys():
append_child(types_el, TYPE_EL_NAME, model_name)
output = self.doc_to_output(request, doc)
finally:
if doc:
doc.unlink()
return self.out_to_response(output)
def save(self):
"""Writes the current contact list, group, and contact state out to a
new contacts file.
"""
print "Connection - save"
dom_impl = minidom.getDOMImplementation()
xml_doc = dom_impl.createDocument(None, 'roster', None)
roster_xml = xml_doc.documentElement
# add newline for human-readability
newline_value = xml_doc.createTextNode('\n')
roster_xml.appendChild(newline_value)
contact_channels_map = self.get_contact_channel_membership_info()
for handle_obj, lists_groups in contact_channels_map.items():
contact_lists, groups = lists_groups
contact_xml = handle_obj.get_xml(contact_lists, groups)
roster_xml.appendChild(contact_xml)
# add newline for human-readability
newline_value = xml_doc.createTextNode('\n\n')
roster_xml.appendChild(newline_value)
account_id = self.get_account_id()
pin.common.save_roster(xml_doc, account_id)
def __init__(self):
impl = getDOMImplementation()
self.doc = impl.createDocument(None, 'urlset', None)
self.urlset = self.doc.documentElement
self.urlset.setAttribute('xmlns',
'http://www.sitemaps.org/schemas/sitemap/0.9')
def toDom(self):
doc = getDOMImplementation().createDocument("http://info.teragrid.org/glue/2009/02/spec_2.0_r02",
"Entities",None)
for share in self.data.shares:
sdoc = ComputingShareTeraGridXml(share).toDom()
doc.documentElement.appendChild(sdoc.documentElement.firstChild)
return doc
def __init__(self, filename=""):
super(DMPlaylist, self).__init__()
self.document = parse(filename) if filename \
else getDOMImplementation().createDocument(None,
"DMPlaylist", None)
self._categories = []
self._items = []
for node in self.document.documentElement.childNodes:
if hasattr(node, "tagName"):
if node.tagName == TAG_CATEGORY:
category = DMPlaylistCategory(self.document,
node.getAttribute("name"))
for child in node.childNodes:
if hasattr(child, "tagName"):
childName = "".join(map(lambda x: x.data.strip(),
child.childNodes))
item = DMPlaylistItem(self.document,
childName,
child.getAttribute("source"),
child.getAttribute("played"))
category._items.append(item)
self._categories.append(category)
elif node.tagName == TAG_ITEM:
childName = "".join(map(lambda x: x.data.strip(),
node.childNodes))
item = DMPlaylistItem(self.document,
childName,
node.getAttribute("source"),
node.getAttribute("played"))
self._items.append(item)
def BeginTemplate(self):
'''Generates the skeleton of the ADMX template. An ADMX template contains
an ADMX "PolicyDefinitions" element with four child nodes: "policies"
"policyNamspaces", "resources", "supportedOn" and "categories"
'''
dom_impl = minidom.getDOMImplementation('')
self._doc = dom_impl.createDocument(None, 'policyDefinitions', None)
policy_definitions_elem = self._doc.documentElement
policy_definitions_elem.attributes['revision'] = '1.0'
policy_definitions_elem.attributes['schemaVersion'] = '1.0'
self._AddPolicyNamespaces(policy_definitions_elem,
self.config['admx_prefix'],
self.config['admx_namespace'])
self.AddElement(policy_definitions_elem, 'resources',
{'minRequiredRevision' : '1.0'})
self._AddSupportedOn(policy_definitions_elem,
self.config['win_supported_os'])
self._categories_elem = self.AddElement(policy_definitions_elem,
'categories')
self._AddCategories(self.config['win_mandatory_category_path'])
self._AddCategories(self.config['win_recommended_category_path'])
self._active_policies_elem = self.AddElement(policy_definitions_elem,
'policies')
self._active_mandatory_policy_group_name = \
self.config['win_mandatory_category_path'][-1]
self._active_recommended_policy_group_name = \
self.config['win_recommended_category_path'][-1]
def makeRequest(self, params):
"""Create and serialise SOAP envelope from a DOM document"""
global NS
impl = minidom.getDOMImplementation()
self.requestDoc = impl.createDocument(self.targetNs, "soap:Envelope", None)
setDocAttr = self.requestDoc.documentElement.setAttribute
setDocAttr("xmlns:soap", NS["soap"])
for name, value in self.requestNamespaces.iteritems():
setDocAttr("xmlns:" + name, value)
setDocAttr("xmlns", self.targetNs)
# create header
if len(self._headers):
header = self.requestDoc.createElementNS(NS["soap"], "soap:Header")
self.addLiteral(self.requestDoc, header, self._headers)
self.requestDoc.documentElement.appendChild(header)
# and body
body = self.requestDoc.createElementNS(NS["soap"], "soap:Body")
self.requestDoc.documentElement.appendChild(body)
operation = self.requestDoc.createElement(self.name)
if type(params) == dict:
self.addLiteral(self.requestDoc, operation, params)
body.appendChild(operation)
return self.requestDoc.toxml()
def Generate(self):
"""Creates font a DOM with data for every table.
Uses |table_data_generators| to plug in XML generators.
Returns:
A DOM ready for serialization.
"""
doc = minidom.getDOMImplementation().createDocument(None,
'font_test_data', None)
root_element = doc.documentElement
# We need to set the path of the font as if in the root source directory
# The assumption is that we have a '../' prefix
root_element.setAttribute('path', self.font_path[3:])
h = hashlib.new('sha1')
h.update(open(self.font_path, 'r').read())
root_element.setAttribute('sha1', h.hexdigest())
font = ttLib.TTFont(self.font_path)
# There is always a postscript name for Windows_BMP
name_record = font['name'].getName(6, 3, 1)
root_element.setAttribute('post_name',
self.Unpack(name_record.string))
for (name, table_data_generator) in self.table_data_generators:
name += '_table'
table_element = doc.createElement(name)
root_element.appendChild(table_element)
table_data_generator.Generate(font, doc, table_element)
return doc
def set_event_command(self, event, command, config=None, create_new=True):
cfg_nodes = self.root_node.getElementsByTagName("ItemDefinitionGroup")
for cfg_node in cfg_nodes:
if config is not None:
if 'Condition' not in cfg_node.attributes.keys():
continue
cond_attr = cfg_node.attributes["Condition"].value
if cond_attr.lower().find("debug") >= 0:
cur_mode = "Debug"
else:
cur_mode = "Release"
if cur_mode.lower() != config.lower():
continue
event_node = self.get_or_create_node(cfg_node, event, create_new)
if event_node is None:
continue
cmd_node = self.get_or_create_node(event_node, "Command")
if cmd_node.firstChild is None:
impl = minidom.getDOMImplementation()
dom = impl.createDocument(None, 'catalog', None)
nodeValue = dom.createTextNode(command)
cmd_node.appendChild(nodeValue)
else:
cmd_node.firstChild.nodeValue = command
def run(self, test):
std_out = sys.stdout
std_err = sys.stderr
sys.stdout = StringIO()
sys.stderr = StringIO()
"Run the given test case or test suite."
result_xml = getDOMImplementation().createDocument(None, 'testsuites', None)
result = _OpusXMLTestResult(result_xml, self.descriptions, self.verbosity)
startTime = time.time()
test(result)
stopTime = time.time()
timeTaken = stopTime - startTime
result.printErrors()
run = result.testsRun
failed, errored = map(len, (result.failures, result.errors))
top_element = result_xml.documentElement
top_element.setAttribute('errors', '%d' % errored)
top_element.setAttribute('failures', '%d' % failed)
top_element.setAttribute('tests', '%d' % run)
top_element.setAttribute('time', '%.3f' % timeTaken)
stream_xml = result_xml.createElement('system-out')
stream_text_xml = result_xml.createTextNode('%s' % sys.stdout.getvalue())
stream_xml.appendChild(stream_text_xml)
top_element.appendChild(stream_xml)
stream_xml = result_xml.createElement('system-err')
stream_text_xml = result_xml.createTextNode('%s' % sys.stderr.getvalue())
stream_xml.appendChild(stream_text_xml)
top_element.appendChild(stream_xml)
self.stream.write(result_xml.toprettyxml())
sys.stdout = std_out
sys.stderr = std_err
return result
def save(config={}, filename=DEFAULT_CONFIG_FILE):
impl = getDOMImplementation()
dom = impl.createDocument(None, "server", impl.createDocumentType('server', None, "../xml/server.dtd"))
dserver = dom.documentElement
dconfig = dom.createElement('config')
for sec,key in CONFIG_ITEMS:
if config[sec]:
ditem = dom.createElement(sec)
ditem.setAttribute(key, config[sec])
dconfig.appendChild(ditem)
dserver.appendChild(dconfig)
dauth = dom.createElement('auth')
users = config['users']
if users:
for user in users:
if not users.get(user):
print "[WARNING] User %s has no password" % user
duser = dom.createElement('user')
duser.setAttribute('name', user)
duser.setAttribute('password', users.get(user))
dauth.appendChild(duser)
dserver.appendChild(dauth)
configFile = file(DEFAULT_CONFIG_FILE, 'w')
dom.writexml(configFile, addindent=' ', newl='\n', encoding='UTF-8')
configFile.close()
def citiesCode():
impl = minidom.getDOMImplementation()
dom = impl.createDocument(None, 'CitiesCode', None)
rootNode = dom.documentElement
provinces = getCitiesCode.getProCode() #获取省编号
for pro in provinces:
province = dom.createElement('province')
province.setAttribute('id', pro.split('|')[0])
province.setAttribute('name', pro.split('|')[1])
cities = getCitiesCode.getCityCode(pro.split('|')[0]) #获取市编号
for ci in cities:
city = dom.createElement('city')
city.setAttribute('id', ci.split('|')[0])
city.setAttribute('name', ci.split('|')[1])
areas = getCitiesCode.getAreaCode(ci.split('|')[0])
for ar in areas:
area = dom.createElement('area')
area.setAttribute('id', ar.split('|')[0])
area.setAttribute('name', ar.split('|')[1])
city.appendChild(area)
province.appendChild(city)
rootNode.appendChild(province)
writeXML(dom, '../xml/CitiesCode.xml')
def request_frame_document(self, message):
frame = self.message_frame_dict[message]
doc = getDOMImplementation().createDocument(None, "stack", None)
top_element = doc.documentElement
if frame:
self.addFrame(frame, top_element, doc, includeContent=True)
return xmlrpclib.Binary(bz2.compress(doc.toxml()))
def DoTrackX(rgm, args):
if len(args) != 1:
return DoHelp(rgm, args)
info = rgm.GetInfo()
_, _, _, _, _, _, _, tracks, _ = info
range_iter = ParseRange(args[0], 0, tracks-1)
if not range_iter:
return DoHelp(rgm, args)
gpxdoc = minidom.getDOMImplementation().createDocument(
'http://www.topografix.com/GPX/1/1', 'gpx', None)
e_gpx = gpxdoc.documentElement
e_gpx.setAttribute('version', '1.1')
e_gpx.setAttribute('creator', 'rgm3800py')
e_trk = gpxdoc.createElement('trk')
e_gpx.appendChild(e_trk)
for i in range_iter:
e_trkseg = gpxdoc.createElement('trkseg')
e_trk.appendChild(e_trkseg)
waypoints = rgm.GetWaypoints(i)
for wp in waypoints:
e_trkseg.appendChild(wp.GetGPXTrackPT(gpxdoc))
print gpxdoc.toxml()
return 0
def xml_document(top):
# First, make the header
impl = getDOMImplementation()
xml = impl.createDocument(None, top, None)
top = xml.documentElement
return xml, top
def __init__(self, samplerate, nframes, wavpath):
"""Init a sonic visualiser environment structure based on
the attributes of the main audio file
Args:
samplerate(int): media sample rate (Hz)
nframes(int): number of samples
wavpath(str): Full path to the wav file used in the current environment
"""
imp = minidom.getDOMImplementation()
dt = imp.createDocumentType('sonic-visualiser', None, None)
self.doc = doc = imp.createDocument(None,'sv', dt)
root = doc.documentElement
self.__dname = dict()
self.data = root.appendChild(doc.createElement('data'))
self.display = root.appendChild(doc.createElement('display'))
window = self.display.appendChild(doc.createElement('window'))
self.defwidth = 900
window.setAttribute('width', str(self.defwidth))
window.setAttribute('height', str(856))
self.selections = root.appendChild(doc.createElement('selections'))
self.nbdata = 0
#self.nchannels = nchannels
self.samplerate = samplerate
self.nframes = nframes
self.__setMainWaveModel(wavpath)
def to_xml(self):
"""
Turn this into an XML
document
"""
impl = getDOMImplementation()
doc = impl.createDocument(None, 'Exception', None)
rootNode = doc.documentElement
type_node = doc.createElement("type")
text_node = doc.createTextNode(self.__class__.__name__)
type_node.appendChild(text_node)
rootNode.appendChild(type_node)
type_node = doc.createElement("code")
text_node = doc.createTextNode(str(self.code))
type_node.appendChild(text_node)
rootNode.appendChild(type_node)
type_node = doc.createElement("message")
text_node = doc.createTextNode(self.message)
type_node.appendChild(text_node)
rootNode.appendChild(type_node)
type_node = doc.createElement("description")
text_node = doc.createTextNode(self.description)
type_node.appendChild(text_node)
rootNode.appendChild(type_node)
return doc
def generate(self, fileName):
self.allRecords = []
relations = self.report.relations()
# The following loop generates one entry to allRecords list for each record
# that will be created. If there are any relations it acts like a
# LEFT JOIN against the main model/table.
for record in self.pool.get(self.model).browse(self.cr, self.uid, self.ids, self.context):
newRecords = self.generateIds( record, relations, '', [ { 'root': record } ] )
copies = 1
if self.report.copiesField() and record.__hasattr__(self.report.copiesField()):
copies = int( record.__getattr__(self.report.copiesField()) )
for new in newRecords:
for x in xrange(copies):
self.allRecords.append( new )
# Once all records have been calculated, create the XML structure itself
self.document = getDOMImplementation().createDocument(None, 'data', None)
topNode = self.document.documentElement
for records in self.allRecords:
recordNode = self.document.createElement('record')
topNode.appendChild( recordNode )
self.generateXmlRecord( records['root'], records, recordNode, '', self.report.fields() )
# Once created, the only missing step is to store the XML into a file
f = codecs.open( fileName, 'wb+', 'utf-8' )
try:
topNode.writexml( f )
finally:
f.close()
def __init__(self, cls, db_name, db_user, db_passwd,
db_host, db_port, db_table, ddl_dir, enable_ssl):
self.cls = cls
if not db_name:
db_name = cls.__name__.lower()
self.db_name = db_name
self.db_user = db_user
self.db_passwd = db_passwd
self.db_host = db_host
self.db_port = db_port
self.db_table = db_table
self.ddl_dir = ddl_dir
self.s3 = None
self.converter = XMLConverter(self)
self.impl = getDOMImplementation()
self.doc = self.impl.createDocument(None, 'objects', None)
self.connection = None
self.enable_ssl = enable_ssl
self.auth_header = None
if self.db_user:
import base64
base64string = base64.encodestring('%s:%s' % (self.db_user, self.db_passwd))[:-1]
authheader = "Basic %s" % base64string
self.auth_header = authheader
def save(self):
"""
_save_
Serialise this to XML compatible with PhEDEx injection
"""
impl = getDOMImplementation()
doc = impl.createDocument(None, "block", None)
result = doc.createElement("block")
result.setAttribute('name', self.fileblockName)
result.setAttribute('is-open', self.isOpen)
for lfn, checksums, size in self:
# checksums is a comma separated list of key:value pair
formattedChecksums = ",".join(["%s:%s" % (x.lower(), y) for x, y \
in checksums.items() \
if y not in (None, '')])
ifile = doc.createElement("file")
ifile.setAttribute('name', lfn)
ifile.setAttribute('checksum', formattedChecksums)
ifile.setAttribute('bytes', str(size))
result.appendChild(ifile)
return result
def _initEmptyManifest(self):
self.doc = xml.getDOMImplementation().createDocument(None, 'manifest', None)
root = self.doc.documentElement
root.setAttribute('xmlns:android', 'http://schemas.android.com/apk/res/android')
root.setAttribute('package', 'prj.chameleon.entry')
applicationDoc = self.doc.createElement('application')
root.appendChild(applicationDoc)
def createXML(self, frame_count):
implementation = getDOMImplementation()
document = implementation.createDocument(None, None, None)
annotation = document.createElement("annotation")
document.appendChild(annotation)
folder = document.createElement("folder")
folder.appendChild(document.createTextNode("JPEGImages"))
annotation.appendChild(folder)
filename = document.createElement("filename")
filename.appendChild(
document.createTextNode(fileName + "_" + str(frame_count)))
annotation.appendChild(filename)
path = document.createElement("path")
path.appendChild(
document.createTextNode(
"C:/AIoT/Projects/keras-yolo3-master/VOCdevkit/VOC2007/JPEGImages/"
+ fileName + "_%d.jpg" % frame_count))
annotation.appendChild(path)
source = document.createElement("source")
annotation.appendChild(source)
database = document.createElement("database")
database.appendChild(document.createTextNode("Unknown"))
source.appendChild(database)
size = document.createElement("size")
annotation.appendChild(size)
width = document.createElement("width")
width.appendChild(document.createTextNode("1920"))
size.appendChild(width)
height = document.createElement("height")
height.appendChild(document.createTextNode("1080"))
size.appendChild(height)
depth = document.createElement("depth")
depth.appendChild(document.createTextNode("3"))
size.appendChild(depth)
segmented = document.createElement("segmented")
segmented.appendChild(document.createTextNode("0"))
annotation.appendChild(segmented)
tup_list = self.dict.get(frame_count)
for tup in tup_list:
object = document.createElement("object")
annotation.appendChild(object)
name = document.createElement("name")
name.appendChild(document.createTextNode("person"))
object.appendChild(name)
pose = document.createElement("pose")
pose.appendChild(document.createTextNode("Unspecified"))
object.appendChild(pose)
truncated = document.createElement("truncated")
truncated.appendChild(document.createTextNode("0"))
object.appendChild(truncated)
difficult = document.createElement("difficult")
difficult.appendChild(document.createTextNode("0"))
object.appendChild(difficult)
bndbox = document.createElement("bndbox")
object.appendChild(bndbox)
xmin = document.createElement("xmin")
xmin.appendChild(document.createTextNode(tup[3]))
bndbox.appendChild(xmin)
ymin = document.createElement("ymin")
ymin.appendChild(document.createTextNode(tup[2]))
bndbox.appendChild(ymin)
xmax = document.createElement("xmax")
xmax.appendChild(document.createTextNode(tup[1]))
bndbox.appendChild(xmax)
ymax = document.createElement("ymax")
ymax.appendChild(document.createTextNode(tup[0]))
bndbox.appendChild(ymax)
out = open(xml_save_path + "/" + fileName + "_%d.xml" % frame_count,
"w")
document.writexml(out, '', '\t', '\n')
print("Save xml: " + fileName + "_%d.xml" % frame_count)
def export_to_xml(self, path, names_to_labels, imagecontainer):
impl = minidom.getDOMImplementation()
ann = self._annotations
for plateid in ann:
# load plate specific meta data
imagecontainer.set_plate(plateid)
meta_data = imagecontainer.get_meta_data()
time_points = meta_data.times
# the reference time on which this file is based on
min_time = time_points[0]
for position in ann[plateid]:
ann2 = ann[plateid][position]
bycn = OrderedDict()
for time in ann2:
for cn in ann2[time]:
if not cn in bycn:
bycn[cn] = OrderedDict()
bycn[cn][time] = ann2[time][cn]
doc = impl.createDocument(None, 'CellCounter_Marker_File', None)
top = doc.documentElement
element = doc.createElement('Marker_Data')
top.appendChild(element)
idx_base = time_points.index(min_time)
for cn in bycn:
element2 = doc.createElement('Marker_Type')
element.appendChild(element2)
element3 = doc.createElement('Type')
class_label = names_to_labels[cn]
text = doc.createTextNode(str(class_label))
element3.appendChild(text)
element2.appendChild(element3)
for time in bycn[cn]:
idx = time_points.index(time) + 1 - idx_base
for item in bycn[cn][time]:
element3 = doc.createElement('Marker')
element4 = doc.createElement('MarkerX')
text = doc.createTextNode(str(item[0]))
element4.appendChild(text)
element3.appendChild(element4)
element4 = doc.createElement('MarkerY')
text = doc.createTextNode(str(item[1]))
element4.appendChild(text)
element3.appendChild(element4)
element4 = doc.createElement('MarkerZ')
text = doc.createTextNode(str(idx))
element4.appendChild(text)
element3.appendChild(element4)
element2.appendChild(element3)
filename = 'PL%s___P%s___T%05d.xml' % \
(plateid, position, min_time)
f = file(os.path.join(path, filename), 'w')
doc.writexml(f, indent=' ', addindent=' ', encoding='utf8',
newl='\n')
f.close()
def convert(stats, epg, epgfile):
impl = miniDom.getDOMImplementation()
dcmnt = impl.createDocument(None, u'tv', None)
root = dcmnt.documentElement
# create channels
for stat in stats:
if stats[0] == "webik":
continue
channNode = dcmnt.createElement(u'channel')
displNode = dcmnt.createElement(u'display-name')
displText = dcmnt.createTextNode(stat[1])
displNode.appendChild(displText)
displNode.setAttribute('lang', 'cs')
channNode.appendChild(displNode)
channNode.setAttribute('id', stat[0])
root.appendChild(channNode)
# create programms
for stat in stats:
if stat[0] == "webik":
continue
# load data of one channel to temporary list
tmpday = []
for day in epg:
for item in day[stat[0]]:
tmpprog = {}
tmpprog['title'] = item['title']
tmpprog['description'] = item['description']
if 'edition' in item and 'asset' in item['edition']:
tmpprog['icon'] = item['edition']['asset']
tmpprog['start'] = item['since']
tmpprog['stop'] = item['till']
tmpday.append(tmpprog)
# check and repair time continuity
tmpday2 = []
flag = False
for i in range(len(tmpday)):
if flag:
flag = False
continue
if i < len(tmpday) - 2:
# if tmpday[i]['start'] == tmpday[i + 1]['start']:
# flag = True
# if tmpday[i]['stop'] > tmpday[i + 1]['stop']:
# tmpday2.append(tmpday[i])
# continue
# elif tmpday[i]['stop'] < tmpday[i + 1]['stop']:
# tmpday2.append(tmpday[i + 1])
# continue
if tmpday[i]['start'] <= tmpday[i + 1]['start']:
if tmpday[i]['stop'] > tmpday[i + 1]['stop']:
flag = True
tmpday2.append(tmpday[i])
continue
if tmpday[i]['stop'] > tmpday[i + 1]['start']:
flag = True
tmpday2.append(tmpday[i])
continue
elif tmpday[i]['start'] >= tmpday[i + 1]['start']:
if tmpday[i]['stop'] < tmpday[i + 1]['stop']:
flag = True
tmpday2.append(tmpday[i+1])
continue
if tmpday[i]['start'] < tmpday[i + 1]['stop']:
flag = True
tmpday2.append(tmpday[i + 1])
continue
if tmpday2 and tmpday[i]['start']>=tmpday2[-1]['start'] and tmpday[i]['stop']<=tmpday2[-1]['stop']:
continue
tmpday2.append(tmpday[i])
for item in tmpday2:
prgNode = dcmnt.createElement(u'programme')
titleNode = dcmnt.createElement(u'title')
titleText = dcmnt.createTextNode(item['title'])
titleNode.appendChild(titleText)
titleNode.setAttribute('lang', 'cs')
prgNode.appendChild(titleNode)
descNode = dcmnt.createElement(u'desc')
descText = dcmnt.createTextNode(item['description'])
descNode.appendChild(descText)
descNode.setAttribute('lang', 'cs')
prgNode.appendChild(descNode)
if 'icon' in item:
iconNode = dcmnt.createElement(u'icon')
iconNode.setAttribute('src', item['icon'])
prgNode.appendChild(iconNode)
prgNode.setAttribute('start', convertTime(item['start']))
prgNode.setAttribute('stop', convertTime(item['stop']))
prgNode.setAttribute('channel', stat[0])
root.appendChild(prgNode)
with codecs_open(epgfile, "w", "utf-8") as out:
dcmnt.writexml(out, addindent = ' ', newl = '\n', encoding = "utf-8")
out.close()
def exportDesignAsXML(self,
elementids=None,
REQUEST=None,
dbsettings=True):
"""
"""
impl = getDOMImplementation()
doc = impl.createDocument(None, "plominodatabase", None)
root = doc.documentElement
root.setAttribute("id", self.id)
if REQUEST:
str_elementids = REQUEST.get("elementids")
if str_elementids is not None:
elementids = str_elementids.split("@")
if elementids is None:
elements = self.getForms() + self.getViews() + self.getAgents() + [
o for o in self.resources.getChildNodes()
]
else:
elements = []
for id in elementids:
if id.startswith('resources/'):
e = getattr(self.resources, id.split('/')[1])
else:
e = getattr(self, id)
elements.append(e)
# Sort elements by type (to store forms before views), then by id
elements.sort(key=lambda elt: elt.getId())
elements.sort(key=lambda elt: elt.Type())
designNode = doc.createElement('design')
# export database settings
if dbsettings:
node = self.exportElementAsXML(doc, self, isDatabase=True)
designNode.appendChild(node)
# export database design elements
for e in elements:
if e.meta_type in plomino_schemas.keys():
node = self.exportElementAsXML(doc, e)
else:
node = self.exportResourceAsXML(doc, e)
designNode.appendChild(node)
root.appendChild(designNode)
s = doc.toxml()
if REQUEST:
REQUEST.RESPONSE.setHeader('content-type',
"text/xml;charset=utf-8")
# Usage of lxml to make a pretty output
try:
from lxml import etree
parser = etree.XMLParser(strip_cdata=False, encoding="utf-8")
return etree.tostring(etree.XML(s, parser),
encoding="utf-8",
pretty_print=True)
except ImportError:
return s.encode('utf-8').replace("><", ">\n<")
idref = bookid+itemref.getAttribute("idref")
if idref in itemhrefs:
firstitemhrefs.append(itemhrefs[idref])
break
for itemref in itemreflist:
itemrefs.append(bookid+itemref.getAttribute("idref"))
booknum=booknum+1;
printt("after file loop:%s"%(time()-t))
t = time()
## create content.opf file.
uniqueid="epubmerge-uid-%d" % time() # real sophisticated uid scheme.
contentdom = getDOMImplementation().createDocument(None, "package", None)
package = contentdom.documentElement
package.setAttribute("version","2.0")
package.setAttribute("xmlns","http://www.idpf.org/2007/opf")
package.setAttribute("unique-identifier","epubmerge-id")
metadata=newTag(contentdom,"metadata",
attrs={"xmlns:dc":"http://purl.org/dc/elements/1.1/",
"xmlns:opf":"http://www.idpf.org/2007/opf"})
metadata.appendChild(newTag(contentdom,"dc:identifier",text=uniqueid,attrs={"id":"epubmerge-id"}))
if( titleopt is None ):
titleopt = booktitles[0]+" Anthology"
metadata.appendChild(newTag(contentdom,"dc:title",text=titleopt))
# If cmdline authors, use those instead of those collected from the epubs
# (allauthors kept for TOC & description gen below.
def __init__(self, wixDir, manufacturer, suiteName, appName, architecture,
versionType, versionMajor, versionMinor, upgradePolicy,
commitBranch, commitDate, commitIndex):
self.wixDir = wixDir
self.manufacturer = manufacturer
self.suiteName = suiteName
self.appName = appName
self.architecture = architecture
self.versionType = versionType
self.versionMajor = versionMajor
self.versionMinor = versionMinor
self.upgradePolicy = upgradePolicy
self.commitBranch = commitBranch
self.commitDate = commitDate
self.commitIndex = commitIndex
# Check versionType
allowedVersionTypes = ["stable", "beta", "alpha"]
if not self.versionType in allowedVersionTypes:
raise ValueError('Unknown versionType: "' + self.versionType +
'".' + ' Allowed values are: "' +
'", "'.join(allowedVersionTypes) + '".')
# Check commit information
if versionType in ["beta", "alpha"]:
hasCommitInfo = (self.commitBranch and self.commitDate
and self.commitIndex)
if not hasCommitInfo:
raise ValueError(
'Commit info not found while required to deploy when' +
' versionType = "' + versionType + '.' +
' Please compile from a git repository.')
# Check upgradePolicy
allowedUpgradePolicies = {
"stable": ["all", "minor", "none"],
"beta": ["minor", "none"],
"alpha": ["minor", "none"]
}
if not self.upgradePolicy in allowedUpgradePolicies[self.versionType]:
raise ValueError(
'Unknown upgradePolicy: "' + self.upgradePolicy + '".' +
' Allowed values when versionType = "' + self.versionType + '"'
' are: ' +
'", "'.join(allowedUpgradePolicies[self.versionType]) + '".')
# Check architecture
allowedArchitectures = ["x86", "x64"]
if not self.architecture in allowedArchitectures:
raise ValueError('Unknown architecture: "' + self.versionType +
'".' + ' Allowed values are: "' +
'", "'.join(allowedArchitectures) + '".')
# Set appOrSuiteName. Examples:
# - for suite installers: "VGC"
# - for app installers: "VGC Illustration", "VGC Animation", etc.
self.appOrSuiteName = self.suiteName
if self.appName:
self.appOrSuiteName += " " + self.appName
# Set commitDateAndIndex
# Example: "2019-07-08.1"
if self.versionType in ["beta", "alpha"]:
commitDateAndIndex = self.commitDate + "." + self.commitIndex
# Set branchSuffix
# Example: "-gh62"
branchSuffix = ""
if ((self.versionType == "beta"
and self.commitBranch != self.versionMajor) or
(self.versionType == "alpha" and self.commitBranch != "master")):
branchSuffix = "-" + self.commitBranch
# Set installVersion and installHumanVersion
# Example: "19.7.08001" / "2019-07-08.1"
if self.versionType == "stable":
major = int(self.versionMajor[2:4])
minor = int(self.versionMinor)
self.installVersion = "{}.{}".format(major, minor)
self.installHumanVersion = "{}.{}".format(self.versionMajor, minor)
elif self.versionType in ["beta", "alpha"]:
major = int(self.commitDate[2:4])
minor = int(self.commitDate[5:7])
build = int(self.commitDate[8:10]) * 1000 + int(self.commitIndex)
self.installVersion = "{}.{}.{}".format(major, minor, build)
self.installHumanVersion = commitDateAndIndex
# Set installFamilySuffix and fullVersion (except the architecture suffix)
# Example:
# installFamilySuffix = " 2020 Beta"
# fullVersion = "2020 Beta 2019-07-08.1"
if self.versionType == "stable":
if self.upgradePolicy == "all": p = ""
elif self.upgradePolicy == "minor": p = " {}"
elif self.upgradePolicy == "none": p = " {}.{}"
self.installFamilySuffix = p.format(self.versionMajor,
self.versionMinor)
self.fullVersion = self.versionMajor
if minor > 0:
self.fullVersion += "." + self.versionMinor
elif self.versionType == "beta":
if self.upgradePolicy == "minor": p = " {} Beta{}"
elif self.upgradePolicy == "none": p = " {} Beta{} {}"
q = "{} Beta{} {}"
self.installFamilySuffix = p.format(self.versionMajor,
branchSuffix,
commitDateAndIndex)
self.fullVersion = q.format(self.versionMajor, branchSuffix,
commitDateAndIndex)
elif self.versionType == "alpha":
if self.upgradePolicy == "minor": p = " Alpha{}"
elif self.upgradePolicy == "none": p = " Alpha{} {}"
q = "Alpha{} {}"
self.installFamilySuffix = p.format(branchSuffix,
commitDateAndIndex)
self.fullVersion = q.format(branchSuffix, commitDateAndIndex)
# Set architecture and add it as suffix to installFamily and fullVersion
# Example:
# installFamilySuffix = " 2020 Beta 32-bit"
# fullVersion = "2020 Beta 2019-07-08.1 32-bit"
if self.architecture == "x64":
self.win64yesno = "yes"
self.programFilesFolder = "ProgramFiles64Folder"
elif self.architecture == "x86":
self.win64yesno = "no"
self.programFilesFolder = "ProgramFilesFolder"
self.installFamilySuffix += " 32-bit"
self.fullVersion += " 32-bit"
# Set installFamily
# Example: "VGC 2020 Beta 32-bit"
self.installFamily = self.suiteName + self.installFamilySuffix
# Set installerName and msiName
if self.versionType == "stable" and self.upgradePolicy == "minor":
installerTypeSuffix = " - Minor Updates Only"
elif self.upgradePolicy == "none":
installerTypeSuffix = " - No Updates"
else:
installerTypeSuffix = ""
self.msiName = self.appOrSuiteName + " " + self.fullVersion + installerTypeSuffix
self.installerName = self.appOrSuiteName + " " + self.fullVersion + " Installer" + installerTypeSuffix
# Create XML document.
#
domImplementation = getDOMImplementation()
self.domDocument = domImplementation.createDocument(None, "Wix", None)
# Get Wix root element and set its xmlns attribute.
#
self.root = WixElement(self.domDocument.documentElement, self, "")
self.root.setAttribute("xmlns",
"http://schemas.microsoft.com/wix/2006/wi")
# Add product. Note that we regenerate its ProductCode GUID
# (= 'Id' attribute) when the version change since we consider all
# changes of version to be "Major Upgrades" in MSI terminology. We need
# this since components may be added, moved or removed even when going
# from VGC 2020.0 to VGC 2020.1. Also, we desire that the name of our
# MSI file changes in this case, and it is a Microsoft requirement to
# keep the same MSI filename during a "Minor Upgrade" or "Small Upgrade".
#
self.product = self.root.createChild(
"Product",
[("Name", self.appOrSuiteName + self.installFamilySuffix),
("Id",
self.dynamicGuid("Product/ProductCode/" + self.appOrSuiteName)),
("UpgradeCode",
self.staticGuid("Product/UpgradeCode/" + self.appOrSuiteName)),
("Language", "1033"), ("Codepage", "1252"),
("Version", self.installVersion),
("Manufacturer", self.manufacturer)])
# Add package
#
# Note: manual specification of "Platform" is discouraged in favour
# of using the candle.exe -arch x64/x86 switch, but we use both anyway.
#
self.package = self.product.createChild(
"Package",
[("Id", self.dynamicGuid("Package/Id/" + self.appOrSuiteName)),
("Keywords", "Installer"),
("Description", "Installer of " + self.msiName),
("Manufacturer", self.manufacturer), ("InstallerVersion", "500"),
("InstallPrivileges", "elevated"), ("InstallScope", "perMachine"),
("Languages", "1033"), ("Compressed", "yes"),
("SummaryCodepage", "1252"), ("Platform", self.architecture)])
# Add media
self.media = self.product.createChild("Media",
[("Id", "1"),
("Cabinet", "Cabinet.cab"),
("EmbedCab", "yes")])
# See: https://stackoverflow.com/questions/2058230/wix-create-non-advertised-shortcut-for-all-users-per-machine
self.product.createChild("Property", [("Id", "DISABLEADVTSHORTCUTS"),
("Value", "1")])
# Allow major upgrades and prevent downgrades.
#
# We use the afterInstallExecute schedule in order not to break user
# shortcuts in the Desktop or Task Bar, see:
# http://windows-installer-xml-wix-toolset.687559.n2.nabble.com/Keep-Desktop-Shortcuts-and-Pinned-Task-Bar-Icons-with-Upgrades-td7599707.html
# https://stackoverflow.com/questions/32318662/user-pinned-taskbar-shortcuts-and-major-upgrades
#
self.majorUpgrades = self.product.createChild(
"MajorUpgrade",
[("Schedule", "afterInstallExecute"),
("DowngradeErrorMessage",
"A newer version of [ProductName] is already installed.")])
# Add basic directory structure.
self.targetDirectory = self.product.createDirectory(
"SourceDir", "TARGETDIR")
self.programFilesDirectory = self.targetDirectory.createDirectory(
"PFiles", self.programFilesFolder)
self.installDirectory = self.programFilesDirectory.createDirectory(
self.installFamily, "INSTALLFOLDER")
self.startMenuDirectory = self.targetDirectory.createDirectory(
"Programs", "ProgramMenuFolder")
self.desktopDirectory = self.targetDirectory.createDirectory(
"Desktop", "DesktopFolder")
def _CreateDocumentElement(self):
dom_impl = minidom.getDOMImplementation('')
doc = dom_impl.createDocument(None, 'root', None)
return doc.documentElement
from xml.parsers import expat
from xml.dom.minidom import _append_child, _set_attribute_node
from xml.dom.NodeFilter import NodeFilter
from xml.dom.minicompat import *
TEXT_NODE = Node.TEXT_NODE
CDATA_SECTION_NODE = Node.CDATA_SECTION_NODE
DOCUMENT_NODE = Node.DOCUMENT_NODE
FILTER_ACCEPT = xmlbuilder.DOMBuilderFilter.FILTER_ACCEPT
FILTER_REJECT = xmlbuilder.DOMBuilderFilter.FILTER_REJECT
FILTER_SKIP = xmlbuilder.DOMBuilderFilter.FILTER_SKIP
FILTER_INTERRUPT = xmlbuilder.DOMBuilderFilter.FILTER_INTERRUPT
theDOMImplementation = minidom.getDOMImplementation()
# Expat typename -> TypeInfo
_typeinfo_map = {
"CDATA": minidom.TypeInfo(None, "cdata"),
"ENUM": minidom.TypeInfo(None, "enumeration"),
"ENTITY": minidom.TypeInfo(None, "entity"),
"ENTITIES": minidom.TypeInfo(None, "entities"),
"ID": minidom.TypeInfo(None, "id"),
"IDREF": minidom.TypeInfo(None, "idref"),
"IDREFS": minidom.TypeInfo(None, "idrefs"),
"NMTOKEN": minidom.TypeInfo(None, "nmtoken"),
"NMTOKENS": minidom.TypeInfo(None, "nmtokens"),
}
def make_xml():
impl = getDOMImplementation()
impl2 = getDOMImplementation()
#creation du document reponse correction qui sera envoyé a gestionnaire_Correction
documentCopieReponse = impl2.createDocument(None, "Reponse", None)
rootNodeReponse = documentCopieReponse.documentElement
rootNodeReponse.setAttribute("type", "correction")
idNodeReponse = documentCopieReponse.createElement('Identifiant')
idQuestionnaire = raw_input('Quelle ID voulez vous mettre a ce questionnaire? ')
idQuestionnaireText = documentCopieReponse.createTextNode(idQuestionnaire)
idNodeReponse.appendChild(idQuestionnaireText)
rootNodeReponse.appendChild(idNodeReponse)
# creation du document Questionnaire qui sera envoyé a gestionnaire_QCM
documentQuestionnaire = impl.createDocument(None, "QCM", None)
rootNodeQuestionnaire = documentQuestionnaire.documentElement
NodeQuestionnaire = documentQuestionnaire.createElement('Questionnaire')
NodeQuestionnaire.setAttribute("id", idQuestionnaire)
NodeQuestionnaire.setAttribute("id_formation", raw_input('Quelle ID de formation voulez vous mettre pour ce questionnaire? '))
NodeQuestionnaire.setAttribute("id_matiere", raw_input('Quelle ID de matiere voulez vous mettre pour ce questionnaire? ') )
rootNodeQuestionnaire.appendChild(NodeQuestionnaire)
try:
nbquestion = int(raw_input('Combien de question voulez vous?'))
while True:
if nbquestion > 0:
break
else:
nbquestion = int(raw_input('Réponse non approprié, combien de question voulez vous? '))
except ValueError:
print "Veuillez choisir un nombre pour le prochain test"
exit(-1)
contenuNodeReponse = documentQuestionnaire.createElement("contenu")
# creation des différentes questions
# debut de la boucle while de question
cpt = 0;
while nbquestion > cpt:
# creation question pour reponse
questionNodeReponse = documentQuestionnaire.createElement("Question")
questionNodeReponse.setAttribute("id", str(cpt))
# creation question pour questionnaire
questionNodeQuestionnaire = documentQuestionnaire.createElement("Question")
questionNodeQuestionnaire.setAttribute("id", str(cpt))
# enonce pour questionnaire
newnode3 = documentQuestionnaire.createElement("Enonce")
text = documentQuestionnaire.createTextNode(raw_input('Entrez une question : '))
newnode3.appendChild(text)
questionNodeQuestionnaire.appendChild(newnode3)
cpt = cpt + 1
try:
nbReponse = int(raw_input('Combien de réponse voulez vous ? '))
while True:
if nbReponse > 0:
break
else:
nbReponse = int(raw_input('Réponse non approprié, combien de réponse voulez vous ? '))
except ValueError:
print "Veuillez choisir un nombre pour le prochain test"
exit(-1)
cptReponse = 0
while nbReponse > cptReponse:
# choix pour les differente reponse
choixNode = documentQuestionnaire.createElement("choix")
choixNode.setAttribute("id", str(cptReponse))
textChoix = documentQuestionnaire.createTextNode(raw_input('Entrez une reponse: '))
choixNode.appendChild(textChoix)
cptReponse = cptReponse + 1
questionNodeQuestionnaire.appendChild(choixNode)
# demande de bonne reponse et mise en place de la reponse dans le bon endroit
questionNodeReponse.setAttribute("rep", raw_input('Quelle était l\'ID de la bonne reponse? (La première réponse -> ID = 0, la deuxième réponse -> ID = 1) '))
contenuNodeReponse.appendChild(questionNodeReponse)
NodeQuestionnaire.appendChild(questionNodeQuestionnaire)
rootNodeReponse.appendChild(contenuNodeReponse)
return documentQuestionnaire.toprettyxml(), documentCopieReponse.toprettyxml()
def Init(self):
dom_impl = minidom.getDOMImplementation('')
self._doc = dom_impl.createDocument(None, 'html', None)
body = self.AddElement(self._doc.documentElement, 'body')
self._main_div = self.AddElement(body, 'div')
self._indent_level = 0
# Human-readable names of supported platforms.
self._PLATFORM_MAP = {
'win': 'Windows',
'mac': 'Mac',
'linux': 'Linux',
'chrome_os': self.config['os_name'],
'android': 'Android',
'ios': 'iOS',
}
# Human-readable names of supported products.
self._PRODUCT_MAP = {
'chrome': self.config['app_name'],
'chrome_frame': self.config['frame_name'],
'chrome_os': self.config['os_name'],
'webview': self.config['webview_name'],
}
# Human-readable names of supported features. Each supported feature has
# a 'doc_feature_X' entry in |self.messages|.
self._FEATURE_MAP = {}
for message in self.messages:
if message.startswith('doc_feature_'):
self._FEATURE_MAP[
message[12:]] = self.messages[message]['text']
# Human-readable names of types.
self._TYPE_MAP = {
'string': 'String',
'int': 'Integer',
'main': 'Boolean',
'int-enum': 'Integer',
'string-enum': 'String',
'list': 'List of strings',
'string-enum-list': 'List of strings',
'dict': 'Dictionary',
'external': 'External data reference',
}
self._REG_TYPE_MAP = {
'string': 'REG_SZ',
'int': 'REG_DWORD',
'main': 'REG_DWORD',
'int-enum': 'REG_DWORD',
'string-enum': 'REG_SZ',
'dict': 'REG_SZ',
}
self._RESTRICTION_TYPE_MAP = {
'int-enum': 'choice',
'string-enum': 'choice',
'list': 'string',
'string-enum-list': 'multi-select',
'dict': 'string',
}
# The CSS style-sheet used for the document. It will be used in Google
# Sites, which strips class attributes from HTML tags. To work around this,
# the style-sheet is a dictionary and the style attributes will be added
# "by hand" for each element.
self._STYLE = {
'table': 'border-style: none; border-collapse: collapse;',
'tr': 'height: 0px;',
'td': 'border: 1px dotted rgb(170, 170, 170); padding: 7px; '
'vertical-align: top; width: 236px; height: 15px;',
'thead td': 'font-weight: bold;',
'td.left': 'width: 200px;',
'td.right': 'width: 100%;',
'dt': 'font-weight: bold;',
'dd dl': 'margin-top: 0px; margin-bottom: 0px;',
'.monospace': 'font-family: monospace;',
'.pre': 'white-space: pre;',
'div.note': 'border: 2px solid black; padding: 5px; margin: 5px;',
'div.group_desc': 'margin-top: 20px; margin-bottom: 20px;',
'ul': 'padding-left: 0px; margin-left: 0px;'
}
def newDocument(self):
"""clear DOM"""
impl = mdom.getDOMImplementation()
self.doc = impl.createDocument(None, self.rootTag, None)
import time
import ic_testcase
import datetime
import re
import os
import fileinput
import random
import base64
import tempfile
import shutil
from base64 import b64encode, b64decode, encodestring
import xml.dom.minidom
from xml.dom.minidom import getDOMImplementation
impl = getDOMImplementation()
from ..utils import getText
my_test_file = "my_test_file.txt"
fw_target_num = 0
RCI_QUERY_SETTING = \
"""<sci_request version="1.0">
<send_message cache="false">
<targets>
<device id="%s"/>
</targets>
<rci_request version="1.1">
<query_setting><system><description/></system></query_setting>
</rci_request>
#License as published by the Free Software Foundation; either
#version 2 of the License, or (at your option) any later version.
#
#This library is distributed in the hope that it will be useful,
#but WITHOUT ANY WARRANTY; without even the implied warranty of
#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
#Library General Public License for more details.
#
#You should have received a copy of the GNU Library General Public
#License along with this library; if not, write to the Free
#Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
#MA 02111-1307, USA
from propfind import PROPFIND
from xml.dom import minidom
domimpl = minidom.getDOMImplementation()
from utils import get_parenturi
class REPORT(PROPFIND):
def __init__(self, uri, dataclass, depth, body):
PROPFIND.__init__(self, uri, dataclass, depth, body)
doc = minidom.parseString(body)
self.filter = doc.documentElement
def create_propname(self):
""" create a multistatus response for the prop names """
dc = self._dataclass
def generate(self):
if not self.host:
conn = cups.Connection()
else:
if not self.port:
self.port = 631
conn = cups.Connection(self.host, self.port)
printers = conn.getPrinters()
for p, v in printers.items():
if v['printer-is-shared']:
attrs = conn.getPrinterAttributes(p)
uri = urlparse.urlparse(v['printer-uri-supported'])
tree = ElementTree()
tree.parse(StringIO(XML_TEMPLATE.replace('\n', '').replace('\r', '').replace('\t', '')))
name = tree.find('name')
name.text = 'AirPrint %s @ %%h' % (p)
service = tree.find('service')
port = service.find('port')
port_no = None
if hasattr(uri, 'port'):
port_no = uri.port
if not port_no:
port_no = self.port
if not port_no:
port_no = cups.getPort()
port.text = '%d' % port_no
if hasattr(uri, 'path'):
rp = uri.path
else:
rp = uri[2]
re_match = re.match(r'^//(.*):(\d+)(/.*)', rp)
if re_match:
rp = re_match.group(3)
#Remove leading slashes from path
#TODO XXX FIXME I'm worried this will match broken urlparse
#results as well (for instance if they don't include a port)
#the xml would be malform'd either way
rp = re.sub(r'^/+', '', rp)
path = Element('txt-record')
path.text = 'rp=%s' % (rp)
service.append(path)
desc = Element('txt-record')
desc.text = 'note=%s' % (v['printer-info'])
service.append(desc)
product = Element('txt-record')
product.text = 'product=(GPL Ghostscript)'
service.append(product)
state = Element('txt-record')
state.text = 'printer-state=%s' % (v['printer-state'])
service.append(state)
ptype = Element('txt-record')
ptype.text = 'printer-type=%s' % (hex(v['printer-type']))
service.append(ptype)
pdl = Element('txt-record')
fmts = []
defer = []
for a in attrs['document-format-supported']:
if a in DOCUMENT_TYPES:
if DOCUMENT_TYPES[a]:
fmts.append(a)
else:
defer.append(a)
fmts = ','.join(fmts+defer)
dropped = []
# TODO XXX FIXME all fields should be checked for 255 limit
while len('pdl=%s' % (fmts)) >= 255:
(fmts, drop) = fmts.rsplit(',', 1)
dropped.append(drop)
if len(dropped) and self.verbose:
sys.stderr.write('%s Losing support for: %s%s' % (p, ','.join(dropped), os.linesep))
pdl.text = 'pdl=%s' % (fmts)
service.append(pdl)
if self.adminurl:
admin = Element('txt-record')
admin.text = 'adminurl=%s' % (v['printer-uri-supported'])
service.append(admin)
fname = '%s%s.service' % (self.prefix, p)
if self.directory:
fname = os.path.join(self.directory, fname)
f = open(fname, 'w')
if etree:
tree.write(f, pretty_print=True, xml_declaration=True, encoding="UTF-8")
else:
xmlstr = tostring(tree.getroot())
doc = parseString(xmlstr)
dt= minidom.getDOMImplementation('').createDocumentType('service-group', None, 'avahi-service.dtd')
doc.insertBefore(dt, doc.documentElement)
doc.writexml(f)
f.close()
if self.verbose:
sys.stderr.write('Created: %s%s' % (fname, os.linesep))
def doMerge(outputio,
files,
authoropts=[],
titleopt=None,
descopt=None,
tags=[],
languages=['en'],
titlenavpoints=True,
flattentoc=False,
printtimes=False,
coverjpgpath=None,
keepmetadatafiles=False,
source=None):
'''
outputio = output file name or StringIO.
files = list of input file names or StringIOs.
authoropts = list of authors to use, otherwise add from all input
titleopt = title, otherwise '<first title> Anthology'
descopt = description, otherwise '<title> by <author>' list for all input
tags = dc:subject tags to include, otherwise none.
languages = dc:language tags to include
titlenavpoints if true, put in a new TOC entry for each epub, nesting each epub's chapters under it
flattentoc if true, flatten TOC down to one level only.
coverjpgpath, Path to a jpg to use as cover image.
'''
printt = partial(cond_print,printtimes)
## Python 2.5 ZipFile is rather more primative than later
## versions. It can operate on a file, or on a StringIO, but
## not on an open stream. OTOH, I suspect we would have had
## problems with closing and opening again to change the
## compression type anyway.
filecount=0
t = time()
## Write mimetype file, must be first and uncompressed.
## Older versions of python(2.4/5) don't allow you to specify
## compression by individual file.
## Overwrite if existing output file.
outputepub = ZipFile(outputio, "w", compression=ZIP_STORED)
outputepub.debug = 3
outputepub.writestr("mimetype", "application/epub+zip")
outputepub.close()
## Re-open file for content.
outputepub = ZipFile(outputio, "a", compression=ZIP_DEFLATED)
outputepub.debug = 3
## Create META-INF/container.xml file. The only thing it does is
## point to content.opf
containerdom = getDOMImplementation().createDocument(None, "container", None)
containertop = containerdom.documentElement
containertop.setAttribute("version","1.0")
containertop.setAttribute("xmlns","urn:oasis:names:tc:opendocument:xmlns:container")
rootfiles = containerdom.createElement("rootfiles")
containertop.appendChild(rootfiles)
rootfiles.appendChild(newTag(containerdom,"rootfile",{"full-path":"content.opf",
"media-type":"application/oebps-package+xml"}))
outputepub.writestr("META-INF/container.xml",containerdom.toprettyxml(indent=' ',encoding='utf-8'))
## Process input epubs.
items = [] # list of (id, href, type) tuples(all strings) -- From .opfs' manifests
items.append(("ncx","toc.ncx","application/x-dtbncx+xml")) ## we'll generate the toc.ncx file,
## but it needs to be in the items manifest.
itemrefs = [] # list of strings -- idrefs from .opfs' spines
navmaps = [] # list of navMap DOM elements -- TOC data for each from toc.ncx files
is_ffdl_epub = [] # list of t/f
itemhrefs = {} # hash of item[id]s to itemref[href]s -- to find true start of book(s).
firstitemhrefs = []
booktitles = [] # list of strings -- Each book's title
allauthors = [] # list of lists of strings -- Each book's list of authors.
filelist = []
printt("prep output:%s"%(time()-t))
t = time()
booknum=1
firstmetadom = None
for file in files:
if file == None : continue
book = "%d" % booknum
bookdir = "%d/" % booknum
bookid = "a%d" % booknum
epub = ZipFile(file, 'r')
## Find the .opf file.
container = epub.read("META-INF/container.xml")
containerdom = parseString(container)
rootfilenodelist = containerdom.getElementsByTagNameNS("*","rootfile")
rootfilename = rootfilenodelist[0].getAttribute("full-path")
## Save the path to the .opf file--hrefs inside it are relative to it.
relpath = get_path_part(rootfilename)
metadom = parseString(epub.read(rootfilename))
#logger.debug("metadom:%s"%epub.read(rootfilename))
if booknum==1 and not source:
try:
firstmetadom = metadom.getElementsByTagNameNS("*","metadata")[0]
source=firstmetadom.getElementsByTagName("dc:source")[0].firstChild.data.encode("utf-8")
except:
source=""
# if the epub was ever edited with Sigil, it changed the unique-identifier,
# but dc:contributor was left.
#is_ffdl_epub.append(metadom.documentElement.getAttribute('unique-identifier') == "fanficdownloader-uid")
is_ffdl_epub.append(False)
for c in metadom.getElementsByTagName("dc:contributor"):
# logger.debug("dc:contributor:%s"%getText(c.childNodes))
if c.getAttribute("opf:role") == "bkp" and \
getText(c.childNodes) in ["fanficdownloader [http://fanficdownloader.googlecode.com]",
"FanFicFare [https://github.com/JimmXinu/FanFicFare]"]:
is_ffdl_epub[-1] = True # set last.
break;
## Save indiv book title
try:
booktitles.append(metadom.getElementsByTagName("dc:title")[0].firstChild.data)
except:
booktitles.append("(Title Missing)")
## Save authors.
authors=[]
for creator in metadom.getElementsByTagName("dc:creator"):
try:
if( creator.getAttribute("opf:role") == "aut" or not creator.hasAttribute("opf:role") and creator.firstChild != None):
authors.append(creator.firstChild.data)
except:
pass
if len(authors) == 0:
authors.append("(Author Missing)")
allauthors.append(authors)
if keepmetadatafiles:
itemid=bookid+"rootfile"
itemhref = rootfilename
href=bookdir+itemhref
#logger.debug("write rootfile %s to %s"%(itemhref,href))
outputepub.writestr(href,
epub.read(itemhref))
items.append((itemid,href,"origrootfile/xml"))
# spin through the manifest--only place there are item tags.
# Correction--only place there *should* be item tags. But
# somebody found one that did.
manifesttag=metadom.getElementsByTagNameNS("*","manifest")[0]
for item in manifesttag.getElementsByTagNameNS("*","item"):
itemid=bookid+item.getAttribute("id")
itemhref = unquote(item.getAttribute("href")) # remove %20, etc.
href=bookdir+relpath+itemhref
if( item.getAttribute("media-type") == "application/x-dtbncx+xml" ):
# TOC file is only one with this type--as far as I know.
# grab the whole navmap, deal with it later.
tocdom = parseString(epub.read(relpath+item.getAttribute("href")))
# update all navpoint ids with bookid for uniqueness.
for navpoint in tocdom.getElementsByTagNameNS("*","navPoint"):
navpoint.setAttribute("id",bookid+navpoint.getAttribute("id"))
# update all content paths with bookdir for uniqueness.
for content in tocdom.getElementsByTagNameNS("*","content"):
content.setAttribute("src",bookdir+relpath+content.getAttribute("src"))
navmaps.append(tocdom.getElementsByTagNameNS("*","navMap")[0])
if keepmetadatafiles:
#logger.debug("write toc.ncx %s to %s"%(relpath+itemhref,href))
outputepub.writestr(href,
epub.read(relpath+itemhref))
items.append((itemid,href,"origtocncx/xml"))
else:
href=href.encode('utf8')
#logger.debug("item id: %s -> %s:"%(itemid,href))
itemhrefs[itemid] = href
if href not in filelist:
try:
outputepub.writestr(href,
epub.read(relpath+itemhref))
if re.match(r'.*/(file|chapter)\d+\.x?html',href):
filecount+=1
items.append((itemid,href,item.getAttribute("media-type")))
filelist.append(href)
except KeyError, ke: # Skip missing files.
logger.info("Skipping missing file %s (%s)"%(href,relpath+itemhref))
del itemhrefs[itemid]
itemreflist = metadom.getElementsByTagNameNS("*","itemref")
# logger.debug("itemreflist:%s"%itemreflist)
# logger.debug("itemhrefs:%s"%itemhrefs)
# logger.debug("bookid:%s"%bookid)
# logger.debug("itemreflist[0].getAttribute(idref):%s"%itemreflist[0].getAttribute("idref"))
# Looking for the first item in itemreflist that wasn't
# discarded due to missing files.
for itemref in itemreflist:
idref = bookid+itemref.getAttribute("idref")
if idref in itemhrefs:
firstitemhrefs.append(itemhrefs[idref])
break
for itemref in itemreflist:
itemrefs.append(bookid+itemref.getAttribute("idref"))
booknum=booknum+1;
def Init(self):
impl = minidom.getDOMImplementation()
self._doc = impl.createDocument(None, 'resources', None)
self._resources = self._doc.documentElement
def __init__(self):
HTMLParser.__init__(self)
self.__impl = getDOMImplementation()
self.__document = self.__impl.createDocument(None, None, None)
self.__elements = []
def newDocument(tag):
impl = minidom.getDOMImplementation()
dom = impl.createDocument(None, tag, None)
return dom.documentElement
def __init__(self, showSkipped=True):
self._doc = getDOMImplementation().createDocument(
None, 'testsuite', None)
self._show_skipped = showSkipped
def write_sample_feed(buildenv, master_feed, src_impl):
path = buildenv.local_iface_file
old_path = os.path.join(buildenv.metadir, buildenv.iface_name + '.xml')
if os.path.exists(old_path):
warn("Removing old %s file: use %s instead now", old_path, path)
os.unlink(old_path)
impl = minidom.getDOMImplementation()
XMLNS_IFACE = namespaces.XMLNS_IFACE
doc = impl.createDocument(XMLNS_IFACE, "interface", None)
root = doc.documentElement
root.setAttributeNS(XMLNS_NAMESPACE, 'xmlns', XMLNS_IFACE)
prefixes = Prefixes(XMLNS_IFACE)
def addSimple(parent, name, text = None):
elem = doc.createElementNS(XMLNS_IFACE, name)
parent.appendChild(doc.createTextNode('\n' + ' ' * (1 + depth(parent))))
parent.appendChild(elem)
if text:
elem.appendChild(doc.createTextNode(text))
return elem
def close(element):
element.appendChild(doc.createTextNode('\n' + ' ' * depth(element)))
addSimple(root, 'name', master_feed.name)
addSimple(root, 'summary', master_feed.summary)
addSimple(root, 'description', master_feed.description)
feed_for = addSimple(root, 'feed-for')
feed_for.setAttributeNS(None, 'interface', find_feed_for(master_feed))
group = addSimple(root, 'group')
main = src_impl.attrs.get(XMLNS_0COMPILE + ' binary-main', None)
if main:
group.setAttributeNS(None, 'main', main)
lib_mappings = src_impl.attrs.get(XMLNS_0COMPILE + ' binary-lib-mappings', None)
if lib_mappings:
prefixes.setAttributeNS(group, XMLNS_0COMPILE, 'lib-mappings', lib_mappings)
for d in src_impl.dependencies:
if parse_bool(d.metadata.get(XMLNS_0COMPILE + ' include-binary', 'false')):
requires = d.qdom.toDOM(doc, prefixes)
requires.removeAttributeNS(XMLNS_0COMPILE, 'include-binary')
group.appendChild(requires)
set_arch = True
impl_elem = addSimple(group, 'implementation')
impl_template = buildenv.get_binary_template()
if impl_template:
arm_if_0install_attrs(impl_template)
# Copy attributes from template
for fullname, value in impl_template.attrs.items():
if fullname == 'arch':
set_arch = False
if value == '*-*':
continue
if ' ' in fullname:
ns, localName = fullname.split(' ', 1)
else:
ns, localName = None, fullname
prefixes.setAttributeNS(impl_elem, ns, localName, value)
# Copy child nodes
for child in impl_template.childNodes:
impl_elem.appendChild(child.toDOM(doc, prefixes))
if impl_template.content:
impl_elem.appendChild(doc.createTextNode(impl_template.content))
for version_elem in itertools.chain(
impl_elem.getElementsByTagName('version'),
):
pin_components = version_elem.getAttributeNS(XMLNS_0COMPILE, "pin-components")
if pin_components:
pin_components = int(pin_components)
iface = version_elem.parentNode.getAttribute("interface")
assert iface
dep_impl = buildenv.chosen_impl(iface)
impl_version = model.parse_version(dep_impl.attrs.get('version'))
pinned_components = [impl_version[0][:pin_components]]
# (for -pre versions)
min_version = min(pinned_components, impl_version)
# clone and increment
max_version = [pinned_components[0][:]]
max_version[0][-1] += 1
version_elem.setAttribute("not-before", model.format_version(min_version))
version_elem.setAttribute("before", model.format_version(max_version))
if set_arch:
group.setAttributeNS(None, 'arch', buildenv.target_arch)
impl_elem.setAttributeNS(None, 'version', src_impl.version)
if not impl_elem.hasAttribute('license'):
license = src_impl.attrs.get('license')
if license:
impl_elem.setAttributeNS(None, 'license', license)
version_modifier = buildenv.version_modifier
if version_modifier:
impl_elem.setAttributeNS(None, 'version-modifier', version_modifier)
impl_elem.setAttributeNS(None, 'id', '..')
impl_elem.setAttributeNS(None, 'released', time.strftime('%Y-%m-%d'))
close(group)
close(root)
for ns, prefix in list(prefixes.prefixes.items()):
root.setAttributeNS(XMLNS_NAMESPACE, 'xmlns:' + prefix, ns)
stream = codecs.open(path, 'w', encoding = 'utf-8')
try:
doc.writexml(stream)
finally:
stream.close()
def make_classpath():
impl = minidom.getDOMImplementation()
return impl.createDocument(None, 'classpath', None)
def create_doc_without_doctype(doctype=None):
return getDOMImplementation().createDocument(None, "doc", doctype)
def CreatePlistDocument(self):
dom_impl = minidom.getDOMImplementation('')
doctype = dom_impl.createDocumentType(
'plist', '-//Apple//DTD PLIST 1.0//EN',
'http://www.apple.com/DTDs/PropertyList-1.0.dtd')
return dom_impl.createDocument(None, 'plist', doctype)
def to_dom(self, serializer=Serializer()):
dom = minidom.getDOMImplementation()
document = dom.createDocument(None, self.__tag, None)
self._append_to_dom_element(document.documentElement, dom, document,
serializer)
return document
from requests import post
import xpath
from random import randrange
from time import sleep
from string import Template
from nose.tools import *
from xml.dom.minidom import parseString, getDOMImplementation
import ic_testcase
import logging
dom = getDOMImplementation()
from ic_plugin import ICPlugin
log = logging.getLogger('ic_testcase')
log.setLevel(logging.INFO)
if len(log.handlers) == 0:
handler = logging.StreamHandler()
handler.setLevel(logging.INFO)
formatter = logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(message)s')
handler.setFormatter(formatter)
log.addHandler(handler)
logging.getLogger('requests').setLevel(logging.WARNING)
##################################################################
# Elements and Groups to ignore (to not ruin device config)
##################################################################
EXCLUDE_GROUP = []
EXCLUDE_ELEMENT = []
def to_xml(self, package):
"""
create XML document for the package
"""
imp = minidom.getDOMImplementation('')
# Create document type
dt = imp.createDocumentType('package', '', '')
dt.internalSubset = self.doctype()
# Create XML document with this document type
doc = imp.createDocument('', 'package', dt)
docr = doc.documentElement
pid = doc.createAttribute('id')
pid.value = package.id
docr.setAttributeNode(pid)
name = doc.createElement('name')
name.appendChild(doc.createTextNode(package.label))
docr.appendChild(name)
version = doc.createElement('version')
numeric = doc.createElement('numeric')
numeric.appendChild(doc.createTextNode(str(package.version)))
label = doc.createElement('label')
label.appendChild(doc.createTextNode(str(package.version)))
version.appendChild(numeric)
version.appendChild(label)
docr.appendChild(version)
description = doc.createElement('description')
description.appendChild(doc.createTextNode(package.description))
docr.appendChild(description)
licenses = doc.createElement('licenses')
licenses.appendChild(doc.createTextNode(package.licenses))
docr.appendChild(licenses)
commands = doc.createElement('commands')
reboot = doc.createAttribute('reboot')
reboot.value = str(package.reboot)
commands.setAttributeNode(reboot)
precommand = doc.createElement('preCommand')
precommandname = doc.createAttribute('name')
precommandname.value = package.precmd.name
precommand.setAttributeNode(precommandname)
precommand.appendChild(doc.createTextNode(package.precmd.command))
installinit = doc.createElement('installInit')
installinitname = doc.createAttribute('name')
installinitname.value = package.initcmd.name
installinit.setAttributeNode(installinitname)
installinit.appendChild(doc.createTextNode(package.initcmd.command))
command = doc.createElement('command')
commandname = doc.createAttribute('name')
commandname.value = package.cmd.name
command.setAttributeNode(commandname)
command.appendChild(doc.createTextNode(package.cmd.command))
postsuccess = doc.createElement('postCommandSuccess')
postsuccessname = doc.createAttribute('name')
postsuccessname.value = package.postcmd_ok.name
postsuccess.setAttributeNode(postsuccessname)
postsuccess.appendChild(doc.createTextNode(package.postcmd_ok.command))
postfailure = doc.createElement('postCommandFailure')
postfailurename = doc.createAttribute('name')
postfailurename.value = package.postcmd_ko.name
postfailure.setAttributeNode(postfailurename)
postfailure.appendChild(doc.createTextNode(package.postcmd_ko.command))
commands.appendChild(precommand)
commands.appendChild(installinit)
commands.appendChild(command)
commands.appendChild(postsuccess)
commands.appendChild(postfailure)
docr.appendChild(commands)
associateinventory = doc.createElement('associateinventory')
appenchild = doc.createTextNode(str(package.associateinventory))
associateinventory.appendChild(appenchild)
docr.appendChild(associateinventory)
query = doc.createElement('query')
Qvendor = doc.createElement('Qvendor')
Qvendor.appendChild(doc.createTextNode(package.Qvendor))
query.appendChild(Qvendor)
Qsoftware = doc.createElement('Qsoftware')
Qsoftware.appendChild(doc.createTextNode(package.Qsoftware))
query.appendChild(Qsoftware)
Qversion = doc.createElement('Qversion')
Qversion.appendChild(doc.createTextNode(package.Qversion))
query.appendChild(Qversion)
boolcnd = doc.createElement('boolcnd')
boolcnd.appendChild(doc.createTextNode(package.boolcnd))
query.appendChild(boolcnd)
docr.appendChild(query)
return doc.toprettyxml(encoding='utf-8')
def test_upgradeSite(self):
templates_tool = self.dummy_template_tool
repository = "dummy_repository"
# setup dummy repository to make unit test independant from any real
# repository. This function creates the bt5list XML of the repository and
# the minimum BT files.
def createBtAndAddToRepository(repository, xml, **kw):
bt_dir = "%s/%s/bt" % (repository, kw['title'])
if not os.path.exists(bt_dir):
os.makedirs(bt_dir)
with open("%s/title" % bt_dir, "wb") as f:
f.write(kw['title'])
template = xml.createElement('template')
template.setAttribute('id', kw['title'])
defaults = {
'copyright': "Copyright Test Template Tool",
'license': "GPL",
'title': kw['title'], # title is mandatory
'version': "1.0",
'revision': "1"
}
for el in ['copyright', 'version', 'revision', 'license', 'title']:
node = xml.createElement(el)
node.appendChild(xml.createTextNode(kw.get(el, defaults[el])))
template.appendChild(node)
for dep in kw.get('dependency_list', []):
node = xml.createElement('dependency')
node.appendChild(xml.createTextNode(dep))
template.appendChild(node)
xml.documentElement.appendChild(template)
def copyTestCoreBt(bt_name):
bt_path = "%s/%s" % (repository, bt_name)
available_bt, = self.portal.portal_templates.getRepositoryBusinessTemplateList(
template_list=('test_core',)
)
test_core_path = available_bt.repository + "/test_core"
if os.path.exists(bt_path):
shutil.rmtree(bt_path)
shutil.copytree(test_core_path, bt_path)
# bt4 and bt5 are copies of test_core
copyTestCoreBt("bt4")
copyTestCoreBt("bt5")
# create bt1..5 BT inside dummy_repository
repo_xml = getDOMImplementation().createDocument(None, "repository", None)
createBtAndAddToRepository(repository, repo_xml, title='bt1', dependency_list=('bt4',)),
createBtAndAddToRepository(repository, repo_xml, title='bt2'),
createBtAndAddToRepository(repository, repo_xml, title='bt3'),
createBtAndAddToRepository(repository, repo_xml, title='bt4'),
createBtAndAddToRepository(repository, repo_xml, title='bt5'),
with open("%s/bt5list" % repository,"wb") as repo_xml_fd:
repo_xml.writexml(repo_xml_fd)
repo_xml_fd.close()
# Install dummy_repository
templates_tool.repository_dict[repository] = None
templates_tool.updateRepositoryBusinessTemplateList([repository])
def getInstalledBtList():
return sorted([bt.getTitle() for bt in templates_tool.getInstalledBusinessTemplateList()])
# Install manually 2 BT
templates_tool.updateBusinessTemplateFromUrl("%s/bt2" % repository)
self.assertEqual(getInstalledBtList(), ['bt2'])
templates_tool.updateBusinessTemplateFromUrl("%s/bt3" % repository)
self.assertEqual(getInstalledBtList(), ['bt2', 'bt3'])
# First upgrade
templates_tool.upgradeSite(bt5_list=['bt1'], keep_bt5_id_set=['bt2'], delete_orphaned=True)
self.assertEqual(getInstalledBtList(), ['bt1', 'bt2', 'bt4'])
# test_file has been installed with bt4
erp5_test = self.portal.portal_skins['erp5_test']
self.assertTrue(erp5_test.hasObject('test_file'))
# Second upgrade
templates_tool.upgradeSite(bt5_list=['bt5'], keep_bt5_id_set=['bt2'], delete_orphaned=True)
self.assertEqual(getInstalledBtList(), ['bt2', 'bt5'])
# test_file is now installed with bt5
erp5_test = self.portal.portal_skins['erp5_test']
self.assertTrue(erp5_test.hasObject('test_file'))
def execute(my):
node_names = []
# find out which nodes are of interest
if my.mode == "select":
top_nodes = my.app.get_selected_top_nodes()
else:
top_nodes = my.app.get_top_nodes()
# go through each top level node
for top_node in top_nodes:
if top_node in ['persp', 'top', 'front', 'side']:
continue
node_names.append(top_node)
set_names = my.app.get_sets()
node_names.extend(set_names)
# sort the node_names
node_names.sort()
user = my.info.get_user()
# get the pid of this process
pid = os.getpid()
# create an xml document
xml_impl = getDOMImplementation()
doc = xml_impl.createDocument(None, "session", None)
root = doc.documentElement
# get the name of the file
file_path = my.app.get_file_path()
file_node = doc.createElement("file")
file_node.setAttribute("name", os.path.basename(file_path))
file_node.setAttribute("dir", os.path.dirname(file_path))
root.appendChild(file_node)
project_node = doc.createElement("project")
project_node.setAttribute("dir", my.app.get_project())
root.appendChild(project_node)
# max it drill down is 4 levels to discover tactic node
my.process_nodes(doc, node_names, level=4)
# add namespace info
if my.app.name == "maya":
cur_namespace = my.app.get_namespace_info('-cur')
xml_node = doc.createElement("namespace")
xml_node.setAttribute("name", cur_namespace)
xml_node.setAttribute("current", "true")
root.appendChild(xml_node)
namespaces = my.app.get_namespace_info()
if namespaces:
for namespace in namespaces:
xml_node = doc.createElement("namespace")
xml_node.setAttribute("name", namespace)
root.appendChild(xml_node)
# dump out the xml
xml = doc.toprettyxml()
# inform the server of the information of this session
server = my.info.get_xmlrpc_server()
ticket = my.info.get_ticket()
project_code = my.info.get_project_code()
server.update_session(ticket, project_code, user, pid, xml)
def doUnMerge(inputio,outdir=None):
epub = ZipFile(inputio, 'r') # works equally well with inputio as a path or a blob
outputios = []
## Find the .opf file.
container = epub.read("META-INF/container.xml")
containerdom = parseString(container)
rootfilenodelist = containerdom.getElementsByTagName("rootfile")
rootfilename = rootfilenodelist[0].getAttribute("full-path")
contentdom = parseString(epub.read(rootfilename))
## Save the path to the .opf file--hrefs inside it are relative to it.
relpath = get_path_part(rootfilename)
#logger.debug("relpath:%s"%relpath)
# spin through the manifest--only place there are item tags.
# Correction--only place there *should* be item tags. But
# somebody found one that did.
manifesttag=contentdom.getElementsByTagNameNS("*","manifest")[0]
for item in manifesttag.getElementsByTagNameNS("*","item"):
# look for our fake media-type for original rootfiles.
if( item.getAttribute("media-type") == "origrootfile/xml" ):
# found one, assume the dir containing it is a complete
# original epub, do initial setup of epub.
itemhref = relpath+unquote(item.getAttribute("href"))
#logger.debug("Found origrootfile:%s"%itemhref)
curepubpath = re.sub(r'([^\d/]+/)+$','',get_path_part(itemhref))
savehref = itemhref[len(curepubpath):]
#logger.debug("curepubpath:%s"%curepubpath)
outputio = StringIO()
outputepub = ZipFile(outputio, "w", compression=ZIP_STORED)
outputepub.debug = 3
outputepub.writestr("mimetype", "application/epub+zip")
outputepub.close()
## Re-open file for content.
outputepub = ZipFile(outputio, "a", compression=ZIP_DEFLATED)
outputepub.debug = 3
## Create META-INF/container.xml file. The only thing it does is
## point to content.opf
containerdom = getDOMImplementation().createDocument(None, "container", None)
containertop = containerdom.documentElement
containertop.setAttribute("version","1.0")
containertop.setAttribute("xmlns","urn:oasis:names:tc:opendocument:xmlns:container")
rootfiles = containerdom.createElement("rootfiles")
containertop.appendChild(rootfiles)
rootfiles.appendChild(newTag(containerdom,"rootfile",{"full-path":savehref,
"media-type":"application/oebps-package+xml"}))
outputepub.writestr("META-INF/container.xml",containerdom.toprettyxml(indent=' ',encoding='utf-8'))
outputepub.writestr(savehref,epub.read(itemhref))
for item2 in contentdom.getElementsByTagName("item"):
item2href = relpath+unquote(item2.getAttribute("href"))
if item2href.startswith(curepubpath) and item2href != itemhref:
save2href = item2href[len(curepubpath):]
#logger.debug("Found %s -> %s"%(item2href,save2href))
outputepub.writestr(save2href,epub.read(item2href))
# declares all the files created by Windows. otherwise, when
# it runs in appengine, windows unzips the files as 000 perms.
for zf in outputepub.filelist:
zf.create_system = 0
outputepub.close()
outputios.append(outputio)
if outdir:
outfilenames=[]
for count,epubIO in enumerate(outputios):
filename="%s/%d.epub"%(outdir,count)
logger.debug("write %s"%filename)
outstream = open(filename,"wb")
outstream.write(epubIO.getvalue())
outstream.close()
outfilenames.append(filename)
return outfilenames
else:
return outputios
def testStringEncodings(self):
enum_policy_a = {
'name': 'SampleEnumPolicy.A',
'type': 'string-enum',
'items': [{
'name': 'tls1.2',
'value': 'tls1.2'
}]
}
enum_policy_b = {
'name': 'SampleEnumPolicy.B',
'type': 'string-enum',
'items': [{
'name': 'tls1.2',
'value': 'tls1.2'
}]
}
dom_impl = minidom.getDOMImplementation('')
self.writer._doc = dom_impl.createDocument(None, 'policyDefinitions',
None)
self.writer._active_policies_elem = self.writer._doc.documentElement
self.writer._active_mandatory_policy_group_name = 'PolicyGroup'
self.writer.WritePolicy(enum_policy_a)
self.writer.WritePolicy(enum_policy_b)
output = self.writer.GetTemplateText()
expected_output = (
'<?xml version="1.0" ?>\n'
'<policyDefinitions>\n'
' <policy class="TestClass" displayName="$(string.SampleEnumPolicy_A)"'
' explainText="$(string.SampleEnumPolicy_A_Explain)"'
' key="Software\\Policies\\Test" name="SampleEnumPolicy.A"'
' presentation="$(presentation.SampleEnumPolicy.A)">\n'
' <parentCategory ref="PolicyGroup"/>\n'
' <supportedOn ref="SUPPORTED_TESTOS"/>\n'
' <elements>\n'
' <enum id="SampleEnumPolicy.A" valueName="SampleEnumPolicy.A">\n'
' <item displayName="$(string.tls1_2)">\n'
' <value>\n'
' <string>tls1.2</string>\n'
' </value>\n'
' </item>\n'
' </enum>\n'
' </elements>\n'
' </policy>\n'
' <policy class="TestClass" displayName="$(string.SampleEnumPolicy_B)"'
' explainText="$(string.SampleEnumPolicy_B_Explain)"'
' key="Software\\Policies\\Test" name="SampleEnumPolicy.B"'
' presentation="$(presentation.SampleEnumPolicy.B)">\n'
' <parentCategory ref="PolicyGroup"/>\n'
' <supportedOn ref="SUPPORTED_TESTOS"/>\n'
' <elements>\n'
' <enum id="SampleEnumPolicy.B" valueName="SampleEnumPolicy.B">\n'
' <item displayName="$(string.tls1_2)">\n'
' <value>\n'
' <string>tls1.2</string>\n'
' </value>\n'
' </item>\n'
' </enum>\n'
' </elements>\n'
' </policy>\n'
'</policyDefinitions>')
self.AssertXMLEquals(output, expected_output)
