pyogrio 0.8.0__cp39-cp39-win_amd64.whl → 0.10.0__cp39-cp39-win_amd64.whl

pyogrio/tests/test_path.py

@@ -1,16 +1,17 @@
+import contextlib
 import os
 from pathlib import Path
-import contextlib
-from zipfile import ZipFile, ZIP_DEFLATED
-
-import pytest
+from zipfile import ZIP_DEFLATED, ZipFile
 
 import pyogrio
 import pyogrio.raw
-from pyogrio.util import vsi_path, get_vsi_path_or_buffer
+from pyogrio._compat import HAS_PYPROJ
+from pyogrio.util import get_vsi_path_or_buffer, vsi_path
+
+import pytest
 
 try:
-    import geopandas  # NOQA
+    import geopandas  # noqa: F401
 
     has_geopandas = True
 except ImportError:
@@ -32,9 +33,11 @@ def change_cwd(path):
     [
         # local file paths that should be passed through as is
         ("data.gpkg", "data.gpkg"),
+        (Path("data.gpkg"), "data.gpkg"),
         ("/home/user/data.gpkg", "/home/user/data.gpkg"),
         (r"C:\User\Documents\data.gpkg", r"C:\User\Documents\data.gpkg"),
         ("file:///home/user/data.gpkg", "/home/user/data.gpkg"),
+        ("/home/folder # with hash/data.gpkg", "/home/folder # with hash/data.gpkg"),
         # cloud URIs
         ("https://testing/data.gpkg", "/vsicurl/https://testing/data.gpkg"),
         ("s3://testing/data.gpkg", "/vsis3/testing/data.gpkg"),
@@ -83,6 +86,8 @@ def change_cwd(path):
             "s3://testing/test.zip!a/b/item.shp",
             "/vsizip/vsis3/testing/test.zip/a/b/item.shp",
         ),
+        ("/vsimem/data.gpkg", "/vsimem/data.gpkg"),
+        (Path("/vsimem/data.gpkg"), "/vsimem/data.gpkg"),
     ],
 )
 def test_vsi_path(path, expected):
@@ -237,6 +242,9 @@ def test_detect_zip_path(tmp_path, naturalearth_lowres):
     path = tmp_path / "test.zip"
     with ZipFile(path, mode="w", compression=ZIP_DEFLATED, compresslevel=5) as out:
         for ext in ["dbf", "prj", "shp", "shx"]:
+            if not HAS_PYPROJ and ext == "prj":
+                continue
+
             filename = f"test1.{ext}"
             out.write(tmp_path / filename, filename)
 
@@ -278,6 +286,7 @@ def test_url():
     assert len(result[0]) == 177
 
 
+@pytest.mark.network
 @pytest.mark.skipif(not has_geopandas, reason="GeoPandas not available")
 def test_url_dataframe():
     url = "https://raw.githubusercontent.com/geopandas/pyogrio/main/pyogrio/tests/fixtures/naturalearth_lowres/naturalearth_lowres.shp"
@@ -333,19 +342,23 @@ def test_uri_s3_dataframe(aws_env_setup):
     assert len(df) == 67
 
 
-def test_get_vsi_path_or_buffer_obj_to_string():
-    path = Path("/tmp/test.gpkg")
-    assert get_vsi_path_or_buffer(path) == str(path)
+@pytest.mark.parametrize(
+    "path, expected",
+    [
+        (Path("/tmp/test.gpkg"), str(Path("/tmp/test.gpkg"))),
+        (Path("/vsimem/test.gpkg"), "/vsimem/test.gpkg"),
+    ],
+)
+def test_get_vsi_path_or_buffer_obj_to_string(path, expected):
+    """Verify that get_vsi_path_or_buffer retains forward slashes in /vsimem paths.
+
+    The /vsimem paths should keep forward slashes for GDAL to recognize them as such.
+    However, on Windows systems, forward slashes are by default replaced by backslashes,
+    so this test verifies that this doesn't happen for /vsimem paths.
+    """
+    assert get_vsi_path_or_buffer(path) == expected
 
 
 def test_get_vsi_path_or_buffer_fixtures_to_string(tmp_path):
     path = tmp_path / "test.gpkg"
     assert get_vsi_path_or_buffer(path) == str(path)
