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()