Example #1
1
def create_app(config=None):
    """Create an instance of the tentd flask application"""
    app = Flask("tentd")
    app.add_url_rule("/", "home", description)
    app.request_class = Request

    # Load the default configuration values
    import tentd.defaults as defaults

    app.config.from_object(defaults)

    # Load the user configuration values
    if isinstance(config, basestring):
        config = make_config(config)

    if not isinstance(config, dict):
        raise TypeError("Config argument must be a dict or string.")

    if config is not None:
        app.config.update(config)

    # Initialise the db for this app
    db.init_app(app)

    # Register the entity blueprints
    for blueprint in (entity, followers, posts):
        app.register_blueprint(blueprint, url_prefix=blueprint.prefix(app))

    return app
Example #2
0
def create_app():
    from flask import Flask, Request, got_request_exception
    import rollbar.contrib.flask
    app = Flask(__name__)

    @app.route('/')
    def index():
        return 'Index page'

    @app.route('/cause_error', methods=['GET', 'POST'])
    def cause_error():
        raise Exception("Uh oh")
    
    @app.before_first_request
    def init_rollbar():
        rollbar.init(TOKEN, 'flasktest',
                     root=os.path.dirname(os.path.realpath(__file__)),
                     allow_logging_basic_config=True)
        got_request_exception.connect(rollbar.contrib.flask.report_exception, app)

    class CustomRequest(Request):
        @property
        def rollbar_person(self):
            return {'id': '123', 'username': 'testuser', 'email': 'test@example.com'}

    app.request_class = CustomRequest
    
    return app
Example #3
0
def create_app(config_name):
    app = Flask(__name__)
    app.config.from_object(config[config_name])
    config[config_name].init_app(app)
    app.request_class = ProxiedRequest

    db.init_app(app)
    bootstrap.init_app(app)
    mail.init_app(app)
    moment.init_app(app)
    login_manager.init_app(app)

    from .main import main as main_blueprint
    from .urls import urls as url_blueprint
    from .admin import admin as admin_blueprint
    from .auth import auth as auth_blueprint
    from .apartment import apartment as apartment_blueprint
    from .strava import strava as strava_blueprint

    app.register_blueprint(main_blueprint)
    app.register_blueprint(url_blueprint, url_prefix='/urls')
    app.register_blueprint(admin_blueprint, url_prefix='/admin')
    app.register_blueprint(auth_blueprint, url_prefix='/auth')
    app.register_blueprint(apartment_blueprint, url_prefix='/apartment')
    app.register_blueprint(strava_blueprint, url_prefix='/strava')

    if not app.config['SSL_DISABLE']:
        from flask.ext.sslify import SSLify
        sslify = SSLify(app)

    return app
Example #4
0
 def load_app(self, config):
     """
     Called from the parent class, so we can provide the appropriate flask
     app for this test case.
     """
     app = Flask('test.localhost')
     app.request_class = Request
     app.config.update(config)
     app.register_blueprint(test_views)
     app.central_userdb = UserDB(app.config['MONGO_URI'], 'eduid_am')
     app.session_interface = SessionFactory(app.config)
     return app
Example #5
0
def create(static_url_path='', configuration=None, settings=settings,
           environment_variable="CRAIC_SETTINGS", blueprints=[]):
    """Create the Craic application.

    :param static_url_path: Default ``''``. Specify the URL path for static
        files.
    :param configuration: Default `None`. Python configuration file name.
    :param settings: Default :mod:`settings`. Default configuration settings -
        used only if `configuration` is not provided.
    :param environment_variable: Default ``'CRAIC_SETTINGS'``. The name of the
        environment variable that points to a configuration file - overrides
        any existing configuration setting.
    :param blueprints: Default `[]`. A list of application blueprints.
    """
    ret_val = Flask(__name__, static_url_path=static_url_path)
    ret_val.request_class = Request

    if configuration:
        ret_val.config.from_pyfile(configuration)
    else:
        ret_val.config.from_object(settings)

    ret_val.config.from_envvar(environment_variable, silent=True)
    init_extensions(ret_val)
    init_blueprints(ret_val, *blueprints)
    init_middleware(ret_val)

    @ret_val.before_request
    def before_request():
        g.is_local = is_local(request.environ)
        g.user_agent = UserAgent(request.environ)

    @ret_val.context_processor
    def context_processor():
        if hasattr(g, "title"):
            title = gettext("Craic / %(title)s", title=g.title)
        else:
            title = gettext("Craic.")

        return dict(title=title)

    return ret_val