-
-
-@pytest.mark.parametrize(
-    "raw_path", ["/vsimem/test.shp.zip", "/vsizip//vsimem/test.shp.zip"]
-)
-def test_vsimem_path_exception(raw_path):
-    with pytest.raises(ValueError, match=""):
-        vsi_path(raw_path)

pyogrio/tests/test_raw_io.py

@@ -1,33 +1,36 @@
 import contextlib
 import ctypes
-from io import BytesIO
 import json
 import sys
+from io import BytesIO
+from zipfile import ZipFile
 
 import numpy as np
 from numpy import array_equal
-import pytest
 
 import pyogrio
 from pyogrio import (
-    list_layers,
+    __gdal_version__,
+    get_gdal_config_option,
     list_drivers,
+    list_layers,
     read_info,
     set_gdal_config_options,
-    get_gdal_config_option,
-    __gdal_version__,
 )
-from pyogrio._compat import HAS_SHAPELY, HAS_PYARROW
-from pyogrio.raw import read, write, open_arrow
-from pyogrio.errors import DataSourceError, DataLayerError, FeatureError
+from pyogrio._compat import HAS_PYARROW, HAS_SHAPELY
+from pyogrio.errors import DataLayerError, DataSourceError, FeatureError
+from pyogrio.raw import open_arrow, read, write
 from pyogrio.tests.conftest import (
-    DRIVERS,
     DRIVER_EXT,
+    DRIVERS,
     prepare_testfile,
-    requires_pyarrow_api,
     requires_arrow_api,
+    requires_pyarrow_api,
+    requires_shapely,
 )
 
+import pytest
+
 try:
     import shapely
 except ImportError:
@@ -116,6 +119,29 @@ def test_read_no_geometry(naturalearth_lowres):
     assert geometry is None
 
 
