Polars v1.0.0 compatibility

h3ronpy/CHANGES.rst

@@ -17,6 +17,7 @@ Unreleased
 
 - Restrict numpy version to <2 until incompatibilities of rust-numpy with version 2 are resolved
 - Add `cells_to_localij` and `localij_to_cells` functions.
+- Polars v1.0.0 compatibility.
 
 0.20.2 - 2024-04-16
 -------------------

h3ronpy/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "h3ronpy"
-version = "0.20.2"
+version = "0.21.0"
 authors = ["Nico Mandery <nico@nmandery.net>"]
 description = "Data science toolkit for the H3 geospatial grid"
 edition = "2021"

h3ronpy/python/h3ronpy/polars/__init__.py

@@ -9,6 +9,7 @@
 """
 
 from functools import wraps
+import typing
 import polars as pl
 import pyarrow as pa
 from .. import arrow as _arrow
@@ -67,63 +68,71 @@ class H3Expr:
     def __init__(self, expr: pl.Expr):
         self._expr = expr
 
+    def __expr_map_series(self, func: typing.Callable[[pl.Series], pl.Series | typing.Any]) -> pl.Expr:
+        if hasattr(self._expr, "map"):
+            # polars < 1.0
+            return self._expr.map(func)
+        return self._expr.map_batches(func)
+
     def cells_resolution(self) -> pl.Expr:
-        return self._expr.map(lambda s: cells_resolution(s)).alias("resolution")
+        return self.__expr_map_series(lambda s: cells_resolution(s)).alias("resolution")
 
     def change_resolution(self, resolution: int) -> pl.Expr:
-        return self._expr.map(lambda s: change_resolution(s, resolution))
+        return self.__expr_map_series(lambda s: change_resolution(s, resolution))
 
     def change_resolution_list(self, resolution: int) -> pl.Expr:
-        return self._expr.map(lambda s: change_resolution_list(s, resolution))
+        return self.__expr_map_series(lambda s: change_resolution_list(s, resolution))
 
     def cells_parse(self, set_failing_to_invalid: bool = False) -> pl.Expr:
-        return self._expr.map(lambda s: cells_parse(s, set_failing_to_invalid=set_failing_to_invalid)).alias("cell")
+        return self.__expr_map_series(lambda s: cells_parse(s, set_failing_to_invalid=set_failing_to_invalid)).alias(
+            "cell"
+        )
 
     def vertexes_parse(self, set_failing_to_invalid: bool = False) -> pl.Expr:
-        return self._expr.map(lambda s: vertexes_parse(s, set_failing_to_invalid=set_failing_to_invalid)).alias(
+        return self.__expr_map_series(lambda s: vertexes_parse(s, set_failing_to_invalid=set_failing_to_invalid)).alias(
             "vertex"
         )
 
     def directededges_parse(self, set_failing_to_invalid: bool = False) -> pl.Expr:
-        return self._expr.map(lambda s: directededges_parse(s, set_failing_to_invalid=set_failing_to_invalid)).alias(
-            "directededge"
-        )
+        return self.__expr_map_series(
+            lambda s: directededges_parse(s, set_failing_to_invalid=set_failing_to_invalid)
+        ).alias("directededge")
 
     def grid_disk(self, k: int, flatten: bool = False) -> pl.Expr:
-        return self._expr.map(lambda s: grid_disk(s, k, flatten=flatten))
+        return self.__expr_map_series(lambda s: grid_disk(s, k, flatten=flatten))
 
     def compact(self, mixed_resolutions: bool = False) -> pl.Expr:
-        return self._expr.map(lambda s: compact(s, mixed_resolutions=mixed_resolutions))
+        return self.__expr_map_series(lambda s: compact(s, mixed_resolutions=mixed_resolutions))
 
     def uncompact(self, target_resolution: int) -> pl.Expr:
-        return self._expr.map(lambda s: uncompact(s, target_resolution))
+        return self.__expr_map_series(lambda s: uncompact(s, target_resolution))
 
     def cells_area_m2(self) -> pl.Expr:
-        return self._expr.map(lambda s: cells_area_m2(s)).alias("area_m2")
+        return self.__expr_map_series(lambda s: cells_area_m2(s)).alias("area_m2")
 
     def cells_area_km2(self) -> pl.Expr:
-        return self._expr.map(lambda s: cells_area_km2(s)).alias("area_km2")
+        return self.__expr_map_series(lambda s: cells_area_km2(s)).alias("area_km2")
 
     def cells_area_rads2(self) -> pl.Expr:
-        return self._expr.map(lambda s: cells_area_rads2(s)).alias("area_rads2")
+        return self.__expr_map_series(lambda s: cells_area_rads2(s)).alias("area_rads2")
 
     def cells_valid(self) -> pl.Expr:
-        return self._expr.map(lambda s: cells_valid(s)).alias("cells_valid")
+        return self.__expr_map_series(lambda s: cells_valid(s)).alias("cells_valid")
 
     def vertexes_valid(self) -> pl.Expr:
-        return self._expr.map(lambda s: vertexes_valid(s)).alias("vertexes_valid")
+        return self.__expr_map_series(lambda s: vertexes_valid(s)).alias("vertexes_valid")
 
     def directededges_valid(self) -> pl.Expr:
-        return self._expr.map(lambda s: directededges_valid(s)).alias("directededges_valid")
+        return self.__expr_map_series(lambda s: directededges_valid(s)).alias("directededges_valid")
 
     def cells_to_string(self) -> pl.Expr:
-        return self._expr.map(lambda s: cells_to_string(s))
+        return self.__expr_map_series(lambda s: cells_to_string(s))
 
     def vertexes_to_string(self) -> pl.Expr:
-        return self._expr.map(lambda s: vertexes_to_string(s))
+        return self.__expr_map_series(lambda s: vertexes_to_string(s))
 
     def directededges_to_string(self) -> pl.Expr:
-        return self._expr.map(lambda s: directededges_to_string(s))
+        return self.__expr_map_series(lambda s: directededges_to_string(s))
 
 
 @pl.api.register_series_namespace("h3")