Example #6
0
def create_app(configfilename=None):
    """Loads the configfilename in the app.config object as requested"""
    setup_logging()
    log.debug('creating application')
    app = Flask(__name__)
    setup_config(app, configfilename)
    setup_modules(app)
    setup_aux(app)
    # If we run behind nginx, fix the request vars
    if app.config['PROXYPASS']:
        log.debug("Loading proxy fix")
        app.wsgi_app = ProxyFix(app.wsgi_app)
    else:
        log.debug("Running without proxy fix")
    # bittorrent clients live in the stone age
    app.request_class = Latin1Request
    log.debug('setup request class')
    # Register the redis connect before every request
    app.before_request(redis_connect)
    log.debug('assigned before_request')
    return app
Example #7
0
def create_app():
    from flask import Flask, Request, got_request_exception
    import rollbar.contrib.flask
    app = Flask(__name__)

    @app.route('/')
    def index():
        return 'Index page'

    @app.route('/cause_error', methods=['GET', 'POST'])
    def cause_error():
        raise Exception("Uh oh")

    class CustomRequest(Request):
        @property
        def rollbar_person(self):
            return {'id': '123', 'username': 'testuser', 'email': 'test@example.com'}

    app.request_class = CustomRequest

    return app
Example #8
0
import pymongo
from urlparse import urlparse
import datetime
import logging

logging.basicConfig(level=logging.DEBUG)

HEADERS_TO_COPY = ['Content-Type']


class SimpleRequest(Request):
    want_form_data_parsed = False
    data = None

app = Flask(__name__)
app.request_class = SimpleRequest

MONGO_URL = os.environ.get('MONGOHQ_URL')

if MONGO_URL:
    conn = pymongo.MongoClient(MONGO_URL)
    db = conn[urlparse(MONGO_URL).path[1:]]
else:
    conn = pymongo.MongoClient('localhost', 27017)
    db = conn[__name__]

@app.route('/', defaults={'path': ''}, methods=['GET'])
@app.route('/<path:path>', methods=['GET'])
def catch_all_get(path):

    doc = db.state.find_one({'_id': path})
Example #9
0
import os
import json

from flask import Flask, jsonify
from sqlalchemy import create_engine
from sqlalchemy.pool import StaticPool
from sqlalchemy.orm import sessionmaker, scoped_session

from .orm.mappings import metadata
from .models import User, Blog, Entry, Client
from .services import EntryService, BlogService, UserService, OAuthService
from .oauth import OAuthRequest

app = Flask('faust')
app.request_class = OAuthRequest

try:
  username = 'vagrant'
  password = 'vagrant'
  host = 'localhost'
  port = 5432
  name = 'faust'
  connection_string = 'postgresql://%s:%s@%s:%d/%s' % (username, password, host, port, name)
  engine = create_engine(connection_string)
except Exception:
  connection_string = 'sqlite:///:memory:'
  engine = create_engine(connection_string, 
    connect_args={'check_same_thread':False},
    poolclass=StaticPool,
    echo=False
  )
Example #10
0
        if len(get_ip_users( request.remote_addr )) >= NUM_USERS_REQUIRED:
            state = "unlocked"
        else:
            state = "locked"
        return render_template('index.html', **locals())

@app.route('/add')
def cookie_insertion():
    redirect_to_index = redirect('/')
    response = make_response(redirect_to_index)
    # Create random cookie id
    cookie = '%030x' % random.randrange(256**15)
    # Don't expire for a month
    expires = datetime.now() + timedelta(days=30)
    response.set_cookie('existing_user', cookie, expires=expires)
    return response
    
@app.route('/critical_mass_reached')
def critical_mass_reached():
    num_users = len(get_ip_users( request.remote_addr ))
    percent = min(100 * num_users/NUM_USERS_REQUIRED,100)
    return Response("%s,%s" % (percent,num_users), mimetype='text/plain')

if __name__ == '__main__':
    # Bind to PORT if defined, otherwise default to 5000.
    port = int(os.environ.get('PORT', 5000))
    # App debugging on
    app.debug = True
    # Workaround for Heroku Request IPs
    app.request_class = ProxiedRequest
    app.run(host='0.0.0.0', port=port)
