ocf-data-sampler 0.0.53__tar.gz → 0.0.54__tar.gz

{ocf_data_sampler-0.0.53/ocf_data_sampler.egg-info → ocf_data_sampler-0.0.54}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: ocf_data_sampler
-Version: 0.0.53
+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.54/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-0.0.54/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-0.0.54/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-0.0.54/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-0.0.54/ocf_data_sampler/torch_datasets/datasets/__init__.py

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

{ocf_data_sampler-0.0.53 → ocf_data_sampler-0.0.54/ocf_data_sampler.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: ocf_data_sampler
-Version: 0.0.53
+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.53 → ocf_data_sampler-0.0.54}/ocf_data_sampler.egg-info/SOURCES.txt

@@ -35,6 +35,10 @@ ocf_data_sampler/numpy_sample/nwp.py
 ocf_data_sampler/numpy_sample/satellite.py
 ocf_data_sampler/numpy_sample/site.py
 ocf_data_sampler/numpy_sample/sun_position.py
+ocf_data_sampler/sample/__init__.py
+ocf_data_sampler/sample/base.py
+ocf_data_sampler/sample/site.py
+ocf_data_sampler/sample/uk_regional.py
 ocf_data_sampler/select/__init__.py
 ocf_data_sampler/select/dropout.py
 ocf_data_sampler/select/fill_time_periods.py
@@ -71,6 +75,9 @@ tests/select/test_find_contiguous_time_periods.py
 tests/select/test_location.py
 tests/select/test_select_spatial_slice.py
 tests/select/test_select_time_slice.py
+tests/test_sample/test_base.py
+tests/test_sample/test_site_sample.py
+tests/test_sample/test_uk_regional_sample.py
 tests/torch_datasets/conftest.py
 tests/torch_datasets/test_merge_and_fill_utils.py
 tests/torch_datasets/test_pvnet_uk_regional.py

{ocf_data_sampler-0.0.53 → ocf_data_sampler-0.0.54}/ocf_data_sampler.egg-info/requires.txt

@@ -11,7 +11,11 @@ pyproj
 pathy
 pyaml_env
 pyresample
+h5netcdf
 
 [docs]
 mkdocs>=1.2
 mkdocs-material>=8.0
+
+[plot]
+matplotlib

{ocf_data_sampler-0.0.53 → ocf_data_sampler-0.0.54}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ocf_data_sampler"
-version = "0.0.53"
+version = "0.0.54"
 license = { file = "LICENSE" }
 readme = "README.md"
 description = "Sample from weather data for renewable energy prediction"
@@ -30,7 +30,8 @@ dependencies = [ # Migration from requirements.txt
     "pyproj",
     "pathy",
     "pyaml_env",
-    "pyresample"
+    "pyresample",
+    "h5netcdf",
 ]
 
 keywords = [ # I've added some keywords, but please provide feedback if you'd like them changed!
@@ -51,6 +52,9 @@ docs = [
     "mkdocs>=1.2",
     "mkdocs-material>=8.0"
 ]
+plot = [
+    "matplotlib"
+]
 
 [project.urls]
 homepage = "https://github.com/openclimatefix"

ocf_data_sampler-0.0.54/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]))

ocf_data_sampler-0.0.54/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)

ocf_data_sampler-0.0.54/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,)

ocf_data_sampler-0.0.53/ocf_data_sampler/torch_datasets/datasets/__init__.py

@@ -1,2 +0,0 @@
-from .pvnet_uk_regional import PVNetUKRegionalDataset
-from .site import SitesDataset