pyogrio 0.8.0__cp311-cp311-win_amd64.whl → 0.10.0__cp311-cp311-win_amd64.whl

pyogrio/tests/test_geopandas_io.py

@@ -1,14 +1,23 @@
 import contextlib
+import locale
+import warnings
 from datetime import datetime
 from io import BytesIO
-import locale
+from zipfile import ZipFile
 
 import numpy as np
-import pytest
 
-from pyogrio import list_layers, read_info, __gdal_version__
+from pyogrio import (
+    __gdal_version__,
+    list_drivers,
+    list_layers,
+    read_info,
+    vsi_listtree,
+    vsi_unlink,
+)
+from pyogrio._compat import HAS_ARROW_WRITE_API, HAS_PYPROJ, PANDAS_GE_15
 from pyogrio.errors import DataLayerError, DataSourceError, FeatureError, GeometryError
-from pyogrio.geopandas import read_dataframe, write_dataframe, PANDAS_GE_20
+from pyogrio.geopandas import PANDAS_GE_20, read_dataframe, write_dataframe
 from pyogrio.raw import (
     DRIVERS_NO_MIXED_DIMENSIONS,
     DRIVERS_NO_MIXED_SINGLE_MULTI,
@@ -16,27 +25,29 @@ from pyogrio.raw import (
 from pyogrio.tests.conftest import (
     ALL_EXTS,
     DRIVERS,
-    requires_pyarrow_api,
+    START_FID,
     requires_arrow_write_api,
     requires_gdal_geos,
+    requires_pyarrow_api,
+    requires_pyproj,
 )
-from pyogrio._compat import PANDAS_GE_15, HAS_ARROW_WRITE_API
 
-try:
-    import pandas as pd
-    from pandas.testing import (
-        assert_frame_equal,
-        assert_index_equal,
-        assert_series_equal,
-    )
+import pytest
 
+try:
     import geopandas as gp
+    import pandas as pd
     from geopandas.array import from_wkt
-    from geopandas.testing import assert_geodataframe_equal
 
     import shapely  # if geopandas is present, shapely is expected to be present
     from shapely.geometry import Point
 
+    from geopandas.testing import assert_geodataframe_equal
+    from pandas.testing import (
+        assert_index_equal,
+        assert_series_equal,
+    )
+
 except ImportError:
     pass
 
@@ -124,7 +135,8 @@ def test_read_csv_platform_encoding(tmp_path):
 def test_read_dataframe(naturalearth_lowres_all_ext):
     df = read_dataframe(naturalearth_lowres_all_ext)
 
-    assert df.crs == "EPSG:4326"
+    if HAS_PYPROJ:
+        assert df.crs == "EPSG:4326"
     assert len(df) == 177
     assert df.columns.tolist() == [
         "pop_est",
@@ -142,14 +154,13 @@ def test_read_dataframe_vsi(naturalearth_lowres_vsi, use_arrow):
 
 
 @pytest.mark.parametrize(
-    "columns, fid_as_index, exp_len", [(None, False, 2), ([], True, 2), ([], False, 0)]
+    "columns, fid_as_index, exp_len", [(None, False, 3), ([], True, 3), ([], False, 0)]
 )
 def test_read_layer_without_geometry(
-    test_fgdb_vsi, columns, fid_as_index, use_arrow, exp_len
+    no_geometry_file, columns, fid_as_index, use_arrow, exp_len
 ):
     result = read_dataframe(
-        test_fgdb_vsi,
-        layer="basetable",
+        no_geometry_file,
         columns=columns,
         fid_as_index=fid_as_index,
         use_arrow=use_arrow,
@@ -195,38 +206,62 @@ def test_read_no_geometry_no_columns_no_fids(naturalearth_lowres, use_arrow):
         )
 
 
-def test_read_force_2d(test_fgdb_vsi, use_arrow):
-    with pytest.warns(
-        UserWarning, match=r"Measured \(M\) geometry types are not supported"
-    ):
-        df = read_dataframe(test_fgdb_vsi, layer="test_lines", max_features=1)
-        assert df.iloc[0].geometry.has_z
+def test_read_force_2d(tmp_path, use_arrow):
+    filename = tmp_path / "test.gpkg"
+
+    # create a GPKG with 3D point values
+    expected = gp.GeoDataFrame(
+        geometry=[Point(0, 0, 0), Point(1, 1, 0)], crs="EPSG:4326"
+    )
+    write_dataframe(expected, filename)
+
+    df = read_dataframe(filename)
+    assert df.iloc[0].geometry.has_z
+
+    df = read_dataframe(
+        filename,
+        force_2d=True,
+        max_features=1,
+        use_arrow=use_arrow,
+    )
+    assert not df.iloc[0].geometry.has_z
 
-        df = read_dataframe(
-            test_fgdb_vsi,
-            layer="test_lines",
-            force_2d=True,
-            max_features=1,
-            use_arrow=use_arrow,
-        )
-        assert not df.iloc[0].geometry.has_z
 
+def test_read_layer(tmp_path, use_arrow):
+    filename = tmp_path / "test.gpkg"
+
+    # create a multilayer GPKG
+    expected1 = gp.GeoDataFrame(geometry=[Point(0, 0)], crs="EPSG:4326")
+    write_dataframe(
+        expected1,
+        filename,
+        layer="layer1",
+    )
+
+    expected2 = gp.GeoDataFrame(geometry=[Point(1, 1)], crs="EPSG:4326")
+    write_dataframe(expected2, filename, layer="layer2", append=True)
+
+    assert np.array_equal(
+        list_layers(filename), [["layer1", "Point"], ["layer2", "Point"]]
+    )
+
+    kwargs = {"use_arrow": use_arrow, "max_features": 1}
 
-@pytest.mark.filterwarnings("ignore: Measured")
-@pytest.mark.filterwarnings("ignore: More than one layer found in")
-def test_read_layer(test_fgdb_vsi, use_arrow):
-    layers = list_layers(test_fgdb_vsi)
-    kwargs = {"use_arrow": use_arrow, "read_geometry": False, "max_features": 1}
+    # The first layer is read by default, which will warn when there are multiple
+    # layers
+    with pytest.warns(UserWarning, match="More than one layer found"):
+        df = read_dataframe(filename, **kwargs)
 
-    # The first layer is read by default (NOTE: first layer has no features)
-    df = read_dataframe(test_fgdb_vsi, **kwargs)
-    df2 = read_dataframe(test_fgdb_vsi, layer=layers[0][0], **kwargs)
-    assert_frame_equal(df, df2)
+    assert_geodataframe_equal(df, expected1)
 
-    # Reading a specific layer should return that layer.
+    # Reading a specific layer by name should return that layer.
     # Detected here by a known column.
-    df = read_dataframe(test_fgdb_vsi, layer="test_lines", **kwargs)
-    assert "RIVER_MILE" in df.columns
+    df = read_dataframe(filename, layer="layer2", **kwargs)
+    assert_geodataframe_equal(df, expected2)
+
+    # Reading a specific layer by index should return that layer
+    df = read_dataframe(filename, layer=1, **kwargs)
+    assert_geodataframe_equal(df, expected2)
 
 
 def test_read_layer_invalid(naturalearth_lowres_all_ext, use_arrow):
@@ -234,22 +269,19 @@ def test_read_layer_invalid(naturalearth_lowres_all_ext, use_arrow):
         read_dataframe(naturalearth_lowres_all_ext, layer="wrong", use_arrow=use_arrow)
 
 
-@pytest.mark.filterwarnings("ignore: Measured")
-def test_read_datetime(test_fgdb_vsi, use_arrow):
-    df = read_dataframe(
-        test_fgdb_vsi, layer="test_lines", use_arrow=use_arrow, max_features=1
-    )
+def test_read_datetime(datetime_file, use_arrow):
+    df = read_dataframe(datetime_file, use_arrow=use_arrow)
     if PANDAS_GE_20:
         # starting with pandas 2.0, it preserves the passed datetime resolution
-        assert df.SURVEY_DAT.dtype.name == "datetime64[ms]"
+        assert df.col.dtype.name == "datetime64[ms]"
     else:
-        assert df.SURVEY_DAT.dtype.name == "datetime64[ns]"
+        assert df.col.dtype.name == "datetime64[ns]"
 
 
 @pytest.mark.filterwarnings("ignore: Non-conformant content for record 1 in column ")
 @pytest.mark.requires_arrow_write_api
-def test_read_datetime_tz(test_datetime_tz, tmp_path, use_arrow):
-    df = read_dataframe(test_datetime_tz)
+def test_read_datetime_tz(datetime_tz_file, tmp_path, use_arrow):
+    df = read_dataframe(datetime_tz_file)
     # Make the index non-consecutive to test this case as well. Added for issue
     # https://github.com/geopandas/pyogrio/issues/324
     df = df.set_index(np.array([0, 2]))
@@ -319,14 +351,17 @@ def test_read_write_datetime_tz_with_nulls(tmp_path, use_arrow):
     assert_geodataframe_equal(df, result)
 
 
-def test_read_null_values(test_fgdb_vsi, use_arrow):
-    df = read_dataframe(
-        test_fgdb_vsi, layer="basetable_2", use_arrow=use_arrow, read_geometry=False
-    )
+def test_read_null_values(tmp_path, use_arrow):
+    filename = tmp_path / "test_null_values_no_geometry.gpkg"
+
+    # create a GPKG with no geometries and only null values
+    expected = pd.DataFrame({"col": [None, None]})
+    write_dataframe(expected, filename)
+
+    df = read_dataframe(filename, use_arrow=use_arrow, read_geometry=False)
 
     # make sure that Null values are preserved
-    assert df.SEGMENT_NAME.isnull().max()
-    assert df.loc[df.SEGMENT_NAME.isnull()].SEGMENT_NAME.iloc[0] is None
+    assert np.array_equal(df.col.values, expected.col.values)
 
 
 def test_read_fid_as_index(naturalearth_lowres_all_ext, use_arrow):
@@ -344,12 +379,9 @@ def test_read_fid_as_index(naturalearth_lowres_all_ext, use_arrow):
         fid_as_index=True,
         **kwargs,
     )
-    if naturalearth_lowres_all_ext.suffix in [".gpkg"]:
-        # File format where fid starts at 1
-        assert_index_equal(df.index, pd.Index([3, 4], name="fid"))
-    else:
-        # File format where fid starts at 0
-        assert_index_equal(df.index, pd.Index([2, 3], name="fid"))
+    fids_expected = pd.Index([2, 3], name="fid")
+    fids_expected += START_FID[naturalearth_lowres_all_ext.suffix]
+    assert_index_equal(df.index, fids_expected)
 
 
 def test_read_fid_as_index_only(naturalearth_lowres, use_arrow):
@@ -605,17 +637,22 @@ def test_read_fids_arrow_warning_old_gdal(naturalearth_lowres_all_ext):
         assert len(df) == 1
 
 
-def test_read_fids_force_2d(test_fgdb_vsi):
-    with pytest.warns(
-        UserWarning, match=r"Measured \(M\) geometry types are not supported"
-    ):
-        df = read_dataframe(test_fgdb_vsi, layer="test_lines", fids=[22])
-        assert len(df) == 1
-        assert df.iloc[0].geometry.has_z
+def test_read_fids_force_2d(tmp_path):
+    filename = tmp_path / "test.gpkg"
 
-        df = read_dataframe(test_fgdb_vsi, layer="test_lines", force_2d=True, fids=[22])
-        assert len(df) == 1
-        assert not df.iloc[0].geometry.has_z
+    # create a GPKG with 3D point values
+    expected = gp.GeoDataFrame(
+        geometry=[Point(0, 0, 0), Point(1, 1, 0)], crs="EPSG:4326"
+    )
+    write_dataframe(expected, filename)
+
+    df = read_dataframe(filename, fids=[1])
+    assert_geodataframe_equal(df, expected.iloc[:1])
+
+    df = read_dataframe(filename, force_2d=True, fids=[1])
+    assert np.array_equal(
+        df.geometry.values, shapely.force_2d(expected.iloc[:1].geometry.values)
+    )
 
 
 @pytest.mark.parametrize("skip_features", [10, 200])
@@ -769,7 +806,7 @@ def test_read_sql_invalid(naturalearth_lowres_all_ext, use_arrow):
             )
 
     with pytest.raises(
-        ValueError, match="'sql' paramater cannot be combined with 'layer'"
+        ValueError, match="'sql' parameter cannot be combined with 'layer'"
     ):
         read_dataframe(
             naturalearth_lowres_all_ext,
@@ -924,9 +961,9 @@ def test_write_csv_encoding(tmp_path, encoding):
     write_dataframe(df, csv_pyogrio_path, encoding=encoding)
 
     # Check if the text files written both ways can be read again and give same result.
-    with open(csv_path, "r", encoding=encoding) as csv:
+    with open(csv_path, encoding=encoding) as csv:
         csv_str = csv.read()
-    with open(csv_pyogrio_path, "r", encoding=encoding) as csv_pyogrio:
+    with open(csv_pyogrio_path, encoding=encoding) as csv_pyogrio:
         csv_pyogrio_str = csv_pyogrio.read()
     assert csv_str == csv_pyogrio_str
 
@@ -960,7 +997,7 @@ def test_write_dataframe(tmp_path, naturalearth_lowres, ext, use_arrow):
     if DRIVERS[ext] in DRIVERS_NO_MIXED_SINGLE_MULTI:
         assert list(geometry_types) == ["MultiPolygon"]
     else:
-        assert set(geometry_types) == set(["MultiPolygon", "Polygon"])
+        assert set(geometry_types) == {"MultiPolygon", "Polygon"}
 
     # Coordinates are not precisely equal when written to JSON
     # dtypes do not necessarily round-trip precisely through JSON
@@ -1062,6 +1099,23 @@ def test_write_empty_dataframe(tmp_path, ext, use_arrow):
     assert_geodataframe_equal(df, expected)
 
 
+def test_write_empty_geometry(tmp_path):
+    expected = gp.GeoDataFrame({"x": [0]}, geometry=from_wkt(["POINT EMPTY"]), crs=4326)
+    filename = tmp_path / "test.gpkg"
+
+    # Check that no warning is raised with GeoSeries.notna()
+    with warnings.catch_warnings():
+        warnings.simplefilter("error", UserWarning)
+        if not HAS_PYPROJ:
+            warnings.filterwarnings("ignore", message="'crs' was not provided.")
+        write_dataframe(expected, filename)
+    assert filename.exists()
+
+    # Xref GH-436: round-tripping possible with GPKG but not others
+    df = read_dataframe(filename)
+    assert_geodataframe_equal(df, expected)
+
+
 @pytest.mark.parametrize("ext", [".geojsonl", ".geojsons"])
 @pytest.mark.requires_arrow_write_api
 def test_write_read_empty_dataframe_unsupported(tmp_path, ext, use_arrow):
@@ -1161,7 +1215,7 @@ def test_write_dataframe_gdal_options(
         df,
         outfilename2,
         use_arrow=use_arrow,
-        layer_options=dict(spatial_index=spatial_index),
+        layer_options={"spatial_index": spatial_index},
     )
     assert outfilename2.exists() is True
     index_filename2 = tmp_path / "test2.qix"
@@ -1207,7 +1261,7 @@ def test_write_dataframe_gdal_options_dataset(tmp_path, naturalearth_lowres, use
         df,
         test_no_contents_filename2,
         use_arrow=use_arrow,
-        dataset_options=dict(add_gpkg_ogr_contents=False),
+        dataset_options={"add_gpkg_ogr_contents": False},
     )
     assert "gpkg_ogr_contents" not in _get_gpkg_table_names(test_no_contents_filename2)
 
@@ -1320,7 +1374,8 @@ def test_write_dataframe_promote_to_multi_layer_geom_type(
             ".shp",
             None,
             "Point",
-            "Could not add feature to layer at index|Error while writing batch to OGR layer",
+            "Could not add feature to layer at index|Error while writing batch to OGR "
+            "layer",
         ),
     ],
 )