Example #11
0
from data_models import Quote, Tag, Vote
from jsonify import jsonify
import flask_override
from db import db
from sql import db_session # yuck, we shouldnt dep on this
from basic_auth import FlaskRealmDigestDB
from news import News
from rest import build_link, add_loc_hdr, add_link_hdr

# app config
SECRET_KEY = '\xfb\x12\xdf\xa1@i\xd6>V\xc0\xbb\x8fp\x16#Z\x0b\x81\xeb\x16'
DEBUG = True
CACHE_TYPE = 'simple'

app = Flask(__name__)
app.request_class = flask_override.Request
app.config.from_object(__name__)
app.wsgi_app = ProxyFix(app.wsgi_app)

cache = Cache(app)

navs = [
    build_link('/top', 'pyqdb/quotes', Quote.list_json_mimetype, title='Top'),
    build_link('/quotes', 'pyqdb/quotes', Quote.list_json_mimetype, title='Browse'),
    build_link('/random', 'pyqdb/quotes', Quote.list_json_mimetype, title='Random'),
    build_link('/tags', 'pyqdb/tags', Tag.list_json_mimetype, title='Tags'),
    build_link('/search', '', 'application/json', title='Search'),
    build_link('/quotes/new', 'pyqdb/quote/new', Quote.json_mimetype, title='Submit')
]

authDB = FlaskRealmDigestDB('MyAuthRealm')
Example #12
0
def create_app(config):
    app = Flask(__name__,
                template_folder=config.SOURCE_TEMPLATES_DIR,
                static_folder=path.join(config.SECUREDROP_ROOT, 'static'))
    app.request_class = RequestThatSecuresFileUploads
    app.config.from_object(config.SourceInterfaceFlaskConfig)

    # The default CSRF token expiration is 1 hour. Since large uploads can
    # take longer than an hour over Tor, we increase the valid window to 24h.
    app.config['WTF_CSRF_TIME_LIMIT'] = 60 * 60 * 24

    CSRFProtect(app)

    @app.errorhandler(CSRFError)
    def handle_csrf_error(e):
        msg = render_template('session_timeout.html')
        session.clear()
        flash(Markup(msg), "important")
        return redirect(url_for('main.index'))

    assets = Environment(app)
    app.config['assets'] = assets

    i18n.setup_app(config, app)

    app.jinja_env.trim_blocks = True
    app.jinja_env.lstrip_blocks = True
    app.jinja_env.globals['version'] = version.__version__
    if getattr(config, 'CUSTOM_HEADER_IMAGE', None):
        app.jinja_env.globals['header_image'] = config.CUSTOM_HEADER_IMAGE
        app.jinja_env.globals['use_custom_header_image'] = True
    else:
        app.jinja_env.globals['header_image'] = 'logo.png'
        app.jinja_env.globals['use_custom_header_image'] = False

    app.jinja_env.filters['rel_datetime_format'] = \
        template_filters.rel_datetime_format
    app.jinja_env.filters['nl2br'] = evalcontextfilter(template_filters.nl2br)
    app.jinja_env.filters['filesizeformat'] = template_filters.filesizeformat

    for module in [main, info, api]:
        app.register_blueprint(module.make_blueprint(config))

    @app.before_request
    @ignore_static
    def check_tor2web():
        # ignore_static here so we only flash a single message warning
        # about Tor2Web, corresponding to the initial page load.
        if 'X-tor2web' in request.headers:
            flash(Markup(gettext(
                '<strong>WARNING:&nbsp;</strong> '
                'You appear to be using Tor2Web. '
                'This <strong>&nbsp;does not&nbsp;</strong> '
                'provide anonymity. '
                '<a href="{url}">Why is this dangerous?</a>')
                .format(url=url_for('info.tor2web_warning'))),
                  "banner-warning")

    @app.before_request
    @ignore_static
    def setup_g():
        """Store commonly used values in Flask's special g object"""
        g.locale = i18n.get_locale(config)
        g.text_direction = i18n.get_text_direction(g.locale)
        g.html_lang = i18n.locale_to_rfc_5646(g.locale)
        g.locales = i18n.get_locale2name()

        if 'expires' in session and datetime.utcnow() >= session['expires']:
            msg = render_template('session_timeout.html')

            # clear the session after we render the message so it's localized
            session.clear()

            flash(Markup(msg), "important")

        session['expires'] = datetime.utcnow() + \
            timedelta(minutes=getattr(config,
                                      'SESSION_EXPIRATION_MINUTES',
                                      120))

        # ignore_static here because `crypto_util.hash_codename` is scrypt
        # (very time consuming), and we don't need to waste time running if
        # we're just serving a static resource that won't need to access
        # these common values.
        if logged_in():
            g.codename = session['codename']
            g.filesystem_id = crypto_util.hash_codename(g.codename)
            try:
                g.source = Source.query \
                            .filter(Source.filesystem_id == g.filesystem_id) \
                            .one()
            except NoResultFound as e:
                app.logger.error(
                    "Found no Sources when one was expected: %s" %
                    (e,))
                del session['logged_in']
                del session['codename']
                return redirect(url_for('main.index'))
            g.loc = store.path(g.filesystem_id)

    @app.teardown_appcontext
    def shutdown_session(exception=None):
        """Automatically remove database sessions at the end of the request, or
        when the application shuts down"""
        db_session.remove()

    @app.errorhandler(404)
    def page_not_found(error):
        return render_template('notfound.html'), 404

    @app.errorhandler(500)
    def internal_error(error):
        return render_template('error.html'), 500

    return app
