def get_init(global_config, settings, init_cls=None) -> Initializer: """Get Initializer class instance for WSGI-like app. TODO: Deprecated. Use Pyramid's ``bootstrap()`` instead. Reads reference to the initializer from settings, resolves it and creates the initializer instance. Example 1:: config_uri = argv[1] init = get_init(dict(__file__=config_uri), settings) :param global_config: Global config dictionary, having __file__ entry as given by Paster :param settings: Settings dictionary :param init_cls: Explicitly give the Initializer class to use, otherwise read ``websauna.init`` settings. """ assert "websauna.init" in settings, "You must have websauna.init setting pointing to your Initializer class" assert "__file__" in global_config if not init_cls: init_cls = settings.get("websauna.init") if not init_cls: raise RuntimeError("INI file lacks websauna.init option") resolver = DottedNameResolver() init_cls = resolver.resolve(init_cls) init = init_cls(global_config, settings) return init
def create_dummy_extract(): date = datetime.datetime.now() real_estate = RealEstateRecord( u'test', u'BL', u'Laufen', 2770, 1000, MultiPolygon(), ViewServiceRecord('test_link', 1, 1.0, {'de': 'test_legend'})) plr_office = OfficeRecord({u'en': u'PLR Authority'}) resolver = DottedNameResolver() date_method_string = Config.get('extract').get('base_data').get( 'methods').get('date') date_method = resolver.resolve(date_method_string) av_update_date = date_method(real_estate) base_data = Config.get_base_data(av_update_date) av_provider_method_string = Config.get('extract').get('base_data').get( 'methods').get('provider') av_provider_method = resolver.resolve(av_provider_method_string) cadaster_state = date theme = ThemeRecord(u'TEST', {u'de': u'TEST TEXT'}) datasources = [DatasourceRecord(theme, date, plr_office)] plr_cadastre_authority = Config.get_plr_cadastre_authority() embeddable = EmbeddableRecord(cadaster_state, plr_cadastre_authority, av_provider_method(real_estate), av_update_date, datasources) record = ExtractRecord(real_estate, ImageRecord('100'.encode('utf-8')), ImageRecord('100'.encode('utf-8')), ImageRecord('100'.encode('utf-8')), ImageRecord('100'.encode('utf-8')), plr_office, base_data, embeddable) return record
def debug(request, registry, settings): """Invoke pdb breakpoint from a template. Example: .. code-block:: html+jinja <h1>{{ site_name }}</h1> {{ debug() }} This will invoke function from :ref:`websauna.template_debugger` setting. The debugger is turned on only on :ref:`development.ini`. If there is no debugger configured, a warning is given. """ def _dummy(): logger.warn( "{{ debug() }} invoked, but websauna.template_debugger not set") return "" template_debugger = settings.get("websauna.template_debugger") if not template_debugger: debugger = _dummy else: r = DottedNameResolver() debugger = r.resolve(template_debugger) def _inner(): debugger() return "" return _inner
def configure_mailer(self): """Configure outgoing email backend and email test views.""" from pyramid_mailer import IMailer settings = self.settings.copy() # Empty values are not handled gracefully, so mutate them here before passing forward to mailer if settings.get("mail.username", "x") == "": settings["mail.username"] = None if settings.get("mail.password", "x") == "": settings["mail.password"] = None mailer_class = settings.get("websauna.mailer", "") if mailer_class in ("mail", ""): # TODO: Make mailer_class explicit so we can dynamically load pyramid_mail.Mailer # Default from pyramid_mailer import mailer_factory_from_settings mailer = mailer_factory_from_settings(settings) self.config.registry.registerUtility(mailer, IMailer) else: # debug backend resolver = DottedNameResolver() mailer_cls = resolver.resolve(mailer_class) mailer = mailer_cls() self.config.registry.registerUtility(mailer, IMailer) if settings.get("websauna.sample_html_email", False): from websauna.system.mail import views self.config.scan(views) self.config.add_jinja2_search_path( 'websauna.system:mail/templates', name='.html')
def includeme(config): """Bind to the db engine specifed in ``config.registry.settings``. Setup:: >>> from mock import Mock >>> import pyramid_basemodel >>> _engine_from_config = pyramid_basemodel.engine_from_config >>> _bind_engine = pyramid_basemodel.bind_engine >>> pyramid_basemodel.engine_from_config = Mock() >>> pyramid_basemodel.engine_from_config.return_value = 'engine' >>> pyramid_basemodel.bind_engine = Mock() >>> mock_config = Mock() >>> mock_config.registry.settings = {} Calls ``bind_engine`` with the configured ``engine``:: >>> includeme(mock_config) >>> >>> mock_config.action.assert_called_with(None, ... pyramid_basemodel.bind_engine, ... ('engine',), ... {'should_create': False, 'should_drop': False}) Unless told not to:: >>> pyramid_basemodel.bind_engine = Mock() >>> mock_config = Mock() >>> mock_config.registry.settings = {'basemodel.should_bind_engine': False} >>> includeme(mock_config) >>> mock_config.action.called False Teardown:: >>> pyramid_basemodel.engine_from_config = _engine_from_config >>> pyramid_basemodel.bind_engine = _bind_engine """ # Bind the engine. settings = config.get_settings() engine_kwargs_factory = settings.pop('sqlalchemy.engine_kwargs_factory', None) if engine_kwargs_factory: kwargs_factory = config.maybe_dotted(engine_kwargs_factory) engine_kwargs = kwargs_factory(config.registry) else: engine_kwargs = {} pool_class = settings.pop('sqlalchemy.pool_class', None) if pool_class: dotted_name = DottedNameResolver() engine_kwargs['poolclass'] = dotted_name.resolve(pool_class) should_bind = asbool(settings.get('basemodel.should_bind_engine', True)) should_create = asbool(settings.get('basemodel.should_create_all', False)) should_drop = asbool(settings.get('basemodel.should_drop_all', False)) if should_bind: engine = engine_from_config(settings, 'sqlalchemy.', **engine_kwargs) config.action(None, bind_engine, (engine,), { 'should_create': should_create, 'should_drop': should_drop})
def get_municipality(request): """ Returns the requested municipality logo from database. Args: request (pyramid.request.Request): The request containing the fosnr as matchdict parameter. Returns: pyramid.response.Response: The generated response object. """ fosnr = request.matchdict.get('fosnr') source_params = Config.get_municipality_config().get('source').get('params') session = database_adapter.get_session(source_params.get('db_connection')) try: model = DottedNameResolver().resolve(source_params.get('model')) municipality = session.query(model).filter_by(fosnr=fosnr).first() if municipality: logo = getattr(municipality, 'logo', None) if logo: response = request.response response.status_int = 200 response.content_type = 'image/*' response.body = base64.b64decode(logo.encode('ascii')) return response raise HTTPNotFound() finally: session.close()
def test_app_no_login_real_policy(request, test_app_no_perm): """A configured Assembl fixture with permissions and no user logged in""" config = testing.setUp( registry=test_app_no_perm.app.registry, settings=get_config(), ) from ...auth.util import authentication_callback from pyramid.authorization import ACLAuthorizationPolicy from pyramid.path import DottedNameResolver resolver = DottedNameResolver(__package__) auth_policy_name = "assembl.auth.util.UpgradingSessionAuthenticationPolicy" auth_policy = resolver.resolve(auth_policy_name)( callback=authentication_callback) config.set_authorization_policy(ACLAuthorizationPolicy()) config.set_authentication_policy(auth_policy) import transaction # ensure default roles and permissions at startup from ...models import get_session_maker with transaction.manager: session = get_session_maker() from ...lib.migration import bootstrap_db_data bootstrap_db_data(session, False) return test_app_no_perm
def get_storage_impl(settings) -> Callable[[Any], Any]: """ Get and configure the storage backend wrapper """ resolver = DottedNameResolver(__name__) storage = settings.get("pypi.storage", "file") if storage == "azure-blob": if not AZURE_BLOB_IS_AVAILABLE: raise ValueError( "azure-blob storage backend selected but Azure Blob " "Storage is not available. " "Please install the azure-storage-blob library by " "including the `azure-blob` extra in your pip-install step. " "For example: `pip install pypicloud[azure-blob]`") storage = "pypicloud.storage.AzureBlobStorage" elif storage == "s3": storage = "pypicloud.storage.S3Storage" elif storage == "cloudfront": storage = "pypicloud.storage.CloudFrontS3Storage" elif storage == "gcs": if not GCS_IS_AVAILABLE: raise ValueError( "gcs backend selected but GCS is not available. " "Please install the google-cloud-storage library by " "including the `gcs` extra in your pip-install step. " "For example: `pip install pypicloud[gcs]`") storage = "pypicloud.storage.GoogleCloudStorage" elif storage == "file": storage = "pypicloud.storage.FileStorage" storage_impl = resolver.resolve(storage) kwargs = storage_impl.configure(settings) return partial(storage_impl, **kwargs)
def main(): # pragma: no cover parser = ArgumentParser('Pubsub listener pushing to websockets.') parser.add_argument('config', help='path to the config file') args, settings = parser.parse_args(), {} load_into_settings(args.config, settings) config = settings['config'] ioloop.install() sub_socket = zmq.Context().socket(zmq.SUB) sub_socket.connect(config.get('zeromq', 'sub')) sub_socket.setsockopt(zmq.SUBSCRIBE, 'PUSH') print 'SUB sub_socket on', config.get('zeromq', 'sub') loop = ioloop.IOLoop.instance() port = config.get('websockets', 'port') Push(zmqstream.ZMQStream(sub_socket, loop)) application.listen(port) print 'websockets on :%s' % port # Send a status report every 10 seconds. cfg = config.get_map('storage') storage = DottedNameResolver(None).resolve(cfg.pop('backend'))(**cfg) ip = '%s:%s' % (socket.gethostbyname(socket.getfqdn()), port) callback = partial(report_status, storage, ip) period = config.get('monitor', 'period') ioloop.PeriodicCallback(callback, period * 1000).start() # Get in the pool right away. callback() loop.start()
def includeme(config): """ Let extdirect be included by config.include(). """ settings = config.registry.settings extdirect_config = dict() names = ("api_path", "router_path", "namespace", "descriptor", "expose_exceptions", "debug_mode", "json_encoder") for name in names: qname = "pyramid_extdirect.{}".format(name) value = settings.get(qname, None) if name == "expose_exceptions" or name == "debug_mode": value = (value == "true") if name == "json_encoder" and value: from pyramid.path import DottedNameResolver resolver = DottedNameResolver() value = resolver.resolve(value) if value is not None: extdirect_config[name] = value extd = Extdirect(**extdirect_config) config.registry.registerUtility(extd, IExtdirect) api_view_perm = settings.get("pyramid_extdirect.api_view_permission") config.add_route('extapi', extd.api_path) config.add_view(api_view, route_name='extapi', permission=api_view_perm) router_view_perm = settings.get("pyramid_extdirect.router_view_permission") config.add_route('extrouter', extd.router_path) config.add_view(router_view, route_name='extrouter', permission=router_view_perm)
def site_factory(request): """Application site factory On application startup, this factory checks configuration to get application name and load it from the ZODB; if the application can't be found, configuration is scanned to get application factory, create a new one and create a local site manager. """ conn = get_connection(request) root = conn.root() application_key = request.registry.settings.get(PYAMS_APPLICATION_SETTINGS_KEY, PYAMS_APPLICATION_DEFAULT_NAME) application = root.get(application_key) if application is None: factory = request.registry.settings.get(PYAMS_APPLICATION_FACTORY_KEY) if factory: resolver = DottedNameResolver() factory = resolver.maybe_resolve(factory) else: factory = request.registry.queryUtility(ISiteRootFactory, default=BaseSiteRoot) application = root[application_key] = factory() if IPossibleSite.providedBy(application): lsm = LocalSiteManager(application, default_folder=False) application.setSiteManager(lsm) try: # if some components require a valid and complete registry # with all registered utilities, they can subscribe to # INewLocalSiteCreatedEvent event interface set_local_registry(application.getSiteManager()) get_current_registry().notify(NewLocalSiteCreatedEvent(application)) finally: set_local_registry(None) import transaction # pylint: disable=import-outside-toplevel transaction.commit() return application
def plr_sources(pyramid_oereb_test_config): plr_sources = [] for plr in pyramid_oereb_test_config.get('plrs'): plr_source_class = DottedNameResolver().maybe_resolve( plr.get('source').get('class')) plr_sources.append(plr_source_class(**plr)) yield plr_sources
def includeme(config): accession_factory = config.registry.settings.get('accession_factory') if accession_factory: factory = DottedNameResolver().resolve(accession_factory) else: factory = enc_accession config.registry[ACCESSION_FACTORY] = factory
def render(resource): """TALES extension rendering method""" library, resource_name = resource.split(':') resolver = DottedNameResolver() module = resolver.maybe_resolve(library) resource = getattr(module, resource_name) return get_resource_path(resource)
def run_widgets(self, request): theme = request.registry.settings['mokacms.theme'] db = request.mdb self.log.debug("Running widgets for %s, (theme: %s)", self, theme) resolver = DottedNameResolver() theme = Theme.get(db, theme) widgets = [] result = {} for template in theme.templates: if template['file'] == self.template: widgets = template["widgets"] self.log.debug("Found widgets: %s", widgets) for widget in widgets: callable_ = widget['callable'] cname = "{}.{}".format(callable_.__module__, callable_.__name__) args = {a['name']: a['value'] for a in widget['args']} self.log.debug("Excecuting %s with args %s", cname, args) try: result[cname] = dict( args=widget['args'], result=callable_(request, **args) ) except: self.log.exception("Error while running widget %s with args %s", cname, args) raise return result
def __init__(self, **kwargs): """ Keyword Args: db_connection (str): A rfc1738 conform database connection string in the form of: ``<driver_name>://<username>:<password>@<database_host>:<port>/<database_name>`` model (str): A valid dotted name string which leads to an importable representation of sqlalchemy.ext.declarative.DeclarativeMeta or the real class itself. """ from pyramid_oereb import database_adapter if database_adapter: self._adapter_ = database_adapter else: raise ConfigurationError( 'Adapter for database must be defined if you use database sources.' ) if kwargs.get('db_connection'): self._key_ = kwargs.get('db_connection') else: raise ConfigurationError( '"db_connection" for source has to be defined in used yaml ' 'configuration file') if kwargs.get('model'): self._model_ = DottedNameResolver().maybe_resolve( kwargs.get('model')) else: raise ConfigurationError( '"model" for source has to be defined in used yaml configuration file' )
def debug(request, registry, settings): """Invoke pdb breakpoint from a template. Example: .. code-block:: html+jinja <h1>{{ site_name }}</h1> {{ debug() }} This will invoke function from :ref:`websauna.template_debugger` setting. The debugger is turned on only on :ref:`development.ini`. If there is no debugger configured, nothing happens. """ def _dummy(): return "" template_debugger = settings.get("websauna.template_debugger") if not template_debugger: return _dummy() r = DottedNameResolver() debugger = r.resolve(template_debugger) assert debugger, "Could not find debugger in websauna.template_debugger setting: {}".format(template_debugger) def _inner(): debugger() return "" return _inner
def command(self): ini_file = self.args[-1] # pylint: disable=E1101 # TheLMA setup. config = self.__setup_thelma(ini_file) # Initialize the tool and run it. rsv = DottedNameResolver(None) tool_cls = rsv.resolve(self.__target_class.tool) arg_names = [od[1] for od in self.__target_class.option_defs] # Initializing lazy options. We pass the target class and the # options so the callback has access to them. opts = self.options # pylint: disable=E1101 for arg_name in arg_names: arg_value = getattr(opts, arg_name) if isinstance(arg_value, LazyOptionCallback): arg_value = arg_value.initialize(self.__target_class, opts) setattr(opts, arg_name, arg_value) # We only now do a final loop over the options so that lazy option # callbacks get a chance to set dependent option values. kw = {} for arg_name in arg_names: kw[arg_name] = getattr(opts, arg_name) # Remove options that are for command use only. for opt in self.parser.option_list: if opt.dest in kw and opt.pass_to_tool is False: del kw[opt.dest] tool = tool_cls(**kw) try: tool.run() except: transaction.abort() raise else: if tool.has_errors(): err_msgs = tool.get_messages() msg = 'Errors occurred during the tool run. Error messages:\n' raise RuntimeError(msg + os.linesep.join(err_msgs)) warn_msgs = tool.get_messages(logging_level=logging.WARNING) if warn_msgs \ and not self.options.ignore_warnings: # pylint: disable=E1101 msg = 'Warnings occurred during the tool run. You can ' \ 'repeat the run with the --ignore-warnings switch ' \ 'to force changes to be committed. Warning messages:\n' raise RuntimeError(msg + os.linesep.join(warn_msgs)) try: # This gives the tool command a chance to perform actions after # the tool has run. self.__target_class.finalize(tool, opts) except: transaction.abort() raise else: # Create a report of the run. self.__run_report(tool) # All good - check if we should commit. if not self.options.simulate: # pylint: disable=E1101 transaction.commit() else: transaction.abort() config.end()
def add_logging(config, log_key, log_func=None): resolver = DottedNameResolver() if log_func is None: log_func = operator.attrgetter(log_key) log_func = resolver.maybe_resolve(log_func) config.registry[get_key("registered_loggers")][log_key] = log_func config.registry[get_key("order")].append(log_key)
def deserialize(self, node, value): """Deserialize path to object.""" if value in (colander.null, ''): return value try: return DottedNameResolver().resolve(value) except Exception as err: raise colander.Invalid(node, msg=str(err), value=value)
def includeme(config): from pyramid.path import DottedNameResolver accession_factory = config.registry.settings.get('accession_factory') if accession_factory: factory = DottedNameResolver().resolve(accession_factory) else: factory = prod_accession config.registry[ACCESSION_FACTORY] = factory
def get_processor_factory(settings): """Get processor factory from settings and return """ resolver = DottedNameResolver() processor_factory = settings['billy.processor_factory'] processor_factory = resolver.maybe_resolve(processor_factory) return processor_factory
def get_region(name, **settings): region = regions.get(name) if not region: settings_ = dict(default_settings) settings_.update(settings) region = regions[name] = build_dogpile_region_from_dict( DottedNameResolver().maybe_resolve, name, settings_) return region
def colander_schema(self): if not self._colander_schema_runtime: schema = self._colander_schema schema = DottedNameResolver(__name__).maybe_resolve(schema) if callable(schema): schema = schema() self._colander_schema_runtime = schema return self._colander_schema_runtime
def __new__(cls, namespace, base, *args, **kw): # Dotted name support makes it easy to configure with pyramid_multiauth name_resolver = DottedNameResolver(caller_package()) base = name_resolver.maybe_resolve(base) # Dynamically create a subclass name = 'Namespaced_%s_%s' % (namespace, base.__name__) klass = type(name, (cls, base), {'_namespace_prefix': namespace + '.'}) return super(NamespacedAuthenticationPolicy, klass).__new__(klass)
def _load_module(config, package, module): try: resolver = DottedNameResolver() # log.debug('{0}.{1}'.format(package, module)) prefix = resolver.resolve('{0}.{1}:ROUTE_PREFIX'.format( package, module)) except ImportError, e: prefix = None
def create_processor(): """ Creates and returns a processor based on the application configuration. You should use one (and only one) processor per request. Otherwise some results can be mixed or missing. Returns: pyramid_oereb.lib.processor.Processor: A processor. """ real_estate_config = Config.get_real_estate_config() municipality_config = Config.get_municipality_config() exclusion_of_liability_config = Config.get_exclusion_of_liability_config() glossary_config = Config.get_glossary_config() extract = Config.get_extract_config() certification = extract.get('certification') certification_at_web = extract.get('certification_at_web') plr_cadastre_authority = Config.get_plr_cadastre_authority() real_estate_reader = RealEstateReader( real_estate_config.get('source').get('class'), **real_estate_config.get('source').get('params')) municipality_reader = MunicipalityReader( municipality_config.get('source').get('class'), **municipality_config.get('source').get('params')) exclusion_of_liability_reader = ExclusionOfLiabilityReader( exclusion_of_liability_config.get('source').get('class'), **exclusion_of_liability_config.get('source').get('params')) glossary_reader = GlossaryReader( glossary_config.get('source').get('class'), **glossary_config.get('source').get('params')) plr_sources = [] for plr in Config.get('plrs'): plr_source_class = DottedNameResolver().maybe_resolve( plr.get('source').get('class')) plr_sources.append(plr_source_class(**plr)) extract_reader = ExtractReader( plr_sources, plr_cadastre_authority, certification, certification_at_web, ) return Processor( real_estate_reader=real_estate_reader, municipality_reader=municipality_reader, exclusion_of_liability_reader=exclusion_of_liability_reader, glossary_reader=glossary_reader, plr_sources=plr_sources, extract_reader=extract_reader, )
def callback(self, config, target): view = DottedNameResolver().maybe_resolve(target) route_name = self.state.route_name # self.state.add_method(self.request_method, view) config.add_view(view, route_name=route_name, request_method=self.request_method, context=self.state, **self.view_arguments)
def ResolveName(name, base=None, raiseExcp=True): """ Lookup python object by dotted python name. Wraps pyramid.DottedNameResolver. returns object or None """ if not name: return None if not isinstance(name, basestring): return name if not base: base = caller_package() if not raiseExcp: d = DottedNameResolver(base) return d.maybe_resolve(name) d = DottedNameResolver(base) return d.resolve(name)
def includeme(config): """ Set up and configure the pypicloud app """ config.set_root_factory(Root) config.include('pyramid_tm') config.include('pyramid_beaker') config.include('pyramid_duh') config.include('pyramid_duh.auth') config.include('pypicloud.auth') config.include('pypicloud.access') settings = config.get_settings() config.add_renderer('json', json_renderer) # Jinja2 configuration settings['jinja2.filters'] = { 'static_url': 'pyramid_jinja2.filters:static_url_filter', 'tojson': to_json, } settings['jinja2.directories'] = ['pypicloud:templates'] config.include('pyramid_jinja2') # BEAKER CONFIGURATION settings.setdefault('session.type', 'cookie') settings.setdefault('session.httponly', 'true') config.set_session_factory(session_factory_from_settings(settings)) # PYPICLOUD SETTINGS config.registry.fallback_url = settings.get('pypi.fallback_url', 'http://pypi.python.org/simple') config.registry.use_fallback = asbool(settings.get('pypi.use_fallback', True)) realm = settings.get('pypi.realm', 'pypi') config.registry.realm = realm # CACHING DATABASE SETTINGS resolver = DottedNameResolver(__name__) dotted_cache = settings.get('pypi.db', 'sql') if dotted_cache == 'sql': dotted_cache = 'pypicloud.cache.SQLCache' elif dotted_cache == 'redis': dotted_cache = 'pypicloud.cache.RedisCache' cache_impl = resolver.resolve(dotted_cache) cache_impl.configure(config) cache_impl.reload_if_needed() config.add_request_method(cache_impl, name='db', reify=True) # Special request methods config.add_request_method(_app_url, name='app_url') config.add_request_method(lambda x: __version__, name='pypicloud_version', reify=True) cache_max_age = int(settings.get('pyramid.cache_max_age', 3600)) config.add_static_view(name='static/%s' % __version__, path='pypicloud:static', cache_max_age=cache_max_age)