def _parse_ui_elements(self, module_or_list): if not module_or_list: return {} elif isinstance(module_or_list, compat.string_type): module_name = module_or_list.split('.')[-1] module_or_list = {module_name: module_or_list} return {k: import_object(v) for k, v in module_or_list.iteritems()}
def add_transform(self, module_or_list): if isinstance(module_or_list, compat.list_type): self.transforms.extends(self._parse_transforms(module_or_list)) else: if isinstance(module_or_list, compat.string_type): module_or_list = import_object(module_or_list) super(ServerApplication, self).add_transform(module_or_list)
def start_server(*args, **kwargs): global __SERVER debugcolorizer('### SERVER ###', fg='black', bg='blue') logging.info('Starting server...') if not settings.is_options_parsed(): options.parse_command_line() settings.options_parse(options.options.as_dict()) settings_dict = settings.as_dict() try: module = None for key in constants.APPLICATION_CLASS_LIST: if key in settings_dict: cls = settings_dict[key] module = import_object(cls) break application = module(**settings_dict) except: application = ServerApplication(**settings_dict) if settings.DEBUG: code = jsoncolorize(jsondumps(settings_dict, indent=2, sort_keys=True)) logging.debug(' * Settings:\n\n%s\n\n', code) http_server = httpserver.HTTPServer( application, **{ 'xheaders': settings.XHEADERS, 'ssl_options': application.ssl_options }) io_loop = ioloop.IOLoop.current() application.set_exit_callback(partial(_stop_loop, io_loop)) with stack_context.NullContext(): if settings.PREFORK_PROCESS > -1: http_server.bind(settings.PORT) http_server.start(settings.PREFORK_PROCESS) else: http_server.listen(settings.PORT) yield gen.Task(application.start) __SERVER = ServerEnvironment(settings.SERVER_NAME, application, http_server, io_loop) url = 'http://{domain}:{port}'.format(**settings_dict) logging.info('%s v%s', __SERVER.name.upper(), __SERVER.version.value) logging.info('Running server on %s', url) logging.info('--') if not compat.WIN and settings.DEBUG and not settings.DISABLE_BROWSER: import subprocess subprocess.Popen(['open', url]) yield gen.Task(lambda callback: None)
def _parse_handlers_list(self, module_or_list): result = [] for item in module_or_list: if isinstance(item, compat.list_type) and len(item) in (2, 3, 4): result.append(item) elif isinstance(item, compat.string_type): values = import_object('%s.%s' % (item, DEFAULT_CONTAINER)) if not isinstance(values, compat.list_type): raise ConfigurationError( 'Module "%s" does not define "%s" attribute like a list' % (item, DEFAULT_CONTAINER)) result.extend(values) else: raise ConfigurationError('Element not supported: %s' % item) return result
def factory(name=None, options=None, module=None, settings=None, **kwargs): """ Example: -------- .. code-block:: python options = { 'session': { 'module': 'path.to.module', 'settings': { ... } }, 'cache': 'path.to.module' } module = factory('session', options) # settings or keywords argument settings = { 'name': 'sid', 'secure_cookie': True, 'adapter': { 'port': 11211, 'domain': 'localhost' } } module = factory(module='path.to.module', settings=settings) :param name: (string) :param options: (dict) :param settings: (dict) :param module: (string or instance) :param kwargs: :return: """ if module is None: if isinstance(name, compat.string_type) and isinstance(options, dict): if name not in options: raise FactoryError('Option not supported: %s' % name) else: opts = options[name] if isinstance(opts, dict) and 'module' in opts: module = opts['module'] or module try: settings = opts['settings'] except: settings = settings elif isinstance(opts, compat.string_type): module = opts else: raise FactoryError( 'Please define into your "options" a dictionary ' 'with a {"name": "path.to.module"} or ' '{"name": {"module": "module.to.path", "settings": {}}}' ) else: raise FactoryError('Bad configuration, you need to define the ' 'argument "name" with "options" and/or ' '"settings", or maybe "module" and "settings"') if isinstance(module, compat.string_type): module = import_object(module) if not callable(module): raise FactoryError('The module must be callable or an object instance') if settings: kwargs.update(settings) return module(**kwargs)
def _import_class(self, value): return import_object(value)
def _parse_transforms(self, module_or_list): if not module_or_list: return [] elif isinstance(module_or_list, compat.string_type): module_or_list = [module_or_list] return [import_object(item) for item in module_or_list]