Example #13
0
#!/usr/bin/env python

import socket
from flask import Flask
from flask import Request, request
from functools import partial
import json

from werkzeug.datastructures import ImmutableOrderedMultiDict

class OrderedRequest(Request):
    parameter_storage_class = ImmutableOrderedMultiDict

app = Flask(__name__)
app.request_class = OrderedRequest

SOCKET_HOST = "lsnag.int.unavco.org"
SOCKET_PORT = 8080



def standardize_json(result, headers = None):
    """
    LiveService returns json with the headers first (if no columns are specified) 
    and then each row of data, like a csv file.  This function will
    turn this result into a more standard version of json
    """
    json_result = json.loads(result)
    if headers is None:
        headers = json_result.pop(0)
    # Get a partial that we can pass to map
Example #14
0
from flask import Flask
from flask_restful import Api
from flask.ext.login import LoginManager

import skwele.views as views
from skwele.request import Request
from skwele.resources.user import user_loader, User, UserList
from skwele.resources.org import Org, OrgList
from skwele.resources.dataset import Dataset, DatasetList

app = Flask(__name__)
app.request_class = Request
api = Api(app)

app.secret_key = 'A0Zr98j/3yX R~XHH!jmN]LWX/,?RT'

login_manager = LoginManager()
login_manager.init_app(app)
login_manager.user_loader(user_loader)

#
# Flask-RESTful routing
#
api.add_resource(UserList, '/users')
api.add_resource(User,     '/users/<id>', endpoint='user')
api.add_resource(OrgList,  '/orgs')
api.add_resource(Org,      '/orgs/<id>', endpoint='org')
api.add_resource(DatasetList, '/datasets')
api.add_resource(Dataset,  '/datasets/<id>', endpoint='dataset')
Example #15
0

class JSONRequest(Request):
    # from http://flask.pocoo.org/snippets/45/
    def wants_json(self):
        mimes = json_mimetypes
        mimes.append('text/html')
        best = self.accept_mimetypes.best_match(mimes)
        return best in json_mimetypes and \
            self.accept_mimetypes[best] > \
            self.accept_mimetypes['text/html']


app = Flask(__name__)
app.config.from_object(config)
app.request_class = JSONRequest
app.jinja_env.filters['datetime'] = format_datetime
app.jinja_env.filters['isodatetime'] = lambda d: d.isoformat() + 'Z'
app.jinja_env.filters['format_currency'] = format_currency
app.static_folder = 'static'

redis_conn = redis.from_url(app.config['REDIS_URL'])
app.session_interface = session.RedisSessionInterface(redis_conn)

csrf = SeaSurf(app)
db = SQLAlchemy(app)
migrate = Migrate(app, db)

login_manager = LoginManager()
login_manager.login_view = "auth.login"
login_manager.init_app(app)
Example #16
0
import config
import lib
from flask import Flask, Request
from flask.ext.sqlalchemy import SQLAlchemy

