def addRow(request): email = request.COOKIES.get('user') d = dict() try: d['user'] = User.objects.get(email=email) except: d['message'] = 'Unknown user.' d['redirect'] = "/" # redirect to main page return getDbData(request) if request.method == 'POST': projname = request.POST['projname'] tablename = request.POST['tablename'] # rowdata is a list of data: ["prvni sloupec","druhy sloupec",...] # je treba to tu nejak poskladat, musi to byt seznam kvuli poradi zaznamu... #rowdata = ["0","pepa"] # temporary data rowdata = json.loads(request.POST['rowdata']) rowdata[0] = XML.GenerateID(enc(d['user'].pk, projname), tablename) try: XML.AddRow(enc(d['user'].pk, projname), tablename, rowdata) except XML.DoesNotExistError: d['message'] = 'Database or table does not exist.' except XML.IncompatibleRowDataError: d['message'] = 'Row data incompatible.' except XML.TableNotFoundError: d['message'] = 'Table was not found.' #print(d['message']) return getDbData(request)
def test_countChildren_multipleChildren(self): s = "<xml><THU><Team><ACRush></ACRush><Jelly></Jelly><Cooly></Cooly></Team><JiaJia><Team><Ahyangyi></Ahyangyi><Dragon></Dragon><Cooly><Amber></Amber></Cooly></Team></JiaJia></THU><Team><Cooly></Cooly><Jelly></Jelly></Team></xml>" a = fromstring(s) pattern = XML.getPattern(a) patternChildren = 0 patternChildren = XML.countChildren(pattern) self.assertTrue(patternChildren == 2)
def main(): # part1: #------------------------------------------------------------------- Part1.Part1() #------------------------------------------------------------------- # part2: #------------------------------------------------------------------- # set last parameter to true to enable export of shots stitched_shots, all_shots, outstitched_shots = Part2.Part2(False) #------------------------------------------------------------------- #html stuff: #------------------------------------------------------------------- HTML.html_stuff(stitched_shots, all_shots, outstitched_shots, 'Oberstdorf16-shots.csv', './html_input/index_part1.txt', './html_input/index_part2.txt', './html_output/index.html') #------------------------------------------------------------------- #xml stuff: #------------------------------------------------------------------- XML.create_XML('caffe_output.txt')
def dumb_loop(self, ip='localhost', port=49494, dest_ip='localhost', dest_port=8000): #print("in dumb loop") #ping the game server sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) #sock.bind((ip, port)) sock.connect((dest_ip, dest_port)) #sock.listen(1) while True: #connection, client_addr = sock.accept() data = XML.add_spaces(sock.recv(8192)) #print(data) msg_type = data.split()[0][1:-1] if msg_type == 'start-game': #print("SPlayer::dumb_loop: got a start-game") sg_d = xmltodict.parse(data) name = self.startGame(sg_d['start-game']) sock.sendall(XML.encode_name(name)) elif msg_type == 'do-move': #print("SPlayer::dumb_loop: got a do-move") board, dice = XML.decode_do_move(xmltodict.parse(data)['do-move']) moves = self.doMove(board, dice) encoded_moves = XML.encode_moves(moves) #print("sending these moves back: "+encoded_moves) #print("") sock.sendall(encoded_moves) elif msg_type == 'doubles-penalty': #print("SPlayer::dumb_loop: got a doubles-penalty") self.doublesPenalty() sock.sendall(XML.encode_void())
def preprocess(self): message = XML.dig(self.xml, "message") if not message: raise XML.XMLValidityError("A Message's root node must be named 'message'") # Stamp it with the current time if it has no timestamp yet if not XML.dig(message, "timestamp"): XML.addElement(message, "timestamp", "%d" % time.time())
def dbIter(self): if os.path.isfile(self.path): dom = XML.parseStream(open(self.path)) for element in XML.getChildElements(dom.documentElement): if element.nodeName == "ruleset": yield element else: log.msg("The file %r does not exist, loading no rulesets" % self.path)
def textComponent(self, element, args, *path): """A convenience function for defining components that just look for a node in the message and return its shallowText. """ element = XML.dig(args.message.xml, *path) if element: return [XML.shallowText(element)] else: return [MarkAsHidden()]
def test_findMatches_guaranteed_match(self): s = "<xml><THU><Team></Team></THU><THU></THU></xml>" a = fromstring(s) pattern = XML.getPattern(a) patternChildren = 0 patternChildren = XML.countChildren(pattern) XML.matches = 0 XML.findMatches(a, pattern, patternChildren) self.assertTrue(XML.matches == 0)
def test_count_breadth(self): s = "<xml><THU><Team></Team><ACRush></ACRush><Jelly></Jelly><Cooly></Cooly><JiaJia></JiaJia><Ahyangyi></Ahyangyi><Dragon></Dragon></THU></xml>" a = fromstring(s) pattern = XML.getPattern(a) patternChildren = 0 patternChildren = XML.countChildren(pattern) XML.numElements = 0 XML.numElements = XML.count(a, pattern, patternChildren) self.assertTrue(XML.numElements == 8)
def test_findMatches(self): s = "<xml><THU><Team><ACRush></ACRush><Jelly></Jelly><Cooly></Cooly></Team><JiaJia><Team><Ahyangyi></Ahyangyi><Dragon></Dragon><Cooly><Amber></Amber></Cooly></Team></JiaJia></THU><Team><Cooly></Cooly></Team></xml>" a = fromstring(s) pattern = XML.getPattern(a) patternChildren = 0 patternChildren = XML.countChildren(pattern) XML.locations = [] XML.locations = XML.findMatches(a, pattern, patternChildren) self.assertTrue(XML.locations == []) #function only works in conjunction with the count function
def test_count(self): s = "<xml><THU>\n\t<Team>\n\t\t<ACRush></ACRush>\n\t\t<Jelly></Jelly>\n\t\t<Cooly></Cooly>\n\t</Team>\n\t<JiaJia>\n\t\t<Team>\n\t\t\t<Ahyangyi></Ahyangyi>\n\t\t\t<Dragon></Dragon>\n\t\t\t<Cooly><Amber></Amber></Cooly>\n\t\t</Team>\n\t</JiaJia>\n</THU>\n<Team><Cooly></Cooly></Team>\n</xml>" a = fromstring(s) pattern = XML.getPattern(a) patternChildren = 0 patternChildren = XML.countChildren(pattern) XML.numElements = 0 XML.numElements = XML.count(a, pattern, patternChildren) self.assertTrue(XML.numElements == 13)
def preprocess(self): message = XML.dig(self.xml, "message") if not message: raise XML.XMLValidityError( "A Message's root node must be named 'message'") # Stamp it with the current time if it has no timestamp yet if not XML.dig(message, "timestamp"): XML.addElement(message, "timestamp", "%d" % time.time())
def __getPublicPrefs(): # # Return an XML description of all exposed preferences # global __publicPrefs pp = XML.Element("PluginPreferences") for key in __publicPrefs: e = XML.ElementWithText(key, Get(key)) e.set("description", __publicPrefs[key]) pp.append(e) return XML.ElementToString(pp)
def getXMLMailHeaders(self, document): """Return a <mailHeaders> tag representing a subset of the headers for this message. This is placed in the <generator> tag of any message passing through this module, to document and log the message's true source. """ node = document.createElementNS(None, "mailHeaders") for name, value in self.message.items(): if name in interestingHeaders: XML.addElement(node, "header", content=str(value)).setAttributeNS(None, 'name', name) return node
def main(): # Creating the banner: print(create_banner()) # Asking the user in which mode the program needs to be run: mode = ask_mode() # If the program is ran in mode 2, ask the IP-address and present results form SQLite database: if mode == '2': ip_address = ask_ip_address() SQL.show_results(ip_address) sys.exit() # Asking for user input needed to execute the portscan: scan_type = ask_scantype() target = ask_host() first_port = ask_first_port() last_port = ask_last_port(first_port) save_output = ask_output() # Creating the dictionary to store scan results: portscan = create_dict(target, scan_type) # Check which scan to conduct and execute scan (while using threading to speed up the scan): if scan_type == "TCP-Connect Scan": print(70 * "-" + "\n*** Starting TCP-Connect Scan ***") threader(portscans.TCP_connect_scan, target, first_port, last_port, portscan) elif scan_type == "UDP Scan": print(70 * "-" + "\n*** Starting UDP Scan ***") # Executing UDP scan without threading, because this creates false positives, # possibly because packets are sent faster then the router can respond with an ICMP type 3 code 3 packet: portscans.UDP_scan(target, first_port, last_port, portscan) elif scan_type == "TCP-SYN Scan": print(70 * "-" + "\n*** Starting TCP-SYN Scan ***") threader(portscans.TCP_SYN_scan, target, first_port, last_port, portscan) elif scan_type == "TCP-XMAS Scan": print(70 * "-" + "\n*** Starting TCP-XMAS Scan ***") threader(portscans.XMAS_scan, target, first_port, last_port, portscan) # Sorting the lists within the portscan dictionary: sort_dict(portscan) # Writing the scan results to a XML or JSON file, if specified: if save_output: if save_output in ['xml', 'XML']: XML.writeToXML(portscan) elif save_output in ['json', 'JSON']: writeToJSON(portscan) # Writing the scan results to a SQLite database file: SQL.writeToSQLite(portscan) # Printing finished line: print("*** Portscan finished ***")
def getXMLMailHeaders(self, document): """Return a <mailHeaders> tag representing a subset of the headers for this message. This is placed in the <generator> tag of any message passing through this module, to document and log the message's true source. """ node = document.createElementNS(None, "mailHeaders") for name, value in self.message.items(): if name in interestingHeaders: XML.addElement(node, "header", content=str(value)).setAttributeNS( None, 'name', name) return node
def pathMatchTag(self, element, function, textExtractor=XML.shallowText): """Implements the logic common to all tags that test the text matched by an XPath against the text inside our element. The given function is used to determine if the text matches. This implements the properties common to several elements: - The caseSensitive attribute defaults to 1, but can be set to zero to force both strings to lowercase. - Each XPath match is tested separately, with 'or' semantics: if any of the XPath matches cause the provided function to match, this returns True - If there are no XPath matches, returns False """ path = element.getAttributeNS(None, 'path') xp = XML.XPath(XML.pathShortcuts.get(path, path)) # Are we doing a case sensitive match? Default is no. caseSensitive = element.getAttributeNS(None, 'caseSensitive') if caseSensitive: caseSensitive = int(caseSensitive) else: caseSensitive = 0 text = XML.shallowText(element).strip() if not caseSensitive: text = text.lower() def filterMatch(msg): # Use queryobject then str() so that matched # nodes without any text still give us at least # the empty string. This is important so that <find> # with an empty search string can be used to test # for the existence of an XPath match. nodes = xp.queryObject(msg) if nodes: matchStrings = map(textExtractor, nodes) # Any of the XPath matches can make our match true for matchString in matchStrings: matchString = matchString.strip() if not caseSensitive: matchString = matchString.lower() if function(matchString, text): return True return False return filterMatch
def caps_store(self, path, xml): """Generate a list of acceptable capabilities to grant access to 'store'. In addition to the usual ones, allow ('ruleset.uri', x) where x is the ruleset's URI. """ uri = XML.parseString(xml).documentElement.getAttributeNS(None, 'uri') return self.makeDefaultCaps(path) + [('ruleset.uri', uri)]
def run_probes(self): """ run probes and upload probe data """ try: probes = XML.XML(str(self.proxy.GetProbes())) except (Proxy.ProxyError, Proxy.CertificateError, socket.gaierror, socket.error): err = sys.exc_info()[1] self.fatal_error("Failed to download probes from bcfg2: %s" % err) except XML.ParseError: err = sys.exc_info()[1] self.fatal_error("Server returned invalid probe requests: %s" % err) self.times['probe_download'] = time.time() # execute probes probedata = XML.Element("ProbeData") for probe in probes.findall(".//probe"): probedata.append(self.run_probe(probe)) if len(probes.findall(".//probe")) > 0: try: # upload probe responses self.proxy.RecvProbeData( XML.tostring(probedata, xml_declaration=False).decode('utf-8')) except Proxy.ProxyError: err = sys.exc_info()[1] self.fatal_error("Failed to upload probe data: %s" % err) self.times['probe_upload'] = time.time()
def element_match(self, element): """Compare a given variable exactly to the element's content, not including leading and trailing whitespace. """ return "(%s = %s)" % ( self.varLookup(element.getAttributeNS(None, 'var')), quote(XML.shallowText(element).strip(), 'varchar'))
def rulesetReturn(msg): nodes = xp.queryObject(msg) if nodes: self.result = XML.allText(nodes[0]).strip() else: self.result = None raise RulesetReturnException()
def renamepage(request): d = dict() email = request.COOKIES.get('user') try: d['user'] = User.objects.get(email=email) except: d['message'] = 'Unknown user.' d['redirect'] = "/" # redirect to main page return redirect("/") else: if request.method == 'POST': oldproject = request.POST['projname'] newproject = request.POST['newprojname'] try: XML.RenameProject(enc(d['user'].pk, oldproject), enc(d['user'].pk, newproject)) except XML.AlreadyExistsError: d['message'] = 'New project already exists.' return redirect('dashboard') except XML.AlreadyExistsError: d['message'] = 'Old project does not exist.' return redirect('dashboard') # nejsem si jistý nasledujicima dvema radkama !!! w = models.Webpage.objects.get(name=oldproject, user=d['user'].pk) w.name = str(newproject) w.save() return redirect('dashboard')
def createFile(request): email = request.COOKIES.get('user') d = dict() try: d['user'] = User.objects.get(email=email) except: d['message'] = 'Unknown user.' d['redirect'] = "/" # redirect to main page return getDirData(request) if request.method == 'POST': projname = request.POST['projname'] path = json.loads(request.POST['requestpath']) name = request.POST['name'] size = request.POST['size'] try: XML.AddToFiletree(enc(d['user'].pk, projname), path, name, 'f', "unknown", size) except XML.NameContainsWrongCharError: d['message'] = 'File/dir name contains unacceptable characters (only [a-zA-Z0-9_.]).' except XML.DoesNotExistError: d['message'] = 'Path or directory does not exist.' except XML.WrongTypeError: d['message'] = 'You cannot put things into file.' except XML.AlreadyExistsError: d['message'] = 'File/dir with the same name already exists.' return getDirData(request)
def element_like(self, element): """Compare a given variable to the element's content using SQL's 'LIKE' operator, not including leading and trailing whitespace. This is case-insensitive, and includes the '%' wildcard which may be placed at the beginning or end of the string. """ return "(%s LIKE %s)" % (self.varLookup(element.getAttributeNS(None, 'var')), quote(XML.shallowText(element).strip(), 'varchar'))
def component_text(self, element, args): """This is a generic version of textComponent, in which 'path' can be specified by users. Any textComponent can be rewritten as a <text> component. """ path = element.getAttributeNS(None, 'path') if not path: raise XML.XMLValidityError( "The 'path' attribute on <text> is required.") xp = XML.XPath(XML.pathShortcuts.get(path, path)) nodes = xp.queryObject(args.message) if nodes: return [XML.shallowText(nodes[0])] else: return [MarkAsHidden()]
def __init__(self, src="", id="", loglevel=0, debug=0): self.ckin = 0 self._owner = 0 self.verbose = 1 fname = os.path.basename(src) ff = os.path.splitext(fname) if src: root = XML.XML_Node(name='doc', src=src, preprocess=1, debug=debug) if id: s = root.child(id=id) else: s = root.child(name="phase") self._name = s['id'] # initialize the equation of state ThermoPhase.__init__(self, xml_phase=s) # initialize the kinetics model ph = [self] Kinetics.__init__(self, xml_phase=s, phases=ph) # initialize the transport model Transport.__init__(self, xml_phase=s, phase=self, model='', loglevel=loglevel)
def evalComponent(self, node, args): """Given a DOM node for a component, evaluate it and return the result list. An empty list always indicates that the component ran but had nothing to format- we return None if the node is ignored. Text nodes return a list with only their data. Newline characters in a text node are converted to spaces, so newlines and tabs can be used to prettify the XML without it affecting the final output- this combined with the redundant whitespace elimination in joinComponents() gives HTML-like semantics. Literal linebreaks can be obtained with the <br/> component. Elements invoke the corresponding component_* handler, which must return a sequence. """ if node.nodeType == node.TEXT_NODE: return [node.data.replace("\n", " ")] elif node.nodeType == node.ELEMENT_NODE: f = getattr(self, "component_" + node.nodeName, None) if f: return f(node, args) else: raise XML.XMLValidityError( "Unknown component name in %s: %r" % (self.__class__.__name__, node.nodeName))
def _reportUnusedParameters(self, unused): if unused: l = ['"%s"' % el for el in unused] l.sort() raise XML.XMLValidityError( "Some formatter parameters were not recognized: " + ", ".join(l))
def element_return(self, element): """Set the current result and exit the ruleset immediately""" if element.hasAttributeNS(None, 'path'): path = element.getAttributeNS(None, 'path') xp = XML.XPath(XML.pathShortcuts.get(path, path)) # Define a rulesetReturn function that returns the value of the XPath def rulesetReturn(msg): nodes = xp.queryObject(msg) if nodes: self.result = XML.allText(nodes[0]).strip() else: self.result = None raise RulesetReturnException() return rulesetReturn else: # No path, define a rulesetReturn function that returns this element's string value def rulesetReturn(msg): self.result = XML.shallowText(element) if not self.result: self.result = None raise RulesetReturnException() return rulesetReturn
def update_login_token(): xml_string = Data.Load(LOGIN_QUEUE_TOKEN_NAME) tree = XML.ElementFromString(xml_string) Dict['expiration'] = tree.findtext('token-expires-at') Dict['usertoken'] = tree.findtext('token') Dict['planid'] = tree.findtext('plid') Dict['userid'] = tree.findtext('id')
def ToXML(self): """ Serialize the item as XML. @return: string """ return XML.ElementToString(self.root)
def element_ruleset(self, element): """<ruleset> for the most part works just like <rule>, but since it's the root node it's responsible for initializing and returning the ruleset's result. """ if element is not self.xml.documentElement: raise XML.XMLValidityError( "The <ruleset> element must only occur at the document " + "root. Use <rule> to create nested rules.") # Go ahead and store the URI attribute if we have one. # If not, this will be None. self.uri = element.getAttributeNS(None, 'uri') or None # URIs are always encoded if necessary, since just about everywhere we'd need to # use a URI we can't support Unicode yet. Specific examples are IRC servers/channels # and as dict keys in an XML-RPC response. if type(self.uri) is unicode: self.uri = self.uri.encode() # Create a function to evaluate this element as a <rule> would be evaluated ruleFunc = self.element_rule(element) # Now wrap this function in one that performs our initialization and such def rulesetRoot(msg): self.result = None try: ruleFunc(msg) except RulesetReturnException: pass result = self.result del self.result return result return rulesetRoot
def main(): #html stuff: #------------------------------------------------------------------- #HTML.html_stuff('./html_input/index_part1.txt', './html_input/index_part2.txt', './html_output/index.html') #------------------------------------------------------------------- #convert groundtruth from 0.5secs intervall (manual input) to usable intervals (1,2,3,4,5secs) #data = FileIO.read_groundtruth('groundtruth_1001_05secs.csv') #FileIO.convert_groundtruth(data, 'groundtruth_1001_2secs.csv', 4) #xml stuff: #------------------------------------------------------------------- XML.create_XML('caffe_output_2secs_p_c_3.txt', 'groundtruth_1001_2secs.csv', '1001_77_2secs_p_c.csv')
def matches(self, msg): match = self.projectPath.queryObject(msg) if match: for node in match: project = XML.shallowText(node) if (project.strip().lower() in self.projects): return True return False
def element_like(self, element): """Compare a given variable to the element's content using SQL's 'LIKE' operator, not including leading and trailing whitespace. This is case-insensitive, and includes the '%' wildcard which may be placed at the beginning or end of the string. """ return "(%s LIKE %s)" % ( self.varLookup(element.getAttributeNS(None, 'var')), quote(XML.shallowText(element).strip(), 'varchar'))
def Cloth_Rigger_ReadXML(prop, filename=None): if not filename: filename = Cloth_Rigger_GetXMLFile(prop) cloth = prop.Parent3DObject cloth_op = cloth.ActivePrimitive.ConstructionHistory.Find('syCloth') if cloth_op: XML.ReadSyflexXMLPreset(filename, cloth_op)
def loadGames(): try: f = open("./xml/packlist.chess", "r") except FileNotFoundError: return saves = f.readlines() for save in saves: save = save.rstrip() gameID = save[:save.find(":")] lastNum = save[save.find(":")+1:] g = Game() g.id = int(gameID) xmlPath = "./xml/"+gameID+"/"+lastNum+".xml" try: m = XML.parse_meta(xmlPath) g.password = m["password"] g.board.whoseTurn = WHITE if m["turn"] == "white" else BLACK g.board.xSize = int(m["sizeX"]) g.board.ySize = int(m["sizeY"]) g.movesmade = int(m["movesmade"]) g.board.setup_fields() except KeyError: continue figures = XML.parse_figures(xmlPath) for figure in figures: g.board.getFieldByCords(figure.posx, figure.posy).figure = figure g.board.postMoveUpdate() if g.password is None: g.password = "" if g.movesmade > 3: glist.append(g) print("Loaded Game:", g.id) else: removeLine("./xml/packlist.chess", str(g.id)+":"+str(g.movesmade)+"\n") rmdir("./xml/"+str(g.id)) print("Removed SaveGame:", g.id)
def __init__(self, tag="MediaItem"): """ Creates a custom MediaItem with the given tag @param tag: The tag for the MediaItem @type tag: string @return: MediaItem """ self.root = XML.Element(tag)
def Set(key, value): """ Sets the preference for the given key to the given value. @param key: The key of the preference @type key: string @param value: The value to set @type value: string """ el = Plugin.__prefs.find(key) if el is None: el = XML.Element(key) el.text = value Plugin.__prefs.append(el) else: el.text = value XML.ElementToFile(Plugin.__prefs, Plugin.__prefsPath) Log.Add("(Framework) Set preference '%s' to '%s'", (key, value))
def Get(key): """ Gets the preference value for the given key. @param key: The key of the preference @type key: string @return: key """ return XML.TextFromElement(Plugin.__prefs.find(key))
def _insertRuleset(self, none, result, ruleset): """Callback used by store() to insert a new or modified ruleset into the SQL database""" import Database d = Database.pool.runOperation( "INSERT INTO rulesets (uri, xml) values(%s, %s)" % (Database.quote(ruleset.uri, 'text'), Database.quote(XML.toString(ruleset.xml), 'text'))) d.addCallback(result.callback) d.addErrback(result.errback)
def run(): dossiers = os.listdir('./../') if 'zip' not in dossiers: os.mkdir('./../zip') if 'xml' not in dossiers: os.mkdir('./../xml') if 'wordOut' not in dossiers: os.mkdir('./../wordOut') # Fichier source à modifier à choisir. file = raw_input("entrer le nom du fichier word sans l'extension :\n>>>") # Changement de l'extension du fichier pour une archive. ext.changeExt(file, 'docx', 'zip', './../word/', './../zip/') print('zipage done') # Extraction du fichier 'document.xml' de l'archive. zip.extract('./../zip/' + file + '.zip') print('extract done') # Mets en forme le document xml pour créer un arbre propre. xml.xml('./../word/document.xml', file) print('xml done') # Extrait tout les fichiers de l'archive pour modifier les fichiers html zip.extractAll('./../zip/' + file + '.zip') print('extractAll done') # Suppression des espaces des fichiers HTML # html.run() # print('rewrite html done') # zip.addFile(file) # print('create new zip done') # Création de la noouvelle archive et ajout des fichiers modifiés zip.zipdir('./../tmp', file) ext.changeExt(file, 'zip', 'docx', './../wordOut/', './../wordOut/') rmtree('./../zip') rmtree('./../xml') # rmtree('./../tmp') os.remove('./../wordOut/' + file + '.zip')
def caps_store(self, path, xml): """Generate a list of acceptable capabilities to grant access to 'store'. In addition to the usual ones, allow ('ruleset.uri', x) where x is the ruleset's URI. """ if (xml.startswith('[')): uri = xml.split('\n')[0][2:] else: uri = XML.parseString(xml).documentElement.getAttributeNS(None, 'uri') return self.makeDefaultCaps(path) + [('ruleset.uri', uri)]
def postprocessMessage(self, xml): """Gets a chance to modify all XML messages before they're loaded and dispatched to the Hub. This does the following: - If there is no <generator> at all, adds a generic one - Removes any <mailHeaders> tag that may already exist in <generator> - Adds a correct <mailHeaders> tag to the <generator> """ # Create the <generator> tag if it doesn't exist if not XML.dig(xml, "message", "generator"): xml.documentElement.appendChild(self.getLocalGenerator(xml)) generator = XML.dig(xml, "message", "generator") # Delete an existing <mailHeaders> for child in list(XML.getChildElements(generator)): if child.nodeName == "mailHeaders": generator.removeChild(child) # Add a new <mailHeaders> generator.appendChild(self.getXMLMailHeaders(xml)) return xml
def command_Announce(self, project): """Old-style announcements: Announce <project> in the subject line. The body of the email contained the message's text, marked up with {color} tags but with no metadata. """ xml = XML.createRootNode() # Convert the given project name to a <project> tag inside <source>, # after filtering it a bit... in the old CIA project names and IRC channel # names weren't particularly distinct, so preceeding "#" characters on # projects were ignored. We preserve this behaviour. if project[0] == "#": project = project[1:] XML.buryValue(xml, project, "message", "source", "project") # Since old-style commits didn't have any metadata, the best we can do # is to represent the log in a <colorText> element colorText = ColorTextParser().parse(self.message.get_payload()).documentElement XML.bury(xml, "message", "body").appendChild(xml.importNode(colorText, True)) return xml
def format(self, args): """The formatter entry point. This just finds the current component tree and invokes walkComponents and joinComponents on it. """ # Parse the default component tree, caching it per-class if self.__class__._defaultTreeOwner is not self.__class__.defaultComponentTree: self.__class__._defaultTreeOwner = self.__class__.defaultComponentTree self.__class__._cachedDefaultTree = XML.parseString(self.__class__.defaultComponentTree).documentElement # This will use the default component tree if it hasn't been overridden in this instance tree = self.componentTree or self.__class__._cachedDefaultTree return self.joinComponents(self.walkComponents(tree.childNodes, args))
def component_text(self, element, args): """This is a generic version of textComponent, in which 'path' can be specified by users. Any textComponent can be rewritten as a <text> component. """ path = element.getAttributeNS(None, 'path') if not path: raise XML.XMLValidityError("The 'path' attribute on <text> is required.") xp = XML.XPath(XML.pathShortcuts.get(path, path)) nodes = xp.queryObject(args.message) if nodes: return [XML.shallowText(nodes[0])] else: return [MarkAsHidden()]
def __init__(self, src="", root=None): self.ckin = 0 self._owner = 0 self.verbose = 1 # get the 'phase' element s = XML.find_XML(src=src, root=root, name="phase") # get the equation of state model ThermoPhase.__init__(self, xml_phase=s) # get the kinetics model Kinetics.__init__(self, xml_phase=s, phases=[self]) SolidTransport.__init__(self, phase=self)
def dbStore(self, ruleset=None): """Write all rulesets to disk in one big XML file""" doc = XML.parseString("<rulesets>\n" "<!--\n" "This is a ruleset storage for CIA. It tells the CIA server\n" "how to deliver messages. Don't edit it by hand while the server\n" "is running, use tools/ruleset_editor.py\n" "-->\n" "\n" "</rulesets>") root = doc.documentElement for ruleset in self.flatten(): root.appendChild(XML.Domlette.ConvertDocument(ruleset.xml).documentElement) root.appendChild(doc.createTextNode("\n\n")) f = open(self.path, "w") XML.Domlette.Print(doc, f) f.write("\n")
def loadParametersFrom(self, xml, unused=None): """This is given a <formatter> element possibly containing extra parameters for the formatter to process and store. Any problems should be signalled with an XML.XMLValidityError. By default, this tries to find a param_* handler for each element it comes across. Returns a set object, containing the names of all unused parameters. This allows callers, during validation, to look for misspelled or otherwise unused elements. """ unused = set() for tag in XML.getChildElements(xml): f = getattr(self, 'param_'+tag.nodeName, None) if f: f(tag) else: unused.add(tag.nodeName) return unused
def test_xmlSolve_multipleChildren(self): r = StringIO("<THU><Team><ACRush></ACRush><Jelly></Jelly><Cooly></Cooly></Team><JiaJia><Team><Ahyangyi></Ahyangyi><Dragon></Dragon><Cooly><Amber></Amber></Cooly></Team></JiaJia></THU><Team><Cooly></Cooly><Jelly></Jelly></Team>") w = StringIO() XML.xmlSolve(r,w) self.assertTrue(w.getvalue() == "1\n2\n")
def test_getPattern(self): s = "<xml><THU>\n\t<Team>\n\t\t<ACRush></ACRush>\n\t\t<Jelly></Jelly>\n\t\t<Cooly></Cooly>\n\t</Team>\n\t<JiaJia>\n\t\t<Team>\n\t\t\t<Ahyangyi></Ahyangyi>\n\t\t\t<Dragon></Dragon>\n\t\t\t<Cooly><Amber></Amber></Cooly>\n\t\t</Team>\n\t</JiaJia>\n</THU>\n<Team><Cooly></Cooly></Team>\n</xml>" a = fromstring(s) pattern = XML.getPattern(a) self.assertTrue(type(pattern) is Element) self.assertTrue(pattern.tag == "Team")
def main(): XML.xmlSolve(sys.stdin, sys.stdout)
print 'Bind failed. Error Code : ' + str(msg[0]) + ' Message ' + msg[1] sys.exit() class Save(Thread): def __init__(self, xml): Thread.__init__(self) self.xml = xml def run(self): while True: time.sleep(300) self.xml.write() print 'Saved' # get XML document xml = XML('/home/pi/Programmes/Python/Projet/Preferences.xml') # instanciate shift and sooperlooper shift = Shift() sooper = SooperLooper() # animate LEDs shift.loading('b') # pedals = [] for i in range(0, 5): pedal = "/Root/Pedal_" + str(i) + "/" pedals.append(Pedal(i,
def test_xmlSolve_noAnswer(self): r = StringIO("<THU><Team><ACRush></ACRush><Jelly></Jelly><Cooly></Cooly></Team><JiaJia><Team><Ahyangyi></Ahyangyi><Dragon></Dragon><Cooly><Amber></Amber></Cooly></Team></JiaJia></THU><Jesse></Jesse>") w = StringIO() XML.xmlSolve(r,w) self.assertTrue(w.getvalue() == "0\n")