From c99aff85c75d2e2f76dae60bd6a4155aa43b8dda Mon Sep 17 00:00:00 2001 From: Amirabbas Jalali <258926044+amirabbas-jalali-bentley@users.noreply.github.com> Date: Tue, 17 Nov 2026 14:17:07 -0600 Subject: [PATCH 1/5] Align SearchNeighborhood wire schema and add drillhole limit controls - Rename max_drillholes_per_estimate to max_drillholes while accepting max_drillholes_per_estimate via AliasChoices, rejecting conflicting alias values, and preserving a read-only .max_drillholes_per_estimate property. - Add min_drillholes (and min_drillholes_per_estimate alias, omitted when None or 0) and drillhole_limit_scope (omitted when None or 'global'). - Enforce cross-field validation on SearchNeighborhood for non-global drillhole_limit_scope, drillhole bounds, and sample/sector ceilings. - Annotate ellipsoid with PlainValidator, PlainSerializer, and WithJsonSchema and use a wrap model serializer so SearchNeighborhood.model_json_schema() describes the wire payload accurately. --- .../src/evo/compute/tasks/common/search.py | 278 ++++++++++++++++-- .../geostatistics/test_break_ties_tasks.py | 4 +- .../tests/geostatistics/test_idw_tasks.py | 5 +- packages/evo-compute/tests/test_tasks.py | 216 +++++++++++++- 4 files changed, 473 insertions(+), 30 deletions(-) diff --git a/packages/evo-compute/src/evo/compute/tasks/common/search.py b/packages/evo-compute/src/evo/compute/tasks/common/search.py index 5cae21091..93ff79e25 100644 --- a/packages/evo-compute/src/evo/compute/tasks/common/search.py +++ b/packages/evo-compute/src/evo/compute/tasks/common/search.py @@ -13,10 +13,21 @@ from __future__ import annotations -from typing import Any +from collections.abc import Mapping +from typing import Annotated, Any, Literal -from evo.objects.typed.types import Ellipsoid -from pydantic import BaseModel, Field, model_serializer, model_validator +from evo.objects.typed.types import Ellipsoid, EllipsoidRanges, Rotation +from pydantic import ( + AliasChoices, + BaseModel, + Field, + PlainSerializer, + PlainValidator, + SerializerFunctionWrapHandler, + WithJsonSchema, + model_serializer, + model_validator, +) __all__ = [ "SearchNeighborhood", @@ -28,9 +39,107 @@ "max_empty_quadrants", "max_samples_per_quadrant", "max_samples_per_drillhole", - "max_drillholes_per_estimate", + "max_drillholes", ) +_ELLIPSOID_JSON_SCHEMA: dict[str, Any] = { + "type": "object", + "title": "Ellipsoid", + "additionalProperties": False, + "required": ["ellipsoid_ranges", "rotation"], + "properties": { + "ellipsoid_ranges": { + "type": "object", + "title": "Ellipsoid Ranges", + "additionalProperties": False, + "required": ["major", "semi_major", "minor"], + "properties": { + "major": {"type": "number", "exclusiveMinimum": 0, "title": "Major"}, + "semi_major": {"type": "number", "exclusiveMinimum": 0, "title": "Semi Major"}, + "minor": {"type": "number", "exclusiveMinimum": 0, "title": "Minor"}, + }, + }, + "rotation": { + "type": "object", + "title": "Rotation", + "additionalProperties": False, + "properties": { + "dip_azimuth": {"type": "number", "minimum": 0, "maximum": 360, "default": 0, "title": "Dip Azimuth"}, + "dip": {"type": "number", "minimum": 0, "maximum": 180, "default": 0, "title": "Dip"}, + "pitch": {"type": "number", "minimum": 0, "maximum": 360, "default": 0, "title": "Pitch"}, + }, + }, + }, +} + + +def _parse_ellipsoid_ranges(raw: Any) -> EllipsoidRanges: + if isinstance(raw, EllipsoidRanges): + return raw + if isinstance(raw, Mapping): + unknown = set(raw) - {"major", "semi_major", "minor"} + if unknown: + raise ValueError(f"Unexpected ellipsoid_ranges field(s): {', '.join(sorted(map(str, unknown)))}.") + missing = {"major", "semi_major", "minor"} - set(raw) + if missing: + raise ValueError(f"Missing ellipsoid_ranges field(s): {', '.join(sorted(missing))}.") + try: + return EllipsoidRanges(major=raw["major"], semi_major=raw["semi_major"], minor=raw["minor"]) + except TypeError as exc: + raise ValueError(str(exc)) from exc + try: + return EllipsoidRanges.from_array_like(raw) + except TypeError as exc: + raise ValueError(str(exc)) from exc + + +def _parse_rotation(raw: Any) -> Rotation | None: + if raw is None or isinstance(raw, Rotation): + return raw + if isinstance(raw, Mapping): + unknown = set(raw) - {"dip_azimuth", "dip", "pitch"} + if unknown: + raise ValueError(f"Unexpected rotation field(s): {', '.join(sorted(map(str, unknown)))}.") + try: + return Rotation( + dip_azimuth=raw["dip_azimuth"] if "dip_azimuth" in raw else 0.0, + dip=raw["dip"] if "dip" in raw else 0.0, + pitch=raw["pitch"] if "pitch" in raw else 0.0, + ) + except TypeError as exc: + raise ValueError(str(exc)) from exc + try: + return Rotation.from_array_like(raw) + except TypeError as exc: + raise ValueError(str(exc)) from exc + + +def _validate_ellipsoid(value: Any) -> Ellipsoid: + if isinstance(value, Ellipsoid): + return value + if not isinstance(value, Mapping): + raise ValueError(f"Expected an Ellipsoid or mapping, got {type(value).__name__}.") + unknown = set(value) - {"ellipsoid_ranges", "ranges", "rotation"} + if unknown: + raise ValueError(f"Unexpected ellipsoid field(s): {', '.join(sorted(map(str, unknown)))}.") + if "ellipsoid_ranges" not in value and "ranges" not in value: + raise ValueError("Ellipsoid mapping requires 'ellipsoid_ranges' (or 'ranges').") + if "ellipsoid_ranges" in value and "ranges" in value: + wire_ranges = _parse_ellipsoid_ranges(value["ellipsoid_ranges"]) + attr_ranges = _parse_ellipsoid_ranges(value["ranges"]) + if wire_ranges.to_dict() != attr_ranges.to_dict(): + raise ValueError("Conflicting 'ellipsoid_ranges' and 'ranges' values on ellipsoid.") + ranges = wire_ranges + elif "ellipsoid_ranges" in value: + ranges = _parse_ellipsoid_ranges(value["ellipsoid_ranges"]) + else: + ranges = _parse_ellipsoid_ranges(value["ranges"]) + return Ellipsoid(ranges=ranges, rotation=_parse_rotation(value.get("rotation"))) + + +def _serialize_ellipsoid(ellipsoid: Ellipsoid) -> dict[str, Any]: + return ellipsoid.to_dict() + class SearchNeighborhood(BaseModel): """Search neighborhood parameters for geostatistical operations. @@ -42,7 +151,9 @@ class SearchNeighborhood(BaseModel): orientation) and constraints on the number of samples to use. Kriging, IDW, KNN and declustering can further limit the samples by octant, - quadrant and drillhole. The other tasks do not support these limits and + quadrant and drillhole (``max_samples_per_drillhole`` and ``max_drillholes``). + Kriging additionally supports ``min_drillholes`` and non-global + ``drillhole_limit_scope``. The other tasks do not support these limits and refuse a neighborhood that sets them. Example:: @@ -50,24 +161,28 @@ class SearchNeighborhood(BaseModel): >>> search = SearchNeighborhood( ... ellipsoid=Ellipsoid( ... ranges=EllipsoidRanges(major=200.0, semi_major=150.0, minor=100.0), - ... rotation=Rotation(dip_azimuth=45.0), + ... rotation=Rotation(dip_azimuth=45.0, dip=0.0, pitch=0.0), ... ), ... max_samples=20, ... ) >>> - >>> # Octant search, using at most 3 samples from each drillhole: + >>> # Octant search, using at most 3 samples from each drillhole across at most 6 drillholes: >>> search = SearchNeighborhood( ... ellipsoid=Ellipsoid(ranges=EllipsoidRanges(major=200.0, semi_major=150.0, minor=100.0)), ... max_samples=24, ... max_samples_per_octant=3, ... max_empty_octants=4, ... max_samples_per_drillhole=3, + ... max_drillholes=6, ... ) """ - model_config = {"arbitrary_types_allowed": True} - - ellipsoid: Ellipsoid + ellipsoid: Annotated[ + Ellipsoid, + PlainValidator(_validate_ellipsoid), + PlainSerializer(_serialize_ellipsoid), + WithJsonSchema(_ELLIPSOID_JSON_SCHEMA), + ] """The ellipsoid defining the spatial extent to search for samples.""" max_samples: int = Field(ge=1) @@ -100,34 +215,151 @@ class SearchNeighborhood(BaseModel): max_samples_per_drillhole: int | None = Field(None, ge=1) """The maximum number of samples to use from each drillhole. Requires a downhole intervals source object.""" - max_drillholes_per_estimate: int | None = Field(None, ge=1) + max_drillholes: int | None = Field( + None, + ge=1, + validation_alias=AliasChoices("max_drillholes", "max_drillholes_per_estimate"), + ) """The maximum number of drillholes used in each estimate. Requires a downhole intervals source object.""" + min_drillholes: int | None = Field( + None, + ge=0, + validation_alias=AliasChoices("min_drillholes", "min_drillholes_per_estimate"), + ) + """The minimum number of distinct drillholes required per estimate. + + Omitted (disabled) when ``None`` or ``0``. Currently supported only by kriging + and requires a downhole intervals source object. + """ + + drillhole_limit_scope: Literal["global", "quadrant", "octant"] | None = None + """Scope at which ``max_samples_per_drillhole`` is applied. + + ``"global"`` (or ``None``) applies ``max_samples_per_drillhole`` across the whole + neighborhood and is omitted on the wire. ``"quadrant"`` and ``"octant"`` apply + ``max_samples_per_drillhole`` within each sector, require ``max_samples_per_drillhole`` + to be set, and are currently supported only by kriging. + """ + + @property + def max_drillholes_per_estimate(self) -> int | None: + """Backwards-compatible alias for :attr:`max_drillholes`.""" + return self.max_drillholes + + @model_validator(mode="before") + @classmethod + def _reject_conflicting_aliases(cls, data: Any) -> Any: + if isinstance(data, Mapping): + for canonical, legacy in ( + ("max_drillholes", "max_drillholes_per_estimate"), + ("min_drillholes", "min_drillholes_per_estimate"), + ): + if canonical in data and legacy in data and data[canonical] != data[legacy]: + raise ValueError( + f"Conflicting values for {canonical!r} ({data[canonical]!r}) and {legacy!r} ({data[legacy]!r})." + ) + return data + @model_validator(mode="after") def _check_sample_limits(self) -> SearchNeighborhood: - if self.min_samples is not None and self.min_samples > self.max_samples: + if self.drillhole_limit_scope in ("quadrant", "octant") and self.max_samples_per_drillhole is None: raise ValueError( - f"min_samples must be between 1 and max_samples ({self.max_samples}), got {self.min_samples}." + f"drillhole_limit_scope={self.drillhole_limit_scope!r} requires max_samples_per_drillhole to be set." ) + + if self.min_drillholes is not None and self.max_drillholes is not None: + if self.min_drillholes > self.max_drillholes: + raise ValueError( + f"min_drillholes ({self.min_drillholes}) cannot exceed max_drillholes ({self.max_drillholes})." + ) + + scope_sectors = {"quadrant": 4, "octant": 8}.get(self.drillhole_limit_scope or "global", 1) + sample_ceilings: list[tuple[int, str]] = [(self.max_samples, f"max_samples ({self.max_samples})")] + if self.max_samples_per_octant is not None: + octant_ceiling = 8 * self.max_samples_per_octant + sample_ceilings.append((octant_ceiling, f"8 * max_samples_per_octant ({octant_ceiling})")) + if self.max_samples_per_quadrant is not None: + quadrant_ceiling = 4 * self.max_samples_per_quadrant + sample_ceilings.append((quadrant_ceiling, f"4 * max_samples_per_quadrant ({quadrant_ceiling})")) + if self.max_drillholes is not None and self.max_samples_per_drillhole is not None: + drillhole_ceiling = self.max_drillholes * self.max_samples_per_drillhole * scope_sectors + if scope_sectors == 1: + label = f"max_drillholes * max_samples_per_drillhole ({drillhole_ceiling})" + else: + label = ( + f"max_drillholes * max_samples_per_drillhole * {scope_sectors} " + f"({self.drillhole_limit_scope} sectors = {drillhole_ceiling})" + ) + sample_ceilings.append((drillhole_ceiling, label)) + + if self.min_samples is not None: + for ceiling, label in sample_ceilings: + if self.min_samples > ceiling: + raise ValueError(f"min_samples ({self.min_samples}) cannot exceed {label}.") + + if self.min_drillholes is not None and self.min_drillholes > 0: + for ceiling, label in sample_ceilings: + if self.min_drillholes > ceiling: + raise ValueError(f"min_drillholes ({self.min_drillholes}) cannot exceed {label}.") + + if self.max_empty_octants is not None: + required_octants = 8 - self.max_empty_octants + for ceiling, label in sample_ceilings: + if required_octants > ceiling: + raise ValueError( + f"max_empty_octants={self.max_empty_octants} requires at least {required_octants} " + f"occupied octants, which exceeds {label}." + ) + + if self.max_empty_quadrants is not None: + required_quadrants = 4 - self.max_empty_quadrants + for ceiling, label in sample_ceilings: + if required_quadrants > ceiling: + raise ValueError( + f"max_empty_quadrants={self.max_empty_quadrants} requires at least {required_quadrants} " + f"occupied quadrants, which exceeds {label}." + ) + return self - @model_serializer - def _serialize(self) -> dict[str, Any]: - result = { - "ellipsoid": self.ellipsoid.to_dict(), - "max_samples": self.max_samples, + @model_serializer(mode="wrap") + def _serialize(self, handler: SerializerFunctionWrapHandler): + return { + key: value + for key, value in handler(self).items() + if value is not None + and not (key == "min_drillholes" and value == 0) + and not (key == "drillhole_limit_scope" and value == "global") } - for name in ("min_samples", *_SECTOR_AND_DRILLHOLE_LIMITS): - if (value := getattr(self, name)) is not None: - result[name] = value - return result + + +def _active_kriging_only_drillhole_limits(neighborhood: SearchNeighborhood) -> list[str]: + limits: list[str] = [] + if neighborhood.min_drillholes is not None and neighborhood.min_drillholes > 0: + limits.append("min_drillholes") + if neighborhood.drillhole_limit_scope not in (None, "global"): + limits.append("drillhole_limit_scope") + return limits def _reject_sector_and_drillhole_limits(neighborhood: SearchNeighborhood) -> SearchNeighborhood: """Refuse octant, quadrant and drillhole limits, for tasks whose service does not accept them.""" - if limits := [name for name in _SECTOR_AND_DRILLHOLE_LIMITS if getattr(neighborhood, name) is not None]: + limits = [name for name in _SECTOR_AND_DRILLHOLE_LIMITS if getattr(neighborhood, name) is not None] + limits.extend(_active_kriging_only_drillhole_limits(neighborhood)) + if limits: raise ValueError( f"This task does not support {', '.join(limits)}. " "Octant, quadrant and drillhole limits are only available for kriging, IDW, KNN and declustering." ) return neighborhood + + +def _reject_kriging_only_drillhole_limits(neighborhood: SearchNeighborhood) -> SearchNeighborhood: + """Refuse drillhole limits that are only supported by the kriging task.""" + if limits := _active_kriging_only_drillhole_limits(neighborhood): + raise ValueError( + f"This task does not support {', '.join(limits)}. " + "min_drillholes and non-global drillhole_limit_scope are only supported by Kriging." + ) + return neighborhood diff --git a/packages/evo-compute/tests/geostatistics/test_break_ties_tasks.py b/packages/evo-compute/tests/geostatistics/test_break_ties_tasks.py index e1cafb66d..4f6da5c1e 100644 --- a/packages/evo-compute/tests/geostatistics/test_break_ties_tasks.py +++ b/packages/evo-compute/tests/geostatistics/test_break_ties_tasks.py @@ -168,9 +168,9 @@ def test_search_limits_are_refused(self): search = SearchNeighborhood( ellipsoid=Ellipsoid(ranges=EllipsoidRanges(major=200, semi_major=150, minor=100)), max_samples=20, - max_drillholes_per_estimate=4, + max_drillholes=4, ) - with self.assertRaisesRegex(ValidationError, "does not support max_drillholes_per_estimate"): + with self.assertRaisesRegex(ValidationError, "does not support max_drillholes"): self._params(neighborhood=search) def test_default_seed(self): diff --git a/packages/evo-compute/tests/geostatistics/test_idw_tasks.py b/packages/evo-compute/tests/geostatistics/test_idw_tasks.py index f3748a716..5bf39a009 100644 --- a/packages/evo-compute/tests/geostatistics/test_idw_tasks.py +++ b/packages/evo-compute/tests/geostatistics/test_idw_tasks.py @@ -228,11 +228,12 @@ def test_search_limits_in_neighborhood(self): ellipsoid=Ellipsoid(ranges=EllipsoidRanges(major=200, semi_major=150, minor=100)), max_samples=20, max_empty_quadrants=1, - max_drillholes_per_estimate=4, + max_drillholes=4, ) d = _dump(_params(neighborhood=search)) self.assertEqual(d["neighborhood"]["max_empty_quadrants"], 1) - self.assertEqual(d["neighborhood"]["max_drillholes_per_estimate"], 4) + self.assertEqual(d["neighborhood"]["max_drillholes"], 4) + self.assertNotIn("max_drillholes_per_estimate", d["neighborhood"]) def test_sample_limit_boundaries_in_neighborhood(self): ellipsoid = Ellipsoid(ranges=EllipsoidRanges(major=200, semi_major=150, minor=100)) diff --git a/packages/evo-compute/tests/test_tasks.py b/packages/evo-compute/tests/test_tasks.py index 0c3ec41bb..e0e50d91a 100644 --- a/packages/evo-compute/tests/test_tasks.py +++ b/packages/evo-compute/tests/test_tasks.py @@ -19,7 +19,7 @@ from pydantic import ValidationError from evo.compute.tasks import SearchNeighborhood, run -from evo.compute.tasks.common import Ellipsoid, EllipsoidRanges +from evo.compute.tasks.common import Ellipsoid, EllipsoidRanges, Rotation from evo.compute.tasks.common.results import TaskAttribute, TaskResultList, TaskTarget from evo.compute.tasks.common.runner import TaskRegistry, run_tasks from evo.compute.tasks.common.source_target import _convert_object_reference @@ -308,7 +308,7 @@ def test_raises_for_invalid_url(self): class TestSearchNeighborhood(unittest.TestCase): - """Tests for sample, octant, quadrant and drillhole limits on SearchNeighborhood.""" + """Tests for sample, octant, quadrant, drillhole limits and wire schema on SearchNeighborhood.""" LIMITS = { "max_empty_octants": 4, @@ -316,7 +316,9 @@ class TestSearchNeighborhood(unittest.TestCase): "max_empty_quadrants": 1, "max_samples_per_quadrant": 5, "max_samples_per_drillhole": 2, - "max_drillholes_per_estimate": 6, + "max_drillholes": 6, + "min_drillholes": 2, + "drillhole_limit_scope": "octant", } def _search(self, max_samples: int = 24, **limits) -> SearchNeighborhood: @@ -329,6 +331,9 @@ def _search(self, max_samples: int = 24, **limits) -> SearchNeighborhood: def test_limits_are_omitted_unless_set(self): search = self._search() self.assertIsNone(search.min_samples) + self.assertIsNone(search.max_drillholes) + self.assertIsNone(search.min_drillholes) + self.assertIsNone(search.drillhole_limit_scope) self.assertEqual(set(search.model_dump(mode="json")), {"ellipsoid", "max_samples"}) def test_sample_limit_boundaries_are_accepted(self): @@ -372,11 +377,216 @@ def test_limits_outside_the_service_bounds_are_refused(self): ("max_samples_per_octant", 0), ("max_samples_per_quadrant", 0), ("max_samples_per_drillhole", 0), + ("max_drillholes", 0), ("max_drillholes_per_estimate", 0), + ("min_drillholes", -1), + ("min_drillholes_per_estimate", -1), + ("drillhole_limit_scope", "sector"), ]: with self.subTest(name=name, value=value), self.assertRaises(ValidationError): self._search(**{name: value}) + def test_max_drillholes_backwards_compatibility(self): + via_canonical = self._search(max_drillholes=6) + self.assertEqual(via_canonical.max_drillholes, 6) + self.assertEqual(via_canonical.max_drillholes_per_estimate, 6) + dumped_canonical = via_canonical.model_dump(mode="json", by_alias=True, exclude_none=True) + self.assertEqual(dumped_canonical["max_drillholes"], 6) + self.assertNotIn("max_drillholes_per_estimate", dumped_canonical) + + via_legacy = self._search(max_drillholes_per_estimate=6) + self.assertEqual(via_legacy.max_drillholes, 6) + self.assertEqual(via_legacy.max_drillholes_per_estimate, 6) + dumped_legacy = via_legacy.model_dump(mode="json", by_alias=True, exclude_none=True) + self.assertEqual(dumped_legacy["max_drillholes"], 6) + self.assertNotIn("max_drillholes_per_estimate", dumped_legacy) + + with self.assertRaises(AttributeError): + via_canonical.max_drillholes_per_estimate = 4 # type: ignore[misc] + + def test_conflicting_drillhole_aliases_are_rejected(self): + ellipsoid = Ellipsoid(ranges=EllipsoidRanges(major=200, semi_major=150, minor=100)) + equal = SearchNeighborhood.model_validate( + { + "ellipsoid": ellipsoid, + "max_samples": 24, + "max_drillholes": 6, + "max_drillholes_per_estimate": 6, + "min_drillholes": 2, + "min_drillholes_per_estimate": 2, + } + ) + self.assertEqual(equal.max_drillholes, 6) + self.assertEqual(equal.min_drillholes, 2) + + for conflicting in [ + {"max_drillholes": 6, "max_drillholes_per_estimate": 4}, + {"max_drillholes": None, "max_drillholes_per_estimate": 4}, + {"min_drillholes": 2, "min_drillholes_per_estimate": 3}, + {"min_drillholes": 0, "min_drillholes_per_estimate": 2}, + ]: + with self.subTest(**conflicting), self.assertRaisesRegex(ValidationError, "Conflicting values"): + SearchNeighborhood.model_validate({"ellipsoid": ellipsoid, "max_samples": 24, **conflicting}) + + def test_min_drillholes_omitted_when_none_or_zero_and_emitted_when_positive(self): + for kwargs in [{}, {"min_drillholes": None}, {"min_drillholes": 0}, {"min_drillholes_per_estimate": 0}]: + with self.subTest(**kwargs): + dumped = self._search(**kwargs).model_dump(mode="json", by_alias=True, exclude_none=True) + self.assertNotIn("min_drillholes", dumped) + self.assertNotIn("min_drillholes_per_estimate", dumped) + + for kwargs in [{"min_drillholes": 3}, {"min_drillholes_per_estimate": 3}]: + with self.subTest(**kwargs): + dumped = self._search(**kwargs).model_dump(mode="json", by_alias=True, exclude_none=True) + self.assertEqual(dumped["min_drillholes"], 3) + self.assertNotIn("min_drillholes_per_estimate", dumped) + + def test_drillhole_limit_scope_omitted_when_global_and_requires_samples_per_drillhole(self): + for scope in (None, "global"): + with self.subTest(scope=scope): + dumped = self._search(drillhole_limit_scope=scope).model_dump( + mode="json", by_alias=True, exclude_none=True + ) + self.assertNotIn("drillhole_limit_scope", dumped) + + for scope in ("quadrant", "octant"): + with self.subTest(scope=scope): + with self.assertRaisesRegex(ValidationError, "requires max_samples_per_drillhole"): + self._search(drillhole_limit_scope=scope) + + dumped = self._search(max_samples_per_drillhole=2, drillhole_limit_scope=scope).model_dump( + mode="json", by_alias=True, exclude_none=True + ) + self.assertEqual(dumped["drillhole_limit_scope"], scope) + self.assertEqual(dumped["max_samples_per_drillhole"], 2) + + def test_contradictory_neighborhood_bounds_are_rejected(self): + valid_cases = [ + {"max_samples": 8, "min_samples": 8, "max_samples_per_octant": 1}, + {"max_samples": 8, "min_samples": 8, "max_samples_per_quadrant": 2}, + {"max_samples": 20, "min_drillholes": 4, "max_drillholes": 4}, + {"max_samples": 6, "min_samples": 6, "max_drillholes": 3, "max_samples_per_drillhole": 2}, + { + "max_samples": 24, + "min_samples": 16, + "max_drillholes": 2, + "max_samples_per_drillhole": 2, + "drillhole_limit_scope": "quadrant", + }, + { + "max_samples": 32, + "min_samples": 32, + "max_drillholes": 2, + "max_samples_per_drillhole": 2, + "drillhole_limit_scope": "octant", + }, + {"max_samples": 8, "max_empty_octants": 0, "max_samples_per_quadrant": 2}, + { + "max_samples": 16, + "max_empty_octants": 0, + "max_drillholes": 2, + "max_samples_per_drillhole": 2, + "drillhole_limit_scope": "quadrant", + }, + {"max_samples": 4, "max_empty_quadrants": 0, "max_drillholes": 2, "max_samples_per_drillhole": 2}, + ] + for kwargs in valid_cases: + with self.subTest(valid=kwargs): + self._search(**kwargs) + + invalid_cases = [ + {"max_samples": 20, "min_samples": 9, "max_samples_per_octant": 1}, + {"max_samples": 20, "min_samples": 9, "max_samples_per_quadrant": 2}, + {"max_samples": 20, "min_samples": 7, "max_drillholes": 3, "max_samples_per_drillhole": 2}, + { + "max_samples": 24, + "min_samples": 17, + "max_drillholes": 2, + "max_samples_per_drillhole": 2, + "drillhole_limit_scope": "quadrant", + }, + { + "max_samples": 40, + "min_samples": 33, + "max_drillholes": 2, + "max_samples_per_drillhole": 2, + "drillhole_limit_scope": "octant", + }, + {"max_samples": 20, "min_drillholes": 5, "max_drillholes": 4}, + {"max_samples": 4, "min_drillholes": 5}, + {"max_samples": 20, "min_drillholes": 9, "max_samples_per_octant": 1}, + {"max_samples": 20, "min_drillholes": 9, "max_samples_per_quadrant": 2}, + {"max_samples": 5, "max_empty_octants": 2}, + {"max_samples": 20, "max_empty_octants": 0, "max_samples_per_quadrant": 1}, + {"max_samples": 20, "max_empty_octants": 0, "max_drillholes": 2, "max_samples_per_drillhole": 2}, + {"max_samples": 3, "max_empty_quadrants": 0}, + {"max_samples": 20, "max_empty_quadrants": 0, "max_drillholes": 1, "max_samples_per_drillhole": 3}, + ] + for kwargs in invalid_cases: + with self.subTest(invalid=kwargs), self.assertRaises(ValidationError): + self._search(**kwargs) + + def test_model_json_schema_describes_wire_payload_and_round_trips(self): + expected_fields = { + "ellipsoid", + "max_samples", + "min_samples", + "max_empty_octants", + "max_samples_per_octant", + "max_empty_quadrants", + "max_samples_per_quadrant", + "max_samples_per_drillhole", + "max_drillholes", + "min_drillholes", + "drillhole_limit_scope", + } + for mode in ("validation", "serialization"): + with self.subTest(mode=mode): + schema = SearchNeighborhood.model_json_schema(mode=mode) + self.assertEqual(set(schema["properties"]), expected_fields) + self.assertEqual(schema["required"], ["ellipsoid", "max_samples"]) + ellipsoid_schema = schema["properties"]["ellipsoid"] + self.assertIn("ellipsoid_ranges", ellipsoid_schema["properties"]) + self.assertIn("rotation", ellipsoid_schema["properties"]) + self.assertNotIn("ranges", ellipsoid_schema["properties"]) + self.assertNotIn("_rotation", ellipsoid_schema["properties"]) + self.assertEqual( + set(ellipsoid_schema["properties"]["ellipsoid_ranges"]["properties"]), + {"major", "semi_major", "minor"}, + ) + + original = SearchNeighborhood( + ellipsoid=Ellipsoid( + ranges=EllipsoidRanges(major=200.0, semi_major=150.0, minor=100.0), + rotation=Rotation(dip_azimuth=45.0, dip=30.0, pitch=15.0), + ), + max_samples=24, + **self.LIMITS, + ) + wire = original.model_dump(mode="json", by_alias=True, exclude_none=True) + round_tripped = SearchNeighborhood.model_validate(wire) + self.assertEqual(round_tripped.model_dump(mode="json", by_alias=True, exclude_none=True), wire) + + from_attr_dict = SearchNeighborhood.model_validate( + { + "ellipsoid": {"ranges": {"major": 200.0, "semi_major": 150.0, "minor": 100.0}}, + "max_samples": 20, + } + ) + self.assertEqual(from_attr_dict.ellipsoid.ranges.major, 200.0) + + for bad_ellipsoid in [ + { + "ellipsoid_ranges": {"major": 200.0, "semi_major": 150.0, "minor": 100.0}, + "ranges": {"major": 100.0, "semi_major": 150.0, "minor": 100.0}, + }, + {"ellipsoid_ranges": None}, + {"ellipsoid_ranges": {"major": 200.0, "semi_major": 150.0, "minor": 100.0}, "rotation": "none"}, + {1: 2}, + ]: + with self.subTest(bad_ellipsoid=bad_ellipsoid), self.assertRaises(ValidationError): + SearchNeighborhood.model_validate({"ellipsoid": bad_ellipsoid, "max_samples": 20}) + class TestRunTasksDispatch(unittest.IsolatedAsyncioTestCase): """Tests that run_tasks dispatches to concrete runner subclasses, not abstract TaskRunner.""" From 0094577e114b33277506db2cabee8c11b96d558f Mon Sep 17 00:00:00 2001 From: Amirabbas Jalali <258926044+amirabbas-jalali-bentley@users.noreply.github.com> Date: Tue, 17 Nov 2026 14:19:18 -0600 Subject: [PATCH 2/5] Enforce task-specific drillhole limit support across geostatistics tasks - Reject min_drillholes (> 0) and non-global drillhole_limit_scope on IDWParameters, KNNParameters, and DeclusteringParameters with a clear error indicating those options are only supported by Kriging. - Add coverage for Kriging drillhole limits, IDW/KNN/Declustering rejection of Kriging-only drillhole options, and simulation/break-ties rejection of all sector and drillhole limits. --- .../tasks/geostatistics/declustering.py | 8 ++++- .../evo/compute/tasks/geostatistics/idw.py | 8 ++++- .../evo/compute/tasks/geostatistics/knn.py | 8 ++++- .../geostatistics/test_break_ties_tasks.py | 30 +++++++++++++++---- .../test_conditional_turning_bands_tasks.py | 19 +++++++----- .../test_conditioned_simulator_tasks.py | 19 +++++++----- .../geostatistics/test_declustering_tasks.py | 16 ++++++++++ .../tests/geostatistics/test_idw_tasks.py | 23 ++++++++++++++ .../tests/geostatistics/test_knn_tasks.py | 16 ++++++++++ .../tests/geostatistics/test_kriging_tasks.py | 21 +++++++++++++ .../test_simulation_report_tasks.py | 19 +++++++----- 11 files changed, 157 insertions(+), 30 deletions(-) diff --git a/packages/evo-compute/src/evo/compute/tasks/geostatistics/declustering.py b/packages/evo-compute/src/evo/compute/tasks/geostatistics/declustering.py index a04217a13..5c0cc6654 100644 --- a/packages/evo-compute/src/evo/compute/tasks/geostatistics/declustering.py +++ b/packages/evo-compute/src/evo/compute/tasks/geostatistics/declustering.py @@ -61,7 +61,7 @@ from evo.common import IContext, IFeedback from evo.objects import ObjectSchema from evo.objects.typed import BaseObject, object_from_reference -from pydantic import BaseModel, BeforeValidator, Field, SerializerFunctionWrapHandler, model_serializer +from pydantic import BaseModel, BeforeValidator, Field, SerializerFunctionWrapHandler, field_validator, model_serializer from ..common import ( AnyTargetAttribute, @@ -70,6 +70,7 @@ ) from ..common.results import TaskTarget from ..common.runner import TaskRunner +from ..common.search import _reject_kriging_only_drillhole_limits from ..common.source_target import _convert_object_reference __all__ = [ @@ -171,6 +172,11 @@ class DeclusteringParameters(BaseModel): Default is ``2.0`` (standard IDW). Must be positive when provided. """ + @field_validator("neighborhood") + @classmethod + def _check_neighborhood(cls, neighborhood: SearchNeighborhood) -> SearchNeighborhood: + return _reject_kriging_only_drillhole_limits(neighborhood) + @model_serializer(mode="wrap") def _serialize(self, handler: SerializerFunctionWrapHandler) -> dict[str, Any]: result = handler(self) diff --git a/packages/evo-compute/src/evo/compute/tasks/geostatistics/idw.py b/packages/evo-compute/src/evo/compute/tasks/geostatistics/idw.py index 9ef505fa2..b33b12b77 100644 --- a/packages/evo-compute/src/evo/compute/tasks/geostatistics/idw.py +++ b/packages/evo-compute/src/evo/compute/tasks/geostatistics/idw.py @@ -42,7 +42,7 @@ from evo.common import IContext, IFeedback from evo.objects import ObjectSchema from evo.objects.typed import BaseObject, object_from_reference -from pydantic import BaseModel, Field, SerializerFunctionWrapHandler, model_serializer +from pydantic import BaseModel, Field, SerializerFunctionWrapHandler, field_validator, model_serializer from ..common import ( AnySourceAttribute, @@ -52,6 +52,7 @@ ) from ..common.results import TaskTarget from ..common.runner import TaskRunner +from ..common.search import _reject_kriging_only_drillhole_limits __all__ = [ "IDWParameters", @@ -134,6 +135,11 @@ class IDWParameters(BaseModel): ``target["filter"]`` by the custom serialiser. """ + @field_validator("neighborhood") + @classmethod + def _check_neighborhood(cls, neighborhood: SearchNeighborhood) -> SearchNeighborhood: + return _reject_kriging_only_drillhole_limits(neighborhood) + @model_serializer(mode="wrap") def _serialize(self, handler: SerializerFunctionWrapHandler) -> dict[str, Any]: result = handler(self) diff --git a/packages/evo-compute/src/evo/compute/tasks/geostatistics/knn.py b/packages/evo-compute/src/evo/compute/tasks/geostatistics/knn.py index 01743466f..32dd286f9 100644 --- a/packages/evo-compute/src/evo/compute/tasks/geostatistics/knn.py +++ b/packages/evo-compute/src/evo/compute/tasks/geostatistics/knn.py @@ -40,7 +40,7 @@ from evo.common import IContext, IFeedback from evo.objects import ObjectSchema from evo.objects.typed import BaseObject, object_from_reference -from pydantic import BaseModel, Field, SerializerFunctionWrapHandler, model_serializer +from pydantic import BaseModel, Field, SerializerFunctionWrapHandler, field_validator, model_serializer from ..common import ( AnySourceAttribute, @@ -50,6 +50,7 @@ ) from ..common.results import TaskTarget from ..common.runner import TaskRunner +from ..common.search import _reject_kriging_only_drillhole_limits __all__ = [ "KNNParameters", @@ -122,6 +123,11 @@ class KNNParameters(BaseModel): ``target["filter"]`` by the custom serialiser. """ + @field_validator("neighborhood") + @classmethod + def _check_neighborhood(cls, neighborhood: SearchNeighborhood) -> SearchNeighborhood: + return _reject_kriging_only_drillhole_limits(neighborhood) + @model_serializer(mode="wrap") def _serialize(self, handler: SerializerFunctionWrapHandler) -> dict[str, Any]: result = handler(self) diff --git a/packages/evo-compute/tests/geostatistics/test_break_ties_tasks.py b/packages/evo-compute/tests/geostatistics/test_break_ties_tasks.py index 4f6da5c1e..a8ad8442f 100644 --- a/packages/evo-compute/tests/geostatistics/test_break_ties_tasks.py +++ b/packages/evo-compute/tests/geostatistics/test_break_ties_tasks.py @@ -165,13 +165,31 @@ def test_min_samples_absent_when_not_set(self): self.assertNotIn("min_samples", d["neighborhood"]) def test_search_limits_are_refused(self): - search = SearchNeighborhood( - ellipsoid=Ellipsoid(ranges=EllipsoidRanges(major=200, semi_major=150, minor=100)), - max_samples=20, - max_drillholes=4, + ellipsoid = Ellipsoid(ranges=EllipsoidRanges(major=200, semi_major=150, minor=100)) + dumped_defaults = self._dump( + self._params( + neighborhood=SearchNeighborhood( + ellipsoid=ellipsoid, + max_samples=20, + min_drillholes=0, + drillhole_limit_scope="global", + ) + ) ) - with self.assertRaisesRegex(ValidationError, "does not support max_drillholes"): - self._params(neighborhood=search) + self.assertNotIn("min_drillholes", dumped_defaults["neighborhood"]) + self.assertNotIn("drillhole_limit_scope", dumped_defaults["neighborhood"]) + + for kwargs, expected in [ + ({"max_drillholes": 4}, "does not support max_drillholes"), + ({"max_drillholes_per_estimate": 4}, "does not support max_drillholes"), + ({"min_drillholes": 2}, "does not support min_drillholes"), + ( + {"max_samples_per_drillhole": 2, "drillhole_limit_scope": "quadrant"}, + "does not support max_samples_per_drillhole, drillhole_limit_scope", + ), + ]: + with self.subTest(**kwargs), self.assertRaisesRegex(ValidationError, expected): + self._params(neighborhood=SearchNeighborhood(ellipsoid=ellipsoid, max_samples=20, **kwargs)) def test_default_seed(self): d = self._dump(self._params()) diff --git a/packages/evo-compute/tests/geostatistics/test_conditional_turning_bands_tasks.py b/packages/evo-compute/tests/geostatistics/test_conditional_turning_bands_tasks.py index 14e9fcd0e..a07d349d9 100644 --- a/packages/evo-compute/tests/geostatistics/test_conditional_turning_bands_tasks.py +++ b/packages/evo-compute/tests/geostatistics/test_conditional_turning_bands_tasks.py @@ -198,13 +198,18 @@ def test_number_of_lines_out_of_range_rejected(self): _params(number_of_lines=1001) def test_search_limits_are_refused(self): - search = SearchNeighborhood( - ellipsoid=Ellipsoid(ranges=EllipsoidRanges(major=70, semi_major=70, minor=5)), - max_samples=40, - max_empty_octants=2, - ) - with self.assertRaisesRegex(ValidationError, "does not support max_empty_octants"): - _params(neighborhood=search) + ellipsoid = Ellipsoid(ranges=EllipsoidRanges(major=70, semi_major=70, minor=5)) + for kwargs, expected in [ + ({"max_empty_octants": 2}, "does not support max_empty_octants"), + ({"max_drillholes": 4}, "does not support max_drillholes"), + ({"min_drillholes": 2}, "does not support min_drillholes"), + ( + {"max_samples_per_drillhole": 2, "drillhole_limit_scope": "quadrant"}, + "does not support max_samples_per_drillhole, drillhole_limit_scope", + ), + ]: + with self.subTest(**kwargs), self.assertRaisesRegex(ValidationError, expected): + _params(neighborhood=SearchNeighborhood(ellipsoid=ellipsoid, max_samples=40, **kwargs)) def test_no_filters_by_default(self): d = _dump(_params()) diff --git a/packages/evo-compute/tests/geostatistics/test_conditioned_simulator_tasks.py b/packages/evo-compute/tests/geostatistics/test_conditioned_simulator_tasks.py index 7fce228ce..48feca611 100644 --- a/packages/evo-compute/tests/geostatistics/test_conditioned_simulator_tasks.py +++ b/packages/evo-compute/tests/geostatistics/test_conditioned_simulator_tasks.py @@ -152,13 +152,18 @@ def test_block_discretization_default(self): self.assertEqual(d["block_discretization"]["nx"], 1) def test_search_limits_are_refused(self): - search = SearchNeighborhood( - ellipsoid=Ellipsoid(ranges=EllipsoidRanges(major=300, semi_major=200, minor=100)), - max_samples=24, - max_samples_per_drillhole=3, - ) - with self.assertRaisesRegex(ValidationError, "does not support max_samples_per_drillhole"): - _params(neighborhood=search) + ellipsoid = Ellipsoid(ranges=EllipsoidRanges(major=300, semi_major=200, minor=100)) + for kwargs, expected in [ + ({"max_samples_per_drillhole": 3}, "does not support max_samples_per_drillhole"), + ({"max_drillholes": 4}, "does not support max_drillholes"), + ({"min_drillholes": 2}, "does not support min_drillholes"), + ( + {"max_samples_per_drillhole": 2, "drillhole_limit_scope": "octant"}, + "does not support max_samples_per_drillhole, drillhole_limit_scope", + ), + ]: + with self.subTest(**kwargs), self.assertRaisesRegex(ValidationError, expected): + _params(neighborhood=SearchNeighborhood(ellipsoid=ellipsoid, max_samples=24, **kwargs)) def test_custom_simulations(self): d = _dump(_params(number_of_simulations=10, number_of_simulations_to_save=3)) diff --git a/packages/evo-compute/tests/geostatistics/test_declustering_tasks.py b/packages/evo-compute/tests/geostatistics/test_declustering_tasks.py index d9844e10b..ebbd3368b 100644 --- a/packages/evo-compute/tests/geostatistics/test_declustering_tasks.py +++ b/packages/evo-compute/tests/geostatistics/test_declustering_tasks.py @@ -160,10 +160,26 @@ def test_search_limits_in_neighborhood(self): max_samples=20, max_samples_per_octant=2, max_samples_per_drillhole=3, + max_drillholes=5, + min_drillholes=0, + drillhole_limit_scope="global", ) d = self._dump(self._params(neighborhood=search)) self.assertEqual(d["neighborhood"]["max_samples_per_octant"], 2) self.assertEqual(d["neighborhood"]["max_samples_per_drillhole"], 3) + self.assertEqual(d["neighborhood"]["max_drillholes"], 5) + self.assertNotIn("min_drillholes", d["neighborhood"]) + self.assertNotIn("drillhole_limit_scope", d["neighborhood"]) + + def test_kriging_only_drillhole_limits_rejected(self): + ellipsoid = Ellipsoid(ranges=EllipsoidRanges(major=200, semi_major=150, minor=100)) + for limits in [ + {"min_drillholes": 2}, + {"max_samples_per_drillhole": 2, "drillhole_limit_scope": "quadrant"}, + {"max_samples_per_drillhole": 2, "drillhole_limit_scope": "octant"}, + ]: + with self.subTest(**limits), self.assertRaisesRegex(ValidationError, "only supported by Kriging"): + self._params(neighborhood=SearchNeighborhood(ellipsoid=ellipsoid, max_samples=20, **limits)) def test_default_power_is_idw(self): params = self._params() diff --git a/packages/evo-compute/tests/geostatistics/test_idw_tasks.py b/packages/evo-compute/tests/geostatistics/test_idw_tasks.py index 5bf39a009..4f13c01aa 100644 --- a/packages/evo-compute/tests/geostatistics/test_idw_tasks.py +++ b/packages/evo-compute/tests/geostatistics/test_idw_tasks.py @@ -229,11 +229,34 @@ def test_search_limits_in_neighborhood(self): max_samples=20, max_empty_quadrants=1, max_drillholes=4, + min_drillholes=0, + drillhole_limit_scope="global", ) d = _dump(_params(neighborhood=search)) self.assertEqual(d["neighborhood"]["max_empty_quadrants"], 1) self.assertEqual(d["neighborhood"]["max_drillholes"], 4) self.assertNotIn("max_drillholes_per_estimate", d["neighborhood"]) + self.assertNotIn("min_drillholes", d["neighborhood"]) + self.assertNotIn("drillhole_limit_scope", d["neighborhood"]) + + legacy = SearchNeighborhood( + ellipsoid=Ellipsoid(ranges=EllipsoidRanges(major=200, semi_major=150, minor=100)), + max_samples=20, + max_drillholes_per_estimate=4, + ) + d_legacy = _dump(_params(neighborhood=legacy)) + self.assertEqual(d_legacy["neighborhood"]["max_drillholes"], 4) + self.assertNotIn("max_drillholes_per_estimate", d_legacy["neighborhood"]) + + def test_kriging_only_drillhole_limits_rejected(self): + ellipsoid = Ellipsoid(ranges=EllipsoidRanges(major=200, semi_major=150, minor=100)) + for limits in [ + {"min_drillholes": 2}, + {"max_samples_per_drillhole": 2, "drillhole_limit_scope": "quadrant"}, + {"max_samples_per_drillhole": 2, "drillhole_limit_scope": "octant"}, + ]: + with self.subTest(**limits), self.assertRaisesRegex(ValidationError, "only supported by Kriging"): + _params(neighborhood=SearchNeighborhood(ellipsoid=ellipsoid, max_samples=20, **limits)) def test_sample_limit_boundaries_in_neighborhood(self): ellipsoid = Ellipsoid(ranges=EllipsoidRanges(major=200, semi_major=150, minor=100)) diff --git a/packages/evo-compute/tests/geostatistics/test_knn_tasks.py b/packages/evo-compute/tests/geostatistics/test_knn_tasks.py index a7ae34889..ab44ff615 100644 --- a/packages/evo-compute/tests/geostatistics/test_knn_tasks.py +++ b/packages/evo-compute/tests/geostatistics/test_knn_tasks.py @@ -130,10 +130,26 @@ def test_search_limits_in_neighborhood(self): max_samples=20, max_empty_octants=2, max_samples_per_quadrant=5, + max_drillholes=4, + min_drillholes=0, + drillhole_limit_scope="global", ) d = _dump(_params(neighborhood=search)) self.assertEqual(d["neighborhood"]["max_empty_octants"], 2) self.assertEqual(d["neighborhood"]["max_samples_per_quadrant"], 5) + self.assertEqual(d["neighborhood"]["max_drillholes"], 4) + self.assertNotIn("min_drillholes", d["neighborhood"]) + self.assertNotIn("drillhole_limit_scope", d["neighborhood"]) + + def test_kriging_only_drillhole_limits_rejected(self): + ellipsoid = Ellipsoid(ranges=EllipsoidRanges(major=200, semi_major=150, minor=100)) + for limits in [ + {"min_drillholes": 2}, + {"max_samples_per_drillhole": 2, "drillhole_limit_scope": "quadrant"}, + {"max_samples_per_drillhole": 2, "drillhole_limit_scope": "octant"}, + ]: + with self.subTest(**limits), self.assertRaisesRegex(ValidationError, "only supported by Kriging"): + _params(neighborhood=SearchNeighborhood(ellipsoid=ellipsoid, max_samples=20, **limits)) def test_sample_limit_boundaries_in_neighborhood(self): ellipsoid = Ellipsoid(ranges=EllipsoidRanges(major=200, semi_major=150, minor=100)) diff --git a/packages/evo-compute/tests/geostatistics/test_kriging_tasks.py b/packages/evo-compute/tests/geostatistics/test_kriging_tasks.py index 17ea36bde..f72533664 100644 --- a/packages/evo-compute/tests/geostatistics/test_kriging_tasks.py +++ b/packages/evo-compute/tests/geostatistics/test_kriging_tasks.py @@ -1166,10 +1166,31 @@ def test_search_limits_are_sent_in_the_neighborhood(self): max_samples=20, max_samples_per_octant=2, max_samples_per_drillhole=3, + max_drillholes=6, + min_drillholes=2, + drillhole_limit_scope="octant", ) params_dict = self._make_params(search=search).model_dump(mode="json", by_alias=True, exclude_none=True) self.assertEqual(params_dict["neighborhood"]["max_samples_per_octant"], 2) self.assertEqual(params_dict["neighborhood"]["max_samples_per_drillhole"], 3) + self.assertEqual(params_dict["neighborhood"]["max_drillholes"], 6) + self.assertEqual(params_dict["neighborhood"]["min_drillholes"], 2) + self.assertEqual(params_dict["neighborhood"]["drillhole_limit_scope"], "octant") + + default_drillholes = SearchNeighborhood( + ellipsoid=Ellipsoid(ranges=EllipsoidRanges(major=100, semi_major=100, minor=50)), + max_samples=20, + max_drillholes_per_estimate=5, + min_drillholes=0, + drillhole_limit_scope="global", + ) + default_dict = self._make_params(search=default_drillholes).model_dump( + mode="json", by_alias=True, exclude_none=True + ) + self.assertEqual(default_dict["neighborhood"]["max_drillholes"], 5) + self.assertNotIn("max_drillholes_per_estimate", default_dict["neighborhood"]) + self.assertNotIn("min_drillholes", default_dict["neighborhood"]) + self.assertNotIn("drillhole_limit_scope", default_dict["neighborhood"]) def test_can_construct_with_field_name_search(self): """Users should be able to construct KrigingParameters with search=...""" diff --git a/packages/evo-compute/tests/geostatistics/test_simulation_report_tasks.py b/packages/evo-compute/tests/geostatistics/test_simulation_report_tasks.py index 29f017b38..d98ac9bd9 100644 --- a/packages/evo-compute/tests/geostatistics/test_simulation_report_tasks.py +++ b/packages/evo-compute/tests/geostatistics/test_simulation_report_tasks.py @@ -142,13 +142,18 @@ def test_neighborhood(self): self.assertEqual(d["neighborhood"]["max_samples"], 20) def test_search_limits_are_refused(self): - search = SearchNeighborhood( - ellipsoid=Ellipsoid(ranges=EllipsoidRanges(major=200.0, semi_major=150.0, minor=100.0)), - max_samples=20, - max_samples_per_quadrant=4, - ) - with self.assertRaisesRegex(ValidationError, "does not support max_samples_per_quadrant"): - _params(neighborhood=search) + ellipsoid = Ellipsoid(ranges=EllipsoidRanges(major=200.0, semi_major=150.0, minor=100.0)) + for kwargs, expected in [ + ({"max_samples_per_quadrant": 4}, "does not support max_samples_per_quadrant"), + ({"max_drillholes": 4}, "does not support max_drillholes"), + ({"min_drillholes": 2}, "does not support min_drillholes"), + ( + {"max_samples_per_drillhole": 2, "drillhole_limit_scope": "octant"}, + "does not support max_samples_per_drillhole, drillhole_limit_scope", + ), + ]: + with self.subTest(**kwargs), self.assertRaisesRegex(ValidationError, expected): + _params(neighborhood=SearchNeighborhood(ellipsoid=ellipsoid, max_samples=20, **kwargs)) def test_block_discretization_defaults(self): d = _dump(_params()) From 70fe3a3282f59f3c3f08bac7389e48c5d90cc826 Mon Sep 17 00:00:00 2001 From: Amirabbas Jalali <258926044+amirabbas-jalali-bentley@users.noreply.github.com> Date: Tue, 17 Nov 2026 14:22:04 -0600 Subject: [PATCH 3/5] Use canonical neighborhood and kriging_method names on KrigingParameters - Rename KrigingParameters.search and KrigingParameters.method to neighborhood and kriging_method, accepting both canonical and legacy names via AliasChoices, preserving read-only .search and .method properties, and always serializing 'neighborhood' and 'kriging_method'. - Update docstrings, MkDocs index examples, and Kriging example notebooks to use canonical parameter names. --- mkdocs/docs/packages/evo-compute/index.md | 12 ++--- .../evo-compute/docs/examples/kriging.ipynb | 8 +-- .../docs/examples/kriging_multiple.ipynb | 8 +-- .../src/evo/compute/tasks/__init__.py | 2 +- .../compute/tasks/geostatistics/kriging.py | 28 ++++++++--- .../tests/geostatistics/test_kriging_tasks.py | 49 ++++++++++++++++--- 6 files changed, 79 insertions(+), 28 deletions(-) diff --git a/mkdocs/docs/packages/evo-compute/index.md b/mkdocs/docs/packages/evo-compute/index.md index 83e691c99..538e5f0a3 100644 --- a/mkdocs/docs/packages/evo-compute/index.md +++ b/mkdocs/docs/packages/evo-compute/index.md @@ -19,7 +19,7 @@ params = KrigingParameters( source=pointset.attributes["grade"], target=block_model.attributes["kriged_grade"], # Creates if new, updates if exists variogram=variogram, - search=SearchNeighborhood( + neighborhood=SearchNeighborhood( ellipsoid=Ellipsoid(ranges=EllipsoidRanges(200, 150, 100)), max_samples=20, ), @@ -40,13 +40,13 @@ results = await run(manager, [ source=pointset.attributes["Au"], target=block_model.attributes["Au_kriged"], variogram=au_variogram, - search=SearchNeighborhood(...), + neighborhood=SearchNeighborhood(...), ), KrigingParameters( source=pointset.attributes["Cu"], target=block_model.attributes["Cu_kriged"], variogram=cu_variogram, - search=SearchNeighborhood(...), + neighborhood=SearchNeighborhood(...), ), ], preview=True) @@ -94,7 +94,7 @@ first_result = await run(manager, KrigingParameters( source=pointset.attributes["grade"], target=block_model.attributes["kriged_grade"], variogram=variogram, - search=SearchNeighborhood(...), + neighborhood=SearchNeighborhood(...), target_filter=Filter( where=FilterCondition( attribute=block_model.attributes["domain"], @@ -113,7 +113,7 @@ results = await run(manager, [ source=pointset.attributes["grade"], target=block_model.attributes["kriged_grade"], # Exists → update variogram=variogram, - search=SearchNeighborhood(...), + neighborhood=SearchNeighborhood(...), target_filter=Filter( where=FilterCondition( attribute=block_model.attributes["domain"], @@ -126,7 +126,7 @@ results = await run(manager, [ source=pointset.attributes["grade"], target=block_model.attributes["kriged_grade"], # Exists → update variogram=variogram, - search=SearchNeighborhood(...), + neighborhood=SearchNeighborhood(...), target_filter=Filter( where=FilterCondition( attribute=block_model.attributes["domain"], diff --git a/packages/evo-compute/docs/examples/kriging.ipynb b/packages/evo-compute/docs/examples/kriging.ipynb index 0536e28b8..3a3722caf 100644 --- a/packages/evo-compute/docs/examples/kriging.ipynb +++ b/packages/evo-compute/docs/examples/kriging.ipynb @@ -201,12 +201,12 @@ "outputs": [], "source": [ "# Create kriging parameters\n", - "# Note: method defaults to ordinary kriging, so we don't need to specify it\n", + "# Note: kriging_method defaults to ordinary kriging, so we don't need to specify it\n", "kriging_params = KrigingParameters(\n", " source=source_pointset.attributes[\"Ag_ppm Values\"],\n", " target=target_grid.attributes[\"kriged_grade 5\"],\n", " variogram=variogram,\n", - " search=SearchNeighborhood(\n", + " neighborhood=SearchNeighborhood(\n", " ellipsoid=search_ellipsoid,\n", " max_samples=20,\n", " ),\n", @@ -285,7 +285,7 @@ " source=source_pointset.attributes[\"Ag_ppm Values\"],\n", " target=target_grid.attributes[\"kriged_grade_diagnostics\"],\n", " variogram=variogram,\n", - " search=SearchNeighborhood(\n", + " neighborhood=SearchNeighborhood(\n", " ellipsoid=search_ellipsoid,\n", " max_samples=20,\n", " ),\n", @@ -599,7 +599,7 @@ " source=source_pointset_created.locations.attributes[\"elevation\"],\n", " target=Target.new_attribute(target_grid_created, attribute_name=\"kriged_elevation2\"),\n", " variogram=variogram_created,\n", - " search=SearchNeighborhood(\n", + " neighborhood=SearchNeighborhood(\n", " ellipsoid=Ellipsoid(\n", " ranges=EllipsoidRanges(major=134.0, semi_major=90.0, minor=40.0),\n", " rotation=Rotation(dip_azimuth=100.0, dip=65.0, pitch=75.0),\n", diff --git a/packages/evo-compute/docs/examples/kriging_multiple.ipynb b/packages/evo-compute/docs/examples/kriging_multiple.ipynb index d03aedeed..17d38185d 100644 --- a/packages/evo-compute/docs/examples/kriging_multiple.ipynb +++ b/packages/evo-compute/docs/examples/kriging_multiple.ipynb @@ -267,14 +267,14 @@ "discretization = BlockDiscretization(nx=3, ny=3, nz=2)\n", "\n", "# Create parameter sets for each scenario, all targeting the same Block Model\n", - "# Note: method defaults to ordinary kriging, so we don't need to specify it\n", + "# Note: kriging_method defaults to ordinary kriging, so we don't need to specify it\n", "parameter_sets = []\n", "for max_samples in max_samples_values:\n", " params = KrigingParameters(\n", " source=source,\n", " target=block_model.attributes[f\"Samples={max_samples}\"],\n", " variogram=variogram,\n", - " search=SearchNeighborhood(ellipsoid=search_ellipsoid, max_samples=max_samples),\n", + " neighborhood=SearchNeighborhood(ellipsoid=search_ellipsoid, max_samples=max_samples),\n", " block_discretization=discretization,\n", " )\n", " parameter_sets.append(params)\n", @@ -691,14 +691,14 @@ "source = source_pointset.attributes[\"Ag_ppm Values\"]\n", "\n", "# Create parameter sets for each scenario, all targeting the same Block Model\n", - "# Note: method defaults to ordinary kriging, so we don't need to specify it\n", + "# Note: kriging_method defaults to ordinary kriging, so we don't need to specify it\n", "parameter_sets = []\n", "for max_samples in max_samples_values:\n", " params = KrigingParameters(\n", " source=source,\n", " target=block_model.attributes[f\"Samples={max_samples}\"],\n", " variogram=variogram,\n", - " search=SearchNeighborhood(ellipsoid=search_ellipsoid, max_samples=max_samples),\n", + " neighborhood=SearchNeighborhood(ellipsoid=search_ellipsoid, max_samples=max_samples),\n", " target_region_filter=RegionFilter(\n", " attribute=block_model.attributes[\"domain\"],\n", " names=[\"LMS1\"], # Filter by category name\n", diff --git a/packages/evo-compute/src/evo/compute/tasks/__init__.py b/packages/evo-compute/src/evo/compute/tasks/__init__.py index 94c00ea0d..a3f860014 100644 --- a/packages/evo-compute/src/evo/compute/tasks/__init__.py +++ b/packages/evo-compute/src/evo/compute/tasks/__init__.py @@ -136,7 +136,7 @@ async def run( ... source=pointset.attributes["grade"], ... target=Target.new_attribute(block_model, "kriged_grade"), ... variogram=variogram, - ... search=SearchNeighborhood( + ... neighborhood=SearchNeighborhood( ... ellipsoid=var_ell.scaled(2.0), ... max_samples=20, ... ), diff --git a/packages/evo-compute/src/evo/compute/tasks/geostatistics/kriging.py b/packages/evo-compute/src/evo/compute/tasks/geostatistics/kriging.py index 9c6c6528b..fb03cefe3 100644 --- a/packages/evo-compute/src/evo/compute/tasks/geostatistics/kriging.py +++ b/packages/evo-compute/src/evo/compute/tasks/geostatistics/kriging.py @@ -24,7 +24,7 @@ ... source=pointset.attributes["grade"], ... target=Target.new_attribute(block_model, "kriged_grade"), ... variogram=variogram, - ... search=SearchNeighborhood( + ... neighborhood=SearchNeighborhood( ... ellipsoid=Ellipsoid(ranges=EllipsoidRanges(200, 150, 100)), ... max_samples=20, ... ), @@ -42,6 +42,7 @@ from evo.objects import ObjectSchema from evo.objects.typed import BaseObject, object_from_reference from pydantic import ( + AliasChoices, BaseModel, Field, PrivateAttr, @@ -352,11 +353,11 @@ class KrigingParameters(BaseModel): ... source=pointset.attributes["grade"], # Source attribute ... target=block_model.attributes["kriged_grade"], # Target attribute (creates if doesn't exist) ... variogram=variogram, # Variogram model - ... search=SearchNeighborhood( + ... neighborhood=SearchNeighborhood( ... ellipsoid=Ellipsoid(ranges=EllipsoidRanges(200, 150, 100)), ... max_samples=20, ... ), - ... # method defaults to ordinary kriging + ... # kriging_method defaults to ordinary kriging ... ) >>> >>> # With a target filter to restrict kriging to specific categories on the target: @@ -364,7 +365,7 @@ class KrigingParameters(BaseModel): ... source=pointset.attributes["grade"], ... target=block_model.attributes["kriged_grade"], ... variogram=variogram, - ... search=SearchNeighborhood(...), + ... neighborhood=SearchNeighborhood(...), ... target_filter=Filter( ... where=FilterCondition( ... attribute=block_model.attributes["domain"], @@ -379,7 +380,7 @@ class KrigingParameters(BaseModel): ... source=pointset.attributes["grade"], ... target=block_model.attributes["kriged_grade"], ... variogram=variogram, - ... search=SearchNeighborhood(...), + ... neighborhood=SearchNeighborhood(...), ... diagnostics=KrigingDiagnostics(kriging_variance=True, num_samples=True), ... ) """ @@ -395,12 +396,25 @@ class KrigingParameters(BaseModel): variogram: GeoscienceObjectReference """Model of the covariance within the domain (Variogram object or reference).""" - search: SearchNeighborhood = Field(alias="neighborhood") + neighborhood: SearchNeighborhood = Field(validation_alias=AliasChoices("neighborhood", "search")) """Search neighborhood parameters.""" - method: SimpleKriging | OrdinaryKriging = Field(default_factory=OrdinaryKriging, alias="kriging_method") + kriging_method: SimpleKriging | OrdinaryKriging = Field( + default_factory=OrdinaryKriging, + validation_alias=AliasChoices("kriging_method", "method"), + ) """The kriging method to use. Defaults to ordinary kriging if not specified.""" + @property + def search(self) -> SearchNeighborhood: + """Backwards-compatible alias for :attr:`neighborhood`.""" + return self.neighborhood + + @property + def method(self) -> SimpleKriging | OrdinaryKriging: + """Backwards-compatible alias for :attr:`kriging_method`.""" + return self.kriging_method + source_filter: Filter | None = Field(None, exclude=True) """Optional filter to restrict kriging to a subset of the source data.""" diff --git a/packages/evo-compute/tests/geostatistics/test_kriging_tasks.py b/packages/evo-compute/tests/geostatistics/test_kriging_tasks.py index f72533664..4973212a0 100644 --- a/packages/evo-compute/tests/geostatistics/test_kriging_tasks.py +++ b/packages/evo-compute/tests/geostatistics/test_kriging_tasks.py @@ -45,9 +45,12 @@ from evo.compute.tasks.geostatistics.kriging import ( RECOMMENDED_DIAGNOSTIC_NAMES, KrigingDiagnostics, + KrigingMethod, KrigingParameters, KrigingResult, KrigingResultModel, + OrdinaryKriging, + SimpleKriging, ) # --------------------------------------------------------------------------- @@ -1148,17 +1151,49 @@ def _make_params(self, **kwargs): return KrigingParameters(**defaults) def test_search_serializes_as_neighborhood_with_by_alias(self): - """When by_alias=True, the 'search' field should serialize as 'neighborhood'.""" + """When by_alias=True, the neighborhood field should serialize as 'neighborhood'.""" params = self._make_params() params_dict = params.model_dump(mode="json", by_alias=True, exclude_none=True) self.assertIn("neighborhood", params_dict) self.assertNotIn("search", params_dict) + self.assertIn("kriging_method", params_dict) + self.assertNotIn("method", params_dict) - def test_search_serializes_as_search_without_by_alias(self): - """When by_alias=False (default), the field should serialize as 'search'.""" + def test_always_serializes_neighborhood_and_kriging_method_without_by_alias(self): + """Even when by_alias=False (default), canonical 'neighborhood' and 'kriging_method' keys are emitted.""" params = self._make_params() params_dict = params.model_dump() - self.assertIn("search", params_dict) + self.assertIn("neighborhood", params_dict) + self.assertNotIn("search", params_dict) + self.assertIn("kriging_method", params_dict) + self.assertNotIn("method", params_dict) + + def test_kriging_method_canonical_and_legacy_alias(self): + """KrigingParameters accepts both kriging_method=... and method=... and exposes both attributes.""" + default_params = self._make_params() + self.assertIsInstance(default_params.kriging_method, OrdinaryKriging) + self.assertIs(default_params.method, default_params.kriging_method) + + via_canonical = KrigingParameters( + source=Source(object=POINTSET_URL, attribute="grade"), + target=Target.new_attribute(GRID_URL, "kriged_grade"), + variogram=VARIOGRAM_URL, + neighborhood=SearchNeighborhood( + ellipsoid=Ellipsoid(ranges=EllipsoidRanges(major=100, semi_major=100, minor=50)), + max_samples=20, + ), + kriging_method=KrigingMethod.simple(mean=42.5), + ) + self.assertIsInstance(via_canonical.kriging_method, SimpleKriging) + self.assertEqual(via_canonical.kriging_method.mean, 42.5) + self.assertIs(via_canonical.method, via_canonical.kriging_method) + self.assertEqual(via_canonical.model_dump()["kriging_method"], {"type": "simple", "mean": 42.5}) + + via_legacy = self._make_params(method=KrigingMethod.simple(mean=12.0)) + self.assertIsInstance(via_legacy.kriging_method, SimpleKriging) + self.assertEqual(via_legacy.method.mean, 12.0) + self.assertIs(via_legacy.method, via_legacy.kriging_method) + self.assertEqual(via_legacy.model_dump()["kriging_method"], {"type": "simple", "mean": 12.0}) def test_search_limits_are_sent_in_the_neighborhood(self): search = SearchNeighborhood( @@ -1195,7 +1230,8 @@ def test_search_limits_are_sent_in_the_neighborhood(self): def test_can_construct_with_field_name_search(self): """Users should be able to construct KrigingParameters with search=...""" params = self._make_params() - self.assertIsNotNone(params.search) + self.assertIsNotNone(params.neighborhood) + self.assertIs(params.search, params.neighborhood) def test_can_construct_with_alias_neighborhood(self): """Users should also be able to construct with neighborhood=...""" @@ -1209,7 +1245,8 @@ def test_can_construct_with_alias_neighborhood(self): variogram=VARIOGRAM_URL, neighborhood=search, ) - self.assertIsNotNone(params.search) + self.assertIs(params.neighborhood, search) + self.assertIs(params.search, search) def test_sample_limit_boundaries_in_neighborhood(self): ellipsoid = Ellipsoid(ranges=EllipsoidRanges(major=100, semi_major=100, minor=50)) From 5824002cbd147c706464bfcede6277744a88b3d6 Mon Sep 17 00:00:00 2001 From: Amirabbas Jalali <258926044+amirabbas-jalali-bentley@users.noreply.github.com> Date: Tue, 17 Nov 2026 17:08:09 -0600 Subject: [PATCH 4/5] Bump evo-compute version to 0.1.1 Prepare evo-compute 0.1.1 release in pyproject.toml and uv.lock. --- packages/evo-compute/pyproject.toml | 2 +- uv.lock | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/packages/evo-compute/pyproject.toml b/packages/evo-compute/pyproject.toml index 8ed2a5a71..9a3aadf5c 100644 --- a/packages/evo-compute/pyproject.toml +++ b/packages/evo-compute/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "evo-compute" -version = "0.1.0" +version = "0.1.1" requires-python = ">=3.11.5" license-files = ["LICENSE.md"] dynamic = ["readme"] diff --git a/uv.lock b/uv.lock index fbe37f76f..1e2a03667 100644 --- a/uv.lock +++ b/uv.lock @@ -950,7 +950,7 @@ test = [ [[package]] name = "evo-compute" -version = "0.1.0" +version = "0.1.1" source = { editable = "packages/evo-compute" } dependencies = [ { name = "evo-blockmodels", extra = ["utils"] }, From 1ba75b3630ba61f93de806a3cb65ee79adedd9cf Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" <41898282+github-actions[bot]@users.noreply.github.com> Date: Tue, 17 Nov 2026 23:08:37 +0000 Subject: [PATCH 5/5] Update to MkDocs documentation --- mkdocs/site/packages/evo-compute/index.html | 12 +-- .../kriging/KrigingParameters.html | 58 ++++++++++-- .../search/SearchNeighborhood.html | 90 +++++++++++++++++-- 3 files changed, 140 insertions(+), 20 deletions(-) diff --git a/mkdocs/site/packages/evo-compute/index.html b/mkdocs/site/packages/evo-compute/index.html index 642bbbe3d..c7b3117ee 100644 --- a/mkdocs/site/packages/evo-compute/index.html +++ b/mkdocs/site/packages/evo-compute/index.html @@ -92,7 +92,7 @@

