Adapt pysteps to allow for postprocessing plugins

ci/test_plugin_support.py

@@ -13,15 +13,11 @@
 from pysteps import io
 
 print("Testing plugin support: ", end="")
-assert hasattr(io.importers, "import_abc_xxx")
-assert hasattr(io.importers, "import_abc_yyy")
+assert hasattr(io.importers, "import_institution_name")
 
-assert "abc_xxx" in io.interface._importer_methods
-assert "abc_yyy" in io.interface._importer_methods
+assert "institution_name" in io.interface._importer_methods
 
-from pysteps.io.importers import import_abc_xxx, import_abc_yyy
-
-import_abc_xxx("filename")
-import_abc_yyy("filename")
+from pysteps.io.importers import import_institution_name
 
+import_institution_name("filename")
 print("PASSED")

pysteps/__init__.py

@@ -218,3 +218,4 @@ def load_config_file(params_file=None, verbose=False, dryrun=False):
 
 # After the sub-modules are loaded, register the discovered importers plugin.
 io.interface.discover_importers()
+postprocessing.interface.discover_postprocessors()

pysteps/io/interface.py

@@ -14,11 +14,8 @@
 """
 import importlib
 
-from importlib.metadata import entry_points
-
-from pysteps import io
 from pysteps.decorators import postprocess_import
-from pysteps.io import importers, exporters
+from pysteps.io import importers, exporters, interface
 from pprint import pprint
 
 _importer_methods = dict(
@@ -49,7 +46,16 @@ def discover_importers():
     The importers found are added to the `pysteps.io.interface_importer_methods`
     dictionary containing the available importers.
     """
-    for entry_point in entry_points(group="pysteps.plugins.importers"):
+    # The pkg resources needs to be reload to detect new packages installed during
+    # the execution of the python application. For example, when the plugins are
+    # installed during the tests
+    import pkg_resources
+
+    importlib.reload(pkg_resources)
+
+    for entry_point in pkg_resources.iter_entry_points(
+        group="pysteps.plugins.importer", name=None
+    ):
         _importer = entry_point.load()
 
         importer_function_name = _importer.__name__
@@ -63,14 +69,14 @@ def discover_importers():
             RuntimeWarning(
                 f"The importer identifier '{importer_short_name}' is already available in"
                 "'pysteps.io.interface._importer_methods'.\n"
-                f"Skipping {entry_point.module}:{entry_point.attr}"
+                f"Skipping {entry_point.module_name}:{entry_point.attrs}"
             )
 
         if hasattr(importers, importer_function_name):
             RuntimeWarning(
                 f"The importer function '{importer_function_name}' is already an attribute"
                 "of 'pysteps.io.importers`.\n"
-                f"Skipping {entry_point.module}:{entry_point.attr}"
+                f"Skipping {entry_point.module_name}:{entry_point.attrs}"
             )
         else:
             setattr(importers, importer_function_name, _importer)
@@ -81,22 +87,22 @@ def importers_info():
 
     # Importers available in the `io.importers` module
     available_importers = [
-        attr for attr in dir(io.importers) if attr.startswith("import_")
+        attr for attr in dir(importers) if attr.startswith("import_")
     ]
 
     print("\nImporters available in the pysteps.io.importers module")
     pprint(available_importers)
 
     # Importers declared in the pysteps.io.get_method interface
     importers_in_the_interface = [
-        f.__name__ for f in io.interface._importer_methods.values()
+        f.__name__ for f in interface._importer_methods.values()
     ]
 
     print("\nImporters available in the pysteps.io.get_method interface")
     pprint(
         [
             (short_name, f.__name__)
-            for short_name, f in io.interface._importer_methods.items()
+            for short_name, f in interface._importer_methods.items()
         ]
     )
 
@@ -107,7 +113,7 @@ def importers_info():
 
     difference = available_importers ^ importers_in_the_interface
     if len(difference) > 0:
-        print("\nIMPORTANT:")
+        # print("\nIMPORTANT:")
         _diff = available_importers - importers_in_the_interface
         if len(_diff) > 0:
             print(

pysteps/postprocessing/__init__.py

@@ -2,3 +2,6 @@
 """Methods for post-processing of forecasts."""
 
 from . import ensemblestats
+from .diagnostics import *
+from .interface import *
+from .ensemblestats import *

pysteps/postprocessing/diagnostics.py

@@ -0,0 +1,26 @@
+"""
+pysteps.postprocessing.diagnostics
+====================
+
+Methods for applying diagnostics postprocessing.
+
+The methods in this module implement the following interface::
+
+    diagnostic_xxx(optional arguments)
+
+where **xxx** is the name of the diagnostic to be applied.
+
+Available Diagnostics Postprocessors
+------------------------
+
+.. autosummary::
+    :toctree: ../generated/
+
+"""
+
+# def diagnostic_example1(filename, **kwargs):
+#     return "Hello, I am an example diagnostics postprocessor."
+
+
+# def diagnostic_example2(filename, **kwargs):
+#     return [[42, 42], [42, 42]]

pysteps/postprocessing/ensemblestats.py

@@ -177,3 +177,11 @@ def banddepth(X, thr=None, norm=False):
         depth = (depth - depth.min()) / (depth.max() - depth.min())
 
     return depth
+
+
+# def ensemblestat_example1(filename, **kwargs):
+#     return "Hello, I am an example of postprocessing ensemble statistics."
+
+
+# def ensemblestat_example2(filename, **kwargs):
+#     return [[42, 42], [42, 42]]