Delete pelican/plugins directory

pelican/plugins/_utils.py

@@ -1,125 +0,0 @@
-import importlib
-import importlib.machinery
-import importlib.util
-import inspect
-import logging
-import pkgutil
-import sys
-
-
-logger = logging.getLogger(__name__)
-
-
-def iter_namespace(ns_pkg):
-    # Specifying the second argument (prefix) to iter_modules makes the
-    # returned name an absolute name instead of a relative one. This allows
-    # import_module to work without having to do additional modification to
-    # the name.
-    return pkgutil.iter_modules(ns_pkg.__path__, ns_pkg.__name__ + ".")
-
-
-def get_namespace_plugins(ns_pkg=None):
-    if ns_pkg is None:
-        import pelican.plugins as ns_pkg
-
-    return {
-        name: importlib.import_module(name)
-        for finder, name, ispkg
-        in iter_namespace(ns_pkg)
-        if ispkg
-    }
-
-
-def list_plugins(ns_pkg=None):
-    from pelican.log import init as init_logging
-    init_logging(logging.INFO)
-    ns_plugins = get_namespace_plugins(ns_pkg)
-    if ns_plugins:
-        logger.info('Plugins found:\n' + '\n'.join(ns_plugins))
-    else:
-        logger.info('No plugins are installed')
-
-
-def load_legacy_plugin(plugin, plugin_paths):
-    if '.' in plugin:
-        # it is in a package, try to resolve package first
-        package, _, _ = plugin.rpartition('.')
-        load_legacy_plugin(package, plugin_paths)
-
-    # Try to find plugin in PLUGIN_PATHS
-    spec = importlib.machinery.PathFinder.find_spec(plugin, plugin_paths)
-    if spec is None:
-        # If failed, try to find it in normal importable locations
-        spec = importlib.util.find_spec(plugin)
-    if spec is None:
-        raise ImportError('Cannot import plugin `{}`'.format(plugin))
-    else:
-        # Avoid loading the same plugin twice
-        if spec.name in sys.modules:
-            return sys.modules[spec.name]
-        # create module object from spec
-        mod = importlib.util.module_from_spec(spec)
-        # place it into sys.modules cache
-        # necessary if module imports itself at some point (e.g. packages)
-        sys.modules[spec.name] = mod
-        try:
-            # try to execute it inside module object
-            spec.loader.exec_module(mod)
-        except Exception:  # problem with import
-            try:
-                # remove module from sys.modules since it can't be loaded
-                del sys.modules[spec.name]
-            except KeyError:
-                pass
-            raise
-
-        # if all went well, we have the plugin module
-        return mod
-
-
-def load_plugins(settings):
-    logger.debug('Finding namespace plugins')
-    namespace_plugins = get_namespace_plugins()
-    if namespace_plugins:
-        logger.debug('Namespace plugins found:\n' +
-                     '\n'.join(namespace_plugins))
-    plugins = []
-    if settings.get('PLUGINS') is not None:
-        for plugin in settings['PLUGINS']:
-            if isinstance(plugin, str):
-                logger.debug('Loading plugin `%s`', plugin)
-                # try to find in namespace plugins
-                if plugin in namespace_plugins:
-                    plugin = namespace_plugins[plugin]
-                elif 'pelican.plugins.{}'.format(plugin) in namespace_plugins:
-                    plugin = namespace_plugins['pelican.plugins.{}'.format(
-                        plugin)]
-                # try to import it
-                else:
-                    try:
-                        plugin = load_legacy_plugin(
-                            plugin,
-                            settings.get('PLUGIN_PATHS', []))
-                    except ImportError as e:
-                        logger.error('Cannot load plugin `%s`\n%s', plugin, e)
-                        continue
-            plugins.append(plugin)
-    else:
-        plugins = list(namespace_plugins.values())
-
-    return plugins
-
-
-def get_plugin_name(plugin):
-    """
-    Plugins can be passed as module objects, however this breaks caching as
-    module objects cannot be pickled. To work around this, all plugins are
-    stringified post-initialization.
-    """
-    if inspect.isclass(plugin):
-        return plugin.__qualname__
-
-    if inspect.ismodule(plugin):
-        return plugin.__name__
-
-    return type(plugin).__qualname__

pelican/plugins/signals.py

@@ -1,49 +0,0 @@
-from blinker import signal
-
-# Run-level signals:
-
-initialized = signal('pelican_initialized')
-get_generators = signal('get_generators')
-all_generators_finalized = signal('all_generators_finalized')
-get_writer = signal('get_writer')
-finalized = signal('pelican_finalized')
-
-# Reader-level signals
-
-readers_init = signal('readers_init')
-
-# Generator-level signals
-
-generator_init = signal('generator_init')
-
-article_generator_init = signal('article_generator_init')
-article_generator_pretaxonomy = signal('article_generator_pretaxonomy')
-article_generator_finalized = signal('article_generator_finalized')
-article_generator_write_article = signal('article_generator_write_article')
-article_writer_finalized = signal('article_writer_finalized')
-
-page_generator_init = signal('page_generator_init')
-page_generator_finalized = signal('page_generator_finalized')
-page_generator_write_page = signal('page_generator_write_page')
-page_writer_finalized = signal('page_writer_finalized')
-
-static_generator_init = signal('static_generator_init')
-static_generator_finalized = signal('static_generator_finalized')
-
-# Page-level signals
-
-article_generator_preread = signal('article_generator_preread')
-article_generator_context = signal('article_generator_context')
-
-page_generator_preread = signal('page_generator_preread')
-page_generator_context = signal('page_generator_context')
-
-static_generator_preread = signal('static_generator_preread')
-static_generator_context = signal('static_generator_context')
-
-content_object_init = signal('content_object_init')
-
-# Writers signals
-content_written = signal('content_written')
-feed_generated = signal('feed_generated')
-feed_written = signal('feed_written')