app = Flask(__name__)
app.config.from_object(config)
app.request_class = lib.Request

db = SQLAlchemy(app)

def format_datetime(value):
    return value.strftime("%Y-%m-%d %H:%M:%S %z")
app.jinja_env.filters['datetime'] = format_datetime

import foodforus.views

if not app.debug:
    import logging
    from logging.handlers import SMTPHandler
    mail_handler = SMTPHandler('127.0.0.1',
                               app.config['MAIL_FROM'],
                               app.config['ADMINS'], "foodforus error")
    mail_handler.setFormatter(logging.Formatter('''\
Message type:       %(levelname)s
Time:               %(asctime)s

%(message)s
'''))
    mail_handler.setLevel(logging.ERROR)
    app.logger.addHandler(mail_handler)
Example #17
0
def create_app(config_filename=None):
    app = Flask(__name__)
    app.request_class = Request
    app.url_map.converters['re'] = RegexConverter

    if config_filename is None:
        HerokuConfig(app)
    else:
        AppConfig(app, config_filename)

    from_envvars(app.config, prefix='')
    app.debug = app.config.get('DEBUG')

    # TODO: these variables probably aren't unjsonnable anymore

    # push all variables into the environment
    unjsonnable = (datetime, timedelta)
    data = {k: json.dumps(v) for k, v in app.config.items() if not isinstance(v, unjsonnable)}
    os.environ.update(data)

    # app.logger.info('App is running on port %s', os.environ.get('PORT'))

    if app.config['DEBUG'] is not True:
        log_level = app.config.get('LOG_LEVEL', 'DEBUG')
        app.logger.setLevel(getattr(logging, log_level.upper()))

    import bauble.db as db

    if 'LOG_SQL' in os.environ:
        logging.getLogger('sqlalchemy.engine').setLevel(logging.INFO)

    db.init_app(app)

    # register flask extensionsa
    SSLify(app, permanent=True)
    app.login_manager = LoginManager(app)
    app.login_manager.login_view = "auth.login"
    app.mail = Mail(app)
    app.babel = Babel(app)

    from .assets import init_app
    init_app(app)


    # TODO: just import everything controllers

    for controller in ['auth', 'index', 'batch']:
        module = import_module('bauble.controllers.{}'.format(controller))
        app.register_blueprint(module.blueprint)

    from bauble.resource import Resource
    controllers = ['search', 'family', 'genus', 'taxon', 'accession',
                   'plant', 'location', 'vernacular_name']
    for controller in controllers:
        module = import_module('bauble.controllers.{}'.format(controller))
        for attr_name in dir(module):
            attr = getattr(module, attr_name)
            # find all the blueprints in the files
            if isinstance(attr, Blueprint):
                app.register_blueprint(attr)
            # if isclass(attr) and issubclass(attr, Blueprint) and attr != Resource:
            #     app.register_blueprint(attr())

    from bauble.error import init_errorhandlers
    init_errorhandlers(app)

    app.json_encoder = JSONEncoder

    return app
from flask import json
from flask import Flask
from flask.ext import gae_tests
from flask.ext import gae_blobstore
from google.appengine.api import files
from google.appengine.ext import ndb


# test application..

class TestModel(ndb.Model):
  blob_key = ndb.BlobKeyProperty()

app = Flask(__name__)
app.debug = True
app.request_class = gae_tests.FileUploadRequest

@app.route('/test_upload', methods=['POST', 'OPTIONS', 'HEAD', 'PUT'])
@gae_blobstore.upload_blobs()
def test_upload(uploads):
  entities = []
  try:
    for upload in uploads:
      entity = TestModel(
        blob_key=upload.blob_key)
      entities.append(entity)
      blob_info = upload.blob_info
      logging.info('upload.blob_info: %s', blob_info)
    ndb.put_multi(entities)
  except:
    # rollback the operation and delete the blobs,
Example #19
0
File: store.py Project: dlobue/clio
app = Flask(__name__)
app.config.from_object('clio.settings')
try:
    app.config.from_envvar('CLIO_SETTINGS')