Single task

source=pointset.attributes["grade"], target=block_model.attributes["kriged_grade"], # Creates if new, updates if exists variogram=variogram, - search=SearchNeighborhood( + neighborhood=SearchNeighborhood( ellipsoid=Ellipsoid(ranges=EllipsoidRanges(200, 150, 100)), max_samples=20, ), @@ -109,13 +109,13 @@

Multiple tasks

source=pointset.attributes["Au"], target=block_model.attributes["Au_kriged"], variogram=au_variogram, - search=SearchNeighborhood(...), + neighborhood=SearchNeighborhood(...), ), KrigingParameters( source=pointset.attributes["Cu"], target=block_model.attributes["Cu_kriged"], variogram=cu_variogram, - search=SearchNeighborhood(...), + neighborhood=SearchNeighborhood(...), ), ], preview=True) @@ -152,7 +152,7 @@

How do I run source=pointset.attributes["grade"], target=block_model.attributes["kriged_grade"], variogram=variogram, - search=SearchNeighborhood(...), + neighborhood=SearchNeighborhood(...), target_filter=Filter( where=FilterCondition( attribute=block_model.attributes["domain"], @@ -171,7 +171,7 @@

How do I run source=pointset.attributes["grade"], target=block_model.attributes["kriged_grade"], # Exists → update variogram=variogram, - search=SearchNeighborhood(...), + neighborhood=SearchNeighborhood(...), target_filter=Filter( where=FilterCondition( attribute=block_model.attributes["domain"], @@ -184,7 +184,7 @@

How do I run source=pointset.attributes["grade"], target=block_model.attributes["kriged_grade"], # Exists → update variogram=variogram, - search=SearchNeighborhood(...), + neighborhood=SearchNeighborhood(...), target_filter=Filter( where=FilterCondition( attribute=block_model.attributes["domain"], diff --git a/mkdocs/site/packages/evo-compute/typed-objects/kriging/KrigingParameters.html b/mkdocs/site/packages/evo-compute/typed-objects/kriging/KrigingParameters.html index 763bd0a2f..d82113d5b 100644 --- a/mkdocs/site/packages/evo-compute/typed-objects/kriging/KrigingParameters.html +++ b/mkdocs/site/packages/evo-compute/typed-objects/kriging/KrigingParameters.html @@ -100,11 +100,11 @@

@@ -214,17 +214,59 @@

+ neighborhood + + +

+
neighborhood: SearchNeighborhood = Field(validation_alias=AliasChoices('neighborhood', 'search'))
+
+ +
+ +

Search neighborhood parameters.

+ +
+ + + +
+ + + +

+ kriging_method + + +

+
kriging_method: SimpleKriging | OrdinaryKriging = Field(
+    default_factory=OrdinaryKriging, validation_alias=AliasChoices("kriging_method", "method")
+)
+
+ +
+ +

The kriging method to use. Defaults to ordinary kriging if not specified.

+ +
+ +
+ +
+ + +

search

-
search: SearchNeighborhood = Field(alias='neighborhood')
+
search: SearchNeighborhood
 
-

Search neighborhood parameters.

+

Backwards-compatible alias for :attr:neighborhood.

@@ -239,12 +281,12 @@

-
method: SimpleKriging | OrdinaryKriging = Field(default_factory=OrdinaryKriging, alias='kriging_method')
+
method: SimpleKriging | OrdinaryKriging
 
-

The kriging method to use. Defaults to ordinary kriging if not specified.

+

Backwards-compatible alias for :attr:kriging_method.

diff --git a/mkdocs/site/packages/evo-compute/typed-objects/search/SearchNeighborhood.html b/mkdocs/site/packages/evo-compute/typed-objects/search/SearchNeighborhood.html index 9c3330ac4..530011b4e 100644 --- a/mkdocs/site/packages/evo-compute/typed-objects/search/SearchNeighborhood.html +++ b/mkdocs/site/packages/evo-compute/typed-objects/search/SearchNeighborhood.html @@ -95,24 +95,27 @@