API Documentation

Reader

class papotch.reader.Reader(uri: str | Path | bytes, layer: int | str | None = None, encoding: str | None = None, columns: str | Sequence[str] | None = None, where: str | None = None, max_features: int | None = None, bbox: tuple[float, float, float, float] | None = None, **kwargs)

Class extracting Data using the polars_st read_file() function.

Parameters:

• uri (str | Path | bytes) – Path to the data source

• layer (int | str | None = None) – Index or name of the layer to read

• encoding (str | None = None) – Data encoding

• columns (str | Sequence[str] | None = None) – Column(s) to read from the source

• where (str | None = None) – SQL condition to filter data

• max_features – Maximum number of features to read

• bbox (tuple[float, float, float, float] | None = None) – Bounding box spatially filtering read data

extract(active_geometry: str = 'geometry') → Data

Extract data using the polars_st read_file() function.

Parameters:

active_geometry (str) – Active geometry name of the returned Data. Default to “geometry”

property bbox: tuple[float, float, float, float] | None

property columns: str | Sequence[str] | None

property encoding: str | None

property layer: int | str | None

property max_features: int | None

property uri: str | Path | bytes

property where: str | None

Data

class papotch.data.Data(df: DataFrame, active_geometry: str = 'geometry')

The central class holding the data.

This is a thin wrapper around a polars DataFrame, passed from polars_st.

Parameters:

• df (polars.DataFrame) – The DataFrame to be processed.

• active_geometry (str) – The current geometry column used for the processing.

affine_transform(matrix: Sequence[float]) → Data

area(column_name: str = '_area') → None

attribute_join(other: DataFrame, left_on: str, right_on: str, how: str = 'inner') → Data

boundary() → Data

bounds(column_name: str = '_bounds') → None

buffer(distance: float) → Data

build_area() → Data

calculate_attribute(*exprs, **named_exprs) → Data

center() → Data

centroid() → Data

clip_by_rect(rect: tuple[float, float, float, float]) → Data

clone()

collect(into: Literal['Unknown', 'Point', 'LineString', 'Polygon', 'MultiPoint', 'MultiLineString', 'MultiPolygon', 'GeometryCollection', 'CircularString', 'CompoundCurve', 'CurvePolygon', 'MultiCurve', 'MultiSurface', 'Curve', 'Surface', 'PolyhedralSurface', 'Tin', 'Triangle'] | None = None) → Data

concave_hull() → Data

convex_hull() → Data

coordinate_dimension(column_name: str = '_coord_dim') → None

coordinates(column_name: str = '_coord') → None

count_coordinates(column_name: str = '_n_coord') → None

count_geometries(column_name: str = '_n_geom') → None

count_interior_rings(column_name: str = '_n_rings') → None

count_points(column_name: str = '_n_points') → None

coverage_union_all() → Data

delaunay_triangles(tolerance: float = 0.0, only_edges: bool = False) → Data

difference_all(grid_size: float | None = None) → Data

dimensions(column_name: str = '_dimensions') → None

distance(other: Data, column_name: str = '_distance') → None

drop_attribute(attributes: list[str] | str) → Data

envelope() → Data

explore()

exterior_ring(column_name: str = '_ext_ring') → Data

extract_unique_points() → Data

filter_attribute(*args, **kwargs) → Data

flip_xy() → Data

force_2d() → Data

force_3d(default_z: float) → Data

frechet_distance(other: Data, density: float, column_name: str = '_frechet') → Data

geometry_type(column_name: str = '_geom_type') → None

get_nth_geometry(column_name: str = '_nth_geom', index: int = 0) → Data

get_nth_interior_ring(column_name: str = '_nth_ring', index: int = 0) → Data

get_nth_point(column_name: str = '_nth_point', index: int = 0) → Data

group_by_attributes(columns: Sequence[str], geom_agg: Literal['coverage_union', 'union', 'difference', 'symmetric_difference', 'collect', 'intersection', 'total_bounds'] = 'coverage_union')

group_by_collect(columns: Sequence[str]) → Data

group_by_coverage_union() → Data

group_by_difference() → Data

group_by_intersection(columns: Sequence[str]) → Data

group_by_union() → Data

has_m(column_name: str = '_has_m') → Data

has_z(column_name: str = '_has_z') → Data

