def create_mailer(registry: Registry) -> IMailer:
"""Create a new mailer instance.
"""
settings = registry.settings
# Empty values are not handled gracefully, so mutate them here before passing forward to mailer
if settings.get("mail.username", "x") == "":
settings["mail.username"] = None
if settings.get("mail.password", "x") == "":
settings["mail.password"] = None
mailer_class = settings.get("websauna.mailer", "")
if mailer_class in ("mail", ""):
# TODO: Make mailer_class explicit so we can dynamically load pyramid_mail.Mailer
# Default
from pyramid_mailer import mailer_factory_from_settings
mailer = mailer_factory_from_settings(settings)
else:
# debug backend
resolver = DottedNameResolver()
mailer_cls = resolver.resolve(mailer_class)
mailer = mailer_cls()
return mailer
def get_profile(self, request=None):
"""
Returns AuthUser.profile object, creates record if it doesn't exist.
.. code-block:: python
from apex.models import AuthUser
user = AuthUser.get_by_id(1)
profile = user.get_profile(request)
in **development.ini**
.. code-block:: python
apex.auth_profile =
"""
if not request:
request = get_current_request()
auth_profile = request.registry.settings.get('apex.auth_profile')
if auth_profile:
resolver = DottedNameResolver(auth_profile.split('.')[0])
profile_cls = resolver.resolve(auth_profile)
return get_or_create(DBSession, profile_cls, auth_id=self.id)
def check_password(cls, **kwargs):
if kwargs.has_key('id'):
user = cls.get_by_id(kwargs['id'])
if kwargs.has_key('login'):
user = cls.get_by_login(kwargs['login'])
request = get_current_request()
use_sha256 = asbool(request.registry.settings.get('apex.use_sha256'))
if not user:
return False
try:
if use_sha256:
pw = kwargs['password']
if CRYPTPasswordManager(SHA256CRYPT).check(user.password, pw):
return True
else:
pw = kwargs['password'] + user.salt
if BCRYPTPasswordManager().check(user.password, pw):
return True
except TypeError:
pass
fallback_auth = request.registry.settings.get('apex.fallback_auth')
if fallback_auth:
resolver = DottedNameResolver(fallback_auth.split('.', 1)[0])
fallback = resolver.resolve(fallback_auth)
pw = kwargs['password']
return fallback().check(DBSession, request, user, pw)
return False
def check_password(cls, **kwargs):
if 'id' in kwargs:
user = cls.get_by_id(kwargs['id'])
if 'login' in kwargs:
user = cls.get_by_login(kwargs['login'])
if not user:
return False
try:
if BCRYPTPasswordManager().check(user.password,
'%s%s' % (kwargs['password'],
user.salt)):
return True
except TypeError:
pass
request = get_current_request()
fallback_auth = request.registry.settings.get('apex.fallback_auth')
if fallback_auth:
resolver = DottedNameResolver(fallback_auth.split('.', 1)[0])
fallback = resolver.resolve(fallback_auth)
return fallback().check(DBSession, request, user,
kwargs['password'])
return False
def get_storage_factory(settings, prefix='filestore'):
"""Uses a Pyramid deployment settings dictionary to construct and return
an instance of a :class:`FileStorage` subclass.
The `prefix` will be used to extract storage configuration. The package to
use is determined by the `$prefix` config setting, and any setting named
`$prefix.$key` will be passed to the subclass constructor as `$key`.
The `$prefix` config setting may be either the full dotted python name of a
data manager class, or the name of one of the modules in the
floof.model.filestore namespace, currently `local` or `mogilefs`.
"""
# Pull prefix.key out of the config object
kwargs = {}
plen = len(prefix)
for key, val in settings.iteritems():
if key[0:plen] == prefix and len(key) > plen:
kwargs[ key[plen+1:] ] = val
# Resolve the data manager
resolver = DottedNameResolver(None)
manager = settings[prefix]
name = 'floof.model.filestore.' + manager + '.FileStorage'
try:
storage = resolver.resolve(name)
except ImportError:
storage = resolver.resolve(manager)
def storage_factory():
"""Returns an instance of the chosen data manager for attachement to a
request object and use over the life of a single request. The instance
must be manually joined to a Zope-style transaction."""
return storage(transaction.manager, **kwargs)
return storage_factory
def disqus_comments_view(context, request):
settings = get_settings_util()
available = settings.get('kotti_disqus-disqus_available_types', [])
available += get_settings()['kotti_disqus.extra_types'].split()
resolver = DottedNameResolver(None)
types = tuple(resolver.resolve(typ) for typ in available)
if not isinstance(context, types):
raise PredicateMismatch()
api = template_api(context, request)
disqus_url = ''
disqus_shortname = settings['kotti_disqus-disqus_shortname']
base_url = settings['kotti_disqus-disqus_base_url'].strip('/')
if base_url:
disqus_url = base_url + api.url(context)[len(request.application_url):]
else:
disqus_url = api.url(context)
return {
'disqus_shortname': disqus_shortname,
'disqus_url': disqus_url,
}
def base_config(**settings):
from pyramid.authorization import ACLAuthorizationPolicy
resolver = DottedNameResolver()
setup_defaults(settings)
authn_policy = resolver.maybe_resolve(settings['arche.authn_factory'])(settings)
authz_policy = ACLAuthorizationPolicy()
return Configurator(root_factory = root_factory,
settings = settings,
authentication_policy = authn_policy,
authorization_policy = authz_policy,)
def renderer_factory(info):
path = info.name
registry = info.registry
settings = info.settings
lookup = registry.queryUtility(IMakoLookup)
if lookup is None:
reload_templates = settings.get('reload_templates', False)
directories = settings.get('mako.directories', None)
module_directory = settings.get('mako.module_directory', None)
input_encoding = settings.get('mako.input_encoding', 'utf-8')
error_handler = settings.get('mako.error_handler', None)
default_filters = settings.get('mako.default_filters', 'h')
imports = settings.get('mako.imports', None)
strict_undefined = settings.get('mako.strict_undefined', 'false')
preprocessor = settings.get('mako.preprocessor', None)
if directories is None:
raise ConfigurationError(
'Mako template used without a ``mako.directories`` setting')
if not is_nonstr_iter(directories):
directories = list(filter(None, directories.splitlines()))
directories = [ abspath_from_asset_spec(d) for d in directories ]
if module_directory is not None:
module_directory = abspath_from_asset_spec(module_directory)
if error_handler is not None:
dotted = DottedNameResolver(info.package)
error_handler = dotted.maybe_resolve(error_handler)
if default_filters is not None:
if not is_nonstr_iter(default_filters):
default_filters = list(filter(
None, default_filters.splitlines()))
if imports is not None:
if not is_nonstr_iter(imports):
imports = list(filter(None, imports.splitlines()))
strict_undefined = asbool(strict_undefined)
if preprocessor is not None:
dotted = DottedNameResolver(info.package)
preprocessor = dotted.maybe_resolve(preprocessor)
lookup = PkgResourceTemplateLookup(directories=directories,
module_directory=module_directory,
input_encoding=input_encoding,
error_handler=error_handler,
default_filters=default_filters,
imports=imports,
filesystem_checks=reload_templates,
strict_undefined=strict_undefined,
preprocessor=preprocessor)
registry_lock.acquire()
try:
registry.registerUtility(lookup, IMakoLookup)
finally:
registry_lock.release()
return MakoLookupTemplateRenderer(path, lookup)
def includeme(config):
resolver = DottedNameResolver()
service_name = config.registry.settings.get("sms.service")
if not service_name:
raise SMSConfigurationError("sms.service setting missing")
service_cls = resolver.resolve(service_name)
if not service_cls:
raise SMSConfigurationError("Not a valid sms.service: {}".format(service_name))
config.registry.registerAdapter(factory=service_cls, required=(IRequest,), provided=ISMSService)
def pshell_file_config(self, filename):
resolver = DottedNameResolver(None)
self.loaded_objects = {}
self.object_help = {}
config = self.ConfigParser()
config.read(filename)
try:
items = config.items('pshell')
except ConfigParser.NoSectionError:
return
for k, v in items:
self.loaded_objects[k] = resolver.maybe_resolve(v)
self.object_help[k] = v
def includeme(config):
"""
Pyramid entry point
"""
settings = config.registry.settings
config.add_tween('rollbar.contrib.pyramid.rollbar_tween_factory', under=EXCVIEW)
# run patch_debugtoolbar, unless they disabled it
if asbool(settings.get('rollbar.patch_debugtoolbar', True)):
patch_debugtoolbar(settings)
def hook(request, data):
data['framework'] = 'pyramid'
if request:
request.environ['rollbar.uuid'] = data['uuid']
if request.matched_route:
data['context'] = request.matched_route.name
rollbar.BASE_DATA_HOOK = hook
kw = parse_settings(settings)
access_token = kw.pop('access_token')
environment = kw.pop('environment', 'production')
if kw.get('scrub_fields'):
kw['scrub_fields'] = set([str.strip(x) for x in kw.get('scrub_fields').split('\n') if x])
if kw.get('exception_level_filters'):
r = DottedNameResolver()
exception_level_filters = []
for line in kw.get('exception_level_filters').split('\n'):
if line:
dotted_path, level = line.split()
try:
cls = r.resolve(dotted_path)
exception_level_filters.append((cls, level))
except ImportError:
log.error('Could not import %r' % dotted_path)
kw['exception_level_filters'] = exception_level_filters
kw['enabled'] = asbool(kw.get('enabled', True))
rollbar.init(access_token, environment, **kw)
def __init__(self,
app_router: Router,
rest_url: str='http://localhost',
base_path: str='/',
header: dict=None,
user_path: str='',
user_login: str='',
user_password: str='',
):
"""Initialize self."""
self.app_router = app_router
"""The adhocracy wsgi application"""
self.app = TestApp(app_router)
""":class:`webtest.TestApp`to send requests to the backend server."""
self.rest_url = rest_url
"""backend server url to generate request urls."""
self.base_path = base_path
"""path prefix to generate request urls."""
self.header = header or {}
"""default header for requests, mostly for authentication.
If not set, `user_login` and `user_password` is used to login,
the new authentication header is stored in `header`.
"""
if user_password and user_login and not header:
token, user_path = self._get_token_and_user_path(user_login,
user_password)
self.header = {UserTokenHeader: token}
self.user_password = user_password
"""password for authenticated user."""
self.user_login = user_login
"""login name for authenticated user."""
self.user_path = user_path
"""path for authenticated user."""
self._resolver = DottedNameResolver()
def _find_methods(worker):
cronjobsentry = worker.app.registry.settings.get('cronjobs')
if cronjobsentry is None:
raise ValueError("cronjobs must exist in application configuration if you want to run this. "
"It should point to methods that can be run by the crontick worker. "
"See voteit.core.scripts.crontick")
resolver = DottedNameResolver(None)
dotteds = [x.strip() for x in cronjobsentry.strip().splitlines()]
methods = []
for dotted in dotteds:
try:
methods.append(resolver.resolve(dotted))
except ImportError, e:
worker.logger.exception(e)
def pshell_file_config(self, loader, defaults):
settings = loader.get_settings('pshell', defaults)
resolver = DottedNameResolver(None)
self.loaded_objects = {}
self.object_help = {}
self.setup = None
for k, v in settings.items():
if k == 'setup':
self.setup = v
elif k == 'default_shell':
self.preferred_shells = [x.lower() for x in aslist(v)]
elif k in ('__file__', 'here'):
continue
else:
self.loaded_objects[k] = resolver.maybe_resolve(v)
self.object_help[k] = v
def pshell_file_config(self, filename):
config = self.ConfigParser()
config.read(filename)
try:
items = config.items("pshell")
except configparser.NoSectionError:
return
resolver = DottedNameResolver(None)
self.loaded_objects = {}
self.object_help = {}
self.setup = None
for k, v in items:
if k == "setup":
self.setup = v
else:
self.loaded_objects[k] = resolver.maybe_resolve(v)
self.object_help[k] = v
def __init__(self, app, rest_url: str = "http://localhost", base_path: str = "/", header: dict = None):
"""Initialize self."""
self.app = TestApp(app)
""":class:`webtest.TestApp`to send requests to the backend server."""
self.rest_url = rest_url
"""backend server url to generate request urls."""
self.base_path = base_path
"""path prefix to generate request urls."""
self.header = header or {}
"""default header for requests, mostly for authentication."""
self._resolver = DottedNameResolver()
def pshell_file_config(self, filename):
config = self.ConfigParser()
config.optionxform = str
config.read(filename)
try:
items = config.items('pshell')
except configparser.NoSectionError:
return
resolver = DottedNameResolver(None)
self.loaded_objects = {}
self.object_help = {}
self.setup = None
for k, v in items:
if k == 'setup':
self.setup = v
elif k == 'default_shell':
self.preferred_shells = [x.lower() for x in aslist(v)]
else:
self.loaded_objects[k] = resolver.maybe_resolve(v)
self.object_help[k] = v
def check_password(cls, **kwargs):
if kwargs.has_key("id"):
user = cls.get_by_id(kwargs["id"])
if kwargs.has_key("login"):
user = cls.get_by_login(kwargs["login"])
if not user:
return False
try:
if BCRYPTPasswordManager().check(user.password, "%s%s" % (kwargs["password"], user.salt)):
return True
except TypeError:
pass
request = get_current_request()
fallback_auth = request.registry.settings.get("apex.fallback_auth")
if fallback_auth:
resolver = DottedNameResolver(fallback_auth.split(".", 1)[0])
fallback = resolver.resolve(fallback_auth)
return fallback().check(DBSession, request, user, kwargs["password"])
return False
def _setup_listeners(settings):
# step 2: setup listeners
for s in settings['kotti.sanitize_on_write'].split():
dotted, sanitizers = s.split(':')
classname, attributename = dotted.rsplit('.', 1)
_class = DottedNameResolver().resolve(classname)
def _create_handler(attributename, sanitizers):
def handler(event):
value = getattr(event.object, attributename)
for sanitizer_name in sanitizers.split(','):
value = settings['kotti.sanitizers'][sanitizer_name](value)
setattr(event.object, attributename, value)
return handler
objectevent_listeners[(ObjectInsert, _class)].append(
_create_handler(attributename, sanitizers))
objectevent_listeners[(ObjectUpdate, _class)].append(
_create_handler(attributename, sanitizers))
def from_settings(cls, settings={}, prefix="srpauth.", **kwds):
"""Create a new SRPAuthenticationPolicy from a settings dict."""
# Grab out all the settings keys that start with our prefix.
auth_settings = {}
for name, value in settings.iteritems():
if not name.startswith(prefix):
continue
auth_settings[name[len(prefix):]] = value
# Update with any additional keyword arguments.
auth_settings.update(kwds)
# Now look for specific keys of interest.
maybe_resolve = DottedNameResolver(None).maybe_resolve
# You must specify a realm.
if "realm" not in auth_settings:
raise ValueError("pyramid_srpauth: you must specify the realm")
# NonceManager can be specified as class or instance name.
nonce_manager = maybe_resolve(auth_settings.get("nonce_manager"))
if callable(nonce_manager):
nonce_manager = nonce_manager()
auth_settings["nonce_manager"] = nonce_manager
# get_password can be dotted name of a callable
get_password = maybe_resolve(auth_settings.get("get_password"))
if get_password is not None:
assert callable(get_password)
auth_settings["get_password"] = get_password
# get_verifier can be dotted name of a callable
get_verifier = maybe_resolve(auth_settings.get("get_verifier"))
if get_verifier is not None:
assert callable(get_verifier)
auth_settings["get_verifier"] = get_verifier
# groupfinder can be dotted name of a callable
groupfinder = maybe_resolve(auth_settings.get("groupfinder"))
if groupfinder is not None:
assert callable(groupfinder)
auth_settings["groupfinder"] = groupfinder
# OK, the rest should just be keyword arguments.
return cls(**auth_settings)
class AppUser:
""":class:`webtest.TestApp` wrapper for backend functional testing."""
def __init__(self,
app,
rest_url: str = 'http://localhost',
base_path: str = '/',
header: dict = None):
"""Initialize self."""
self.app = TestApp(app)
""":class:`webtest.TestApp`to send requests to the backend server."""
self.rest_url = rest_url
"""backend server url to generate request urls."""
self.base_path = base_path
"""path prefix to generate request urls."""
self.header = header or {}
"""default header for requests, mostly for authentication."""
self._resolver = DottedNameResolver()
def post_resource(self, path: str, iresource: IInterface,
cstruct: dict) -> TestResponse:
"""Build and post request to create a new resource."""
url = self._build_url(path)
props = self._build_post_body(iresource, cstruct)
resp = self.app.post_json(url,
props,
headers=self.header,
expect_errors=True)
return resp
def put(self, path: str, cstruct: dict = {}) -> TestResponse:
"""Put request to modify a resource."""
url = self._build_url(path)
resp = self.app.put_json(url,
cstruct,
headers=self.header,
expect_errors=True)
return resp
def post(self, path: str, cstruct: dict = {}) -> TestResponse:
"""Post request to create a new resource."""
url = self._build_url(path)
resp = self.app.post_json(url,
cstruct,
headers=self.header,
expect_errors=True)
return resp
def _build_post_body(self, iresource: IInterface, cstruct: dict) -> dict:
return {'content_type': iresource.__identifier__, 'data': cstruct}
def _build_url(self, path: str) -> str:
if path.startswith('http'):
return path
return self.rest_url + self.base_path + path
def batch(self, subrequests: list):
"""Build and post batch request to the backend rest server."""
resp = self.app.post_json(batch_url,
subrequests,
headers=self.header,
expect_errors=True)
return resp
def get(self, path: str, params={}) -> TestResponse:
"""Send get request to the backend rest server."""
url = self._build_url(path)
resp = self.app.get(url,
headers=self.header,
params=params,
expect_errors=True)
return resp
def options(self, path: str) -> TestResponse:
"""Send options request to the backend rest server."""
url = self._build_url(path)
resp = self.app.options(url, headers=self.header, expect_errors=True)
return resp
def get_postable_types(self, path: str) -> []:
"""Send options request and return the postable content types."""
resp = self.options(path)
if 'POST' not in resp.json:
return []
post_request_body = resp.json['POST']['request_body']
type_names = sorted([r['content_type'] for r in post_request_body])
iresources = [self._resolver.resolve(t) for t in type_names]
return iresources
class PShellCommand(object):
description = """\
Open an interactive shell with a Pyramid app loaded. This command
accepts one positional argument named "config_uri" which specifies the
PasteDeploy config file to use for the interactive shell. The format is
"inifile#name". If the name is left off, the Pyramid default application
will be assumed. Example: "pshell myapp.ini#main".
If you do not point the loader directly at the section of the ini file
containing your Pyramid application, the command will attempt to
find the app for you. If you are loading a pipeline that contains more
than one Pyramid application within it, the loader will use the
last one.
"""
bootstrap = staticmethod(bootstrap) # for testing
get_config_loader = staticmethod(get_config_loader) # for testing
pkg_resources = pkg_resources # for testing
parser = argparse.ArgumentParser(
description=textwrap.dedent(description),
formatter_class=argparse.RawDescriptionHelpFormatter,
)
parser.add_argument(
'-p',
'--python-shell',
action='store',
dest='python_shell',
default='',
help=('Select the shell to use. A list of possible '
'shells is available using the --list-shells '
'option.'),
)
parser.add_argument(
'-l',
'--list-shells',
dest='list',
action='store_true',
help='List all available shells.',
)
parser.add_argument(
'--setup',
dest='setup',
help=("A callable that will be passed the environment "
"before it is made available to the shell. This "
"option will override the 'setup' key in the "
"[pshell] ini section."),
)
parser.add_argument(
'config_uri',
nargs='?',
default=None,
help='The URI to the configuration file.',
)
parser.add_argument(
'config_vars',
nargs='*',
default=(),
help="Variables required by the config file. For example, "
"`http_port=%%(http_port)s` would expect `http_port=8080` to be "
"passed here.",
)
default_runner = python_shell_runner # testing
loaded_objects = {}
object_help = {}
preferred_shells = []
setup = None
pystartup = os.environ.get('PYTHONSTARTUP')
resolver = DottedNameResolver(None)
def __init__(self, argv, quiet=False):
self.quiet = quiet
self.args = self.parser.parse_args(argv[1:])
def pshell_file_config(self, loader, defaults):
settings = loader.get_settings('pshell', defaults)
self.loaded_objects = {}
self.object_help = {}
self.setup = None
for k, v in settings.items():
if k == 'setup':
self.setup = v
elif k == 'default_shell':
self.preferred_shells = [x.lower() for x in aslist(v)]
else:
self.loaded_objects[k] = self.resolver.maybe_resolve(v)
self.object_help[k] = v
def out(self, msg): # pragma: no cover
if not self.quiet:
print(msg)
def run(self, shell=None):
if self.args.list:
return self.show_shells()
if not self.args.config_uri:
self.out('Requires a config file argument')
return 2
config_uri = self.args.config_uri
config_vars = parse_vars(self.args.config_vars)
loader = self.get_config_loader(config_uri)
loader.setup_logging(config_vars)
self.pshell_file_config(loader, config_vars)
self.env = self.bootstrap(config_uri, options=config_vars)
# remove the closer from the env
self.closer = self.env.pop('closer')
try:
if shell is None:
try:
shell = self.make_shell()
except ValueError as e:
self.out(str(e))
return 1
with self.setup_env():
shell(self.env, self.help)
finally:
self.closer()
@contextmanager
def setup_env(self):
# setup help text for default environment
env = self.env
env_help = dict(env)
env_help['app'] = 'The WSGI application.'
env_help['root'] = 'Root of the default resource tree.'
env_help['registry'] = 'Active Pyramid registry.'
env_help['request'] = 'Active request object.'
env_help[
'root_factory'] = 'Default root factory used to create `root`.'
# load the pshell section of the ini file
env.update(self.loaded_objects)
# eliminate duplicates from env, allowing custom vars to override
for k in self.loaded_objects:
if k in env_help:
del env_help[k]
# override use_script with command-line options
if self.args.setup:
self.setup = self.args.setup
if self.setup:
# call the setup callable
self.setup = self.resolver.maybe_resolve(self.setup)
# store the env before muddling it with the script
orig_env = env.copy()
setup_manager = make_contextmanager(self.setup)
with setup_manager(env):
# remove any objects from default help that were overidden
for k, v in env.items():
if k not in orig_env or v != orig_env[k]:
if getattr(v, '__doc__', False):
env_help[k] = v.__doc__.replace("\n", " ")
else:
env_help[k] = v
del orig_env
# generate help text
help = ''
if env_help:
help += 'Environment:'
for var in sorted(env_help.keys()):
help += '\n %-12s %s' % (var, env_help[var])
if self.object_help:
help += '\n\nCustom Variables:'
for var in sorted(self.object_help.keys()):
help += '\n %-12s %s' % (var, self.object_help[var])
if self.pystartup and os.path.isfile(self.pystartup):
with open(self.pystartup, 'rb') as fp:
exec(fp.read().decode('utf-8'), env)
if '__builtins__' in env:
del env['__builtins__']
self.help = help.strip()
yield
def show_shells(self):
shells = self.find_all_shells()
sorted_names = sorted(shells.keys(), key=lambda x: x.lower())
self.out('Available shells:')
for name in sorted_names:
self.out(' %s' % (name, ))
return 0
def find_all_shells(self):
pkg_resources = self.pkg_resources
shells = {}
for ep in pkg_resources.iter_entry_points('pyramid.pshell_runner'):
name = ep.name
shell_factory = ep.load()
shells[name] = shell_factory
return shells
def make_shell(self):
shells = self.find_all_shells()
shell = None
user_shell = self.args.python_shell.lower()
if not user_shell:
preferred_shells = self.preferred_shells
if not preferred_shells:
# by default prioritize all shells above python
preferred_shells = [k for k in shells.keys() if k != 'python']
max_weight = len(preferred_shells)
def order(x):
# invert weight to reverse sort the list
# (closer to the front is higher priority)
try:
return preferred_shells.index(x[0].lower()) - max_weight
except ValueError:
return 1
sorted_shells = sorted(shells.items(), key=order)
if len(sorted_shells) > 0:
shell = sorted_shells[0][1]
else:
runner = shells.get(user_shell)
if runner is not None:
shell = runner
if shell is None:
raise ValueError('could not find a shell named "%s"' %
user_shell)
if shell is None:
# should never happen, but just incase entry points are borked
shell = self.default_runner
return shell
import logging
import sys
from pyramid.interfaces import IRootFactory
from pyramid.httpexceptions import HTTPFound
from pyramid.util import DottedNameResolver
from pyramid.view import view_config
from karl.models.interfaces import IProfile
from karl.models.interfaces import ICatalogSearch
from karl.utils import find_users
from karl.views.login import remember_login
resolve_dotted_name = DottedNameResolver(sys.modules[__name__]).resolve
log = logging.getLogger(__name__)
def includeme(config):
settings = config.registry.settings
sso = settings.get('sso', None)
if not sso:
return
for name in sso.split():
prefix = 'sso.%s.' % name
provider = settings.get('%sprovider' % prefix)
if provider == 'github':
config.include('velruse.providers.github')
config.add_github_login_from_settings(prefix=prefix)
def get_is_blacklisted():
""" Returns the is_blacklisted function or the default fallback """
settings = get_settings()
is_blacklisted_dotted = settings.get('kotti_es.is_blacklisted')
is_blacklisted = DottedNameResolver(None).resolve(is_blacklisted_dotted)
return is_blacklisted
def __call__(self, info):
path = info.name
registry = info.registry
settings = info.settings
settings_prefix = self.settings_prefix
if settings_prefix is None:
settings_prefix = info.type +'.'
lookup = registry.queryUtility(IMakoLookup, name=settings_prefix)
def sget(name, default=None):
return settings.get(settings_prefix + name, default)
if lookup is None:
reload_templates = settings.get('pyramid.reload_templates', None)
if reload_templates is None:
reload_templates = settings.get('reload_templates', False)
reload_templates = asbool(reload_templates)
directories = sget('directories', [])
module_directory = sget('module_directory', None)
input_encoding = sget('input_encoding', 'utf-8')
error_handler = sget('error_handler', None)
default_filters = sget('default_filters', 'h')
imports = sget('imports', None)
strict_undefined = asbool(sget('strict_undefined', False))
preprocessor = sget('preprocessor', None)
if not is_nonstr_iter(directories):
directories = list(filter(None, directories.splitlines()))
directories = [ abspath_from_asset_spec(d) for d in directories ]
if module_directory is not None:
module_directory = abspath_from_asset_spec(module_directory)
if error_handler is not None:
dotted = DottedNameResolver(info.package)
error_handler = dotted.maybe_resolve(error_handler)
if default_filters is not None:
if not is_nonstr_iter(default_filters):
default_filters = list(filter(
None, default_filters.splitlines()))
if imports is not None:
if not is_nonstr_iter(imports):
imports = list(filter(None, imports.splitlines()))
if preprocessor is not None:
dotted = DottedNameResolver(info.package)
preprocessor = dotted.maybe_resolve(preprocessor)
lookup = PkgResourceTemplateLookup(
directories=directories,
module_directory=module_directory,
input_encoding=input_encoding,
error_handler=error_handler,
default_filters=default_filters,
imports=imports,
filesystem_checks=reload_templates,
strict_undefined=strict_undefined,
preprocessor=preprocessor
)
registry_lock.acquire()
try:
registry.registerUtility(lookup, IMakoLookup,
name=settings_prefix)
finally:
registry_lock.release()
return MakoLookupTemplateRenderer(path, lookup)
def __call__(self, info):
p = re.compile(r"(?P<asset>[\w_.:/]+)" r"(?:\#(?P<defname>[\w_]+))?" r"(\.(?P<ext>.*))")
asset, defname, ext = p.match(info.name).group("asset", "defname", "ext")
path = "%s.%s" % (asset, ext)
registry = info.registry
settings = info.settings
settings_prefix = self.settings_prefix
if settings_prefix is None:
settings_prefix = info.type + "."
lookup = registry.queryUtility(IMakoLookup, name=settings_prefix)
def sget(name, default=None):
return settings.get(settings_prefix + name, default)
if lookup is None:
reload_templates = settings.get("pyramid.reload_templates", None)
if reload_templates is None:
reload_templates = settings.get("reload_templates", False)
reload_templates = asbool(reload_templates)
directories = sget("directories", [])
module_directory = sget("module_directory", None)
input_encoding = sget("input_encoding", "utf-8")
error_handler = sget("error_handler", None)
default_filters = sget("default_filters", "h")
imports = sget("imports", None)
strict_undefined = asbool(sget("strict_undefined", False))
preprocessor = sget("preprocessor", None)
if not is_nonstr_iter(directories):
directories = list(filter(None, directories.splitlines()))
directories = [abspath_from_asset_spec(d) for d in directories]
if module_directory is not None:
module_directory = abspath_from_asset_spec(module_directory)
if error_handler is not None:
dotted = DottedNameResolver(info.package)
error_handler = dotted.maybe_resolve(error_handler)
if default_filters is not None:
if not is_nonstr_iter(default_filters):
default_filters = list(filter(None, default_filters.splitlines()))
if imports is not None:
if not is_nonstr_iter(imports):
imports = list(filter(None, imports.splitlines()))
if preprocessor is not None:
dotted = DottedNameResolver(info.package)
preprocessor = dotted.maybe_resolve(preprocessor)
lookup = PkgResourceTemplateLookup(
directories=directories,
module_directory=module_directory,
input_encoding=input_encoding,
error_handler=error_handler,
default_filters=default_filters,
imports=imports,
filesystem_checks=reload_templates,
strict_undefined=strict_undefined,
preprocessor=preprocessor,
)
registry_lock.acquire()
try:
registry.registerUtility(lookup, IMakoLookup, name=settings_prefix)
finally:
registry_lock.release()
return MakoLookupTemplateRenderer(path, defname, lookup)
def __init__(self, *args, **kwargs):
self.sep = kwargs.get('sep', u'\n')
res = DottedNameResolver('pyramid_formalchemy.actions')
list.__init__(self, [res.maybe_resolve(a) for a in args])
def __init__(self, *args, **kwargs):
res = DottedNameResolver('pyramid_formalchemy.actions')
list.__init__(self, [res.maybe_resolve(a) for a in args])
def maybe_dotted():
from pyramid.util import DottedNameResolver
resolver = DottedNameResolver()
return resolver.maybe_resolve
class AppUser:
""":class:`webtest.TestApp` wrapper for backend functional testing."""
def __init__(self,
app_router: Router,
rest_url: str='http://localhost',
base_path: str='/',
header: dict=None,
user_path: str='',
user_login: str='',
user_password: str='',
):
"""Initialize self."""
self.app_router = app_router
"""The adhocracy wsgi application"""
self.app = TestApp(app_router)
""":class:`webtest.TestApp`to send requests to the backend server."""
self.rest_url = rest_url
"""backend server url to generate request urls."""
self.base_path = base_path
"""path prefix to generate request urls."""
self.header = header or {}
"""default header for requests, mostly for authentication.
If not set, `user_login` and `user_password` is used to login,
the new authentication header is stored in `header`.
"""
if user_password and user_login and not header:
token, user_path = self._get_token_and_user_path(user_login,
user_password)
self.header = {UserTokenHeader: token}
self.user_password = user_password
"""password for authenticated user."""
self.user_login = user_login
"""login name for authenticated user."""
self.user_path = user_path
"""path for authenticated user."""
self._resolver = DottedNameResolver()
def _get_token_and_user_path(self, login: str, password: str) -> tuple:
login_page = self.rest_url + '/login_username'
data = {'name': login,
'password': password}
resp = self.app.post_json(login_page, data).json
return resp['user_token'], resp['user_path']
def post_resource(self, path: str,
iresource: IInterface,
cstruct: dict) -> TestResponse:
"""Build and post request to create a new resource."""
url = self._build_url(path)
props = self._build_post_body(iresource, cstruct)
resp = self.app.post_json(url, props, headers=self.header,
expect_errors=True)
return resp
def put(self,
path: str,
cstruct: dict={},
upload_files: [(str, str, bytes)]=None,
) -> TestResponse:
"""Put request to modify a resource."""
url = self._build_url(path)
kwargs = {'headers': self.header,
'expect_errors': True,
}
if upload_files:
kwargs['upload_files'] = upload_files
resp = self.app.put(url, cstruct, **kwargs)
else:
resp = self.app.put_json(url, cstruct, **kwargs)
return resp
def post(self,
path: str,
cstruct: dict={},
upload_files: [(str, str, bytes)]=None,
) -> TestResponse:
"""Post request to create a new resource."""
url = self._build_url(path)
kwargs = {'headers': self.header,
'expect_errors': True,
}
if upload_files:
kwargs['upload_files'] = upload_files
resp = self.app.post(url, cstruct, **kwargs)
else:
resp = self.app.post_json(url, cstruct, **kwargs)
return resp
def _build_post_body(self, iresource: IInterface, cstruct: dict) -> dict:
return {'content_type': iresource.__identifier__,
'data': cstruct}
def _build_url(self, path: str) -> str:
if path.startswith('http'):
return path
return self.rest_url + self.base_path + path
def batch(self, subrequests: list):
"""Build and post batch request to the backend rest server."""
resp = self.app.post_json(batch_url, subrequests, headers=self.header,
expect_errors=True)
return resp
def get(self, path: str, params={}) -> TestResponse:
"""Send get request to the backend rest server."""
url = self._build_url(path)
resp = self.app.get(url,
headers=self.header,
params=params,
expect_errors=True)
return resp
def delete(self, path: str) -> TestResponse:
"""Send delete request to the backend rest server."""
url = self._build_url(path)
resp = self.app.delete(url,
headers=self.header,
expect_errors=True)
return resp
def options(self, path: str) -> TestResponse:
"""Send options request to the backend rest server."""
url = self._build_url(path)
resp = self.app.options(url, headers=self.header, expect_errors=True)
return resp
def get_postable_types(self, path: str) -> []:
"""Send options request and return the postable content types."""
resp = self.options(path)
if 'POST' not in resp.json:
return []
post_request_body = resp.json['POST']['request_body']
type_names = sorted([r['content_type'] for r in post_request_body])
iresources = [self._resolver.resolve(t) for t in type_names]
return iresources
def get_imperative_config(package):
resolver = DottedNameResolver(package)
try:
return resolver.resolve('.application:configure_karl')
except ImportError:
return None
def run(self, shell=None):
if self.args.list:
return self.show_shells()
if not self.args.config_uri:
self.out('Requires a config file argument')
return 2
config_uri = self.args.config_uri
config_vars = parse_vars(self.args.config_vars)
loader = self.get_config_loader(config_uri)
loader.setup_logging(config_vars)
self.pshell_file_config(loader, config_vars)
env = self.bootstrap(config_uri, options=config_vars)
# remove the closer from the env
self.closer = env.pop('closer')
# setup help text for default environment
env_help = dict(env)
env_help['app'] = 'The WSGI application.'
env_help['root'] = 'Root of the default resource tree.'
env_help['registry'] = 'Active Pyramid registry.'
env_help['request'] = 'Active request object.'
env_help['root_factory'] = (
'Default root factory used to create `root`.')
# override use_script with command-line options
if self.args.setup:
self.setup = self.args.setup
if self.setup:
# store the env before muddling it with the script
orig_env = env.copy()
# call the setup callable
resolver = DottedNameResolver(None)
setup = resolver.maybe_resolve(self.setup)
setup(env)
# remove any objects from default help that were overidden
for k, v in env.items():
if k not in orig_env or env[k] != orig_env[k]:
if getattr(v, '__doc__', False):
env_help[k] = v.__doc__.replace("\n", " ")
else:
env_help[k] = v
# load the pshell section of the ini file
env.update(self.loaded_objects)
# eliminate duplicates from env, allowing custom vars to override
for k in self.loaded_objects:
if k in env_help:
del env_help[k]
# generate help text
help = ''
if env_help:
help += 'Environment:'
for var in sorted(env_help.keys()):
help += '\n %-12s %s' % (var, env_help[var])
if self.object_help:
help += '\n\nCustom Variables:'
for var in sorted(self.object_help.keys()):
help += '\n %-12s %s' % (var, self.object_help[var])
if shell is None:
try:
shell = self.make_shell()
except ValueError as e:
self.out(str(e))
self.closer()
return 1
if self.pystartup and os.path.isfile(self.pystartup):
with open(self.pystartup, 'rb') as fp:
exec_(fp.read().decode('utf-8'), env)
if '__builtins__' in env:
del env['__builtins__']
try:
shell(env, help)
finally:
self.closer()
def __call__(self, info):
p = re.compile(r'(?P<asset>[\w_.:/-]+)'
r'(?:\#(?P<defname>[\w_]+))?'
r'(\.(?P<ext>.*))')
asset, defname, ext = p.match(info.name).group('asset', 'defname',
'ext')
path = '%s.%s' % (asset, ext)
registry = info.registry
settings = info.settings
settings_prefix = self.settings_prefix
if settings_prefix is None:
settings_prefix = info.type + '.'
lookup = registry.queryUtility(IMakoLookup, name=settings_prefix)
def sget(name, default=None):
return settings.get(settings_prefix + name, default)
if lookup is None:
reload_templates = settings.get('pyramid.reload_templates', None)
if reload_templates is None:
reload_templates = settings.get('reload_templates', False)
reload_templates = asbool(reload_templates)
directories = sget('directories', [])
module_directory = sget('module_directory', None)
input_encoding = sget('input_encoding', 'utf-8')
error_handler = sget('error_handler', None)
default_filters = sget('default_filters', 'h')
imports = sget('imports', None)
strict_undefined = asbool(sget('strict_undefined', False))
preprocessor = sget('preprocessor', None)
if not is_nonstr_iter(directories):
directories = list(filter(None, directories.splitlines()))
directories = [abspath_from_asset_spec(d) for d in directories]
if module_directory is not None:
module_directory = abspath_from_asset_spec(module_directory)
if error_handler is not None:
dotted = DottedNameResolver(info.package)
error_handler = dotted.maybe_resolve(error_handler)
if default_filters is not None:
if not is_nonstr_iter(default_filters):
default_filters = list(
filter(None, default_filters.splitlines()))
if imports is not None:
if not is_nonstr_iter(imports):
imports = list(filter(None, imports.splitlines()))
if preprocessor is not None:
dotted = DottedNameResolver(info.package)
preprocessor = dotted.maybe_resolve(preprocessor)
lookup = PkgResourceTemplateLookup(
directories=directories,
module_directory=module_directory,
input_encoding=input_encoding,
error_handler=error_handler,
default_filters=default_filters,
imports=imports,
filesystem_checks=reload_templates,
strict_undefined=strict_undefined,
preprocessor=preprocessor)
with registry_lock:
registry.registerUtility(lookup,
IMakoLookup,
name=settings_prefix)
return MakoLookupTemplateRenderer(path, defname, lookup)
import logging
from pyramid.compat import configparser
from pyramid.util import DottedNameResolver
from pyramid.paster import bootstrap
# pshellintellij uses first two arguments as ports to connect shell
if len(sys.argv) > 3:
config_file = sys.argv[3]
else:
config_file = 'development.ini'
bootstrap = (bootstrap, )
config = configparser.ConfigParser()
config.read(config_file)
resolver = DottedNameResolver(None)
loaded_objects = {}
object_help = {}
setup = None
try:
items = config.items('pshell')
for k, v in items:
if k == 'setup':
setup = v
else:
loaded_objects[k] = resolver.maybe_resolve(v)
object_help[k] = v
except configparser.NoSectionError:
pass
def get_imperative_config(package):
resolver = DottedNameResolver(package)
try:
return resolver.resolve('.application:configure_karl')
except ImportError:
return None
def get_module(package):
""" Returns a module based on the string passed
"""
resolver = DottedNameResolver(package.split('.', 1)[0])
return resolver.resolve(package)
def command(self, shell=None):
config_uri = self.args[0]
config_file = config_uri.split('#', 1)[0]
self.logging_file_config(config_file)
self.pshell_file_config(config_file)
# bootstrap the environ
env = self.bootstrap[0](config_uri)
# remove the closer from the env
closer = env.pop('closer')
# setup help text for default environment
env_help = dict(env)
env_help['app'] = 'The WSGI application.'
env_help['root'] = 'Root of the default resource tree.'
env_help['registry'] = 'Active Pyramid registry.'
env_help['request'] = 'Active request object.'
env_help['root_factory'] = (
'Default root factory used to create `root`.')
# override use_script with command-line options
if self.options.setup:
self.setup = self.options.setup
if self.setup:
# store the env before muddling it with the script
orig_env = env.copy()
# call the setup callable
resolver = DottedNameResolver(None)
setup = resolver.maybe_resolve(self.setup)
setup(env)
# remove any objects from default help that were overidden
for k, v in env.iteritems():
if k not in orig_env or env[k] != orig_env[k]:
env_help[k] = v
# load the pshell section of the ini file
env.update(self.loaded_objects)
# eliminate duplicates from env, allowing custom vars to override
for k in self.loaded_objects:
if k in env_help:
del env_help[k]
# generate help text
help = ''
if env_help:
help += 'Environment:'
for var in sorted(env_help.keys()):
help += '\n %-12s %s' % (var, env_help[var])
if self.object_help:
help += '\n\nCustom Variables:'
for var in sorted(self.object_help.keys()):
help += '\n %-12s %s' % (var, self.object_help[var])
if shell is None and not self.options.disable_ipython:
shell = self.make_ipython_v0_11_shell()
if shell is None:
shell = self.make_ipython_v0_10_shell()
if shell is None:
shell = self.make_default_shell()
try:
shell(env, help)
finally:
closer()
class AppUser:
""":class:`webtest.TestApp` wrapper for backend functional testing."""
def __init__(
self,
app_router: Router,
base_path: str = '/',
header: dict = None,
user_path: str = '',
user_login: str = '',
user_password: str = '',
):
"""Initialize self."""
self.app_router = app_router
"""The adhocracy wsgi application"""
self.app = TestApp(app_router)
""":class:`webtest.TestApp`to send requests to the backend server."""
self.rest_url = rest_url()
"""backend server url to generate request urls."""
self.base_path = base_path
"""path prefix to generate request urls."""
self.header = header or {}
"""default header for requests, mostly for authentication.
If not set, `user_login` and `user_password` is used to login,
the new authentication header is stored in `header`.
"""
if user_password and user_login and not header:
token, user_path = self._get_token_and_user_path(
user_login, user_password)
self.header = {UserTokenHeader: token}
self.user_password = user_password
"""password for authenticated user."""
self.user_login = user_login
"""login name for authenticated user."""
self.user_path = user_path
"""path for authenticated user."""
self._resolver = DottedNameResolver()
def _get_token_and_user_path(self, login: str, password: str) -> tuple:
login_page = self.rest_url + '/login_username'
data = {'name': login, 'password': password}
resp = self.app.post_json(login_page, data).json
return resp['user_token'], resp['user_path']
def post_resource(self, path: str, iresource: IInterface,
cstruct: dict) -> TestResponse:
"""Build and post request to create a new resource."""
url = self._build_url(path)
props = self._build_post_body(iresource, cstruct)
resp = self.app.post_json(url,
props,
headers=self.header,
expect_errors=True)
return resp
def put(
self,
path: str,
cstruct: dict = {},
upload_files: [(str, str, bytes)] = None,
extra_headers: dict = {},
) -> TestResponse:
"""Put request to modify a resource."""
url = self._build_url(path)
headers = copy(self.header)
headers.update(extra_headers)
kwargs = {
'headers': headers,
'expect_errors': True,
}
if upload_files:
kwargs['upload_files'] = upload_files
resp = self.app.put(url, cstruct, **kwargs)
else:
resp = self.app.put_json(url, cstruct, **kwargs)
return resp
def post(
self,
path: str,
cstruct: dict = {},
upload_files: [(str, str, bytes)] = None,
extra_headers: dict = {},
) -> TestResponse:
"""Post request to create a new resource."""
url = self._build_url(path)
headers = copy(self.header)
headers.update(extra_headers)
kwargs = {
'headers': headers,
'expect_errors': True,
}
if upload_files:
kwargs['upload_files'] = upload_files
resp = self.app.post(url, cstruct, **kwargs)
else:
resp = self.app.post_json(url, cstruct, **kwargs)
return resp
def _build_post_body(self, iresource: IInterface, cstruct: dict) -> dict:
return {'content_type': iresource.__identifier__, 'data': cstruct}
def _build_url(self, path: str) -> str:
if path.startswith('http'):
return path
elif path.startswith('/') and (self.base_path == '\\'):
return self.rest_url + path
else:
return self.rest_url + self.base_path + path
def batch(self, subrequests: list):
"""Build and post batch request to the backend rest server."""
resp = self.app.post_json(batch_url,
subrequests,
headers=self.header,
expect_errors=True)
return resp
def head(self, path: str, extra_headers={}) -> TestResponse:
"""Send head request to the backend rest server."""
url = self._build_url(path)
headers = copy(self.header)
headers.update(extra_headers)
resp = self.app.head(url, headers=headers, expect_errors=True)
return resp
def get(self, path: str, params={}, extra_headers={}) -> TestResponse:
"""Send get request to the backend rest server."""
url = self._build_url(path)
headers = copy(self.header)
headers.update(extra_headers)
resp = self.app.get(url,
headers=headers,
params=params,
expect_errors=True)
return resp
def delete(self, path: str) -> TestResponse:
"""Send delete request to the backend rest server."""
url = self._build_url(path)
resp = self.app.delete(url, headers=self.header, expect_errors=True)
return resp
def options(self, path: str) -> TestResponse:
"""Send options request to the backend rest server."""
url = self._build_url(path)
resp = self.app.options(url, headers=self.header, expect_errors=True)
return resp
def get_postable_types(self, path: str) -> []:
"""Send options request and return the postable content types."""
resp = self.options(path)
if 'POST' not in resp.json:
return []
post_request_body = resp.json['POST']['request_body']
type_names = sorted([r['content_type'] for r in post_request_body])
iresources = [self._resolver.resolve(t) for t in type_names]
return iresources
def run(self, shell=None):
if self.args.list:
return self.show_shells()
if not self.args.config_uri:
self.out('Requires a config file argument')
return 2
config_uri = self.args.config_uri
config_vars = parse_vars(self.args.config_vars)
loader = self.get_config_loader(config_uri)
loader.setup_logging(config_vars)
self.pshell_file_config(loader, config_vars)
env = self.bootstrap(config_uri, options=config_vars)
# remove the closer from the env
self.closer = env.pop('closer')
# setup help text for default environment
env_help = dict(env)
env_help['app'] = 'The WSGI application.'
env_help['root'] = 'Root of the default resource tree.'
env_help['registry'] = 'Active Pyramid registry.'
env_help['request'] = 'Active request object.'
env_help['root_factory'] = (
'Default root factory used to create `root`.')
# override use_script with command-line options
if self.args.setup:
self.setup = self.args.setup
if self.setup:
# store the env before muddling it with the script
orig_env = env.copy()
# call the setup callable
resolver = DottedNameResolver(None)
setup = resolver.maybe_resolve(self.setup)
setup(env)
# remove any objects from default help that were overidden
for k, v in env.items():
if k not in orig_env or env[k] != orig_env[k]:
if getattr(v, '__doc__', False):
env_help[k] = v.__doc__.replace("\n", " ")
else:
env_help[k] = v
# load the pshell section of the ini file
env.update(self.loaded_objects)
# eliminate duplicates from env, allowing custom vars to override
for k in self.loaded_objects:
if k in env_help:
del env_help[k]
# generate help text
help = ''
if env_help:
help += 'Environment:'
for var in sorted(env_help.keys()):
help += '\n %-12s %s' % (var, env_help[var])
if self.object_help:
help += '\n\nCustom Variables:'
for var in sorted(self.object_help.keys()):
help += '\n %-12s %s' % (var, self.object_help[var])
if shell is None:
try:
shell = self.make_shell()
except ValueError as e:
self.out(str(e))
self.closer()
return 1
if self.pystartup and os.path.isfile(self.pystartup):
with open(self.pystartup, 'rb') as fp:
exec_(fp.read().decode('utf-8'), env)
if '__builtins__' in env:
del env['__builtins__']
try:
shell(env, help)
finally:
self.closer()
def get_module(package):
""" Returns a module based on the string passed
"""
resolver = DottedNameResolver(package.split('.', 1)[0])
return resolver.resolve(package)
from pyramid.decorator import reify
from pyramid.traversal import resource_path
from substanced.content import ContentRegistry
from substanced.content import add_content_type
from substanced.content import add_service_type
from substanced.workflow import IWorkflow
from zope.interface.interfaces import IInterface
from adhocracy_core.exceptions import RuntimeConfigurationError
from adhocracy_core.interfaces import ISheet
from adhocracy_core.interfaces import IItemVersion
from adhocracy_core.interfaces import IItem
from adhocracy_core.interfaces import ResourceMetadata
from adhocracy_core.utils import get_iresource
resolver = DottedNameResolver()
class ResourceContentRegistry(ContentRegistry):
"""Extend substanced content registry to work with resources."""
def __init__(self, registry):
"""Initialize self."""
super().__init__(registry)
self.resources_meta = {}
"""Resources meta mapping.
Dictionary with key iresource (`resource type` interface) and value
:class:`adhocracy_core.interfaces.ResourceMetadata`.
"""
self.sheets_meta = {}
"""Sheets meta mapping.
charset=renderer[1],
content_type=renderer[0][0]
)
#def get_reference_graph(n, maxdepth):
# g = nx.Graph()
# g.add_node(n, type='self')
# for f in build_reference_graph(n, maxdepth=maxdepth):
# g.add_edge( f[1], f[3], type=f[2], power=f[4], depth=f[0])
#
# return g
from pyramid.util import DottedNameResolver
dotted_name_resolver = DottedNameResolver()
def get_reference_graph(cls, argdict=None):
# TODO reference graph collection
argdict = argdict or {}
if isinstance(cls, basestring):
try:
reference_graph = "networkx.generators.%s" % cls
cls = dotted_name_resolver.resolve(reference_graph)
if not hasattr(cls, '__name__'):
raise Exception('not a class') # TODO: validation dict
except ImportError:
raise
except AttributeError:
raise
else:
def __init__(self, *args, **kwargs):
self.sep = kwargs.get('sep', u'\n')
res = DottedNameResolver('pyramid_formalchemy.actions')
list.__init__(self, [res.maybe_resolve(a) for a in args])
def _makeOne(self, package=None):
from pyramid.util import DottedNameResolver
return DottedNameResolver(package)
def run(self, shell=None):
if not self.args:
self.out('Requires a config file argument')
return 2
config_uri = self.args[0]
config_file = config_uri.split('#', 1)[0]
setup_logging(config_file)
self.pshell_file_config(config_file)
# bootstrap the environ
env = self.bootstrap[0](config_uri, options=parse_vars(self.args[1:]))
# remove the closer from the env
closer = env.pop('closer')
# setup help text for default environment
env_help = dict(env)
env_help['app'] = 'The WSGI application.'
env_help['root'] = 'Root of the default resource tree.'
env_help['registry'] = 'Active Pyramid registry.'
env_help['request'] = 'Active request object.'
env_help['root_factory'] = (
'Default root factory used to create `root`.')
# override use_script with command-line options
if self.options.setup:
self.setup = self.options.setup
if self.setup:
# store the env before muddling it with the script
orig_env = env.copy()
# call the setup callable
resolver = DottedNameResolver(None)
setup = resolver.maybe_resolve(self.setup)
setup(env)
# remove any objects from default help that were overidden
for k, v in env.items():
if k not in orig_env or env[k] != orig_env[k]:
env_help[k] = v
# load the pshell section of the ini file
env.update(self.loaded_objects)
# eliminate duplicates from env, allowing custom vars to override
for k in self.loaded_objects:
if k in env_help:
del env_help[k]
# generate help text
help = ''
if env_help:
help += 'Environment:'
for var in sorted(env_help.keys()):
help += '\n %-12s %s' % (var, env_help[var])
if self.object_help:
help += '\n\nCustom Variables:'
for var in sorted(self.object_help.keys()):
help += '\n %-12s %s' % (var, self.object_help[var])
if shell is None:
shell = self.make_shell()
try:
shell(env, help)
finally:
closer()
# -*- coding: utf-8 -*-
import collections
import logging
from codecs import open
from pkg_resources import resource_filename
from pyramid import httpexceptions
from pyramid.util import DottedNameResolver
from h.util.redirects import lookup as lookup_redirects
from h.util.redirects import parse as parse_redirects
log = logging.getLogger(__name__)
resolver = DottedNameResolver(None)
def conditional_http_tween_factory(handler, registry):
"""A tween that sets up conditional response handling for some requests."""
def conditional_http_tween(request):
response = handler(request)
# If the Last-Modified header has been set, we want to enable the
# conditional response processing.
if response.last_modified is not None:
response.conditional_response = True
# We want to only enable the conditional machinery if either we were
# given an explicit ETag header by the view...
if response.etag is not None:
response.conditional_response = True
return response
class AppUser:
""":class:`webtest.TestApp` wrapper for backend functional testing."""
def __init__(self, app,
rest_url: str='http://localhost',
base_path: str='/',
header: dict=None):
"""Initialize self."""
self.app = TestApp(app)
""":class:`webtest.TestApp`to send requests to the backend server."""
self.rest_url = rest_url
"""backend server url to generate request urls."""
self.base_path = base_path
"""path prefix to generate request urls."""
self.header = header or {}
"""default header for requests, mostly for authentication."""
self._resolver = DottedNameResolver()
def post_resource(self, path: str,
iresource: IInterface,
cstruct: dict) -> TestResponse:
"""Build and post request to create a new resource."""
url = self._build_url(path)
props = self._build_post_body(iresource, cstruct)
resp = self.app.post_json(url, props, headers=self.header,
expect_errors=True)
return resp
def put(self, path: str, cstruct: dict={}) -> TestResponse:
"""Put request to modify a resource."""
url = self._build_url(path)
resp = self.app.put_json(url, cstruct, headers=self.header,
expect_errors=True)
return resp
def post(self, path: str, cstruct: dict={}) -> TestResponse:
"""Post request to create a new resource."""
url = self._build_url(path)
resp = self.app.post_json(url, cstruct, headers=self.header,
expect_errors=True)
return resp
def _build_post_body(self, iresource: IInterface, cstruct: dict) -> dict:
return {'content_type': iresource.__identifier__,
'data': cstruct}
def _build_url(self, path: str) -> str:
if path.startswith('http'):
return path
return self.rest_url + self.base_path + path
def batch(self, subrequests: list):
"""Build and post batch request to the backend rest server."""
resp = self.app.post_json(batch_url, subrequests, headers=self.header,
expect_errors=True)
return resp
def get(self, path: str, params={}) -> TestResponse:
"""Send get request to the backend rest server."""
url = self._build_url(path)
resp = self.app.get(url,
headers=self.header,
params=params,
expect_errors=True)
return resp
def options(self, path: str) -> TestResponse:
"""Send options request to the backend rest server."""
url = self._build_url(path)
resp = self.app.options(url, headers=self.header, expect_errors=True)
return resp
def get_postable_types(self, path: str) -> []:
"""Send options request and return the postable content types."""
resp = self.options(path)
if 'POST' not in resp.json:
return []
post_request_body = resp.json['POST']['request_body']
type_names = sorted([r['content_type'] for r in post_request_body])
iresources = [self._resolver.resolve(t) for t in type_names]
return iresources
