def __init__(self, settings, loader=FileSystemLoader): self.settings = settings self.search_path = getattr(settings, 'TEMPLATE_DIRS', list()) self.loader = import_string(getattr(settings, 'TEMPLATE_LOADER', 'jinja2.FileSystemLoader')) if getattr(settings, "JINJA2_BYTECODE_CACHE", False): self.bytecode_cache = import_string(getattr(settings, 'JINJA2_BYTECODE_CACHE')) else: self.bytecode_cache = None self.env = Environment(loader=self.loader(self.search_path), auto_reload=getattr(settings, 'JINJA2_AUTO_RELOAD', False), cache_size=getattr(settings, 'JINJA2_CHACHE_SIZE', 50), extensions=getattr(settings, 'JINJA2_EXTENSIONS', ()), bytecode_cache=self.bytecode_cache) self.filters = getattr(settings, 'JINJA2_FILTERS', []) self.globals = getattr(settings, 'JINJA2_GLOBALS', []) # Not good :-( for name, f in self.load_filters(self.filters).iteritems(): self.add_filter(f, name) for name, f in self.load_globals(self.globals).iteritems(): self.add_global(f, name) if getattr(settings, 'USE_I18N'): try: self.env.install_gettext_translations(translation) except Exception: self.env.install_null_translations()
def babel_extract(fileobj, keywords, comment_tags, options): """Babel extraction method for Jinja templates. .. versionchanged:: 2.3 Basic support for translation comments was added. If `comment_tags` is now set to a list of keywords for extraction, the extractor will try to find the best preceeding comment that begins with one of the keywords. For best results, make sure to not have more than one gettext call in one line of code and the matching comment in the same line or the line before. :param fileobj: the file-like object the messages should be extracted from :param keywords: a list of keywords (i.e. function names) that should be recognized as translation functions :param comment_tags: a list of translator tags to search for and include in the results. :param options: a dictionary of additional options (optional) :return: an iterator over ``(lineno, funcname, message, comments)`` tuples. (comments will be empty currently) """ extensions = set() for extension in options.get('extensions', '').split(','): extension = extension.strip() if not extension: continue extensions.add(import_string(extension)) if InternationalizationExtension not in extensions: extensions.add(InternationalizationExtension) environment = get_spontaneous_environment( options.get('block_start_string', BLOCK_START_STRING), options.get('block_end_string', BLOCK_END_STRING), options.get('variable_start_string', VARIABLE_START_STRING), options.get('variable_end_string', VARIABLE_END_STRING), options.get('comment_start_string', COMMENT_START_STRING), options.get('comment_end_string', COMMENT_END_STRING), options.get('line_statement_prefix') or LINE_STATEMENT_PREFIX, options.get('line_comment_prefix') or LINE_COMMENT_PREFIX, str(options.get('trim_blocks', TRIM_BLOCKS)).lower() in \ ('1', 'on', 'yes', 'true'), NEWLINE_SEQUENCE, frozenset(extensions), # fill with defaults so that environments are shared # with other spontaneus environments. The rest of the # arguments are optimizer, undefined, finalize, autoescape, # loader, cache size, auto reloading setting and the # bytecode cache True, Undefined, None, False, None, 0, False, None ) source = fileobj.read().decode(options.get('encoding', 'utf-8')) try: node = environment.parse(source) tokens = list(environment.lex(environment.preprocess(source))) except TemplateSyntaxError as e: # skip templates with syntax errors return finder = _CommentFinder(tokens, comment_tags) for lineno, func, message in extract_from_ast(node, keywords): yield lineno, func, message, finder.find_comments(lineno)
def visit(self, elem): children = [self.visit(child) for child in elem.iterchildren()] cls_name = elem.xpath("local-name()") ns = elem.nsmap[elem.prefix] if ns not in self.imports: self.imports[ns] = import_string(ns) module = self.imports[ns] cls = getattr(module, cls_name) wid = elem.attrib.pop("id", None) for scls in cls.mro(): method_name = "visit_{0}".format(scls.__name__) method = getattr(self, method_name, None) if method: result = method(elem, cls, children) break else: result = self.generic_visit(elem, cls, children) if wid: self.glbls[wid] = result return result
def load_extensions(self, extensions): """Load extensions """ for extension in extensions: if isinstance(extension, basestring): extension = import_string(extension) self.add_extension(extension)
def babel_extract(fileobj, keywords, comment_tags, options): extensions = set() for extension in options.get('extensions', '').split(','): extension = extension.strip() if not extension: continue extensions.add(import_string(extension)) if InternationalizationExtension not in extensions: extensions.add(InternationalizationExtension) def getbool(options, key, default = False): return options.get(key, str(default)).lower() in ('1', 'on', 'yes', 'true') silent = getbool(options, 'silent', True) environment = Environment(options.get('block_start_string', BLOCK_START_STRING), options.get('block_end_string', BLOCK_END_STRING), options.get('variable_start_string', VARIABLE_START_STRING), options.get('variable_end_string', VARIABLE_END_STRING), options.get('comment_start_string', COMMENT_START_STRING), options.get('comment_end_string', COMMENT_END_STRING), options.get('line_statement_prefix') or LINE_STATEMENT_PREFIX, options.get('line_comment_prefix') or LINE_COMMENT_PREFIX, getbool(options, 'trim_blocks', TRIM_BLOCKS), NEWLINE_SEQUENCE, frozenset(extensions), cache_size=0, auto_reload=False) if getbool(options, 'newstyle_gettext'): environment.newstyle_gettext = True source = fileobj.read().decode(options.get('encoding', 'utf-8')) try: node = environment.parse(source) tokens = list(environment.lex(environment.preprocess(source))) except TemplateSyntaxError as e: if not silent: raise return finder = _CommentFinder(tokens, comment_tags) for lineno, func, message in extract_from_ast(node, keywords): yield (lineno, func, message, finder.find_comments(lineno))
def load_extensions(environment, extensions): result = {} for extension in extensions: if isinstance(extension, basestring): extension = import_string(extension) result[extension.identifier] = extension(environment) return result
def setup_app(app): backend = app.config.get('EMAIL_BACKEND', 'flask.ext.email:ConsoleMail') module = import_string(backend) backimpl = module() backimpl.init_app(app) if 'email' not in app.extensions: app.extensions['email'] = backimpl return app
def load_extensions(environment, extensions): """Load the extensions from the list and bind it to the environment. Returns a dict of instantiated environments. """ result = {} for extension in extensions: if isinstance(extension, string_types): extension = import_string(extension) result[extension.identifier] = extension(environment) return result
def parse(self, parser): lineno = next(parser.stream).lineno atom_ns = None atom_path = [] atom_args = [] atom_kwargs = [] atom_ns = parser.stream.expect('name').value parser.stream.expect('colon') while parser.stream.current.type not in ['lparen', 'eof']: atom_path.append(parser.stream.current.value) next(parser.stream) parser.stream.expect('lparen') while parser.stream.current.type not in ['rparen', 'eof']: expr, key = parser.parse_expression(), None if parser.stream.skip_if('assign'): key = expr expr = parser.parse_expression() if key: atom_kwargs.append(nodes.Keyword(key.name, expr)) else: atom_args.append(expr) parser.stream.skip_if('comma') parser.stream.expect('rparen') env_atoms_ns = self.environment.globals.get('atoms_ns') env_atom_host = env_atoms_ns and env_atoms_ns.get(atom_ns) if not env_atom_host: raise TemplateSyntaxError('"%s" atom namespace not found' % atom_ns, lineno) full_atom_path = str('.'.join([env_atom_host, ''.join(atom_path)])) env_atom_name = 'loaded_atom_%s' % hashlib.md5(full_atom_path).hexdigest() if env_atom_name not in self.environment.globals: try: imported_atom = import_string(full_atom_path) except AttributeError: raise ImportError('Atom "%s" not found' % full_atom_path) self.environment.globals.update({ env_atom_name: imported_atom }) atom_func = nodes.Name(env_atom_name, 'load') node = nodes.Output([ nodes.MarkSafeIfAutoescape( nodes.Call(atom_func, atom_args, atom_kwargs, None, None) ) ]) node.set_lineno(lineno) return node
def create_env(cls, debug=False, loader=None, **options) -> Environment: # bytecode cache bytecode_cache = options.pop('bytecode_cache', {}) bytecode_cache.setdefault('name', 'default') bytecode_cache.setdefault('enabled', False) bytecode_cache.setdefault( 'backend', 'aioja.bccache.aiocache.AioRedisBytecodeCache') if bytecode_cache['enabled']: bytecode_cls = import_string(bytecode_cache['backend']) bytecode_options = bytecode_cache.get('options') or {} options['bytecode_cache'] = bytecode_cls(**bytecode_options) # undefined undefined = options.pop('undefined', None) if undefined is not None: if isinstance(undefined, str): options['undefined'] = import_string(undefined) else: options['undefined'] = undefined if debug: options.setdefault('undefined', DebugUndefined) else: options.setdefault('undefined', ChainableUndefined) options.setdefault('auto_reload', debug) options.setdefault('autoescape', True) # environment if isinstance(options.get('environment'), str): environment_cls = import_string(options.pop('environment')) else: environment_cls = Environment env = environment_cls(loader=loader, **options) env.globals.update(DEFAULT_GLOBALS) env.filters.update(DEFAULT_FILTERS) env.tests.update(DEFAULT_TESTS) env.extensions.update(load_extensions(env, DEFAULT_EXTENSIONS)) return env
def installBlueprint(self, app): """ 批量导入蓝图,注册蓝图 遍历所有的文件夹 再拼接字符串,利用import_string导入蓝图 最后再注册蓝图 """ for plugin in self.pluginsInfo()['plus_list']: if os.path.exists(self.plugins_path + plugin['path'] + '/controller/urls.py'): bp = import_string(f'plugins.{plugin["path"]}.controller.urls.blueprint') app.register_blueprint(bp, url_prefix=f'/{plugin["apiRoute"]}')
def babel_extract(fileobj, keywords, comment_tags, options): """Babel extraction method for Jinja templates. :param fileobj: the file-like object the messages should be extracted from :param keywords: a list of keywords (i.e. function names) that should be recognized as translation functions :param comment_tags: a list of translator tags to search for and include in the results. (Unused) :param options: a dictionary of additional options (optional) :return: an iterator over ``(lineno, funcname, message, comments)`` tuples. (comments will be empty currently) """ extensions = set() for extension in options.get("extensions", "").split(","): extension = extension.strip() if not extension: continue extensions.add(import_string(extension)) if InternationalizationExtension not in extensions: extensions.add(InternationalizationExtension) environment = get_spontaneous_environment( options.get("block_start_string", BLOCK_START_STRING), options.get("block_end_string", BLOCK_END_STRING), options.get("variable_start_string", VARIABLE_START_STRING), options.get("variable_end_string", VARIABLE_END_STRING), options.get("comment_start_string", COMMENT_START_STRING), options.get("comment_end_string", COMMENT_END_STRING), options.get("line_statement_prefix") or LINE_STATEMENT_PREFIX, str(options.get("trim_blocks", TRIM_BLOCKS)).lower() in ("1", "on", "yes", "true"), NEWLINE_SEQUENCE, frozenset(extensions), # fill with defaults so that environments are shared # with other spontaneus environments. The rest of the # arguments are optimizer, undefined, finalize, autoescape, # loader, cache size, auto reloading setting and the # bytecode cache True, Undefined, None, False, None, 0, False, None, ) source = fileobj.read().decode(options.get("encoding", "utf-8")) try: node = environment.parse(source) except TemplateSyntaxError, e: # skip templates with syntax errors return
def extend(self, *args, scope_: Scope = Scope.GLOBALS, **kwargs): """ Add extra filters, tests, globals or policies. This method accepts the same arguments as the `dict` constructor: A dict, a dict subclass or some keyword arguments. """ extensions = dict(*args, **kwargs) target = getattr(self.env, scope_.value) for name, ext in extensions.items(): if isinstance(ext, str): ext = import_string(ext) target[name] = ext
def main(global_config, **settings): """ This function returns the Pyramid WSGI application. """ config = Configurator(settings=settings) # http://docs.pylonsproject.org/projects/pyramid_exclog/dev/api.html#pyramid_exclog.includeme config.include('pyramid_exclog') # https://docs.pylonsproject.org/projects/pyramid_jinja2/dev/api.html#pyramid_jinja2.includeme config.include('pyramid_jinja2') config.get_jinja2_environment().filters.update({ 'date_format' : import_string('tumblrproxy.lib.template_filter.date_format'), 'tumblr_video' : import_string('tumblrproxy.lib.tumblr_filter.video_embed') }) # view handler config.include('tumblrproxy.controllers.blog') # jinja2 configuration config.add_jinja2_search_path("tumblrproxy:templates") # static content route config.add_static_view('static', 'static', cache_max_age=3600) return config.make_wsgi_app()
def install_blueprint(self, app): """ 批量导入蓝图,注册蓝图 遍历所有的文件夹 再拼接字符串,利用import_string导入蓝图 最后再注册蓝图 """ for plugin in self.plugins_info()['plus_list']: # 加载目录 plugin_path_dir_list = [i for i in os.listdir(self.plugins_path + plugin['path']) if "." not in i] for plugin_path_dir in plugin_path_dir_list: if os.path.exists(self.plugins_path + plugin['path'] + f'/{plugin_path_dir}/urls.py'): bp = import_string(f'plugins.{plugin["path"]}.{plugin_path_dir}.urls.blueprint') app.register_blueprint(bp, url_prefix=f'{bp.name}')
def babel_extract(fileobj, keywords, comment_tags, options): """Babel extraction method for Jinja templates. :param fileobj: the file-like object the messages should be extracted from :param keywords: a list of keywords (i.e. function names) that should be recognized as translation functions :param comment_tags: a list of translator tags to search for and include in the results. (Unused) :param options: a dictionary of additional options (optional) :return: an iterator over ``(lineno, funcname, message, comments)`` tuples. (comments will be empty currently) """ extensions = set() for extension in options.get('extensions', '').split(','): extension = extension.strip() if not extension: continue extensions.add(import_string(extension)) if InternationalizationExtension not in extensions: extensions.add(InternationalizationExtension) environment = get_spontaneous_environment( options.get('block_start_string', BLOCK_START_STRING), options.get('block_end_string', BLOCK_END_STRING), options.get('variable_start_string', VARIABLE_START_STRING), options.get('variable_end_string', VARIABLE_END_STRING), options.get('comment_start_string', COMMENT_START_STRING), options.get('comment_end_string', COMMENT_END_STRING), options.get('line_statement_prefix') or LINE_STATEMENT_PREFIX, options.get('line_comment_prefix') or LINE_COMMENT_PREFIX, str(options.get('trim_blocks', TRIM_BLOCKS)).lower() in \ ('1', 'on', 'yes', 'true'), NEWLINE_SEQUENCE, frozenset(extensions), # fill with defaults so that environments are shared # with other spontaneus environments. The rest of the # arguments are optimizer, undefined, finalize, autoescape, # loader, cache size, auto reloading setting and the # bytecode cache True, Undefined, None, False, None, 0, False, None ) source = fileobj.read().decode(options.get('encoding', 'utf-8')) try: node = environment.parse(source) except TemplateSyntaxError, e: # skip templates with syntax errors return
def create_app(mode): app = Flask(__name__) bp = import_string(blueprint) app.register_blueprint(bp) register_errors(app) app.config['SQLALCHEMY_DATABASE_URI'] = config[ mode].SQLALCHEMY_DATABASE_URI app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = config[ mode].SQLALCHEMY_TRACK_MODIFICATIONS app.config['SQLALCHEMY_COMMIT_TEARDOWN'] = config[ mode].SQLALCHEMY_COMMIT_ON_TEARDOWN db.init_app(app=app) return app
async def index(request): settings = Settings() if request.method == METH_POST: # the 302 redirect is processed as an exception, so if this coroutine returns there's a form error form_errors = await process_form(request) else: form_errors = None network_klass = import_string(settings.NETWORK_CLASS) network_api = network_klass() network_status = network_api.status() return { 'page_title': 'Network', 'network_status': network_status, 'form_errors': form_errors }
def babel_extract(fileobj, keywords, comment_tags, options): extensions = set() for extension in options.get('extensions', '').split(','): extension = extension.strip() if not extension: continue extensions.add(import_string(extension)) if InternationalizationExtension not in extensions: extensions.add(InternationalizationExtension) def getbool(options, key, default=False): return options.get(key, str(default)).lower() in ('1', 'on', 'yes', 'true') silent = getbool(options, 'silent', True) environment = Environment( options.get('block_start_string', BLOCK_START_STRING), options.get('block_end_string', BLOCK_END_STRING), options.get('variable_start_string', VARIABLE_START_STRING), options.get('variable_end_string', VARIABLE_END_STRING), options.get('comment_start_string', COMMENT_START_STRING), options.get('comment_end_string', COMMENT_END_STRING), options.get('line_statement_prefix') or LINE_STATEMENT_PREFIX, options.get('line_comment_prefix') or LINE_COMMENT_PREFIX, getbool(options, 'trim_blocks', TRIM_BLOCKS), NEWLINE_SEQUENCE, frozenset(extensions), cache_size=0, auto_reload=False) if getbool(options, 'newstyle_gettext'): environment.newstyle_gettext = True source = fileobj.read().decode(options.get('encoding', 'utf-8')) try: node = environment.parse(source) tokens = list(environment.lex(environment.preprocess(source))) except TemplateSyntaxError as e: if not silent: raise return finder = _CommentFinder(tokens, comment_tags) for lineno, func, message in extract_from_ast(node, keywords): yield (lineno, func, message, finder.find_comments(lineno))
def routes_info(): """ Available API description """ routes = [] for rule in app.url_map.iter_rules(): try: if rule.endpoint != 'static': if hasattr(app.view_functions[rule.endpoint], 'import_name'): import_name = app.view_functions[rule.endpoint].import_name obj = import_string(import_name) routes.append({ rule.rule: "%s\n%s" % (",".join(list(rule.methods)), obj.__doc__) }) else: methods = list( filter( lambda x: x in ['GET', 'POST', 'DELETE', 'PUT', 'PATCH'], list(rule.methods))) methods_repr = [] for m in methods: methods_repr.append(m) endpoint_doc = app.view_functions[rule.endpoint].__doc__ if endpoint_doc: methods_repr.append( list(str(endpoint_doc).split('\n'))[1:-1]) routes.append({rule.rule: methods_repr}) except Exception as exc: routes.append({ rule.rule: "(%s) INVALID ROUTE DEFINITION!!!" % rule.endpoint }) route_info = "%s => %s" % (rule.rule, rule.endpoint) app.logger.error("Invalid route: %s" % route_info, exc_info=True) routes = sorted(routes, key=lambda d: list(d.keys())) return jsonify(code=200, data=routes)
async def process_form(request): settings = Settings() new_job = {} missing_fields = [] fields = ['ontology_id', 'json_content'] data = await request.post() for f in fields: new_job[f] = data.get(f) if not new_job[f]: missing_fields.append(f) if missing_fields: return 'Invalid form submission, missing fields: {}'.format( ', '.join(missing_fields)) ontology_id = new_job['ontology_id'] json_content = loads(new_job['json_content']) session = await get_session(request) session['ontology_id'] = ontology_id service_klass = import_string(settings.SERVICE_CLASS) agent_id = service_klass().find_provider(ontology_id) if not service_klass.can_perform(agent_id, ontology_id): return 'The service indicates that this service cannot be performed at this time' result = service_klass.perform(agent_id, ontology_id, json_content) # TODO Record the result of the perform so we can check on its status redirect_url = request.app.router['jobs'].url() raise HTTPFound(redirect_url)
def generator_router(dir_name, module_join): """ 自动导入路由 :return: """ for name in os.listdir(dir_name): file_name = os.path.join(dir_name, name) if os.path.isfile(file_name): if (name.endswith('.py') and not name.endswith('not_import.py') and not name.endswith('router.py') and not name.endswith('route.py') and name != '__init__.py'): module_name = name[:name.rfind('.')] module_path = module_join + '.' + module_name module = import_string(module_path) for child in dir(module): if child not in names: child_module = getattr(module, child) if ischildof(child_module, Resource): child_module_name = module_path + '.' + child if child_module_name not in view_set: view_set.add(child_module_name) try: if isinstance(child_module.api_url, basestring): api.add_resource( child_module, child_module.api_url) else: api.add_resource( child_module, *child_module.api_url) except AssertionError: print('has: ' + child_module_name) elif name != '__pycache__': # pass generator_router(file_name, module_join + '.' + name)
def help(): """Print all defined routes and their endpoint docstrings This also handles flask-router, which uses a centralized scheme to deal with routes, instead of defining them as a decorator on the target function. """ routes = [] for rule in flask.current_app.url_map.iter_rules(): try: if rule.endpoint != 'static': if hasattr(flask.current_app.view_functions[rule.endpoint], 'import_name'): import_name = flask.current_app.view_functions[ rule.endpoint].import_name obj = import_string(import_name) routes.append({ rule.rule: "%s\n%s" % (",".join(list(rule.methods)), obj.__doc__) }) else: routes.append({ rule.rule: flask.current_app.view_functions[rule.endpoint].__doc__ }) except Exception as exc: routes.append({ rule.rule: "(%s) INVALID ROUTE DEFINITION!!!" % rule.endpoint }) route_info = "%s => %s" % (rule.rule, rule.endpoint) flask.current_app.logger.error("Invalid route: %s" % route_info, exc_info=True) # func_list[rule.rule] = obj.__doc__ return flask.jsonify(code=200, data=routes)
def maybe_import_string(val): if isinstance(val, string_types): return import_string(val.strip()) return val
def babel_extract(fileobj, keywords, comment_tags, options): """Babel extraction method for Jinja templates. .. versionchanged:: 2.3 Basic support for translation comments was added. If `comment_tags` is now set to a list of keywords for extraction, the extractor will try to find the best preceeding comment that begins with one of the keywords. For best results, make sure to not have more than one gettext call in one line of code and the matching comment in the same line or the line before. .. versionchanged:: 2.5.1 The `newstyle_gettext` flag can be set to `True` to enable newstyle gettext calls. .. versionchanged:: 2.7 A `silent` option can now be provided. If set to `False` template syntax errors are propagated instead of being ignored. :param fileobj: the file-like object the messages should be extracted from :param keywords: a list of keywords (i.e. function names) that should be recognized as translation functions :param comment_tags: a list of translator tags to search for and include in the results. :param options: a dictionary of additional options (optional) :return: an iterator over ``(lineno, funcname, message, comments)`` tuples. (comments will be empty currently) """ extensions = set() for extension in options.get('extensions', '').split(','): extension = extension.strip() if not extension: continue extensions.add(import_string(extension)) if InternationalizationExtension not in extensions: extensions.add(InternationalizationExtension) def getbool(options, key, default=False): return options.get(key, str(default)).lower() in \ ('1', 'on', 'yes', 'true') silent = getbool(options, 'silent', True) environment = Environment( options.get('block_start_string', BLOCK_START_STRING), options.get('block_end_string', BLOCK_END_STRING), options.get('variable_start_string', VARIABLE_START_STRING), options.get('variable_end_string', VARIABLE_END_STRING), options.get('comment_start_string', COMMENT_START_STRING), options.get('comment_end_string', COMMENT_END_STRING), options.get('line_statement_prefix') or LINE_STATEMENT_PREFIX, options.get('line_comment_prefix') or LINE_COMMENT_PREFIX, getbool(options, 'trim_blocks', TRIM_BLOCKS), getbool(options, 'lstrip_blocks', LSTRIP_BLOCKS), NEWLINE_SEQUENCE, getbool(options, 'keep_trailing_newline', KEEP_TRAILING_NEWLINE), frozenset(extensions), cache_size=0, auto_reload=False ) if getbool(options, 'newstyle_gettext'): environment.newstyle_gettext = True source = fileobj.read().decode(options.get('encoding', 'utf-8')) try: node = environment.parse(source) tokens = list(environment.lex(environment.preprocess(source))) except TemplateSyntaxError as e: if not silent: raise # skip templates with syntax errors return finder = _CommentFinder(tokens, comment_tags) for lineno, func, message in extract_from_ast(node, keywords): yield lineno, func, message, finder.find_comments(lineno)
def maybe_import_string(val): if isinstance(val, basestring): return import_string(val.strip()) return val
"""Base application, run this to start the backend.""" import os from flask import Flask from jinja2.utils import import_string from src import auth, generate_sudoku, static, score_boards from src.models import DB APP = Flask(__name__) try: if os.environ['ENV'] == 'prod': APP.config.from_object(import_string('config.ProductionConfig')) elif os.environ['ENV'] == "test": APP.config.from_object(import_string('config.TestingConfig')) elif os.environ['ENV'] == "staging": APP.config.from_object(import_string('config.StagingConfig')) else: APP.config.from_object(import_string('config.DevelopmentConfig')) except KeyError: APP.config.from_object(import_string('config.DevelopmentConfig')) APP.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False APP.register_blueprint(auth.BP) APP.register_blueprint(generate_sudoku.BP) APP.register_blueprint(score_boards.BP) APP.register_blueprint(static.BP) DB.init_app(APP)
print('No previous compressed files found in {output_dir}' .format(output_dir=env.compressor_output_dir)) template_dirs = [os.path.join(app.root_path, x) for x in get_template_dirs(app)] print('Compressing static assets into {output_dir}' .format(output_dir=env.compressor_output_dir)) compressor = env.extensions['jac.extension.CompressorExtension'].compressor compressor.offline_compress(env, template_dirs) print('Finished offline-compressing static assets.') return 0 if __name__ == '__main__': if len(sys.argv) <= 1: print('You have to specify the app i.e. my_module:create_app or my_module:app', file=sys.stderr) exit(1) try: from flask import Flask except ImportError: print('Make sure you have flask installed to run this script\n\n', file=sys.stderr) raise app_factory = import_string(sys.argv[1]) app = app_factory() if callable(app_factory) and not isinstance(app_factory, Flask) else app_factory with app.app_context(): sys.exit(offline_compile(app))
def __init__(self, params): self.context_processors = [ import_string(p) for p in params['OPTIONS'].pop('context_processors', []) ] super(Jinja2Backend, self).__init__(params)
def has_attr(obj_path: str, attr: str) -> bool: # https://jinja.palletsprojects.com/en/3.0.x/api/#custom-tests obj = import_string(obj_path) return hasattr(obj, attr)
os.path.join(app.root_path, x) for x in get_template_dirs(app) ] print('Compressing static assets into {output_dir}'.format( output_dir=env.compressor_output_dir)) compressor = env.extensions['jac.extension.CompressorExtension'].compressor compressor.offline_compress(env, template_dirs) print('Finished offline-compressing static assets.') return 0 if __name__ == '__main__': if len(sys.argv) <= 1: print( 'You have to specify the app i.e. my_module:create_app or my_module:app', file=sys.stderr) exit(1) try: from flask import Flask except ImportError: print('Make sure you have flask installed to run this script\n\n', file=sys.stderr) raise app_factory = import_string(sys.argv[1]) app = app_factory() if callable(app_factory) and not isinstance( app_factory, Flask) else app_factory sys.exit(offline_compile(app))