/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/plugin.py

  • Committer: John Arbash Meinel
  • Date: 2008-11-25 17:15:26 UTC
  • mto: This revision was merged to the branch mainline in revision 3851.
  • Revision ID: john@arbash-meinel.com-20081125171526-pi2g4m1w70pkie1f
Add a bit of help text when supplying --help.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2004, 2005, 2007, 2008 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
 
18
18
"""bzr python plugin support.
26
26
plugins.
27
27
 
28
28
BZR_PLUGIN_PATH is also honoured for any plugins imported via
29
 
'import bzrlib.plugins.PLUGINNAME', as long as set_plugins_path has been
 
29
'import bzrlib.plugins.PLUGINNAME', as long as set_plugins_path has been 
30
30
called.
31
31
"""
32
32
 
41
41
import imp
42
42
import re
43
43
import types
 
44
import zipfile
44
45
 
45
46
from bzrlib import (
46
47
    _format_version_tuple,
52
53
from bzrlib import plugins as _mod_plugins
53
54
""")
54
55
 
55
 
from bzrlib.symbol_versioning import (
56
 
    deprecated_function,
57
 
    deprecated_in,
58
 
    )
 
56
from bzrlib.symbol_versioning import deprecated_function, one_three
59
57
 
60
58
 
61
59
DEFAULT_PLUGIN_PATH = None
62
60
_loaded = False
63
 
_plugins_disabled = False
64
 
 
65
 
 
66
 
def are_plugins_disabled():
67
 
    return _plugins_disabled
 
61
 
 
62
def get_default_plugin_path():
 
63
    """Get the DEFAULT_PLUGIN_PATH"""
 
64
    global DEFAULT_PLUGIN_PATH
 
65
    if DEFAULT_PLUGIN_PATH is None:
 
66
        DEFAULT_PLUGIN_PATH = osutils.pathjoin(config.config_dir(), 'plugins')
 
67
    return DEFAULT_PLUGIN_PATH
68
68
 
69
69
 
70
70
def disable_plugins():
72
72
 
73
73
    Future calls to load_plugins() will be ignored.
74
74
    """
75
 
    global _plugins_disabled
76
 
    _plugins_disabled = True
77
 
    load_plugins([])
 
75
    # TODO: jam 20060131 This should probably also disable
 
76
    #       load_from_dirs()
 
77
    global _loaded
 
78
    _loaded = True
78
79
 
79
80
 
80
81
def _strip_trailing_sep(path):
81
82
    return path.rstrip("\\/")
82
83
 
83
84
 
84
 
def set_plugins_path(path=None):
85
 
    """Set the path for plugins to be loaded from.
86
 
 
87
 
    :param path: The list of paths to search for plugins.  By default,
88
 
        path will be determined using get_standard_plugins_path.
89
 
        if path is [], no plugins can be loaded.
90
 
    """
91
 
    if path is None:
92
 
        path = get_standard_plugins_path()
93
 
    _mod_plugins.__path__ = path
94
 
    PluginImporter.reset()
95
 
    # Set up a blacklist for disabled plugins
96
 
    disabled_plugins = os.environ.get('BZR_DISABLE_PLUGINS', None)
97
 
    if disabled_plugins is not None:
98
 
        for name in disabled_plugins.split(os.pathsep):
99
 
            PluginImporter.blacklist.add('bzrlib.plugins.' + name)
100
 
    # Set up a the specific paths for plugins
101
 
    specific_plugins = os.environ.get('BZR_PLUGINS_AT', None)
102
 
    if specific_plugins is not None:
103
 
        for spec in specific_plugins.split(os.pathsep):
104
 
            plugin_name, plugin_path = spec.split('@')
105
 
            PluginImporter.specific_paths[
106
 
                'bzrlib.plugins.%s' % plugin_name] = plugin_path
107
 
    return path
108
 
 
109
 
 
110
 
def _append_new_path(paths, new_path):
111
 
    """Append a new path if it set and not already known."""
112
 
    if new_path is not None and new_path not in paths:
113
 
        paths.append(new_path)
114
 
    return paths
115
 
 
116
 
 
117
 
def get_core_plugin_path():
118
 
    core_path = None
 
85
def set_plugins_path():
 
86
    """Set the path for plugins to be loaded from."""
 
87
    path = os.environ.get('BZR_PLUGIN_PATH',
 
88
                          get_default_plugin_path()).split(os.pathsep)
119
89
    bzr_exe = bool(getattr(sys, 'frozen', None))
120
90
    if bzr_exe:    # expand path for bzr.exe
121
91
        # We need to use relative path to system-wide plugin
128
98
        # then plugins directory is
129
99
        # C:\Program Files\Bazaar\plugins
130
100
        # so relative path is ../../../plugins
131
 
        core_path = osutils.abspath(osutils.pathjoin(
132
 
                osutils.dirname(__file__), '../../../plugins'))
133
 
    else:     # don't look inside library.zip
134
 
        # search the plugin path before the bzrlib installed dir
135
 
        core_path = os.path.dirname(_mod_plugins.__file__)
136
 
    return core_path
137
 
 
138
 
 
139
 
def get_site_plugin_path():
140
 
    """Returns the path for the site installed plugins."""
141
 
    if sys.platform == 'win32':
142
 
        # We don't have (yet) a good answer for windows since that is certainly
143
 
        # related to the way we build the installers. -- vila20090821
144
 
        return None
145
 
    site_path = None
146
 
    try:
147
 
        from distutils.sysconfig import get_python_lib
148
 
    except ImportError:
149
 
        # If distutuils is not available, we just don't know where they are
150
 
        pass
151
 
    else:
152
 
        site_path = osutils.pathjoin(get_python_lib(), 'bzrlib', 'plugins')
153
 
    return site_path
154
 
 
155
 
 
156
 
def get_user_plugin_path():
157
 
    return osutils.pathjoin(config.config_dir(), 'plugins')
158
 
 
159
 
 
160
 
def get_standard_plugins_path():
161
 
    """Determine a plugin path suitable for general use."""
162
 
    # Ad-Hoc default: core is not overriden by site but user can overrides both
163
 
    # The rationale is that:
164
 
    # - 'site' comes last, because these plugins should always be available and
165
 
    #   are supposed to be in sync with the bzr installed on site.
166
 
    # - 'core' comes before 'site' so that running bzr from sources or a user
167
 
    #   installed version overrides the site version.
168
 
    # - 'user' comes first, because... user is always right.
169
 
    # - the above rules clearly defines which plugin version will be loaded if
170
 
    #   several exist. Yet, it is sometimes desirable to disable some directory
171
 
    #   so that a set of plugins is disabled as once. This can be done via
172
 
    #   -site, -core, -user.
173
 
 
174
 
    env_paths = os.environ.get('BZR_PLUGIN_PATH', '+user').split(os.pathsep)
175
 
    defaults = ['+core', '+site']
176
 
 
177
 
    # The predefined references
178
 
    refs = dict(core=get_core_plugin_path(),
179
 
                site=get_site_plugin_path(),
180
 
                user=get_user_plugin_path())
181
 
 
182
 
    # Unset paths that should be removed
183
 
    for k,v in refs.iteritems():
184
 
        removed = '-%s' % k
185
 
        # defaults can never mention removing paths as that will make it
186
 
        # impossible for the user to revoke these removals.
187
 
        if removed in env_paths:
188
 
            env_paths.remove(removed)
189
 
            refs[k] = None
190
 
 
191
 
    # Expand references
192
 
    paths = []
193
 
    for p in env_paths + defaults:
194
 
        if p.startswith('+'):
195
 
            # Resolve references if they are known
196
 
            try:
197
 
                p = refs[p[1:]]
198
 
            except KeyError:
199
 
                # Leave them untouched so user can still use paths starting
200
 
                # with '+'
201
 
                pass
202
 
        _append_new_path(paths, p)
203
 
 
 
101
        path.append(osutils.abspath(osutils.pathjoin(
 
102
            osutils.dirname(__file__), '../../../plugins')))
204
103
    # Get rid of trailing slashes, since Python can't handle them when
205
104
    # it tries to import modules.
206
 
    paths = map(_strip_trailing_sep, paths)
207
 
    return paths
208
 
 
209
 
 
210
 
def load_plugins(path=None):
 
105
    path = map(_strip_trailing_sep, path)
 
106
    if not bzr_exe:     # don't look inside library.zip
 
107
        # search the plugin path before the bzrlib installed dir
 
108
        path.append(os.path.dirname(_mod_plugins.__file__))
 
109
    # search the arch independent path if we can determine that and
 
110
    # the plugin is found nowhere else
 
111
    if sys.platform != 'win32':
 
112
        try:
 
113
            from distutils.sysconfig import get_python_lib
 
114
        except ImportError:
 
115
            # If distutuils is not available, we just won't add that path
 
116
            pass
 
117
        else:
 
118
            archless_path = osutils.pathjoin(get_python_lib(), 'bzrlib',
 
119
                    'plugins')
 
120
            if archless_path not in path:
 
121
                path.append(archless_path)
 
122
    _mod_plugins.__path__ = path
 
123
    return path
 
124
 
 
125
 
 
126
def load_plugins():
211
127
    """Load bzrlib plugins.
212
128
 
213
129
    The environment variable BZR_PLUGIN_PATH is considered a delimited
215
131
    files (and whatever other extensions are used in the platform,
216
132
    such as *.pyd).
217
133
 
218
 
    load_from_path() provides the underlying mechanism and is called with
 
134
    load_from_dirs() provides the underlying mechanism and is called with
219
135
    the default directory list to provide the normal behaviour.
220
 
 
221
 
    :param path: The list of paths to search for plugins.  By default,
222
 
        path will be determined using get_standard_plugins_path.
223
 
        if path is [], no plugins can be loaded.
224
136
    """
225
137
    global _loaded
226
138
    if _loaded:
229
141
    _loaded = True
230
142
 
231
143
    # scan for all plugins in the path.
232
 
    load_from_path(set_plugins_path(path))
 
144
    load_from_path(set_plugins_path())
233
145
 
234
146
 
235
147
def load_from_path(dirs):
244
156
 
245
157
    The python module path for bzrlib.plugins will be modified to be 'dirs'.
246
158
    """
247
 
    # Explicitly load the plugins with a specific path
248
 
    for fullname, path in PluginImporter.specific_paths.iteritems():
249
 
        name = fullname[len('bzrlib.plugins.'):]
250
 
        _load_plugin_module(name, path)
251
 
 
252
159
    # We need to strip the trailing separators here as well as in the
253
160
    # set_plugins_path function because calling code can pass anything in to
254
161
    # this function, and since it sets plugins.__path__, it should set it to
268
175
load_from_dirs = load_from_path
269
176
 
270
177
 
271
 
def _find_plugin_module(dir, name):
272
 
    """Check if there is a valid python module that can be loaded as a plugin.
273
 
 
274
 
    :param dir: The directory where the search is performed.
275
 
    :param path: An existing file path, either a python file or a package
276
 
        directory.
277
 
 
278
 
    :return: (name, path, description) name is the module name, path is the
279
 
        file to load and description is the tuple returned by
280
 
        imp.get_suffixes().
281
 
    """
282
 
    path = osutils.pathjoin(dir, name)
283
 
    if os.path.isdir(path):
284
 
        # Check for a valid __init__.py file, valid suffixes depends on -O and
285
 
        # can be .py, .pyc and .pyo
286
 
        for suffix, mode, kind in imp.get_suffixes():
287
 
            if kind not in (imp.PY_SOURCE, imp.PY_COMPILED):
288
 
                # We don't recognize compiled modules (.so, .dll, etc)
289
 
                continue
290
 
            init_path = osutils.pathjoin(path, '__init__' + suffix)
291
 
            if os.path.isfile(init_path):
292
 
                return name, init_path, (suffix, mode, kind)
293
 
    else:
294
 
        for suffix, mode, kind in imp.get_suffixes():
295
 
            if name.endswith(suffix):
296
 
                # Clean up the module name
297
 
                name = name[:-len(suffix)]
298
 
                if kind == imp.C_EXTENSION and name.endswith('module'):
299
 
                    name = name[:-len('module')]
300
 
                return name, path, (suffix, mode, kind)
301
 
    # There is no python module here
302
 
    return None, None, (None, None, None)
303
 
 
304
 
 
305
 
def _load_plugin_module(name, dir):
306
 
    """Load plugin name from dir.
307
 
 
308
 
    :param name: The plugin name in the bzrlib.plugins namespace.
309
 
    :param dir: The directory the plugin is loaded from for error messages.
310
 
    """
311
 
    if ('bzrlib.plugins.%s' % name) in PluginImporter.blacklist:
312
 
        return
313
 
    try:
314
 
        exec "import bzrlib.plugins.%s" % name in {}
315
 
    except KeyboardInterrupt:
316
 
        raise
317
 
    except errors.IncompatibleAPI, e:
318
 
        trace.warning("Unable to load plugin %r. It requested API version "
319
 
            "%s of module %s but the minimum exported version is %s, and "
320
 
            "the maximum is %s" %
321
 
            (name, e.wanted, e.api, e.minimum, e.current))
322
 
    except Exception, e:
323
 
        trace.warning("%s" % e)
324
 
        if re.search('\.|-| ', name):
325
 
            sanitised_name = re.sub('[-. ]', '_', name)
326
 
            if sanitised_name.startswith('bzr_'):
327
 
                sanitised_name = sanitised_name[len('bzr_'):]
328
 
            trace.warning("Unable to load %r in %r as a plugin because the "
329
 
                    "file path isn't a valid module name; try renaming "
330
 
                    "it to %r." % (name, dir, sanitised_name))
331
 
        else:
332
 
            trace.warning('Unable to load plugin %r from %r' % (name, dir))
333
 
        trace.log_exception_quietly()
334
 
        if 'error' in debug.debug_flags:
335
 
            trace.print_exception(sys.exc_info(), sys.stderr)
336
 
 
337
 
 
338
178
def load_from_dir(d):
339
179
    """Load the plugins in directory d.
340
 
 
 
180
    
341
181
    d must be in the plugins module path already.
342
 
    This function is called once for each directory in the module path.
343
182
    """
 
183
    # Get the list of valid python suffixes for __init__.py?
 
184
    # this includes .py, .pyc, and .pyo (depending on if we are running -O)
 
185
    # but it doesn't include compiled modules (.so, .dll, etc)
 
186
    valid_suffixes = [suffix for suffix, mod_type, flags in imp.get_suffixes()
 
187
                              if flags in (imp.PY_SOURCE, imp.PY_COMPILED)]
 
188
    package_entries = ['__init__'+suffix for suffix in valid_suffixes]
344
189
    plugin_names = set()
345
 
    for p in os.listdir(d):
346
 
        name, path, desc = _find_plugin_module(d, p)
347
 
        if name is not None:
348
 
            if name == '__init__':
349
 
                # We do nothing with the __init__.py file in directories from
350
 
                # the bzrlib.plugins module path, we may want to, one day
351
 
                # -- vila 20100316.
352
 
                continue # We don't load __init__.py in the plugins dirs
353
 
            elif getattr(_mod_plugins, name, None) is not None:
354
 
                # The module has already been loaded from another directory
355
 
                # during a previous call.
356
 
                # FIXME: There should be a better way to report masked plugins
357
 
                # -- vila 20100316
358
 
                trace.mutter('Plugin name %s already loaded', name)
 
190
    for f in os.listdir(d):
 
191
        path = osutils.pathjoin(d, f)
 
192
        if os.path.isdir(path):
 
193
            for entry in package_entries:
 
194
                # This directory should be a package, and thus added to
 
195
                # the list
 
196
                if os.path.isfile(osutils.pathjoin(path, entry)):
 
197
                    break
 
198
            else: # This directory is not a package
 
199
                continue
 
200
        else:
 
201
            for suffix_info in imp.get_suffixes():
 
202
                if f.endswith(suffix_info[0]):
 
203
                    f = f[:-len(suffix_info[0])]
 
204
                    if suffix_info[2] == imp.C_EXTENSION and f.endswith('module'):
 
205
                        f = f[:-len('module')]
 
206
                    break
359
207
            else:
360
 
                plugin_names.add(name)
361
 
 
 
208
                continue
 
209
        if f == '__init__':
 
210
            continue # We don't load __init__.py again in the plugin dir
 
211
        elif getattr(_mod_plugins, f, None):
 
212
            trace.mutter('Plugin name %s already loaded', f)
 
213
        else:
 
214
            # trace.mutter('add plugin name %s', f)
 
215
            plugin_names.add(f)
 
216
    
362
217
    for name in plugin_names:
363
 
        _load_plugin_module(name, d)
 
218
        try:
 
219
            exec "import bzrlib.plugins.%s" % name in {}
 
220
        except KeyboardInterrupt:
 
221
            raise
 
222
        except errors.IncompatibleAPI, e:
 
223
            trace.warning("Unable to load plugin %r. It requested API version "
 
224
                "%s of module %s but the minimum exported version is %s, and "
 
225
                "the maximum is %s" %
 
226
                (name, e.wanted, e.api, e.minimum, e.current))
 
227
        except Exception, e:
 
228
            trace.warning("%s" % e)
 
229
            ## import pdb; pdb.set_trace()
 
230
            if re.search('\.|-| ', name):
 
231
                sanitised_name = re.sub('[-. ]', '_', name)
 
232
                if sanitised_name.startswith('bzr_'):
 
233
                    sanitised_name = sanitised_name[len('bzr_'):]
 
234
                trace.warning("Unable to load %r in %r as a plugin because the "
 
235
                        "file path isn't a valid module name; try renaming "
 
236
                        "it to %r." % (name, d, sanitised_name))
 
237
            else:
 
238
                trace.warning('Unable to load plugin %r from %r' % (name, d))
 
239
            trace.log_exception_quietly()
 
240
            if 'error' in debug.debug_flags:
 
241
                trace.print_exception(sys.exc_info(), sys.stderr)
 
242
 
 
243
 
 
244
@deprecated_function(one_three)
 
245
def load_from_zip(zip_name):
 
246
    """Load all the plugins in a zip."""
 
247
    valid_suffixes = ('.py', '.pyc', '.pyo')    # only python modules/packages
 
248
                                                # is allowed
 
249
    try:
 
250
        index = zip_name.rindex('.zip')
 
251
    except ValueError:
 
252
        return
 
253
    archive = zip_name[:index+4]
 
254
    prefix = zip_name[index+5:]
 
255
 
 
256
    trace.mutter('Looking for plugins in %r', zip_name)
 
257
 
 
258
    # use zipfile to get list of files/dirs inside zip
 
259
    try:
 
260
        z = zipfile.ZipFile(archive)
 
261
        namelist = z.namelist()
 
262
        z.close()
 
263
    except zipfile.error:
 
264
        # not a valid zip
 
265
        return
 
266
 
 
267
    if prefix:
 
268
        prefix = prefix.replace('\\','/')
 
269
        if prefix[-1] != '/':
 
270
            prefix += '/'
 
271
        ix = len(prefix)
 
272
        namelist = [name[ix:]
 
273
                    for name in namelist
 
274
                    if name.startswith(prefix)]
 
275
 
 
276
    trace.mutter('Names in archive: %r', namelist)
 
277
    
 
278
    for name in namelist:
 
279
        if not name or name.endswith('/'):
 
280
            continue
 
281
    
 
282
        # '/' is used to separate pathname components inside zip archives
 
283
        ix = name.rfind('/')
 
284
        if ix == -1:
 
285
            head, tail = '', name
 
286
        else:
 
287
            head, tail = name.rsplit('/',1)
 
288
        if '/' in head:
 
289
            # we don't need looking in subdirectories
 
290
            continue
 
291
    
 
292
        base, suffix = osutils.splitext(tail)
 
293
        if suffix not in valid_suffixes:
 
294
            continue
 
295
    
 
296
        if base == '__init__':
 
297
            # package
 
298
            plugin_name = head
 
299
        elif head == '':
 
300
            # module
 
301
            plugin_name = base
 
302
        else:
 
303
            continue
 
304
    
 
305
        if not plugin_name:
 
306
            continue
 
307
        if getattr(_mod_plugins, plugin_name, None):
 
308
            trace.mutter('Plugin name %s already loaded', plugin_name)
 
309
            continue
 
310
    
 
311
        try:
 
312
            exec "import bzrlib.plugins.%s" % plugin_name in {}
 
313
            trace.mutter('Load plugin %s from zip %r', plugin_name, zip_name)
 
314
        except KeyboardInterrupt:
 
315
            raise
 
316
        except Exception, e:
 
317
            ## import pdb; pdb.set_trace()
 
318
            trace.warning('Unable to load plugin %r from %r'
 
319
                    % (name, zip_name))
 
320
            trace.log_exception_quietly()
 
321
            if 'error' in debug.debug_flags:
 
322
                trace.print_exception(sys.exc_info(), sys.stderr)
364
323
 
365
324
 
366
325
def plugins():
367
326
    """Return a dictionary of the plugins.
368
 
 
 
327
    
369
328
    Each item in the dictionary is a PlugIn object.
370
329
    """
371
330
    result = {}
413
372
        """
414
373
        self.module = module
415
374
 
416
 
    def get_help_text(self, additional_see_also=None, verbose=True):
 
375
    def get_help_text(self, additional_see_also=None):
417
376
        """Return a string with the help for this topic.
418
377
 
419
378
        :param additional_see_also: Additional help topics to be
425
384
            result = self.module.__doc__
426
385
        if result[-1] != '\n':
427
386
            result += '\n'
428
 
        # there is code duplicated here and in bzrlib/help_topic.py's
 
387
        # there is code duplicated here and in bzrlib/help_topic.py's 
429
388
        # matching Topic code. This should probably be factored in
430
389
        # to a helper function and a common base class.
431
390
        if additional_see_also is not None:
523
482
        return version_string
524
483
 
525
484
    __version__ = property(_get__version__)
526
 
 
527
 
 
528
 
class _PluginImporter(object):
529
 
    """An importer tailored to bzr specific needs.
530
 
 
531
 
    This is a singleton that takes care of:
532
 
    - disabled plugins specified in 'blacklist',
533
 
    - plugins that needs to be loaded from specific directories.
534
 
    """
535
 
 
536
 
    def __init__(self):
537
 
        self.reset()
538
 
 
539
 
    def reset(self):
540
 
        self.blacklist = set()
541
 
        self.specific_paths = {}
542
 
 
543
 
    def find_module(self, fullname, parent_path=None):
544
 
        """Search a plugin module.
545
 
 
546
 
        Disabled plugins raise an import error, plugins with specific paths
547
 
        returns a specific loader.
548
 
 
549
 
        :return: None if the plugin doesn't need special handling, self
550
 
            otherwise.
551
 
        """
552
 
        if not fullname.startswith('bzrlib.plugins.'):
553
 
            return None
554
 
        if fullname in self.blacklist:
555
 
            raise ImportError('%s is disabled' % fullname)
556
 
        if fullname in self.specific_paths:
557
 
            return self
558
 
        return None
559
 
 
560
 
    def load_module(self, fullname):
561
 
        """Load a plugin from a specific directory."""
562
 
        # We are called only for specific paths
563
 
        plugin_path = self.specific_paths[fullname]
564
 
        loading_path = None
565
 
        package = False
566
 
        if os.path.isdir(plugin_path):
567
 
            for suffix, mode, kind in imp.get_suffixes():
568
 
                if kind not in (imp.PY_SOURCE, imp.PY_COMPILED):
569
 
                    # We don't recognize compiled modules (.so, .dll, etc)
570
 
                    continue
571
 
                init_path = osutils.pathjoin(plugin_path, '__init__' + suffix)
572
 
                if os.path.isfile(init_path):
573
 
                    loading_path = init_path
574
 
                    package = True
575
 
                    break
576
 
        else:
577
 
            for suffix, mode, kind in imp.get_suffixes():
578
 
                if plugin_path.endswith(suffix):
579
 
                    loading_path = plugin_path
580
 
                    break
581
 
        if loading_path is None:
582
 
            raise ImportError('%s cannot be loaded from %s'
583
 
                              % (fullname, plugin_path))
584
 
        f = open(loading_path, mode)
585
 
        try:
586
 
            mod = imp.load_module(fullname, f, loading_path,
587
 
                                  (suffix, mode, kind))
588
 
            if package:
589
 
                # The plugin can contain modules, so be ready
590
 
                mod.__path__ = [plugin_path]
591
 
            mod.__package__ = fullname
592
 
            return mod
593
 
        finally:
594
 
            f.close()
595
 
 
596
 
 
597
 
# Install a dedicated importer for plugins requiring special handling
598
 
PluginImporter = _PluginImporter()
599
 
sys.meta_path.append(PluginImporter)