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
class app: """ """ controller_list = {} def __init__(self, name): self.app = Flask(name) self.app.debug = True self.app.secret_key = "this is a key" # app.run(host='0.0.0.0') def run(self, port): for k, v in self.controller_list.iteritems(): print "Start Controller: %s" % (k) self.app.run(host="0.0.0.0", port=port) def add_controller(self, controller): self.controller_list[controller.name] = controller for k, v in controller.function_list.iteritems(): route_path = "/" + controller.name + k if v.type == 1: route_path = "/" + controller.name + k + "/<path:url_var>" print "Reg function: %s" % (route_path) self.app.add_url_rule(route_path, None, v.func, **v.options)
def create_app(self): app = Flask(__name__) app.config.from_object(config['unit_test']) app.add_url_rule('/test', view_func=test_route) app.add_url_rule('/', view_func=index) #print "app.view_functions: {}".format(app.view_functions) return app
def test_url_invalid_object(self): app = Flask(__name__) app.add_url_rule("/<hey>", "foobar", view_func=lambda x: x) field = fields.Url("foobar") with app.test_request_context("/"): self.assertRaises(MarshallingException, lambda: field.output("hey", None))
def test_url_superclass_kwargs(self): app = Flask(__name__) app.add_url_rule("/<hey>", "foobar", view_func=lambda x: x) field = fields.Url(absolute=True, attribute='hey') with app.test_request_context("/hey"): self.assertEquals("http://localhost/3", field.output("hey", Foo()))
def test_url_absolute(self): app = Flask(__name__) app.add_url_rule("/<hey>", "foobar", view_func=lambda x: x) field = fields.Url("foobar", absolute=True) with app.test_request_context("/"): self.assertEquals("http://localhost/3", field.output("hey", Foo()))
def start(application): """Start the web frontend""" # Make sure our views can access the main application global app app = application static_path = os.path.join( os.path.dirname(os.path.abspath(__file__)), '../static/' ) config = app.get_config() frontend = Flask(__name__, static_folder=static_path) # Make sure we crash if there's some bug in the frontend code, this is so # we'll find the bugs frontend.config['PROPAGATE_EXCEPTIONS'] = True frontend.add_url_rule('/', view_func=MainView.as_view('index')) frontend.add_url_rule('/data.json', view_func=DataView.as_view('data')) # Set up the route for static files @frontend.route('/static/<path:filename>') def send_static(filename): return send_from_directory(static_path, filename) frontend.run(host='0.0.0.0', port=config.http_port) return frontend
class MethodViewLoginTestCase(unittest.TestCase): def setUp(self): self.app = Flask(__name__) self.login_manager = LoginManager() self.login_manager.init_app(self.app) self.login_manager._login_disabled = False class SecretEndpoint(MethodView): decorators = [ login_required, fresh_login_required, ] def options(self): return u'' def get(self): return u'' self.app.add_url_rule('/secret', view_func=SecretEndpoint.as_view('secret')) def test_options_call_exempt(self): with self.app.test_client() as c: result = c.open('/secret', method='OPTIONS') self.assertEqual(result.status_code, 200)
class PointOfInterestSearchEndpointTest(unittest.TestCase): def setUp(self): self._poi_service = Mock() self._poi_service.name_search = Mock(return_value=[]) self._app = Flask(__name__) self._endpoint = PointOfInterestSearchEndpoint('test', self._poi_service) self._app.add_url_rule('/search', 'test.search', self._endpoint.get) self._app.add_url_rule('/<slug>', 'test.poi', self._endpoint.get) def test_making_search_passes_it_to_service(self): self._poi_service.search_name.return_value = [] search_terms = "test search" self._make_search_request(search_terms) self._poi_service.search_name.assert_called_once_with(search_terms) def test_return_value_from_service_is_serialised_to_json(self): self._poi_service.search_name.return_value = [PointOfInterest(slug='test:test')] response = self._make_search_request("test") self.assertEquals('test:test', response['results'][0]['poi']['slug']) def _make_search_request(self, search_terms): with self._app.test_request_context( '/search?q={q}'.format(q=quote_plus(search_terms)), headers=[('Accept', 'application/json')] ): response = self._endpoint.get() return json.loads(response.data)
def test_instance_methods(): class HelloWorldService: def get_value(self): return "test message 1" class HelloWorld: def from_injected_service(self, service: HelloWorldService): return service.get_value() def static_value(self): return "test message 2" app = Flask(__name__) hello_world = HelloWorld() app.add_url_rule('/from_injected_service', 'from_injected_service', hello_world.from_injected_service) app.add_url_rule('/static_value', 'static_value', hello_world.static_value) FlaskInjector(app=app) client = app.test_client() response = client.get('/from_injected_service') eq_(response.data.decode('utf-8'), "test message 1") response = client.get('/static_value') eq_(response.data.decode('utf-8'), "test message 2")
def test_url_without_endpoint(self): app = Flask(__name__) app.add_url_rule("/<hey>", "foobar", view_func=lambda x: x) field = fields.Url() with app.test_request_context("/hey"): self.assertEquals("/3", field.output("hey", Foo()))
def test_url_without_endpoint_absolute_scheme(self): app = Flask(__name__) app.add_url_rule("/<hey>", "foobar", view_func=lambda x: x) field = fields.Url(absolute=True, scheme='https') with app.test_request_context("/hey", base_url="http://localhost"): self.assertEquals("https://localhost/3", field.output("hey", Foo()))
def create_app(self): class DefaultView(MethodView): '''Default route docstring''' def put(self): return "put on default route" def post(self): return "post on default route" class ScopedView(MethodView): '''Scoped route docstring''' scopes = ['default'] decorators = [advertise('scopes')] def get(self): return "scoped route" app = Flask(__name__,static_folder=None) app.add_url_rule('/default',view_func=DefaultView.as_view('default')) app.add_url_rule('/scoped',view_func=ScopedView.as_view('scoped')) discoverer = Discoverer(app) self.expected_resources = { '/scoped': { 'scopes':['default'], 'description': 'Scoped route docstring', 'methods': ['HEAD','OPTIONS','GET'], }, '/default': { 'description': 'Default route docstring', 'methods': ['PUT','POST','OPTIONS'], }, } return app
class FyPress(): def __init__(self, config, manager=False): from flask.ext.babel import Babel from utils.mysql import FlaskFyMySQL self.prepared = False self.config = config self.app = Flask( __name__, template_folder=self.config.TEMPLATE_FOLDER, static_folder=self.config.STATIC_FOLDER ) self.app.config.from_object(config) self.app.wsgi_app = ProxyFix(self.app.wsgi_app) self.babel = Babel(self.app) self.db = FlaskFyMySQL(self.app) if not manager: self.prepare() def run(self, host='0.0.0.0', port=5000): if self.prepared == False: self.prepare() self.app.run(host=host, port=port, debug=self.config.DEBUG) def prepare(self): local.fp = self self.prepared = True @self.app.before_request def before_request(): g.start = time.time() if self.config.DEBUG: @self.app.after_request def after_request(response): diff = time.time() - g.start if (response.response): response.headers["Execution-Time"] = str(diff) return response self.app.add_url_rule(self.app.config['UPLOAD_DIRECTORY_URL']+'<filename>', 'FyPress.uploaded_file', build_only=True) self.app.wsgi_app = SharedDataMiddleware(self.app.wsgi_app, {self.app.config['UPLOAD_DIRECTORY_URL']: self.app.config['UPLOAD_DIRECTORY']}) self.blueprint() def blueprint(self): ### Blueprints ### from user import user_blueprint from admin import admin_blueprint from public import public_blueprint ### Load Blueprints ### self.app.register_blueprint(user_blueprint) self.app.register_blueprint(admin_blueprint) self.app.register_blueprint(public_blueprint) @staticmethod def uploaded_file(filename): return send_from_directory(self.app.config['UPLOAD_DIRECTORY'], filename)
def create_app(): app = Flask( __name__.split('.')[0], template_folder='../templates', static_url_path=None, static_folder=None ) env = Development if os.environ.get('APPLICATION_ENV', '') == 'Production': env = Production app.config.from_object(env) # Load config items into jinja settings for key, val in app.config.items(): if key.startswith('JINJA'): setattr(app.jinja_env, key[6:].lower(), val) register_controllers(app) register_errorhandlers(app) register_extensions(app) app.static_folder = '../public/' app.add_url_rule(app.config['STATIC_URL_PATH'] + '/<path:filename>', endpoint='static', view_func=app.send_static_file ) signal.signal(signal.SIGUSR1, sig_handler) signal.signal(signal.SIGUSR2, sig_handler) return app
def make_oauth_wsgi(oauth, next_app, config=None): app = Flask(__name__, static_folder=None) app.config['PROPAGATE_EXCEPTIONS'] = True if config: app.config.update(config) else: app.config.from_envvar('OAUTH_SETTINGS') app.next_app = next_app oauth.init_app(app) app.add_url_rule('/login', endpoint=None, view_func=login) app.add_url_rule('/logout', endpoint=None, view_func=logout) app.add_url_rule('/login/oauth_callback', endpoint=None, view_func=authorized) app.add_url_rule( '/', endpoint=None, view_func=default_handler, methods=['GET', 'HEAD', 'POST', 'PUT', 'DELETE'], ) app.add_url_rule( '/<path:any>', endpoint=None, view_func=default_handler, methods=['GET', 'HEAD', 'POST', 'PUT', 'DELETE'], ) auth = get_auth_provider(oauth) if not auth._tokengetter: auth.tokengetter(get_oauth_token) app.wsgi_app = ProxyFix(app.wsgi_app) return app
def startAPIs(plugin_controller, model_controller, hostname, port): global _rest_controllers global _http_server _rest_controllers = [PluginControllerAPI(plugin_controller), ModelControllerAPI(model_controller)] app = Flask('APISController') _http_server = HTTPServer(WSGIContainer(app)) while True: try: _http_server.listen(port, address=hostname) logger.getLogger().info( "REST API server configured on %s" % str( CONF.getApiRestfulConInfo())) break except socket.error as exception: if exception.errno == 98: # Port already in use # Let's try the next one port += 1 if port > 65535: raise Exception("No ports available!") CONF.setApiRestfulConInfoPort(port) CONF.saveConfig() else: raise exception routes = [r for c in _rest_controllers for r in c.getRoutes()] for route in routes: app.add_url_rule(route.path, view_func=route.view_func, methods=route.methods) logging.getLogger("tornado.access").addHandler(logger.getLogger(app)) logging.getLogger("tornado.access").propagate = False threading.Thread(target=startServer).start()
def create_backend_app(service): from werkzeug.routing import Map # Create the backend_app backend_app = Flask(__name__) backend_app.debug = True backend_app.service = service # Reset view functions to reset the app backend_app.view_functions = {} backend_app.url_map = Map() backend_app.url_map.converters['regex'] = RegexConverter backend = BACKENDS[service] for url_path, handler in backend.flask_paths.items(): if handler.__name__ == 'dispatch': endpoint = '{0}.dispatch'.format(handler.__self__.__name__) else: endpoint = None if endpoint in backend_app.view_functions: # HACK: Sometimes we map the same view to multiple url_paths. Flask # requries us to have different names. endpoint += "2" backend_app.add_url_rule( url_path, endpoint=endpoint, methods=HTTP_METHODS, view_func=convert_flask_to_httpretty_response(handler), strict_slashes=False, ) backend_app.test_client_class = AWSTestHelper return backend_app
def __init__(self, default_format, directory, *default_configs): app = Flask("configurator") view = ConfigView.as_view("config", default_format, directory, *default_configs) app.add_url_rule("/", view_func=view) self.app = app
def create_app(test_config=None): app = Flask(__name__, instance_relative_config = True) app.config.from_mapping( SECRET_KEY='dev', DATABASE=os.path.join(app.instance_path, 'grub.sqlite') ) if test_config is None: # load the instance config, if it exists, when not testing app.config.from_pyfile('config.py', silent=True) else: # load the test config if passed in app.config.from_mapping(test_config) # ensure the instance folder exists try: os.makedirs(app.instance_path) except OSError: pass # Db from . import db db.init_app(app) # Orders from . import orders app.register_blueprint(orders.bp) app.add_url_rule('/', endpoint='index') # Orders from . import users app.register_blueprint(users.bp) return app
def test_url_parameters(self): app = Flask(__name__) app.add_url_rule("/<foo>", "foobar", view_func=lambda x: x) field = fields.Url("foobar", attributes={'foo': 'hey'}) with app.test_request_context("/"): self.assertEquals("/3", field.output("hey", Foo()))
def setUp(self): app = Flask(__name__) app.debug = True toybox = ToyBox(app) app.add_url_rule("/test", view_func=DummyModelView.as_view("test")) app.add_url_rule("/test-base", view_func=DummyBaseModelView.as_view("test_base")) self.app = app.test_client()
def get_flask_application(core): application = Flask(__name__) application.debug = True for app in core.apps: for url, view in app.get_urls(): application.add_url_rule(url, view.__class__.__name__, view(core)) return application
def create_app(test_config=None): # create and configure the app app = Flask(__name__, instance_relative_config=True) app.config.from_mapping( SECRET_KEY='dev', DATABASE=os.path.join(app.instance_path, 'flaskr.sqlite') ) if test_config is None: # load the instance config, if it exists, when not testing app.config.from_pyfile('config.py', silent=True) else: app.config.from_mapping(test_config) # ensure the isntance folder exists try: os.makedirs(app.instance_path) except OSError: pass @app.route('/hello') def hello(): return 'Hello, World!' from . import db db.init_app(app) from . import auth app.register_blueprint(auth.bp) from . import blog app.register_blueprint(blog.bp) app.add_url_rule('/', endpoint='index') return app
def create_app(defer_init_app=False, freezer_kwargs=None): app = Flask(__name__) app.register_blueprint(admin_blueprint, url_prefix='/admin') if not freezer_kwargs: freezer_kwargs = {} if defer_init_app: freezer = Freezer(**freezer_kwargs) else: freezer = Freezer(app, **freezer_kwargs) @app.route('/') def index(): return ('Main index ' + url_for('product', product_id='5', revision='b12ef20')) @app.route('/page/<name>/') def page(name): url_for('product', product_id='3') # Pretend we’re adding a link url_for('product', product_id='4') # Another link return u'Hello\xa0World! ' + name @app.route('/where_am_i/') def where_am_i(): return (url_for('where_am_i') + ' ' + url_for('where_am_i', _external=True)) @app.route('/robots.txt') def robots_txt(): content = 'User-agent: *\nDisallow: /' return app.response_class(content, mimetype='text/plain') for asset in ("favicon.ico",): url = "/" + asset name = asset.replace(".", "_") _partial = partial(app.send_static_file, filename=asset) app.add_url_rule(url, name, _partial) @app.route('/product_<int:product_id>/') def product_route(product_id): return 'Product num %i' % product_id @app.route('/add/', methods=['POST']) def add_something(product_id): return 'This view should be ignored as it does not accept GET.' @freezer.register_generator def product_generator(): # endpoint, values yield 'product', {'product_id': 0} yield 'page', {'name': 'foo'} # Just a `values` dict. The endpoint defaults to the name of the # generator function, just like with Flask views yield {'product_id': 1} # single string: url yield '/product_2/' if defer_init_app: freezer.init_app(app) return app, freezer
def startAPIs(plugin_manager, model_controller, mapper_manager, hostname=None, port=None): global _rest_controllers global _http_server _rest_controllers = [PluginControllerAPI(plugin_manager, mapper_manager), ModelControllerAPI(model_controller)] #TODO: some way to get defaults.. from config? if str(hostname) == "None": hostname = "localhost" if str(port) == "None": port = 9977 if CONF.getApiRestfulConInfo() is None: CONF.setApiRestfulConInfo(hostname, port) app = Flask('APISController') _http_server = HTTPServer(WSGIContainer(app)) _http_server.listen(port,address=hostname) routes = [r for c in _rest_controllers for r in c.getRoutes()] for route in routes: app.add_url_rule(route.path, view_func=route.view_func, methods=route.methods) logging.getLogger("tornado.access").addHandler(logger.getLogger(app)) logging.getLogger("tornado.access").propagate = False threading.Thread(target=startServer).start()
def create_app(config={}): app = Flask("chassis") app.config.from_envvar("FLASK_CONFIG") app.config.update(config) #External sentry.init_app(app) api.init_app(app) cache.init_app(app) #Internal db.init_app(app) #API Endpoints api.add_resource(CatAPI, "/cats/<int:cat_id>") api.add_resource(TodoListAPI, "/todos") app.add_url_rule("/", view_func=show_todos) with app.app_context(): db.create_all() #Debug tools if app.debug: DebugToolbarExtension(app) if app.config.get("PROFILE", False): app.wsgi_app = ProfilerMiddleware(app.wsgi_app, restrictions=[30], sort_by=("time", "cumulative")) return app
def create_app(defer_init_app=False, freezer_kwargs=None): app = Flask(__name__) app.register_blueprint(admin_blueprint, url_prefix="/admin") if not freezer_kwargs: freezer_kwargs = {} if defer_init_app: freezer = Freezer(**freezer_kwargs) else: freezer = Freezer(app, **freezer_kwargs) @app.route("/") def index(): return "Main index " + url_for("product", product_id="5", revision="b12ef20") @app.route("/page/<name>/") def page(name): url_for("product", product_id="3") # Pretend we’re adding a link url_for("product", product_id="4") # Another link return u"Hello\xa0World! " + name @app.route("/where_am_i/") def where_am_i(): return url_for("where_am_i") + " " + url_for("where_am_i", _external=True) @app.route("/robots.txt") def robots_txt(): content = "User-agent: *\nDisallow: /" return app.response_class(content, mimetype="text/plain") for asset in ("favicon.ico",): url = "/" + asset name = asset.replace(".", "_") app.add_url_rule(url, name, partial(app.send_static_file, filename=asset)) @app.route("/product_<int:product_id>/") def product(product_id): return "Product num %i" % product_id @freezer.register_generator def product(): # endpoint, values yield "product", {"product_id": 0} # Just a `values` dict. The endpoint defaults to the name of the # generator function, just like with Flask views yield {"product_id": 1} # single string: url yield "/product_2/" yield "page", {"name": u"I løvë Unicode"} @app.errorhandler(404) def not_found(e): return "Page not found", 404 freezer.error_handler_spec[None] = {404: "/404.html"} if defer_init_app: freezer.init_app(app) return app, freezer
class WebServer (threading.Thread): def __init__(self): threading.Thread.__init__(self) self.ioLoop = IOLoop.instance() self.app = Flask(__name__) self.app.add_url_rule(rule='/icnaas/api/v1.0/fmc_manager', methods=['POST'], view_func=self.groupMigration) #@self.app.route('/icnaas/api/v1.0/fmc_manager', methods=['POST']) def groupMigration(self): if not request.json or not 'mobility_prediction' in request.json: abort(400) print "Received Migration from MP_MIDDLEWARE" #print json.loads(request.data) mig = Migration() code = mig.processMigrationInfo(request.json) return jsonify({'result': code}), code #return jsonify({'result': 200}), 200 def stop(self): self.ioLoop.stop() def run(self): http_server = HTTPServer(WSGIContainer(self.app)) http_server.listen(5000) self.ioLoop.start()
def create_app(): app = Flask(__name__) api = Api(app) app.config.from_object('config.default') app.config.from_envvar('APP_SETTINGS', silent=False) app.add_url_rule('/api/login', 'login', _get_token) from models.base import db db.init_app(app) from controllers.index import Index from controllers.user import UsersList, UserSingle from controllers.tasks import TaskSingle, Tasks, AssignTask from controllers.comments import Comments from controllers.reports import UserComments, TaskStats app.before_request(db_connect.before_request) app.after_request(db_connect.after_request) app.add_url_rule('/api/tasks/<int:task_id>/comments', view_func=Comments.as_view(COMMENTS)) api.add_resource(Index, '/api/index') api.add_resource(UsersList, '/api/users') api.add_resource(UserSingle, '/api/users/<int:user_id>') api.add_resource(Tasks, '/api/tasks') api.add_resource(TaskSingle, '/api/tasks/<int:task_id>') api.add_resource(AssignTask, '/api/assign_task') api.add_resource(UserComments, '/api/reports/user_comments') api.add_resource(TaskStats, '/api/reports/task_stats') return app
""" Программа использует flask и запускает веб-сервер. При запросе к этому серверу он возвращает содержимое файла index.html Файл обрабатывается как шаблон. Он не находится! """ from flask import Flask, render_template def index(): """ функция обрабатывает шаблон index.html и возвращает получившийся документ""" return render_template('index.html') app = Flask(__name__) # создаём правило для URL '/': app.add_url_rule('/', 'index', index) # Запускаем веб-сервер: app.run()
def __init__(self, app: flask.Flask, config: typing.Dict[str, typing.Any], login_name: str = 'authl.login', login_path: str = '/login', callback_name: str = 'authl.callback', callback_path: str = '/cb', tester_name: str = 'authl.test', tester_path: str = None, login_render_func: typing.Callable = None, notify_render_func: typing.Callable = None, session_auth_name: typing.Optional[str] = 'me', force_https: bool = False, stylesheet: typing.Union[str, typing.Callable] = None, on_verified: typing.Callable = None, make_permanent: bool = True, state_storage: typing.Dict = None, token_storage: tokens.TokenStore = None, session_namespace='_authl', ): # pylint:disable=too-many-arguments,too-many-locals,too-many-statements if state_storage is None: state_storage = typing.cast(typing.Dict, flask.session) self.authl = from_config( config, state_storage, token_storage) self._session = state_storage self.login_name = login_name self.callback_name = callback_name self.tester_name = tester_name self._tester_path = tester_path self._login_render_func = login_render_func self._notify_render_func = notify_render_func self._session_auth_name = session_auth_name self.force_https = force_https self._stylesheet = stylesheet self._on_verified = on_verified self.make_permanent = make_permanent self._prefill_key = session_namespace + '.prefill' for sfx in ['', '/', '/<path:redir>']: app.add_url_rule(login_path + sfx, login_name, self._login_endpoint, methods=('GET', 'POST')) app.add_url_rule(callback_path + '/<hid>', callback_name, self._callback_endpoint, methods=('GET', 'POST')) if tester_path: def find_service(): from flask import request url = request.args.get('url') if not url: return json.dumps(None) handler, _, canon_url = self.authl.get_handler_for_url(url) if handler: return json.dumps({'name': handler.service_name, 'url': canon_url}) return json.dumps(None) app.add_url_rule(tester_path, tester_name, find_service)
""" 모델로더와 서빙 클래스를 Flask 프레임워크에 적용 """ import os from flask import Flask, jsonify, request, Response from aicentro.serving.serving_config import configure_error_handlers context = os.getenv('AICENTRO_NOTEBOOK_CONTEXT_PATH', default='') # Flask 객체 생성 app = Flask(__name__) # Flask 객체에 URL Rule 정의 app.add_url_rule( '{0}/'.format(context), # URL 패스 정의 view_func=serving, # 서빙 클래스 객체 methods=['GET', 'POST'] # 서비스 가능 HTTP 메소드 ) # Error Handler 적용 # 에러에 따른 결과 포멧 변경 시 별도 함수 호출 def message_format(code, message): """ 에러 발생 시 리턴되는 Json 포멧 정의 :param code: configure_error_hanlders 함수 호출 시 지정된 code 값 :param message: error 발생 시 exception 의 메시지 :return: dict: Json 으로 생성될 Dictionary """ return { 'error_code': code,
JUPITER_CONFIG_INI_PATH = '/jupiter/build/jupiter_config.ini' APP_DIR = "/jupiter/build/app_specific_files/" app = Flask(__name__) def recv_task_assign_info(): """ Receive task assignment information from the workers """ assign = request.args.get('assign') task_assign_summary.append(assign) log.debug("Task assign summary: " + json.dumps(task_assign_summary)) return 'ok' app.add_url_rule('/recv_task_assign_info', 'recv_task_assign_info', recv_task_assign_info) def recv_mapping(): """ From each droplet, the master receive the local mapping of the assigned task for that droplet, combine all of the information Write the global mapping to ``assignments`` variable and ``local/input_to_CIRCE.txt`` Returns: str: ``ok`` if mapping is ready, ``not ok`` otherwise Raises: Exception: when mapping is not ready """ try:
# 'production' is a magic string for bugsnag, rest are arbitrary release_stage=config.REALM.replace("prod", "production"), notify_release_stages=["production", "test"], use_ssl=True) handle_exceptions(app) from filters import * app.jinja_env.filters['status_class'] = status_class app.jinja_env.filters['friendly_time'] = friendly_time app.jinja_env.filters['friendly_size'] = friendly_size app.jinja_env.filters['to_qs'] = to_qs app.jinja_env.filters['approximate_time'] = approximate_time app.jinja_env.filters['exact_time'] = exact_time app.jinja_env.filters['short_date'] = short_date app.add_url_rule('/', 'views.home') app.add_url_rule('/<name>', 'views.bin', methods=[ 'GET', 'POST', 'DELETE', 'PUT', 'OPTIONS', 'HEAD', 'PATCH', 'TRACE' ]) app.add_url_rule('/docs/<name>', 'views.docs') app.add_url_rule('/api/v1/bins', 'api.bins', methods=['POST']) app.add_url_rule('/api/v1/bins/<name>', 'api.bin', methods=['GET']) app.add_url_rule('/api/v1/bins/<bin>/requests', 'api.requests', methods=['GET']) app.add_url_rule('/api/v1/bins/<bin>/requests/<name>', 'api.request',
import logging from slack_logger import SlackHandler, SlackFormatter from flask.logging import default_handler app = Flask(__name__) app.debug = True root = logging.getLogger() # def yashlogger(abc,level="asd"): # print(abc) app.add_url_rule( '/gqlsecretpathhuehuehuehue', view_func=GraphQLView.as_view( 'graphql', schema=schema, graphiql=True # for having the GraphiQL interface ) ) # Custom static data @app.route('/app/<path:filename>') def custom_static(filename): return send_from_directory("app-static", filename) @app.route('/asdasdafgwgwrgregergerger') def yash(): pass @app.route('/', methods=['GET']) def home(): return "<a href='app/index.html'>Hello there</h1></a>"
@app.route('/suma/<int:valor1>/<int:valor2>') def suma(valor1, valor2): return 'La suma es: {0}'.format((valor1 + valor2)) @app.route('/perfil/<nombre>/<int:edad>') def perfil(nombre, edad): return 'Tu nombre es: {0} y tu edad es: {1}'.format(nombre, edad) @app.route('/lenguajes') def lenguajes(): data = { 'hay_lenguajes': False, 'lenguajes': ['PHP', 'Python', 'kotlin', 'Java'] } return render_template('lenguajes.html', data=data) @app.route('/datos') def datos(): print(request.args) a = request.args.get('valor1') b = int(request.args.get('valor2')) return 'Esto son los datos: {0}, {1}'.format(a, b + 15) if __name__ == '__main__': app.add_url_rule('/', view_func=index) app.run(debug=True, port=5005)
response.mimetype = 'text/xml' return response @app.route('/robots.txt') def robots(): return send_from_directory(app.static_folder, "robots.txt") # The "main" routes. 99% of requests will come in through these. app.add_url_rule( "/update/1/<product>/<version>/<buildID>/<buildTarget>/<locale>/<channel>/update.xml", view_func=ClientRequestView.as_view("clientrequest1"), # Underlying code depends on osVersion being set. Since this route only # exists to support ancient queries, and all newer versions have osVersion # in them it's easier to set this here than make the all of the underlying # code support queries without it. defaults={ "queryVersion": 2, "osVersion": "" }, ) app.add_url_rule( '/update/2/<product>/<version>/<buildID>/<buildTarget>/<locale>/<channel>/<osVersion>/update.xml', view_func=ClientRequestView.as_view('clientrequest2'), defaults={'queryVersion': 2}, ) app.add_url_rule( '/update/3/<product>/<version>/<buildID>/<buildTarget>/<locale>/<channel>/<osVersion>/<distribution>/<distVersion>/update.xml', view_func=ClientRequestView.as_view('clientrequest3'), defaults={'queryVersion': 3}, )
from flask_graphql import GraphQLView from lime_comb_api.auth import jwt_validate from lime_comb_api.schema import Mutation, Query googleclouddebugger.enable() googlecloudprofiler.start( service="lime-comb-api", service_version="0.0.0", # verbose is the logging level. 0-error, 1-warning, 2-info, # 3-debug. It defaults to 0 (error) if not set. verbose=3, # project_id must be set if not running on GCP. # project_id='lime-comb', ) schema = graphene.Schema(query=Query) view_func = GraphQLView.as_view( "graphql", schema=graphene.Schema(query=Query, mutation=Mutation), graphiql=True, # get_context=lambda: {"session": db_session}, ) app = Flask(__name__) app.add_url_rule("/", view_func=jwt_validate(view_func)) if __name__ == "__main__": app.run(debug=True)
from flask import Flask from toga_flask import TogaApp from freedom import app as freedom app = Flask(__name__, static_folder='../static') app.add_url_rule('/', view_func=TogaApp.as_view("foo", app_module=freedom)) if __name__ == '__main__': app.run(port=8081, debug=True)
from flask import Flask from schema import Query from flask_graphql import GraphQLView from graphene import Schema import os view_func = GraphQLView.as_view( 'graphql', schema=Schema(query=Query), graphiql=True) app = Flask(__name__) app.add_url_rule('/graphql', view_func=view_func) if __name__ == '__main__': app.run(host='0.0.0.0', port=os.environ.get('PORT', 5000))
] } allowed_url = 'https://d32e0zjclv95xl.cloudfront.net' # allowed_url = 'http://localhost:4200' # TODO: change this to cloudfront # Enable CORS CORS(application, resources={r"/*": { "origins": config['ORIGINS'] }}, headers='Content-Type, X-Api-Key, Token', supports_credentials=True) # add a rule for the index page. (Put here by AWS in the sample) application.add_url_rule( '/', 'index', (lambda: header_text + say_hello() + instructions + footer_text)) # add a rule when the page is accessed with a name appended to the site # URL. Put here by AWS in the sample application.add_url_rule('/<username>', 'hello', (lambda username: header_text + say_hello(username) + home_link + footer_text)) ################################################################################################################## # The stuff I added begins here. _default_context = None _user_service = None
def create_app(handle, instance, reloader=None): check.inst_param(handle, 'handle', ExecutionTargetHandle) check.inst_param(instance, 'instance', DagsterInstance) check.opt_inst_param(reloader, 'reloader', Reloader) app = Flask('dagster-ui') sockets = Sockets(app) app.app_protocol = lambda environ_path_info: 'graphql-ws' schema = create_schema() subscription_server = DagsterSubscriptionServer(schema=schema) execution_manager = SubprocessExecutionManager(instance) warn_if_compute_logs_disabled() print('Loading repository...') context = DagsterGraphQLContext( handle=handle, instance=instance, execution_manager=execution_manager, reloader=reloader, version=__version__, ) # Automatically initialize scheduler everytime Dagit loads scheduler_handle = context.scheduler_handle if scheduler_handle: handle = context.get_handle() python_path = sys.executable repository_path = handle.data.repository_yaml scheduler_handle.up(python_path, repository_path) app.add_url_rule( '/graphql', 'graphql', DagsterGraphQLView.as_view( 'graphql', schema=schema, graphiql=True, # XXX(freiksenet): Pass proper ws url graphiql_template=PLAYGROUND_TEMPLATE, executor=Executor(), context=context, ), ) sockets.add_url_rule( '/graphql', 'graphql', dagster_graphql_subscription_view(subscription_server, context)) app.add_url_rule( # should match the `build_local_download_url` '/download/<string:run_id>/<string:step_key>/<string:file_type>', 'download_view', download_view(context), ) # these routes are specifically for the Dagit UI and are not part of the graphql # API that we want other people to consume, so they're separate for now. # Also grabbing the magic global request args dict so that notebook_view is testable app.add_url_rule('/dagit/notebook', 'notebook', lambda: notebook_view(request.args)) app.add_url_rule('/static/<path:path>/<string:file>', 'static_view', static_view) app.add_url_rule('/vendor/<path:path>/<string:file>', 'vendor_view', vendor_view) app.add_url_rule('/<string:worker_name>.worker.js', 'worker_view', worker_view) app.add_url_rule('/dagit_info', 'sanity_view', info_view) app.add_url_rule('/<path:_path>', 'index_catchall', index_view) app.add_url_rule('/', 'index', index_view, defaults={'_path': ''}) CORS(app) return app
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL # FACEBOOK BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN # ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. import json import os import sys import threading import time sys.path.insert(0, 'backend') from states import NetworkStateService from flask import Flask, Response, request app = Flask(__name__, static_url_path='', static_folder='public') app.add_url_rule('/', 'root', lambda: app.send_static_file('index.html')) @app.route('/api/comments', methods=['GET', 'POST']) def comments_handler(): with open('database/comments.json', 'r') as file: comments = json.loads(file.read()) if request.method == 'POST': newComment = request.form.to_dict() newComment['id'] = int(time.time() * 1000) comments.append(newComment) with open('database/comments.json', 'w') as file: file.write(json.dumps(comments, indent=4, separators=(',', ': ')))
import os import logging.config application = Flask(os.environ.get("APPLICATION_NAME")) SETTINGS_FILE = os.environ.get("SETTINGS_FILE", "settings.local_settings") application.config.from_object(SETTINGS_FILE) with application.app_context(): # this loads all the views with the app context # this is also helpful when the views import other # modules, this will load everything under the application # context and then one can use the current_app configuration # parameters from apis.urls import all_urls from scripts import ALL_CLI_COMMANDS for cli_name, cli_command in ALL_CLI_COMMANDS.items(): application.cli.add_command(cli_command, name=cli_name) # Adding all the url rules in the api application for url, view, methods, _ in all_urls: application.add_url_rule(url, view_func=view, methods=methods) logging.config.dictConfig(application.config["LOGGING"]) celery = Celery(application.name, broker=application.config['CELERY_BROKER_URL']) celery.conf.update(application.config)
return 'Nothing' class StopAll(views.MethodView): def get(self): self.stop_all() return render_template("Switch.html") @staticmethod def stop_all(): for cid in dev_ena: dev_ena[cid] = False app.add_url_rule('/login', view_func=Login.as_view(name='login')) print('stop_all') return 'Nothing' app.add_url_rule('/login', view_func=Login.as_view(name='login')) app.add_url_rule('/chem_a', view_func=ChemA.as_view(name='chem_a')) app.add_url_rule('/chem_b', view_func=ChemB.as_view(name='chem_b')) app.add_url_rule('/chem_wax', view_func=ChemWax.as_view(name='chem_wax')) app.add_url_rule('/chem_wheel', view_func=ChemWheel.as_view(name='chem_wheel')) app.add_url_rule('/l2_1', view_func=L21.as_view(name='l2_1')) app.add_url_rule('/l2_2', view_func=L22.as_view(name='l2_2')) app.add_url_rule('/wheel', view_func=Wheel.as_view(name='wheel')) app.add_url_rule('/stop_all', view_func=StopAll.as_view(name='stop_all')) if __name__ == '__main__': app.run(host='0.0.0.0', port=5010)
from flask import Flask # Create Flask application object. That requires an arg for resolve the path. app = Flask(__name__) # Create a view function for root path. Decorate a python function with app.route() @app.route('/') def index(): # It's a view function. return "<h2>Hello, FLASK!</h2>", 200 # 200 is a status_code of response. It's not require @app.route('/user/<name>') def get_user(name): return "Welcome, {}".format(name), 200 def list_users(): return "LIST OF USERS", 200 app.add_url_rule(rule='/user', endpoint='list_users', view_func=list_users) # Run Flask web server. Debug mode on, port 8000. if __name__ == '__main__': app.run(port=8000, debug=1) # You can test typing that, "curl -X GET localhost:8000"
class FibonacciServer(object): MAX_ACCEPTABLE_NUMBER = 10000 MAX_LOG_FILE_BYTES = 50 << 20 # 50 MB MAX_LOG_FILE_BACKUP = 9 RUNTIME_LOG = 'runtime.log' def __init__(self, host='127.0.0.1', port=8080): self._host = host self._port = port self._app = Flask(__name__) self._init_logging() self._add_routes() self._fib = Fibonacci() def index(self): """Handles `GET /` request, this is required when deploy to heroku (it hits this uri to verify """ msg = ('Welcome to Fibonacci Server!\n\n' 'Currently only one API is supported:\n\n' 'GET /v1/fib/:number\n') return msg, 200, {'Content-Type': 'text/plain; charset=utf-8'} def fib(self, version, number): """Handles the `GET /:version/fib/:number` request. Status goes to header, data goes to body in JSON. Status codes are: - 200 OK - 400 BAD REQUEST (invalid parameter) - 403 REQUEST ENTITY TOO LARGE (input number too large) - 500 INTERNAL SERVER ERROR (unknown exception) - 501 NOT IMPLEMENTED (not supported API) """ if version != 'v1': return self._response(501) try: n = int(number) except ValueError: return self._response(400) if n < 0: return self._response(400) elif n > self.MAX_ACCEPTABLE_NUMBER: return self._response(413) try: seq = self._fib.sequence(n) return self._response(200, seq) except: return self._response(500) def run(self): self._app.run(host=self._host, port=self._port) def _init_logging(self): """Configure web log generated by werkzeug to use 'runtime.log' """ handler = RotatingFileHandler( self.RUNTIME_LOG, maxBytes=self.MAX_LOG_FILE_BYTES, backupCount=self.MAX_LOG_FILE_BACKUP) logger = logging.getLogger('werkzeug') logger.addHandler(handler) logger.setLevel(logging.INFO) # Turns off console log def _add_routes(self): self._app.add_url_rule('/', endpoint='index', view_func=self.index) self._app.add_url_rule('/<version>/fib/<number>', endpoint='fib', view_func=self.fib) def _response(self, status, data=None): data = data or [] return Response(json.dumps(data), status=status, mimetype='application/json') def _test_client(self): return self._app.test_client()
class FieldsTestCase(unittest.TestCase): def setUp(self): self.app = Flask(__name__) self.app.add_url_rule("/<hey>", "foobar", view_func=lambda x: x) bp = Blueprint("foo", __name__, url_prefix="/foo") bp.add_url_rule("/<hey>", "foobar", view_func=lambda x: x) self.app.register_blueprint(bp) def test_decimal_trash(self): self.assertRaises(MarshallingException, lambda: fields.Float().output('a', {'a': 'Foo'})) def test_basic_dictionary(self): obj = {"foo": 3} field = fields.String() self.assertEquals(field.output("foo", obj), "3") def test_no_attribute(self): obj = {"bar": 3} field = fields.String() self.assertEquals(field.output("foo", obj), None) def test_date_field_invalid(self): obj = {"bar": 3} field = fields.DateTime() self.assertRaises(MarshallingException, lambda: field.output("bar", obj)) def test_attribute(self): obj = {"bar": 3} field = fields.String(attribute="bar") self.assertEquals(field.output("foo", obj), "3") def test_formatting_field_none(self): obj = {} field = fields.FormattedString("/foo/{0[account_sid]}/{0[sid]}/") self.assertRaises(MarshallingException, lambda: field.output("foo", obj)) def test_formatting_field_tuple(self): obj = (3, 4) field = fields.FormattedString("/foo/{0[account_sid]}/{0[sid]}/") self.assertRaises(MarshallingException, lambda: field.output("foo", obj)) def test_formatting_field_dict(self): obj = { "sid": 3, "account_sid": 4, } field = fields.FormattedString("/foo/{account_sid}/{sid}/") self.assertEquals(field.output("foo", obj), "/foo/4/3/") def test_formatting_field(self): obj = Mock() obj.sid = 3 obj.account_sid = 4 field = fields.FormattedString("/foo/{account_sid}/{sid}/") self.assertEquals(field.output("foo", obj), "/foo/4/3/") def test_basic_field(self): obj = Mock() obj.foo = 3 field = fields.Raw() self.assertEquals(field.output("foo", obj), 3) def test_raw_field(self): obj = Mock() obj.foo = 3 field = fields.Raw() self.assertEquals(field.output("foo", obj), 3) def test_nested_raw_field(self): foo = Mock() bar = Mock() bar.value = 3 foo.bar = bar field = fields.Raw() self.assertEquals(field.output("bar.value", foo), 3) def test_formatted_string_invalid_obj(self): field = fields.FormattedString("{hey}") self.assertRaises(MarshallingException, lambda: field.output("hey", None)) def test_formatted_string(self): field = fields.FormattedString("{hey}") self.assertEquals("3", field.output("hey", Foo())) def test_string_with_attribute(self): field = fields.String(attribute="hey") self.assertEquals("3", field.output("foo", Foo())) def test_string_with_lambda(self): field = fields.String(attribute=lambda x: x.hey) self.assertEquals("3", field.output("foo", Foo())) def test_string_with_partial(self): def f(x, suffix): return "%s-%s" % (x.hey, suffix) p = partial(f, suffix="whatever") field = fields.String(attribute=p) self.assertEquals("3-whatever", field.output("foo", Foo())) def test_url_invalid_object(self): field = fields.Url("foobar") with self.app.test_request_context("/"): self.assertRaises(MarshallingException, lambda: field.output("hey", None)) def test_url(self): field = fields.Url("foobar") with self.app.test_request_context("/"): self.assertEquals("/3", field.output("hey", Foo())) def test_url_absolute(self): field = fields.Url("foobar", absolute=True) with self.app.test_request_context("/"): self.assertEquals("http://localhost/3", field.output("hey", Foo())) def test_url_absolute_scheme(self): """Url.scheme should override current_request.scheme""" field = fields.Url("foobar", absolute=True, scheme='https') with self.app.test_request_context("/", base_url="http://localhost"): self.assertEquals("https://localhost/3", field.output("hey", Foo())) def test_url_without_endpoint_invalid_object(self): field = fields.Url() with self.app.test_request_context("/hey"): self.assertRaises(MarshallingException, lambda: field.output("hey", None)) def test_url_without_endpoint(self): field = fields.Url() with self.app.test_request_context("/hey"): self.assertEquals("/3", field.output("hey", Foo())) def test_url_without_endpoint_absolute(self): field = fields.Url(absolute=True) with self.app.test_request_context("/hey"): self.assertEquals("http://localhost/3", field.output("hey", Foo())) def test_url_without_endpoint_absolute_scheme(self): field = fields.Url(absolute=True, scheme='https') with self.app.test_request_context("/hey", base_url="http://localhost"): self.assertEquals("https://localhost/3", field.output("hey", Foo())) def test_url_with_blueprint_invalid_object(self): field = fields.Url() with self.app.test_request_context("/foo/hey"): self.assertRaises(MarshallingException, lambda: field.output("hey", None)) def test_url_with_blueprint(self): field = fields.Url() with self.app.test_request_context("/foo/hey"): self.assertEquals("/foo/3", field.output("hey", Foo())) def test_url_with_blueprint_absolute(self): field = fields.Url(absolute=True) with self.app.test_request_context("/foo/hey"): self.assertEquals("http://localhost/foo/3", field.output("hey", Foo())) def test_url_with_blueprint_absolute_scheme(self): field = fields.Url(absolute=True, scheme='https') with self.app.test_request_context("/foo/hey", base_url="http://localhost"): self.assertEquals("https://localhost/foo/3", field.output("hey", Foo())) def test_url_superclass_kwargs(self): field = fields.Url(absolute=True, attribute='hey') with self.app.test_request_context("/hey"): self.assertEquals("http://localhost/3", field.output("hey", Foo())) def test_int(self): field = fields.Integer() self.assertEquals(3, field.output("hey", {'hey': 3})) def test_int_default(self): field = fields.Integer(default=1) self.assertEquals(1, field.output("hey", {'hey': None})) def test_no_int(self): field = fields.Integer() self.assertEquals(0, field.output("hey", {'hey': None})) def test_int_decode_error(self): field = fields.Integer() self.assertRaises(MarshallingException, lambda: field.output("hey", {'hey': 'Explode please I am nowhere looking like an int'})) def test_float(self): field = fields.Float() self.assertEquals(3.0, field.output("hey", {'hey': 3.0})) def test_float_decode_error(self): field = fields.Float() self.assertRaises(MarshallingException, lambda: field.output("hey", {'hey': 'Explode!'})) PI_STR = u'3.14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664709384460955058223172535940812848111745028410270193852110555964462294895493038196442881097566593344612847564823378678316527120190914564856692346034861' PI = Decimal(PI_STR) def test_arbitrary(self): field = fields.Arbitrary() self.assertEquals(self.PI_STR, field.output("hey", {'hey': self.PI})) def test_fixed(self): field5 = fields.Fixed(5) field4 = fields.Fixed(4) self.assertEquals('3.14159', field5.output("hey", {'hey': self.PI})) self.assertEquals('3.1416', field4.output("hey", {'hey': self.PI})) self.assertEquals('3.0000', field4.output("hey", {'hey': '3'})) self.assertEquals('3.0000', field4.output("hey", {'hey': '03'})) self.assertEquals('3.0000', field4.output("hey", {'hey': '03.0'})) def test_zero_fixed(self): field = fields.Fixed() self.assertEquals('0.00000', field.output('hey', {'hey': 0})) def test_infinite_fixed(self): field = fields.Fixed() self.assertRaises(MarshallingException, lambda: field.output("hey", {'hey': '+inf'})) self.assertRaises(MarshallingException, lambda: field.output("hey", {'hey': '-inf'})) def test_advanced_fixed(self): field = fields.Fixed() self.assertRaises(MarshallingException, lambda: field.output("hey", {'hey': 'NaN'})) def test_fixed_with_attribute(self): field = fields.Fixed(4, attribute="bar") self.assertEquals('3.0000', field.output("foo", {'bar': '3'})) def test_string(self): field = fields.String() self.assertEquals("3", field.output("hey", Foo())) def test_string_no_value(self): field = fields.String() self.assertEquals(None, field.output("bar", Foo())) def test_string_none(self): field = fields.String() self.assertEquals(None, field.output("empty", {'empty': None})) def test_rfc822_date_field_without_offset(self): obj = {"bar": datetime(2011, 8, 22, 20, 58, 45)} field = fields.DateTime() self.assertEquals("Mon, 22 Aug 2011 20:58:45 -0000", field.output("bar", obj)) def test_rfc822_date_field_with_offset(self): obj = {"bar": datetime(2011, 8, 22, 20, 58, 45, tzinfo=pytz.timezone('CET'))} field = fields.DateTime() self.assertEquals("Mon, 22 Aug 2011 19:58:45 -0000", field.output("bar", obj)) def test_iso8601_date_field_without_offset(self): obj = {"bar": datetime(2011, 8, 22, 20, 58, 45)} field = fields.DateTime(dt_format='iso8601') self.assertEquals("2011-08-22T20:58:45", field.output("bar", obj)) def test_iso8601_date_field_with_offset(self): obj = {"bar": datetime(2011, 8, 22, 20, 58, 45, tzinfo=pytz.timezone('CET'))} field = fields.DateTime(dt_format='iso8601') self.assertEquals("2011-08-22T20:58:45+01:00", field.output("bar", obj)) def test_unsupported_datetime_format(self): obj = {"bar": datetime(2011, 8, 22, 20, 58, 45)} field = fields.DateTime(dt_format='raw') self.assertRaises(MarshallingException, lambda: field.output('bar', obj)) def test_to_dict(self): obj = {"hey": 3} self.assertEquals(obj, fields.to_marshallable_type(obj)) def test_to_dict_obj(self): obj = {"hey": 3} self.assertEquals(obj, fields.to_marshallable_type(Foo())) def test_to_dict_custom_marshal(self): obj = {"hey": 3} self.assertEquals(obj, fields.to_marshallable_type(Bar())) def test_get_value(self): self.assertEquals(3, fields.get_value("hey", {"hey": 3})) def test_get_value_no_value(self): self.assertEquals(None, fields.get_value("foo", {"hey": 3})) def test_get_value_obj(self): self.assertEquals(3, fields.get_value("hey", Foo())) def test_list(self): obj = {'list': ['a', 'b', 'c']} field = fields.List(fields.String) self.assertEquals(['a', 'b', 'c'], field.output('list', obj)) def test_list_from_set(self): obj = {'list': set(['a', 'b', 'c'])} field = fields.List(fields.String) self.assertEquals(set(['a', 'b', 'c']), set(field.output('list', obj))) def test_list_from_object(self): class TestObject(object): def __init__(self, list): self.list = list obj = TestObject(['a', 'b', 'c']) field = fields.List(fields.String) self.assertEquals(['a', 'b', 'c'], field.output('list', obj)) def test_list_with_attribute(self): class TestObject(object): def __init__(self, list): self.foo = list obj = TestObject(['a', 'b', 'c']) field = fields.List(fields.String, attribute='foo') self.assertEquals(['a', 'b', 'c'], field.output('list', obj)) def test_list_with_scoped_attribute_on_dict_or_obj(self): class TestObject(object): def __init__(self, list_): self.bar = list_ class TestEgg(object): def __init__(self, val): self.attrib = val eggs = [TestEgg(i) for i in ['a', 'b', 'c']] test_obj = TestObject(eggs) test_dict = {'bar': [{'attrib': 'a'}, {'attrib':'b'}, {'attrib':'c'}]} field = fields.List(fields.String(attribute='attrib'), attribute='bar') self.assertEquals(['a', 'b', 'c'], field.output('bar', test_obj)) self.assertEquals(['a', 'b', 'c'], field.output('bar', test_dict)) def test_null_list(self): class TestObject(object): def __init__(self, list): self.list = list obj = TestObject(None) field = fields.List(fields.String) self.assertEquals(None, field.output('list', obj)) def test_indexable_object(self): class TestObject(object): def __init__(self, foo): self.foo = foo def __getitem__(self, n): if type(n) is int: if n < 3: return n raise IndexError raise TypeError obj = TestObject("hi") field = fields.String(attribute="foo") self.assertEquals("hi", field.output("foo", obj)) def test_list_from_dict_with_attribute(self): obj = {'list': [{'a': 1, 'b': 1}, {'a': 2, 'b': 1}, {'a': 3, 'b': 1}]} field = fields.List(fields.Integer(attribute='a')) self.assertEquals([1, 2, 3], field.output('list', obj)) def test_list_of_nested(self): obj = {'list': [{'a': 1, 'b': 1}, {'a': 2, 'b': 1}, {'a': 3, 'b': 1}]} field = fields.List(fields.Nested({'a': fields.Integer})) self.assertEquals([OrderedDict([('a', 1)]), OrderedDict([('a', 2)]), OrderedDict([('a', 3)])], field.output('list', obj)) def test_nested_with_default(self): obj = None field = fields.Nested({'a': fields.Integer, 'b': fields.String}, default={}) self.assertEquals({}, field.output('a', obj)) def test_list_of_raw(self): obj = {'list': [{'a': 1, 'b': 1}, {'a': 2, 'b': 1}, {'a': 3, 'b': 1}]} field = fields.List(fields.Raw) self.assertEquals([OrderedDict([('a', 1), ('b', 1), ]), OrderedDict([('a', 2), ('b', 1), ]), OrderedDict([('a', 3), ('b', 1), ])], field.output('list', obj)) obj = {'list': [1, 2, 'a']} field = fields.List(fields.Raw) self.assertEquals([1, 2, 'a'], field.output('list', obj))
from database.base import db_session, Base, engine from flask import Flask from flask_graphql import GraphQLView from schema import schema from schema_triangle import SerializeTriangle from flask_cors import CORS Base.metadata.create_all(engine) app = Flask(__name__) CORS(app) app.add_url_rule('/graphql', view_func=GraphQLView.as_view( 'graphql', schema=schema, graphiql=True, middleware=[SerializeTriangle()])) @app.teardown_appcontext def shutdown_session(exception=None): db_session.remove() if __name__ == '__main__': app.run(threaded=True, debug=True)
tmp = ''.join(random.choice(src_str) for _ in xrange(24)) f.write('\n#Auto-generated secret key\nSECRET_KEY = """' + tmp + '"""\n') app.config["SECRET_KEY"] = tmp #Make a dictionary of queues of stuff that remotes need to do queues = dict() #Make a dictionary of clients live_clients = dict() #Global variable to hold the current client app.config['current_client'] = None #Make a new static endpoint so that the path gets set goodly app.static_url_path = app.config.get("URL_PREFIX", "") + '/static' app.static_folder = 'static' app.add_url_rule(app.static_url_path + '/<path:filename>', endpoint='static', view_func=app.send_static_file) #Make the database handler db = SQLAlchemy(app) db.create_all() #Make a dictionary to hold handlers for glacier handlers = dict() for region in glacier.regions(): handlers[region.name] = None #Has the current config been validated? validated_glacier = False validated_db = False
from flask import Flask, request, url_for, abort, jsonify from router import app_routes # INITIALIZATION app = Flask(__name__) app.config.from_object(__name__) # CONFIGURATION # Load default configuration and override config from an environment variable app.config.update( dict(DATABASE=os.path.join(app.root_path, 'nft.db'), DEBUG=True, SECRET_KEY='development_key')) app.config.from_envvar('FLASK_SETTINGS', silent=True) app.config.from_pyfile('config.cfg', silent=True) # ROUTES for route in app_routes: options_and_url = re.split(',\s|\s', route[0]) route[2].methods = options_and_url[0:-1] app.add_url_rule(options_and_url[-1], route[1], route[2], methods=options_and_url[0:-1]) # MAIN if __name__ == '__main__': app.run(host='0.0.0.0', port=8000)
from flask import Flask from . import db db.does_table_exists() app = Flask(__name__) from . import views app.register_blueprint(views.bp) app.add_url_rule('/create/note', endpoint='create') app.add_url_rule('/notes', endpoint='get_notes') app.add_url_rule('/notes/<int:id>', endpoint='get_a_note') app.add_url_rule('/update/note/<int:id>', endpoint='update') app.add_url_rule('/delete/note/<int:id>', endpoint='delete')
import sys from flask import Flask import function_method from flask_cors import * app = Flask(__name__, static_folder='static', template_folder="templates") CORS(app, supports_credentials=True) app.add_url_rule('/', view_func=function_method.index, methods=["GET"]) # 跳转首页 app.add_url_rule('/api/get_board_count', view_func=function_method.get_board_count, methods=["GET"]) # 获取板卡数量 app.add_url_rule('/api/get_board_status', view_func=function_method.get_board_status, methods=["GET"]) # 获取板卡状态 app.add_url_rule('/api/start_data_receiving', view_func=function_method.start_data_receiving, methods=["GET"]) # 开启接收数据 app.add_url_rule('/api/stop_data_receiving', view_func=function_method.stop_data_receiving, methods=["GET"]) # 停止接收数据 app.add_url_rule('/api/close_Unload_library', view_func=function_method.close_Unload_library, methods=["GET"]) # 释放资源 if __name__ == '__main__': host = "0.0.0.0" port = 5000 if sys.argv[1:]: # 192.168.4.100:8000 try: host, port = sys.argv[1:][0].split(":") try: functionname, pattern = sys.argv[1:][1].split("=") try: import ast pattern = ast.literal_eval(pattern) except Exception as e: print('debug参数格式有误错误信息为{},\n'
input_pdb_string = server_job_manager.status.submitted().pdb_string rq_job = Job.create( create_metrics_from_pdb, [input_pdb_string], connection=REDIS_CONNECTION, ) rq_job_handle = JOB_QUEUE.enqueue_job(rq_job) server_job_manager.rq_job_handle = rq_job_handle return message_dict["tag"], server_job_manager else: raise ValueError(f'Unexpected job type: {message_dict["tag"]}') app.add_url_rule( "/graphql", view_func=GraphQLView.as_view( "graphql", schema=schema, graphiql=True # for having the GraphiQL interface ), ) @app.teardown_appcontext def shutdown_session(exception=None): big_structure_db_session.remove() designs_db_session.remove() __version__ = "0.1.0"
jwt = JWTManager(app) LOGGER.info("Initialzed JSON web token") from fkart.controllers import export_api_list, PKG_DIR #for c_name in export_api_list: # print(c_name.__name__) # Initialzing apis from controllers for api in export_api_list: # in-case export list contains direct urls # if hasattr(api, "url"): # api_url = getattr(api, "url") #else: api_url = api.__name__.lower().split("api")[0] api_name = api.__name__.lower() api_url_temp = "" for i in api_url.split('_'): api_url_temp += i api_url = api_url_temp del(api_url_temp) #print("API URL:"+api_url) #print('API NAME:'+api_name) # for removing '/' from beginning if present # if api_url[0] == "/": # api_url = api_url[1:] view = api.as_view("%s" % api_name) app.add_url_rule("/"+(api_url), view_func=view) LOGGER.info("Added APIs to be used")
# flask.app.Flask.add_url_rule from flask import Flask app = Flask(__name__) def index(): return 'Hi' # 데코레이터 없이 함수를 선언 app.add_url_rule('/index', view_func=index, methods=['GET']) # add_url_rule이라는 메서드로 리소스를 추가한다. # rule, endpoint, view function 순서로 넣어주어야 하지만 지정해서 넣어줄 수도 있음. 메소드도 설정 가능 app.run(debug=True)
class CogCompTimeDemoService: def __init__(self): self.app = Flask(__name__) CORS(self.app) self.backend = CogCompTimeBackend() @staticmethod def handle_root(path): if path == "" or path is None: path = "index.html" return send_from_directory('./frontend', path) @staticmethod def handle_index(): return send_from_directory('./frontend', 'index.html') def tokenized_to_origin_span(self, text, token_list): text = text.replace("\n", "") token_span = [] pointer = 0 for token in token_list: while True: if token[0] == text[pointer]: start = pointer end = start + len(token) - 1 pointer = end + 1 break else: pointer += 1 token_span.append([start, end]) return token_span def handle_request(self): args = request.get_json() text = args['text'] order = self.backend.build_graph(text) return { "result": order, } def handle_uiuc_request(self): form = json.loads(request.data) stories = form['oneie']['en']['json'] story_jsons = {} for s in stories: if len(stories[s]) == 0: continue if s not in story_jsons: story_jsons[s] = [] ls = [x.strip() for x in stories[s].split("\n")] for lls in ls: try: obj = json.loads(lls) story_jsons[s].append(obj) except: continue event_lines = [ x.strip() for x in form['coref']['event.cs'].split("\n") ] temporal_content = process_kairos(story_jsons, event_lines) form['temporal_relation']['en'][ 'temporal_relation.cs'] = temporal_content return form def handle_json_request(self): args = request.get_json() tokens = args["tokens"] sent_ends = args["sentences"]["sentenceEndPositions"] sentences = [] sentence = [] for i, token in enumerate(tokens): sentence.append(token) if i + 1 in sent_ends: sentences.append(sentence) sentence = [] views = args["views"] event_view = None event_view_id = None for i, view in enumerate(views): if view["viewName"] == "Event_extraction": event_view = view event_view_id = i break if event_view is None: return args event_triggers = [] con_id_to_json_id = {} for i, constituent in enumerate( event_view["viewData"][0]['constituents']): start = constituent["start"] if "properties" in constituent: key = (constituent['properties']['sentence_id'], start) if key[0] > 0: key = (key[0], start - sent_ends[key[0] - 1]) event_triggers.append(key) if key not in con_id_to_json_id: con_id_to_json_id[key] = [] con_id_to_json_id[key].append(i) event_triggers = list(set(event_triggers)) formatted_events = [] for event in event_triggers: formatted_events.append(event) single_verb_map, relation_map = self.backend.build_graph_with_events( sentences, formatted_events, dct="2020-10-01") for back_id in single_verb_map: trigger_key = formatted_events[back_id] update_ids = con_id_to_json_id[trigger_key] for uid in update_ids: args["views"][event_view_id]["viewData"][0]["constituents"][ uid]["properties"]["duration"] = int( single_verb_map[back_id][1]) for back_id_pair in relation_map: source = back_id_pair[0] dest = back_id_pair[1] for s_uid in con_id_to_json_id[formatted_events[source]]: for d_uid in con_id_to_json_id[formatted_events[dest]]: args["views"][event_view_id]["viewData"][0][ "relations"].append({ "relationName": relation_map[back_id_pair][0], "srcConstituent": s_uid, "targetConstituent": d_uid, "properties": { "distance": int(relation_map[back_id_pair][1]) } }) return args def handle_json_request_no_gurobi(self): args = request.get_json() tokens = args["tokens"] sent_ends = args["sentences"]["sentenceEndPositions"] sentences = [] sentence = [] for i, token in enumerate(tokens): sentence.append(token) if i + 1 in sent_ends: sentences.append(sentence) sentence = [] views = args["views"] event_view = None event_view_id = None for i, view in enumerate(views): if view["viewName"] == "Event_extraction": event_view = view event_view_id = i break if event_view is None: return args event_triggers = [] con_id_to_json_id = {} for i, constituent in enumerate( event_view["viewData"][0]['constituents']): start = constituent["start"] if "properties" in constituent: key = (constituent['properties']['sentence_id'], start) if key[0] > 0: key = (key[0], start - sent_ends[key[0] - 1]) event_triggers.append(key) if key not in con_id_to_json_id: con_id_to_json_id[key] = [] con_id_to_json_id[key].append(i) event_triggers = list(set(event_triggers)) formatted_events = [] for event in event_triggers: formatted_events.append(event) single_verb_map, relation_map = self.backend.build_graph_with_events_no_gurobi( sentences, formatted_events, dct="2020-10-01") for back_id in single_verb_map: trigger_key = formatted_events[back_id] update_ids = con_id_to_json_id[trigger_key] for uid in update_ids: args["views"][event_view_id]["viewData"][0]["constituents"][ uid]["properties"]["duration"] = int( single_verb_map[back_id][1]) args["views"][event_view_id]["viewData"][0]["constituents"][ uid]["properties"][ "duration_minute_prob"] = single_verb_map[back_id][2] args["views"][event_view_id]["viewData"][0]["constituents"][ uid]["properties"]["duration_hour_prob"] = single_verb_map[ back_id][3] args["views"][event_view_id]["viewData"][0]["constituents"][ uid]["properties"]["duration_day_prob"] = single_verb_map[ back_id][4] args["views"][event_view_id]["viewData"][0]["constituents"][ uid]["properties"]["duration_week_prob"] = single_verb_map[ back_id][5] args["views"][event_view_id]["viewData"][0]["constituents"][ uid]["properties"][ "duration_month_prob"] = single_verb_map[back_id][6] args["views"][event_view_id]["viewData"][0]["constituents"][ uid]["properties"]["duration_year_prob"] = single_verb_map[ back_id][7] args["views"][event_view_id]["viewData"][0]["constituents"][ uid]["properties"][ "duration_decade_prob"] = single_verb_map[back_id][8] for back_id_pair in relation_map: source = back_id_pair[0] dest = back_id_pair[1] for s_uid in con_id_to_json_id[formatted_events[source]]: for d_uid in con_id_to_json_id[formatted_events[dest]]: args["views"][event_view_id]["viewData"][0][ "relations"].append({ "relationName": relation_map[back_id_pair][0], "srcConstituent": s_uid, "targetConstituent": d_uid, "properties": { "distance": int(relation_map[back_id_pair][1]) } }) return args def start(self, localhost=False, port=80, ssl=False): self.app.add_url_rule("/", "", self.handle_index) self.app.add_url_rule("/<path:path>", "<path:path>", self.handle_root) self.app.add_url_rule("/request", "request", self.handle_request, methods=['POST', 'GET']) self.app.add_url_rule("/request_temporal_json", "request_temporal_json", self.handle_json_request, methods=['POST', 'GET']) self.app.add_url_rule("/annotate", "annotate", self.handle_json_request, methods=['POST', 'GET']) self.app.add_url_rule("/annotate_no_gurobi", "annotate_no_gurobi", self.handle_json_request_no_gurobi, methods=['POST', 'GET']) self.app.add_url_rule("/request_uiuc_temporal", "request_uiuc_temporal", self.handle_uiuc_request, methods=['POST', 'GET']) if ssl: if localhost: if port == 0: self.app.run(ssl_context='adhoc') else: self.app.run(ssl_context='adhoc', port=port) else: self.app.run(host='0.0.0.0', port=port, ssl_context='adhoc') else: if localhost: if port == 0: self.app.run() else: self.app.run(port=port) else: self.app.run(host='0.0.0.0', port=port)
return str(params) # 方法视图 class GetView(MethodView): @filter_params(get=get_field) def get(self, params=None): return str(params) @filter_params(post=post_field, response='html') def post(self, params=None): return str(params) # 标准视图demo class BaseView(View): @filter_params(get=get_field, post=post_field, response='html') def dispatch_request(self, params=None): return str(params) app.add_url_rule('/getview', view_func=GetView.as_view('getview')) app.add_url_rule('/baseview', view_func=BaseView.as_view('baseview')) if __name__ == "__main__": app.run()
load_dotenv(dotenv_path, verbose=True) app = Flask(__name__) app.config['SQLALCHEMY_DATABASE_URI'] = str(engine.url) app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False alchemy_app = SQLAlchemy(app) CORS(app) app.config['BASIC_AUTH_USERNAME'] = os.environ['BASIC_AUTH_USER_NAME'] app.config['BASIC_AUTH_PASSWORD'] = os.environ['BASIC_AUTH_PASSWORD'] basic_auth = BasicAuth(app) if os.environ["ENV"] != 'production': app.debug = True app.add_url_rule('/api', view_func=GraphQLView.as_view('graphql', schema=schema, graphiql=True, context={'session': db_session})) else: app.debug = False app.add_url_rule('/api', view_func=GraphQLView.as_view('graphql', schema=schema, graphiql=False, context={'session': db_session})) app.add_url_rule('/sandbox', view_func=GraphQLView.as_view('sandbox', schema=schema, graphiql=True, context={'session': db_session})) class RegexConverter(BaseConverter): def __init__(self, url_map, *items): super(RegexConverter, self).__init__(url_map) self.regex = items[0]