From ef35c4b3d131ebbec4974be0bffabf28c2f1af95 Mon Sep 17 00:00:00 2001 From: eli knaap Date: Thu, 20 Jul 2023 15:49:43 -0700 Subject: [PATCH 01/17] add first draft of correlogram --- esda/__init__.py | 21 +- esda/correlogram.py | 144 ++++++ notebooks/correlogram.ipynb | 893 ++++++++++++++++++++++++++++++++++++ 3 files changed, 1042 insertions(+), 16 deletions(-) create mode 100644 esda/correlogram.py create mode 100644 notebooks/correlogram.ipynb diff --git a/esda/__init__.py b/esda/__init__.py index 802c0fc8..13ac9fd4 100644 --- a/esda/__init__.py +++ b/esda/__init__.py @@ -4,6 +4,7 @@ """ from . import _version, adbscan, shape # noqa F401 +from .correlogram import correlogram # noqa F401 from .gamma import Gamma # noqa F401 from .geary import Geary # noqa F401 from .geary_local import Geary_Local # noqa F401 @@ -15,22 +16,10 @@ from .join_counts_local_mv import Join_Counts_Local_MV # noqa F401 from .lee import Spatial_Pearson, Spatial_Pearson_Local # noqa F401 from .losh import LOSH # noqa F401 -from .map_comparison import ( # noqa F401 - areal_entropy, - completeness, - external_entropy, - homogeneity, - overlay_entropy, -) -from .moran import ( # noqa F401 - Moran, - Moran_BV, - Moran_BV_matrix, - Moran_Local, - Moran_Local_BV, - Moran_Local_Rate, - Moran_Rate, -) +from .map_comparison import (areal_entropy, completeness, # noqa F401 + external_entropy, homogeneity, overlay_entropy) +from .moran import (Moran, Moran_BV, Moran_BV_matrix, Moran_Local, # noqa F401 + Moran_Local_BV, Moran_Local_Rate, Moran_Rate) from .silhouettes import boundary_silhouette, path_silhouette # noqa F401 from .smaup import Smaup # noqa F401 from .topo import isolation, prominence # noqa F401 diff --git a/esda/correlogram.py b/esda/correlogram.py new file mode 100644 index 00000000..5d53cdf8 --- /dev/null +++ b/esda/correlogram.py @@ -0,0 +1,144 @@ +# Spatial Correlograms + +import geopandas as gpd +import pandas as pd +import numpy as np +from joblib import Parallel, delayed +from libpysal.cg.kdtree import KDTree +from libpysal.weights import KNN, DistanceBand +from libpysal.weights.util import get_points_array + +from .geary import Geary +from .getisord import G +from .moran import Moran + + +def _get_autocorrelation_stat(inputs): + """helper function for computing parallel autocorrelation statistics + + Parameters + ---------- + inputs : tuple + tuple of (y, tree, W, statistic, STATISTIC, dist, weights_kwargs, stat_kwargs) + + Returns + ------- + pandas.Series + a pandas series with the computed autocorrelation statistic and its simulated p-value + """ + ( + y, # y variable + tree, # kd tree + W, # weights class DistanceBand or KNN + STATISTIC, # class of statistic (Moran, Geary, etc) + dist, # threshold/k parameter for the weights + weights_kwargs, # additional args + stat_kwargs, # additional args + ) = inputs + + w = W(tree, dist, silence_warnings=True, **weights_kwargs) + autocorr = STATISTIC(y, w, **stat_kwargs) + attrs = [] + all_attrs = list(dict(vars(autocorr)).keys()) + for attribute in all_attrs: + attrs.append(getattr(autocorr, str(attribute))) + return pd.Series(attrs, index=all_attrs, name=dist) + + +def correlogram( + gdf: gpd.GeoDataFrame, + variable: str, + distances: list, + distance_type: str = "band", + statistic: str = "I", + weights_kwargs: dict = None, + stat_kwargs: dict = None, + n_jobs: int = -1, + backend: str = "loky", +): + """Generate a spatial correlogram + + Parameters + ---------- + gdf : gpd.GeoDataFrame + geodataframe holding spatial and attribute data + variable: str + column on the geodataframe used to compute autocorrelation statistic + distances : list + list of distances to compute the autocorrelation statistic + distance_type : str, optional + which concept of distance to increment. Options are {`band`, `knn`}. + by default 'band' (for `libpysal.weights.DistanceBand` weights) + statistic : str, by default 'I' + which spatial autocorrelation statistic to compute. Options in {`I`, `G`, `C`} + weights_kwargs : dict + additional keyword arguments passed to the libpysal.weights.W class + stat_kwargs : dict + additional keyword arguments passed to the `esda` autocorrelation statistic class. + For example for faster results with no statistical inference, set the nuumber + of permutations to zero with {permutations: 0} + n_jobs : int + number of jobs to pass to joblib. If -1 (default), all cores will be used + backend : str + backend parameter passed to joblb + + Returns + ------- + outputs : pandas.DataFrame + table of autocorrelation statistics at increasing distance bandwidths + """ + if stat_kwargs is None: + stat_kwargs = dict() + if weights_kwargs is None: + weights_kwargs = dict() + if statistic == "I": + STATISTIC = Moran + elif statistic == "G": + STATISTIC = G + elif statistic == "C": + STATISTIC = Geary + else: + with NotImplementedError as e: + raise e("Only I, G, and C statistics are currently implemented") + + if distance_type == "band": + W = DistanceBand + elif distance_type == "knn": + if max(distances) > gdf.shape[0] - 1: + with ValueError as e: + raise e("max number of neighbors must be less than or equal to n-1") + W = KNN + else: + with NotImplementedError as e: + raise e("distance_type must be either `band` or `knn` ") + + # should be able to build the tree once and reuse it? + # but in practice, im not seeing any real difference from starting a new W from scratch each time + pts = get_points_array(gdf[gdf.geometry.name]) + tree = KDTree(pts) + y = gdf[variable].values + + inputs = [ + tuple( + [ + y, + tree, + W, + STATISTIC, + dist, + weights_kwargs, + stat_kwargs, + ] + ) + for dist in distances + ] + + outputs = Parallel(n_jobs=n_jobs, backend=backend)( + delayed(_get_autocorrelation_stat)(i) for i in inputs + ) + + return ( + pd.DataFrame(outputs) + .select_dtypes(["number"]) + .drop(columns=["permutations", "n"]) + ) diff --git a/notebooks/correlogram.ipynb b/notebooks/correlogram.ipynb new file mode 100644 index 00000000..c125ae33 --- /dev/null +++ b/notebooks/correlogram.ipynb @@ -0,0 +1,893 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "0c88261c-c8d4-4638-a727-60d833b7d111", + "metadata": { + "execution": { + "iopub.execute_input": "2023-07-20T22:49:18.712153Z", + "iopub.status.busy": "2023-07-20T22:49:18.711912Z", + "iopub.status.idle": "2023-07-20T22:49:19.589892Z", + "shell.execute_reply": "2023-07-20T22:49:19.589387Z", + "shell.execute_reply.started": "2023-07-20T22:49:18.712128Z" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2\n", + "\n", + "from libpysal import examples\n", + "from esda import correlogram\n", + "\n", + "import geopandas as gpd" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "68d86eb6-8595-48f0-a244-8889c59e770d", + "metadata": { + "execution": { + "iopub.execute_input": "2023-07-20T22:49:19.591487Z", + "iopub.status.busy": "2023-07-20T22:49:19.591218Z", + "iopub.status.idle": "2023-07-20T22:49:20.094875Z", + "shell.execute_reply": "2023-07-20T22:49:20.094527Z", + "shell.execute_reply.started": "2023-07-20T22:49:19.591478Z" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Example not available: Sacramento1\n", + "Example not downloaded: Chicago parcels\n", + "Example not downloaded: Chile Migration\n", + "Example not downloaded: Spirals\n" + ] + } + ], + "source": [ + "sac = gpd.read_file(examples.load_example(\"Sacramento1\").get_path(\"sacramentot2.shp\"))" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "2650732f-b704-4af8-bfee-ccd8c75cf133", + "metadata": { + "execution": { + "iopub.execute_input": "2023-07-20T22:49:20.095433Z", + "iopub.status.busy": "2023-07-20T22:49:20.095333Z", + "iopub.status.idle": "2023-07-20T22:49:20.222852Z", + "shell.execute_reply": "2023-07-20T22:49:20.222561Z", + "shell.execute_reply.started": "2023-07-20T22:49:20.095423Z" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "sac = sac.to_crs(sac.estimate_utm_crs()) # now in meters)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "ab615631-b083-4700-b402-8dd8343cc790", + "metadata": { + "execution": { + "iopub.execute_input": "2023-07-20T22:49:20.223564Z", + "iopub.status.busy": "2023-07-20T22:49:20.223461Z", + "iopub.status.idle": "2023-07-20T22:49:20.262911Z", + "shell.execute_reply": "2023-07-20T22:49:20.262441Z", + "shell.execute_reply.started": "2023-07-20T22:49:20.223555Z" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "distances = [i+500 for i in range(0,5000, 500)]" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "049e4002-52a1-4205-9238-bfdb175f04ff", + "metadata": { + "execution": { + "iopub.execute_input": "2023-07-20T22:49:20.263491Z", + "iopub.status.busy": "2023-07-20T22:49:20.263397Z", + "iopub.status.idle": "2023-07-20T22:49:20.300614Z", + "shell.execute_reply": "2023-07-20T22:49:20.300307Z", + "shell.execute_reply.started": "2023-07-20T22:49:20.263481Z" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[500, 1000, 1500, 2000, 2500, 3000, 3500, 4000, 4500, 5000]" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "distances" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "d3b1de58-3fb4-4874-ae5b-63f5e03f869d", + "metadata": { + "execution": { + "iopub.execute_input": "2023-07-20T22:49:20.301206Z", + "iopub.status.busy": "2023-07-20T22:49:20.301109Z", + "iopub.status.idle": "2023-07-20T22:49:20.358953Z", + "shell.execute_reply": "2023-07-20T22:49:20.358487Z", + "shell.execute_reply.started": "2023-07-20T22:49:20.301198Z" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "\u001b[0;31mSignature:\u001b[0m\n", + "\u001b[0mcorrelogram\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mgdf\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgeopandas\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgeodataframe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mGeoDataFrame\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mvariable\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mdistances\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mlist\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mdistance_type\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mstr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'band'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mstatistic\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mstr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'I'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mweights_kwargs\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mdict\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mstat_kwargs\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mdict\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mn_jobs\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mint\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mbackend\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mstr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'loky'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mDocstring:\u001b[0m\n", + "Generate a spatial correlogram\n", + "\n", + "Parameters\n", + "----------\n", + "gdf : gpd.GeoDataFrame\n", + " geodataframe holding spatial and attribute data\n", + "variable: str\n", + " column on the geodataframe used to compute autocorrelation statistic\n", + "distances : list\n", + " list of distances to compute the autocorrelation statistic\n", + "distance_type : str, optional\n", + " which concept of distance to increment. Options are {`band`, `knn`}.\n", + " by default 'band' (for `libpysal.weights.DistanceBand` weights)\n", + "statistic : str, by default 'I'\n", + " which spatial autocorrelation statistic to compute. Options in {`I`, `G`, `C`}\n", + "weights_kwargs : dict\n", + " additional keyword arguments passed to the libpysal.weights.W class\n", + "stat_kwargs : dict\n", + " additional keyword arguments passed to the `esda` autocorrelation statistic class.\n", + " For example for faster results with no statistical inference, set the nuumber\n", + " of permutations to zero with {permutations: 0}\n", + "n_jobs : int\n", + " number of jobs to pass to joblib. If -1 (default), all cores will be used\n", + "backend : str\n", + " backend parameter passed to joblb\n", + "\n", + "Returns\n", + "-------\n", + "outputs : pandas.DataFrame\n", + " table of autocorrelation statistics at increasing distance bandwidths\n", + "\u001b[0;31mFile:\u001b[0m ~/Dropbox/projects/esda/esda/correlogram.py\n", + "\u001b[0;31mType:\u001b[0m function" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "correlogram?" + ] + }, + { + "cell_type": "markdown", + "id": "d77ee874-e889-4d60-a039-434906696451", + "metadata": {}, + "source": [ + "## Distance Bands" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "9d546402-f9c8-407c-945e-b72979fc9df8", + "metadata": { + "execution": { + "iopub.execute_input": "2023-07-20T22:49:20.361041Z", + "iopub.status.busy": "2023-07-20T22:49:20.360937Z", + "iopub.status.idle": "2023-07-20T22:49:21.867643Z", + "shell.execute_reply": "2023-07-20T22:49:21.866722Z", + "shell.execute_reply.started": "2023-07-20T22:49:20.361032Z" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "corr = correlogram(sac, 'HH_INC', distances)" + ] + }, + { + "cell_type": "markdown", + "id": "5187da59-aba0-465d-9fa7-e22794c8eb1a", + "metadata": {}, + "source": [ + "Corr is a dataframe of autocorrelation statistics indexed by distance" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "af5bad37-874a-483b-a692-a3ae205416f8", + "metadata": { + "execution": { + "iopub.execute_input": "2023-07-20T22:49:21.868855Z", + "iopub.status.busy": "2023-07-20T22:49:21.868719Z", + "iopub.status.idle": "2023-07-20T22:49:21.927474Z", + "shell.execute_reply": "2023-07-20T22:49:21.927066Z", + "shell.execute_reply.started": "2023-07-20T22:49:21.868843Z" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
z2ssEIVI_normseI_normVI_randseI_randIz_normz_randp_normp_randp_simEI_simseI_simVI_simz_simp_z_sim
5001.260604e+11-0.0024880.4975340.7053610.4962390.7044420.0582270.0860760.0861889.314058e-019.313166e-010.432-0.0193140.6846360.4687260.1132604.549124e-01
10001.260604e+11-0.0024880.0142590.1194090.0142210.1192540.4920694.1416864.1470883.447621e-053.367309e-050.0010.0000390.1165760.0135904.2206841.217809e-05
15001.260604e+11-0.0024880.0045860.0677190.0045740.0676310.4549426.7548086.7636201.430242e-111.345857e-110.001-0.0021120.0686210.0047096.6605951.363609e-11
20001.260604e+11-0.0024880.0021640.0465150.0021580.0464540.56259112.14844812.1642985.846476e-344.815656e-340.001-0.0034130.0454440.00206512.4551236.557497e-36
25001.260604e+11-0.0024880.0014810.0384830.0014770.0384330.50109113.08569813.1027713.974924e-393.174519e-390.001-0.0017980.0375700.00141213.3852783.686049e-41
30001.260604e+11-0.0024880.0011580.0340250.0011550.0339810.51010015.06498415.0846392.752332e-512.043904e-510.001-0.0019510.0342260.00117114.9608406.617265e-51
35001.260604e+11-0.0024880.0009000.0299940.0008970.0299550.51204617.15452917.1768925.813950e-663.955413e-660.001-0.0030330.0299700.00089817.1865301.674951e-66
40001.260604e+11-0.0024880.0007550.0274790.0007530.0274430.46538617.02686917.0490565.190784e-653.552242e-650.001-0.0028350.0271390.00073717.2526225.346716e-67
45001.260604e+11-0.0024880.0007380.0271750.0007370.0271400.46304017.13055517.1529018.781368e-665.979201e-660.001-0.0010660.0272260.00074117.0461131.867826e-65
50001.260604e+11-0.0024880.0006760.0260070.0006750.0259730.42898416.59055516.6121998.156288e-625.686988e-620.001-0.0030130.0274450.00075315.7405443.987723e-56
\n", + "
" + ], + "text/plain": [ + " z2ss EI VI_norm seI_norm VI_rand seI_rand \\\n", + "500 1.260604e+11 -0.002488 0.497534 0.705361 0.496239 0.704442 \n", + "1000 1.260604e+11 -0.002488 0.014259 0.119409 0.014221 0.119254 \n", + "1500 1.260604e+11 -0.002488 0.004586 0.067719 0.004574 0.067631 \n", + "2000 1.260604e+11 -0.002488 0.002164 0.046515 0.002158 0.046454 \n", + "2500 1.260604e+11 -0.002488 0.001481 0.038483 0.001477 0.038433 \n", + "3000 1.260604e+11 -0.002488 0.001158 0.034025 0.001155 0.033981 \n", + "3500 1.260604e+11 -0.002488 0.000900 0.029994 0.000897 0.029955 \n", + "4000 1.260604e+11 -0.002488 0.000755 0.027479 0.000753 0.027443 \n", + "4500 1.260604e+11 -0.002488 0.000738 0.027175 0.000737 0.027140 \n", + "5000 1.260604e+11 -0.002488 0.000676 0.026007 0.000675 0.025973 \n", + "\n", + " I z_norm z_rand p_norm p_rand p_sim \\\n", + "500 0.058227 0.086076 0.086188 9.314058e-01 9.313166e-01 0.432 \n", + "1000 0.492069 4.141686 4.147088 3.447621e-05 3.367309e-05 0.001 \n", + "1500 0.454942 6.754808 6.763620 1.430242e-11 1.345857e-11 0.001 \n", + "2000 0.562591 12.148448 12.164298 5.846476e-34 4.815656e-34 0.001 \n", + "2500 0.501091 13.085698 13.102771 3.974924e-39 3.174519e-39 0.001 \n", + "3000 0.510100 15.064984 15.084639 2.752332e-51 2.043904e-51 0.001 \n", + "3500 0.512046 17.154529 17.176892 5.813950e-66 3.955413e-66 0.001 \n", + "4000 0.465386 17.026869 17.049056 5.190784e-65 3.552242e-65 0.001 \n", + "4500 0.463040 17.130555 17.152901 8.781368e-66 5.979201e-66 0.001 \n", + "5000 0.428984 16.590555 16.612199 8.156288e-62 5.686988e-62 0.001 \n", + "\n", + " EI_sim seI_sim VI_sim z_sim p_z_sim \n", + "500 -0.019314 0.684636 0.468726 0.113260 4.549124e-01 \n", + "1000 0.000039 0.116576 0.013590 4.220684 1.217809e-05 \n", + "1500 -0.002112 0.068621 0.004709 6.660595 1.363609e-11 \n", + "2000 -0.003413 0.045444 0.002065 12.455123 6.557497e-36 \n", + "2500 -0.001798 0.037570 0.001412 13.385278 3.686049e-41 \n", + "3000 -0.001951 0.034226 0.001171 14.960840 6.617265e-51 \n", + "3500 -0.003033 0.029970 0.000898 17.186530 1.674951e-66 \n", + "4000 -0.002835 0.027139 0.000737 17.252622 5.346716e-67 \n", + "4500 -0.001066 0.027226 0.000741 17.046113 1.867826e-65 \n", + "5000 -0.003013 0.027445 0.000753 15.740544 3.987723e-56 " + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "corr" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "d82a3e65-4cfd-43d7-990c-2dde5fb23ee9", + "metadata": { + "execution": { + "iopub.execute_input": "2023-07-20T22:49:21.928184Z", + "iopub.status.busy": "2023-07-20T22:49:21.928063Z", + "iopub.status.idle": "2023-07-20T22:49:22.518997Z", + "shell.execute_reply": "2023-07-20T22:49:22.518633Z", + "shell.execute_reply.started": "2023-07-20T22:49:21.928172Z" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 413, + "width": 547 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "corr.I.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "511b4ce9-9c68-4142-a6b7-f202b39a9951", + "metadata": { + "execution": { + "iopub.execute_input": "2023-07-20T22:49:22.519810Z", + "iopub.status.busy": "2023-07-20T22:49:22.519649Z", + "iopub.status.idle": "2023-07-20T22:49:22.696759Z", + "shell.execute_reply": "2023-07-20T22:49:22.696420Z", + "shell.execute_reply.started": "2023-07-20T22:49:22.519800Z" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "corr = correlogram(sac, 'HH_INC', distances, statistic='C')" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "8586e477-faac-434c-90e3-fbc34e044375", + "metadata": { + "execution": { + "iopub.execute_input": "2023-07-20T22:49:22.697318Z", + "iopub.status.busy": "2023-07-20T22:49:22.697218Z", + "iopub.status.idle": "2023-07-20T22:49:22.811351Z", + "shell.execute_reply": "2023-07-20T22:49:22.810994Z", + "shell.execute_reply.started": "2023-07-20T22:49:22.697308Z" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 413, + "width": 556 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "corr.C.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "d9984fc2-400b-4561-9158-c2a28ac25476", + "metadata": { + "execution": { + "iopub.execute_input": "2023-07-20T22:49:22.812136Z", + "iopub.status.busy": "2023-07-20T22:49:22.811979Z", + "iopub.status.idle": "2023-07-20T22:49:22.960098Z", + "shell.execute_reply": "2023-07-20T22:49:22.959785Z", + "shell.execute_reply.started": "2023-07-20T22:49:22.812116Z" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/knaaptime/Dropbox/projects/esda/esda/getisord.py:168: RuntimeWarning: overflow encountered in long_scalars\n", + " EG2 = b0 * (sum(y2) ** 2) + b1 * sum(y4) + b2 * (sum(y) ** 2) * sum(y2)\n", + "/Users/knaaptime/Dropbox/projects/esda/esda/getisord.py:171: RuntimeWarning: overflow encountered in long_scalars\n", + " EG2DEN = ((sum(y) ** 2 - sum(y2)) ** 2) * n * (n - 1) * (n - 2) * (n - 3)\n", + "/Users/knaaptime/Dropbox/projects/esda/esda/getisord.py:168: RuntimeWarning: overflow encountered in long_scalars\n", + " EG2 = b0 * (sum(y2) ** 2) + b1 * sum(y4) + b2 * (sum(y) ** 2) * sum(y2)\n", + "/Users/knaaptime/Dropbox/projects/esda/esda/getisord.py:171: RuntimeWarning: overflow encountered in long_scalars\n", + " EG2DEN = ((sum(y) ** 2 - sum(y2)) ** 2) * n * (n - 1) * (n - 2) * (n - 3)\n", + "/Users/knaaptime/Dropbox/projects/esda/esda/getisord.py:126: RuntimeWarning: invalid value encountered in sqrt\n", + " self.z_norm = (self.G - self.EG) / np.sqrt(self.VG)\n", + "/Users/knaaptime/Dropbox/projects/esda/esda/getisord.py:168: RuntimeWarning: overflow encountered in long_scalars\n", + " EG2 = b0 * (sum(y2) ** 2) + b1 * sum(y4) + b2 * (sum(y) ** 2) * sum(y2)\n", + "/Users/knaaptime/Dropbox/projects/esda/esda/getisord.py:171: RuntimeWarning: overflow encountered in long_scalars\n", + " EG2DEN = ((sum(y) ** 2 - sum(y2)) ** 2) * n * (n - 1) * (n - 2) * (n - 3)\n", + "/Users/knaaptime/Dropbox/projects/esda/esda/getisord.py:126: RuntimeWarning: invalid value encountered in sqrt\n", + " self.z_norm = (self.G - self.EG) / np.sqrt(self.VG)\n", + "/Users/knaaptime/Dropbox/projects/esda/esda/getisord.py:168: RuntimeWarning: overflow encountered in long_scalars\n", + " EG2 = b0 * (sum(y2) ** 2) + b1 * sum(y4) + b2 * (sum(y) ** 2) * sum(y2)\n", + "/Users/knaaptime/Dropbox/projects/esda/esda/getisord.py:171: RuntimeWarning: overflow encountered in long_scalars\n", + " EG2DEN = ((sum(y) ** 2 - sum(y2)) ** 2) * n * (n - 1) * (n - 2) * (n - 3)\n", + "/Users/knaaptime/Dropbox/projects/esda/esda/getisord.py:168: RuntimeWarning: overflow encountered in long_scalars\n", + " EG2 = b0 * (sum(y2) ** 2) + b1 * sum(y4) + b2 * (sum(y) ** 2) * sum(y2)\n", + "/Users/knaaptime/Dropbox/projects/esda/esda/getisord.py:171: RuntimeWarning: overflow encountered in long_scalars\n", + " EG2DEN = ((sum(y) ** 2 - sum(y2)) ** 2) * n * (n - 1) * (n - 2) * (n - 3)\n", + "/Users/knaaptime/Dropbox/projects/esda/esda/getisord.py:168: RuntimeWarning: overflow encountered in long_scalars\n", + " EG2 = b0 * (sum(y2) ** 2) + b1 * sum(y4) + b2 * (sum(y) ** 2) * sum(y2)\n", + "/Users/knaaptime/Dropbox/projects/esda/esda/getisord.py:171: RuntimeWarning: overflow encountered in long_scalars\n", + " EG2DEN = ((sum(y) ** 2 - sum(y2)) ** 2) * n * (n - 1) * (n - 2) * (n - 3)\n", + "/Users/knaaptime/Dropbox/projects/esda/esda/getisord.py:168: RuntimeWarning: overflow encountered in long_scalars\n", + " EG2 = b0 * (sum(y2) ** 2) + b1 * sum(y4) + b2 * (sum(y) ** 2) * sum(y2)\n", + "/Users/knaaptime/Dropbox/projects/esda/esda/getisord.py:171: RuntimeWarning: overflow encountered in long_scalars\n", + " EG2DEN = ((sum(y) ** 2 - sum(y2)) ** 2) * n * (n - 1) * (n - 2) * (n - 3)\n", + "/Users/knaaptime/Dropbox/projects/esda/esda/getisord.py:168: RuntimeWarning: overflow encountered in long_scalars\n", + " EG2 = b0 * (sum(y2) ** 2) + b1 * sum(y4) + b2 * (sum(y) ** 2) * sum(y2)\n", + "/Users/knaaptime/Dropbox/projects/esda/esda/getisord.py:171: RuntimeWarning: overflow encountered in long_scalars\n", + " EG2DEN = ((sum(y) ** 2 - sum(y2)) ** 2) * n * (n - 1) * (n - 2) * (n - 3)\n", + "/Users/knaaptime/Dropbox/projects/esda/esda/getisord.py:168: RuntimeWarning: overflow encountered in long_scalars\n", + " EG2 = b0 * (sum(y2) ** 2) + b1 * sum(y4) + b2 * (sum(y) ** 2) * sum(y2)\n", + "/Users/knaaptime/Dropbox/projects/esda/esda/getisord.py:171: RuntimeWarning: overflow encountered in long_scalars\n", + " EG2DEN = ((sum(y) ** 2 - sum(y2)) ** 2) * n * (n - 1) * (n - 2) * (n - 3)\n", + "/Users/knaaptime/Dropbox/projects/esda/esda/getisord.py:168: RuntimeWarning: overflow encountered in long_scalars\n", + " EG2 = b0 * (sum(y2) ** 2) + b1 * sum(y4) + b2 * (sum(y) ** 2) * sum(y2)\n", + "/Users/knaaptime/Dropbox/projects/esda/esda/getisord.py:171: RuntimeWarning: overflow encountered in long_scalars\n", + " EG2DEN = ((sum(y) ** 2 - sum(y2)) ** 2) * n * (n - 1) * (n - 2) * (n - 3)\n" + ] + } + ], + "source": [ + "corr = correlogram(sac, 'HH_INC', distances, statistic='G')" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "61cb28fd-2e07-44df-8b25-b11b4b06e9f4", + "metadata": { + "execution": { + "iopub.execute_input": "2023-07-20T22:49:22.960762Z", + "iopub.status.busy": "2023-07-20T22:49:22.960655Z", + "iopub.status.idle": "2023-07-20T22:49:23.079355Z", + "shell.execute_reply": "2023-07-20T22:49:23.079008Z", + "shell.execute_reply.started": "2023-07-20T22:49:22.960752Z" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 413, + "width": 565 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "corr.G.plot()" + ] + }, + { + "cell_type": "markdown", + "id": "9d885279-a3d6-45bf-ad17-2eff155cff76", + "metadata": {}, + "source": [ + "## KNN Distance" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "42a8033a-9058-4e92-80c9-939a13e83a5b", + "metadata": { + "execution": { + "iopub.execute_input": "2023-07-20T22:49:23.079937Z", + "iopub.status.busy": "2023-07-20T22:49:23.079843Z", + "iopub.status.idle": "2023-07-20T22:49:23.122936Z", + "shell.execute_reply": "2023-07-20T22:49:23.122493Z", + "shell.execute_reply.started": "2023-07-20T22:49:23.079928Z" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "kdists = list(range(1,50))" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "772cc3aa-1aae-4faf-bac1-b51b4d774a9e", + "metadata": { + "execution": { + "iopub.execute_input": "2023-07-20T22:49:23.123739Z", + "iopub.status.busy": "2023-07-20T22:49:23.123603Z", + "iopub.status.idle": "2023-07-20T22:49:23.498167Z", + "shell.execute_reply": "2023-07-20T22:49:23.497650Z", + "shell.execute_reply.started": "2023-07-20T22:49:23.123728Z" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "kcorr = correlogram(sac, \"HH_INC\", kdists, distance_type='knn')" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "fd15a2dc-437e-436d-af31-745b09369209", + "metadata": { + "execution": { + "iopub.execute_input": "2023-07-20T22:49:23.498734Z", + "iopub.status.busy": "2023-07-20T22:49:23.498627Z", + "iopub.status.idle": "2023-07-20T22:49:23.619852Z", + "shell.execute_reply": "2023-07-20T22:49:23.619490Z", + "shell.execute_reply.started": "2023-07-20T22:49:23.498724Z" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 413, + "width": 556 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "kcorr.I.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6ce895b3-7af7-4c16-94b0-7f4a724e55ea", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python [conda env:esda]", + "language": "python", + "name": "conda-env-esda-py" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.11" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "state": {}, + "version_major": 2, + "version_minor": 0 + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 5e7807eb4b9b3bde281bbb69b6369993c05e33b4 Mon Sep 17 00:00:00 2001 From: eli knaap Date: Thu, 27 Jul 2023 15:56:28 -0700 Subject: [PATCH 02/17] add comment to include geoda version --- esda/correlogram.py | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/esda/correlogram.py b/esda/correlogram.py index 5d53cdf8..d6eb84b3 100644 --- a/esda/correlogram.py +++ b/esda/correlogram.py @@ -142,3 +142,9 @@ def correlogram( .select_dtypes(["number"]) .drop(columns=["permutations", "n"]) ) + + +## Note: To be implemented: + +## non-parametric version used in geoda https://geodacenter.github.io/workbook/5a_global_auto/lab5a.html#spatial-correlogram +## as given in https://link.springer.com/article/10.1023/A:1009601932481' \ No newline at end of file From 59f41b2f7850591c9b49d80e3d8cc580e3476845 Mon Sep 17 00:00:00 2001 From: eli knaap Date: Thu, 3 Aug 2023 16:02:59 -0700 Subject: [PATCH 03/17] add correlogram test --- .gitignore | 1 - esda/tests/test_correlogram.py | 19 +++++++++++++++++++ 2 files changed, 19 insertions(+), 1 deletion(-) create mode 100644 esda/tests/test_correlogram.py diff --git a/.gitignore b/.gitignore index bef761d3..1d3af4d2 100644 --- a/.gitignore +++ b/.gitignore @@ -56,7 +56,6 @@ notebooks/splot.ipynb notebooks/test.ipynb pysal_data/ spdep-geary.ipynb -tests/ tools/changelog.md tools/changelog_2.0.0.md tools/changelog_2.0.1.md diff --git a/esda/tests/test_correlogram.py b/esda/tests/test_correlogram.py new file mode 100644 index 00000000..27e8e538 --- /dev/null +++ b/esda/tests/test_correlogram.py @@ -0,0 +1,19 @@ +from libpysal import examples +from esda import correlogram +import numpy as np +from numpy.testing import assert_array_almost_equal + +import geopandas as gpd + +sac = gpd.read_file(examples.load_example("Sacramento1").get_path("sacramentot2.shp")) +sac = sac.to_crs(sac.estimate_utm_crs()) # now in meters) + +distances = [i + 500 for i in range(0, 2000, 500)] + +corr = correlogram(sac, "HH_INC", distances) + +test_data = np.array( + [0.05822723177762817, 0.49206877942505206, 0.45494217612839183, 0.5625914469490942] +) + +assert_array_almost_equal(corr.I, test_data) From 062560c660c567b52065b61cc6a424e190ab505f Mon Sep 17 00:00:00 2001 From: eli knaap Date: Thu, 3 Aug 2023 16:07:58 -0700 Subject: [PATCH 04/17] typos, test func --- esda/correlogram.py | 9 ++++----- esda/tests/test_correlogram.py | 13 ++++++++----- 2 files changed, 12 insertions(+), 10 deletions(-) diff --git a/esda/correlogram.py b/esda/correlogram.py index d6eb84b3..f3ae5e7c 100644 --- a/esda/correlogram.py +++ b/esda/correlogram.py @@ -2,7 +2,6 @@ import geopandas as gpd import pandas as pd -import numpy as np from joblib import Parallel, delayed from libpysal.cg.kdtree import KDTree from libpysal.weights import KNN, DistanceBand @@ -75,12 +74,12 @@ def correlogram( additional keyword arguments passed to the libpysal.weights.W class stat_kwargs : dict additional keyword arguments passed to the `esda` autocorrelation statistic class. - For example for faster results with no statistical inference, set the nuumber + For example for faster results with no statistical inference, set the number of permutations to zero with {permutations: 0} n_jobs : int number of jobs to pass to joblib. If -1 (default), all cores will be used backend : str - backend parameter passed to joblb + backend parameter passed to joblib Returns ------- @@ -144,7 +143,7 @@ def correlogram( ) -## Note: To be implemented: +## Note: To be implemented: ## non-parametric version used in geoda https://geodacenter.github.io/workbook/5a_global_auto/lab5a.html#spatial-correlogram -## as given in https://link.springer.com/article/10.1023/A:1009601932481' \ No newline at end of file +## as given in https://link.springer.com/article/10.1023/A:1009601932481' diff --git a/esda/tests/test_correlogram.py b/esda/tests/test_correlogram.py index 27e8e538..c2533320 100644 --- a/esda/tests/test_correlogram.py +++ b/esda/tests/test_correlogram.py @@ -5,15 +5,18 @@ import geopandas as gpd + sac = gpd.read_file(examples.load_example("Sacramento1").get_path("sacramentot2.shp")) sac = sac.to_crs(sac.estimate_utm_crs()) # now in meters) distances = [i + 500 for i in range(0, 2000, 500)] -corr = correlogram(sac, "HH_INC", distances) +def test_correlogram(): + + corr = correlogram(sac, "HH_INC", distances) -test_data = np.array( - [0.05822723177762817, 0.49206877942505206, 0.45494217612839183, 0.5625914469490942] -) + test_data = np.array( + [0.05822723177762817, 0.49206877942505206, 0.45494217612839183, 0.5625914469490942] + ) -assert_array_almost_equal(corr.I, test_data) + assert_array_almost_equal(corr.I, test_data) From 3b2009676749cabfdd406879eee6029a40fa60c6 Mon Sep 17 00:00:00 2001 From: eli knaap Date: Thu, 3 Aug 2023 16:28:19 -0700 Subject: [PATCH 05/17] add explanation and some notebook text --- esda/correlogram.py | 4 + notebooks/correlogram.ipynb | 657 ++++++++++++++++++++++-------------- 2 files changed, 408 insertions(+), 253 deletions(-) diff --git a/esda/correlogram.py b/esda/correlogram.py index f3ae5e7c..c5c0e301 100644 --- a/esda/correlogram.py +++ b/esda/correlogram.py @@ -57,6 +57,10 @@ def correlogram( ): """Generate a spatial correlogram + A spatial correlogram is a set of spatial autocorrelation statistics calculated for + a set of increasing distances. It is a useful exploratory tool for examining + how the relationship between spatial units changes over different notions of scale. + Parameters ---------- gdf : gpd.GeoDataFrame diff --git a/notebooks/correlogram.ipynb b/notebooks/correlogram.ipynb index c125ae33..3a86c795 100644 --- a/notebooks/correlogram.ipynb +++ b/notebooks/correlogram.ipynb @@ -6,16 +6,43 @@ "id": "0c88261c-c8d4-4638-a727-60d833b7d111", "metadata": { "execution": { - "iopub.execute_input": "2023-07-20T22:49:18.712153Z", - "iopub.status.busy": "2023-07-20T22:49:18.711912Z", - "iopub.status.idle": "2023-07-20T22:49:19.589892Z", - "shell.execute_reply": "2023-07-20T22:49:19.589387Z", - "shell.execute_reply.started": "2023-07-20T22:49:18.712128Z" + "iopub.execute_input": "2023-08-03T23:17:14.119270Z", + "iopub.status.busy": "2023-08-03T23:17:14.119197Z", + "iopub.status.idle": "2023-08-03T23:17:15.653710Z", + "shell.execute_reply": "2023-08-03T23:17:15.653322Z", + "shell.execute_reply.started": "2023-08-03T23:17:14.119261Z" }, "tags": [] }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Author: eli knaap\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:38: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", + " @jit\n", + "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:164: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", + " @jit\n", + "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:198: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", + " @jit\n", + "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:260: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", + " @jit\n", + "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/numba/core/decorators.py:282: RuntimeWarning: nopython is set for njit and is ignored\n", + " warnings.warn('nopython is set for njit and is ignored', RuntimeWarning)\n" + ] + } + ], "source": [ + "%load_ext watermark\n", + "%watermark -a 'eli knaap'\n", "%load_ext autoreload\n", "%autoreload 2\n", "\n", @@ -31,26 +58,15 @@ "id": "68d86eb6-8595-48f0-a244-8889c59e770d", "metadata": { "execution": { - "iopub.execute_input": "2023-07-20T22:49:19.591487Z", - "iopub.status.busy": "2023-07-20T22:49:19.591218Z", - "iopub.status.idle": "2023-07-20T22:49:20.094875Z", - "shell.execute_reply": "2023-07-20T22:49:20.094527Z", - "shell.execute_reply.started": "2023-07-20T22:49:19.591478Z" + "iopub.execute_input": "2023-08-03T23:17:15.655111Z", + "iopub.status.busy": "2023-08-03T23:17:15.654916Z", + "iopub.status.idle": "2023-08-03T23:17:15.875563Z", + "shell.execute_reply": "2023-08-03T23:17:15.875259Z", + "shell.execute_reply.started": "2023-08-03T23:17:15.655098Z" }, "tags": [] }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Example not available: Sacramento1\n", - "Example not downloaded: Chicago parcels\n", - "Example not downloaded: Chile Migration\n", - "Example not downloaded: Spirals\n" - ] - } - ], + "outputs": [], "source": [ "sac = gpd.read_file(examples.load_example(\"Sacramento1\").get_path(\"sacramentot2.shp\"))" ] @@ -61,11 +77,11 @@ "id": "2650732f-b704-4af8-bfee-ccd8c75cf133", "metadata": { "execution": { - "iopub.execute_input": "2023-07-20T22:49:20.095433Z", - "iopub.status.busy": "2023-07-20T22:49:20.095333Z", - "iopub.status.idle": "2023-07-20T22:49:20.222852Z", - "shell.execute_reply": "2023-07-20T22:49:20.222561Z", - "shell.execute_reply.started": "2023-07-20T22:49:20.095423Z" + "iopub.execute_input": "2023-08-03T23:17:15.876077Z", + "iopub.status.busy": "2023-08-03T23:17:15.875986Z", + "iopub.status.idle": "2023-08-03T23:17:15.953792Z", + "shell.execute_reply": "2023-08-03T23:17:15.953427Z", + "shell.execute_reply.started": "2023-08-03T23:17:15.876067Z" }, "tags": [] }, @@ -76,64 +92,15 @@ }, { "cell_type": "code", - "execution_count": 4, - "id": "ab615631-b083-4700-b402-8dd8343cc790", - "metadata": { - "execution": { - "iopub.execute_input": "2023-07-20T22:49:20.223564Z", - "iopub.status.busy": "2023-07-20T22:49:20.223461Z", - "iopub.status.idle": "2023-07-20T22:49:20.262911Z", - "shell.execute_reply": "2023-07-20T22:49:20.262441Z", - "shell.execute_reply.started": "2023-07-20T22:49:20.223555Z" - }, - "tags": [] - }, - "outputs": [], - "source": [ - "distances = [i+500 for i in range(0,5000, 500)]" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "049e4002-52a1-4205-9238-bfdb175f04ff", - "metadata": { - "execution": { - "iopub.execute_input": "2023-07-20T22:49:20.263491Z", - "iopub.status.busy": "2023-07-20T22:49:20.263397Z", - "iopub.status.idle": "2023-07-20T22:49:20.300614Z", - "shell.execute_reply": "2023-07-20T22:49:20.300307Z", - "shell.execute_reply.started": "2023-07-20T22:49:20.263481Z" - }, - "tags": [] - }, - "outputs": [ - { - "data": { - "text/plain": [ - "[500, 1000, 1500, 2000, 2500, 3000, 3500, 4000, 4500, 5000]" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "distances" - ] - }, - { - "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "id": "d3b1de58-3fb4-4874-ae5b-63f5e03f869d", "metadata": { "execution": { - "iopub.execute_input": "2023-07-20T22:49:20.301206Z", - "iopub.status.busy": "2023-07-20T22:49:20.301109Z", - "iopub.status.idle": "2023-07-20T22:49:20.358953Z", - "shell.execute_reply": "2023-07-20T22:49:20.358487Z", - "shell.execute_reply.started": "2023-07-20T22:49:20.301198Z" + "iopub.execute_input": "2023-08-03T23:17:16.046262Z", + "iopub.status.busy": "2023-08-03T23:17:16.046130Z", + "iopub.status.idle": "2023-08-03T23:17:16.093964Z", + "shell.execute_reply": "2023-08-03T23:17:16.093568Z", + "shell.execute_reply.started": "2023-08-03T23:17:16.046251Z" }, "tags": [] }, @@ -156,6 +123,10 @@ "\u001b[0;31mDocstring:\u001b[0m\n", "Generate a spatial correlogram\n", "\n", + "A spatial correlogram is a set of spatial autocorrelation statistics calculated for\n", + "a set of increasing distances. It is a useful exploratory tool for examining\n", + "how the relationship between spatial units changes over different notions of scale.\n", + "\n", "Parameters\n", "----------\n", "gdf : gpd.GeoDataFrame\n", @@ -173,12 +144,12 @@ " additional keyword arguments passed to the libpysal.weights.W class\n", "stat_kwargs : dict\n", " additional keyword arguments passed to the `esda` autocorrelation statistic class.\n", - " For example for faster results with no statistical inference, set the nuumber\n", + " For example for faster results with no statistical inference, set the number\n", " of permutations to zero with {permutations: 0}\n", "n_jobs : int\n", " number of jobs to pass to joblib. If -1 (default), all cores will be used\n", "backend : str\n", - " backend parameter passed to joblb\n", + " backend parameter passed to joblib\n", "\n", "Returns\n", "-------\n", @@ -206,19 +177,185 @@ }, { "cell_type": "code", - "execution_count": 7, - "id": "9d546402-f9c8-407c-945e-b72979fc9df8", + "execution_count": 4, + "id": "ab615631-b083-4700-b402-8dd8343cc790", "metadata": { "execution": { - "iopub.execute_input": "2023-07-20T22:49:20.361041Z", - "iopub.status.busy": "2023-07-20T22:49:20.360937Z", - "iopub.status.idle": "2023-07-20T22:49:21.867643Z", - "shell.execute_reply": "2023-07-20T22:49:21.866722Z", - "shell.execute_reply.started": "2023-07-20T22:49:20.361032Z" + "iopub.execute_input": "2023-08-03T23:17:15.954294Z", + "iopub.status.busy": "2023-08-03T23:17:15.954208Z", + "iopub.status.idle": "2023-08-03T23:17:15.982954Z", + "shell.execute_reply": "2023-08-03T23:17:15.982573Z", + "shell.execute_reply.started": "2023-08-03T23:17:15.954284Z" }, "tags": [] }, "outputs": [], + "source": [ + "# Create a liste of distances between 500 and 5000 (meters, here) in increments of 500\n", + "\n", + "distances = [i+500 for i in range(0,5000, 500)]" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "049e4002-52a1-4205-9238-bfdb175f04ff", + "metadata": { + "execution": { + "iopub.execute_input": "2023-08-03T23:17:16.013401Z", + "iopub.status.busy": "2023-08-03T23:17:16.013302Z", + "iopub.status.idle": "2023-08-03T23:17:16.044125Z", + "shell.execute_reply": "2023-08-03T23:17:16.043717Z", + "shell.execute_reply.started": "2023-08-03T23:17:16.013392Z" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[500, 1000, 1500, 2000, 2500, 3000, 3500, 4000, 4500, 5000]" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "distances" + ] + }, + { + "cell_type": "markdown", + "id": "d5642b21-6e3c-46ed-8c6f-5ada5baec96d", + "metadata": {}, + "source": [ + "The correlogram will compute an autocorrelation statistic (Moran's $I$ by default) at each distance threshold. Plotting this statistic against distance reveals how spatial similarity changes over distance (similar in concept to a variogram)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "9d546402-f9c8-407c-945e-b72979fc9df8", + "metadata": { + "execution": { + "iopub.execute_input": "2023-08-03T23:17:16.094447Z", + "iopub.status.busy": "2023-08-03T23:17:16.094359Z", + "iopub.status.idle": "2023-08-03T23:17:17.640557Z", + "shell.execute_reply": "2023-08-03T23:17:17.640202Z", + "shell.execute_reply.started": "2023-08-03T23:17:16.094438Z" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:38: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", + " @jit\n", + "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:38: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", + " @jit\n", + "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:164: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", + " @jit\n", + "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:164: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", + " @jit\n", + "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:198: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", + " @jit\n", + "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:198: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", + " @jit\n", + "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:260: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", + " @jit\n", + "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:260: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", + " @jit\n", + "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:38: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", + " @jit\n", + "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:164: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", + " @jit\n", + "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:198: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", + " @jit\n", + "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:260: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", + " @jit\n", + "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:38: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", + " @jit\n", + "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:38: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", + " @jit\n", + "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:38: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", + " @jit\n", + "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:164: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", + " @jit\n", + "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:198: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", + " @jit\n", + "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:260: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", + " @jit\n", + "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:164: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", + " @jit\n", + "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:198: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", + " @jit\n", + "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:260: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", + " @jit\n", + "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:164: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", + " @jit\n", + "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:198: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", + " @jit\n", + "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:260: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", + " @jit\n", + "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:38: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", + " @jit\n", + "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:164: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", + " @jit\n", + "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:198: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", + " @jit\n", + "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:260: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", + " @jit\n", + "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:38: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", + " @jit\n", + "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:164: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", + " @jit\n", + "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:198: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", + " @jit\n", + "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:260: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", + " @jit\n", + "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:38: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", + " @jit\n", + "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:38: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", + " @jit\n", + "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:164: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", + " @jit\n", + "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:198: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", + " @jit\n", + "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:260: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", + " @jit\n", + "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:164: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", + " @jit\n", + "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:198: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", + " @jit\n", + "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:260: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", + " @jit\n", + "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/numba/core/decorators.py:282: RuntimeWarning: nopython is set for njit and is ignored\n", + " warnings.warn('nopython is set for njit and is ignored', RuntimeWarning)\n", + "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/numba/core/decorators.py:282: RuntimeWarning: nopython is set for njit and is ignored\n", + " warnings.warn('nopython is set for njit and is ignored', RuntimeWarning)\n", + "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/numba/core/decorators.py:282: RuntimeWarning: nopython is set for njit and is ignored\n", + " warnings.warn('nopython is set for njit and is ignored', RuntimeWarning)\n", + "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/numba/core/decorators.py:282: RuntimeWarning: nopython is set for njit and is ignored\n", + " warnings.warn('nopython is set for njit and is ignored', RuntimeWarning)\n", + "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/numba/core/decorators.py:282: RuntimeWarning: nopython is set for njit and is ignored\n", + " warnings.warn('nopython is set for njit and is ignored', RuntimeWarning)\n", + "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/numba/core/decorators.py:282: RuntimeWarning: nopython is set for njit and is ignored\n", + " warnings.warn('nopython is set for njit and is ignored', RuntimeWarning)\n", + "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/numba/core/decorators.py:282: RuntimeWarning: nopython is set for njit and is ignored\n", + " warnings.warn('nopython is set for njit and is ignored', RuntimeWarning)\n", + "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/numba/core/decorators.py:282: RuntimeWarning: nopython is set for njit and is ignored\n", + " warnings.warn('nopython is set for njit and is ignored', RuntimeWarning)\n", + "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/numba/core/decorators.py:282: RuntimeWarning: nopython is set for njit and is ignored\n", + " warnings.warn('nopython is set for njit and is ignored', RuntimeWarning)\n", + "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/numba/core/decorators.py:282: RuntimeWarning: nopython is set for njit and is ignored\n", + " warnings.warn('nopython is set for njit and is ignored', RuntimeWarning)\n" + ] + } + ], "source": [ "corr = correlogram(sac, 'HH_INC', distances)" ] @@ -228,20 +365,20 @@ "id": "5187da59-aba0-465d-9fa7-e22794c8eb1a", "metadata": {}, "source": [ - "Corr is a dataframe of autocorrelation statistics indexed by distance" + "`corr` is a dataframe of autocorrelation statistics indexed by distance. It includes all attributes created by the esda autocorrelation statistic class (e.g. [Moran](https://pysal.org/esda/generated/esda.Moran.html#esda.Moran), [Geary](https://pysal.org/esda/generated/esda.Geary.html#esda.Geary), or [Geits-Ord G](https://pysal.org/esda/generated/esda.G.html#esda.G)). The row index for each statistic is the distance at which it was computed" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "id": "af5bad37-874a-483b-a692-a3ae205416f8", "metadata": { "execution": { - "iopub.execute_input": "2023-07-20T22:49:21.868855Z", - "iopub.status.busy": "2023-07-20T22:49:21.868719Z", - "iopub.status.idle": "2023-07-20T22:49:21.927474Z", - "shell.execute_reply": "2023-07-20T22:49:21.927066Z", - "shell.execute_reply.started": "2023-07-20T22:49:21.868843Z" + "iopub.execute_input": "2023-08-03T23:17:17.641508Z", + "iopub.status.busy": "2023-08-03T23:17:17.641305Z", + "iopub.status.idle": "2023-08-03T23:17:17.681585Z", + "shell.execute_reply": "2023-08-03T23:17:17.681182Z", + "shell.execute_reply.started": "2023-08-03T23:17:17.641493Z" }, "tags": [] }, @@ -300,12 +437,12 @@ " 0.086188\n", " 9.314058e-01\n", " 9.313166e-01\n", - " 0.432\n", - " -0.019314\n", - " 0.684636\n", - " 0.468726\n", - " 0.113260\n", - " 4.549124e-01\n", + " 0.458\n", + " 0.027403\n", + " 0.727508\n", + " 0.529268\n", + " 0.042369\n", + " 4.831021e-01\n", " \n", " \n", " 1000\n", @@ -321,11 +458,11 @@ " 3.447621e-05\n", " 3.367309e-05\n", " 0.001\n", - " 0.000039\n", - " 0.116576\n", - " 0.013590\n", - " 4.220684\n", - " 1.217809e-05\n", + " -0.008944\n", + " 0.118608\n", + " 0.014068\n", + " 4.224103\n", + " 1.199469e-05\n", " \n", " \n", " 1500\n", @@ -341,11 +478,11 @@ " 1.430242e-11\n", " 1.345857e-11\n", " 0.001\n", - " -0.002112\n", - " 0.068621\n", - " 0.004709\n", - " 6.660595\n", - " 1.363609e-11\n", + " -0.000999\n", + " 0.068681\n", + " 0.004717\n", + " 6.638500\n", + " 1.584454e-11\n", " \n", " \n", " 2000\n", @@ -361,11 +498,11 @@ " 5.846476e-34\n", " 4.815656e-34\n", " 0.001\n", - " -0.003413\n", - " 0.045444\n", - " 0.002065\n", - " 12.455123\n", - " 6.557497e-36\n", + " -0.003165\n", + " 0.045885\n", + " 0.002105\n", + " 12.329971\n", + " 3.123456e-35\n", " \n", " \n", " 2500\n", @@ -381,11 +518,11 @@ " 3.974924e-39\n", " 3.174519e-39\n", " 0.001\n", - " -0.001798\n", - " 0.037570\n", - " 0.001412\n", - " 13.385278\n", - " 3.686049e-41\n", + " -0.000344\n", + " 0.038534\n", + " 0.001485\n", + " 13.012945\n", + " 5.164165e-39\n", " \n", " \n", " 3000\n", @@ -401,11 +538,11 @@ " 2.752332e-51\n", " 2.043904e-51\n", " 0.001\n", - " -0.001951\n", - " 0.034226\n", - " 0.001171\n", - " 14.960840\n", - " 6.617265e-51\n", + " -0.002044\n", + " 0.034211\n", + " 0.001170\n", + " 14.970316\n", + " 5.738734e-51\n", " \n", " \n", " 3500\n", @@ -421,11 +558,11 @@ " 5.813950e-66\n", " 3.955413e-66\n", " 0.001\n", - " -0.003033\n", - " 0.029970\n", - " 0.000898\n", - " 17.186530\n", - " 1.674951e-66\n", + " -0.001840\n", + " 0.028561\n", + " 0.000816\n", + " 17.992425\n", + " 1.116830e-72\n", " \n", " \n", " 4000\n", @@ -441,11 +578,11 @@ " 5.190784e-65\n", " 3.552242e-65\n", " 0.001\n", - " -0.002835\n", - " 0.027139\n", - " 0.000737\n", - " 17.252622\n", - " 5.346716e-67\n", + " -0.002860\n", + " 0.027790\n", + " 0.000772\n", + " 16.849263\n", + " 5.311531e-64\n", " \n", " \n", " 4500\n", @@ -461,11 +598,11 @@ " 8.781368e-66\n", " 5.979201e-66\n", " 0.001\n", - " -0.001066\n", - " 0.027226\n", - " 0.000741\n", - " 17.046113\n", - " 1.867826e-65\n", + " -0.001020\n", + " 0.027315\n", + " 0.000746\n", + " 16.989197\n", + " 4.936597e-65\n", " \n", " \n", " 5000\n", @@ -481,11 +618,11 @@ " 8.156288e-62\n", " 5.686988e-62\n", " 0.001\n", - " -0.003013\n", - " 0.027445\n", - " 0.000753\n", - " 15.740544\n", - " 3.987723e-56\n", + " -0.001263\n", + " 0.026385\n", + " 0.000696\n", + " 16.306799\n", + " 4.415019e-60\n", " \n", " \n", "\n", @@ -505,7 +642,7 @@ "5000 1.260604e+11 -0.002488 0.000676 0.026007 0.000675 0.025973 \n", "\n", " I z_norm z_rand p_norm p_rand p_sim \\\n", - "500 0.058227 0.086076 0.086188 9.314058e-01 9.313166e-01 0.432 \n", + "500 0.058227 0.086076 0.086188 9.314058e-01 9.313166e-01 0.458 \n", "1000 0.492069 4.141686 4.147088 3.447621e-05 3.367309e-05 0.001 \n", "1500 0.454942 6.754808 6.763620 1.430242e-11 1.345857e-11 0.001 \n", "2000 0.562591 12.148448 12.164298 5.846476e-34 4.815656e-34 0.001 \n", @@ -517,19 +654,19 @@ "5000 0.428984 16.590555 16.612199 8.156288e-62 5.686988e-62 0.001 \n", "\n", " EI_sim seI_sim VI_sim z_sim p_z_sim \n", - "500 -0.019314 0.684636 0.468726 0.113260 4.549124e-01 \n", - "1000 0.000039 0.116576 0.013590 4.220684 1.217809e-05 \n", - "1500 -0.002112 0.068621 0.004709 6.660595 1.363609e-11 \n", - "2000 -0.003413 0.045444 0.002065 12.455123 6.557497e-36 \n", - "2500 -0.001798 0.037570 0.001412 13.385278 3.686049e-41 \n", - "3000 -0.001951 0.034226 0.001171 14.960840 6.617265e-51 \n", - "3500 -0.003033 0.029970 0.000898 17.186530 1.674951e-66 \n", - "4000 -0.002835 0.027139 0.000737 17.252622 5.346716e-67 \n", - "4500 -0.001066 0.027226 0.000741 17.046113 1.867826e-65 \n", - "5000 -0.003013 0.027445 0.000753 15.740544 3.987723e-56 " + "500 0.027403 0.727508 0.529268 0.042369 4.831021e-01 \n", + "1000 -0.008944 0.118608 0.014068 4.224103 1.199469e-05 \n", + "1500 -0.000999 0.068681 0.004717 6.638500 1.584454e-11 \n", + "2000 -0.003165 0.045885 0.002105 12.329971 3.123456e-35 \n", + "2500 -0.000344 0.038534 0.001485 13.012945 5.164165e-39 \n", + "3000 -0.002044 0.034211 0.001170 14.970316 5.738734e-51 \n", + "3500 -0.001840 0.028561 0.000816 17.992425 1.116830e-72 \n", + "4000 -0.002860 0.027790 0.000772 16.849263 5.311531e-64 \n", + "4500 -0.001020 0.027315 0.000746 16.989197 4.936597e-65 \n", + "5000 -0.001263 0.026385 0.000696 16.306799 4.415019e-60 " ] }, - "execution_count": 8, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } @@ -538,17 +675,25 @@ "corr" ] }, + { + "cell_type": "markdown", + "id": "fc0196ce-f47d-424b-8ca6-2ef56c25193b", + "metadata": {}, + "source": [ + "Often, it is easiest to visualize the statistic, and the pandas `plot` function will plot a column against the dataframe's index by default" + ] + }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 10, "id": "d82a3e65-4cfd-43d7-990c-2dde5fb23ee9", "metadata": { "execution": { - "iopub.execute_input": "2023-07-20T22:49:21.928184Z", - "iopub.status.busy": "2023-07-20T22:49:21.928063Z", - "iopub.status.idle": "2023-07-20T22:49:22.518997Z", - "shell.execute_reply": "2023-07-20T22:49:22.518633Z", - "shell.execute_reply.started": "2023-07-20T22:49:21.928172Z" + "iopub.execute_input": "2023-08-03T23:17:17.682221Z", + "iopub.status.busy": "2023-08-03T23:17:17.682125Z", + "iopub.status.idle": "2023-08-03T23:17:19.216811Z", + "shell.execute_reply": "2023-08-03T23:17:19.216525Z", + "shell.execute_reply.started": "2023-08-03T23:17:17.682213Z" }, "tags": [] }, @@ -556,16 +701,16 @@ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 9, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -583,17 +728,25 @@ "corr.I.plot()" ] }, + { + "cell_type": "markdown", + "id": "746f27c2-664b-4d75-abb2-5b202d96c4ab", + "metadata": {}, + "source": [ + "Autocorrelation statistics differ in concept, so the shape of the spatial correlogram statistic will vary considerably, based on which statistic is created. For example, we can also plot Geary's $C$" + ] + }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 11, "id": "511b4ce9-9c68-4142-a6b7-f202b39a9951", "metadata": { "execution": { - "iopub.execute_input": "2023-07-20T22:49:22.519810Z", - "iopub.status.busy": "2023-07-20T22:49:22.519649Z", - "iopub.status.idle": "2023-07-20T22:49:22.696759Z", - "shell.execute_reply": "2023-07-20T22:49:22.696420Z", - "shell.execute_reply.started": "2023-07-20T22:49:22.519800Z" + "iopub.execute_input": "2023-08-03T23:17:19.217430Z", + "iopub.status.busy": "2023-08-03T23:17:19.217299Z", + "iopub.status.idle": "2023-08-03T23:17:19.394178Z", + "shell.execute_reply": "2023-08-03T23:17:19.393803Z", + "shell.execute_reply.started": "2023-08-03T23:17:19.217422Z" }, "tags": [] }, @@ -604,15 +757,15 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 12, "id": "8586e477-faac-434c-90e3-fbc34e044375", "metadata": { "execution": { - "iopub.execute_input": "2023-07-20T22:49:22.697318Z", - "iopub.status.busy": "2023-07-20T22:49:22.697218Z", - "iopub.status.idle": "2023-07-20T22:49:22.811351Z", - "shell.execute_reply": "2023-07-20T22:49:22.810994Z", - "shell.execute_reply.started": "2023-07-20T22:49:22.697308Z" + "iopub.execute_input": "2023-08-03T23:17:19.394764Z", + "iopub.status.busy": "2023-08-03T23:17:19.394667Z", + "iopub.status.idle": "2023-08-03T23:17:19.498505Z", + "shell.execute_reply": "2023-08-03T23:17:19.498233Z", + "shell.execute_reply.started": "2023-08-03T23:17:19.394755Z" }, "tags": [] }, @@ -620,16 +773,16 @@ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 11, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -647,17 +800,25 @@ "corr.C.plot()" ] }, + { + "cell_type": "markdown", + "id": "39390947-1cd9-4a4a-9e9b-71bb7c493b39", + "metadata": {}, + "source": [ + "...Or Getis-Ord $G$" + ] + }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 13, "id": "d9984fc2-400b-4561-9158-c2a28ac25476", "metadata": { "execution": { - "iopub.execute_input": "2023-07-20T22:49:22.812136Z", - "iopub.status.busy": "2023-07-20T22:49:22.811979Z", - "iopub.status.idle": "2023-07-20T22:49:22.960098Z", - "shell.execute_reply": "2023-07-20T22:49:22.959785Z", - "shell.execute_reply.started": "2023-07-20T22:49:22.812116Z" + "iopub.execute_input": "2023-08-03T23:17:19.499009Z", + "iopub.status.busy": "2023-08-03T23:17:19.498927Z", + "iopub.status.idle": "2023-08-03T23:17:19.631772Z", + "shell.execute_reply": "2023-08-03T23:17:19.631432Z", + "shell.execute_reply.started": "2023-08-03T23:17:19.499001Z" }, "tags": [] }, @@ -666,49 +827,29 @@ "name": "stderr", "output_type": "stream", "text": [ - "/Users/knaaptime/Dropbox/projects/esda/esda/getisord.py:168: RuntimeWarning: overflow encountered in long_scalars\n", + "/Users/knaaptime/Dropbox/projects/esda/esda/getisord.py:168: RuntimeWarning: overflow encountered in scalar add\n", " EG2 = b0 * (sum(y2) ** 2) + b1 * sum(y4) + b2 * (sum(y) ** 2) * sum(y2)\n", - "/Users/knaaptime/Dropbox/projects/esda/esda/getisord.py:171: RuntimeWarning: overflow encountered in long_scalars\n", + "/Users/knaaptime/Dropbox/projects/esda/esda/getisord.py:171: RuntimeWarning: overflow encountered in scalar multiply\n", " EG2DEN = ((sum(y) ** 2 - sum(y2)) ** 2) * n * (n - 1) * (n - 2) * (n - 3)\n", - "/Users/knaaptime/Dropbox/projects/esda/esda/getisord.py:168: RuntimeWarning: overflow encountered in long_scalars\n", + "/Users/knaaptime/Dropbox/projects/esda/esda/getisord.py:168: RuntimeWarning: overflow encountered in scalar add\n", " EG2 = b0 * (sum(y2) ** 2) + b1 * sum(y4) + b2 * (sum(y) ** 2) * sum(y2)\n", - "/Users/knaaptime/Dropbox/projects/esda/esda/getisord.py:171: RuntimeWarning: overflow encountered in long_scalars\n", + "/Users/knaaptime/Dropbox/projects/esda/esda/getisord.py:171: RuntimeWarning: overflow encountered in scalar multiply\n", " EG2DEN = ((sum(y) ** 2 - sum(y2)) ** 2) * n * (n - 1) * (n - 2) * (n - 3)\n", "/Users/knaaptime/Dropbox/projects/esda/esda/getisord.py:126: RuntimeWarning: invalid value encountered in sqrt\n", " self.z_norm = (self.G - self.EG) / np.sqrt(self.VG)\n", - "/Users/knaaptime/Dropbox/projects/esda/esda/getisord.py:168: RuntimeWarning: overflow encountered in long_scalars\n", + "/Users/knaaptime/Dropbox/projects/esda/esda/getisord.py:168: RuntimeWarning: overflow encountered in scalar add\n", " EG2 = b0 * (sum(y2) ** 2) + b1 * sum(y4) + b2 * (sum(y) ** 2) * sum(y2)\n", - "/Users/knaaptime/Dropbox/projects/esda/esda/getisord.py:171: RuntimeWarning: overflow encountered in long_scalars\n", + "/Users/knaaptime/Dropbox/projects/esda/esda/getisord.py:171: RuntimeWarning: overflow encountered in scalar multiply\n", " EG2DEN = ((sum(y) ** 2 - sum(y2)) ** 2) * n * (n - 1) * (n - 2) * (n - 3)\n", "/Users/knaaptime/Dropbox/projects/esda/esda/getisord.py:126: RuntimeWarning: invalid value encountered in sqrt\n", " self.z_norm = (self.G - self.EG) / np.sqrt(self.VG)\n", - "/Users/knaaptime/Dropbox/projects/esda/esda/getisord.py:168: RuntimeWarning: overflow encountered in long_scalars\n", - " EG2 = b0 * (sum(y2) ** 2) + b1 * sum(y4) + b2 * (sum(y) ** 2) * sum(y2)\n", - "/Users/knaaptime/Dropbox/projects/esda/esda/getisord.py:171: RuntimeWarning: overflow encountered in long_scalars\n", - " EG2DEN = ((sum(y) ** 2 - sum(y2)) ** 2) * n * (n - 1) * (n - 2) * (n - 3)\n", - "/Users/knaaptime/Dropbox/projects/esda/esda/getisord.py:168: RuntimeWarning: overflow encountered in long_scalars\n", + "/Users/knaaptime/Dropbox/projects/esda/esda/getisord.py:168: RuntimeWarning: overflow encountered in scalar add\n", " EG2 = b0 * (sum(y2) ** 2) + b1 * sum(y4) + b2 * (sum(y) ** 2) * sum(y2)\n", - "/Users/knaaptime/Dropbox/projects/esda/esda/getisord.py:171: RuntimeWarning: overflow encountered in long_scalars\n", + "/Users/knaaptime/Dropbox/projects/esda/esda/getisord.py:171: RuntimeWarning: overflow encountered in scalar multiply\n", " EG2DEN = ((sum(y) ** 2 - sum(y2)) ** 2) * n * (n - 1) * (n - 2) * (n - 3)\n", - "/Users/knaaptime/Dropbox/projects/esda/esda/getisord.py:168: RuntimeWarning: overflow encountered in long_scalars\n", + "/Users/knaaptime/Dropbox/projects/esda/esda/getisord.py:168: RuntimeWarning: overflow encountered in scalar add\n", " EG2 = b0 * (sum(y2) ** 2) + b1 * sum(y4) + b2 * (sum(y) ** 2) * sum(y2)\n", - "/Users/knaaptime/Dropbox/projects/esda/esda/getisord.py:171: RuntimeWarning: overflow encountered in long_scalars\n", - " EG2DEN = ((sum(y) ** 2 - sum(y2)) ** 2) * n * (n - 1) * (n - 2) * (n - 3)\n", - "/Users/knaaptime/Dropbox/projects/esda/esda/getisord.py:168: RuntimeWarning: overflow encountered in long_scalars\n", - " EG2 = b0 * (sum(y2) ** 2) + b1 * sum(y4) + b2 * (sum(y) ** 2) * sum(y2)\n", - "/Users/knaaptime/Dropbox/projects/esda/esda/getisord.py:171: RuntimeWarning: overflow encountered in long_scalars\n", - " EG2DEN = ((sum(y) ** 2 - sum(y2)) ** 2) * n * (n - 1) * (n - 2) * (n - 3)\n", - "/Users/knaaptime/Dropbox/projects/esda/esda/getisord.py:168: RuntimeWarning: overflow encountered in long_scalars\n", - " EG2 = b0 * (sum(y2) ** 2) + b1 * sum(y4) + b2 * (sum(y) ** 2) * sum(y2)\n", - "/Users/knaaptime/Dropbox/projects/esda/esda/getisord.py:171: RuntimeWarning: overflow encountered in long_scalars\n", - " EG2DEN = ((sum(y) ** 2 - sum(y2)) ** 2) * n * (n - 1) * (n - 2) * (n - 3)\n", - "/Users/knaaptime/Dropbox/projects/esda/esda/getisord.py:168: RuntimeWarning: overflow encountered in long_scalars\n", - " EG2 = b0 * (sum(y2) ** 2) + b1 * sum(y4) + b2 * (sum(y) ** 2) * sum(y2)\n", - "/Users/knaaptime/Dropbox/projects/esda/esda/getisord.py:171: RuntimeWarning: overflow encountered in long_scalars\n", - " EG2DEN = ((sum(y) ** 2 - sum(y2)) ** 2) * n * (n - 1) * (n - 2) * (n - 3)\n", - "/Users/knaaptime/Dropbox/projects/esda/esda/getisord.py:168: RuntimeWarning: overflow encountered in long_scalars\n", - " EG2 = b0 * (sum(y2) ** 2) + b1 * sum(y4) + b2 * (sum(y) ** 2) * sum(y2)\n", - "/Users/knaaptime/Dropbox/projects/esda/esda/getisord.py:171: RuntimeWarning: overflow encountered in long_scalars\n", + "/Users/knaaptime/Dropbox/projects/esda/esda/getisord.py:171: RuntimeWarning: overflow encountered in scalar multiply\n", " EG2DEN = ((sum(y) ** 2 - sum(y2)) ** 2) * n * (n - 1) * (n - 2) * (n - 3)\n" ] } @@ -719,15 +860,15 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 14, "id": "61cb28fd-2e07-44df-8b25-b11b4b06e9f4", "metadata": { "execution": { - "iopub.execute_input": "2023-07-20T22:49:22.960762Z", - "iopub.status.busy": "2023-07-20T22:49:22.960655Z", - "iopub.status.idle": "2023-07-20T22:49:23.079355Z", - "shell.execute_reply": "2023-07-20T22:49:23.079008Z", - "shell.execute_reply.started": "2023-07-20T22:49:22.960752Z" + "iopub.execute_input": "2023-08-03T23:17:19.632360Z", + "iopub.status.busy": "2023-08-03T23:17:19.632277Z", + "iopub.status.idle": "2023-08-03T23:17:19.742848Z", + "shell.execute_reply": "2023-08-03T23:17:19.742560Z", + "shell.execute_reply.started": "2023-08-03T23:17:19.632352Z" }, "tags": [] }, @@ -735,16 +876,16 @@ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 13, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -770,17 +911,27 @@ "## KNN Distance" ] }, + { + "cell_type": "markdown", + "id": "3db93010-f7d2-45f2-8121-c8ebf0ae71a9", + "metadata": {}, + "source": [ + "It is also possible to consider different concepts of *distance*. For example, rather than stepping through increments of Euclidean distance/length at each interval, we could instead step through increments of nearest-neighbors.\n", + "\n", + "Instead of adding neighbors using sequential distances of 500 meters, here we will step through the 50 nearest neighbors, adding one neighbor at a time" + ] + }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 15, "id": "42a8033a-9058-4e92-80c9-939a13e83a5b", "metadata": { "execution": { - "iopub.execute_input": "2023-07-20T22:49:23.079937Z", - "iopub.status.busy": "2023-07-20T22:49:23.079843Z", - "iopub.status.idle": "2023-07-20T22:49:23.122936Z", - "shell.execute_reply": "2023-07-20T22:49:23.122493Z", - "shell.execute_reply.started": "2023-07-20T22:49:23.079928Z" + "iopub.execute_input": "2023-08-03T23:17:19.743298Z", + "iopub.status.busy": "2023-08-03T23:17:19.743225Z", + "iopub.status.idle": "2023-08-03T23:17:19.774928Z", + "shell.execute_reply": "2023-08-03T23:17:19.774506Z", + "shell.execute_reply.started": "2023-08-03T23:17:19.743290Z" }, "tags": [] }, @@ -791,15 +942,15 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 16, "id": "772cc3aa-1aae-4faf-bac1-b51b4d774a9e", "metadata": { "execution": { - "iopub.execute_input": "2023-07-20T22:49:23.123739Z", - "iopub.status.busy": "2023-07-20T22:49:23.123603Z", - "iopub.status.idle": "2023-07-20T22:49:23.498167Z", - "shell.execute_reply": "2023-07-20T22:49:23.497650Z", - "shell.execute_reply.started": "2023-07-20T22:49:23.123728Z" + "iopub.execute_input": "2023-08-03T23:17:19.775493Z", + "iopub.status.busy": "2023-08-03T23:17:19.775413Z", + "iopub.status.idle": "2023-08-03T23:17:20.190519Z", + "shell.execute_reply": "2023-08-03T23:17:20.190080Z", + "shell.execute_reply.started": "2023-08-03T23:17:19.775485Z" }, "tags": [] }, @@ -810,15 +961,15 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 17, "id": "fd15a2dc-437e-436d-af31-745b09369209", "metadata": { "execution": { - "iopub.execute_input": "2023-07-20T22:49:23.498734Z", - "iopub.status.busy": "2023-07-20T22:49:23.498627Z", - "iopub.status.idle": "2023-07-20T22:49:23.619852Z", - "shell.execute_reply": "2023-07-20T22:49:23.619490Z", - "shell.execute_reply.started": "2023-07-20T22:49:23.498724Z" + "iopub.execute_input": "2023-08-03T23:17:20.191137Z", + "iopub.status.busy": "2023-08-03T23:17:20.191053Z", + "iopub.status.idle": "2023-08-03T23:17:20.299850Z", + "shell.execute_reply": "2023-08-03T23:17:20.299494Z", + "shell.execute_reply.started": "2023-08-03T23:17:20.191127Z" }, "tags": [] }, @@ -826,16 +977,16 @@ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 16, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -878,7 +1029,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.11" + "version": "3.11.4" }, "widgets": { "application/vnd.jupyter.widget-state+json": { From 82a359b79d416921162352cb454c29418fd41e7b Mon Sep 17 00:00:00 2001 From: eli knaap Date: Thu, 27 Jul 2023 16:24:49 -0700 Subject: [PATCH 06/17] update to pyproject --- .github/release.yml | 16 + .gitignore | 1 + pyproject.toml | 109 +++ requirements.txt | 4 - requirements_docs.txt | 6 - requirements_plus.txt | 1 - requirements_tests.txt | 6 - setup.cfg | 20 - setup.py | 80 -- versioneer.py | 2123 ---------------------------------------- 10 files changed, 126 insertions(+), 2240 deletions(-) create mode 100644 .github/release.yml create mode 100644 pyproject.toml delete mode 100644 requirements.txt delete mode 100644 requirements_docs.txt delete mode 100644 requirements_plus.txt delete mode 100644 requirements_tests.txt delete mode 100644 setup.cfg delete mode 100644 setup.py delete mode 100644 versioneer.py diff --git a/.github/release.yml b/.github/release.yml new file mode 100644 index 00000000..f5435449 --- /dev/null +++ b/.github/release.yml @@ -0,0 +1,16 @@ +changelog: + exclude: + labels: + - ignore-for-release + authors: + - dependabot + categories: + - title: Bug Fixes + labels: + - bug + - title: Enhancements + labels: + - enhancement + - title: Other Changes + labels: + - "*" diff --git a/.gitignore b/.gitignore index 1d3af4d2..0caa530b 100644 --- a/.gitignore +++ b/.gitignore @@ -1,6 +1,7 @@ *.pyc .ipynb_checkpoints/ .DS_Store +.vscode/ # Packages *.egg diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 00000000..d5d3da9a --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,109 @@ +[build-system] +requires = ["setuptools>=61.0", "setuptools_scm[toml]>=6.2"] +build-backend = "setuptools.build_meta" + +[tool.setuptools_scm] + +[project] +name = "esda" +dynamic = ["version"] +authors = [ + { name = "Serge Rey", email = "sjsrey@gmail.com" }, + { name = "Levi Wolf", email = "levi.john.wolf@bristol.ac.uk" }, +] +maintainers = [{ name = "esda contributors" }] +license = { text = "BSD 3-Clause" } +description = "Exploratory Spatial Data Analysis in PySAL" +keywords = ["exploratory data analysis, spatial statistics"] +readme = { text = """\ +Exploratory Spatial Data Analysis in PySAL + + +.. _PySAL: http://pysal.org +""", content-type = "text/x-rst" } +classifiers = [ + "Programming Language :: Python :: 3", + "License :: OSI Approved :: BSD License", + "Operating System :: OS Independent", + "Intended Audience :: Science/Research", + "Topic :: Scientific/Engineering :: GIS", +] +requires-python = ">=3.8" +dependencies = [ +"libpysal", +"pandas", +"scikit-learn", +"scipy>=0.11" +] + + +[project.urls] +Home = "https://pysal.org/esda/" +Repository = "https://github.com/pysal/esda" + +[project.optional-dependencies] +tests = [ + "codecov", + "coverage", + "pytest", + "pytest-cov", + "pytest-xdist", + "geopandas" +] +dev = ["pre-commit"] +docs = [ + "nbsphinx", + "numpydoc", + "pandoc", + "sphinx", + "sphinxcontrib-bibtex", + "sphinx_bootstrap_theme", +] +notebooks = [ + "folium", + "matplotlib", + "matplotlib-scalebar", + "seaborn", + "watermark", +] + + +[tool.setuptools.packages.find] +include = ["esda", "esda.*"] + +[tool.black] +line-length = 88 + +[tool.ruff] +line-length = 88 +select = ["E", "F", "W", "I", "UP", "N", "B", "A", "C4", "SIM", "ARG"] +target-version = "py38" +ignore = [ + "B006", + "B008", + "B009", + "B010", + "C408", + "E731", + "F401", + "F403", + "N803", + "N806", + "N999", + "UP007" +] +exclude = ["esda/tests/*", "docs/*"] + +[tool.coverage.run] +source = ["./esda"] + +[tool.coverage.report] +exclude_lines = [ + "if self.debug:", + "pragma: no cover", + "raise NotImplementedError", + "except ModuleNotFoundError:", + "except ImportError", +] +ignore_errors = true +omit = ["esda/tests/*", "docs/conf.py"] \ No newline at end of file diff --git a/requirements.txt b/requirements.txt deleted file mode 100644 index 170bf1e6..00000000 --- a/requirements.txt +++ /dev/null @@ -1,4 +0,0 @@ -libpysal -pandas -scikit-learn -scipy>=0.11 \ No newline at end of file diff --git a/requirements_docs.txt b/requirements_docs.txt deleted file mode 100644 index ade81622..00000000 --- a/requirements_docs.txt +++ /dev/null @@ -1,6 +0,0 @@ -nbsphinx -numpydoc -sphinx -sphinxcontrib-bibtex -sphinxcontrib-napoleon -sphinx_bootstrap_theme diff --git a/requirements_plus.txt b/requirements_plus.txt deleted file mode 100644 index c3db4451..00000000 --- a/requirements_plus.txt +++ /dev/null @@ -1 +0,0 @@ -numba diff --git a/requirements_tests.txt b/requirements_tests.txt deleted file mode 100644 index ee0258fe..00000000 --- a/requirements_tests.txt +++ /dev/null @@ -1,6 +0,0 @@ -codecov -geopandas -pytest -pytest-cov -pytest-xdist -twine diff --git a/setup.cfg b/setup.cfg deleted file mode 100644 index d93df069..00000000 --- a/setup.cfg +++ /dev/null @@ -1,20 +0,0 @@ -[versioneer] -VCS = git -style = pep440 -versionfile_source = esda/_version.py -versionfile_build = esda/_version.py -tag_prefix = v -parentdir_prefix = esda- - -[flake8] -max_line_length = 88 -exclude = docs/conf.py, versioneer.py, esda/_version.py -ignore = - F403, - F405 - -[black] -line-length = 88 - -[isort] -profile = black \ No newline at end of file diff --git a/setup.py b/setup.py deleted file mode 100644 index bfa10167..00000000 --- a/setup.py +++ /dev/null @@ -1,80 +0,0 @@ -# coding: utf-8 -import os -from distutils.command.build_py import build_py - -from setuptools import find_packages, setup - -import versioneer - -package = "esda" - -# BEFORE importing distutils, remove MANIFEST. distutils doesn't properly -# update it when the contents of directories change. -if os.path.exists("MANIFEST"): - os.remove("MANIFEST") - -with open("README.md", "r", encoding="utf8") as file: - long_description = file.read() - - -def _get_requirements_from_files(groups_files): - groups_reqlist = {} - - for k, v in groups_files.items(): - with open(v, "r") as f: - pkg_list = f.read().splitlines() - groups_reqlist[k] = pkg_list - - return groups_reqlist - - -def setup_package(): - # get all file endings and copy whole file names without a file suffix - # assumes nested directories are only down one level - _groups_files = { - "base": "requirements.txt", - "tests": "requirements_tests.txt", - "docs": "requirements_docs.txt", - "plus": "requirements_plus.txt", - } - - reqs = _get_requirements_from_files(_groups_files) - install_reqs = reqs.pop("base") - extras_reqs = reqs - - setup( - name=package, - version=versioneer.get_version(), - cmdclass=versioneer.get_cmdclass({"build_py": build_py}), - description="Exploratory Spatial Data Analysis.", - long_description=long_description, - long_description_content_type="text/markdown", - url=f"https://github.com/pysal/{package}", - maintainer="Serge Rey, Levi Wolf", - maintainer_email="sjsrey@gmail.com,levi.john.wolf@bristol.ac.uk", - keywords="spatial statistics", - classifiers=[ - "Development Status :: 5 - Production/Stable", - "Intended Audience :: Science/Research", - "Intended Audience :: Developers", - "Intended Audience :: Education", - "Topic :: Scientific/Engineering", - "Topic :: Scientific/Engineering :: GIS", - "License :: OSI Approved :: BSD License", - "Programming Language :: Python", - "Programming Language :: Python :: 3.8", - "Programming Language :: Python :: 3.9", - "Programming Language :: Python :: 3.10", - "Programming Language :: Python :: 3.11", - ], - license="3-Clause BSD", - packages=find_packages(), - py_modules=[package], - install_requires=install_reqs, - extras_require=extras_reqs, - zip_safe=False, - ) - - -if __name__ == "__main__": - setup_package() diff --git a/versioneer.py b/versioneer.py deleted file mode 100644 index e283ecbf..00000000 --- a/versioneer.py +++ /dev/null @@ -1,2123 +0,0 @@ -# Version: 0.20 - -"""The Versioneer - like a rocketeer, but for versions. - -The Versioneer -============== - -* like a rocketeer, but for versions! -* https://github.com/python-versioneer/python-versioneer -* Brian Warner -* License: Public Domain -* Compatible with: Python 3.6, 3.7, 3.8, 3.9 and pypy3 -* [![Latest Version][pypi-image]][pypi-url] -* [![Build Status][travis-image]][travis-url] - -This is a tool for managing a recorded version number in distutils-based -python projects. The goal is to remove the tedious and error-prone "update -the embedded version string" step from your release process. Making a new -release should be as easy as recording a new tag in your version-control -system, and maybe making new tarballs. - - -## Quick Install - -* `pip install versioneer` to somewhere in your $PATH -* add a `[versioneer]` section to your setup.cfg (see [Install](INSTALL.md)) -* run `versioneer install` in your source tree, commit the results -* Verify version information with `python setup.py version` - -## Version Identifiers - -Source trees come from a variety of places: - -* a version-control system checkout (mostly used by developers) -* a nightly tarball, produced by build automation -* a snapshot tarball, produced by a web-based VCS browser, like github's - "tarball from tag" feature -* a release tarball, produced by "setup.py sdist", distributed through PyPI - -Within each source tree, the version identifier (either a string or a number, -this tool is format-agnostic) can come from a variety of places: - -* ask the VCS tool itself, e.g. "git describe" (for checkouts), which knows - about recent "tags" and an absolute revision-id -* the name of the directory into which the tarball was unpacked -* an expanded VCS keyword ($Id$, etc) -* a `_version.py` created by some earlier build step - -For released software, the version identifier is closely related to a VCS -tag. Some projects use tag names that include more than just the version -string (e.g. "myproject-1.2" instead of just "1.2"), in which case the tool -needs to strip the tag prefix to extract the version identifier. For -unreleased software (between tags), the version identifier should provide -enough information to help developers recreate the same tree, while also -giving them an idea of roughly how old the tree is (after version 1.2, before -version 1.3). Many VCS systems can report a description that captures this, -for example `git describe --tags --dirty --always` reports things like -"0.7-1-g574ab98-dirty" to indicate that the checkout is one revision past the -0.7 tag, has a unique revision id of "574ab98", and is "dirty" (it has -uncommitted changes). - -The version identifier is used for multiple purposes: - -* to allow the module to self-identify its version: `myproject.__version__` -* to choose a name and prefix for a 'setup.py sdist' tarball - -## Theory of Operation - -Versioneer works by adding a special `_version.py` file into your source -tree, where your `__init__.py` can import it. This `_version.py` knows how to -dynamically ask the VCS tool for version information at import time. - -`_version.py` also contains `$Revision$` markers, and the installation -process marks `_version.py` to have this marker rewritten with a tag name -during the `git archive` command. As a result, generated tarballs will -contain enough information to get the proper version. - -To allow `setup.py` to compute a version too, a `versioneer.py` is added to -the top level of your source tree, next to `setup.py` and the `setup.cfg` -that configures it. This overrides several distutils/setuptools commands to -compute the version when invoked, and changes `setup.py build` and `setup.py -sdist` to replace `_version.py` with a small static file that contains just -the generated version data. - -## Installation - -See [INSTALL.md](./INSTALL.md) for detailed installation instructions. - -## Version-String Flavors - -Code which uses Versioneer can learn about its version string at runtime by -importing `_version` from your main `__init__.py` file and running the -`get_versions()` function. From the "outside" (e.g. in `setup.py`), you can -import the top-level `versioneer.py` and run `get_versions()`. - -Both functions return a dictionary with different flavors of version -information: - -* `['version']`: A condensed version string, rendered using the selected - style. This is the most commonly used value for the project's version - string. The default "pep440" style yields strings like `0.11`, - `0.11+2.g1076c97`, or `0.11+2.g1076c97.dirty`. See the "Styles" section - below for alternative styles. - -* `['full-revisionid']`: detailed revision identifier. For Git, this is the - full SHA1 commit id, e.g. "1076c978a8d3cfc70f408fe5974aa6c092c949ac". - -* `['date']`: Date and time of the latest `HEAD` commit. For Git, it is the - commit date in ISO 8601 format. This will be None if the date is not - available. - -* `['dirty']`: a boolean, True if the tree has uncommitted changes. Note that - this is only accurate if run in a VCS checkout, otherwise it is likely to - be False or None - -* `['error']`: if the version string could not be computed, this will be set - to a string describing the problem, otherwise it will be None. It may be - useful to throw an exception in setup.py if this is set, to avoid e.g. - creating tarballs with a version string of "unknown". - -Some variants are more useful than others. Including `full-revisionid` in a -bug report should allow developers to reconstruct the exact code being tested -(or indicate the presence of local changes that should be shared with the -developers). `version` is suitable for display in an "about" box or a CLI -`--version` output: it can be easily compared against release notes and lists -of bugs fixed in various releases. - -The installer adds the following text to your `__init__.py` to place a basic -version in `YOURPROJECT.__version__`: - - from ._version import get_versions - __version__ = get_versions()['version'] - del get_versions - -## Styles - -The setup.cfg `style=` configuration controls how the VCS information is -rendered into a version string. - -The default style, "pep440", produces a PEP440-compliant string, equal to the -un-prefixed tag name for actual releases, and containing an additional "local -version" section with more detail for in-between builds. For Git, this is -TAG[+DISTANCE.gHEX[.dirty]] , using information from `git describe --tags ---dirty --always`. For example "0.11+2.g1076c97.dirty" indicates that the -tree is like the "1076c97" commit but has uncommitted changes (".dirty"), and -that this commit is two revisions ("+2") beyond the "0.11" tag. For released -software (exactly equal to a known tag), the identifier will only contain the -stripped tag, e.g. "0.11". - -Other styles are available. See [details.md](details.md) in the Versioneer -source tree for descriptions. - -## Debugging - -Versioneer tries to avoid fatal errors: if something goes wrong, it will tend -to return a version of "0+unknown". To investigate the problem, run `setup.py -version`, which will run the version-lookup code in a verbose mode, and will -display the full contents of `get_versions()` (including the `error` string, -which may help identify what went wrong). - -## Known Limitations - -Some situations are known to cause problems for Versioneer. This details the -most significant ones. More can be found on Github -[issues page](https://github.com/python-versioneer/python-versioneer/issues). - -### Subprojects - -Versioneer has limited support for source trees in which `setup.py` is not in -the root directory (e.g. `setup.py` and `.git/` are *not* siblings). The are -two common reasons why `setup.py` might not be in the root: - -* Source trees which contain multiple subprojects, such as - [Buildbot](https://github.com/buildbot/buildbot), which contains both - "master" and "slave" subprojects, each with their own `setup.py`, - `setup.cfg`, and `tox.ini`. Projects like these produce multiple PyPI - distributions (and upload multiple independently-installable tarballs). -* Source trees whose main purpose is to contain a C library, but which also - provide bindings to Python (and perhaps other languages) in subdirectories. - -Versioneer will look for `.git` in parent directories, and most operations -should get the right version string. However `pip` and `setuptools` have bugs -and implementation details which frequently cause `pip install .` from a -subproject directory to fail to find a correct version string (so it usually -defaults to `0+unknown`). - -`pip install --editable .` should work correctly. `setup.py install` might -work too. - -Pip-8.1.1 is known to have this problem, but hopefully it will get fixed in -some later version. - -[Bug #38](https://github.com/python-versioneer/python-versioneer/issues/38) is tracking -this issue. The discussion in -[PR #61](https://github.com/python-versioneer/python-versioneer/pull/61) describes the -issue from the Versioneer side in more detail. -[pip PR#3176](https://github.com/pypa/pip/pull/3176) and -[pip PR#3615](https://github.com/pypa/pip/pull/3615) contain work to improve -pip to let Versioneer work correctly. - -Versioneer-0.16 and earlier only looked for a `.git` directory next to the -`setup.cfg`, so subprojects were completely unsupported with those releases. - -### Editable installs with setuptools <= 18.5 - -`setup.py develop` and `pip install --editable .` allow you to install a -project into a virtualenv once, then continue editing the source code (and -test) without re-installing after every change. - -"Entry-point scripts" (`setup(entry_points={"console_scripts": ..})`) are a -convenient way to specify executable scripts that should be installed along -with the python package. - -These both work as expected when using modern setuptools. When using -setuptools-18.5 or earlier, however, certain operations will cause -`pkg_resources.DistributionNotFound` errors when running the entrypoint -script, which must be resolved by re-installing the package. This happens -when the install happens with one version, then the egg_info data is -regenerated while a different version is checked out. Many setup.py commands -cause egg_info to be rebuilt (including `sdist`, `wheel`, and installing into -a different virtualenv), so this can be surprising. - -[Bug #83](https://github.com/python-versioneer/python-versioneer/issues/83) describes -this one, but upgrading to a newer version of setuptools should probably -resolve it. - - -## Updating Versioneer - -To upgrade your project to a new release of Versioneer, do the following: - -* install the new Versioneer (`pip install -U versioneer` or equivalent) -* edit `setup.cfg`, if necessary, to include any new configuration settings - indicated by the release notes. See [UPGRADING](./UPGRADING.md) for details. -* re-run `versioneer install` in your source tree, to replace - `SRC/_version.py` -* commit any changed files - -## Future Directions - -This tool is designed to make it easily extended to other version-control -systems: all VCS-specific components are in separate directories like -src/git/ . The top-level `versioneer.py` script is assembled from these -components by running make-versioneer.py . In the future, make-versioneer.py -will take a VCS name as an argument, and will construct a version of -`versioneer.py` that is specific to the given VCS. It might also take the -configuration arguments that are currently provided manually during -installation by editing setup.py . Alternatively, it might go the other -direction and include code from all supported VCS systems, reducing the -number of intermediate scripts. - -## Similar projects - -* [setuptools_scm](https://github.com/pypa/setuptools_scm/) - a non-vendored build-time - dependency -* [minver](https://github.com/jbweston/miniver) - a lightweight reimplementation of - versioneer -* [versioningit](https://github.com/jwodder/versioningit) - a PEP 518-based setuptools - plugin - -## License - -To make Versioneer easier to embed, all its code is dedicated to the public -domain. The `_version.py` that it creates is also in the public domain. -Specifically, both are released under the Creative Commons "Public Domain -Dedication" license (CC0-1.0), as described in -https://creativecommons.org/publicdomain/zero/1.0/ . - -[pypi-image]: https://img.shields.io/pypi/v/versioneer.svg -[pypi-url]: https://pypi.python.org/pypi/versioneer/ -[travis-image]: -https://img.shields.io/travis/com/python-versioneer/python-versioneer.svg -[travis-url]: https://travis-ci.com/github/python-versioneer/python-versioneer - -""" - -import configparser -import errno -import json -import os -import re -import subprocess -import sys - - -class VersioneerConfig: # pylint: disable=too-few-public-methods # noqa - """Container for Versioneer configuration parameters.""" - - -def get_root(): - """Get the project root directory. - - We require that all commands are run from the project root, i.e. the - directory that contains setup.py, setup.cfg, and versioneer.py . - """ - root = os.path.realpath(os.path.abspath(os.getcwd())) - setup_py = os.path.join(root, "setup.py") - versioneer_py = os.path.join(root, "versioneer.py") - if not (os.path.exists(setup_py) or os.path.exists(versioneer_py)): - # allow 'python path/to/setup.py COMMAND' - root = os.path.dirname(os.path.realpath(os.path.abspath(sys.argv[0]))) - setup_py = os.path.join(root, "setup.py") - versioneer_py = os.path.join(root, "versioneer.py") - if not (os.path.exists(setup_py) or os.path.exists(versioneer_py)): - err = ( - "Versioneer was unable to run the project root directory. " - "Versioneer requires setup.py to be executed from " - "its immediate directory (like 'python setup.py COMMAND'), " - "or in a way that lets it use sys.argv[0] to find the root " - "(like 'python path/to/setup.py COMMAND')." - ) - raise VersioneerBadRootError(err) - try: - # Certain runtime workflows (setup.py install/develop in a setuptools - # tree) execute all dependencies in a single python process, so - # "versioneer" may be imported multiple times, and python's shared - # module-import table will cache the first one. So we can't use - # os.path.dirname(__file__), as that will find whichever - # versioneer.py was first imported, even in later projects. - my_path = os.path.realpath(os.path.abspath(__file__)) - me_dir = os.path.normcase(os.path.splitext(my_path)[0]) - vsr_dir = os.path.normcase(os.path.splitext(versioneer_py)[0]) - if me_dir != vsr_dir: - print( - "Warning: build in %s is using versioneer.py from %s" - % (os.path.dirname(my_path), versioneer_py) - ) - except NameError: - pass - return root - - -def get_config_from_root(root): - """Read the project setup.cfg file to determine Versioneer config.""" - # This might raise EnvironmentError (if setup.cfg is missing), or - # configparser.NoSectionError (if it lacks a [versioneer] section), or - # configparser.NoOptionError (if it lacks "VCS="). See the docstring at - # the top of versioneer.py for instructions on writing your setup.cfg . - setup_cfg = os.path.join(root, "setup.cfg") - parser = configparser.ConfigParser() - with open(setup_cfg, "r") as cfg_file: - parser.read_file(cfg_file) - VCS = parser.get("versioneer", "VCS") # mandatory - - # Dict-like interface for non-mandatory entries - section = parser["versioneer"] - - # pylint:disable=attribute-defined-outside-init # noqa - cfg = VersioneerConfig() - cfg.VCS = VCS - cfg.style = section.get("style", "") - cfg.versionfile_source = section.get("versionfile_source") - cfg.versionfile_build = section.get("versionfile_build") - cfg.tag_prefix = section.get("tag_prefix") - if cfg.tag_prefix in ("''", '""'): - cfg.tag_prefix = "" - cfg.parentdir_prefix = section.get("parentdir_prefix") - cfg.verbose = section.get("verbose") - return cfg - - -class NotThisMethod(Exception): - """Exception raised if a method is not valid for the current scenario.""" - - -# these dictionaries contain VCS-specific tools -LONG_VERSION_PY = {} -HANDLERS = {} - - -def register_vcs_handler(vcs, method): # decorator - """Create decorator to mark a method as the handler of a VCS.""" - - def decorate(f): - """Store f in HANDLERS[vcs][method].""" - HANDLERS.setdefault(vcs, {})[method] = f - return f - - return decorate - - -# pylint:disable=too-many-arguments,consider-using-with # noqa -def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False, env=None): - """Call the given command(s).""" - assert isinstance(commands, list) - process = None - for command in commands: - try: - dispcmd = str([command] + args) - # remember shell=False, so use git.cmd on windows, not just git - process = subprocess.Popen( - [command] + args, - cwd=cwd, - env=env, - stdout=subprocess.PIPE, - stderr=(subprocess.PIPE if hide_stderr else None), - ) - break - except EnvironmentError: - e = sys.exc_info()[1] - if e.errno == errno.ENOENT: - continue - if verbose: - print("unable to run %s" % dispcmd) - print(e) - return None, None - else: - if verbose: - print("unable to find command, tried %s" % (commands,)) - return None, None - stdout = process.communicate()[0].strip().decode() - if process.returncode != 0: - if verbose: - print("unable to run %s (error)" % dispcmd) - print("stdout was %s" % stdout) - return None, process.returncode - return stdout, process.returncode - - -LONG_VERSION_PY[ - "git" -] = r''' -# This file helps to compute a version number in source trees obtained from -# git-archive tarball (such as those provided by githubs download-from-tag -# feature). Distribution tarballs (built by setup.py sdist) and build -# directories (produced by setup.py build) will contain a much shorter file -# that just contains the computed version number. - -# This file is released into the public domain. Generated by -# versioneer-0.20 (https://github.com/python-versioneer/python-versioneer) - -"""Git implementation of _version.py.""" - -import errno -import os -import re -import subprocess -import sys - - -def get_keywords(): - """Get the keywords needed to look up the version information.""" - # these strings will be replaced by git during git-archive. - # setup.py/versioneer.py will grep for the variable names, so they must - # each be defined on a line of their own. _version.py will just call - # get_keywords(). - git_refnames = "%(DOLLAR)sFormat:%%d%(DOLLAR)s" - git_full = "%(DOLLAR)sFormat:%%H%(DOLLAR)s" - git_date = "%(DOLLAR)sFormat:%%ci%(DOLLAR)s" - keywords = {"refnames": git_refnames, "full": git_full, "date": git_date} - return keywords - - -class VersioneerConfig: # pylint: disable=too-few-public-methods - """Container for Versioneer configuration parameters.""" - - -def get_config(): - """Create, populate and return the VersioneerConfig() object.""" - # these strings are filled in when 'setup.py versioneer' creates - # _version.py - cfg = VersioneerConfig() - cfg.VCS = "git" - cfg.style = "%(STYLE)s" - cfg.tag_prefix = "%(TAG_PREFIX)s" - cfg.parentdir_prefix = "%(PARENTDIR_PREFIX)s" - cfg.versionfile_source = "%(VERSIONFILE_SOURCE)s" - cfg.verbose = False - return cfg - - -class NotThisMethod(Exception): - """Exception raised if a method is not valid for the current scenario.""" - - -LONG_VERSION_PY = {} -HANDLERS = {} - - -def register_vcs_handler(vcs, method): # decorator - """Create decorator to mark a method as the handler of a VCS.""" - def decorate(f): - """Store f in HANDLERS[vcs][method].""" - if vcs not in HANDLERS: - HANDLERS[vcs] = {} - HANDLERS[vcs][method] = f - return f - return decorate - - -# pylint:disable=too-many-arguments,consider-using-with # noqa -def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False, - env=None): - """Call the given command(s).""" - assert isinstance(commands, list) - process = None - for command in commands: - try: - dispcmd = str([command] + args) - # remember shell=False, so use git.cmd on windows, not just git - process = subprocess.Popen([command] + args, cwd=cwd, env=env, - stdout=subprocess.PIPE, - stderr=(subprocess.PIPE if hide_stderr - else None)) - break - except EnvironmentError: - e = sys.exc_info()[1] - if e.errno == errno.ENOENT: - continue - if verbose: - print("unable to run %%s" %% dispcmd) - print(e) - return None, None - else: - if verbose: - print("unable to find command, tried %%s" %% (commands,)) - return None, None - stdout = process.communicate()[0].strip().decode() - if process.returncode != 0: - if verbose: - print("unable to run %%s (error)" %% dispcmd) - print("stdout was %%s" %% stdout) - return None, process.returncode - return stdout, process.returncode - - -def versions_from_parentdir(parentdir_prefix, root, verbose): - """Try to determine the version from the parent directory name. - - Source tarballs conventionally unpack into a directory that includes both - the project name and a version string. We will also support searching up - two directory levels for an appropriately named parent directory - """ - rootdirs = [] - - for _ in range(3): - dirname = os.path.basename(root) - if dirname.startswith(parentdir_prefix): - return {"version": dirname[len(parentdir_prefix):], - "full-revisionid": None, - "dirty": False, "error": None, "date": None} - rootdirs.append(root) - root = os.path.dirname(root) # up a level - - if verbose: - print("Tried directories %%s but none started with prefix %%s" %% - (str(rootdirs), parentdir_prefix)) - raise NotThisMethod("rootdir doesn't start with parentdir_prefix") - - -@register_vcs_handler("git", "get_keywords") -def git_get_keywords(versionfile_abs): - """Extract version information from the given file.""" - # the code embedded in _version.py can just fetch the value of these - # keywords. When used from setup.py, we don't want to import _version.py, - # so we do it with a regexp instead. This function is not used from - # _version.py. - keywords = {} - try: - with open(versionfile_abs, "r") as fobj: - for line in fobj: - if line.strip().startswith("git_refnames ="): - mo = re.search(r'=\s*"(.*)"', line) - if mo: - keywords["refnames"] = mo.group(1) - if line.strip().startswith("git_full ="): - mo = re.search(r'=\s*"(.*)"', line) - if mo: - keywords["full"] = mo.group(1) - if line.strip().startswith("git_date ="): - mo = re.search(r'=\s*"(.*)"', line) - if mo: - keywords["date"] = mo.group(1) - except EnvironmentError: - pass - return keywords - - -@register_vcs_handler("git", "keywords") -def git_versions_from_keywords(keywords, tag_prefix, verbose): - """Get version information from git keywords.""" - if "refnames" not in keywords: - raise NotThisMethod("Short version file found") - date = keywords.get("date") - if date is not None: - # Use only the last line. Previous lines may contain GPG signature - # information. - date = date.splitlines()[-1] - - # git-2.2.0 added "%%cI", which expands to an ISO-8601 -compliant - # datestamp. However we prefer "%%ci" (which expands to an "ISO-8601 - # -like" string, which we must then edit to make compliant), because - # it's been around since git-1.5.3, and it's too difficult to - # discover which version we're using, or to work around using an - # older one. - date = date.strip().replace(" ", "T", 1).replace(" ", "", 1) - refnames = keywords["refnames"].strip() - if refnames.startswith("$Format"): - if verbose: - print("keywords are unexpanded, not using") - raise NotThisMethod("unexpanded keywords, not a git-archive tarball") - refs = {r.strip() for r in refnames.strip("()").split(",")} - # starting in git-1.8.3, tags are listed as "tag: foo-1.0" instead of - # just "foo-1.0". If we see a "tag: " prefix, prefer those. - TAG = "tag: " - tags = {r[len(TAG):] for r in refs if r.startswith(TAG)} - if not tags: - # Either we're using git < 1.8.3, or there really are no tags. We use - # a heuristic: assume all version tags have a digit. The old git %%d - # expansion behaves like git log --decorate=short and strips out the - # refs/heads/ and refs/tags/ prefixes that would let us distinguish - # between branches and tags. By ignoring refnames without digits, we - # filter out many common branch names like "release" and - # "stabilization", as well as "HEAD" and "master". - tags = {r for r in refs if re.search(r'\d', r)} - if verbose: - print("discarding '%%s', no digits" %% ",".join(refs - tags)) - if verbose: - print("likely tags: %%s" %% ",".join(sorted(tags))) - for ref in sorted(tags): - # sorting will prefer e.g. "2.0" over "2.0rc1" - if ref.startswith(tag_prefix): - r = ref[len(tag_prefix):] - # Filter out refs that exactly match prefix or that don't start - # with a number once the prefix is stripped (mostly a concern - # when prefix is '') - if not re.match(r'\d', r): - continue - if verbose: - print("picking %%s" %% r) - return {"version": r, - "full-revisionid": keywords["full"].strip(), - "dirty": False, "error": None, - "date": date} - # no suitable tags, so version is "0+unknown", but full hex is still there - if verbose: - print("no suitable tags, using unknown + full revision id") - return {"version": "0+unknown", - "full-revisionid": keywords["full"].strip(), - "dirty": False, "error": "no suitable tags", "date": None} - - -@register_vcs_handler("git", "pieces_from_vcs") -def git_pieces_from_vcs(tag_prefix, root, verbose, runner=run_command): - """Get version from 'git describe' in the root of the source tree. - - This only gets called if the git-archive 'subst' keywords were *not* - expanded, and _version.py hasn't already been rewritten with a short - version string, meaning we're inside a checked out source tree. - """ - GITS = ["git"] - if sys.platform == "win32": - GITS = ["git.cmd", "git.exe"] - - _, rc = runner(GITS, ["rev-parse", "--git-dir"], cwd=root, - hide_stderr=True) - if rc != 0: - if verbose: - print("Directory %%s not under git control" %% root) - raise NotThisMethod("'git rev-parse --git-dir' returned error") - - # if there is a tag matching tag_prefix, this yields TAG-NUM-gHEX[-dirty] - # if there isn't one, this yields HEX[-dirty] (no NUM) - describe_out, rc = runner(GITS, ["describe", "--tags", "--dirty", - "--always", "--long", - "--match", "%%s*" %% tag_prefix], - cwd=root) - # --long was added in git-1.5.5 - if describe_out is None: - raise NotThisMethod("'git describe' failed") - describe_out = describe_out.strip() - full_out, rc = runner(GITS, ["rev-parse", "HEAD"], cwd=root) - if full_out is None: - raise NotThisMethod("'git rev-parse' failed") - full_out = full_out.strip() - - pieces = {} - pieces["long"] = full_out - pieces["short"] = full_out[:7] # maybe improved later - pieces["error"] = None - - branch_name, rc = runner(GITS, ["rev-parse", "--abbrev-ref", "HEAD"], - cwd=root) - # --abbrev-ref was added in git-1.6.3 - if rc != 0 or branch_name is None: - raise NotThisMethod("'git rev-parse --abbrev-ref' returned error") - branch_name = branch_name.strip() - - if branch_name == "HEAD": - # If we aren't exactly on a branch, pick a branch which represents - # the current commit. If all else fails, we are on a branchless - # commit. - branches, rc = runner(GITS, ["branch", "--contains"], cwd=root) - # --contains was added in git-1.5.4 - if rc != 0 or branches is None: - raise NotThisMethod("'git branch --contains' returned error") - branches = branches.split("\n") - - # Remove the first line if we're running detached - if "(" in branches[0]: - branches.pop(0) - - # Strip off the leading "* " from the list of branches. - branches = [branch[2:] for branch in branches] - if "master" in branches: - branch_name = "master" - elif not branches: - branch_name = None - else: - # Pick the first branch that is returned. Good or bad. - branch_name = branches[0] - - pieces["branch"] = branch_name - - # parse describe_out. It will be like TAG-NUM-gHEX[-dirty] or HEX[-dirty] - # TAG might have hyphens. - git_describe = describe_out - - # look for -dirty suffix - dirty = git_describe.endswith("-dirty") - pieces["dirty"] = dirty - if dirty: - git_describe = git_describe[:git_describe.rindex("-dirty")] - - # now we have TAG-NUM-gHEX or HEX - - if "-" in git_describe: - # TAG-NUM-gHEX - mo = re.search(r'^(.+)-(\d+)-g([0-9a-f]+)$', git_describe) - if not mo: - # unparseable. Maybe git-describe is misbehaving? - pieces["error"] = ("unable to parse git-describe output: '%%s'" - %% describe_out) - return pieces - - # tag - full_tag = mo.group(1) - if not full_tag.startswith(tag_prefix): - if verbose: - fmt = "tag '%%s' doesn't start with prefix '%%s'" - print(fmt %% (full_tag, tag_prefix)) - pieces["error"] = ("tag '%%s' doesn't start with prefix '%%s'" - %% (full_tag, tag_prefix)) - return pieces - pieces["closest-tag"] = full_tag[len(tag_prefix):] - - # distance: number of commits since tag - pieces["distance"] = int(mo.group(2)) - - # commit: short hex revision ID - pieces["short"] = mo.group(3) - - else: - # HEX: no tags - pieces["closest-tag"] = None - count_out, rc = runner(GITS, ["rev-list", "HEAD", "--count"], cwd=root) - pieces["distance"] = int(count_out) # total number of commits - - # commit date: see ISO-8601 comment in git_versions_from_keywords() - date = runner(GITS, ["show", "-s", "--format=%%ci", "HEAD"], cwd=root)[0].strip() - # Use only the last line. Previous lines may contain GPG signature - # information. - date = date.splitlines()[-1] - pieces["date"] = date.strip().replace(" ", "T", 1).replace(" ", "", 1) - - return pieces - - -def plus_or_dot(pieces): - """Return a + if we don't already have one, else return a .""" - if "+" in pieces.get("closest-tag", ""): - return "." - return "+" - - -def render_pep440(pieces): - """Build up version string, with post-release "local version identifier". - - Our goal: TAG[+DISTANCE.gHEX[.dirty]] . Note that if you - get a tagged build and then dirty it, you'll get TAG+0.gHEX.dirty - - Exceptions: - 1: no tags. git_describe was just HEX. 0+untagged.DISTANCE.gHEX[.dirty] - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - if pieces["distance"] or pieces["dirty"]: - rendered += plus_or_dot(pieces) - rendered += "%%d.g%%s" %% (pieces["distance"], pieces["short"]) - if pieces["dirty"]: - rendered += ".dirty" - else: - # exception #1 - rendered = "0+untagged.%%d.g%%s" %% (pieces["distance"], - pieces["short"]) - if pieces["dirty"]: - rendered += ".dirty" - return rendered - - -def render_pep440_branch(pieces): - """TAG[[.dev0]+DISTANCE.gHEX[.dirty]] . - - The ".dev0" means not master branch. Note that .dev0 sorts backwards - (a feature branch will appear "older" than the master branch). - - Exceptions: - 1: no tags. 0[.dev0]+untagged.DISTANCE.gHEX[.dirty] - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - if pieces["distance"] or pieces["dirty"]: - if pieces["branch"] != "master": - rendered += ".dev0" - rendered += plus_or_dot(pieces) - rendered += "%%d.g%%s" %% (pieces["distance"], pieces["short"]) - if pieces["dirty"]: - rendered += ".dirty" - else: - # exception #1 - rendered = "0" - if pieces["branch"] != "master": - rendered += ".dev0" - rendered += "+untagged.%%d.g%%s" %% (pieces["distance"], - pieces["short"]) - if pieces["dirty"]: - rendered += ".dirty" - return rendered - - -def render_pep440_pre(pieces): - """TAG[.post0.devDISTANCE] -- No -dirty. - - Exceptions: - 1: no tags. 0.post0.devDISTANCE - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - if pieces["distance"]: - rendered += ".post0.dev%%d" %% pieces["distance"] - else: - # exception #1 - rendered = "0.post0.dev%%d" %% pieces["distance"] - return rendered - - -def render_pep440_post(pieces): - """TAG[.postDISTANCE[.dev0]+gHEX] . - - The ".dev0" means dirty. Note that .dev0 sorts backwards - (a dirty tree will appear "older" than the corresponding clean one), - but you shouldn't be releasing software with -dirty anyways. - - Exceptions: - 1: no tags. 0.postDISTANCE[.dev0] - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - if pieces["distance"] or pieces["dirty"]: - rendered += ".post%%d" %% pieces["distance"] - if pieces["dirty"]: - rendered += ".dev0" - rendered += plus_or_dot(pieces) - rendered += "g%%s" %% pieces["short"] - else: - # exception #1 - rendered = "0.post%%d" %% pieces["distance"] - if pieces["dirty"]: - rendered += ".dev0" - rendered += "+g%%s" %% pieces["short"] - return rendered - - -def render_pep440_post_branch(pieces): - """TAG[.postDISTANCE[.dev0]+gHEX[.dirty]] . - - The ".dev0" means not master branch. - - Exceptions: - 1: no tags. 0.postDISTANCE[.dev0]+gHEX[.dirty] - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - if pieces["distance"] or pieces["dirty"]: - rendered += ".post%%d" %% pieces["distance"] - if pieces["branch"] != "master": - rendered += ".dev0" - rendered += plus_or_dot(pieces) - rendered += "g%%s" %% pieces["short"] - if pieces["dirty"]: - rendered += ".dirty" - else: - # exception #1 - rendered = "0.post%%d" %% pieces["distance"] - if pieces["branch"] != "master": - rendered += ".dev0" - rendered += "+g%%s" %% pieces["short"] - if pieces["dirty"]: - rendered += ".dirty" - return rendered - - -def render_pep440_old(pieces): - """TAG[.postDISTANCE[.dev0]] . - - The ".dev0" means dirty. - - Exceptions: - 1: no tags. 0.postDISTANCE[.dev0] - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - if pieces["distance"] or pieces["dirty"]: - rendered += ".post%%d" %% pieces["distance"] - if pieces["dirty"]: - rendered += ".dev0" - else: - # exception #1 - rendered = "0.post%%d" %% pieces["distance"] - if pieces["dirty"]: - rendered += ".dev0" - return rendered - - -def render_git_describe(pieces): - """TAG[-DISTANCE-gHEX][-dirty]. - - Like 'git describe --tags --dirty --always'. - - Exceptions: - 1: no tags. HEX[-dirty] (note: no 'g' prefix) - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - if pieces["distance"]: - rendered += "-%%d-g%%s" %% (pieces["distance"], pieces["short"]) - else: - # exception #1 - rendered = pieces["short"] - if pieces["dirty"]: - rendered += "-dirty" - return rendered - - -def render_git_describe_long(pieces): - """TAG-DISTANCE-gHEX[-dirty]. - - Like 'git describe --tags --dirty --always -long'. - The distance/hash is unconditional. - - Exceptions: - 1: no tags. HEX[-dirty] (note: no 'g' prefix) - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - rendered += "-%%d-g%%s" %% (pieces["distance"], pieces["short"]) - else: - # exception #1 - rendered = pieces["short"] - if pieces["dirty"]: - rendered += "-dirty" - return rendered - - -def render(pieces, style): - """Render the given version pieces into the requested style.""" - if pieces["error"]: - return {"version": "unknown", - "full-revisionid": pieces.get("long"), - "dirty": None, - "error": pieces["error"], - "date": None} - - if not style or style == "default": - style = "pep440" # the default - - if style == "pep440": - rendered = render_pep440(pieces) - elif style == "pep440-branch": - rendered = render_pep440_branch(pieces) - elif style == "pep440-pre": - rendered = render_pep440_pre(pieces) - elif style == "pep440-post": - rendered = render_pep440_post(pieces) - elif style == "pep440-post-branch": - rendered = render_pep440_post_branch(pieces) - elif style == "pep440-old": - rendered = render_pep440_old(pieces) - elif style == "git-describe": - rendered = render_git_describe(pieces) - elif style == "git-describe-long": - rendered = render_git_describe_long(pieces) - else: - raise ValueError("unknown style '%%s'" %% style) - - return {"version": rendered, "full-revisionid": pieces["long"], - "dirty": pieces["dirty"], "error": None, - "date": pieces.get("date")} - - -def get_versions(): - """Get version information or return default if unable to do so.""" - # I am in _version.py, which lives at ROOT/VERSIONFILE_SOURCE. If we have - # __file__, we can work backwards from there to the root. Some - # py2exe/bbfreeze/non-CPython implementations don't do __file__, in which - # case we can only use expanded keywords. - - cfg = get_config() - verbose = cfg.verbose - - try: - return git_versions_from_keywords(get_keywords(), cfg.tag_prefix, - verbose) - except NotThisMethod: - pass - - try: - root = os.path.realpath(__file__) - # versionfile_source is the relative path from the top of the source - # tree (where the .git directory might live) to this file. Invert - # this to find the root from __file__. - for _ in cfg.versionfile_source.split('/'): - root = os.path.dirname(root) - except NameError: - return {"version": "0+unknown", "full-revisionid": None, - "dirty": None, - "error": "unable to find root of source tree", - "date": None} - - try: - pieces = git_pieces_from_vcs(cfg.tag_prefix, root, verbose) - return render(pieces, cfg.style) - except NotThisMethod: - pass - - try: - if cfg.parentdir_prefix: - return versions_from_parentdir(cfg.parentdir_prefix, root, verbose) - except NotThisMethod: - pass - - return {"version": "0+unknown", "full-revisionid": None, - "dirty": None, - "error": "unable to compute version", "date": None} -''' - - -@register_vcs_handler("git", "get_keywords") -def git_get_keywords(versionfile_abs): - """Extract version information from the given file.""" - # the code embedded in _version.py can just fetch the value of these - # keywords. When used from setup.py, we don't want to import _version.py, - # so we do it with a regexp instead. This function is not used from - # _version.py. - keywords = {} - try: - with open(versionfile_abs, "r") as fobj: - for line in fobj: - if line.strip().startswith("git_refnames ="): - mo = re.search(r'=\s*"(.*)"', line) - if mo: - keywords["refnames"] = mo.group(1) - if line.strip().startswith("git_full ="): - mo = re.search(r'=\s*"(.*)"', line) - if mo: - keywords["full"] = mo.group(1) - if line.strip().startswith("git_date ="): - mo = re.search(r'=\s*"(.*)"', line) - if mo: - keywords["date"] = mo.group(1) - except EnvironmentError: - pass - return keywords - - -@register_vcs_handler("git", "keywords") -def git_versions_from_keywords(keywords, tag_prefix, verbose): - """Get version information from git keywords.""" - if "refnames" not in keywords: - raise NotThisMethod("Short version file found") - date = keywords.get("date") - if date is not None: - # Use only the last line. Previous lines may contain GPG signature - # information. - date = date.splitlines()[-1] - - # git-2.2.0 added "%cI", which expands to an ISO-8601 -compliant - # datestamp. However we prefer "%ci" (which expands to an "ISO-8601 - # -like" string, which we must then edit to make compliant), because - # it's been around since git-1.5.3, and it's too difficult to - # discover which version we're using, or to work around using an - # older one. - date = date.strip().replace(" ", "T", 1).replace(" ", "", 1) - refnames = keywords["refnames"].strip() - if refnames.startswith("$Format"): - if verbose: - print("keywords are unexpanded, not using") - raise NotThisMethod("unexpanded keywords, not a git-archive tarball") - refs = {r.strip() for r in refnames.strip("()").split(",")} - # starting in git-1.8.3, tags are listed as "tag: foo-1.0" instead of - # just "foo-1.0". If we see a "tag: " prefix, prefer those. - TAG = "tag: " - tags = {r[len(TAG) :] for r in refs if r.startswith(TAG)} - if not tags: - # Either we're using git < 1.8.3, or there really are no tags. We use - # a heuristic: assume all version tags have a digit. The old git %d - # expansion behaves like git log --decorate=short and strips out the - # refs/heads/ and refs/tags/ prefixes that would let us distinguish - # between branches and tags. By ignoring refnames without digits, we - # filter out many common branch names like "release" and - # "stabilization", as well as "HEAD" and "master". - tags = {r for r in refs if re.search(r"\d", r)} - if verbose: - print("discarding '%s', no digits" % ",".join(refs - tags)) - if verbose: - print("likely tags: %s" % ",".join(sorted(tags))) - for ref in sorted(tags): - # sorting will prefer e.g. "2.0" over "2.0rc1" - if ref.startswith(tag_prefix): - r = ref[len(tag_prefix) :] - # Filter out refs that exactly match prefix or that don't start - # with a number once the prefix is stripped (mostly a concern - # when prefix is '') - if not re.match(r"\d", r): - continue - if verbose: - print("picking %s" % r) - return { - "version": r, - "full-revisionid": keywords["full"].strip(), - "dirty": False, - "error": None, - "date": date, - } - # no suitable tags, so version is "0+unknown", but full hex is still there - if verbose: - print("no suitable tags, using unknown + full revision id") - return { - "version": "0+unknown", - "full-revisionid": keywords["full"].strip(), - "dirty": False, - "error": "no suitable tags", - "date": None, - } - - -@register_vcs_handler("git", "pieces_from_vcs") -def git_pieces_from_vcs(tag_prefix, root, verbose, runner=run_command): - """Get version from 'git describe' in the root of the source tree. - - This only gets called if the git-archive 'subst' keywords were *not* - expanded, and _version.py hasn't already been rewritten with a short - version string, meaning we're inside a checked out source tree. - """ - GITS = ["git"] - if sys.platform == "win32": - GITS = ["git.cmd", "git.exe"] - - _, rc = runner(GITS, ["rev-parse", "--git-dir"], cwd=root, hide_stderr=True) - if rc != 0: - if verbose: - print("Directory %s not under git control" % root) - raise NotThisMethod("'git rev-parse --git-dir' returned error") - - # if there is a tag matching tag_prefix, this yields TAG-NUM-gHEX[-dirty] - # if there isn't one, this yields HEX[-dirty] (no NUM) - describe_out, rc = runner( - GITS, - [ - "describe", - "--tags", - "--dirty", - "--always", - "--long", - "--match", - "%s*" % tag_prefix, - ], - cwd=root, - ) - # --long was added in git-1.5.5 - if describe_out is None: - raise NotThisMethod("'git describe' failed") - describe_out = describe_out.strip() - full_out, rc = runner(GITS, ["rev-parse", "HEAD"], cwd=root) - if full_out is None: - raise NotThisMethod("'git rev-parse' failed") - full_out = full_out.strip() - - pieces = {} - pieces["long"] = full_out - pieces["short"] = full_out[:7] # maybe improved later - pieces["error"] = None - - branch_name, rc = runner(GITS, ["rev-parse", "--abbrev-ref", "HEAD"], cwd=root) - # --abbrev-ref was added in git-1.6.3 - if rc != 0 or branch_name is None: - raise NotThisMethod("'git rev-parse --abbrev-ref' returned error") - branch_name = branch_name.strip() - - if branch_name == "HEAD": - # If we aren't exactly on a branch, pick a branch which represents - # the current commit. If all else fails, we are on a branchless - # commit. - branches, rc = runner(GITS, ["branch", "--contains"], cwd=root) - # --contains was added in git-1.5.4 - if rc != 0 or branches is None: - raise NotThisMethod("'git branch --contains' returned error") - branches = branches.split("\n") - - # Remove the first line if we're running detached - if "(" in branches[0]: - branches.pop(0) - - # Strip off the leading "* " from the list of branches. - branches = [branch[2:] for branch in branches] - if "master" in branches: - branch_name = "master" - elif not branches: - branch_name = None - else: - # Pick the first branch that is returned. Good or bad. - branch_name = branches[0] - - pieces["branch"] = branch_name - - # parse describe_out. It will be like TAG-NUM-gHEX[-dirty] or HEX[-dirty] - # TAG might have hyphens. - git_describe = describe_out - - # look for -dirty suffix - dirty = git_describe.endswith("-dirty") - pieces["dirty"] = dirty - if dirty: - git_describe = git_describe[: git_describe.rindex("-dirty")] - - # now we have TAG-NUM-gHEX or HEX - - if "-" in git_describe: - # TAG-NUM-gHEX - mo = re.search(r"^(.+)-(\d+)-g([0-9a-f]+)$", git_describe) - if not mo: - # unparseable. Maybe git-describe is misbehaving? - pieces["error"] = "unable to parse git-describe output: '%s'" % describe_out - return pieces - - # tag - full_tag = mo.group(1) - if not full_tag.startswith(tag_prefix): - if verbose: - fmt = "tag '%s' doesn't start with prefix '%s'" - print(fmt % (full_tag, tag_prefix)) - pieces["error"] = "tag '%s' doesn't start with prefix '%s'" % ( - full_tag, - tag_prefix, - ) - return pieces - pieces["closest-tag"] = full_tag[len(tag_prefix) :] - - # distance: number of commits since tag - pieces["distance"] = int(mo.group(2)) - - # commit: short hex revision ID - pieces["short"] = mo.group(3) - - else: - # HEX: no tags - pieces["closest-tag"] = None - count_out, rc = runner(GITS, ["rev-list", "HEAD", "--count"], cwd=root) - pieces["distance"] = int(count_out) # total number of commits - - # commit date: see ISO-8601 comment in git_versions_from_keywords() - date = runner(GITS, ["show", "-s", "--format=%ci", "HEAD"], cwd=root)[0].strip() - # Use only the last line. Previous lines may contain GPG signature - # information. - date = date.splitlines()[-1] - pieces["date"] = date.strip().replace(" ", "T", 1).replace(" ", "", 1) - - return pieces - - -def do_vcs_install(manifest_in, versionfile_source, ipy): - """Git-specific installation logic for Versioneer. - - For Git, this means creating/changing .gitattributes to mark _version.py - for export-subst keyword substitution. - """ - GITS = ["git"] - if sys.platform == "win32": - GITS = ["git.cmd", "git.exe"] - files = [manifest_in, versionfile_source] - if ipy: - files.append(ipy) - try: - my_path = __file__ - if my_path.endswith(".pyc") or my_path.endswith(".pyo"): - my_path = os.path.splitext(my_path)[0] + ".py" - versioneer_file = os.path.relpath(my_path) - except NameError: - versioneer_file = "versioneer.py" - files.append(versioneer_file) - present = False - try: - with open(".gitattributes", "r") as fobj: - for line in fobj: - if line.strip().startswith(versionfile_source): - if "export-subst" in line.strip().split()[1:]: - present = True - break - except EnvironmentError: - pass - if not present: - with open(".gitattributes", "a+") as fobj: - fobj.write(f"{versionfile_source} export-subst\n") - files.append(".gitattributes") - run_command(GITS, ["add", "--"] + files) - - -def versions_from_parentdir(parentdir_prefix, root, verbose): - """Try to determine the version from the parent directory name. - - Source tarballs conventionally unpack into a directory that includes both - the project name and a version string. We will also support searching up - two directory levels for an appropriately named parent directory - """ - rootdirs = [] - - for _ in range(3): - dirname = os.path.basename(root) - if dirname.startswith(parentdir_prefix): - return { - "version": dirname[len(parentdir_prefix) :], - "full-revisionid": None, - "dirty": False, - "error": None, - "date": None, - } - rootdirs.append(root) - root = os.path.dirname(root) # up a level - - if verbose: - print( - "Tried directories %s but none started with prefix %s" - % (str(rootdirs), parentdir_prefix) - ) - raise NotThisMethod("rootdir doesn't start with parentdir_prefix") - - -SHORT_VERSION_PY = """ -# This file was generated by 'versioneer.py' (0.20) from -# revision-control system data, or from the parent directory name of an -# unpacked source archive. Distribution tarballs contain a pre-generated copy -# of this file. - -import json - -version_json = ''' -%s -''' # END VERSION_JSON - - -def get_versions(): - return json.loads(version_json) -""" - - -def versions_from_file(filename): - """Try to determine the version from _version.py if present.""" - try: - with open(filename) as f: - contents = f.read() - except EnvironmentError: - raise NotThisMethod("unable to read _version.py") - mo = re.search( - r"version_json = '''\n(.*)''' # END VERSION_JSON", contents, re.M | re.S - ) - if not mo: - mo = re.search( - r"version_json = '''\r\n(.*)''' # END VERSION_JSON", contents, re.M | re.S - ) - if not mo: - raise NotThisMethod("no version_json in _version.py") - return json.loads(mo.group(1)) - - -def write_to_version_file(filename, versions): - """Write the given version number to the given _version.py file.""" - os.unlink(filename) - contents = json.dumps(versions, sort_keys=True, indent=1, separators=(",", ": ")) - with open(filename, "w") as f: - f.write(SHORT_VERSION_PY % contents) - - print("set %s to '%s'" % (filename, versions["version"])) - - -def plus_or_dot(pieces): - """Return a + if we don't already have one, else return a .""" - if "+" in pieces.get("closest-tag", ""): - return "." - return "+" - - -def render_pep440(pieces): - """Build up version string, with post-release "local version identifier". - - Our goal: TAG[+DISTANCE.gHEX[.dirty]] . Note that if you - get a tagged build and then dirty it, you'll get TAG+0.gHEX.dirty - - Exceptions: - 1: no tags. git_describe was just HEX. 0+untagged.DISTANCE.gHEX[.dirty] - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - if pieces["distance"] or pieces["dirty"]: - rendered += plus_or_dot(pieces) - rendered += "%d.g%s" % (pieces["distance"], pieces["short"]) - if pieces["dirty"]: - rendered += ".dirty" - else: - # exception #1 - rendered = "0+untagged.%d.g%s" % (pieces["distance"], pieces["short"]) - if pieces["dirty"]: - rendered += ".dirty" - return rendered - - -def render_pep440_branch(pieces): - """TAG[[.dev0]+DISTANCE.gHEX[.dirty]] . - - The ".dev0" means not master branch. Note that .dev0 sorts backwards - (a feature branch will appear "older" than the master branch). - - Exceptions: - 1: no tags. 0[.dev0]+untagged.DISTANCE.gHEX[.dirty] - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - if pieces["distance"] or pieces["dirty"]: - if pieces["branch"] != "master": - rendered += ".dev0" - rendered += plus_or_dot(pieces) - rendered += "%d.g%s" % (pieces["distance"], pieces["short"]) - if pieces["dirty"]: - rendered += ".dirty" - else: - # exception #1 - rendered = "0" - if pieces["branch"] != "master": - rendered += ".dev0" - rendered += "+untagged.%d.g%s" % (pieces["distance"], pieces["short"]) - if pieces["dirty"]: - rendered += ".dirty" - return rendered - - -def render_pep440_pre(pieces): - """TAG[.post0.devDISTANCE] -- No -dirty. - - Exceptions: - 1: no tags. 0.post0.devDISTANCE - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - if pieces["distance"]: - rendered += ".post0.dev%d" % pieces["distance"] - else: - # exception #1 - rendered = "0.post0.dev%d" % pieces["distance"] - return rendered - - -def render_pep440_post(pieces): - """TAG[.postDISTANCE[.dev0]+gHEX] . - - The ".dev0" means dirty. Note that .dev0 sorts backwards - (a dirty tree will appear "older" than the corresponding clean one), - but you shouldn't be releasing software with -dirty anyways. - - Exceptions: - 1: no tags. 0.postDISTANCE[.dev0] - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - if pieces["distance"] or pieces["dirty"]: - rendered += ".post%d" % pieces["distance"] - if pieces["dirty"]: - rendered += ".dev0" - rendered += plus_or_dot(pieces) - rendered += "g%s" % pieces["short"] - else: - # exception #1 - rendered = "0.post%d" % pieces["distance"] - if pieces["dirty"]: - rendered += ".dev0" - rendered += "+g%s" % pieces["short"] - return rendered - - -def render_pep440_post_branch(pieces): - """TAG[.postDISTANCE[.dev0]+gHEX[.dirty]] . - - The ".dev0" means not master branch. - - Exceptions: - 1: no tags. 0.postDISTANCE[.dev0]+gHEX[.dirty] - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - if pieces["distance"] or pieces["dirty"]: - rendered += ".post%d" % pieces["distance"] - if pieces["branch"] != "master": - rendered += ".dev0" - rendered += plus_or_dot(pieces) - rendered += "g%s" % pieces["short"] - if pieces["dirty"]: - rendered += ".dirty" - else: - # exception #1 - rendered = "0.post%d" % pieces["distance"] - if pieces["branch"] != "master": - rendered += ".dev0" - rendered += "+g%s" % pieces["short"] - if pieces["dirty"]: - rendered += ".dirty" - return rendered - - -def render_pep440_old(pieces): - """TAG[.postDISTANCE[.dev0]] . - - The ".dev0" means dirty. - - Exceptions: - 1: no tags. 0.postDISTANCE[.dev0] - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - if pieces["distance"] or pieces["dirty"]: - rendered += ".post%d" % pieces["distance"] - if pieces["dirty"]: - rendered += ".dev0" - else: - # exception #1 - rendered = "0.post%d" % pieces["distance"] - if pieces["dirty"]: - rendered += ".dev0" - return rendered - - -def render_git_describe(pieces): - """TAG[-DISTANCE-gHEX][-dirty]. - - Like 'git describe --tags --dirty --always'. - - Exceptions: - 1: no tags. HEX[-dirty] (note: no 'g' prefix) - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - if pieces["distance"]: - rendered += "-%d-g%s" % (pieces["distance"], pieces["short"]) - else: - # exception #1 - rendered = pieces["short"] - if pieces["dirty"]: - rendered += "-dirty" - return rendered - - -def render_git_describe_long(pieces): - """TAG-DISTANCE-gHEX[-dirty]. - - Like 'git describe --tags --dirty --always -long'. - The distance/hash is unconditional. - - Exceptions: - 1: no tags. HEX[-dirty] (note: no 'g' prefix) - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - rendered += "-%d-g%s" % (pieces["distance"], pieces["short"]) - else: - # exception #1 - rendered = pieces["short"] - if pieces["dirty"]: - rendered += "-dirty" - return rendered - - -def render(pieces, style): - """Render the given version pieces into the requested style.""" - if pieces["error"]: - return { - "version": "unknown", - "full-revisionid": pieces.get("long"), - "dirty": None, - "error": pieces["error"], - "date": None, - } - - if not style or style == "default": - style = "pep440" # the default - - if style == "pep440": - rendered = render_pep440(pieces) - elif style == "pep440-branch": - rendered = render_pep440_branch(pieces) - elif style == "pep440-pre": - rendered = render_pep440_pre(pieces) - elif style == "pep440-post": - rendered = render_pep440_post(pieces) - elif style == "pep440-post-branch": - rendered = render_pep440_post_branch(pieces) - elif style == "pep440-old": - rendered = render_pep440_old(pieces) - elif style == "git-describe": - rendered = render_git_describe(pieces) - elif style == "git-describe-long": - rendered = render_git_describe_long(pieces) - else: - raise ValueError("unknown style '%s'" % style) - - return { - "version": rendered, - "full-revisionid": pieces["long"], - "dirty": pieces["dirty"], - "error": None, - "date": pieces.get("date"), - } - - -class VersioneerBadRootError(Exception): - """The project root directory is unknown or missing key files.""" - - -def get_versions(verbose=False): - """Get the project version from whatever source is available. - - Returns dict with two keys: 'version' and 'full'. - """ - if "versioneer" in sys.modules: - # see the discussion in cmdclass.py:get_cmdclass() - del sys.modules["versioneer"] - - root = get_root() - cfg = get_config_from_root(root) - - assert cfg.VCS is not None, "please set [versioneer]VCS= in setup.cfg" - handlers = HANDLERS.get(cfg.VCS) - assert handlers, "unrecognized VCS '%s'" % cfg.VCS - verbose = verbose or cfg.verbose - assert ( - cfg.versionfile_source is not None - ), "please set versioneer.versionfile_source" - assert cfg.tag_prefix is not None, "please set versioneer.tag_prefix" - - versionfile_abs = os.path.join(root, cfg.versionfile_source) - - # extract version from first of: _version.py, VCS command (e.g. 'git - # describe'), parentdir. This is meant to work for developers using a - # source checkout, for users of a tarball created by 'setup.py sdist', - # and for users of a tarball/zipball created by 'git archive' or github's - # download-from-tag feature or the equivalent in other VCSes. - - get_keywords_f = handlers.get("get_keywords") - from_keywords_f = handlers.get("keywords") - if get_keywords_f and from_keywords_f: - try: - keywords = get_keywords_f(versionfile_abs) - ver = from_keywords_f(keywords, cfg.tag_prefix, verbose) - if verbose: - print("got version from expanded keyword %s" % ver) - return ver - except NotThisMethod: - pass - - try: - ver = versions_from_file(versionfile_abs) - if verbose: - print("got version from file %s %s" % (versionfile_abs, ver)) - return ver - except NotThisMethod: - pass - - from_vcs_f = handlers.get("pieces_from_vcs") - if from_vcs_f: - try: - pieces = from_vcs_f(cfg.tag_prefix, root, verbose) - ver = render(pieces, cfg.style) - if verbose: - print("got version from VCS %s" % ver) - return ver - except NotThisMethod: - pass - - try: - if cfg.parentdir_prefix: - ver = versions_from_parentdir(cfg.parentdir_prefix, root, verbose) - if verbose: - print("got version from parentdir %s" % ver) - return ver - except NotThisMethod: - pass - - if verbose: - print("unable to compute version") - - return { - "version": "0+unknown", - "full-revisionid": None, - "dirty": None, - "error": "unable to compute version", - "date": None, - } - - -def get_version(): - """Get the short version string for this project.""" - return get_versions()["version"] - - -def get_cmdclass(cmdclass=None): - """Get the custom setuptools/distutils subclasses used by Versioneer. - - If the package uses a different cmdclass (e.g. one from numpy), it - should be provide as an argument. - """ - if "versioneer" in sys.modules: - del sys.modules["versioneer"] - # this fixes the "python setup.py develop" case (also 'install' and - # 'easy_install .'), in which subdependencies of the main project are - # built (using setup.py bdist_egg) in the same python process. Assume - # a main project A and a dependency B, which use different versions - # of Versioneer. A's setup.py imports A's Versioneer, leaving it in - # sys.modules by the time B's setup.py is executed, causing B to run - # with the wrong versioneer. Setuptools wraps the sub-dep builds in a - # sandbox that restores sys.modules to it's pre-build state, so the - # parent is protected against the child's "import versioneer". By - # removing ourselves from sys.modules here, before the child build - # happens, we protect the child from the parent's versioneer too. - # Also see https://github.com/python-versioneer/python-versioneer/issues/52 - - cmds = {} if cmdclass is None else cmdclass.copy() - - # we add "version" to both distutils and setuptools - from distutils.core import Command - - class cmd_version(Command): - description = "report generated version string" - user_options = [] - boolean_options = [] - - def initialize_options(self): - pass - - def finalize_options(self): - pass - - def run(self): - vers = get_versions(verbose=True) - print("Version: %s" % vers["version"]) - print(" full-revisionid: %s" % vers.get("full-revisionid")) - print(" dirty: %s" % vers.get("dirty")) - print(" date: %s" % vers.get("date")) - if vers["error"]: - print(" error: %s" % vers["error"]) - - cmds["version"] = cmd_version - - # we override "build_py" in both distutils and setuptools - # - # most invocation pathways end up running build_py: - # distutils/build -> build_py - # distutils/install -> distutils/build ->.. - # setuptools/bdist_wheel -> distutils/install ->.. - # setuptools/bdist_egg -> distutils/install_lib -> build_py - # setuptools/install -> bdist_egg ->.. - # setuptools/develop -> ? - # pip install: - # copies source tree to a tempdir before running egg_info/etc - # if .git isn't copied too, 'git describe' will fail - # then does setup.py bdist_wheel, or sometimes setup.py install - # setup.py egg_info -> ? - - # we override different "build_py" commands for both environments - if "build_py" in cmds: - _build_py = cmds["build_py"] - elif "setuptools" in sys.modules: - from setuptools.command.build_py import build_py as _build_py - else: - from distutils.command.build_py import build_py as _build_py - - class cmd_build_py(_build_py): - def run(self): - root = get_root() - cfg = get_config_from_root(root) - versions = get_versions() - _build_py.run(self) - # now locate _version.py in the new build/ directory and replace - # it with an updated value - if cfg.versionfile_build: - target_versionfile = os.path.join(self.build_lib, cfg.versionfile_build) - print("UPDATING %s" % target_versionfile) - write_to_version_file(target_versionfile, versions) - - cmds["build_py"] = cmd_build_py - - if "build_ext" in cmds: - _build_ext = cmds["build_ext"] - elif "setuptools" in sys.modules: - from setuptools.command.build_ext import build_ext as _build_ext - else: - from distutils.command.build_ext import build_ext as _build_ext - - class cmd_build_ext(_build_ext): - def run(self): - root = get_root() - cfg = get_config_from_root(root) - versions = get_versions() - _build_ext.run(self) - if self.inplace: - # build_ext --inplace will only build extensions in - # build/lib<..> dir with no _version.py to write to. - # As in place builds will already have a _version.py - # in the module dir, we do not need to write one. - return - # now locate _version.py in the new build/ directory and replace - # it with an updated value - target_versionfile = os.path.join(self.build_lib, cfg.versionfile_build) - print("UPDATING %s" % target_versionfile) - write_to_version_file(target_versionfile, versions) - - cmds["build_ext"] = cmd_build_ext - - if "cx_Freeze" in sys.modules: # cx_freeze enabled? - from cx_Freeze.dist import build_exe as _build_exe - - # nczeczulin reports that py2exe won't like the pep440-style string - # as FILEVERSION, but it can be used for PRODUCTVERSION, e.g. - # setup(console=[{ - # "version": versioneer.get_version().split("+", 1)[0], # FILEVERSION - # "product_version": versioneer.get_version(), - # ... - - class cmd_build_exe(_build_exe): - def run(self): - root = get_root() - cfg = get_config_from_root(root) - versions = get_versions() - target_versionfile = cfg.versionfile_source - print("UPDATING %s" % target_versionfile) - write_to_version_file(target_versionfile, versions) - - _build_exe.run(self) - os.unlink(target_versionfile) - with open(cfg.versionfile_source, "w") as f: - LONG = LONG_VERSION_PY[cfg.VCS] - f.write( - LONG - % { - "DOLLAR": "$", - "STYLE": cfg.style, - "TAG_PREFIX": cfg.tag_prefix, - "PARENTDIR_PREFIX": cfg.parentdir_prefix, - "VERSIONFILE_SOURCE": cfg.versionfile_source, - } - ) - - cmds["build_exe"] = cmd_build_exe - del cmds["build_py"] - - if "py2exe" in sys.modules: # py2exe enabled? - from py2exe.distutils_buildexe import py2exe as _py2exe - - class cmd_py2exe(_py2exe): - def run(self): - root = get_root() - cfg = get_config_from_root(root) - versions = get_versions() - target_versionfile = cfg.versionfile_source - print("UPDATING %s" % target_versionfile) - write_to_version_file(target_versionfile, versions) - - _py2exe.run(self) - os.unlink(target_versionfile) - with open(cfg.versionfile_source, "w") as f: - LONG = LONG_VERSION_PY[cfg.VCS] - f.write( - LONG - % { - "DOLLAR": "$", - "STYLE": cfg.style, - "TAG_PREFIX": cfg.tag_prefix, - "PARENTDIR_PREFIX": cfg.parentdir_prefix, - "VERSIONFILE_SOURCE": cfg.versionfile_source, - } - ) - - cmds["py2exe"] = cmd_py2exe - - # we override different "sdist" commands for both environments - if "sdist" in cmds: - _sdist = cmds["sdist"] - elif "setuptools" in sys.modules: - from setuptools.command.sdist import sdist as _sdist - else: - from distutils.command.sdist import sdist as _sdist - - class cmd_sdist(_sdist): - def run(self): - versions = get_versions() - # pylint:disable=attribute-defined-outside-init # noqa - self._versioneer_generated_versions = versions - # unless we update this, the command will keep using the old - # version - self.distribution.metadata.version = versions["version"] - return _sdist.run(self) - - def make_release_tree(self, base_dir, files): - root = get_root() - cfg = get_config_from_root(root) - _sdist.make_release_tree(self, base_dir, files) - # now locate _version.py in the new base_dir directory - # (remembering that it may be a hardlink) and replace it with an - # updated value - target_versionfile = os.path.join(base_dir, cfg.versionfile_source) - print("UPDATING %s" % target_versionfile) - write_to_version_file( - target_versionfile, self._versioneer_generated_versions - ) - - cmds["sdist"] = cmd_sdist - - return cmds - - -CONFIG_ERROR = """ -setup.cfg is missing the necessary Versioneer configuration. You need -a section like: - - [versioneer] - VCS = git - style = pep440 - versionfile_source = src/myproject/_version.py - versionfile_build = myproject/_version.py - tag_prefix = - parentdir_prefix = myproject- - -You will also need to edit your setup.py to use the results: - - import versioneer - setup(version=versioneer.get_version(), - cmdclass=versioneer.get_cmdclass(), ...) - -Please read the docstring in ./versioneer.py for configuration instructions, -edit setup.cfg, and re-run the installer or 'python versioneer.py setup'. -""" - -SAMPLE_CONFIG = """ -# See the docstring in versioneer.py for instructions. Note that you must -# re-run 'versioneer.py setup' after changing this section, and commit the -# resulting files. - -[versioneer] -#VCS = git -#style = pep440 -#versionfile_source = -#versionfile_build = -#tag_prefix = -#parentdir_prefix = - -""" - -OLD_SNIPPET = """ -from ._version import get_versions -__version__ = get_versions()['version'] -del get_versions -""" - -INIT_PY_SNIPPET = """ -from . import {0} -__version__ = {0}.get_versions()['version'] -""" - - -def do_setup(): - """Do main VCS-independent setup function for installing Versioneer.""" - root = get_root() - try: - cfg = get_config_from_root(root) - except ( - EnvironmentError, - configparser.NoSectionError, - configparser.NoOptionError, - ) as e: - if isinstance(e, (EnvironmentError, configparser.NoSectionError)): - print("Adding sample versioneer config to setup.cfg", file=sys.stderr) - with open(os.path.join(root, "setup.cfg"), "a") as f: - f.write(SAMPLE_CONFIG) - print(CONFIG_ERROR, file=sys.stderr) - return 1 - - print(" creating %s" % cfg.versionfile_source) - with open(cfg.versionfile_source, "w") as f: - LONG = LONG_VERSION_PY[cfg.VCS] - f.write( - LONG - % { - "DOLLAR": "$", - "STYLE": cfg.style, - "TAG_PREFIX": cfg.tag_prefix, - "PARENTDIR_PREFIX": cfg.parentdir_prefix, - "VERSIONFILE_SOURCE": cfg.versionfile_source, - } - ) - - ipy = os.path.join(os.path.dirname(cfg.versionfile_source), "__init__.py") - if os.path.exists(ipy): - try: - with open(ipy, "r") as f: - old = f.read() - except EnvironmentError: - old = "" - module = os.path.splitext(os.path.basename(cfg.versionfile_source))[0] - snippet = INIT_PY_SNIPPET.format(module) - if OLD_SNIPPET in old: - print(" replacing boilerplate in %s" % ipy) - with open(ipy, "w") as f: - f.write(old.replace(OLD_SNIPPET, snippet)) - elif snippet not in old: - print(" appending to %s" % ipy) - with open(ipy, "a") as f: - f.write(snippet) - else: - print(" %s unmodified" % ipy) - else: - print(" %s doesn't exist, ok" % ipy) - ipy = None - - # Make sure both the top-level "versioneer.py" and versionfile_source - # (PKG/_version.py, used by runtime code) are in MANIFEST.in, so - # they'll be copied into source distributions. Pip won't be able to - # install the package without this. - manifest_in = os.path.join(root, "MANIFEST.in") - simple_includes = set() - try: - with open(manifest_in, "r") as f: - for line in f: - if line.startswith("include "): - for include in line.split()[1:]: - simple_includes.add(include) - except EnvironmentError: - pass - # That doesn't cover everything MANIFEST.in can do - # (http://docs.python.org/2/distutils/sourcedist.html#commands), so - # it might give some false negatives. Appending redundant 'include' - # lines is safe, though. - if "versioneer.py" not in simple_includes: - print(" appending 'versioneer.py' to MANIFEST.in") - with open(manifest_in, "a") as f: - f.write("include versioneer.py\n") - else: - print(" 'versioneer.py' already in MANIFEST.in") - if cfg.versionfile_source not in simple_includes: - print( - " appending versionfile_source ('%s') to MANIFEST.in" - % cfg.versionfile_source - ) - with open(manifest_in, "a") as f: - f.write("include %s\n" % cfg.versionfile_source) - else: - print(" versionfile_source already in MANIFEST.in") - - # Make VCS-specific changes. For git, this means creating/changing - # .gitattributes to mark _version.py for export-subst keyword - # substitution. - do_vcs_install(manifest_in, cfg.versionfile_source, ipy) - return 0 - - -def scan_setup_py(): - """Validate the contents of setup.py against Versioneer's expectations.""" - found = set() - setters = False - errors = 0 - with open("setup.py", "r") as f: - for line in f.readlines(): - if "import versioneer" in line: - found.add("import") - if "versioneer.get_cmdclass()" in line: - found.add("cmdclass") - if "versioneer.get_version()" in line: - found.add("get_version") - if "versioneer.VCS" in line: - setters = True - if "versioneer.versionfile_source" in line: - setters = True - if len(found) != 3: - print("") - print("Your setup.py appears to be missing some important items") - print("(but I might be wrong). Please make sure it has something") - print("roughly like the following:") - print("") - print(" import versioneer") - print(" setup( version=versioneer.get_version(),") - print(" cmdclass=versioneer.get_cmdclass(), ...)") - print("") - errors += 1 - if setters: - print("You should remove lines like 'versioneer.VCS = ' and") - print("'versioneer.versionfile_source = ' . This configuration") - print("now lives in setup.cfg, and should be removed from setup.py") - print("") - errors += 1 - return errors - - -if __name__ == "__main__": - cmd = sys.argv[1] - if cmd == "setup": - errors = do_setup() - errors += scan_setup_py() - if errors: - sys.exit(1) From b686d6d06aaf7f038d9cb8f4c35eb3e957ccb0ef Mon Sep 17 00:00:00 2001 From: eli knaap Date: Fri, 28 Jul 2023 12:55:23 -0700 Subject: [PATCH 07/17] scm init --- esda/__init__.py | 27 ++++++++++++++++++++++----- 1 file changed, 22 insertions(+), 5 deletions(-) diff --git a/esda/__init__.py b/esda/__init__.py index 13ac9fd4..2c6948f5 100644 --- a/esda/__init__.py +++ b/esda/__init__.py @@ -3,6 +3,10 @@ ================================================= """ + +import contextlib +from importlib.metadata import PackageNotFoundError, version + from . import _version, adbscan, shape # noqa F401 from .correlogram import correlogram # noqa F401 from .gamma import Gamma # noqa F401 @@ -16,13 +20,26 @@ from .join_counts_local_mv import Join_Counts_Local_MV # noqa F401 from .lee import Spatial_Pearson, Spatial_Pearson_Local # noqa F401 from .losh import LOSH # noqa F401 -from .map_comparison import (areal_entropy, completeness, # noqa F401 - external_entropy, homogeneity, overlay_entropy) -from .moran import (Moran, Moran_BV, Moran_BV_matrix, Moran_Local, # noqa F401 - Moran_Local_BV, Moran_Local_Rate, Moran_Rate) +from .map_comparison import ( + areal_entropy, + completeness, # noqa F401 + external_entropy, + homogeneity, + overlay_entropy, +) +from .moran import ( + Moran, + Moran_BV, + Moran_BV_matrix, + Moran_Local, # noqa F401 + Moran_Local_BV, + Moran_Local_Rate, + Moran_Rate, +) from .silhouettes import boundary_silhouette, path_silhouette # noqa F401 from .smaup import Smaup # noqa F401 from .topo import isolation, prominence # noqa F401 from .util import fdr # noqa F401 -__version__ = _version.get_versions()["version"] +with contextlib.suppress(PackageNotFoundError): + __version__ = version("esda") From 7e383465b516333635072ece8665de1e79dc9056 Mon Sep 17 00:00:00 2001 From: eli knaap Date: Fri, 28 Jul 2023 12:58:08 -0700 Subject: [PATCH 08/17] update release workflow --- .github/workflows/upload_package.yml | 109 +++++++++++---------------- 1 file changed, 44 insertions(+), 65 deletions(-) diff --git a/.github/workflows/upload_package.yml b/.github/workflows/upload_package.yml index 92950b36..e0fcc47f 100644 --- a/.github/workflows/upload_package.yml +++ b/.github/workflows/upload_package.yml @@ -1,66 +1,45 @@ +name: Release Package - # Release package on GitHub and publish to PyPI - - # Important: In order to trigger this workflow for the organization - # repo (organzation-name/repo-name vs. user-name/repo-name), a tagged - # commit must be made to *organzation-name/repo-name*. If the tagged - # commit is made to *user-name/repo-name*, a release will be published - # under the user's name, not the organzation. - - #-------------------------------------------------- - name: Release & Publish - - on: - push: - # Sequence of patterns matched against refs/tags - tags: - - "v*" # Push events to matching v*, i.e. v1.0, v20.15.10 - - jobs: - build: - name: Create release & publish to PyPI - runs-on: ubuntu-latest - steps: - - name: Checkout repo - uses: actions/checkout@v3 - - - name: Set up python - uses: actions/setup-python@v4 - with: - python-version: "3.x" - - - name: Install Dependencies - run: | - python -m pip install --upgrade pip - pip install setuptools wheel twine jupyter urllib3 pandas pyyaml - python setup.py sdist bdist_wheel - - - name: run Changelog - run: | - jupyter nbconvert --to notebook --execute --inplace --ExecutePreprocessor.timeout=-1 --ExecutePreprocessor.kernel_name=python3 tools/gitcount.ipynb - - - name: cat Changelog - uses: pCYSl5EDgo/cat@master - id: changetxt - with: - path: ./tools/changelog.md - env: - TEXT: ${{ steps.changetxt.outputs.text }} - - - name: Get the tag name - run: echo "TAG=${GITHUB_REF/refs\/tags\//}" >> $GITHUB_ENV - - - name: Release - uses: softprops/action-gh-release@v1 - with: - body: ${{ steps.changetxt.outputs.text }} - body_path: ${{ steps.changetxt.outputs.path }} - name: Release ${{ env.TAG }} - env: - GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} - - - name: Publish distribution 📦 to PyPI - uses: pypa/gh-action-pypi-publish@master - with: - user: __token__ - password: ${{ secrets.PYPI_PASSWORD }} +on: + push: + # Sequence of patterns matched against refs/tags + tags: + - 'v*' # Push events to matching v*, i.e. v1.0, v20.15.10 + workflow_dispatch: + inputs: + version: + description: Manual Release + default: test + required: false + +jobs: + build: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v3 + - name: Set up Python + uses: actions/setup-python@v4 + with: + python-version: '3.x' + + - name: Install dependencies + run: | + python -m pip install --upgrade pip + pip install setuptools wheel twine jupyter urllib3 pandas pyyaml + python setup.py sdist bdist_wheel + + - name: Create Release Notes + uses: actions/github-script@v6 + with: + github-token: ${{secrets.GITHUB_TOKEN}} + script: | + await github.request(`POST /repos/${{ github.repository }}/releases`, { + tag_name: "${{ github.ref }}", + generate_release_notes: true + }); + + - name: Publish distribution 📦 to PyPI + uses: pypa/gh-action-pypi-publish@release/v1 + with: + user: __token__ + password: ${{ secrets.pypi_password }} \ No newline at end of file From 6d7c0cd502b5eeff1bfcc17cd65c3e1b96d81f22 Mon Sep 17 00:00:00 2001 From: Martin Fleischmann Date: Wed, 2 Aug 2023 22:29:25 +0200 Subject: [PATCH 09/17] use radius --- esda/shape.py | 4 ++-- esda/tests/test_shape.py | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/esda/shape.py b/esda/shape.py index bedfdb07..82f7b664 100644 --- a/esda/shape.py +++ b/esda/shape.py @@ -181,8 +181,8 @@ def minimum_bounding_circle_ratio(collection): (1963) """ ga = _cast(collection) - mbc = shapely.minimum_bounding_circle(ga) - return shapely.area(ga) / shapely.area(mbc) + mbca = (shapely.minimum_bounding_radius(ga) ** 2) * numpy.pi + return shapely.area(ga) / mbca def radii_ratio(collection): diff --git a/esda/tests/test_shape.py b/esda/tests/test_shape.py index e5b16bf9..70baeca4 100644 --- a/esda/tests/test_shape.py +++ b/esda/tests/test_shape.py @@ -79,7 +79,7 @@ def test_nmi(): def test_mbc(): observed = esda.shape.minimum_bounding_circle_ratio(shape) - testing.assert_allclose(observed, 0.437571, atol=ATOL) + testing.assert_allclose(observed, 0.434765, atol=ATOL) def test_reflexive_angle_ratio(): From 77bce5ff2a8ae423572f45f75c903fbce5754e8c Mon Sep 17 00:00:00 2001 From: Martin Fleischmann Date: Thu, 3 Aug 2023 16:34:18 +0200 Subject: [PATCH 10/17] CI: properly test min and dev (#258) * CI: properly test min and dev * better pins * fix nightly index * pin scipy to actual min req * update requirements.txt --- .github/workflows/testing.yml | 4 +- ci/311-DEV.yaml | 13 +- ci/311-numba-DEV.yaml | 13 +- ci/{38-numba.yaml => 38-minimal-numba.yaml} | 8 +- ci/{38.yaml => 38-minimal.yaml} | 8 +- esda/_version.py | 657 -------------------- 6 files changed, 24 insertions(+), 679 deletions(-) rename ci/{38-numba.yaml => 38-minimal-numba.yaml} (69%) rename ci/{38.yaml => 38-minimal.yaml} (68%) delete mode 100644 esda/_version.py diff --git a/.github/workflows/testing.yml b/.github/workflows/testing.yml index 368d43d9..a768f0cb 100644 --- a/.github/workflows/testing.yml +++ b/.github/workflows/testing.yml @@ -28,8 +28,8 @@ matrix: os: [ubuntu-latest] environment-file: - - ci/38.yaml - - ci/38-numba.yaml + - ci/38-minimal.yaml + - ci/38-minimal-numba.yaml - ci/39.yaml - ci/39-numba.yaml - ci/310.yaml diff --git a/ci/311-DEV.yaml b/ci/311-DEV.yaml index 49ab5b13..609f1963 100644 --- a/ci/311-DEV.yaml +++ b/ci/311-DEV.yaml @@ -5,9 +5,6 @@ dependencies: - python=3.11 # required - geos - - pandas>=1.0 - - scikit-learn - - scipy>=1.0 # testing - codecov - matplotlib @@ -23,6 +20,10 @@ dependencies: - sphinxcontrib-napoleon - sphinx_bootstrap_theme - pip: - - git+https://github.com/pysal/libpysal@main - - git+https://github.com/geopandas/geopandas@main - - git+https://github.com/toblerity/shapely@main \ No newline at end of file + - --pre --index-url https://pypi.anaconda.org/scientific-python-nightly-wheels/simple --extra-index-url https://pypi.org/simple + - scikit-learn + - scipy + - pandas + - git+https://github.com/pysal/libpysal@main + - git+https://github.com/geopandas/geopandas@main + - git+https://github.com/toblerity/shapely@main diff --git a/ci/311-numba-DEV.yaml b/ci/311-numba-DEV.yaml index 4d3c3ca9..1ccc3e79 100644 --- a/ci/311-numba-DEV.yaml +++ b/ci/311-numba-DEV.yaml @@ -5,9 +5,6 @@ dependencies: - python=3.11 # required - geos - - pandas>=1.0 - - scikit-learn - - scipy>=1.0 - numba # testing - codecov @@ -25,6 +22,10 @@ dependencies: - sphinxcontrib-napoleon - sphinx_bootstrap_theme - pip: - - git+https://github.com/pysal/libpysal@main - - git+https://github.com/geopandas/geopandas@main - - git+https://github.com/toblerity/shapely@main \ No newline at end of file + - --pre --index-url https://pypi.anaconda.org/scientific-python-nightly-wheels/simple --extra-index-url https://pypi.org/simple + - scikit-learn + - scipy + - pandas + - git+https://github.com/pysal/libpysal@main + - git+https://github.com/geopandas/geopandas@main + - git+https://github.com/toblerity/shapely@main \ No newline at end of file diff --git a/ci/38-numba.yaml b/ci/38-minimal-numba.yaml similarity index 69% rename from ci/38-numba.yaml rename to ci/38-minimal-numba.yaml index 8672da92..e07beea4 100644 --- a/ci/38-numba.yaml +++ b/ci/38-minimal-numba.yaml @@ -6,9 +6,9 @@ dependencies: # required - libpysal - numba - - pandas>=1.0 - - scikit-learn - - scipy>=1.0 + - pandas>=1.4,<1.5 + - scikit-learn>=1.0,<1.1 + - scipy>=1.9,<1.10 # testing - codecov - matplotlib @@ -17,5 +17,5 @@ dependencies: - pytest-xdist - rtree # optional - - geopandas>=0.7.0 + - geopandas>=0.12.0,<0.13 - shapely>=2 diff --git a/ci/38.yaml b/ci/38-minimal.yaml similarity index 68% rename from ci/38.yaml rename to ci/38-minimal.yaml index 8eeff975..ef6042f1 100644 --- a/ci/38.yaml +++ b/ci/38-minimal.yaml @@ -5,9 +5,9 @@ dependencies: - python=3.8 # required - libpysal - - pandas>=1.0 - - scikit-learn - - scipy>=1.0 + - pandas>=1.4,<1.5 + - scikit-learn>=1.0,<1.1 + - scipy>=1.9,<1.10 # testing - codecov - matplotlib @@ -16,5 +16,5 @@ dependencies: - pytest-xdist - rtree # optional - - geopandas>=0.7.0 + - geopandas>=0.12.0,<0.13 - shapely>=2 diff --git a/esda/_version.py b/esda/_version.py deleted file mode 100644 index bc5c4cfe..00000000 --- a/esda/_version.py +++ /dev/null @@ -1,657 +0,0 @@ -# This file helps to compute a version number in source trees obtained from -# git-archive tarball (such as those provided by githubs download-from-tag -# feature). Distribution tarballs (built by setup.py sdist) and build -# directories (produced by setup.py build) will contain a much shorter file -# that just contains the computed version number. - -# This file is released into the public domain. Generated by -# versioneer-0.20 (https://github.com/python-versioneer/python-versioneer) - -"""Git implementation of _version.py.""" - -import errno -import os -import re -import subprocess -import sys - - -def get_keywords(): - """Get the keywords needed to look up the version information.""" - # these strings will be replaced by git during git-archive. - # setup.py/versioneer.py will grep for the variable names, so they must - # each be defined on a line of their own. _version.py will just call - # get_keywords(). - git_refnames = "$Format:%d$" - git_full = "$Format:%H$" - git_date = "$Format:%ci$" - keywords = {"refnames": git_refnames, "full": git_full, "date": git_date} - return keywords - - -class VersioneerConfig: # pylint: disable=too-few-public-methods - """Container for Versioneer configuration parameters.""" - - -def get_config(): - """Create, populate and return the VersioneerConfig() object.""" - # these strings are filled in when 'setup.py versioneer' creates - # _version.py - cfg = VersioneerConfig() - cfg.VCS = "git" - cfg.style = "pep440" - cfg.tag_prefix = "v" - cfg.parentdir_prefix = "esda-" - cfg.versionfile_source = "esda/_version.py" - cfg.verbose = False - return cfg - - -class NotThisMethod(Exception): - """Exception raised if a method is not valid for the current scenario.""" - - -LONG_VERSION_PY = {} -HANDLERS = {} - - -def register_vcs_handler(vcs, method): # decorator - """Create decorator to mark a method as the handler of a VCS.""" - - def decorate(f): - """Store f in HANDLERS[vcs][method].""" - if vcs not in HANDLERS: - HANDLERS[vcs] = {} - HANDLERS[vcs][method] = f - return f - - return decorate - - -# pylint:disable=too-many-arguments,consider-using-with # noqa -def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False, env=None): - """Call the given command(s).""" - assert isinstance(commands, list) - process = None - for command in commands: - try: - dispcmd = str([command] + args) - # remember shell=False, so use git.cmd on windows, not just git - process = subprocess.Popen( - [command] + args, - cwd=cwd, - env=env, - stdout=subprocess.PIPE, - stderr=(subprocess.PIPE if hide_stderr else None), - ) - break - except EnvironmentError: - e = sys.exc_info()[1] - if e.errno == errno.ENOENT: - continue - if verbose: - print("unable to run %s" % dispcmd) - print(e) - return None, None - else: - if verbose: - print("unable to find command, tried %s" % (commands,)) - return None, None - stdout = process.communicate()[0].strip().decode() - if process.returncode != 0: - if verbose: - print("unable to run %s (error)" % dispcmd) - print("stdout was %s" % stdout) - return None, process.returncode - return stdout, process.returncode - - -def versions_from_parentdir(parentdir_prefix, root, verbose): - """Try to determine the version from the parent directory name. - - Source tarballs conventionally unpack into a directory that includes both - the project name and a version string. We will also support searching up - two directory levels for an appropriately named parent directory - """ - rootdirs = [] - - for _ in range(3): - dirname = os.path.basename(root) - if dirname.startswith(parentdir_prefix): - return { - "version": dirname[len(parentdir_prefix) :], - "full-revisionid": None, - "dirty": False, - "error": None, - "date": None, - } - rootdirs.append(root) - root = os.path.dirname(root) # up a level - - if verbose: - print( - "Tried directories %s but none started with prefix %s" - % (str(rootdirs), parentdir_prefix) - ) - raise NotThisMethod("rootdir doesn't start with parentdir_prefix") - - -@register_vcs_handler("git", "get_keywords") -def git_get_keywords(versionfile_abs): - """Extract version information from the given file.""" - # the code embedded in _version.py can just fetch the value of these - # keywords. When used from setup.py, we don't want to import _version.py, - # so we do it with a regexp instead. This function is not used from - # _version.py. - keywords = {} - try: - with open(versionfile_abs, "r") as fobj: - for line in fobj: - if line.strip().startswith("git_refnames ="): - mo = re.search(r'=\s*"(.*)"', line) - if mo: - keywords["refnames"] = mo.group(1) - if line.strip().startswith("git_full ="): - mo = re.search(r'=\s*"(.*)"', line) - if mo: - keywords["full"] = mo.group(1) - if line.strip().startswith("git_date ="): - mo = re.search(r'=\s*"(.*)"', line) - if mo: - keywords["date"] = mo.group(1) - except EnvironmentError: - pass - return keywords - - -@register_vcs_handler("git", "keywords") -def git_versions_from_keywords(keywords, tag_prefix, verbose): - """Get version information from git keywords.""" - if "refnames" not in keywords: - raise NotThisMethod("Short version file found") - date = keywords.get("date") - if date is not None: - # Use only the last line. Previous lines may contain GPG signature - # information. - date = date.splitlines()[-1] - - # git-2.2.0 added "%cI", which expands to an ISO-8601 -compliant - # datestamp. However we prefer "%ci" (which expands to an "ISO-8601 - # -like" string, which we must then edit to make compliant), because - # it's been around since git-1.5.3, and it's too difficult to - # discover which version we're using, or to work around using an - # older one. - date = date.strip().replace(" ", "T", 1).replace(" ", "", 1) - refnames = keywords["refnames"].strip() - if refnames.startswith("$Format"): - if verbose: - print("keywords are unexpanded, not using") - raise NotThisMethod("unexpanded keywords, not a git-archive tarball") - refs = {r.strip() for r in refnames.strip("()").split(",")} - # starting in git-1.8.3, tags are listed as "tag: foo-1.0" instead of - # just "foo-1.0". If we see a "tag: " prefix, prefer those. - TAG = "tag: " - tags = {r[len(TAG) :] for r in refs if r.startswith(TAG)} - if not tags: - # Either we're using git < 1.8.3, or there really are no tags. We use - # a heuristic: assume all version tags have a digit. The old git %d - # expansion behaves like git log --decorate=short and strips out the - # refs/heads/ and refs/tags/ prefixes that would let us distinguish - # between branches and tags. By ignoring refnames without digits, we - # filter out many common branch names like "release" and - # "stabilization", as well as "HEAD" and "master". - tags = {r for r in refs if re.search(r"\d", r)} - if verbose: - print("discarding '%s', no digits" % ",".join(refs - tags)) - if verbose: - print("likely tags: %s" % ",".join(sorted(tags))) - for ref in sorted(tags): - # sorting will prefer e.g. "2.0" over "2.0rc1" - if ref.startswith(tag_prefix): - r = ref[len(tag_prefix) :] - # Filter out refs that exactly match prefix or that don't start - # with a number once the prefix is stripped (mostly a concern - # when prefix is '') - if not re.match(r"\d", r): - continue - if verbose: - print("picking %s" % r) - return { - "version": r, - "full-revisionid": keywords["full"].strip(), - "dirty": False, - "error": None, - "date": date, - } - # no suitable tags, so version is "0+unknown", but full hex is still there - if verbose: - print("no suitable tags, using unknown + full revision id") - return { - "version": "0+unknown", - "full-revisionid": keywords["full"].strip(), - "dirty": False, - "error": "no suitable tags", - "date": None, - } - - -@register_vcs_handler("git", "pieces_from_vcs") -def git_pieces_from_vcs(tag_prefix, root, verbose, runner=run_command): - """Get version from 'git describe' in the root of the source tree. - - This only gets called if the git-archive 'subst' keywords were *not* - expanded, and _version.py hasn't already been rewritten with a short - version string, meaning we're inside a checked out source tree. - """ - GITS = ["git"] - if sys.platform == "win32": - GITS = ["git.cmd", "git.exe"] - - _, rc = runner(GITS, ["rev-parse", "--git-dir"], cwd=root, hide_stderr=True) - if rc != 0: - if verbose: - print("Directory %s not under git control" % root) - raise NotThisMethod("'git rev-parse --git-dir' returned error") - - # if there is a tag matching tag_prefix, this yields TAG-NUM-gHEX[-dirty] - # if there isn't one, this yields HEX[-dirty] (no NUM) - describe_out, rc = runner( - GITS, - [ - "describe", - "--tags", - "--dirty", - "--always", - "--long", - "--match", - "%s*" % tag_prefix, - ], - cwd=root, - ) - # --long was added in git-1.5.5 - if describe_out is None: - raise NotThisMethod("'git describe' failed") - describe_out = describe_out.strip() - full_out, rc = runner(GITS, ["rev-parse", "HEAD"], cwd=root) - if full_out is None: - raise NotThisMethod("'git rev-parse' failed") - full_out = full_out.strip() - - pieces = {} - pieces["long"] = full_out - pieces["short"] = full_out[:7] # maybe improved later - pieces["error"] = None - - branch_name, rc = runner(GITS, ["rev-parse", "--abbrev-ref", "HEAD"], cwd=root) - # --abbrev-ref was added in git-1.6.3 - if rc != 0 or branch_name is None: - raise NotThisMethod("'git rev-parse --abbrev-ref' returned error") - branch_name = branch_name.strip() - - if branch_name == "HEAD": - # If we aren't exactly on a branch, pick a branch which represents - # the current commit. If all else fails, we are on a branchless - # commit. - branches, rc = runner(GITS, ["branch", "--contains"], cwd=root) - # --contains was added in git-1.5.4 - if rc != 0 or branches is None: - raise NotThisMethod("'git branch --contains' returned error") - branches = branches.split("\n") - - # Remove the first line if we're running detached - if "(" in branches[0]: - branches.pop(0) - - # Strip off the leading "* " from the list of branches. - branches = [branch[2:] for branch in branches] - if "master" in branches: - branch_name = "master" - elif not branches: - branch_name = None - else: - # Pick the first branch that is returned. Good or bad. - branch_name = branches[0] - - pieces["branch"] = branch_name - - # parse describe_out. It will be like TAG-NUM-gHEX[-dirty] or HEX[-dirty] - # TAG might have hyphens. - git_describe = describe_out - - # look for -dirty suffix - dirty = git_describe.endswith("-dirty") - pieces["dirty"] = dirty - if dirty: - git_describe = git_describe[: git_describe.rindex("-dirty")] - - # now we have TAG-NUM-gHEX or HEX - - if "-" in git_describe: - # TAG-NUM-gHEX - mo = re.search(r"^(.+)-(\d+)-g([0-9a-f]+)$", git_describe) - if not mo: - # unparseable. Maybe git-describe is misbehaving? - pieces["error"] = "unable to parse git-describe output: '%s'" % describe_out - return pieces - - # tag - full_tag = mo.group(1) - if not full_tag.startswith(tag_prefix): - if verbose: - fmt = "tag '%s' doesn't start with prefix '%s'" - print(fmt % (full_tag, tag_prefix)) - pieces["error"] = "tag '%s' doesn't start with prefix '%s'" % ( - full_tag, - tag_prefix, - ) - return pieces - pieces["closest-tag"] = full_tag[len(tag_prefix) :] - - # distance: number of commits since tag - pieces["distance"] = int(mo.group(2)) - - # commit: short hex revision ID - pieces["short"] = mo.group(3) - - else: - # HEX: no tags - pieces["closest-tag"] = None - count_out, rc = runner(GITS, ["rev-list", "HEAD", "--count"], cwd=root) - pieces["distance"] = int(count_out) # total number of commits - - # commit date: see ISO-8601 comment in git_versions_from_keywords() - date = runner(GITS, ["show", "-s", "--format=%ci", "HEAD"], cwd=root)[0].strip() - # Use only the last line. Previous lines may contain GPG signature - # information. - date = date.splitlines()[-1] - pieces["date"] = date.strip().replace(" ", "T", 1).replace(" ", "", 1) - - return pieces - - -def plus_or_dot(pieces): - """Return a + if we don't already have one, else return a .""" - if "+" in pieces.get("closest-tag", ""): - return "." - return "+" - - -def render_pep440(pieces): - """Build up version string, with post-release "local version identifier". - - Our goal: TAG[+DISTANCE.gHEX[.dirty]] . Note that if you - get a tagged build and then dirty it, you'll get TAG+0.gHEX.dirty - - Exceptions: - 1: no tags. git_describe was just HEX. 0+untagged.DISTANCE.gHEX[.dirty] - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - if pieces["distance"] or pieces["dirty"]: - rendered += plus_or_dot(pieces) - rendered += "%d.g%s" % (pieces["distance"], pieces["short"]) - if pieces["dirty"]: - rendered += ".dirty" - else: - # exception #1 - rendered = "0+untagged.%d.g%s" % (pieces["distance"], pieces["short"]) - if pieces["dirty"]: - rendered += ".dirty" - return rendered - - -def render_pep440_branch(pieces): - """TAG[[.dev0]+DISTANCE.gHEX[.dirty]] . - - The ".dev0" means not master branch. Note that .dev0 sorts backwards - (a feature branch will appear "older" than the master branch). - - Exceptions: - 1: no tags. 0[.dev0]+untagged.DISTANCE.gHEX[.dirty] - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - if pieces["distance"] or pieces["dirty"]: - if pieces["branch"] != "master": - rendered += ".dev0" - rendered += plus_or_dot(pieces) - rendered += "%d.g%s" % (pieces["distance"], pieces["short"]) - if pieces["dirty"]: - rendered += ".dirty" - else: - # exception #1 - rendered = "0" - if pieces["branch"] != "master": - rendered += ".dev0" - rendered += "+untagged.%d.g%s" % (pieces["distance"], pieces["short"]) - if pieces["dirty"]: - rendered += ".dirty" - return rendered - - -def render_pep440_pre(pieces): - """TAG[.post0.devDISTANCE] -- No -dirty. - - Exceptions: - 1: no tags. 0.post0.devDISTANCE - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - if pieces["distance"]: - rendered += ".post0.dev%d" % pieces["distance"] - else: - # exception #1 - rendered = "0.post0.dev%d" % pieces["distance"] - return rendered - - -def render_pep440_post(pieces): - """TAG[.postDISTANCE[.dev0]+gHEX] . - - The ".dev0" means dirty. Note that .dev0 sorts backwards - (a dirty tree will appear "older" than the corresponding clean one), - but you shouldn't be releasing software with -dirty anyways. - - Exceptions: - 1: no tags. 0.postDISTANCE[.dev0] - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - if pieces["distance"] or pieces["dirty"]: - rendered += ".post%d" % pieces["distance"] - if pieces["dirty"]: - rendered += ".dev0" - rendered += plus_or_dot(pieces) - rendered += "g%s" % pieces["short"] - else: - # exception #1 - rendered = "0.post%d" % pieces["distance"] - if pieces["dirty"]: - rendered += ".dev0" - rendered += "+g%s" % pieces["short"] - return rendered - - -def render_pep440_post_branch(pieces): - """TAG[.postDISTANCE[.dev0]+gHEX[.dirty]] . - - The ".dev0" means not master branch. - - Exceptions: - 1: no tags. 0.postDISTANCE[.dev0]+gHEX[.dirty] - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - if pieces["distance"] or pieces["dirty"]: - rendered += ".post%d" % pieces["distance"] - if pieces["branch"] != "master": - rendered += ".dev0" - rendered += plus_or_dot(pieces) - rendered += "g%s" % pieces["short"] - if pieces["dirty"]: - rendered += ".dirty" - else: - # exception #1 - rendered = "0.post%d" % pieces["distance"] - if pieces["branch"] != "master": - rendered += ".dev0" - rendered += "+g%s" % pieces["short"] - if pieces["dirty"]: - rendered += ".dirty" - return rendered - - -def render_pep440_old(pieces): - """TAG[.postDISTANCE[.dev0]] . - - The ".dev0" means dirty. - - Exceptions: - 1: no tags. 0.postDISTANCE[.dev0] - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - if pieces["distance"] or pieces["dirty"]: - rendered += ".post%d" % pieces["distance"] - if pieces["dirty"]: - rendered += ".dev0" - else: - # exception #1 - rendered = "0.post%d" % pieces["distance"] - if pieces["dirty"]: - rendered += ".dev0" - return rendered - - -def render_git_describe(pieces): - """TAG[-DISTANCE-gHEX][-dirty]. - - Like 'git describe --tags --dirty --always'. - - Exceptions: - 1: no tags. HEX[-dirty] (note: no 'g' prefix) - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - if pieces["distance"]: - rendered += "-%d-g%s" % (pieces["distance"], pieces["short"]) - else: - # exception #1 - rendered = pieces["short"] - if pieces["dirty"]: - rendered += "-dirty" - return rendered - - -def render_git_describe_long(pieces): - """TAG-DISTANCE-gHEX[-dirty]. - - Like 'git describe --tags --dirty --always -long'. - The distance/hash is unconditional. - - Exceptions: - 1: no tags. HEX[-dirty] (note: no 'g' prefix) - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - rendered += "-%d-g%s" % (pieces["distance"], pieces["short"]) - else: - # exception #1 - rendered = pieces["short"] - if pieces["dirty"]: - rendered += "-dirty" - return rendered - - -def render(pieces, style): - """Render the given version pieces into the requested style.""" - if pieces["error"]: - return { - "version": "unknown", - "full-revisionid": pieces.get("long"), - "dirty": None, - "error": pieces["error"], - "date": None, - } - - if not style or style == "default": - style = "pep440" # the default - - if style == "pep440": - rendered = render_pep440(pieces) - elif style == "pep440-branch": - rendered = render_pep440_branch(pieces) - elif style == "pep440-pre": - rendered = render_pep440_pre(pieces) - elif style == "pep440-post": - rendered = render_pep440_post(pieces) - elif style == "pep440-post-branch": - rendered = render_pep440_post_branch(pieces) - elif style == "pep440-old": - rendered = render_pep440_old(pieces) - elif style == "git-describe": - rendered = render_git_describe(pieces) - elif style == "git-describe-long": - rendered = render_git_describe_long(pieces) - else: - raise ValueError("unknown style '%s'" % style) - - return { - "version": rendered, - "full-revisionid": pieces["long"], - "dirty": pieces["dirty"], - "error": None, - "date": pieces.get("date"), - } - - -def get_versions(): - """Get version information or return default if unable to do so.""" - # I am in _version.py, which lives at ROOT/VERSIONFILE_SOURCE. If we have - # __file__, we can work backwards from there to the root. Some - # py2exe/bbfreeze/non-CPython implementations don't do __file__, in which - # case we can only use expanded keywords. - - cfg = get_config() - verbose = cfg.verbose - - try: - return git_versions_from_keywords(get_keywords(), cfg.tag_prefix, verbose) - except NotThisMethod: - pass - - try: - root = os.path.realpath(__file__) - # versionfile_source is the relative path from the top of the source - # tree (where the .git directory might live) to this file. Invert - # this to find the root from __file__. - for _ in cfg.versionfile_source.split("/"): - root = os.path.dirname(root) - except NameError: - return { - "version": "0+unknown", - "full-revisionid": None, - "dirty": None, - "error": "unable to find root of source tree", - "date": None, - } - - try: - pieces = git_pieces_from_vcs(cfg.tag_prefix, root, verbose) - return render(pieces, cfg.style) - except NotThisMethod: - pass - - try: - if cfg.parentdir_prefix: - return versions_from_parentdir(cfg.parentdir_prefix, root, verbose) - except NotThisMethod: - pass - - return { - "version": "0+unknown", - "full-revisionid": None, - "dirty": None, - "error": "unable to compute version", - "date": None, - } From c0260bcdf39689dfaf152b1e8d4e4fdbb8e57ad0 Mon Sep 17 00:00:00 2001 From: eli knaap Date: Thu, 3 Aug 2023 16:37:06 -0700 Subject: [PATCH 11/17] rebase --- esda/__init__.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/esda/__init__.py b/esda/__init__.py index 2c6948f5..4659f515 100644 --- a/esda/__init__.py +++ b/esda/__init__.py @@ -7,8 +7,8 @@ import contextlib from importlib.metadata import PackageNotFoundError, version -from . import _version, adbscan, shape # noqa F401 -from .correlogram import correlogram # noqa F401 +from . import adbscan, shape # noqa F401 # noqa F401 +from .correlogram import correlogram # noqa F401 from .gamma import Gamma # noqa F401 from .geary import Geary # noqa F401 from .geary_local import Geary_Local # noqa F401 From e5cc4438f1fbadbc225f5d59cf562ececcaf4abe Mon Sep 17 00:00:00 2001 From: eli knaap Date: Thu, 3 Aug 2023 16:51:22 -0700 Subject: [PATCH 12/17] rm manifest --- .coveragerc | 2 -- MANIFEST.in | 3 --- 2 files changed, 5 deletions(-) delete mode 100644 MANIFEST.in diff --git a/.coveragerc b/.coveragerc index 560b9317..dc104fc5 100644 --- a/.coveragerc +++ b/.coveragerc @@ -9,8 +9,6 @@ omit = docs/conf.py setup.py */tests/* - versioneer.py - *_version.py [html] directory = coverage_html_report diff --git a/MANIFEST.in b/MANIFEST.in deleted file mode 100644 index a5a65faf..00000000 --- a/MANIFEST.in +++ /dev/null @@ -1,3 +0,0 @@ -include MANIFEST.in LICENSE.txt requirements.txt requirements_docs.txt requirements_plus.txt requirements_tests.txt -include versioneer.py -include esda/_version.py From f2b952e54933d17fd9d88ad82838f3c45d40b06a Mon Sep 17 00:00:00 2001 From: eli knaap Date: Thu, 3 Aug 2023 17:21:31 -0700 Subject: [PATCH 13/17] double comment --- esda/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/esda/__init__.py b/esda/__init__.py index 4659f515..18c54f79 100644 --- a/esda/__init__.py +++ b/esda/__init__.py @@ -7,7 +7,7 @@ import contextlib from importlib.metadata import PackageNotFoundError, version -from . import adbscan, shape # noqa F401 # noqa F401 +from . import adbscan, shape # noqa F401 from .correlogram import correlogram # noqa F401 from .gamma import Gamma # noqa F401 from .geary import Geary # noqa F401 From d8708fa28468d0e9832e338ad7d3d62f5a6dfcd1 Mon Sep 17 00:00:00 2001 From: eli knaap Date: Sat, 5 Aug 2023 15:39:13 -0700 Subject: [PATCH 14/17] callable --- esda/correlogram.py | 66 ++-- notebooks/correlogram.ipynb | 658 +++++++++++++++--------------------- 2 files changed, 294 insertions(+), 430 deletions(-) diff --git a/esda/correlogram.py b/esda/correlogram.py index c5c0e301..2d6a64f2 100644 --- a/esda/correlogram.py +++ b/esda/correlogram.py @@ -6,14 +6,11 @@ from libpysal.cg.kdtree import KDTree from libpysal.weights import KNN, DistanceBand from libpysal.weights.util import get_points_array +from esda.moran import Moran -from .geary import Geary -from .getisord import G -from .moran import Moran - -def _get_autocorrelation_stat(inputs): - """helper function for computing parallel autocorrelation statistics +def _get_stat(inputs): + """helper function for computing parallel statistics at multiple Graph specifications Parameters ---------- @@ -27,8 +24,8 @@ def _get_autocorrelation_stat(inputs): """ ( y, # y variable - tree, # kd tree - W, # weights class DistanceBand or KNN + tree, # kdreee, + W, # weights class STATISTIC, # class of statistic (Moran, Geary, etc) dist, # threshold/k parameter for the weights weights_kwargs, # additional args @@ -48,16 +45,16 @@ def correlogram( gdf: gpd.GeoDataFrame, variable: str, distances: list, + statistic: callable = Moran, distance_type: str = "band", - statistic: str = "I", weights_kwargs: dict = None, stat_kwargs: dict = None, + select_numeric: bool = False, n_jobs: int = -1, - backend: str = "loky", ): """Generate a spatial correlogram - A spatial correlogram is a set of spatial autocorrelation statistics calculated for + A spatial profile is a set of spatial autocorrelation statistics calculated for a set of increasing distances. It is a useful exploratory tool for examining how the relationship between spatial units changes over different notions of scale. @@ -69,21 +66,27 @@ def correlogram( column on the geodataframe used to compute autocorrelation statistic distances : list list of distances to compute the autocorrelation statistic + statistic : callable + statistic to be computed for a range of libpysal.Graph specifications. + This should be a class with a signature like `Statistic(y,w, **kwargs)` + where y is a numpy array and w is a libpysal.Graph. + Generally, this is a class from pysal's `esda` package + defaults to esda.Moran, which computes the Moran's I statistic distance_type : str, optional which concept of distance to increment. Options are {`band`, `knn`}. by default 'band' (for `libpysal.weights.DistanceBand` weights) - statistic : str, by default 'I' - which spatial autocorrelation statistic to compute. Options in {`I`, `G`, `C`} weights_kwargs : dict additional keyword arguments passed to the libpysal.weights.W class stat_kwargs : dict additional keyword arguments passed to the `esda` autocorrelation statistic class. For example for faster results with no statistical inference, set the number of permutations to zero with {permutations: 0} + select_numeric : bool + if True, only return numeric attributes from the original class. This is useful + e.g. to prevent lists inside a "cell" of a dataframe n_jobs : int number of jobs to pass to joblib. If -1 (default), all cores will be used - backend : str - backend parameter passed to joblib + Returns ------- @@ -94,15 +97,6 @@ def correlogram( stat_kwargs = dict() if weights_kwargs is None: weights_kwargs = dict() - if statistic == "I": - STATISTIC = Moran - elif statistic == "G": - STATISTIC = G - elif statistic == "C": - STATISTIC = Geary - else: - with NotImplementedError as e: - raise e("Only I, G, and C statistics are currently implemented") if distance_type == "band": W = DistanceBand @@ -115,36 +109,32 @@ def correlogram( with NotImplementedError as e: raise e("distance_type must be either `band` or `knn` ") - # should be able to build the tree once and reuse it? - # but in practice, im not seeing any real difference from starting a new W from scratch each time + # there's a faster way to do this by building the largest tree first, then subsetting... pts = get_points_array(gdf[gdf.geometry.name]) tree = KDTree(pts) y = gdf[variable].values inputs = [ - tuple( - [ + ( y, tree, W, - STATISTIC, + statistic, dist, weights_kwargs, stat_kwargs, - ] - ) + ) for dist in distances ] - outputs = Parallel(n_jobs=n_jobs, backend=backend)( - delayed(_get_autocorrelation_stat)(i) for i in inputs + outputs = Parallel(n_jobs=n_jobs, backend="loky")( + delayed(_get_stat)(i) for i in inputs ) - return ( - pd.DataFrame(outputs) - .select_dtypes(["number"]) - .drop(columns=["permutations", "n"]) - ) + df = pd.DataFrame(outputs) + if select_numeric: + df = df.select_dtypes(["number"]) + return df ## Note: To be implemented: diff --git a/notebooks/correlogram.ipynb b/notebooks/correlogram.ipynb index 3a86c795..3df59b96 100644 --- a/notebooks/correlogram.ipynb +++ b/notebooks/correlogram.ipynb @@ -6,11 +6,11 @@ "id": "0c88261c-c8d4-4638-a727-60d833b7d111", "metadata": { "execution": { - "iopub.execute_input": "2023-08-03T23:17:14.119270Z", - "iopub.status.busy": "2023-08-03T23:17:14.119197Z", - "iopub.status.idle": "2023-08-03T23:17:15.653710Z", - "shell.execute_reply": "2023-08-03T23:17:15.653322Z", - "shell.execute_reply.started": "2023-08-03T23:17:14.119261Z" + "iopub.execute_input": "2023-08-05T22:38:08.827468Z", + "iopub.status.busy": "2023-08-05T22:38:08.827205Z", + "iopub.status.idle": "2023-08-05T22:38:09.918747Z", + "shell.execute_reply": "2023-08-05T22:38:09.918338Z", + "shell.execute_reply.started": "2023-08-05T22:38:08.827374Z" }, "tags": [] }, @@ -34,9 +34,7 @@ "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:198: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", " @jit\n", "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:260: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", - " @jit\n", - "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/numba/core/decorators.py:282: RuntimeWarning: nopython is set for njit and is ignored\n", - " warnings.warn('nopython is set for njit and is ignored', RuntimeWarning)\n" + " @jit\n" ] } ], @@ -58,11 +56,11 @@ "id": "68d86eb6-8595-48f0-a244-8889c59e770d", "metadata": { "execution": { - "iopub.execute_input": "2023-08-03T23:17:15.655111Z", - "iopub.status.busy": "2023-08-03T23:17:15.654916Z", - "iopub.status.idle": "2023-08-03T23:17:15.875563Z", - "shell.execute_reply": "2023-08-03T23:17:15.875259Z", - "shell.execute_reply.started": "2023-08-03T23:17:15.655098Z" + "iopub.execute_input": "2023-08-05T22:38:09.920052Z", + "iopub.status.busy": "2023-08-05T22:38:09.919906Z", + "iopub.status.idle": "2023-08-05T22:38:10.131010Z", + "shell.execute_reply": "2023-08-05T22:38:10.130752Z", + "shell.execute_reply.started": "2023-08-05T22:38:09.920043Z" }, "tags": [] }, @@ -77,11 +75,11 @@ "id": "2650732f-b704-4af8-bfee-ccd8c75cf133", "metadata": { "execution": { - "iopub.execute_input": "2023-08-03T23:17:15.876077Z", - "iopub.status.busy": "2023-08-03T23:17:15.875986Z", - "iopub.status.idle": "2023-08-03T23:17:15.953792Z", - "shell.execute_reply": "2023-08-03T23:17:15.953427Z", - "shell.execute_reply.started": "2023-08-03T23:17:15.876067Z" + "iopub.execute_input": "2023-08-05T22:38:10.131596Z", + "iopub.status.busy": "2023-08-05T22:38:10.131507Z", + "iopub.status.idle": "2023-08-05T22:38:10.206997Z", + "shell.execute_reply": "2023-08-05T22:38:10.206722Z", + "shell.execute_reply.started": "2023-08-05T22:38:10.131587Z" }, "tags": [] }, @@ -92,15 +90,15 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 4, "id": "d3b1de58-3fb4-4874-ae5b-63f5e03f869d", "metadata": { "execution": { - "iopub.execute_input": "2023-08-03T23:17:16.046262Z", - "iopub.status.busy": "2023-08-03T23:17:16.046130Z", - "iopub.status.idle": "2023-08-03T23:17:16.093964Z", - "shell.execute_reply": "2023-08-03T23:17:16.093568Z", - "shell.execute_reply.started": "2023-08-03T23:17:16.046251Z" + "iopub.execute_input": "2023-08-05T22:38:10.207610Z", + "iopub.status.busy": "2023-08-05T22:38:10.207522Z", + "iopub.status.idle": "2023-08-05T22:38:10.252685Z", + "shell.execute_reply": "2023-08-05T22:38:10.252390Z", + "shell.execute_reply.started": "2023-08-05T22:38:10.207601Z" }, "tags": [] }, @@ -113,17 +111,17 @@ "\u001b[0;34m\u001b[0m \u001b[0mgdf\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mgeopandas\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgeodataframe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mGeoDataFrame\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", "\u001b[0;34m\u001b[0m \u001b[0mvariable\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", "\u001b[0;34m\u001b[0m \u001b[0mdistances\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mlist\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mstatistic\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m<\u001b[0m\u001b[0mbuilt\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;32min\u001b[0m \u001b[0mfunction\u001b[0m \u001b[0mcallable\u001b[0m\u001b[0;34m>\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m<\u001b[0m\u001b[0;32mclass\u001b[0m \u001b[0;34m'esda.moran.Moran'\u001b[0m\u001b[0;34m>\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", "\u001b[0;34m\u001b[0m \u001b[0mdistance_type\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mstr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'band'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m \u001b[0mstatistic\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mstr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'I'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", "\u001b[0;34m\u001b[0m \u001b[0mweights_kwargs\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mdict\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", "\u001b[0;34m\u001b[0m \u001b[0mstat_kwargs\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mdict\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mselect_numeric\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mbool\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", "\u001b[0;34m\u001b[0m \u001b[0mn_jobs\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mint\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m \u001b[0mbackend\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mstr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'loky'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", "\u001b[0;34m\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;31mDocstring:\u001b[0m\n", "Generate a spatial correlogram\n", "\n", - "A spatial correlogram is a set of spatial autocorrelation statistics calculated for\n", + "A spatial profile is a set of spatial autocorrelation statistics calculated for\n", "a set of increasing distances. It is a useful exploratory tool for examining\n", "how the relationship between spatial units changes over different notions of scale.\n", "\n", @@ -135,21 +133,27 @@ " column on the geodataframe used to compute autocorrelation statistic\n", "distances : list\n", " list of distances to compute the autocorrelation statistic\n", + "statistic : callable\n", + " statistic to be computed for a range of libpysal.Graph specifications.\n", + " This should be a class with a signature like `Statistic(y,w, **kwargs)`\n", + " where y is a numpy array and w is a libpysal.Graph.\n", + " Generally, this is a class from pysal's `esda` package\n", + " defaults to esda.Moran, which computes the Moran's I statistic\n", "distance_type : str, optional\n", " which concept of distance to increment. Options are {`band`, `knn`}.\n", " by default 'band' (for `libpysal.weights.DistanceBand` weights)\n", - "statistic : str, by default 'I'\n", - " which spatial autocorrelation statistic to compute. Options in {`I`, `G`, `C`}\n", "weights_kwargs : dict\n", " additional keyword arguments passed to the libpysal.weights.W class\n", "stat_kwargs : dict\n", " additional keyword arguments passed to the `esda` autocorrelation statistic class.\n", " For example for faster results with no statistical inference, set the number\n", " of permutations to zero with {permutations: 0}\n", + "select_numeric : bool\n", + " if True, only return numeric attributes from the original class. This is useful\n", + " e.g. to prevent lists inside a \"cell\" of a dataframe\n", "n_jobs : int\n", " number of jobs to pass to joblib. If -1 (default), all cores will be used\n", - "backend : str\n", - " backend parameter passed to joblib\n", + "\n", "\n", "Returns\n", "-------\n", @@ -167,6 +171,33 @@ "correlogram?" ] }, + { + "cell_type": "code", + "execution_count": 5, + "id": "90fc27f4-1f71-4a39-bcd1-339fa27fa3b4", + "metadata": { + "execution": { + "iopub.execute_input": "2023-08-05T22:38:10.253267Z", + "iopub.status.busy": "2023-08-05T22:38:10.253180Z", + "iopub.status.idle": "2023-08-05T22:38:10.283353Z", + "shell.execute_reply": "2023-08-05T22:38:10.282850Z", + "shell.execute_reply.started": "2023-08-05T22:38:10.253257Z" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "from esda import Moran, Geary, G" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b77f0304-7eb2-4a95-af23-35c3d7bbb20a", + "metadata": {}, + "outputs": [], + "source": [] + }, { "cell_type": "markdown", "id": "d77ee874-e889-4d60-a039-434906696451", @@ -177,15 +208,31 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, + "id": "236f9f70-4707-4335-ab8f-f9ec7c4027e7", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9184373d-203c-43ec-80fe-94c0cdb41e85", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 6, "id": "ab615631-b083-4700-b402-8dd8343cc790", "metadata": { "execution": { - "iopub.execute_input": "2023-08-03T23:17:15.954294Z", - "iopub.status.busy": "2023-08-03T23:17:15.954208Z", - "iopub.status.idle": "2023-08-03T23:17:15.982954Z", - "shell.execute_reply": "2023-08-03T23:17:15.982573Z", - "shell.execute_reply.started": "2023-08-03T23:17:15.954284Z" + "iopub.execute_input": "2023-08-05T22:38:10.283933Z", + "iopub.status.busy": "2023-08-05T22:38:10.283848Z", + "iopub.status.idle": "2023-08-05T22:38:10.313104Z", + "shell.execute_reply": "2023-08-05T22:38:10.312763Z", + "shell.execute_reply.started": "2023-08-05T22:38:10.283925Z" }, "tags": [] }, @@ -198,15 +245,15 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "id": "049e4002-52a1-4205-9238-bfdb175f04ff", "metadata": { "execution": { - "iopub.execute_input": "2023-08-03T23:17:16.013401Z", - "iopub.status.busy": "2023-08-03T23:17:16.013302Z", - "iopub.status.idle": "2023-08-03T23:17:16.044125Z", - "shell.execute_reply": "2023-08-03T23:17:16.043717Z", - "shell.execute_reply.started": "2023-08-03T23:17:16.013392Z" + "iopub.execute_input": "2023-08-05T22:38:10.315016Z", + "iopub.status.busy": "2023-08-05T22:38:10.314723Z", + "iopub.status.idle": "2023-08-05T22:38:10.343152Z", + "shell.execute_reply": "2023-08-05T22:38:10.342713Z", + "shell.execute_reply.started": "2023-08-05T22:38:10.315005Z" }, "tags": [] }, @@ -217,7 +264,7 @@ "[500, 1000, 1500, 2000, 2500, 3000, 3500, 4000, 4500, 5000]" ] }, - "execution_count": 6, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } @@ -236,128 +283,14 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "id": "9d546402-f9c8-407c-945e-b72979fc9df8", "metadata": { - "execution": { - "iopub.execute_input": "2023-08-03T23:17:16.094447Z", - "iopub.status.busy": "2023-08-03T23:17:16.094359Z", - "iopub.status.idle": "2023-08-03T23:17:17.640557Z", - "shell.execute_reply": "2023-08-03T23:17:17.640202Z", - "shell.execute_reply.started": "2023-08-03T23:17:16.094438Z" - }, "tags": [] }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:38: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", - " @jit\n", - "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:38: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", - " @jit\n", - "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:164: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", - " @jit\n", - "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:164: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", - " @jit\n", - "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:198: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", - " @jit\n", - "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:198: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", - " @jit\n", - "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:260: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", - " @jit\n", - "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:260: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", - " @jit\n", - "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:38: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", - " @jit\n", - "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:164: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", - " @jit\n", - "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:198: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", - " @jit\n", - "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:260: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", - " @jit\n", - "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:38: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", - " @jit\n", - "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:38: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", - " @jit\n", - "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:38: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", - " @jit\n", - "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:164: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", - " @jit\n", - "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:198: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", - " @jit\n", - "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:260: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", - " @jit\n", - "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:164: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", - " @jit\n", - "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:198: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", - " @jit\n", - "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:260: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", - " @jit\n", - "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:164: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", - " @jit\n", - "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:198: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", - " @jit\n", - "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:260: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", - " @jit\n", - "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:38: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", - " @jit\n", - "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:164: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", - " @jit\n", - "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:198: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", - " @jit\n", - "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:260: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", - " @jit\n", - "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:38: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", - " @jit\n", - "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:164: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", - " @jit\n", - "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:198: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", - " @jit\n", - "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:260: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", - " @jit\n", - "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:38: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", - " @jit\n", - "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:38: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", - " @jit\n", - "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:164: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", - " @jit\n", - "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:198: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", - " @jit\n", - "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:260: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", - " @jit\n", - "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:164: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", - " @jit\n", - "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:198: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", - " @jit\n", - "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/libpysal/cg/alpha_shapes.py:260: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", - " @jit\n", - "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/numba/core/decorators.py:282: RuntimeWarning: nopython is set for njit and is ignored\n", - " warnings.warn('nopython is set for njit and is ignored', RuntimeWarning)\n", - "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/numba/core/decorators.py:282: RuntimeWarning: nopython is set for njit and is ignored\n", - " warnings.warn('nopython is set for njit and is ignored', RuntimeWarning)\n", - "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/numba/core/decorators.py:282: RuntimeWarning: nopython is set for njit and is ignored\n", - " warnings.warn('nopython is set for njit and is ignored', RuntimeWarning)\n", - "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/numba/core/decorators.py:282: RuntimeWarning: nopython is set for njit and is ignored\n", - " warnings.warn('nopython is set for njit and is ignored', RuntimeWarning)\n", - "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/numba/core/decorators.py:282: RuntimeWarning: nopython is set for njit and is ignored\n", - " warnings.warn('nopython is set for njit and is ignored', RuntimeWarning)\n", - "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/numba/core/decorators.py:282: RuntimeWarning: nopython is set for njit and is ignored\n", - " warnings.warn('nopython is set for njit and is ignored', RuntimeWarning)\n", - "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/numba/core/decorators.py:282: RuntimeWarning: nopython is set for njit and is ignored\n", - " warnings.warn('nopython is set for njit and is ignored', RuntimeWarning)\n", - "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/numba/core/decorators.py:282: RuntimeWarning: nopython is set for njit and is ignored\n", - " warnings.warn('nopython is set for njit and is ignored', RuntimeWarning)\n", - "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/numba/core/decorators.py:282: RuntimeWarning: nopython is set for njit and is ignored\n", - " warnings.warn('nopython is set for njit and is ignored', RuntimeWarning)\n", - "/Users/knaaptime/mambaforge/envs/esda/lib/python3.11/site-packages/numba/core/decorators.py:282: RuntimeWarning: nopython is set for njit and is ignored\n", - " warnings.warn('nopython is set for njit and is ignored', RuntimeWarning)\n" - ] - } - ], + "outputs": [], "source": [ - "corr = correlogram(sac, 'HH_INC', distances)" + "prof = correlogram(sac, 'HH_INC', distances, Moran)" ] }, { @@ -365,7 +298,7 @@ "id": "5187da59-aba0-465d-9fa7-e22794c8eb1a", "metadata": {}, "source": [ - "`corr` is a dataframe of autocorrelation statistics indexed by distance. It includes all attributes created by the esda autocorrelation statistic class (e.g. [Moran](https://pysal.org/esda/generated/esda.Moran.html#esda.Moran), [Geary](https://pysal.org/esda/generated/esda.Geary.html#esda.Geary), or [Geits-Ord G](https://pysal.org/esda/generated/esda.G.html#esda.G)). The row index for each statistic is the distance at which it was computed" + "`prof` is a dataframe of autocorrelation statistics indexed by distance. It includes all attributes created by the esda autocorrelation statistic class (e.g. [Moran](https://pysal.org/esda/generated/esda.Moran.html#esda.Moran), [Geary](https://pysal.org/esda/generated/esda.Geary.html#esda.Geary), or [Geits-Ord G](https://pysal.org/esda/generated/esda.G.html#esda.G)). The row index for each statistic is the distance at which it was computed" ] }, { @@ -374,11 +307,11 @@ "id": "af5bad37-874a-483b-a692-a3ae205416f8", "metadata": { "execution": { - "iopub.execute_input": "2023-08-03T23:17:17.641508Z", - "iopub.status.busy": "2023-08-03T23:17:17.641305Z", - "iopub.status.idle": "2023-08-03T23:17:17.681585Z", - "shell.execute_reply": "2023-08-03T23:17:17.681182Z", - "shell.execute_reply.started": "2023-08-03T23:17:17.641493Z" + "iopub.execute_input": "2023-08-05T22:38:11.719943Z", + "iopub.status.busy": "2023-08-05T22:38:11.719810Z", + "iopub.status.idle": "2023-08-05T22:38:11.764412Z", + "shell.execute_reply": "2023-08-05T22:38:11.764069Z", + "shell.execute_reply.started": "2023-08-05T22:38:11.719928Z" }, "tags": [] }, @@ -404,17 +337,21 @@ " \n", " \n", " \n", + " y\n", + " w\n", + " permutations\n", + " n\n", + " z\n", " z2ss\n", " EI\n", " VI_norm\n", " seI_norm\n", " VI_rand\n", - " seI_rand\n", - " I\n", - " z_norm\n", + " ...\n", " z_rand\n", " p_norm\n", " p_rand\n", + " sim\n", " p_sim\n", " EI_sim\n", " seI_sim\n", @@ -426,244 +363,173 @@ " \n", " \n", " 500\n", + " [52941, 51958, 32992, 54556, 50815, 60167, 490...\n", + " <libpysal.weights.distance.DistanceBand object...\n", + " 999\n", + " 403\n", + " [0.27506115837390277, 0.21948138443207246, -0....\n", " 1.260604e+11\n", " -0.002488\n", " 0.497534\n", " 0.705361\n", " 0.496239\n", - " 0.704442\n", - " 0.058227\n", - " 0.086076\n", + " ...\n", " 0.086188\n", " 9.314058e-01\n", " 9.313166e-01\n", - " 0.458\n", - " 0.027403\n", - " 0.727508\n", - " 0.529268\n", - " 0.042369\n", - " 4.831021e-01\n", + " [0.844396197392476, 2.460929829670082, -0.1016...\n", + " 0.431\n", + " -0.018034\n", + " 0.709650\n", + " 0.503603\n", + " 0.107463\n", + " 4.572107e-01\n", " \n", " \n", " 1000\n", + " [52941, 51958, 32992, 54556, 50815, 60167, 490...\n", + " <libpysal.weights.distance.DistanceBand object...\n", + " 999\n", + " 403\n", + " [0.27506115837390277, 0.21948138443207246, -0....\n", " 1.260604e+11\n", " -0.002488\n", " 0.014259\n", " 0.119409\n", " 0.014221\n", - " 0.119254\n", - " 0.492069\n", - " 4.141686\n", + " ...\n", " 4.147088\n", " 3.447621e-05\n", " 3.367309e-05\n", + " [0.016637719416899677, 0.14068907773528574, 0....\n", " 0.001\n", - " -0.008944\n", - " 0.118608\n", - " 0.014068\n", - " 4.224103\n", - " 1.199469e-05\n", + " -0.004937\n", + " 0.121159\n", + " 0.014680\n", + " 4.102093\n", + " 2.047149e-05\n", " \n", " \n", " 1500\n", + " [52941, 51958, 32992, 54556, 50815, 60167, 490...\n", + " <libpysal.weights.distance.DistanceBand object...\n", + " 999\n", + " 403\n", + " [0.27506115837390277, 0.21948138443207246, -0....\n", " 1.260604e+11\n", " -0.002488\n", " 0.004586\n", " 0.067719\n", " 0.004574\n", - " 0.067631\n", - " 0.454942\n", - " 6.754808\n", + " ...\n", " 6.763620\n", " 1.430242e-11\n", " 1.345857e-11\n", + " [-0.06613591918264287, -0.03976625497662466, 0...\n", " 0.001\n", - " -0.000999\n", - " 0.068681\n", - " 0.004717\n", - " 6.638500\n", - " 1.584454e-11\n", + " -0.005058\n", + " 0.063487\n", + " 0.004031\n", + " 7.245597\n", + " 2.152698e-13\n", " \n", " \n", " 2000\n", + " [52941, 51958, 32992, 54556, 50815, 60167, 490...\n", + " <libpysal.weights.distance.DistanceBand object...\n", + " 999\n", + " 403\n", + " [0.27506115837390277, 0.21948138443207246, -0....\n", " 1.260604e+11\n", " -0.002488\n", " 0.002164\n", " 0.046515\n", " 0.002158\n", - " 0.046454\n", - " 0.562591\n", - " 12.148448\n", + " ...\n", " 12.164298\n", " 5.846476e-34\n", " 4.815656e-34\n", + " [0.02987677956015972, 0.052610415562373586, -0...\n", " 0.001\n", - " -0.003165\n", - " 0.045885\n", - " 0.002105\n", - " 12.329971\n", - " 3.123456e-35\n", + " 0.000219\n", + " 0.046736\n", + " 0.002184\n", + " 12.033054\n", + " 1.190917e-33\n", " \n", " \n", " 2500\n", + " [52941, 51958, 32992, 54556, 50815, 60167, 490...\n", + " <libpysal.weights.distance.DistanceBand object...\n", + " 999\n", + " 403\n", + " [0.27506115837390277, 0.21948138443207246, -0....\n", " 1.260604e+11\n", " -0.002488\n", " 0.001481\n", " 0.038483\n", " 0.001477\n", - " 0.038433\n", - " 0.501091\n", - " 13.085698\n", + " ...\n", " 13.102771\n", " 3.974924e-39\n", " 3.174519e-39\n", + " [0.052314956676911994, 0.003768547001240843, -...\n", " 0.001\n", - " -0.000344\n", - " 0.038534\n", - " 0.001485\n", - " 13.012945\n", - " 5.164165e-39\n", - " \n", - " \n", - " 3000\n", - " 1.260604e+11\n", - " -0.002488\n", - " 0.001158\n", - " 0.034025\n", - " 0.001155\n", - " 0.033981\n", - " 0.510100\n", - " 15.064984\n", - " 15.084639\n", - " 2.752332e-51\n", - " 2.043904e-51\n", - " 0.001\n", - " -0.002044\n", - " 0.034211\n", - " 0.001170\n", - " 14.970316\n", - " 5.738734e-51\n", - " \n", - " \n", - " 3500\n", - " 1.260604e+11\n", - " -0.002488\n", - " 0.000900\n", - " 0.029994\n", - " 0.000897\n", - " 0.029955\n", - " 0.512046\n", - " 17.154529\n", - " 17.176892\n", - " 5.813950e-66\n", - " 3.955413e-66\n", - " 0.001\n", - " -0.001840\n", - " 0.028561\n", - " 0.000816\n", - " 17.992425\n", - " 1.116830e-72\n", - " \n", - " \n", - " 4000\n", - " 1.260604e+11\n", - " -0.002488\n", - " 0.000755\n", - " 0.027479\n", - " 0.000753\n", - " 0.027443\n", - " 0.465386\n", - " 17.026869\n", - " 17.049056\n", - " 5.190784e-65\n", - " 3.552242e-65\n", - " 0.001\n", - " -0.002860\n", - " 0.027790\n", - " 0.000772\n", - " 16.849263\n", - " 5.311531e-64\n", - " \n", - " \n", - " 4500\n", - " 1.260604e+11\n", - " -0.002488\n", - " 0.000738\n", - " 0.027175\n", - " 0.000737\n", - " 0.027140\n", - " 0.463040\n", - " 17.130555\n", - " 17.152901\n", - " 8.781368e-66\n", - " 5.979201e-66\n", - " 0.001\n", - " -0.001020\n", - " 0.027315\n", - " 0.000746\n", - " 16.989197\n", - " 4.936597e-65\n", - " \n", - " \n", - " 5000\n", - " 1.260604e+11\n", - " -0.002488\n", - " 0.000676\n", - " 0.026007\n", - " 0.000675\n", - " 0.025973\n", - " 0.428984\n", - " 16.590555\n", - " 16.612199\n", - " 8.156288e-62\n", - " 5.686988e-62\n", - " 0.001\n", - " -0.001263\n", - " 0.026385\n", - " 0.000696\n", - " 16.306799\n", - " 4.415019e-60\n", + " -0.001288\n", + " 0.037959\n", + " 0.001441\n", + " 13.234630\n", + " 2.768439e-40\n", " \n", " \n", "\n", + "

5 rows × 23 columns

\n", "" ], "text/plain": [ - " z2ss EI VI_norm seI_norm VI_rand seI_rand \\\n", - "500 1.260604e+11 -0.002488 0.497534 0.705361 0.496239 0.704442 \n", - "1000 1.260604e+11 -0.002488 0.014259 0.119409 0.014221 0.119254 \n", - "1500 1.260604e+11 -0.002488 0.004586 0.067719 0.004574 0.067631 \n", - "2000 1.260604e+11 -0.002488 0.002164 0.046515 0.002158 0.046454 \n", - "2500 1.260604e+11 -0.002488 0.001481 0.038483 0.001477 0.038433 \n", - "3000 1.260604e+11 -0.002488 0.001158 0.034025 0.001155 0.033981 \n", - "3500 1.260604e+11 -0.002488 0.000900 0.029994 0.000897 0.029955 \n", - "4000 1.260604e+11 -0.002488 0.000755 0.027479 0.000753 0.027443 \n", - "4500 1.260604e+11 -0.002488 0.000738 0.027175 0.000737 0.027140 \n", - "5000 1.260604e+11 -0.002488 0.000676 0.026007 0.000675 0.025973 \n", + " y \\\n", + "500 [52941, 51958, 32992, 54556, 50815, 60167, 490... \n", + "1000 [52941, 51958, 32992, 54556, 50815, 60167, 490... \n", + "1500 [52941, 51958, 32992, 54556, 50815, 60167, 490... \n", + "2000 [52941, 51958, 32992, 54556, 50815, 60167, 490... \n", + "2500 [52941, 51958, 32992, 54556, 50815, 60167, 490... \n", + "\n", + " w permutations n \\\n", + "500 " ] }, - "execution_count": 17, + "execution_count": 18, "metadata": {}, "output_type": "execute_result" }, From 94c6b568c126d69ae54ebdaf08aabfba36209bf5 Mon Sep 17 00:00:00 2001 From: eli knaap Date: Sat, 5 Aug 2023 15:42:17 -0700 Subject: [PATCH 15/17] knn test --- esda/tests/test_correlogram.py | 18 ++++++++++++++++-- 1 file changed, 16 insertions(+), 2 deletions(-) diff --git a/esda/tests/test_correlogram.py b/esda/tests/test_correlogram.py index c2533320..b72552f7 100644 --- a/esda/tests/test_correlogram.py +++ b/esda/tests/test_correlogram.py @@ -10,13 +10,27 @@ sac = sac.to_crs(sac.estimate_utm_crs()) # now in meters) distances = [i + 500 for i in range(0, 2000, 500)] +kdists = list(range(1, 6)) -def test_correlogram(): + +def test_distance_correlogram(): corr = correlogram(sac, "HH_INC", distances) test_data = np.array( - [0.05822723177762817, 0.49206877942505206, 0.45494217612839183, 0.5625914469490942] + [ + 0.05822723177762817, + 0.49206877942505206, + 0.45494217612839183, + 0.5625914469490942, + ] ) assert_array_almost_equal(corr.I, test_data) + + +def test_k_distance_correlogram(): + corr = correlogram(sac, "HH_INC", kdists, distance_type="knn") + + test_data = np.array([0.62411734, 0.59734846, 0.56958116, 0.54252517, 0.54093269]) + assert_array_almost_equal(corr.I, test_data) From 943b659a00ce63a469c35f09456d63a0aad49e72 Mon Sep 17 00:00:00 2001 From: eli knaap Date: Sat, 5 Aug 2023 15:43:04 -0700 Subject: [PATCH 16/17] formatting --- esda/correlogram.py | 1 + 1 file changed, 1 insertion(+) diff --git a/esda/correlogram.py b/esda/correlogram.py index 2d6a64f2..87d7af3b 100644 --- a/esda/correlogram.py +++ b/esda/correlogram.py @@ -6,6 +6,7 @@ from libpysal.cg.kdtree import KDTree from libpysal.weights import KNN, DistanceBand from libpysal.weights.util import get_points_array + from esda.moran import Moran From a73b94bcdc9f9554de99c8d8676bb02de7fbd7c5 Mon Sep 17 00:00:00 2001 From: eli knaap Date: Sat, 5 Aug 2023 15:46:20 -0700 Subject: [PATCH 17/17] local import --- esda/correlogram.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/esda/correlogram.py b/esda/correlogram.py index 87d7af3b..82ba84c8 100644 --- a/esda/correlogram.py +++ b/esda/correlogram.py @@ -7,7 +7,7 @@ from libpysal.weights import KNN, DistanceBand from libpysal.weights.util import get_points_array -from esda.moran import Moran +from .moran import Moran def _get_stat(inputs):