/usr/lib/python3/dist-packages/cement/core/extension.py is in python3-cement 2.10.0-1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 | """Cement core extensions module."""
import sys
from ..core import exc, interface, handler
from ..utils.misc import minimal_logger
LOG = minimal_logger(__name__)
def extension_validator(klass, obj):
"""
Validates an handler implementation against the IExtension interface.
"""
members = [
'_setup',
'load_extension',
'load_extensions',
'get_loaded_extensions',
]
interface.validate(IExtension, obj, members)
class IExtension(interface.Interface):
"""
This class defines the Extension Handler Interface. Classes that
implement this handler must provide the methods and attributes defined
below.
Implementations do *not* subclass from interfaces.
Usage:
.. code-block:: python
from cement.core import extension
class MyExtensionHandler(object):
class Meta:
interface = extension.IExtension
label = 'my_extension_handler'
...
"""
# pylint: disable=W0232, C0111, R0903
class IMeta:
"""Interface meta-data."""
label = 'extension'
"""The string identifier of the interface."""
validator = extension_validator
"""The interface validator function."""
# Must be provided by the implementation
Meta = interface.Attribute('Handler Meta-data class')
def _setup(app_obj):
"""
The _setup function is called during application initialization and
must 'setup' the handler object making it ready for the framework
or the application to make further calls to it.
:param app_obj: The application object.
:returns: None
"""
def load_extension(self, ext_module):
"""
Load an extension whose module is 'ext_module'. For example,
'cement.ext.ext_configobj'.
:param ext_module: The name of the extension to load.
:type ext_module: ``str``
"""
def load_extensions(self, ext_list):
"""
Load all extensions from ext_list.
:param ext_list: A list of extension modules to load. For example:
``['cement.ext.ext_configobj', 'cement.ext.ext_logging']``
:type ext_list: ``list``
"""
class CementExtensionHandler(handler.CementBaseHandler):
class Meta:
"""
Handler meta-data (can be passed as keyword arguments to the parent
class).
"""
interface = IExtension
"""The interface that this class implements."""
label = 'cement'
"""The string identifier of the handler."""
def __init__(self, **kw):
"""
This is an implementation of the IExtentionHandler interface. It
handles loading framework extensions.
"""
super(CementExtensionHandler, self).__init__(**kw)
self.app = None
self._loaded_extensions = []
def get_loaded_extensions(self):
"""Returns list of loaded extensions."""
return self._loaded_extensions
def load_extension(self, ext_module):
"""
Given an extension module name, load or in other-words 'import' the
extension.
:param ext_module: The extension module name. For example:
'cement.ext.ext_logging'.
:type ext_module: ``str``
:raises: cement.core.exc.FrameworkError
"""
# If its not a full module path then preppend our default path
if ext_module.find('.') == -1:
ext_module = 'cement.ext.ext_%s' % ext_module
if ext_module in self._loaded_extensions:
LOG.debug("framework extension '%s' already loaded" % ext_module)
return
LOG.debug("loading the '%s' framework extension" % ext_module)
try:
if ext_module not in sys.modules:
__import__(ext_module, globals(), locals(), [], 0)
if hasattr(sys.modules[ext_module], 'load'):
sys.modules[ext_module].load(self.app)
if ext_module not in self._loaded_extensions:
self._loaded_extensions.append(ext_module)
except ImportError as e:
raise exc.FrameworkError(e.args[0])
def load_extensions(self, ext_list):
"""
Given a list of extension modules, iterate over the list and pass
individually to self.load_extension().
:param ext_list: A list of extension modules.
:type ext_list: ``list``
"""
for ext in ext_list:
self.load_extension(ext)
|