except RuntimeError:
    if os.path.exists('/etc/clio/app.conf'):
        app.logger.debug("couldn't load settings from file in envvar. trying /etc/clio/app.conf")
        try:
            app.config.from_pyfile('/etc/clio/app.conf')
        except RuntimeError:
            app.logger.debug("unable to find any settings files. using defaults in local settings module.")
    else:
        app.logger.debug("unable to find any settings files. using defaults in local settings module.")

from utils import ExtRequest
app.request_class = ExtRequest

mongo_conn = None
def get_mongo_conn():
    global mongo_conn
    if mongo_conn is None:
        mongo_conn = pymongo.Connection(app.config['MONGO_HOSTS'], app.config['MONGO_PORT']).clio
    return mongo_conn


def validify_data(data):
    if not isinstance(data, dict):
        return data

    for key in data.iterkeys():
        if isinstance(data[key], dict):
Example #20
0
from raven import Client
from raven.middleware import Sentry

from yoi.account.user import bp as account
from yoi.config import (secret,
                        database_url,
                        in_production,
                        canonical_domain,
                        always_secure)
from yoi import dweeb
from yoi.flask_genshi import Genshi, render_response
from yoi import middleware
from yoi.resources import static_url

app = Flask(__name__)
app.request_class = dweeb.Request

app.genshi = Genshi(app)
app.db = SQLAlchemy(app)

app.register_blueprint(account)

# FIXME - Use app.config.from_object
app.config['DEBUG'] = True
app.config['PROPAGATE_EXCEPTIONS'] = True
app.config['SQLALCHEMY_DATABASE_URI'] = database_url
app.config['SECRET_KEY'] = secret

if canonical_domain:
    app.config['SESSION_COOKIE_DOMAIN'] = canonical_domain
app.config['SESSION_COOKIE_HTTPONLY'] = True
Example #21
0
from flask import Flask

app = Flask(__name__)
app.config.from_object('coinvibes.settings')

import coinvibes.views
import coinvibes.exchange_apis
import coinvibes.utils
import coinvibes.api_v1

import analytics

analytics.init('5asae1e0a2gpb8uu0sx0')

## use HerokuRequest class so we get real IPs
app.request_class = utils.ProxiedRequest
Example #22
0
DEBUG_MODE = settings.DEBUG_MODE


DIRNAME = os.path.dirname(__file__)
if not DIRNAME:
    DIRNAME = '/home/ki/my_projects/dartz_spb_ru__shop/dartz_shop/src'
DB_NAME = '%s/items.csv' % DIRNAME
LOCKFILE = '%s/items.lock' % DIRNAME


class CyrillicRequest(Request):
    url_charset = 'cp1251'

app = Flask(__name__)
if not DEBUG_MODE:
    app.request_class = CyrillicRequest

# Turn of on production
app.debug = DEBUG_MODE


#=============================
#           UTILS
#=============================
def unicode_csv_reader(unicode_csv_data, dialect=csv.excel, **kwargs):
    # csv.py doesn't do Unicode; encode temporarily as UTF-8:
    csv_reader = csv.reader(unicode_csv_data,
                            dialect=dialect, **kwargs)
    for row in csv_reader:
        # decode UTF-8 back to Unicode, cell by cell:
        yield [unicode(cell, 'utf-8') for cell in row]
Example #23
0
# Allow login manager to load a user from the database
@lm.user_loader
def load_user(id):
    if id is not None:
        return User.query.get(int(id))
    else:
        return None

# Remember the current user
@app.before_request
def before_request():
    g.user = current_user

# Replace the remote_addr property so that it returns a non-proxy IP
class HerokuRequest(Request):
    @property
    def remote_addr(self):
        forwarded_for = self.environ.get("HTTP_X_FORWARDED_FOR", None)
        if forwarded_for:
            # If the object contains multiple addresses, the actual IP is first
            if "," in forwarded_for:
                return fwd.split(",")[0]
            else:
                return forwarded_for
        # Otherwise, return the default value
        else:
            return self.environ.get("REMOTE_ADDR")

# Use the HerokuRequest class so that the actual IPs are retrieved
app.request_class = HerokuRequest
# -*- coding: UTF-8 -*-
# vim: set ts=4 sw=4 expandtab :

from flask import Flask, Response, jsonify, request, abort

import complexform

app = Flask(__name__)
app.request_class = complexform.ComplexFormRequest

@app.route("/", methods=["GET", "POST", "PATCH", "DELETE"])
def index():
    print "REQUEST"

    import pdb; pdb.set_trace()

    return "OK"

