import flask import flask_bouncer import flask_login import flask_restx from flask import request from flask_restx import fields from website import decorators from website.data.comments import models as models from website.domain.blogs import queries as blog_queries from website.domain.comments import operations, queries from website.interfaces import api from website.interfaces.api.comments import serializers comments = flask.Blueprint( name="api-comments", import_name=__name__, url_prefix="/api/v1/comments", ) api_comments = api.Api( app=comments, version="1.0", title="Comments API", description="API for comments, which currently relies on session cookies.", ) comment_marshaller = api_comments.model( name="Comment", model=dict(body=fields.String), ) class CommentDetail(flask_restx.Resource): serializer = serializers.Comment()
''' Implements the Flask API endpoints. ''' from expertise.service.expertise import ExpertiseService import openreview from openreview.openreview import OpenReviewException from .utils import mock_client from .utils import get_user_id import flask from copy import deepcopy from flask_cors import CORS from multiprocessing import Value from csv import reader BLUEPRINT = flask.Blueprint('expertise', __name__) CORS(BLUEPRINT, supports_credentials=True) def get_client(): token = flask.request.headers.get('Authorization') in_test_mode = 'IN_TEST' in flask.current_app.config.keys() if in_test_mode: return mock_client() return openreview.Client( token=token, baseurl=flask.current_app.config['OPENREVIEW_BASEURL']) def format_error(status_code, description): '''
import flask from data import db_session from data.jobs import Jobs blueprint = flask.Blueprint('jobs_api', __name__, template_folder='templates') @blueprint.route('/api/jobs') def get_jobs(): jobs = db_session.create_session().query(Jobs).all() return flask.jsonify({'jobs': [item.to_dict() for item in jobs]}) @blueprint.route('/api/jobs/<int:jobs_id>', methods=['GET']) def get_one_jobs(jobs_id): db_sess = db_session.create_session() jobs = db_sess.query(Jobs).get(jobs_id) if not jobs: return flask.jsonify({'error': 'Not found'}) return flask.jsonify({ 'jobs': jobs.to_dict(only=('team_leader', 'job', 'work_size', 'collaborators', 'start_date', 'end_date', 'is_finished')) }) @blueprint.route('/api/jobs', methods=['POST']) def create_jobs(): if not flask.request.json: return flask.jsonify({'error': 'Empty request'})
# Copyright 2016: Mirantis Inc. # All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); you may # not use this file except in compliance with the License. You may obtain # a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations # under the License. import flask optimization = flask.Blueprint("optimization", __name__) @optimization.route("/") def get_optimization(): return flask.jsonify({"result": {"optimization": "dummy"}}) def get_blueprints(): return [["/optimization", optimization]]
import typing import flask import flask_apispec import flask_jwt_extended import flask_jwt_extended.exceptions from flask_apispec import views from backend import settings from . import schema app = flask.Blueprint('workspace', __name__) @flask_apispec.use_kwargs(schema.AuthRequestSchema) @flask_apispec.marshal_with(schema.AuthResponseSchema) class OrthancAuth(views.MethodResource): def post(self, **kwargs: typing.Any) -> typing.Dict[str, typing.Any]: access_token = kwargs.pop('token_value') granted = True try: flask_jwt_extended.decode_token(access_token) except flask_jwt_extended.exceptions.JWTDecodeError: granted = False return { 'granted': granted, 'validity': settings.ORTHANC_SESSION_VALIDITY }
import logging import flask import os import config photos_routes = flask.Blueprint('photos', __name__, url_prefix='/api') logger = logging.getLogger(__name__) @photos_routes.route('/photos', methods=['DELETE']) def delete_photos(): save_dir = os.path.join(config.root_dir, config.save_dir) removed = [] for filename in os.listdir(save_dir): os.unlink(os.path.join(save_dir, filename)) removed.append(filename) return flask.jsonify({'removed': removed}), 200
import jinja2 import flask blueprint = flask.Blueprint('filters', __name__) @blueprint.app_template_filter() def datetimeformat(value, format='%H:%M / %d-%m-%Y'): from datetime import datetime return datetime.utcfromtimestamp(value).strftime(format) @blueprint.app_template_filter() def folder(value): return value.split('.')[0] @blueprint.app_template_filter() def slug(str): import re slug = re.sub("[!@#$%^&*()[\]{};:,\\|./<>?|~=+]", "", str) slug = slug.replace(' ', '_') return slug
from ipaddress import ip_address import flask from nyaa import forms, models from nyaa.extensions import db bp = flask.Blueprint('admin', __name__, url_prefix='/admin') @bp.route('/log', endpoint='log', methods=['GET']) def view_adminlog(): if not flask.g.user or not flask.g.user.is_moderator: flask.abort(403) page = flask.request.args.get('p', flask.request.args.get('offset', 1, int), int) logs = models.AdminLog.all_logs() \ .order_by(models.AdminLog.created_time.desc()) \ .paginate(page=page, per_page=20) return flask.render_template('adminlog.html', adminlog=logs) @bp.route('/bans', endpoint='bans', methods=['GET', 'POST']) def view_adminbans(): if not flask.g.user or not flask.g.user.is_moderator: flask.abort(403) form = forms.StringSubmitForm()
def __init__( self, name='__main__', server=None, static_folder='static', assets_folder=None, assets_url_path='/assets', include_assets_files=True, url_base_pathname='/', compress=True, meta_tags=None, index_string=_default_index, external_scripts=None, external_stylesheets=None, **kwargs): # pylint-disable: too-many-instance-attributes if 'csrf_protect' in kwargs: warnings.warn(''' `csrf_protect` is no longer used, CSRF protection has been removed as it is no longer necessary. See https://github.com/plotly/dash/issues/141 for details. ''', DeprecationWarning) self._assets_folder = assets_folder or os.path.join( flask.helpers.get_root_path(name), 'assets' ) # allow users to supply their own flask server self.server = server or Flask(name, static_folder=static_folder) self.server.register_blueprint( flask.Blueprint('assets', 'assets', static_folder=self._assets_folder, static_url_path=assets_url_path)) self.url_base_pathname = url_base_pathname self.config = _AttributeDict({ 'suppress_callback_exceptions': False, 'routes_pathname_prefix': url_base_pathname, 'requests_pathname_prefix': url_base_pathname, 'include_assets_files': include_assets_files, 'assets_external_path': '', }) # list of dependencies self.callback_map = {} self._index_string = '' self.index_string = index_string self._meta_tags = meta_tags or [] self._favicon = None if compress: # gzip Compress(self.server) @self.server.errorhandler(exceptions.PreventUpdate) def _handle_error(error): """Handle a halted callback and return an empty 204 response""" print(error, file=sys.stderr) return ('', 204) # static files from the packages self.css = Css() self.scripts = Scripts() self._external_scripts = external_scripts or [] self._external_stylesheets = external_stylesheets or [] self.registered_paths = {} # urls def add_url(name, view_func, methods=('GET',)): self.server.add_url_rule( name, view_func=view_func, endpoint=name, methods=list(methods) ) add_url( '{}_dash-layout'.format(self.config['routes_pathname_prefix']), self.serve_layout) add_url( '{}_dash-dependencies'.format( self.config['routes_pathname_prefix']), self.dependencies) add_url( '{}_dash-update-component'.format( self.config['routes_pathname_prefix']), self.dispatch, ['POST']) add_url(( '{}_dash-component-suites' '/<string:package_name>' '/<path:path_in_package_dist>').format( self.config['routes_pathname_prefix']), self.serve_component_suites) add_url( '{}_dash-routes'.format(self.config['routes_pathname_prefix']), self.serve_routes) add_url( self.config['routes_pathname_prefix'], self.index) # catch-all for front-end routes add_url( '{}<path:path>'.format(self.config['routes_pathname_prefix']), self.index) self.server.before_first_request(self._setup_server) self._layout = None self._cached_layout = None self.routes = []
import flask import flask_cors import connexion from . import utils from . import config ui_bp = flask.Blueprint('ui', __name__) @ui_bp.route('/swagger_ui') @ui_bp.route('/swagger_ui/') def serve_swagger_ui_index(): ''' Swagger UI to graphically call API. :return: ''' return flask.render_template('swagger_ui.html', api_url=flask.request.url_root + 'swagger_ui.json') @ui_bp.route('/swagger_ui/<path:filename>') def serve_swagger_ui_static_files(filename): return flask.send_from_directory('static', filename) @ui_bp.route('/swagger_ui.json') def serve_swagger_ui_json(): return utils.yaml_to_json(config.wd + '/' + config.SPEC_FN)
import json import editdistance import flask from flask_login import login_required from sqlalchemy import func from ..models.journal import Journal journals = flask.Blueprint('journals', __name__) @journals.route('/lookup', methods=['GET']) @login_required def lookup(): MAX_RESULTS = 10 typed = flask.request.args['journal_typed'].lower() result = Journal.query.filter(func.lower( Journal.name).like(f"%{typed}%")).all() names = [r.name for r in result] dists = [editdistance.eval(typed, name.lower()) for name in names] # Sort the names by Levenshtein distance response = list(zip(names, dists)) response.sort(key=lambda x: x[1]) response = [r[0] for r in response] response = response[:MAX_RESULTS] return json.dumps(response)
# Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import flask import hotline.database.ext import hotline.telephony.lowlevel import peewee from hotline.auth import super_admin_required from hotline.database import highlevel as db from hotline.database import models blueprint = flask.Blueprint("numberadmin", __name__, template_folder="templates") hotline.database.ext.init_app(blueprint) @blueprint.route("/admin/numbers") @super_admin_required def list(): numbers = models.Number.select( models.Number.number, models.Number.country, models.Number.pool, models.Number.features, models.Event.name, models.Event.slug, ).join(
import flask import rod import rod.model.level import rod.model.schemas level_handler = flask.Blueprint('level', __name__) @level_handler.route('/level', methods=['GET']) def list_level(): course_id = flask.request.args.get('course_id') query = rod.model.level.Level.query.filter_by(is_deleted=False) if course_id: levels = query.filter_by(course_id=course_id).all() else: levels = query.all() return flask.jsonify({ 'items': rod.model.schemas.LevelSchema(many=True).dump(levels).data, 'count': len(levels) }) @level_handler.route('/level/<int:level_id>', methods=['GET']) def get_level(level_id): level_obj = rod.model.db.session.query(rod.model.level.Level).get(level_id)
import flask import io from bson.objectid import ObjectId import flask_plate image_api = flask.Blueprint('image_api', __name__) @image_api.route('/image/<image_id>') def get_image(image_id): return flask.send_file(io.BytesIO( flask_plate.db.fs.get(ObjectId(image_id)).read()), mimetype='image/jpg')
# You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Place Explorer related handlers.""" import flask from flask import current_app, g import routes.api.place as place_api bp = flask.Blueprint('place', __name__, url_prefix='/place') # List of DCIDs displayed in the static place_landing.html page. _PLACE_LANDING_DCIDS = [ 'geoId/1714000', 'geoId/4805000', 'geoId/0667000', 'geoId/5363000', 'geoId/17031', 'geoId/06059', 'geoId/48201', 'geoId/06085', 'geoId/06', 'geoId/48', 'geoId/17', 'geoId/21',
""" views.py renders html based on given URL and handles PDF and XML file generation """ import flask import json from flask import request import StringIO from xhtml2pdf import pisa import dicttoxml import logging log = logging.getLogger(__name__) view = flask.Blueprint("view", __name__, template_folder='templates') app = flask.Flask(__name__) @view.route('/reportgen/', methods=['GET', 'POST']) def defaultview(): """ serving landing page index.html """ if request.method == "POST": #in case of report generation dict = json.loads(request.form['data']) if request.form['type'] == "pdf": #Generate PDF
# http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or # implied. # See the License for the specific language governing permissions and # limitations under the License. import flask from driverlog.dashboard import decorators from driverlog.dashboard import parameters from driverlog.dashboard import vault blueprint = flask.Blueprint('api', __name__, url_prefix='/api/1.0') def get_drivers_internal(**params): drivers = vault.get_vault()['drivers_map'] filtered_drivers = [] # when release_id is not set return only drivers from active releases if not params.get('release_id'): all_releases = vault.get_vault()['releases_map'] active_releases = ','.join( sorted(r['id'].lower() for r in all_releases.values() if r.get('active'))) params['release_id'] = active_releases for driver in drivers.values():
import flask from pypi_org.infrastructure.view_modifiers import response from pypi_org.services import user_service import pypi_org.infrastructure.cookie_auth as cookie_auth blueprint = flask.Blueprint('account', __name__, template_folder='templates') # ################### INDEX ################################# @blueprint.route('/account') @response(template_file='account/index.html') def index(): user_id = cookie_auth.get_user_id_via_auth_cookie(flask.request) if user_id is None: return flask.redirect('/account/login') user = user_service.find_user_by_id(user_id) if not user: return flask.redirect('/account/login') return {'user': user} # ################### REGISTER ################################# @blueprint.route('/account/register', methods=['GET']) @response(template_file='account/register.html') def register_get():
Generic API To get frames """ import flask import os import json import pymongo import bson import WebUI from WebUI.utils import jsonify import random mod = flask.Blueprint('api', __name__) # Shared connection #conn = pymongo.Connection(flask.current_app.config["MONGO_SERVER"]) #db = conn[flask.current_app.config["MONGO_DB"]] clips = WebUI.db["clips"] clipscores = WebUI.db["clip_scores"] frames = WebUI.db["frames"] # Preload kit texts path = os.path.join(WebUI.app.config['STATIC_DIR'], "data/kit_texts.js") fin = open(path, "rt") kit_texts = json.loads(fin.read()) # Preload top results # Mostly obsolete
import time import flask from flask import request from exts import db from forms.front.postforms import PostForm, CommentForm from models.common.postmodels import PostModel, BoardModel, CommentModel, PostStarModel from utils import xtjson from models.front.accountmodels import FrontUser, FrontRole, FrontPermission from enumerations import PostSortType from others.decorators.frontdecorators import login_required, json_login_required import settings from sqlalchemy import and_ bp = flask.Blueprint('post', __name__, url_prefix='/post/') @bp.route('/', methods=('GET', 'POST')) @login_required def post(): form = PostForm(request.form) if request.method == 'POST': if form.validate(): title = form.title.data content = form.content.data board_id = form.board_id.data board = BoardModel.query.filter_by(id=board_id).first() author = flask.g.front_user post = PostModel(title=title, content=content,
'`ENABLED_IDENTITY_PROVIDERS` missing `providers` field in flask app' ' settings') default_idp = fence.settings.ENABLED_IDENTITY_PROVIDERS['default'] idps = fence.settings.ENABLED_IDENTITY_PROVIDERS['providers'] # Mapping from IDP ID (what goes in ``fence/local_settings.py`` in # ``ENABLED_IDENTITY_PROVIDERS``) to the name in the URL on the blueprint (see # below). IDP_URL_MAP = { 'fence': 'fence', 'google': 'google', 'shibboleth': 'shib', } blueprint = flask.Blueprint('login', __name__) blueprint_api = Api(blueprint) @blueprint.route('', methods=['GET']) def default_login(): """ The default root login route. """ def absolute_login_url(provider_id): base_url = flask.current_app.config['BASE_URL'] return urlparse.urljoin(base_url, '/login/{}'.format(IDP_URL_MAP[provider_id])) def provider_info(idp_id): return {
from __future__ import absolute_import from __future__ import unicode_literals import flask status = flask.Blueprint('status', __name__) @status.route('/status/healthcheck') def healthcheck(): return ''
import flask import json import data import auth app_api = flask.Blueprint('app_api', __name__) @app_api.route('/api/1/favourite/<movie_id>') def toggle_favourite(movie_id): # check if the user is logged in if not auth.is_authenticated(): return json.dumps({ 'success': False, 'message': 'You are not logged in' }) # toggle favourite status and send the new status back favourite_status = data.toggle_favourite(flask.session['user_id'], movie_id) return json.dumps({ 'success': True, 'favourite': favourite_status, }) @app_api.route('/api/1/vote/<poll_id>/<choice_id>') def vote_poll(poll_id, choice_id): # check if the user is logged in if not auth.is_authenticated(): return json.dumps({ 'success': False,
"""Settings UI module.""" import re import copy import flask from flask_babel import gettext, lazy_gettext from superdesk.utc import utcnow from newsroom.utils import get_json_or_400, set_version_creator from newsroom.template_filters import newsroom_config from newsroom.decorator import admin_only, account_manager_only blueprint = flask.Blueprint('settings', __name__) GENERAL_SETTINGS_LOOKUP = {'_id': 'general_settings'} def get_settings_collection(): return flask.current_app.data.pymongo('items').db.settings @blueprint.route('/settings/<app_id>') @account_manager_only def app(app_id): for app in flask.current_app.settings_apps: if app._id == app_id: return flask.render_template('settings.html', setting_type=app_id, data=app.data()) flask.abort(404)
ACCESS_TOKEN_URI = 'https://www.googleapis.com/oauth2/v4/token' AUTHORIZATION_URL = 'https://accounts.google.com/o/oauth2/v2/auth?access_type=offline&prompt=consent' AUTHORIZATION_SCOPE ='openid email profile' AUTH_REDIRECT_URI = os.environ.get("FN_AUTH_REDIRECT_URI", False) BASE_URI = os.environ.get("FN_BASE_URI", False) CLIENT_ID = os.environ.get("FN_CLIENT_ID", False) CLIENT_SECRET = os.environ.get("FN_CLIENT_SECRET", False) AUTH_TOKEN_KEY = 'auth_token' AUTH_STATE_KEY = 'auth_state' app = flask.Blueprint('google_auth', __name__) def is_logged_in(): return True if AUTH_TOKEN_KEY in flask.session else False def build_credentials(): if not is_logged_in(): raise Exception('User must be logged in') oauth2_tokens = flask.session[AUTH_TOKEN_KEY] return google.oauth2.credentials.Credentials( oauth2_tokens['access_token'], refresh_token=oauth2_tokens['refresh_token'],
import flask import jenkins blueprint = flask.Blueprint('jenkins', __name__) opts = { 'url': 'http://*****:*****@blueprint.route('/jenkins', methods=['GET', 'POST']) def jenkins_action(): conn = None try: conn = jenkins.Jenkins(**opts) except: return flask.jsonify(err, 500) jobs = [conn.get_job_info(j['fullname']) for j in conn.get_jobs()] context = {'jobs': jobs} return flask.render_template('jenkins.html', context=context)
import logging import flask import rmc.models as m from rmc.server import profile import rmc.server.view_helpers as view_helpers view = flask.Blueprint('profile_view', __name__, url_prefix='/profile') @view.route('/demo') def demo_profile(): fbid = c.DEMO_ACCOUNT_FBID user = m.User.objects(fbid=fbid).first() # To catch errors on dev. We may not all have the test account in our mongo if user is None: logging.error("Accessed non-existant test/demo account %s" % fbid) return flask.redirect('/profile') return profile.render_profile_page(user.id, user) # TODO(mack): maybe support fbid in addition to user_id # TODO(mack): move each api into own class @view.route('/', defaults={'profile_user_id': None}) @view.route('/<string:profile_user_id>') @view_helpers.login_required def profile_page(profile_user_id): return profile.render_profile_page(profile_user_id)
import flask from xmltodict import parse from flask import current_app from .cas_urls import create_cas_login_url from .cas_urls import create_cas_logout_url from .cas_urls import create_cas_validate_url try: from urllib import urlopen except ImportError: from urllib.request import urlopen blueprint = flask.Blueprint('cas', __name__) @blueprint.route('/login/') def login(): """ This route has two purposes. First, it is used by the user to login. Second, it is used by the CAS to respond with the `ticket` after the user logs in successfully. When the user accesses this url, they are redirected to the CAS to login. If the login was successful, the CAS will respond to this route with the ticket in the url. The ticket is then validated. If validation was successful the logged in username is saved in the user's session under the key `CAS_USERNAME_SESSION_KEY` and the user's attributes are saved under the key 'CAS_USERNAME_ATTRIBUTE_KEY' """
import flask_login as login # from flask.ext import login import flask import base64 from eisitirio import app from eisitirio.database import db from eisitirio.database import models from eisitirio.helpers import login_manager from eisitirio.logic import cancellation_logic from eisitirio.scripts import create_qr_codes APP = flask.current_app #app.APP#DB = db.DB from eisitirio.app import eisitiriodb as DB ADMIN_TICKETS = flask.Blueprint('admin_tickets', __name__) @ADMIN_TICKETS.route('/admin/ticket/<int:ticket_id>/view') @ADMIN_TICKETS.route( '/admin/ticket/<int:ticket_id>/view/page/<int:events_page>') @login.login_required @login_manager.admin_required def view_ticket(ticket_id, events_page=1): """View a ticket object.""" ticket = models.Ticket.query.get_or_404(ticket_id) if ticket: events = ticket.events.paginate(events_page, 10, True) else: events = None
import sqlite3 import flask import flask_cors import jsonschema import dbshare.db import dbshare.query import dbshare.api.schema import dbshare.api.table import dbshare.api.user import dbshare.api.view from dbshare import constants from dbshare import utils blueprint = flask.Blueprint("api_db", __name__) flask_cors.CORS(blueprint, methods=["GET"]) @blueprint.route("/<name:dbname>", methods=["GET", "PUT", "POST", "DELETE"]) def database(dbname): """GET: List the database tables, views and metadata. PUT: Create the database, load the data if any input. POST: Edit the database metadata. DELETE: Delete the database. """ if utils.http_GET(): try: db = dbshare.db.get_check_read(dbname, nrows=True) except ValueError: