本文整理汇总了Python中werkzeug.utils.import_string函数的典型用法代码示例。如果您正苦于以下问题:Python import_string函数的具体用法?Python import_string怎么用?Python import_string使用的例子?那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了import_string函数的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: main
def main(entrypoint, adapter, host, port, debug, level):
if '.' not in sys.path:
sys.path.insert(0, '.')
# Get the API object
api = import_string(entrypoint)
if not isinstance(api, RESTArt):
raise RuntimeError(
'The object specified by entrypoint %r is not an '
'instance of `restart.api.RESTArt`' % str(entrypoint)
)
# Get the adapter class
adapter_class = import_string(adapter)
if not issubclass(adapter_class, Adapter):
raise RuntimeError(
'The class specified by adapter %r is not a subclass '
'of `restart.adapter.Adapter`' % str(adapter)
)
# Change the level of the global logger
from .logging import global_logger
global_logger.setLevel(level)
# Run the API as a service
service = Service(api, adapter_class)
service.run(host, port, debug)
示例2: autodiscover
def autodiscover(self, paths, models=None, module_names=None):
"""
Automatically register all Kibble views under ``path``.
:param paths: The module paths to search under.
:param module_names: A list of module names to match on. e.g. `kibble`
will only attempt to autodiscover `kibble.py` files.
:param models: A list of model kinds (either a ``ndb.Model`` subclass
or a string) (Optional)
"""
from werkzeug.utils import find_modules, import_string
from .base import KibbleMeta
all_models = models is None
models = [
(x._kind() if isinstance(x, ndb.Model) else x)
for x in models or []]
for p in paths:
for mod in find_modules(p, True, True):
# logger.debug("Autodiscover: %s", mod)
if module_names is None \
or mod.rsplit('.', 1)[-1] in module_names:
import_string(mod)
for view in KibbleMeta._autodiscover:
if view.model and (all_models or view.kind() in models):
self.register_view(view)
示例3: try_to_eval
def try_to_eval(string, context={}, **general_context):
"""Take care of evaluating the python expression.
If an exception happens, it tries to import the needed module.
@param string: String to evaluate
@param context: Context needed, in some cases, to evaluate the string
@return: The value of the expression inside string
"""
if not string:
return None
res = None
imports = []
general_context.update(context)
simple = False
while True:
try:
# kwalitee: disable=eval
res = eval(string, globals().update(general_context), locals())
except NameError as err:
#Try first to import using werkzeug import_string
try:
from werkzeug.utils import import_string
if "." in string:
part = string.split('.')[0]
import_string(part)
for i in string.split('.')[1:]:
part += '.' + i
import_string(part)
continue
else:
simple = True
except:
pass
import_name = str(err).split("'")[1]
if import_name not in imports:
if import_name in context:
globals()[import_name] = context[import_name]
else:
globals()[import_name] = __import__(import_name)
imports.append(import_name)
continue
elif simple:
import_name = str(err).split("'")[0]
if import_name in context:
globals()[import_name] = context[import_name]
else:
globals()[import_name] = __import__(import_name)
imports.append(import_name)
continue
raise ImportError("Can't import the needed module to evaluate %s"
(string, ))
import os
if isinstance(res, type(os)):
raise ImportError
return res
示例4: import_module_from_packages
def import_module_from_packages(name, app=None, packages=None, silent=False):
if packages is None:
if app is None and has_app_context():
app = current_app
if app is None:
raise Exception(
'Working outside application context or provide app'
)
#FIXME
packages = app.config.get('PACKAGES', [])
for package in packages:
if package.endswith('.*'):
for module in find_modules(package[:-2], include_packages=True):
try:
yield import_string(module + '.' + name, silent)
except ImportError:
pass
except Exception as e:
import traceback
traceback.print_exc()
app.logger.error('Could not import: "%s.%s: %s',
module, name, str(e))
pass
continue
try:
yield import_string(package + '.' + name, silent)
except ImportError:
pass
except Exception as e:
import traceback
traceback.print_exc()
app.logger.error('Could not import: "%s.%s: %s',
package, name, str(e))
pass
示例5: create_app
def create_app(config_name):
app = Flask(__name__)
app.config.from_object(config[config_name])
db.init_app(app)
csrf.init_app(app)
bcrypt.init_app(app)
mail.init_app(app)
login_manager.init_app(app)
redis_store.init_app(app)
celery.conf.update(app.config)
models_committed.connect(receive_change, app)
sign_in_manage = {}
sign_in_func = 'account.sign_in'
for path in blueprints:
bp = import_string('sayit.views.' + path[0])
app.register_blueprint(bp, url_prefix=path[1])
sign_in_manage[bp.name] = sign_in_func
for path in jinja_filters:
flt = import_string('sayit.filters:' + path[0])
app.jinja_env.filters[path[1]] = flt
login_manager.blueprint_login_views = sign_in_manage
return app
示例6: serializer
def serializer(metadata_prefix):
"""Return etree_dumper instances."""
metadataFormats = current_app.config['OAISERVER_METADATA_FORMATS']
serializer_ = metadataFormats[metadata_prefix]['serializer']
if isinstance(serializer_, tuple):
return partial(import_string(serializer_[0]), **serializer_[1])
return import_string(serializer_)
示例7: import_module_from_packages
def import_module_from_packages(name, app=None, packages=None, silent=False):
"""Import modules from packages."""
warnings.warn("Use of import_module_from_packages has been deprecated."
" Please use Flask-Registry instead.", DeprecationWarning)
if app is None and has_app_context():
app = current_app
if app is None:
raise Exception(
'Working outside application context or provide app'
)
if packages is None:
packages = app.config.get('PACKAGES', [])
for package in packages:
if package.endswith('.*'):
for module in find_modules(package[:-2], include_packages=True):
try:
yield import_string(module + '.' + name, silent)
except ImportError:
pass
except Exception:
app.logger.exception("could not import %s.%s",
package, name)
continue
try:
yield import_string(package + '.' + name, silent)
except ImportError:
pass
except Exception:
app.logger.exception("could not import %s.%s", package, name)
示例8: _get_search_results
def _get_search_results(self, q):
from flask_cms.app import app
results = {}
searchable_models = app.config.get("SEARCHABLE_MODELS", [])
for model in searchable_models:
model_string = model[0]
model_class = import_string(model_string)
# Only get these columns from db
columns_to_select = model[2]
entities = [import_string("{}.{}".format(model_string, column))
for column in columns_to_select]
# build search condition
searchable_columns = model[1]
column_objs = [import_string("{}.{}".format(model_string, column))
for column in searchable_columns]
search_condition = [obj.like("%{}%".format(q))
for obj in column_objs]
# query model with entities for search condition
model_results = (model_class.query.
with_entities(*entities).
filter(or_(*search_condition)).
params(q=q).all())
if model_results:
results[model_class.__tablename__] = model_results
return results
示例9: _discover_module
def _discover_module(self, pkg):
import_str = pkg + '.' + self.module_name
blacklist = self.app.config.get(
'%s_%s_EXCLUDE' % (self.cfg_var_prefix, self.module_name.upper()),
[]
)
try:
import_string(import_str, silent=self.silent)
except ImportError as e: # pylint: disable=C0103
self._handle_importerror(e, pkg, import_str)
return
except SyntaxError as e:
self._handle_syntaxerror(e, pkg, import_str)
return
for m in find_modules(import_str):
if m in blacklist: # Exclude specific package
continue
try:
module = import_string(m, silent=self.silent)
if module is not None:
self.register(module)
except ImportError as e: # pylint: disable=C0103
self._handle_importerror(e, import_str, m)
except SyntaxError as e:
self._handle_syntaxerror(e, import_str, m)
示例10: test_import_string_attribute_error
def test_import_string_attribute_error():
with pytest.raises(AttributeError) as foo_exc:
utils.import_string('tests.res.foo')
assert 'screw your import' in str(foo_exc)
with pytest.raises(AttributeError) as bar_exc:
utils.import_string('tests.res.bar')
assert 'screw your import' in str(bar_exc)
示例11: __init__
def __init__(self):
# avoid 'no implementation for kind' error.
import_string(settings.AUTH_USER_MODEL)
if not 'kay.sessions.middleware.SessionMiddleware' in \
settings.MIDDLEWARE_CLASSES:
raise ImproperlyConfigured(
"The DatastoreBackend requires session middleware to "
"be installed. Edit your MIDDLEWARE_CLASSES setting to insert "
"'kay.sessions.middleware.SessionMiddleware'.")
示例12: run
def run(*args):
# XXX: Need to import here before manager is run to ensure additional
# commands are registered
for mod in 'account', 'video':
import_string('wonder.romeo.%s.commands' % mod)
if args:
return manager.handle(sys.argv[0], args)
else:
return manager.run()
示例13: test_import_string_attribute_error
def test_import_string_attribute_error(tmpdir, monkeypatch):
monkeypatch.syspath_prepend(str(tmpdir))
tmpdir.join('foo_test.py').write('from bar_test import value')
tmpdir.join('bar_test.py').write('raise AttributeError("screw you!")')
with pytest.raises(AttributeError) as foo_exc:
utils.import_string('foo_test')
assert 'screw you!' in str(foo_exc)
with pytest.raises(AttributeError) as bar_exc:
utils.import_string('bar_test')
assert 'screw you!' in str(bar_exc)
示例14: init_app
def init_app(self, app, elasticsearch=None):
"""Flask application initialization."""
self.init_config(app)
# Configure elasticsearch client.
self._clients[app] = elasticsearch
for autoindex in app.config.get('SEARCH_AUTOINDEX', []):
import_string(autoindex)
app.cli.add_command(index_cmd)
app.extensions['invenio-search'] = self
示例15: init_tasks
def init_tasks(app):
"""
Extracts modules (task types) from global configuration
:param app: Current Flask application instance
:type app: Flask.Flask
:return: Dictionary with instantiated *TaskType objects
:rtype: dict
"""
task_types = {}
loaders = {}
enabled_tasks = app.config.get("ENABLED_TASKS", {})
for plugin, task in enabled_tasks.iteritems():
task_settings = import_string(
"{plugin_name}.settings".format(plugin_name=plugin)
)
plugin_instance = import_string(
"{plugin_name}".format(plugin_name=plugin))
settings = plugin_instance.configure(task_settings)
task_instance = import_string(
"{plugin_name}.models.task_types.{task}".format(
plugin_name=plugin, task=task)
)
static_path = import_string(plugin).__path__[0]
js_name = 'plugin_js_{task}'.format(task=task_instance.type_name)
css_name = 'plugin_css_{task}'.format(task=task_instance.type_name)
if len(task_instance.JS_ASSETS) > 0:
js = Bundle(*map(lambda x: os.path.join(static_path, x),
task_instance.JS_ASSETS),
output="scripts/{name}.js".format(name=js_name),
filters=app.config.get('JS_ASSETS_FILTERS', ''))
app.assets.register(js_name, js)
if len(task_instance.CSS_ASSETS) > 0:
css = Bundle(*map(lambda x: os.path.join(static_path, x),
task_instance.CSS_ASSETS),
output="styles/{name}.css".format(name=css_name),
filters=app.config.get('CSS_ASSETS_FILTERS', ''))
app.assets.register(css_name, css)
loaders[task_instance.type_name] = jinja2.PackageLoader(plugin)
task_types[task_instance.type_name] = task_instance(settings=settings)
app.jinja_loader = jinja2.ChoiceLoader([
app.jinja_loader,
jinja2.PrefixLoader(loaders)])
return task_types