@@ -1443,6 +1498,7 @@ def test_write_dataframe_infer_geometry_with_nulls(tmp_path, geoms, ext, use_arr
     "ignore: You will likely lose important projection information"
 )
 @pytest.mark.requires_arrow_write_api
+@requires_pyproj
 def test_custom_crs_io(tmp_path, naturalearth_lowres_all_ext, use_arrow):
     df = read_dataframe(naturalearth_lowres_all_ext)
     # project Belgium to a custom Albers Equal Area projection
@@ -1517,6 +1573,22 @@ def test_write_read_null(tmp_path, use_arrow):
     assert result_gdf["object_str"][2] is None
 
 
+@pytest.mark.requires_arrow_write_api
+def test_write_read_vsimem(naturalearth_lowres_vsi, use_arrow):
+    path, _ = naturalearth_lowres_vsi
+    mem_path = f"/vsimem/{path.name}"
+
+    input = read_dataframe(path, use_arrow=use_arrow)
+    assert len(input) == 177
+
+    try:
+        write_dataframe(input, mem_path, use_arrow=use_arrow)
+        result = read_dataframe(mem_path, use_arrow=use_arrow)
+        assert len(result) == 177
+    finally:
+        vsi_unlink(mem_path)
+
+
 @pytest.mark.parametrize(
     "wkt,geom_types",
     [
@@ -1529,7 +1601,7 @@ def test_write_read_null(tmp_path, use_arrow):
             ["2.5D MultiLineString", "MultiLineString Z"],
         ),
         (
-            "MultiPolygon Z (((0 0 0, 0 1 0, 1 1 0, 0 0 0)), ((1 1 1, 1 2 1, 2 2 1, 1 1 1)))",
+            "MultiPolygon Z (((0 0 0, 0 1 0, 1 1 0, 0 0 0)), ((1 1 1, 1 2 1, 2 2 1, 1 1 1)))",  # noqa: E501
             ["2.5D MultiPolygon", "MultiPolygon Z"],
         ),
         (
@@ -1572,7 +1644,7 @@ def test_write_geometry_z_types(tmp_path, wkt, geom_types, use_arrow):
             "MultiPolygon Z",
             False,
             [
-                "MultiPolygon Z (((0 0 0, 0 1 0, 1 1 0, 0 0 0)), ((1 1 1, 1 2 1, 2 2 1, 1 1 1)))"
+                "MultiPolygon Z (((0 0 0, 0 1 0, 1 1 0, 0 0 0)), ((1 1 1, 1 2 1, 2 2 1, 1 1 1)))"  # noqa: E501
             ],
         ),
         (
@@ -1641,24 +1713,76 @@ def test_write_geometry_z_types_auto(
     assert_geodataframe_equal(gdf, result_gdf)
 
 
-def test_read_multisurface(data_dir, use_arrow):
+@pytest.mark.parametrize(
+    "on_invalid, message",
+    [
+        (
+            "warn",
+            "Invalid WKB: geometry is returned as None. IllegalArgumentException: "
+            "Invalid number of points in LinearRing found 2 - must be 0 or >=",
+        ),
+        ("raise", "Invalid number of points in LinearRing found 2 - must be 0 or >="),
+        ("ignore", None),
+    ],
+)
+def test_read_invalid_poly_ring(tmp_path, use_arrow, on_invalid, message):
+    if on_invalid == "raise":
+        handler = pytest.raises(shapely.errors.GEOSException, match=message)
+    elif on_invalid == "warn":
+        handler = pytest.warns(match=message)
+    elif on_invalid == "ignore":
+        handler = contextlib.nullcontext()
+    else:
+        raise ValueError(f"unknown value for on_invalid: {on_invalid}")
+
+    # create a GeoJSON file with an invalid exterior ring
+    invalid_geojson = """{
+        "type": "FeatureCollection",
+        "features": [
+            {
+                "type": "Feature",
+                "properties": {},
+                "geometry": {
+                    "type": "Polygon",
+                    "coordinates": [ [ [0, 0], [0, 0] ] ]
+                }
+            }
+        ]
+    }"""
+
+    filename = tmp_path / "test.geojson"
+    with open(filename, "w") as f:
+        _ = f.write(invalid_geojson)
+
+    with handler:
+        df = read_dataframe(
+            filename,
+            use_arrow=use_arrow,
+            on_invalid=on_invalid,
+        )
+        df.geometry.isnull().all()
+
+
+def test_read_multisurface(multisurface_file, use_arrow):
     if use_arrow:
+        # TODO: revisit once https://github.com/geopandas/pyogrio/issues/478
+        # is resolved.
+        pytest.skip("Shapely + GEOS 3.13 crashes in from_wkb for this case")
+
         with pytest.raises(shapely.errors.GEOSException):
             # TODO(Arrow)
             # shapely fails parsing the WKB
-            read_dataframe(data_dir / "test_multisurface.gpkg", use_arrow=True)
+            read_dataframe(multisurface_file, use_arrow=True)
     else:
-        df = read_dataframe(data_dir / "test_multisurface.gpkg")
+        df = read_dataframe(multisurface_file)
 
         # MultiSurface should be converted to MultiPolygon
         assert df.geometry.type.tolist() == ["MultiPolygon"]
 
 
-def test_read_dataset_kwargs(data_dir, use_arrow):
-    filename = data_dir / "test_nested.geojson"
-
+def test_read_dataset_kwargs(nested_geojson_file, use_arrow):
     # by default, nested data are not flattened
-    df = read_dataframe(filename, use_arrow=use_arrow)
+    df = read_dataframe(nested_geojson_file, use_arrow=use_arrow)
 
     expected = gp.GeoDataFrame(
         {
@@ -1671,7 +1795,9 @@ def test_read_dataset_kwargs(data_dir, use_arrow):
 
     assert_geodataframe_equal(df, expected)
 
-    df = read_dataframe(filename, use_arrow=use_arrow, FLATTEN_NESTED_ATTRIBUTES="YES")
+    df = read_dataframe(
+        nested_geojson_file, use_arrow=use_arrow, FLATTEN_NESTED_ATTRIBUTES="YES"
+    )
 
     expected = gp.GeoDataFrame(
         {
@@ -1873,6 +1999,9 @@ def test_write_memory(naturalearth_lowres, driver):
         check_dtype=not is_json,
     )
 
+    # Check temp file was cleaned up. Filter, as gdal keeps cache files in /vsimem/.
+    assert vsi_listtree("/vsimem/", pattern="pyogrio_*") == []
+
 
 def test_write_memory_driver_required(naturalearth_lowres):
     df = read_dataframe(naturalearth_lowres)
@@ -1885,6 +2014,9 @@ def test_write_memory_driver_required(naturalearth_lowres):
     ):
         write_dataframe(df.head(1), buffer, driver=None, layer="test")
 
+    # Check temp file was cleaned up. Filter, as gdal keeps cache files in /vsimem/.
+    assert vsi_listtree("/vsimem/", pattern="pyogrio_*") == []
+
 
 @pytest.mark.parametrize("driver", ["ESRI Shapefile", "OpenFileGDB"])
 def test_write_memory_unsupported_driver(naturalearth_lowres, driver):
@@ -1900,6 +2032,9 @@ def test_write_memory_unsupported_driver(naturalearth_lowres, driver):
     ):
         write_dataframe(df, buffer, driver=driver, layer="test")
 
+    # Check temp file was cleaned up. Filter, as gdal keeps cache files in /vsimem/.
+    assert vsi_listtree("/vsimem/", pattern="pyogrio_*") == []
+
 
 @pytest.mark.parametrize("driver", ["GeoJSON", "GPKG"])
 def test_write_memory_append_unsupported(naturalearth_lowres, driver):
@@ -1912,6 +2047,9 @@ def test_write_memory_append_unsupported(naturalearth_lowres, driver):
     ):
         write_dataframe(df.head(1), buffer, driver=driver, layer="test", append=True)
 
+    # Check temp file was cleaned up. Filter, as gdal keeps cache files in /vsimem/.
+    assert vsi_listtree("/vsimem/", pattern="pyogrio_*") == []
+
 
 def test_write_memory_existing_unsupported(naturalearth_lowres):
     df = read_dataframe(naturalearth_lowres)
@@ -1923,6 +2061,33 @@ def test_write_memory_existing_unsupported(naturalearth_lowres):
     ):
         write_dataframe(df.head(1), buffer, driver="GeoJSON", layer="test")
 
+    # Check temp file was cleaned up. Filter, as gdal keeps cache files in /vsimem/.
+    assert vsi_listtree("/vsimem/", pattern="pyogrio_*") == []
+
+
+def test_write_open_file_handle(tmp_path, naturalearth_lowres):
+    """Verify that writing to an open file handle is not currently supported"""
+
+    df = read_dataframe(naturalearth_lowres)
+
+    # verify it fails for regular file handle
+    with pytest.raises(
+        NotImplementedError, match="writing to an open file handle is not yet supported"
+    ):
+        with open(tmp_path / "test.geojson", "wb") as f:
+            write_dataframe(df.head(1), f)
+
+    # verify it fails for ZipFile
+    with pytest.raises(
+        NotImplementedError, match="writing to an open file handle is not yet supported"
+    ):
+        with ZipFile(tmp_path / "test.geojson.zip", "w") as z:
+            with z.open("test.geojson", "w") as f:
+                write_dataframe(df.head(1), f)
+
+    # Check temp file was cleaned up. Filter, as gdal keeps cache files in /vsimem/.
+    assert vsi_listtree("/vsimem/", pattern="pyogrio_*") == []
+
 
 @pytest.mark.parametrize("ext", ["gpkg", "geojson"])
 def test_non_utf8_encoding_io(tmp_path, ext, encoded_text):
@@ -2014,7 +2179,8 @@ def test_non_utf8_encoding_io_shapefile(tmp_path, encoded_text, use_arrow):
 
 
 def test_encoding_read_option_collision_shapefile(naturalearth_lowres, use_arrow):
-    """Providing both encoding parameter and ENCODING open option (even if blank) is not allowed"""
+    """Providing both encoding parameter and ENCODING open option
+    (even if blank) is not allowed."""
 
     with pytest.raises(
         ValueError, match='cannot provide both encoding parameter and "ENCODING" option'
@@ -2025,7 +2191,8 @@ def test_encoding_read_option_collision_shapefile(naturalearth_lowres, use_arrow
 
 
 def test_encoding_write_layer_option_collision_shapefile(tmp_path, encoded_text):
-    """Providing both encoding parameter and ENCODING layer creation option (even if blank) is not allowed"""
+    """Providing both encoding parameter and ENCODING layer creation option
+    (even if blank) is not allowed."""
     encoding, text = encoded_text
 
     output_path = tmp_path / "test.shp"
@@ -2033,7 +2200,10 @@ def test_encoding_write_layer_option_collision_shapefile(tmp_path, encoded_text)
 
     with pytest.raises(
         ValueError,
-        match='cannot provide both encoding parameter and "ENCODING" layer creation option',
+        match=(
+            'cannot provide both encoding parameter and "ENCODING" layer creation '
+            "option"
+        ),
     ):
         write_dataframe(
             df, output_path, encoding=encoding, layer_options={"ENCODING": ""}
@@ -2067,3 +2237,78 @@ def test_non_utf8_encoding_shapefile_sql(tmp_path, use_arrow):
     )
     assert actual.columns[0] == mandarin
     assert actual[mandarin].values[0] == mandarin
+
+
+@pytest.mark.requires_arrow_write_api
+def test_write_kml_file_coordinate_order(tmp_path, use_arrow):
+    # confirm KML coordinates are written in lon, lat order even if CRS axis
+    # specifies otherwise
+    points = [Point(10, 20), Point(30, 40), Point(50, 60)]
+    gdf = gp.GeoDataFrame(geometry=points, crs="EPSG:4326")
+    output_path = tmp_path / "test.kml"
+    write_dataframe(
+        gdf, output_path, layer="tmp_layer", driver="KML", use_arrow=use_arrow
+    )
+
+    gdf_in = read_dataframe(output_path, use_arrow=use_arrow)
+
+    assert np.array_equal(gdf_in.geometry.values, points)
+
+    if "LIBKML" in list_drivers():
+        # test appending to the existing file only if LIBKML is available
+        # as it appears to fall back on LIBKML driver when appending.
+        points_append = [Point(70, 80), Point(90, 100), Point(110, 120)]
+        gdf_append = gp.GeoDataFrame(geometry=points_append, crs="EPSG:4326")
+
+        write_dataframe(
+            gdf_append,
+            output_path,
+            layer="tmp_layer",
+            driver="KML",
+            use_arrow=use_arrow,
+            append=True,
+        )
+        # force_2d used to only compare xy geometry as z-dimension is undesirably
+        # introduced when the kml file is over-written.
+        gdf_in_appended = read_dataframe(
+            output_path, use_arrow=use_arrow, force_2d=True
+        )
+
+        assert np.array_equal(gdf_in_appended.geometry.values, points + points_append)
+
+
+@pytest.mark.requires_arrow_write_api
+def test_write_geojson_rfc7946_coordinates(tmp_path, use_arrow):
+    points = [Point(10, 20), Point(30, 40), Point(50, 60)]
+    gdf = gp.GeoDataFrame(geometry=points, crs="EPSG:4326")
+    output_path = tmp_path / "test.geojson"
+    write_dataframe(
+        gdf,
+        output_path,
+        layer="tmp_layer",
+        driver="GeoJSON",
+        RFC7946=True,
+        use_arrow=use_arrow,
+    )
+
+    gdf_in = read_dataframe(output_path, use_arrow=use_arrow)
+
+    assert np.array_equal(gdf_in.geometry.values, points)
+
+    # test appending to the existing file
+
+    points_append = [Point(70, 80), Point(90, 100), Point(110, 120)]
+    gdf_append = gp.GeoDataFrame(geometry=points_append, crs="EPSG:4326")
+
+    write_dataframe(
+        gdf_append,
+        output_path,
+        layer="tmp_layer",
+        driver="GeoJSON",
+        RFC7946=True,
+        use_arrow=use_arrow,
+        append=True,
+    )
+
+    gdf_in_appended = read_dataframe(output_path, use_arrow=use_arrow)
+    assert np.array_equal(gdf_in_appended.geometry.values, points + points_append)