import simplejson as json
from flask import g
from flask import Flask
from flask import request
import r3d2msa as r3d
import mimerender
app = Flask(__name__, static_url_path='/r3d-2-msa/static')
# Define some content types
# TODO: Are these good types?
mimerender.register_mime('fasta', ('text/fasta',))
mimerender.register_mime('stockholm', ('text/stockholm',))
mimerender.register_mime('clustal', ('text/clustal',))
mimerender = mimerender.FlaskMimeRender()
def examples():
"""Get all known examples. This loads a JSON file for examples as this is
pretty basic configuration stuff and doesn't need a connection to a
database.
:returns: A list of the examples used.
"""
with open(app.config['examples'], 'rb') as raw:
return json.load(raw)
import mimerender
mimerender.register_mime('pdf', ('application/pdf', ))
mimerender = mimerender.FlaskMimeRender(global_charset='UTF-8')
def render_pdf(html):
from xhtml2pdf import pisa
from cStringIO import StringIO
pdf = StringIO()
pisa.CreatePDF(StringIO(html.encode('utf-8')), pdf)
resp = pdf.getvalue()
pdf.close()
return resp
@app.route('/invoice/<invoice_id>/', methods=['GET'])
@login_required
@mimerender(default='html',
html=lambda html: html,
pdf=render_pdf,
override_input_key='format')
def view_invoice(org_id, invoice_id):
html = render_template('invoice.html', id=invoice_id)
return {'html': html} # mimerender requires a dict
import os.path
from elasticsearch import Elasticsearch
from elasticsearch_dsl import Search, Q
from elasticsearch_dsl.query import MultiMatch, Match
from elasticsearch.exceptions import NotFoundError
import yaml
import sys
import json
from rdflib import Graph, plugin
import mimerender
import cgi
import html
import re
from json import dumps
mimerender.register_mime("turtle", ("text/turtle","text/n3"))
mimerender.register_mime("rdfxml", ("application/rdf+xml", "application/xml"))
mimerender.register_mime("nt", ("application/n-triples",))
#mimerender.register_mime("jsonld", ("application/ld+json",))
produces = mimerender.BottleMimeRender()
conf = {}
def find_static():
cwd = None
try:
cwd = os.path.dirname(__file__)
except NameError:
cwd = "."
return os.path.abspath(os.path.join(cwd, "static"))
import json
import time
import logging
from logging.handlers import RotatingFileHandler
from flask import current_app, Flask, request, Response, render_template, Markup
from weasyprint import HTML, CSS
import mimerender
from queremos import generate_base_letter
mimerender.register_mime('pdf', ('application/pdf',))
mimerender = mimerender.FlaskMimeRender(global_charset='UTF-8')
app = Flask(__name__)
formatter = logging.Formatter("%(asctime)s \t %(message)s")
handler = RotatingFileHandler('solicitudes.log', maxBytes=100000, backupCount=1)
handler.setFormatter(formatter)
app.logger.addHandler(handler)
app.logger.setLevel(logging.INFO)
def render_pdf(html):
page_settings = [CSS(string='@page { size: A3; margin: 1cm }')]
pdf = HTML(string=html).write_pdf(stylesheets=page_settings)
return pdf
def form_to_json_request(form_answers):
print(list(form_answers.keys()))
answers = {
"fecha": time.strftime("%d/%m/%Y"),
raise ArticleNotFound(self.path)
def __exit__(self, exc_type, exc_val, exc_tb):
pass
class DefaultConfig(object):
DEBUG = True
BLOGROOT = "."
THEME = "simplex"
BLOGTITLE = "Powered by Blogstrap"
HOMEPAGE_MESSAGE = "SUCCESS"
# Registering markdown as a valid MIME.
# More info: https://tools.ietf.org/html/rfc7763
mimerender.register_mime('markdown', ('text/markdown',))
mimerender = mimerender.FlaskMimeRender()
def create_app(config_file=None):
app = flask.Flask(__name__)
if config_file:
app.config.from_pyfile(config_file)
else:
app.config.from_object(DefaultConfig)
def render_html(message):
return flask.render_template("strapdown.html",
theme=app.config['THEME'],
text=message,
import json
from mimerender import FlaskMimeRender, register_mime, MimeRenderException
render = FlaskMimeRender()
try:
register_mime('jsonld', ('application/ld+json', ))
except MimeRenderException:
# assume already registered
pass
from flask import render_template
from mimerender import FlaskMimeRender
from config import DEBUG
from error import NotFound
# Following http://stackoverflow.com/q/13480675
render_xml_exception = lambda exception: '<exception>%s</exception>'%exception
render_json_exception = lambda exception: json.dumps({ 'exception' : '; '.join(exception.args)})
render_html_exception = lambda exception: '<html><body>%s</body></html>'%exception
render_txt_exception = lambda exception: exception
def map_exceptions(f):
mapping = [(NotFound, '404 Not Found')] # always mapped
if not DEBUG:
# only mapped when w/o Werkzeug
mapping.append([
(ValueError, '500 Internal Server Error'),
(NameError, '500 Internal Server Error'),
])
from botocore.errorfactory import ClientError
from flask import render_template, request
from flask.views import MethodView
from flask_sse import sse
from mimerender import FlaskMimeRender, register_mime
from werkzeug.exceptions import NotFound, Unauthorized
from flask_mongorest import methods
from flask_mongorest.exceptions import ValidationError
from flask_mongorest.utils import encode_default
TIMEOUT = 55 # in seconds
BUCKET = os.environ.get("S3_DOWNLOADS_BUCKET", "mongorest-downloads")
s3_client = boto3.client("s3")
flask_mimerender = FlaskMimeRender(global_override_input_key="short_mime")
register_mime("gz", ("application/gzip",))
def render_json(**payload):
return ujson.dumps(payload, allow_nan=True, default=encode_default)
def render_html(**payload):
d = ujson.dumps(payload, default=encode_default, sort_keys=True, indent=4)
return render_template("mongorest/debug.html", data=d)
def render_gz(**payload):
s3 = payload.get("s3")
if s3 and s3["update"]:
