pax_global_header 0000666 0000000 0000000 00000000064 15256506516 0014525 g ustar 00root root 0000000 0000000 52 comment=199fc53c8a1b87fe4f11d7a8f69f0d1408d9ef71
geopandas-1.2.0/ 0000775 0000000 0000000 00000000000 15256506516 0013466 5 ustar 00root root 0000000 0000000 geopandas-1.2.0/.coveragerc 0000664 0000000 0000000 00000000507 15256506516 0015611 0 ustar 00root root 0000000 0000000 [report]
exclude_lines =
pragma: no cover
if TYPE_CHECKING:
def __repr__
raise AssertionError
raise NotImplementedError
if __name__ == .__main__.:
omit =
geopandas/tests/*
geopandas/io/tests/*
geopandas/tools/tests/*
geopandas/_version.py
geopandas/datasets/naturalearth_creation.py
geopandas-1.2.0/.git-blame-ignore-revs 0000664 0000000 0000000 00000000471 15256506516 0017570 0 ustar 00root root 0000000 0000000 # black-ification of code
479b6e706293ff1a484e4e121682f3a105a53aa9
7bc3166cfecdd120b544701cff5e37b4482cbbb5
f4b749d148f0eb13e7e92fbbf7e2eae79de2543a
373ac8bf731db1002e09859587c475a5f56c4e8b
50c59d395bc539eb411f9a5c6cdf04d37510060a
5dc982edbfc2633cd2c7a22ebd314d1b9b810a9a
44dba4fde90e8010ea6c71c6cf51b34413440177
geopandas-1.2.0/.gitattributes 0000664 0000000 0000000 00000000171 15256506516 0016360 0 ustar 00root root 0000000 0000000 geopandas/_version.py export-subst
# GitHub syntax highlighting
pixi.lock linguist-language=YAML linguist-generated=true
geopandas-1.2.0/.github/ 0000775 0000000 0000000 00000000000 15256506516 0015026 5 ustar 00root root 0000000 0000000 geopandas-1.2.0/.github/ISSUE_TEMPLATE/ 0000775 0000000 0000000 00000000000 15256506516 0017211 5 ustar 00root root 0000000 0000000 geopandas-1.2.0/.github/ISSUE_TEMPLATE/bug_report.md 0000664 0000000 0000000 00000001645 15256506516 0021711 0 ustar 00root root 0000000 0000000 ---
name: Bug Report
about: Create a bug report to help us improve geopandas
title: "BUG:"
labels: "bug, needs triage"
---
- [ ] I have checked that this issue has not already been reported.
- [ ] I have confirmed this bug exists on the latest version of geopandas.
- [ ] (optional) I have confirmed this bug exists on the main branch of geopandas.
---
**Note**: Please read [this guide](https://matthewrocklin.com/minimal-bug-reports) detailing how to provide the necessary information for us to reproduce your bug.
#### Code Sample, a copy-pastable example
```python
# Your code here
```
#### Problem description
[this should explain **why** the current behaviour is a problem and why the expected output is a better solution]
#### Expected Output
#### Output of ``geopandas.show_versions()``
[paste the output of ``geopandas.show_versions()`` here leaving a blank line after the details tag]
geopandas-1.2.0/.github/ISSUE_TEMPLATE/config.yml 0000664 0000000 0000000 00000000324 15256506516 0021200 0 ustar 00root root 0000000 0000000 blank_issues_enabled: true
contact_links:
- name: GeoPandas Discussions
url: https://github.com/geopandas/geopandas/discussions
about: Ask a general question about GeoPandas (e.g., usage, installation)
geopandas-1.2.0/.github/ISSUE_TEMPLATE/feature_request.md 0000664 0000000 0000000 00000001635 15256506516 0022743 0 ustar 00root root 0000000 0000000 ---
name: Feature Request
about: Suggest an idea for geopandas
title: "ENH:"
labels: "enhancement"
---
#### Is your feature request related to a problem?
[this should provide a description of what the problem is, e.g. "I wish I could use geopandas to do [...]"]
#### Describe the solution you'd like
[this should provide a description of the feature request, e.g. "`GeoDataFrame.foo` should get a new parameter `bar` that [...]", try to write a docstring for the desired feature]
#### API breaking implications
[this should provide a description of how this feature will affect the API]
#### Describe alternatives you've considered
[this should provide a description of any alternative solutions or features you've considered]
#### Additional context
[add any other context, code examples, or references to existing implementations about the feature request here]
```python
# Your code here, if applicable
```
geopandas-1.2.0/.github/dependabot.yml 0000664 0000000 0000000 00000000332 15256506516 0017654 0 ustar 00root root 0000000 0000000 version: 2
updates:
# Maintain dependencies for GitHub Actions
- package-ecosystem: "github-actions"
directory: "/"
schedule:
# Check for updates to GitHub Actions every week
interval: "weekly"
geopandas-1.2.0/.github/workflows/ 0000775 0000000 0000000 00000000000 15256506516 0017063 5 ustar 00root root 0000000 0000000 geopandas-1.2.0/.github/workflows/release.yml 0000664 0000000 0000000 00000002151 15256506516 0021225 0 ustar 00root root 0000000 0000000 name: Publish geopandas to PyPI / GitHub
on:
push:
tags:
- "v*"
jobs:
build-n-publish:
name: Build and publish geopandas to PyPI
runs-on: ubuntu-latest
environment:
name: pypi
url: https://pypi.org/p/geopandas
permissions:
contents: write # this permission is required for the Github release action
id-token: write # IMPORTANT: this permission is mandatory for trusted publishing
steps:
- name: Checkout source
uses: actions/checkout@v7
- name: Set up Python
uses: actions/setup-python@v7
with:
python-version: "3.x"
- name: Build source and wheel distributions
run: |
python -m pip install --upgrade build twine
python -m build
twine check --strict dist/*
- name: Publish distribution to PyPI
uses: pypa/gh-action-pypi-publish@release/v1
- name: Create GitHub Release
uses: softprops/action-gh-release@v3
with:
tag_name: ${{ github.ref_name }}
draft: true
prerelease: false
files: dist/*.tar.gz
geopandas-1.2.0/.github/workflows/tests.yaml 0000664 0000000 0000000 00000006726 15256506516 0021124 0 ustar 00root root 0000000 0000000 name: Tests
on:
push:
branches: [main, 0.**]
pull_request:
branches: [main, 0.**]
schedule:
- cron: "0 0 * * *"
concurrency:
group: ${{ github.workflow }}-${{ github.ref }}
cancel-in-progress: true
jobs:
Test:
name: ${{ matrix.os }}, ${{ matrix.env }}
runs-on: ${{ matrix.os }}
defaults:
run:
shell: bash -l {0}
# skip scheduled runs on forks
if: (github.event_name == 'schedule' && github.repository == 'geopandas/geopandas') || (github.event_name != 'schedule')
strategy:
fail-fast: false
matrix:
os: [ubuntu-latest]
postgis: [false]
dev: [false]
doctest: [false]
env:
- ci/envs/311-latest.yaml
- ci/envs/311-minimal.yaml
# - ci/envs/311-pd23.yaml -> in postgis env below
# - ci/envs/312-latest.yaml -> in postgis env below
- ci/envs/313-latest-no-pyogrio.yaml
- ci/envs/313-latest-no-pyproj.yaml
# - ci/envs/313-latest.yaml -> in doctest env below
- ci/envs/313-no-optional-deps.yaml
- ci/envs/314-latest.yaml
# - ci/envs/313-dev.yaml -> in dev env below
include:
# PostGIS envs
- env: ci/envs/311-pd23.yaml
postgis: true
os: ubuntu-latest
- env: ci/envs/312-latest.yaml
postgis: true
os: ubuntu-latest
# doctest env
- env: ci/envs/313-latest.yaml
doctest: true
os: ubuntu-latest
# MacOS & Windows envs
- env: ci/envs/313-latest-no-pyogrio.yaml
os: macos-latest
- env: ci/envs/313-latest.yaml
os: macos-latest
- env: ci/envs/313-latest-no-pyogrio.yaml
os: windows-latest
- env: ci/envs/313-latest.yaml
os: windows-latest
# Dev env
- env: ci/envs/313-dev.yaml
os: ubuntu-latest
dev: true
steps:
- uses: actions/checkout@v7
- name: Install Conda environment with Micromamba
uses: mamba-org/setup-micromamba@v3
with:
environment-file: ${{ matrix.env }}
- name: Install package
# install without deps to avoid installing default but optional pyproj/pyogrio
run: pip install -e . --no-deps
- name: Check and Log Environment
run: |
python -V
python -c "import geopandas; geopandas.show_versions();"
micromamba info
micromamba list
- name: Test
env:
PYTHONWARNINGS: ${{ matrix.dev && 'error' || 'default' }}
run: |
pytest -v -r a -n auto --color=yes --cov=geopandas --cov-append --cov-report term-missing --cov-report xml geopandas/
- name: Test with PostGIS
if: ${{ matrix.postgis }}
env:
PGUSER: postgres
PGPASSWORD: postgres
PGHOST: "127.0.0.1"
PGPORT: 5432
run: |
conda install postgis -c conda-forge
sh ci/scripts/setup_postgres.sh
set -o pipefail
pytest -v -r a --color=yes --cov=geopandas --cov-append --cov-report term-missing --cov-report xml geopandas/io/tests/test_sql.py | tee /dev/stderr | if grep SKIPPED >/dev/null;then echo "TESTS SKIPPED, FAILING" && exit 1;fi
- name: Test docstrings
if: ${{ matrix.doctest }}
run: |
pytest -v --color=yes --doctest-only geopandas --ignore=geopandas/datasets
- uses: codecov/codecov-action@v7
geopandas-1.2.0/.gitignore 0000664 0000000 0000000 00000001722 15256506516 0015460 0 ustar 00root root 0000000 0000000 # Autogenerated
geopandas/_version.py
# Byte-compiled / optimized / DLL files
__pycache__/
*.py[cod]
*$py.class
# C extensions
*.so
# Distribution / packaging
.Python
env/
venv*/
build/
dist/
eggs/
.eggs/
lib/
lib64/
parts/
sdist/
var/
wheels/
*.egg-info/
.installed.cfg
*.egg
# Unit test / coverage reports
htmlcov/
.tox/
.coverage
.coverage.*
.cache
nosetests.xml
coverage.xml
*.cover
.hypothesis/
result_images
# Sphinx documentation
doc/_build/
.buildinfo
# Jupyter Notebook
.ipynb_checkpoints
# pytest
.pytest_cache
.mypy_cache
# projects
.spyderproject
.spyproject
.idea
.ropeproject
.vscode
*.py~
.DS_Store
examples/nybb_*.zip
doc/source/savefig
doc/source/reference
doc/source/docs/reference/api/*.rst
geopandas.egg-info
geopandas/version.py
geopandas/datasets/ne_110m_admin_0_countries.zip
.asv
doc/source/getting_started/my_file.geojson
.ruff_cache
.env
doc/test_fiona.gpkg
doc/test_pyogrio.gpkg
# pixi environments
.pixi
*.egg-info
pixi.toml
pixi.lock
geopandas-1.2.0/.pre-commit-config.yaml 0000664 0000000 0000000 00000000516 15256506516 0017751 0 ustar 00root root 0000000 0000000 ci:
autofix_prs: false
autoupdate_schedule: quarterly
files: 'geopandas\/'
repos:
- repo: https://github.com/astral-sh/ruff-pre-commit
rev: "v0.15.20"
hooks:
- id: ruff-format
- id: ruff-check
name: sort imports with ruff
args: [--select, I, --fix]
- id: ruff-check geopandas-1.2.0/CHANGELOG.md 0000664 0000000 0000000 00000216203 15256506516 0015303 0 ustar 00root root 0000000 0000000 # Changelog
## Version 1.2.0 (September 28, 2026)
New features and improvements:
- Static plotting in GeoPandas has been re-implemented. The new tooling shall be mostly
backwards compatible while bringing a set of enhancements:
- Categorical plotting now allows dict-based mapping of categories to colors and
other styles.
- Legends now reflect the geometry type and complete set of styles, not just a
color.
- Plotting of continuous variables with a classification scheme can now produce
a colorbar instead of a categorical legend when using `colorbar=True` within
`legend_kwds`.
- `vmin` and `vmax` keywords are supported when `scheme` is defined, not ignored.
- When using categorical colormap with categorical plots, colors are now assigned
in order to optimize the contrast of the resulting map.
- Colorbar size is automatically adjusted to be approximately the size of the plot.
- Colorbar now indicates extensions if the `vmin` and/or `vmax` clip the values.
- Legends are created automatically by matplotlib. This also means that you can
create a single legend from a layered map by calling `ax.legend()` directly.
- GeoPandas now labels axes using the information on units from CRS. This can be
controlled via the `add_labels` keyword.
- Static plots can include a basemap defined by the `tiles` keyword, exposing
`contextily.add_basemap` from within the `plot` method. Requires `contextily`
package to be installed.
- `scheme` keyword can take a value `"greedy"` resulting in a greedy (topological)
coloring where no two adjacent polygons share a color. Requires `mapclassify` and
`libpysal` packages.
The related refactoring of the plotting infrastructure has changed the internal
representation of the figure generated by GeoPandas. This can be considered a breaking
change if you rely the composition of collections, as that has changed. A number of
plotting-related bugs has been fixed along as a side effect. All changes are reflected
in an updated user guide.
(#3708, #3728, #3748, #3752, #3753, #3763, #3767, #3689).
- GeoParquet improvements:
- The upcoming GeoParquet 2.0 specification is now supported for both writing
and reading (#3632).
- `read_parquet` now support direct reading from HTTP/HTTPS protocols (#3699).
- `GeoDataFrame.to_parquet` and `read_parquet` will now write and read ``attrs``
respectively (#3597).
- Added `geopandas.make_grid` and `GeoSeries.make_grid` to generate a square
or hexagonal grids covering the input geometry (#2062).
- Added `geopandas.read_file_info` to expose information about file layers, including layer
metadata (this is an alias for `pyogrio.read_info`) (#3759).
- Add ``grid_size`` parameter to ``union``, ``difference``, ``symmetric_difference``
and ``intersection`` (#3593).
- Document how to access the feature ID (`fid`) as the index when reading files
with `read_file` and the pyogrio engine, using `fid_as_index=True` (#3829).
Deprecations and compatibility notes:
- The `resolution` keyword to `buffer` has been deprecated to align with the convention in shapely,
`quad_segs` should be used instead (#3600).
- Expired deprecations: option `use_pygeos` which had no functionality,
`seed` keyword in sample_points (replaced by `rng`) (#3613).
Bug fixes:
- Fix `GeoSeries.sample_points` looping without end on zero-area polygons, such as a
collapsed ring; it now returns an empty `MultiPoint`, as it already did for empty
and missing geometries (#3851).
- Fix ``read_parquet`` ignoring the ``partitioning`` keyword when auto-detecting
the columns to read, so that ``partitioning=None`` no longer raises (#3459).
- Fix ``GeoDataFrame.explode()`` raising a cryptic error when passing multiple
(non-geometry) columns; it now falls back to the pandas multi-column explode (#2753).
- Fix `GeoDataFrame.from_features` raising a `ValueError` for an empty list of
features when a `crs` is provided; it now returns an empty `GeoDataFrame` with
a `geometry` column (#3777).
- Fix the index level of the parts created by `explode(index_parts=True)` and
`get_coordinates(index_parts=True)` being `int32` instead of `int64` on 32-bit
platforms (#3865).
- Various compatibility fixes for pandas 3.1 (#3802, #3831).
Community:
- GeoPandas now uses the NumFOCUS Code of Conduct.
- GeoPandas has a new software paper which can be used as canonical citation, see https://geopandas.org/en/latest/about/citing.html
Notes on dependencies:
- GeoPandas 1.2 now requires Python 3.11 or greater and pandas 2.2, numpy 2.0, pyproj 3.7, and
shapely 2.1, are now the minimum required version for these dependencies.
Furthermore, the minimum tested version for optional dependencies has been updated to
fiona 1.8.21, scipy 1.9, matplotlib 3.9, mapclassify 2.7 folium 0.15, pyarrow 15.0 and
SQLAlchemy 2.0. Older versions of these libraries may continue to work, but are no longer
considered supported (#3371, #3581).
## Version 1.1.4 (June 26, 2026)
Bug fixes:
- Further hardening of ``to_postgis`` against SQL injection (#3800).
- Ensure that points generated by ``sample_points`` are not sorted along x-axis (#3773).
- Fix ``GeoDataFrame.explore()`` ignoring custom ``legend_kwds={"labels": ...}``
for categorical and boolean columns (#3496).
- More graceful handling of ``keep_geom_type`` in the ``overlay()`` function with
empty input (#3745).
## Version 1.1.3 (March 10, 2026)
This release addresses a handful of small compatibility issues with pandas 3.0 and backports some bugfixes.
Bug fixes:
- Improved compatibility with pandas 3.0 Copy-on-Write feature, making use of deferred copies where possible (#3298, #3711).
- Fix `GeoSeries.sample_points` not accepting list-like `size` when generating points using
`pointpaterns` (#3710).
- Fix `from_wkt/wkb` to correctly handle missing values with pandas 3 (where the new `str` dtype is used) (#3714).
- Fix `to_postgis` to correctly handle missing values with pandas 3 (where the new `str` dtype is used) (#3722).
- Using `loc` to assign column values to a new row index now correctly preserves the column CRS and geometry dtype
on pandas 3.1, due to an upstream bug fix (#3741, Pandas #62523)
- Random states in `pointpats` methods of `sample_points`` can now be fixed with `rng` (#3737).
## Version 1.1.2 (December 22, 2025)
Bug fixes:
- Fix an issue that caused an error in `GeoDataFrame.from_features` when there is no `properties` field (#3599).
- Fix `read_file` and `to_file` errors (#3682)
- Fix `read_parquet` with `to_pandas_kwargs` for complex (list/struct) arrow types (#3640)
- `value_counts` on GeoSeries now preserves CRS in index (#3669)
- Fix f-string placeholders appearing in error messages when `pyogrio` cannot be imported (#3682).
- Fix `read_parquet` with `to_pandas_kwargs` for complex (list/struct) arrow types (#3640).
- `.to_json` now provides a clearer error message when called on a GeoDataFrame without an active geometry
column (#3648).
- Calling `del gdf["geometry"]` now will downcast to a `pd.DataFrame` if there are no geometry columns left
in the dataframe (#3648).
- Fix SQL injection in `to_postgis` via geometry column name (#3681).
## Version 1.1.1 (June 27, 2025)
Bug fixes:
- Fix regression in the GeoDataFrame constructor when np.nan is given as an only geometry (#3591).
- Fix regression in `overlay` with `how="identity"` when input dataframes have column
names that are equal (#3596).
## Version 1.1.0 (June 1, 2025)
Notes on dependencies:
- GeoPandas 1.1 now requires Python 3.10 or greater and pandas 2.0, numpy 1.24, pyproj 3.5,
are now the minimum required version for these dependencies.
Furthermore, the minimum tested version for optional dependencies has been updated to
fiona 1.8.21, scipy 1.9, matplotlib 3.7, mapclassify 2.5, folium 0.12 and
SQLAlchemy 2.0. Older versions of these libraries may continue to work, but are no longer
considered supported (#3371).
New features and improvements:
- Added options to return the result of `SpatialIndex.query` in a form of a dense or a
sparse boolean array. This adds optional dependency on `scipy` for the sparse output.
Note that this also changes the previously undocumented behaviour of the `output_format`
keyword (#1674).
- Add ``grid_size`` parameter to ``union_all`` and ``dissolve`` (#3445).
- `GeoDataFrame.plot` now supports `pd.Index` as an input for the `column` keyword (#3463).
- Added `disjoint_subset` union algorithm for `union_all` and `dissolve` (#3534).
- Added `constrained_delaunay_triangles` method to GeoSeries/GeoDataFrame (#3552).
- Added `to_pandas_kwargs` argument to `from_arrow`, `read_parquet` and `read_feather`
to allow better control of conversion of non-geometric Arrow data to DataFrames (#3466).
- Added `is_valid_coverage` and `invalid_coverage_edges` to GeoSeries/GeoDataFrame to
allow validation of polygonal coverage (#3545).
- Added `maximum_inscribed_circle` method from shapely to GeoSeries/GeoDataFrame (#3544).
- Added `minimum_clearance_line` method from shapely to GeoSeries/GeoDataFrame (#3543).
- Added `orient_polygons` method from shapely to GeoSeries/GeoDataFrame (#3559).
- Added ``method`` and ``keep_collapsed`` argument to ``make_valid`` (#3548).
- Added `simplify_coverage` method for topological simplification of polygonal coverages
to GeoSeries/GeoDataFrame (#3541).
- Added initial support of M coordinates (`m` and `has_m` properties, `include_m` in `get_coordinates`) (#3561).
- Added `geom_equals_identical` method exposing `equals_identical` from shapely to GeoSeries/GeoDataFrame (#3560).
- GeoPandas now attempts to use a range request when reading from an URL even if the header
does not directly indicate its support (#3572).
- Added `geopandas.accessors` module. Import this module to register a
`pandas.Series.geo` accessor, which exposes GeoSeries methods via pandas's
extension mechanism (#3272).
- Improve performance of `overlay` with `how=identity` (#3504).
- A warning message is raised in `read_file` when a GeoDataFrame or GeoSeries mask
and/or the source dataset is missing a defined CRS (#3464).
- GeoDataFrame no longer hard-codes the class internally, allowing easier subclassing (#3505).
Bug fixes:
- Fix an issue that showed numpy dtypes in bbox in `to_geo_dict` and `__geo_interface__`. (#3436).
- Fix an issue in `sample_points` that could occasionally result in non-uniform distribution (#3470).
- Fix unspecified layer warning being emitted while reading multilayer datasets, even
when layer is specified when using the mask or bbox keywords (#3378).
- Properly support named aggregations over a geometry column in `GroupBy.agg` (#3368).
- Support GeoDataFrame constructor receiving arguments to `geometry` which are not
(Geo)Series, but instead should be interpreted as column names, like Enums (#3384).
- Fix regression where constructing a GeoSeries from a pd.Series with GeometryDtype values
failed when `crs` was provided (#3383).
- Fix regression where `overlay` with `keep_geom_type` returns wrong results if the
input contains invalid geometries (#3395).
- Fix the dtype of the GeometryArray backing data being incorrect for zero length
GeoDataFrames causing errors in `overlay` (#3424).
- Fix regression where constructing a GeoSeries from a pd.Series with GeometryDtype values
failed when `crs` was provided (#3383).
- Fix plotting of polygons with holes by normalizing the coordinate order prior to plotting (#3483).
- Fix an issue in plotting when polygon patches were not closed (#3576).
- Fix ambiguous error when GeoDataFrame is initialised with a column called "crs" (#3502).
- Avoid change of the plot aspect when plotting missing values (#3438).
Deprecations and compatibility notes:
- The `GeoSeries.select` method wrapping the pandas `Series.select` method has been removed.
The upstream method no longer exists in all supported version of pandas (#3394).
- The deprecated `geom_almost_equals` method has been removed. Use
`geom_equals_exact` instead (#3522).
## Version 1.0.1 (July 2, 2024)
Bug fixes:
- Support a named datetime or object dtype index in `explore()` (#3360, #3364).
- Fix a regression preventing a Series as an argument for geometric methods (#3363).
## Version 1.0.0 (June 24, 2024)
Notes on dependencies:
- GeoPandas 1.0 drops support for shapely<2 and PyGEOS. The only geometry engine that is
currently supported is shapely >= 2. As a consequence, spatial indexing based on the
rtree package has also been removed (#3035).
- The I/O engine now defaults to Pyogrio which is now installed with GeoPandas instead
of Fiona (#3223).
New methods:
- Added `count_geometries` method from shapely to GeoSeries/GeoDataFrame (#3154).
- Added `count_interior_rings` method from shapely to GeoSeries/GeoDataFrame (#3154).
- Added `relate_pattern` method from shapely to GeoSeries/GeoDataFrame (#3211).
- Added `intersection_all` method from shapely to GeoSeries/GeoDataFrame (#3228).
- Added `line_merge` method from shapely to GeoSeries/GeoDataFrame (#3214).
- Added `set_precision` and `get_precision` methods from shapely to GeoSeries/GeoDataFrame (#3175).
- Added `count_coordinates` method from shapely to GeoSeries/GeoDataFrame (#3026).
- Added `minimum_clearance` method from shapely to GeoSeries/GeoDataFrame (#2989).
- Added `shared_paths` method from shapely to GeoSeries/GeoDataFrame (#3215).
- Added `is_ccw` method from shapely to GeoSeries/GeoDataFrame (#3027).
- Added `is_closed` attribute from shapely to GeoSeries/GeoDataFrame (#3092).
- Added `force_2d` and `force_3d` methods from shapely to GeoSeries/GeoDataFrame (#3090).
- Added `voronoi_polygons` method from shapely to GeoSeries/GeoDataFrame (#3177).
- Added `contains_properly` method from shapely to GeoSeries/GeoDataFrame (#3105).
- Added `build_area` method exposing `build_area` shapely to GeoSeries/GeoDataFrame (#3202).
- Added `snap` method from shapely to GeoSeries/GeoDataFrame (#3086).
- Added `transform` method from shapely to GeoSeries/GeoDataFrame (#3075).
- Added `get_geometry` method from shapely to GeoSeries/GeoDataFrame (#3287).
- Added `dwithin` method to check for a "distance within" predicate on
GeoSeries/GeoDataFrame (#3153).
- Added `to_geo_dict` method to generate GeoJSON-like dictionary from a GeoDataFrame (#3132).
- Added `polygonize` method exposing both `polygonize` and `polygonize_full` from
shapely to GeoSeries/GeoDataFrame (#2963).
- Added `is_valid_reason` method from shapely to GeoSeries/GeoDataFrame (#3176).
- Added `to_arrow` method and `from_arrow` class method to
GeoSeries/GeoDataFrame to export and import to/from Arrow data with GeoArrow
extension types (#3219, #3301).
New features and improvements:
- Added ``predicate="dwithin"`` option and ``distance`` argument to the ``sindex.query()`` method
and ``sjoin`` (#2882).
- GeoSeries and GeoDataFrame `__repr__` now trims trailing zeros for a more readable
output (#3087).
- Add `on_invalid` parameter to `from_wkt` and `from_wkb` (#3110).
- `make_valid` option in `overlay` now uses the `make_valid` method instead of
`buffer(0)` (#3113).
- Passing `"geometry"` as `dtype` to `pd.read_csv` will now return a GeoSeries for
the specified columns (#3101).
- Added support to ``read_file`` for the ``mask`` keyword for the pyogrio engine (#3062).
- Added support to ``read_file`` for the ``columns`` keyword for the fiona engine (#3133).
- Added support to ``to_parquet`` and ``read_parquet`` for writing and reading files
using the GeoArrow-based native geometry encoding of GeoParquet 1.1 (#3253, #3275).
- Add `sort` keyword to `clip` method for GeoSeries and GeoDataFrame to allow optional
preservation of the original order of observations (#3233).
- Added `show_bbox`, `drop_id` and `to_wgs84` arguments to allow further customization of
`GeoSeries.to_json` (#3226).
- `explore` now supports `GeoDataFrame`s with additional columns containing datetimes, uuids and
other non JSON serializable objects (#3261).
- The `GeoSeries.fillna` method now supports the `limit` keyword (#3290).
- Added ``on_attribute`` option argument to the ``sjoin()``
method, allowing to restrict joins to the observations with
matching attributes (#3231).
- Added support for `bbox` covering encoding in geoparquet. Can filter reading of parquet
files based on a bounding box, and write out a bounding box column to parquet files (#3282).
- `align` keyword in binary methods now defaults to `None`, treated as True. Explicit True
will silence the warning about mismatched indices (#3212).
- `GeoSeries.set_crs` can now be used to remove CRS information by passing
`crs=None, allow_override=True` (#3316).
- Added ``autolim`` keyword argument to ``GeoSeries.plot()`` and ``GeoDataFrame.plot()`` (#2817).
- Added `metadata` parameter to `GeoDataFrame.to_file` (#2850).
- Updated documentation to clarify that passing a named (Geo)Series as the `geometry`
argument to the GeoDataFrame constructor will not use the name but will always
produce a GeoDataFrame with an active geometry column named "geometry" (#3337).
- `read_postgis` will query the spatial_ref_sys table to determine the CRS authority
instead of its current behaviour of assuming EPSG. In the event the spiatal_ref_sys
table is not present, or the SRID is not present, `read_postgis` will fallback
on assuming EPSG CRS authority (#3329).
- Added ``GeoDataFrame.active_geometry_name`` property returning the active geometry column's name or None if no active geometry column is set (#2943).
Backwards incompatible API changes:
- The `sjoin` method will now preserve the name of the index of the right
GeoDataFrame, if it has one, instead of always using `"index_right"` as the
name for the resulting column in the return value (#846, #2144).
- GeoPandas now raises a ValueError when an unaligned Series is passed as a method
argument to avoid confusion of whether the automatic alignment happens or not (#3271).
- The deprecated default value of GeoDataFrame/ GeoSeries `explode(.., index_parts=True)` is now
set to false for consistency with pandas (#3174).
- The behaviour of `set_geometry` has been changed when passed a (Geo)Series `ser` with a name.
The new active geometry column name in this case will be `ser.name`, if not None, rather than
the previous active geometry column name. This means that if the new and old names are
different, then both columns will be preserved in the GeoDataFrame. To replicate the previous
behaviour, you can instead call `gdf.set_geometry(ser.rename(gdf.active_geometry_name))` (#3237).
Note that this behaviour change does not affect the `GeoDataFrame` constructor, passing a named
GeoSeries `ser` to `GeoDataFrame(df, geometry=ser)` will always produce a GeoDataFrame with a
geometry column named "geometry" to preserve backwards compatibility. If you would like to
instead propagate the name of `ser` when constructing a GeoDataFrame, you can instead call
`df.set_geometry(ser)` or `GeoDataFrame(df, geometry=ser).rename_geometry(ser.name)` (#3337).
- `delaunay_triangles` now considers all geometries together when creating the Delaunay triangulation
instead of performing the operation element-wise. If you want to generate Delaunay
triangles for each geometry separately, use ``shapely.delaunay_triangles`` instead. (#3273)
- Reading a data source that does not have a geometry field using ``read_file``
now returns a Pandas DataFrame instead of a GeoDataFrame with an empty
``geometry`` column.
Enforced deprecations:
- The deprecation of `geopandas.datasets` has been enforced and the module has been
removed. New sample datasets are now available in the
[geodatasets](https://geodatasets.readthedocs.io/en/latest/) package (#3084).
- Many longstanding deprecated functions, methods and properties have been removed (#3174), (#3190)
- Removed deprecated functions
`geopandas.io.read_file`, `geopandas.io.to_file` and `geopandas.io.sql.read_postgis`.
`geopandas.read_file`, `geopandas.read_postgis` and the GeoDataFrame/GeoSeries `to_file(..)`
method should be used instead.
- Removed deprecated `GeometryArray.data` property, `np.asarray(..)` or the `to_numpy()`
method should be used instead.
- Removed deprecated `sindex.query_bulk` method, using `sindex.query` instead.
- Removed deprecated `sjoin` parameter `op`, `predicate` should be supplied instead.
- Removed deprecated GeoSeries/ GeoDataFrame methods `__xor__`, `__or__`, `__and__` and
`__sub__`. Instead use methods `symmetric_difference`, `union`, `intersection` and
`difference` respectively.
- Removed deprecated plotting functions `plot_polygon_collection`,
`plot_linestring_collection` and `plot_point_collection`, use the GeoSeries/GeoDataFrame `.plot`
method directly instead.
- Removed deprecated GeoSeries/GeoDataFrame `.plot` parameters `axes` and `colormap`, instead use
`ax` and `cmap` respectively.
- Removed compatibility for specifying the `version` keyword in `to_parquet` and `to_feather`.
This keyword will now be passed through to pyarrow and use `schema_version` to specify the GeoParquet specification version (#3334).
New deprecations:
- `unary_union` attribute is now deprecated and replaced by the `union_all()` method (#3007) allowing
opting for a faster union algorithm for coverages (#3151).
- The ``include_fields`` and ``ignore_fields`` keywords in ``read_file()`` are deprecated
for the default pyogrio engine. Currently those are translated to the ``columns`` keyword
for backwards compatibility, but you should directly use the ``columns`` keyword instead
to select which columns to read (#3133).
- The `drop` keyword in `set_geometry` has been deprecated, and in future the `drop=True`
behaviour will be removed (#3237). To prepare for this change, you should remove any explicit
`drop=False` calls in your code (the default behaviour already is the same as `drop=False`).
To replicate the previous `drop=True` behaviour you should replace
`gdf.set_geometry(new_geo_col, drop=True)` with
```python
geo_col_name = gdf.active_geometry_name
gdf.set_geometry(new_geo_col).drop(columns=geo_col_name).rename_geometry(geo_col_name)
```
- The `geopandas.use_pygeos` option has been deprecated and will be removed in GeoPandas
1.1 (#3283)
- Manual overriding of an existing CRS of a GeoSeries or GeoDataFrame by setting the `crs` property has been deprecated
and will be disabled in future. Use the `set_crs()` method instead (#3085).
Bug fixes:
- Fix `GeoDataFrame.merge()` incorrectly returning a `DataFrame` instead of a
`GeoDataFrame` when the `suffixes` argument is applied to the active
geometry column (#2933).
- Fix bug in `GeoDataFrame` constructor where if `geometry` is given a named
`GeoSeries` the name was not used as the active geometry column name (#3237).
- Fix bug in `GeoSeries` constructor when passing a Series and specifying a `crs` to not change the original input data (#2492).
- Fix regression preventing reading from file paths containing hashes in `read_file`
with the fiona engine (#3280). An analogous fix for pyogrio is included in
pyogrio 0.8.1.
- Fix `to_parquet` to write correct metadata in case of 3D geometries (#2824).
- Fixes for compatibility with psycopg (#3167).
- Fix to allow appending dataframes with no CRS to PostGIS tables with no CRS (#3328)
- Fix plotting of all-empty GeoSeries using `explore` (#3316).
## Version 0.14.4 (April 26, 2024)
- Several fixes for compatibility with the upcoming pandas 3.0, numpy 2.0 and
fiona 1.10 releases.
## Version 0.14.3 (Jan 31, 2024)
- Several fixes for compatibility with the latest pandas 2.2 release.
- Fix bug in `pandas.concat` CRS consistency checking where CRS differing by WKT
whitespace only were treated as incompatible (#3023).
## Version 0.14.2 (Jan 4, 2024)
- Fix regression in `overlay` where using `buffer(0)` instead of `make_valid` internally
produced invalid results (#3074).
- Fix `explore()` method when the active geometry contains missing and empty geometries (#3094).
## Version 0.14.1 (Nov 11, 2023)
- The Parquet and Feather IO functions now support the latest 1.0.0 version
of the GeoParquet specification (geoparquet.org) (#2663).
- Fix `read_parquet` and `read_feather` for [CVE-2023-47248](https://www.cve.org/CVERecord?id=CVE-2023-47248>) (#3070).
## Version 0.14 (Sep 15, 2023)
GeoPandas will use Shapely 2.0 by default instead of PyGEOS when both Shapely >= 2.0 and
PyGEOS are installed. PyGEOS will continue to be used by default when PyGEOS is
installed alongside Shapely < 2.0. Support for PyGEOS and Shapely < 2.0 will be removed
in GeoPandas 1.0. (#2999)
API changes:
- ``seed`` keyword in ``sample_points`` is deprecated. Use ``rng`` instead. (#2913).
New methods:
- Added ``concave_hull`` method from shapely to GeoSeries/GeoDataFrame (#2903).
- Added ``delaunay_triangles`` method from shapely to GeoSeries/GeoDataFrame (#2907).
- Added ``extract_unique_points`` method from shapely to GeoSeries/GeoDataFrame (#2915).
- Added ``frechet_distance()`` method from shapely to GeoSeries/GeoDataFrame (#2929).
- Added ``hausdorff_distance`` method from shapely to GeoSeries/GeoDataFrame (#2909).
- Added ``minimum_rotated_rectangle`` method from shapely to GeoSeries/GeoDataFrame (#2541).
- Added ``offset_curve`` method from shapely to GeoSeries/GeoDataFrame (#2902).
- Added ``remove_repeated_points`` method from shapely to GeoSeries/GeoDataFrame (#2940).
- Added ``reverse`` method from shapely to GeoSeries/GeoDataFrame (#2988).
- Added ``segmentize`` method from shapely to GeoSeries/GeoDataFrame (#2910).
- Added ``shortest_line`` method from shapely to GeoSeries/GeoDataFrame (#2960).
New features and improvements:
- Added ``exclusive`` parameter to ``sjoin_nearest`` method for Shapely >= 2.0 (#2877)
- The ``to_file()`` method will now automatically detect the FlatGeoBuf driver
for files with the `.fgb` extension (#2958)
Bug fixes:
- Fix ambiguous error when GeoDataFrame is initialized with a column called ``"crs"`` (#2944)
- Fix a color assignment in ``explore`` when using ``UserDefined`` bins (#2923)
- Fix bug in `apply` with `axis=1` where the given user defined function returns nested
data in the geometry column (#2959)
- Properly infer schema for ``np.int32`` and ``pd.Int32Dtype`` columns (#2950)
- ``assert_geodataframe_equal`` now handles GeoDataFrames with no active geometry (#2498)
Notes on (optional) dependencies:
- GeoPandas 0.14 drops support for Python 3.8 and pandas 1.3 and below (the minimum
supported pandas version is now 1.4). Further, the minimum required versions for the
listed dependencies have now changed to shapely 1.8.0, fiona 1.8.21, pyproj 3.3.0 and
matplotlib 3.5.0 (#3001)
Deprecations and compatibility notes:
- `geom_almost_equals()` methods have been deprecated and
`geom_equals_exact()` should be used instead (#2604).
## Version 0.13.2 (Jun 6, 2023)
Bug fix:
- Fix a regression in reading from local file URIs (``file://..``) using
``geopandas.read_file`` (#2948).
## Version 0.13.1 (Jun 5, 2023)
Bug fix:
- Fix a regression in reading from URLs using ``geopandas.read_file`` (#2908). This
restores the behaviour to download all data up-front before passing it to the
underlying engine (fiona or pyogrio), except if the server supports partial requests
(to support reading a subset of a large file).
## Version 0.13 (May 6, 2023)
New methods:
- Added ``sample_points`` method to sample random points from Polygon or LineString
geometries (#2860).
- New ``hilbert_distance()`` method that calculates the distance along a Hilbert curve
for each geometry in a GeoSeries/GeoDataFrame (#2297).
- Support for sorting geometries (for example, using ``sort_values()``) based on
the distance along the Hilbert curve (#2070).
- Added ``get_coordinates()`` method from shapely to GeoSeries/GeoDataFrame (#2624).
- Added ``minimum_bounding_circle()`` method from shapely to GeoSeries/GeoDataFrame (#2621).
- Added `minimum_bounding_radius()` as GeoSeries method (#2827).
Other new features and improvements:
- The Parquet and Feather IO functions now support the latest 1.0.0-beta.1 version
of the GeoParquet specification () (#2663).
- Added support to fill missing values in `GeoSeries.fillna` via another `GeoSeries` (#2535).
- Support specifying ``min_zoom`` and ``max_zoom`` inside the ``map_kwds`` argument for ``.explore()`` (#2599).
- Added support for append (``mode="a"`` or ``append=True``) in ``to_file()``
using ``engine="pyogrio"`` (#2788).
- Added a ``to_wgs84`` keyword to ``to_json`` allowing automatic re-projecting to follow
the 2016 GeoJSON specification (#416).
- ``to_json`` output now includes a ``"crs"`` field if the CRS is not the default WGS84 (#1774).
- Improve error messages when accessing the `geometry` attribute of GeoDataFrame without an active geometry column
related to the default name `"geometry"` being provided in the constructor (#2577)
Deprecations and compatibility notes:
- Added warning that ``unary_union`` will return ``'GEOMETRYCOLLECTION EMPTY'`` instead
of None for all-None GeoSeries. (#2618)
- The ``query_bulk()`` method of the spatial index `.sindex` property is deprecated
in favor of ``query()`` (#2823).
Bug fixes:
- Ensure that GeoDataFrame created from DataFrame is a copy, not a view (#2667)
- Fix mismatch between geometries and colors in ``plot()`` if an empty or missing
geometry is present (#2224)
- Escape special characters to avoid TemplateSyntaxError in ``explore()`` (#2657)
- Fix `to_parquet`/`to_feather` to not write an invalid bbox (with NaNs) in the
metadata in case of an empty GeoDataFrame (#2653)
- Fix `to_parquet`/`to_feather` to use correct WKB flavor for 3D geometries (#2654)
- Fix `read_file` to avoid reading all file bytes prior to calling Fiona or
Pyogrio if provided a URL as input (#2796)
- Fix `copy()` downcasting GeoDataFrames without an active geometry column to a
DataFrame (#2775)
- Fix geometry column name propagation when GeoDataFrame columns are a multiindex (#2088)
- Fix `iterfeatures()` method of GeoDataFrame to correctly handle non-scalar values
when `na='drop'` is specified (#2811)
- Fix issue with passing custom legend labels to `plot` (#2886)
Notes on (optional) dependencies:
- GeoPandas 0.13 drops support pandas 1.0.5 (the minimum supported
pandas version is now 1.1). Further, the minimum required versions for the listed
dependencies have now changed to shapely 1.7.1, fiona 1.8.19, pyproj 3.0.1 and
matplotlib 3.3.4 (#2655)
## Version 0.12.2 (December 10, 2022)
Bug fixes:
- Correctly handle geometries with Z dimension in ``to_crs()`` when using PyGEOS or
Shapely >= 2.0 (previously the z coordinates were lost) (#1345).
- Assign Crimea to Ukraine in the ``naturalearth_lowres`` built-in dataset (#2670)
## Version 0.12.1 (October 29, 2022)
Small bug-fix release removing the shapely<2 pin in the installation requirements.
## Version 0.12 (October 24, 2022)
The highlight of this release is the support for Shapely 2.0. This makes it possible to
test Shapely 2.0 (currently 2.0b1) alongside GeoPandas.
Note that if you also have PyGEOS installed, you need to set an environment variable
(`USE_PYGEOS=0`) before importing geopandas to actually test Shapely 2.0 features instead of PyGEOS. See
for more details.
New features and improvements:
- Added ``normalize()`` method from shapely to GeoSeries/GeoDataFrame (#2537).
- Added ``make_valid()`` method from shapely to GeoSeries/GeoDataFrame (#2539).
- Added ``where`` filter to ``read_file`` (#2552).
- Updated the distributed natural earth datasets (*naturalearth_lowres* and
*naturalearth_cities*) to version 5.1 (#2555).
Deprecations and compatibility notes:
- Accessing the `crs` of a `GeoDataFrame` without active geometry column was deprecated
and this now raises an AttributeError (#2578).
- Resolved colormap-related warning in ``.explore()`` for recent Matplotlib versions
(#2596).
Bug fixes:
- Fix cryptic error message in ``geopandas.clip()`` when clipping with an empty geometry (#2589).
- Accessing `gdf.geometry` where the active geometry column is missing, and a column
named `"geometry"` is present will now raise an `AttributeError`, rather than
returning `gdf["geometry"]` (#2575).
- Combining GeoSeries/GeoDataFrames with ``pandas.concat`` will no longer silently
override CRS information if not all inputs have the same CRS (#2056).
## Version 0.11.1 (July 24, 2022)
Small bug-fix release:
- Fix regression (RecursionError) in reshape methods such as ``unstack()``
and ``pivot()`` involving MultiIndex, or GeoDataFrame construction with
MultiIndex (#2486).
- Fix regression in ``GeoDataFrame.explode()`` with non-default
geometry column name.
- Fix regression in ``apply()`` causing row-wise all nan float columns to be
casted to GeometryDtype (#2482).
- Fix a crash in datetime column reading where the file contains mixed timezone
offsets (#2479). These will be read as UTC localized values.
- Fix a crash in datetime column reading where the file contains datetimes
outside the range supported by [ns] precision (#2505).
- Fix regression in passing the Parquet or Feather format ``version`` in
``to_parquet`` and ``to_feather``. As a result, the ``version`` parameter
for the ``to_parquet`` and ``to_feather`` methods has been replaced with
``schema_version``. ``version`` will be passed directly to underlying
feather or parquet writer. ``version`` will only be used to set
``schema_version`` if ``version`` is one of 0.1.0 or 0.4.0 (#2496).
Version 0.11 (June 20, 2022)
----------------------------
Highlights of this release:
- The ``geopandas.read_file()`` and `GeoDataFrame.to_file()` methods to read
and write GIS file formats can now optionally use the
[pyogrio](https://github.com/geopandas/pyogrio/) package under the hood
through the ``engine="pyogrio"`` keyword. The pyogrio package implements
vectorized IO for GDAL/OGR vector data sources, and is faster compared to
the ``fiona``-based engine (#2225).
- GeoParquet support updated to implement
[v0.4.0](https://github.com/opengeospatial/geoparquet/releases/tag/v0.4.0) of the
OpenGeospatial/GeoParquet specification (#2441). Backwards compatibility with v0.1.0 of
the metadata spec (implemented in the previous releases of GeoPandas) is guaranteed,
and reading and writing Parquet and Feather files will no longer produce a ``UserWarning``
(#2327).
New features and improvements:
- Improved handling of GeoDataFrame when the active geometry column is
lost from the GeoDataFrame. Previously, square bracket indexing ``gdf[[...]]`` returned
a GeoDataFrame when the active geometry column was retained and a DataFrame was
returned otherwise. Other pandas indexing methods (``loc``, ``iloc``, etc) did not follow
the same rules. The new behaviour for all indexing/reshaping operations is now as
follows (#2329, #2060):
- If operations produce a ``DataFrame`` containing the active geometry column, a
GeoDataFrame is returned
- If operations produce a ``DataFrame`` containing ``GeometryDtype`` columns, but not the
active geometry column, a ``GeoDataFrame`` is returned, where the active geometry
column is set to ``None`` (set the new geometry column with ``set_geometry()``)
- If operations produce a ``DataFrame`` containing no ``GeometryDtype`` columns, a
``DataFrame`` is returned (this can be upcast again by calling ``set_geometry()`` or the
``GeoDataFrame`` constructor)
- If operations produce a ``Series`` of ``GeometryDtype``, a ``GeoSeries`` is returned,
otherwise ``Series`` is returned.
- Error messages for having an invalid geometry column
have been improved, indicating the name of the last valid active geometry column set
and whether other geometry columns can be promoted to the active geometry column
(#2329).
- Datetime fields are now read and written correctly for GIS formats which support them
(e.g. GPKG, GeoJSON) with fiona 1.8.14 or higher. Previously, datetimes were read as
strings (#2202).
- ``folium.Map`` keyword arguments can now be specified as the ``map_kwds`` argument to
``GeoDataFrame.explore()`` method (#2315).
- Add a new parameter ``style_function`` to ``GeoDataFrame.explore()`` to enable plot styling
based on GeoJSON properties (#2377).
- It is now possible to write an empty ``GeoDataFrame`` to a file for supported formats
(#2240). Attempting to do so will now emit a ``UserWarning`` instead of a ``ValueError``.
- Fast rectangle clipping has been exposed as ``GeoSeries/GeoDataFrame.clip_by_rect()``
(#1928).
- The ``mask`` parameter of ``GeoSeries/GeoDataFrame.clip()`` now accepts a rectangular mask
as a list-like to perform fast rectangle clipping using the new
``GeoSeries/GeoDataFrame.clip_by_rect()`` (#2414).
- Bundled demo dataset ``naturalearth_lowres`` has been updated to version 5.0.1 of the
source, with field ``ISO_A3`` manually corrected for some cases (#2418).
Deprecations and compatibility notes:
- The active development branch of geopandas on GitHub has been renamed from master to
main (#2277).
- Deprecated methods ``GeometryArray.equals_exact()`` and ``GeometryArray.almost_equals()``
have been removed. They should
be replaced with ``GeometryArray.geom_equals_exact()`` and
``GeometryArray.geom_almost_equals()`` respectively (#2267).
- Deprecated CRS functions ``explicit_crs_from_epsg()``, ``epsg_from_crs()`` and
``get_epsg_file_contents()`` were removed (#2340).
- Warning about the behaviour change to ``GeoSeries.isna()`` with empty
geometries present has been removed (#2349).
- Specifying a CRS in the ``GeoDataFrame/GeoSeries`` constructor which contradicted the
underlying ``GeometryArray`` now raises a ``ValueError`` (#2100).
- Specifying a CRS in the ``GeoDataFrame`` constructor when no geometry column is provided
and calling ``GeoDataFrame. set_crs`` on a ``GeoDataFrame`` without an active geometry
column now raise a ``ValueError`` (#2100)
- Passing non-geometry data to the``GeoSeries`` constructor is now fully deprecated and
will raise a ``TypeError`` (#2314). Previously, a ``pandas.Series`` was returned for
non-geometry data.
- Deprecated ``GeoSeries/GeoDataFrame`` set operations ``__xor__()``,
``__or__()``, ``__and__()`` and ``__sub__()``, ``geopandas.io.file.read_file``/``to_file`` and
``geopandas.io.sql.read_postgis`` now emit ``FutureWarning`` instead of
``DeprecationWarning`` and will be completely removed in a future release.
- Accessing the ``crs`` of a ``GeoDataFrame`` without active geometry column is deprecated and will be removed in GeoPandas 0.12 (#2373).
Bug fixes:
- ``GeoSeries.to_frame`` now creates a ``GeoDataFrame`` with the geometry column name set
correctly (#2296)
- Fix pickle files created with pygeos installed can not being readable when pygeos is
not installed (#2237).
- Fixed ``UnboundLocalError`` in ``GeoDataFrame.plot()`` using ``legend=True`` and
``missing_kwds`` (#2281).
- Fix ``explode()`` incorrectly relating index to columns, including where the input index
is not unique (#2292)
- Fix ``GeoSeries.[xyz]`` raising an ``IndexError`` when the underlying GeoSeries contains
empty points (#2335). Rows corresponding to empty points now contain ``np.nan``.
- Fix ``GeoDataFrame.iloc`` raising a ``TypeError`` when indexing a ``GeoDataFrame`` with only
a single column of ``GeometryDtype`` (#1970).
- Fix ``GeoDataFrame.iterfeatures()`` not returning features with the same field order as
``GeoDataFrame.columns`` (#2396).
- Fix ``GeoDataFrame.from_features()`` to support reading GeoJSON with null properties
(#2243).
- Fix ``GeoDataFrame.to_parquet()`` not intercepting ``engine`` keyword argument, breaking
consistency with pandas (#2227)
- Fix ``GeoDataFrame.explore()`` producing an error when ``column`` is of boolean dtype
(#2403).
- Fix an issue where ``GeoDataFrame.to_postgis()`` output the wrong SRID for ESRI
authority CRS (#2414).
- Fix ``GeoDataFrame.from_dict/from_features`` classmethods using ``GeoDataFrame`` rather
than ``cls`` as the constructor.
- Fix ``GeoDataFrame.plot()`` producing incorrect colors with mixed geometry types when
``colors`` keyword is provided. (#2420)
Notes on (optional) dependencies:
- GeoPandas 0.11 drops support for Python 3.7 and pandas 0.25 (the minimum supported
pandas version is now 1.0.5). Further, the minimum required versions for the listed
dependencies have now changed to shapely 1.7, fiona 1.8.13.post1, pyproj 2.6.1.post1,
matplotlib 3.2, mapclassify 2.4.0 (#2358, #2391)
Version 0.10.2 (October 16, 2021)
---------------------------------
Small bug-fix release:
- Fix regression in ``overlay()`` in case no geometries are intersecting (but
have overlapping total bounds) (#2172).
- Fix regression in ``overlay()`` with ``keep_geom_type=True`` in case the
overlay of two geometries in a GeometryCollection with other geometry types
(#2177).
- Fix ``overlay()`` to honor the ``keep_geom_type`` keyword for the
``op="difference"`` case (#2164).
- Fix regression in ``plot()`` with a mapclassify ``scheme`` in case the
formatted legend labels have duplicates (#2166).
- Fix a bug in the ``explore()`` method ignoring the ``vmin`` and ``vmax`` keywords
in case they are set to 0 (#2175).
- Fix ``unary_union`` to correctly handle a GeoSeries with missing values (#2181).
- Avoid internal deprecation warning in ``clip()`` (#2179).
Version 0.10.1 (October 8, 2021)
--------------------------------
Small bug-fix release:
- Fix regression in ``overlay()`` with non-overlapping geometries and a
non-default ``how`` (i.e. not "intersection") (#2157).
Version 0.10.0 (October 3, 2021)
--------------------------------
Highlights of this release:
- A new ``sjoin_nearest()`` method to join based on proximity, with the
ability to set a maximum search radius (#1865). In addition, the ``sindex``
attribute gained a new method for a "nearest" spatial index query (#1865,
#2053).
- A new ``explore()`` method on GeoDataFrame and GeoSeries with native support
for interactive visualization based on folium / leaflet.js (#1953)
- The ``geopandas.sjoin()``/``overlay()``/``clip()`` functions are now also
available as methods on the GeoDataFrame (#2141, #1984, #2150).
New features and improvements:
- Add support for pandas' ``value_counts()`` method for geometry dtype (#2047).
- The ``explode()`` method has a new ``ignore_index`` keyword (consistent with
pandas' explode method) to reset the index in the result, and a new
``index_parts`` keywords to control whether a cumulative count indexing the
parts of the exploded multi-geometries should be added (#1871).
- ``points_from_xy()`` is now available as a GeoSeries method ``from_xy`` (#1936).
- The ``to_file()`` method will now attempt to detect the driver (if not
specified) based on the extension of the provided filename, instead of
defaulting to ESRI Shapefile (#1609).
- Support for the ``storage_options`` keyword in ``read_parquet()`` for
specifying filesystem-specific options (e.g. for S3) based on fsspec (#2107).
- The read/write functions now support ``~`` (user home directory) expansion (#1876).
- Support the ``convert_dtypes()`` method from pandas to preserve the
GeoDataFrame class (#2115).
- Support WKB values in the hex format in ``GeoSeries.from_wkb()`` (#2106).
- Update the ``estimate_utm_crs()`` method to handle crossing the antimeridian
with pyproj 3.1+ (#2049).
- Improved heuristic to decide how many decimals to show in the repr based on
whether the CRS is projected or geographic (#1895).
- Switched the default for ``geocode()`` from GeoCode.Farm to the Photon
geocoding API () (#2007).
Deprecations and compatibility notes:
- The ``op=`` keyword of ``sjoin()`` to indicate which spatial predicate to use
for joining is being deprecated and renamed in favor of a new ``predicate=``
keyword (#1626).
- The ``cascaded_union`` attribute is deprecated, use ``unary_union`` instead (#2074).
- Constructing a GeoDataFrame with a duplicated "geometry" column is now
disallowed. This can also raise an error in the ``pd.concat(.., axis=1)``
function if this results in duplicated active geometry columns (#2046).
- The ``explode()`` method currently returns a GeoSeries/GeoDataFrame with a
MultiIndex, with an additional level with indices of the parts of the
exploded multi-geometries. For consistency with pandas, this will change in
the future and the new ``index_parts`` keyword is added to control this.
Bug fixes:
- Fix in the ``clip()`` function to correctly clip MultiPoints instead of
leaving them intact when partly outside of the clip bounds (#2148).
- Fix ``GeoSeries.isna()`` to correctly return a boolean Series in case of an
empty GeoSeries (#2073).
- Fix the GeoDataFrame constructor to preserve the geometry name when the
argument is already a GeoDataFrame object (i.e. ``GeoDataFrame(gdf)``) (#2138).
- Fix loss of the values' CRS when setting those values as a column
(``GeoDataFrame.__setitem__``) (#1963)
- Fix in ``GeoDataFrame.apply()`` to preserve the active geometry column name
(#1955).
- Fix in ``sjoin()`` to not ignore the suffixes in case of a right-join
(``how="right``) (#2065).
- Fix ``GeoDataFrame.explode()`` with a MultiIndex (#1945).
- Fix the handling of missing values in ``to/from_wkb`` and ``to_from_wkt`` (#1891).
- Fix ``to_file()`` and ``to_json()`` when DataFrame has duplicate columns to
raise an error (#1900).
- Fix bug in the colors shown with user-defined classification scheme (#2019).
- Fix handling of the ``path_effects`` keyword in ``plot()`` (#2127).
- Fix ``GeoDataFrame.explode()`` to preserve ``attrs`` (#1935)
Notes on (optional) dependencies:
- GeoPandas 0.10.0 dropped support for Python 3.6 and pandas 0.24. Further,
the minimum required versions are numpy 1.18, shapely 1.6, fiona 1.8,
matplotlib 3.1 and pyproj 2.2.
- Plotting with a classification schema now requires mapclassify version >=
2.4 (#1737).
- Compatibility fixes for the latest numpy in combination with Shapely 1.7 (#2072)
- Compatibility fixes for the upcoming Shapely 1.8 (#2087).
- Compatibility fixes for the latest PyGEOS (#1872, #2014) and matplotlib
(colorbar issue, #2066).
Version 0.9.0 (February 28, 2021)
---------------------------------
Many documentation improvements and a restyled and restructured website with
a new logo (#1564, #1579, #1617, #1668, #1731, #1750, #1757, #1759).
New features and improvements:
- The ``geopandas.read_file`` function now accepts more general
file-like objects (e.g. ``fsspec`` open file objects). It will now also
automatically recognize zipped files (#1535).
- The ``GeoDataFrame.plot()`` method now provides access to the pandas plotting
functionality for the non-geometry columns, either using the ``kind`` keyword
or the accessor method (e.g. ``gdf.plot(kind="bar")`` or ``gdf.plot.bar()``)
(#1465).
- New ``from_wkt()``, ``from_wkb()``, ``to_wkt()``, ``to_wkb()`` methods for
GeoSeries to construct a GeoSeries from geometries in WKT or WKB
representation, or to convert a GeoSeries to a pandas Seriew with WKT or WKB
values (#1710).
- New ``GeoSeries.z`` attribute to access the z-coordinates of Point geometries
(similar to the existing ``.x`` and ``.y`` attributes) (#1773).
- The ``to_crs()`` method now handles missing values (#1618).
- Support for pandas' new ``.attrs`` functionality (#1658).
- The ``dissolve()`` method now allows dissolving by no column (``by=None``) to
create a union of all geometries (single-row GeoDataFrame) (#1568).
- New ``estimate_utm_crs()`` method on GeoSeries/GeoDataFrame to determine the
UTM CRS based on the bounds (#1646).
- ``GeoDataFrame.from_dict()`` now accepts ``geometry`` and ``crs`` keywords
(#1619).
- ``GeoDataFrame.to_postgis()`` and ``geopandas.read_postgis()`` now supports
both sqlalchemy engine and connection objects (#1638).
- The ``GeoDataFrame.explode()`` method now allows exploding based on a
non-geometry column, using the pandas implementation (#1720).
- Performance improvement in ``GeoDataFrame/GeoSeries.explode()`` when using
the PyGEOS backend (#1693).
- The binary operation and predicate methods (eg ``intersection()``,
``intersects()``) have a new ``align`` keyword which allows optionally not
aligning on the index before performing the operation with ``align=False``
(#1668).
- The ``GeoDataFrame.dissolve()`` method now supports all relevant keywords of
``groupby()``, i.e. the ``level``, ``sort``, ``observed`` and ``dropna`` keywords
(#1845).
- The ``geopandas.overlay()`` function now accepts ``make_valid=False`` to skip
the step to ensure the input geometries are valid using ``buffer(0)`` (#1802).
- The ``GeoDataFrame.to_json()`` method gained a ``drop_id`` keyword to
optionally not write the GeoDataFrame's index as the "id" field in the
resulting JSON (#1637).
- A new ``aspect`` keyword in the plotting methods to optionally allow retaining
the original aspect (#1512)
- A new ``interval`` keyword in the ``legend_kwds`` group of the ``plot()`` method
to control the appearance of the legend labels when using a classification
scheme (#1605).
- The spatial index of a GeoSeries (accessed with the ``sindex`` attribute) is
now stored on the underlying array. This ensures that the spatial index is
preserved in more operations where possible, and that multiple geometry
columns of a GeoDataFrame can each have a spatial index (#1444).
- Addition of a ``has_sindex`` attribute on the GeoSeries/GeoDataFrame to check
if a spatial index has already been initialized (#1627).
- The ``geopandas.testing.assert_geoseries_equal()`` and ``assert_geodataframe_equal()``
testing utilities now have a ``normalize`` keyword (False by default) to
normalize geometries before comparing for equality (#1826). Those functions
now also give a more informative error message when failing (#1808).
Deprecations and compatibility notes:
- The ``is_ring`` attribute currently returns True for Polygons. In the future,
this will be False (#1631). In addition, start to check it for LineStrings
and LinearRings (instead of always returning False).
- The deprecated ``objects`` keyword in the ``intersection()`` method of the
``GeoDataFrame/GeoSeries.sindex`` spatial index object has been removed
(#1444).
Bug fixes:
- Fix regression in the ``plot()`` method raising an error with empty
geometries (#1702, #1828).
- Fix ``geopandas.overlay()`` to preserve geometries of the correct type which
are nested within a GeometryCollection as a result of the overlay
operation (#1582). In addition, a warning will now be raised if geometries
of different type are dropped from the result (#1554).
- Fix the repr of an empty GeoSeries to not show spurious warnings (#1673).
- Fix the ``.crs`` for empty GeoDataFrames (#1560).
- Fix ``geopandas.clip`` to preserve the correct geometry column name (#1566).
- Fix bug in ``plot()`` method when using ``legend_kwds`` with multiple subplots
(#1583)
- Fix spurious warning with ``missing_kwds`` keyword of the ``plot()`` method
when there are no areas with missing data (#1600).
- Fix the ``plot()`` method to correctly align values passed to the ``column``
keyword as a pandas Series (#1670).
- Fix bug in plotting MultiPoints when passing values to determine the color
(#1694)
- The ``rename_geometry()`` method now raises a more informative error message
when a duplicate column name is used (#1602).
- Fix ``explode()`` method to preserve the CRS (#1655)
- Fix the ``GeoSeries.apply()`` method to again accept the ``convert_dtype``
keyword to be consistent with pandas (#1636).
- Fix ``GeoDataFrame.apply()`` to preserve the CRS when possible (#1848).
- Fix bug in containment test as ``geom in geoseries`` (#1753).
- The ``shift()`` method of a GeoSeries/GeoDataFrame now preserves the CRS
(#1744).
- The PostGIS IO functionality now quotes table names to ensure it works with
case-sensitive names (#1825).
- Fix the ``GeoSeries`` constructor without passing data but only an index (#1798).
Notes on (optional) dependencies:
- GeoPandas 0.9.0 dropped support for Python 3.5. Further, the minimum
required versions are pandas 0.24, numpy 1.15 and shapely 1.6 and fiona 1.8.
- The ``descartes`` package is no longer required for plotting polygons. This
functionality is now included by default in GeoPandas itself, when
matplotlib is available (#1677).
- Fiona is now only imported when used in ``read_file``/``to_file``. This means
you can now force geopandas to install without fiona installed (although it
is still a default requirement) (#1775).
- Compatibility with the upcoming Shapely 1.8 (#1659, #1662, #1819).
Version 0.8.2 (January 25, 2021)
--------------------------------
Small bug-fix release for compatibility with PyGEOS 0.9.
Version 0.8.1 (July 15, 2020)
-----------------------------
Small bug-fix release:
- Fix a regression in the ``plot()`` method when visualizing with a
JenksCaspallSampled or FisherJenksSampled scheme (#1486).
- Fix spurious warning in ``GeoDataFrame.to_postgis`` (#1497).
- Fix the un-pickling with ``pd.read_pickle`` of files written with older
GeoPandas versions (#1511).
Version 0.8.0 (June 24, 2020)
-----------------------------
**Experimental**: optional use of PyGEOS to speed up spatial operations (#1155).
PyGEOS is a faster alternative for Shapely (being contributed back to a future
version of Shapely), and is used in element-wise spatial operations and for
spatial index in e.g. ``sjoin`` (#1343, #1401, #1421, #1427, #1428). See the
[installation docs](https://geopandas.readthedocs.io/en/latest/install.html#using-the-optional-pygeos-dependency)
for more info and how to enable it.
New features and improvements:
- IO enhancements:
- New ``GeoDataFrame.to_postgis()`` method to write to PostGIS database (#1248).
- New Apache Parquet and Feather file format support (#1180, #1435)
- Allow appending to files with ``GeoDataFrame.to_file`` (#1229).
- Add support for the ``ignore_geometry`` keyword in ``read_file`` to only read
the attribute data. If set to True, a pandas DataFrame without geometry is
returned (#1383).
- ``geopandas.read_file`` now supports reading from file-like objects (#1329).
- ``GeoDataFrame.to_file`` now supports specifying the CRS to write to the file
(#802). By default it still uses the CRS of the GeoDataFrame.
- New ``chunksize`` keyword in ``geopandas.read_postgis`` to read a query in
chunks (#1123).
- Improvements related to geometry columns and CRS:
- Any column of the GeoDataFrame that has a "geometry" dtype is now returned
as a GeoSeries. This means that when having multiple geometry columns, not
only the "active" geometry column is returned as a GeoSeries, but also
accessing another geometry column (``gdf["other_geom_column"]``) gives a
GeoSeries (#1336).
- Multiple geometry columns in a GeoDataFrame can now each have a different
CRS. The global ``gdf.crs`` attribute continues to returns the CRS of the
"active" geometry column. The CRS of other geometry columns can be accessed
from the column itself (eg ``gdf["other_geom_column"].crs``) (#1339).
- New ``set_crs()`` method on GeoDataFrame/GeoSeries to set the CRS of naive
geometries (#747).
- Improvements related to plotting:
- The y-axis is now scaled depending on the center of the plot when using a
geographic CRS, instead of using an equal aspect ratio (#1290).
- When passing a column of categorical dtype to the ``column=`` keyword of the
GeoDataFrame ``plot()``, we now honor all categories and its order (#1483).
In addition, a new ``categories`` keyword allows to specify all categories
and their order otherwise (#1173).
- For choropleths using a classification scheme (using ``scheme=``), the
``legend_kwds`` accept two new keywords to control the formatting of the
legend: ``fmt`` with a format string for the bin edges (#1253), and ``labels``
to pass fully custom class labels (#1302).
- New ``covers()`` and ``covered_by()`` methods on GeoSeries/GeoDataFrame for the
equivalent spatial predicates (#1460, #1462).
- GeoPandas now warns when using distance-based methods with data in a
geographic projection (#1378).
Deprecations:
- When constructing a GeoSeries or GeoDataFrame from data that already has a
CRS, a deprecation warning is raised when both CRS don't match, and in the
future an error will be raised in such a case. You can use the new ``set_crs``
method to override an existing CRS. See
[the docs](https://geopandas.readthedocs.io/en/latest/projections.html#projection-for-multiple-geometry-columns).
- The helper functions in the ``geopandas.plotting`` module are deprecated for
public usage (#656).
- The ``geopandas.io`` functions are deprecated, use the top-level ``read_file`` and
``to_file`` instead (#1407).
- The set operators (``&``, ``|``, ``^``, ``-``) are deprecated, use the
``intersection()``, ``union()``, ``symmetric_difference()``, ``difference()`` methods
instead (#1255).
- The ``sindex`` for empty dataframe will in the future return an empty spatial
index instead of ``None`` (#1438).
- The ``objects`` keyword in the ``intersection`` method of the spatial index
returned by the ``sindex`` attribute is deprecated and will be removed in the
future (#1440).
Bug fixes:
- Fix the ``total_bounds()`` method to ignore missing and empty geometries (#1312).
- Fix ``geopandas.clip`` when masking with non-overlapping area resulting in an
empty GeoDataFrame (#1309, #1365).
- Fix error in ``geopandas.sjoin`` when joining on an empty geometry column (#1318).
- CRS related fixes: ``pandas.concat`` preserves CRS when concatenating GeoSeries
objects (#1340), preserve the CRS in ``geopandas.clip`` (#1362) and in
``GeoDataFrame.astype`` (#1366).
- Fix bug in ``GeoDataFrame.explode()`` when 'level_1' is one of the column names
(#1445).
- Better error message when rtree is not installed (#1425).
- Fix bug in ``GeoSeries.equals()`` (#1451).
- Fix plotting of multi-part geometries with additional style keywords (#1385).
And we now have a [Code of Conduct](https://github.com/geopandas/geopandas/blob/main/CODE_OF_CONDUCT.md)!
GeoPandas 0.8.0 is the last release to support Python 3.5. The next release
will require Python 3.6, pandas 0.24, numpy 1.15 and shapely 1.6 or higher.
Version 0.7.0 (February 16, 2020)
---------------------------------
Support for Python 2.7 has been dropped. GeoPandas now works with Python >= 3.5.
The important API change of this release is that GeoPandas now requires
PROJ > 6 and pyproj > 2.2, and that the ``.crs`` attribute of a GeoSeries and
GeoDataFrame no longer stores the CRS information as a proj4 string or dict,
but as a ``pyproj.CRS`` object (#1101).
This gives a better user interface and integrates improvements from pyproj and
PROJ 6, but might also require some changes in your code. Check the
[migration guide](https://geopandas.readthedocs.io/en/latest/projections.html#upgrading-to-geopandas-0-7-with-pyproj-2-2-and-proj-6)
in the documentation.
Other API changes;
- The ``GeoDataFrame.to_file`` method will now also write the GeoDataFrame index
to the file, if the index is named and/or non-integer. You can use the
``index=True/False`` keyword to overwrite this default inference (#1059).
New features and improvements:
- A new ``geopandas.clip`` function to clip a GeoDataFrame to the spatial extent
of another shape (#1128).
- The ``geopandas.overlay`` function now works for all geometry types, including
points and linestrings in addition to polygons (#1110).
- The ``plot()`` method gained support for missing values (in the column that
determines the colors). By default it doesn't plot the corresponding
geometries, but using the new ``missing_kwds`` argument you can specify how to
style those geometries (#1156).
- The ``plot()`` method now also supports plotting GeometryCollection and
LinearRing objects (#1225).
- Added support for filtering with a geometry or reading a subset of the rows in
``geopandas.read_file`` (#1160).
- Added support for the new nullable integer data type of pandas in
``GeoDataFrame.to_file`` (#1220).
Bug fixes:
- ``GeoSeries.reset_index()`` now correctly results in a GeoDataFrame instead of DataFrame (#1252).
- Fixed the ``geopandas.sjoin`` function to handle MultiIndex correctly (#1159).
- Fixed the ``geopandas.sjoin`` function to preserve the index name of the left GeoDataFrame (#1150).
Version 0.6.3 (February 6, 2020)
---------------------------------
Small bug-fix release:
- Compatibility with Shapely 1.7 and pandas 1.0 (#1244).
- Fix ``GeoDataFrame.fillna`` to accept non-geometry values again when there are
no missing values in the geometry column. This should make it easier to fill
the numerical columns of the GeoDataFrame (#1279).
Version 0.6.2 (November 18, 2019)
---------------------------------
Small bug-fix release fixing a few regressions:
- Fix a regression in passing an array of RRB(A) tuples to the ``.plot()``
method (#1178, #1211).
- Fix the ``bounds`` and ``total_bounds`` attributes for empty GeoSeries, which
also fixes the repr of an empty or all-NA GeoSeries (#1184, #1195).
- Fix filtering of a GeoDataFrame to preserve the index type when ending up
with an empty result (#1190).
Version 0.6.1 (October 12, 2019)
--------------------------------
Small bug-fix release fixing a few regressions:
- Fix ``astype`` when converting to string with Multi geometries (#1145) or when converting a dataframe without geometries (#1144).
- Fix ``GeoSeries.fillna`` to accept ``np.nan`` again (#1149).
Version 0.6.0 (September 27, 2019)
----------------------------------
Important note! This will be the last release to support Python 2.7 (#1031)
API changes:
- A refactor of the internals based on the pandas ExtensionArray interface (#1000). The main user visible changes are:
- The ``.dtype`` of a GeoSeries is now a ``'geometry'`` dtype (and no longer a numpy ``object`` dtype).
- The ``.values`` of a GeoSeries now returns a custom ``GeometryArray``, and no longer a numpy array. To get back a numpy array of Shapely scalars, you can convert explicitly using ``np.asarray(..)``.
- The ``GeoSeries`` constructor now raises a warning when passed non-geometry data. Currently the constructor falls back to return a pandas ``Series``, but in the future this will raise an error (#1085).
- The missing value handling has been changed to now separate the concepts of missing geometries and empty geometries (#601, 1062). In practice this means that (see [the docs](https://geopandas.readthedocs.io/en/v0.6.0/missing_empty.html) for more details):
- ``GeoSeries.isna`` now considers only missing values, and if you want to check for empty geometries, you can use ``GeoSeries.is_empty`` (``GeoDataFrame.isna`` already only looked at missing values).
- ``GeoSeries.dropna`` now actually drops missing values (before it didn't drop either missing or empty geometries)
- ``GeoSeries.fillna`` only fills missing values (behaviour unchanged).
- ``GeoSeries.align`` uses missing values instead of empty geometries by default to fill non-matching index entries.
New features and improvements:
- Addition of a ``GeoSeries.affine_transform`` method, equivalent of Shapely's function (#1008).
- Addition of a ``GeoDataFrame.rename_geometry`` method to easily rename the active geometry column (#1053).
- Addition of ``geopandas.show_versions()`` function, which can be used to give an overview of the installed libraries in bug reports (#899).
- The ``legend_kwds`` keyword of the ``plot()`` method can now also be used to specify keywords for the color bar (#1102).
- Performance improvement in the ``sjoin()`` operation by reusing existing spatial index of the input dataframes, if available (#789).
- Updated documentation to work with latest version of geoplot and contextily (#1044, #1088).
- A new ``geopandas.options`` configuration, with currently a single option to control the display precision of the coordinates (``options.display_precision``). The default is now to show less coordinates (3 for projected and 5 for geographic coordinates), but the default can be overridden with the option.
Bug fixes:
- Also try to use ``pysal`` instead of ``mapclassify`` if available (#1082).
- The ``GeoDataFrame.astype()`` method now correctly returns a ``GeoDataFrame`` if the geometry column is preserved (#1009).
- The ``to_crs`` method now uses ``always_xy=True`` to ensure correct lon/lat order handling for pyproj>=2.2.0 (#1122).
- Fixed passing list-like colors in the ``plot()`` method in case of "multi" geometries (#1119).
- Fixed the coloring of shapes and colorbar when passing a custom ``norm`` in the ``plot()`` method (#1091, #1089).
- Fixed ``GeoDataFrame.to_file`` to preserve VFS file paths (e.g. when a "s3://" path is specified) (#1124).
- Fixed failing case in ``geopandas.sjoin`` with empty geometries (#1138).
In addition, the minimum required versions of some dependencies have been increased: GeoPandas now requires pandas >=0.23.4 and matplotlib >=2.0.1 (#1002).
Version 0.5.1 (July 11, 2019)
-----------------------------
- Compatibility with latest mapclassify version 2.1.0 (#1025).
Version 0.5.0 (April 25, 2019)
------------------------------
Improvements:
- Significant performance improvement (around 10x) for ``GeoDataFrame.iterfeatures``,
which also improves ``GeoDataFrame.to_file`` (#864).
- File IO enhancements based on Fiona 1.8:
- Support for writing bool dtype (#855) and datetime dtype, if the file format supports it (#728).
- Support for writing dataframes with multiple geometry types, if the file format allows it (e.g. GeoJSON for all types, or ESRI Shapefile for Polygon+MultiPolygon) (#827, #867, #870).
- Compatibility with pyproj >= 2 (#962).
- A new ``geopandas.points_from_xy()`` helper function to convert x and y coordinates to Point objects (#896).
- The ``buffer`` and ``interpolate`` methods now accept an array-like to specify a variable distance for each geometry (#781).
- Addition of a ``relate`` method, corresponding to the shapely method that returns the DE-9IM matrix (#853).
- Plotting improvements:
- Performance improvement in plotting by only flattening the geometries if there are actually 'Multi' geometries (#785).
- Choropleths: access to all ``mapclassify`` classification schemes and addition of the ``classification_kwds`` keyword in the ``plot`` method to specify options for the scheme (#876).
- Ability to specify a matplotlib axes object on which to plot the color bar with the ``cax`` keyword, in order to have more control over the color bar placement (#894).
- Changed the default provider in ``geopandas.tools.geocode`` from Google (now requires an API key) to Geocode.Farm (#907, #975).
Bug fixes:
- Remove the edge in the legend marker (#807).
- Fix the ``align`` method to preserve the CRS (#829).
- Fix ``geopandas.testing.assert_geodataframe_equal`` to correctly compare left and right dataframes (#810).
- Fix in choropleth mapping when the values contain missing values (#877).
- Better error message in ``sjoin`` if the input is not a GeoDataFrame (#842).
- Fix in ``read_postgis`` to handle nullable (missing) geometries (#856).
- Correctly passing through the ``parse_dates`` keyword in ``read_postgis`` to the underlying pandas method (#860).
- Fixed the shape of Antarctica in the included demo dataset 'naturalearth_lowres'
(by updating to the latest version) (#804).
Version 0.4.1 (March 5, 2019)
-----------------------------
Small bug-fix release for compatibility with the latest Fiona and PySAL
releases:
- Compatibility with Fiona 1.8: fix deprecation warning (#854).
- Compatibility with PySAL 2.0: switched to ``mapclassify`` instead of ``PySAL`` as
dependency for choropleth mapping with the ``scheme`` keyword (#872).
- Fix for new ``overlay`` implementation in case the intersection is empty (#800).
Version 0.4.0 (July 15, 2018)
-----------------------------
Improvements:
- Improved ``overlay`` function (better performance, several incorrect behaviours fixed) (#429)
- Pass keywords to control legend behavior (``legend_kwds``) to ``plot`` (#434)
- Add basic support for reading remote datasets in ``read_file`` (#531)
- Pass kwargs for ``buffer`` operation on GeoSeries (#535)
- Expose all geopy services as options in geocoding (#550)
- Faster write speeds to GeoPackage (#605)
- Permit ``read_file`` filtering with a bounding box from a GeoDataFrame (#613)
- Set CRS on GeoDataFrame returned by ``read_postgis`` (#627)
- Permit setting markersize for Point GeoSeries plots with column values (#633)
- Started an example gallery (#463, #690, #717)
- Support for plotting MultiPoints (#683)
- Testing functionality (e.g. ``assert_geodataframe_equal``) is now publicly exposed (#707)
- Add ``explode`` method to GeoDataFrame (similar to the GeoSeries method) (#671)
- Set equal aspect on active axis on multi-axis figures (#718)
- Pass array of values to column argument in ``plot`` (#770)
Bug fixes:
- Ensure that colorbars are plotted on the correct axis (#523)
- Handle plotting empty GeoDataFrame (#571)
- Save z-dimension when writing files (#652)
- Handle reading empty shapefiles (#653)
- Correct dtype for empty result of spatial operations (#685)
- Fix empty ``sjoin`` handling for pandas>=0.23 (#762)
Version 0.3.0 (August 29, 2017)
-------------------------------
Improvements:
- Improve plotting performance using ``matplotlib.collections`` (#267)
- Improve default plotting appearance. The defaults now follow the new matplotlib defaults (#318, #502, #510)
- Provide access to x/y coordinates as attributes for Point GeoSeries (#383)
- Make the NYBB dataset available through ``geopandas.datasets`` (#384)
- Enable ``sjoin`` on non-integer-index GeoDataFrames (#422)
- Add ``cx`` indexer to GeoDataFrame (#482)
- ``GeoDataFrame.from_features`` now also accepts a Feature Collection (#225, #507)
- Use index label instead of integer id in output of ``iterfeatures`` and
``to_json`` (#421)
- Return empty data frame rather than raising an error when performing a spatial join with non overlapping geodataframes (#335)
Bug fixes:
- Compatibility with shapely 1.6.0 (#512)
- Fix ``fiona.filter`` results when bbox is not None (#372)
- Fix ``dissolve`` to retain CRS (#389)
- Fix ``cx`` behavior when using index of 0 (#478)
- Fix display of lower bin in legend label of choropleth plots using a PySAL scheme (#450)
Version 0.2.0
-------------
Improvements:
- Complete overhaul of the documentation
- Addition of ``overlay`` to perform spatial overlays with polygons (#142)
- Addition of ``sjoin`` to perform spatial joins (#115, #145, #188)
- Addition of ``__geo_interface__`` that returns a python data structure
to represent the ``GeoSeries`` as a GeoJSON-like ``FeatureCollection`` (#116)
and ``iterfeatures`` method (#178)
- Addition of the ``explode`` (#146) and ``dissolve`` (#310, #311) methods.
- Addition of the ``sindex`` attribute, a Spatial Index using the optional
dependency ``rtree`` (``libspatialindex``) that can be used to speed up
certain operations such as overlays (#140, #141).
- Addition of the ``GeoSeries.cx`` coordinate indexer to slice a GeoSeries based
on a bounding box of the coordinates (#55).
- Improvements to plotting: ability to specify edge colors (#173), support for
the ``vmin``, ``vmax``, ``figsize``, ``linewidth`` keywords (#207), legends
for chloropleth plots (#210), color points by specifying a colormap (#186) or
a single color (#238).
- Larger flexibility of ``to_crs``, accepting both dicts and proj strings (#289)
- Addition of embedded example data, accessible through
``geopandas.datasets.get_path``.
API changes:
- In the ``plot`` method, the ``axes`` keyword is renamed to ``ax`` for
consistency with pandas, and the ``colormap`` keyword is renamed to ``cmap``
for consistency with matplotlib (#208, #228, #240).
Bug fixes:
- Properly handle rows with missing geometries (#139, #193).
- Fix ``GeoSeries.to_json`` (#263).
- Correctly serialize metadata when pickling (#199, #206).
- Fix ``merge`` and ``concat`` to return correct GeoDataFrame (#247, #320, #322).
geopandas-1.2.0/CITATION.cff 0000664 0000000 0000000 00000002504 15256506516 0015361 0 ustar 00root root 0000000 0000000 cff-version: "1.2.0"
message: "If you use this software, please cite the article below."
title: GeoPandas
authors:
- family-names: Fleischmann
given-names: Martin
orcid: "https://orcid.org/0000-0003-3319-3366"
- family-names: "Van den Bossche"
given-names: Joris
orcid: "https://orcid.org/0000-0003-3284-2977"
- family-names: Jordahl
given-names: Kelsey
- family-names: Richards
given-names: "Matthew John"
- family-names: McBride
given-names: James
- family-names: Wasserman
given-names: Jacob
- family-names: Ward
given-names: Brendan
- family-names: Wolf
given-names: "Levi John"
preferred-citation:
type: article
title: "GeoPandas: Fundamental Data Structures for Vector Spatial Data in Python"
authors:
- family-names: Fleischmann
given-names: Martin
- family-names: "Van Den Bossche"
given-names: Joris
- family-names: Jordahl
given-names: Kelsey
- family-names: Richards
given-names: "Matthew John"
- family-names: McBride
given-names: James
- family-names: Wasserman
given-names: Jacob
- family-names: Ward
given-names: Brendan
- family-names: Wolf
given-names: "Levi John"
year: 2026
month: 12
journal: "Computers, Environment and Urban Systems"
volume: 130
start: 102495
issn: "0198-9715"
doi: 10.1016/j.compenvurbsys.2026.102495
languages:
- en
geopandas-1.2.0/CITATION.md 0000664 0000000 0000000 00000002124 15256506516 0015221 0 ustar 00root root 0000000 0000000 To cite GeoPandas please use the following
[software paper](https://doi.org/10.1016/j.compenvurbsys.2026.102495) published in the
Computers, Environment and Urban Systems.
> Fleischmann, M., Van den Bossche, J., Jordahl, K., Richards, M. J., McBride, J.,
> Wasserman, J., Ward, B., & Wolf, L. J. (2026). GeoPandas: Fundamental data structures
> for vector spatial data in Python. _Computers, Environment and Urban Systems_, 130,
> 102495. https://doi.org/10.1016/j.compenvurbsys.2026.102495
BibTeX:
```bibtex
@article{fleischmann2026GeoPandas,
title = {{{GeoPandas}}: {{Fundamental}} Data Structures for Vector Spatial Data in {{Python}}},
shorttitle = {{{GeoPandas}}},
author = {Fleischmann, Martin and Van den Bossche, Joris and Jordahl, Kelsey and Richards, Matthew John and McBride, James and Wasserman, Jacob and Ward, Brendan and Wolf, Levi John},
year = 2026,
month = dec,
journal = {Computers, Environment and Urban Systems},
volume = {130},
pages = {102495},
issn = {01989715},
doi = {10.1016/j.compenvurbsys.2026.102495},
urldate = {2026-08-01},
langid = {english},
}
``` geopandas-1.2.0/CODE_OF_CONDUCT.md 0000664 0000000 0000000 00000003244 15256506516 0016270 0 ustar 00root root 0000000 0000000 # NumFOCUS Code of Conduct
You can find the whole document here [https://numfocus.org/code-of-conduct](https://numfocus.org/code-of-conduct).
## The short version
NumFOCUS is dedicated to providing a harassment-free community for everyone, regardless of gender, sexual orientation, gender identity and expression, disability, physical appearance, body size, race, or religion. We do not tolerate harassment of community members in any form.
Be kind to others. Do not insult or put down others. Behave professionally. Remember that harassment and sexist, racist, or exclusionary jokes are not appropriate for NumFOCUS.
All communication should be appropriate for a professional audience including people of many different backgrounds. Sexual language and imagery is not appropriate.
Thank you for helping make this a welcoming, friendly community for all.
## Long version
You can find the long version of the Code of Conduct on the NumFOCUS website [https://numfocus.org/code-of-conduct](https://numfocus.org/code-of-conduct)
## How to report
If you feel that the Code of Conduct has been violated, feel free to submit a report, by using the form: [NumFOCUS Code of Conduct Reporting Form](https://forms.monday.com/forms/f130e8cddb99568fa86cf077b8912a60?r=use1)Â Â
## Who will receive your report
Your report will be received and handled by NumFOCUS Code of Conduct Working Group; trained, and experienced contributors with diverse backgrounds. The group is making decisions independently from the project, PyData, NumFOCUS or any other organization.
You can learn more about the current group members, as well as the reporting procedure **[HERE](https://numfocus.org/code-of-conduct)**
geopandas-1.2.0/CONTRIBUTING.md 0000664 0000000 0000000 00000037464 15256506516 0015735 0 ustar 00root root 0000000 0000000 # Contributing to GeoPandas
(Contribution guidelines largely copied from
[pandas](http://pandas.pydata.org/pandas-docs/stable/development/contributing.html))
## Overview
Contributions to GeoPandas are very welcome. They are likely to be accepted more quickly
if they follow these guidelines.
At this stage of GeoPandas development, the priorities are to define a simple, usable,
and stable API and to have clean, maintainable, readable code. Performance matters, but
not at the expense of those goals.
In general, GeoPandas follows the conventions of the pandas project where applicable.
In particular, when submitting a pull request:
- All existing tests should pass. Please make sure that the test suite passes, both
locally and on [GitHub Actions](https://github.com/geopandas/geopandas/actions).
Status on GHA will be visible on a pull request. GHA are automatically enabled on your
own fork as well. To trigger a check, make a PR to your own fork.
- New functionality should include tests. Please write reasonable tests for your code
and make sure that they pass on your pull request.
- Classes, methods, functions, etc. should have docstrings. The first line of a
docstring should be a standalone summary. Parameters and return values should be
documented explicitly.
- Follow PEP 8 when possible. We use [ruff](https://docs.astral.sh/ruff/) to ensure a
consistent code format throughout the project. For more details see the section _Style
Guide_ below.
- Imports should be grouped with standard library imports first, 3rd-party libraries
next, and GeoPandas imports third. Within each grouping, imports should be
alphabetized. Always use absolute imports when possible, and explicit relative imports
for local imports when necessary in tests.
- GeoPandas supports Python 3.10+ only.
- Unless your PR implements minor changes or internal work only, make sure it contains a
note describing the changes in the `CHANGELOG.md` file.
### Seven Steps for Contributing
There are seven basic steps to contributing to GeoPandas:
1. Fork the GeoPandas git repository
2. Create a development environment
3. Install GeoPandas dependencies
4. Make a `development` build of GeoPandas
5. Make changes to code and add tests
6. Update the documentation
7. Submit a Pull Request
Each of these 7 steps is detailed below.
## 1) Forking the GeoPandas repository using Git
To the new user, working with Git is one of the more daunting aspects of contributing to
GeoPandas. It can very quickly become overwhelming, but sticking to the guidelines below
will help keep the process straightforward and mostly trouble free. As always, if you
are having difficulties please feel free to ask for help.
The code is hosted on [GitHub](https://github.com/geopandas/geopandas). To contribute
you will need to sign up for a [free GitHub account](https://github.com/signup/free). We
use [Git](http://git-scm.com/) for version control to allow many people to work together
on the project.
Some great resources for learning Git:
- Software Carpentry\'s [Git Tutorial](http://swcarpentry.github.io/git-novice/)
- [Atlassian](https://www.atlassian.com/git/tutorials/what-is-version-control)
- the [GitHub help pages](http://help.github.com/).
- Matthew Brett\'s [Pydagogue](https://matthew-brett.github.io/pydagogue/).
### Getting started with Git
[GitHub has instructions](https://github.com/git-guides/install-git) for installing
git, setting up your SSH key, and configuring git. All these steps need to be completed
before you can work seamlessly between your local repository and GitHub.
### Forking
You will need your own fork to work on the code. Go to the [GeoPandas project
page](https://github.com/geopandas/geopandas) and hit the `Fork` button. You will want
to clone your fork to your machine:
git clone git@github.com:your-user-name/geopandas.git geopandas-yourname
cd geopandas-yourname
git remote add upstream git://github.com/geopandas/geopandas.git
This creates the directory `geopandas-yourname` and connects your repository to the
upstream (main project) GeoPandas repository.
The testing suite will run automatically on GitHub Actions once your pull request is
submitted. The test suite will also automatically run on your branch so you can check it
prior to submitting the pull request.
### Creating a branch
You want your main branch to reflect only production-ready code, so create a feature
branch for making your changes. For example:
git branch shiny-new-feature
git checkout shiny-new-feature
The above can be simplified to:
git checkout -b shiny-new-feature
This changes your working directory to the shiny-new-feature branch. Keep any changes in
this branch specific to one bug or feature so it is clear what the branch brings to
GeoPandas. You can have many shiny-new-features and switch in between them using the git
checkout command.
To update this branch, you need to retrieve the changes from the main branch:
git fetch upstream
git rebase upstream/main
This will replay your commits on top of the latest GeoPandas git main. If this leads to
merge conflicts, you must resolve these before submitting your pull request. If you have
uncommitted changes, you will need to `stash` them prior to updating. This will
effectively store your changes and they can be reapplied after updating.
## 2) Creating a development environment
A development environment is a virtual space where you can keep an independent
installation of GeoPandas. This makes it easy to keep both a stable version of python in
one place you use for work, and a development version (which you may break while playing
with code) in another.
An easy way to create a GeoPandas development environment is as follows:
- Install either [Anaconda or miniconda](https://www.anaconda.com/docs/getting-started/concepts/anaconda-or-miniconda)
- Make sure that you have cloned the repository
- `cd` to the `geopandas` source directory
### Using the provided environment
GeoPandas provides an environment which includes the required dependencies for
development. The environment file is located in the top level of the repo and is named
`environment-dev.yml`. You can create this environment by navigating to the the
`geopandas` source directory and running:
conda env create -f environment-dev.yml
This will create a new conda environment named `geopandas-dev`.
### Creating the environment manually
Alternatively, it is possible to create a development environment manually. To do this,
tell conda to create a new environment named `geopandas-dev`, or any other name you
would like for this environment, by running:
conda create -n geopandas-dev python
This will create the new environment, and not touch any of your existing environments,
nor any existing python installation.
### Working with the environment
To work in this environment, you need to `activate` it. The instructions below should
work for both Windows, Mac and Linux:
conda activate geopandas-dev
Once your environment is activated, you will see a confirmation message to indicate you
are in the new development environment.
To view your environments:
conda info -e
To return to you home root environment:
conda deactivate
See the full conda docs [here](http://conda.pydata.org/docs).
At this point you can easily do a *development* install, as detailed in the next
sections.
## 3) Installing Dependencies
To run GeoPandas in a development environment, you must first install the dependencies
of GeoPandas. If you used the provided environment in section 2, skip this step and
continue to section 4. If you created the environment manually, we suggest installing
dependencies using the following commands (executed after your development environment
has been activated):
conda install -c conda-forge pandas pyogrio shapely pyproj pytest
This should install all necessary dependencies.
## 4) Making a development build
Once dependencies are in place, make an in-place build by navigating to the git clone of
the GeoPandas repository and running:
python -m pip install -e .
## 5) Making changes and writing tests
GeoPandas is serious about testing and strongly encourages contributors to embrace
[test-driven development (TDD)](http://en.wikipedia.org/wiki/Test-driven_development).
This development process "relies on the repetition of a very short development cycle:
first the developer writes an (initially failing) automated test case that defines a
desired improvement or new function, then produces the minimum amount of code to pass
that test." So, before actually writing any code, you should write your tests. Often
the test can be taken from the original GitHub issue. However, it is always worth
considering additional use cases and writing corresponding tests.
Adding tests is one of the most common requests after code is pushed to GeoPandas.
Therefore, it is worth getting in the habit of writing tests ahead of time so this is
never an issue.
GeoPandas uses the [pytest testing system](http://doc.pytest.org/en/latest/) and the
convenient extensions in
[numpy.testing](http://docs.scipy.org/doc/numpy/reference/routines.testing.html).
### Writing tests
All tests should go into each module's `tests` sub-directory. This folder contains many current
examples of tests, and we suggest looking to these for inspiration.
The `geopandas.testing` module has some special `assert` functions that make it easier to make
statements about whether GeoSeries or GeoDataFrame objects are equivalent. The easiest
way to verify that your code is correct is to explicitly construct the result you
expect, then compare the actual result to the expected correct result, using eg the
function `assert_geoseries_equal`.
### Running the test suite
The tests can then be run directly inside your Git clone (without having to install
GeoPandas) by typing:
pytest
## 6) Updating the Documentation
GeoPandas documentation resides in the `doc` folder. Changes to the docs are made by
modifying the appropriate file in the `source` folder within `doc`. GeoPandas docs use
mixture of reStructuredText syntax for `rst` files, [which is explained
here](http://www.sphinx-doc.org/en/stable/rest.html#rst-primer) and MyST syntax for `md`
files [explained here](https://myst-parser.readthedocs.io/en/latest/index.html). The
docstrings follow the [Numpy Docstring
standard](https://numpydoc.readthedocs.io/en/latest/format.html#docstring-standard).
Some pages and examples are Jupyter notebooks converted to docs using
[nbsphinx](https://nbsphinx.readthedocs.io/). Jupyter notebooks should be stored without
the output.
We highly encourage you to follow the [Google developer documentation style
guide](https://developers.google.com/style/highlights) when updating or creating new
documentation.
Once you have made your changes, you may try if they render correctly by building the
docs using sphinx. To do so, you can navigate to the `doc` folder:
cd doc
and type:
make html
The resulting html pages will be located in `doc/build/html`.
In case of any errors, you can try to use `make html` within a new environment based on
environment.yml specification in the `doc` folder. You may need to register Jupyter
kernel as `geopandas_docs`. Using conda:
cd doc
conda env create -f environment.yml
conda activate geopandas_docs
python -m ipykernel install --user --name geopandas_docs
make html
For minor updates, you can skip the `make html` part as reStructuredText and MyST syntax
are usually quite straightforward.
## 7) Submitting a Pull Request
Once you've made changes and pushed them to your forked repository, you then submit a
pull request to have them integrated into the GeoPandas code base.
You can find a pull request (or PR) tutorial in the [GitHub's Help
Docs](https://help.github.com/articles/using-pull-requests/).
## Style Guide & Linting
GeoPandas follows the [PEP8](http://www.python.org/dev/peps/pep-0008/) standard and uses
[ruff](https://docs.astral.sh/ruff/) to ensure a consistent code format throughout the
project.
Continuous Integration (GitHub Actions) will run those tools and report any stylistic
errors in your code. Therefore, it is helpful before submitting code to run the check
yourself:
ruff format geopandas
ruff check geopandas
git diff upstream/main -u -- "*.py" | ruff check .
to auto-format your code. Additionally, many editors have plugins that will apply `ruff`
as you edit files.
Optionally (but recommended), you can setup [pre-commit hooks](https://pre-commit.com/)
to automatically run `ruff` when you make a git commit. If you did not use the provided
development environment in `environment-dev.yml`, you must first install `pre-commit`:
$ python -m pip install pre-commit
From the root of the geopandas repository, you should then install the `pre-commit`
included in GeoPandas:
$ pre-commit install
Then `ruff` will be run automatically each time you commit changes. You can skip these
checks with `git commit --no-verify`.
## Commit message conventions
Commit your changes to your local repository with an explanatory message. GeoPandas uses
the pandas convention for commit message prefixes and layout. Here are some common
prefixes along with general guidelines for when to use them:
- ENH: Enhancement, new functionality
- BUG: Bug fix
- DOC: Additions/updates to documentation
- TST: Additions/updates to tests
- BLD: Updates to the build process/scripts
- PERF: Performance improvement
- TYP: Type annotations
- CLN: Code cleanup
The following defines how a commit message should be structured. Please refer to the
relevant GitHub issues in your commit message using GH1234 or #1234. Either style is
fine, but the former is generally preferred:
- a subject line with < 80 characters.
- One blank line.
- Optionally, a commit message body.
Now you can commit your changes in your local repository:
git commit -m
## AI Assisted Contributions
We recognise that AI coding assistants are now a regular part of many developers\'
workflows. However, AI-generated PRs can sometimes lead to undesirable additional
maintainer burden. PRs that appear to be fully generated by AI with little to no
engagement from the author may be closed without further review.
Remember that maintainers volunteer to support GeoPandas, and low quality AI generated
Pull Requests are not an effective use of that precious time - a contribution should be
worth more to the project than the time it takes to review it. Ultimately, the person
submitting an issue or PR is responsible for its content, regardless of whether AI tools
were used in its creation and they must ensure the contribution meets the GeoPandas
guidelines.
We are not opposed to the use of AI tools in writing PRs, but require the following:
- Only submit a PR if you are able to debug and own the changes yourself - review all
generated code to understand every detail
- Match the style and conventions used in the rest of the codebase, including PR titles
and descriptions
- Be upfront about AI usage and summarise what was AI-generated
- If there are parts you don\'t fully understand, leave comments on your own PR
explaining what steps you took to verify correctness
- Watch for AI\'s tendency to generate overly verbose comments, unnecessary test cases,
and incorrect fixes
- Break down large PRs into smaller ones to make review easier
- AI agents should never tag or ping maintainers
- AI generated PRs will not be accepted unless they resolve an existing issue where
there is consensus on the solution to implement. If no issue exists, open a new issue
and engage to gather consensus.
When interacting with developers (forums, discussions, issues, pull requests, etc.) do
not use AI to speak for you, except for translation or grammar editing. If the
developers want to chat with a chatbot, they can do so themselves. Human-to-human
communication is essential for an open source community to thrive.
This policy is adapted in part from the Apache Arrow AI-generated code Contribution
guidelines.
geopandas-1.2.0/LICENSE.txt 0000664 0000000 0000000 00000002732 15256506516 0015315 0 ustar 00root root 0000000 0000000 Copyright (c) 2013-2022, GeoPandas developers.
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
* Neither the name of GeoPandas nor the names of its contributors may
be used to endorse or promote products derived from this software without
specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
geopandas-1.2.0/README.md 0000664 0000000 0000000 00000020142 15256506516 0014744 0 ustar 00root root 0000000 0000000 [](https://pypi.python.org/pypi/geopandas/)
[](https://github.com/geopandas/geopandas/actions?query=workflow%3ATests)
[](https://codecov.io/gh/geopandas/geopandas)
[](https://gitter.im/geopandas/geopandas?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
[](https://mybinder.org/v2/gh/geopandas/geopandas/main)
[](https://zenodo.org/badge/latestdoi/11002815)
[](https://numfocus.org)
GeoPandas
---------
Python tools for geographic data
Introduction
------------
GeoPandas is a project to add support for geographic data to
[pandas](http://pandas.pydata.org) objects. It currently implements
`GeoSeries` and `GeoDataFrame` types which are subclasses of
`pandas.Series` and `pandas.DataFrame` respectively. GeoPandas
objects can act on [shapely](http://shapely.readthedocs.io/en/latest/)
geometry objects and perform geometric operations.
GeoPandas geometry operations are cartesian. The coordinate reference
system (crs) can be stored as an attribute on an object, and is
automatically set when loading from a file. Objects may be
transformed to new coordinate systems with the `to_crs()` method.
There is currently no enforcement of like coordinates for operations,
but that may change in the future.
Documentation is available at [geopandas.org](http://geopandas.org)
(current release) and
[Read the Docs](http://geopandas.readthedocs.io/en/latest/)
(release and development versions).
[//]: # (numfocus-fiscal-sponsor-attribution)
The GeoPandas project uses an [open governance model](https://github.com/geopandas/governance/blob/main/Governance.md)
and is fiscally sponsored by [NumFOCUS](https://numfocus.org/). Consider making
a [tax-deductible donation](https://numfocus.org/donate-for-geopandas) to help the project
pay for developer time, professional services, travel, workshops, and a variety of other needs.
Install
--------
See the [installation docs](https://geopandas.readthedocs.io/en/latest/install.html)
for all details. GeoPandas depends on the following packages:
- ``pandas``
- ``shapely``
- ``pyogrio``
- ``pyproj``
- ``packaging``
Further, ``matplotlib`` is an optional dependency, required for plotting.
Those packages depend on several low-level libraries for geospatial analysis, which can be a challenge to install. Therefore, we recommend to install GeoPandas using the [conda package manager](https://conda.io/en/latest/). See the [installation docs](https://geopandas.readthedocs.io/en/latest/install.html) for more details.
Get in touch
------------
- Ask usage questions ("How do I?") on [StackOverflow](https://stackoverflow.com/questions/tagged/geopandas) or [GIS StackExchange](https://gis.stackexchange.com/questions/tagged/geopandas).
- Get involved in [discussions on GitHub](https://github.com/geopandas/geopandas/discussions)
- Report bugs, suggest features or view the source code [on GitHub](https://github.com/geopandas/geopandas).
- For a quick question about a bug report or feature request, or Pull Request, head over to the [gitter channel](https://gitter.im/geopandas/geopandas).
- For less well defined questions or ideas, or to announce other projects of interest to GeoPandas users, ... use the [mailing list](https://groups.google.com/forum/#!forum/geopandas).
Examples
--------
>>> import geopandas
>>> from shapely.geometry import Polygon
>>> p1 = Polygon([(0, 0), (1, 0), (1, 1)])
>>> p2 = Polygon([(0, 0), (1, 0), (1, 1), (0, 1)])
>>> p3 = Polygon([(2, 0), (3, 0), (3, 1), (2, 1)])
>>> g = geopandas.GeoSeries([p1, p2, p3])
>>> g
0 POLYGON ((0 0, 1 0, 1 1, 0 0))
1 POLYGON ((0 0, 1 0, 1 1, 0 1, 0 0))
2 POLYGON ((2 0, 3 0, 3 1, 2 1, 2 0))
dtype: geometry

Some geographic operations return normal pandas objects. The `area` property of a `GeoSeries` will return a `pandas.Series` containing the area of each item in the `GeoSeries`:
>>> print(g.area)
0 0.5
1 1.0
2 1.0
dtype: float64
Other operations return GeoPandas objects:
>>> g.buffer(0.5)
0 POLYGON ((-0.3535533905932737 0.35355339059327...
1 POLYGON ((-0.5 0, -0.5 1, -0.4975923633360985 ...
2 POLYGON ((1.5 0, 1.5 1, 1.502407636663901 1.04...
dtype: geometry

GeoPandas objects also know how to plot themselves. GeoPandas uses
[matplotlib](http://matplotlib.org) for plotting. To generate a plot of a
`GeoSeries`, use:
>>> g.plot()
GeoPandas also implements alternate constructors that can read any data format recognized by [pyogrio](http://pyogrio.readthedocs.io/en/latest/). To read a zip file containing an ESRI shapefile with the [boroughs boundaries of New York City](https://data.cityofnewyork.us/City-Government/Borough-Boundaries/tqmj-j8zm) (the example can be fetched using the [`geodatasets`](https://geodatasets.readthedocs.io/en/latest/) package):
>>> import geodatasets
>>> nybb_path = geodatasets.get_path('nybb')
>>> boros = geopandas.read_file(nybb_path)
>>> boros = boros.set_index('BoroCode').sort_index()
>>> boros
BoroName Shape_Leng Shape_Area \
BoroCode
1 Manhattan 359299.096471 6.364715e+08
2 Bronx 464392.991824 1.186925e+09
3 Brooklyn 741080.523166 1.937479e+09
4 Queens 896344.047763 3.045213e+09
5 Staten Island 330470.010332 1.623820e+09
geometry
BoroCode
1 MULTIPOLYGON (((981219.0557861328 188655.31579...
2 MULTIPOLYGON (((1012821.805786133 229228.26458...
3 MULTIPOLYGON (((1021176.479003906 151374.79699...
4 MULTIPOLYGON (((1029606.076599121 156073.81420...
5 MULTIPOLYGON (((970217.0223999023 145643.33221...

>>> boros['geometry'].convex_hull
BoroCode
1 POLYGON ((977855.4451904297 188082.3223876953,...
2 POLYGON ((1017949.977600098 225426.8845825195,...
3 POLYGON ((988872.8212280273 146772.0317993164,...
4 POLYGON ((1000721.531799316 136681.776184082, ...
5 POLYGON ((915517.6877458114 120121.8812543372,...
dtype: geometry

How to cite
-----------
To cite GeoPandas please use the following [software paper](https://doi.org/10.1016/j.compenvurbsys.2026.102495) published in the Computers, Environment and Urban Systems.
> Fleischmann, M., Van den Bossche, J., Jordahl, K., Richards, M. J., McBride, J., Wasserman, J., Ward, B., & Wolf, L. J. (2026). GeoPandas: Fundamental data structures for vector spatial data in Python. _Computers, Environment and Urban Systems_, 130, 102495. https://doi.org/10.1016/j.compenvurbsys.2026.102495
BibTeX:
```bibtex
@article{fleischmann2026GeoPandas,
title = {{{GeoPandas}}: {{Fundamental}} Data Structures for Vector Spatial Data in {{Python}}},
shorttitle = {{{GeoPandas}}},
author = {Fleischmann, Martin and Van den Bossche, Joris and Jordahl, Kelsey and Richards, Matthew John and McBride, James and Wasserman, Jacob and Ward, Brendan and Wolf, Levi John},
year = 2026,
month = dec,
journal = {Computers, Environment and Urban Systems},
volume = {130},
pages = {102495},
issn = {01989715},
doi = {10.1016/j.compenvurbsys.2026.102495},
urldate = {2026-08-01},
langid = {english},
}
``` geopandas-1.2.0/asv.conf.json 0000664 0000000 0000000 00000014027 15256506516 0016102 0 ustar 00root root 0000000 0000000 {
// The version of the config file format. Do not change, unless
// you know what you are doing.
"version": 1,
// The name of the project being benchmarked
"project": "geopandas",
// The project's homepage
"project_url": "http://geopandas.org/",
// The URL or local path of the source code repository for the
// project being benchmarked
"repo": ".",
// List of branches to benchmark. If not provided, defaults to "master"
// (for git) or "default" (for mercurial).
// "branches": ["master"], // for git
// "branches": ["default"], // for mercurial
// The DVCS being used. If not set, it will be automatically
// determined from "repo" by looking at the protocol in the URL
// (if remote), or by looking for special directories, such as
// ".git" (if local).
// "dvcs": "git",
// The tool to use to create environments. May be "conda",
// "virtualenv" or other value depending on the plugins in use.
// If missing or the empty string, the tool will be automatically
// determined by looking for tools on the PATH environment
// variable.
"environment_type": "conda",
"conda_channels": ["conda-forge", "defaults"],
// timeout in seconds for installing any dependencies in environment
// defaults to 10 min
//"install_timeout": 600,
// the base URL to show a commit for the project.
"show_commit_url": "http://github.com/geopandas/geopandas/commit/",
// The Pythons you'd like to test against. If not provided, defaults
// to the current version of Python used to run `asv`.
// "pythons": ["2.7", "3.3"],
// The matrix of dependencies to test. Each key is the name of a
// package (in PyPI) and the values are version numbers. An empty
// list or empty string indicates to just test against the default
// (latest) version. null indicates that the package is to not be
// installed. If the package to be tested is only available from
// PyPi, and the 'environment_type' is conda, then you can preface
// the package name by 'pip+', and the package will be installed via
// pip (with all the conda available packages installed first,
// followed by the pip installed packages).
//
"matrix": {
"pandas": [],
"shapely": [],
"pyogrio": [],
"pyproj": [],
"matplotlib": [],
},
// "numpy": ["1.6", "1.7"],
// "six": ["", null], // test with and without six installed
// "pip+emcee": [""], // emcee is only available for install with pip.
// },
// Combinations of libraries/python versions can be excluded/included
// from the set to test. Each entry is a dictionary containing additional
// key-value pairs to include/exclude.
//
// An exclude entry excludes entries where all values match. The
// values are regexps that should match the whole string.
//
// An include entry adds an environment. Only the packages listed
// are installed. The 'python' key is required. The exclude rules
// do not apply to includes.
//
// In addition to package names, the following keys are available:
//
// - python
// Python version, as in the *pythons* variable above.
// - environment_type
// Environment type, as above.
// - sys_platform
// Platform, as in sys.platform. Possible values for the common
// cases: 'linux2', 'win32', 'cygwin', 'darwin'.
//
// "exclude": [
// {"python": "3.2", "sys_platform": "win32"}, // skip py3.2 on windows
// {"environment_type": "conda", "six": null}, // don't run without six on conda
// ],
//
// "include": [
// // additional env for python2.7
// {"python": "2.7", "numpy": "1.8"},
// // additional env if run on windows+conda
// {"platform": "win32", "environment_type": "conda", "python": "2.7", "libpython": ""},
// ],
// The directory (relative to the current directory) that benchmarks are
// stored in. If not provided, defaults to "benchmarks"
// "benchmark_dir": "benchmarks",
// The directory (relative to the current directory) to cache the Python
// environments in. If not provided, defaults to "env"
"env_dir": ".asv/env",
// The directory (relative to the current directory) that raw benchmark
// results are stored in. If not provided, defaults to "results".
"results_dir": ".asv/results",
// The directory (relative to the current directory) that the html tree
// should be written to. If not provided, defaults to "html".
"html_dir": ".asv/html",
// The number of characters to retain in the commit hashes.
// "hash_length": 8,
// `asv` will cache wheels of the recent builds in each
// environment, making them faster to install next time. This is
// number of builds to keep, per environment.
// "wheel_cache_size": 0
// The commits after which the regression search in `asv publish`
// should start looking for regressions. Dictionary whose keys are
// regexps matching to benchmark names, and values corresponding to
// the commit (exclusive) after which to start looking for
// regressions. The default is to start from the first commit
// with results. If the commit is `null`, regression detection is
// skipped for the matching benchmark.
//
// "regressions_first_commits": {
// "some_benchmark": "352cdf", // Consider regressions only after this commit
// "another_benchmark": null, // Skip regression detection altogether
// }
// The thresholds for relative change in results, after which `asv
// publish` starts reporting regressions. Dictionary of the same
// form as in ``regressions_first_commits``, with values
// indicating the thresholds. If multiple entries match, the
// maximum is taken. If no entry matches, the default is 5%.
//
// "regressions_thresholds": {
// "some_benchmark": 0.01, // Threshold of 1%
// "another_benchmark": 0.5, // Threshold of 50%
// }
}
geopandas-1.2.0/benchmarks/ 0000775 0000000 0000000 00000000000 15256506516 0015603 5 ustar 00root root 0000000 0000000 geopandas-1.2.0/benchmarks/__init__.py 0000664 0000000 0000000 00000000001 15256506516 0017703 0 ustar 00root root 0000000 0000000
geopandas-1.2.0/benchmarks/clip.py 0000664 0000000 0000000 00000001335 15256506516 0017106 0 ustar 00root root 0000000 0000000 from geopandas import read_file, clip
from shapely.geometry import box
try:
from geopandas.tests.util import _NATURALEARTH_LOWRES
from geopandas.tests.util import _NATURALEARTH_CITIES
except:
# geopandas <=0.14 compat
from geopandas.datasets import get_path
_NATURALEARTH_LOWRES = get_path("naturalearth_lowres")
_NATURALEARTH_CITIES = get_path("naturalearth_cities")
class Bench:
def setup(self, *args):
world = read_file(_NATURALEARTH_LOWRES)
capitals = read_file(_NATURALEARTH_CITIES)
self.bounds = [box(*geom.bounds) for geom in world.geometry]
self.points = capitals
def time_clip(self):
for bound in self.bounds:
clip(self.points, bound)
geopandas-1.2.0/benchmarks/geom_methods.py 0000664 0000000 0000000 00000010174 15256506516 0020632 0 ustar 00root root 0000000 0000000 import random
import numpy as np
from geopandas import GeoSeries
from shapely.geometry import Point, Polygon, MultiPolygon
def with_attributes(**attrs):
def decorator(func):
for key, value in attrs.items():
setattr(func, key, value)
return func
return decorator
class Bench:
def setup(self, *args):
self.points = GeoSeries([Point(i, i) for i in range(100000)])
triangles = GeoSeries(
[
Polygon([(random.random(), random.random()) for _ in range(3)])
for _ in range(1000)
]
)
triangles2 = triangles.copy().iloc[np.random.choice(1000, 1000)]
triangles3 = GeoSeries(
[
Polygon([(random.random(), random.random()) for _ in range(3)])
for _ in range(10000)
]
)
triangles4 = GeoSeries(
[
MultiPolygon(
[Polygon([(random.random(), random.random()) for _ in range(3)])]
)
for _ in range(10000)
]
)
triangle = Polygon([(random.random(), random.random()) for _ in range(3)])
self.triangles, self.triangles2 = triangles, triangles2
self.triangles_big = triangles3
self.multi_triangles = triangles4
self.triangle = triangle
@with_attributes(
param_names=["op"],
params=[
(
"contains",
"crosses",
"disjoint",
"intersects",
"overlaps",
"touches",
"within",
"geom_equals",
"geom_equals_exact",
)
],
)
def time_binary_predicate(self, op):
getattr(self.triangles, op)(self.triangle)
@with_attributes(
param_names=["op"],
params=[
(
"contains",
"crosses",
"disjoint",
"intersects",
"overlaps",
"touches",
"within",
"geom_equals",
)
],
) # 'geom_equals_exact')])
def time_binary_predicate_vector(self, op):
getattr(self.triangles, op)(self.triangles2)
@with_attributes(param_names=["op"], params=[("distance")])
def time_binary_float(self, op):
getattr(self.triangles, op)(self.triangle)
@with_attributes(param_names=["op"], params=[("distance")])
def time_binary_float_vector(self, op):
getattr(self.triangles, op)(self.triangles2)
@with_attributes(
param_names=["op"],
params=[("difference", "symmetric_difference", "union", "intersection")],
)
def time_binary_geo(self, op):
getattr(self.triangles, op)(self.triangle)
@with_attributes(
param_names=["op"],
params=[("difference", "symmetric_difference", "union", "intersection")],
)
def time_binary_geo_vector(self, op):
getattr(self.triangles, op)(self.triangles2)
@with_attributes(
param_names=["op"], params=[("is_valid", "is_empty", "is_simple", "is_ring")]
)
def time_unary_predicate(self, op):
getattr(self.triangles, op)
@with_attributes(param_names=["op"], params=[("area", "length")])
def time_unary_float(self, op):
getattr(self.triangles_big, op)
@with_attributes(
param_names=["op"],
params=[
("boundary", "centroid", "convex_hull", "envelope", "exterior", "interiors")
],
)
def time_unary_geo(self, op):
getattr(self.triangles, op)
def time_unary_geo_representative_point(self, *args):
getattr(self.triangles, "representative_point")()
def time_geom_type(self, *args):
self.triangles_big.geom_type
def time_bounds(self, *args):
self.triangles.bounds
def time_union_all(self, *args):
self.triangles.union_all()
def time_buffer(self, *args):
self.points.buffer(2)
def time_explode(self, *args):
self.multi_triangles.explode()
# TODO
# project, interpolate, affine_transform, translate, rotate, scale, skew
# cx indexer
geopandas-1.2.0/benchmarks/io.py 0000664 0000000 0000000 00000006167 15256506516 0016576 0 ustar 00root root 0000000 0000000 import os
import shutil
import tempfile
import warnings
import numpy as np
from shapely.geometry import Point
from geopandas import GeoDataFrame, GeoSeries, read_file, read_parquet, read_feather
# TEMP: hide warning from to_parquet
warnings.filterwarnings("ignore", message=".*initial implementation of Parquet.*")
format_dict = {
"ESRI Shapefile": (
".shp",
lambda gdf, filename: gdf.to_file(filename, driver="ESRI Shapefile"),
lambda filename: read_file(filename, driver="ESRI Shapefile"),
),
"GeoJSON": (
".json",
lambda gdf, filename: gdf.to_file(filename, driver="GeoJSON"),
lambda filename: read_file(filename, driver="GeoJSON"),
),
"GPKG": (
".gpkg",
lambda gdf, filename: gdf.to_file(filename, driver="GeoJSON"),
lambda filename: read_file(filename, driver="GeoJSON"),
),
"Parquet": (
".parquet",
lambda gdf, filename: gdf.to_parquet(filename),
lambda filename: read_parquet(filename),
),
"Feather": (
".feather",
lambda gdf, filename: gdf.to_feather(filename),
lambda filename: read_feather(filename),
),
}
class Bench:
params = ["ESRI Shapefile", "GeoJSON", "GPKG", "Parquet", "Feather"]
param_names = ["file_format"]
def setup(self, file_format):
self.ext, self.writer, self.reader = format_dict[file_format]
num_points = 20000
xs = np.random.rand(num_points)
ys = np.random.rand(num_points)
self.points = GeoSeries([Point(x, y) for (x, y) in zip(xs, ys)])
self.df = GeoDataFrame(
{
"geometry": self.points,
"x": xs,
"y": ys,
"s": np.zeros(num_points, dtype="object"),
}
)
self.tmpdir = tempfile.mkdtemp()
self.filename = os.path.join(self.tmpdir, "frame" + self.ext)
self.writer(self.df, self.filename)
def teardown(self, file_format):
shutil.rmtree(self.tmpdir)
class BenchFrame(Bench):
params = ["ESRI Shapefile", "GeoJSON", "GPKG", "Parquet", "Feather"]
param_names = ["file_format"]
def time_write(self, file_format):
with tempfile.TemporaryDirectory() as tmpdir:
out_filename = os.path.join(tmpdir, "frame" + self.ext)
self.writer(self.df, out_filename)
def time_read(self, file_format):
self.reader(self.filename)
class BenchSeries(Bench):
params = ["ESRI Shapefile", "GeoJSON", "GPKG"]
param_names = ["file_format"]
def setup(self, file_format):
super().setup(file_format)
self.filename_series = os.path.join(self.tmpdir, "series" + self.ext)
self.writer(self.points, self.filename_series)
def time_write_series(self, file_format):
with tempfile.TemporaryDirectory() as tmpdir:
out_filename = os.path.join(tmpdir, "series" + self.ext)
self.writer(self.points, out_filename)
def time_read_series(self, file_format):
GeoSeries.from_file(self.filename_series)
def time_read_series_from_frame(self, file_format):
GeoSeries.from_file(self.filename)
geopandas-1.2.0/benchmarks/overlay.py 0000664 0000000 0000000 00000004274 15256506516 0017645 0 ustar 00root root 0000000 0000000 from geopandas import GeoDataFrame, GeoSeries, read_file, overlay
import numpy as np
from shapely.geometry import Point, Polygon
from geopandas.tests.util import _NATURALEARTH_LOWRES
from geopandas.tests.util import _NATURALEARTH_CITIES
class Countries:
param_names = ["how"]
params = [
("intersection", "union", "identity", "symmetric_difference", "difference")
]
def setup(self, *args):
world = read_file(_NATURALEARTH_LOWRES)
capitals = read_file(_NATURALEARTH_CITIES)
countries = world[["geometry", "name"]]
countries = countries.to_crs("+init=epsg:3395")[countries.name != "Antarctica"]
capitals = capitals.to_crs("+init=epsg:3395")
capitals["geometry"] = capitals.buffer(500000)
self.countries = countries
self.capitals = capitals
def time_overlay(self, how):
overlay(self.countries, self.capitals, how=how)
class Small:
param_names = ["how"]
params = [
("intersection", "union", "identity", "symmetric_difference", "difference")
]
def setup(self, *args):
polys1 = GeoSeries(
[
Polygon([(0, 0), (2, 0), (2, 2), (0, 2)]),
Polygon([(2, 2), (4, 2), (4, 4), (2, 4)]),
]
)
polys2 = GeoSeries(
[
Polygon([(1, 1), (3, 1), (3, 3), (1, 3)]),
Polygon([(3, 3), (5, 3), (5, 5), (3, 5)]),
]
)
df1 = GeoDataFrame({"geometry": polys1, "df1": [1, 2]})
df2 = GeoDataFrame({"geometry": polys2, "df2": [1, 2]})
self.df1, self.df2 = df1, df2
def time_overlay(self, how):
overlay(self.df1, self.df2, how=how)
class ManyPoints:
param_names = ["how"]
params = [
("intersection", "union", "identity", "symmetric_difference", "difference")
]
def setup(self, *args):
points = GeoDataFrame(geometry=[Point(i, i) for i in range(1000)])
base = np.array([[0, 0], [0, 100], [100, 100], [100, 0]])
polys = GeoDataFrame(geometry=[Polygon(base + i * 100) for i in range(10)])
self.df1, self.df2 = points, polys
def time_overlay(self, how):
overlay(self.df1, self.df2, how=how)
geopandas-1.2.0/benchmarks/plotting.py 0000664 0000000 0000000 00000004471 15256506516 0020023 0 ustar 00root root 0000000 0000000 import random
from geopandas import GeoDataFrame, GeoSeries
from shapely.geometry import Point, LineString, Polygon, MultiPolygon
import numpy as np
class Bench:
param_names = ["geom_type"]
params = [("Point", "LineString", "Polygon", "MultiPolygon", "mixed")]
def setup(self, geom_type):
if geom_type == "Point":
geoms = GeoSeries([Point(i, i) for i in range(1000)])
elif geom_type == "LineString":
geoms = GeoSeries(
[
LineString([(random.random(), random.random()) for _ in range(5)])
for _ in range(100)
]
)
elif geom_type == "Polygon":
geoms = GeoSeries(
[
Polygon([(random.random(), random.random()) for _ in range(3)])
for _ in range(100)
]
)
elif geom_type == "MultiPolygon":
geoms = GeoSeries(
[
MultiPolygon(
[
Polygon(
[(random.random(), random.random()) for _ in range(3)]
)
for _ in range(3)
]
)
for _ in range(20)
]
)
elif geom_type == "mixed":
g1 = GeoSeries([Point(i, i) for i in range(100)])
g2 = GeoSeries(
[
LineString([(random.random(), random.random()) for _ in range(5)])
for _ in range(100)
]
)
g3 = GeoSeries(
[
Polygon([(random.random(), random.random()) for _ in range(3)])
for _ in range(100)
]
)
geoms = g1
geoms.iloc[np.random.randint(0, 100, 50)] = g2.iloc[:50]
geoms.iloc[np.random.randint(0, 100, 33)] = g3.iloc[:33]
print(geoms.geom_type.value_counts())
df = GeoDataFrame({"geometry": geoms, "values": np.random.randn(len(geoms))})
self.geoms = geoms
self.df = df
def time_plot_series(self, *args):
self.geoms.plot()
def time_plot_values(self, *args):
self.df.plot(column="values")
geopandas-1.2.0/benchmarks/sindex.py 0000664 0000000 0000000 00000006571 15256506516 0017460 0 ustar 00root root 0000000 0000000 from shapely.geometry import Point
from geopandas.tests.util import _NATURALEARTH_LOWRES
from geopandas.tests.util import _NATURALEARTH_CITIES
from geopandas import read_file, GeoSeries
# Derive list of valid query predicates based on underlying index backend;
# we have to create a non-empty instance of the index to get these
index = GeoSeries([Point(0, 0)]).sindex
predicates = sorted(p for p in index.valid_query_predicates if p is not None)
geom_types = ("mixed", "points", "polygons")
def generate_test_df():
world = read_file(_NATURALEARTH_LOWRES)
capitals = read_file(_NATURALEARTH_CITIES)
countries = world.to_crs("epsg:3395")[["geometry"]]
capitals = capitals.to_crs("epsg:3395")[["geometry"]]
mixed = capitals.append(countries) # get a mix of geometries
points = capitals
polygons = countries
# filter out invalid geometries
data = {
"mixed": mixed[mixed.is_valid],
"points": points[points.is_valid],
"polygons": polygons[polygons.is_valid],
}
# ensure index is pre-generated
for data_type in data.keys():
data[data_type].sindex.query(data[data_type].geometry.values[0])
return data
class BenchIntersection:
param_names = ["input_geom_type", "tree_geom_type"]
params = [
geom_types,
geom_types,
]
def setup(self, *args):
self.data = generate_test_df()
# cache bounds so that bound creation is not counted in benchmarks
self.bounds = {
data_type: [g.bounds for g in self.data[data_type].geometry]
for data_type in self.data.keys()
}
def time_intersects(self, input_geom_type, tree_geom_type):
tree = self.data[tree_geom_type].sindex
for bounds in self.bounds[input_geom_type]:
tree.intersection(bounds)
class BenchIndexCreation:
param_names = ["tree_geom_type"]
params = [
geom_types,
]
def setup(self, *args):
self.data = generate_test_df()
def time_index_creation(self, tree_geom_type):
"""Time creation of spatial index.
Note: requires running a single query to ensure that
lazy-building indexes are actually built.
"""
# Note: the GeoDataFram._sindex_generated attribute will
# be removed by GH#1444 but is kept here (in the benchmarks
# so that we can compare pre GH#1444 to post GH#1444 if needed
self.data[tree_geom_type]._sindex_generated = None
self.data[tree_geom_type].geometry.values._sindex = None
tree = self.data[tree_geom_type].sindex
# also do a single query to ensure the index is actually
# generated and used
tree.query(self.data[tree_geom_type].geometry.values[0])
class BenchQuery:
param_names = ["predicate", "input_geom_type", "tree_geom_type"]
params = [
predicates,
geom_types,
geom_types,
]
def setup(self, *args):
self.data = generate_test_df()
def time_query_bulk(self, predicate, input_geom_type, tree_geom_type):
self.data[tree_geom_type].sindex.query(
self.data[input_geom_type].geometry.values,
predicate=predicate,
)
def time_query(self, predicate, input_geom_type, tree_geom_type):
tree = self.data[tree_geom_type].sindex
for geom in self.data[input_geom_type].geometry.values:
tree.query(geom, predicate=predicate)
geopandas-1.2.0/benchmarks/sjoin.py 0000664 0000000 0000000 00000001702 15256506516 0017277 0 ustar 00root root 0000000 0000000 import random
from geopandas import GeoDataFrame, GeoSeries, sjoin
from shapely.geometry import Point, LineString, Polygon
import numpy as np
class Bench:
param_names = ["op"]
params = [("intersects", "contains", "within")]
def setup(self, *args):
triangles = GeoSeries(
[
Polygon([(random.random(), random.random()) for _ in range(3)])
for _ in range(1000)
]
)
points = GeoSeries(
[
Point(x, y)
for x, y in zip(np.random.random(10000), np.random.random(10000))
]
)
df1 = GeoDataFrame(
{"val1": np.random.randn(len(triangles)), "geometry": triangles}
)
df2 = GeoDataFrame({"val1": np.random.randn(len(points)), "geometry": points})
self.df1, self.df2 = df1, df2
def time_sjoin(self, predicate):
sjoin(self.df1, self.df2, predicate=predicate)
geopandas-1.2.0/benchmarks/transform.py 0000664 0000000 0000000 00000001431 15256506516 0020167 0 ustar 00root root 0000000 0000000 from geopandas import GeoDataFrame, GeoSeries, read_file
import numpy as np
import pandas as pd
from shapely.geometry import Point
from geopandas.tests.util import _NYBB
class CRS:
def setup(self):
nybb = read_file(_NYBB)
self.long_nybb = GeoDataFrame(pd.concat(10 * [nybb]), crs=nybb.crs)
num_points = 20000
longitudes = np.random.rand(num_points) - 120
latitudes = np.random.rand(num_points) + 38
self.point_df = GeoSeries(
[Point(x, y) for (x, y) in zip(longitudes, latitudes)]
)
self.point_df.crs = {"init": "epsg:4326"}
def time_transform_wgs84(self):
self.long_nybb.to_crs({"init": "epsg:4326"})
def time_transform_many_points(self):
self.point_df.to_crs({"init": "epsg:32610"})
geopandas-1.2.0/ci/ 0000775 0000000 0000000 00000000000 15256506516 0014061 5 ustar 00root root 0000000 0000000 geopandas-1.2.0/ci/envs/ 0000775 0000000 0000000 00000000000 15256506516 0015034 5 ustar 00root root 0000000 0000000 geopandas-1.2.0/ci/envs/311-latest.yaml 0000664 0000000 0000000 00000001243 15256506516 0017516 0 ustar 00root root 0000000 0000000 name: test
channels:
- conda-forge
dependencies:
- python=3.11
# required
- pandas
- shapely
- pyogrio
- pyproj
- packaging
# testing
- pytest
- pytest-cov
- pytest-xdist
- fsspec
- requests
- aiohttp
- pytz
# optional
- matplotlib-base
- mapclassify
- libpysal
- folium
- xyzservices
- contextily
- scipy
- geopy
- pointpats
- geodatasets
# installed in tests.yaml, because not available on windows
# - postgis
- sqlalchemy<2.1 # test oldest support sqlalchemy version
- psycopg2
- libspatialite
- geoalchemy2
- pyarrow
- geoarrow-pyarrow
- fiona
- pyogrio
# doctest testing
- pytest-doctestplus
geopandas-1.2.0/ci/envs/311-minimal.yaml 0000664 0000000 0000000 00000000626 15256506516 0017654 0 ustar 00root root 0000000 0000000 name: test
channels:
- conda-forge
dependencies:
- python=3.11
# required
- numpy=2.0
- pandas=2.2
- shapely=2.1.0
- pyogrio=0.8
- pyproj=3.7.0
- packaging
# testing
- pytest
- pytest-cov
- pytest-xdist
- fsspec
- requests
- aiohttp
- pytz
# optional
- matplotlib=3.9.1
- mapclassify=2.7.0
- geopy
- sqlalchemy
- libspatialite
- pyarrow=15.0
- geodatasets
geopandas-1.2.0/ci/envs/311-pd23.yaml 0000664 0000000 0000000 00000001176 15256506516 0016777 0 ustar 00root root 0000000 0000000 name: test
channels:
- conda-forge
dependencies:
- python=3.11
# required
- pandas=2.3
- numpy=2.3 # released 3 days after pandas 2.3
- shapely
- pyogrio
- pyproj
- packaging
# testing
- pytest
- pytest-cov
- pytest-xdist
- fsspec
- requests
- aiohttp
- pytz
# optional
- matplotlib
- mapclassify
- folium
- xyzservices
- scipy
- geopy
- geodatasets
# installed in tests.yaml, because not available on windows
# - postgis
- sqlalchemy<2.1 # test oldest support sqlalchemy version
- psycopg2
- libspatialite
- geoalchemy2
- pyarrow
# doctest testing
- pytest-doctestplus
geopandas-1.2.0/ci/envs/312-latest.yaml 0000664 0000000 0000000 00000001161 15256506516 0017516 0 ustar 00root root 0000000 0000000 name: test
channels:
- conda-forge
dependencies:
- python=3.12
# required
- pandas
- shapely
- pyogrio
- pyproj
- packaging
# testing
- pytest
- pytest-cov
- pytest-xdist
- fsspec
- requests
- aiohttp
- pytz
# optional
- fiona
- matplotlib
- mapclassify
- libpysal
- folium
- xyzservices
- contextily
- scipy
- geopy
- pointpats
- geodatasets
# installed in tests.yaml, because not available on windows
# - postgis
- sqlalchemy
- psycopg
- psycopg2
- libspatialite
- geoalchemy2
- pyarrow
- geoarrow-pyarrow
# doctest testing
- pytest-doctestplus
geopandas-1.2.0/ci/envs/313-dev.yaml 0000664 0000000 0000000 00000002056 15256506516 0017005 0 ustar 00root root 0000000 0000000 name: test
channels:
- conda-forge
dependencies:
- python=3.13
- cython
# required
- pyproj
- gdal
- geos
- packaging
# testing
- pytest
- pytest-cov
- pytest-xdist
- fsspec
- requests
- aiohttp
# optional
#- geopy
- sqlalchemy<2.1 # test oldest support sqlalchemy version
- libspatialite
- rasterio
- pip
- pip:
- geopy
- mapclassify>=2.6.0
# dev versions of packages
- --pre --index-url https://pypi.anaconda.org/scientific-python-nightly-wheels/simple --extra-index-url https://pypi.fury.io/arrow-nightlies/ --extra-index-url https://pypi.org/simple
- numpy>=2.0.0
- fiona
- pandas
- matplotlib
- pyarrow
- shapely
- git+https://github.com/python-visualization/folium.git@main
- git+https://github.com/python-visualization/branca.git@main
- git+https://github.com/geopandas/xyzservices.git@main
- git+https://github.com/geopandas/contextily.git@main
- git+https://github.com/geopandas/geodatasets.git@main
- git+https://github.com/geopandas/pyogrio.git@main
geopandas-1.2.0/ci/envs/313-latest-no-pyogrio.yaml 0000664 0000000 0000000 00000000744 15256506516 0021625 0 ustar 00root root 0000000 0000000 name: test
channels:
- conda-forge
dependencies:
- python=3.13
# required
- pandas
- shapely
# - pyogrio # build with only fiona
- libgdal
- pyproj
- packaging
# testing
- pytest
- pytest-cov
- pytest-xdist
- pytz
# - fsspec # to have one non-minimal build without fsspec
# optional
- matplotlib>=3.6
- mapclassify
- folium
- xyzservices
- scipy
- geopy
- sqlalchemy
- libspatialite
- pyarrow
- fiona
- pointpats
- geodatasets geopandas-1.2.0/ci/envs/313-latest-no-pyproj.yaml 0000664 0000000 0000000 00000000716 15256506516 0021457 0 ustar 00root root 0000000 0000000 name: test
channels:
- conda-forge
dependencies:
- python=3.13
# required
- pandas
- shapely
# - pyogrio
# - pyproj
- packaging
# testing
- pytest
- pytest-cov
- pytest-xdist
- fsspec
- requests
- aiohttp
- pytz
# optional
- fiona
- matplotlib
- mapclassify
- folium
- xyzservices
- scipy
- geopy
# - pointpats
- geodatasets
# - sqlalchemy>=2
# - psycopg2
# - libspatialite
# - geoalchemy2
- pyarrow
geopandas-1.2.0/ci/envs/313-latest.yaml 0000664 0000000 0000000 00000001213 15256506516 0017515 0 ustar 00root root 0000000 0000000 name: test
channels:
- conda-forge
dependencies:
- python=3.13
# required
- pandas
- shapely
- pyogrio
- pyproj
- packaging
# testing
- pytest
- pytest-cov
- pytest-xdist
- fsspec
- requests
- aiohttp
- pytz
# optional
- fiona
- matplotlib
- mapclassify
- libpysal
- folium
- xyzservices
- contextily
- scipy
- geopy
- pointpats
- geodatasets
# installed in tests.yaml, because not available on windows
# - postgis
- sqlalchemy
- psycopg
- psycopg2
- libspatialite
- geoalchemy2
- pyarrow
- geoarrow-pyarrow
- libgdal-arrow-parquet
# doctest testing
- pytest-doctestplus
geopandas-1.2.0/ci/envs/313-no-optional-deps.yaml 0000664 0000000 0000000 00000000312 15256506516 0021410 0 ustar 00root root 0000000 0000000 name: test
channels:
- conda-forge
dependencies:
- python=3.13
# required
- pandas
- shapely
- pyogrio>=0.7.2
- pyproj
- packaging
# testing
- pytest
- pytest-cov
- pytest-xdist
geopandas-1.2.0/ci/envs/314-latest.yaml 0000664 0000000 0000000 00000001210 15256506516 0017513 0 ustar 00root root 0000000 0000000 name: test
channels:
- conda-forge
dependencies:
- python=3.14
# required
- pandas
- shapely
- pyogrio
- pyproj
- packaging
# testing
- pytest
- pytest-cov
- pytest-xdist
- fsspec
- requests
- aiohttp
- pytz
# optional
# - fiona # no 3.14 build yet
- matplotlib
- mapclassify
- libpysal
- folium
- xyzservices
- contextily
- scipy
- geopy
- pointpats
- geodatasets
# installed in tests.yaml, because not available on windows
# - postgis
- sqlalchemy
- psycopg
- psycopg2
- libspatialite
- geoalchemy2
- pyarrow
- geoarrow-pyarrow
# doctest testing
- pytest-doctestplus
geopandas-1.2.0/ci/scripts/ 0000775 0000000 0000000 00000000000 15256506516 0015550 5 ustar 00root root 0000000 0000000 geopandas-1.2.0/ci/scripts/setup_postgres.sh 0000664 0000000 0000000 00000001362 15256506516 0021174 0 ustar 00root root 0000000 0000000 #!/bin/sh
set -e
if [ -z "${PGUSER}" ] || [ -z "${PGPORT}" ]; then
echo "Environment variables PGUSER and PGPORT must be set"
exit 1
fi
PGDATA=$(mktemp -d /tmp/postgres.XXXXXX)
echo "Setting up PostgreSQL in ${PGDATA} on port ${PGPORT}"
pg_ctl -D ${PGDATA} initdb
pg_ctl -D ${PGDATA} start
SOCKETPATH="/tmp/.s.PGSQL.${PGPORT}"
echo -n 'waiting for postgres'
while [ ! -e ${SOCKETPATH} ]; do
sleep 1
echo -n '.'
done
echo
echo "Done setting up PostgreSQL. When finished, stop and cleanup using:"
echo
echo " pg_ctl -D ${PGDATA} stop"
echo " rm -rf ${PGDATA}"
echo
createuser -U ${USER} -s ${PGUSER}
createdb --owner=${PGUSER} test_geopandas
psql -d test_geopandas -q -c "CREATE EXTENSION postgis"
echo "PostGIS server ready."
geopandas-1.2.0/codecov.yml 0000664 0000000 0000000 00000000243 15256506516 0015632 0 ustar 00root root 0000000 0000000 coverage:
status:
project:
default:
target: 95% # the required coverage value
threshold: 0.2% # the leniency in hitting the target
geopandas-1.2.0/doc/ 0000775 0000000 0000000 00000000000 15256506516 0014233 5 ustar 00root root 0000000 0000000 geopandas-1.2.0/doc/Makefile 0000664 0000000 0000000 00000013073 15256506516 0015677 0 ustar 00root root 0000000 0000000 # Makefile for Sphinx documentation
#
# You can set these variables from the command line.
SPHINXOPTS =
SPHINXBUILD = sphinx-build
PAPER =
BUILDDIR = build
# Internal variables.
PAPEROPT_a4 = -D latex_paper_size=a4
PAPEROPT_letter = -D latex_paper_size=letter
ALLSPHINXOPTS = -d $(BUILDDIR)/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) source
# the i18n builder cannot share the environment and doctrees with the others
I18NSPHINXOPTS = $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) source
.PHONY: help clean html dirhtml singlehtml pickle json htmlhelp qthelp devhelp epub latex latexpdf text man changes linkcheck doctest gettext
help:
@echo "Please use \`make ' where is one of"
@echo " html to make standalone HTML files"
@echo " dirhtml to make HTML files named index.html in directories"
@echo " singlehtml to make a single large HTML file"
@echo " pickle to make pickle files"
@echo " json to make JSON files"
@echo " htmlhelp to make HTML files and an HTML help project"
@echo " qthelp to make HTML files and a qthelp project"
@echo " devhelp to make HTML files and a Devhelp project"
@echo " epub to make an epub"
@echo " latex to make LaTeX files, you can set PAPER=a4 or PAPER=letter"
@echo " latexpdf to make LaTeX files and run them through pdflatex"
@echo " text to make text files"
@echo " man to make manual pages"
@echo " texinfo to make Texinfo files"
@echo " info to make Texinfo files and run them through makeinfo"
@echo " gettext to make PO message catalogs"
@echo " changes to make an overview of all changed/added/deprecated items"
@echo " linkcheck to check all external links for integrity"
@echo " doctest to run all doctests embedded in the documentation (if enabled)"
clean:
-rm -rf $(BUILDDIR)/*
-rm -rf source/reference/*
html:
$(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html
@echo
@echo "Build finished. The HTML pages are in $(BUILDDIR)/html."
dirhtml:
$(SPHINXBUILD) -b dirhtml $(ALLSPHINXOPTS) $(BUILDDIR)/dirhtml
@echo
@echo "Build finished. The HTML pages are in $(BUILDDIR)/dirhtml."
singlehtml:
$(SPHINXBUILD) -b singlehtml $(ALLSPHINXOPTS) $(BUILDDIR)/singlehtml
@echo
@echo "Build finished. The HTML page is in $(BUILDDIR)/singlehtml."
pickle:
$(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) $(BUILDDIR)/pickle
@echo
@echo "Build finished; now you can process the pickle files."
json:
$(SPHINXBUILD) -b json $(ALLSPHINXOPTS) $(BUILDDIR)/json
@echo
@echo "Build finished; now you can process the JSON files."
htmlhelp:
$(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) $(BUILDDIR)/htmlhelp
@echo
@echo "Build finished; now you can run HTML Help Workshop with the" \
".hhp project file in $(BUILDDIR)/htmlhelp."
qthelp:
$(SPHINXBUILD) -b qthelp $(ALLSPHINXOPTS) $(BUILDDIR)/qthelp
@echo
@echo "Build finished; now you can run "qcollectiongenerator" with the" \
".qhcp project file in $(BUILDDIR)/qthelp, like this:"
@echo "# qcollectiongenerator $(BUILDDIR)/qthelp/GeoPandas.qhcp"
@echo "To view the help file:"
@echo "# assistant -collectionFile $(BUILDDIR)/qthelp/GeoPandas.qhc"
devhelp:
$(SPHINXBUILD) -b devhelp $(ALLSPHINXOPTS) $(BUILDDIR)/devhelp
@echo
@echo "Build finished."
@echo "To view the help file:"
@echo "# mkdir -p $$HOME/.local/share/devhelp/GeoPandas"
@echo "# ln -s $(BUILDDIR)/devhelp $$HOME/.local/share/devhelp/GeoPandas"
@echo "# devhelp"
epub:
$(SPHINXBUILD) -b epub $(ALLSPHINXOPTS) $(BUILDDIR)/epub
@echo
@echo "Build finished. The epub file is in $(BUILDDIR)/epub."
latex:
$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
@echo
@echo "Build finished; the LaTeX files are in $(BUILDDIR)/latex."
@echo "Run \`make' in that directory to run these through (pdf)latex" \
"(use \`make latexpdf' here to do that automatically)."
latexpdf:
$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
@echo "Running LaTeX files through pdflatex..."
$(MAKE) -C $(BUILDDIR)/latex all-pdf
@echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex."
text:
$(SPHINXBUILD) -b text $(ALLSPHINXOPTS) $(BUILDDIR)/text
@echo
@echo "Build finished. The text files are in $(BUILDDIR)/text."
man:
$(SPHINXBUILD) -b man $(ALLSPHINXOPTS) $(BUILDDIR)/man
@echo
@echo "Build finished. The manual pages are in $(BUILDDIR)/man."
texinfo:
$(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo
@echo
@echo "Build finished. The Texinfo files are in $(BUILDDIR)/texinfo."
@echo "Run \`make' in that directory to run these through makeinfo" \
"(use \`make info' here to do that automatically)."
info:
$(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo
@echo "Running Texinfo files through makeinfo..."
make -C $(BUILDDIR)/texinfo info
@echo "makeinfo finished; the Info files are in $(BUILDDIR)/texinfo."
gettext:
$(SPHINXBUILD) -b gettext $(I18NSPHINXOPTS) $(BUILDDIR)/locale
@echo
@echo "Build finished. The message catalogs are in $(BUILDDIR)/locale."
changes:
$(SPHINXBUILD) -b changes $(ALLSPHINXOPTS) $(BUILDDIR)/changes
@echo
@echo "The overview file is in $(BUILDDIR)/changes."
linkcheck:
$(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) $(BUILDDIR)/linkcheck
@echo
@echo "Link check complete; look for any errors in the above output " \
"or in $(BUILDDIR)/linkcheck/output.txt."
doctest:
$(SPHINXBUILD) -b doctest $(ALLSPHINXOPTS) $(BUILDDIR)/doctest
@echo "Testing of doctests in the sources finished, look at the " \
"results in $(BUILDDIR)/doctest/output.txt."
dash: html
rm -rf geopandas.docset
doc2dash --name=geopandas _build/html
geopandas-1.2.0/doc/environment.yml 0000664 0000000 0000000 00000001420 15256506516 0017317 0 ustar 00root root 0000000 0000000 name: geopandas_docs
channels:
- conda-forge
dependencies:
- python=3.13
- pandas
- shapely
- geopy
- matplotlib
- mapclassify
- sphinx
- pydata-sphinx-theme
- numpydoc
- ipython
- pillow
- mock
- pyepsg
- sphinx-gallery
- jinja2
- doc2dash
- matplotlib-scalebar
# specify additional dependencies to reduce solving for conda
- geos
- nbsphinx
- jupyter_client
- ipykernel
- myst-parser
- folium
- xyzservices
- packaging
- pip
- pip:
- sphinx-toggleprompt
- geodatasets
# proj/pyproj deps from pip to avoid Proj env warning from conda+readthedocs
- pyproj
- cartopy
- fiona
- pyogrio
- rasterio
- contextily
- pointpats
- libpysal
- matplotlib_map_utils
geopandas-1.2.0/doc/make.bat 0000664 0000000 0000000 00000011770 15256506516 0015646 0 ustar 00root root 0000000 0000000 @ECHO OFF
REM Command file for Sphinx documentation
if "%SPHINXBUILD%" == "" (
set SPHINXBUILD=sphinx-build
)
set BUILDDIR=build
set ALLSPHINXOPTS=-d %BUILDDIR%/doctrees %SPHINXOPTS% source
set I18NSPHINXOPTS=%SPHINXOPTS% source
if NOT "%PAPER%" == "" (
set ALLSPHINXOPTS=-D latex_paper_size=%PAPER% %ALLSPHINXOPTS%
set I18NSPHINXOPTS=-D latex_paper_size=%PAPER% %I18NSPHINXOPTS%
)
if "%1" == "" goto help
if "%1" == "help" (
:help
echo.Please use `make ^` where ^ is one of
echo. html to make standalone HTML files
echo. dirhtml to make HTML files named index.html in directories
echo. singlehtml to make a single large HTML file
echo. pickle to make pickle files
echo. json to make JSON files
echo. htmlhelp to make HTML files and an HTML help project
echo. qthelp to make HTML files and a qthelp project
echo. devhelp to make HTML files and a Devhelp project
echo. epub to make an epub
echo. latex to make LaTeX files, you can set PAPER=a4 or PAPER=letter
echo. text to make text files
echo. man to make manual pages
echo. texinfo to make Texinfo files
echo. gettext to make PO message catalogs
echo. changes to make an overview over all changed/added/deprecated items
echo. linkcheck to check all external links for integrity
echo. doctest to run all doctests embedded in the documentation if enabled
goto end
)
if "%1" == "clean" (
for /d %%i in (%BUILDDIR%\*) do rmdir /q /s %%i
del /q /s %BUILDDIR%\*
goto end
)
if "%1" == "html" (
%SPHINXBUILD% -b html %ALLSPHINXOPTS% %BUILDDIR%/html
if errorlevel 1 exit /b 1
echo.
echo.Build finished. The HTML pages are in %BUILDDIR%/html.
goto end
)
if "%1" == "dirhtml" (
%SPHINXBUILD% -b dirhtml %ALLSPHINXOPTS% %BUILDDIR%/dirhtml
if errorlevel 1 exit /b 1
echo.
echo.Build finished. The HTML pages are in %BUILDDIR%/dirhtml.
goto end
)
if "%1" == "singlehtml" (
%SPHINXBUILD% -b singlehtml %ALLSPHINXOPTS% %BUILDDIR%/singlehtml
if errorlevel 1 exit /b 1
echo.
echo.Build finished. The HTML pages are in %BUILDDIR%/singlehtml.
goto end
)
if "%1" == "pickle" (
%SPHINXBUILD% -b pickle %ALLSPHINXOPTS% %BUILDDIR%/pickle
if errorlevel 1 exit /b 1
echo.
echo.Build finished; now you can process the pickle files.
goto end
)
if "%1" == "json" (
%SPHINXBUILD% -b json %ALLSPHINXOPTS% %BUILDDIR%/json
if errorlevel 1 exit /b 1
echo.
echo.Build finished; now you can process the JSON files.
goto end
)
if "%1" == "htmlhelp" (
%SPHINXBUILD% -b htmlhelp %ALLSPHINXOPTS% %BUILDDIR%/htmlhelp
if errorlevel 1 exit /b 1
echo.
echo.Build finished; now you can run HTML Help Workshop with the ^
.hhp project file in %BUILDDIR%/htmlhelp.
goto end
)
if "%1" == "qthelp" (
%SPHINXBUILD% -b qthelp %ALLSPHINXOPTS% %BUILDDIR%/qthelp
if errorlevel 1 exit /b 1
echo.
echo.Build finished; now you can run "qcollectiongenerator" with the ^
.qhcp project file in %BUILDDIR%/qthelp, like this:
echo.^> qcollectiongenerator %BUILDDIR%\qthelp\GeoPandas.qhcp
echo.To view the help file:
echo.^> assistant -collectionFile %BUILDDIR%\qthelp\GeoPandas.ghc
goto end
)
if "%1" == "devhelp" (
%SPHINXBUILD% -b devhelp %ALLSPHINXOPTS% %BUILDDIR%/devhelp
if errorlevel 1 exit /b 1
echo.
echo.Build finished.
goto end
)
if "%1" == "epub" (
%SPHINXBUILD% -b epub %ALLSPHINXOPTS% %BUILDDIR%/epub
if errorlevel 1 exit /b 1
echo.
echo.Build finished. The epub file is in %BUILDDIR%/epub.
goto end
)
if "%1" == "latex" (
%SPHINXBUILD% -b latex %ALLSPHINXOPTS% %BUILDDIR%/latex
if errorlevel 1 exit /b 1
echo.
echo.Build finished; the LaTeX files are in %BUILDDIR%/latex.
goto end
)
if "%1" == "text" (
%SPHINXBUILD% -b text %ALLSPHINXOPTS% %BUILDDIR%/text
if errorlevel 1 exit /b 1
echo.
echo.Build finished. The text files are in %BUILDDIR%/text.
goto end
)
if "%1" == "man" (
%SPHINXBUILD% -b man %ALLSPHINXOPTS% %BUILDDIR%/man
if errorlevel 1 exit /b 1
echo.
echo.Build finished. The manual pages are in %BUILDDIR%/man.
goto end
)
if "%1" == "texinfo" (
%SPHINXBUILD% -b texinfo %ALLSPHINXOPTS% %BUILDDIR%/texinfo
if errorlevel 1 exit /b 1
echo.
echo.Build finished. The Texinfo files are in %BUILDDIR%/texinfo.
goto end
)
if "%1" == "gettext" (
%SPHINXBUILD% -b gettext %I18NSPHINXOPTS% %BUILDDIR%/locale
if errorlevel 1 exit /b 1
echo.
echo.Build finished. The message catalogs are in %BUILDDIR%/locale.
goto end
)
if "%1" == "changes" (
%SPHINXBUILD% -b changes %ALLSPHINXOPTS% %BUILDDIR%/changes
if errorlevel 1 exit /b 1
echo.
echo.The overview file is in %BUILDDIR%/changes.
goto end
)
if "%1" == "linkcheck" (
%SPHINXBUILD% -b linkcheck %ALLSPHINXOPTS% %BUILDDIR%/linkcheck
if errorlevel 1 exit /b 1
echo.
echo.Link check complete; look for any errors in the above output ^
or in %BUILDDIR%/linkcheck/output.txt.
goto end
)
if "%1" == "doctest" (
%SPHINXBUILD% -b doctest %ALLSPHINXOPTS% %BUILDDIR%/doctest
if errorlevel 1 exit /b 1
echo.
echo.Testing of doctests in the sources finished, look at the ^
results in %BUILDDIR%/doctest/output.txt.
goto end
)
:end
geopandas-1.2.0/doc/nyc_boros.py 0000664 0000000 0000000 00000004515 15256506516 0016607 0 ustar 00root root 0000000 0000000 """
Visualizing NYC Boroughs
------------------------
Visualize the Boroughs of New York City with Geopandas.
This example generates many images that are used in the documentation. See
the `Geometric Manipulations ` example for more
details.
First we'll import a dataset containing each borough in New York City. We'll
use the ``datasets`` module to handle this quickly.
"""
import numpy as np
import matplotlib.pyplot as plt
from shapely.geometry import Point
from geopandas import GeoSeries, GeoDataFrame
import geopandas as gpd
import geodatasets
np.random.seed(1)
DPI = 100
path_nybb = geodatasets.get_path("nybb")
boros = GeoDataFrame.from_file(path_nybb)
boros = boros.set_index("BoroCode")
boros
##############################################################################
# Next, we'll plot the raw data
ax = boros.plot()
plt.xticks(rotation=90)
plt.savefig("nyc.png", dpi=DPI, bbox_inches="tight")
##############################################################################
# We can easily retrieve the convex hull of each shape. This corresponds to
# the outer edge of the shapes.
boros.geometry.convex_hull.plot()
plt.xticks(rotation=90)
# Grab the limits which we'll use later
xmin, xmax = plt.gca().get_xlim()
ymin, ymax = plt.gca().get_ylim()
plt.savefig("nyc_hull.png", dpi=DPI, bbox_inches="tight")
##############################################################################
# We'll generate some random dots scattered throughout our data, and will
# use them to perform some set operations with our boroughs. We can use
# GeoPandas to perform unions, intersections, etc.
N = 2000 # number of random points
R = 2000 # radius of buffer in feet
# xmin, xmax, ymin, ymax = 900000, 1080000, 120000, 280000
xc = (xmax - xmin) * np.random.random(N) + xmin
yc = (ymax - ymin) * np.random.random(N) + ymin
pts = GeoSeries([Point(x, y) for x, y in zip(xc, yc)])
mp = pts.buffer(R).union_all()
boros_with_holes = boros.geometry - mp
boros_with_holes.plot()
plt.xticks(rotation=90)
plt.savefig("boros_with_holes.png", dpi=DPI, bbox_inches="tight")
##############################################################################
# Finally, we'll show the holes that were taken out of our boroughs.
holes = boros.geometry & mp
holes.plot()
plt.xticks(rotation=90)
plt.savefig("holes.png", dpi=DPI, bbox_inches="tight")
plt.show()
geopandas-1.2.0/doc/source/ 0000775 0000000 0000000 00000000000 15256506516 0015533 5 ustar 00root root 0000000 0000000 geopandas-1.2.0/doc/source/_static/ 0000775 0000000 0000000 00000000000 15256506516 0017161 5 ustar 00root root 0000000 0000000 geopandas-1.2.0/doc/source/_static/SponsoredProject.svg 0000664 0000000 0000000 00000017256 15256506516 0023220 0 ustar 00root root 0000000 0000000