def init_app(config_file, name=None, **kwargs) -> Flask: name = name or __name__ app = Flask(name, static_url_path='', **kwargs) app.srv_config = create_from_config_file(Configuration, entity_conf=[{ "class": FedEntityConfiguration, "attr": "federation", "path": ["federation"] }], filename=config_file, base_path=dir_path) # app.users = {'test_user': {'name': 'Testing Name'}} try: from .views import intermediate except ImportError: from views import intermediate app.register_blueprint(intermediate) # Initialize the oidc_provider after views to be able to set correct urls app.server = init_entity(app.srv_config.federation, dir_path) return app
def oidc_provider_init_app(config_file, name=None, **kwargs): name = name or __name__ app = Flask(name, static_url_path='', **kwargs) app.srv_config = create_from_config_file(Configuration, entity_conf=[{ "class": FedRPConfiguration, "attr": "rp" }], filename=config_file, base_path=dir_path) app.users = {'test_user': {'name': 'Testing Name'}} try: from .views import oidc_rp_views except ImportError: from views import oidc_rp_views app.register_blueprint(oidc_rp_views) # Initialize the oidc_provider after views to be able to set correct urls app.rph = init_oidc_rp_handler(app.srv_config.rp, dir_path) return app
def create_app(spark_context, app): global recommendationengine recommendationengine = RecommendationEngine(spark_context, app) app = Flask(__name__) app.register_blueprint(main) return app
def create_app(config: dict = {}, mail_client=None): app = Flask(__name__, static_folder='static') if config: app.config.update(config) else: app.config.from_envvar('ALSERVICE_CONFIG') MakoTemplates(app) app._mako_lookup = TemplateLookup(directories=[pkg_resources.resource_filename('alservice.service', 'templates')], input_encoding='utf-8', output_encoding='utf-8', imports=['from flask_babel import gettext as _']) app.al = init_account_linking(app, mail_client) babel = Babel(app) babel.localeselector(get_locale) app.config['BABEL_TRANSLATION_DIRECTORIES'] = pkg_resources.resource_filename('alservice.service', 'data/i18n/locales') from .views import account_linking_views app.register_blueprint(account_linking_views) setup_logging(app.config.get('LOGGING_LEVEL', 'INFO')) logger = logging.getLogger(__name__) logger.info('Running ALservice version %s', pkg_resources.get_distribution('ALservice').version) return app
def init_app(app: Flask): from . import auth, user, order, shop, admin, merchant app.register_blueprint(auth.app) app.register_blueprint(user.app) app.register_blueprint(order.app) app.register_blueprint(shop.app) app.register_blueprint(admin.app) app.register_blueprint(merchant.app)
def create_app(config_filename=None): app = Flask(__name__) app.config.from_object(hepdata_converter_ws) from hepdata_converter_ws.api import api app.register_blueprint(api) return app
def create_app(): app = Flask(__name__) from . import api app.register_blueprint(api.bp) app.height = int(os.environ.get('PREDICTOR_HEIGHT', '0')) app.feature_type = os.environ.get('PREDICTOR_FEATURE_TYPE') app.logger.debug(f"Building predictor: {app.feature_type}") return app
def create_app(config_name): app = Flask(__name__) app.config.from_object(config[config_name]) bootstrap.init_app(app) db.init_app(app) from .main import main as main_blueprint app.register_blueprint(main_blueprint) return app
def create_app(): app = Flask(__name__) from . import api app.register_blueprint(api.bp) app.identifier = os.environ.get('VECTORIZER_IDENTIFIER') app.width = int(os.environ.get('VECTORIZER_WIDTH', '0')) app.constructor = os.environ.get('VECTORIZER_CONSTRUCTOR') app.logger.debug(f"Building vectorizer: {app.constructor}") return app
def create_app(self): from openbrokerapi.api import get_blueprint app = Flask(__name__) self.broker = Mock() app.register_blueprint( get_blueprint(self.broker, BrokerCredentials("", ""), basic_config(level=logging.WARN))) return app
def create_app(): app = Flask(__name__) bootstrap = Bootstrap(app) app.config.from_object(Config) # login manager inicializando la app login_manager.init_app(app) # Se registra el nuevo blueprint auth app.register_blueprint(auth) return app
def init_app(name=None): name = name or __name__ app = Flask(name) app.config.from_pyfile('application.cfg') app.config.from_pyfile('production.cfg') app.jinja_env.globals['GIT_HASH'] = get_git_hash() #app.ldap_orm = Connection(app.config['LDAP_URL'], app.config['LDAP_BIND_DN'], app.config['LDAP_BIND_PW'], auto_bind=True) server = Server(app.config['LDAP_URL'], get_info=ALL) app.ldap_conn = Connection(server, app.config['LDAP_BIND_DN'], app.config['LDAP_BIND_PW'], auto_bind=True) model.ldap_conn = app.ldap_conn model.base_dn = app.config['LDAP_BASE_DN'] from .model import db db.init_app(app) with app.app_context(): db.create_all() app.babel = Babel(app) init_oauth2(app) app.login_manager = LoginManager(app) #init hydra admin api hydra_config = hydra.Configuration( host=app.config['HYDRA_ADMIN_URL'], username=app.config['HYDRA_ADMIN_USER'], password=app.config['HYDRA_ADMIN_PASSWORD']) hydra_client = hydra.ApiClient(hydra_config) app.hydra_api = hydra.AdminApi(hydra_client) from .views import auth_views, frontend_views, init_login_manager, api_views, pki_views, admin_views init_login_manager(app) app.register_blueprint(auth_views) app.register_blueprint(frontend_views) app.register_blueprint(api_views) app.register_blueprint(pki_views) app.register_blueprint(admin_views) @app.before_request def befor_request(): request_start_time = time.time() g.request_time = lambda: "%.5fs" % (time.time() - request_start_time) from .translations import init_babel init_babel(app) app.lenticular_services = {} for service_name, service_config in app.config[ 'LENTICULAR_CLOUD_SERVICES'].items(): app.lenticular_services[service_name] = model.Service.from_config( service_name, service_config) app.pki = Pki(app.config['PKI_PATH'], app.config['DOMAIN']) return app
def oidc_provider_init_app(name=None): name = name or __name__ app = Flask(name) app.config.from_pyfile('application.cfg') app.users = {'test_user': {'name': 'Testing Name'}} from .views import oidc_provider_views app.register_blueprint(oidc_provider_views) # Initialize the oidc_provider after views to be able to set correct urls app.provider = init_oidc_provider(app) return app
def oidc_provider_init_app(name=None): name = name or __name__ app = Flask(name) app.config.from_pyfile("application.cfg") app.users = {"test_user": {"name": "Testing Name"}} from .views import oidc_blueprint app.register_blueprint(oidc_blueprint) # Initialize the oidc_provider after views to be able to set correct urls app.provider = init_oidc_provider(app) return app
def oidc_provider_init_app(op_config, name=None, **kwargs): name = name or __name__ app = Flask(name, static_url_path='', **kwargs) app.srv_config = op_config try: from .views import oidc_op_views except ImportError: from views import oidc_op_views app.register_blueprint(oidc_op_views) # Initialize the oidc_provider after views to be able to set correct urls app.server = init_oidc_op(app) return app
def create_app(config_name): # Creating instance app = Flask(__name__) # Creating the app conifgurations app.config.from_object(config_options[config_name]) #Registering the blueprint from .main import main as main_blueprint app.register_blueprint(main_blueprint) #Setting config from .requests import configure_requests configure_requests(app) return app
def register_routes(_app: Flask): """Registers api resources/routes with Flask app Args: _app (object): Flask app object """ api_blueprint = Blueprint("api", __name__) api = Api(api_blueprint, catch_all_404s=False) api.add_resource( resources.CoursesList, "/courses") api.add_resource( resources.CoursesDetailed, "/courses/<int:id>") _app.register_blueprint(api_blueprint, url_prefix="/api")
def oidc_provider_init_app(name=None): name = name or __name__ app = Flask(name) app.config.from_pyfile('application.cfg') from views import oidc_provider_views app.register_blueprint(oidc_provider_views) # Initialize the oidc_provider after views to be able to set correct urls app.provider = init_oidc_provider(app) sess = Session() sess.init_app(app) login_manager = LoginManager() login_manager.init_app(app) return app
def register_blueprints(*, server: Flask) -> None: """Register all blueprints located in /routes modules to the flask app Args: server: flask server object to hook blueprints to. Returns: None """ for name in find_modules("btc_dash.routes"): # it doesnt like to import robots from btc_dash.routes.robots # so hack around the import string. name = name.split(".") name = ".".join(name + [name[-1]]) module = import_string(name) server.register_blueprint(module)
def app_factory(config): '''This factory creates a Flask application instance based on the settings in the provided configuration object.''' # Create the Flask app, register the blueprint and initialize the # flask-mail service. # Blueprints must be used to implement factories (I believe) because # they allow the factory to register the application's routes # before they must be implemented. app = Flask(__name__) app.config.from_object(config) from app.views import web app.register_blueprint(web) mail.init_app(app) # Create the (only) mongodb instance for use by all running applications. # Different apps may use different Mongo databases. # The production server already has its data, so don't always # call db_reset(). mongo = PyMongo(app) if config.DATA: with app.app_context(): db_reset(mongo, config.DATA) # Store the Mongo database object in the Flask globals so that it can # be accessed when needed. @app.before_request def before_request(): g.mongo = mongo # This Jinja2 template must be defined here, on the app, rather than # in views.py on the blueprint. @app.template_filter('start_token') def start_token(name): '''This routine returns the substring of the given name up to but not including the first slash. If there is no slash, it returns the full name. It is used in the templates to find either the page name or category.''' if (name.find('/') == -1): return name else: return name[:name.find('/')] return app
def register_blueprints(*, app: Flask) -> None: """Register all blueprints located in /routes modules to the flask app Args: app (Flask): flask server object to hook blueprints to. """ for name in find_modules("app.routes"): name = name.split(".") name = ".".join(name + ['blueprint']) try: module = import_string(name) except: continue if isinstance(module, flask.blueprints.Blueprint): app.logger.info(f"Registering {name}...") app.register_blueprint(module)
def make_app(import_name=__name__, config='homebank.settings.Configuration', debug=False): app = Flask(import_name) app.config.from_object(config) app.config.from_envvar('FLASK_SETTINGS', silent=True) app.debug = debug app.jinja_env.filters['currency'] = \ lambda x: "{:,.2f} %s".format(x).replace(",", " ").replace(".", ",") % ( app.config.get('CURRENCY', '') ) if app.debug: import_string('flask.ext.debugtoolbar:DebugToolbarExtension')(app) @app.errorhandler(404) def not_found(ex): return render_template("404.html"), 404 for blueprint in ['__init__', 'accounts', 'transactions']: app.register_blueprint( import_string('homebank.blueprints.%s:root' % blueprint)) login_manager = LoginManager(app=app) login_manager.login_view = "index.login" login_manager.session_protection = "strong" @login_manager.user_loader def load_user(uid): if uid != app.config['PINCODE']: return None return User() if not app.debug: handler = StreamHandler() if 'ERROR_LOG' in app.config: handler = WatchedFileHandler(app.config['ERROR_LOG']) handler.setLevel(WARNING) handler.setFormatter( Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")) app.logger.addHandler(handler) return app
def create_app(): app = Flask(__name__) app.config.from_object(os.environ.get('DISPATCHER_CONFIG_CLASS')) from . import api app.register_blueprint(api.bp) from .database import db db.init_app(app) app.vectorizers = [ requests.get(vectorizer).json() for vectorizer in json.loads(os.environ.get('DISPATCHER_VECTORIZERS')) ] app.predictors = [ requests.get(predictor).json() for predictor in json.loads(os.environ.get('DISPATCHER_PREDICTORS')) ] app.models = json.loads(os.environ.get('DISPATCHER_MODELS')) app.logger.debug(f"Building dispatcher: {app.models}") return app
def oidc_provider_init_app(name=None, **kwargs): name = name or __name__ app = Flask(name, static_url_path='', **kwargs) app.config.from_pyfile(os.path.join(folder,'conf.py')) #app.users = {'test_user': {'name': 'Testing Name'}} try: from .views import oidc_op_views except ImportError: from views import oidc_op_views app.register_blueprint(oidc_op_views) # Initialize the oidc_provider after views to be able to set correct urls app.endpoint_context = init_oidc_op_endpoints(app) return app
def oidc_provider_init_app(config_file, name=None, **kwargs): name = name or __name__ app = Flask(name, static_url_path='', **kwargs) app.config.from_pyfile(os.path.join(dir_path, config_file)) app.users = {'test_user': {'name': 'Testing Name'}} try: from .views import oidc_rp_views except ImportError: from views import oidc_rp_views app.register_blueprint(oidc_rp_views) # Initialize the oidc_provider after views to be able to set correct urls app.rph = init_oidc_rp_handler(app) return 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, '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: # 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 # 从 views.py 中调用 init_route() 函数,称为懒加载 # init_route(app) # 导入auth.py 的bp的 蓝图 函数 from . import auth app.register_blueprint(auth.bp) # 导入系统 system.py 的 bp蓝图 from . import system app.register_blueprint(system.bp) app.add_url_rule('/', endpoint='index') # 用户端蓝图 init_user(app=app) # 管理员端蓝图 init_admin(app=app) # 导入数据库文件 db.py from . import db db.init_app(app) return app
def create_app(config_class=Config): app = Flask(__name__) app.config.from_object(Config) with app.app_context(): db.init_app(app) login_manager.init_app(app) sess.init_app(app) from . import models from .routes import main app.register_blueprint(main) # from app.users.routes import users # from app.quiz.routes import quiz # from app.home.routes import home # app.register_blueprint(users) # app.register_blueprint(quiz) # app.register_blueprint(home) return app
class EmailActivationTest(TestCase): def setUp(self): self.app = Flask(__name__) self.app.register_blueprint(emailactivation.views.app) self.app.config['SECRET_KEY'] = 'SECRET' self.mail = Mail(self.app) @self.app.route('/index') def index(): return 'index' def testSendEmail(self): callback = my_callback data = {'mail':'*****@*****.**'} email = {'subject':'subject', 'sender':'*****@*****.**'} with patch('test_activation.my_callback') as c: with self.app.test_request_context(): c.return_value = url_for('index') signature = signature_serialize(callback, data) with self.mail.record_messages() as outbox: send_activation_email(self.mail, '*****@*****.**', callback=callback, data=data, email_context=email, template_context={}, body_template='test.html') self.assertEquals(1, len(outbox), 'Email was sent') self.assertIn(url_for('emailactivation.activation', signature=signature, _external=True), outbox[0].body) with self.app.test_client() as client: response = client.get(url_for('emailactivation.activation', signature=signature,)) self.assertEquals(302, response.status_code) self.assertEquals(url_for('index', _external=True), response.location)
def __new__(cls, *args, **kwargs): if cls._instance is None: app = Flask(__name__) app.register_blueprint(PeopleBluePrintFactory.create()) flask_injector = FlaskInjector( app=app, modules=[DatabaseModule(), ], ) app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:////tmp/production.db' db.init_app(app) with app.app_context(): db.create_all() cls._instance = flask_injector return cls._instance
def create_app(config_name): app = Flask(__name__) print(__name__) app.config.from_object(config[config_name]) bootstrap.init_app(app) mail.init_app(app) moment.init_app(app) # 初始化db db.init_app(app) login_manager.init_app(app) # 初始化日志配置 common = LogCommon() app = common.init_log(app, 'log') # 附加路由和自定义的错误页面 from app.pyweb.main import main app.register_blueprint(main) # 定义认证路由 from app.pyweb.auth import auth app.register_blueprint(auth, url_prefix='/auth') # 定义Captcha路由 from app.pyweb.captcha_chinese import captcha app.register_blueprint(captcha, url_prefix='/captcha') return app
def make_app(import_name=__name__, config="homebank.settings.Configuration", debug=False): app = Flask(import_name) app.config.from_object(config) app.config.from_envvar("FLASK_SETTINGS", silent=True) app.debug = debug app.jinja_env.filters["currency"] = lambda x: "{:,.2f} %s".format(x).replace(",", " ").replace(".", ",") % ( app.config.get("CURRENCY", "") ) if app.debug: import_string("flask.ext.debugtoolbar:DebugToolbarExtension")(app) @app.errorhandler(404) def not_found(ex): return render_template("404.html"), 404 for blueprint in ["__init__", "accounts", "transactions"]: app.register_blueprint(import_string("homebank.blueprints.%s:root" % blueprint)) login_manager = LoginManager(app=app) login_manager.login_view = "index.login" login_manager.session_protection = "strong" @login_manager.user_loader def load_user(uid): if uid != app.config["PINCODE"]: return None return User() if not app.debug: handler = StreamHandler() if "ERROR_LOG" in app.config: handler = WatchedFileHandler(app.config["ERROR_LOG"]) handler.setLevel(WARNING) handler.setFormatter(Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")) app.logger.addHandler(handler) return app
def oidc_provider_init_app(config_file, name=None, **kwargs): name = name or __name__ app = Flask(name, static_url_path='', **kwargs) app.rp_config = Configuration.create_from_config_file(config_file) # Session key for the application session app.config['SECRET_KEY'] = os.urandom(12).hex() app.users = {'test_user': {'name': 'Testing Name'}} try: from .views import oidc_rp_views except ImportError: from views import oidc_rp_views app.register_blueprint(oidc_rp_views) # Initialize the oidc_provider after views to be able to set correct urls app.rph = init_oidc_rp_handler(app) return app
def oidc_provider_init_app(name=None, config=None): name = name or __name__ app = Flask(name) app.config.from_envvar(SE_LEG_PROVIDER_SETTINGS_ENVVAR) if config: app.config.update(config) # Init logging app = init_logging(app) # Init middleware app.wsgi_app = LocalhostMiddleware(app.wsgi_app, server_name=app.config['SERVER_NAME']) # Initialize registry for plugin handling r = Registry(app=app) r['packages'] = PackageRegistry(app) r['extensions'] = ExtensionRegistry(app) r['config'] = ConfigurationRegistry(app) r['blueprints'] = BlueprintAutoDiscoveryRegistry(app=app) # Init dbs app.authn_requests = OpStorageWrapper(app.config['DB_URI'], 'authn_requests') app.users = OpStorageWrapper(app.config['DB_URI'], 'userinfo') # Init queues app = init_redis_connection(app) app.authn_response_queue = rq.Queue('authn_responses', connection=app.redis) app.authn_response_delay_queue = Scheduler(queue_name='authn_responses', connection=app.redis) # Set up views from .views.oidc_provider import oidc_provider_views app.register_blueprint(oidc_provider_views) from .views.status import status_views app.register_blueprint(status_views) # Initialize the oidc_provider after views to be able to set correct urls app.provider = init_oidc_provider(app) return app
def register_blueprints(*, server: Flask) -> None: """Register all blueprints located in /routes modules to the flask app Args: server: flask server object to hook blueprints to. Returns: None """ for name in find_modules("btc_dash.routes"): # it doesnt like to import robots from btc_dash.routes.robots # so hack around the import string. name = name.split(".") name = ".".join(name + [name[-1]]) try: module = import_string(name) except: # noqa: E722 server.logger.info(f"{name} not a blueprint, skipping...") continue if isinstance(module, flask.blueprints.Blueprint): server.logger.info(f"Registering {name}...") server.register_blueprint(module)
def oidc_provider_init_app(config_file, name=None, **kwargs): name = name or __name__ app = Flask(name, static_url_path='', **kwargs) if config_file.endswith('.yaml'): app.config.update(load_yaml_config(config_file)) elif config_file.endswith('.py'): app.config.from_pyfile(os.path.join(dir_path, config_file)) else: raise ValueError('Unknown configuration format') app.users = {'test_user': {'name': 'Testing Name'}} try: from .views import oidc_rp_views except ImportError: from views import oidc_rp_views app.register_blueprint(oidc_rp_views) # Initialize the oidc_provider after views to be able to set correct urls app.rph = init_oidc_rp_handler(app) return app
def create_app(): application = Flask(__name__) application.secret_key = gen_random_password() Bootstrap(application) application.register_blueprint(base_bp) application.register_blueprint(files_bp) application.register_blueprint(helpers_bp) return application
class SimpleFlaskAppTest(unittest.TestCase): def setUp(self): self.app = Flask(__name__) self.client = self.app.test_client() self.db = MongoEngine(self.app) with self.app.app_context(): self.db.connection.drop_database("test") # self.db.connection class TestCol(db.Document): value = db.StringField() def __unicode__(self): return "TestCol(value={})".format(self.value) TestCol.objects.delete() TestCol.objects.create(value="1") TestCol.objects.create(value="2") self.TestCol = TestCol def _parse(self, resp): resp = resp.decode("utf-8") return json.loads(resp) def test_validation_mongoengine_will_work_with_model_serializer(self): class Doc(db.Document): value = db.StringField(validation=RegexpValidator(r"\d+", message="Bad value").for_mongoengine()) Doc.drop_collection() class Serializer(ModelSerializer): class Meta: model = Doc Doc.objects.create(value="123") s = Serializer(data={"value": "asd"}) self.assertEqual(s.validate(), False) self.assertEqual(s.errors, {"value": ["Bad value"]}) def test_resource_decorator(self): class S(BaseSerializer): field = fields.StringField(required=True) @self.app.route("/test", methods=["POST"]) @validate(S) def resource(cleaned_data): return "OK" resp = self.client.post("/test", data=json.dumps({}), headers={"Content-Type": "application/json"}) self.assertEqual(resp.status_code, 400) self.assertEqual( json.loads(resp.data.decode("utf-8")), {'field': ['Field is required']} ) def testSimpleResourceAndRouter(self): router = DefaultRouter(self.app) class Resource(BaseResource): def get(self, request): return "GET" def post(self, request): return "POST" def put(self, request): return "PUT" def patch(self, request): return "PATCH" def delete(self, request): return "DELETE" @list_route(methods=["GET", "POST"]) def listroute(self, request): return "LIST" @detail_route(methods=["GET", "POST"]) def detailroute(self, request, pk): return "detail" self.assertSetEqual( set(Resource.get_allowed_methods()), {"get", "post", "put", "patch", "delete"} ) router.register("/test", Resource, "test") for method in ["get", "post", "put", "patch", "delete"]: resp = getattr(self.client, method)("/test") self.assertEqual(resp.data.decode("utf-8"), method.upper()) for method in ["GET", "POST"]: resp = getattr(self.client, method.lower())("/test/listroute") self.assertEqual(resp.status_code, 200) self.assertEqual(resp.data.decode("utf-8"), "LIST") for method in ["GET", "POST"]: resp = getattr(self.client, method.lower())("/test/detailroute/1") self.assertEqual(resp.status_code, 200) self.assertEqual(resp.data.decode("utf-8"), "detail") resp = self.client.get("/test/detailroute") self.assertEqual(resp.status_code, 404) def testRoutingWithBluePrint(self): bp = Blueprint("test", __name__) router = DefaultRouter(bp) class Res(BaseResource): def get(self, request): return "GET" router.register("/blabla", Res, "blabla") self.app.register_blueprint(bp, url_prefix="/test") with self.app.test_request_context(): self.assertEqual(url_for("test.blabla"), "/test/blabla") @pytest.mark.testModelResource123 def testModelResource(self): router = DefaultRouter(self.app) class Base(db.Document): title = db.StringField() class ED(db.EmbeddedDocument): value = db.StringField() class Model(db.Document): base = db.ReferenceField(Base) f1 = db.StringField() f2 = db.BooleanField() f3 = db.StringField() embedded = db.EmbeddedDocumentField(ED) listf = db.EmbeddedDocumentListField(ED) dictf = db.DictField() Model.objects.delete() ins = Model.objects.create( base=Base.objects.create(title="1"), f1="1", f2=True, f3="1", embedded={"value": "123"}, listf=[{"value": "234"}], dictf={"key": "value"} ) Model.objects.create( base=Base.objects.create(title="2"), f1="2", f2=True, f3="2", embedded={"value": "123"}, listf=[{"value": "234"}] ) class S(ModelSerializer): title = fields.ForeignKeyField("base__title") class Meta: model = Model fk_fields = ("base__title", ) class ModelRes(ModelResource): serializer_class = S queryset = Model.objects.all() pagination_class = DefaultPagination router.register("/test", ModelRes, "modelres") resp = self.client.get("/test") self.assertEqual(resp.status_code, 200) data = self._parse(resp.data) self.assertEqual(len(data["results"]), 2) item = data["results"][0] self.assertEqual(item["dictf"], {"key": "value"}) self.assertEqual(item["title"], "1") self.assertEqual(item["base__title"], "1") # get one object resp = self.client.get("/test/{}".format(ins.id)) self.assertEqual(resp.status_code, 200) pprint(self._parse(resp.data)) #test pagination for i in range(10): Model.objects.create( base=Base.objects.create(title="1"), f1="1", f2=True, f3="2" ) self.assertEqual(Model.objects.count(), 12) resp = self.client.get("/test?page=1") self.assertEqual(resp.status_code, 200) data = self._parse(resp.data) results = data["results"] self.assertEqual(results[0]["embedded"], {"value": "123"}) self.assertEqual(results[0]["listf"], [{"value": "234"}]) self.assertEqual(len(data["results"]), 10) resp = self.client.get("/test?page=2") self.assertEqual(resp.status_code, 200) data = self._parse(resp.data) self.assertEqual(len(data["results"]), 2) resp = self.client.get("/test?page=2&page_size=5") self.assertEqual(resp.status_code, 200) data = self._parse(resp.data) self.assertEqual(len(data["results"]), 5) resp = self.client.get("/test?page=3&page_size=5") self.assertEqual(resp.status_code, 200) data = self._parse(resp.data) self.assertEqual(len(data["results"]), 2) #test put resp = self.client.put("/test/{}".format(ins.id), data=json.dumps({ "f3": "OLALA" }), headers={"Content-Type": "application/json"}) self.assertEqual(resp.status_code, 200, resp.data) data = self._parse(resp.data) self.assertEqual(data["f1"], "1") self.assertEqual(data["f2"], True) self.assertEqual(data["f3"], "OLALA") def testMongoEngineForeignKeyField(self): self.assertEqual(self.TestCol.objects.count(), 2) class Serializer(BaseSerializer): fk = fields.MongoEngineIdField(self.TestCol, required=True) v = Serializer({"fk": "123"}) self.assertEqual(v.validate(), False) self.assertEqual(v.errors, {'fk': ['Incorrect id: 123']}) v = Serializer({"fk": str(self.TestCol.objects.first().id)}) v.validate() self.assertEqual(v.errors, {}) self.assertEqual(v.cleaned_data["fk"], self.TestCol.objects.first()) class R(BaseResource): def post(self, request): errors, data = self.validate_request(Serializer) if errors: return errors return "OK" self.app.add_url_rule("/api", view_func=R.as_view("test2"), methods=["GET", "POST"]) resp = self.client.post("/api", data=json.dumps({}), headers={"Content-Type": "application/json"}) self.assertEqual(resp.status_code, 400) data = json.loads(resp.data.decode("utf-8")) self.assertEqual(data["fk"], ['Field is required']) def testSerialization(self): class Col(db.Document): value = db.StringField() created = db.DateTimeField(default=datetime.datetime.now) Col.objects.delete() Col.objects.create(value="1") Col.objects.create(value="2") class S(BaseSerializer): value = fields.StringField() created = fields.DateTimeField(read_only=True) data = S(Col.objects.all()).to_python() self.assertEqual(len(data), 2) self.assertEqual( list(map(lambda i: i["value"], data)), ["1", "2"] ) #test can't set read only field ser = S({"value": "1", "created": "2016-01-01 00:00:00"}) ser.validate() self.assertTrue("created" not in ser.cleaned_data) def testModelSerialization(self): class DeepInner(db.EmbeddedDocument): value = db.StringField() class Inner(db.EmbeddedDocument): value = db.StringField() deep = db.EmbeddedDocumentField(DeepInner) class Col(db.Document): value = db.StringField() excluded_field = db.StringField(default="excluded") created = db.DateTimeField(default=datetime.datetime.now) inner = db.EmbeddedDocumentField(Inner) Col.objects.delete() Col.objects.create(value="1", inner={"value": "inner1", "deep": {"value": "123"}}) Col.objects.create(value="2", inner={"value": "inner2"}) class Serializer(ModelSerializer): method_field = fields.MethodField("test") renamed = fields.ForeignKeyField(document_fieldname="inner__deep__value") def test(self, doc): return doc.value class Meta: model = Col fields = ("value", "created", "method_field") fk_fields = ("inner__value", "inner__deep__value") data = Serializer(Col.objects.all()).to_python() for item in data: self.assertTrue("value" in item) self.assertEqual(item["value"], item["method_field"]) self.assertTrue(type(item["created"]), datetime.datetime) self.assertEqual(item["renamed"], item["inner__deep__value"])
:return: """ next_bus = None if len(data) > 0 and len(data[0].mode_list) > 0: first_bus_route = data[0].mode_list[0] if isinstance(first_bus_route, BuswayMode): next_bus = main_component.search_service.get_next_bus( first_bus_route.heading_from, first_bus_route.heading_to, station ) return next_bus @meloentjoer.route("search", methods=["POST"]) def search_route(): json_return = request.get_json() source = json_return["source"] destination = json_return["destination"] data = main_component.search_service.get_direction(source, destination) next_bus = __get_next_bus(data, source) rendered_element = render_template("response.html", entries=data, next_bus=next_bus) return jsonify(data=rendered_element) @meloentjoer.route("/") def index(): return render_template("autocomplete.html", host_url=main_component.general_config.get_host_url()) meloentjoer_app = Flask(__name__) meloentjoer_app.register_blueprint(meloentjoer, url_prefix="/")
import logging from flask.app import Flask from apps.config.apps_config import db_session, log_file app = Flask(__name__) from apps.billing.views import mod as billingModule from apps.login.views import mod as loginModule app.register_blueprint(billingModule) app.register_blueprint(loginModule) @app.teardown_appcontext def shutdown_session(exception=None): log.info("----------------- IN Shutdown session --------------") db_session.remove() log.info("----------------- AFter RemoveShutdown session --------------") logging.basicConfig(filename=log_file, level=logging.DEBUG) log = logging.getLogger()
import json from flask import Blueprint, render_template from flask.app import Flask meloentjoer = Blueprint('meloentjoer', __name__) @meloentjoer.route('/retrieve/<string:word>') def retrieve_route(word): word_list = ['ABCDE', 'EFGHI'] return json.dumps(word_list) @meloentjoer.route('/') def index(): return render_template('autocomplete.html', host_url='http://127.0.0.1:5000/meloentjoer/') meloentjoer_app = Flask(__name__) meloentjoer_app.register_blueprint(meloentjoer, url_prefix='/meloentjoer')
from flask.ext.sqlalchemy import SQLAlchemy import wtforms_json from chisubmit.backend.webapp.auth.testing import TestingAuth from chisubmit.backend.webapp.auth import set_auth from chisubmit.backend.webapp.auth.ldap import LDAPAuth wtforms_json.init() app = Flask(__name__) app.json_encoder = CustomJSONEncoder db = SQLAlchemy(app) import chisubmit.backend.webapp.api.views app.register_blueprint(api_endpoint, url_prefix='/api/v0') class ChisubmitAPIServer(object): def __init__(self, debug): self.app = app self.db = db self.debug = debug if self.debug: self.debug = True self.app.config["DEBUG"] = True self.app.config["TESTING"] = True self.app.config["SQLALCHEMY_RECORD_QUERIES"] = True else:
# coding: utf-8 from flask.app import Flask import admin import blog app = Flask(__name__) app.register_blueprint(blog.mod, url_prefix='/blog') app.register_blueprint(admin.mod, url_prefix='/admin') @app.teardown_appcontext def shutdown_session(exception=None): from database import db_session db_session.remove() @app.template_filter('strftime') def filter_strftime(_datetime): return _datetime.strftime('%Y-%m-%d %H:%M:%S') if __name__ == '__main__': app.run(debug=True)