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 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
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)
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 __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 __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 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 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 getabspath(fpath):
from pyramid.path import AssetResolver
a = AssetResolver('mypyramid')
resolver = a.resolve(fpath)
abspath = resolver.abspath()
logging.debug(abspath)
return abspath
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
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,
)
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
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 __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,
)
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
