pproc-core 0.1.0__py3-none-any.whl

earthkit/workflows/plugins/pproc/_version.py

@@ -0,0 +1,2 @@
+# Do not change! Do not track in version control!
+__version__ = "0.1.0"

earthkit/workflows/plugins/pproc/config/accumulation.py

@@ -0,0 +1,58 @@
+# SPDX-FileCopyrightText: 2026 European Centre for Medium-Range Weather Forecasts (ECMWF)
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from typing import Literal, Optional, Union, Annotated
+import datetime
+
+from earthkit.time.calendar import MonthInYear
+from earthkit.time.sequence import MonthlySequence
+
+from pydantic import Field, ConfigDict
+
+from earthkit.workflows.plugins.pproc.utils.pydantic_utils import PProcBaseModel
+
+NumericCoord = int
+NumericCoords = Union[list[int], range]
+
+Coord = Union[str, NumericCoord]
+Coords = Union[list[str], NumericCoords]
+
+
+class Default(PProcBaseModel):
+    model_config = ConfigDict(validate_by_name=True)
+
+    type_: Literal["default"] = Field("default", alias="type")
+    length: Optional[int] = None
+
+    def name(self, coords: Coords) -> str:
+        if len(coords) == 0:
+            return ""
+        end = coords[-1]
+        if len(coords) == 1 and (self.length is None or isinstance(coords[0], str)):
+            return f"{end}"
+        start = coords[0] if self.length is None else int(end) - self.length
+        return f"{start}-{end}"
+
+
+class Monthly(PProcBaseModel):
+    model_config = ConfigDict(validate_by_name=True)
+
+    type_: Literal["monthly"] = Field("monthly", alias="type")
+    date: str
+
+    def name(self, coords: Coords) -> str:
+        if len(coords) == 0:
+            return ""
+        end = coords[-1]
+        fcdate = datetime.datetime.strptime(self.date, "%Y%m%d")
+        end = int(end)
+        seq = MonthlySequence(1)
+        seq.next(fcdate, False)
+        this_month = fcdate + datetime.timedelta(hours=end - 1)
+        month_length = MonthInYear(this_month.year, this_month.month).length() * 24
+        start = end - month_length
+        return f"{start}-{end}"
+
+
+AccumName = Annotated[Union[Default, Monthly], Field(discriminator="type")]

earthkit/workflows/plugins/pproc/config/mask.py

@@ -0,0 +1,25 @@
+# SPDX-FileCopyrightText: 2026 European Centre for Medium-Range Weather Forecasts (ECMWF)
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from typing import Any, Literal
+
+from pydantic import model_validator
+
+from earthkit.workflows.plugins.pproc.utils.pydantic_utils import PProcBaseModel
+
+
+class MaskExpression(PProcBaseModel):
+    select: dict
+    comparison: Literal["<", ">", ">=", "<=", "==", "!="]
+    value: float
+
+    @model_validator(mode="before")
+    @classmethod
+    def validate_model(cls, data: Any) -> Any:
+        if isinstance(data, list):
+            assert (
+                len(data) == 3
+            ), "Mask expression should be a [select, comparison, value] list"
+            return {"select": data[0], "comparison": data[1], "value": data[2]}
+        return data

earthkit/workflows/plugins/pproc/config/threshold.py

@@ -0,0 +1,47 @@
+# SPDX-FileCopyrightText: 2026 European Centre for Medium-Range Weather Forecasts (ECMWF)
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from pydantic import model_validator
+from typing import Any, Optional, Literal
+
+from earthkit.workflows.plugins.pproc.utils.pydantic_utils import PProcBaseModel
+
+Comparisons = Literal["<", ">", "<=", ">="]
+
+
+class Threshold(PProcBaseModel):
+    select: Optional[dict] = None
+    lower_scale_factor: int = 0
+    lower_comparison: Comparisons
+    lower_value: float
+    upper_scale_factor: int = 0
+    upper_comparison: Optional[Comparisons] = None
+    upper_value: Optional[float] = None
+
+    @model_validator(mode="before")
+    def validate_threshold(cls, data: Any) -> Any:
+        if isinstance(data, dict):
+            if "comparison" in data:
+                data["lower_comparison"] = data.pop("comparison")
+                data["lower_value"] = data.pop("value")
+                data["lower_scale_factor"] = data.pop("scale_factor", 0)
+            if any(k in data for k in ["upper_comparison", "upper_value"]) and not all(
+                k in data for k in ["upper_comparison", "upper_value"]
+            ):
+                raise ValueError(
+                    "Both upper_comparison and upper_value must be provided together"
+                )
+            # Derive scale factors for custom thresholds
+            for value in ["lower_value", "upper_value"]:
+                upper_or_lower = value.split("_")[0]
+                if (
+                    isinstance(data.get(value), float)
+                    and f"{upper_or_lower}_scale_factor" not in data
+                ):
+                    scale_factor = 0
+                    while abs(data[value] * 10**scale_factor) < 1:
+                        scale_factor += 1
+                    data[f"{upper_or_lower}_scale_factor"] = scale_factor
+                    data[value] = round(data[value] * 10**scale_factor)
+        return data