def profile_execute(p_id):
data = Profile().find_by_pk(p_id)
source = data['source']
destination = data['destination']
data = data['profile']
split = int(data.get('split_size') or 0)
""" Dumping from Source """
SourceAct = import_string(source.get('provider') + '.model.SourceAct')
src_act = SourceAct(**source)
file_name = src_act.dump_zipped()
""" Output file name """
dt_utc = datetime.utcnow().strftime('%Y_%m_%d_%H-%M-%S')
out = 'wb_' + functions.clean_str(data['title']) + dt_utc + functions.ext_file(file_name)
if split > 0:
cmd = "split -b %sm %s /tmp/%s" % (split, file_name, out)
subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
""" Executing destination part """
DestinationAct = import_string(destination.get('provider') + '.model.DestinationAct')
dst_act = DestinationAct(**destination)
if split == 0:
dst_act.upload_file(file_name, out)
elif split > 0:
dst_act.mkdir(dt_utc)
dst_act.cd(dt_utc)
for f in os.listdir('/tmp'):
if f.startswith(out):
dst_act.upload_file('/tmp/%s' % f, f)
os.unlink(file_name)
return data
def configure_template_filters(app):
"""Configure filters and tags for jinja"""
app.jinja_env.filters['nl2br'] = import_string('utils.templates.nl2br')
app.jinja_env.filters['dateformat'] = import_string('utils.templates.dateformat')
app.jinja_env.filters['timeformat'] = import_string('utils.templates.timeformat')
app.jinja_env.filters['datetimeformat'] = import_string('utils.templates.datetimeformat')
def load(self):
"""Load all the installed packages.
"""
if self.loaded:
return
from kalapy.web.package import Package
self.lock.acquire()
try:
for package in settings.INSTALLED_PACKAGES:
if package in self.packages:
continue
logger.info(' * Loading package: %s' % package)
if package not in sys.modules:
import_string(package)
self.packages[package] = Package(package)
self.load_modules(package, 'models')
self.load_modules(package, 'views')
self.loaded = True
finally:
self.lock.release()
def load(self):
"""Load all the installed packages.
"""
if self.loaded:
return
from kalapy.web.package import Package
self.lock.acquire()
try:
for package in settings.INSTALLED_PACKAGES:
if package in self.packages:
continue
logger.info(' * Loading package: %s' % package)
if package not in sys.modules:
import_string(package)
self.packages[package] = Package(package)
self.load_modules(package, 'models')
self.load_modules(package, 'views')
self.loaded = True
finally:
self.lock.release()
def set_blueprints(app, blueprints):
"""
Registers blueprints with the app.
"""
# Register blueprints.
for blueprint in blueprints:
url_prefix = None
if len(blueprint) == 2:
blueprint, url_prefix = blueprint
blueprint_object = import_string('%s:BLUEPRINT' % blueprint, silent=True)
blueprint_name, blueprint_import_name = blueprint.split('.')[-1], blueprint
if not blueprint_object:
options = dict(static_folder='static', template_folder='templates')
blueprint_object = Blueprint(blueprint_name, blueprint_import_name, **options)
blueprint_routes = import_string('%s.urls:routes' % blueprint_import_name, silent=True)
if blueprint_routes:
urls.set_urls(blueprint_object, blueprint_routes)
# Other initializations.
for fn, values in [(set_before_handlers, import_string('%s:BEFORE_REQUESTS' % blueprint, silent=True)),
(set_before_app_handlers, import_string('%s:BEFORE_APP_REQUESTS' % blueprint, silent=True)),
(set_after_handlers, import_string('%s:AFTER_REQUESTS' % blueprint, silent=True)),
(set_after_app_handlers, import_string('%s:AFTER_APP_REQUESTS' % blueprint, silent=True)),
(set_context_processors, import_string('%s:CONTEXT_PROCESSORS' % blueprint, silent=True)),
(set_app_context_processors, import_string('%s:APP_CONTEXT_PROCESSORS' % blueprint, silent=True)),
(set_error_handlers, import_string('%s:ERROR_HANDLERS' % blueprint, silent=True)),
(set_app_error_handlers, import_string('%s:APP_ERROR_HANDLERS' % blueprint, silent=True))]:
if values:
fn(blueprint_object, values)
# Can be mounted at specific prefix.
if url_prefix:
app.register_blueprint(blueprint_object, url_prefix=url_prefix)
else:
app.register_blueprint(blueprint_object)
def db_create_models():
"Creates database tables."
# db_createall doesn't work if the models aren't imported
import_string('models', silent=True)
for blueprint_name, blueprint in app.blueprints.iteritems():
import_string('%s.models' % blueprint.import_name, silent=True)
db.create_all()
def db_dropall():
"Drops all database tables"
# db_dropall doesn't work if the models aren't imported
import_string('models', silent=True)
for blueprint_name, blueprint in app.blueprints.iteritems():
import_string('%s.models' % blueprint.import_name, silent=True)
db.drop_all()
def get_view(endpoint):
try:
return import_string('catonmat.views.' + endpoint)
except (ImportError, AttributeError):
try:
return import_string(endpoint)
except (ImportError, AttributeError):
raise RuntimeError('Could not locate view for %r' % endpoint)
def build_suite(name):
"""Build test suite for the given name. A name can be either a package name
or a fully qualified name of the test class or a specific test method within
a package prefixed with ``package_name:``.
For example:
>>> build_suite('hello')
>>> build_suite('hello:HelloTest')
>>> build_suite('hello:HelloTest.test_hello')
>>> build_suite('foo:foo.FooTest')
>>> build_suite('foo:bar.BarTest')
:returns:
an instance of `TestSuite`
"""
try:
package, test = name.split(':')
except:
package, test = name, None
test_module = '%s.%s' % (package, TEST_MODULE)
test_fullname = '%s.%s' % (test_module, test) if test else test_module
suite = unittest.TestSuite()
match = re.match('(.*?)\.(test_\w+)$', test_fullname)
if match:
try:
TestClass = import_string(match.group(1))
except ImportError:
raise ImportError(match.group(1))
suite.addTest(TestClass(match.group(2)))
elif test:
try:
TestClass = import_string(test_fullname)
except AttributeError:
raise AttributeError(test_fullname)
if isinstance(TestClass, unittest.TestCase.__class__):
suite.addTest(unittest.TestLoader().loadTestsFromTestCase(TestClass))
else:
suite.addTest(unittest.defaultTestLoader.loadTestsFromModule(TestClass))
else:
try:
test_modules = list(find_modules(test_module))
except ValueError:
test_modules = [test_module]
for module in map(import_string, test_modules):
suite.addTest(unittest.defaultTestLoader.loadTestsFromModule(module))
return suite
def get_view(endpoint):
"""Returns the view for the endpoint. It will cache both positive and
negative hits, so never pass untrusted values to it. If a view does
not exist, `None` is returned.
"""
view = _resolved_views.get(endpoint)
if view is not None:
return view
try:
view = import_string('solace.views.' + endpoint)
except (ImportError, AttributeError):
view = import_string(endpoint, silent=True)
_resolved_views[endpoint] = view
return view
def get_view(endpoint):
"""Returns the view for the endpoint. It will cache both positive and
negative hits, so never pass untrusted values to it. If a view does
not exist, `None` is returned.
"""
view = _resolved_views.get(endpoint)
if view is not None:
return view
try:
view = import_string('rater.views.' + endpoint)
except (ImportError, AttributeError):
view = import_string(endpoint, silent=True)
_resolved_views[endpoint] = view
return view
def configure_blueprints(app, blueprints):
blueprints_list = []
packages_list = []
for name in blueprints:
blueprint = import_string(name)
blueprints_list.append(blueprint)
package = import_string(blueprint.import_name)
packages_list.append(package)
for package in list(set(packages_list)):
__import__('%s.views' % package.__name__)
for blueprint in list(set(blueprints_list)):
app.register_blueprint(blueprint)
def init_app(self, app):
app.config.setdefault('MSEARCH_BACKEND', 'simple')
msearch_backend = app.config['MSEARCH_BACKEND']
if msearch_backend == 'simple':
backend = import_string(
"flask_msearch.simple_backend.SimpleSearch")
elif msearch_backend == 'whoosh':
backend = import_string(
"flask_msearch.whoosh_backend.WhooshSearch")
elif msearch_backend == 'elasticsearch':
backend = import_string(
"flask_msearch.elasticsearch_backend.ElasticSearch")
else:
raise ValueError('backends {} not exists.'.format(msearch_backend))
self._backend = backend(app, self.db, self.analyzer)
def get_auth_system():
"""Return the auth system."""
global _auth_system
with _auth_select_lock:
if _auth_system is None:
_auth_system = import_string(settings.AUTH_SYSTEM)()
return _auth_system
def __register_blueprint(app, blueprint):
path = ""
name = ""
url_prefix = None
if type(blueprint) == "":
path = blueprint
name = "bp_" + blueprint.split(".")[-1]
else:
path = str(blueprint[0])
if len(blueprint) >= 2:
name = str(blueprint[1])
if len(blueprint) >= 3:
url_prefix = str(blueprint[2])
try:
package = import_string(path + ".views")
except:
raise
bp = getattr(package, name, None)
if not bp:
app.logger.error("import blueprint %s from %s failed!\n" %
(name, package + ".views"))
raise
if url_prefix:
if not url_prefix.startswith("/"):
url_prefix = "/" + url_prefix
app.register_blueprint(bp, url_prefix=url_prefix)
else:
app.register_blueprint(bp)
def add_objtypes(objects, force=False):
"""Add a list of MIME types."""
objs = []
for obj in objects:
name = NotGiven
doc = NotGiven
if isinstance(obj, (list, tuple)):
if len(obj) > 2:
doc = obj[2]
name = obj[1]
obj = obj[0]
if isinstance(obj, string_types):
obj = import_string(obj)
if name is NotGiven:
name = getattr(obj, 'NAME', name)
if doc is NotGiven:
doc = getattr(obj, 'DOC', doc)
objs.append((obj, name, doc))
db.create_all()
try:
root = root_site.add_default_permissions
except NoData:
return
for obj, name, doc in objs:
obj = ObjType.get(obj) # will create the record
_upd(obj, (('name', name), ('doc', doc)), force=force)
if obj._is_new or force:
root(obj)
def find_related_modules(package, related_name_re='.+',
ignore_exceptions=False):
"""Find matching modules using a package and a module name pattern."""
warnings.warn('find_related_modules has been deprecated.',
DeprecationWarning)
package_elements = package.rsplit(".", 1)
try:
if len(package_elements) == 2:
pkg = __import__(package_elements[0], globals(), locals(), [
package_elements[1]])
pkg = getattr(pkg, package_elements[1])
else:
pkg = __import__(package_elements[0], globals(), locals(), [])
pkg_path = pkg.__path__
except AttributeError:
return []
# Find all modules named according to related_name
p = re.compile(related_name_re)
modules = []
for name in find_modules(package, include_packages=True):
if p.match(name.split('.')[-1]):
try:
modules.append(import_string(name, silent=ignore_exceptions))
except Exception as e:
if not ignore_exceptions:
raise e
return modules
def get_auth_system():
"""Return the auth system."""
global _auth_system
with _auth_select_lock:
if _auth_system is None:
_auth_system = import_string(settings.AUTH_SYSTEM)()
return _auth_system
def i18n_store_class(self):
"""Returns the configured auth store class.
:returns:
An auth store class.
"""
return import_string(self.config["tipfy"]["i18n_store_class"])
def load_cache(self):
"""
Load the cache and assign the Cache interface to
"""
BackendClass = import_string(self.cache_type)
if self.cache_type == 'werkzeug.contrib.cache.NullCache':
self.cache = BackendClass(self.cache_default_timeout)
elif self.cache_type == 'werkzeug.contrib.cache.SimpleCache':
self.cache = BackendClass(
self.cache_threshold, self.cache_default_timeout)
elif self.cache_type == 'werkzeug.contrib.cache.MemcachedCache':
self.cache = BackendClass(
self.cache_memcached_servers,
self.cache_default_timeout,
self.cache_key_prefix)
elif self.cache_type == 'werkzeug.contrib.cache.GAEMemcachedCache':
self.cache = BackendClass(
self.cache_default_timeout,
self.cache_key_prefix)
elif self.cache_type == 'werkzeug.contrib.cache.FileSystemCache':
self.cache = BackendClass(
self.cache_dir,
self.cache_threshold,
self.cache_default_timeout)
else:
self.cache = BackendClass(**self.cache_init_kwargs)
def __register_blueprint(app, blueprint):
path = ""
name = ""
url_prefix = None
if type(blueprint) == "":
path = blueprint
name = "bp_" + blueprint.split(".")[-1]
else:
path = str(blueprint[0])
if len(blueprint) >= 2:
name = str(blueprint[1])
if len(blueprint) >= 3:
url_prefix = str(blueprint[2])
try:
package = import_string(path+".views")
except:
raise
bp = getattr(package, name, None)
if not bp:
app.logger.error("import blueprint %s from %s failed!\n" %(name, package+".views"))
raise
if url_prefix:
if not url_prefix.startswith("/"):
url_prefix = "/" + url_prefix
app.register_blueprint(bp, url_prefix=url_prefix)
else:
app.register_blueprint(bp)
def init_app(self, app):
config = app.config.get_namespace(self.ns)
conn_params = config.get('conn_params', {})
self.database = db_url.connect(config['db_url'], **conn_params)
self.model_class = import_string(
config.get('model', 'peeweext.model.Model'))
self._register_handlers(app)
def obj_or_import_string(value, default=None):
"""Import string or return object."""
if isinstance(value, string_types):
return import_string(value)
elif value:
return value
return default
def __init__(self):
engine = import_string(
'kalapy.contrib.sessions.engines.%s' % settings.SESSION_ENGINE)
self.store = engine.Store()
opts = settings.SESSION_COOKIE
self.cookie_name = opts.get('name', 'session_id')
self.cookie_age = opts.get('age', 0)
def __init__(self, result):
self.url = result['url']
self.title_text = result['title']
self.title = highlight_all(result, 'title')
cls = import_string(result['type'])
self.kind = cls.search_document_kind
self.description = cls.describe_search_result(result)
def session_store_class(self):
"""Returns the configured session store class.
:returns:
A session store class.
"""
return import_string(self.config['tipfy']['session_store_class'])
def dispatch(self, request):
"""Dispatches a request. This instantiates and calls a
:class:`tipfy.RequestHandler` based on the matched :class:`Rule`.
:param request:
A :class:`tipfy.Request` instance.
:param match:
A tuple ``(rule, rule_args)`` with the matched rule and rule
arguments.
:param method:
A method to be used instead of using the request or handler method.
:returns:
A :class:`tipfy.Response` instance.
"""
rule, rule_args = self.match(request)
handler = rule.handler
if isinstance(handler, basestring):
if handler not in self.handlers:
self.handlers[handler] = import_string(handler)
rule.handler = handler = self.handlers[handler]
rv = local.current_handler = handler(request)
if not isinstance(rv, BaseResponse) and hasattr(rv, '__call__'):
# If it is a callable but not a response, we call it again.
rv = rv()
return rv
def find_related_modules(package,
related_name_re='.+',
ignore_exceptions=False):
"""Given a package name and a module name pattern, tries to find matching
modules."""
package_elements = package.rsplit(".", 1)
try:
if len(package_elements) == 2:
pkg = __import__(package_elements[0], globals(), locals(),
[package_elements[1]])
pkg = getattr(pkg, package_elements[1])
else:
pkg = __import__(package_elements[0], globals(), locals(), [])
pkg_path = pkg.__path__
except AttributeError:
return []
# Find all modules named according to related_name
p = re.compile(related_name_re)
modules = []
for name in find_modules(package, include_packages=True):
if p.match(name.split('.')[-1]):
try:
modules.append(import_string(name, silent=ignore_exceptions))
except Exception as e:
if not ignore_exceptions:
raise e
return modules
def __init__(self, result):
self.url = result['url']
self.title_text = result['title']
self.title = highlight_all(result, 'title')
cls = import_string(result['type'])
self.kind = cls.search_document_kind
self.description = cls.describe_search_result(result)
def obj_or_import_string(value, default=None):
"""Import string or return object."""
if isinstance(value, string_types):
return import_string(value)
elif value:
return value
return default
def i18n_store_class(self):
"""Returns the configured auth store class.
:returns:
An auth store class.
"""
return import_string(self.config['tipfy']['i18n_store_class'])
def session_store_class(self):
"""Returns the configured session store class.
:returns:
A session store class.
"""
return import_string(self.config["tipfy"]["session_store_class"])
def session_store_class(self):
"""Returns the configured session store class.
:returns:
A session store class.
"""
return import_string(self.config['tipfy']['session_store_class'])
def i18n_store_class(self):
"""Returns the configured i18n store class.
:returns:
An i18n store class.
"""
return import_string(self.config['tipfy']['i18n_store_class'])
def auth_user_model(self):
"""Returns the configured user model.
:returns:
A :class:`tipfy.ext.auth.model.User` class.
"""
return import_string(self.app.get_config(__name__, 'user_model'))
def _load(Obj, lister, force=False):
for obj in lister:
name = NotGiven
doc = NotGiven
if isinstance(obj, (list, tuple)):
if len(obj) > 2:
doc = obj[2]
name = obj[1]
obj = obj[0]
if isinstance(obj, string_types):
obj = import_string(obj)
if name is NotGiven:
name = getattr(obj, 'NAME', name)
if doc is NotGiven:
doc = getattr(obj, 'DOC', doc)
path = obj.__module__ + '.' + obj.__name__
try:
obj = Obj.q.get_by(path=path)
except NoData:
if name is NotGiven:
name = path
obj = Obj.new(name=name, path=path)
else:
_upd(obj, (('name', name), ('doc', doc)), force=force)
add_vars(getattr(obj.mod, 'VAR', ()), obj, force=force)
add_templates(getattr(obj.mod, 'TEMPLATE', ()),
parent=obj,
force=force)
def view(self):
view = import_string(self.name)
if isinstance(view, (object, )):
assert self.options.get('endpoint') is not None
endpoint = self.options.pop('endpoint')
view = view.as_view(endpoint)
return view
def auth_store_class(self):
"""Returns the configured auth store class.
:returns:
An auth store class.
"""
return import_string(self.config['tipfy']['auth_store_class'])
def _set_cache(self, app, config):
import_me = config['CACHE_TYPE']
if '.' not in import_me:
from . import backends
try:
cache_obj = getattr(backends, import_me)
except AttributeError:
raise ImportError("%s is not a valid FlaskCache backend" %
(import_me))
else:
cache_obj = import_string(import_me)
cache_args = config['CACHE_ARGS'][:]
cache_options = {'default_timeout': config['CACHE_DEFAULT_TIMEOUT']}
if config['CACHE_OPTIONS']:
cache_options.update(config['CACHE_OPTIONS'])
if not hasattr(app, 'extensions'):
app.extensions = {}
app.extensions.setdefault('cache', {})
app.extensions['cache'][self] = cache_obj(app, config, cache_args,
cache_options)
def create_app(config_name):
app = flask.Flask(__name__, instance_relative_config=1)
app.config.from_object(config_name)
app.config.from_pyfile("config.py")
for name in extensions:
extension = import_string(name)
extension.init_app(app)
for name in blueprints:
blueprint = import_string(name)
app.register_blueprint(blueprint)
return app
def __init__(self):
engine = import_string('kalapy.contrib.sessions.engines.%s' %
settings.SESSION_ENGINE)
self.store = engine.Store()
opts = settings.SESSION_COOKIE
self.cookie_name = opts.get('name', 'session_id')
self.cookie_age = opts.get('age', 0)
def cmd():
"""
Help to run the command line
:return:
"""
global asm_app, app_dir
asmpyfile = os.path.join(os.path.join(CWD, ENTRY_PY))
if os.path.isfile(asmpyfile):
cwd_to_sys_path()
entry = import_string(ENTRY_PY.replace('.py', ''))
asm_app = entry.app
app_dir = CWD
cli()
return
else:
header()
if len(sys.argv) == 1 or (len(sys.argv) > 1
and sys.argv[1] != 'gen:init'):
print("Error: %s is not setup yet" % about.__title__)
print("missing file '%s' in %s" % (ENTRY_PY, CWD))
print("Run %s in this directory to initialize" %
bold("asm gen:init"))
print('_' * 80)
print("")
elif len(sys.argv) == 1 or (len(sys.argv) > 1
and sys.argv[1] == 'gen:init'):
cli()
def __init__(self):
#: If application is runing in debug mode.
self.debug = settings.DEBUG
# Initialize logging.
init_logger()
# Initialize the object pool
pool.load()
#: List of all the registered middlewares (settings.MIDDLEWARE_CLASSES)
self.middlewares = [
import_string(s)() for s in settings.MIDDLEWARE_CLASSES
]
# static data middleware
self.dispatch = StaticMiddleware.from_paths(
self.dispatch, {
'/static': os.path.join(settings.PROJECT_DIR, 'static'),
}, pool.get_static_paths(), settings.STATIC_LINKS)
pool.url_map.add(
Rule('/static/<filename>',
endpoint='static',
methods=('GET', ),
build_only=True))
#: The jinja2 environment
self.jinja_env = self._create_jinja_env(pool.get_template_paths())
def __init__(self):
#: If application is runing in debug mode.
self.debug = settings.DEBUG
# Initialize logging.
init_logger()
# Initialize the object pool
pool.load()
#: List of all the registered middlewares (settings.MIDDLEWARE_CLASSES)
self.middlewares = [import_string(s)() for s in settings.MIDDLEWARE_CLASSES]
# static data middleware
self.dispatch = StaticMiddleware.from_paths(self.dispatch, {
'/static': os.path.join(settings.PROJECT_DIR, 'static'),
}, pool.get_static_paths(), settings.STATIC_LINKS)
pool.url_map.add(
Rule('/static/<filename>',
endpoint='static', methods=('GET',), build_only=True))
#: The jinja2 environment
self.jinja_env = self._create_jinja_env(pool.get_template_paths())
def _set_cache(self, app, config):
import_me = config['CACHE_TYPE']
if '.' not in import_me:
from . import backends
try:
cache_obj = getattr(backends, import_me)
except AttributeError:
raise ImportError("%s is not a valid FlaskCache backend" % (
import_me))
else:
cache_obj = import_string(import_me)
cache_args = config['CACHE_ARGS'][:]
cache_options = {'default_timeout': config['CACHE_DEFAULT_TIMEOUT']}
if config['CACHE_OPTIONS']:
cache_options.update(config['CACHE_OPTIONS'])
if not hasattr(app, 'extensions'):
app.extensions = {}
app.extensions.setdefault('cache', {})
app.extensions['cache'][self] = cache_obj(
app, config, cache_args, cache_options)
def cmd():
"""
Help to run the command line
:return:
"""
global asm_app, app_dir
script_name = sys.argv[0].split('/')[-1]
is_admin = script_name == 'asm-admin'
asmpyfile = os.path.join(os.path.join(CWD, ENTRY_PY))
if os.path.isfile(asmpyfile):
cwd_to_sys_path()
entry = import_string(ENTRY_PY.replace('.py', ''))
asm_app = entry.app
app_dir = CWD
cli_admin() if is_admin is True else cli()
return
else:
header()
if len(sys.argv) == 1 or (len(sys.argv) > 1 and sys.argv[1] != 'init'):
print("Error: %s is not setup yet" % about.__title__)
print("Run %s in the directory you want to create it" % bold("asm-admin init"))
print("Missing file '%s' in %s" % (ENTRY_PY, CWD))
print('_' * 80)
print("")
if is_admin is True:
cli_admin()
def from_object(self, obj):
"""Updates the values from the given object. An object can be of one
of the following two types:
- a string: in this case the object with that name will be imported
- an actual object reference: that object is used directly
Objects are usually either modules or classes.
Just the uppercase variables in that object are stored in the config
after lowercasing. Example usage::
app.config.from_object('yourapplication.default_config')
from yourapplication import default_config
app.config.from_object(default_config)
You should not use this function to load the actual configuration but
rather configuration defaults. The actual config should be loaded
with :meth:`from_pyfile` and ideally from a location not within the
package because the package might be installed system wide.
:param obj: an import name or object
"""
if isinstance(obj, basestring):
obj = import_string(obj)
for key in dir(obj):
if key.isupper():
self[key] = getattr(obj, key)
def __getitem__(self, module):
"""Returns the configuration for a module. If it is not already
set, loads a ``default_config`` variable from the given module and
updates the configuration with those default values
Every module that allows some kind of configuration sets a
``default_config`` global variable that is loaded by this function,
cached and used in case the requested configuration was not defined
by the user.
:param module:
The module name.
:returns:
A configuration value.
"""
if module not in self.loaded:
# Load default configuration and update config.
values = import_string(module + '.default_config', silent=True)
if values:
self.setdefault(module, values)
self.loaded.append(module)
try:
return dict.__getitem__(self, module)
except KeyError:
raise KeyError('Module %r is not configured.' % module)
def load_middleware(self, classes):
"""Returns a dictionary of middleware instance methods for a list of
classes.
:param classes:
A list of middleware classes.
:return:
A dictionary with middleware instance methods.
"""
res = {}
for cls in classes:
if isinstance(cls, basestring):
id = cls
else:
id = cls.__module__ + '.' + cls.__name__
if id not in self.methods:
if isinstance(cls, basestring):
cls = import_string(cls)
obj = cls()
self.instances[id] = obj
self.methods[id] = [getattr(obj, n, None) for n in self.names]
for name, method in zip(self.names, self.methods[id]):
if method:
res.setdefault(name, []).append(method)
for name in self.reverse_names:
if name in res:
res[name].reverse()
return res
def from_object(self, obj):
"""Updates the values from the given object. An object can be of one
of the following two types:
- a string: in this case the object with that name will be imported
- an actual object reference: that object is used directly
Objects are usually either modules or classes.
Just the uppercase variables in that object are stored in the config
after lowercasing. Example usage::
app.config.from_object('yourapplication.default_config')
from yourapplication import default_config
app.config.from_object(default_config)
You should not use this function to load the actual configuration but
rather configuration defaults. The actual config should be loaded
with :meth:`from_pyfile` and ideally from a location not within the
package because the package might be installed system wide.
:param obj: an import name or object
"""
if isinstance(obj, basestring):
obj = import_string(obj)
for key in dir(obj):
if key.isupper():
self[key] = getattr(obj, key)
def _load(Obj,lister, force=False):
for obj in lister:
name = NotGiven
doc = NotGiven
if isinstance(obj,(list,tuple)):
if len(obj) > 2:
doc = obj[2]
name = obj[1]
obj = obj[0]
if isinstance(obj,string_types):
obj = import_string(obj)
if name is NotGiven:
name = getattr(obj,'NAME',name)
if doc is NotGiven:
doc = getattr(obj,'DOC',doc)
path = obj.__module__+'.'+obj.__name__
try:
obj = Obj.q.get_by(path=path)
except NoData:
if name is NotGiven:
name = path
obj = Obj.new(name=name, path=path)
else:
_upd(obj,(('name',name),('doc',doc)), force=force)
add_vars(getattr(obj.mod,'VAR',()),obj, force=force)
add_templates(getattr(obj.mod,'TEMPLATE',()), parent=obj, force=force)
def add_objtypes(objects, force=False):
"""Add a list of MIME types."""
objs = []
for obj in objects:
name = NotGiven
doc = NotGiven
if isinstance(obj,(list,tuple)):
if len(obj) > 2:
doc = obj[2]
name = obj[1]
obj = obj[0]
if isinstance(obj,string_types):
obj = import_string(obj)
if name is NotGiven:
name = getattr(obj,'NAME',name)
if doc is NotGiven:
doc = getattr(obj,'DOC',doc)
objs.append((obj,name,doc))
db.create_all()
try:
root = root_site.add_default_permissions
except NoData:
return
for obj,name,doc in objs:
obj = ObjType.get(obj) # will create the record
_upd(obj,(('name',name),('doc',doc)), force=force)
if obj._is_new or force:
root(obj)
def dispatch(self, request):
"""Dispatches a request. This instantiates and calls a
:class:`tipfy.RequestHandler` based on the matched :class:`Rule`.
:param request:
A :class:`tipfy.app.Request` instance.
:param match:
A tuple ``(rule, rule_args)`` with the matched rule and rule
arguments.
:param method:
A method to be used instead of using the request or handler method.
:returns:
A :class:`tipfy.app.Response` instance.
"""
rule, rule_args = self.match(request)
handler = rule.handler
if isinstance(handler, basestring):
if handler not in self.handlers:
self.handlers[handler] = import_string(handler)
rule.handler = handler = self.handlers[handler]
rv = local.current_handler = handler(request)
if not isinstance(rv, BaseResponse) and hasattr(rv, '__call__'):
# If it is a callable but not a response, we call it again.
rv = rv()
return rv
def load_cache(self):
"""
Load the cache and assign the Cache interface to
"""
BackendClass = import_string(self.cache_type)
if self.cache_type == 'werkzeug.contrib.cache.NullCache':
self.cache = BackendClass(self.cache_default_timeout)
elif self.cache_type == 'werkzeug.contrib.cache.SimpleCache':
self.cache = BackendClass(
self.cache_threshold, self.cache_default_timeout)
elif self.cache_type == 'werkzeug.contrib.cache.MemcachedCache':
self.cache = BackendClass(
self.cache_memcached_servers,
self.cache_default_timeout,
self.cache_key_prefix)
elif self.cache_type == 'werkzeug.contrib.cache.GAEMemcachedCache':
self.cache = BackendClass(
self.cache_default_timeout,
self.cache_key_prefix)
elif self.cache_type == 'werkzeug.contrib.cache.FileSystemCache':
self.cache = BackendClass(
self.cache_dir,
self.cache_threshold,
self.cache_default_timeout)
else:
self.cache = BackendClass(**self.cache_init_kwargs)
def register_blueprints(app: flask.Flask) -> None:
# Every sub-view needs to be imported to populate the blueprint.
# If this is not done, we will have empty blueprints.
# If we register every module with the ``bp`` attribute normally,
# we would have a lot of duplicate routes, which Werkzeug doesn't filter.
for name in find_modules('core', recursive=True):
if not name.endswith('conftest'):
import_string(name)
# Now import and register each blueprint. Since each blueprint
# is defined in the package's __init__, we scan packages this time,
# unlike the last.
for name in find_modules('core', include_packages=True):
if not name.endswith('conftest'):
mod = import_string(name)
if hasattr(mod, 'bp'):
app.register_blueprint(mod.bp)
def install_app(self, app):
install_apps = app.config.setdefault('INSTALLED_APPS', [])
for blueprint in install_apps:
kwargs = {}
if isinstance(blueprint, dict):
kwargs = blueprint['kwargs']
blueprint = blueprint['blueprint']
app.register_blueprint(import_string(blueprint), **kwargs)
