core-lens 0.1.dev112__tar.gz → 0.1.dev114__tar.gz

{core_lens-0.1.dev112 → core_lens-0.1.dev114}/PKG-INFO

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

{core_lens-0.1.dev112 → core_lens-0.1.dev114}/src/core_lens/base/namespaces/plot.py

@@ -78,15 +78,16 @@ def _wkb_to_arrow_table(
     keep = [geom_col] + (extra_cols or [])
     df = df.select([c for c in keep if c in df.columns])
 
-    def _wkb_geom_type(b: bytes) -> int:
-        """Return the WKB geometry type integer (1-7), or 0 on invalid input."""
-        if not b or len(b) < 5:
-            return 0
-        endian = b[0]  # 1 = little-endian, 0 = big-endian
-        raw = int.from_bytes(b[1:5], "little" if endian == 1 else "big")
-        return raw & 0xFFFF  # strip ISO Z/M/SRID flags
-
-    geom_type_series = df[geom_col].map_elements(_wkb_geom_type, return_dtype=pl.Int32)
+    # WKB type detection: slice byte 1 (skip endian flag) — single byte covers
+    # all standard types 1-7.  bin.slice returns BinaryView in this Polars build
+    # which cannot be cast to UInt8 directly, so we extract the int value via
+    # map_elements on the already-sliced 1-byte series (no endian logic, no
+    # int.from_bytes on 4 bytes — still much cheaper than the original path).
+    geom_type_series = (
+        df[geom_col]
+        .bin.slice(1, 1)
+        .map_elements(lambda b: b[0] if b else 0, return_dtype=pl.UInt8)
+    )
 
     # --- Fast path: pure Polygon / MultiPolygon rows (no Shapely) ---
     poly_mask = geom_type_series.is_in([3, 6])
@@ -134,6 +135,9 @@ def _wkb_to_arrow_table(
         return ac.Table.from_arrow(arrow_table)
 
     arrow_table = df_poly.to_arrow()
+    del (
+        df_poly
+    )  # free Polars WKB buffer before PyArrow combine_chunks() allocates its copy
     wkb_col = arrow_table.column(geom_col).combine_chunks()
     geo_col = ga.from_wkb(wkb_col)
 

{core_lens-0.1.dev112 → core_lens-0.1.dev114}/src/core_lens/base/view.py

@@ -376,7 +376,27 @@ class View:
                 from core_lens.aoi import SeasonConfig
 
                 season_cfg = self._season_config or SeasonConfig()
-                time_expr = resolve_time_filter(self.time_filter, time_col, season_cfg)
+
+                # Detect whether the time column is an integer year column so
+                # _date_range_expr can branch at expression-build time (avoids
+                # the cast-to-string + runtime when/then triple-copy).
+                try:
+                    pq_schema = pl.read_parquet_schema(abs_path)
+                    _time_dtype = pq_schema.get(time_col)
+                    _is_year_col = _time_dtype is not None and _time_dtype in (
+                        pl.Int32,
+                        pl.Int64,
+                        pl.UInt32,
+                        pl.UInt16,
+                    )
+                except Exception:
+                    _is_year_col = False
+
+                # Pass as a private hint inside the filter dict (non-mutating copy).
+                _tf = dict(self.time_filter)
+                if "start" in _tf and "end" in _tf:
+                    _tf["_is_year_col"] = _is_year_col
+                time_expr = resolve_time_filter(_tf, time_col, season_cfg)
 
         lf = scan_with_key_filter(
             path=abs_path,

{core_lens-0.1.dev112 → core_lens-0.1.dev114}/src/core_lens/utils/season.py

@@ -47,7 +47,12 @@ def resolve_time_filter(
         end = time_filter["end"]
         assert isinstance(start, str)
         assert isinstance(end, str)
-        return _date_range_expr(time_col, start, end)
+        # _is_year_col is injected by _materialise when the parquet schema is
+        # available.  When absent (e.g. direct test calls) pass None so that
+        # _date_range_expr uses its runtime when/then fallback.
+        _raw = time_filter.get("_is_year_col")
+        is_year_col: bool | None = bool(_raw) if _raw is not None else None
+        return _date_range_expr(time_col, start, end, is_year_col=is_year_col)
 
     if "season" in time_filter:
         season_name = time_filter["season"]
@@ -64,16 +69,25 @@ def resolve_time_filter(
     )
 
 
-def _date_range_expr(time_col: str, start: str, end: str) -> pl.Expr:
+def _date_range_expr(
+    time_col: str,
+    start: str,
+    end: str,
+    is_year_col: bool | None = None,
+) -> pl.Expr:
     """Return a Polars expression for an inclusive ISO-8601 date range.
 
-    Handles both ``pl.Date`` and ``pl.Int``/``pl.Int64`` time columns (year
-    integers stored as integers rather than dates).
+    When ``is_year_col`` is known (``True`` / ``False``) branches at *build
+    time* — no runtime copies of the column.  When ``None`` (caller has no
+    schema info) falls back to a ``when/then`` that handles both integer-year
+    and Date columns at runtime.
 
     Args:
         time_col: Name of the time column.
         start: ISO-8601 start date string (``"YYYY-MM-DD"``).
         end: ISO-8601 end date string (``"YYYY-MM-DD"``).
+        is_year_col: ``True`` → integer calendar-year column; ``False`` →
+            ``pl.Date`` column; ``None`` → unknown, use runtime detection.
 
     Returns:
         A Polars expression.
@@ -82,25 +96,25 @@ def _date_range_expr(time_col: str, start: str, end: str) -> pl.Expr:
     end_date = datetime.date.fromisoformat(end)
     col = pl.col(time_col)
 
-    # We use cast to string to avoid ComputeError when the column is an integer,
-    # but still allow exact date comparison.
-    # For integer year columns (e.g., 2020), cast to string yields "2020".
-    # For date columns, cast to string yields "2020-01-01".
-    # So we compare strings directly! Lexicographical string comparison works perfectly for ISO-8601 dates and 4-digit years.
-    # For year integers, "2020" >= "2020-01-01" is False.
-    # Wait, "2020" < "2020-01-01". So if it's an integer, "2020" will not be between "2020-01-01" and "2023-12-31" because "2020" is less than "2020-01-01".
-    # To fix this, we can extract the year for the integer comparison using a regex or length check.
-    # Better: check the length of the casted string. If 4, it's a year.
-    s_col = col.cast(pl.String)
-    is_year_int = s_col.str.len_bytes() == 4
+    if is_year_col is True:
+        # Integer year column — compare year integers directly, no string cast.
+        return col.is_between(start_date.year, end_date.year)
 
-    # Use strict=False so "2020-01-01" casts to null instead of raising ComputeError
-    year_expr = s_col.cast(pl.Int32, strict=False).is_between(
-        start_date.year, end_date.year
-    )
-    date_expr = s_col.is_between(pl.lit(start), pl.lit(end))
+    if is_year_col is False:
+        # Date column — compare against date literals directly.
+        return col.is_between(pl.lit(start_date), pl.lit(end_date))
 
-    return pl.when(is_year_int).then(year_expr).otherwise(date_expr)
+    # is_year_col is None — dtype unknown (e.g. direct test call without schema).
+    # Use a runtime when/then that handles both representations.
+    s_col = col.cast(pl.String)
+    is_year_like = s_col.str.len_bytes() == 4
+    return (
+        pl.when(is_year_like)
+        .then(
+            col.cast(pl.Int32, strict=False).is_between(start_date.year, end_date.year)
+        )
+        .otherwise(col.is_between(pl.lit(start_date), pl.lit(end_date)))
+    )
 
 
 def _season_expr(
@@ -227,17 +241,43 @@ def add_temporal_columns(
         df = df.with_columns(exprs)
 
     # --- season / season_year -----------------------------------------------
-    # Built via a Python map so SeasonConfig's exact date ranges are used.
-    # This is the only correct way to handle year-crossing seasons like rabi.
+    # Vectorized via Polars when/then on MM-DD string — no Python loop,
+    # no .to_list(), no Python date objects per row.
     if "season" not in existing or "season_year" not in existing:
-        season_labels = [season_config.season_for(d) for d in df[time_col].to_list()]
+        date_col = pl.col(time_col)
+        md = (
+            date_col.dt.month().cast(pl.String).str.pad_start(2, "0")
+            + pl.lit("-")
+            + date_col.dt.day().cast(pl.String).str.pad_start(2, "0")
+        )
+        k_start, k_end = season_config.kharif
+        r_start, r_end = season_config.rabi
+        z_start, z_end = season_config.zaid
+
+        def _md_between(expr: pl.Expr, start: str, end: str) -> pl.Expr:
+            """True when *expr* (MM-DD string) falls within [start, end], handling year rollover."""
+            if start <= end:
+                # is_between with bare strings → column-name lookup; use pl.lit().
+                return expr.is_between(pl.lit(start), pl.lit(end))
+            # Year-crossing: e.g. rabi 11-01 → 03-31
+            return (expr >= pl.lit(start)) | (expr <= pl.lit(end))
+
+        season_expr = (
+            pl.when(_md_between(md, k_start, k_end))
+            .then(pl.lit("kharif"))
+            .when(_md_between(md, r_start, r_end))
+            .then(pl.lit("rabi"))
+            .otherwise(pl.lit("zaid"))
+            .alias("season")
+        )
+
         if "season" not in existing:
-            df = df.with_columns(pl.Series("season", season_labels, dtype=pl.String))
+            df = df.with_columns(season_expr)
         if "season_year" not in existing:
-            years = df["year"].to_list()
-            season_year_labels = [f"{s}_{y}" for s, y in zip(season_labels, years)]
             df = df.with_columns(
-                pl.Series("season_year", season_year_labels, dtype=pl.String)
+                (pl.col("season") + pl.lit("_") + pl.col("year").cast(pl.String)).alias(
+                    "season_year"
+                )
             )
 
     return df

{core_lens-0.1.dev112 → core_lens-0.1.dev114}/src/core_lens/utils/spatial.py

@@ -230,6 +230,8 @@ def exact_spatial_filter(
             if inter_area / entity_area >= threshold:
                 hit_indices.append(i)
 
+    del geoms  # free all decoded Shapely geometries before assembling result
+
     matched: pl.DataFrame = full_df[hit_indices].select(key_cols)
     return matched