ocf-data-sampler 0.0.52__py3-none-any.whl → 0.0.54__py3-none-any.whl

ocf_data_sampler/load/utils.py

@@ -40,4 +40,4 @@ def get_xr_data_array_from_xr_dataset(ds: xr.Dataset) -> xr.DataArray:
 
     datavars = list(ds.var())
     assert len(datavars) == 1, "Cannot open as xr.DataArray: dataset contains multiple variables"
-    return ds[datavars[0]]
+    return ds[datavars[0]]

ocf_data_sampler/sample/__init__.py

@@ -0,0 +1,10 @@
+from ocf_data_sampler.sample.base import SampleBase
+from ocf_data_sampler.sample.uk_regional import UKRegionalSample
+from ocf_data_sampler.sample.site import SiteSample
+
+
+__all__ = [
+    'SampleBase',
+    'UKRegionalSample',
+    'SiteSample'
+    ]

ocf_data_sampler/sample/base.py

@@ -0,0 +1,44 @@
+"""
+Base class definition - abstract
+Handling of both flat and nested structures - consideration for NWP
+"""
+
+import logging
+import numpy as np
+
+from pathlib import Path
+from typing import Any, Dict, Optional, Union
+from abc import ABC, abstractmethod
+
+logger = logging.getLogger(__name__)
+
+class SampleBase(ABC):
+    """ 
+    Abstract base class for all sample types 
+    Provides core data storage functionality
+    """
+
+    def __init__(self):
+        """ Initialise data container """
+        logger.debug("Initialising SampleBase instance")
+
+    @abstractmethod
+    def to_numpy(self) -> Dict[str, Any]:
+        """ Convert data to a numpy array representation """
+        raise NotImplementedError
+
+    @abstractmethod
+    def plot(self, **kwargs) -> None:
+        """ Abstract method for plotting """
+        raise NotImplementedError
+
+    @abstractmethod
+    def save(self, path: Union[str, Path]) -> None:
+        """ Abstract method for saving sample data """
+        raise NotImplementedError
+
+    @classmethod
+    @abstractmethod
+    def load(cls, path: Union[str, Path]) -> 'SampleBase':
+        """ Abstract class method for loading sample data """
+        raise NotImplementedError

ocf_data_sampler/sample/site.py

@@ -0,0 +1,81 @@
+""" 
+PVNet - Site sample / dataset implementation
+"""
+
+import logging
+import xarray as xr
+import numpy as np
+
+from pathlib import Path
+from typing import Dict, Any, Union
+
+from ocf_data_sampler.sample.base import SampleBase
+from ocf_data_sampler.torch_datasets.datasets.site import convert_netcdf_to_numpy_sample
+
+
+logger = logging.getLogger(__name__)
+
+
+class SiteSample(SampleBase):
+    """ Sample class specific to Site PVNet """
+
+    def __init__(self):
+        logger.debug("Initialise SiteSample instance")
+        super().__init__()
+        self._data = {}
+
+    def to_numpy(self) -> Dict[str, Any]:
+        """ Convert sample numpy arrays - netCDF conversion """
+        logger.debug("Converting site sample to numpy format")
+        
+        try:
+            if not isinstance(self._data, xr.Dataset):
+                raise TypeError("Data must be xarray Dataset")
+            
+            numpy_data = convert_netcdf_to_numpy_sample(self._data)
+
+            logger.debug("Successfully converted to numpy format")
+            return numpy_data
+            
+        except Exception as e:
+            logger.error(f"Error converting to numpy: {str(e)}")
+            raise
+
+    def save(self, path: Union[str, Path]) -> None:
+        """ Save site sample as netCDF - h5netcdf engine """
+        logger.debug(f"Saving SiteSample to {path}")
+        path = Path(path)
+        
+        if path.suffix != '.nc':
+            logger.error(f"Invalid file format - {path.suffix}")
+            raise ValueError("Only .nc format is supported")
+        
+        if not isinstance(self._data, xr.Dataset):
+            raise TypeError("Data must be xarray Dataset for saving")
+                
+        self._data.to_netcdf(
+            path, 
+            mode="w", 
+            engine="h5netcdf"
+        )
+        logger.debug(f"Successfully saved SiteSample - {path}")
+
+    @classmethod
+    def load(cls, path: str) -> None:
+        """ Load site sample from netCDF """
+        logger.debug(f"Loading SiteSample from {path}")
+        path = Path(path)
+        
+        if path.suffix != '.nc':
+            logger.error(f"Invalid file format - {path.suffix}")
+            raise ValueError("Only .nc format is supported")
+        
+        instance = cls()
+        instance._data = xr.open_dataset(path)
+        logger.debug(f"Loaded SiteSample from {path}")
+        return instance
+
+    # TO DO - placeholder for now
+    def plot(self, **kwargs) -> None:
+        """ Plot sample data - placeholder """
+        pass

