vibespatial.io.geoparquet¶

Classes¶

`LegacyWKBGeoParquetTranscodeResult`	Bounded evidence from a metadata-only device-native transcode.
`NativePartitionedParquetSegment`	One partition-homogeneous row group in a clustered spill.
`NativePartitionedParquetLayout`	Host-sized routing metadata for one device-clustered Parquet spill.
`NativePartitionedParquetSink`	Persistent device writer for partition-clustered Parquet row groups.
`GeoParquetScanPlan`
`GeoParquetChunkPlan`
`GeoParquetEnginePlan`
`GeoParquetReadBackendPlan`
`GeoParquetEngineBenchmark`

Functions¶

`load_native_partitioned_parquet_layout`(...)	Load a clustered-spill routing manifest without scanning table rows.
`read_native_partitioned_parquet_partitions`(path, ...)	Read only row groups belonging to selected logical partitions.
`plan_geoparquet_read_backend`(→ GeoParquetReadBackendPlan)
`plan_geoparquet_scan`(→ GeoParquetScanPlan)
`plan_geoparquet_engine`(→ GeoParquetEnginePlan)
`read_geoparquet_native`(...)	Read a GeoParquet file into the shared native tabular result boundary.
`read_geoparquet_owned`(...)
`transcode_legacy_wkb_parquet_to_geoparquet`(...)	Rewrite legacy binary-WKB Parquet as WKB GeoParquet on the GPU.
`write_geoparquet`(→ None)
`read_geoparquet`(path, *[, columns, storage_options, ...])	Read a GeoParquet file into a GeoDataFrame.
`read_geoparquet_batches`(path, *, batch_rows[, ...])	Yield public GeoDataFrames from one budgeted GeoParquet dataset scan.
`benchmark_geoparquet_scan_engine`(...)

Module Contents¶

class vibespatial.io.geoparquet.LegacyWKBGeoParquetTranscodeResult¶

Bounded evidence from a metadata-only device-native transcode.

row_count: int¶

column_count: int¶

geometry_columns: tuple[str, Ellipsis]¶

primary_geometry: str¶

source_bytes: int¶

output_bytes: int¶

backend: str = 'pylibcudf'¶

schema_validated: bool = True¶

values_validated: bool = True¶

atomic_publication: bool = True¶

class vibespatial.io.geoparquet.NativePartitionedParquetSegment¶

One partition-homogeneous row group in a clustered spill.

partition: int¶

row_group: int¶

batch: int¶

row_count: int¶

class vibespatial.io.geoparquet.NativePartitionedParquetLayout¶

Host-sized routing metadata for one device-clustered Parquet spill.

path: pathlib.Path¶

manifest_path: pathlib.Path¶

partition_column: str¶

partition_count: int¶

row_count: int¶

segments: tuple[NativePartitionedParquetSegment, Ellipsis]¶

row_groups_for(partitions: set[int] | tuple[int, Ellipsis] | list[int])¶

class vibespatial.io.geoparquet.NativePartitionedParquetSink(path, *, arrow_schema=None, partition_column: str, partition_count: int, compression: str | None = 'snappy', max_row_group_rows: int = 1000000, max_input_chunk_rows: int = 32000000)¶

Persistent device writer for partition-clustered Parquet row groups.

This is an internal dynamic-output carrier. Each appended pylibcudf table is clustered by a device partition map, and each bounded homogeneous slice becomes one row group in one persistent output file. A small JSON manifest maps logical partitions to row groups for exact projection/pushdown reads.

path¶

manifest_path¶

arrow_schema = None¶

partition_column = ''¶

partition_count¶

compression = 'snappy'¶

max_row_group_rows = 1000000¶

max_input_chunk_rows = 32000000¶

append(table, *, partition_map=None, arrow_schema=None) → None¶: Cluster and append one device table without materializing its rows.

close() → NativePartitionedParquetLayout¶: Close the persistent writer and publish the routing manifest.

vibespatial.io.geoparquet.load_native_partitioned_parquet_layout(path) → NativePartitionedParquetLayout¶: Load a clustered-spill routing manifest without scanning table rows.

vibespatial.io.geoparquet.read_native_partitioned_parquet_partitions(path, partitions, *, columns=None)¶: Read only row groups belonging to selected logical partitions.

class vibespatial.io.geoparquet.GeoParquetScanPlan¶

selected_path: vibespatial.io.support.IOPathKind¶

canonical_gpu: bool¶

uses_pylibcudf: bool¶

bbox_requested: bool¶

metadata_summary_available: bool¶

metadata_source: str | None¶

uses_covering_bbox: bool¶

uses_point_encoding_pushdown: bool¶

row_group_pushdown: bool¶

planner_strategy: str¶

available_row_groups: int | None¶

selected_row_groups: tuple[int, Ellipsis] | None¶

decoded_row_fraction_estimate: float | None¶

pruned_row_group_fraction: float | None¶

reason: str¶

class vibespatial.io.geoparquet.GeoParquetChunkPlan¶

chunk_index: int¶

row_groups: tuple[int, Ellipsis] | None¶

estimated_rows: int¶

estimated_uncompressed_bytes: int = 0¶

class vibespatial.io.geoparquet.GeoParquetEnginePlan¶

