fix!: Generate child fields as non-nullable (#95)

This aligns geoarrow-c with geoarrow-rs and the geoarrow implementation
in the forthcoming geopandas!

This is a huge breaking change in the sense that it causes a lot of
tests to fail in geoarrow-pyarrow; however, it is not much of a breaking
change in the sense that the implementations here never check the
nullability flag on import (and geoarrow-pyarrow defers to them almost
everywhere).

Author: paleolimbot

.github/workflows/python.yaml

@@ -19,15 +19,10 @@ jobs:
     strategy:
       matrix:
         os: [ubuntu-latest]
-        python-version: ['3.8', '3.9', '3.10', '3.11']
+        python-version: ['3.8', '3.9', '3.10', '3.11', '3.12']
 
     steps:
       - uses: actions/checkout@v4
-      - uses: actions/checkout@v4
-        with:
-          repository: geoarrow/geoarrow-python
-          path: geoarrow-python
-
 
       - name: Set up Python ${{ matrix.python-version }}
         uses: actions/setup-python@v4
@@ -40,28 +35,10 @@ jobs:
           pushd python/geoarrow-c
           pip install ".[test]"
 
-      - name: Install (geoarrow-pyarrow)
-        run: |
-          pushd geoarrow-python/geoarrow-pyarrow
-          pip install ".[test]"
-
-      - name: Install (geoarrow-pandas)
-        run: |
-          pushd geoarrow-python/geoarrow-pandas
-          pip install ".[test]"
-
       - name: Run tests (geoarrow-c)
         run: |
           pytest python/geoarrow-c/tests -v -s
 
-      - name: Run tests (geoarrow-pyarrow)
-        run: |
-          pytest geoarrow-python/geoarrow-pyarrow/tests -v -s
-
-      - name: Run tests (geoarrow-pandas)
-        run: |
-          pytest geoarrow-python/geoarrow-pandas/tests -v -s
-
       - name: Install coverage dependencies
         run: |
           sudo apt-get install -y lcov
@@ -72,8 +49,10 @@ jobs:
           pip install -e python/geoarrow-c/
 
       - name: Coverage (geoarrow-c)
-        if: success() && matrix.python-version == '3.11'
+        if: success() && matrix.python-version == '3.12'
         run: |
+          pip install setuptools Cython
+
           pushd python/geoarrow-c
 
           # Build with Cython + gcc coverage options
@@ -99,13 +78,13 @@ jobs:
           popd
 
       - name: Upload coverage to codecov
-        if: success() && matrix.python-version == '3.11'
+        if: success() && matrix.python-version == '3.12'
         uses: codecov/codecov-action@v2
         with:
           files: 'python/geoarrow-c/coverage.info,python/geoarrow-c/coverage.xml'
 
       - name: Run doctests
-        if: success() && matrix.python-version == '3.11'
+        if: success() && matrix.python-version == '3.12'
         run: |
           pushd python/geoarrow-c
           pytest --pyargs geoarrow.c --doctest-modules

python/geoarrow-c/tests/test_geoarrow_lib.py

@@ -98,7 +98,10 @@ def test_c_vector_type():
 
     pa_type = pa.DataType._import_from_c(schema._addr())
     pa_type_expected = pa.struct(
-        [pa.field("x", pa.float64()), pa.field("y", pa.float64())]
+        [
+            pa.field("x", pa.float64(), nullable=False),
+            pa.field("y", pa.float64(), nullable=False),
+        ]
     )
 
     # Depending on how the tests are run, the extension type might be

src/geoarrow/schema.c

@@ -15,6 +15,9 @@ static GeoArrowErrorCode GeoArrowSchemaInitCoordFixedSizeList(struct ArrowSchema
   NANOARROW_RETURN_NOT_OK(ArrowSchemaSetName(schema->children[0], dims));
   NANOARROW_RETURN_NOT_OK(ArrowSchemaSetType(schema->children[0], NANOARROW_TYPE_DOUBLE));
 
+  // Set child field non-nullable
+  schema->children[0]->flags = 0;
+
   return GEOARROW_OK;
 }
 
@@ -29,15 +32,17 @@ static GeoArrowErrorCode GeoArrowSchemaInitCoordStruct(struct ArrowSchema* schem
     NANOARROW_RETURN_NOT_OK(
         ArrowSchemaInitFromType(schema->children[i], NANOARROW_TYPE_DOUBLE));
     NANOARROW_RETURN_NOT_OK(ArrowSchemaSetName(schema->children[i], dim_name));
+    // Set child non-nullable
+    schema->children[i]->flags = 0;
   }
 
   return GEOARROW_OK;
 }
 