ocf_data_sampler/sample/uk_regional.py

@@ -0,0 +1,118 @@
+""" 
+PVNet - UK Regional sample / dataset implementation
+"""
+
+import numpy as np
+import pandas as pd
+import torch
+import logging
+
+from typing import Dict, Any, Union, List, Optional
+from pathlib import Path
+
+from ocf_data_sampler.numpy_sample import (
+    NWPSampleKey, 
+    GSPSampleKey,
+    SatelliteSampleKey
+)
+
+from ocf_data_sampler.sample.base import SampleBase
+
+try:
+    import matplotlib.pyplot as plt
+    MATPLOTLIB_AVAILABLE = True
+except ImportError:
+    MATPLOTLIB_AVAILABLE = False
+    plt = None
+
+
+logger = logging.getLogger(__name__)
+
+
+class UKRegionalSample(SampleBase):
+    """ Sample class specific to UK Regional PVNet """
+
+    def __init__(self):
+        logger.debug("Initialise UKRegionalSample instance")
+        super().__init__()
+        self._data = {}
+
+    def to_numpy(self) -> Dict[str, Any]:
+        """ Convert sample data to numpy format """
+        logger.debug("Converting sample data to numpy format")
+        return self._data
+
+    def save(self, path: Union[str, Path]) -> None:
+        """ Save PVNet sample as .pt """
+        logger.debug(f"Saving UKRegionalSample to {path}")
+        path = Path(path)
+        
+        if path.suffix != '.pt':
+            logger.error(f"Invalid file format: {path.suffix}")
+            raise ValueError(f"Only .pt format is supported: {path.suffix}")
+        
+        torch.save(self._data, path)
+        logger.debug(f"Successfully saved UKRegionalSample to {path}")
+
+    @classmethod
+    def load(cls, path: Union[str, Path]) -> 'UKRegionalSample':
+        """ Load PVNet sample data from .pt """
+        logger.debug(f"Attempting to load UKRegionalSample from {path}")
+        path = Path(path)
+        
+        if path.suffix != '.pt':
+            logger.error(f"Invalid file format: {path.suffix}")
+            raise ValueError(f"Only .pt format is supported: {path.suffix}")
+        
+        instance = cls()
+        instance._data = torch.load(path)
+        logger.debug(f"Successfully loaded UKRegionalSample from {path}")
+        return instance
+
+    def plot(self, **kwargs) -> None:
+        """ Sample visualisation definition """
+        logger.debug("Creating UKRegionalSample visualisation")
+
+        if not MATPLOTLIB_AVAILABLE:
+            raise ImportError(
+                "Matplotlib required for plotting"
+                "Install via 'ocf_data_sampler[plot]'"
+            )
+
+        try:
+            fig, axes = plt.subplots(2, 2, figsize=(12, 8))
+            
+            if NWPSampleKey.nwp in self._data:
+                logger.debug("Plotting NWP data")
+                first_nwp = list(self._data[NWPSampleKey.nwp].values())[0]
+                if 'nwp' in first_nwp:
+                    axes[0, 1].imshow(first_nwp['nwp'][0])
+                    axes[0, 1].set_title('NWP (First Channel)')
+                    if NWPSampleKey.channel_names in first_nwp:
+                        channel_names = first_nwp[NWPSampleKey.channel_names]
+                        if len(channel_names) > 0:
+                            axes[0, 1].set_title(f'NWP: {channel_names[0]}')
+
+            if GSPSampleKey.gsp in self._data:
+                logger.debug("Plotting GSP generation data")
+                axes[0, 0].plot(self._data[GSPSampleKey.gsp])
+                axes[0, 0].set_title('GSP Generation')
+            
+            if GSPSampleKey.solar_azimuth in self._data and GSPSampleKey.solar_elevation in self._data:
+                logger.debug("Plotting solar position data")
+                axes[1, 1].plot(self._data[GSPSampleKey.solar_azimuth], label='Azimuth')
+                axes[1, 1].plot(self._data[GSPSampleKey.solar_elevation], label='Elevation')
+                axes[1, 1].set_title('Solar Position')
+                axes[1, 1].legend()
+
+            if SatelliteSampleKey.satellite_actual in self._data:
+                logger.debug("Plotting satellite data")
+                axes[1, 0].imshow(self._data[SatelliteSampleKey.satellite_actual])
+                axes[1, 0].set_title('Satellite Data')
+            
+            plt.tight_layout()
+            plt.show()
+            logger.debug("Successfully created visualisation")
+        except Exception as e:
+            logger.error(f"Error creating visualisation: {str(e)}")
+            raise

ocf_data_sampler/torch_datasets/datasets/__init__.py

@@ -1,2 +1,11 @@
 from .pvnet_uk_regional import PVNetUKRegionalDataset
-from .site import SitesDataset
+
+from .site import (
+    convert_netcdf_to_numpy_sample,
+    SitesDataset
+)
+
+__all__ = [
+    'convert_netcdf_to_numpy_sample',
+    'SitesDataset'
+]

ocf_data_sampler/torch_datasets/datasets/site.py

@@ -1,6 +1,6 @@
 """Torch dataset for sites"""
 import logging
-
+import numpy as np
 import pandas as pd
 import xarray as xr
 from typing import Tuple
@@ -421,3 +421,27 @@ def convert_to_numpy_and_combine(
     combined_sample = fill_nans_in_arrays(combined_sample)
 
     return combined_sample
+
+
+def coarsen_data(xr_data: xr.Dataset, coarsen_to_deg: float=0.1):
+    """
+    Coarsen the data to a specified resolution in degrees.
+    
+    Args:
+        xr_data: xarray dataset to coarsen
+        coarsen_to_deg: resolution to coarsen to in degrees
+    """
+
+    if "latitude" in xr_data.coords and "longitude" in xr_data.coords:
+        step = np.abs(xr_data.latitude.values[1]-xr_data.latitude.values[0])
+        step = np.round(step,4)
+        coarsen_factor = int(coarsen_to_deg/step)
+        if coarsen_factor > 1:
+            xr_data = xr_data.coarsen(
+                latitude=coarsen_factor,
+                longitude=coarsen_factor,
+                boundary="pad",
+                coord_func="min"
+            ).mean()
+        
+    return xr_data

{ocf_data_sampler-0.0.52.dist-info → ocf_data_sampler-0.0.54.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: ocf_data_sampler
-Version: 0.0.52
+Version: 0.0.54
 Summary: Sample from weather data for renewable energy prediction
 Author: James Fulton, Peter Dudfield, and the Open Climate Fix team
 Author-email: info@openclimatefix.org
@@ -49,9 +49,12 @@ Requires-Dist: pyproj
 Requires-Dist: pathy
 Requires-Dist: pyaml_env
 Requires-Dist: pyresample
+Requires-Dist: h5netcdf
 Provides-Extra: docs
 Requires-Dist: mkdocs>=1.2; extra == "docs"
 Requires-Dist: mkdocs-material>=8.0; extra == "docs"
+Provides-Extra: plot
+Requires-Dist: matplotlib; extra == "plot"
 
 # ocf-data-sampler
  

{ocf_data_sampler-0.0.52.dist-info → ocf_data_sampler-0.0.54.dist-info}/RECORD

@@ -11,7 +11,7 @@ ocf_data_sampler/load/gsp.py,sha256=Gcr1JVUOPKhFRDCSHtfPDjxx0BtyyEhXrZvGEKLPJ5I,
 ocf_data_sampler/load/load_dataset.py,sha256=Ua3RaUg4PIYJkD9BKqTfN8IWUbezbhThJGgEkd9PcaE,1587
 ocf_data_sampler/load/satellite.py,sha256=3KlA1fx4SwxdzM-jC1WRaONXO0D6m0WxORnEnwUnZrA,2967
 ocf_data_sampler/load/site.py,sha256=P83uz01WBDzoZajdOH0m8FQt4-buKDlUk19N548KqhA,1086
-ocf_data_sampler/load/utils.py,sha256=EQGvVWlGMoSOdbDYuMfVAa0v6wmAOPmHIAemdrTB5v4,1406
+ocf_data_sampler/load/utils.py,sha256=sAEkPMS9LXVCrc5pANQo97zaoEItVg9hoNj2ZWfx_Ug,1405
 ocf_data_sampler/load/nwp/__init__.py,sha256=SmcrnbygO5xtCKmGR4wtHrj-HI7nOAvnAtfuvRufBGQ,25
 ocf_data_sampler/load/nwp/nwp.py,sha256=O4QnajEZem8BvBgTcYYDBhRhgqPYuJkolHmpMRmrXEA,610
 ocf_data_sampler/load/nwp/providers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -26,6 +26,10 @@ ocf_data_sampler/numpy_sample/nwp.py,sha256=_seQNWsut3IzPsrpipqImjnaM3XNHZCy5_5b
 ocf_data_sampler/numpy_sample/satellite.py,sha256=8OaTvkPjzSjotcdKsa6BKmmlBKDBunbhDN4Pjo0Grxs,910
 ocf_data_sampler/numpy_sample/site.py,sha256=I-cAXCOF0SDdm5Hx43lFqYZ3jh61kltLQK-fc4_nNu0,1314
 ocf_data_sampler/numpy_sample/sun_position.py,sha256=UklhucCxCT6GMlAhCWL6c4cfWrdc1cWgegrYaqUoHOY,1611
+ocf_data_sampler/sample/__init__.py,sha256=02CM7E5nKkGiYbVW-kvzjNd4RaqGuHCkDChtmDBDUoA,248
+ocf_data_sampler/sample/base.py,sha256=4U78tczCRsKMDwU4HkD20nyGyYjIBSZV5neF2mT--2M,1197
+ocf_data_sampler/sample/site.py,sha256=0BvDXs0kxTjUq7kWpeoITK_uN4uE0w1IvEFXZUoKOb0,2507
+ocf_data_sampler/sample/uk_regional.py,sha256=FPaFi6qaTsi1ag42pfVKDZhopt3cDjQsF4rVI8k2qWo,4244
 ocf_data_sampler/select/__init__.py,sha256=E4AJulEbO2K-o0UlG1fgaEteuf_1ZFjHTvrotXSb4YU,332
 ocf_data_sampler/select/dropout.py,sha256=HCx5Wzk8Oh2Z9vV94Jy-ALJsHtGduwvMaQOleQXp5z0,1142
 ocf_data_sampler/select/fill_time_periods.py,sha256=iTtMjIPFYG5xtUYYedAFBLjTWWUa7t7WQ0-yksWf0-E,440
@@ -36,9 +40,9 @@ ocf_data_sampler/select/select_spatial_slice.py,sha256=WNxwur9Q5oetvogATw8-hNejD
 ocf_data_sampler/select/select_time_slice.py,sha256=9M-yvDv9K77XfEys_OIR31_aVB56sNWk3BnCnkCgcPI,4725
 ocf_data_sampler/select/spatial_slice_for_dataset.py,sha256=3tRrMBXr7s4CnClbVSIq7hpls3H4Y3qYTDwswcxCCCE,1763
 ocf_data_sampler/select/time_slice_for_dataset.py,sha256=P7cAARfDzjttGDvpKt2zuA4WkLoTmSXy_lBpI8RiA6k,4249
-ocf_data_sampler/torch_datasets/datasets/__init__.py,sha256=nJUa2KzVa84ZoM0PT2AbDz26ennmAYc7M7WJVfypPMs,85
+ocf_data_sampler/torch_datasets/datasets/__init__.py,sha256=JMfMQ6DxCWQiwm-Xwdy_b0gnGqZnORSR_SGrLM1QEe4,201
 ocf_data_sampler/torch_datasets/datasets/pvnet_uk_regional.py,sha256=xxeX4Js9LQpydehi3BS7k9psqkYGzgJuM17uTYux40M,8742
-ocf_data_sampler/torch_datasets/datasets/site.py,sha256=v7plMF_WJPkfwnJAUFf_8gXAy8SXE5Og_fgZMEm4c20,15257
+ocf_data_sampler/torch_datasets/datasets/site.py,sha256=5T8nkTMUHHFidZRuFOunYeKAqNuyZ8V7sikBoBOBwwA,16033
 ocf_data_sampler/torch_datasets/utils/merge_and_fill_utils.py,sha256=hIbekql64eXsNDFIoEc--GWxwdVWrh2qKegdOi70Bow,874
 ocf_data_sampler/torch_datasets/utils/valid_time_periods.py,sha256=Qo65qUHtle_bW5tLTYr7empHTRv-lpjvfx_6GNJj3Xg,4371
 scripts/refactor_site.py,sha256=asZ27hQ4IyXgCCUaFJqcz1ObBNcV2W3ywqHBpSXA_fc,1728
@@ -62,12 +66,15 @@ tests/select/test_find_contiguous_time_periods.py,sha256=kOga_V7er5We7ewMARXaKdM
 tests/select/test_location.py,sha256=_WZk2FPYeJ-nIfCJS6Sp_yaVEEo7m31DmMFoZzgyCts,2712
 tests/select/test_select_spatial_slice.py,sha256=7EX9b6g-pMdACQx3yefjs5do2s-Rho2UmKevV4oglsU,5147
 tests/select/test_select_time_slice.py,sha256=nYrdlmZlGEygJKiE26bADiluNPN1qt5kD4FrI2vtxUw,9686
+tests/test_sample/test_base.py,sha256=ljtB38MmscTGN6OvUgclBceNnfx6m7AN8iHYDml9XW4,2189
+tests/test_sample/test_site_sample.py,sha256=Gln-Or060cUWvA7Q7c1vsthgCttOAM2z9yBI9zUIrDw,6238
+tests/test_sample/test_uk_regional_sample.py,sha256=gkeQWC2wC757jKJz_QBmDMFQjn3R54q_tEo948yyxCY,4840
 tests/torch_datasets/conftest.py,sha256=eRCzHE7cxS4AoskExkCGFDBeqItktAYNAdkfpMoFCeE,629
 tests/torch_datasets/test_merge_and_fill_utils.py,sha256=ueA0A7gZaWEgNdsU8p3CnKuvSnlleTUjEhSw2HUUROM,1229
 tests/torch_datasets/test_pvnet_uk_regional.py,sha256=FCiFueeFqrsXe7gWguSjBz5ZeUrvyhGbGw81gaVvkHM,5087
-tests/torch_datasets/test_site.py,sha256=0gT_7k086BBnxqbvOayiUeI-vzJsYXlx3KvACC0c6lk,6114
-ocf_data_sampler-0.0.52.dist-info/LICENSE,sha256=F-Q3UFCR-BECSocV55BFDpn4YKxve9PKrm-lTt6o_Tg,1073
-ocf_data_sampler-0.0.52.dist-info/METADATA,sha256=lUeJfMdOioAdIfntynW_Ql5Azncfd32jMGKW9DPgkFc,12143
-ocf_data_sampler-0.0.52.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-ocf_data_sampler-0.0.52.dist-info/top_level.txt,sha256=Faob6N6cFdPc5eUpCTYcXgCaNhi4XLLteUL5W5ayYmg,31
-ocf_data_sampler-0.0.52.dist-info/RECORD,,
+tests/torch_datasets/test_site.py,sha256=J1ZDE5V5MRlq7EuZ1zUu-aFRGTDJIiO-ZZzkOXvDdWA,6757
+ocf_data_sampler-0.0.54.dist-info/LICENSE,sha256=F-Q3UFCR-BECSocV55BFDpn4YKxve9PKrm-lTt6o_Tg,1073
+ocf_data_sampler-0.0.54.dist-info/METADATA,sha256=o6EIqhbRzXKCy74lRYn4HS48DZyEnyLS1XgiFDh-F-g,12231
+ocf_data_sampler-0.0.54.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+ocf_data_sampler-0.0.54.dist-info/top_level.txt,sha256=Faob6N6cFdPc5eUpCTYcXgCaNhi4XLLteUL5W5ayYmg,31
+ocf_data_sampler-0.0.54.dist-info/RECORD,,

tests/test_sample/test_base.py

@@ -0,0 +1,86 @@
+"""
+Base class testing - SampleBase
+"""
+
+import pytest
+import numpy as np
+
+from pathlib import Path
+from ocf_data_sampler.sample.base import SampleBase
+
+
+class TestSample(SampleBase):
+    """
+    SampleBase for testing purposes
+    Minimal implementations - abstract methods
+    """
+
+    def __init__(self):
+        super().__init__()
+        self._data = {}
+
+    def plot(self, **kwargs):
+        """ Minimal plot implementation """
+        return None
+
+    def to_numpy(self) -> None:
+        """ Standard implementation """
+        return {key: np.array(value) for key, value in self._data.items()}
+
+    def save(self, path):
+        """ Minimal save implementation """
+        path = Path(path)
+        with open(path, 'wb') as f:
+            f.write(b'test_data')
+
+    @classmethod
+    def load(cls, path):
+        """ Minimal load implementation """
+        path = Path(path)
+        instance = cls()
+        return instance
+
+
+def test_sample_base_initialisation():
+    """ Initialisation of SampleBase subclass """
+
+    sample = TestSample()
+    assert hasattr(sample, '_data'), "Sample should have _data attribute"
+    assert sample._data == {}, "Sample should start with empty dict"
+
+
+def test_sample_base_save_load(tmp_path):
+    """ Test basic save and load functionality """
+
+    sample = TestSample()
+    sample._data['test_data'] = [1, 2, 3]
+
+    save_path = tmp_path / 'test_sample.dat'
+    sample.save(save_path)
+    assert save_path.exists()
+
+    loaded_sample = TestSample.load(save_path)
+    assert isinstance(loaded_sample, TestSample)
+
+
+def test_sample_base_abstract_methods():
+    """ Test abstract method enforcement """
+    
+    with pytest.raises(TypeError, match="Can't instantiate abstract class"):
+        SampleBase()
+
+
+def test_sample_base_to_numpy():
+    """ Test the to_numpy functionality """
+    import numpy as np
+    
+    sample = TestSample()
+    sample._data = {
+        'int_data': 42,
+        'list_data': [1, 2, 3]
+    }
+    numpy_data = sample.to_numpy()
+
+    assert isinstance(numpy_data, dict)
+    assert all(isinstance(value, np.ndarray) for value in numpy_data.values())
+    assert np.array_equal(numpy_data['list_data'], np.array([1, 2, 3]))

tests/test_sample/test_site_sample.py

@@ -0,0 +1,195 @@
+"""
+Site class testing - SiteSample
+"""
+
+import pytest
+import numpy as np
+import xarray as xr
+import pandas as pd
+
+from pathlib import Path
+from xarray import Dataset
+
+from ocf_data_sampler.sample.site import SiteSample
+
+
+@pytest.fixture
+def sample_data():
+    """ Fixture creation with sample data """
+
+    #  Time periods specified
+    init_time = pd.Timestamp("2023-01-01 00:00")
+    target_times = pd.date_range("2023-01-01 00:00", periods=4, freq="1h")
+    sat_times = pd.date_range("2023-01-01 00:00", periods=7, freq="5min")
+    site_times = pd.date_range("2023-01-01 00:00", periods=4, freq="30min")
+
+    # Defined steps for NWP data
+    steps = [(t - init_time) for t in target_times]
+    
+    # Create the sample dataset
+    return Dataset(
+        data_vars={
+            'nwp-ukv': (
+                ["nwp-ukv__target_time_utc", "nwp-ukv__channel", 
+                 "nwp-ukv__y_osgb", "nwp-ukv__x_osgb"],
+                np.random.rand(4, 1, 2, 2)
+            ),
+            'satellite': (
+                ["satellite__time_utc", "satellite__channel",
+                 "satellite__y_geostationary", "satellite__x_geostationary"],
+                np.random.rand(7, 1, 2, 2)
+            ),
+            'site': (["site__time_utc"], np.random.rand(4))
+        },
+        coords={
+            # NWP coords
+            'nwp-ukv__target_time_utc': target_times,
+            'nwp-ukv__channel': ['dswrf'],
+            'nwp-ukv__y_osgb': [0, 1],
+            'nwp-ukv__x_osgb': [0, 1],
+            'nwp-ukv__init_time_utc': init_time,
+            'nwp-ukv__step': ('nwp-ukv__target_time_utc', steps),
+            
+            # Sat coords
+            'satellite__time_utc': sat_times,
+            'satellite__channel': ['vis'],
+            'satellite__y_geostationary': [0, 1],
+            'satellite__x_geostationary': [0, 1],
+            
+            # Site coords
+            'site__time_utc': site_times,
+            'site__capacity_kwp': 1000.0,
+            'site__site_id': 1,
+            'site__longitude': -3.5,
+            'site__latitude': 51.5,
+            
+            # Site features as coords
+            'site__solar_azimuth': ('site__time_utc', np.random.rand(4)),
+            'site__solar_elevation': ('site__time_utc', np.random.rand(4)),
+            'site__date_cos': ('site__time_utc', np.random.rand(4)),
+            'site__date_sin': ('site__time_utc', np.random.rand(4)),
+            'site__time_cos': ('site__time_utc', np.random.rand(4)),
+            'site__time_sin': ('site__time_utc', np.random.rand(4))
+        }
+    )
+
+
+def test_site_sample_init():
+    """ Test initialisation """
+    sample = SiteSample()
+    assert isinstance(sample._data, dict)
+    assert len(sample._data) == 0
+
+
+def test_site_sample_with_data(sample_data):
+    """ Testing of defined sample with actual data """
+    sample = SiteSample()
+    sample._data = sample_data
+    
+    # Assert data structure
+    assert isinstance(sample._data, Dataset)
+    
+    # Assert dimensions / shapes
+    expected_dims = {
+        "satellite__x_geostationary",
+        "site__time_utc",
+        "nwp-ukv__target_time_utc",
+        "nwp-ukv__x_osgb",
+        "satellite__channel",
+        "satellite__y_geostationary",
+        "satellite__time_utc",
+        "nwp-ukv__channel",
+        "nwp-ukv__y_osgb",
+    }
+    assert set(sample._data.dims) == expected_dims    
+    assert sample._data["satellite"].values.shape == (7, 1, 2, 2)
+    assert sample._data["nwp-ukv"].values.shape == (4, 1, 2, 2)
+    assert sample._data["site"].values.shape == (4,)
+
+
+def test_save_load(tmp_path, sample_data):
+    """ Save and load functionality """
+    sample = SiteSample()
+    sample._data = sample_data    
+    filepath = tmp_path / "test_sample.nc"
+    sample.save(filepath)
+    
+    # Assert file exists and has content
+    assert filepath.exists()
+    assert filepath.stat().st_size > 0
+    
+    # Load and verify
+    loaded = SiteSample.load(filepath)
+    assert isinstance(loaded, SiteSample)
+    assert isinstance(loaded._data, Dataset)
+    
+    # Compare original / loaded data
+    xr.testing.assert_identical(sample._data, loaded._data)
+
+
+def test_invalid_save_format(sample_data):
+    """ Saving with invalid format """
+    sample = SiteSample()
+    sample._data = sample_data
+    with pytest.raises(ValueError, match="Only .nc format is supported"):
+        sample.save("invalid.txt")
+
+
+def test_invalid_load_format():
+    """ Loading with invalid format """
+    with pytest.raises(ValueError, match="Only .nc format is supported"):
+        SiteSample.load("invalid.txt")
+
+
+def test_invalid_data_type():
+    """ Handling of invalid data types """
+    sample = SiteSample()
+    sample._data = {"invalid": "data"}
+    
+    with pytest.raises(TypeError, match="Data must be xarray Dataset"):
+        sample.to_numpy()
+    
+    with pytest.raises(TypeError, match="Data must be xarray Dataset for saving"):
+        sample.save("test.nc")
+
+
+def test_to_numpy(sample_data):
+    """ To numpy conversion """
+    sample = SiteSample()
+    sample._data = sample_data
+    numpy_data = sample.to_numpy()
+    
+    # Assert structure
+    assert isinstance(numpy_data, dict)
+    assert 'site' in numpy_data
+    assert 'nwp' in numpy_data
+    
+    # Check site - numpy array instead of dict
+    site_data = numpy_data['site']
+    assert isinstance(site_data, np.ndarray)
+    assert site_data.ndim == 1
+    assert len(site_data) == 4
+    assert np.all(site_data >= 0) and np.all(site_data <= 1)
+    
+    # Check NWP
+    assert 'ukv' in numpy_data['nwp']
+    nwp_data = numpy_data['nwp']['ukv']
+    assert 'nwp' in nwp_data
+    assert nwp_data['nwp'].shape == (4, 1, 2, 2)
+
+
+def test_data_consistency(sample_data):
+    """ Consistency of data across operations """
+    sample = SiteSample()
+    sample._data = sample_data    
+    numpy_data = sample.to_numpy()
+    
+    # Assert components remain consistent after conversion above
+    assert numpy_data['nwp']['ukv']['nwp'].shape == (4, 1, 2, 2)
+    assert 'site' in numpy_data
+    
+    # Update site data checks to expect numpy array
+    assert isinstance(numpy_data['site'], np.ndarray)
+    assert numpy_data['site'].shape == (4,)
+    assert np.all(numpy_data['site'] >= 0)
+    assert np.all(numpy_data['site'] <= 1)

tests/test_sample/test_uk_regional_sample.py

@@ -0,0 +1,163 @@
+"""
+UK Regional class testing - UKRegionalSample
+"""
+
+import pytest
+import numpy as np
+import torch
+import tempfile
+
+from ocf_data_sampler.numpy_sample import (
+    GSPSampleKey,
+    SatelliteSampleKey,
+    NWPSampleKey
+)
+
+from ocf_data_sampler.sample.uk_regional import UKRegionalSample
+
+
+# Fixture define
+@pytest.fixture
+def pvnet_config_filename(tmp_path):
+    """ Minimal config file - testing """
+    config_content = """
+    input_data:
+        gsp:
+            zarr_path: ""
+            time_resolution_minutes: 30
+            interval_start_minutes: -180
+            interval_end_minutes: 0
+        nwp:
+            ukv:
+                zarr_path: ""
+                image_size_pixels_height: 64
+                image_size_pixels_width: 64
+                time_resolution_minutes: 60
+                interval_start_minutes: -180
+                interval_end_minutes: 0
+                channels: ["t", "dswrf"]
+                provider: "ukv"
+        satellite:
+            zarr_path: ""
+            image_size_pixels_height: 64
+            image_size_pixels_width: 64
+            time_resolution_minutes: 30
+            interval_start_minutes: -180
+            interval_end_minutes: 0
+            channels: ["HRV"]
+    """
+    config_file = tmp_path / "test_config.yaml"
+    config_file.write_text(config_content)
+    return str(config_file)
+
+
+def create_test_data():
+    """ Synthetic data generation """
+
+    # Field / spatial coordinates
+    nwp_data = {
+        'nwp': np.random.rand(4, 1, 2, 2),
+        'x': np.array([1, 2]),
+        'y': np.array([1, 2]),
+        NWPSampleKey.channel_names: ['test_channel']
+    }
+    
+    return {
+        'nwp': {
+            'ukv': nwp_data
+        },
+        GSPSampleKey.gsp: np.random.rand(7),
+        SatelliteSampleKey.satellite_actual: np.random.rand(7, 1, 2, 2),
+        GSPSampleKey.solar_azimuth: np.random.rand(7),
+        GSPSampleKey.solar_elevation: np.random.rand(7)
+    }
+
+
+# UKRegionalSample testing
+def test_sample_init():
+    """ Initialisation """
+    sample = UKRegionalSample()
+    assert hasattr(sample, '_data'), "Sample should have _data attribute"
+    assert isinstance(sample._data, dict)
+    assert len(sample._data) == 0
+
+
+def test_sample_save_load():
+   sample = UKRegionalSample()
+   sample._data = create_test_data()
+   
+   with tempfile.NamedTemporaryFile(suffix='.pt') as tf:
+       sample.save(tf.name)
+       loaded = UKRegionalSample.load(tf.name)
+       
+       assert set(loaded._data.keys()) == set(sample._data.keys())
+       assert isinstance(loaded._data['nwp'], dict)
+       assert 'ukv' in loaded._data['nwp']
+
+       assert loaded._data[GSPSampleKey.gsp].shape == (7,)
+       assert loaded._data[SatelliteSampleKey.satellite_actual].shape == (7, 1, 2, 2) 
+       assert loaded._data[GSPSampleKey.solar_azimuth].shape == (7,)
+       assert loaded._data[GSPSampleKey.solar_elevation].shape == (7,)
+
+       np.testing.assert_array_almost_equal(
+           loaded._data[GSPSampleKey.gsp], 
+           sample._data[GSPSampleKey.gsp]
+       )
+
+
+def test_save_unsupported_format():
+   """ Test saving - unsupported file format """
+   sample = UKRegionalSample()
+   sample._data = create_test_data()
+  
+   with tempfile.NamedTemporaryFile(suffix='.npz') as tf:
+       with pytest.raises(ValueError, match="Only .pt format is supported"):
+           sample.save(tf.name)
+
+
+def test_load_unsupported_format():
+    """ Test loading - unsupported file format """
+
+    with tempfile.NamedTemporaryFile(suffix='.npz') as tf:
+        with pytest.raises(ValueError, match="Only .pt format is supported"):
+            UKRegionalSample.load(tf.name)
+
+
+def test_load_corrupted_file():
+    """ Test loading - corrupted / empty file """
+
+    with tempfile.NamedTemporaryFile(suffix='.pt') as tf:
+        with open(tf.name, 'wb') as f:
+            f.write(b'corrupted data')
+        
+        with pytest.raises(Exception):
+            UKRegionalSample.load(tf.name)
+
+
+def test_to_numpy():
+    """ To numpy conversion check """
+    sample = UKRegionalSample()
+    sample._data = {
+        'nwp': {
+            'ukv': {
+                'nwp': np.random.rand(4, 1, 2, 2),
+                'x': np.array([1, 2]),
+                'y': np.array([1, 2])
+            }
+        },
+        GSPSampleKey.gsp: np.random.rand(7),
+        SatelliteSampleKey.satellite_actual: np.random.rand(7, 1, 2, 2),
+        GSPSampleKey.solar_azimuth: np.random.rand(7),
+        GSPSampleKey.solar_elevation: np.random.rand(7)
+    }
+    
+    numpy_data = sample.to_numpy()
+    
+    # Check returned data matches
+    assert numpy_data == sample._data
+    assert len(numpy_data) == len(sample._data)
+    
+    # Assert specific keys and types
+    assert 'nwp' in numpy_data
+    assert isinstance(numpy_data['nwp']['ukv']['nwp'], np.ndarray)
+    assert numpy_data[GSPSampleKey.gsp].shape == (7,)

tests/torch_datasets/test_site.py

@@ -1,7 +1,8 @@
 import pandas as pd
 import numpy as np
-from ocf_data_sampler.torch_datasets.datasets.site import SitesDataset, convert_from_dataset_to_dict_datasets
+from ocf_data_sampler.torch_datasets.datasets.site import SitesDataset, convert_from_dataset_to_dict_datasets, coarsen_data
 from xarray import Dataset, DataArray
+import xarray as xr
 
 from torch.utils.data import DataLoader
 
@@ -43,7 +44,6 @@ def test_site(site_config_filename):
 
     expected_data_vars = {"nwp-ukv", "satellite", "site"}
 
-    import xarray as xr
 
     sample.to_netcdf("sample.nc")
     sample = xr.open_dataset("sample.nc")
@@ -198,3 +198,18 @@ def test_process_and_combine_site_sample_dict(site_config_filename):
     assert nwp_result.shape == (4, 1, 2, 2), f"Unexpected shape for nwp-ukv : {nwp_result.shape}"
     site_result = result["site"]
     assert site_result.shape == (197,), f"Unexpected shape for site: {site_result.shape}"
+
+
+def test_potentially_coarsen(ds_nwp_ecmwf):
+    """Test potentially_coarsen function with ECMWF_UK data."""
+    nwp_data = ds_nwp_ecmwf
+    assert nwp_data.ECMWF_UK.shape[3:] == (15, 12)  # Check initial shape (lon, lat)
+
+    data = coarsen_data(xr_data=nwp_data, coarsen_to_deg=2)
+    assert data.ECMWF_UK.shape[3:] == (8, 6)  # Coarsen to every 2 degrees
+
+    data = coarsen_data(xr_data=nwp_data, coarsen_to_deg=3)
+    assert data.ECMWF_UK.shape[3:] == (5, 4)  # Coarsen to every 3 degrees
+
+    data = coarsen_data(xr_data=nwp_data, coarsen_to_deg=1)
+    assert data.ECMWF_UK.shape[3:] == (15, 12)  # No coarsening (same shape)