+@requires_shapely
+def test_read_no_geometry__mask(naturalearth_lowres):
+    geometry, fields = read(
+        naturalearth_lowres,
+        read_geometry=False,
+        mask=shapely.Point(-105, 55),
+    )[2:]
+
+    assert np.array_equal(fields[3], ["CAN"])
+    assert geometry is None
+
+
+def test_read_no_geometry__bbox(naturalearth_lowres):
+    geometry, fields = read(
+        naturalearth_lowres,
+        read_geometry=False,
+        bbox=(-109.0, 55.0, -109.0, 55.0),
+    )[2:]
+
+    assert np.array_equal(fields[3], ["CAN"])
+    assert geometry is None
+
+
 def test_read_no_geometry_no_columns_no_fids(naturalearth_lowres):
     with pytest.raises(
         ValueError,
@@ -255,9 +281,7 @@ def test_read_bbox_where(naturalearth_lowres_all_ext):
     assert np.array_equal(fields[3], ["CAN"])
 
 
-@pytest.mark.skipif(
-    not HAS_SHAPELY, reason="Shapely is required for mask functionality"
-)
+@requires_shapely
 @pytest.mark.parametrize(
     "mask",
     [
@@ -271,17 +295,13 @@ def test_read_mask_invalid(naturalearth_lowres, mask):
         read(naturalearth_lowres, mask=mask)
 
 
-@pytest.mark.skipif(
-    not HAS_SHAPELY, reason="Shapely is required for mask functionality"
-)
+@requires_shapely
 def test_read_bbox_mask_invalid(naturalearth_lowres):
     with pytest.raises(ValueError, match="cannot set both 'bbox' and 'mask'"):
         read(naturalearth_lowres, bbox=(-85, 8, -80, 10), mask=shapely.Point(-105, 55))
 
 
-@pytest.mark.skipif(
-    not HAS_SHAPELY, reason="Shapely is required for mask functionality"
-)
+@requires_shapely
 @pytest.mark.parametrize(
     "mask,expected",
     [
@@ -316,9 +336,7 @@ def test_read_mask(naturalearth_lowres_all_ext, mask, expected):
     assert len(geometry) == len(expected)
 
 
-@pytest.mark.skipif(
-    not HAS_SHAPELY, reason="Shapely is required for mask functionality"
-)
+@requires_shapely
 def test_read_mask_sql(naturalearth_lowres_all_ext):
     fields = read(
         naturalearth_lowres_all_ext,
@@ -329,9 +347,7 @@ def test_read_mask_sql(naturalearth_lowres_all_ext):
     assert np.array_equal(fields[3], ["CAN"])
 
 
-@pytest.mark.skipif(
-    not HAS_SHAPELY, reason="Shapely is required for mask functionality"
-)
+@requires_shapely
 def test_read_mask_where(naturalearth_lowres_all_ext):
     fields = read(
         naturalearth_lowres_all_ext,
@@ -603,13 +619,80 @@ def test_write_no_geom_no_fields():
     __gdal_version__ < (3, 6, 0),
     reason="OpenFileGDB write support only available for GDAL >= 3.6.0",
 )
-def test_write_openfilegdb(tmp_path, naturalearth_lowres):
-    meta, _, geometry, field_data = read(naturalearth_lowres)
+@pytest.mark.parametrize(
+    "write_int64",
+    [
+        False,
+        pytest.param(
+            True,
+            marks=pytest.mark.skipif(
+                __gdal_version__ < (3, 9, 0),
+                reason="OpenFileGDB write support for int64 values for GDAL >= 3.9.0",
+            ),
+        ),
+    ],
+)
+def test_write_openfilegdb(tmp_path, write_int64):
+    # Point(0, 0)
+    expected_geometry = np.array(
+        [bytes.fromhex("010100000000000000000000000000000000000000")] * 3, dtype=object
+    )
+    expected_field_data = [
+        np.array([True, False, True], dtype="bool"),
+        np.array([1, 2, 3], dtype="int16"),
+        np.array([1, 2, 3], dtype="int32"),
+        np.array([1, 2, 3], dtype="int64"),
+        np.array([1, 2, 3], dtype="float32"),
+        np.array([1, 2, 3], dtype="float64"),
+    ]
+    expected_fields = ["bool", "int16", "int32", "int64", "float32", "float64"]
+    expected_meta = {
+        "geometry_type": "Point",
+        "crs": "EPSG:4326",
+        "fields": expected_fields,
+    }
 
     filename = tmp_path / "test.gdb"
-    write(filename, geometry, field_data, driver="OpenFileGDB", **meta)
 
-    assert filename.exists()
+    # int64 is not supported without additional config: https://gdal.org/en/latest/drivers/vector/openfilegdb.html#bit-integer-field-support
+    # it is converted to float64 by default and raises a warning
+    # (for GDAL >= 3.9.0 only)
+    write_params = (
+        {"TARGET_ARCGIS_VERSION": "ARCGIS_PRO_3_2_OR_LATER"} if write_int64 else {}
+    )
+
+    if write_int64 or __gdal_version__ < (3, 9, 0):
+        ctx = contextlib.nullcontext()
+    else:
+        ctx = pytest.warns(
+            RuntimeWarning, match="Integer64 will be written as a Float64"
+        )
+
+    with ctx:
+        write(
+            filename,
+            expected_geometry,
+            expected_field_data,
+            driver="OpenFileGDB",
+            **expected_meta,
+            **write_params,
+        )
+
+    meta, _, geometry, field_data = read(filename)
+
+    if not write_int64:
+        expected_field_data[3] = expected_field_data[3].astype("float64")
+
+    # bool types are converted to int32
+    expected_field_data[0] = expected_field_data[0].astype("int32")
+
+    assert meta["crs"] == expected_meta["crs"]
+    assert np.array_equal(meta["fields"], expected_meta["fields"])
+
+    assert np.array_equal(geometry, expected_geometry)
+    for i in range(len(expected_field_data)):
+        assert field_data[i].dtype == expected_field_data[i].dtype
+        assert np.array_equal(field_data[i], expected_field_data[i])
 
 
 @pytest.mark.parametrize("ext", DRIVERS)
@@ -743,7 +826,7 @@ def assert_equal_result(result1, result2):
 
     assert np.array_equal(meta1["fields"], meta2["fields"])
     assert np.array_equal(index1, index2)
-    assert all([np.array_equal(f1, f2) for f1, f2 in zip(field_data1, field_data2)])
+    assert all(np.array_equal(f1, f2) for f1, f2 in zip(field_data1, field_data2))
 
     if HAS_SHAPELY:
         # a plain `assert np.array_equal(geometry1, geometry2)` doesn't work
@@ -794,6 +877,12 @@ def test_read_from_file_like(tmp_path, naturalearth_lowres, driver, ext):
     assert_equal_result((meta, index, geometry, field_data), result2)
 
 
+def test_read_from_nonseekable_bytes(nonseekable_bytes):
+    meta, _, geometry, _ = read(nonseekable_bytes)
+    assert meta["fields"].shape == (0,)
+    assert len(geometry) == 1
+
+
 @pytest.mark.parametrize("ext", ["gpkg", "fgb"])
 def test_read_write_data_types_numeric(tmp_path, ext):
     # Point(0, 0)
@@ -809,13 +898,13 @@ def test_read_write_data_types_numeric(tmp_path, ext):
         np.array([1, 2, 3], dtype="float64"),
     ]
     fields = ["bool", "int16", "int32", "int64", "float32", "float64"]
-    meta = dict(geometry_type="Point", crs="EPSG:4326", spatial_index=False)
+    meta = {"geometry_type": "Point", "crs": "EPSG:4326", "spatial_index": False}
 
     filename = tmp_path / f"test.{ext}"
     write(filename, geometry, field_data, fields, **meta)
     result = read(filename)[3]
-    assert all([np.array_equal(f1, f2) for f1, f2 in zip(result, field_data)])
-    assert all([f1.dtype == f2.dtype for f1, f2 in zip(result, field_data)])
+    assert all(np.array_equal(f1, f2) for f1, f2 in zip(result, field_data))
+    assert all(f1.dtype == f2.dtype for f1, f2 in zip(result, field_data))
 
     # other integer data types that don't roundtrip exactly
     # these are generally promoted to a larger integer type except for uint64
@@ -866,7 +955,7 @@ def test_read_write_datetime(tmp_path):
     geometry = np.array(
         [bytes.fromhex("010100000000000000000000000000000000000000")] * 2, dtype=object
     )
-    meta = dict(geometry_type="Point", crs="EPSG:4326", spatial_index=False)
+    meta = {"geometry_type": "Point", "crs": "EPSG:4326", "spatial_index": False}
 
     filename = tmp_path / "test.gpkg"
     write(filename, geometry, field_data, fields, **meta)
@@ -889,7 +978,7 @@ def test_read_write_int64_large(tmp_path, ext):
     )
     field_data = [np.array([1, 2192502720, -5], dtype="int64")]
     fields = ["overflow_int64"]
-    meta = dict(geometry_type="Point", crs="EPSG:4326", spatial_index=False)
+    meta = {"geometry_type": "Point", "crs": "EPSG:4326", "spatial_index": False}
 
     filename = tmp_path / f"test.{ext}"
     write(filename, geometry, field_data, fields, **meta)
@@ -912,17 +1001,17 @@ def test_read_data_types_numeric_with_null(test_gpkg_nulls):
             assert field.dtype == "float64"
 
 
-def test_read_unsupported_types(test_ogr_types_list):
-    fields = read(test_ogr_types_list)[3]
+def test_read_unsupported_types(list_field_values_file):
+    fields = read(list_field_values_file)[3]
     # list field gets skipped, only integer field is read
     assert len(fields) == 1
 
-    fields = read(test_ogr_types_list, columns=["int64"])[3]
+    fields = read(list_field_values_file, columns=["int64"])[3]
     assert len(fields) == 1
 
 
-def test_read_datetime_millisecond(test_datetime):
-    field = read(test_datetime)[3][0]
+def test_read_datetime_millisecond(datetime_file):
+    field = read(datetime_file)[3][0]
     assert field.dtype == "datetime64[ms]"
     assert field[0] == np.datetime64("2020-01-01 09:00:00.123")
     assert field[1] == np.datetime64("2020-01-01 10:00:00.000")
@@ -951,13 +1040,14 @@ def test_read_unsupported_ext_with_prefix(tmp_path):
     assert field_data[0] == "data1"
 
 
-def test_read_datetime_as_string(test_datetime_tz):
-    field = read(test_datetime_tz)[3][0]
+def test_read_datetime_as_string(datetime_tz_file):
+    field = read(datetime_tz_file)[3][0]
     assert field.dtype == "datetime64[ms]"
     # timezone is ignored in numpy layer
     assert field[0] == np.datetime64("2020-01-01 09:00:00.123")
     assert field[1] == np.datetime64("2020-01-01 10:00:00.000")
-    field = read(test_datetime_tz, datetime_as_string=True)[3][0]
+
+    field = read(datetime_tz_file, datetime_as_string=True)[3][0]
     assert field.dtype == "object"
     # GDAL doesn't return strings in ISO format (yet)
     assert field[0] == "2020/01/01 09:00:00.123-05"
@@ -973,7 +1063,7 @@ def test_read_write_null_geometry(tmp_path, ext):
     )
     field_data = [np.array([1, 2], dtype="int32")]
     fields = ["col"]
-    meta = dict(geometry_type="Point", crs="EPSG:4326")
+    meta = {"geometry_type": "Point", "crs": "EPSG:4326"}
     if ext == "gpkg":
         meta["spatial_index"] = False
 
@@ -993,12 +1083,12 @@ def test_write_float_nan_null(tmp_path, dtype):
     )
     field_data = [np.array([1.5, np.nan], dtype=dtype)]
     fields = ["col"]
-    meta = dict(geometry_type="Point", crs="EPSG:4326")
+    meta = {"geometry_type": "Point", "crs": "EPSG:4326"}
     filename = tmp_path / "test.geojson"
 
     # default nan_as_null=True
     write(filename, geometry, field_data, fields, **meta)
-    with open(filename, "r") as f:
+    with open(filename) as f:
         content = f.read()
     assert '{ "col": null }' in content
 
@@ -1010,7 +1100,7 @@ def test_write_float_nan_null(tmp_path, dtype):
         ctx = contextlib.nullcontext()
     with ctx:
         write(filename, geometry, field_data, fields, **meta, nan_as_null=False)
-    with open(filename, "r") as f:
+    with open(filename) as f:
         content = f.read()
     assert '"properties": { }' in content
 
@@ -1024,7 +1114,7 @@ def test_write_float_nan_null(tmp_path, dtype):
         nan_as_null=False,
         WRITE_NON_FINITE_VALUES="YES",
     )
-    with open(filename, "r") as f:
+    with open(filename) as f:
         content = f.read()
     assert '{ "col": NaN }' in content
 
@@ -1043,7 +1133,7 @@ def test_write_float_nan_null_arrow(tmp_path):
     )
     field_data = [np.array([1.5, np.nan], dtype="float64")]
     fields = ["col"]
-    meta = dict(geometry_type="Point", crs="EPSG:4326")
+    meta = {"geometry_type": "Point", "crs": "EPSG:4326"}
     fname = tmp_path / "test.arrow"
 
     # default nan_as_null=True
@@ -1146,6 +1236,27 @@ def test_write_memory_existing_unsupported(naturalearth_lowres):
         write(buffer, geometry, field_data, driver="GeoJSON", layer="test", **meta)
 
 
+def test_write_open_file_handle(tmp_path, naturalearth_lowres):
+    """Verify that writing to an open file handle is not currently supported"""
+
+    meta, _, geometry, field_data = read(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(f, geometry, field_data, driver="GeoJSON", layer="test", **meta)
+
+    # 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(f, geometry, field_data, driver="GeoJSON", layer="test", **meta)
+
+
 @pytest.mark.parametrize("ext", ["fgb", "gpkg", "geojson"])
 @pytest.mark.parametrize(
     "read_encoding,write_encoding",
@@ -1182,7 +1293,7 @@ def test_encoding_io(tmp_path, ext, read_encoding, write_encoding):
         np.array([mandarin], dtype=object),
     ]
     fields = [arabic, cree, mandarin]
-    meta = dict(geometry_type="Point", crs="EPSG:4326", encoding=write_encoding)
+    meta = {"geometry_type": "Point", "crs": "EPSG:4326", "encoding": write_encoding}
 
     filename = tmp_path / f"test.{ext}"
     write(filename, geometry, field_data, fields, **meta)
@@ -1232,7 +1343,7 @@ def test_encoding_io_shapefile(tmp_path, read_encoding, write_encoding):
     # character level)  by GDAL when output to shapefile, so we have to truncate
     # before writing
     fields = [arabic[:5], cree[:3], mandarin]
-    meta = dict(geometry_type="Point", crs="EPSG:4326", encoding="UTF-8")
+    meta = {"geometry_type": "Point", "crs": "EPSG:4326", "encoding": "UTF-8"}
 
     filename = tmp_path / "test.shp"
     # NOTE: GDAL automatically creates a cpg file with the encoding name, which
@@ -1277,7 +1388,7 @@ def test_non_utf8_encoding_io(tmp_path, ext, encoded_text):
     field_data = [np.array([text], dtype=object)]
 
     fields = [text]
-    meta = dict(geometry_type="Point", crs="EPSG:4326", encoding=encoding)
+    meta = {"geometry_type": "Point", "crs": "EPSG:4326", "encoding": encoding}
 
     filename = tmp_path / f"test.{ext}"
     write(filename, geometry, field_data, fields, **meta)
@@ -1307,7 +1418,7 @@ def test_non_utf8_encoding_io_shapefile(tmp_path, encoded_text):
     field_data = [np.array([text], dtype=object)]
 
     fields = [text]
-    meta = dict(geometry_type="Point", crs="EPSG:4326", encoding=encoding)
+    meta = {"geometry_type": "Point", "crs": "EPSG:4326", "encoding": encoding}
 
     filename = tmp_path / "test.shp"
     write(filename, geometry, field_data, fields, **meta)
@@ -1357,7 +1468,7 @@ def test_write_with_mask(tmp_path):
     field_data = [np.array([1, 2, 3], dtype="int32")]
     field_mask = [np.array([False, True, False])]
     fields = ["col"]
-    meta = dict(geometry_type="Point", crs="EPSG:4326")
+    meta = {"geometry_type": "Point", "crs": "EPSG:4326"}
 
     filename = tmp_path / "test.geojson"
     write(filename, geometry, field_data, fields, field_mask, **meta)

pyogrio/tests/test_util.py

@@ -0,0 +1,56 @@
+from pathlib import Path
+
+from pyogrio import vsi_listtree, vsi_unlink
+from pyogrio.raw import read, write
+from pyogrio.util import vsimem_rmtree_toplevel
+
+import pytest
+
+
+def test_vsimem_rmtree_toplevel(naturalearth_lowres):
+    # Prepare test data in /vsimem/
+    meta, _, geometry, field_data = read(naturalearth_lowres)
+    meta["spatial_index"] = False
+    meta["geometry_type"] = "MultiPolygon"
+    test_dir_path = Path(f"/vsimem/test/{naturalearth_lowres.stem}.gpkg")
+    test_dir2_path = Path(f"/vsimem/test2/test2/{naturalearth_lowres.stem}.gpkg")
+
+    write(test_dir_path, geometry, field_data, **meta)
+    write(test_dir2_path, geometry, field_data, **meta)
+
+    # Check if everything was created properly with listtree
+    files = vsi_listtree("/vsimem/")
+    assert test_dir_path.as_posix() in files
+    assert test_dir2_path.as_posix() in files
+
+    # Test deleting parent dir of file in single directory
+    vsimem_rmtree_toplevel(test_dir_path)
+    files = vsi_listtree("/vsimem/")
+    assert test_dir_path.parent.as_posix() not in files
+    assert test_dir2_path.as_posix() in files
+
+    # Test deleting top-level dir of file in a subdirectory
+    vsimem_rmtree_toplevel(test_dir2_path)
+    assert test_dir2_path.as_posix() not in vsi_listtree("/vsimem/")
+
+
+def test_vsimem_rmtree_toplevel_error(naturalearth_lowres):
+    # Prepare test data in /vsimem
+    meta, _, geometry, field_data = read(naturalearth_lowres)
+    meta["spatial_index"] = False
+    meta["geometry_type"] = "MultiPolygon"
+    test_file_path = Path(f"/vsimem/pyogrio_test_{naturalearth_lowres.stem}.gpkg")
+
+    write(test_file_path, geometry, field_data, **meta)
+    assert test_file_path.as_posix() in vsi_listtree("/vsimem/")
+
+    # Deleting parent dir of non-existent file should raise an error.
+    with pytest.raises(FileNotFoundError, match="Path does not exist"):
+        vsimem_rmtree_toplevel("/vsimem/test/non-existent.gpkg")
+
+    # File should still be there
+    assert test_file_path.as_posix() in vsi_listtree("/vsimem/")
+
+    # Cleanup.
+    vsi_unlink(test_file_path)
+    assert test_file_path not in vsi_listtree("/vsimem/")