def __init__(self, encoding=None):
self.__stack = []
self.__builder = ET.TreeBuilder()
self.encoding = encoding or "iso-8859-1"
HTMLParser.__init__(self)
.replace("\x1b[1;30m", "")\
.strip()
if passed_pat.match(clean_line):
groups = passed_pat.search(clean_line).groups()
cpu_time, memory_gigs, num_cores, test = groups
approx_wall_time = float(cpu_time) / max(0.05, float(num_cores))
passed.add(test)
passed_times[test] = str(approx_wall_time)
if failed_pat.match(clean_line):
test = failed_pat.search(clean_line).groups()[0]
failed.add(test)
failed.difference_update(passed)
builder = ElementTree.TreeBuilder()
builder.start(
'testsuite', {
'errors': '0',
'tests': str(len(passed) + len(failed)),
'time': '0',
'failures': str(len(failed)),
'name': 'tests'
})
for f in failed:
fail_content = ""
if os.path.isfile("build/x86_64/tests/%s.failed" % f):
with open("build/x86_64/tests/%s.failed" % f, "r") as failFile:
fail_content = failFile.read().replace(chr(27), "")
def main():
parser = ArgumentParser(description="""
Extract the outlines from an SVG file, illustrating the output in a new
SVG. Reads an SVG from stdin and writes a new SVG to stdout.
""")
parser.add_argument(
"--pixels-per-mm", "-p",
type=float, default=5,
help="Resolution to use for converting curves to lines.")
parser.add_argument(
"--line-width-override", "-l",
type=str,
help="""
Override the line width for all lines to this many mm or other CSS
units.
""")
parser.add_argument(
"--colour-override", "-c",
nargs=4, type=float, metavar=("R", "G", "B", "A"),
help="""
Override the line colour for all lines. R, G, B, A in range 0.0 to
1.0.
""")
args = parser.parse_args()
svg = ElementTree.parse(sys.stdin).getroot()
outlines = svg_to_outlines(
svg, pixels_per_mm=args.pixels_per_mm)
width_mm, height_mm = get_svg_page_size(svg)
# Generate a new SVG as output which just contains the line segments
# extracted from the source.
builder = ElementTree.TreeBuilder()
builder.start("svg", {
"xmlns": "http://www.w3.org/2000/svg",
"xmlns:xlink": "http://www.w3.org/1999/xlink",
"version": "1.1",
"width": "{}mm".format(width_mm),
"height": "{}mm".format(height_mm),
"viewBox": "0 0 {} {}".format(width_mm, height_mm)
})
# Define markers for line starts and vertices
mm_per_pixel = 25.4 / 96.0
builder.start("defs")
builder.start("rect", {
"id": "start",
"style": "fill:white;stroke:black;stroke-width:{}".format(
mm_per_pixel),
"x": str(-mm_per_pixel*2),
"y": str(-mm_per_pixel*2),
"width": str(mm_per_pixel*5),
"height": str(mm_per_pixel*5),
})
builder.end("rect")
builder.start("use", {
"id": "end",
"xlink:href": "#start",
})
builder.end("use")
builder.start("circle", {
"id": "vertex",
"style": "fill:black;stroke:none",
"r": str(mm_per_pixel*2),
})
builder.end("circle")
builder.end("defs")
# Draw the lines
for colour, width, points in outlines:
if args.line_width_override is not None:
width = args.line_width_override
if args.colour_override is not None:
colour = args.colour_override
# Draw line
x, y = points[0]
r, g, b, a = colour or (0, 0, 0, 1)
builder.start("path", {
"d": "M{},{} {}".format(
x, y,
" ".join("L{},{}".format(x, y) for x, y in points[1:]),
),
"style": """
fill:none;
stroke:#{:02x}{:02x}{:02x};
stroke-opacity:{};
stroke-width:{}
""".format(int(255*r), int(255*g), int(255*b), a,
width),
})
builder.end("path")
# Draw vertex markers
for x, y in points[1:-1]:
builder.start("use", {
"xlink:href": "#vertex",
"transform": "translate({}, {})".format(x, y)
})
builder.end("use")
# Draw start/end markers
if points[0] != points[-1]:
x, y = points[0]
builder.start("use", {
"xlink:href": "#start",
"transform": "translate({}, {})".format(x, y)
})
builder.end("use")
x, y = points[-1]
builder.start("use", {
"xlink:href": "#end",
"transform": "translate({}, {})".format(x, y),
})
builder.end("use")
else:
x, y = points[0]
builder.start("use", {
"xlink:href": "#vertex",
"transform": "translate({}, {})".format(x, y)
})
builder.end("use")
builder.end("svg")
print(ElementTree.tostring(builder.close(), "unicode"))
def _handle_get_bucket(gcs_stub, bucketpath, param_dict):
"""Handle get bucket request."""
prefix = _get_param('prefix', param_dict, '')
max_keys = _get_param('max-keys', param_dict, common._MAX_GET_BUCKET_RESULT)
marker = _get_param('marker', param_dict, '')
delimiter = _get_param('delimiter', param_dict, '')
stats, last_filename, is_truncated = gcs_stub.get_bucket(
bucketpath, prefix, marker, max_keys, delimiter)
builder = ET.TreeBuilder()
builder.start('ListBucketResult', {'xmlns': common.CS_XML_NS})
for stat in stats:
filename = stat.filename[len(bucketpath) + 1:]
if stat.is_dir:
builder.start('CommonPrefixes', {})
builder.start('Prefix', {})
builder.data(filename)
builder.end('Prefix')
builder.end('CommonPrefixes')
else:
builder.start('Contents', {})
builder.start('Key', {})
builder.data(filename)
builder.end('Key')
builder.start('LastModified', {})
builder.data(common.posix_to_dt_str(stat.st_ctime))
builder.end('LastModified')
builder.start('ETag', {})
builder.data(stat.etag)
builder.end('ETag')
builder.start('Size', {})
builder.data(str(stat.st_size))
builder.end('Size')
builder.end('Contents')
if last_filename:
builder.start('NextMarker', {})
builder.data(last_filename[len(bucketpath) + 1:])
builder.end('NextMarker')
builder.start('IsTruncated', {})
builder.data(str(is_truncated))
builder.end('IsTruncated')
max_keys = _get_param('max-keys', param_dict)
if max_keys is not None:
builder.start('MaxKeys', {})
builder.data(str(max_keys))
builder.end('MaxKeys')
builder.end('ListBucketResult')
root = builder.close()
body = ET.tostring(root)
response_headers = {'content-length': len(body),
'content-type': 'application/xml'}
return _FakeUrlFetchResult(httplib.OK, response_headers, body)
def __init__(self, etreebuilder=None):
if etreebuilder is None:
etreebuilder = ET.TreeBuilder()
self.etreebuilder = etreebuilder
self.default_namespace = None
def __init__(self, root=None):
self.__stack = []
self.__tb = ElementTree.TreeBuilder()
if root is not None:
self.push(root)
def get_element(self):
""" Return element from treebuilder and reset treebuilder for later use. """
element = self.treebuilder.close()
self.treebuilder = etree.TreeBuilder()
return element
def reset(self):
"""Reset this instance. Loses all unprocessed data."""
self.mdstack = [] # When markdown=1, stack contains a list of tags
self.treebuilder = etree.TreeBuilder()
self.mdstate = [] # one of 'block', 'span', 'off', or None
super().reset()
