core-lens 0.1.dev200__tar.gz → 0.1.dev202__tar.gz

{core_lens-0.1.dev200 → core_lens-0.1.dev202}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: core-lens
-Version: 0.1.dev200
+Version: 0.1.dev202
 Summary: Query, analyse, and visualise CoreStack's microwatershed and Earth science data through a clean, composable Python API.
 Project-URL: Homepage, https://github.com/ApoorvaKashyap/core-lens
 Project-URL: Issues, https://github.com/ApoorvaKashyap/core-lens/issues

{core_lens-0.1.dev200 → core_lens-0.1.dev202}/src/core_lens/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.1.dev200'
-__version_tuple__ = version_tuple = (0, 1, 'dev200')
+__version__ = version = '0.1.dev202'
+__version_tuple__ = version_tuple = (0, 1, 'dev202')
 
 __commit_id__ = commit_id = None

{core_lens-0.1.dev200 → core_lens-0.1.dev202}/src/core_lens/base/view.py

@@ -234,15 +234,25 @@ class View:
             season_config=self._season_config,
         )
 
-    def spatial_join(self, other: "BaseEntity", agg: dict[str, str]) -> "View":
+    def spatial_join(self, other: "BaseEntity | View", agg: dict[str, str]) -> "View":
         """Return a new View with a cross-entity join pending.
 
         The join is recorded in the View's ``join_spec`` and computed only at
         materialisation time (``.static``, ``.annual``, or ``.sub_annual``).
 
+        ``other`` may be either a :class:`~core_lens.base.entity.BaseEntity`
+        **or** a :class:`View` (e.g. ``aoi.waterbody``).  When a ``View`` is
+        supplied its underlying ``.entity`` is extracted automatically, so
+        both of the following are equivalent::
+
+            aoi.mws.spatial_join(aoi.waterbody, agg={"kharif": "mean"})
+            aoi.mws.spatial_join(aoi.waterbody.entity, agg={"kharif": "mean"})
+
         Args:
-            other (BaseEntity): The secondary :class:`BaseEntity` whose columns will be
-                joined and aggregated onto ``self``.
+            other (BaseEntity | View): The secondary entity whose columns will
+                be joined and aggregated onto ``self``.  Accepts either a
+                :class:`~core_lens.base.entity.BaseEntity` instance or a
+                :class:`View` (the latter is automatically unwrapped).
             agg (dict[str, str]): Mapping of ``{column: aggregation}`` specifying which columns
                 from ``other`` to bring in and how to aggregate them.
 
@@ -256,12 +266,17 @@ class View:
             )
             raise ValueError("View already has a pending spatial_join.")
 
+        # Accept a View as `other` (e.g. aoi.waterbody) by unwrapping it.
+        # AoI attributes return scoped Views, not bare BaseEntity instances,
+        # so this is the natural way to reference a secondary entity.
+        other_entity = other.entity if isinstance(other, View) else other
+
         return View(
             keys=self.keys,
             entity=self.entity,
             entity_name=self.entity_name,
             time_filter=self.time_filter,
-            join_spec={"other": other, "agg": agg},
+            join_spec={"other": other_entity, "agg": agg},
             season_config=self._season_config,
         )
 
@@ -513,6 +528,13 @@ class View:
             other = self.join_spec["other"]
             agg = self.join_spec["agg"]
 
+            # Defensively unwrap a View to its entity — join_spec["other"] may be a
+            # View when callers pass e.g. aoi.waterbody directly (AoI.__getattr__
+            # returns Views, not bare entities).  spatial_join() already does this
+            # unwrap, but _materialise guards here too for robustness.
+            if isinstance(other, View):
+                other = other.entity
+
             from core_lens.base.entity import _entity_name as _ename
 
             other_entity_name = _ename(type(other))

{core_lens-0.1.dev200 → core_lens-0.1.dev202}/tests/unit/test_view.py

@@ -297,6 +297,76 @@ class TestViewMaterialisation:
         with pytest.raises(ValueError, match="already has a pending spatial_join"):
             view.spatial_join(entity_cls(), {"district": "count"})
 
+    def test_spatial_join_accepts_view_as_other(self, entity_cls: Any) -> None:
+        """Passing a View as `other` (e.g. aoi.waterbody) should unwrap to the
+        underlying entity so that materialisation can call .schema_profile on it.
+
+        Regression test for: AttributeError: 'View' object has no attribute
+        'schema_profile' raised inside execute_spatial_join when AoI attributes
+        (which return Views) were passed directly to spatial_join.
+        """
+        entity = entity_cls()
+        other_entity = entity_cls()
+        # Wrap the secondary entity in a View, mimicking what AoI.__getattr__ returns.
+        other_view = View(
+            keys=pl.DataFrame({"mws_id": []}, schema={"mws_id": pl.String}),
+            entity=other_entity,
+            entity_name="otherw",
+        )
+
+        view = View(
+            keys=pl.DataFrame({"mws_id": []}, schema={"mws_id": pl.String}),
+            entity=entity,
+            entity_name="minimalmws",
+        )
+        joined = view.spatial_join(other_view, {"district": "count"})
+
+        # The join_spec must store the unwrapped BaseEntity, not the View.
+        assert joined.join_spec is not None
+        assert joined.join_spec["other"] is other_entity
+        assert not isinstance(joined.join_spec["other"], View)
+
+    def test_spatial_join_view_other_materialises(self, entity_cls: Any) -> None:
+        """Materialising a View whose join `other` was supplied as a View should
+        produce the same prefixed columns as passing a bare entity directly.
+        """
+        import pathlib
+        import tempfile
+        import sys
+        import os
+
+        conftest_dir = os.path.dirname(__file__)
+        if conftest_dir not in sys.path:
+            sys.path.insert(0, conftest_dir)
+        from conftest import _make_static_parquet, _make_entity_cls
+
+        with tempfile.TemporaryDirectory() as td:
+            sp = pathlib.Path(td) / "static.parquet"
+            _make_static_parquet(sp)
+            full_cls = _make_entity_cls(sp)
+            full_entity = full_cls()
+            keys = full_entity._index.select(full_entity.key_cols)
+
+            # Build the secondary entity wrapped in a View — the pattern from aoi.X
+            other_view = View(
+                keys=keys,
+                entity=full_entity,
+                entity_name="minimalmws",
+            )
+
+            view = View(
+                keys=keys,
+                entity=full_entity,
+                entity_name="minimalmws",
+                join_spec={"other": other_view, "agg": {"district": "count"}},
+            )
+            result = view.static
+
+        joined_cols = [c for c in result.df().columns if c.startswith("minimalmws_")]
+        assert joined_cols, (
+            f"Expected prefixed join columns but got: {result.df().columns}"
+        )
+
     def test_spatial_join_fetches_geometry_if_missing(
         self, entity_cls_full: Any
     ) -> None: