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)
