ocf-data-sampler 0.5.9__tar.gz → 0.5.11__tar.gz

{ocf_data_sampler-0.5.9 → ocf_data_sampler-0.5.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ocf-data-sampler
-Version: 0.5.9
+Version: 0.5.11
 Author: James Fulton, Peter Dudfield
 Author-email: Open Climate Fix team <info@openclimatefix.org>
 License: MIT License

{ocf_data_sampler-0.5.9 → ocf_data_sampler-0.5.11}/ocf_data_sampler/load/gsp.py

@@ -71,7 +71,6 @@ def open_gsp(
     ds = ds.assign_coords(
         x_osgb=(df_gsp_loc.x_osgb.to_xarray()),
         y_osgb=(df_gsp_loc.y_osgb.to_xarray()),
-        nominal_capacity_mwp=ds.installedcapacity_mwp,
         effective_capacity_mwp=ds.capacity_mwp,
     )
 
@@ -84,7 +83,6 @@ def open_gsp(
     coord_dtypes = {
         "time_utc": np.datetime64,
         "gsp_id": np.integer,
-        "nominal_capacity_mwp": np.floating,
         "effective_capacity_mwp": np.floating,
         "x_osgb": np.floating,
         "y_osgb": np.floating,

{ocf_data_sampler-0.5.9 → ocf_data_sampler-0.5.11}/ocf_data_sampler/numpy_sample/gsp.py

@@ -9,7 +9,6 @@ class GSPSampleKey:
     """Keys for the GSP sample dictionary."""
 
     gsp = "gsp"
-    nominal_capacity_mwp = "gsp_nominal_capacity_mwp"
     effective_capacity_mwp = "gsp_effective_capacity_mwp"
     time_utc = "gsp_time_utc"
     t0_idx = "gsp_t0_idx"
@@ -27,8 +26,7 @@ def convert_gsp_to_numpy_sample(da: xr.DataArray, t0_idx: int | None = None) ->
     """
     sample = {
         GSPSampleKey.gsp: da.values,
-        GSPSampleKey.nominal_capacity_mwp: da.isel(time_utc=0)["nominal_capacity_mwp"].values,
-        GSPSampleKey.effective_capacity_mwp: da.isel(time_utc=0)["effective_capacity_mwp"].values,
+        GSPSampleKey.effective_capacity_mwp: da.effective_capacity_mwp.values[0],
         GSPSampleKey.time_utc: da["time_utc"].values.astype(float),
     }
 

ocf_data_sampler-0.5.11/ocf_data_sampler/select/geospatial.py

@@ -0,0 +1,207 @@
+"""Geospatial coordinate transformation functions.
+
+Provides utilities for working with different coordinate systems
+
+Supports conversions between:
+- OSGB36 (Ordnance Survey Great Britain, easting/northing in meters)
+- WGS84 (World Geodetic System, latitude/longitude in degrees)
+- Geostationary satellite coordinate systems
+"""
+
+import numpy as np
+import pyproj
+import xarray as xr
+from pyresample.area_config import load_area_from_string
+
+# Coordinate Reference System (CRS) identifiers
+
+# OSGB36: UK Ordnance Survey National Grid (easting/northing in meters) - https://epsg.io/27700
+OSGB36 = 27700
+# WGS84: World Geodetic System 1984 (latitude/longitude in degrees) - https://epsg.io/4326
+WGS84 = 4326
+
+# Pre-inititiate coordinate Transformer objects
+_osgb_to_lon_lat = pyproj.Transformer.from_crs(crs_from=OSGB36, crs_to=WGS84, always_xy=True)
+_lon_lat_to_osgb = pyproj.Transformer.from_crs(crs_from=WGS84, crs_to=OSGB36, always_xy=True)
+
+
+def osgb_to_lon_lat(
+    x: float | np.ndarray,
+    y: float | np.ndarray,
+) -> tuple[float | np.ndarray, float | np.ndarray]:
+    """Convert OSGB coordinates to lon-lat.
+
+    Args:
+        x: osgb east-west
+        y: osgb south-north
+
+    Return: longitude, latitude
+    """
+    return _osgb_to_lon_lat.transform(xx=x, yy=y)
+
+
+def lon_lat_to_osgb(
+    x: float | np.ndarray,
+    y: float | np.ndarray,
+) -> tuple[float | np.ndarray, float | np.ndarray]:
+    """Convert lon-lat coordinates to OSGB.
+
+    Args:
+        x: longitude east-west
+        y: latitude south-north
+
+    Return: x_osgb, y_osgb
+    """
+    return _lon_lat_to_osgb.transform(xx=x, yy=y)
+
+
+def _get_geostationary_coord_transform(
+    crs_from: int,
+    area_string: str,
+) -> pyproj.transformer.Transformer:
+    """Loads geostationary area and transforms to geostationary coords.
+
+    Args:
+        x: osgb east-west, or latitude
+        y: osgb south-north, or longitude
+        crs_from: the cordiates system of x, y
+        area_string: String containing yaml geostationary area definition to convert to.
+
+    Returns: Coordinate Transformer
+    """
+    if crs_from not in [OSGB36, WGS84]:
+        raise ValueError(f"Unrecognized coordinate system: {crs_from}")
+
+    geostationary_crs = load_area_from_string(area_string).crs
+
+    return pyproj.Transformer.from_crs(
+        crs_from=crs_from,
+        crs_to=geostationary_crs,
+        always_xy=True,
+    )
+
+
+def lon_lat_to_geostationary_area_coords(
+    longitude: float | np.ndarray,
+    latitude: float | np.ndarray,
+    area_string: str,
+) -> tuple[float | np.ndarray, float | np.ndarray]:
+    """Convert from lon-lat to geostationary coords.
+
+    Args:
+        longitude: longitude
+        latitude: latitude
+        area_string: String containing yaml geostationary area definition to convert to.
+
+    Returns: x_geostationary, y_geostationary
+    """
+    coord_transformer = _get_geostationary_coord_transform(WGS84, area_string)
+    return coord_transformer.transform(xx=longitude, yy=latitude)
+
+
+def osgb_to_geostationary_area_coords(
+    x: float | np.ndarray,
+    y: float | np.ndarray,
+    area_string: str,
+) -> tuple[float | np.ndarray, float | np.ndarray]:
+    """Convert from OSGB to geostationary coords.
+
+    Args:
+        x: osgb east-west
+        y: osgb south-north
+        area_string: String containing yaml geostationary area definition to convert to.
+
+    Returns: x_geostationary, y_geostationary
+    """
+    coord_transformer = _get_geostationary_coord_transform(OSGB36, area_string)
+    return coord_transformer.transform(xx=x, yy=y)
+
+
+def find_coord_system(da: xr.DataArray) -> tuple[str, str, str]:
+    """Searches the Xarray object to determine the spatial coordinate system.
+
+    Args:
+        da: Dataset with spatial coords
+
+    Returns:
+        Three strings with:
+            1. The kind of the coordinate system
+            2. Name of the x-coordinate
+            3. Name of the y-coordinate
+    """
+    # We only look at the dimensional coords. It is possible that other coordinate systems are
+    # included as non-dimensional coords
+    dimensional_coords = set(da.xindexes)
+
+    coord_systems = {
+        "lon_lat": ["longitude", "latitude"],
+        "geostationary": ["x_geostationary", "y_geostationary"],
+        "osgb": ["x_osgb", "y_osgb"],
+    }
+
+    coords_systems_found = []
+
+    for coord_name, coord_set in coord_systems.items():
+        if set(coord_set) <= dimensional_coords:
+            coords_systems_found.append(coord_name)
+
+    if len(coords_systems_found)==0:
+        raise ValueError(
+            f"Did not find any coordinate pairs in the dimensional coords: {dimensional_coords}",
+        )
+    elif len(coords_systems_found)>1:
+        raise ValueError(
+            f"Found >1 ({coords_systems_found}) coordinate pairs in the dimensional coords: "
+            f"{dimensional_coords}",
+        )
+    else:
+        coord_system_name = coords_systems_found[0]
+        return coord_system_name, *coord_systems[coord_system_name]
+
+
+def convert_coordinates(
+    x: float | np.ndarray,
+    y: float | np.ndarray,
+    from_coords: str,
+    target_coords: str,
+    area_string: str | None = None,
+) -> tuple[float | np.ndarray, float | np.ndarray]:
+    """Convert x and y coordinates from one coordinate system to another.
+
+    Args:
+        x: The x-coordinate to convert.
+        y: The y-coordinate to convert.
+        from_coords: The coordinate system to convert from.
+        target_coords: The coordinate system to convert to
+        area_string: Optional string containing yaml geostationary area definition. Only used if
+            from_coords or target_coords is "geostationary"
+
+    Returns:
+        The converted (x, y) coordinates.
+    """
+    if from_coords==target_coords:
+        return x, y
+
+    if "geostationary" in (from_coords, target_coords) and area_string is not None:
+        ValueError("If using geostationary coords the `area_string` must be provided")
+
+    match (from_coords, target_coords):
+
+        case ("osgb", "geostationary"):
+            x, y = osgb_to_geostationary_area_coords(x, y, area_string)
+
+        case ("lon_lat", "geostationary"):
+            x, y = lon_lat_to_geostationary_area_coords(x, y, area_string)
+
+        case ("osgb", "lon_lat"):
+            x, y = osgb_to_lon_lat(x, y)
+
+        case ("lon_lat", "osgb"):
+            x, y = lon_lat_to_osgb(x, y)
+
+        case (_, _):
+            raise NotImplementedError(
+                f"Conversion from {from_coords} to "
+                f"{target_coords} is not supported",
+            )
+    return x, y

ocf_data_sampler-0.5.11/ocf_data_sampler/select/location.py

@@ -0,0 +1,63 @@
+"""Location object."""
+
+
+allowed_coord_systems = {"osgb", "lon_lat", "geostationary"}
+
+
+class Location:
+    """A spatial location."""
+
+    def __init__(self, x: float, y: float, coord_system: int, id: int | str | None = None) -> None:
+        """A spatial location.
+
+        Args:
+            x: The east-west / left-right location
+            y: The south-north / down-up location
+            coord_system: The coordinate system
+            id: The location ID
+        """
+        self._check_valid_coord_system(coord_system)
+        self._projections: dict[str, tuple[float, float]] = {coord_system: (x, y)}
+        self.id = id
+
+    @staticmethod
+    def _check_valid_coord_system(coord_system: str) -> None:
+        if coord_system not in allowed_coord_systems:
+            raise ValueError(f"Coordinate  {coord_system} is not supported")
+
+    def in_coord_system(self, coord_system: str) -> tuple[float, float]:
+        """Get the location in a specified coordinate system.
+
+        Args:
+            coord_system: The desired output coordinate system
+        """
+        self._check_valid_coord_system(coord_system)
+
+        if coord_system in self._projections:
+            return self._projections[coord_system]
+        else:
+            raise ValueError(
+                "Requested the coodinate in {coord_system}. This has not yet been added. "
+                "The current available coordinate systems are "
+                f"{list(self.self._projections.keys())}",
+            )
+
+    def add_coord_system(self, x: float, y: float, coord_system: int) -> None:
+        """Add the equivalent location in a different coordinate system.
+
+        Args:
+            x: The east-west / left-right coordinate
+            y: The south-north / down-up coordinate
+            coord_system: The coordinate system name
+        """
+        self._check_valid_coord_system(coord_system)
+        if coord_system in self._projections:
+            if not (x, y)==self._projections[coord_system]:
+                raise ValueError(
+                    f"Tried to re-add coordinate projection {coord_system}, but the supplied"
+                    f"coodrinate values ({x}, {y}) do not match the already stored values "
+                    f"{self._projections[coord_system]}",
+                )
+        else:
+            self._projections[coord_system] = (x, y)
+

{ocf_data_sampler-0.5.9 → ocf_data_sampler-0.5.11}/ocf_data_sampler/select/select_spatial_slice.py

@@ -1,63 +1,13 @@
 """Select spatial slices."""
 
-import logging
-
 import numpy as np
 import xarray as xr
 
-from ocf_data_sampler.select.geospatial import (
-    lon_lat_to_geostationary_area_coords,
-    lon_lat_to_osgb,
-    osgb_to_geostationary_area_coords,
-    osgb_to_lon_lat,
-    spatial_coord_type,
-)
+from ocf_data_sampler.select.geospatial import find_coord_system
 from ocf_data_sampler.select.location import Location
 
-logger = logging.getLogger(__name__)
-
-
-def convert_coordinates(
-    from_coords: str,
-    x: float | np.ndarray,
-    y: float | np.ndarray,
-    da: xr.DataArray,
-) -> tuple[float | np.ndarray, float | np.ndarray]:
-    """Convert x and y coordinates to coordinate system matching xarray data.
-
-    Args:
-        from_coords: The coordinate system to convert from.
-        x: The x-coordinate to convert.
-        y: The y-coordinate to convert.
-        da: The xarray DataArray used for context (e.g., for geostationary conversion).
-
-    Returns:
-        The converted (x, y) coordinates.
-    """
-    target_coords, *_ = spatial_coord_type(da)
-
-    match (from_coords, target_coords):
-        case ("osgb", "geostationary"):
-            x, y = osgb_to_geostationary_area_coords(x, y, da)
-        case ("osgb", "lon_lat"):
-            x, y = osgb_to_lon_lat(x, y)
-        case ("osgb", "osgb"):
-            pass
-        case ("lon_lat", "osgb"):
-            x, y = lon_lat_to_osgb(x, y)
-        case ("lon_lat", "geostationary"):
-            x, y = lon_lat_to_geostationary_area_coords(x, y, da)
-        case ("lon_lat", "lon_lat"):
-            pass
-        case (_, _):
-            raise NotImplementedError(
-                f"Conversion from {from_coords} to "
-                f"{target_coords} is not supported",
-            )
-    return x, y
-
 
-def _get_pixel_index_location(da: xr.DataArray, location: Location) -> Location:
+def _get_pixel_index_location(da: xr.DataArray, location: Location) -> tuple[int, int]:
     """Find pixel index location closest to given Location.
 
     Args:
@@ -65,14 +15,14 @@ def _get_pixel_index_location(da: xr.DataArray, location: Location) -> Location:
         location: The Location object representing the point of interest.
 
     Returns:
-        A Location object with x and y attributes representing the pixel indices.
+        The pixel indices.
 
     Raises:
         ValueError: If the location is outside the bounds of the DataArray.
     """
-    xr_coords, x_dim, y_dim = spatial_coord_type(da)
+    target_coords, x_dim, y_dim = find_coord_system(da)
 
-    x, y = convert_coordinates(location.coordinate_system, location.x, location.y, da)
+    x, y = location.in_coord_system(target_coords)
 
     # Check that requested point lies within the data
     if not (da[x_dim].min() < x < da[x_dim].max()):
@@ -89,7 +39,7 @@ def _get_pixel_index_location(da: xr.DataArray, location: Location) -> Location:
     closest_x = x_index.get_indexer([x], method="nearest")[0]
     closest_y = y_index.get_indexer([y], method="nearest")[0]
 
-    return Location(x=closest_x, y=closest_y, coordinate_system="idx")
+    return closest_x, closest_y
 
 
 def _select_padded_slice(
@@ -213,16 +163,16 @@ def select_spatial_slice_pixels(
     if (height_pixels % 2) != 0:
         raise ValueError("Height must be an even number")
 
-    _, x_dim, y_dim = spatial_coord_type(da)
-    center_idx = _get_pixel_index_location(da, location)
+    _, x_dim, y_dim = find_coord_system(da)
+    center_idx_x, center_idx_y = _get_pixel_index_location(da, location)
 
     half_width = width_pixels // 2
     half_height = height_pixels // 2
 
-    left_idx = int(center_idx.x - half_width)
-    right_idx = int(center_idx.x + half_width)
-    bottom_idx = int(center_idx.y - half_height)
-    top_idx = int(center_idx.y + half_height)
+    left_idx = int(center_idx_x - half_width)
+    right_idx = int(center_idx_x + half_width)
+    bottom_idx = int(center_idx_y - half_height)
+    top_idx = int(center_idx_y + half_height)
 
     data_width_pixels = len(da[x_dim])
     data_height_pixels = len(da[y_dim])

{ocf_data_sampler-0.5.9 → ocf_data_sampler-0.5.11}/ocf_data_sampler/torch_datasets/datasets/pvnet_uk.py

@@ -19,17 +19,15 @@ from ocf_data_sampler.numpy_sample.common_types import NumpyBatch, NumpySample
 from ocf_data_sampler.numpy_sample.gsp import GSPSampleKey
 from ocf_data_sampler.numpy_sample.nwp import NWPSampleKey
 from ocf_data_sampler.select import Location, fill_time_periods
-from ocf_data_sampler.select.geospatial import osgb_to_lon_lat
 from ocf_data_sampler.torch_datasets.utils import (
+    add_alterate_coordinate_projections,
     config_normalization_values_to_dicts,
+    fill_nans_in_arrays,
     find_valid_time_periods,
+    merge_dicts,
     slice_datasets_by_space,
     slice_datasets_by_time,
 )
-from ocf_data_sampler.torch_datasets.utils.merge_and_fill_utils import (
-    fill_nans_in_arrays,
-    merge_dicts,
-)
 from ocf_data_sampler.utils import minutes, tensorstore_compute
 
 xr.set_options(keep_attrs=True)
@@ -59,10 +57,10 @@ def get_gsp_locations(
     for gsp_id in gsp_ids:
         locations.append(
             Location(
-                coordinate_system="osgb",
                 x=df_gsp_loc.loc[gsp_id].x_osgb,
                 y=df_gsp_loc.loc[gsp_id].y_osgb,
-                id=gsp_id,
+                coord_system="osgb",
+                id=int(gsp_id),
             ),
         )
     return locations
@@ -100,10 +98,13 @@ class AbstractPVNetUKDataset(Dataset):
             valid_t0_times = valid_t0_times[valid_t0_times <= pd.Timestamp(end_time)]
 
         # Construct list of locations to sample from
-        self.locations = get_gsp_locations(
-            gsp_ids,
-            version=config.input_data.gsp.boundaries_version,
+        locations = get_gsp_locations(gsp_ids, version=config.input_data.gsp.boundaries_version)
+        self.locations = add_alterate_coordinate_projections(
+            locations,
+            datasets_dict,
+            primary_coords="osgb",
         )
+
         self.valid_t0_times = valid_t0_times
 
         # Assign config and input data to self
@@ -171,11 +172,14 @@ class AbstractPVNetUKDataset(Dataset):
             )
 
         # Add GSP location data
+
+        osgb_x, osgb_y = location.in_coord_system("osgb")
+
         numpy_modalities.append(
             {
                 GSPSampleKey.gsp_id: location.id,
-                GSPSampleKey.x_osgb: location.x,
-                GSPSampleKey.y_osgb: location.y,
+                GSPSampleKey.x_osgb: osgb_x,
+                GSPSampleKey.y_osgb: osgb_y,
             },
         )
 
@@ -191,7 +195,7 @@ class AbstractPVNetUKDataset(Dataset):
             )
 
             # Convert OSGB coordinates to lon/lat
-            lon, lat = osgb_to_lon_lat(location.x, location.y)
+            lon, lat = location.in_coord_system("lon_lat")
 
             # Calculate solar positions and add to modalities
             numpy_modalities.append(make_sun_position_numpy_sample(datetimes, lon, lat))

{ocf_data_sampler-0.5.9 → ocf_data_sampler-0.5.11}/ocf_data_sampler/torch_datasets/datasets/site.py

@@ -25,15 +25,14 @@ from ocf_data_sampler.select import (
     intersection_of_multiple_dataframes_of_periods,
 )
 from ocf_data_sampler.torch_datasets.utils import (
+    add_alterate_coordinate_projections,
     config_normalization_values_to_dicts,
+    fill_nans_in_arrays,
     find_valid_time_periods,
+    merge_dicts,
     slice_datasets_by_space,
     slice_datasets_by_time,
 )
-from ocf_data_sampler.torch_datasets.utils.merge_and_fill_utils import (
-    fill_nans_in_arrays,
-    merge_dicts,
-)
 from ocf_data_sampler.utils import minutes, tensorstore_compute
 
 xr.set_options(keep_attrs=True)
@@ -52,7 +51,7 @@ def get_locations(site_xr: xr.Dataset) -> list[Location]:
             id=site_id,
             x=site.longitude.values,
             y=site.latitude.values,
-            coordinate_system="lon_lat",
+            coord_system="lon_lat",
         )
         locations.append(location)
 
@@ -168,8 +167,14 @@ class SitesDataset(Dataset):
         self.datasets_dict = datasets_dict
         self.config = config
 
-        # get all locations
-        self.locations = get_locations(datasets_dict["site"])
+        # Construct list of locations to sample from
+        locations = get_locations(datasets_dict["site"])
+        self.locations = add_alterate_coordinate_projections(
+            locations,
+            datasets_dict,
+            primary_coords="lon_lat",
+        )
+
         self.location_lookup = {loc.id: loc for loc in self.locations}
 
         # Get t0 times where all input data is available

{ocf_data_sampler-0.5.9 → ocf_data_sampler-0.5.11}/ocf_data_sampler/torch_datasets/utils/__init__.py

@@ -2,4 +2,5 @@ from .config_normalization_values_to_dicts import config_normalization_values_to
 from .merge_and_fill_utils import fill_nans_in_arrays, merge_dicts
 from .valid_time_periods import find_valid_time_periods
 from .spatial_slice_for_dataset import slice_datasets_by_space
-from .time_slice_for_dataset import slice_datasets_by_time
+from .time_slice_for_dataset import slice_datasets_by_time
+from .add_alterate_coordinate_projections import add_alterate_coordinate_projections

ocf_data_sampler-0.5.11/ocf_data_sampler/torch_datasets/utils/add_alterate_coordinate_projections.py

@@ -0,0 +1,77 @@
+""""Function for adding more projections to location objects."""
+
+import numpy as np
+
+from ocf_data_sampler.select import Location
+from ocf_data_sampler.select.geospatial import convert_coordinates, find_coord_system
+
+
+def add_alterate_coordinate_projections(
+    locations: list[Location],
+    datasets_dict: dict,
+    primary_coords: str,
+) -> list[Location]:
+    """Add (in-place) coordinate projections for all dataset to a set of locations.
+
+    Args:
+        locations: A list of locations
+        datasets_dict: The dataset dict to add projections for
+        primary_coords: The primary coords of the locations
+
+    Returns:
+        List of locations with all coordinate projections added
+    """
+    if primary_coords not in ["osgb", "lon_lat"]:
+        raise ValueError("Only osbg and lon_lat are currently supported")
+
+    xs, ys = np.array([loc.in_coord_system(primary_coords) for loc in locations]).T
+
+    datasets_list = []
+    if "nwp" in datasets_dict:
+        datasets_list.extend(datasets_dict["nwp"].values())
+    if "sat" in datasets_dict:
+        datasets_list.append(datasets_dict["sat"])
+
+    computed_coord_systems = {primary_coords}
+
+    # Find all the coord systems required by all datasets
+    for da in datasets_list:
+
+        # Fid the dataset required by this dataset
+        coord_system, *_ = find_coord_system(da)
+
+        # Skip if the projections in this coord system have already been computed
+        if coord_system not in computed_coord_systems:
+
+            # If using geostationary coords we need to extract the area definition string
+            area_string = da.attrs["area"] if coord_system=="geostationary" else None
+
+            new_xs, new_ys = convert_coordinates(
+                x=xs,
+                y=ys,
+                from_coords=primary_coords,
+                target_coords=coord_system,
+                area_string=area_string,
+            )
+
+            # Add the projection to the locations objects
+            for x, y, loc in zip(new_xs, new_ys, locations, strict=True):
+                loc.add_coord_system(x, y, coord_system)
+
+            computed_coord_systems.add(coord_system)
+
+    # Add lon-lat to start since it is required to compute the solar coords
+    if "lon_lat" not in computed_coord_systems:
+        new_xs, new_ys = convert_coordinates(
+            x=xs,
+            y=ys,
+            from_coords=primary_coords,
+            target_coords="lon_lat",
+            area_string=None,
+        )
+
+        # Add the projection to the locations objects
+        for x, y, loc in zip(new_xs, new_ys, locations, strict=False):
+            loc.add_coord_system(x, y, "lon_lat")
+
+    return locations

{ocf_data_sampler-0.5.9 → ocf_data_sampler-0.5.11}/ocf_data_sampler.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ocf-data-sampler
-Version: 0.5.9
+Version: 0.5.11
 Author: James Fulton, Peter Dudfield
 Author-email: Open Climate Fix team <info@openclimatefix.org>
 License: MIT License

{ocf_data_sampler-0.5.9 → ocf_data_sampler-0.5.11}/ocf_data_sampler.egg-info/SOURCES.txt

@@ -55,6 +55,7 @@ ocf_data_sampler/torch_datasets/sample/base.py
 ocf_data_sampler/torch_datasets/sample/site.py
 ocf_data_sampler/torch_datasets/sample/uk_regional.py
 ocf_data_sampler/torch_datasets/utils/__init__.py
+ocf_data_sampler/torch_datasets/utils/add_alterate_coordinate_projections.py
 ocf_data_sampler/torch_datasets/utils/config_normalization_values_to_dicts.py
 ocf_data_sampler/torch_datasets/utils/merge_and_fill_utils.py
 ocf_data_sampler/torch_datasets/utils/spatial_slice_for_dataset.py
@@ -62,4 +63,5 @@ ocf_data_sampler/torch_datasets/utils/time_slice_for_dataset.py
 ocf_data_sampler/torch_datasets/utils/valid_time_periods.py
 ocf_data_sampler/torch_datasets/utils/validation_utils.py
 scripts/download_gsp_location_data.py
-scripts/refactor_site.py
+scripts/refactor_site.py
+tests/test_utils.py

ocf_data_sampler-0.5.11/tests/test_utils.py

@@ -0,0 +1,45 @@
+import dask.array
+import numpy as np
+import xarray as xr
+
+from ocf_data_sampler.load.open_xarray_tensorstore import open_zarr
+from ocf_data_sampler.utils import compute, tensorstore_compute
+
+
+def test_compute():
+    """Test compute function with dask array"""
+    da_dask = xr.DataArray(dask.array.random.random((5, 5)))
+
+    # Create a nested dictionary with dask array
+    lazy_data_dict = {
+        "array1": da_dask,
+        "nested": {"array2": da_dask},
+    }
+
+    computed_data_dict = compute(lazy_data_dict)
+
+    # Assert that the result is no longer lazy
+    assert isinstance(computed_data_dict["array1"].data, np.ndarray)
+    assert isinstance(computed_data_dict["nested"]["array2"].data, np.ndarray)
+
+
+def test_tensorstore_compute(tmp_path):
+
+    # Save a zarr
+    da_dask = xr.DataArray(dask.array.random.random((5, 5)))
+    da_dask.to_dataset(name="array").to_zarr(tmp_path)
+
+    # Re-open with tensorstore
+    da_ts = open_zarr(tmp_path).array
+
+    # Create a nested dictionary with tensorstore arrays
+    lazy_data_dict = {
+        "array1": da_ts,
+        "nested": {"array2": da_ts},
+    }
+
+    computed_data_dict = tensorstore_compute(lazy_data_dict)
+
+    # Assert that the result is no longer lazy
+    assert isinstance(computed_data_dict["array1"].data, np.ndarray)
+    assert isinstance(computed_data_dict["nested"]["array2"].data, np.ndarray)

ocf_data_sampler-0.5.9/ocf_data_sampler/select/geospatial.py

@@ -1,169 +0,0 @@
-"""Geospatial coordinate transformation functions.
-
-Provides utilities for working with different coordinate systems
-commonly used in geospatial applications, particularly for UK-based data.
-
-Supports conversions between:
-- OSGB36 (Ordnance Survey Great Britain, easting/northing in meters)
-- WGS84 (World Geodetic System, latitude/longitude in degrees)
-- Geostationary satellite coordinate systems
-"""
-
-import numpy as np
-import pyproj
-import pyresample
-import xarray as xr
-
-# Coordinate Reference System (CRS) identifiers
-# OSGB36: UK Ordnance Survey National Grid (easting/northing in meters)
-# Refer to - https://epsg.io/27700
-OSGB36 = 27700
-
-# WGS84: World Geodetic System 1984 (latitude/longitude in degrees), used in GPS
-WGS84 = 4326
-
-# Pre-init Transformer
-_osgb_to_lon_lat = pyproj.Transformer.from_crs(
-    crs_from=OSGB36,
-    crs_to=WGS84,
-    always_xy=True,
-).transform
-_lon_lat_to_osgb = pyproj.Transformer.from_crs(
-    crs_from=WGS84,
-    crs_to=OSGB36,
-    always_xy=True,
-).transform
-
-
-def osgb_to_lon_lat(
-    x: float | np.ndarray,
-    y: float | np.ndarray,
-) -> tuple[float | np.ndarray, float | np.ndarray]:
-    """Change OSGB coordinates to lon-lat.
-
-    Args:
-        x: osgb east-west
-        y: osgb north-south
-    Return: 2-tuple of longitude (east-west), latitude (north-south)
-    """
-    return _osgb_to_lon_lat(xx=x, yy=y)
-
-
-def lon_lat_to_osgb(
-    x: float | np.ndarray,
-    y: float | np.ndarray,
-) -> tuple[float | np.ndarray, float | np.ndarray]:
-    """Change lon-lat coordinates to OSGB.
-
-    Args:
-        x: longitude east-west
-        y: latitude north-south
-
-    Return: 2-tuple of OSGB x, y
-    """
-    return _lon_lat_to_osgb(xx=x, yy=y)
-
-
-def lon_lat_to_geostationary_area_coords(
-    longitude: float | np.ndarray,
-    latitude: float | np.ndarray,
-    xr_data: xr.DataArray,
-) -> tuple[float | np.ndarray, float | np.ndarray]:
-    """Loads geostationary area and transformation from lat-lon to geostationary coords.
-
-    Args:
-        longitude: longitude
-        latitude: latitude
-        xr_data: xarray object with geostationary area
-
-    Returns:
-        Geostationary coords: x, y
-    """
-    return coordinates_to_geostationary_area_coords(longitude, latitude, xr_data, WGS84)
-
-
-def osgb_to_geostationary_area_coords(
-    x: float | np.ndarray,
-    y: float | np.ndarray,
-    xr_data: xr.DataArray,
-) -> tuple[float | np.ndarray, float | np.ndarray]:
-    """Loads geostationary area and transformation from OSGB to geostationary coords.
-
-    Args:
-        x: osgb east-west
-        y: osgb north-south
-        xr_data: xarray object with geostationary area
-
-    Returns:
-        Geostationary coords: x, y
-    """
-    return coordinates_to_geostationary_area_coords(x, y, xr_data, OSGB36)
-
-
-def coordinates_to_geostationary_area_coords(
-    x: float | np.ndarray,
-    y: float | np.ndarray,
-    xr_data: xr.DataArray,
-    crs_from: int,
-) -> tuple[float | np.ndarray, float | np.ndarray]:
-    """Loads geostationary area and transforms to geostationary coords.
-
-    Args:
-        x: osgb east-west, or latitude
-        y: osgb north-south, or longitude
-        xr_data: xarray object with geostationary area
-        crs_from: the cordiates system of x,y
-
-    Returns:
-        Geostationary coords: x, y
-    """
-    if crs_from not in [OSGB36, WGS84]:
-        raise ValueError(f"Unrecognized coordinate system: {crs_from}")
-
-    area_definition_yaml = xr_data.attrs["area"]
-
-    geostationary_area_definition = pyresample.area_config.load_area_from_string(
-        area_definition_yaml,
-    )
-    geostationary_crs = geostationary_area_definition.crs
-    osgb_to_geostationary = pyproj.Transformer.from_crs(
-        crs_from=crs_from,
-        crs_to=geostationary_crs,
-        always_xy=True,
-    ).transform
-    return osgb_to_geostationary(xx=x, yy=y)
-
-
-def _coord_priority(available_coords: list[str]) -> tuple[str, str, str]:
-    """Determines the coordinate system of spatial coordinates present."""
-    if "longitude" in available_coords:
-        return "lon_lat", "longitude", "latitude"
-    elif "x_geostationary" in available_coords:
-        return "geostationary", "x_geostationary", "y_geostationary"
-    elif "x_osgb" in available_coords:
-        return "osgb", "x_osgb", "y_osgb"
-    else:
-        raise ValueError(f"Unrecognized coordinate system: {available_coords}")
-
-
-def spatial_coord_type(ds: xr.DataArray) -> tuple[str, str, str]:
-    """Searches the data array to determine the kind of spatial coordinates present.
-
-    This search has a preference for the dimension coordinates of the xarray object.
-
-    Args:
-        ds: Dataset with spatial coords
-
-    Returns:
-        Three strings with:
-            1. The kind of the coordinate system
-            2. Name of the x-coordinate
-            3. Name of the y-coordinate
-    """
-    if isinstance(ds, xr.DataArray):
-        # Search dimension coords of dataarray
-        coords = _coord_priority(ds.xindexes)
-    else:
-        raise ValueError(f"Unrecognized input type: {type(ds)}")
-
-    return coords

ocf_data_sampler-0.5.9/ocf_data_sampler/select/location.py

@@ -1,27 +0,0 @@
-"""Location model with coordinate system validation."""
-
-from pydantic import BaseModel, Field, model_validator
-
-allowed_coordinate_systems = ["osgb", "lon_lat", "geostationary", "idx"]
-
-
-class Location(BaseModel):
-    """Represent a spatial location."""
-
-    coordinate_system: str = Field(...,
-        description="Coordinate system for the location must be lon_lat, osgb, or geostationary",
-    )
-
-    x: float = Field(..., description="x coordinate - i.e. east-west position")
-    y: float = Field(..., description="y coordinate - i.e. north-south position")
-    id: int | None = Field(None, description="ID of the location - e.g. GSP ID")
-
-    @model_validator(mode="after")
-    def validate_coordinate_system(self) -> "Location":
-        """Validate 'coordinate_system'."""
-        if self.coordinate_system not in allowed_coordinate_systems:
-            raise ValueError(
-                f"coordinate_system = {self.coordinate_system} "
-                f"is not in {allowed_coordinate_systems}",
-            )
-        return self