ocf-data-sampler 0.1.9__tar.gz → 0.1.11__tar.gz

{ocf_data_sampler-0.1.9/ocf_data_sampler.egg-info → ocf_data_sampler-0.1.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: ocf_data_sampler
-Version: 0.1.9
+Version: 0.1.11
 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

{ocf_data_sampler-0.1.9 → ocf_data_sampler-0.1.11}/ocf_data_sampler/config/model.py

@@ -49,31 +49,34 @@ class TimeWindowMixin(Base):
         ...,
         description="Data interval ends at `t0 + interval_end_minutes`",
     )
-    
+
     @model_validator(mode='after')
-    def check_interval_range(cls, values):
-        if values.interval_start_minutes > values.interval_end_minutes:
-            raise ValueError('interval_start_minutes must be <= interval_end_minutes')
+    def validate_intervals(cls, values):
+        start = values.interval_start_minutes
+        end = values.interval_end_minutes
+        resolution = values.time_resolution_minutes
+        if start > end:
+            raise ValueError(
+                f"interval_start_minutes ({start}) must be <= interval_end_minutes ({end})"
+            )
+        if (start % resolution != 0):
+            raise ValueError(
+                f"interval_start_minutes ({start}) must be divisible "
+                f"by time_resolution_minutes ({resolution})"
+            )
+        if (end % resolution != 0):
+            raise ValueError(
+                f"interval_end_minutes ({end}) must be divisible "
+                f"by time_resolution_minutes ({resolution})"
+            )
         return values
 
-    @field_validator("interval_start_minutes")
-    def interval_start_minutes_divide_by_time_resolution(cls, v: int, info: ValidationInfo) -> int:
-        if v % info.data["time_resolution_minutes"] != 0:
-            raise ValueError("interval_start_minutes must be divisible by time_resolution_minutes")
-        return v
-
-    @field_validator("interval_end_minutes")
-    def interval_end_minutes_divide_by_time_resolution(cls, v: int, info: ValidationInfo) -> int:
-        if v % info.data["time_resolution_minutes"] != 0:
-            raise ValueError("interval_end_minutes must be divisible by time_resolution_minutes")
-        return v
-
 
 class DropoutMixin(Base):
     """Mixin class, to add dropout minutes"""
 
