def getTree(self):
"распарсить дерево"
#parser = ET.XMLParser(encoding="windows-1251")
#self.tree = ET.parse(self.filename, parser=parser)
if self.xmlstring:
self.tree = ET.ElementTree(ET.XML(self.xmlstring))
elif self.filename:
self.tree = ET.parse(self.filename)
else:
self.tree = ET.ElementTree(ET.XML('<root></root>'))
def test_correct_serialization_meta_attributes(self):
poi = Poi()
poi.length = 10
poi.location = Location( lat= '6.8989', lng = '5.344')
poi.descriptions = {"nl": "Nederlands", "de": "Duits"}
xml_repr = XMLSerializer().serialize(poi)
print xml_repr
poi_xml_tree = ElementTree.XML(xml_repr.encode('utf-8'))
self.assertEqual(poi_xml_tree.tag, 'poi')
length_element = poi_xml_tree.find('length')
self.assertTrue( length_element is not None)
self.assertTrue( 'dimension' in length_element.attrib)
self.assertEqual(length_element.attrib['dimension'], 'dm')
location_element = poi_xml_tree.find('location')
self.assertTrue( location_element is not None)
self.assertTrue( 'projection' in location_element.attrib)
self.assertEqual(location_element.attrib['projection'], 'WGS84')
unser_poi = XMLUnserializer().unserialize(xml_repr, Poi)
self.assertEqual(poi.length, unser_poi.length)
def parse(text):
"""
Parse text as XML.
>>> parse('<doc/>')
<Element doc ...>
>>> parse('')
Traceback (most recent call last):
...
Exception:
<BLANKLINE>
xml.parsers.expat.ExpatError: no element found: line 1, column 0
>>> parse('<doc><foo></doc>')
Traceback (most recent call last):
...
Exception:
<doc><foo></doc>
xml.parsers.expat.ExpatError: mismatched tag: line 1, column 12
"""
try:
doc = ElementTree.XML(text)
except xml.parsers.expat.ExpatError, e:
# This cuts out a little bit of the Python traceback
# and shows the bad XML at the end, right above the
# error description.
raise Exception('\n%s\n%s: %s' % (text, e.__class__, e))
def get_auth_token_handler(request):
'''
Receives: POST data 'ticket' OR GET request with parameters 'auth_token' and 'ticket' from Box.com
Pairs authenticated ticket with Box API Key to retreive Auth auth_token
needed for accessing user Box files and folders.
'''
if request.session.get('auth_token'): # if an active session is present
return redirect('sendbox_app_view', folder_id=0) # redirect to main app page
if request.method == 'POST' and request.POST.get('ticket'): # if POST request was made
url = u'https://www.box.com/api/1.0/rest' # build request url for auth_token retrieval
params = {'action': 'get_auth_token', # build GET parameters
'api_key': settings.BOX_API_KEY,
'ticket': request.POST['ticket']}
try:
response = requests.get(url, params=params) # GET request for auth_token retrieval
obj = ET.XML(response.content) # parse xml response to python object
auth_token = obj.findtext('auth_token') # extract value from 'auth_token' tag
request.session['auth_token'] = auth_token # store auth_token in session key (see django sessions doc)
return redirect('sendbox_app_view', folder_id=0) # redirect to main app page
except AttributeError:
messages.error(request, "Invalid Ticket! Try logging in again!")
return redirect('sendbox_index_view') # django reverse() shortcut (see django shortcuts doc)
if request.GET.get('auth_token') and request.GET.get('ticket'): # if GET parameters are present (for Box.com redirection)
request.session['auth_token'] = request.GET['auth_token'] # just store auth_token in session key
return redirect('sendbox_app_view', folder_id=0) # redirect to main app page
messages.error(request, "Cannot access this page directly!")
return redirect('sendbox_index_view') # redirect to home page
def load_vocabulary(self, vocabulary):
"""
Load the vocabulary (.xml) file.
"""
# word-to-concept mappings
for key in PoS.Grps:
setattr(self, key, {})
# concept-to-word mappings
self.concepts = {}
for key in PoS.Grp2Abr:
self.concepts[key] = {}
if type(vocabulary)==str and len(vocabulary) < 32:
data = open(vocabulary, 'rt').read() # short names are read as filenames
elif type(vocabulary)==file:
data = vocabulary.read() # file handle
else:
data = vocabulary # data buffer
self.xml = ElementTree.XML(data)
if self.xml.tag != 'locale':
raise PUB_InvalidVocabulary("Main element is not 'locale'")
for attrib in ('name', 'lang', 'region', 'encoding', 'direction', 'language', 'variant'):
if self.xml.attrib.has_key(attrib):
setattr(self, attrib, self.xml.attrib[attrib])
else:
setattr(self, attrib, '')
for child in self.xml.getchildren():
if child.tag in PoS.Grps:
for concept in [c for c in child.getchildren()
if c.tag==PoS.Grp2Abr[child.tag]]:
self._load_concept(concept, child.tag)
def close(self):
args = [string.join(self.__data, "")]
if self.__encoding:
args.append(self.__encoding)
stdout, stderr = _elementtidy.fixup(*args)
self.errlog = stderr
return ElementTree.XML(stdout)
def sendbox_index_view(request):
'''
Application Entry Point. Retrieves generated Box.com ticket upon construction.
Facilitates app authentication with user's Box account
'''
url = u'https://www.box.com/api/1.0/rest' # build url for ticket retrieval
params = {'action': 'get_ticket', # build GET parameters
'api_key': settings.BOX_API_KEY}
context = {}
try:
response = requests.get(url, params=params) # GET request for ticket
obj = ET.XML(response.content) # parse xml response to python object
ticket = obj.findtext('ticket') # extract value from 'ticket' tag
url = u'https://www.box.com/api/1.0/auth/%s' % ticket # build url for Box.com ticket authentication
context = {'ticket': ticket, 'url': url, } # template context (see django templates)
except AttributeError: # triggers when obj.find('ticket') asserts to None
messages.error(request, "Invalid API Key!") # django message dispatcher (see django messages doc)
pass
if request.session.get('auth_token'): # check if auth_token exists
context['auth_token'] = request.session.get('auth_token') # add it to context for displaying to user
return render_to_response('sendbox/index.html', # HttpResponse shortcut (see django shortcuts doc)
context,
context_instance=RequestContext(request))
def main(bgffile,xbgffile):
seq = ET.Element(slpsns.xbgf_('sequence'))
rr = ET.SubElement(seq,slpsns.xbgf_('reroot'))
for r in ET.XML('<list>'+''.join(open(bgffile,'r').readlines()).strip()+'</list>').findall('*'):
x = ET.SubElement(rr,'root')
x.text = r.text
ET.ElementTree(seq).write(xbgffile)
return
def xinclude_loader(href, parse="xml", encoding=None):
try:
data = XINCLUDE[href]
except KeyError:
raise IOError("resource not found")
if parse == "xml":
return ElementTree.XML(data)
return data
def check(a, b):
import re
a = ElementTree.tostring(ElementTree.XML(a))
a = re.sub("HTML Tidy[^\"]+", "TIDY", a)
a = re.sub("\r\n", "\n", a)
if a != b:
print a
print "Expected:"
print b
def __init__(self, xmlstate=None, validatestate=True):
self._model = FieldModel(self.modeltext)
if xmlstate is not None:
self._state = ET.ElementTree(ET.XML(xmlstate))
# If state is being pre-supplied, then it ought to validate,
# unless the caller has specifically asserted that it does not:
if validatestate:
self.state_validate()
else:
self._state = ET.ElementTree(ET.Element('none'))
def setUp(self):
from elementtree import ElementTree as et
from elementtree.ElementTree import tostring
from com.finnean.io.reader import XMLReader
reader = XMLReader.XMLReader(r'D:\Lib\Butters\new-results.xml')
root = et.XML(reader.read())
results = root.findall('results')
result = results[0].findall('result')
host, date, ports = result[0].getchildren()
p = ports[0]
service, information = p.getchildren()
self.s = Service(service)
def _retrieve(self):
"""Query Apache Tomcat Server Status Page in XML format and return
the result as an ElementTree object.
@return: ElementTree object of Status Page XML.
"""
url = "%s://%s:%d/manager/status" % (self._proto, self._host,
self._port)
params = {}
params['XML'] = 'true'
response = util.get_url(url, self._user, self._password, params)
tree = ElementTree.XML(response)
return tree
def get_episodes(feed):
#Open URL and get the stuff
url = feed.url
doc = urllib2.urlopen(url)
rssXML = doc.read()
doc.close()
tree = ET.XML(rssXML)
episodes = tree.findall('channel/item')
episodesTitles = tree.findall('channel/item/title')
for j in xrange(len(episodes)):
n = episodesTitles[j]
n = n.text
epN = ((len(episodes)) - j)
epXML = episodes[j]
epXML = ET.tostring(epXML)
newEp = models.Episode(name=n, episodeNum=epN, xml=epXML)
newEp.save()
def _retrieve(self):
"""Query Apache Tomcat Server Status Page in XML format and return
the result as an ElementTree object.
@return: ElementTree object of Status Page XML.
"""
if self._user is not None and self._password is not None:
url = "%s://%s:%s@%s:%d/manager/status?XML=true" % (
self._proto, urllib.quote(self._user),
urllib.quote(self._password), self._host, self._port)
else:
url = "%s://%s:%d/manager/status?XML=true" % (
self._proto, self._host, self._port)
fp = urllib.urlopen(url)
response = util.socket_read(fp)
fp.close()
tree = ElementTree.XML(response)
return tree
def feed(request,slug):
#Entered Function and captured slug
print "Worked!"
print slug
template_name = 'xml.html'
eps = Episode.objects.all().filter(episodeNum = 2)
epsXML = []
for ep in eps:
print ep.xml
tree = ET.XML(ep.xml)
epsXML.append(ET.tostring(tree))
print epsXML
context = {"epsXML": epsXML}
return render_to_response(template_name, context, content_type="application/rss+xml")
def today(league):
yyyymmdd = int(
datetime.datetime.now(pytz.timezone('US/Pacific')).strftime("%Y%m%d"))
games = []
try:
f = urllib2.urlopen(url % (league, yyyymmdd))
jsonp = f.read()
f.close()
json_str = jsonp.replace('shsMSNBCTicker.loadGamesData(',
'').replace(');', '')
json_parsed = json.loads(json_str)
for game_str in json_parsed.get('games', []):
game_tree = ET.XML(game_str)
visiting_tree = game_tree.find('visiting-team')
home_tree = game_tree.find('home-team')
gamestate_tree = game_tree.find('gamestate')
home = home_tree.get('nickname')
away = visiting_tree.get('nickname')
os.environ['TZ'] = 'US/Eastern'
start = int(
time.mktime(
time.strptime(
'%s %d' % (gamestate_tree.get('gametime'), yyyymmdd),
'%I:%M %p %Y%m%d')))
del os.environ['TZ']
games.append({
'league': league,
'start': start,
'home': home,
'away': away,
'home-score': home_tree.get('score'),
'away-score': visiting_tree.get('score'),
'status': gamestate_tree.get('status'),
'clock': gamestate_tree.get('display_status1'),
'clock-section': gamestate_tree.get('display_status2')
})
except Exception, e:
print e
def summarize_list(seq):
return map(summarize, seq)
def normalize_crlf(tree):
for elem in tree.getiterator():
if elem.text: elem.text = elem.text.replace("\r\n", "\n")
if elem.tail: elem.tail = elem.tail.replace("\r\n", "\n")
SAMPLE_XML = ElementTree.XML("""
<body>
<tag>text</tag>
<tag />
<section>
<tag>subtext</tag>
</section>
</body>
""")
#
# interface tests
def check_string(string):
len(string)
for char in string:
if len(char) != 1:
print "expected one-character string, got %r" % char
new_string = string + ""
def summarize_list(seq):
return map(summarize, seq)
def normalize_crlf(tree):
for elem in tree.getiterator():
if elem.text: elem.text = string.replace(elem.text, "\r\n", "\n")
if elem.tail: elem.tail = string.replace(elem.tail, "\r\n", "\n")
SAMPLE_XML = ElementTree.XML("""
<body>
<tag class='a'>text</tag>
<tag class='b' />
<section>
<tag class='b' id='inner'>subtext</tag>
</section>
</body>
""")
#
# interface tests
def check_string(string):
len(string)
for char in string:
if len(char) != 1:
print "expected one-character string, got %r" % char
new_string = string + ""
def make_xml(s):
return et.XML('<xml>%s</xml>' % s)
def __init__(self, xmlrepr):
self.basemodel = ET.XML(xmlrepr)
# modified from http://www.larsen-b.com/Article/204.html
import sys
try:
from elementtree import ElementTree
except:
from xml.etree import ElementTree
try:
file = sys.argv[1]
data = open(file, 'r').read()
except:
print sys.argv[0] + " {kismet logfile}"
sys.exit(1)
detection = ElementTree.XML(data)
# KML Header
print """<?xml version="1.0" encoding="UTF-8"?>
<kml xmlns="http://earth.google.com/kml/2.0">
<Document>
<name>Kismet Log </name>
<Folder>
<name> Kismet Log Points </name>"""
for node in detection.getchildren():
try:
ssid = node.find('SSID').text
except AttributeError:
#hidden SSID
ssid = "{unknown SSID}"
def xml_to_dict(xml):
return XmlDictConfig(ElementTree.XML(xml))
from elementtree import ElementTree as et
from elementtree.ElementTree import tostring
from com.finnean.io.reader import XMLReader
reader = XMLReader.XMLReader(r'D:\Lib\Butters\new-results.xml')
root = et.XML(reader.read())
results = root.findall('results')
result = results[0].findall('result')
host, date, ports = result[0].getchildren()
p = ports[0]
service, information = p.getchildren()
severity, _id, data = information.getchildren()
def testXMLReporting(self):
# silly try/except chaining to find an available version of ElementTree
try:
import elementtree.ElementTree as ET
except ImportError:
try:
import cElementTree as ET
except ImportError:
try:
import lxml.etree as ET
except ImportError:
try:
import xml.etree.ElementTree as ET # Python 2.5
except ImportError:
testoob.testing.skip(reason="Needs ElementTree")
root = ET.XML(self._get_file_report("xml"))
# testsuites tag
self.assertEqual("results", root.tag)
# ensures only one testsuites element
[testsuites] = root.findall("testsuites")
def extract_info(testcase):
class Struct:
pass
result = Struct()
result.tag = testcase.tag
result.name = testcase.attrib["name"]
result.result = testcase.find("result").text
failure = testcase.find("failure")
result.failure = failure is not None and failure.attrib[
"type"] or None
error = testcase.find("error")
result.error = error is not None and error.attrib["type"] or None
return result
testcase_reports = [
extract_info(testcase)
for testcase in testsuites.findall("testcase")
]
# ensure one testcase of each type
[success] = [x for x in testcase_reports if x.result == "success"]
[failure] = [x for x in testcase_reports if x.result == "failure"]
[error] = [x for x in testcase_reports if x.result == "error"]
def check_result(testcase, name=None, failure=None, error=None):
self.assertEqual("testcase", testcase.tag)
self.assertEqual(name, testcase.name)
self.assertEqual(failure, testcase.failure)
self.assertEqual(error, testcase.error)
check_result(success, name="testSuccess (suites.CaseMixed)")
check_result(failure,
name="testFailure (suites.CaseMixed)",
failure="exceptions.AssertionError")
check_result(error,
name="testError (suites.CaseMixed)",
error="exceptions.RuntimeError")