if __name__ == '__main__':
    app.run()
# postgres unicode
psycopg2.extensions.register_type(psycopg2.extensions.UNICODE)
psycopg2.extensions.register_type(psycopg2.extensions.UNICODEARRAY)
from psycopg2.extras import NamedTupleCursor
from itsdangerous import URLSafeSerializer
from functools import wraps
from pkg_resources import resource_string
from datetime import datetime
from pyuca import Collator

collator = Collator()

class MyRequest(Request):
  parameter_storage_class = OrderedMultiDict

app.request_class = MyRequest

from schema import Charakteristika

if 'CHARAKTERISTIKA_DEBUG' in os.environ:
  app.debug = True

from local_settings import active_config
config = active_config(app)
app.secret_key = config.secret

deform_bp = Blueprint('deform', 'deform', static_folder='static', url_prefix='/deform')
app.register_blueprint(deform_bp)

form_deform_templates = resource_filename('deform', 'templates')
form_my_templates = resource_filename(__name__, 'templates')
Example #26
0
from backdrop import statsd
from backdrop.core.data_set import DataSet
from backdrop.core.flaskutils import DataSetConverter
from backdrop.write.decompressing_request import DecompressingRequest
from .validation import auth_header_is_valid, extract_bearer_token
from ..core import log_handler, cache_control
from ..core.errors import ParseError, ValidationError
from ..core.flaskutils import generate_request_id
from ..core.storage.storage_factory import create_storage_engine

ENVIRONMENT = getenv("ENVIRONMENT", "development")

app = Flask("backdrop.write.api")

# We want to allow clients to compress large JSON documents.
app.request_class = DecompressingRequest

feature_flags = FeatureFlag(app)

# Configuration
app.config.from_object(
    "backdrop.write.config.{}".format(ENVIRONMENT))

storage = create_storage_engine(app.config)

admin_api = client.AdminAPI(
    app.config['STAGECRAFT_URL'],
    app.config['SIGNON_API_USER_TOKEN'],
    dry_run=False,
    request_id_fn=generate_request_id,
)
Example #27
0
        return self.readline()


class FileShareRequest(Request):
    def __init__(self, environ, populate_request=True, shallow=False):
        environ = copy(environ)

        stream = ProgressWsgiInputWrapper(environ['wsgi.input'], get_content_length(environ))
        environ['wsgi.input'] = stream

        super(FileShareRequest, self).__init__(environ, populate_request, shallow)

        progress_streams[self.path] = stream


app.request_class = FileShareRequest


@app.route('/')
def index():
    global upload_id

    upload_id += 1

    return render_template('index.html', upload_id=upload_id)


@app.route('/upload/<upload_id>', methods=["POST"])
def upload(upload_id):
    print request.files
