def extract_static_assets_from_components(compo_list): ar = AssetResolver() js_paths = [] js_name = [] css_paths = [] css_name = [] # The Page needs to be in the webassets first, then all other pages, then all components. for cls in compo_list: for js in cls.js_name: if type(js) is not tuple: js = (cls.asset_spec, js) if js in js_name: continue js_name.append(js) js_paths.append(ar.resolve('/'.join(js)).abspath()) cls.js_name = cls.js_name + getattr(cls, 'js_name_no_bundle', []) for css in cls.css_name: if type(css) is not tuple: css = (cls.asset_spec, css) if css in css_name: continue css_name.append(css) css_paths.append(ar.resolve('/'.join(css)).abspath()) cls.css_name = cls.css_name + getattr(cls, 'css_name_no_bundle', []) return js_paths, js_name, css_paths, css_name
class CloudMaker(object): def __init__(self, context, request): self.context = context self.request = request self.resolver = AssetResolver() self.minsize = int(request.registry.settings.get('jcu.words.minsize', 10)) self.maxsize = int(request.registry.settings.get('jcu.words.maxsize', 100)) @view_config(name="keyword-cloud.png") def keyword_cloud_png(self): asset = self.resolver.resolve('jcuwords:keyword-cloud.png') _cloud = open(asset.abspath()).read() return Response(content_type='image/png', body=_cloud) @view_config(name="keyword-cloud") def keyword_cloud(self): return self.make_cloud(True) @view_config(name="keyword-cloud-image") def keyword_cloud_image(self): image_url = self.request.resource_url(None, 'keyword-cloud.png') return {'image': image_url} def invalidate(self): cache.region_invalidate(self.make_cloud, None, False) cache.region_invalidate(self.make_cloud, None, True) def make_cloud(self, output_html): keywords = KeywordManager().all() text = ' '.join([kw.keyword for kw in keywords]) if output_html: max_tags = 30 max_size = 42 else: max_tags = 100 max_size = self.maxsize tags = make_tags(get_tag_counts(text)[:max_tags], minsize=self.minsize, maxsize=max_size) if output_html: size = (900, 300) result = create_html_data(tags, size=size, layout=LAYOUT_HORIZONTAL) else: #now = datetime.utcnow() #filename = 'jcuwords/static/clouds/keyword-cloud-%s.png' % now.isoformat() cloud = self.resolver.resolve('jcuwords:keyword-cloud.png') filename = cloud.abspath() size = (1024, 500) create_tag_image(tags, filename, size=size, fontname='IM Fell DW Pica', layout=LAYOUT_MIX) image_url = self.request.resource_url(None, 'keyword-cloud.png') result = {'image': image_url} return result
def register_mustache_bundle(cfg, name, path='', description=''): """ Register mustache bundle; :param name: module name :param path: asset path :param description: """ resolver = AssetResolver() d = resolver.resolve(path).abspath() if not os.path.isdir(d): raise ConfigurationError("Directory is required: %s"%path) discr = (ID_AMD_MODULE, name) resolver = AssetResolver() abs_path = resolver.resolve(path).abspath() if not path or not os.path.isdir(abs_path): raise ConfigurationError("Directory is required: %s"%path) intr = Introspectable(ID_AMD_MODULE, discr, name, ID_AMD_MODULE) intr['name'] = name intr['path'] = path intr['abs_path'] = abs_path intr['description'] = description storage = cfg.registry.setdefault(ID_BUNDLE, {}) storage[name] = intr cfg.action(discr, introspectables=(intr,))
def init_amd_spec(config, cache_max_age=None): cfg = ptah.get_settings(ptah.CFG_ID_PTAH, config.registry) config.registry[ID_AMD_SPEC] = {} if not cfg['amd-specs']: return if not cfg['amd-spec-dir']: raise ConfigurationError("amd-spec-dir is required.") resolver = AssetResolver() directory = resolver.resolve(cfg['amd-spec-dir']).abspath() specs = {} for item in cfg['amd-specs']: if ':' not in item: spec = '' specfile = item else: spec, specfile = item.split(':',1) if spec in specs: raise ConfigurationError("Spec '%s' already defined."%spec) specs[spec] = specfile spec_mods = {} for spec, specfile in specs.items(): f = resolver.resolve(specfile).abspath() parser = configparser.SafeConfigParser() parser.read(f) mods = {} for section in parser.sections(): if section.endswith('.js'): items = dict(parser.items(section)) url = items.get('url', '') modules = items.get('modules', '') modules = [s for s in [s.strip() for s in modules.split()] if not s.startswith('#')] if url: item = {'url': url, 'name': section} elif modules: item = {'name': section, 'path': os.path.join(directory,section)} mods[section] = item for mod in modules: mods[mod] = item spec_mods[spec] = mods config.registry[ID_AMD_SPEC] = spec_mods config.registry[ID_AMD_SPEC_] = cache_max_age
class PyramidResolver(Resolver): def __init__(self, env): super(PyramidResolver, self).__init__(env) self.resolver = AssetResolver(None) def search_for_source(self, item): try: item = self.resolver.resolve(item).abspath() except ImportError as e: raise BundleError(e) except ValueError as e: return super(PyramidResolver, self).search_for_source(item) # Take care of globs if glob.has_magic(item): return [ filename for filename in glob.iglob(item) if not path.isdir(item) ] else: return item def resolve_source_to_url(self, filepath, item): request = get_current_request() if ':' in item: # webassets gives us an absolute path to the source file # If the input item that generate this path was an asset spec # try to resolve the package and recreate the asset spec to use # for the static route generation. package = item[:item.find(':')] package_path = self.resolver.resolve('%s:' % package).abspath() filepath = filepath.replace(package_path, '').strip('/') spec = '%s:%s' % (package, filepath) else: spec = filepath return request.static_url(spec) def resolve_output_to_url(self, item): if not path.isabs(item): item = path.join(self.env.directory, item) try: request = get_current_request() url = request.static_url(self.search_for_source(item)) return url except ValueError as e: if ':' in item: e.message += '(%s)' % item raise BundleError(e)
def parse_asset_settings(settings): config = configparser.SafeConfigParser() asset_resolver = AssetResolver() dotted_resolver = DottedNameResolver() asset_config = settings.get('assets.config') print asset_config try: s = asset_resolver.resolve(asset_config).abspath() config.read(s) except AttributeError: raise try: store_locally = config.getboolean('assets', 'store_locally') except configparser.NoSectionError: try: with open(asset_config) as fp: config.readfp(fp) except IOError: raise else: store_locally = config.getboolean('assets', 'store_locally') result = dict( store_locally=store_locally, tmp_path=asset_resolver.resolve(config.get('assets', 'tmp_path')).abspath(), save_path=asset_resolver.resolve(config.get('assets', 'save_path')).abspath() ) c = config.items('assets:local') for key, value in c: # Skip any urls since they don't need to be resolved # TODO: Might produce bugs if module name starts with `http` if value.startswith('http'): result[key] = value continue try: value = asset_resolver.resolve(value).abspath() except ValueError: # This gets raised if the name isn't in dotted notation pass except ImportError: # This gets raised if there's ":" in the value but it's not a module pass finally: result[key] = value if not store_locally: c = dict(config.items('assets:cloud')) c['service'] = dotted_resolver.resolve(c.get('service')) result.update(c) return result
def __init__(self, pkg): path = ptah.get_cfg_storage(MIGRATION_ID).get(pkg) if path is None: raise ValueError("Can't find package.") res = AssetResolver(pkg) self.dir = res.resolve('ptah:scripts').abspath() self.versions = res.resolve(path).abspath() if not os.access(self.versions, os.F_OK): raise alembic.util.CommandError("Path doesn't exist: %r." % path)
def test_api_ae_delete_correct(self): a=AssetResolver() self.request.params = MultiDict() self.request.params.add('URI','testAppEnsemble') response = AppEnsembleViews(self.context, self.request).api_action_ae_delete() self.assertTrue(os.path.isfile(a.resolve(os.path.join('aof:tmp','ae-trash','testAppEnsemble.ae')).abspath()),"Error: App-Ensemble was not stored in the trash folder when delting") self.assertEqual(response.status_code,200,'Error: AppEnsemble could not be deleted!') aof.tests._create_test_AppEnsemble() response = AppEnsembleViews(self.context, self.request).api_action_ae_delete() aof.tests._create_test_AppEnsemble() files=os.listdir(a.resolve(os.path.join('aof:tmp','ae-trash')).abspath()) self.assertGreaterEqual(len(fnmatch.filter(files,'testAppEnsemble*')),1,"Error: Renaming deleted AppEnsembles does not work!") aof.tests._create_test_AppEnsemble()
def __init__(self, info): """ Creates a new XML renderer instance for versions rendering. Args: info (pyramid.interfaces.IRendererInfo): Info object. """ a = AssetResolver('pyramid_oereb') resolver = a.resolve('core/renderer/getegrid/templates/xml') geom_resolver = a.resolve('core/renderer/extract/templates/xml') self.template_dirs = [resolver.abspath(), geom_resolver.abspath()] self._gml_id = 0 super(Renderer, self).__init__(info)
def generate_random_filename(path=None, extension='pdf'): r = AssetResolver('erp') path = path or r.resolve('static/temp').abspath() if not os.path.exists(path): os.mkdir(path) filename = generate_random_digest() return '/'.join([path, '{filename}.{extension}'.format(filename=filename, extension=extension)])
def pserve_file_config(self, filename, global_conf=None): here = os.path.abspath(os.path.dirname(filename)) defaults = {} if global_conf: defaults.update(global_conf) defaults['here'] = here config = self.ConfigParser(defaults=defaults) config.optionxform = str config.read(filename) try: items = dict(config.items('pserve')) except configparser.NoSectionError: return watch_files = aslist(items.get('watch_files', ''), flatten=False) # track file paths relative to the ini file resolver = AssetResolver(package=None) for file in watch_files: if ':' in file: file = resolver.resolve(file).abspath() elif not os.path.isabs(file): file = os.path.join(here, file) self.watch_files.append(os.path.abspath(file))
def generate_webasset_bundles(config): compo_bundles = extract_static_assets_from_components(epflutil.Discover.discovered_components) page_bundles = [] pages = [epflpage.Page] + epflutil.Discover.discovered_pages for cls in pages: page_bundles.append(extract_static_assets_from_components([cls])) if not asbool(config.registry.settings.get('epfl.webassets.active', False)): return ar = AssetResolver() epfl_static = ar.resolve('solute.epfl:static') my_env = Environment('%s/bundles' % epfl_static.abspath(), 'bundles') for i, page in enumerate(pages): js_paths, js_name, css_paths, css_name = page_bundles[i] js_paths += compo_bundles[0] js_name += compo_bundles[1] css_paths += compo_bundles[2] css_name += compo_bundles[3] my_env.register('js%s' % i, Bundle(js_paths, filters='rjsmin', output='epfl.%(version)s.js')) my_env.register('css%s' % i, Bundle(css_paths, output='epfl.%(version)s.css')) page.js_name += [("solute.epfl:static", url) for url in my_env['js%s' % i].urls()] page.css_name += [("solute.epfl:static", url) for url in my_env['css%s' % i].urls()] page.bundled_names = js_name + css_name
def __call__(self, info): defname = None asset, ext = info.name.rsplit('.', 1) if '#' in asset: asset, defname = asset.rsplit('#', 1) spec = '%s.%s' % (asset, ext) isabspath = os.path.isabs(spec) colon_in_name = ':' in spec isabsspec = colon_in_name and (not isabspath) isrelspec = (not isabsspec) and (not isabspath) try: # try to find the template using default search paths self.lookup.get_template(spec) except TemplateLookupException: if isrelspec: # convert relative asset spec to absolute asset spec resolver = AssetResolver(info.package) asset = resolver.resolve(spec) spec = asset.absspec() else: raise return self.renderer_factory(spec, defname, self.lookup)
def view_file(request): form = get_form(AddSchema) if request.POST: if 'simpan' in request.POST: settings = get_settings() input_file = request.POST['upload'].file filename = request.POST['upload'].filename ext = get_ext(filename) if ext.lower()!='.png': request.session.flash('File harus format png','error') return dict(form=form.render()) resolver = AssetResolver() static_path = resolver.resolve('sipkd:static').abspath() fullpath = os.path.join( static_path, 'img/logo.png') print '------------------>',fullpath output_file = open(fullpath, 'wb') input_file.seek(0) while True: data = input_file.read(2<<16) if not data: break output_file.write(data) return route_list(request) return dict(form=form.render())
def template_exists(config, relpath): asset_resolver = AssetResolver() for md in config.registry.settings['mako.directories']: asset_descriptor = asset_resolver.resolve('/'.join([md, relpath])) if os.path.exists(asset_descriptor.abspath()): return True return False
def main(argv=sys.argv): global settings global resolver if len(argv) < 2: usage(argv) sys.exit(1) config_uri = argv[1] setup_logging(config_uri) settings = get_appsettings(config_uri) resolver = AssetResolver('digital_ale') dest_prefix = resolver.resolve(settings['scans.prefix']).abspath() engine = engine_from_config(settings, 'sqlalchemy.') DBSession.configure(bind=engine) user = User.get_by_username(u'frank') userid = user and user.id or None #Base.metadata.create_all(engine) with transaction.manager: for filename in sys.argv[2:]: if filename[-3:] == 'jpg': import_jpg(filename, dest_prefix, userid) elif filename[-3:] == 'txt': import_txt(filename, userid) else: print >> sys.stderr, "Warning: (%s) Unknown filetype. Not importing. " % filename
def register(): directories = [] resolver = AssetResolver(self.package_name) # defer spec resolution until register to allow for asset # overrides to take place in an earlier config phase for spec in specs: # the trailing slash helps match asset overrides for folders if not spec.endswith('/'): spec += '/' asset = resolver.resolve(spec) directory = asset.abspath() if not asset.isdir(): raise ConfigurationError('"%s" is not a directory' % directory) intr = self.introspectable('translation directories', directory, spec, 'translation directory') intr['directory'] = directory intr['spec'] = spec introspectables.append(intr) directories.append(directory) tdirs = self.registry.queryUtility(ITranslationDirectories) if tdirs is None: tdirs = [] self.registry.registerUtility(tdirs, ITranslationDirectories) if override: tdirs.extend(directories) else: for directory in reversed(directories): tdirs.insert(0, directory)
def view_file(request): form = get_form(AddSchema) if request.POST: if "simpan" in request.POST: settings = get_settings() input_file = request.POST["upload"].file filename = request.POST["upload"].filename ext = get_ext(filename) if ext.lower() != ".png": request.session.flash("File harus format png", "error") return dict(form=form.render()) resolver = AssetResolver() static_path = resolver.resolve("sipkd:static").abspath() fullpath = os.path.join(static_path, "img/logo.png") print "------------------>", fullpath output_file = open(fullpath, "wb") input_file.seek(0) while True: data = input_file.read(2 << 16) if not data: break output_file.write(data) return route_list(request) return dict(form=form.render())
def collect_static(self): """Collect all static files from all static views for the manifest.""" def recurse(collector, path): for entry in scandir(path): if entry.name.startswith("."): # Dot files are usually backups or other no no files continue # Don't process our internal cache folder if MARKER_FOLDER in entry.path: continue relative = os.path.relpath(entry.path, collector.root) if entry.is_file(): collector.collect(path, name, entry, relative) elif entry.is_dir(): recurse(collector, entry.path) r = AssetResolver() for name, asset_spec in self.views.items(): root = r.resolve(asset_spec).abspath() collector = CopyAndHashCollector(root, self.settings) recurse(collector, root) results = collector.finish() # Expose for testing return results
def set_up_content_mgmt_app(config, potfile_asset_spec, dictionary_factory): """ provide static content backend for hnc projects, text-keys are provided by babel message extractors into the domain.pot file, this is usually located in the root/locale folder config: is pyramid configuration instance potfile_asset_spec: describing path to potfile message catalog render_ctxt_info: is a function with request as sole parameter, when returns truthy value, additional HTML comments are rendered before the output text, normally only admins are interested in this """ def add_renderer_variables(event): if event['renderer_name'] != 'json': request = event['request'] event.update({'_': request._}) return event a = AssetResolver() asset_path = a.resolve(potfile_asset_spec) if not asset_path.exists(): raise ValueError( "POTFILE does not exist in specified location: {}".format( potfile_asset_spec)) config.add_subscriber(add_content(dictionary_factory, potfile_asset_spec), 'pyramid.events.ContextFound') config.add_subscriber(add_renderer_variables, 'pyramid.events.BeforeRender') return lambda: polib.pofile(asset_path.abspath())
def register_less_bundle(cfg, name, path, description='', watchdir=None): """ Register less bundle; :param name: module name :param path: asset path :param description: """ resolver = AssetResolver() abs_path = resolver.resolve(path).abspath() if not os.path.isfile(abs_path): raise ConfigurationError("less file is required: %s" % path) discr = (ID_BUNDLE, name) intr = Introspectable(ID_BUNDLE, discr, name, ID_BUNDLE) intr['name'] = name intr['path'] = path intr['abs_path'] = abs_path intr['watchdir'] = watchdir or os.path.dirname(abs_path) intr['description'] = description storage = cfg.registry.setdefault(ID_BUNDLE, {}) storage[name] = intr cfg.action(discr, introspectables=(intr,))
def __init__(self, request): super(NodeAppView, self).__init__(request) view = request.view_name subpath = request.subpath if not len(subpath): raise HTTPNotFound() appname = subpath[0] if len(subpath) == 1: # check for existence asset = 'haberdashery:apps/%s' % appname resolver = AssetResolver() descriptor = resolver.resolve(asset) if not descriptor.exists(): raise HTTPNotFound() # send back index to start load app settings = self.get_app_settings() basecolor = settings['default.css.basecolor'] template = 'trumpet:templates/webview-app.mako' env = dict(appname=appname, basecolor=basecolor) content = render(template, env) self.response = Response(body=content) else: #asset = 'haberdashery:apps/%s' % appname asset = os.path.join('haberdashery:apps', *subpath) self.response = static_asset_response(request, asset)
def view_file(request): form = get_form(AddSchema) if request.POST: if 'simpan' in request.POST: settings = get_settings() input_file = request.POST['upload'].file filename = request.POST['upload'].filename ext = get_ext(filename) if ext.lower()!='.png': request.session.flash('File harus format png','error') return dict(form=form.render()) resolver = AssetResolver() static_path = resolver.resolve('reklame:static').abspath() fullpath = os.path.join( static_path, 'img/logo.png') print '------------------>',fullpath output_file = open(fullpath, 'wb') input_file.seek(0) while True: data = input_file.read(2<<16) if not data: break output_file.write(data) return route_list(request) return dict(form=form.render())
def add_layer(cfg, layer, name='', path='', description=''): """ add new layer :param layer: layer id :param name: name :param path: asset path :param description: module description """ if not path: raise ConfigurationError('Path is required') discr = (ID_LAYER, name, layer) resolver = AssetResolver() directory = resolver.resolve(path).abspath() intr = Introspectable(ID_LAYER, discr, name, ID_LAYER) intr['name'] = name intr['layer'] = layer intr['path'] = directory intr['asset'] = path intr['description'] = description intr['filters'] = {} storage = cfg.registry.setdefault(ID_LAYER, {}) layers = storage.setdefault(layer, []) layers.insert(0, intr) cfg.action(discr, introspectables=(intr, )) log.info("Add layer: %s path:%s" % (layer, path))
def __init__(self, virtpath=None, abspath=None, type="file", mount_point=None): """ mount_point: (virtual_path, absolute_path) """ self.mount_point = None if mount_point: ar = AssetResolver() self.mount_point = (mount_point[0], ar.resolve(mount_point[1]).abspath()) if virtpath and abspath: raise RuntimeError("ERR - need only virtpath nor abspath") if virtpath: self.virtpath = os.path.normpath(virtpath) if mount_point is None: self.mount_point = get_absmount(self.virtpath) self.abspath = get_abspath(self.virtpath, self.mount_point) elif abspath: self.abspath = os.path.normpath(abspath) if mount_point is None: self.mount_point = get_virtmount(self.abspath) self.virtpath = get_virtpath(self.abspath, self.mount_point) else: raise RuntimeERror("ERR - need either virtpath or abspath") self.parent = None self._meta = None self.type = type self.mimetype = None
def add_bower_component(config, path, components_name=None): """ """ registry = config.registry resolver = AssetResolver() directory = resolver.resolve(path).abspath() if not os.path.isfile(os.path.join(directory, 'bower.json')): raise ConfigurationError( "Directory '{0}' does not contain 'bower.json' file" .format(directory) ) bower = get_bower(registry) if components_name is None: components_name = bower.components_name discr = ('djed:static', directory, components_name) def register(): info = BowerComponentInfo(directory, components_name) registry.registerUtility(info, IBowerComponent, name='-'.join(discr)) config.action(discr, register)
def setUp(self): # Setting up Testpool and TestAppEnsemble a = AssetResolver() path = a.resolve(aof.tests.settings["app_pool_path"]).abspath() ap = AppPool.Instance() ap.load(source=path,format="turtle") self.aeTests=AppEnsembleTests() aof.tests._create_test_AppEnsemble() #Set up Test-HTML for Documentation aof.tests._create_test_html_file() # Creating app with parameter META=aof.tests.settings["META"] app = main({},app_pool_path=aof.tests.settings["app_pool_path"], app_ensemble_folder=aof.tests.settings["app_ensemble_folder"], documentation_docs_path=aof.tests.settings["documentation_docs_path"], META=META) self.testapp = TestApp(app) self.meta=ast.literal_eval(META)
def normalize_path(config, keyname): try: resolver = AssetResolver() path = config.registry.settings[keyname] return resolver.resolve(path).abspath() except KeyError: raise ConfigurationError("{} is not found in settings".format(keyname))
def register_less_bundle(cfg, name, path, description='', watchdir=None): """ Register less bundle; :param name: module name :param path: asset path :param description: """ resolver = AssetResolver() abs_path = resolver.resolve(path).abspath() if not os.path.isfile(abs_path): raise ConfigurationError("less file is required: %s" % path) discr = (ID_BUNDLE, name) intr = Introspectable(ID_BUNDLE, discr, name, ID_BUNDLE) intr['name'] = name intr['path'] = path intr['abs_path'] = abs_path intr['watchdir'] = watchdir or os.path.dirname(abs_path) intr['description'] = description storage = cfg.registry.setdefault(ID_BUNDLE, {}) storage[name] = intr cfg.action(discr, introspectables=(intr, ))
def xml_templates(): a = AssetResolver('pyramid_oereb') resolver = a.resolve('lib/renderer/extract/templates/xml') templates = TemplateLookup(directories=[resolver.abspath()], output_encoding='utf-8', input_encoding='utf-8') return templates
def register(): directories = [] resolver = AssetResolver(self.package_name) # defer spec resolution until register to allow for asset # overrides to take place in an earlier config phase for spec in specs: # the trailing slash helps match asset overrides for folders if not spec.endswith('/'): spec += '/' asset = resolver.resolve(spec) directory = asset.abspath() if not asset.isdir(): raise ConfigurationError('"%s" is not a directory' % directory) intr = self.introspectable( 'translation directories', directory, spec, 'translation directory', ) intr['directory'] = directory intr['spec'] = spec introspectables.append(intr) directories.append(directory) tdirs = self.registry.queryUtility(ITranslationDirectories) if tdirs is None: tdirs = [] self.registry.registerUtility(tdirs, ITranslationDirectories) if override: tdirs.extend(directories) else: for directory in reversed(directories): tdirs.insert(0, directory)
def add_layer(cfg, layer, name='', path='', description=''): """ add new layer :param layer: layer id :param name: name :param path: asset path :param description: module description """ if not path: raise ConfigurationError('Path is required') discr = (ID_LAYER, name, layer) resolver = AssetResolver() directory = resolver.resolve(path).abspath() intr = Introspectable(ID_LAYER, discr, name, ID_LAYER) intr['name'] = name intr['layer'] = layer intr['path'] = directory intr['asset'] = path intr['description'] = description intr['filters'] = {} storage = cfg.registry.setdefault(ID_LAYER, {}) layers = storage.setdefault(layer, []) layers.insert(0, intr) cfg.action(discr, introspectables=(intr,)) log.info("Add layer: %s path:%s"%(layer, path))
def register_handlebars_bundle(cfg, name, path='', description='', i18n_domain=''): """ Register handlebars bundle; :param name: module name :param path: asset path :param description: :param i18n_domain: i18n domain """ resolver = AssetResolver() abs_path = resolver.resolve(path).abspath() if not path or not os.path.isdir(abs_path): raise ConfigurationError("Directory is required: %s" % path) discr = (ID_AMD_MODULE, name) intr = Introspectable(ID_AMD_MODULE, discr, name, ID_AMD_MODULE) intr['name'] = name intr['path'] = path intr['abs_path'] = abs_path intr['description'] = description intr['i18n_domain'] = i18n_domain storage = cfg.registry.setdefault(ID_BUNDLE, {}) storage[name] = intr cfg.action(discr, introspectables=(intr, ))
def getabspath(fpath): from pyramid.path import AssetResolver a = AssetResolver('mypyramid') resolver = a.resolve(fpath) abspath = resolver.abspath() logging.debug(abspath) return abspath
class PyramidResolver(Resolver): def __init__(self, env): super(PyramidResolver, self).__init__(env) self.resolver = AssetResolver(None) def _split_asset_spec(self, item): if ':' in item: package, filepath = item.split(':', 1) try: package = self.resolver.resolve('%s:' % package).abspath() except ImportError as e: raise BundleError(e) return (package, filepath) else: return (None, item) def search_for_source(self, item): package, filepath = self._split_asset_spec(item) if package is None: return super(PyramidResolver, self).search_for_source(filepath) else: return self.consider_single_directory(package, filepath) def resolve_source_to_url(self, filepath, item): request = get_current_request() if request is not None: try: return request.static_url(filepath) except ValueError: pass return super(PyramidResolver, self).resolve_source_to_url(filepath, item) def resolve_output_to_path(self, target, bundle): package, filepath = self._split_asset_spec(target) if package is not None: target = path.join(package, filepath) return super(PyramidResolver, self).resolve_output_to_path(target, bundle) def resolve_output_to_url(self, item): request = get_current_request() package, filepath = self._split_asset_spec(item) if package is not None: item = path.join(package, filepath) else: if not path.isabs(filepath): item = path.join(self.env.directory, filepath) if request is not None: try: url = request.static_url(item) return url except ValueError: pass return super(PyramidResolver, self).resolve_output_to_url(item)
def get_parser(self, ini_filename='test.ini'): medici = AssetResolver('pyramid_analytics') app_path = medici.resolve('').abspath() project_path = path.split(app_path)[0] ini_path = path.join(project_path, 'pyramid_analytics', ini_filename) parser = configparser.SafeConfigParser() parser.read(ini_path) return parser
def __call__(self, info): resolver = AssetResolver(info.package) tmpl_path = resolver.resolve(info.name).abspath() return GenshiTemplateRenderer( path=tmpl_path, settings=info.settings, package=info.package, )
class AssetRendererFactory: def __init__(self, info): del info # unused self.resolver = AssetResolver('c2cgeoportal_geoportal') def __call__(self, value, system): asset = self.resolver.resolve(system['renderer_name']) return asset.stream().read()
def _get_asset_mtime(path): if ':' in path: package, path = path.split(':') resolver = AssetResolver(package) else: resolver = AssetResolver() fullpath = resolver.resolve(path).abspath() return int(os.path.getmtime(fullpath))
def add_amd_dir(cfg, path): data = cfg.get_settings()['amd.debug.data'] paths = data.setdefault('paths', []) resolver = AssetResolver() directory = resolver.resolve(path).abspath() paths.append((path, directory)) log.info("Add resource dir: %s" % path)
class AssetRendererFactory: def __init__(self, info: Any): del info # unused self.resolver = AssetResolver("c2cgeoportal_geoportal") def __call__(self, value: Any, system: Dict[str, str]) -> bytes: del value asset = self.resolver.resolve(system["renderer_name"]) return cast(bytes, asset.stream().read())
def favicon(request): settings = request.registry.settings favicon_path = settings.get('favicon_path', None) a = AssetResolver() if favicon_path: #only if an absolute path was given; otherwise, we'll accept #package path+'favicon.ico', e.g., 'myproject:static/favicon.ico' if os.path.isabs(favicon_path): favicon_path = os.path.join(favicon_path, 'favicon.ico') resolver = a.resolve(favicon_path) else: resolver = a.resolve('favicon.ico') icon_path = resolver.abspath() return FileResponse(icon_path , request=request)
def __init__(self, request): self.request = request resolver = AssetResolver() file_path = resolver.resolve('nadamusic:integrations.json').abspath() with open(file_path) as f: creds = json.load(f) self.client_id = creds['client_id'] self.client_secret = creds['client_secret'] self.redirect_uri = creds['redirect_uri'] self.scope = creds['scope']
def __init__(self, static_view_name: str, path: str, settings: dict): """Initialize CollectedStaticCacheBuster. :param static_view_name: Asset name. :param path: Asset path. :param settings: Configurations. """ self.settings = settings self.static_view_name = static_view_name r = AssetResolver() self.root = r.resolve(path).abspath()
def __init__(self, info): """ Creates a new XML renderer instance for versions rendering. Args: info (pyramid.interfaces.IRendererInfo): Info object. """ a = AssetResolver('pyramid_oereb') resolver = a.resolve('lib/renderer/versions/templates/xml') self.template_dir = resolver.abspath() super(Renderer, self).__init__(info)
def add_bower_components(config, path, name=None): resolver = AssetResolver() directory = resolver.resolve(path).abspath() bower = get_bower(config.registry) if name is None: name = bower.components_name components = bower.components(name, directory) log.info("Add bower components '{0}': {1}".format(components.name, path))
def _get_asset_hash(path): if ':' in path: package, path = path.split(':') resolver = AssetResolver(package) else: resolver = AssetResolver() fullpath = resolver.resolve(path).abspath() md5 = hashlib.md5() with open(fullpath, 'rb') as f: for chunk in iter(lambda: f.read(128 * md5.block_size), b''): md5.update(chunk) return md5.hexdigest()
def ResolveAsset(name, base=None, raiseExcp=True): """ Lookup asset path (template, json or any other file) and returns asset descriptor object or None. """ if not name: return None if not isinstance(name, basestring): return name if not base: base = caller_package() if name.startswith("./"): # use relative file system path name = os.getcwd()+name[1:] if not raiseExcp: try: d = AssetResolver(base) return d.resolve(name) except: return None d = AssetResolver(base) return d.resolve(name)
def backup_site(): """Run the site backup script. Runs the configured backup script ``websauna.backup_script``. The backup script can be any UNIX executable. The script gets the environment variables from *websauna* configuration, as exposed by :py:func:`websauna.utils.exportenv.create_settings_env`. In the case the backup script fails, an exception is raised and logged through normal application logging means. Run backup from the command line:: echo "from websauna.system.devop import backup ; backup.backup_site()" | pyramid-web20-shell development.ini Note that the output is buffered, so there might not be instant feedback. """ registry = get_current_registry() backup_script_spec = registry.settings.get("websauna.backup_script", "").strip() if not backup_script_spec: # Currently we do not have backup script defined, do not run return resolver = AssetResolver(None) backup_script = resolver.resolve(backup_script_spec).abspath() assert os.path.exists( backup_script), "Backup script does not exist: {}, spec {}".format( backup_script, backup_script_spec) assert stat.S_IXUSR & os.stat(backup_script)[ stat.ST_MODE], "Backup script is not executable: {}".format( backup_script) backup_timeout = int(registry.settings.get("websauna.backup_timeout")) # Export all secrets and settings env = create_settings_env(registry) try: subprocess.check_output([ backup_script, ], timeout=backup_timeout, stderr=subprocess.STDOUT, env=env) except subprocess.CalledProcessError as e: # Capture error to Sentry logger.error(e.output) raise
def add_layers(cfg, name='', path='', description=''): """ add new layers, read directory use first level folders as layer name :param name: name :param path: asset path :param description: module description """ resolver = AssetResolver() directory = resolver.resolve(path).abspath() for layer in os.listdir(directory): layer_path = os.path.join(directory, layer) if os.path.isdir(layer_path): add_layer(cfg, layer, name, layer_path, description)
def _load_asset(self, filename): """Load pyramid asset resource """ if ':' not in filename: raise IOError('Not a asset style path') resolver = AssetResolver(self.package) filepath = resolver.resolve(filename).abspath() fileobj = open(filepath, 'rt') mtime = os.path.getmtime(filepath) def _uptodate(): return mtime == os.path.getmtime(filepath) return filepath, filename, fileobj, _uptodate