core-lens 0.1.dev142__tar.gz → 0.1.dev143__tar.gz

{core_lens-0.1.dev142 → core_lens-0.1.dev143}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: core-lens
-Version: 0.1.dev142
+Version: 0.1.dev143
 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.dev142 → core_lens-0.1.dev143}/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.dev142'
-__version_tuple__ = version_tuple = (0, 1, 'dev142')
+__version__ = version = '0.1.dev143'
+__version_tuple__ = version_tuple = (0, 1, 'dev143')
 
 __commit_id__ = commit_id = None

{core_lens-0.1.dev142 → core_lens-0.1.dev143}/src/core_lens/aoi.py

@@ -383,19 +383,16 @@ class AoI:
         # Entity instances are created lazily on first access via _get_entity().
         self._entity_instances: dict[str, BaseEntity] = {}
 
-        # Initialise boundary-entity cache.  Only populated by the
-        # named-boundary path (_resolve_named_boundary); bbox= / geometry=
-        # construction leaves these as None so __getattr__ falls through
-        # to the normal spatial_filter path for every entity.
-        self._boundary_entity_name: str | None = None
-        self._boundary_keys: pl.DataFrame | None = None
+        # Initialise boundary kwargs and lazily computed geometry.
+        self._boundary_kwargs: dict[str, str | list[str]] | None = None
+        self._geometry: shapely.Geometry | None = None
 
         if geometry is not None:
-            self.geometry: "shapely.Geometry" = geometry
+            self._geometry = geometry
         elif bbox is not None:
-            self.geometry = _bbox_to_polygon(bbox)
+            self._geometry = _bbox_to_polygon(bbox)
         else:
-            self.geometry = self._resolve_named_boundary(entity_kwargs)
+            self._boundary_kwargs = entity_kwargs
 
         # Entity views are created lazily on demand in __getattr__.
         self._scoped: dict[str, "View"] = {}
@@ -406,6 +403,17 @@ class AoI:
         if validate_all:
             self.validate()
 
+    @property
+    def geometry(self) -> "shapely.Geometry":
+        """The resolved boundary of this AoI as a Shapely geometry."""
+        if self._geometry is None:
+            if self._boundary_kwargs is not None:
+                self._geometry = self._resolve_named_boundary(self._boundary_kwargs)
+            else:
+                # Should not happen if initialization was correct
+                raise ValueError("No boundary defined.")
+        return self._geometry
+
     @property
     def current_season(self) -> str:
         """The season name for today's date under the AoI's SeasonConfig.
@@ -538,23 +546,20 @@ class AoI:
         if name in _REGISTRY:
             if name not in self._scoped:
                 entity = self._get_entity(name)
-                if name == self._boundary_entity_name:
-                    # This entity *defined* the AoI boundary — we already
-                    # have its exact matching keys from
-                    # _resolve_named_boundary.  Skip the bbox-index build
-                    # and geometric predicate entirely.
-                    from core_lens.base.view import View
-
-                    assert (
-                        self._boundary_keys is not None
-                    )  # set by _resolve_named_boundary
-                    view = View(
-                        keys=self._boundary_keys,
-                        entity=entity,
-                        entity_name=name,
-                    )
+
+                if self._boundary_kwargs is not None:
+                    schema = entity.schema_profile
+                    # If this entity has all the filter columns natively, filter directly
+                    if all(
+                        k in schema.key_cols or k in schema.extra_static_cols
+                        for k in self._boundary_kwargs
+                    ):
+                        view = entity.where(**self._boundary_kwargs)
+                    else:
+                        view = entity.spatial_filter(geometry=self.geometry)
                 else:
                     view = entity.spatial_filter(geometry=self.geometry)
+
                 view._season_config = self.seasons
                 self._scoped[name] = view
             return self._scoped[name]
@@ -608,24 +613,6 @@ class AoI:
         # Reconstruct the boundary geometry from cached WKB bytes (fast).
         geometry: shapely.Geometry = shapely.from_wkb(geom_wkb)
 
-        # Reconstruct _boundary_keys DataFrame from cached key_rows.
-        # We need the key column names — get them from the boundary entity.
-        boundary_entity_cls = _REGISTRY.get(boundary_entity_name)
-        if boundary_entity_cls is not None:
-            key_cols = boundary_entity_cls().key_cols
-            self._boundary_entity_name = boundary_entity_name
-            self._boundary_keys = pl.DataFrame(
-                {col: [row[i] for row in key_rows] for i, col in enumerate(key_cols)}
-            )
-        else:
-            # Registry changed since cache was populated — defensive fallback.
-            logger.warning(
-                "Boundary cache returned entity name '{}' not found in current registry.",
-                boundary_entity_name,
-            )
-            self._boundary_entity_name = None
-            self._boundary_keys = None
-
         return geometry
 
     @classmethod

{core_lens-0.1.dev142 → core_lens-0.1.dev143}/tests/unit/test_aoi.py

@@ -389,13 +389,15 @@ class TestAoIResolveGeometry:
             assert getattr(aoi.geometry, "equals", lambda x: False)(union)
 
             with pytest.raises(ValueError, match="No rows matched the filters"):
-                AoI(data_root=str(tmp_path), mws_id="999")
+                bad_aoi = AoI(data_root=str(tmp_path), mws_id="999")
+                _ = bad_aoi.geometry
 
             with pytest.raises(
                 EntityValidationError,
                 match="No registered entity can satisfy the filters",
             ):
-                AoI(data_root=str(tmp_path), unknown_key="1")
+                invalid_aoi = AoI(data_root=str(tmp_path), unknown_key="1")
+                _ = invalid_aoi.geometry
 
             # Test fallback match by entity name
             aoi_fallback = AoI(data_root=str(tmp_path), mws="1")