Example #28
0
def create_app(config=None, **kwargs):
    """Create the WSGI application that is this app.

    In addition to the arguments documented below, this function accepts as a
    keyword agument all agruments to :py:class:`flask.Flask` except
    `import_name`, which is set to 'evesrp'. Additionally, the value of
    `instance_relative_config` has a default value of `True`.

    If the `config` argument isn't specified, the app will attempt to use the
    file 'config.py' in the instance folder if it exists, and will then fall
    back to using the value of the EVESRP_SETTINGS environment variable as a
    path to a config file.

    :param config: The app configuration file. Can be a Python
        :py:class:`dict`, a path to a configuration file, or an importable
        module name containing the configuration.
    :type config: str, dict
    """
    # Default instance_relative_config to True to let the config fallback work
    kwargs.setdefault('instance_relative_config', True)
    app = Flask('evesrp', **kwargs)
    app.request_class = AcceptRequest
    app.config.from_object('evesrp.default_config')
    # Push the instance folder path onto sys.path to allow importing from there
    sys.path.insert(0, app.instance_path)
    # Check in config is a dict, python config file, or importable object name,
    # in that order. Finally, check the EVESRP_SETTINGS environment variable
    # as a last resort.
    if isinstance(config, dict):
        app.config.update(config)
    elif isinstance(config, six.string_types):
        if config.endswith(('.txt', '.py', '.cfg')):
            app.config.from_pyfile(config)
        else:
            app.config.from_object(config)
    elif config is None:
        try:
            app.config.from_pyfile('config.py')
        except OSError:
            app.config.from_envvar('EVESRP_SETTINGS')

    # Register SQLAlchemy monitoring before the DB is connected
    app.before_request(sqlalchemy_before)

    db.init_app(app)

    from .views.login import login_manager
    login_manager.init_app(app)

    before_csrf = list(app.before_request_funcs[None])
    csrf.init_app(app)
    # Remove the context processor that checks CSRF values. All it is used for
    # is the template function.
    app.before_request_funcs[None] = before_csrf

    # Hook up OAuth
    oauth.init_app(app)

    # Connect views
    from .views import index, error_page, update_navbar, divisions, login,\
            requests, api
    app.add_url_rule(rule=u'/', view_func=index)
    for error_code in (400, 403, 404, 500):
        app.register_error_handler(error_code, error_page)
    app.after_request(update_navbar)
    app.register_blueprint(divisions.blueprint, url_prefix='/division')
    app.register_blueprint(login.blueprint)
    app.register_blueprint(requests.blueprint, url_prefix='/request')
    app.register_blueprint(api.api, url_prefix='/api')
    app.register_blueprint(api.filters, url_prefix='/api/filter')

    from .views import request_count
    app.add_template_global(request_count)

    from .json import SRPEncoder
    app.json_encoder=SRPEncoder

    # Configure the Jinja context
    # Inject variables into the context
    from .auth import PermissionType
    @app.context_processor
    def inject_enums():
        return {
            'ActionType': models.ActionType,
            'PermissionType': PermissionType,
            'app_version': __version__,
            'site_name': app.config['SRP_SITE_NAME'],
            'url_for_page': requests.url_for_page,
        }
    # Auto-trim whitespace
    app.jinja_env.trim_blocks = True
    app.jinja_env.lstrip_blocks = True

    init_app(app)

    return app
Example #29
0
File: app.py Project: iluddy/flock
    setup_logger(cfg["logging"]["file"], cfg["logging"]["level"])

    # Init Rollbar
    @app.before_first_request
    def init_rollbar():
        rollbar.init(
            cfg["rollbar"]["token"],
            cfg["rollbar"]["environment"],
            root=os.path.dirname(os.path.realpath(__file__)),
            allow_logging_basic_config=False
        )
        got_request_exception.connect(rollbar.contrib.flask.report_exception, app)

    class CustomRequest(Request):
        @property
        def rollbar_person(self):
            from flask import session
            return {'id': session['user_id'], 'username': session['user_name'], 'email': session['email']}

    app.request_class = CustomRequest

    # Create Views
    from flock import views

    # Run using flask development server
    # app.run(cfg["web_server"]["host"], cfg["web_server"]["port"])

    # Run with Tornado
    http_server = HTTPServer(WSGIContainer(app))
    http_server.listen(cfg["web_server"]["port"], address=cfg["web_server"]["host"])
    IOLoop.instance().start()
Example #30
0
                                  "%(asctime)s - %(name)s - " + \
                                  "%(levelname)s\n%(message)s")
    file_handler.setFormatter(formatter)
    app.logger.addHandler(file_handler)

# initialize configured database connections
for username, password, database, label, hidden in config.DEFAULT_DATABASES:
    models.add_database(username, password, database, label, hidden)


class LimitedRequest(Request):
    """ extending Flask's request class to limit form uploads to 500 MB """
    max_form_memory_size = 500 * 1024 * 1024


app.request_class = LimitedRequest
app.config.update(
    SECRET_KEY=config.SECRET_KEY,
    PERMANENT_SESSION_LIFETIME=datetime.timedelta(days=14),
    CACHE_TYPE='filesystem',
    CACHE_DIR=config.TEMP_DIR,
    MAIL_SERVER=config.MAIL_SERVER,
    MAIL_PORT=config.MAIL_PORT,
    MAIL_USE_TLS=config.MAIL_USE_TLS,
    MAIL_USE_SSL=config.MAIL_USE_SSL,
    MAIL_USERNAME=config.MAIL_USERNAME,
    MAIL_PASSWORD=config.MAIL_PASSWORD,
    DEFAULT_MAIL_SENDER=config.DEFAULT_MAIL_SENDER
)
cache.init_app(app)
mail.init_app(app)