def __call__(self, event):
item = event.target['item']
instantiated = False
raw = None
if isinstance(item, FunctionType):
raw = item
elif not isinstance(item, str):
initialized = item
instantiated = True
else:
with ignored(ImportError, AttributeError):
raw = load_definition_from_string(item)
if not instantiated:
if not raw:
raise NameError(
'Cannot initialize dependency {0}, the module may not exist.'.format(item))
args, kwargs = [], {}
if isinstance(raw, FunctionType):
kwargs['container'] = self.container
init = event.target.get('init', {})
if isinstance(init, dict):
for key, val in init.items():
kwargs[key] = get_param_from_container(val, self.container)
elif isinstance(init, list):
for arg in init:
args.append(get_param_from_container(arg, self.container))
initialized = raw(*args, **kwargs)
return initialized
def wrapper(self, *args, **kwargs):
if not hasattr(self.request, "user"):
self.request.user = None
auth_config = self.container.get("application.config")["auth"]
valid = True
if self.request.user:
# User is already authenticated, redirect to success url
if auto_redirect:
return self.redirect(auth_config["url"]["login_success"])
form_config = auth_config["form"]
if self.request.is_method(method):
# Form has been posted, validate the user
form_class_module = form_class or form_config["class"]
form = imports.load_definition_from_string(form_class_module)()
form.data = self.request
if form.is_valid():
authenticator = self.container.get("auth_authenticator")
username_field = getattr(form, form_config["username"])
password_field = getattr(form, form_config["password"])
user = authenticator.authenticate(username=username_field.value, password=password_field.value)
if user:
self.request.user = user
self.request.session[auth_config["session"]["key"]] = getattr(
user, auth_config["db"]["username_field"]
)
if auto_redirect:
return self.redirect(auth_config["url"]["login_success"])
else:
valid = False
else:
valid = False
if not valid:
self.flash_messages.add(form_config["invalid_message"], "error")
return self.redirect(auth_config["url"]["login"])
return func(self, **kwargs)
def __init__(self, config=None):
"""Initializes the application.
Registers any events that are within the application configuration.
Example:
.. code-block:: python
app = Base()
Events:
Dispatches the INIT.
Args:
config (mixed): See the Base.config properties.
"""
Base.global_app = self
self.config = config or {}
if not self.config.get('exceptions'):
self.exception_class = ApplicationError
else:
self.exception_class = imports.load_definition_from_string(
self.config['exceptions']['class'])
self.register_events()
self.trigger_init_event()
super(Base, self).__init__()
def register_components(self):
"""Register any components specified with the application.
Components can include the following modules:
- dependencies
- events
- models
- routes
- views
Registering a component will merge any configuration settings within
the above modules prior to the application booting.
An example component might look like:
/component
/views
/index.html
/routes.py
/views.py
"""
types = ('dependencies', 'events', 'routes', 'models', 'views')
for component in self.config['components']:
for type_ in types:
with contextmanagers.suppress(Exception):
type_component = imports.load_definition_from_string(
'{}.{}.{}'.format(component, type_, type_))
if type_ == 'dependencies':
self.container.update(type_component)
if not isinstance(type_component, ModuleType):
self._config[type_] = dict_deep_update(
self._config.get(type_, {}), type_component)
self._config['views'][
'renderers']['jinja2']['config']['packages'].append(
(component, 'views'))
def wrapper(self, *args, **kwargs):
provider = self.container.get(DEPENDENCY)
redirect_url = provider.config.get('authenticated_route', redirect)
if self.request.user:
return self.redirect(redirect_url)
form = imports.load_definition_from_string(
form_class)(action=self.request)
form.data = self.request
user = None
if self.request.is_method(method):
if form.is_valid():
user = provider.authenticate(
username=getattr(form, provider.user_model_identifier),
password=form.password)
if user:
if self.request.get['redirect']:
redirect_url = parse.unquote_plus(
self.request.get['redirect'])
if provider.user_meets_requirements(user, requires):
provider.login(user, self.request)
if redirect_callback:
redirect_url = redirect_callback(user)
else:
self.flash_messages.add(
invalid_credentials_message, namespace='error')
redirect_url = form.action
return self.redirect(redirect_url, clear=True)
kwargs['form'] = form
return func(self, **kwargs)
def __init__(self, config=None):
"""Initializes the application.
Registers any events that are within the application configuration.
Example:
.. code-block:: python
app = Base()
Events:
Dispatches the INIT.
Args:
config (mixed): See the Base.config properties.
"""
Base.global_app = self
self.config = config or {}
if 'exceptions' not in self.config:
self.exception_class = ApplicationError
else:
self.exception_class = imports.load_definition_from_string(
self.config['exceptions']['class'])
self.register_events()
self.trigger_init_event()
super(Base, self).__init__()
def wrapper(self, *args, **kwargs):
provider = self.container.get(DEPENDENCY)
redirect_url = provider.config.get('authenticated_route', redirect)
if self.request.user:
return self.redirect(redirect_url)
form = imports.load_definition_from_string(
form_class)(action=self.request)
if self.request.is_method(method):
user = None
namespace = 'error'
message = error_message
form.data = self.request
if form.is_valid():
forgotten_password_token_manager = self.container.get(
'auth_forgotten_password_token_manager')
forgotten_password_token_manager.provider = provider
email_address = getattr(form, provider.config['model']['identifier'])
user = provider.get_user_by_email_address(email_address)
if user:
namespace = 'success'
message = success_message
token = forgotten_password_token_manager.create_token(
user, self.request)
forgotten_password_token_manager.notify_user(
user,
request=self.request,
subject=subject,
template=template,
token=token)
self.flash_messages.add(message, namespace)
return self.redirect(str(self.request.url))
kwargs['form'] = form
return func(self, **kwargs)
def _get_dependency(self, definition):
"""Loads a definition item.
"""
item = definition['item']
if isinstance(item, str):
item = imports.load_definition_from_string(definition['item'])
return item
def __call__(self, event):
item = event.target['item']
instantiated = False
raw = None
if isinstance(item, FunctionType):
raw = item
elif not isinstance(item, str):
initialized = item
instantiated = True
else:
with ignored(ImportError, AttributeError):
raw = load_definition_from_string(item)
if not instantiated:
if not raw:
raise NameError(
'Cannot initialize dependency {0}, the module may not exist.'
.format(item))
args, kwargs = [], {}
if isinstance(raw, FunctionType):
kwargs['container'] = self.container
init = event.target.get('init', {})
if isinstance(init, dict):
for key, val in init.items():
kwargs[key] = get_param_from_container(val, self.container)
elif isinstance(init, list):
for arg in init:
args.append(get_param_from_container(arg, self.container))
initialized = raw(*args, **kwargs)
return initialized
def runserver(self, host, port, noreload):
"""Runs the development server for the current application.
Args:
host: The host to bind to
port: The port to run on
"""
app_dir = os.environ['APP_DIR']
app_module = os.environ['APP_MODULE']
script_dir = os.environ['SCRIPT_DIR']
public_dir = os.environ['PUBLIC_DIR']
os.chdir(app_dir)
app = load_definition_from_string('{0}.app.application'.format(
app_module))
kwargs = {
'app': app,
'script_dir': script_dir,
'public_dir': public_dir,
}
if host:
kwargs['host'] = host
if port:
kwargs['port'] = int(port)
kwargs['noreload'] = True if noreload else False
make_dev_server(**kwargs)
def session(self):
if not self._session:
if not self._session_options:
self._session_options = {}
storage = load_definition_from_string(self._session_class)
session_cookie = self.cookies[COOKIE_KEY]
self._session = storage(id=session_cookie.value, **self._session_options) if session_cookie else storage(**self._session_options)
return self._session
def _process_config(self, config):
if 'serializer_class' in config:
self.serializer_class = imports.load_definition_from_string(
config['serializer_class'])
del config['serializer_class']
if 'encoding' in config:
self.encoding = config['encoding']
del config['encoding']
def _load_metadata(self, metadata):
if isinstance(metadata, str):
try:
return imports.load_definition_from_string(metadata)
except Exception as e:
raise ConsoleError(
'Missing connection metadata for {} ({})'.format(
metadata, e))
def execute(self):
from __main__ import APP_MODULE, APP_DIR, SCRIPT_DIR, PUBLIC_DIR
app = load_definition_from_string(
'{0}.app.application'.format(APP_MODULE))
os.chdir(APP_DIR)
make_dev_server(app,
do_reload=True,
script_dir=SCRIPT_DIR,
public_dir=PUBLIC_DIR)
def __find(self, name):
"""
Attempts to retrieve a definition from the container configuration. If
no definition is found, it will attempt to add the requested dependency
to the container.
"""
definitions = self.definitions
if name not in definitions:
try:
load_definition_from_string(name)
self.add(name, name)
definitions = self.definitions
except:
raise KeyError('Dependency {} does not exist'.format(name))
if 'item' not in definitions[name]:
raise KeyError('item not specified in dependency definition')
definition = definitions[name]
definition['type'] = definition.get('type', 'singleton').lower()
return definition
def __find(self, name):
"""
Attempts to retrieve a definition from the container configuration. If
no definition is found, it will attempt to add the requested dependency
to the container.
"""
definitions = self.definitions
if name not in definitions:
try:
load_definition_from_string(name)
self.add(name, name)
definitions = self.definitions
except:
raise KeyError('Dependency {} does not exist'.format(name))
if 'item' not in definitions[name]:
raise KeyError('item not specified in dependency definition')
definition = definitions[name]
definition['type'] = definition.get('type', 'singleton').lower()
return definition
def session(self):
if not self._session:
if not self._session_options:
self._session_options = {}
storage = load_definition_from_string(self._session_class)
session_cookie = self.cookies[COOKIE_KEY]
self._session = storage(
id=session_cookie.value, **
self._session_options) if session_cookie else storage(
**self._session_options)
return self._session
def __init__(self, config=None):
"""Initializes the container and set some default configuration options.
Args:
dict config: A dict containing the params, definitions and processors.
"""
self.config = dict_deep_update(DEFAULTS, config or {})
self.__instantiated = {}
for event, listeners in self.config['processors'].items():
for processor in listeners:
self.attach_processor(event, load_definition_from_string(processor)())
def session(self):
session_class = self.environ.get('watson.session.class', None)
if session_class and not self._session:
storage = load_definition_from_string(session_class)
options = self.environ['watson.session.options'].copy()
http_cookie = self.environ.get('HTTP_COOKIE', None)
if (http_cookie and '{0}='.format(COOKIE_KEY) in http_cookie):
session_cookie = self.cookies[COOKIE_KEY]
if session_cookie:
options['id'] = session_cookie.value
self._session = storage(**options)
return self._session
def execute(self):
app_dir = os.environ['APP_DIR']
app_module = os.environ['APP_MODULE']
script_dir = os.environ['SCRIPT_DIR']
public_dir = os.environ['PUBLIC_DIR']
os.chdir(app_dir)
app = load_definition_from_string('{0}.app.application'.format(
app_module))
make_dev_server(app,
do_reload=True,
script_dir=script_dir,
public_dir=public_dir)
def commands(self):
"""A list of all commands added to the runner.
Returns:
OrderedDict containing all the commands.
"""
commands = {}
for command in self._commands:
if isinstance(command, str):
command = load_definition_from_string(command)
commands[command.name] = command
return OrderedDict(sorted(commands.items()))
def commands(self):
"""A list of all commands added to the runner.
Returns:
OrderedDict containing all the commands.
"""
commands = {}
for command in self._commands:
if isinstance(command, str):
command = load_definition_from_string(command)
commands[command.cased_name()] = command
return OrderedDict(sorted(commands.items()))
def populate(session, file_name):
total = 0
with open(file_name) as file:
json_data = json.loads(file.read())
with transaction_scope(session) as session:
for item in json_data:
class_ = imports.load_definition_from_string(item['class'])
basic_fields = {k: v for k, v in item['fields'].items() if not isinstance(v, (list, tuple))}
obj = class_(**basic_fields)
total += 1
session.add(obj)
return total
def __init__(self, config=None):
"""Initializes the container and set some default configuration options.
Args:
dict config: A dict containing the params, definitions and processors.
"""
self.config = dict_deep_update(DEFAULTS, config or {})
self.__instantiated = {}
for event, listeners in self.config['processors'].items():
for processor in listeners:
self.attach_processor(event,
load_definition_from_string(processor)())
def __init__(self, config, application, renderer):
"""Application can be any WSGI callable
"""
self.application = application
self.config = config
self.renderer = renderer
self.panels = collections.OrderedDict()
for module, settings in config['panels'].items():
if settings['enabled']:
panel = imports.load_definition_from_string(
module)(settings, renderer, application)
panel.register_listeners()
self.panels[module] = panel
def __init__(self, config, application, renderer):
"""Application can be any WSGI callable
"""
self.application = application
self.config = config
self.renderer = renderer
self.panels = collections.OrderedDict()
for module, settings in config['panels'].items():
if settings['enabled']:
panel = imports.load_definition_from_string(module)(
settings, renderer, application)
panel.register_listeners()
self.panels[module] = panel
def __init__(self, config=None):
"""Initializes the container and set some default configuration options.
Args:
config (dict): The params, definitions and processors.
"""
self.__instantiated__ = {}
self.config = dict_deep_update(DEFAULTS, config or {})
self.__instantiated__ = {}
self._pre_process_event = types.Event(name=PRE_EVENT)
self._post_process_event = types.Event(name=POST_EVENT)
for event, listeners in self.config['processors'].items():
for processor in listeners:
self.attach_processor(
event,
imports.load_definition_from_string(processor)())
def _setup_provider(self, app, provider, config_):
auth_config = app.config['auth']
provider_ = imports.load_definition_from_string(provider)
provider_config = datastructures.dict_deep_update(
auth_config['common'], provider_.defaults)
provider_config = datastructures.dict_deep_update(
provider_config, config_)
config_.update(provider_config)
dependency_config = {
'init': {
'config': lambda container: container.get('application.config')['auth']['providers'][provider],
'session': lambda container: container.get('sqlalchemy_session_{0}'.format(container.get('application.config')['auth']['providers'][provider]['session'])),
}
}
dependency_config.update(app.config['dependencies'][
'definitions'].get(provider, {}))
app.container.add_definition(provider, dependency_config)
def create_user(self, username, password, auth_provider, database):
"""Create a new user.
Args:
username: The username of the user
password: The password of the user
database: The name of the database session.
"""
session = ensure_session_in_container(self.container, database)
provider = self.container.get(auth_provider)
user_model = provider.config['model']['class']
model_class = imports.load_definition_from_string(user_model)
with transaction_scope(session) as session:
user = model_class()
setattr(user, provider.config['model']['identifier'], username)
setattr(user, 'password', password)
session.add(user)
self.write('Created user {}'.format(username))
def execute(self):
app_dir = os.environ['APP_DIR']
app_module = os.environ['APP_MODULE']
script_dir = os.environ['SCRIPT_DIR']
public_dir = os.environ['PUBLIC_DIR']
os.chdir(app_dir)
app = load_definition_from_string('{0}.app.application'.format(
app_module))
kwargs = {
'app': app,
'script_dir': script_dir,
'public_dir': public_dir,
}
if self.parsed_args.host:
kwargs['host'] = self.parsed_args.host
if self.parsed_args.port:
kwargs['port'] = int(self.parsed_args.port)
make_dev_server(**kwargs)
def execute(self):
app_dir = os.environ['APP_DIR']
app_module = os.environ['APP_MODULE']
script_dir = os.environ['SCRIPT_DIR']
public_dir = os.environ['PUBLIC_DIR']
os.chdir(app_dir)
app = load_definition_from_string(
'{0}.app.application'.format(app_module))
kwargs = {
'app': app,
'script_dir': script_dir,
'public_dir': public_dir,
}
if self.parsed_args.host:
kwargs['host'] = self.parsed_args.host
if self.parsed_args.port:
kwargs['port'] = int(self.parsed_args.port)
make_dev_server(**kwargs)
def wrapper(self, *args, **kwargs):
provider = self.container.get(DEPENDENCY)
form = imports.load_definition_from_string(
form_class)(action=self.request)
form.data = self.request
user = None
if self.request.is_method(method):
result = {}
if form.is_valid():
user = provider.authenticate(
username=getattr(form, provider.user_model_identifier),
password=form.password)
if user and provider.user_meets_requirements(user, requires):
result['token'] = provider.login(user, self.request)
else:
self.response.status_code = 403
result['message'] = 'Unable to authenticate the specified credentials.'
return Model(format='json', data=result)
return func(self, **kwargs)
def wrapper(self, *args, **kwargs):
provider = self.container.get(DEPENDENCY)
redirect_url = provider.config.get('authenticated_route', redirect)
if self.request.user:
return self.redirect(redirect_url)
form = imports.load_definition_from_string(
form_class)(action=self.request)
kwargs['form'] = form
forgotten_password_token_manager = self.container.get(
'auth_forgotten_password_token_manager')
forgotten_password_token_manager.provider = provider
token = forgotten_password_token_manager.get_token(
self.request.get['token'])
namespace = 'error'
message = error_message
if self.request.is_method(method):
form.data = self.request
redirect_url = str(self.request.url)
if form.is_valid():
if token:
message = success_message
namespace = 'success'
forgotten_password_token_manager.update_user_password(
token, form.password)
forgotten_password_token_manager.notify_user(
token.user,
request=self.request,
subject=subject,
template=template,
password=form.password)
if authenticate_on_reset:
provider.login(token.user, self.request)
else:
message = invalid_message
self.flash_messages.add(message, namespace)
return self.redirect(redirect_url, clear=True)
if not token:
self.flash_messages.add(message, namespace)
return self.redirect(
provider.config['forgotten_password_route'])
return func(self, **kwargs)
def test_load_invalid_definition(self):
with raises(ImportError):
imports.load_definition_from_string('invalid.module.Class')
def test_from_cache(self):
imports.load_definition_from_string('tests.watson.common.support.DATA')
assert 'tests.watson.common.support.DATA' in imports.definition_lookup
def test_load_definition_from_string(self):
assert isinstance(
load_definition_from_string('watson.http.MIME_TYPES'), dict)
def test_load_definition_from_string(self):
data = imports.load_definition_from_string(
'tests.watson.common.support.DATA')
assert isinstance(data, dict)
def __call__(self, event):
app = event.target
config = app.config['logging']
logger_config_callable = imports.load_definition_from_string(
config['callable'])
logger_config_callable(config['options'])
config = context.config
fileConfig(config.config_file_name)
logger = logging.getLogger('alembic.env')
watson = config.watson
USE_TWOPHASE = watson['config']['migrations']['use_twophase']
target_metadata = {}
engines = {}
for name, options in watson['config']['connections'].items():
metadata = options['metadata']
if isinstance(metadata, str):
metadata = load_definition_from_string(metadata).metadata
target_metadata[name] = metadata
engines[name] = {
'url': options['connection_string'],
'instance': watson['container'].get(
'sqlalchemy_engine_{0}'.format(name))
}
def run_migrations_offline():
"""Run migrations in 'offline' mode.
This configures the context with just a URL
and not an Engine, though an Engine is acceptable
here as well. By skipping the Engine creation
we don't even need a DBAPI to be available.
def test_load_invalid_definition(self):
with raises(ImportError):
imports.load_definition_from_string('invalid.module.Class')
def test_load_definition_from_string(self):
assert isinstance(
load_definition_from_string(
'watson.http.MIME_TYPES'),
dict)
def test_load_invalid_definition(self):
assert None == load_definition_from_string('invalid.module.Class')
def test_load_invalid_definition(self):
assert None == load_definition_from_string('invalid.module.Class')
def test_from_cache(self):
imports.load_definition_from_string('tests.watson.common.support.DATA')
assert 'tests.watson.common.support.DATA' in imports.definition_lookup
def __call__(self, event):
app = event.target
config = app.config['logging']
logger_config_callable = imports.load_definition_from_string(
config['callable'])
logger_config_callable(config['options'])