def build(cls, name, array, dim_names=None): """ Construct a LIGO Light Weight XML Array document subtree from a numpy array object. Example: >>> import numpy, sys >>> a = numpy.arange(12, dtype = "double") >>> a.shape = (4, 3) >>> Array.build(u"test", a).write(sys.stdout) # doctest: +NORMALIZE_WHITESPACE <Array Type="real_8" Name="test:array"> <Dim>3</Dim> <Dim>4</Dim> <Stream Delimiter=" " Type="Local"> 0 3 6 9 1 4 7 10 2 5 8 11 </Stream> </Array> """ # Type must be set for .__init__(); easier to set Name # afterwards to take advantage of encoding handled by # attribute proxy elem = cls( Attributes({u"Type": ligolwtypes.FromNumPyType[str(array.dtype)]})) elem.Name = name if dim_names is None: dim_names = [None] * len(array.shape) elif len(dim_names) != len(array.shape): raise ValueError( "dim_names must be same length as number of dimensions") for name, n in reversed(zip(dim_names, array.shape)): child = elem.appendChild(ligolw.Dim()) if name is not None: child.Name = name child.n = n elem.appendChild( ArrayStream( Attributes({ u"Type": ArrayStream.Type.default, u"Delimiter": ArrayStream.Delimiter.default }))) elem.array = array return elem
def _write_scaninfo(self): for scan in self.scaninfo: if type(scan) == type({}): self.write_parser.startElement("scaninfo", Attributes(dict(type = scan.get("type", ""), protocol = scan.get("protocol", ""), numservices = scan.get("numservices", ""), services = scan.get("services", "")))) self.write_parser.endElement("scaninfo")
def _write_permissions(self): permissions = self.permissions self.writer.startElement("permissions", Attributes({})) for perm in permissions: attrs = Attributes({'id': perm.id, 'type': perm.type}) self.writer.startElement("permission", attrs) if perm.description: self.writer.startElement("description", Attributes({})) self.writer.characters(perm.description) self.writer.endElement("description") for constraint in perm.constraints: self.writer.startElement("constraint", Attributes({'type': constraint.type})) self.writer.characters(constraint.content) self.writer.endElement("constraint") self.writer.endElement("permission") self.writer.endElement("permissions")
def _write_runstats(self): ################## # Runstats element self.write_parser.startElement("runstats", Attributes(dict())) ## Finished element self.write_parser.startElement("finished", Attributes(dict(time = str(self.finish_epoc_time)))) self.write_parser.endElement("finished") ## Hosts element self.write_parser.startElement("hosts", Attributes(dict(up = str(self.hosts_up), down = str(self.hosts_down), total = str(self.hosts_scanned)))) self.write_parser.endElement("hosts") self.write_parser.endElement("runstats")
def startElement(self, name, attrs): if name == "record" and self.processed > 0 \ and self.processed % self.groups_of == 0: self.new_handler() XMLFilterBase.startDocument(self) XMLFilterBase.startPrefixMapping(self, "", self.uri) XMLFilterBase.startElement(self, "collection", Attributes({})) if name != "collection": XMLFilterBase.startElement(self, name, attrs)
def _write_roles(self): roles = self.roles self.writer.startElement("roles", Attributes({})) for role in roles: self.writer.startElement("role", Attributes({'id': role.id})) if role.description: self.writer.startElement("description", Attributes({})) self.writer.characters(role.description) self.writer.endElement("description") if role.permissions: self.writer.startElement("permissions", Attributes({})) for p in role.permissions: self.writer.startElement("permission", Attributes({"ref": p.id})) self.writer.endElement("permission") self.writer.endElement("permissions") self.writer.endElement("role") self.writer.endElement("roles")
def from_array(name, array, dim_names=None): """ Construct a LIGO Light Weight XML Array document subtree from a numpy array object. Example: >>> import numpy, sys >>> a = numpy.arange(12, dtype = "double") >>> a.shape = (4, 3) >>> from_array(u"test", a).write(sys.stdout) # doctest: +NORMALIZE_WHITESPACE <Array Type="real_8" Name="test:array"> <Dim>3</Dim> <Dim>4</Dim> <Stream Delimiter=" " Type="Local"> 0 3 6 9 1 4 7 10 2 5 8 11 </Stream> </Array> """ # Type must be set for .__init__(); easier to set Name afterwards # to take advantage of encoding handled by attribute proxy doc = Array( Attributes({u"Type": ligolwtypes.FromNumPyType[str(array.dtype)]})) doc.Name = name for n, dim in enumerate(reversed(array.shape)): child = ligolw.Dim() if dim_names is not None: child.Name = dim_names[n] child.pcdata = unicode(dim) doc.appendChild(child) child = ArrayStream( Attributes({ u"Type": ArrayStream.Type.default, u"Delimiter": ArrayStream.Delimiter.default })) doc.appendChild(child) doc.array = array return doc
def write_xml_node(self, root): """ """ for child in root: self.startElement(child.get_name(), Attributes(child.get_attrs())) if child.get_text() != "": self.characters(child.get_text()) self.write_xml_node(child.get_children()) self.endElement(child.get_name())
def _write_nmaprun(self): self.write_parser.startElement("nmaprun", Attributes(dict(annotation = str(self.profile_annotation), args = str(self.nmap_command), description = str(self.profile_description), hint = str(self.profile_hint), nmap_output = str(self.nmap_output), options = str(self.profile_options), profile = str(self.profile), profile_name = str(self.profile_name), scanner = str(self.scanner), start = str(self.start), startstr = str(self.formated_date), target = str(self.target), version = str(self.scanner_version), scan_name = str(self.scan_name))))
def _write_nmaprun(self, writer): writer.startElement("nmaprun", Attributes(dict(args = str(self.nmap_command), description = str(self.profile_description), nmap_output = self.nmap_output, # Note that option arguments are discarded. This # is incorrect behavior. options = str(",".join(self.profile_options.keys())), profile = str(self.profile), profile_name = str(self.profile_name), scanner = str(self.scanner), start = str(self.start), startstr = str(self.formated_date), target = str(self.target), version = str(self.scanner_version), scan_name = str(self.scan_name))))
def startElement(self, name, attrs): if self.in_universe >= 0: self.in_universe += 1 if name == "zml_file": if attrs.getValue("version") != "0.1": raise FilterError, "Only format 0.1 is supported in this handler." attrs = Attributes({"version": "0.2"}) elif name == "model_object" and attrs["class"] == "Universe": self.in_universe = 0 elif self.in_universe == 1: if name == "array" and attrs["label"] == "cell": self.recording = "cell" self.cell = [] elif name == "array" and attrs["label"] == "cell_active": self.recording = "cell_active" self.cell_active = [] if self.recording is None: XMLFilterBase.startElement(self, name, attrs)
def endElement(self, name): if self.in_universe >= 0: self.in_universe -= 1 if self.in_universe == -1: # send the recorded tags in the new format if not (self.cell is None and self.cell_active is None): if self.cell is None: self.cell = numpy.identity(3, float)*20.0 if self.cell_active is None: self.cell_active = numpy.zeros(3, bool) XMLFilterBase.startElement(self, "unit_cell", Attributes({"label": "cell"})) # matrix XMLFilterBase.startElement(self, "array", Attributes({"label": "matrix"})) XMLFilterBase.startElement(self, "shape", Attributes({})) XMLFilterBase.characters(self, "3 3") XMLFilterBase.endElement(self, "shape") XMLFilterBase.startElement(self, "cells", Attributes({})) XMLFilterBase.characters(self, " ".join(str(v) for v in self.cell.ravel())) XMLFilterBase.endElement(self, "cells") XMLFilterBase.endElement(self, "array") # matrix XMLFilterBase.startElement(self, "array", Attributes({"label": "active"})) XMLFilterBase.startElement(self, "shape", Attributes({})) XMLFilterBase.characters(self, "3") XMLFilterBase.endElement(self, "shape") XMLFilterBase.startElement(self, "cells", Attributes({})) XMLFilterBase.characters(self, " ".join(str(v) for v in self.cell_active)) XMLFilterBase.endElement(self, "cells") XMLFilterBase.endElement(self, "array") # end unit cell XMLFilterBase.endElement(self, "unit_cell") if self.recording is None: XMLFilterBase.endElement(self, name) else: if name == "array" and self.recording == "cell": self.recording = None words = (" ".join(self.cell)).split()[2:] self.cell = numpy.array([float(v) for v in words]) self.cell.shape = (3,3) if name == "array" and self.recording == "cell_active": self.recording = None words = (" ".join(self.cell_active)).split()[1:] self.cell_active = numpy.array([eval(v) for v in words]) self.cell_active.shape = (3,)
def write_xml(self, xml_file=None): xml_file = xml_file or SECURITY_FILE if self._locked: raise ResourceBusyError else: self._locked = True xml = open(xml_file, "w", 1) xml.flush() xml.seek(0) self.writer = XMLGenerator(xml) self.writer.startDocument() self.writer.startElement("security", Attributes({})) self._write_permissions() self._write_roles() self._write_users() self.writer.endElement("security") self.writer.endDocument() xml.flush() xml.close() del xml self._locked = False
def _write_users(self): users = self.users self.writer.startElement("users", Attributes({})) for user in users: attrs = Attributes({'login': user.login, 'superuser': user.superuser and "yes" or "no"}) self.writer.startElement("user", attrs) if user.name: self.writer.startElement("name", Attributes({})) self.writer.characters(user.name) self.writer.endElement("name") self.writer.startElement("password", Attributes({})) self.writer.characters(user.password) self.writer.endElement("password") if user.roles: self.writer.startElement("roles", Attributes({})) for r in user.roles: self.writer.startElement("role", Attributes({'ref': r.id})) self.writer.endElement("role") self.writer.endElement("roles") self.writer.endElement("user") self.writer.endElement("users")
def _write_verbose(self, writer): writer.startElement("verbose", Attributes(dict( level=str(self.verbose_level)))) writer.endElement("verbose")
def _write_verbose(self): self.write_parser.startElement("verbose", Attributes(dict( level=str(self.verbose_level)))) self.write_parser.endElement("verbose")
def _write_debugging(self): self.write_parser.startElement("debugging", Attributes(dict( level=str(self.debugging_level)))) self.write_parser.endElement("debugging")
def _write_hosts(self): for host in self.hosts: # Start host element self.write_parser.startElement("host", Attributes(dict(comment=host.comment))) # Status element self.write_parser.startElement("status", Attributes(dict(state=host.state))) self.write_parser.endElement("status") ################## # Address elements ## IPv4 if type(host.ip) == type({}): self.write_parser.startElement("address", Attributes(dict(addr=host.ip.get("addr", ""), vendor=host.ip.get("vendor", ""), addrtype=host.ip.get("type", "")))) self.write_parser.endElement("address") ## IPv6 if type(host.ipv6) == type({}): self.write_parser.startElement("address", Attributes(dict(addr=host.ipv6.get("addr", ""), vendor=host.ipv6.get("vendor", ""), addrtype=host.ipv6.get("type", "")))) self.write_parser.endElement("address") ## MAC if type(host.mac) == type({}): self.write_parser.startElement("address", Attributes(dict(addr=host.mac.get("addr", ""), vendor=host.mac.get("vendor", ""), addrtype=host.mac.get("type", "")))) self.write_parser.endElement("address") # End of Address elements ######################### ################### # Hostnames element self.write_parser.startElement("hostnames", Attributes({})) for hname in host.hostnames: if type(hname) == type({}): self.write_parser.startElement("hostname", Attributes(dict(name = hname.get("hostname", ""), type = hname.get("hostname_type", "")))) self.write_parser.endElement("hostname") self.write_parser.endElement("hostnames") # End of Hostnames element ########################## ############### # Ports element self.write_parser.startElement("ports", Attributes({})) for ps in host.ports: ## Extraports elements for ext in ps["extraports"]: if type(ext) == type({}): self.write_parser.startElement("extraports", Attributes(dict(count = ext.get("count", ""), state = ext.get("state", "")))) self.write_parser.endElement("extraports") ## Port elements for p in ps["port"]: if type(p) == type({}): self.write_parser.startElement("port", Attributes(dict(portid = p.get("portid", ""), protocol = p.get("protocol", "")))) ### Port state self.write_parser.startElement("state", Attributes(dict(state=p.get("port_state", "")))) self.write_parser.endElement("state") ### Port service info self.write_parser.startElement("service", Attributes(dict(conf = p.get("service_conf", ""), method = p.get("service_method", ""), name = p.get("service_name", ""), product = p.get("service_product", ""), version = p.get("service_version", ""), extrainfo = p.get("service_extrainfo", "")\ ))) self.write_parser.endElement("service") self.write_parser.endElement("port") self.write_parser.endElement("ports") # End of Ports element ###################### ############ # OS element self.write_parser.startElement("os", Attributes({})) ## Ports used elements for pu in host.ports_used: if type(pu) == type({}): self.write_parser.startElement("portused", Attributes(dict(state = pu.get("state", ""), proto = pu.get("proto", ""), portid = pu.get("portid", "")))) self.write_parser.endElement("portused") ## Osclass elements for oc in host.osclasses: if type(oc) == type({}): self.write_parser.startElement("osclass", Attributes(dict(vendor = oc.get("vendor", ""), osfamily = oc.get("osfamily", ""), type = oc.get("type", ""), osgen = oc.get("osgen", ""), accuracy = oc.get("accuracy", "")))) self.write_parser.endElement("osclass") ## Osmatch elements if type(host.osmatch) == type({}): self.write_parser.startElement("osmatch", Attributes(dict(name = host.osmatch.get("name", ""), accuracy = host.osmatch.get("accuracy", "")))) self.write_parser.endElement("osmatch") self.write_parser.endElement("os") # End of OS element ################### # Uptime element if type(host.uptime) == type({}): self.write_parser.startElement("uptime", Attributes(dict(seconds = host.uptime.get("seconds", ""), lastboot = host.uptime.get("lastboot", "")))) self.write_parser.endElement("uptime") ##################### # Sequences elementes ## TCP Sequence element # Cannot use dict() here, because of the 'class' attribute. if type(host.tcpsequence) == type({}): self.write_parser.startElement("tcpsequence", Attributes({"index":host.tcpsequence.get("index", ""), "class":host.tcpsequence.get("class", ""), "difficulty":host.tcpsequence.get("difficulty", ""), "values":host.tcpsequence.get("values", "")})) self.write_parser.endElement("tcpsequence") ## IP ID Sequence element if type(host.ipidsequence) == type({}): self.write_parser.startElement("ipidsequence", Attributes({"class":host.ipidsequence.get("class", ""), "values":host.ipidsequence.get("values", "")})) self.write_parser.endElement("ipidsequence") ## TCP TS Sequence element if type(host.tcptssequence) == type({}): self.write_parser.startElement("tcptssequence", Attributes({"class":host.tcptssequence.get("class", ""), "values":host.tcptssequence.get("values", "")})) self.write_parser.endElement("tcptssequence") # End of sequences elements ########################### # End host element self.write_parser.endElement("host")
def _write_debugging(self, writer): writer.startElement("debugging", Attributes(dict( level=str(self.debugging_level)))) writer.endElement("debugging")