add UKV

src/nwp_consumer/internal/entities/coordinates.py

@@ -98,6 +98,10 @@ class NWPDimensionCoordinateMap:
     longitude: list[float] | None = None
     """The longitude coordinates of the forecast grid in degrees. """
 
+    x: list[float] | None = None
+    y: list[float] | None = None
+    # These are the x and y osgb that the UKV model uses. They are not used in the other models
+
     def __post_init__(self) -> None:
         """Rigidly set input value ordering and precision."""
         self.variable = sorted(self.variable)

src/nwp_consumer/internal/entities/modelmetadata.py

@@ -297,3 +297,30 @@ class Models:
     )
     """MetOffice's Unified Model, in the Global configuration, at a resolution of 10km."""
 
+    MO_UKV_2KM: ModelMetadata = ModelMetadata(
+        name="UKV",
+        resolution="2km",
+        expected_coordinates=NWPDimensionCoordinateMap(
+            init_time=[],
+            step=list(range(0, 55)),
+            variable=sorted(
+                [
+                    Parameter.CLOUD_COVER_TOTAL,
+                    Parameter.CLOUD_COVER_HIGH,
+                    Parameter.CLOUD_COVER_MEDIUM,
+                    Parameter.CLOUD_COVER_LOW,
+                    Parameter.VISIBILITY_SL,
+                    Parameter.RELATIVE_HUMIDITY_SL,
+                    Parameter.SNOW_DEPTH_GL,
+                    Parameter.DOWNWARD_SHORTWAVE_RADIATION_FLUX_GL,
+                    Parameter.TEMPERATURE_SL,
+                    Parameter.WIND_U_COMPONENT_10m,
+                    Parameter.WIND_V_COMPONENT_10m,
+                ],
+            ),
+            x=list(range(0, 455)),
+            y=list(range(0, 639)),
+        ),
+    )
+    """MetOffice's UKV Mode, at a resolution of approximate 2km."""
+

src/nwp_consumer/internal/repositories/raw_repositories/mo_datahub.py

@@ -73,11 +73,15 @@ def __init__(self, order_id: str, api_key: str) -> None:
     @staticmethod
     @override
     def repository() -> entities.RawRepositoryMetadata:
+
+        requested_model: str = os.getenv("MODEL", default="default")
+        running_hours = list(range(0, 24)) if requested_model == "ukv-uk-2km" else [0, 12]
+
         return entities.RawRepositoryMetadata(
             name="MetOffice-Weather-Datahub",
             is_archive=False,
             is_order_based=True,
-            running_hours=[0, 12],
+            running_hours=running_hours,
             delay_minutes=60,
             max_connections=10,
             required_env=["METOFFICE_API_KEY", "METOFFICE_ORDER_ID"],
@@ -86,6 +90,7 @@ def repository() -> entities.RawRepositoryMetadata:
             available_models={
                 "default": entities.Models.MO_UM_GLOBAL_10KM,
                 "um-global-10km": entities.Models.MO_UM_GLOBAL_10KM,
+                "ukv-uk-2km": entities.Models.MO_UKV_2KM,
             },
         )
 
@@ -280,16 +285,19 @@ def _convert(path: pathlib.Path) -> ResultE[list[xr.DataArray]]:
                 )
 
         try:
-            da: xr.DataArray = (
+            ds = (
                 ds.pipe(
                     entities.Parameter.rename_else_drop_ds_vars,
                     allowed_parameters=MetOfficeDatahubRawRepository.model().expected_coordinates.variable,
                 )
                 .rename(name_dict={"time": "init_time"})
-                .expand_dims(dim="init_time")
-                .expand_dims(dim="step")
-                .to_dataarray(name=MetOfficeDatahubRawRepository.model().name)
-            )
+                .expand_dims(dim="init_time"))
+
+            if "step" not in ds.dims:
+                ds = ds.expand_dims(dim="step")
+
+            da: xr.DataArray = ds.to_dataarray(name=MetOfficeDatahubRawRepository.model().name)
+
             da = (
                 da.drop_vars(
                     names=[
@@ -299,10 +307,14 @@ def _convert(path: pathlib.Path) -> ResultE[list[xr.DataArray]]:
                     ],
                     errors="ignore",
                 )
-                .transpose(*MetOfficeDatahubRawRepository.model().expected_coordinates.dims)
-                .sortby(variables=["step", "variable", "longitude"])
-                .sortby(variables="latitude", ascending=False)
-            )
+                .transpose(*MetOfficeDatahubRawRepository.model().expected_coordinates.dims))
+
+            if "latitude" in MetOfficeDatahubRawRepository.model().expected_coordinates.dims:
+                da = da.sortby(variables=["step", "variable", "longitude"])
+                da = da.sortby(variables="latitude", ascending=False)
+            else:
+                da = da.sortby(variables=["step", "variable"])
+
         except Exception as e:
             return Failure(
                 ValueError(

src/nwp_consumer/internal/repositories/raw_repositories/test_mo_datahub.py

@@ -3,6 +3,7 @@
 import os
 import pathlib
 import unittest
+from unittest.mock import patch
 
 from returns.result import Failure, ResultE, Success
 
@@ -89,3 +90,43 @@ class TestCase:
                 else:
                     self.assertIsInstance(region_result, Success, msg=f"{region_result}")
 
+        @patch.dict(os.environ, {"MODEL": "UKV"}, clear=True)
+        def test_convert_ukv() -> None:
+
+            @dataclasses.dataclass
+            class TestCase:
+                filename: str
+                expected_coords: NWPDimensionCoordinateMap
+                should_error: bool
+
+            tests: list[TestCase] = [
+                TestCase(
+                    filename="test_MO_UKV_agl_relative-humidity_1.5_2025012112.grib",
+                    expected_coords=dataclasses.replace(
+                        MetOfficeDatahubRawRepository.model().expected_coordinates,
+                        init_time=[dt.datetime(2025, 1, 21, 12, tzinfo=dt.UTC)],
+                        variable=[Parameter.TEMPERATURE_SL],
+                        step=[0],
+                    ),
+                    should_error=False,
+                ),
+            ]
+
+            for t in tests:
+                with self.subTest(name=t.filename):
+                    # Attempt to convert the file
+                    result = MetOfficeDatahubRawRepository._convert(
+                        path=pathlib.Path(__file__).parent.absolute() / "test_gribs" / t.filename,
+                    )
+                    region_result: ResultE[dict[str, slice]] = result.do(
+                        region
+                        for das in result
+                        for da in das
+                        for region in NWPDimensionCoordinateMap.from_xarray(da).bind(
+                            t.expected_coords.determine_region,
+                        )
+                    )
+                    if t.should_error:
+                        self.assertIsInstance(region_result, Failure, msg=f"{region_result}")
+                    else:
+                        self.assertIsInstance(region_result, Success, msg=f"{region_result}")