Home
Diffusion Pillar (dillo) Browse

pillar/pillar/extension.py
f8ff30fb4de6dillo

Last Change
Raw File

extension.py
View Options

"""Pillar extensions support.
Each Pillar extension should create a subclass of PillarExtension, which
can then be registered to the application at app creation time:
from pillar_server import PillarServer
from attract_server import AttractExtension
app = PillarServer('.')
app.load_extension(AttractExtension(), url_prefix='/attract')
app.process_extensions() # Always process extensions after the last one is loaded.
if __name__ == '__main__':
app.run('::0', 5000)
"""
import abc
import inspect
import pathlib
import typing
import flask
import pillarsdk
class PillarExtension(object, metaclass=abc.ABCMeta):
# Set to True when your extension implements the project_settings() method.
has_project_settings = False
# Set to True when your extension implements the context_processor() method.
has_context_processor = False
# List of Celery task modules introduced by this extension.
celery_task_modules: typing.List[str] = []
# Set of user roles used/introduced by this extension.
user_roles: typing.Set[str] = set()
user_roles_indexable: typing.Set[str] = set()
# User capabilities introduced by this extension. The final set of
# capabilities is the union of all app-level and extension-level caps.
user_caps: typing.Mapping[str, typing.FrozenSet] = {}
@property
@abc.abstractmethod
def name(self):
"""The name of this extension.
The name determines the path at which Eve exposes the extension's
resources (/{extension name}/{resource name}), as well as the
MongoDB collection in which those resources are stored
({extensions name}.{resource name}).
:rtype: unicode
"""
@property
def icon(self) -> str:
"""Returns the icon HTML class, for use like i.pi-{{ext.icon}}
Defaults to the extension name.
"""
return self.name
@abc.abstractmethod
def flask_config(self):
"""Returns extension-specific defaults for the Flask configuration.
Use this to set sensible default values for configuration settings
introduced by the extension.
:rtype: dict
"""
@abc.abstractmethod
def blueprints(self):
"""Returns the list of top-level blueprints for the extension.
These blueprints will be mounted at the url prefix given to
app.load_extension().
:rtype: list of flask.Blueprint objects.
"""
@abc.abstractmethod
def eve_settings(self):
"""Returns extensions to the Eve settings.
Currently only the DOMAIN key is used to insert new resources into
Eve's configuration.
:rtype: dict
"""
@property
def template_path(self):
"""Returns the path where templates for this extension are stored.
Note that this path is not connected to any blueprint, so it is up to
the extension to provide extension-unique subdirectories.
"""
return None
@property
def static_path(self):
"""Returns the path where static files are stored.
Registers an endpoint named 'static_<extension name>', to use like:
`url_for('static_attract', filename='js/somefile.js')`
May return None, in which case the extension will not be able to serve
static files.
"""
return None
@property
def translations_path(self) -> typing.Union[pathlib.Path, None]:
"""Returns the path where the translations for this extension are stored.
This is top folder that contains a "translations" sub-folder
May return None, in which case English will always be used for this extension.
"""
class_filename = pathlib.Path(inspect.getfile(self.__class__))
# Pillar extensions instantiate the PillarExtension from a sub-folder in
# the main project (e.g. //blender_cloud/blender_cloud/__init__.py), but
# the translations folders is in the main project folder.
translations_path = class_filename.parents[1] / 'translations'
return translations_path if translations_path.is_dir() else None
def setup_app(self, app):
"""Called during app startup, after all extensions have loaded."""
def sidebar_links(self, project: pillarsdk.Project) -> str:
"""Returns the sidebar link(s) for the given projects.
:returns: HTML as a string for the sidebar.
"""
return ''
def project_settings(self, project: pillarsdk.Project, **template_args: dict) -> flask.Response:
"""Renders the project settings page for this extension.
Set YourExtension.has_project_settings = True and Pillar will call this function.
:param project: the project for which to render the settings.
:param template_args: additional template arguments.
:returns: a Flask HTTP response
"""
def context_processor(self) -> dict:
"""Returns a dictionary that gets injected into the Flask Jinja2 namespace.
Set has_context_processor to True when your extension implements this method.
"""
return {}