def generateSegment(self, coords, attr):
featureMember = Element("gml:featureMember")
feature = SubElement(featureMember, "segment")
feature.set("gml:fid", str(attr["id"]))
FID = SubElement(feature, "FID")
FID.text = str(attr["id"])
geometryProperty = SubElement(feature, "gml:geometryProperty")
lineString = SubElement(geometryProperty, "gml:LineString")
coordinates = SubElement(lineString, "gml:coordinates")
coordinates.text = " ".join(map(lambda x: "%s,%s" % x, coords))
for k, v in attr.iteritems():
if k in exportTags:
SubElement(feature, "" + k).text = v
ElementTree(featureMember).write(self.fh, "utf-8")
self.fh.write("\n")
def generateMultiWay(self, attr):
featureMember = Element("gml:featureMember")
feature = SubElement(featureMember, "way")
FID = SubElement(feature, "FID")
FID.text = str(attr["id"])
geometryProperty = SubElement(feature, "gml:geometryProperty")
lineString = SubElement(geometryProperty, "gml:MultiLineString")
data = []
for i in attr['segments']:
lsm = SubElement(lineString, "gml:lineStringMember")
ls = SubElement(lsm, "gml:LineString")
coordinates = SubElement(ls, "gml:coordinates")
coordinates.text = " ".join(map(lambda x: "%s,%s" % x, i))
for k, v in attr.iteritems():
if k != "segments":
SubElement(feature, "" + k).text = v
ElementTree(featureMember).write(self.fh, "utf-8")
self.fh.write("\n")
def __init__(self,
encoding="utf-8",
date=None,
source_info_url=None,
source_info_name=None,
generator_info_url=None,
generator_info_name=None):
"""
Arguments:
'encoding' -- The text encoding that will be used.
*Defaults to 'utf-8'*
'date' -- The date this data was generated. *Optional*
'source_info_url' -- A URL for information about the source of the
data. *Optional*
'source_info_name' -- A human readable description of
'source_info_url'. *Optional*
'generator_info_url' -- A URL for information about the program
that is generating the XMLTV document.
*Optional*
'generator_info_name' -- A human readable description of
'generator_info_url'. *Optional*
"""
if DEBUG >= 0: print "in Writer:__init__"
self.encoding = encoding
self.data = {
'date': date,
'source_info_url': source_info_url,
'source_info_name': source_info_name,
'generator_info_url': generator_info_url,
'generator_info_name': generator_info_name
}
self.root = Element('tv')
for attr in self.data.keys():
if self.data[attr]:
self.root.set(attr, self.data[attr])
def test_is_package_ref(self):
builder = ComponentDescriptor(None)
deb_rule = Element('deb')
udeb_rule = Element('udeb')
dsc_rule = Element('dsc')
rpm_rule = Element('rpm')
srpm_rule = Element('srpm')
component_rule = Element('component')
assert builder.is_package_ref(deb_rule)
assert builder.is_package_ref(udeb_rule)
assert builder.is_package_ref(dsc_rule)
assert builder.is_package_ref(rpm_rule)
assert builder.is_package_ref(srpm_rule)
assert not builder.is_package_ref(component_rule)
def elementFromTag(tree, tag, parent=None):
tagName = tag[1]
if not tagName:
tagName = ""
ns = None
if tag[0]:
if tag[0] in tree.prefixmap:
ns = tree.prefixmap[tag[0]]
else:
nsattr = "xmlns:%s" % tag[0]
if nsattr in tag[2]:
ns = tag[2][nsattr]
del tag[2][nsattr]
tree.prefixmap[tag[0]] = ns
elif "xmlns" in tag[2]:
ns = tag[2]["xmlns"]
del tag[2]["xmlns"]
elif parent is not None:
ns = parent.ns
localName = tag
if ns:
tagName = "{%s}%s" % (ns, tagName)
elem = Element(tagName, tag[2])
try:
elem.start = tree.err_info
elem.end = None
except:
# will happen when parsing with cElementTree
pass
# print elem.localName
if parent is not None:
parent.append(elem)
tree.nodemap[elem] = parent
tree.nodes.append(elem)
if elem.ns is not None:
if elem.ns not in tree.tags:
tree.tags[elem.ns] = {}
tree.tags[elem.ns][elem.localName] = elem
return elem
def _modify_config_file(self, instance, config_file, seed_ips, token):
# XML (0.6.x)
if config_file.endswith(".xml"):
remote_file = "storage-conf.xml"
xml = parse_xml(urllib.urlopen(config_file)).getroot()
# Seeds
seeds = xml.find("Seeds")
if seeds is not None:
while seeds.getchildren():
seeds.remove(seeds.getchildren()[0])
else:
seeds = Element("Seeds")
xml.append(seeds)
for seed_ip in seed_ips:
seed = Element("Seed")
seed.text = seed_ip
seeds.append(seed)
# Initial token
initial_token = xml.find("InitialToken")
if initial_token is None:
initial_token = Element("InitialToken")
xml.append(initial_token)
initial_token.text = token
# Logs
commit_log_directory = xml.find("CommitLogDirectory")
if commit_log_directory is None:
commit_log_directory = Element("CommitLogDirectory")
xml.append(commit_log_directory)
commit_log_directory.text = "/mnt/cassandra-logs"
# Data
data_file_directories = xml.find("DataFileDirectories")
if data_file_directories is not None:
while data_file_directories.getchildren():
data_file_directories.remove(
data_file_directories.getchildren()[0])
else:
data_file_directories = Element("DataFileDirectories")
xml.append(data_file_directories)
data_file_directory = Element("DataFileDirectory")
data_file_directory.text = "/mnt/cassandra-data"
data_file_directories.append(data_file_directory)
# listen address
listen_address = xml.find("ListenAddress")
if listen_address is None:
listen_address = Element("ListenAddress")
xml.append(listen_address)
listen_address.text = ""
# thrift address
thrift_address = xml.find("ThriftAddress")
if thrift_address is None:
thrift_address = Element("ThriftAddress")
xml.append(thrift_address)
thrift_address.text = ""
fd, temp_file = tempfile.mkstemp(prefix='storage-conf.xml_',
text=True)
os.write(fd, dump_xml(xml))
os.close(fd)
# YAML (0.7.x)
elif config_file.endswith(".yaml"):
remote_file = "cassandra.yaml"
yaml = parse_yaml(urllib.urlopen(config_file))
yaml['seeds'] = seed_ips
yaml['initial_token'] = token
yaml['data_file_directories'] = ['/mnt/cassandra-data']
yaml['commitlog_directory'] = '/mnt/cassandra-logs'
yaml['listen_address'] = str(instance.private_dns_name)
yaml['rpc_address'] = str(instance.public_dns_name)
fd, temp_file = tempfile.mkstemp(prefix='cassandra.yaml_',
text=True)
os.write(fd, dump_yaml(yaml))
os.close(fd)
else:
raise Exception("Configuration file must be one of xml or yaml")
return temp_file, remote_file
handlerclass = get_tree_handler(tree, tree.current,
default_completion.get(lang))
values = handlerclass.values(attr, tree)
if not values:
return None
values.sort()
return values
# configure catalogs to use
basedir = os.path.dirname(os.path.dirname(os.getcwd()))
catalogs = os.path.join(basedir, "test", "stuff", "xml")
getService().setCatalogs([os.path.join(catalogs, "testcat.xml")])
from cElementTree import Element
tree = koXMLTreeService.XMLDocument()
tree.root = tree.current = Element('')
handlerclass = get_tree_handler(tree, tree.current)
assert handlerclass != None, "no handler class for empty tree"
xml = """<?xml version="1.0"?>
<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
<xsl:output method="html" indent="yes"/>
<html> <
"""
tags = getValidTagNames(xml, lang="XSLT")
assert tags == ['body', 'head'], \
"invalid output tags for stylesheet"
xml = "<"
assert getValidTagNames(xml) == None, "invalid children for html"
