Migrate CLI functionality to plugin layer subset 2

improver/blending/weighted_blend.py

@@ -21,6 +21,7 @@
 from improver.blending.utilities import find_blend_dim_coord, store_record_run_as_coord
 from improver.metadata.constants import FLOAT_DTYPE, PERC_COORD
 from improver.metadata.forecast_times import rebadge_forecasts_as_latest_cycle
+from improver.utilities.complex_conversion import complex_to_deg, deg_to_complex
 from improver.utilities.cube_manipulation import (
     MergeCubes,
     collapsed,
@@ -29,7 +30,6 @@
     get_dim_coord_names,
     sort_coord_in_cube,
 )
-from improver.wind_calculations.wind_direction import WindDirection
 
 
 class MergeCubesForWeightedBlending(BasePlugin):
@@ -631,7 +631,7 @@ def weighted_mean(self, cube: Cube, weights: Optional[Cube]) -> Cube:
 
         # If units are degrees, convert degrees to complex numbers.
         if cube.units == "degrees":
-            cube.data = WindDirection.deg_to_complex(cube.data)
+            cube.data = deg_to_complex(cube.data)
 
         weights_array = self.get_weights_array(cube, weights)
 
@@ -658,7 +658,7 @@ def weighted_mean(self, cube: Cube, weights: Optional[Cube]) -> Cube:
 
         # If units are degrees, convert complex numbers back to degrees.
         if cube.units == "degrees":
-            result.data = WindDirection.complex_to_deg(result.data)
+            result.data = complex_to_deg(result.data)
 
         return result
 

improver/cli/extract.py