hausdorff_distance(other: Data, density: float, column_name: str = '_hausdorff') → None

head(n: int = 5) → None

Print the first lines of Data.

Parameters:

n (int) – The number of rows to print

interior_rings(column_name: str = '_int_rings') → None

interpolate(distance: float, normalize: bool) → Data

intersection_all(grid_size: float | None = None) → Data

is_ccw(column_name: str = '_is_ccw') → Data

is_closed(column_name: str = '_is_closed') → Data

is_empty(column_name: str = '_is_empty') → Data

is_ring(column_name: str = '_is_ring') → Data

is_simple(column_name: str = '_is_simple') → Data

is_valid(column_name: str = '_is_valid') → Data

is_valid_reason(column_name: str = '_is_val_r') → Data

length(column_name: str = '_length') → None

line_merge(directed: bool) → Data

m(column_name: str = '_m') → None

make_valid() → Data

minimum_clearance(column_name: str = '_min_clear') → None

minimum_rotated_rectangle() → Data

multi() → Data

node() → Data

normalize() → Data

offset_curve(distance: float, quad_segs: int = 8, join_style: Literal['round', 'mitre', 'bevel'] = 'round', mitre_limit: float = 5.0) → Data

plot(**kwargs)

point_on_surface() → Data

polygonize() → Data

precision(column_name: str = '_precision') → None

project(other: Data, normalize: bool) → Data

remove_repeated_points() → Data

rename_attribute(attribute: str, new_name: str) → Data

reverse() → Data

rotate(angle: float, origin: Literal['center', 'centroid'] | Sequence[float] = 'center') → Data

scale(x: float, y: float, z: float, origin: Literal['center', 'centroid'] | Sequence[float] = 'center') → Data

segmentize(max_length: float) → Data

set_precision(grid_size: float, mode: Literal['valid_output', 'no_topo', 'keep_collapsed'] = 'valid_output') → Data

set_srid(srid: int) → Data

shared_paths(other: Data) → Data

simplify(tolerance: float, preserve_topology: bool) → Data

skew(x: float, y: float, z: float, origin: Literal['center', 'centroid'] | Sequence[float] = 'center') → Data

snap(other: Data, tolerance: float) → Data

spatial_join(other: DataFrame, predicate: str, how: str = 'inner') → Data

srid(column_name: str = '_srid') → Data

substring(start: int, end: int) → Data

symmetric_difference_all(grid_size: float | None = None) → Data

tail(n: int = 5) → None

Print the last lines of Data.

Parameters:

n (int) – The number of rows to print

to_dict(column_name: str = '_dict') → Data

to_ewkt(column_name: str = '_ewkt') → Data

to_geojson(column_name: str = '_geojson') → Data

to_shapely(column_name: str = '_shapely') → Data

to_srid(srid: int) → Data

to_wkt(column_name: str = '_wkt') → Data

total_bounds() → Data

translate(x: float = 0.0, y: float = 0.0, z: float = 0.0) → Data

unary_union(grid_size: float) → Data

union(other: Data, grid_size: float | None = None) → Data

union_all(grid_size: float | None = None) → Data

voronoi_polygons(tolerance: float = 0.0, extend_to: bytes | None = None, only_edges: bool = False) → Data

write(path: str, layer: str, driver: str, **kwargs) → None

write_geojson(path: str, **kwargs) → None

write_gpkg(path: str, layer: str | None = '_layer', **kwargs) → None

write_postgis(uri: str, layer: str, **kwargs) → None

write_shapefile(path: str, **kwargs) → None

x(column_name: str = '_x') → None

y(column_name: str = '_y') → None

z(column_name: str = '_z') → None

property active_geometry: str

Return the name of the active geometry.

Returns:

The name of the active geometry

Return type:

str

property df: DataFrame

Return the underlying DataFrame.

Returns:

The polars DataFrame hosting the data

Return type:

polars.DataFrame

property extent: Data

Return the extent of the DataFrame.

Returns:

A Data with a single rectangle geometry

Return type:

Data

property schema: dict

Return the schema of the Data instance.

Returns:

The dictionnary of the field names and types

Return type:

dict

property shape: tuple[int, int]

Return the shape of the Data instance.

Returns:

The number of lines and columns of the Data

Return type:

tuple[int, int]