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 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 create_app(settings):
from pyramid.config import Configurator
from pyramid.authorization import ACLAuthorizationPolicy
from pyramid.path import AssetResolver
from pyramid.response import FileResponse
from h.auth import HybridAuthenticationPolicy
from h.models import groupfinder
authn_policy = HybridAuthenticationPolicy(callback=groupfinder)
authz_policy = ACLAuthorizationPolicy()
config = Configurator(
settings=settings,
authentication_policy=authn_policy,
authorization_policy=authz_policy,
)
favicon = AssetResolver().resolve('h:favicon.ico')
config.add_route('favicon', '/favicon.ico')
config.add_view(
lambda request: FileResponse(favicon.abspath(), request=request),
route_name='favicon'
)
config.add_route('ok', '/ruok')
config.add_view(lambda request: 'imok', renderer='string', route_name='ok')
# Include all the pyramid subcomponents
config.include(includeme)
return config.make_wsgi_app()
def get_template(self, uri):
"""Fetch a template from the cache, or check the filesystem
for it
In addition to the basic filesystem lookup, this subclass will
use pkg_resource to load a file using the asset
specification syntax.
"""
isabs = os.path.isabs(uri)
if (not isabs) and (':' in uri):
# Windows can't cope with colons in filenames, so we replace the
# colon with a dollar sign in the filename mako uses to actually
# store the generated python code in the mako module_directory or
# in the temporary location of mako's modules
adjusted = uri.replace(':', '$')
try:
if self.filesystem_checks:
return self._check(adjusted, self._collection[adjusted])
else:
return self._collection[adjusted]
except KeyError:
asset = AssetResolver().resolve(uri)
if asset.exists():
srcfile = asset.abspath()
return self._load(srcfile, adjusted)
raise TopLevelLookupException(
"Can not locate template for uri %r" % uri)
try:
return TemplateLookup.get_template(self, uri)
except TemplateLookupException:
if isabs:
return self._load(uri, uri)
else:
raise
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 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 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 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,))
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 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 getabspath(fpath):
from pyramid.path import AssetResolver
a = AssetResolver('mypyramid')
resolver = a.resolve(fpath)
abspath = resolver.abspath()
logging.debug(abspath)
return abspath
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_md5(spec):
asset = AssetResolver(None).resolve(spec)
md5 = hashlib.md5()
with asset.stream() as stream:
for block in iter(lambda: stream.read(4096), b''):
md5.update(block)
return md5.hexdigest()
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 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 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 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 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 create_app(settings):
from horus import groupfinder
from pyramid.config import Configurator
from pyramid.authentication import AuthTktAuthenticationPolicy
from pyramid.authorization import ACLAuthorizationPolicy
from pyramid.path import AssetResolver
from pyramid.response import FileResponse
authn_policy = AuthTktAuthenticationPolicy(
settings['auth.secret'],
callback=groupfinder
)
authz_policy = ACLAuthorizationPolicy()
config = Configurator(
settings=settings,
authentication_policy=authn_policy,
authorization_policy=authz_policy,
root_factory='h.resources.RootFactory'
)
favicon = AssetResolver().resolve('h:favicon.ico')
config.add_route('favicon', '/favicon.ico')
config.add_view(
lambda request: FileResponse(favicon.abspath(), request=request),
route_name='favicon'
)
config.include(includeme)
return config.make_wsgi_app()
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 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 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 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 __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 __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
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)
def setUp(self):
# Sets up the AppPool for Testing with two apps (one with maximum attributes one with minimum attributes)
self.config = testing.setUp(settings=aof.tests.settings)
a = AssetResolver()
self.path = a.resolve(aof.tests.settings["app_pool_path"]).abspath()
self.ap=AppPool.Instance()
self.ap.load(source=self.path, format="turtle")
self.maxApp=URIRef("http://mustermann.de/maxApp")
self.minApp=URIRef("http://mustermann.de/minApp")
def get_rpath(filename):
a = AssetResolver('inventory')
resolver = a.resolve(''.join(['reports/',filename]))
return resolver.abspath()
class LayersCommand(object):
parser = argparse.ArgumentParser(description="player management")
parser.add_argument('config', metavar='config', help='ini config file')
# layers/templates
parser.add_argument('-l',
action="store",
nargs="*",
dest='layers',
help='List layers')
parser.add_argument('-lt',
action="store",
nargs="*",
dest='templates',
help='List templates')
parser.add_argument('-c',
action="store",
nargs=2,
dest='customize',
help='Customize template')
def __init__(self, args):
self.options = args
self.env = bootstrap(args.config)
self.registry = self.env['registry']
self.resolver = AssetResolver()
def run(self):
if self.options.layers is not None:
self.list_layers()
elif self.options.templates is not None:
self.list_templates()
elif self.options.customize is not None:
self.customize()
else:
self.parser.print_help()
def customize(self):
storage = self.registry.get(ID_LAYER, {})
tmpl, dest = self.options.customize
# find template
if ':' not in tmpl:
print('Template format is wrong.')
return
layer, tname = tmpl.split(':', 1)
if tname.endswith('.lt'):
tname = tname[:-3]
if layer not in storage:
print('Layer "%s" could not be found.' % layer)
return
extensions = [
name for name, factory in self.registry.getUtilitiesFor(
IRendererFactory) if name.startswith('.')
]
template_path = None
layer_data = storage[layer]
for intr in layer_data:
for ext in extensions:
fname = os.path.join(intr['path'], '%s%s' % (tname, ext))
if os.path.exists(fname):
template_path = fname
break
if template_path is None:
print('Template "%s" could not be found.' % tmpl)
return
# get destination directory
dest_path = os.path.abspath(dest)
if not os.path.isdir(dest_path):
dest_path = self.resolver.resolve(dest).abspath()
if not os.path.isdir(dest_path):
print('Destination directory is not found.')
return
shutil.copy(template_path, dest_path)
print('Source: "%s"' % template_path)
print('Destination: "%s"' %
os.path.join(dest_path,
os.path.split(template_path)[-1]))
def list_layers(self):
storage = self.registry.get(ID_LAYER)
if not storage:
print('No layers are found.')
return
storage = sorted(storage.items())
filter = [s.strip().split(':', 1)[0] for s in self.options.layers]
for name, layers in storage:
if filter and name not in filter:
continue
print(grpTitleWrap.fill('Layer: %s' % name))
for layer in layers:
print(grpDescriptionWrap.fill('name: %s' % layer['name']))
print(grpDescriptionWrap.fill('path: %s' % layer['asset']))
print()
def list_templates(self):
storage = self.registry.get(ID_LAYER)
if not storage:
print('No layers are found.')
return
print()
storage = sorted(storage.items())
f_layers = [s.strip().split(':', 1)[0] for s in self.options.templates]
factories = dict((name, factory) for name, factory in
self.registry.getUtilitiesFor(IRendererFactory)
if name.startswith('.'))
for name, layers in storage:
if f_layers and name not in f_layers:
continue
print(grpTitleWrap.fill('Layer: %s' % name))
tmpls = {}
for layer in layers:
if os.path.isdir(layer['path']):
for name in os.listdir(layer['path']):
if '.' in name:
rname, rtype = os.path.splitext(name)
key = (layer['asset'], rname)
if rtype in factories and key not in tmpls:
tmpls[key] = rtype
curr_asset = None
for (asset, rname), rtype in sorted(tmpls.items()):
if curr_asset != asset:
curr_asset = asset
print('')
print(grpDescriptionWrap.fill(asset))
if rname in layer['filters']:
f = layer['filters'][rname]
sinfo = ('%s.py: %s' %
(f.__module__.replace('.', '/'), f.__name__))
print(
grpThirdLevelWrap.fill('%s: %s (%s)' %
(rname, rtype, sinfo)))
else:
print(grpThirdLevelWrap.fill('%s: %s' %
(rname, rtype)))
print()
def resolvecss(data, spec):
if ':' in spec:
pkg, name = spec.split(':', 1)
return AssetResolver(pkg).resolve(name).stream().read()
return resolve(spec)(data)
from .handlebars import list_bundles
log = logging.getLogger('pyramid_amdjs')
ID_AMD_SPEC = 'pyramid_amdjs:amd-spec'
ID_AMD_SPEC_ = 'pyramid_amdsj:amd-spec_'
ID_AMD_MODULE = 'pyramid_amdjs:amd-module'
ID_AMD_BUILD = 'pyramid_amdjs:build-init'
ID_AMD_MD5 = 'pyramid_amdjs:md5-init'
ID_AMD_BUILD_MD5 = 'pyramid_amdjs:build-md5-init'
JS_MOD = 1
CSS_MOD = 2
RESOLVER = AssetResolver()
CURL_PATH = RESOLVER.resolve('pyramid_amdjs:static/lib/curl.js').abspath()
def init_amd_spec(config, cache_max_age=None):
cfg = config.get_settings()
if not cfg['amd.spec']:
return
if not cfg['amd.spec-dir']:
raise ConfigurationError("amd.spec-dir is required.")
directory = RESOLVER.resolve(cfg['amd.spec-dir']).abspath()
# register static view
config.add_static_view('_amdjs/bundles/', directory)
"""
command = App(
'hypothesis',
version=version,
description=description,
opts=pserve.PServeCommand.parser.option_list[1:],
args_callback=get_config,
)
# Teach urlparse about extension schemes
uses_netloc.append('chrome-extension')
uses_relative.append('chrome-extension')
# Fetch an asset spec resolver
resolve = AssetResolver().resolve
def add_base_url(event):
request = event['request']
assets_env = request.webassets_env
view_name = getattr(request, 'view_name', None)
if view_name == 'embed.js' and not assets_env.debug:
base_url = join(request.webassets_env.url, 'app.html')
else:
base_url = request.resource_url(request.context, 'app')
event['base_url'] = base_url
def abspath(asset_spec):
return Path(AssetResolver().resolve(asset_spec).abspath())
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)
except AttributeError as e: # pragma: no cover
if e.message == "'NoneType' object has no attribute 'static_url'":
# render() has been called outside of a request
# e.g., to compile assets before handling requests
# and so failure is acceptable
pass
else:
raise
def json_asset(spec, **kw):
utf8 = codecs.getreader("utf-8")
asset = AssetResolver(caller_package()).resolve(spec)
return json.load(utf8(asset.stream()), **kw)
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from pyramid.httpexceptions import HTTPMethodNotAllowed
from pyramid.path import AssetResolver
from pyramid.tweens import INGRESS, EXCVIEW
from pyramid.response import FileResponse
from webob.multidict import MultiDict
from whitenoise import WhiteNoise
resolver = AssetResolver()
def whitenoise_tween_factory(handler, registry):
def whitenoise_tween(request):
whn = request.registry.whitenoise
if whn.autorefresh:
static_file = whn.find_file(request.path_info)
else:
static_file = whn.files.get(request.path_info)
# We could not find a static file, so we'll just continue processing
# this as normal.
if static_file is None:
return handler(request)
class PyramidResolver(Resolver):
def __init__(self):
super(PyramidResolver, self).__init__()
self.resolver = AssetResolver(None)
def _split_spec(self, item):
if ':' in item:
package, subpath = item.split(':', 1)
return (package, subpath)
else:
return (None, item)
def _resolve_spec(self, spec):
package, subpath = self._split_spec(spec)
try:
pkgpath = self.resolver.resolve(package + ':').abspath()
except ImportError as e:
raise BundleError(e)
else:
return path.join(pkgpath, subpath)
def search_for_source(self, ctx, item):
package, subpath = self._split_spec(item)
if package is None:
if USING_WEBASSETS_CONTEXT:
return super(PyramidResolver,
self).search_for_source(ctx, item)
else: # pragma: no cover
return super(PyramidResolver, self).search_for_source(item)
else:
pkgpath = self._resolve_spec(package + ':')
return self.consider_single_directory(pkgpath, subpath)
def resolve_source_to_url(self, ctx, filepath, item):
request = get_current_request()
# Use the filepath to reconstruct the item without globs
package, _ = self._split_spec(item)
if package is not None:
pkgdir = self._resolve_spec(package + ':')
if filepath.startswith(pkgdir):
item = '{}:{}'.format(package, filepath[len(pkgdir):])
# Attempt to resolve the filepath as passed (but after versioning).
# If this fails, it may be because the static route was registered
# with an asset spec. In this case, the original item may also be
# an asset spec contained therein, so try to resolve that.
if request is not None:
for attempt in (filepath, item):
try:
return request.static_url(attempt)
except ValueError:
pass
if USING_WEBASSETS_CONTEXT:
return super(PyramidResolver,
self).resolve_source_to_url(ctx, filepath, item)
else: # pragma: no cover
return super(PyramidResolver,
self).resolve_source_to_url(filepath, item)
def resolve_output_to_path(self, ctx, target, bundle):
package, filepath = self._split_spec(target)
if package is not None:
pkgpath = self._resolve_spec(package + ':')
target = path.join(pkgpath, filepath)
if USING_WEBASSETS_CONTEXT:
return super(PyramidResolver,
self).resolve_output_to_path(ctx, target, bundle)
else: # pragma: no cover
return super(PyramidResolver,
self).resolve_output_to_path(target, bundle)
def resolve_output_to_url(self, ctx, item):
request = get_current_request()
if not path.isabs(item):
if ':' not in item:
if 'asset_base' in ctx.config:
if ctx.config['asset_base'].endswith(':'):
item = ctx.config['asset_base'] + item
else:
item = path.join(ctx.config['asset_base'], item)
else:
item = path.join(ctx.directory, item)
if ':' in item:
filepath = self._resolve_spec(item)
else:
filepath = item
if request is not None:
for attempt in (filepath, item):
try:
return request.static_url(item)
except ValueError:
pass
if USING_WEBASSETS_CONTEXT:
return super(PyramidResolver,
self).resolve_output_to_url(ctx, filepath)
else: # pragma: no cover
return super(PyramidResolver, self).resolve_output_to_url(filepath)
def __init__(self, info):
del info # unused
self.resolver = AssetResolver('c2cgeoportal_geoportal')
def __init__(self, package: str, base_path: str, param: str = "x") -> None:
super().__init__(param=param)
self.asset_resolver = AssetResolver(package)
self.base_path = base_path
self.token_cache: Dict[str, str] = {}
from pyramid.view import view_config
from pyramid.httpexceptions import HTTPFound
from pyramid.security import remember, forget
from pyramid.response import Response
from pyramid.path import AssetResolver
from ..services.user import UserService
from ..services.blog_record import BlogRecordService
from ..forms import RegistrationForm, LoginForm
from ..models.user import User
resolver = AssetResolver()
# _robots = /static/robots.txt
_robots = open(
resolver.resolve('nadamusic:static/robots.txt').abspath()).read()
_robots_response = Response(content_type='text/plain', body=_robots)
@view_config(name='robots.txt')
def robotstxt_view(context, request):
return _robots_response
@view_config(route_name='index', renderer='nadamusic:templates/index.jinja2')
def index_page(request):
page = int(request.params.get('page', 1))
paginator = BlogRecordService.get_paginator(request, page)
return {'paginator': paginator}
def __init__(self, static_view_name, path, settings: dict):
self.settings = settings
self.static_view_name = static_view_name
r = AssetResolver()
self.root = r.resolve(path).abspath()
def includeme(cfg):
cfg.include('pyramid_chameleon')
import os
from pyramid.path import AssetResolver
from pyramid.settings import aslist
from pyramid.exceptions import ConfigurationError
from ptah.renderer.renderer import lt_renderer_factory
from ptah.renderer.layer import add_layer, add_layers, change_layers_order
from ptah.renderer.layer import add_tmpl_filter
from ptah.renderer.layout_impl import add_layout, set_layout_data
# config directives
cfg.add_directive('add_layer', add_layer)
cfg.add_directive('add_layers', add_layers)
cfg.add_directive('add_layout', add_layout)
cfg.add_directive('add_tmpl_filter', add_tmpl_filter)
# request.render_tmpl
cfg.add_request_method(render, 'render_tmpl')
# request.set_layout_data
cfg.add_request_method(set_layout_data, 'set_layout_data')
def get_layout_data(request):
return {}
cfg.add_request_method(get_layout_data, 'layout_data', True, True)
# renderer factory
cfg.add_renderer('.lt', lt_renderer_factory)
# layout renderer
cfg.add_renderer('ptah.renderer:layout', layout)
# order
settings = cfg.get_settings()
order = {}
for key, val in settings.items():
if key.startswith('layer.order.'):
layer = key[12:]
order[layer] = [s.strip() for s in aslist(val)]
if order:
cfg.action(
'ptah.renderer.order',
change_layers_order, (cfg, order), order=999999+1)
# global custom layer
custom = settings.get('layer.custom', '').strip()
if custom:
resolver = AssetResolver()
directory = resolver.resolve(custom).abspath()
if not os.path.isdir(directory):
raise ConfigurationError(
"Directory is required for layer.custom setting: %s"%custom)
cfg.action(
'ptah.renderer.custom',
add_layers, (cfg, 'layer_custom', custom), order=999999+2)
# formatters
from ptah.renderer import formatter
cfg.add_directive('add_formatter', formatter.add_formatter)
cfg.add_request_method(formatter.formatters, 'fmt', True, True)
# messages layer and request helpers
from ptah.renderer.message import render_messages
cfg.add_layer('message', path='ptah.renderer:templates/message/')
cfg.add_request_method(add_message, 'add_message')
cfg.add_request_method(render_messages, 'render_messages')
def spec_stream(self):
return AssetResolver().resolve(self.spec_path).stream()
def extension(args, console):
"""Build the browser extensions.
Accepts one (optional) argument which is the base URL of an h server."""
if len(args) == 0:
console.error('You must supply a paste configuration file.')
return 2
if len(args) < 2:
console.error('You must supply a url to the hosted backend.')
return 2
from codecs import open
from os import makedirs
from os.path import abspath, exists, join
from shutil import copyfile, copytree, rmtree
from urlparse import (
urljoin,
urlparse,
urlunparse,
uses_netloc,
uses_relative,
)
from chameleon.zpt.template import PageTextTemplateFile
from pyramid.path import AssetResolver
from pyramid.renderers import get_renderer, render
from pyramid.settings import asbool
from pyramid_webassets import IWebAssetsEnvironment
from h import bootstrap, layouts
resolve = AssetResolver().resolve
def make_relative(request, url):
assets_url = request.webassets_env.url
if url.startswith(assets_url):
return url[len(assets_url):].strip('/')
return url
def app(env, base_url=None):
asset_env = env['registry'].queryUtility(IWebAssetsEnvironment)
request = env['request']
context = request.context
base_template = get_renderer('h:templates/base.pt').implementation()
api_url = request.registry.settings.get('api.url', None)
api_url = api_url or urljoin(request.host_url, '/api/')
app_layout = layouts.SidebarLayout(context, request)
app_page = render(
'h:templates/app.pt', {
'base_url': base_url,
'layout': {
'css_links': app_layout.css_links,
'js_links': app_layout.js_links,
'csp': '',
'inline_webfont': False,
},
'main_template': base_template,
'request': request,
'service_url': api_url,
})
app_html_file = join(asset_env.directory, 'app.html')
with open(app_html_file, 'w', 'utf-8-sig') as f:
f.write(app_page)
def chrome(env):
registry = env['registry']
request = env['request']
asset_env = registry.queryUtility(IWebAssetsEnvironment)
settings = registry.settings
develop = asbool(settings.get('webassets.debug', False))
# Root the request at the app url
app_url = urlparse(args[1])
request.host = app_url.netloc
request.scheme = app_url.scheme
app_url = urlunparse(app_url)
# Fully-qualify the static asset url
asset_url = urlparse(asset_env.url)
if not asset_url.netloc:
asset_url = (
request.scheme,
request.host,
asset_url.path,
asset_url.params,
asset_url.query,
asset_url.fragment,
)
asset_url = urlunparse(asset_url)
# Configure the load path and output url
asset_env.append_path(resolve('h:').abspath(), asset_url)
asset_env.url = asset_url
def getUrl(url):
if not develop:
rel = make_relative(request, url)
if rel != url:
return "chrome.extension.getURL('public/%s')" % rel
return '"%s"' % url
if develop:
# Load the app from the development server.
app_expr = json.dumps(app_url)
else:
# Load the app from the extension bundle.
app_expr = "chrome.extension.getURL('public/app.html')"
# Build the app html
app(env, base_url=app_url)
embed = render(
'h:templates/embed.txt',
{
'app':
app_expr,
'options':
json.dumps({
'Heatmap': {
"container": '.annotator-frame',
},
'Toolbar': {
'container': '.annotator-frame',
},
}),
'role':
json.dumps('host'),
'inject':
'[%s]' %
', '.join([getUrl(url) for url in asset_env['inject'].urls()]),
'jquery':
getUrl(asset_env['jquery'].urls()[0]),
'raf':
getUrl(asset_env['raf'].urls()[0]),
},
request=request,
)
embed_js_file = join(asset_env.directory, 'js/embed.js')
with open(embed_js_file, 'w', 'utf-8-sig') as f:
f.write(embed)
# Chrome is strict about the format of the version string
ext_version = '.'.join(version.replace('-', '.').split('.')[:4])
manifest_file = resolve('h:browser/chrome/manifest.json').abspath()
manifest_renderer = PageTextTemplateFile(manifest_file)
manifest = manifest_renderer(src=asset_url, version=ext_version)
manifest_json_file = join('./build/chrome', 'manifest.json')
with open(manifest_json_file, 'w', 'utf-8-sig') as f:
f.write(manifest)
# Due to Content Security Policy, the web font script cannot be inline.
webfont = resolve('h:templates/webfont.js').abspath()
copyfile(webfont, join(asset_env.directory, 'webfont.js'))
# Make sure the common build dir exists
if not exists('./build'): makedirs('./build')
# Build the chrome extension
if exists('./build/chrome'): rmtree('./build/chrome')
copytree(resolve('h:browser/chrome').abspath(), './build/chrome')
copytree(resolve('h:images').abspath(), './build/chrome/public/images')
copytree(resolve('h:lib').abspath(), './build/chrome/public/lib')
settings = {'webassets.base_dir': abspath('./build/chrome/public')}
# Override static asset route generation with the STATIC_URL argument
if len(args) > 2:
settings.update({
'webassets.base_url': args[2],
})
# Make sure urlparse understands chrome-extension:// URLs
uses_netloc.append('chrome-extension')
uses_relative.append('chrome-extension')
bootstrap(args[0], options=settings, config_fn=chrome)
def __init__(self, env):
Resolver.__init__(self, env)
self.resolver = AssetResolver(None)
def __init__(self, args):
self.options = args
self.env = bootstrap(args.config)
self.registry = self.env['registry']
self.resolver = AssetResolver()
from pyramid.i18n import TranslationStringFactory, get_localizer
from pyramid.path import AssetResolver
from pyramid.response import Response
from pyramid.security import effective_principals
from pyramid.threadlocal import get_current_request
from pyramid.view import view_config
from sqlalchemy.orm.exc import NoResultFound, MultipleResultsFound
from lokp.config.files import upload_directory_path, upload_max_file_size
from lokp.models import File, DBSession, Activity, A_Tag_Group, A_Tag, A_Key, \
A_Value
from lokp.utils.files import get_valid_file_extension, get_file_size, \
clean_filename, get_file_hash, get_folders_from_identifier
from lokp.utils.views import validate_uuid
lokpAssetResolver = AssetResolver('lokp')
log = logging.getLogger(__name__)
_ = TranslationStringFactory('lokp')
@view_config(route_name='file_upload_form_embedded',
permission='edit',
renderer='lokp:templates/form/fileupload_embedded.mak')
def file_upload_form_embedded(request):
class MemoryTmpStore(dict):
def preview_url(self, uid):
return None
tmpStore = MemoryTmpStore()
class Schema(colander.Schema):
def _getHash(self, package, path):
import hashlib
from pyramid.path import AssetResolver
abspath = AssetResolver(package).resolve(path).abspath()
with open(abspath, 'rb') as f:
return hashlib.md5(f.read()).hexdigest()[:8]
def _normalize_source_path(self, spath):
# spath might be an asset spec
try:
spath = AssetResolver(None).resolve(spath).abspath()
except ImportError, e:
raise BundleError(e)
def get_webassets_env_from_settings(settings, prefix='webassets'):
"""This function will take all webassets.* parameters, and
call the ``Environment()`` constructor with kwargs passed in.
The only two parameters that are not passed as keywords are:
* base_dir
* base_url
which are passed in positionally.
Read the ``WebAssets`` docs for ``Environment`` for more details.
"""
# Make a dictionary of the webassets.* elements...
kwargs = {} # assets settings
cut_prefix = len(prefix) + 1
for k in settings:
if k.startswith(prefix):
val = settings[k]
if isinstance(val, six.string_types):
if val.lower() in auto_booly:
val = asbool(val)
elif val.lower().startswith(
'json:') and k[cut_prefix:] != 'manifest':
val = json.loads(val[5:])
kwargs[k[cut_prefix:]] = val
if 'base_dir' not in kwargs:
raise Exception(
"You need to provide webassets.base_dir in your configuration")
if 'base_url' not in kwargs:
raise Exception(
"You need to provide webassets.base_url in your configuration")
asset_dir = kwargs.pop('base_dir')
asset_url = kwargs.pop('base_url')
if ':' in asset_dir:
try:
asset_dir = AssetResolver(None).resolve(asset_dir).abspath()
except ImportError:
pass
if 'debug' in kwargs:
kwargs['debug'] = maybebool(kwargs['debug'])
if 'cache' in kwargs:
cache = kwargs['cache'] = maybebool(kwargs['cache'])
if cache and isinstance(cache,
six.string_types) and not path.isdir(cache):
makedirs(cache)
# 'updater' is just passed in...
if 'auto_build' in kwargs:
kwargs['auto_build'] = maybebool(kwargs['auto_build'])
if 'jst_compiler' in kwargs:
kwargs['JST_COMPILER'] = kwargs.pop('jst_compiler')
if 'jst_namespace' in kwargs:
kwargs['JST_NAMESPACE'] = kwargs.pop('jst_namespace')
if 'manifest' in kwargs:
kwargs['manifest'] = maybebool(kwargs['manifest'])
if 'url_expire' in kwargs:
kwargs['url_expire'] = maybebool(kwargs['url_expire'])
if 'static_view' in kwargs:
kwargs['static_view'] = asbool(kwargs['static_view'])
else:
kwargs['static_view'] = False
if 'cache_max_age' in kwargs:
kwargs['cache_max_age'] = int(kwargs.pop('cache_max_age'))
else:
kwargs['cache_max_age'] = None
if 'load_path' in kwargs:
# force load_path to be an array and split on whitespace
if not isinstance(kwargs['load_path'], list):
kwargs['load_path'] = kwargs['load_path'].split()
paths = kwargs.pop('paths', None)
if 'bundles' in kwargs:
if isinstance(kwargs['bundles'], six.string_types):
kwargs['bundles'] = kwargs['bundles'].split()
bundles = kwargs.pop('bundles', None)
assets_env = Environment(asset_dir, asset_url, **kwargs)
if paths is not None:
for map_path, map_url in json.loads(paths).items():
assets_env.append_path(map_path, map_url)
def yaml_stream(fname):
if path.exists(fname):
return open(fname, 'rb')
else:
return assets_env.resolver.resolver.resolve(fname).stream()
if isinstance(bundles, list):
loaded = {}
for bpath in bundles:
with closing(yaml_stream(bpath)) as s:
loader = YAMLLoader(s)
loaded.update(loader.load_bundles())
assets_env.register(loaded)
elif isinstance(bundles, dict):
assets_env.register(bundles)
return assets_env
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()
env = self.env
# Attempt to resolve the filepath as passed (but after versioning).
# If this fails, it may be because the static route was registered
# with an asset spec. In this case, the original item may also be
# an asset spec contained therein, so try to resolve that.
if request is not None:
for attempt in (filepath, item):
try:
return request.static_url(attempt)
except:
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()
# Attempt to resolve the output item. First, resolve the item if its
# an asset spec. If it's a relative path, construct a url from the
# environment base url, which may be an asset spec that the base class
# cannot handle. Try to resolve this url and the item against the
# `static_url` method.
url = None
package, filepath = self._split_asset_spec(item)
if package is None:
if not path.isabs(filepath):
item = path.join(self.env.directory, filepath)
url = path.join(self.env.url, filepath)
else:
item = path.join(package, filepath)
if url is None:
url = super(PyramidResolver, self).resolve_output_to_url(item)
for attempt in (url, item):
try:
return request.static_url(attempt)
except:
pass
return url
"d": polygon((20, 2), (38, 20), (20, 38), (2, 20)), # diamond
}
def pyxColor(string):
"""
:param string: RGB color name like 'ffffff'
:return: pyx color.
>>> assert pyxColor('ffffff')
"""
assert len(string) == 6
colorTuple = tuple(
int('0x' + c, 16) for c in [string[i:i + 2] for i in range(0, 6, 2)])
return color.rgb(*[i / 255.0 for i in colorTuple])
if __name__ == '__main__': # pragma: no cover
if not pyx:
sys.exit(1)
asset_resolver = AssetResolver()
for icon in ICONS:
c = canvas.canvas()
c.draw(
shapes[icon.name[0]],
[deco.stroked([linewidth]), deco.filled([pyxColor(icon.name[1:])])])
stream = c.pipeGS("pngalpha", resolution=20, bbox=bbox.bbox(0, 0, 40, 40))
with open(asset_resolver.resolve(icon.asset_spec).abspath(), 'wb') as fp:
fp.write(stream.read())
sys.exit(0)
def __init__(self, env):
super(PyramidResolver, self).__init__(env)
self.resolver = AssetResolver(None)
def __init__(self, info: Any):
del info # unused
self.resolver = AssetResolver("c2cgeoportal_geoportal")
