Improve logging of generators and writer loaders (#2821)

RELEASE.md

@@ -0,0 +1,3 @@
+Release type: patch
+
+Improve logging of generators and writer loaders

pelican/__init__.py

@@ -93,7 +93,7 @@ class Pelican:
                 path=self.path,
                 theme=self.theme,
                 output_path=self.output_path,
-            ) for cls in self.get_generator_classes()
+            ) for cls in self._get_generator_classes()
         ]
 
         # Delete the output directory if (1) the appropriate setting is True
@@ -114,7 +114,7 @@ class Pelican:
 
         signals.all_generators_finalized.send(generators)
 
-        writer = self.get_writer()
+        writer = self._get_writer()
 
         for p in generators:
             if hasattr(p, 'generate_output'):
@@ -162,46 +162,57 @@ class Pelican:
                     pluralized_draft_pages,
                     time.time() - start_time))
 
-    def get_generator_classes(self):
+    def _get_generator_classes(self):
-        generators = [ArticlesGenerator, PagesGenerator]
+        discovered_generators = [
+            (ArticlesGenerator, "internal"),
+            (PagesGenerator, "internal")
+        ]
 
-        if self.settings['TEMPLATE_PAGES']:
+        if self.settings["TEMPLATE_PAGES"]:
-            generators.append(TemplatePagesGenerator)
+            discovered_generators.append((TemplatePagesGenerator, "internal"))
-        if self.settings['OUTPUT_SOURCES']:
-            generators.append(SourceFileGenerator)
 
-        for pair in signals.get_generators.send(self):
+        if self.settings["OUTPUT_SOURCES"]:
-            (funct, value) = pair
+            discovered_generators.append((SourceFileGenerator, "internal"))
 
-            if not isinstance(value, Iterable):
+        for receiver, values in signals.get_generators.send(self):
-                value = (value, )
+            if not isinstance(values, Iterable):
+                values = (values,)
 
-            for v in value:
+                discovered_generators.extend(
-                if isinstance(v, type):
+                    [(generator, receiver.__module__) for generator in values]
-                    logger.debug('Found generator: %s', v)
+                )
-                    generators.append(v)
 
         # StaticGenerator must run last, so it can identify files that
         # were skipped by the other generators, and so static files can
         # have their output paths overridden by the {attach} link syntax.
-        generators.append(StaticGenerator)
+        discovered_generators.append((StaticGenerator, "internal"))
+
+        generators = []
+
+        for generator, origin in discovered_generators:
+            if not isinstance(generator, type):
+                logger.error("Generator %s (%s) cannot be loaded", generator, origin)
+                continue
+
+            logger.debug("Found generator: %s (%s)", generator.__name__, origin)
+            generators.append(generator)
+
         return generators
 
-    def get_writer(self):
+    def _get_writer(self):
-        writers = [w for (_, w) in signals.get_writer.send(self)
+        writers = [w for _, w in signals.get_writer.send(self) if isinstance(w, type)]
-                   if isinstance(w, type)]
+        num_writers = len(writers)
-        writers_found = len(writers)
+
-        if writers_found == 0:
+        if num_writers == 0:
             return Writer(self.output_path, settings=self.settings)
-        else:
+
-            writer = writers[0]
+        if num_writers > 1:
-            if writers_found == 1:
+            logger.warning("%s writers found, using only first one", num_writers)
-                logger.debug('Found writer: %s', writer)
+
-            else:
+        writer = writers[0]
-                logger.warning(
+
-                    '%s writers found, using only first one: %s',
+        logger.debug("Found writer: %s", writer)
-                    writers_found, writer)
+        return writer(self.output_path, settings=self.settings)
-            return writer(self.output_path, settings=self.settings)
 
 
 class PrintSettings(argparse.Action):

pelican/tests/test_pelican.py

@@ -84,14 +84,14 @@ class TestPelican(LoggedTestCase):
         # have their output paths overridden by the {attach} link syntax.
 
         pelican = Pelican(settings=read_settings(path=None))
-        generator_classes = pelican.get_generator_classes()
+        generator_classes = pelican._get_generator_classes()
 
         self.assertTrue(
             generator_classes[-1] is StaticGenerator,
             "StaticGenerator must be the last generator, but it isn't!")
         self.assertIsInstance(
             generator_classes, Sequence,
-            "get_generator_classes() must return a Sequence to preserve order")
+            "_get_generator_classes() must return a Sequence to preserve order")
 
     def test_basic_generation_works(self):
         # when running pelican without settings, it should pick up the default