-static GeoArrowErrorCode GeoArrowSchemaInitListStruct(struct ArrowSchema* schema,
-                                                      enum GeoArrowCoordType coord_type,
-                                                      const char* dims, int n,
-                                                      const char** child_names) {
+static GeoArrowErrorCode GeoArrowSchemaInitListOf(struct ArrowSchema* schema,
+                                                  enum GeoArrowCoordType coord_type,
+                                                  const char* dims, int n,
+                                                  const char** child_names) {
   if (n == 0) {
     switch (coord_type) {
       case GEOARROW_COORD_TYPE_SEPARATE:
@@ -51,9 +56,14 @@ static GeoArrowErrorCode GeoArrowSchemaInitListStruct(struct ArrowSchema* schema
     ArrowSchemaInit(schema);
     NANOARROW_RETURN_NOT_OK(ArrowSchemaSetFormat(schema, "+l"));
     NANOARROW_RETURN_NOT_OK(ArrowSchemaAllocateChildren(schema, 1));
-    NANOARROW_RETURN_NOT_OK(GeoArrowSchemaInitListStruct(schema->children[0], coord_type,
-                                                         dims, n - 1, child_names + 1));
-    return ArrowSchemaSetName(schema->children[0], child_names[0]);
+    NANOARROW_RETURN_NOT_OK(GeoArrowSchemaInitListOf(schema->children[0], coord_type,
+                                                     dims, n - 1, child_names + 1));
+    NANOARROW_RETURN_NOT_OK(ArrowSchemaSetName(schema->children[0], child_names[0]));
+
+    // Set child field non-nullable
+    schema->children[0]->flags = 0;
+
+    return NANOARROW_OK;
   }
 }
 
@@ -112,32 +122,42 @@ GeoArrowErrorCode GeoArrowSchemaInit(struct ArrowSchema* schema, enum GeoArrowTy
     case GEOARROW_GEOMETRY_TYPE_POINT:
       switch (coord_type) {
         case GEOARROW_COORD_TYPE_SEPARATE:
-          return GeoArrowSchemaInitCoordStruct(schema, dims);
+          NANOARROW_RETURN_NOT_OK(GeoArrowSchemaInitCoordStruct(schema, dims));
+          break;
         case GEOARROW_COORD_TYPE_INTERLEAVED:
-          return GeoArrowSchemaInitCoordFixedSizeList(schema, dims);
+          NANOARROW_RETURN_NOT_OK(GeoArrowSchemaInitCoordFixedSizeList(schema, dims));
+          break;
         default:
           return EINVAL;
       }
+      break;
 
     case GEOARROW_GEOMETRY_TYPE_LINESTRING:
-      return GeoArrowSchemaInitListStruct(schema, coord_type, dims, 1,
-                                          CHILD_NAMES_LINESTRING);
+      NANOARROW_RETURN_NOT_OK(
+          GeoArrowSchemaInitListOf(schema, coord_type, dims, 1, CHILD_NAMES_LINESTRING));
+      break;
     case GEOARROW_GEOMETRY_TYPE_MULTIPOINT:
-      return GeoArrowSchemaInitListStruct(schema, coord_type, dims, 1,
-                                          CHILD_NAMES_MULTIPOINT);
+      NANOARROW_RETURN_NOT_OK(
+          GeoArrowSchemaInitListOf(schema, coord_type, dims, 1, CHILD_NAMES_MULTIPOINT));
+      break;
     case GEOARROW_GEOMETRY_TYPE_POLYGON:
-      return GeoArrowSchemaInitListStruct(schema, coord_type, dims, 2,
-                                          CHILD_NAMES_POLYGON);
+      NANOARROW_RETURN_NOT_OK(
+          GeoArrowSchemaInitListOf(schema, coord_type, dims, 2, CHILD_NAMES_POLYGON));
+      break;
     case GEOARROW_GEOMETRY_TYPE_MULTILINESTRING:
-      return GeoArrowSchemaInitListStruct(schema, coord_type, dims, 2,
-                                          CHILD_NAMES_MULTILINESTRING);
+      NANOARROW_RETURN_NOT_OK(GeoArrowSchemaInitListOf(schema, coord_type, dims, 2,
+                                                       CHILD_NAMES_MULTILINESTRING));
+      break;
     case GEOARROW_GEOMETRY_TYPE_MULTIPOLYGON:
-      return GeoArrowSchemaInitListStruct(schema, coord_type, dims, 3,
-                                          CHILD_NAMES_MULTIPOLYGON);
+      NANOARROW_RETURN_NOT_OK(GeoArrowSchemaInitListOf(schema, coord_type, dims, 3,
+                                                       CHILD_NAMES_MULTIPOLYGON));
+      break;
 
     default:
       return ENOTSUP;
   }
+
+  return NANOARROW_OK;
 }
 
 GeoArrowErrorCode GeoArrowSchemaInitExtension(struct ArrowSchema* schema,