selected_path: vibespatial.io.support.IOPathKind¶

backend: str¶

geometry_encoding: str | None¶

chunk_count: int¶

target_chunk_rows: int | None¶

uses_row_group_pruning: bool¶

reason: str¶

class vibespatial.io.geoparquet.GeoParquetReadBackendPlan¶

requested_backend: str¶

selected_backend: str¶

selected_mode: vibespatial.runtime.ExecutionMode¶

can_use_pylibcudf: bool¶

gpu_rejection_reason: str | None¶

reason: str¶

explicit_host_compatibility: bool = False¶

class vibespatial.io.geoparquet.GeoParquetEngineBenchmark¶

backend: str¶

geometry_encoding: str¶

rows: int¶

chunk_rows: int | None¶

chunk_count: int¶

elapsed_seconds: float¶

rows_per_second: float¶

planning_elapsed_seconds: float = 0.0¶

scan_elapsed_seconds: float = 0.0¶

decode_elapsed_seconds: float = 0.0¶

concat_elapsed_seconds: float = 0.0¶

vibespatial.io.geoparquet.plan_geoparquet_read_backend(path, *, backend: str, bbox, columns, storage_options, filesystem, filters, to_pandas_kwargs, geo_metadata, available_columns=None) → GeoParquetReadBackendPlan¶

vibespatial.io.geoparquet.plan_geoparquet_scan(*, bbox: tuple[float, float, float, float] | None = None, geo_metadata: dict[str, Any] | None = None, metadata_summary: vibespatial.io.geoparquet_planner.GeoParquetMetadataSummary | None = None, planner_strategy: str = 'auto') → GeoParquetScanPlan¶

vibespatial.io.geoparquet.plan_geoparquet_engine(*, geo_metadata: dict[str, Any] | None, scan_plan: GeoParquetScanPlan, chunk_plans: tuple[GeoParquetChunkPlan, Ellipsis], target_chunk_rows: int | None, read_plan: GeoParquetReadBackendPlan) → GeoParquetEnginePlan¶

vibespatial.io.geoparquet.read_geoparquet_native(path, *, columns=None, storage_options=None, bbox=None, chunk_rows: int | None = None, backend: str = 'auto', to_pandas_kwargs=None, **kwargs) → vibespatial.api._native_results.NativeTabularResult¶: Read a GeoParquet file into the shared native tabular result boundary.

vibespatial.io.geoparquet.read_geoparquet_owned(path, *, columns=None, storage_options=None, bbox=None, chunk_rows: int | None = None, backend: str = 'auto', **kwargs) → vibespatial.geometry.owned.OwnedGeometryArray¶

vibespatial.io.geoparquet.transcode_legacy_wkb_parquet_to_geoparquet(source, destination, *, geometry_columns: dict[str, dict[str, Any]], primary_geometry: str, compression: str | None = 'snappy', schema_version: str = '1.1.0', row_group_size: int | None = None) → LegacyWKBGeoParquetTranscodeResult¶

Rewrite legacy binary-WKB Parquet as WKB GeoParquet on the GPU.

Geometry payloads and attributes remain in pylibcudf columns. PyArrow is used only for source schema/footer metadata and the serialized Arrow schema stored in the destination footer; no geometry is decoded or materialized.

vibespatial.io.geoparquet.write_geoparquet(df, path, *, index: bool | None = None, compression: str | None = 'snappy', geometry_encoding: str = 'WKB', schema_version: str | None = None, write_covering_bbox: bool = False, **kwargs) → None¶

vibespatial.io.geoparquet.read_geoparquet(path, *, columns=None, storage_options=None, bbox=None, to_pandas_kwargs=None, **kwargs)¶

Read a GeoParquet file into a GeoDataFrame.

When PyArrow is available the reader plans row-group selection from spatial metadata, keeps the table columnar through scan/decode, and only materializes a GeoDataFrame at the terminal public read boundary.

Aliased as vibespatial.read_parquet().

Parameters¶

pathstr or Path: Path to the GeoParquet file.
columnslist of str, optional: Subset of columns to read.
storage_optionsdict, optional: Storage options for fsspec-compatible filesystems.
bboxtuple of (minx, miny, maxx, maxy), optional: Spatial filter bounding box for row-group pruning.
to_pandas_kwargsdict, optional: Extra keyword arguments passed to pyarrow.Table.to_pandas().
**kwargs: Passed through to the underlying Parquet reader.

Returns¶

GeoDataFrame

vibespatial.io.geoparquet.read_geoparquet_batches(path, *, batch_rows: int, columns=None, storage_options=None, bbox=None, to_pandas_kwargs=None, **kwargs)¶

Yield public GeoDataFrames from one budgeted GeoParquet dataset scan.

Batches follow whole Parquet row groups and may therefore exceed batch_rows by one row group. Projection, filtering, geometry decode, and attributes use the same backend as read_geoparquet(); only the bounded public consumption shape differs.

vibespatial.io.geoparquet.benchmark_geoparquet_scan_engine(*, geometry_type: str = 'point', rows: int = 100000, geometry_encoding: str = 'geoarrow', chunk_rows: int | None = None, compression: str | None = None, backend: str = 'cpu', repeat: int = 5, seed: int = 0) → GeoParquetEngineBenchmark¶