self.manifest.remove_file_entry(f_info.filename) else: self.outzip.writestr(f_info, self.inzip.read(f_info.filename)) writer = _ZipWriteSplitStream(self.outzip, self.chunksize) output_encode(self.xml_serializer(writer(stream)), encoding=encoding, out=writer) for args in self._deferred: self.add_file(*args) self.manifest.remove_file_entry(THUMBNAILS + '/') if manifest_info: self.outzip.writestr(manifest_info, str(self.manifest)) self.inzip.close() self.outzip.close() if out is None: return result def add_file(self, path, content, mimetype): if self.outzip and path not in self.outzip.namelist(): try: self.outzip.writestr(path, content) self.manifest.add_file_entry(path, mimetype) except ValueError: self._deferred.append((path, content, mimetype)) MIMETemplateLoader.add_factory('oo.org', Template)
# You should have received a copy of the GNU General Public License along with # this program. If not, see <http://www.gnu.org/licenses/>. # ############################################################################### __metaclass__ = type import genshi.core from genshi.template import NewTextTemplate, MarkupTemplate from relatorio.reporting import MIMETemplateLoader class RelatorioStream(genshi.core.Stream): "Base class for the relatorio streams." def render(self, method=None, encoding='utf-8', out=None, **kwargs): "calls the serializer to render the template" return self.serializer(self.events) def serialize(self, method='xml', **kwargs): "generates the bitstream corresponding to the template" return self.render(method, **kwargs) def __or__(self, function): "Support for the bitwise operator" return RelatorioStream(self.events | function, self.serializer) MIMETemplateLoader.add_factory('text', NewTextTemplate) MIMETemplateLoader.add_factory('xml', MarkupTemplate)
class PDFSerializer: def __init__(self): self.text_serializer = genshi.output.TextSerializer() def __call__(self, stream, method=None, encoding='utf-8', out=None): if out is None: result = BytesIO() else: result = out working_dir = tempfile.mkdtemp(prefix='relatorio') tex_file = os.path.join(working_dir, 'report.tex') pdf_file = os.path.join(working_dir, 'report.pdf') with open(tex_file, 'w') as fp: fp.write(_encode(self.text_serializer(stream))) subprocess.check_call([TEXEXEC, '--purge', 'report.tex'], cwd=working_dir) with open(pdf_file, 'r') as fp: result.write(fp.read()) shutil.rmtree(working_dir, ignore_errors=True) if out is None: return result MIMETemplateLoader.add_factory('pdf', Template)
def setup(self): self.loader = MIMETemplateLoader() our_dir, _ = os.path.split(__file__) self.report = Report(os.path.join(our_dir, 'templates', 'test.tmpl'), 'text/plain', DefaultFactory(), self.loader)
self.text_serializer = genshi.output.TextSerializer() def __call__(self, stream): result = StringIO() yml = StringIO(_encode(self.text_serializer(stream))) chart_yaml = yaml.load(yml.read()) chart_info = chart_yaml['chart'] chart_type = chart_info['output_type'] if chart_type == 'png': surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, chart_yaml['options']['width'], chart_yaml['options']['height']) elif chart_type == 'svg': surface = cairo.SVGSurface(result, chart_yaml['options']['width'], chart_yaml['options']['height']) else: raise NotImplementedError chart = PYCHA_TYPE[chart_info['type']](surface, chart_yaml['options']) chart.addDataset(chart_info['dataset']) chart.render() if chart_type == 'png': surface.write_to_png(result) elif chart_type == 'svg': surface.finish() return result MIMETemplateLoader.add_factory('chart', Template, Template.id_function)
# this program. If not, see <http://www.gnu.org/licenses/>. # ############################################################################### __metaclass__ = type import genshi.core from genshi.template import NewTextTemplate, MarkupTemplate from relatorio.reporting import MIMETemplateLoader class RelatorioStream(genshi.core.Stream): "Base class for the relatorio streams." def render(self, method=None, encoding='utf-8', out=None, **kwargs): "calls the serializer to render the template" return self.serializer(self.events) def serialize(self, method='xml', **kwargs): "generates the bitstream corresponding to the template" return self.render(method, **kwargs) def __or__(self, function): "Support for the bitwise operator" return RelatorioStream(self.events | function, self.serializer) MIMETemplateLoader.add_factory('text', NewTextTemplate) MIMETemplateLoader.add_factory('xml', MarkupTemplate)
manifest_info = None for f_info in self.inzip.infolist(): if f_info.filename.startswith('ObjectReplacements'): continue elif f_info.filename in files: stream = files[f_info.filename] # create a new file descriptor, copying some attributes from # the original file new_info = zipfile.ZipInfo(f_info.filename, now) for attr in ('compress_type', 'flag_bits', 'create_system'): setattr(new_info, attr, getattr(f_info, attr)) serialized_stream = output_encode(self.xml_serializer(stream), encoding='utf-8') self.outzip.writestr(new_info, serialized_stream) elif f_info.filename == MANIFEST: manifest_info = f_info elif f_info.filename == META: self.outzip.writestr(f_info, str(self.meta)) elif f_info.filename.startswith(THUMBNAILS + '/'): self.manifest.remove_file_entry(f_info.filename) else: self.outzip.writestr(f_info, self.inzip.read(f_info.filename)) self.manifest.remove_file_entry(THUMBNAILS + '/') if manifest_info: self.outzip.writestr(manifest_info, str(self.manifest)) self.outzip.close() return self.new_oo MIMETemplateLoader.add_factory('oo.org', Template)
class Template(NewTextTemplate): def generate(self, *args, **kwargs): generated = super(Template, self).generate(*args, **kwargs) return RelatorioStream(generated, PDFSerializer()) class PDFSerializer: def __init__(self): self.working_dir = tempfile.mkdtemp(prefix="relatorio") self.tex_file = os.path.join(self.working_dir, "report.tex") self.pdf_file = os.path.join(self.working_dir, "report.pdf") self.text_serializer = genshi.output.TextSerializer() def __call__(self, stream): tex_file = open(self.tex_file, "w") tex_file.write(_encode(self.text_serializer(stream))) tex_file.close() subprocess.check_call([TEXEXEC, "--purge", "report.tex"], cwd=self.working_dir) pdf = StringIO() pdf.write(open(self.pdf_file, "r").read()) shutil.rmtree(self.working_dir, ignore_errors=True) return pdf MIMETemplateLoader.add_factory("pdf", Template)
class Template(NewTextTemplate): def generate(self, *args, **kwargs): generated = super(Template, self).generate(*args, **kwargs) return RelatorioStream(generated, PDFSerializer()) class PDFSerializer: def __init__(self): self.working_dir = tempfile.mkdtemp(prefix='relatorio') self.tex_file = os.path.join(self.working_dir, 'report.tex') self.pdf_file = os.path.join(self.working_dir, 'report.pdf') self.text_serializer = genshi.output.TextSerializer() def __call__(self, stream): tex_file = open(self.tex_file, 'w') tex_file.write(_encode(self.text_serializer(stream))) tex_file.close() subprocess.check_call([TEXEXEC, '--purge', 'report.tex'], cwd=self.working_dir) pdf = BytesIO() pdf.write(open(self.pdf_file, 'r').read()) shutil.rmtree(self.working_dir, ignore_errors=True) return pdf MIMETemplateLoader.add_factory('pdf', Template)