@@ -52,13 +52,8 @@ def process(
             A single cube matching the input constraints or None. If no
             sub-cube is found within the cube that matches the constraints.
     """
-    from improver.utilities.cube_extraction import extract_subcube
+    from improver.utilities.cube_extraction import ExtractSubCube
 
-    result = extract_subcube(cube, constraints, units)
-
-    if result is None and ignore_failure:
-        return cube
-    if result is None:
-        msg = "Constraint(s) could not be matched in input cube"
-        raise ValueError(msg)
+    plugin = ExtractSubCube(constraints, units=units, ignore_failure=ignore_failure)
+    result = plugin.process(cube)
     return result

improver/cli/freezing_rain.py

@@ -39,8 +39,6 @@ def process(*cubes: cli.inputcube, model_id_attr: str = None):
             A cube of freezing rain rate or accumulation probabilities.
 
     """
-    from iris.cube import CubeList
-
     from improver.precipitation_type.freezing_rain import FreezingRain
 
-    return FreezingRain(model_id_attr=model_id_attr)(CubeList(cubes))
+    return FreezingRain(model_id_attr=model_id_attr)(*cubes)

improver/cli/hail_fraction.py

@@ -27,34 +27,6 @@ def process(*cubes: cli.inputcubelist, model_id_attr: str = None):
             A single cube containing the hail fraction.
 
     """
-    from iris.cube import CubeList
-
     from improver.precipitation_type.hail_fraction import HailFraction
-    from improver.utilities.flatten import flatten
-
-    (
-        vertical_updraught,
-        hail_size,
-        cloud_condensation_level,
-        convective_cloud_top,
-        hail_melting_level,
-        altitude,
-    ) = CubeList(flatten(cubes)).extract(
-        [
-            "maximum_vertical_updraught",
-            "diameter_of_hail_stones",
-            "air_temperature_at_condensation_level",
-            "air_temperature_at_convective_cloud_top",
-            "altitude_of_rain_from_hail_falling_level",
-            "surface_altitude",
-        ]
-    )
 
-    return HailFraction(model_id_attr=model_id_attr)(
-        vertical_updraught,
-        hail_size,
-        cloud_condensation_level,
-        convective_cloud_top,
-        hail_melting_level,
-        altitude,
-    )
+    return HailFraction(model_id_attr=model_id_attr)(*cubes)

improver/cli/hail_size.py

@@ -33,24 +33,6 @@ def process(*cubes: cli.inputcubelist, model_id_attr: str = None):
         iris.cube.Cube:
             Cube of diameter_of_hail (m).
     """
-
-    from iris.cube import CubeList
-
     from improver.psychrometric_calculations.hail_size import HailSize
-    from improver.utilities.flatten import flatten
 
-    cubes = flatten(cubes)
-    (temperature, ccl_pressure, ccl_temperature, wet_bulb_zero, orography,) = CubeList(
-        cubes
-    ).extract(
-        [
-            "air_temperature",
-            "air_pressure_at_condensation_level",
-            "air_temperature_at_condensation_level",
-            "wet_bulb_freezing_level_altitude",
-            "surface_altitude",
-        ]
-    )
-    return HailSize(model_id_attr=model_id_attr)(
-        ccl_temperature, ccl_pressure, temperature, wet_bulb_zero, orography,
-    )
+    return HailSize(model_id_attr=model_id_attr)(*cubes)

improver/cli/interpolate_using_difference.py

@@ -53,7 +53,7 @@ def process(
     """
     from improver.utilities.interpolation import InterpolateUsingDifference
 
-    result = InterpolateUsingDifference()(
-        cube, reference_cube, limit=limit, limit_as_maximum=limit_as_maximum
+    result = InterpolateUsingDifference(limit_as_maximum=limit_as_maximum)(
+        cube, reference_cube=reference_cube, limit=limit,
     )
     return result

improver/cli/lightning_from_cape_and_precip.py

@@ -29,10 +29,6 @@ def process(
         iris.cube.Cube:
             Cube of probabilities of lightning relative to a zero rate thresholds
     """
-    from iris.cube import CubeList
-
     from improver.lightning import LightningFromCapePrecip
 
-    result = LightningFromCapePrecip()(CubeList(cubes), model_id_attr=model_id_attr)
-
-    return result
+    return LightningFromCapePrecip(model_id_attr=model_id_attr)(*cubes)

improver/cli/nbhood.py

@@ -96,51 +96,17 @@ def process(
         RuntimeError:
             If degree_as_complex is used with neighbourhood_shape='circular'.
     """
-    from improver.nbhood import radius_by_lead_time
-    from improver.nbhood.nbhood import (
-        GeneratePercentilesFromANeighbourhood,
-        NeighbourhoodProcessing,
-    )
-    from improver.utilities.pad_spatial import remove_cube_halo
-    from improver.wind_calculations.wind_direction import WindDirection
-
-    if neighbourhood_output == "percentiles":
-        if weighted_mode:
-            raise RuntimeError(
-                "weighted_mode cannot be used with" 'neighbourhood_output="percentiles"'
-            )
-        if degrees_as_complex:
-            raise RuntimeError("Cannot generate percentiles from complex numbers")
-
-    if neighbourhood_shape == "circular":
-        if degrees_as_complex:
-            raise RuntimeError(
-                "Cannot process complex numbers with circular neighbourhoods"
-            )
-
-    if degrees_as_complex:
-        # convert cube data into complex numbers
-        cube.data = WindDirection.deg_to_complex(cube.data)
+    from improver.nbhood.nbhood import MetaNeighbourhood
 
-    radius_or_radii, lead_times = radius_by_lead_time(radii, lead_times)
-
-    if neighbourhood_output == "probabilities":
-        result = NeighbourhoodProcessing(
-            neighbourhood_shape,
-            radius_or_radii,
-            lead_times=lead_times,
-            weighted_mode=weighted_mode,
-            sum_only=area_sum,
-            re_mask=True,
-        )(cube, mask_cube=mask)
-    elif neighbourhood_output == "percentiles":
-        result = GeneratePercentilesFromANeighbourhood(
-            radius_or_radii, lead_times=lead_times, percentiles=percentiles,
-        )(cube)
-
-    if degrees_as_complex:
-        # convert neighbourhooded cube back to degrees
-        result.data = WindDirection.complex_to_deg(result.data)
-    if halo_radius is not None:
-        result = remove_cube_halo(result, halo_radius)
-    return result
+    plugin = MetaNeighbourhood(
+        neighbourhood_output=neighbourhood_output,
+        neighbourhood_shape=neighbourhood_shape,
+        radii=radii,
+        lead_times=lead_times,
+        degrees_as_complex=degrees_as_complex,
+        weighted_mode=weighted_mode,
+        area_sum=area_sum,
+        percentiles=percentiles,
+        halo_radius=halo_radius,
+    )
+    return plugin(cube, mask=mask)

improver/cli/phase_change_level.py

@@ -72,5 +72,5 @@ def process(
         horizontal_interpolation=horizontal_interpolation,
         model_id_attr=model_id_attr,
     )
-    result = plugin(cubes)
+    result = plugin(*cubes)
     return result

improver/cli/phase_probability.py

@@ -45,10 +45,8 @@ def process(*cubes: cli.inputcube):
             The name of the orography cube must be "surface_altitude".
             The name of the site ancillary most be "grid_neighbours".
     """
-    from iris.cube import CubeList
-
     from improver.psychrometric_calculations.precip_phase_probability import (
         PrecipPhaseProbability,
     )
 
-    return PrecipPhaseProbability()(CubeList(cubes))
+    return PrecipPhaseProbability()(*cubes)

improver/cli/snow_splitter.py

@@ -42,8 +42,6 @@ def process(*cubes: cli.inputcube, output_is_rain: bool):
             on precipitation cube)
 
     """
-    from iris.cube import CubeList
-
     from improver.precipitation_type.snow_splitter import SnowSplitter
 
-    return SnowSplitter(output_is_rain=output_is_rain)(CubeList(cubes))
+    return SnowSplitter(output_is_rain=output_is_rain)(*cubes)

improver/cli/vertical_updraught.py

@@ -33,4 +33,4 @@ def process(*cubes: cli.inputcube, model_id_attr: str = None):
     """
     from improver.wind_calculations.vertical_updraught import VerticalUpdraught
 
-    return VerticalUpdraught(model_id_attr=model_id_attr)(cubes)
+    return VerticalUpdraught(model_id_attr=model_id_attr)(*cubes)

improver/cli/wet_bulb_freezing_level.py

@@ -30,11 +30,8 @@ def process(wet_bulb_temperature: cli.inputcube):
             Cube of wet-bulb freezing level.
 
     """
-    from improver.utilities.cube_extraction import ExtractLevel
+    from improver.psychrometric_calculations.wet_bulb_temperature import (
+        MetaWetBulbFreezingLevel,
+    )
 
-    wet_bulb_freezing_level = ExtractLevel(
-        positive_correlation=False, value_of_level=273.15
-    )(wet_bulb_temperature)
-    wet_bulb_freezing_level.rename("wet_bulb_freezing_level_altitude")
-
-    return wet_bulb_freezing_level
+    return MetaWetBulbFreezingLevel()(wet_bulb_temperature)

improver/cli/wet_bulb_temperature.py

@@ -49,4 +49,4 @@ def process(
 
     return WetBulbTemperature(
         precision=convergence_condition, model_id_attr=model_id_attr
-    )(cubes)
+    )(*cubes)

improver/lightning.py

@@ -4,7 +4,7 @@
 # See LICENSE in the root of the repository for full licensing details.
 """Module containing lightning classes."""
 from datetime import timedelta
-from typing import Tuple
+from typing import Tuple, Union
 
 import iris
 import numpy as np
@@ -18,6 +18,7 @@
     generate_mandatory_attributes,
 )
 from improver.threshold import LatitudeDependentThreshold
+from improver.utilities.common_input_handle import as_cubelist
 from improver.utilities.cube_checker import spatial_coords_match
 from improver.utilities.rescale import rescale
 from improver.utilities.spatial import create_vicinity_coord
@@ -44,6 +45,17 @@ class LightningFromCapePrecip(PostProcessingPlugin):
 
     """
 
+    def __init__(self, model_id_attr: str = None) -> None:
+        """
+        Initialise the plugin with the model_id_attr.
+
+        Args:
+            model_id_attr:
+                The name of the dataset attribute to be used to identify the source
+                model when blending data from different models.
+        """
+        self._model_id_attr = model_id_attr
+
     @staticmethod
     def _get_inputs(cubes: CubeList) -> Tuple[Cube, Cube]:
         """
@@ -96,17 +108,14 @@ def _get_inputs(cubes: CubeList) -> Tuple[Cube, Cube]:
             raise ValueError("Supplied cubes do not have the same spatial coordinates")
         return cape, precip
 
-    def process(self, cubes: CubeList, model_id_attr: str = None) -> Cube:
+    def process(self, *cubes: Union[Cube, CubeList]) -> Cube:
         """
         From the supplied CAPE and precipitation-rate cubes, calculate a probability
         of lightning cube.
 
         Args:
             cubes:
                 Cubes of CAPE and Precipitation rate.
-            model_id_attr:
-                The name of the dataset attribute to be used to identify the source
-                model when blending data from different models.
 
         Returns:
             Cube of lightning data
@@ -115,6 +124,7 @@ def process(self, cubes: CubeList, model_id_attr: str = None) -> Cube:
             ValueError:
                 If one of the cubes is not found or doesn't match the other
         """
+        cubes = as_cubelist(*cubes)
         cape, precip = self._get_inputs(cubes)
 
         cape_true = LatitudeDependentThreshold(
@@ -137,7 +147,7 @@ def process(self, cubes: CubeList, model_id_attr: str = None) -> Cube:
             template_cube=precip,
             data=data.astype(FLOAT_DTYPE),
             mandatory_attributes=generate_mandatory_attributes(
-                cubes, model_id_attr=model_id_attr
+                cubes, model_id_attr=self._model_id_attr
             ),
         )