-    dropout_timedeltas_minutes: Optional[List[int]] = Field(
-        default=None,
+    dropout_timedeltas_minutes: List[int] = Field(
+        default=[],
         description="List of possible minutes before t0 where data availability may start. Must be "
         "negative or zero.",
     )
@@ -88,18 +91,17 @@ class DropoutMixin(Base):
     @field_validator("dropout_timedeltas_minutes")
     def dropout_timedeltas_minutes_negative(cls, v: List[int]) -> List[int]:
         """Validate 'dropout_timedeltas_minutes'"""
-        if v is not None:
-            for m in v:
-                assert m <= 0, "Dropout timedeltas must be negative"
+        for m in v:
+            assert m <= 0, "Dropout timedeltas must be negative"
         return v
 
     @model_validator(mode="after")
     def dropout_instructions_consistent(self) -> Self:
         if self.dropout_fraction == 0:
-            if self.dropout_timedeltas_minutes is not None:
+            if self.dropout_timedeltas_minutes != []:
                 raise ValueError("To use dropout timedeltas dropout fraction should be > 0")
         else:
-            if self.dropout_timedeltas_minutes is None:
+            if self.dropout_timedeltas_minutes == []:
                 raise ValueError("To dropout fraction > 0 requires a list of dropout timedeltas")
         return self
 

{ocf_data_sampler-0.1.9 → ocf_data_sampler-0.1.11}/ocf_data_sampler/load/satellite.py

@@ -1,7 +1,5 @@
 """Satellite loader"""
 
-import subprocess
-
 import xarray as xr
 from ocf_data_sampler.load.utils import (
     check_time_unique_increasing,
@@ -10,63 +8,59 @@ from ocf_data_sampler.load.utils import (
 )
 
 
-def _get_single_sat_data(zarr_path: str) -> xr.Dataset:
-    """Helper function to open a Zarr from either a local or GCP path.
+def get_single_sat_data(zarr_path: str) -> xr.Dataset:
+    """Helper function to open a zarr from either a local or GCP path
 
     Args:
-        zarr_path: Path to a Zarr file. Wildcards (*) are supported **only** for local paths. 
-                   GCS paths (gs://) **do not support** wildcards.
+        zarr_path: path to a zarr file. Wildcards (*) are supported only for local paths
+                   GCS paths (gs://) do not support wildcards
 
     Returns:
-        An xarray Dataset containing satellite data.
+        An xarray Dataset containing satellite data
 
     Raises:
-        ValueError: If a wildcard (*) is used in a GCS (gs://) path.
+        ValueError: If a wildcard (*) is used in a GCS (gs://) path
     """
 
-    # These kwargs are used if the path contains "*"
-    openmf_kwargs = dict(
-        engine="zarr",
-        concat_dim="time",
-        combine="nested",
-        chunks="auto",
-        join="override",
-    )
-
     # Raise an error if a wildcard is used in a GCP path
     if "gs://" in str(zarr_path) and "*" in str(zarr_path):
-        raise ValueError("Wildcard (*) paths are not supported for GCP (gs://) URLs.")
+        raise ValueError("Wildcard (*) paths are not supported for GCP (gs://) URLs")
 
     # Handle multi-file dataset for local paths
     if "*" in str(zarr_path):
-        ds = xr.open_mfdataset(zarr_path, **openmf_kwargs)
+        ds = xr.open_mfdataset(
+            zarr_path,
+            engine="zarr",
+            concat_dim="time",
+            combine="nested",
+            chunks="auto",
+            join="override",
+        )
+        check_time_unique_increasing(ds.time)
     else:
         ds = xr.open_dataset(zarr_path, engine="zarr", chunks="auto")
 
-    # Ensure time is unique and sorted
-    ds = ds.drop_duplicates("time").sortby("time")
-
     return ds
 
 
 def open_sat_data(zarr_path: str | list[str]) -> xr.DataArray:
-    """Lazily opens the Zarr store.
+    """Lazily opens the zarr store
 
     Args:
-      zarr_path: Cloud URL or local path pattern, or list of these. If GCS URL, it must start with
-          'gs://'.
+      zarr_path: Cloud URL or local path pattern, or list of these. If GCS URL, 
+                 it must start with 'gs://'
     """
 
     # Open the data
     if isinstance(zarr_path, (list, tuple)):
         ds = xr.combine_nested(
-            [_get_single_sat_data(path) for path in zarr_path],
+            [get_single_sat_data(path) for path in zarr_path],
             concat_dim="time",
             combine_attrs="override",
             join="override",
         )
     else:
-        ds = _get_single_sat_data(zarr_path)
+        ds = get_single_sat_data(zarr_path)
 
     ds = ds.rename(
         {
@@ -76,9 +70,7 @@ def open_sat_data(zarr_path: str | list[str]) -> xr.DataArray:
     )
 
     check_time_unique_increasing(ds.time_utc)
-
     ds = make_spatial_coords_increasing(ds, x_coord="x_geostationary", y_coord="y_geostationary")
-    
     ds = ds.transpose("time_utc", "channel", "x_geostationary", "y_geostationary")
     
     # TODO: should we control the dtype of the DataArray?

{ocf_data_sampler-0.1.9 → ocf_data_sampler-0.1.11}/ocf_data_sampler/load/site.py

@@ -20,7 +20,7 @@ def open_site(generation_file_path: str, metadata_file_path: str) -> xr.DataArra
 
     assert metadata_df.index.is_unique
 
-    # Ensure metadata aligns with the site_id dimension in data_ds
+    # Ensure metadata aligns with the site_id dimension in generation_ds
     metadata_df = metadata_df.reindex(generation_ds.site_id.values)
 
     # Assign coordinates to the Dataset using the aligned metadata

{ocf_data_sampler-0.1.9 → ocf_data_sampler-0.1.11}/ocf_data_sampler/numpy_sample/gsp.py

@@ -18,9 +18,13 @@ class GSPSampleKey:
 
 
 def convert_gsp_to_numpy_sample(da: xr.DataArray, t0_idx: int | None = None) -> dict:
-    """Convert from Xarray to NumpySample"""
+    """Convert from Xarray to NumpySample
+    
+    Args:
+        da: Xarray DataArray containing GSP data
+        t0_idx: Index of the t0 timestamp in the time dimension of the GSP data
+    """
 
-   # Extract values from the DataArray
     sample = {
         GSPSampleKey.gsp: da.values,
         GSPSampleKey.nominal_capacity_mwp: da.isel(time_utc=0)["nominal_capacity_mwp"].values,

{ocf_data_sampler-0.1.9 → ocf_data_sampler-0.1.11}/ocf_data_sampler/numpy_sample/nwp.py

@@ -12,30 +12,24 @@ class NWPSampleKey:
     step = 'nwp_step'
     target_time_utc = 'nwp_target_time_utc'
     t0_idx = 'nwp_t0_idx'
-    y_osgb = 'nwp_y_osgb'
-    x_osgb = 'nwp_x_osgb'
-
 
 
 def convert_nwp_to_numpy_sample(da: xr.DataArray, t0_idx: int | None = None) -> dict:
-    """Convert from Xarray to NWP NumpySample"""
+    """Convert from Xarray to NWP NumpySample
+    
+    Args:
+        da: Xarray DataArray containing NWP data
+        t0_idx: Index of the t0 timestamp in the time dimension of the NWP
+    """
     
-    # Create example and add t if available
     sample = {
         NWPSampleKey.nwp: da.values,
         NWPSampleKey.channel_names: da.channel.values,
         NWPSampleKey.init_time_utc: da.init_time_utc.values.astype(float),
         NWPSampleKey.step: (da.step.values / pd.Timedelta("1h")).astype(int),
+        NWPSampleKey.target_time_utc: da.target_time_utc.values.astype(float),
     }
 
-    if "target_time_utc" in da.coords:
-        sample[NWPSampleKey.target_time_utc] = da.target_time_utc.values.astype(float)
-
-    # TODO: Do we need this at all? Especially since it is only present in UKV data
-    for sample_key, dataset_key in ((NWPSampleKey.y_osgb, "y_osgb"),(NWPSampleKey.x_osgb, "x_osgb"),):
-        if dataset_key in da.coords:
-            sample[sample_key] = da[dataset_key].values
-
     if t0_idx is not None:
         sample[NWPSampleKey.t0_idx] = t0_idx
         

{ocf_data_sampler-0.1.9 → ocf_data_sampler-0.1.11}/ocf_data_sampler/numpy_sample/satellite.py

@@ -1,4 +1,5 @@
 """Convert Satellite to NumpySample"""
+
 import xarray as xr
 
 
@@ -12,19 +13,21 @@ class SatelliteSampleKey:
 
 
 def convert_satellite_to_numpy_sample(da: xr.DataArray, t0_idx: int | None = None) -> dict:
-    """Convert from Xarray to NumpySample"""
+    """Convert from Xarray to NumpySample
+    
+    Args:
+        da: xarray DataArray containing satellite data
+        t0_idx: Index of the t0 timestamp in the time dimension of the satellite data
+    """
     sample = {
         SatelliteSampleKey.satellite_actual: da.values,
         SatelliteSampleKey.time_utc: da.time_utc.values.astype(float),
+        SatelliteSampleKey.x_geostationary: da.x_geostationary.values,
+        SatelliteSampleKey.y_geostationary: da.y_geostationary.values,
     }
 
-    for sample_key, dataset_key in (
-         (SatelliteSampleKey.x_geostationary, "x_geostationary"),
-        (SatelliteSampleKey.y_geostationary, "y_geostationary"),
-    ):
-        sample[sample_key] = da[dataset_key].values
-
     if t0_idx is not None:
         sample[SatelliteSampleKey.t0_idx] = t0_idx
 
-    return sample
+    return sample
+    

{ocf_data_sampler-0.1.9 → ocf_data_sampler-0.1.11}/ocf_data_sampler/numpy_sample/site.py

@@ -18,9 +18,13 @@ class SiteSampleKey:
     time_cos = "site_time_cos"
 
 def convert_site_to_numpy_sample(da: xr.DataArray, t0_idx: int | None = None) -> dict:
-    """Convert from Xarray to NumpySample"""
+    """Convert from Xarray to NumpySample
+    
+    Args:
+        da: xarray DataArray containing site data
+        t0_idx: Index of the t0 timestamp in the time dimension of the site data
+    """
 
-    # Extract values from the DataArray
     sample = {
         SiteSampleKey.generation: da.values,
         SiteSampleKey.capacity_kwp: da.isel(time_utc=0)["capacity_kwp"].values,

{ocf_data_sampler-0.1.9 → ocf_data_sampler-0.1.11}/ocf_data_sampler/numpy_sample/sun_position.py

@@ -27,16 +27,15 @@ def calculate_azimuth_and_elevation(
         latitude=lat,
         method='nrel_numpy'
     )
-    azimuth = solpos["azimuth"].values
-    elevation = solpos["elevation"].values
-    return azimuth, elevation
+
+    return solpos["azimuth"].values, solpos["elevation"].values
 
 
 def make_sun_position_numpy_sample(
-        datetimes: pd.DatetimeIndex, 
-        lon: float, 
-        lat: float, 
-        key_prefix: str = "gsp"
+    datetimes: pd.DatetimeIndex, 
+    lon: float, 
+    lat: float, 
+    key_prefix: str = "gsp"
 ) -> dict:
     """Creates NumpySample with standardized solar coordinates
 
@@ -44,22 +43,22 @@ def make_sun_position_numpy_sample(
         datetimes: The datetimes to calculate solar angles for
         lon: The longitude
         lat: The latitude
+        key_prefix: The prefix to add to the keys in the NumpySample
     """
     
     azimuth, elevation = calculate_azimuth_and_elevation(datetimes, lon, lat)
 
     # Normalise
-
     # Azimuth is in range [0, 360] degrees
     azimuth = azimuth / 360
 
     # Elevation is in range [-90, 90] degrees
     elevation = elevation / 180 + 0.5
-    
+
     # Make NumpySample
     sun_numpy_sample = {
         key_prefix + "_solar_azimuth": azimuth,
         key_prefix + "_solar_elevation": elevation,
     }
 
-    return sun_numpy_sample
+    return sun_numpy_sample

{ocf_data_sampler-0.1.9 → ocf_data_sampler-0.1.11}/ocf_data_sampler/sample/__init__.py

@@ -1,10 +1,3 @@
 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.1.11/ocf_data_sampler/sample/base.py

@@ -0,0 +1,79 @@
+""" Base class for handling flat/nested data structures with NWP consideration """
+
+import numpy as np
+import torch
+
+from typing import TypeAlias
+from abc import ABC, abstractmethod
+
+
+NumpySample: TypeAlias = dict[str, np.ndarray | dict[str, np.ndarray]]
+NumpyBatch: TypeAlias = dict[str, np.ndarray | dict[str, np.ndarray]]
+TensorBatch: TypeAlias = dict[str, torch.Tensor | dict[str, torch.Tensor]]
+
+
+class SampleBase(ABC):
+    """ 
+    Abstract base class for all sample types 
+    Provides core data storage functionality
+    """
+
+    @abstractmethod
+    def to_numpy(self) -> NumpySample:
+        """Convert sample data to numpy format"""
+        raise NotImplementedError
+
+    @abstractmethod
+    def plot(self) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def save(self, path: str) -> None:
+        raise NotImplementedError
+
+    @classmethod
+    @abstractmethod
+    def load(cls, path: str) -> 'SampleBase':
+        raise NotImplementedError
+
+
+def batch_to_tensor(batch: NumpyBatch) -> TensorBatch:
+    """
+    Recursively converts numpy arrays in nested dict to torch tensors
+    Args:
+        batch: NumpyBatch with data in numpy arrays
+    Returns:
+        TensorBatch with data in torch tensors
+    """
+
+    for k, v in batch.items():
+        if isinstance(v, dict):
+            batch[k] = batch_to_tensor(v)
+        elif isinstance(v, np.ndarray):
+            if v.dtype == np.bool_:
+                batch[k] = torch.tensor(v, dtype=torch.bool)
+            elif np.issubdtype(v.dtype, np.number):
+                batch[k] = torch.as_tensor(v)
+    return batch
+
+
+def copy_batch_to_device(batch: TensorBatch, device: torch.device) -> TensorBatch:
+    """Recursively copies tensors in nested dict to specified device
+
+    Args:
+        batch: Nested dict with tensors to move
+        device: Device to move tensors to
+    
+    Returns:
+        A dict with tensors moved to the new device
+    """
+    batch_copy = {}
+
+    for k, v in batch.items():
+        if isinstance(v, dict):
+            batch_copy[k] = copy_batch_to_device(v, device)  
+        elif isinstance(v, torch.Tensor):
+            batch_copy[k] = v.to(device)
+        else:
+            batch_copy[k] = v
+    return batch_copy

ocf_data_sampler-0.1.11/ocf_data_sampler/sample/site.py

@@ -0,0 +1,44 @@
+"""PVNet Site sample implementation for netCDF data handling and conversion"""
+
+import xarray as xr
+
+from typing_extensions import override
+
+from ocf_data_sampler.sample.base import SampleBase, NumpySample
+from ocf_data_sampler.torch_datasets.datasets.site import convert_netcdf_to_numpy_sample
+
+
+class SiteSample(SampleBase):
+    """Handles PVNet site specific netCDF operations"""
+
+    def __init__(self, data: xr.Dataset):
+        
+        if not isinstance(data, xr.Dataset):
+            raise TypeError(f"Data must be xarray Dataset - Found type {type(data)}")
+        
+        self._data = data
+
+    @override
+    def to_numpy(self) -> NumpySample:                    
+        return convert_netcdf_to_numpy_sample(self._data)
+
+    def save(self, path: str) -> None:
+        """Save site sample data as netCDF
+        
+        Args:
+            path: Path to save the netCDF file
+        """
+        self._data.to_netcdf(path, mode="w", engine="h5netcdf")
+
+    @classmethod
+    def load(cls, path: str) -> 'SiteSample':
+        """Load site sample data from netCDF
+        
+        Args:
+            path: Path to load the netCDF file from
+        """
+        return cls(xr.open_dataset(path))
+
+    # TODO - placeholder for now
+    def plot(self) -> None:
+        raise NotImplementedError("Plotting not yet implemented for SiteSample")

ocf_data_sampler-0.1.11/ocf_data_sampler/sample/uk_regional.py

@@ -0,0 +1,75 @@
+"""PVNet UK Regional sample implementation for dataset handling and visualisation"""
+
+from typing_extensions import override
+
+import torch
+
+from ocf_data_sampler.sample.base import SampleBase, NumpySample
+from ocf_data_sampler.numpy_sample import (
+    NWPSampleKey, 
+    GSPSampleKey,
+    SatelliteSampleKey
+)
+
+
+class UKRegionalSample(SampleBase):
+    """Handles UK Regional PVNet data operations"""
+
+    def __init__(self, data: NumpySample):
+        self._data = data
+
+    @override
+    def to_numpy(self) -> NumpySample:
+        return self._data
+
+    def save(self, path: str) -> None:
+        """Save PVNet sample as pickle format using torch.save
+        
+        Args:
+            path: Path to save the sample data to
+        """        
+        torch.save(self._data, path)
+
+    @classmethod
+    def load(cls, path: str) -> 'UKRegionalSample':
+        """Load PVNet sample data from .pt format
+        
+        Args:
+            path: Path to load the sample data from
+        """
+        # TODO: We should move away from using torch.load(..., weights_only=False)
+        return cls(torch.load(path, weights_only=False))
+
+    def plot(self) -> None:
+        """Creates visualisations for NWP, GSP, solar position, and satellite data"""
+        from matplotlib import pyplot as plt
+
+        fig, axes = plt.subplots(2, 2, figsize=(12, 8))
+        
+        if NWPSampleKey.nwp in self._data:
+            first_nwp = list(self._data[NWPSampleKey.nwp].values())[0]
+            if 'nwp' in first_nwp:
+                axes[0, 1].imshow(first_nwp['nwp'][0])
+                title = 'NWP (First Channel)'
+                if NWPSampleKey.channel_names in first_nwp:
+                    channel_names = first_nwp[NWPSampleKey.channel_names]
+                    if channel_names:
+                        title = f'NWP: {channel_names[0]}'
+                axes[0, 1].set_title(title)
+
+        if GSPSampleKey.gsp in self._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:
+            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:
+            axes[1, 0].imshow(self._data[SatelliteSampleKey.satellite_actual])
+            axes[1, 0].set_title('Satellite Data')
+        
+        plt.tight_layout()
+        plt.show()

ocf_data_sampler-0.1.11/ocf_data_sampler/select/dropout.py

@@ -0,0 +1,52 @@
+"""Functions for simulating dropout in time series data 
+
+This is used for the following types of data: GSP, Satellite and Site
+This is not used for NWP
+"""
+import numpy as np
+import pandas as pd
+import xarray as xr
+
+
+def draw_dropout_time(
+    t0: pd.Timestamp,
+    dropout_timedeltas: list[pd.Timedelta],
+    dropout_frac: float,
+) -> pd.Timestamp:
+    """Randomly pick a dropout time from a list of timedeltas
+    
+    Args:
+        t0: The forecast init-time
+        dropout_timedeltas: List of timedeltas relative to t0 to pick from
+        dropout_frac: Probability that dropout will be applied. This should be between 0 and 1 
+            inclusive
+    """
+
+    if dropout_frac>0:
+        assert len(dropout_timedeltas) > 0, "To apply dropout dropout_timedeltas must be provided"
+
+    for t in dropout_timedeltas:
+        assert t <= pd.Timedelta("0min"), "Dropout timedeltas must be negative"
+
+    assert 0 <= dropout_frac <= 1
+
+    if (len(dropout_timedeltas) == 0) or (np.random.uniform() >= dropout_frac):
+        dropout_time = t0
+    else:
+        dropout_time = t0 + np.random.choice(dropout_timedeltas)
+
+    return dropout_time
+
+
+def apply_dropout_time(
+    ds: xr.DataArray,
+    dropout_time: pd.Timestamp,
+ ) -> xr.DataArray:
+    """Apply dropout time to the data
+    
+    Args:
+        ds: Xarray DataArray with 'time_utc' coordiante 
+        dropout_time: Time after which data is set to NaN
+    """
+    # This replaces the times after the dropout with NaNs
+    return ds.where(ds.time_utc <= dropout_time)

{ocf_data_sampler-0.1.9 → ocf_data_sampler-0.1.11}/ocf_data_sampler/select/fill_time_periods.py

@@ -1,10 +1,12 @@
-"""fill time periods"""
+"""Fill time periods between start and end dates at specified frequency"""
 
 import pandas as pd
 import numpy as np
 
 
 def fill_time_periods(time_periods: pd.DataFrame, freq: pd.Timedelta) -> pd.DatetimeIndex:
+    """Generate DatetimeIndex for all timestamps between start and end dates"""
+    
     start_dts = pd.to_datetime(time_periods["start_dt"].values).ceil(freq)
     end_dts = pd.to_datetime(time_periods["end_dt"].values)
     date_ranges = [pd.date_range(start_dt, end_dt, freq=freq) for start_dt, end_dt in zip(start_dts, end_dts)]

{ocf_data_sampler-0.1.9 → ocf_data_sampler-0.1.11}/ocf_data_sampler/select/find_contiguous_time_periods.py

@@ -5,7 +5,6 @@ import pandas as pd
 from ocf_data_sampler.load.utils import check_time_unique_increasing
 
 
-
 def find_contiguous_time_periods(
     datetimes: pd.DatetimeIndex,
     min_seq_length: int,

{ocf_data_sampler-0.1.9 → ocf_data_sampler-0.1.11}/ocf_data_sampler/torch_datasets/datasets/pvnet_uk.py

@@ -186,9 +186,8 @@ class PVNetUKRegionalDataset(Dataset):
             gsp_ids: List of GSP IDs to create samples for. Defaults to all
         """
         
-        config = load_yaml_configuration(config_filename)
-
-        # Validate channels for NWP and satellite data
+        # config = load_yaml_configuration(config_filename)
+        config: Configuration = load_yaml_configuration(config_filename)
         validate_nwp_channels(config)
         validate_satellite_channels(config)