text stringlengths 81 112k |
|---|
Compiles a template from the given string.
This is one of the required methods of Django template engines.
def from_string(self, template_code):
'''
Compiles a template from the given string.
This is one of the required methods of Django template engines.
'''
dmp = apps.get_app_config('django_mako_plus')
mako_template = Template(template_code, imports=dmp.template_imports, input_encoding=dmp.options['DEFAULT_TEMPLATE_ENCODING'])
return MakoTemplateAdapter(mako_template) |
Retrieves a template object from the pattern "app_name/template.html".
This is one of the required methods of Django template engines.
Because DMP templates are always app-specific (Django only searches
a global set of directories), the template_name MUST be in the format:
"app_name/template.html" (even on Windows). DMP splits the template_name
string on the slash to get the app name and template name.
Template rendering can be limited to a specific def/block within the template
by specifying `#def_name`, e.g. `myapp/mytemplate.html#myblockname`.
def get_template(self, template_name):
'''
Retrieves a template object from the pattern "app_name/template.html".
This is one of the required methods of Django template engines.
Because DMP templates are always app-specific (Django only searches
a global set of directories), the template_name MUST be in the format:
"app_name/template.html" (even on Windows). DMP splits the template_name
string on the slash to get the app name and template name.
Template rendering can be limited to a specific def/block within the template
by specifying `#def_name`, e.g. `myapp/mytemplate.html#myblockname`.
'''
dmp = apps.get_app_config('django_mako_plus')
match = RE_TEMPLATE_NAME.match(template_name)
if match is None or match.group(1) is None or match.group(3) is None:
raise TemplateDoesNotExist('Invalid template_name format for a DMP template. This method requires that the template name be in app_name/template.html format (separated by slash).')
if not dmp.is_registered_app(match.group(1)):
raise TemplateDoesNotExist('Not a DMP app, so deferring to other template engines for this template')
return self.get_template_loader(match.group(1)).get_template(match.group(3), def_name=match.group(5)) |
Returns a template loader object for the given app name in the given subdir.
For example, get_template_loader('homepage', 'styles') will return
a loader for the styles/ directory in the homepage app.
The app parameter can be either an app name or an AppConfig instance.
The subdir parameter is normally 'templates', 'scripts', or 'styles',
but it can be any subdirectory name of the given app.
Normally, you should not have to call this method. Django automatically
generates two shortcut functions for every DMP-registered apps,
and these shortcut functions are the preferred way to render templates.
This method is useful when you want a custom template loader to a directory
that does not conform to the app_dir/templates/* pattern.
If the loader is not found in the DMP cache, one of two things occur:
1. If create=True, it is created automatically and returned. This overrides
the need to register the app as a DMP app.
2. If create=False, a TemplateDoesNotExist is raised. This is the default
behavior.
def get_template_loader(self, app, subdir='templates', create=False):
'''
Returns a template loader object for the given app name in the given subdir.
For example, get_template_loader('homepage', 'styles') will return
a loader for the styles/ directory in the homepage app.
The app parameter can be either an app name or an AppConfig instance.
The subdir parameter is normally 'templates', 'scripts', or 'styles',
but it can be any subdirectory name of the given app.
Normally, you should not have to call this method. Django automatically
generates two shortcut functions for every DMP-registered apps,
and these shortcut functions are the preferred way to render templates.
This method is useful when you want a custom template loader to a directory
that does not conform to the app_dir/templates/* pattern.
If the loader is not found in the DMP cache, one of two things occur:
1. If create=True, it is created automatically and returned. This overrides
the need to register the app as a DMP app.
2. If create=False, a TemplateDoesNotExist is raised. This is the default
behavior.
'''
# ensure we have an AppConfig
if app is None:
raise TemplateDoesNotExist("Cannot locate loader when app is None")
if not isinstance(app, AppConfig):
app = apps.get_app_config(app)
# get the loader with the path of this app+subdir
path = os.path.join(app.path, subdir)
# if create=False, the loader must already exist in the cache
if not create:
dmp = apps.get_app_config('django_mako_plus')
if not dmp.is_registered_app(app):
raise ValueError("{} is not registered with DMP [hint: check urls.py for include('django_mako_plus.urls')].".format(app))
# return the template by path
return self.get_template_loader_for_path(path, use_cache=True) |
Returns a template loader object for the given directory path.
For example, get_template_loader('/var/mytemplates/') will return
a loader for that specific directory.
Normally, you should not have to call this method. Django automatically
adds request.dmp.render() and request.dmp.render_to_string() on each
request.
This method is useful when you want a custom template loader for a specific
directory that may be outside your project directory or that is otherwise
not contained in a normal Django app. If the directory is inside an app,
call get_template_loader() instead.
Unless use_cache=False, this method caches template loaders in the DMP
cache for later use.
def get_template_loader_for_path(self, path, use_cache=True):
'''
Returns a template loader object for the given directory path.
For example, get_template_loader('/var/mytemplates/') will return
a loader for that specific directory.
Normally, you should not have to call this method. Django automatically
adds request.dmp.render() and request.dmp.render_to_string() on each
request.
This method is useful when you want a custom template loader for a specific
directory that may be outside your project directory or that is otherwise
not contained in a normal Django app. If the directory is inside an app,
call get_template_loader() instead.
Unless use_cache=False, this method caches template loaders in the DMP
cache for later use.
'''
# get from the cache if we are able
if use_cache:
try:
return self.template_loaders[path]
except KeyError:
pass # not there, so we'll create
# create the loader
loader = MakoTemplateLoader(path, None)
# cache if we are allowed
if use_cache:
self.template_loaders[path] = loader
# return
return loader |
Triggered by the @converter_function decorator
def _register_converter(cls, conv_func, conv_type):
'''Triggered by the @converter_function decorator'''
cls.converters.append(ConverterFunctionInfo(conv_func, conv_type, len(cls.converters)))
cls._sort_converters() |
Sorts the converter functions
def _sort_converters(cls, app_ready=False):
'''Sorts the converter functions'''
# app_ready is True when called from DMP's AppConfig.ready()
# we can't sort before then because models aren't ready
cls._sorting_enabled = cls._sorting_enabled or app_ready
if cls._sorting_enabled:
for converter in cls.converters:
converter.prepare_sort_key()
cls.converters.sort(key=attrgetter('sort_key')) |
Iterates the urlparams and converts them according to the
type hints in the current view function. This is the primary
function of the class.
def convert_parameters(self, request, *args, **kwargs):
'''
Iterates the urlparams and converts them according to the
type hints in the current view function. This is the primary
function of the class.
'''
args = list(args)
urlparam_i = 0
parameters = self.view_parameters.get(request.method.lower()) or self.view_parameters.get(None)
if parameters is not None:
# add urlparams into the arguments and convert the values
for parameter_i, parameter in enumerate(parameters):
# skip request object, *args, **kwargs
if parameter_i == 0 or parameter.kind is inspect.Parameter.VAR_POSITIONAL or parameter.kind is inspect.Parameter.VAR_KEYWORD:
pass
# value in kwargs?
elif parameter.name in kwargs:
kwargs[parameter.name] = self.convert_value(kwargs[parameter.name], parameter, request)
# value in args?
elif parameter_i - 1 < len(args):
args[parameter_i - 1] = self.convert_value(args[parameter_i - 1], parameter, request)
# urlparam value?
elif urlparam_i < len(request.dmp.urlparams):
kwargs[parameter.name] = self.convert_value(request.dmp.urlparams[urlparam_i], parameter, request)
urlparam_i += 1
# can we assign a default value?
elif parameter.default is not inspect.Parameter.empty:
kwargs[parameter.name] = self.convert_value(parameter.default, parameter, request)
# fallback is None
else:
kwargs[parameter.name] = self.convert_value(None, parameter, request)
return args, kwargs |
Converts a parameter value in the view function call.
value: value from request.dmp.urlparams to convert
The value will always be a string, even if empty '' (never None).
parameter: an instance of django_mako_plus.ViewParameter that holds this parameter's
name, type, position, etc.
request: the current request object.
"converter functions" register with this class using the @parameter_converter
decorator. See converters.py for the built-in converters.
This function goes through the list of registered converter functions,
selects the most-specific one that matches the parameter.type, and
calls it to convert the value.
If the converter function raises a ValueError, it is caught and
switched to an Http404 to tell the browser that the requested URL
doesn't resolve to a page.
Other useful exceptions that converter functions can raise are:
Any extension of BaseRedirectException (RedirectException,
InternalRedirectException, JavascriptRedirectException, ...)
Http404: returns a Django Http404 response
def convert_value(self, value, parameter, request):
'''
Converts a parameter value in the view function call.
value: value from request.dmp.urlparams to convert
The value will always be a string, even if empty '' (never None).
parameter: an instance of django_mako_plus.ViewParameter that holds this parameter's
name, type, position, etc.
request: the current request object.
"converter functions" register with this class using the @parameter_converter
decorator. See converters.py for the built-in converters.
This function goes through the list of registered converter functions,
selects the most-specific one that matches the parameter.type, and
calls it to convert the value.
If the converter function raises a ValueError, it is caught and
switched to an Http404 to tell the browser that the requested URL
doesn't resolve to a page.
Other useful exceptions that converter functions can raise are:
Any extension of BaseRedirectException (RedirectException,
InternalRedirectException, JavascriptRedirectException, ...)
Http404: returns a Django Http404 response
'''
try:
# we don't convert anything without type hints
if parameter.type is inspect.Parameter.empty:
if log.isEnabledFor(logging.DEBUG):
log.debug('skipping conversion of parameter `%s` because it has no type hint', parameter.name)
return value
# find the converter method for this type
# I'm iterating through the list to find the most specific match first
# The list is sorted by specificity so subclasses come before their superclasses
for ci in self.converters:
if issubclass(parameter.type, ci.convert_type):
if log.isEnabledFor(logging.DEBUG):
log.debug('converting parameter `%s` using %s', parameter.name, ci.convert_func)
return ci.convert_func(value, parameter)
# if we get here, there wasn't a converter or this type
raise ImproperlyConfigured(message='No parameter converter exists for type: {}. Do you need to add an @parameter_converter function for the type?'.format(parameter.type))
except (BaseRedirectException, Http404):
log.info('Exception raised during conversion of parameter %s (%s): %s', parameter.position, parameter.name, e)
raise # allow these to pass through to the router
except ValueError as e:
log.info('ValueError raised during conversion of parameter %s (%s): %s', parameter.position, parameter.name, e)
raise ConverterHttp404(value, parameter, 'A parameter could not be converted - see the logs for more detail') from e
except Exception as e:
log.info('Exception raised during conversion of parameter %s (%s): %s', parameter.position, parameter.name, e)
raise ConverterException(value, parameter, 'A parameter could not be converted - see the logs for more detail') from e |
Creates an entry file for the given script map
def create_entry_file(self, filename, script_map, enapps):
'''Creates an entry file for the given script map'''
if len(script_map) == 0:
return
# create the entry file
template = MakoTemplate('''
<%! import os %>
// dynamic imports are within functions so they don't happen until called
DMP_CONTEXT.loadBundle({
%for (app, template), script_paths in script_map.items():
"${ app }/${ template }": () => [
%for path in script_paths:
import(/* webpackMode: "eager" */ "./${ os.path.relpath(path, os.path.dirname(filename)) }"),
%endfor
],
%endfor
})
''')
content = template.render(
enapps=enapps,
script_map=script_map,
filename=filename,
).strip()
# ensure the parent directories exist
if not os.path.exists(os.path.dirname(filename)):
os.makedirs(os.path.dirname(filename))
# if the file exists, then consider the options
file_exists = os.path.exists(filename)
if file_exists and self.running_inline:
# running inline means that we're in debug mode and webpack is likely watching, so
# we don't want to recreate the entry file (and cause webpack to constantly reload)
# unless we have changes
with open(filename, 'r') as fin:
if content == fin.read():
return False
if file_exists and not self.options.get('overwrite'):
raise CommandError('Refusing to destroy existing file: {} (use --overwrite option or remove the file)'.format(filename))
# if we get here, write the file
self.message('Creating {}'.format(os.path.relpath(filename, settings.BASE_DIR)), level=3)
with open(filename, 'w') as fout:
fout.write(content)
return True |
Maps templates in this app to their scripts. This function deep searches
app/templates/* for the templates of this app. Returns the following
dictionary with absolute paths:
{
( 'appname', 'template1' ): [ '/abs/path/to/scripts/template1.js', '/abs/path/to/scripts/supertemplate1.js' ],
( 'appname', 'template2' ): [ '/abs/path/to/scripts/template2.js', '/abs/path/to/scripts/supertemplate2.js', '/abs/path/to/scripts/supersuper2.js' ],
...
}
Any files or subdirectories starting with double-underscores (e.g. __dmpcache__) are skipped.
def generate_script_map(self, config):
'''
Maps templates in this app to their scripts. This function deep searches
app/templates/* for the templates of this app. Returns the following
dictionary with absolute paths:
{
( 'appname', 'template1' ): [ '/abs/path/to/scripts/template1.js', '/abs/path/to/scripts/supertemplate1.js' ],
( 'appname', 'template2' ): [ '/abs/path/to/scripts/template2.js', '/abs/path/to/scripts/supertemplate2.js', '/abs/path/to/scripts/supersuper2.js' ],
...
}
Any files or subdirectories starting with double-underscores (e.g. __dmpcache__) are skipped.
'''
script_map = OrderedDict()
template_root = os.path.join(os.path.relpath(config.path, settings.BASE_DIR), 'templates')
def recurse(folder):
subdirs = []
if os.path.exists(folder):
for filename in os.listdir(folder):
if filename.startswith('__'):
continue
filerel = os.path.join(folder, filename)
if os.path.isdir(filerel):
subdirs.append(filerel)
elif os.path.isfile(filerel):
template_name = os.path.relpath(filerel, template_root)
scripts = self.template_scripts(config, template_name)
key = ( config.name, os.path.splitext(template_name)[0] )
self.message('Found template: {}; static files: {}'.format(key, scripts), level=3)
script_map[key] = scripts
for subdir in subdirs:
recurse(subdir)
recurse(template_root)
return script_map |
Returns a list of scripts used by the given template object AND its ancestors.
This runs a ProviderRun on the given template (as if it were being displayed).
This allows the WEBPACK_PROVIDERS to provide the JS files to us.
def template_scripts(self, config, template_name):
'''
Returns a list of scripts used by the given template object AND its ancestors.
This runs a ProviderRun on the given template (as if it were being displayed).
This allows the WEBPACK_PROVIDERS to provide the JS files to us.
'''
dmp = apps.get_app_config('django_mako_plus')
template_obj = dmp.engine.get_template_loader(config, create=True).get_mako_template(template_name, force=True)
mako_context = create_mako_context(template_obj)
inner_run = WebpackProviderRun(mako_context['self'])
inner_run.run()
scripts = []
for tpl in inner_run.templates:
for p in tpl.providers:
if os.path.exists(p.absfilepath):
scripts.append(p.absfilepath)
return scripts |
Returns the redirect response for this exception.
def get_response(self, request, *args, **kwargs):
'''Returns the redirect response for this exception.'''
# normal process
response = HttpResponseRedirect(self.redirect_to)
response[REDIRECT_HEADER_KEY] = self.redirect_to
return response |
Returns the redirect response for this exception.
def get_response(self, request):
'''Returns the redirect response for this exception.'''
# the redirect key is already placed in the response by HttpResponseJavascriptRedirect
return HttpResponseJavascriptRedirect(self.redirect_to, *self.args, **self.kwargs) |
Convenience method that calls get_template_loader() on the DMP
template engine instance.
def get_template_loader(app, subdir='templates'):
'''
Convenience method that calls get_template_loader() on the DMP
template engine instance.
'''
dmp = apps.get_app_config('django_mako_plus')
return dmp.engine.get_template_loader(app, subdir, create=True) |
Convenience method that directly renders a template, given the app and template names.
def render_template(request, app, template_name, context=None, subdir="templates", def_name=None):
'''
Convenience method that directly renders a template, given the app and template names.
'''
return get_template(app, template_name, subdir).render(context, request, def_name) |
Convenience method that calls get_template_loader_for_path() on the DMP
template engine instance.
def get_template_loader_for_path(path, use_cache=True):
'''
Convenience method that calls get_template_loader_for_path() on the DMP
template engine instance.
'''
dmp = apps.get_app_config('django_mako_plus')
return dmp.engine.get_template_loader_for_path(path, use_cache) |
Convenience method that retrieves a template given a direct path to it.
def get_template_for_path(path, use_cache=True):
'''
Convenience method that retrieves a template given a direct path to it.
'''
dmp = apps.get_app_config('django_mako_plus')
app_path, template_name = os.path.split(path)
return dmp.engine.get_template_loader_for_path(app_path, use_cache=use_cache).get_template(template_name) |
Convenience method that directly renders a template, given a direct path to it.
def render_template_for_path(request, path, context=None, use_cache=True, def_name=None):
'''
Convenience method that directly renders a template, given a direct path to it.
'''
return get_template_for_path(path, use_cache).render(context, request, def_name) |
Returns the fully-qualified name of the given object
def qualified_name(obj):
'''Returns the fully-qualified name of the given object'''
if not hasattr(obj, '__module__'):
obj = obj.__class__
module = obj.__module__
if module is None or module == str.__class__.__module__:
return obj.__qualname__
return '{}.{}'.format(module, obj.__qualname__) |
Imports a fully-qualified name from a module:
cls = import_qualified('homepage.views.index.MyForm')
Raises an ImportError if it can't be ipmorted.
def import_qualified(name):
'''
Imports a fully-qualified name from a module:
cls = import_qualified('homepage.views.index.MyForm')
Raises an ImportError if it can't be ipmorted.
'''
parts = name.rsplit('.', 1)
if len(parts) != 2:
raise ImportError('Invalid fully-qualified name: {}'.format(name))
try:
return getattr(import_module(parts[0]), parts[1])
except AttributeError:
raise ImportError('{} not found in module {}'.format(parts[1], parts[0])) |
Returns the HTML for the given provider group (or all groups if None)
def links(tself, group=None):
'''Returns the HTML for the given provider group (or all groups if None)'''
pr = ProviderRun(tself, group)
pr.run()
return mark_safe(pr.getvalue()) |
Returns the HTML for the given provider group, using an app and template name.
This method should not normally be used (use links() instead). The use of
this method is when provider need to be called from regular python code instead
of from within a rendering template environment.
def template_links(request, app, template_name, context=None, group=None, force=True):
'''
Returns the HTML for the given provider group, using an app and template name.
This method should not normally be used (use links() instead). The use of
this method is when provider need to be called from regular python code instead
of from within a rendering template environment.
'''
if isinstance(app, str):
app = apps.get_app_config(app)
if context is None:
context = {}
dmp = apps.get_app_config('django_mako_plus')
template_obj = dmp.engine.get_template_loader(app, create=True).get_mako_template(template_name, force=force)
return template_obj_links(request, template_obj, context, group) |
Returns the HTML for the given provider group, using a template object.
This method should not normally be used (use links() instead). The use of
this method is when provider need to be called from regular python code instead
of from within a rendering template environment.
def template_obj_links(request, template_obj, context=None, group=None):
'''
Returns the HTML for the given provider group, using a template object.
This method should not normally be used (use links() instead). The use of
this method is when provider need to be called from regular python code instead
of from within a rendering template environment.
'''
# the template_obj can be a MakoTemplateAdapter or a Mako Template
# if our DMP-defined MakoTemplateAdapter, switch to the embedded Mako Template
template_obj = getattr(template_obj, 'mako_template', template_obj)
# create a mako context so it seems like we are inside a render
context_dict = {
'request': request,
}
if isinstance(context, Context):
for d in context:
context_dict.update(d)
elif context is not None:
context_dict.update(context)
mako_context = create_mako_context(template_obj, **context_dict)
return links(mako_context['self'], group=group) |
Called when 'link' is not defined in the settings
def build_default_link(self):
'''Called when 'link' is not defined in the settings'''
attrs = {}
attrs["rel"] = "stylesheet"
attrs["href"] ="{}?{:x}".format(
os.path.join(settings.STATIC_URL, self.filepath).replace(os.path.sep, '/'),
self.version_id,
)
attrs.update(self.options['link_attrs'])
attrs["data-context"] = self.provider_run.uid # can't be overridden
return '<link{} />'.format(flatatt(attrs)) |
Called when 'filepath' is not defined in the settings
def build_default_filepath(self):
'''Called when 'filepath' is not defined in the settings'''
return os.path.join(
self.app_config.name,
'scripts',
self.template_relpath + '.js',
) |
Mako tag to include a Django template withing the current DMP (Mako) template.
Since this is a Django template, it is search for using the Django search
algorithm (instead of the DMP app-based concept).
See https://docs.djangoproject.com/en/2.1/topics/templates/.
The current context is sent to the included template, which makes all context
variables available to the Django template. Any additional kwargs are added
to the context.
def django_include(context, template_name, **kwargs):
'''
Mako tag to include a Django template withing the current DMP (Mako) template.
Since this is a Django template, it is search for using the Django search
algorithm (instead of the DMP app-based concept).
See https://docs.djangoproject.com/en/2.1/topics/templates/.
The current context is sent to the included template, which makes all context
variables available to the Django template. Any additional kwargs are added
to the context.
'''
try:
djengine = engines['django']
except KeyError as e:
raise TemplateDoesNotExist("Django template engine not configured in settings, so template cannot be found: {}".format(template_name)) from e
djtemplate = djengine.get_template(template_name)
djcontext = {}
djcontext.update(context)
djcontext.update(kwargs)
return djtemplate.render(djcontext, context['request']) |
Internal method to toggle autoescaping on or off. This function
needs access to the caller, so the calling method must be
decorated with @supports_caller.
def _toggle_autoescape(context, escape_on=True):
'''
Internal method to toggle autoescaping on or off. This function
needs access to the caller, so the calling method must be
decorated with @supports_caller.
'''
previous = is_autoescape(context)
setattr(context.caller_stack, AUTOESCAPE_KEY, escape_on)
try:
context['caller'].body()
finally:
setattr(context.caller_stack, AUTOESCAPE_KEY, previous) |
Returns a relative path, but only if it doesn't start with a non-pretty parent directory ".."
def pretty_relpath(path, start):
'''
Returns a relative path, but only if it doesn't start with a non-pretty parent directory ".."
'''
relpath = os.path.relpath(path, start)
if relpath.startswith('..'):
return path
return relpath |
Returns True if the given function is decorated with @view_function
def is_decorated(cls, f):
'''Returns True if the given function is decorated with @view_function'''
real_func = inspect.unwrap(f)
return real_func in cls.DECORATED_FUNCTIONS |
Initializes the providers (called from dmp app ready())
def initialize_providers(cls):
'''Initializes the providers (called from dmp app ready())'''
dmp = apps.get_app_config('django_mako_plus')
# regular content providers
cls.CONTENT_PROVIDERS = []
for provider_settings in dmp.options[cls.SETTINGS_KEY]:
# import the class for this provider
assert 'provider' in provider_settings, "Invalid entry in settings.py: CONTENT_PROVIDERS item must have 'provider' key"
provider_cls = import_string(provider_settings['provider'])
# combine options from all of its bases, then from settings.py
options = {}
for base in reversed(inspect.getmro(provider_cls)):
options.update(getattr(base, 'DEFAULT_OPTIONS', {}))
options.update(provider_settings)
# add to the list
if options['enabled']:
pe = ProviderEntry(provider_cls, options)
pe.options['template_cache_key'] = '_dmp_provider_{}_'.format(id(pe))
cls.CONTENT_PROVIDERS.append(pe) |
Performs the run through the templates and their providers
def run(self):
'''Performs the run through the templates and their providers'''
for tpl in self.templates:
for provider in tpl.providers:
provider.provide() |
Provider instances use this to write to the buffer
def write(self, content):
'''Provider instances use this to write to the buffer'''
self.buffer.write(content)
if settings.DEBUG:
self.buffer.write('\n') |
Triggered by view_function._sort_converters when our sort key should be created.
This can't be called in the constructor because Django models might not be ready yet.
def prepare_sort_key(self):
'''
Triggered by view_function._sort_converters when our sort key should be created.
This can't be called in the constructor because Django models might not be ready yet.
'''
if isinstance(self.convert_type, str):
try:
app_name, model_name = self.convert_type.split('.')
except ValueError:
raise ImproperlyConfigured('"{}" is not a valid converter type. String-based converter types must be specified in "app.Model" format.'.format(self.convert_type))
try:
self.convert_type = apps.get_model(app_name, model_name)
except LookupError as e:
raise ImproperlyConfigured('"{}" is not a valid model name. {}'.format(self.convert_type, e))
# we reverse sort by ( len(mro), source code order ) so subclasses match first
# on same types, last declared method sorts first
self.sort_key = ( -1 * len(inspect.getmro(self.convert_type)), -1 * self.source_order ) |
Returns the command to run, as a list (see subprocess module)
def build_command(self):
'''Returns the command to run, as a list (see subprocess module)'''
# if defined in settings, run the function or return the string
if self.options['command']:
return self.options['command'](self) if callable(self.options['command']) else self.options['command']
# build the default
return self.build_default_command() |
Returns True if self.sourcepath is newer than self.targetpath
def needs_compile(self):
'''Returns True if self.sourcepath is newer than self.targetpath'''
try:
source_mtime = os.stat(self.sourcepath).st_mtime
except OSError: # no source for this template, so just return
return False
try:
target_mtime = os.stat(self.targetpath).st_mtime
except OSError: # target doesn't exist, so compile
return True
# both source and target exist, so compile if source newer
return source_mtime > target_mtime |
Generator that iterates the template and its ancestors.
The order is from most specialized (furthest descendant) to
most general (furthest ancestor).
obj can be either:
1. Mako Template object
2. Mako `self` object (available within a rendering template)
def template_inheritance(obj):
'''
Generator that iterates the template and its ancestors.
The order is from most specialized (furthest descendant) to
most general (furthest ancestor).
obj can be either:
1. Mako Template object
2. Mako `self` object (available within a rendering template)
'''
if isinstance(obj, MakoTemplate):
obj = create_mako_context(obj)['self']
elif isinstance(obj, MakoContext):
obj = obj['self']
while obj is not None:
yield obj.template
obj = obj.inherits |
This structure is what Django wants when errors occur in templates.
It gives the user a nice stack trace in the error page during debug.
def get_template_debug(template_name, error):
'''
This structure is what Django wants when errors occur in templates.
It gives the user a nice stack trace in the error page during debug.
'''
# This is taken from mako.exceptions.html_error_template(), which has an issue
# in Py3 where files get loaded as bytes but `lines = src.split('\n')` below
# splits with a string. Not sure if this is a bug or if I'm missing something,
# but doing a custom debugging template allows a workaround as well as a custom
# DMP look.
# I used to have a file in the templates directory for this, but too many users
# reported TemplateNotFound errors. This function is a bit of a hack, but it only
# happens during development (and mako.exceptions does this same thing).
# /justification
stacktrace_template = MakoTemplate(r"""
<%! from mako.exceptions import syntax_highlight, pygments_html_formatter %>
<style>
.stacktrace { margin:5px 5px 5px 5px; }
.highlight { padding:0px 10px 0px 10px; background-color:#9F9FDF; }
.nonhighlight { padding:0px; background-color:#DFDFDF; }
.sample { padding:10px; margin:10px 10px 10px 10px;
font-family:monospace; }
.sampleline { padding:0px 10px 0px 10px; }
.sourceline { margin:5px 5px 10px 5px; font-family:monospace;}
.location { font-size:80%; }
.highlight { white-space:pre; }
.sampleline { white-space:pre; }
% if pygments_html_formatter:
${pygments_html_formatter.get_style_defs() | n}
.linenos { min-width: 2.5em; text-align: right; }
pre { margin: 0; }
.syntax-highlighted { padding: 0 10px; }
.syntax-highlightedtable { border-spacing: 1px; }
.nonhighlight { border-top: 1px solid #DFDFDF;
border-bottom: 1px solid #DFDFDF; }
.stacktrace .nonhighlight { margin: 5px 15px 10px; }
.sourceline { margin: 0 0; font-family:monospace; }
.code { background-color: #F8F8F8; width: 100%; }
.error .code { background-color: #FFBDBD; }
.error .syntax-highlighted { background-color: #FFBDBD; }
% endif
## adjustments to Django css
table.source {
background-color: #fdfdfd;
}
table.source > tbody > tr > th {
width: auto;
}
table.source > tbody > tr > td {
font-family: inherit;
white-space: normal;
padding: 15px;
}
#template {
background-color: #b3daff;
}
</style>
<%
src = tback.source
line = tback.lineno
if isinstance(src, bytes):
src = src.decode()
if src:
lines = src.split('\n')
else:
lines = None
%>
<h3>${tback.errorname}: ${tback.message}</h3>
% if lines:
<div class="sample">
<div class="nonhighlight">
% for index in range(max(0, line-4),min(len(lines), line+5)):
<%
if pygments_html_formatter:
pygments_html_formatter.linenostart = index + 1
%>
% if index + 1 == line:
<%
if pygments_html_formatter:
old_cssclass = pygments_html_formatter.cssclass
pygments_html_formatter.cssclass = 'error ' + old_cssclass
%>
${lines[index] | n,syntax_highlight(language='mako')}
<%
if pygments_html_formatter:
pygments_html_formatter.cssclass = old_cssclass
%>
% else:
${lines[index] | n,syntax_highlight(language='mako')}
% endif
% endfor
</div>
</div>
% endif
<div class="stacktrace">
% for (filename, lineno, function, line) in tback.reverse_traceback:
<div class="location">${filename}, line ${lineno}:</div>
<div class="nonhighlight">
<%
if pygments_html_formatter:
pygments_html_formatter.linenostart = lineno
%>
<div class="sourceline">${line | n,syntax_highlight(filename)}</div>
</div>
% endfor
</div>
""")
tback = RichTraceback(error, error.__traceback__)
lines = stacktrace_template.render_unicode(tback=tback)
return {
'message': '',
'source_lines': [
( '', mark_safe(lines) ),
],
'before': '',
'during': '',
'after': '',
'top': 0,
'bottom': 0,
'total': 0,
'line': tback.lineno or 0,
'name': template_name,
'start': 0,
'end': 0,
} |
Returns the name of this template (if created from a file) or "string" if not
def name(self):
'''Returns the name of this template (if created from a file) or "string" if not'''
if self.mako_template.filename:
return os.path.basename(self.mako_template.filename)
return 'string' |
Renders a template using the Mako system. This method signature conforms to
the Django template API, which specifies that template.render() returns a string.
@context A dictionary of name=value variables to send to the template page. This can be a real dictionary
or a Django Context object.
@request The request context from Django. If this is None, any TEMPLATE_CONTEXT_PROCESSORS defined in your settings
file will be ignored but the template will otherwise render fine.
@def_name Limits output to a specific top-level Mako <%block> or <%def> section within the template.
If the section is a <%def>, any parameters must be in the context dictionary. For example,
def_name="foo" will call <%block name="foo"></%block> or <%def name="foo()"></def> within
the template.
Returns the rendered template as a unicode string.
The method triggers two signals:
1. dmp_signal_pre_render_template: you can (optionally) return a new Mako Template object from a receiver to replace
the normal template object that is used for the render operation.
2. dmp_signal_post_render_template: you can (optionally) return a string to replace the string from the normal
template object render.
def render(self, context=None, request=None, def_name=None):
'''
Renders a template using the Mako system. This method signature conforms to
the Django template API, which specifies that template.render() returns a string.
@context A dictionary of name=value variables to send to the template page. This can be a real dictionary
or a Django Context object.
@request The request context from Django. If this is None, any TEMPLATE_CONTEXT_PROCESSORS defined in your settings
file will be ignored but the template will otherwise render fine.
@def_name Limits output to a specific top-level Mako <%block> or <%def> section within the template.
If the section is a <%def>, any parameters must be in the context dictionary. For example,
def_name="foo" will call <%block name="foo"></%block> or <%def name="foo()"></def> within
the template.
Returns the rendered template as a unicode string.
The method triggers two signals:
1. dmp_signal_pre_render_template: you can (optionally) return a new Mako Template object from a receiver to replace
the normal template object that is used for the render operation.
2. dmp_signal_post_render_template: you can (optionally) return a string to replace the string from the normal
template object render.
'''
dmp = apps.get_app_config('django_mako_plus')
# set up the context dictionary, which is the variables available throughout the template
context_dict = {}
# if request is None, add some default items because the context processors won't happen
if request is None:
context_dict['settings'] = settings
context_dict['STATIC_URL'] = settings.STATIC_URL
# let the context_processors add variables to the context.
if not isinstance(context, Context):
context = Context(context) if request is None else RequestContext(request, context)
with context.bind_template(self):
for d in context:
context_dict.update(d)
context_dict.pop('self', None) # some contexts have self in them, and it messes up render_unicode below because we get two selfs
# send the pre-render signal
if dmp.options['SIGNALS'] and request is not None:
for receiver, ret_template_obj in dmp_signal_pre_render_template.send(sender=self, request=request, context=context, template=self.mako_template):
if ret_template_obj is not None:
if isinstance(ret_template_obj, MakoTemplateAdapter):
self.mako_template = ret_template_obj.mako_template # if the signal function sends a MakoTemplateAdapter back, use the real mako template inside of it
else:
self.mako_template = ret_template_obj # if something else, we assume it is a mako.template.Template, so use it as the template
# do we need to limit down to a specific def?
# this only finds within the exact template (won't go up the inheritance tree)
render_obj = self.mako_template
if def_name is None:
def_name = self.def_name
if def_name: # do we need to limit to just a def?
render_obj = self.mako_template.get_def(def_name)
# PRIMARY FUNCTION: render the template
if log.isEnabledFor(logging.INFO):
log.info('rendering template %s%s%s', self.name, ('::' if def_name else ''), def_name or '')
if settings.DEBUG:
try:
content = render_obj.render_unicode(**context_dict)
except Exception as e:
log.exception('exception raised during template rendering: %s', e) # to the console
e.template_debug = get_template_debug('%s%s%s' % (self.name, ('::' if def_name else ''), def_name or ''), e)
raise
else: # this is outside the above "try" loop because in non-DEBUG mode, we want to let the exception throw out of here (without having to re-raise it)
content = render_obj.render_unicode(**context_dict)
# send the post-render signal
if dmp.options['SIGNALS'] and request is not None:
for receiver, ret_content in dmp_signal_post_render_template.send(sender=self, request=request, context=context, template=self.mako_template, content=content):
if ret_content is not None:
content = ret_content # sets it to the last non-None return in the signal receiver chain
# return
return mark_safe(content) |
Renders the template and returns an HttpRequest object containing its content.
This method returns a django.http.Http404 exception if the template is not found.
If the template raises a django_mako_plus.RedirectException, the browser is redirected to
the given page, and a new request from the browser restarts the entire DMP routing process.
If the template raises a django_mako_plus.InternalRedirectException, the entire DMP
routing process is restarted internally (the browser doesn't see the redirect).
@request The request context from Django. If this is None, any TEMPLATE_CONTEXT_PROCESSORS defined in your settings
file will be ignored but the template will otherwise render fine.
@template The template file path to render. This is relative to the app_path/controller_TEMPLATES_DIR/ directory.
For example, to render app_path/templates/page1, set template="page1.html", assuming you have
set up the variables as described in the documentation above.
@context A dictionary of name=value variables to send to the template page. This can be a real dictionary
or a Django Context object.
@def_name Limits output to a specific top-level Mako <%block> or <%def> section within the template.
For example, def_name="foo" will call <%block name="foo"></%block> or <%def name="foo()"></def> within the template.
@content_type The MIME type of the response. Defaults to settings.DEFAULT_CONTENT_TYPE (usually 'text/html').
@status The HTTP response status code. Defaults to 200 (OK).
@charset The charset to encode the processed template string (the output) with. Defaults to settings.DEFAULT_CHARSET (usually 'utf-8').
The method triggers two signals:
1. dmp_signal_pre_render_template: you can (optionally) return a new Mako Template object from a receiver to replace
the normal template object that is used for the render operation.
2. dmp_signal_post_render_template: you can (optionally) return a string to replace the string from the normal
template object render.
def render_to_response(self, context=None, request=None, def_name=None, content_type=None, status=None, charset=None):
'''
Renders the template and returns an HttpRequest object containing its content.
This method returns a django.http.Http404 exception if the template is not found.
If the template raises a django_mako_plus.RedirectException, the browser is redirected to
the given page, and a new request from the browser restarts the entire DMP routing process.
If the template raises a django_mako_plus.InternalRedirectException, the entire DMP
routing process is restarted internally (the browser doesn't see the redirect).
@request The request context from Django. If this is None, any TEMPLATE_CONTEXT_PROCESSORS defined in your settings
file will be ignored but the template will otherwise render fine.
@template The template file path to render. This is relative to the app_path/controller_TEMPLATES_DIR/ directory.
For example, to render app_path/templates/page1, set template="page1.html", assuming you have
set up the variables as described in the documentation above.
@context A dictionary of name=value variables to send to the template page. This can be a real dictionary
or a Django Context object.
@def_name Limits output to a specific top-level Mako <%block> or <%def> section within the template.
For example, def_name="foo" will call <%block name="foo"></%block> or <%def name="foo()"></def> within the template.
@content_type The MIME type of the response. Defaults to settings.DEFAULT_CONTENT_TYPE (usually 'text/html').
@status The HTTP response status code. Defaults to 200 (OK).
@charset The charset to encode the processed template string (the output) with. Defaults to settings.DEFAULT_CHARSET (usually 'utf-8').
The method triggers two signals:
1. dmp_signal_pre_render_template: you can (optionally) return a new Mako Template object from a receiver to replace
the normal template object that is used for the render operation.
2. dmp_signal_post_render_template: you can (optionally) return a string to replace the string from the normal
template object render.
'''
try:
if content_type is None:
content_type = mimetypes.types_map.get(os.path.splitext(self.mako_template.filename)[1].lower(), settings.DEFAULT_CONTENT_TYPE)
if charset is None:
charset = settings.DEFAULT_CHARSET
if status is None:
status = 200
content = self.render(context=context, request=request, def_name=def_name)
return HttpResponse(content.encode(charset), content_type='%s; charset=%s' % (content_type, charset), status=status)
except RedirectException: # redirect to another page
e = sys.exc_info()[1]
if request is None:
log.info('a template redirected processing to %s', e.redirect_to)
else:
log.info('view function %s.%s redirected processing to %s', request.dmp.module, request.dmp.function, e.redirect_to)
# send the signal
dmp = apps.get_app_config('django_mako_plus')
if dmp.options['SIGNALS']:
dmp_signal_redirect_exception.send(sender=sys.modules[__name__], request=request, exc=e)
# send the browser the redirect command
return e.get_response(request) |
Retrieves the given parser action object by its dest= attribute
def get_action_by_dest(self, parser, dest):
'''Retrieves the given parser action object by its dest= attribute'''
for action in parser._actions:
if action.dest == dest:
return action
return None |
Placing this in execute because then subclass handle() don't have to call super
def execute(self, *args, **options):
'''Placing this in execute because then subclass handle() don't have to call super'''
if options['verbose']:
options['verbosity'] = 3
if options['quiet']:
options['verbosity'] = 0
self.verbosity = options.get('verbosity', 1)
super().execute(*args, **options) |
Print a message to the console
def message(self, msg='', level=1, tab=0):
'''Print a message to the console'''
if self.verbosity >= level:
self.stdout.write('{}{}'.format(' ' * tab, msg)) |
Encodes a UID to an 11-length string, encoded using base58 url-safe alphabet
def b58enc(uid):
'''Encodes a UID to an 11-length string, encoded using base58 url-safe alphabet'''
# note: i tested a buffer array too, but string concat was 2x faster
if not isinstance(uid, int):
raise ValueError('Invalid integer: {}'.format(uid))
if uid == 0:
return BASE58CHARS[0]
enc_uid = ""
while uid:
uid, r = divmod(uid, 58)
enc_uid = BASE58CHARS[r] + enc_uid
return enc_uid |
Decodes a UID from base58, url-safe alphabet back to int.
def b58dec(enc_uid):
'''Decodes a UID from base58, url-safe alphabet back to int.'''
if isinstance(enc_uid, str):
pass
elif isinstance(enc_uid, bytes):
enc_uid = enc_uid.decode('utf8')
else:
raise ValueError('Cannot decode this type: {}'.format(enc_uid))
uid = 0
try:
for i, ch in enumerate(enc_uid):
uid = (uid * 58) + BASE58INDEX[ch]
except KeyError:
raise ValueError('Invalid character: "{}" ("{}", index 5)'.format(ch, enc_uid, i))
return uid |
Minifies the source text (if needed)
def minify(text, minifier):
'''Minifies the source text (if needed)'''
# there really isn't a good way to know if a file is already minified.
# our heuristic is if source is more than 50 bytes greater of dest OR
# if a hard return is found in the first 50 chars, we assume it is not minified.
minified = minifier(text)
if abs(len(text) - len(minified)) > 50 or '\n' in text[:50]:
return minified
return text |
Returns the result score if the file matches this rule
def match(self, fname, flevel, ftype):
'''Returns the result score if the file matches this rule'''
# if filetype is the same
# and level isn't set or level is the same
# and pattern matche the filename
if self.filetype == ftype and (self.level is None or self.level == flevel) and fnmatch.fnmatch(fname, self.pattern):
return self.score
return 0 |
Adds rules for the command line options
def create_rules(self):
'''Adds rules for the command line options'''
dmp = apps.get_app_config('django_mako_plus')
# the default
rules = [
# files are included by default
Rule('*', level=None, filetype=TYPE_FILE, score=1),
# files at the app level are skipped
Rule('*', level=0, filetype=TYPE_FILE, score=-2),
# directories are recursed by default
Rule('*', level=None, filetype=TYPE_DIRECTORY, score=1),
# directories at the app level are skipped
Rule('*', level=0, filetype=TYPE_DIRECTORY, score=-2),
# media, scripts, styles directories are what we want to copy
Rule('media', level=0, filetype=TYPE_DIRECTORY, score=6),
Rule('scripts', level=0, filetype=TYPE_DIRECTORY, score=6),
Rule('styles', level=0, filetype=TYPE_DIRECTORY, score=6),
# ignore the template cache directories
Rule(dmp.options['TEMPLATES_CACHE_DIR'], level=None, filetype=TYPE_DIRECTORY, score=-3),
# ignore python cache directories
Rule('__pycache__', level=None, filetype=TYPE_DIRECTORY, score=-3),
# ignore compiled python files
Rule('*.pyc', level=None, filetype=TYPE_FILE, score=-3),
]
# include rules have score of 50 because they trump all initial rules
for pattern in (self.options.get('include_dir') or []):
self.message('Setting rule - recurse directories: {}'.format(pattern), 1)
rules.append(Rule(pattern, level=None, filetype=TYPE_DIRECTORY, score=50))
for pattern in (self.options.get('include_file') or []):
self.message('Setting rule - include files: {}'.format(pattern), 1)
rules.append(Rule(pattern, level=None, filetype=TYPE_FILE, score=50))
# skip rules have score of 100 because they trump everything, including the includes from the command line
for pattern in (self.options.get('skip_dir') or []):
self.message('Setting rule - skip directories: {}'.format(pattern), 1)
rules.append(Rule(pattern, level=None, filetype=TYPE_DIRECTORY, score=-100))
for pattern in (self.options.get('skip_file') or []):
self.message('Setting rule - skip files: {}'.format(pattern), 1)
rules.append(Rule(pattern, level=None, filetype=TYPE_FILE, score=-100))
return rules |
Copies the static files from one directory to another. If this command is run, we assume the user wants to overwrite any existing files.
def copy_dir(self, source, dest, level=0):
'''Copies the static files from one directory to another. If this command is run, we assume the user wants to overwrite any existing files.'''
encoding = settings.DEFAULT_CHARSET or 'utf8'
msglevel = 2 if level == 0 else 3
self.message('Directory: {}'.format(source), msglevel, level)
# create a directory for this app
if not os.path.exists(dest):
self.message('Creating directory: {}'.format(dest), msglevel, level+1)
os.mkdir(dest)
# go through the files in this app
for fname in os.listdir(source):
source_path = os.path.join(source, fname)
dest_path = os.path.join(dest, fname)
ext = os.path.splitext(fname)[1].lower()
# get the score for this file
score = 0
for rule in self.rules:
score += rule.match(fname, level, TYPE_DIRECTORY if os.path.isdir(source_path) else TYPE_FILE)
# if score is not above zero, we skip this file
if score <= 0:
self.message('Skipping file with score {}: {}'.format(score, source_path), msglevel, level+1)
continue
### if we get here, we need to copy the file ###
# if a directory, recurse to it
if os.path.isdir(source_path):
self.message('Creating directory with score {}: {}'.format(score, source_path), msglevel, level+1)
# create it in the destination and recurse
if not os.path.exists(dest_path):
os.mkdir(dest_path)
elif not os.path.isdir(dest_path): # could be a file or link
os.unlink(dest_path)
os.mkdir(dest_path)
self.copy_dir(source_path, dest_path, level+1)
# if a regular Javscript file, run through the static file processors (scripts group)
elif ext == '.js' and not self.options.get('no_minify') and jsmin:
self.message('Including and minifying file with score {}: {}'.format(score, source_path), msglevel, level+1)
with open(source_path, encoding=encoding) as fin:
with open(dest_path, 'w', encoding=encoding) as fout:
minified = minify(fin.read(), jsmin)
fout.write(minified)
# if a CSS file, run through the static file processors (styles group)
elif ext == '.css' and not self.options.get('no_minify') and cssmin:
self.message('Including and minifying file with score {}: {}'.format(score, source_path), msglevel, level+1)
with open(source_path, encoding=encoding) as fin:
with open(dest_path, 'w', encoding=encoding) as fout:
minified = minify(fin.read(), cssmin)
fout.write(minified)
# otherwise, just copy the file
else:
self.message('Including file with score {}: {}'.format(score, source_path), msglevel, level+1)
shutil.copy2(source_path, dest_path) |
Includes a DMP (Mako) template into a normal django template.
context: automatically provided
template_name: specified as "app/template"
def_name: optional block to render within the template
Example:
{% load django_mako_plus %}
{% dmp_include "homepage/bsnav_dj.html" %}
or
{% dmp_include "homepage/bsnav_dj.html" "blockname" %}
def dmp_include(context, template_name, def_name=None, **kwargs):
'''
Includes a DMP (Mako) template into a normal django template.
context: automatically provided
template_name: specified as "app/template"
def_name: optional block to render within the template
Example:
{% load django_mako_plus %}
{% dmp_include "homepage/bsnav_dj.html" %}
or
{% dmp_include "homepage/bsnav_dj.html" "blockname" %}
'''
dmp = apps.get_app_config('django_mako_plus')
template = dmp.engine.get_template(template_name)
dmpcontext = context.flatten()
dmpcontext.update(kwargs)
return mark_safe(template.render(
context=dmpcontext,
request=context.get('request'),
def_name=def_name
)) |
App-specific render function that renders templates in the *current app*, attached to the request for convenience
def render(self, template, context=None, def_name=None, subdir='templates', content_type=None, status=None, charset=None):
'''App-specific render function that renders templates in the *current app*, attached to the request for convenience'''
template_adapter = self.get_template_loader(subdir).get_template(template)
return getattr(template_adapter, 'render_to_response')(context=context, request=self.request, def_name=def_name, content_type=content_type, status=status, charset=charset) |
App-specific render function that renders templates in the *current app*, attached to the request for convenience
def render_to_string(self, template, context=None, def_name=None, subdir='templates'):
'''App-specific render function that renders templates in the *current app*, attached to the request for convenience'''
template_adapter = self.get_template_loader(subdir).get_template(template)
return getattr(template_adapter, 'render')(context=context, request=self.request, def_name=def_name) |
App-specific function to get the current app's template loader
def get_template_loader(self, subdir='templates'):
'''App-specific function to get the current app's template loader'''
if self.request is None:
raise ValueError("this method can only be called after the view middleware is run. Check that `django_mako_plus.middleware` is in MIDDLEWARE.")
dmp = apps.get_app_config('django_mako_plus')
return dmp.engine.get_template_loader(self.app, subdir) |
Called by Django when the app is ready for use.
def ready(self):
'''Called by Django when the app is ready for use.'''
# set up the options
self.options = {}
self.options.update(DEFAULT_OPTIONS)
for template_engine in settings.TEMPLATES:
if template_engine.get('BACKEND', '').startswith('django_mako_plus'):
self.options.update(template_engine.get('OPTIONS', {}))
# dmp-enabled apps registry
self.registration_lock = threading.RLock()
self.registered_apps = {}
# init the template engine
self.engine = engines['django_mako_plus']
# default imports on every compiled template
self.template_imports = [
'import django_mako_plus',
'import django.utils.html', # used in template.py
]
self.template_imports.extend(self.options['DEFAULT_TEMPLATE_IMPORTS'])
# initialize the list of providers
ProviderRun.initialize_providers()
# set up the parameter converters (can't import until apps are set up)
from .converter.base import ParameterConverter
ParameterConverter._sort_converters(app_ready=True) |
Registers an app as a "DMP-enabled" app. Normally, DMP does this
automatically when included in urls.py.
If app is None, the DEFAULT_APP is registered.
def register_app(self, app=None):
'''
Registers an app as a "DMP-enabled" app. Normally, DMP does this
automatically when included in urls.py.
If app is None, the DEFAULT_APP is registered.
'''
app = app or self.options['DEFAULT_APP']
if not app:
raise ImproperlyConfigured('An app name is required because DEFAULT_APP is empty - please use a '
'valid app name or set the DEFAULT_APP in settings')
if isinstance(app, str):
app = apps.get_app_config(app)
# since this only runs at startup, this lock doesn't affect performance
with self.registration_lock:
# short circuit if already registered
if app.name in self.registered_apps:
return
# first time for this app, so add to our dictionary
self.registered_apps[app.name] = app
# set up the template, script, and style renderers
# these create and cache just by accessing them
self.engine.get_template_loader(app, 'templates', create=True)
self.engine.get_template_loader(app, 'scripts', create=True)
self.engine.get_template_loader(app, 'styles', create=True)
# send the registration signal
if self.options['SIGNALS']:
dmp_signal_register_app.send(sender=self, app_config=app) |
Returns true if the given app/app name is registered with DMP
def is_registered_app(self, app):
'''Returns true if the given app/app name is registered with DMP'''
if app is None:
return False
if isinstance(app, AppConfig):
app = app.name
return app in self.registered_apps |
Returns the element at idx, or default if idx is beyond the length of the list
def get(self, idx, default=''):
'''Returns the element at idx, or default if idx is beyond the length of the list'''
# if the index is beyond the length of the list, return ''
if isinstance(idx, int) and (idx >= len(self) or idx < -1 * len(self)):
return default
# else do the regular list function (for int, slice types, etc.)
return super().__getitem__(idx) |
Converts to int or float:
'', '-', None convert to parameter default
Anything else uses int() or float() constructor
def convert_int(value, parameter):
'''
Converts to int or float:
'', '-', None convert to parameter default
Anything else uses int() or float() constructor
'''
value = _check_default(value, parameter, ( '', '-', None ))
if value is None or isinstance(value, int):
return value
try:
return int(value)
except Exception as e:
raise ValueError(str(e)) |
Converts to int or float:
'', '-', None convert to parameter default
Anything else uses int() or float() constructor
def convert_float(value, parameter):
'''
Converts to int or float:
'', '-', None convert to parameter default
Anything else uses int() or float() constructor
'''
value = _check_default(value, parameter, ( '', '-', None ))
if value is None or isinstance(value, float):
return value
try:
return float(value)
except Exception as e:
raise ValueError(str(e)) |
Converts to decimal.Decimal:
'', '-', None convert to parameter default
Anything else uses Decimal constructor
def convert_decimal(value, parameter):
'''
Converts to decimal.Decimal:
'', '-', None convert to parameter default
Anything else uses Decimal constructor
'''
value = _check_default(value, parameter, ( '', '-', None ))
if value is None or isinstance(value, decimal.Decimal):
return value
try:
return decimal.Decimal(value)
except Exception as e:
raise ValueError(str(e)) |
Converts to boolean (only the first char of the value is used):
'', '-', None convert to parameter default
'f', 'F', '0', False always convert to False
Anything else converts to True.
def convert_boolean(value, parameter, default=False):
'''
Converts to boolean (only the first char of the value is used):
'', '-', None convert to parameter default
'f', 'F', '0', False always convert to False
Anything else converts to True.
'''
value = _check_default(value, parameter, ( '', '-', None ))
if isinstance(value, bool):
return value
if isinstance(value, str) and len(value) > 0:
value = value[0]
return value not in ( 'f', 'F', '0', False, None ) |
Converts to datetime.datetime:
'', '-', None convert to parameter default
The first matching format in settings.DATETIME_INPUT_FORMATS converts to datetime
def convert_datetime(value, parameter):
'''
Converts to datetime.datetime:
'', '-', None convert to parameter default
The first matching format in settings.DATETIME_INPUT_FORMATS converts to datetime
'''
value = _check_default(value, parameter, ( '', '-', None ))
if value is None or isinstance(value, datetime.datetime):
return value
for fmt in settings.DATETIME_INPUT_FORMATS:
try:
return datetime.datetime.strptime(value, fmt)
except (ValueError, TypeError):
continue
raise ValueError("`{}` does not match a format in settings.DATETIME_INPUT_FORMATS".format(value)) |
Converts to datetime.date:
'', '-', None convert to parameter default
The first matching format in settings.DATE_INPUT_FORMATS converts to datetime
def convert_date(value, parameter):
'''
Converts to datetime.date:
'', '-', None convert to parameter default
The first matching format in settings.DATE_INPUT_FORMATS converts to datetime
'''
value = _check_default(value, parameter, ( '', '-', None ))
if value is None or isinstance(value, datetime.date):
return value
for fmt in settings.DATE_INPUT_FORMATS:
try:
return datetime.datetime.strptime(value, fmt).date()
except (ValueError, TypeError):
continue
raise ValueError("`{}` does not match a format in settings.DATE_INPUT_FORMATS".format(value)) |
Converts to a Model object.
'', '-', '0', None convert to parameter default
Anything else is assumed an object id and sent to `.get(id=value)`.
def convert_id_to_model(value, parameter):
'''
Converts to a Model object.
'', '-', '0', None convert to parameter default
Anything else is assumed an object id and sent to `.get(id=value)`.
'''
value = _check_default(value, parameter, ( '', '-', '0', None ))
if isinstance(value, (int, str)): # only convert if we have the id
try:
return parameter.type.objects.get(id=value)
except (MultipleObjectsReturned, ObjectDoesNotExist) as e:
raise ValueError(str(e))
return value |
Returns the default if the value is "empty"
def _check_default(value, parameter, default_chars):
'''Returns the default if the value is "empty"'''
# not using a set here because it fails when value is unhashable
if value in default_chars:
if parameter.default is inspect.Parameter.empty:
raise ValueError('Value was empty, but no default value is given in view function for parameter: {} ({})'.format(parameter.position, parameter.name))
return parameter.default
return value |
Decorator that denotes a function as a url parameter converter.
def parameter_converter(*convert_types):
'''
Decorator that denotes a function as a url parameter converter.
'''
def inner(func):
for ct in convert_types:
ParameterConverter._register_converter(func, ct)
return func
return inner |
Run all the stages in protocol
Parameters
----------
handler : SystemHandler
Container of initial conditions of simulation
cfg : dict
Imported YAML file.
def protocol(handler, cfg):
"""
Run all the stages in protocol
Parameters
----------
handler : SystemHandler
Container of initial conditions of simulation
cfg : dict
Imported YAML file.
"""
# Stages
if 'stages' not in cfg:
raise ValueError('Protocol must include stages of simulation')
pos, vel, box = handler.positions, handler.velocities, handler.box
stages = cfg.pop('stages')
for stage_options in stages:
options = DEFAULT_OPTIONS.copy()
options.update(cfg)
stage_system_options = prepare_system_options(stage_options)
options.update(stage_options)
options['system_options'].update(stage_system_options)
stage = Stage(handler, positions=pos, velocities=vel, box=box,
total_stages=len(stages), **options)
pos, vel, box = stage.run()
del stage |
Launch MD simulation, which may consist of:
1. Optional minimization
2. Actual MD simulation, with n steps.
This method also handles reporters.
Returns
-------
positions, velocities : unit.Quantity([natoms, 3])
Position, velocity of each atom in the system
box : unit.Quantity([1, 3])
Periodic conditions box vectors
def run(self):
"""
Launch MD simulation, which may consist of:
1. Optional minimization
2. Actual MD simulation, with n steps.
This method also handles reporters.
Returns
-------
positions, velocities : unit.Quantity([natoms, 3])
Position, velocity of each atom in the system
box : unit.Quantity([1, 3])
Periodic conditions box vectors
"""
if self.verbose:
status = '#{}'.format(self.stage_index)
if self.total_stages is not None:
status += '/{}'.format(self.total_stages)
status += ': {}'.format(self.name)
pieces = []
if self.restrained_atoms is not None:
pieces.append('restrained {}'.format(self.restrained_atoms))
if self.constrained_atoms is not None:
pieces.append('constrained {}'.format(self.constrained_atoms))
if self.distance_restrained_atoms is not None:
pieces.append('distance restrained for {} atom pairs'.format(len(self.distance_restrained_atoms)))
if pieces:
status += ' [{}]'.format(', '.join(pieces))
logger.info(status)
# Add forces
self.apply_restraints()
self.apply_constraints()
if self.barostat:
self.apply_barostat()
if self.minimization:
if self.verbose:
logger.info(' Minimizing...')
self.minimize()
uses_pbc = self.system.usesPeriodicBoundaryConditions()
if self.steps:
# Stdout progress
if self.report and self.progress_reporter not in self.simulation.reporters:
self.simulation.reporters.append(self.progress_reporter)
# Log report
if self.report and self.log_reporter not in self.simulation.reporters:
self.simulation.reporters.append(self.log_reporter)
# Trajectory / movie files
if self.trajectory and self.trajectory_reporter not in self.simulation.reporters:
self.simulation.reporters.append(self.trajectory_reporter)
# Checkpoint or restart files
if self.restart and self.restart_reporter not in self.simulation.reporters:
self.simulation.reporters.append(self.restart_reporter)
# MD simulation
if self.verbose:
pbc = 'PBC ' if uses_pbc else ''
conditions = 'NPT' if self.barostat else 'NVT'
logger.info(' Running {}MD for {} steps @ {}K, {}'.format(pbc, self.steps,
self.temperature,
conditions))
with self.handle_exceptions():
self.simulate()
if self.save_state_at_end:
path = self.new_filename(suffix='.state')
self.simulation.saveState(path)
# Save and return state
state = self.simulation.context.getState(getPositions=True, getVelocities=True,
enforcePeriodicBox=uses_pbc)
return state.getPositions(), state.getVelocities(), state.getPeriodicBoxVectors() |
Minimize energy of the system until meeting `tolerance` or
performing `max_iterations`.
def minimize(self, tolerance=None, max_iterations=None):
"""
Minimize energy of the system until meeting `tolerance` or
performing `max_iterations`.
"""
if tolerance is None:
tolerance = self.minimization_tolerance
if max_iterations is None:
max_iterations = self.minimization_max_iterations
self.simulation.minimizeEnergy(tolerance * u.kilojoules_per_mole, max_iterations) |
Advance simulation n steps
def simulate(self, steps=None):
"""
Advance simulation n steps
"""
if steps is None:
steps = self.steps
self.simulation.step(steps) |
Force that restrains atoms to fix their positions, while allowing
tiny movement to resolve severe clashes and so on.
Returns
-------
force : simtk.openmm.CustomExternalForce
A custom force to restrain the selected atoms
def restraint_force(self, indices=None, strength=5.0):
"""
Force that restrains atoms to fix their positions, while allowing
tiny movement to resolve severe clashes and so on.
Returns
-------
force : simtk.openmm.CustomExternalForce
A custom force to restrain the selected atoms
"""
if self.system.usesPeriodicBoundaryConditions():
expression = 'k*periodicdistance(x, y, z, x0, y0, z0)^2'
else:
expression = 'k*((x-x0)^2 + (y-y0)^2 + (z-z0)^2)'
force = mm.CustomExternalForce(expression)
force.addGlobalParameter('k', strength*u.kilocalories_per_mole/u.angstroms**2)
force.addPerParticleParameter('x0')
force.addPerParticleParameter('y0')
force.addPerParticleParameter('z0')
positions = self.positions if self.positions is not None else self.handler.positions
if indices is None:
indices = range(self.handler.topology.getNumAtoms())
for i, index in enumerate(indices):
force.addParticle(i, positions[index].value_in_unit(u.nanometers))
return force |
Parameters
----------
atoms : tuple of tuple of int or str
Pair of atom indices to be restrained, with shape (n, 2),
like ((a1, a2), (a3, a4)). Items can be str compatible with MDTraj DSL.
distances : tuple of float
Equilibrium distances for each pair
strengths : tuple of float
Force constant for each pair
def distance_restraint_force(self, atoms, distances, strengths):
"""
Parameters
----------
atoms : tuple of tuple of int or str
Pair of atom indices to be restrained, with shape (n, 2),
like ((a1, a2), (a3, a4)). Items can be str compatible with MDTraj DSL.
distances : tuple of float
Equilibrium distances for each pair
strengths : tuple of float
Force constant for each pair
"""
system = self.system
force = mm.HarmonicBondForce()
force.setUsesPeriodicBoundaryConditions(self.system.usesPeriodicBoundaryConditions())
for pair, distance, strength in zip(atoms, distances, strengths):
indices = []
for atom in pair:
if isinstance(atom, str):
index = self.subset(atom)
if len(index) != 1:
raise ValueError('Distance restraint for selection `{}` returns != 1 atom!: {}'
.format(atom, index))
indices.append(int(index[0]))
elif isinstance(atom, (int, float)):
indices.append(int(atom))
else:
raise ValueError('Distance restraint atoms must be int or str DSL selections')
if distance == 'current':
pos = self.positions or system.positions
distance = np.linalg.norm(pos[indices[0]] - pos[indices[1]])
force.addBond(indices[0], indices[1], distance*u.nanometers,
strength*u.kilocalories_per_mole/u.angstroms**2)
return force |
Returns a list of atom indices corresponding to a MDTraj DSL
query. Also will accept list of numbers, which will be coerced
to int and returned.
def subset(self, selector):
"""
Returns a list of atom indices corresponding to a MDTraj DSL
query. Also will accept list of numbers, which will be coerced
to int and returned.
"""
if isinstance(selector, (list, tuple)):
return map(int, selector)
selector = SELECTORS.get(selector, selector)
mdtop = MDTrajTopology.from_openmm(self.handler.topology)
return mdtop.select(selector) |
Handle Ctrl+C and accidental exceptions and attempt to save
the current state of the simulation
def handle_exceptions(self, verbose=True):
"""
Handle Ctrl+C and accidental exceptions and attempt to save
the current state of the simulation
"""
try:
yield
except (KeyboardInterrupt, Exception) as ex:
if not self.attempt_rescue:
raise ex
if isinstance(ex, KeyboardInterrupt):
reraise = False
answer = timed_input('\n\nDo you want to save current state? (y/N): ')
if answer and answer.lower() not in ('y', 'yes'):
if verbose:
sys.exit('Ok, bye!')
else:
reraise = True
logger.error('\n\nAn error occurred: %s', ex)
if verbose:
logger.info('Saving state...')
try:
self.backup_simulation()
except Exception:
if verbose:
logger.error('FAILED :(')
else:
if verbose:
logger.info('SUCCESS!')
finally:
if reraise:
raise ex
sys.exit() |
Creates an emergency report run, .state included
def backup_simulation(self):
"""
Creates an emergency report run, .state included
"""
path = self.new_filename(suffix='_emergency.state')
self.simulation.saveState(path)
uses_pbc = self.system.usesPeriodicBoundaryConditions()
state_kw = dict(getPositions=True, getVelocities=True,
getForces=True, enforcePeriodicBox=uses_pbc,
getParameters=True, getEnergy=True)
state = self.simulation.context.getState(**state_kw)
for reporter in self.simulation.reporters:
if not isinstance(reporter, app.StateDataReporter):
reporter.report(self.simulation, state) |
Get, parse and prepare input file.
def prepare_input(argv=None):
"""
Get, parse and prepare input file.
"""
p = ArgumentParser(description='InsiliChem Ommprotocol: '
'easy to deploy MD protocols for OpenMM')
p.add_argument('input', metavar='INPUT FILE', type=extant_file,
help='YAML input file')
p.add_argument('--version', action='version', version='%(prog)s v{}'.format(__version__))
p.add_argument('-c', '--check', action='store_true',
help='Validate input file only')
args = p.parse_args(argv if argv else sys.argv[1:])
jinja_env = jinja2.Environment(trim_blocks=True, lstrip_blocks=True)
# Load config file
with open(args.input) as f:
rendered = jinja_env.from_string(f.read()).render()
cfg = yaml.load(rendered, Loader=YamlLoader)
# Paths and dirs
from .md import SYSTEM_OPTIONS
cfg['_path'] = os.path.abspath(args.input)
cfg['system_options'] = prepare_system_options(cfg, defaults=SYSTEM_OPTIONS)
cfg['outputpath'] = sanitize_path_for_file(cfg.get('outputpath', '.'), args.input)
if not args.check:
with ignored_exceptions(OSError):
os.makedirs(cfg['outputpath'])
handler = prepare_handler(cfg)
return handler, cfg, args |
Load all files into single object.
def prepare_handler(cfg):
"""
Load all files into single object.
"""
positions, velocities, box = None, None, None
_path = cfg.get('_path', './')
forcefield = cfg.pop('forcefield', None)
topology_args = sanitize_args_for_file(cfg.pop('topology'), _path)
if 'checkpoint' in cfg:
restart_args = sanitize_args_for_file(cfg.pop('checkpoint'), _path)
restart = Restart.load(*restart_args)
positions = restart.positions
velocities = restart.velocities
box = restart.box
if 'positions' in cfg:
positions_args = sanitize_args_for_file(cfg.pop('positions'), _path)
positions = Positions.load(*positions_args)
box = BoxVectors.load(*positions_args)
if 'velocities' in cfg:
velocities_args = sanitize_args_for_file(cfg.pop('velocities'), _path)
velocities = Velocities.load(*velocities_args)
if 'box' in cfg:
box_args = sanitize_args_for_file(cfg.pop('box'), _path)
box = BoxVectors.load(*box_args)
options = {}
for key in 'positions velocities box forcefield'.split():
value = locals()[key]
if value is not None:
options[key] = value
return SystemHandler.load(*topology_args, **options) |
Retrieve and delete (pop) system options from input configuration.
def prepare_system_options(cfg, defaults=None):
"""
Retrieve and delete (pop) system options from input configuration.
"""
d = {} if defaults is None else defaults.copy()
if 'nonbondedMethod' in cfg:
d['nonbondedMethod'] = warned_getattr(openmm_app, cfg.pop('nonbondedMethod'), None)
if 'nonbondedCutoff' in cfg:
d['nonbondedCutoff'] = cfg.pop('nonbondedCutoff') * u.nanometers
if 'constraints' in cfg:
d['constraints'] = warned_getattr(openmm_app, cfg.pop('constraints'), None)
for key in ['rigidWater', 'ewaldErrorTolerance']:
if key in cfg:
d[key] = cfg.pop(key)
if 'extra_system_options' in cfg:
if 'implicitSolvent' in cfg['extra_system_options']:
implicit_solvent = warned_getattr(
openmm_app, cfg['extra_system_options']['implicitSolvent'], None)
cfg['extra_system_options']['implicitSolvent'] = implicit_solvent
d.update(cfg.pop('extra_system_options'))
return d |
Given a list of filenames, check which ones are `frcmods`. If so,
convert them to ffxml. Else, just return them.
def process_forcefield(*forcefields):
"""
Given a list of filenames, check which ones are `frcmods`. If so,
convert them to ffxml. Else, just return them.
"""
for forcefield in forcefields:
if forcefield.endswith('.frcmod'):
gaffmol2 = os.path.splitext(forcefield)[0] + '.gaff.mol2'
yield create_ffxml_file([gaffmol2], [forcefield])
else:
yield forcefield |
Given an OpenMM xml file containing the state of the simulation,
generate a PDB snapshot for easy visualization.
def statexml2pdb(topology, state, output=None):
"""
Given an OpenMM xml file containing the state of the simulation,
generate a PDB snapshot for easy visualization.
"""
state = Restart.from_xml(state)
system = SystemHandler.load(topology, positions=state.positions)
if output is None:
output = topology + '.pdb'
system.write_pdb(output) |
Extract a single frame structure from a trajectory.
def export_frame_coordinates(topology, trajectory, nframe, output=None):
"""
Extract a single frame structure from a trajectory.
"""
if output is None:
basename, ext = os.path.splitext(trajectory)
output = '{}.frame{}.inpcrd'.format(basename, nframe)
# ParmEd sometimes struggles with certain PRMTOP files
if os.path.splitext(topology)[1] in ('.top', '.prmtop'):
top = AmberPrmtopFile(topology)
mdtop = mdtraj.Topology.from_openmm(top.topology)
traj = mdtraj.load_frame(trajectory, int(nframe), top=mdtop)
structure = parmed.openmm.load_topology(top.topology, system=top.createSystem())
structure.box_vectors = top.topology.getPeriodicBoxVectors()
else: # standard protocol (the topology is loaded twice, though)
traj = mdtraj.load_frame(trajectory, int(nframe), top=topology)
structure = parmed.load_file(topology)
structure.positions = traj.openmm_positions(0)
if traj.unitcell_vectors is not None: # if frame provides box vectors, use those
structure.box_vectors = traj.openmm_boxes(0)
structure.save(output, overwrite=True) |
Include file referenced at node.
def construct_include(self, node):
"""Include file referenced at node."""
filename = os.path.join(self._root, self.construct_scalar(node))
filename = os.path.abspath(filename)
extension = os.path.splitext(filename)[1].lstrip('.')
with open(filename, 'r') as f:
if extension in ('yaml', 'yml'):
return yaml.load(f, Loader=self)
else:
return ''.join(f.readlines()) |
Loads topology, positions and, potentially, velocities and vectors,
from a PDB or PDBx file
Parameters
----------
path : str
Path to PDB/PDBx file
forcefields : list of str
Paths to FFXML and/or FRCMOD forcefields. REQUIRED.
Returns
-------
pdb : SystemHandler
SystemHandler with topology, positions, and, potentially, velocities and
box vectors. Forcefields are embedded in the `master` attribute.
def from_pdb(cls, path, forcefield=None, loader=PDBFile, strict=True, **kwargs):
"""
Loads topology, positions and, potentially, velocities and vectors,
from a PDB or PDBx file
Parameters
----------
path : str
Path to PDB/PDBx file
forcefields : list of str
Paths to FFXML and/or FRCMOD forcefields. REQUIRED.
Returns
-------
pdb : SystemHandler
SystemHandler with topology, positions, and, potentially, velocities and
box vectors. Forcefields are embedded in the `master` attribute.
"""
pdb = loader(path)
box = kwargs.pop('box', pdb.topology.getPeriodicBoxVectors())
positions = kwargs.pop('positions', pdb.positions)
velocities = kwargs.pop('velocities', getattr(pdb, 'velocities', None))
if strict and not forcefield:
from .md import FORCEFIELDS as forcefield
logger.info('! Forcefields for PDB not specified. Using default: %s',
', '.join(forcefield))
pdb.forcefield = ForceField(*list(process_forcefield(*forcefield)))
return cls(master=pdb.forcefield, topology=pdb.topology, positions=positions,
velocities=velocities, box=box, path=path, **kwargs) |
Loads Amber Parm7 parameters and topology file
Parameters
----------
path : str
Path to *.prmtop or *.top file
positions : simtk.unit.Quantity
Atomic positions
Returns
-------
prmtop : SystemHandler
SystemHandler with topology
def from_amber(cls, path, positions=None, strict=True, **kwargs):
"""
Loads Amber Parm7 parameters and topology file
Parameters
----------
path : str
Path to *.prmtop or *.top file
positions : simtk.unit.Quantity
Atomic positions
Returns
-------
prmtop : SystemHandler
SystemHandler with topology
"""
if strict and positions is None:
raise ValueError('Amber TOP/PRMTOP files require initial positions.')
prmtop = AmberPrmtopFile(path)
box = kwargs.pop('box', prmtop.topology.getPeriodicBoxVectors())
return cls(master=prmtop, topology=prmtop.topology, positions=positions, box=box,
path=path, **kwargs) |
Loads PSF Charmm structure from `path`. Requires `charmm_parameters`.
Parameters
----------
path : str
Path to PSF file
forcefield : list of str
Paths to Charmm parameters files, such as *.par or *.str. REQUIRED
Returns
-------
psf : SystemHandler
SystemHandler with topology. Charmm parameters are embedded in
the `master` attribute.
def from_charmm(cls, path, positions=None, forcefield=None, strict=True, **kwargs):
"""
Loads PSF Charmm structure from `path`. Requires `charmm_parameters`.
Parameters
----------
path : str
Path to PSF file
forcefield : list of str
Paths to Charmm parameters files, such as *.par or *.str. REQUIRED
Returns
-------
psf : SystemHandler
SystemHandler with topology. Charmm parameters are embedded in
the `master` attribute.
"""
psf = CharmmPsfFile(path)
if strict and forcefield is None:
raise ValueError('PSF files require key `forcefield`.')
if strict and positions is None:
raise ValueError('PSF files require key `positions`.')
psf.parmset = CharmmParameterSet(*forcefield)
psf.loadParameters(psf.parmset)
return cls(master=psf, topology=psf.topology, positions=positions, path=path,
**kwargs) |
Loads a topology from a Desmond DMS file located at `path`.
Arguments
---------
path : str
Path to a Desmond DMS file
def from_desmond(cls, path, **kwargs):
"""
Loads a topology from a Desmond DMS file located at `path`.
Arguments
---------
path : str
Path to a Desmond DMS file
"""
dms = DesmondDMSFile(path)
pos = kwargs.pop('positions', dms.getPositions())
return cls(master=dms, topology=dms.getTopology(), positions=pos, path=path,
**kwargs) |
Loads a topology from a Gromacs TOP file located at `path`.
Additional root directory for parameters can be specified with `forcefield`.
Arguments
---------
path : str
Path to a Gromacs TOP file
positions : simtk.unit.Quantity
Atomic positions
forcefield : str, optional
Root directory for parameter files
def from_gromacs(cls, path, positions=None, forcefield=None, strict=True, **kwargs):
"""
Loads a topology from a Gromacs TOP file located at `path`.
Additional root directory for parameters can be specified with `forcefield`.
Arguments
---------
path : str
Path to a Gromacs TOP file
positions : simtk.unit.Quantity
Atomic positions
forcefield : str, optional
Root directory for parameter files
"""
if strict and positions is None:
raise ValueError('Gromacs TOP files require initial positions.')
box = kwargs.pop('box', None)
top = GromacsTopFile(path, includeDir=forcefield, periodicBoxVectors=box)
return cls(master=top, topology=top.topology, positions=positions, box=box,
path=path, **kwargs) |
Try to load a file automatically with ParmEd. Not guaranteed to work, but
might be useful if it succeeds.
Arguments
---------
path : str
Path to file that ParmEd can load
def from_parmed(cls, path, *args, **kwargs):
"""
Try to load a file automatically with ParmEd. Not guaranteed to work, but
might be useful if it succeeds.
Arguments
---------
path : str
Path to file that ParmEd can load
"""
st = parmed.load_file(path, structure=True, *args, **kwargs)
box = kwargs.pop('box', getattr(st, 'box', None))
velocities = kwargs.pop('velocities', getattr(st, 'velocities', None))
positions = kwargs.pop('positions', getattr(st, 'positions', None))
return cls(master=st, topology=st.topology, positions=positions, box=box,
velocities=velocities, path=path, **kwargs) |
Loads pickled topology. Careful with Python versions though!
def _pickle_load(path):
"""
Loads pickled topology. Careful with Python versions though!
"""
_, ext = os.path.splitext(path)
topology = None
if sys.version_info.major == 2:
if ext == '.pickle2':
with open(path, 'rb') as f:
topology = pickle.load(f)
elif ext in ('.pickle3', '.pickle'):
with open(path, 'rb') as f:
topology = pickle.load(f, protocol=3)
elif sys.version_info.major == 3:
if ext == '.pickle2':
with open(path, 'rb') as f:
topology = pickle.load(f)
elif ext in ('.pickle3', '.pickle'):
with open(path, 'rb') as f:
topology = pickle.load(f)
if topology is None:
raise ValueError('File {} is not compatible with this version'.format(path))
return topology |
Create an OpenMM system for every supported topology file with given system options
def create_system(self, **system_options):
"""
Create an OpenMM system for every supported topology file with given system options
"""
if self.master is None:
raise ValueError('Handler {} is not able to create systems.'.format(self))
if isinstance(self.master, ForceField):
system = self.master.createSystem(self.topology, **system_options)
elif isinstance(self.master, (AmberPrmtopFile, GromacsTopFile, DesmondDMSFile)):
system = self.master.createSystem(**system_options)
elif isinstance(self.master, CharmmPsfFile):
if not hasattr(self.master, 'parmset'):
raise ValueError('PSF topology files require Charmm parameters.')
system = self.master.createSystem(self.master.parmset, **system_options)
else:
raise NotImplementedError('Handler {} is not able to create systems.'.format(self))
if self.has_box:
system.setDefaultPeriodicBoxVectors(*self.box)
return system |
Outputs a PDB file with the current contents of the system
def write_pdb(self, path):
"""
Outputs a PDB file with the current contents of the system
"""
if self.master is None and self.positions is None:
raise ValueError('Topology and positions are needed to write output files.')
with open(path, 'w') as f:
PDBFile.writeFile(self.topology, self.positions, f) |
Returns u.Quantity with box vectors from XSC file
def from_xsc(cls, path):
""" Returns u.Quantity with box vectors from XSC file """
def parse(path):
"""
Open and parses an XSC file into its fields
Parameters
----------
path : str
Path to XSC file
Returns
-------
namedxsc : namedtuple
A namedtuple with XSC fields as names
"""
with open(path) as f:
lines = f.readlines()
NamedXsc = namedtuple('NamedXsc', lines[1].split()[1:])
return NamedXsc(*map(float, lines[2].split()))
xsc = parse(path)
return u.Quantity([[xsc.a_x, xsc.a_y, xsc.a_z],
[xsc.b_x, xsc.b_y, xsc.b_z],
[xsc.c_x, xsc.c_y, xsc.c_z]], unit=u.angstroms) |
Get box vectors from comma-separated values in file `path`.
The csv file must containt only one line, which in turn can contain
three values (orthogonal vectors) or nine values (triclinic box).
The values should be in nanometers.
Parameters
----------
path : str
Path to CSV file
Returns
-------
vectors : simtk.unit.Quantity([3, 3], unit=nanometers
def from_csv(cls, path):
"""
Get box vectors from comma-separated values in file `path`.
The csv file must containt only one line, which in turn can contain
three values (orthogonal vectors) or nine values (triclinic box).
The values should be in nanometers.
Parameters
----------
path : str
Path to CSV file
Returns
-------
vectors : simtk.unit.Quantity([3, 3], unit=nanometers
"""
with open(path) as f:
fields = map(float, next(f).split(','))
if len(fields) == 3:
return u.Quantity([[fields[0], 0, 0],
[0, fields[1], 0],
[0, 0, fields[2]]], unit=u.nanometers)
elif len(fields) == 9:
return u.Quantity([fields[0:3],
fields[3:6],
fields[6:9]], unit=u.nanometers)
else:
raise ValueError('This type of CSV is not supported. Please '
'provide a comma-separated list of three or nine '
'floats in a single-line file.') |
Get information about the next report this object will generate.
Parameters
----------
simulation : Simulation
The Simulation to generate a report for
Returns
-------
tuple
A five element tuple. The first element is the number of steps
until the next report. The remaining elements specify whether
that report will require positions, velocities, forces, and
energies respectively.
def describeNextReport(self, simulation):
"""Get information about the next report this object will generate.
Parameters
----------
simulation : Simulation
The Simulation to generate a report for
Returns
-------
tuple
A five element tuple. The first element is the number of steps
until the next report. The remaining elements specify whether
that report will require positions, velocities, forces, and
energies respectively.
"""
steps = self.interval - simulation.currentStep % self.interval
return steps, False, False, False, False |
Generate a report.
Parameters
----------
simulation : Simulation
The Simulation to generate a report for
state : State
The current state of the simulation
def report(self, simulation, state):
"""Generate a report.
Parameters
----------
simulation : Simulation
The Simulation to generate a report for
state : State
The current state of the simulation
"""
if not self._initialized:
self._initial_clock_time = datetime.now()
self._initial_simulation_time = state.getTime()
self._initial_steps = simulation.currentStep
self._initialized = True
steps = simulation.currentStep
time = datetime.now() - self._initial_clock_time
days = time.total_seconds()/86400.0
ns = (state.getTime()-self._initial_simulation_time).value_in_unit(u.nanosecond)
margin = ' ' * self.margin
ns_day = ns/days
delta = ((self.total_steps-steps)*time.total_seconds())/steps
# remove microseconds to have cleaner output
remaining = timedelta(seconds=int(delta))
percentage = 100.0*steps/self.total_steps
if ns_day:
template = '{}{}/{} steps ({:.1f}%) - {} left @ {:.1f} ns/day \r'
else:
template = '{}{}/{} steps ({:.1f}%) \r'
report = template.format(margin, steps, self.total_steps, percentage, remaining, ns_day)
self._out.write(report)
if hasattr(self._out, 'flush'):
self._out.flush() |
Generate a report.
Parameters
----------
simulation : Simulation
The Simulation to generate a report for
state : State
The current state of the simulation
def report(self, simulation, state):
"""Generate a report.
Parameters
----------
simulation : Simulation
The Simulation to generate a report for
state : State
The current state of the simulation
"""
if not self._initialized:
self._initialized = True
self._steps[0] += self.interval
positions = state.getPositions()
# Serialize
self._out.write(b''.join([b'\nSTARTOFCHUNK\n',
pickle.dumps([self._steps[0], positions._value]),
b'\nENDOFCHUNK\n']))
if hasattr(self._out, 'flush'):
self._out.flush() |
If path exists, modify to add a counter in the filename. Useful
for preventing accidental overrides. For example, if `file.txt`
exists, check if `file.1.txt` also exists. Repeat until we find
a non-existing version, such as `file.12.txt`.
Parameters
----------
path : str
Path to be checked
Returns
-------
newpath : str
A modified version of path with a counter right before the extension.
def assert_not_exists(path, sep='.'):
"""
If path exists, modify to add a counter in the filename. Useful
for preventing accidental overrides. For example, if `file.txt`
exists, check if `file.1.txt` also exists. Repeat until we find
a non-existing version, such as `file.12.txt`.
Parameters
----------
path : str
Path to be checked
Returns
-------
newpath : str
A modified version of path with a counter right before the extension.
"""
name, ext = os.path.splitext(path)
i = 1
while os.path.exists(path):
path = '{}{}{}{}'.format(name, sep, i, ext)
i += 1
return path |
Make sure object `obj` is of type `types`. Else, raise TypeError.
def assertinstance(obj, types):
"""
Make sure object `obj` is of type `types`. Else, raise TypeError.
"""
if isinstance(obj, types):
return obj
raise TypeError('{} must be instance of {}'.format(obj, types)) |
Check if file exists with argparse
def extant_file(path):
"""
Check if file exists with argparse
"""
if not os.path.exists(path):
raise argparse.ArgumentTypeError("{} does not exist".format(path))
return path |
Sort files taking into account potentially absent suffixes like
somefile.dcd
somefile.1000.dcd
somefile.2000.dcd
To be used with sorted(..., key=callable).
def sort_key_for_numeric_suffixes(path, sep='.', suffix_index=-2):
"""
Sort files taking into account potentially absent suffixes like
somefile.dcd
somefile.1000.dcd
somefile.2000.dcd
To be used with sorted(..., key=callable).
"""
chunks = path.split(sep)
# Remove suffix from path and convert to int
if chunks[suffix_index].isdigit():
return sep.join(chunks[:suffix_index] + chunks[suffix_index+1:]), int(chunks[suffix_index])
return path, 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.