def __init__(self, apt_id, uri, dist, sections, local_path):
Element.__init__(self, 'aptsource')
self.setAttribute('apt_id', apt_id)
self.setAttribute('uri', uri)
self.setAttribute('dist', dist)
self.setAttribute('sections', sections)
self.setAttribute('local_path', local_path)
def xml_encode(self, text):
from xml.dom.minidom import Text, Element
t = Text()
t.data = text
e = Element('x')
e.appendChild(t)
return e.toxml()[3:-4]
def __init__(self, name, subtag_name, data, name_att='name'):
Element.__init__(self, name)
self.__data_dict__ = {}
for key, value in data.items():
self.__data_dict__[key] = TextElement(subtag_name, value)
self.__data_dict__[key].setAttribute('name', key)
self.appendChild(self.__data_dict__[key])
def get(self, *args):
self.response.headers['Content-Type'] = "application/rss+xml"
items = self.getItems(*args)
itemElems = []
for item in items:
itemElem = Element("item")
self._appendElementWithTextNode(itemElem, "title", item.title)
self._appendElementWithTextNode(itemElem, "link", item.link)
self._appendElementWithTextNode(itemElem, "description", item.description)
self._appendElementWithTextNode(itemElem, "guid", item.link)
if item.subPlaceFeedLink:
self._appendElementWithTextNode(itemElem, "sharkattackdata:subPlaceFeedLink", item.subPlaceFeedLink)
if item.attackFeedLink:
self._appendElementWithTextNode(itemElem, "sharkattackdata:attackFeedLink", item.attackFeedLink)
itemElems.append(itemElem)
# Need to make channel element after the generator returned by getItems has been iterated.
channelElem = Element("channel")
self._appendElementWithTextNode(channelElem, "title", self._feedTitle)
self._appendElementWithTextNode(channelElem, "link", self._feedLink)
self._appendElementWithTextNode(channelElem, "description", self._feedDescription)
for itemElem in itemElems:
channelElem.appendChild(itemElem)
responseText = """<?xml version="1.0"?>
<rss version="2.0" xmlns:sharkattackdata="http://sharkattackdata.com/rss/modules/1.0/">
%s
</rss>
""" % (channelElem.toprettyxml())
self.response.out.write(responseText)
def __init__(self, conn, machines=None):
raise RuntimeError , "ClientMachineDatabaseElement isn't working"
Element.__init__(self, 'machine_database')
self.conn = conn
if machines is not None:
self.machines = MachinesElement(conn, machines)
self.appendChild(self.machines)
def __init__(self, name):
Element.__init__(self, 'family')
self.setAttribute('name', name)
self.parents = Element('parents')
self.environ = Element('environ')
self.appendChild(self.parents)
self.appendChild(self.environ)
def __init__(self, name, localpath, paramvalues=[],
responsedestination=None):
Element.__init__(self, 'METHODCALL')
self.setName(name)
self.appendChild(localpath)
self.appendChildren(paramvalues)
self.appendOptionalChild(responsedestination)
def __init__(
self,
name,
type,
value_array=None,
array_size=None,
class_origin=None,
propagated=None,
qualifiers=[],
xml_lang=None,
embedded_object=None,
):
Element.__init__(self, "PROPERTY.ARRAY")
self.setName(name)
self.setAttribute("TYPE", type)
if array_size is not None:
self.setAttribute("ARRAYSIZE", str(array_size))
self.setOptionalAttribute("CLASSORIGIN", class_origin)
self.setOptionalAttribute("EmbeddedObject", embedded_object)
if propagated is not None:
self.setAttribute("PROPAGATED", str(propagated).lower())
self.setOptionalAttribute("xml:lang", xml_lang)
self.appendChildren(qualifiers)
self.appendOptionalChild(value_array)
def __init__(self, name, type, array_size=None, qualifiers=[]):
Element.__init__(self, "PARAMETER.ARRAY")
self.setName(name)
self.setAttribute("TYPE", type)
if array_size is not None:
self.setAttribute("ARRAYSIZE", str(array_size))
self.appendChildren(qualifiers)
def __init__(self, name, reference_class=None, array_size=None, qualifiers=[]):
Element.__init__(self, "PARAMETER.REFARRAY")
self.setName(name)
self.setOptionalAttribute("REFERENCECLASS", reference_class)
if array_size is not None:
self.setAttribute("ARRAYSIZE", str(array_size))
self.appendChildren(qualifiers)
def __init__(self, ownerDocument, name=""):
Element.__init__(self, TAG_CATEGORY)
self.name = name
self.ownerDocument = ownerDocument
self._items = []
self.setAttribute("name", self.name)
def __init__(
self,
name,
type,
value=None,
propagated=None,
overridable=None,
tosubclass=None,
toinstance=None,
translatable=None,
xml_lang=None,
):
Element.__init__(self, "QUALIFIER")
self.setName(name)
self.setAttribute("TYPE", type)
if propagated is not None:
self.setAttribute("PROPAGATED", str(propagated).lower())
if overridable is not None:
self.setAttribute("OVERRIDABLE", str(overridable).lower())
if tosubclass is not None:
self.setAttribute("TOSUBCLASS", str(tosubclass).lower())
if toinstance is not None:
self.setAttribute("TOINSTANCE", str(toinstance).lower())
if translatable is not None:
self.setAttribute("TRANSLATABLE", str(translatable).lower())
self.setOptionalAttribute("xml:lang", xml_lang)
self.appendOptionalChild(value)
def __init__(self, name, type, value, is_array=None,
array_size=None, qualifier_scopes={},
overridable=None, tosubclass=None,
toinstance=None, translatable=None):
Element.__init__(self, 'QUALIFIER.DECLARATION')
self.setName(name)
self.setAttribute('TYPE', type)
if is_array is not None:
self.setOptionalAttribute('ISARRAY', str(is_array).lower())
if array_size is not None:
self.setAttribute('ARRAYSIZE', str(array_size))
if overridable is not None:
self.setAttribute('OVERRIDABLE', str(overridable).lower())
if tosubclass is not None:
self.setAttribute('TOSUBCLASS', str(tosubclass).lower())
if toinstance is not None:
self.setAttribute('TOINSTANCE', str(toinstance).lower())
if translatable is not None:
self.setAttribute('TRANSLATABLE', str(translatable).lower())
if qualifier_scopes:
scope = SCOPE(qualifier_scopes)
self.appendOptionalChild(scope)
if value is not None:
if is_array:
xval = VALUE_ARRAY(value)
else:
xval = VALUE(value)
self.appendOptionalChild(xval)
def __init__(self, suite, nonus=False, updates=False, local=False, common=False):
Element.__init__(self, 'suite')
self.setAttribute('name', suite)
self.setAttribute('nonus', nonus)
self.setAttribute('updates', updates)
self.setAttribute('local', local)
self.setAttribute('common', common)
def _add_lang_to_html(htmltext, lang):
'''
Take a piece of HTML and add an xml:lang attribute to it.
'''
if lang == 'und':
return htmltext
parser = html5lib.HTMLParser(
tree=html5lib.treebuilders.getTreeBuilder("dom")
)
html = parser.parseFragment(htmltext)
html.normalize()
if len(html.childNodes) == 0:
return '<div xml:lang="%s"></div>' % lang
elif len(html.childNodes) == 1:
node = html.firstChild
if node.nodeType == Node.TEXT_NODE:
div = Element('div')
div.ownerDocument = html
div.setAttribute('xml:lang', lang)
div.childNodes = [node]
html.childNodes = [div]
else:
node.setAttribute('xml:lang', lang)
else:
#add a single encompassing div
div = Element('div')
div.ownerDocument = html
div.setAttribute('xml:lang', lang)
div.childNodes = html.childNodes
html.childNodes = [div]
return html.toxml()
def __init__(self, conn, path='/'):
Element.__init__(self, 'paelladatabase')
self.conn = conn
self.stmt = StatementCursor(self.conn)
self._profile_traits_ = ProfileTrait(self.conn)
self.path = path
self.aptsources = AptSourceListElement()
self.appendChild(self.aptsources)
if 'apt_sources' in self.stmt.tables():
for row in self.stmt.select(table='apt_sources', order=['apt_id']):
element = AptSourceElement(row.apt_id, row.uri, row.dist, row.sections,
row.local_path)
self.aptsources.appendChild(element)
self.suites = SuitesElement()
self.appendChild(self.suites)
for row in self._suite_rows():
args = map(str, [row.suite, row.nonus, row.updates, row.local, row.common])
element = SuiteElement(*args)
for suiteapt in self.stmt.select(table='suite_apt_sources', order=['ord'],
clause=Eq('suite', row.suite)):
element.appendChild(SuiteAptElement(row.suite,
suiteapt.apt_id, str(suiteapt.ord)))
self.suites.appendChild(element)
else:
print 'WARNING, apt_sources table does not exist, backing up anyway'
self.profiles = PaellaProfiles(self.conn)
self.family = Family(self.conn)
suites = [x.suite for x in self._suite_rows()]
for suite in suites:
self.appendChild(TraitsElement(self.conn, suite))
def __init__(self, suite, nonus=False, updates=False, local=False, common=False):
Element.__init__(self, "suite")
self.setAttribute("name", suite)
self.setAttribute("nonus", nonus)
self.setAttribute("updates", updates)
self.setAttribute("local", local)
self.setAttribute("common", common)
def __init__(self, name, data=None, paramtype=None,
embedded_object=None):
Element.__init__(self, 'PARAMVALUE')
self.setName(name)
self.setOptionalAttribute('PARAMTYPE', paramtype)
self.setOptionalAttribute('EmbeddedObject', embedded_object)
self.appendOptionalChild(data)
def __init__(self, mnt_name, mnt_point, fstype, mnt_opts, dump, pass_):
Element.__init__(self, "mount")
self.setAttribute("mnt_name", mnt_name)
self.setAttribute("mnt_point", mnt_point)
self.setAttribute("fstype", fstype)
self.setAttribute("mnt_opts", mnt_opts)
self.setAttribute("dump", dump)
self.setAttribute("pass", pass_)
def __init__(self, name, suite):
Element.__init__(self, "profile")
self.setAttribute("name", name)
self.setAttribute("suite", suite)
self.traits = Element("traits")
self.appendChild(self.traits)
self.environ = Element("environ")
self.appendChild(self.environ)
def node2xml(node):
"""Takes in a node object and returns an XML object for that node"""
ele = Element("node")
for k, v in node.attrs.items():
ele.setAttribute(k, v)
for k, v in node.tags.items():
ele.appendChild(tag2xml(k, v))
return ele
def set_scripts(self):
self.scripts = [x.script for x in self.traitscripts.scripts(self.name)]
while self.scripts_element.hasChildNodes():
del self.scripts_element.childNodes[0]
for script in self.scripts:
element = Element('script')
element.setAttribute('name', script)
self.scripts_element.appendChild(element)
def _getElementForMappingEntry(entry, mappingStyle):
e = Element(mappingStyle)
for k, v in entry.items():
# ignore empty, None or compiled regexp items into output
if not v or (k == "path-match-expr"):
continue
e.setAttribute(k, str(v))
return e
def __init__(self, classname, data):
Element.__init__(self, "INSTANCENAME")
self.setAttribute("CLASSNAME", classname)
if data is not None:
if type(data) == list:
self.appendChildren(data)
else:
self.appendChild(data)
def __init__(self):
Element.__init__(self, 'paelladatabase')
self.aptsources = AptSourceListElement()
self.appendChild(self.aptsources)
self.suites_element = SuitesElement()
self.suites = {}
self.suite_traits = {}
self.appendChild(self.suites_element)
def __init__(self, conn):
Element.__init__(self, 'machine_database')
self.conn = conn
self.kernels = KernelsElement(conn)
self.machines = MachineListElement(conn)
for e in [self.machines, self.kernels]:
self.appendChild(e)
def __init__(self, name, data=None):
Element.__init__(self, "METHODRESPONSE")
self.setName(name)
if data is not None:
if type(data) == tuple or type(data) == list:
self.appendChildren(data)
else:
self.appendChild(data)
def __init__(self, name, rows, key=False):
Element.__init__(self, name)
for row in rows:
if key:
rowdata = PkRowElement(row[key], row)
else:
rowdata = RowElement(row)
self.appendChild(rowdata)
def __init__(self, conn):
Element.__init__(self, 'profiles')
self.conn = conn
self.stmt = StatementCursor(self.conn)
self.env = ProfileEnvironment(self.conn)
self.profiletraits = ProfileTrait(self.conn)
self._profiles = {}
for row in self.stmt.select(table='profiles', order='profile'):
self._append_profile(row.profile, row.suite)
def __init__(self, conn):
Element.__init__(self, "mounts")
self.conn = conn
self.cursor = StatementCursor(self.conn)
self.cursor.set_table("mounts")
self.mounts = []
rows = self.cursor.select(order="mnt_name")
for r in rows:
self.append_mount(r.mnt_name, r.mnt_point, r.fstype, r.mnt_opts, r.dump, r["pass"])
def value_from_xml_element(self, xml: minidom.Element, registry: ObjectRegistry):
if xml.tagName != self.tag_name:
raise ValueError("Wrong value type (%s instead of %s)" % (xml.tagName, self.tag_name))
guid = xml.getAttribute("guid")
if guid and guid in registry.registry:
value = registry.registry[guid]
elif self.typename == "vector":
value = NVector(
float(xml_text(xml.getElementsByTagName("x")[0])),
float(xml_text(xml.getElementsByTagName("y")[0]))
)
if xml.getAttribute("guid"):
value.guid = xml.getAttribute("guid")
registry.register(value)
elif self.typename == "color":
value = NVector(
float(xml_text(xml.getElementsByTagName("r")[0])),
float(xml_text(xml.getElementsByTagName("g")[0])),
float(xml_text(xml.getElementsByTagName("b")[0])),
float(xml_text(xml.getElementsByTagName("a")[0]))
)
elif self.typename == "gradient":
value = [
GradientPoint.from_dom(sub, registry)
for sub in xml_child_elements(xml, GradientPoint.type.typename)
]
elif self.typename == "real" or self.typename == "angle":
value = float(xml.getAttribute("value"))
elif self.typename == "integer":
value = int(xml.getAttribute("value"))
elif self.typename == "time":
value = FrameTime.parse_string(xml.getAttribute("value"), registry)
elif self.typename == "bool":
value = str_to_bool(xml.getAttribute("value"))
elif self.typename == "string":
return xml_text(xml)
elif self.typename == "bone_object":
# Already done above but this forces the guid to be present
return registry.get_object(xml.getAttribute("guid"))
else:
raise ValueError("Unsupported type %s" % self.typename)
return self.type_wrapper(value)
def test_head(self):
"""
L{LatexSpitter.visitNode} writes out author information for each
I{link} element with a I{rel} attribute set to I{author}.
"""
head = Element('head')
first = Element('link')
first.setAttribute('rel', 'author')
first.setAttribute('title', 'alice')
second = Element('link')
second.setAttribute('rel', 'author')
second.setAttribute('href', 'http://example.com/bob')
third = Element('link')
third.setAttribute('rel', 'author')
third.setAttribute('href', 'mailto:[email protected]')
head.appendChild(first)
head.appendChild(second)
head.appendChild(third)
self.spitter.visitNode(head)
self.assertEqual(
''.join(self.output),
'\\author{alice \\and $<$http://example.com/bob$>$ \\and $<[email protected]$>$}')
def toXml(self):
xml = Element("ChapterAtom")
subtag = Element("ChapterUID")
text = Text()
text.data = str(self.UID)
subtag.appendChild(text)
xml.appendChild(subtag)
if self.timeStart is not None:
subtag = Element("ChapterTimeStart")
text = Text()
m, ms = divmod(self.timeStart, 60 * 10**9)
s1 = ms / 10**9
h1, m1 = divmod(m, 60)
text.data = f"{h1}:{m1:02d}:{s1:012.9f}"
subtag.appendChild(text)
xml.appendChild(subtag)
if self.timeEnd is not None:
subtag = Element("ChapterTimeEnd")
text = Text()
m, ms = divmod(self.timeEnd, 60 * 10**9)
s1 = ms / 10**9
h1, m1 = divmod(m, 60)
text.data = f"{h1}:{m1:02d}:{s1:012.9f}"
subtag.appendChild(text)
xml.appendChild(subtag)
subtag = Element("ChapterFlagHidden")
text = Text()
text.data = str(int(bool(self.hidden)))
subtag.appendChild(text)
xml.appendChild(subtag)
subtag = Element("ChapterFlagEnabled")
text = Text()
text.data = str(int(bool(self.enabled)))
subtag.appendChild(text)
xml.appendChild(subtag)
# TODO
if self.segmentUID is not None:
pass
if self.segmentEditionUID is not None:
pass
if self.tracks is not None:
pass
for display in self.displays:
xml.appendChild(display.toXml())
return xml
def __init__(self, suite):
Element.__init__(self, 'traits')
self.suite = suite
self.setAttribute('suite', self.suite)
def __init__(self, tag):
Element.__init__(self, tag)
class TraitElement(Element):
def __init__(self, conn, suite):
self.conn = conn
self.cursor = StatementCursor(self.conn, name='_Trait_')
Element.__init__(self, 'trait')
self.desc_element = TextElement('description', None)
self.parent_element = Element('parents')
self.pkg_element = Element('packages')
self.env_element = Element('environ')
self.templ_element = Element('templates')
self.scripts_element = Element('scripts')
self.appendChild(self.desc_element)
self.appendChild(self.parent_element)
self.appendChild(self.pkg_element)
self.appendChild(self.env_element)
self.appendChild(self.templ_element)
self.appendChild(self.scripts_element)
self.set_suite(suite)
def set_suite(self, suite):
self.suite = suite
# will probably make this a configuration option later
# turning it off for now.
if False:
self.setAttribute('suite', self.suite)
self.traitparent = TraitParent(self.conn, self.suite)
self.traitpackage = TraitPackage(self.conn, self.suite)
self.traittemplate = TraitTemplate(self.conn, self.suite)
self.traitscripts = TraitScript(self.conn, self.suite)
def set_environ(self):
self.environ = TraitEnvironment(self.conn, self.suite, self.name)
while self.env_element.hasChildNodes():
del self.env_element.childNodes[0]
for key, value in self.environ.items():
var_element = TraitVariableElement(self.name, key, value)
self.env_element.appendChild(var_element)
def set_parents(self):
self.parents = self.traitparent.parents(self.name)
while self.parent_element.hasChildNodes():
del self.parent_element.childNodes[0]
for parent in self.parents:
self.parent_element.appendChild(ParentElement(parent.parent))
def set_packages(self):
self.packages = self.traitpackage.packages([self.name])
while self.pkg_element.hasChildNodes():
del self.pkg_element.childNodes[0]
for package in self.packages:
pelement = PackageElement(package.package)
pelement.setAttribute('action', package.action)
self.pkg_element.appendChild(pelement)
def set_templates(self):
self.templates = self.traittemplate.templates(self.name)
while self.templ_element.hasChildNodes():
del self.templ_element.childNodes[0]
for template in self.templates:
element = TemplateElement(template.template)
for att in ['mode', 'owner', 'grp_owner']:
element.setAttribute(att, template[att])
self.templ_element.appendChild(element)
def set_scripts(self):
self.scripts = [x.script for x in self.traitscripts.scripts(self.name)]
while self.scripts_element.hasChildNodes():
del self.scripts_element.childNodes[0]
for script in self.scripts:
element = Element('script')
element.setAttribute('name', script)
self.scripts_element.appendChild(element)
def set_name(self, name):
self.name = name
self.setAttribute('name', self.name)
def set_priority(self, priority):
self.priority = priority
self.setAttribute('priority', self.priority)
def set(self, name):
self.set_name(name)
# this is probably not needed here, and slows things down
# considerably
#self.set_suite(self.suite)
self.set_environ()
self.set_parents()
self.set_packages()
self.set_templates()
self.set_scripts()
def str(self):
print self.toprettyxml()
def add_register(self, parent: minidom.Element, node: RegNode) -> None:
register = self.doc.createElement(self.ns + "register")
parent.appendChild(register)
self.add_nameGroup(register, self.get_name(node),
node.get_property("name", default=None),
node.get_property("desc"))
if (self.standard >= Standard.IEEE_1685_2014
) and not node.get_property("ispresent"):
self.add_value(register, self.ns + "isPresent", "0")
if node.is_array:
if node.array_stride != (node.get_property("regwidth") / 8):
self.msg.fatal(
"IP-XACT does not support register arrays whose stride is larger then the register's size",
node.inst.inst_src_ref)
for dim in node.array_dimensions:
self.add_value(register, self.ns + "dim", "%d" % dim)
self.add_value(register, self.ns + "addressOffset",
self.hex_str(self.get_reg_addr_offset(node)))
# DNE: <spirit/ipxact:typeIdentifier>
self.add_value(register, self.ns + "size",
"%d" % node.get_property("regwidth"))
if self._max_width is None:
self._max_width = node.get_property("regwidth")
else:
self._max_width = max(node.get_property("regwidth"),
self._max_width)
# DNE: <spirit/ipxact:volatile>
# DNE: <spirit/ipxact:access>
if self.standard <= Standard.IEEE_1685_2009:
reset = 0
mask = 0
for field in node.fields(skip_not_present=False):
field_reset = field.get_property("reset")
if field_reset is not None:
field_mask = ((1 << field.width) - 1) << field.lsb
field_reset = (field_reset << field.lsb) & field_mask
reset |= field_reset
mask |= field_mask
if mask != 0:
reset_el = self.doc.createElement(self.ns + "reset")
register.appendChild(reset_el)
self.add_value(reset_el, self.ns + "value",
self.hex_str(reset))
self.add_value(reset_el, self.ns + "mask", self.hex_str(mask))
for field in node.fields(skip_not_present=False):
self.add_field(register, field)
# DNE: <spirit/ipxact:alternateRegisters> [...]
# DNE: <spirit/ipxact:parameters>
vendorExtensions = self.doc.createElement(self.ns + "vendorExtensions")
self.register_vendorExtensions(vendorExtensions, node)
if vendorExtensions.hasChildNodes():
register.appendChild(vendorExtensions)
def __init__(self, name):
Element.__init__(self, 'script')
self.setAttribute('name', name)
def _create_failure_or_error(self, document, test, element_type):
element = Element(element_type)
element.setAttribute('type', self._get_attr(test, 'fail_class'))
element.setAttribute('message', self._get_attr(test, 'fail_reason'))
traceback_content = self._escape_cdata(
test.get('traceback', self.UNKNOWN))
traceback = document.createCDATASection(traceback_content)
element.appendChild(traceback)
system_out = Element('system-out')
try:
with open(test.get("logfile"), "r") as logfile_obj:
text_output = logfile_obj.read()
except (TypeError, IOError):
text_output = self.UNKNOWN
system_out_cdata_content = self._escape_cdata(text_output)
system_out_cdata = document.createCDATASection(
system_out_cdata_content)
system_out.appendChild(system_out_cdata)
element.appendChild(system_out)
return element
def __init__(self, partition, start, size, id):
Element.__init__(self, 'partition')
self.setAttribute('partition', partition)
self.setAttribute('start', start)
self.setAttribute('size', size)
self.setAttribute('Id', id)
def __init__(self, name):
Element.__init__(self, 'machine_type')
self.setAttribute('name', name)
self.devices = []
self.modules = []
self.machine_type = name
def from_dom(cls, xml: minidom.Element, registry: ObjectRegistry):
return GradientPoint(
value_from_xml_string(xml.getAttribute("pos"), float, registry),
cls.type.value_from_xml_element(xml, registry)
)
def setAttribute(self, attname, value):
if not attname in self.attOrder:
self.attOrder += [attname]
Element.setAttribute(self, attname, value)
def get_mobjects_from(
self,
element: MinidomElement,
inherited_style: Dict[str, str],
within_defs: bool = False,
) -> List[VMobject]:
"""Parses a given SVG element into a Mobject.
Parameters
----------
element : :class:`Element`
The SVG data in the XML to be parsed.
inherited_style : :class:`dict`
Dictionary of the SVG attributes for children to inherit.
within_defs : :class:`bool`
Whether ``element`` is within a ``defs`` element, which indicates
whether elements with `id` attributes should be added to the
definitions list.
Returns
-------
List[VMobject]
A VMobject representing the associated SVG element.
"""
result = []
# First, let all non-elements pass (like text entries)
if not isinstance(element, MinidomElement):
return result
style = cascade_element_style(element, inherited_style)
is_defs = element.tagName == "defs"
if element.tagName == "style":
pass # TODO, handle style
elif element.tagName in ["g", "svg", "symbol", "defs"]:
result += it.chain(*[
self.get_mobjects_from(
child, style, within_defs=within_defs or is_defs)
for child in element.childNodes
])
elif element.tagName == "path":
temp = element.getAttribute("d")
if temp != "":
result.append(self.path_string_to_mobject(temp, style))
elif element.tagName == "use":
# note, style is calcuated in a different way for `use` elements.
result += self.use_to_mobjects(element, style)
elif element.tagName == "rect":
result.append(self.rect_to_mobject(element, style))
elif element.tagName == "circle":
result.append(self.circle_to_mobject(element, style))
elif element.tagName == "ellipse":
result.append(self.ellipse_to_mobject(element, style))
elif element.tagName in ["polygon", "polyline"]:
result.append(self.polygon_to_mobject(element, style))
else:
pass # TODO
result = [m for m in result if m is not None]
self.handle_transforms(element, VGroup(*result))
if len(result) > 1 and not self.unpack_groups:
result = [VGroup(*result)]
if within_defs and element.hasAttribute("id"):
# it seems wasteful to throw away the actual element,
# but I'd like the parsing to be as similar as possible
self.def_map[element.getAttribute("id")] = (style, element)
if is_defs:
# defs shouldn't be part of the result tree, only the id dictionary.
return []
return result
def add_field(self, parent: minidom.Element, node: FieldNode) -> None:
field = self.doc.createElement(self.ns + "field")
parent.appendChild(field)
self.add_nameGroup(field, self.get_name(node),
node.get_property("name", default=None),
node.get_property("desc"))
if (self.standard >= Standard.IEEE_1685_2014
) and not node.get_property("ispresent"):
self.add_value(field, self.ns + "isPresent", "0")
self.add_value(field, self.ns + "bitOffset", "%d" % node.low)
if self.standard >= Standard.IEEE_1685_2014:
reset = node.get_property("reset")
if reset is not None:
resets_el = self.doc.createElement(self.ns + "resets")
field.appendChild(resets_el)
reset_el = self.doc.createElement(self.ns + "reset")
resets_el.appendChild(reset_el)
self.add_value(reset_el, self.ns + "value",
self.hex_str(reset))
# DNE: <spirit/ipxact:typeIdentifier>
self.add_value(field, self.ns + "bitWidth", "%d" % node.width)
if node.is_volatile:
self.add_value(field, self.ns + "volatile", "true")
sw = node.get_property("sw")
self.add_value(field, self.ns + "access", typemaps.access_from_sw(sw))
encode = node.get_property("encode")
if encode is not None:
enum_values_el = self.doc.createElement(self.ns +
"enumeratedValues")
field.appendChild(enum_values_el)
for enum_value in encode:
enum_value_el = self.doc.createElement(self.ns +
"enumeratedValue")
enum_values_el.appendChild(enum_value_el)
self.add_nameGroup(enum_value_el, enum_value.name,
enum_value.rdl_name, enum_value.rdl_desc)
self.add_value(enum_value_el, self.ns + "value",
self.hex_str(enum_value.value))
# DNE <spirit/ipxact:vendorExtensions>
onwrite = node.get_property("onwrite")
if onwrite:
self.add_value(field, self.ns + "modifiedWriteValue",
typemaps.mwv_from_onwrite(onwrite))
# DNE: <spirit/ipxact:writeValueConstraint>
onread = node.get_property("onread")
if onread:
self.add_value(field, self.ns + "readAction",
typemaps.readaction_from_onread(onread))
if node.get_property("donttest"):
self.add_value(field, self.ns + "testable", "false")
# DNE: <ipxact:reserved>
# DNE: <spirit/ipxact:parameters>
vendorExtensions = self.doc.createElement(self.ns + "vendorExtensions")
self.field_vendorExtensions(vendorExtensions, node)
if vendorExtensions.hasChildNodes():
field.appendChild(vendorExtensions)
def render(self, request):
"""
Render as HTML a listing of all known users with links to their
personal resources.
"""
listing = Element('ul')
for link, text in self._users():
linkElement = Element('a')
linkElement.setAttribute('href', link + '/')
textNode = Text()
textNode.data = text
linkElement.appendChild(textNode)
item = Element('li')
item.appendChild(linkElement)
listing.appendChild(item)
return self.template % {'users': listing.toxml()}
def add_value(self, parent: minidom.Element, tag: str, value: str) -> None:
el = self.doc.createElement(tag)
txt = self.doc.createTextNode(value)
el.appendChild(txt)
parent.appendChild(el)
def rect_to_mobject(self, rect_element: MinidomElement, style: dict):
"""Converts a SVG <rect> command to a VMobject.
Parameters
----------
rect_element : minidom.Element
A SVG rect path command.
style : dict
Style specification, using the SVG names for properties.
Returns
-------
Rectangle
Creates either a Rectangle, or RoundRectangle, VMobject from a
rect element.
"""
stroke_width = rect_element.getAttribute("stroke-width")
corner_radius = rect_element.getAttribute("rx")
if stroke_width in ["", "none", "0"]:
stroke_width = 0
if corner_radius in ["", "0", "none"]:
corner_radius = 0
corner_radius = float(corner_radius)
parsed_style = parse_style(style)
parsed_style["stroke_width"] = stroke_width
if corner_radius == 0:
if config["renderer"] == "opengl":
mob = OpenGLRectangle(
width=self.attribute_to_float(
rect_element.getAttribute("width")),
height=self.attribute_to_float(
rect_element.getAttribute("height")),
**parsed_style,
)
else:
mob = Rectangle(
width=self.attribute_to_float(
rect_element.getAttribute("width")),
height=self.attribute_to_float(
rect_element.getAttribute("height")),
**parsed_style,
)
else:
if config["renderer"] == "opengl":
mob = OpenGLRoundedRectangle(
width=self.attribute_to_float(
rect_element.getAttribute("width")),
height=self.attribute_to_float(
rect_element.getAttribute("height")),
corner_radius=corner_radius,
**parsed_style,
)
else:
mob = RoundedRectangle(
width=self.attribute_to_float(
rect_element.getAttribute("width")),
height=self.attribute_to_float(
rect_element.getAttribute("height")),
corner_radius=corner_radius,
**parsed_style,
)
mob.shift(mob.get_center() - mob.get_corner(UP + LEFT))
return mob
def _merge_placeholder_broken_inside_runs_if_required(paragraph: Element):
"""Merge broken runs containing mustache placeholders.
:param paragraph: paragraph xml element containing broken runs
docx document is made up of paragraph among other things. A run is a part
of a paragraph with different formatting(color, bold...). But most times
Microsoft word and libreoffice Writer splits up text with same formatting
into different runs. If this text contains mustache placeholders, it will
be missed by mustache renderer.
This method merges runs into one if it contains mustache placeholders.
"""
runs = paragraph.getElementsByTagNameNS(_namespaces['w'], 'r')
def _merge(run: Element,
text_to_replace='',
open_brace_count=0,
close_brace_count=0,
runs_to_merge=None):
"""Merge placeholders broken into runs
Microsoft Word and libreoffice most times split placeholders into
multiple runs. For example
<w:r>
<w:rPr>
<w:b w:val="false"/>
<w:bCs w:val="false"/>
</w:rPr>
<w:t>{{PRODUCTS</w:t>
</w:r>
<w:r>
<w:rPr/>
<w:t>}}</w:t>
</w:r>
We need to merge this into one run while retaining the style
"""
if runs_to_merge is None:
runs_to_merge = []
if run is None:
return
elif not run_contains_text(run):
pass
else:
text = get_run_text(run)
open_brace_count += text.count('{{')
close_brace_count += text.count('}}')
text_to_replace += text
# Once we have matching nodes, set text_to_replace as value to the
# last run and remove previous runs
if not open_brace_count == close_brace_count:
runs_to_merge.append(run)
elif runs_to_merge:
set_run_text(run, text_to_replace)
for r in runs_to_merge:
paragraph.removeChild(r)
runs_to_merge = []
text_to_replace = ''
return _merge(run.nextSibling, text_to_replace, open_brace_count,
close_brace_count, runs_to_merge)
_merge(runs[0])
def __init__(self, conn, suite):
self.conn = conn
self.cursor = StatementCursor(self.conn, name='_Trait_')
Element.__init__(self, 'trait')
self.desc_element = TextElement('description', None)
self.parent_element = Element('parents')
self.pkg_element = Element('packages')
self.env_element = Element('environ')
self.templ_element = Element('templates')
self.scripts_element = Element('scripts')
self.debconf_element = DebConfigurationElement()
self.appendChild(self.desc_element)
self.appendChild(self.parent_element)
self.appendChild(self.pkg_element)
self.appendChild(self.env_element)
self.appendChild(self.templ_element)
self.appendChild(self.debconf_element)
self.appendChild(self.scripts_element)
self.set_suite(suite)
def append_trait(self, trait):
element = Element('trait')
element.setAttribute('name', trait)
self.appendChild(element)
class TraitElement(Element):
def __init__(self, conn, suite):
self.conn = conn
self.cursor = StatementCursor(self.conn, name='_Trait_')
Element.__init__(self, 'trait')
self.desc_element = TextElement('description', None)
self.parent_element = Element('parents')
self.pkg_element = Element('packages')
self.env_element = Element('environ')
self.templ_element = Element('templates')
self.scripts_element = Element('scripts')
self.debconf_element = DebConfigurationElement()
self.appendChild(self.desc_element)
self.appendChild(self.parent_element)
self.appendChild(self.pkg_element)
self.appendChild(self.env_element)
self.appendChild(self.templ_element)
self.appendChild(self.debconf_element)
self.appendChild(self.scripts_element)
self.set_suite(suite)
def set_suite(self, suite):
self.suite = suite
self.setAttribute('suite', self.suite)
self.traitparent = TraitParent(self.conn, self.suite)
self.traitpackage = TraitPackage(self.conn, self.suite)
self.traittemplate = TraitTemplate(self.conn, self.suite)
self.traitdebconf = TraitDebconf(self.conn, self.suite)
self.traitscripts = TraitScript(self.conn, self.suite)
def set_environ(self):
self.environ = TraitEnvironment(self.conn, self.suite, self.name)
new_element = EnvironElement(self.environ)
self.replaceChild(new_element, self.env_element)
self.env_element = new_element
def set_parents(self):
self.parents = self.traitparent.parents(self.name)
while self.parent_element.hasChildNodes():
del self.parent_element.childNodes[0]
for parent in self.parents:
self.parent_element.appendChild(ParentElement(parent.parent))
def set_packages(self):
self.packages = self.traitpackage.packages([self.name])
while self.pkg_element.hasChildNodes():
del self.pkg_element.childNodes[0]
for package in self.packages:
pelement = PackageElement(package.package)
pelement.setAttribute('action', package.action)
self.pkg_element.appendChild(pelement)
def set_templates(self):
self.templates = self.traittemplate.templates(self.name)
while self.templ_element.hasChildNodes():
del self.templ_element.childNodes[0]
for template in self.templates:
element = TemplateElement(template.package, template.template)
for att in ['package', 'mode', 'owner', 'grp_owner']:
element.setAttribute(att, template[att])
self.templ_element.appendChild(element)
def set_debconf(self):
self.debconf = self.traitdebconf.trait_debconf(self.name)
while self.debconf_element.hasChildNodes():
del self.debconf_element.childNodes[0]
for debconf in self.debconf:
element = DebConfElement(self.name, debconf)
self.debconf_element.appendChild(element)
def set_scripts(self):
self.scripts = [x.script for x in self.traitscripts.scripts(self.name)]
while self.scripts_element.hasChildNodes():
del self.scripts_element.childNodes[0]
for script in self.scripts:
element = Element('script')
element.setAttribute('name', script)
self.scripts_element.appendChild(element)
def set_name(self, name):
self.name = name
self.setAttribute('name', self.name)
def set_priority(self, priority):
self.priority = priority
self.setAttribute('priority', self.priority)
def set(self, name):
self.set_name(name)
self.set_suite(self.suite)
self.set_environ()
self.set_parents()
self.set_packages()
self.set_templates()
self.set_debconf()
self.set_scripts()
def str(self):
print self.toprettyxml()
def toXml(self):
xml = Element("EditionEntry")
subtag = Element("EditionUID")
text = Text()
text.data = str(self.UID)
subtag.appendChild(text)
xml.appendChild(subtag)
subtag = Element("EditionFlagHidden")
text = Text()
text.data = str(int(bool(self.hidden)))
subtag.appendChild(text)
xml.appendChild(subtag)
subtag = Element("EditionFlagDefault")
text = Text()
text.data = str(int(bool(self.default)))
subtag.appendChild(text)
xml.appendChild(subtag)
subtag = Element("EditionFlagOrdered")
text = Text()
text.data = str(int(bool(self.ordered)))
subtag.appendChild(text)
xml.appendChild(subtag)
for chapter in self:
xml.appendChild(chapter.toXml())
return xml
def create_domain_xml(vm_name, mem_size, vcpus, dev_type, img_source, vnc_port,
clock_type, vnc_passwd, arch, machine, interfaces):
# domain
result = Element("domain")
result.setAttribute("type", "kvm")
# name
name = Element("name")
vmname = Text()
vmname.data = vm_name
name.appendChild(vmname)
result.appendChild(name)
# uuid
uid = Element("uuid")
vmuid = Text()
vmuid.data = uuid.uuid4()
uid.appendChild(vmuid)
result.appendChild(uid)
# memory 最大
memory = Element("memory")
vmmemory = Text()
vmmemory.data = int(mem_size) * 1024
memory.appendChild(vmmemory)
result.appendChild(memory)
# currentMemory 大小写区分，注意
currentmemory = Element("currentMemory")
vmcurrentmemory = Text()
vmcurrentmemory.data = int(mem_size) * 1024
currentmemory.appendChild(vmcurrentmemory)
result.appendChild(currentmemory)
# vcpus
vcpu = Element("vcpu")
vmvcpu = Text()
vmvcpu.data = str(vcpus)
vcpu.appendChild(vmvcpu)
result.appendChild(vcpu)
# os
osys = Element("os")
ostype = Element("type")
#ostype.setAttribute("arch", os.popen('uname -m').readline().strip('\n'))
ostype.setAttribute("arch", arch)
ostype.setAttribute("machine", machine)
osvirt = Text()
osvirt.data = "hvm"
ostype.appendChild(osvirt)
osys.appendChild(ostype)
#boot
boot = Element("boot")
boot.setAttribute("dev", dev_type)
osys.appendChild(boot)
result.appendChild(osys)
# clock
clock = Element("clock")
clock.setAttribute("sync", clock_type)
result.appendChild(clock)
# features
features = Element("features")
acpi = Element("acpi")
apic = Element("apic")
pae = Element("pae")
features.appendChild(acpi)
features.appendChild(apic)
features.appendChild(pae)
result.appendChild(features)
# devices
devices = Element("devices")
#1 emulator
emulator = Element("emulator")
vmemulator = Text()
vmemulator.data = "/usr/libexec/qemu-kvm"
emulator.appendChild(vmemulator)
devices.appendChild(emulator)
#2 disk
disk = Element("disk")
disk.setAttribute("type", "file")
disk.setAttribute("device", "disk")
source = Element("source")
source.setAttribute("file", img_source)
target = Element("target")
target.setAttribute("dev", "hda")
target.setAttribute("bus", "ide")
driver = Element("driver")
driver.setAttribute("name", "qemu")
driver.setAttribute("type", "qcow2")
disk.appendChild(source)
disk.appendChild(target)
disk.appendChild(driver)
devices.appendChild(disk)
#3 cdrom
disk = Element("disk")
disk.setAttribute("type", "block")
disk.setAttribute("device", "cdrom")
source = Element("source")
#source.setAttribute("file", "/home/local/ubuntu.iso")
target = Element("target")
target.setAttribute("dev", "hdc")
target.setAttribute("bus", "ide")
disk.appendChild(source)
disk.appendChild(target)
devices.appendChild(disk)
#4 interface for 多网卡
for inter in interfaces:
interface = Element("interface")
interface.setAttribute("type", "bridge")
mac = Element("mac")
mac.setAttribute("address", inter["macs"])
model = Element("model")
model.setAttribute("type", inter["br_type"])
source = Element("source")
source.setAttribute("bridge", inter["br"])
vifname = Element("target")
vifname.setAttribute("dev", inter["vif_name"])
interface.appendChild(model)
interface.appendChild(mac)
interface.appendChild(source)
interface.appendChild(vifname)
devices.appendChild(interface)
#5. input
input = Element("input")
input.setAttribute("type", "mouse")
input.setAttribute("bus", "ps2")
devices.appendChild(input)
#5.2 input
inputusb = Element("input")
inputusb.setAttribute("type", "tablet")
inputusb.setAttribute("bus", "usb")
devices.appendChild(inputusb)
#6 vnc
vnc = Element("graphics")
vnc.setAttribute("type", "vnc")
vnc.setAttribute("port", str(vnc_port))
vnc.setAttribute("passwd", vnc_passwd)
vnc.setAttribute("autoport", "no")
vnc.setAttribute("keymap", "en-us")
vnc.setAttribute("listen", "0.0.0.0")
devices.appendChild(vnc)
result.appendChild(devices)
# states
vmstate = Text()
vmstate.data = "destroy"
state = Element("on_poweroff")
state.appendChild(vmstate)
result.appendChild(state)
vmstate = Text()
vmstate.data = "restart"
state = Element("on_reboot")
state.appendChild(vmstate)
result.appendChild(state)
vmstate = Text()
vmstate.data = "destroy"
state = Element("on_crash")
state.appendChild(vmstate)
result.appendChild(state)
return result
def toXml(self):
xml = Element("ChapterDisplay")
subtag = Element("ChapterString")
text = Text()
text.data = self.string
subtag.appendChild(text)
xml.appendChild(subtag)
for lang in self.languages:
subtag = Element("ChapterLanguage")
text = Text()
text.data = lang
subtag.appendChild(text)
xml.appendChild(subtag)
for lang in self.langIETF:
subtag = Element("ChapterLanguageIETF")
text = Text()
text.data = lang
subtag.appendChild(text)
xml.appendChild(subtag)
for country in self.countries:
subtag = Element("ChapterCountry")
text = Text()
text.data = country
subtag.appendChild(text)
xml.appendChild(subtag)
return xml
def _create_failure_or_error(self, document, test, element_type):
element = Element(element_type)
element.setAttribute('type', self._get_attr(test, 'fail_class'))
element.setAttribute('message', self._get_attr(test, 'fail_reason'))
traceback_content = self._escape_cdata(
test.get('traceback', self.UNKNOWN))
traceback = document.createCDATASection(traceback_content)
element.appendChild(traceback)
system_out = Element('system-out')
system_out_cdata_content = self._escape_cdata(
test.get('text_output', self.UNKNOWN))
system_out_cdata = document.createCDATASection(
system_out_cdata_content)
system_out.appendChild(system_out_cdata)
element.appendChild(system_out)
return element
def __init__(self, diskname, device):
Element.__init__(self, 'machine_disk')
self.setAttribute('diskname', diskname)
self.setAttribute('device', device)
def __init__(self, mnt_name, ord, partition):
Element.__init__(self, 'filesystem_mount')
self.setAttribute('mnt_name', mnt_name)
self.setAttribute('ord', ord)
self.setAttribute('partition', partition)
def __init__(self, diskname):
Element.__init__(self, 'diskname')
self.setAttribute('name', diskname)
self.partitions = []
self.diskname = diskname
def get_file_address(root: minidom.Element, base: str):
filename = root.getElementsByTagName(name="filename")[0].childNodes[0].data
return os.path.join(base, str(filename))
