covjsonkit 0.2.18__tar.gz → 0.2.19__tar.gz

{covjsonkit-0.2.18 → covjsonkit-0.2.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: covjsonkit
-Version: 0.2.18
+Version: 0.2.19
 Home-page: https://github.com/ecmwf/covjsonkit
 Author: ECMWF
 Author-email: James.Hawkes@ecmwf.int, Adam.Warde@ecmwf.int, Mathilde.Leuridan@ecmwf.int

{covjsonkit-0.2.18 → covjsonkit-0.2.19}/covjsonkit/decoder/Position.py

@@ -109,9 +109,6 @@ class Position(Decoder):
         dims = ["latitude", "longitude", "levelist", "number", "datetime", "t"]
         ds = []
 
-        # Get coordinates for all domains
-        all_coords = self.get_domains()
-
         unique_coords = set()  # To track unique coordinate tuples
         unique_domains = []  # To store unique domains
 
@@ -131,14 +128,17 @@ class Position(Decoder):
                 unique_domains.append(domain)  # Add to unique domains
 
         all_coords = unique_domains
-        param_values = {}
 
-        # Initialize parameter values for all parameters
-        for parameter in self.parameters:
-            param_values[parameter] = []
+        num = []
+        datetime = []
+        for coverage in self.covjson["coverages"]:
+            num.append(coverage["mars:metadata"]["number"])
+            datetime.append(coverage["mars:metadata"]["Forecast date"])
+        nums = list(set(num))
+        datetime = list(set(datetime))
 
         # Process each coordinate domain
-        for domain_idx, coords in enumerate(all_coords):
+        for coords in all_coords:
             dataarraydict = {}
             x = coords["axes"][self.x_name]["values"]
             y = coords["axes"][self.y_name]["values"]
@@ -147,69 +147,69 @@ class Position(Decoder):
             steps = [step.replace("Z", "") for step in steps]
             steps = pd.to_datetime(steps)
 
-            num = []
-            datetime = []
-            for coverage in self.covjson["coverages"]:
-                num.append(coverage["mars:metadata"]["number"])
-                datetime.append(coverage["mars:metadata"]["Forecast date"])
+            cov_idx_list = self._find_coverages(nums, datetime, x, y, z)
 
-            nums = list(set(num))
-            datetime = list(set(datetime))
+            coords = {
+                "latitude": x,
+                "longitude": y,
+                "levelist": z,
+                "number": nums,
+                "datetime": datetime,
+                "t": steps,
+            }
 
-            # Extract parameter values for the current domain
             for parameter in self.parameters:
-                if len(param_values[parameter]) <= domain_idx:
-                    param_values[parameter].append([])
-
-                for i, num in enumerate(nums):
-                    if len(param_values[parameter][domain_idx]) <= i:
-                        param_values[parameter][domain_idx].append([])
-
-                    for j, date in enumerate(datetime):
-                        if len(param_values[parameter][domain_idx][i]) <= j:
-                            param_values[parameter][domain_idx][i].append([])
-
-                        for k, step in enumerate(steps):
-                            for coverage in self.covjson["coverages"]:
-                                if (
-                                    coverage["mars:metadata"]["number"] == num
-                                    and coverage["mars:metadata"]["Forecast date"] == date
-                                    and coverage["domain"]["axes"][self.x_name]["values"] == x
-                                    and coverage["domain"]["axes"][self.y_name]["values"] == y
-                                    and coverage["domain"]["axes"][self.z_name]["values"] == z
-                                ):
-                                    param_values[parameter][domain_idx][i][j] = coverage["ranges"][parameter]["values"]
+                param_values = [[[] for _ in range(len(datetime))] for _ in range(len(nums))]
 
-            for parameter in self.parameters:
-                param_coords = {
-                    "latitude": x,
-                    "longitude": y,
-                    "levelist": z,
-                    "number": nums,
-                    "datetime": datetime,
-                    "t": steps,
+                # Extract parameter values for the current domain
+                for i, j, cov in cov_idx_list:
+                    param_values[i][j] = cov["ranges"][parameter]["values"]
+
+                long_name = self.get_parameter_metadata(parameter)["observedProperty"]["id"]
+
+                if long_name == "t":
+                    long_name = "T"  # Avoid collision with time dimension 't'
+
+                attrs = {
+                    "type": self.get_parameter_metadata(parameter)["type"],
+                    "units": self.get_parameter_metadata(parameter)["unit"]["symbol"],
+                    "long_name": long_name,
                 }
-                dataarray = xr.DataArray(
-                    [[[param_values[parameter][domain_idx]]]],
-                    dims=dims,
-                    coords=param_coords,
-                    name=f"{parameter}_domain_{domain_idx}",
+                dataarraydict[long_name] = (
+                    dims,
+                    [[[param_values]]],
+                    attrs,
                 )
 
-                dataarray.attrs["type"] = self.get_parameter_metadata(parameter)["type"]
-                dataarray.attrs["units"] = self.get_parameter_metadata(parameter)["unit"]["symbol"]
-                dataarray.attrs["long_name"] = self.get_parameter_metadata(parameter)["observedProperty"]["id"]
-                dataarraydict[dataarray.attrs["long_name"]] = dataarray
-
-            ds.append(xr.Dataset(dataarraydict))
+            ds.append(xr.Dataset(data_vars=dataarraydict, coords=coords))
 
         # Combine all DataArrays into a Dataset
         for mars_metadata in self.mars_metadata[0]:
-            for dss in ds:
-                if mars_metadata != "date" and mars_metadata != "step":
+            if mars_metadata != "date" and mars_metadata != "step":
+                for dss in ds:
                     dss.attrs[mars_metadata] = self.mars_metadata[0][mars_metadata]
 
         if len(ds) == 1:
             return ds[0]
 
         return ds
+
+    def _find_coverages(self, nums, datetime, x, y, z):
+        """Find coverages matching domain parameters and return with indices."""
+        result = []
+        for i, num in enumerate(nums):
+            for j, date in enumerate(datetime):
+                for coverage in self.covjson["coverages"]:
+                    if self._covers_domain(coverage, num, date, x, y, z):
+                        result.append((i, j, coverage))
+        return result
+
+    def _covers_domain(self, coverage, num, date, x, y, z):
+        """Check if coverage matches the given domain parameters."""
+        return (
+            coverage["mars:metadata"]["number"] == num
+            and coverage["mars:metadata"]["Forecast date"] == date
+            and coverage["domain"]["axes"][self.x_name]["values"] == x
+            and coverage["domain"]["axes"][self.y_name]["values"] == y
+            and coverage["domain"]["axes"][self.z_name]["values"] == z
+        )

{covjsonkit-0.2.18 → covjsonkit-0.2.19}/covjsonkit/decoder/TimeSeries.py

@@ -139,14 +139,17 @@ class TimeSeries(Decoder):
                 unique_domains.append(domain)  # Add to unique domains
 
         all_coords = unique_domains
-        param_values = {}
 
-        # Initialize parameter values for all parameters
-        for parameter in self.parameters:
-            param_values[parameter] = []
+        num = []
+        datetime = []
+        for coverage in self.covjson["coverages"]:
+            num.append(coverage["mars:metadata"]["number"])
+            datetime.append(coverage["mars:metadata"]["Forecast date"])
+        nums = list(set(num))
+        datetime = list(set(datetime))
 
         # Process each coordinate domain
-        for domain_idx, coords in enumerate(all_coords):
+        for coords in all_coords:
             dataarraydict = {}
             x = coords["axes"][self.x_name]["values"]
             y = coords["axes"][self.y_name]["values"]
@@ -155,66 +158,46 @@ class TimeSeries(Decoder):
             steps = [step.replace("Z", "") for step in steps]
             steps = pd.to_datetime(steps)
 
-            num = []
-            datetime = []
-            for coverage in self.covjson["coverages"]:
-                num.append(coverage["mars:metadata"]["number"])
-                datetime.append(coverage["mars:metadata"]["Forecast date"])
+            cov_idx_list = self._find_coverages(nums, datetime, x, y, z)
 
-            nums = list(set(num))
-            datetime = list(set(datetime))
+            coords = {
+                "latitude": x,
+                "longitude": y,
+                "levelist": z,
+                "number": nums,
+                "datetime": datetime,
+                "t": steps,
+            }
 
-            # Extract parameter values for the current domain
             for parameter in self.parameters:
-                if len(param_values[parameter]) <= domain_idx:
-                    param_values[parameter].append([])
-
-                for i, num in enumerate(nums):
-                    if len(param_values[parameter][domain_idx]) <= i:
-                        param_values[parameter][domain_idx].append([])
-
-                    for j, date in enumerate(datetime):
-                        if len(param_values[parameter][domain_idx][i]) <= j:
-                            param_values[parameter][domain_idx][i].append([])
-
-                        for k, step in enumerate(steps):
-                            for coverage in self.covjson["coverages"]:
-                                if (
-                                    coverage["mars:metadata"]["number"] == num
-                                    and coverage["mars:metadata"]["Forecast date"] == date
-                                    and coverage["domain"]["axes"][self.x_name]["values"] == x
-                                    and coverage["domain"]["axes"][self.y_name]["values"] == y
-                                    and coverage["domain"]["axes"][self.z_name]["values"] == z
-                                ):
-                                    param_values[parameter][domain_idx][i][j] = coverage["ranges"][parameter]["values"]
+                param_values = [[[] for _ in range(len(datetime))] for _ in range(len(nums))]
 
-            for parameter in self.parameters:
-                param_coords = {
-                    "latitude": x,
-                    "longitude": y,
-                    "levelist": z,
-                    "number": nums,
-                    "datetime": datetime,
-                    "t": steps,
+                # Extract parameter values for the current domain
+                for i, j, cov in cov_idx_list:
+                    param_values[i][j] = cov["ranges"][parameter]["values"]
+
+                long_name = self.get_parameter_metadata(parameter)["observedProperty"]["id"]
+
+                if long_name == "t":
+                    long_name = "T"  # Avoid collision with time dimension 't'
+
+                attrs = {
+                    "type": self.get_parameter_metadata(parameter)["type"],
+                    "units": self.get_parameter_metadata(parameter)["unit"]["symbol"],
+                    "long_name": long_name,
                 }
-                dataarray = xr.DataArray(
-                    [[[param_values[parameter][domain_idx]]]],
-                    dims=dims,
-                    coords=param_coords,
-                    name=f"{parameter}_domain_{domain_idx}",
+                dataarraydict[long_name] = (
+                    dims,
+                    [[[param_values]]],
+                    attrs,
                 )
 
-                dataarray.attrs["type"] = self.get_parameter_metadata(parameter)["type"]
-                dataarray.attrs["units"] = self.get_parameter_metadata(parameter)["unit"]["symbol"]
-                dataarray.attrs["long_name"] = self.get_parameter_metadata(parameter)["observedProperty"]["id"]
-                dataarraydict[dataarray.attrs["long_name"]] = dataarray
-
-            ds.append(xr.Dataset(dataarraydict))
+            ds.append(xr.Dataset(data_vars=dataarraydict, coords=coords))
 
         # Combine all DataArrays into a Dataset
         for mars_metadata in self.mars_metadata[0]:
-            for dss in ds:
-                if mars_metadata != "date" and mars_metadata != "step":
+            if mars_metadata != "date" and mars_metadata != "step":
+                for dss in ds:
                     dss.attrs[mars_metadata] = self.mars_metadata[0][mars_metadata]
 
         if len(ds) == 1:
@@ -222,6 +205,27 @@ class TimeSeries(Decoder):
 
         return ds
 
+    def _find_coverages(self, nums, datetime, x, y, z):
+        """Find coverages that match the given domain parameters (num, date, x, y, z)
+        and return them along with domain parameter indices."""
+        result = []
+        for i, num in enumerate(nums):
+            for j, date in enumerate(datetime):
+                for coverage in self.covjson["coverages"]:
+                    if self._covers_domain(coverage, num, date, x, y, z):
+                        result.append((i, j, coverage))
+        return result
+
+    def _covers_domain(self, coverage, num, date, x, y, z):
+        """check if coverage matches the given domain parameters (num, date, x, y, z)"""
+        return (
+            coverage["mars:metadata"]["number"] == num
+            and coverage["mars:metadata"]["Forecast date"] == date
+            and coverage["domain"]["axes"][self.x_name]["values"] == x
+            and coverage["domain"]["axes"][self.y_name]["values"] == y
+            and coverage["domain"]["axes"][self.z_name]["values"] == z
+        )
+
     def _to_xarray_no_forecast_date(self):
         """Convert monthly-means CovJSON (no 'Forecast date' in metadata) to xarray.
 
@@ -233,7 +237,7 @@ class TimeSeries(Decoder):
         """
         ds_list = []
 
-        for cov_idx, coverage in enumerate(self.covjson["coverages"]):
+        for coverage in self.covjson["coverages"]:
             domain = coverage["domain"]["axes"]
             x = domain[self.x_name]["values"]
             y = domain[self.y_name]["values"]
@@ -246,15 +250,20 @@ class TimeSeries(Decoder):
             dataarraydict = {}
             for parameter in self.parameters:
                 values = coverage["ranges"][parameter]["values"]
-                dataarray = xr.DataArray(
-                    values,
-                    dims=["t"],
-                    coords={"t": steps},
-                )
-                dataarray.attrs["type"] = self.get_parameter_metadata(parameter)["type"]
-                dataarray.attrs["units"] = self.get_parameter_metadata(parameter)["unit"]["symbol"]
-                dataarray.attrs["long_name"] = self.get_parameter_metadata(parameter)["observedProperty"]["id"]
-                dataarraydict[dataarray.attrs["long_name"]] = dataarray
+                long_name = self.get_parameter_metadata(parameter)["observedProperty"]["id"]
+
+                if long_name == "t":
+                    long_name = "T"  # Avoid collision with time dimension 't'
+
+                attrs = {
+                    "type": self.get_parameter_metadata(parameter)["type"],
+                    "units": self.get_parameter_metadata(parameter)["unit"]["symbol"],
+                    "long_name": long_name,
+                }
+
+                dataarray = xr.DataArray(values, dims=["t"], coords={"t": steps}, attrs=attrs)
+
+                dataarraydict[long_name] = dataarray
 
             coord_dict = dict(
                 latitude=(["latitude"], x),

covjsonkit-0.2.19/covjsonkit/version.py

@@ -0,0 +1 @@
+__version__ = "0.2.19"

{covjsonkit-0.2.18 → covjsonkit-0.2.19}/covjsonkit.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: covjsonkit
-Version: 0.2.18
+Version: 0.2.19
 Home-page: https://github.com/ecmwf/covjsonkit
 Author: ECMWF
 Author-email: James.Hawkes@ecmwf.int, Adam.Warde@ecmwf.int, Mathilde.Leuridan@ecmwf.int

{covjsonkit-0.2.18 → covjsonkit-0.2.19}/covjsonkit.egg-info/SOURCES.txt

@@ -65,8 +65,10 @@ tests/conftest.py
 tests/geojsontest.py
 tests/requirements_test.txt
 tests/test_decoder_bounding_box.py
+tests/test_decoder_circle.py
 tests/test_decoder_frame.py
 tests/test_decoder_grid.py
+tests/test_decoder_position.py
 tests/test_decoder_shapefile.py
 tests/test_decoder_time_series.py
 tests/test_decoder_vertical_profile.py
@@ -101,6 +103,8 @@ tests/data/test_geotiff.json
 tests/data/test_multipoint_coverage.json
 tests/data/test_path_coverage.json
 tests/data/test_timeseries_coverage.json
+tests/data/test_timeseries_param_t.json
 tests/data/test_timeseries_xyz_coverage.json
 tests/data/test_verticalprofile_coverage.json
+tests/data/test_verticalprofile_param_t.json
 tests/data/test_verticalprofile_xyz_coverage.json

{covjsonkit-0.2.18 → covjsonkit-0.2.19}/pyproject.toml

@@ -8,7 +8,7 @@ markers = ["data: uses test data (deselect with '-m \"not data\"')",]
 
 [project]
 name = "covjsonkit"
-version = "0.2.18"
+version = "0.2.19"
 dependencies = [
     "pandas<3",
     "orjson",

covjsonkit-0.2.19/tests/data/test_timeseries_param_t.json

@@ -0,0 +1,47 @@
+{
+    "type": "CoverageCollection",
+    "domainType": "PointSeries",
+    "coverages": [
+        {
+            "mars:metadata": {
+                "Forecast date": "2026-05-04T18:00:00Z",
+                "number": 1
+            },
+            "type": "Coverage",
+            "domain": {
+                "type": "Domain",
+                "axes": {
+                    "latitude": {"values": [47.5]},
+                    "longitude": {"values": [8.5]},
+                    "levelist": {"values": [74]},
+                    "t": {"values": ["2026-05-04T18:00:00Z"]}
+                }
+            },
+            "ranges": {
+                "t": {
+                    "type": "NdArray",
+                    "dataType": "float",
+                    "shape": [1],
+                    "axisNames": ["t"],
+                    "values": [285.6]
+                }
+            }
+        }
+    ],
+    "referencing": [
+        {
+            "coordinates": ["latitude", "longitude", "levelist"],
+            "system": {"type": "GeographicCRS"}
+        }
+    ],
+    "parameters": {
+        "t": {
+            "type": "Parameter",
+            "unit": {"symbol": "K"},
+            "observedProperty": {
+                "id": "t",
+                "label": {"en": "Temperature"}
+            }
+        }
+    }
+}

covjsonkit-0.2.19/tests/data/test_verticalprofile_param_t.json

@@ -0,0 +1,94 @@
+{
+    "type": "CoverageCollection",
+    "domainType": "VerticalProfile",
+    "coverages": [
+        {
+            "mars:metadata": {
+                "class": "od",
+                "Forecast date": "2026-05-06T18:00:00Z",
+                "expver": "0001",
+                "levelist": 100,
+                "levtype": "pl",
+                "model": "icon-ch1-eps",
+                "step": 0,
+                "stream": "enfo",
+                "timespan": "none",
+                "type": "cf",
+                "number": 0
+            },
+            "type": "Coverage",
+            "domain": {
+                "type": "Domain",
+                "axes": {
+                    "latitude": {
+                        "values": [
+                            47.45541763305664
+                        ]
+                    },
+                    "longitude": {
+                        "values": [
+                            8.560781121253967
+                        ]
+                    },
+                    "levelist": {
+                        "values": [
+                            100,
+                            150
+                        ]
+                    },
+                    "t": {
+                        "values": [
+                            "2026-05-06T18:00:00Z"
+                        ]
+                    }
+                }
+            },
+            "ranges": {
+                "t": {
+                    "type": "NdArray",
+                    "dataType": "float",
+                    "shape": [
+                        2
+                    ],
+                    "axisNames": [
+                        "levelist"
+                    ],
+                    "values": [
+                        218.3372802734375,
+                        219.89144897460938
+                    ]
+                }
+            }
+        }
+    ],
+    "referencing": [
+        {
+            "coordinates": [
+                "latitude",
+                "longitude",
+                "levelist"
+            ],
+            "system": {
+                "type": "GeographicCRS",
+                "id": "http://www.opengis.net/def/crs/OGC/1.3/CRS84"
+            }
+        }
+    ],
+    "parameters": {
+        "t": {
+            "type": "Parameter",
+            "description": {
+                "en": null
+            },
+            "unit": {
+                "symbol": "K"
+            },
+            "observedProperty": {
+                "id": "t",
+                "label": {
+                    "en": "Temperature"
+                }
+            }
+        }
+    }
+}

{covjsonkit-0.2.18 → covjsonkit-0.2.19}/tests/test_decoder_bounding_box.py

@@ -68,7 +68,7 @@ class TestDecoder:
                     "domain": {
                         "type": "Domain",
                         "axes": {
-                            "t": {"values": ["2017-01-01T01:00:00"]},
+                            "t": {"values": ["2017-01-01T00:00:00"]},
                             "composite": {
                                 "dataType": "tuple",
                                 "coordinates": ["x", "y", "z"],
@@ -190,7 +190,7 @@ class TestDecoder:
         domain2 = {
             "type": "Domain",
             "axes": {
-                "t": {"values": ["2017-01-01T01:00:00"]},
+                "t": {"values": ["2017-01-01T00:00:00"]},
                 "composite": {
                     "dataType": "tuple",
                     "coordinates": ["x", "y", "z"],
@@ -263,7 +263,13 @@ class TestDecoder:
         }
         assert decoder.get_values() == values
 
-    # def test_bounding_box_to_xarray(self):
-    #    decoder = BoundingBox.BoundingBox(self.covjson)
-    #    dataset = decoder.to_xarray()
-    #    print(dataset)
+    def test_bounding_box_to_xarray_param_t(self):
+        """to_xarray works with param 't' - no collision since dims use 'datetimes'."""
+        decoder = BoundingBox.BoundingBox(self.covjson)
+        ds = decoder.to_xarray()
+
+        # Param 't' should be in data_vars (no collision with 'datetimes' dim)
+        assert "t" in ds.data_vars, f"Expected 't' in data_vars, got {list(ds.data_vars)}"
+        assert "p" in ds.data_vars
+        # Time dimension is 'datetimes', not 't'
+        assert "datetimes" in ds.dims

covjsonkit-0.2.19/tests/test_decoder_circle.py

@@ -0,0 +1,71 @@
+"""Tests for Circle decoder's to_xarray method."""
+
+from covjsonkit.decoder import Circle
+
+
+class TestCircleDecoder:
+    def setup_method(self):
+        self.covjson = {
+            "type": "CoverageCollection",
+            "domainType": "circle",
+            "coverages": [
+                {
+                    "mars:metadata": {
+                        "class": "od",
+                        "stream": "oper",
+                        "levtype": "pl",
+                        "date": "20170101",
+                        "step": "0",
+                        "number": "0",
+                    },
+                    "type": "Coverage",
+                    "domain": {
+                        "type": "Domain",
+                        "axes": {
+                            "t": {"values": ["2017-01-01T00:00:00"]},
+                            "composite": {
+                                "dataType": "tuple",
+                                "coordinates": ["x", "y", "z"],
+                                "values": [[1, 20, 1], [2, 21, 3]],
+                            },
+                        },
+                    },
+                    "ranges": {
+                        "t": {
+                            "type": "NdArray",
+                            "dataType": "float",
+                            "shape": [2],
+                            "axisNames": ["t"],
+                            "values": [264.9, 263.8],
+                        },
+                    },
+                },
+            ],
+            "referencing": [
+                {
+                    "coordinates": ["x", "y", "z"],
+                    "system": {
+                        "type": "GeographicCRS",
+                        "id": "http://www.opengis.net/def/crs/OGC/1.3/CRS84",
+                    },
+                }
+            ],
+            "parameters": {
+                "t": {
+                    "type": "Parameter",
+                    "description": "Temperature",
+                    "unit": {"symbol": "K"},
+                    "observedProperty": {"id": "t", "label": {"en": "Temperature"}},
+                },
+            },
+        }
+
+    def test_circle_to_xarray_param_t_no_collision(self):
+        """to_xarray works with param 't' - no collision since dims use 'datetimes'."""
+        decoder = Circle.Circle(self.covjson)
+        ds = decoder.to_xarray()
+
+        # Param 't' should be in data_vars (no collision with 'datetimes' dim)
+        assert "t" in ds.data_vars, f"Expected 't' in data_vars, got {list(ds.data_vars)}"
+        # Time dimension is 'datetimes', not 't'
+        assert "datetimes" in ds.dims

{covjsonkit-0.2.18 → covjsonkit-0.2.19}/tests/test_decoder_frame.py

@@ -314,3 +314,13 @@ class TestDecoder:
         # MARS metadata from the first coverage is attached as dataset attrs
         assert ds.attrs["step"] == "0"
         assert ds.attrs["class"] == "od"
+
+    def test_to_xarray_param_t_no_collision(self):
+        """to_xarray works with param 't' - no collision since dims use 'time'."""
+        decoder = Frame.Frame(self.covjson)
+        ds = decoder.to_xarray()
+
+        # Param 't' should be in data_vars (no collision with 'time' dim)
+        assert "t" in ds.data_vars, f"Expected 't' in data_vars, got {list(ds.data_vars)}"
+        # Time dimension is 'time', not 't'
+        assert "time" in ds.dims