feat: handle geoarrow

Author: nicokant

pyproject.toml

@@ -23,6 +23,7 @@ authors = [
 dependencies = [
   "chardet>=5.2.0",
   "fsspec[s3]>=2026.2.0",
+  "geoarrow-pandas>=0.1.0",
   "gpxpy>=1.6.2",
   "numpy>=2.2.6",
   "pandas>=2.3.3",

src/gps_logger_parser/gps/columns.py

@@ -8,6 +8,7 @@ class GPSHarmonizedColumn(str, Enum):
     TIMESTAMP = "timestamp"
     LATITUDE = "latitude"
     LONGITUDE = "longitude"
+    GEOMETRY = "geometry"
     ALTITUDE = "altitude"
     SPEED_KM_H = "speed_km_h"
     TYPE = "type"
@@ -29,6 +30,7 @@ class GPSHarmonizedColumn(str, Enum):
     GPSHarmonizedColumn.TIMESTAMP: "datetime64[ns]",
     GPSHarmonizedColumn.LATITUDE: "float64",
     GPSHarmonizedColumn.LONGITUDE: "float64",
+    GPSHarmonizedColumn.GEOMETRY: "geoarrow.point",
     GPSHarmonizedColumn.ALTITUDE: "float64",
     GPSHarmonizedColumn.SPEED_KM_H: "float64",
     GPSHarmonizedColumn.TYPE: "object",

src/gps_logger_parser/gps/jm.py

@@ -116,6 +116,10 @@ def harmonize_data(self, data):
                 format="%d %H:%M:%S",
                 errors="coerce",
             )
+
+        # Recreate geometry column now that lat/lon are finalized
+        data = self._create_geometry_column(data)
+
         return data
 
     def _fix_content(self, data):

src/gps_logger_parser/gps/mixin.py

@@ -6,6 +6,7 @@
 GPS_HARMONIZED_COLUMN_TYPES specification.
 """
 
+import geoarrow.pyarrow as ga
 import numpy as np
 import pandas as pd
 
@@ -34,11 +35,15 @@ def harmonize_data(self, data):
         # First, apply standard column renaming
         data = super().harmonize_data(data)
 
-        # Then ensure all GPS harmonized columns exist with correct types
+        # Ensure all GPS harmonized columns exist with correct types
         for harmonized_col in GPSHarmonizedColumn:
             col_name = harmonized_col.value
             pd_dtype = GPS_HARMONIZED_COLUMN_TYPES[harmonized_col]
 
+            # Skip geometry column - we'll create it last from lat/lon
+            if col_name == "geometry":
+                continue
+
             if col_name not in data.columns:
                 # Add column with null values and appropriate dtype
                 if pd_dtype == "float64":
@@ -65,6 +70,56 @@ def harmonize_data(self, data):
                 elif pd_dtype == "datetime64[ns]":
                     data[col_name] = pd.to_datetime(data[col_name], errors="coerce")
 
+        # Create geometry column from latitude and longitude (WGS84)
+        # Note: This creates geometry from current lat/lon values
+        # If parsers modify lat/lon after calling super(), they should
+        # call _create_geometry_column() again
+        data = self._create_geometry_column(data)
+
+        return data
+
+    def _create_geometry_column(self, data):
+        """
+        Create or update geometry column from latitude and longitude.
+
+        This helper method can be called by subclasses after they've
+        finished creating/modifying latitude and longitude columns.
+
+        Args:
+            data: DataFrame with latitude and longitude columns
+
+        Returns:
+            DataFrame with geometry column added/updated
+        """
+        # Only create if lat/lon columns exist and have valid (non-null) values
+        if (
+            "latitude" in data.columns
+            and "longitude" in data.columns
+            and not data["latitude"].isna().all()
+            and not data["longitude"].isna().all()
+        ):
+            # Create point geometries from lat/lon coordinates
+            # GeoArrow expects (x, y) which is (longitude, latitude)
+            points = ga.make_point(
+                data["longitude"].values,
+                data["latitude"].values,
+                crs="EPSG:4326",
+            )
+            # Convert to pandas ArrowExtensionArray
+            data["geometry"] = pd.array(
+                points.to_pylist(), dtype=pd.ArrowDtype(points.type)
+            )
+        else:
+            # Create empty geometry column if lat/lon don't exist or are all null
+            empty_points = ga.make_point(
+                np.full(len(data), np.nan),
+                np.full(len(data), np.nan),
+                crs="EPSG:4326",
+            )
+            data["geometry"] = pd.array(
+                empty_points.to_pylist(), dtype=pd.ArrowDtype(empty_points.type)
+            )
+
         return data
 
     def get_harmonization_schema(self):

src/gps_logger_parser/tests/test_parsers.py

@@ -122,6 +122,32 @@ def test_harmonized_output_schema(file, path, file_format):
                 f"GPS parser {file} is missing harmonized column '{col_name}'"
             )
 
+        # Verify geometry column has correct type and coordinates match lat/lon
+        geometry_field = table.schema.field("geometry")
+        assert "geoarrow.point" in str(geometry_field.type), (
+            f"Geometry column should be geoarrow.point type, got {geometry_field.type} in {file}"
+        )
+
+        # Convert to pandas and verify geometry coordinates match lat/lon
+        df = table.to_pandas()
+        if not df["latitude"].isna().all() and not df["longitude"].isna().all():
+            # Check first non-null geometry
+            for idx in range(min(3, len(df))):
+                if (
+                    not df["latitude"].isna().iloc[idx]
+                    and not df["longitude"].isna().iloc[idx]
+                ):
+                    geom = df["geometry"].iloc[idx]
+                    lat = df["latitude"].iloc[idx]
+                    lon = df["longitude"].iloc[idx]
+                    assert abs(geom["x"] - lon) < 1e-6, (
+                        f"Geometry x-coordinate {geom['x']} doesn't match longitude {lon} in {file}"
+                    )
+                    assert abs(geom["y"] - lat) < 1e-6, (
+                        f"Geometry y-coordinate {geom['y']} doesn't match latitude {lat} in {file}"
+                    )
+                    break
+
 
 @pytest.mark.timeout(10)
 @pytest.mark.parametrize("file,path,file_format", testdata_success)