diff --git a/docs/examples/README.md b/docs/examples/README.md deleted file mode 100644 index 079a9ca..0000000 --- a/docs/examples/README.md +++ /dev/null @@ -1,3 +0,0 @@ -# Examples - -Examples of using **rustac**. diff --git a/docs/examples/example_read.py b/docs/examples/example_read.py deleted file mode 100644 index 238bb49..0000000 --- a/docs/examples/example_read.py +++ /dev/null @@ -1,27 +0,0 @@ -# type: ignore -""" -# Reading and plotting -""" - -# %% -# Reading is done via a top-level async function. -import rustac - -items = await rustac.read("https://github.com/stac-utils/rustac-py/raw/refs/heads/main/data/100-sentinel-2-items.parquet") -items - -# %% -# Let's take a look some of the attributes of the STAC items. -import pandas -from geopandas import GeoDataFrame - -data_frame = GeoDataFrame.from_features(items) -data_frame["datetime"] = pandas.to_datetime(data_frame["datetime"]) -data_frame[["geometry", "datetime", "s2:snow_ice_percentage"]] - -# %% -# How does the snow and ice percentage vary over the year? -from matplotlib.dates import DateFormatter - -axis = data_frame.plot(x="datetime", y="s2:snow_ice_percentage", kind="scatter") -axis.xaxis.set_major_formatter(DateFormatter("%b")) diff --git a/docs/examples/example_search.py b/docs/examples/example_search.py deleted file mode 100644 index 79a9205..0000000 --- a/docs/examples/example_search.py +++ /dev/null @@ -1,48 +0,0 @@ -# type: ignore -""" -# Searching -""" - -# %% -# Search a STAC API with `rustac.search`: -import contextily -import pandas -import rustac -from geopandas import GeoDataFrame - -items = await rustac.search( - "https://stac.eoapi.dev", - collections="MAXAR_Marshall_Fire_21_Update" -) -data_frame = GeoDataFrame.from_features(items) -data_frame["datetime"] = pandas.to_datetime(data_frame["datetime"]) -axis = data_frame.set_crs(epsg=4326).to_crs(epsg=3857).plot(alpha=0.5, edgecolor="k") -contextily.add_basemap(axis, source=contextily.providers.CartoDB.Positron) -axis.set_axis_off() - -# %% -# Search [stac-geoparquet](https://github.com/stac-utils/stac-geoparquet/blob/main/spec/stac-geoparquet-spec.md) with [DuckDB](https://duckdb.org/), no servers required! - -items = await rustac.search( - "../../data/100-sentinel-2-items.parquet", - datetime="2024-12-01T00:00:00Z/..", -) -data_frame = GeoDataFrame.from_features(items) -data_frame["datetime"] = pandas.to_datetime(data_frame["datetime"]) -data_frame[["datetime", "geometry"]] - -# %% -# If you know you're going to a [geopandas.GeoDataFrame][] (or something else that speaks -# arrow), you can use the `arrow` optional dependency for **rustac** (`pip -# install 'rustac[arrow]'`) and search directly to arrow, which can be more -# efficient than going through JSON dictionaries: - -from rustac import DuckdbClient - -client = DuckdbClient() -table = client.search_to_arrow( - "../../data/100-sentinel-2-items.parquet", - datetime="2024-12-01T00:00:00Z/..", -) -data_frame = GeoDataFrame.from_arrow(table) -data_frame[["datetime", "geometry"]] diff --git a/docs/examples/example_store.py b/docs/examples/example_store.py deleted file mode 100644 index e04574d..0000000 --- a/docs/examples/example_store.py +++ /dev/null @@ -1,45 +0,0 @@ -# type: ignore -""" -# Using object storage - -[obstore](https://github.com/developmentseed/obstore) is a new, powerful Python library for getting from and putting to object storage. -**rustac** can use anything that implements [obstore.store.ObjectStore][], and also provides its own zero-dependency version in **rustac.store**. -""" - -# %% -# ## Using **rustac.store**. - -import contextily -import pandas -import rustac -from rustac.store import HTTPStore -from geopandas import GeoDataFrame - -store = HTTPStore("https://raw.githubusercontent.com/stac-utils/rustac-py/refs/heads/main/data") -items = await rustac.read("100-sentinel-2-items.parquet", store=store) -print(len(items["features"])) - -data_frame = GeoDataFrame.from_features(items) -data_frame["datetime"] = pandas.to_datetime(data_frame["datetime"]) -axis = data_frame.set_crs(epsg=4326).to_crs(epsg=3857).plot(alpha=0.5, edgecolor="k") -contextily.add_basemap(axis, source=contextily.providers.CartoDB.Positron) -axis.set_axis_off() - - -# %% -# There's a [whole set][rustac.store.ObjectStore] of provided object storage backends. -# See for how you might configure authenticate with those backends. - -# %% -# ## Using **obstore.store.ObjectStore**. -# -# If you're doing work with **obstore** directly, you can re-use the same `ObjectStore`. - -from obstore.store import HTTPStore - -store = HTTPStore("https://raw.githubusercontent.com/stac-utils/rustac-py/refs/heads/main/data") -items = await rustac.read("100-sentinel-2-items.parquet", store=store) - -# Notice how there's a warning? -# That's because we have to copy the `ObjectStore` when we pass it in to **rustac**. -# This means it can be a bit more efficient to use `rustac.store` if you're only working with **rustac**. diff --git a/docs/notebooks/.gitignore b/docs/notebooks/.gitignore new file mode 100644 index 0000000..4bed5da --- /dev/null +++ b/docs/notebooks/.gitignore @@ -0,0 +1 @@ +*.parquet diff --git a/docs/notebooks/index.md b/docs/notebooks/index.md new file mode 100644 index 0000000..d8a07c5 --- /dev/null +++ b/docs/notebooks/index.md @@ -0,0 +1,3 @@ +# Notebooks + +Examples of using **rustac** in [Jupyter](https://jupyter.org/) notebooks. diff --git a/docs/notebooks/read.ipynb b/docs/notebooks/read.ipynb new file mode 100644 index 0000000..800516f --- /dev/null +++ b/docs/notebooks/read.ipynb @@ -0,0 +1,249 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "ad11edb6", + "metadata": {}, + "source": [ + "# Reading and plotting\n", + "\n", + "Read with our top-level `async` function." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "6e46c484", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "100" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import rustac\n", + "\n", + "items = await rustac.read(\n", + " \"https://github.com/stac-utils/rustac-py/raw/refs/heads/main/data/100-sentinel-2-items.parquet\"\n", + ")\n", + "len(items[\"features\"])" + ] + }, + { + "cell_type": "markdown", + "id": "f7b04d9b", + "metadata": {}, + "source": [ + "Let's take a look at some of the attributes of our STAC items." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "202499c6", + "metadata": {}, + "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", + "
geometrydatetimes2:snow_ice_percentage
0POLYGON ((-105.36543 39.65938, -105.34153 39.7...2024-12-03 17:46:29.024000+00:003.488287
1POLYGON ((-106.18317 40.64479, -104.88456 40.6...2024-12-01 17:57:21.024000+00:0047.351283
2POLYGON ((-105.35345 39.65943, -105.33389 39.7...2024-11-28 17:47:01.025000+00:0056.806326
3POLYGON ((-106.18317 40.64479, -104.88456 40.6...2024-11-26 17:56:09.024000+00:000.588352
4POLYGON ((-105.37083 39.65936, -105.34293 39.7...2024-11-23 17:45:59.024000+00:000.048005
............
95POLYGON ((-106.18317 40.64479, -104.88456 40.6...2024-04-05 17:49:01.024000+00:0048.347121
96POLYGON ((-105.35378 39.65943, -105.34822 39.6...2024-04-02 17:39:01.024000+00:004.604056
97POLYGON ((-106.18317 40.64479, -104.88456 40.6...2024-03-31 17:49:09.024000+00:0023.157783
98POLYGON ((-105.36759 39.65937, -105.33057 39.7...2024-03-28 17:38:59.024000+00:003.135089
99POLYGON ((-106.18317 40.64479, -104.88456 40.6...2024-03-26 17:49:51.024000+00:0032.571989
\n", + "

100 rows × 3 columns

\n", + "
" + ], + "text/plain": [ + " geometry \\\n", + "0 POLYGON ((-105.36543 39.65938, -105.34153 39.7... \n", + "1 POLYGON ((-106.18317 40.64479, -104.88456 40.6... \n", + "2 POLYGON ((-105.35345 39.65943, -105.33389 39.7... \n", + "3 POLYGON ((-106.18317 40.64479, -104.88456 40.6... \n", + "4 POLYGON ((-105.37083 39.65936, -105.34293 39.7... \n", + ".. ... \n", + "95 POLYGON ((-106.18317 40.64479, -104.88456 40.6... \n", + "96 POLYGON ((-105.35378 39.65943, -105.34822 39.6... \n", + "97 POLYGON ((-106.18317 40.64479, -104.88456 40.6... \n", + "98 POLYGON ((-105.36759 39.65937, -105.33057 39.7... \n", + "99 POLYGON ((-106.18317 40.64479, -104.88456 40.6... \n", + "\n", + " datetime s2:snow_ice_percentage \n", + "0 2024-12-03 17:46:29.024000+00:00 3.488287 \n", + "1 2024-12-01 17:57:21.024000+00:00 47.351283 \n", + "2 2024-11-28 17:47:01.025000+00:00 56.806326 \n", + "3 2024-11-26 17:56:09.024000+00:00 0.588352 \n", + "4 2024-11-23 17:45:59.024000+00:00 0.048005 \n", + ".. ... ... \n", + "95 2024-04-05 17:49:01.024000+00:00 48.347121 \n", + "96 2024-04-02 17:39:01.024000+00:00 4.604056 \n", + "97 2024-03-31 17:49:09.024000+00:00 23.157783 \n", + "98 2024-03-28 17:38:59.024000+00:00 3.135089 \n", + "99 2024-03-26 17:49:51.024000+00:00 32.571989 \n", + "\n", + "[100 rows x 3 columns]" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import pandas\n", + "from geopandas import GeoDataFrame\n", + "\n", + "data_frame = GeoDataFrame.from_features(items)\n", + "data_frame[\"datetime\"] = pandas.to_datetime(data_frame[\"datetime\"])\n", + "data_frame[[\"geometry\", \"datetime\", \"s2:snow_ice_percentage\"]]" + ] + }, + { + "cell_type": "markdown", + "id": "5554b3a5", + "metadata": {}, + "source": [ + "How does the snow and ice percentage vary over the year?" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "3e2fa4bf", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from matplotlib.dates import DateFormatter\n", + "\n", + "axis = data_frame.plot(x=\"datetime\", y=\"s2:snow_ice_percentage\", kind=\"scatter\")\n", + "axis.xaxis.set_major_formatter(DateFormatter(\"%b\"))" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "language": "python", + "name": "python3" + }, + "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.13.2" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/notebooks/search.ipynb b/docs/notebooks/search.ipynb new file mode 100644 index 0000000..db7c6b7 --- /dev/null +++ b/docs/notebooks/search.ipynb @@ -0,0 +1,228 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "718f7a84", + "metadata": {}, + "source": [ + "# Searching\n", + "\n", + "Search a STAC API with `rustac.search`." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "121546f5", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import contextily\n", + "import pandas\n", + "import rustac\n", + "from geopandas import GeoDataFrame\n", + "\n", + "items = await rustac.search(\n", + " \"https://stac.eoapi.dev\", collections=\"MAXAR_Marshall_Fire_21_Update\"\n", + ")\n", + "data_frame = GeoDataFrame.from_features(items)\n", + "data_frame[\"datetime\"] = pandas.to_datetime(data_frame[\"datetime\"])\n", + "axis = data_frame.set_crs(epsg=4326).to_crs(epsg=3857).plot(alpha=0.5, edgecolor=\"k\")\n", + "contextily.add_basemap(axis, source=contextily.providers.CartoDB.Positron)\n", + "axis.set_axis_off()" + ] + }, + { + "cell_type": "markdown", + "id": "e390f9bb", + "metadata": {}, + "source": [ + "Search [stac-geoparquet](https://github.com/stac-utils/stac-geoparquet/blob/main/spec/stac-geoparquet-spec.md) with [DuckDB](https://duckdb.org/), no servers required!" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "5194d9ae", + "metadata": {}, + "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", + "
datetimegeometry
02024-12-03 17:46:29.024000+00:00POLYGON ((-105.36543 39.65938, -105.34153 39.7...
12024-12-01 17:57:21.024000+00:00POLYGON ((-106.18317 40.64479, -104.88456 40.6...
\n", + "
" + ], + "text/plain": [ + " datetime \\\n", + "0 2024-12-03 17:46:29.024000+00:00 \n", + "1 2024-12-01 17:57:21.024000+00:00 \n", + "\n", + " geometry \n", + "0 POLYGON ((-105.36543 39.65938, -105.34153 39.7... \n", + "1 POLYGON ((-106.18317 40.64479, -104.88456 40.6... " + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "items = await rustac.search(\n", + " \"../../data/100-sentinel-2-items.parquet\",\n", + " datetime=\"2024-12-01T00:00:00Z/..\",\n", + ")\n", + "data_frame = GeoDataFrame.from_features(items)\n", + "data_frame[\"datetime\"] = pandas.to_datetime(data_frame[\"datetime\"])\n", + "data_frame[[\"datetime\", \"geometry\"]]" + ] + }, + { + "cell_type": "markdown", + "id": "1eed0085", + "metadata": {}, + "source": [ + "If you know you're going to a `geopandas.GeoDataFrame`(or something else that speaks arrow), you can use the `arrow` optional dependency for **rustac** (`pip install 'rustac[arrow]'`) and search directly to arrow, which can be more efficient than going through JSON dictionaries." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "1be22be7", + "metadata": {}, + "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", + "
datetimegeometry
02024-12-03 10:46:29.024000-07:00POLYGON ((-105.36543 39.65938, -105.34153 39.7...
12024-12-01 10:57:21.024000-07:00POLYGON ((-106.18317 40.64479, -104.88456 40.6...
\n", + "
" + ], + "text/plain": [ + " datetime \\\n", + "0 2024-12-03 10:46:29.024000-07:00 \n", + "1 2024-12-01 10:57:21.024000-07:00 \n", + "\n", + " geometry \n", + "0 POLYGON ((-105.36543 39.65938, -105.34153 39.7... \n", + "1 POLYGON ((-106.18317 40.64479, -104.88456 40.6... " + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from rustac import DuckdbClient\n", + "\n", + "client = DuckdbClient()\n", + "table = client.search_to_arrow(\n", + " \"../../data/100-sentinel-2-items.parquet\",\n", + " datetime=\"2024-12-01T00:00:00Z/..\",\n", + ")\n", + "data_frame = GeoDataFrame.from_arrow(table)\n", + "data_frame[[\"datetime\", \"geometry\"]]" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "language": "python", + "name": "python3" + }, + "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.13.2" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/notebooks/stac-geoparquet.ipynb b/docs/notebooks/stac-geoparquet.ipynb new file mode 100644 index 0000000..12564d8 --- /dev/null +++ b/docs/notebooks/stac-geoparquet.ipynb @@ -0,0 +1,363 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "9555163a", + "metadata": {}, + "source": [ + "# stac-geoparquet\n", + "\n", + "[stac-geoparquet](https://github.com/stac-utils/stac-geoparquet/blob/main/spec/stac-geoparquet-spec.md) is a data storage specification for STAC.\n", + "There are (at least) two Python libraries for reading and writing **stac-geoparquet**:\n", + "\n", + "- [stac-geoparquet](https://pypi.org/project/stac-geoparquet/) lives in the same repository as the specification\n", + "- Our **rustac** implementation does more of the hard work in Rust\n", + "\n", + "For more on the difference between the two implementations, see [our README](https://github.com/stac-utils/rustac-py?tab=readme-ov-file#stac-geoparquet).\n", + "\n", + "## Creating stac-geoparquet\n", + "\n", + "Create **stac-geoparquet** from an iterable of items." + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "id": "37025933", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "150.2 kB\n" + ] + } + ], + "source": [ + "from typing import Any\n", + "import os\n", + "import datetime\n", + "import humanize\n", + "import rustac\n", + "\n", + "\n", + "def create_item(\n", + " id: str, dt: datetime.datetime, extra_properties: dict[str, Any] | None = None\n", + ") -> dict[str, Any]:\n", + " properties = {\n", + " \"datetime\": dt.isoformat(),\n", + " }\n", + " if extra_properties:\n", + " properties.update(extra_properties)\n", + " return {\n", + " \"type\": \"Feature\",\n", + " \"stac_version\": \"1.1.0\",\n", + " \"id\": id,\n", + " \"geometry\": {\"type\": \"Point\", \"coordinates\": [-105.1019, 40.1672]},\n", + " \"bbox\": [-105.1019, 40.1672, -105.1019, 40.1672],\n", + " \"properties\": properties,\n", + " # Assets can't be empty at the moment: https://github.com/stac-utils/rustac/issues/766\n", + " \"assets\": {\n", + " \"data\": {\n", + " \"href\": \"https://storage.googleapis.com/open-cogs/stac-examples/20201211_223832_CS2.jpg\"\n", + " }\n", + " },\n", + " \"links\": [],\n", + " }\n", + "\n", + "\n", + "items = [\n", + " create_item(\n", + " f\"item-{i}\",\n", + " datetime.datetime(2024, 1, 1, tzinfo=datetime.timezone.utc)\n", + " + datetime.timedelta(hours=i),\n", + " )\n", + " for i in range(10000)\n", + "]\n", + "await rustac.write(\"items.parquet\", items)\n", + "print(humanize.naturalsize(os.path.getsize(\"items.parquet\")))" + ] + }, + { + "cell_type": "markdown", + "id": "419d11b3", + "metadata": {}, + "source": [ + "Reading is just as simple." + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "id": "164ecaee", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{\n", + " \"type\": \"Feature\",\n", + " \"stac_version\": \"1.1.0\",\n", + " \"id\": \"item-0\",\n", + " \"geometry\": {\n", + " \"type\": \"Point\",\n", + " \"coordinates\": [\n", + " -105.1019,\n", + " 40.1672\n", + " ]\n", + " },\n", + " \"bbox\": [\n", + " -105.1019,\n", + " 40.1672,\n", + " -105.1019,\n", + " 40.1672\n", + " ],\n", + " \"properties\": {\n", + " \"datetime\": \"2024-01-01T00:00:00Z\"\n", + " },\n", + " \"links\": [],\n", + " \"assets\": {\n", + " \"data\": {\n", + " \"href\": \"https://storage.googleapis.com/open-cogs/stac-examples/20201211_223832_CS2.jpg\"\n", + " }\n", + " }\n", + "}\n" + ] + } + ], + "source": [ + "import json\n", + "\n", + "item_collection = await rustac.read(\"items.parquet\")\n", + "print(json.dumps(item_collection[\"features\"][0], indent=2))" + ] + }, + { + "cell_type": "markdown", + "id": "2223d4ce", + "metadata": {}, + "source": [ + "## Appending\n", + "\n", + "One of STAC's key features is its flexibility.\n", + "The core specification is minimal, so data producers are encouraged to use [extensions](https://stac-extensions.github.io/) and custom attributes to add expressiveness to their STAC items. \n", + "This flexibility is an awkward fit with [parquet](https://parquet.apache.org/) (and [arrow](https://arrow.apache.org/)), which require fixed schemas.\n", + "Many parquet implementations simply punt on appends ([e.g.](https://github.com/apache/arrow/issues/42711#issuecomment-2184210686)).\n", + "\n", + "To add new data to an existing **stac-geoparquet** data store, you can:\n", + "\n", + "- Read, update, and write\n", + "- Create a new file and search over both, e.g. with [DuckDB](https://duckdb.org/)\n", + "\n", + "Let's take a look at both options.\n", + "\n", + "### Read, update, and write\n", + "\n", + "If you can fit all of your items into memory, you can read all of your items in, add the new items, then write them back out.\n", + "**rustac** will take care of updating the output schema to match the new items.\n", + "It's not very elegant, but it works." + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "id": "870cbebb", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "That took 0.37 seconds to read\n", + "That took 1.20 seconds to write\n", + "9999 items have a 'foo' property\n" + ] + } + ], + "source": [ + "import time\n", + "\n", + "new_items = [\n", + " create_item(\n", + " f\"new-item-{i}\",\n", + " datetime.datetime(1986, 6, 14, tzinfo=datetime.timezone.utc)\n", + " + datetime.timedelta(hours=i),\n", + " {\"foo\": \"bar\"}, # add a new attribute that wasn't in the original schema\n", + " )\n", + " for i in range(9999)\n", + "]\n", + "\n", + "start = time.time()\n", + "old_items = await rustac.read(\"items.parquet\")\n", + "print(f\"That took {time.time() - start:0.2f} seconds to read\")\n", + "\n", + "start = time.time()\n", + "await rustac.write(\"more-items.parquet\", old_items[\"features\"] + new_items)\n", + "print(f\"That took {time.time() - start:0.2f} seconds to write\")\n", + "\n", + "all_the_items = await rustac.read(\"more-items.parquet\")\n", + "print(\n", + " len(\n", + " list(item for item in all_the_items[\"features\"] if \"foo\" in item[\"properties\"])\n", + " ),\n", + " \"items have a 'foo' property\",\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "5afaf71c", + "metadata": {}, + "source": [ + "### Create a new file\n", + "\n", + "Some tools, like **DuckDB**, can query across multiple parquet files.\n", + "This lets you write your new items in a second file next to your old one, then query across both." + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "id": "0fabaa18", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "┌───────────┬──────────────────────────┬───────────────────────────┐\n", + "│ id │ datetime │ geometry │\n", + "│ varchar │ timestamp with time zone │ geometry │\n", + "├───────────┼──────────────────────────┼───────────────────────────┤\n", + "│ item-0 │ 2023-12-31 17:00:00-07 │ POINT (-105.1019 40.1672) │\n", + "│ item-1 │ 2023-12-31 18:00:00-07 │ POINT (-105.1019 40.1672) │\n", + "│ item-2 │ 2023-12-31 19:00:00-07 │ POINT (-105.1019 40.1672) │\n", + "│ item-3 │ 2023-12-31 20:00:00-07 │ POINT (-105.1019 40.1672) │\n", + "│ item-4 │ 2023-12-31 21:00:00-07 │ POINT (-105.1019 40.1672) │\n", + "│ item-5 │ 2023-12-31 22:00:00-07 │ POINT (-105.1019 40.1672) │\n", + "│ item-6 │ 2023-12-31 23:00:00-07 │ POINT (-105.1019 40.1672) │\n", + "│ item-7 │ 2024-01-01 00:00:00-07 │ POINT (-105.1019 40.1672) │\n", + "│ item-8 │ 2024-01-01 01:00:00-07 │ POINT (-105.1019 40.1672) │\n", + "│ item-9 │ 2024-01-01 02:00:00-07 │ POINT (-105.1019 40.1672) │\n", + "│ · │ · │ · │\n", + "│ · │ · │ · │\n", + "│ · │ · │ · │\n", + "│ item-9990 │ 2025-02-19 23:00:00-07 │ POINT (-105.1019 40.1672) │\n", + "│ item-9991 │ 2025-02-20 00:00:00-07 │ POINT (-105.1019 40.1672) │\n", + "│ item-9992 │ 2025-02-20 01:00:00-07 │ POINT (-105.1019 40.1672) │\n", + "│ item-9993 │ 2025-02-20 02:00:00-07 │ POINT (-105.1019 40.1672) │\n", + "│ item-9994 │ 2025-02-20 03:00:00-07 │ POINT (-105.1019 40.1672) │\n", + "│ item-9995 │ 2025-02-20 04:00:00-07 │ POINT (-105.1019 40.1672) │\n", + "│ item-9996 │ 2025-02-20 05:00:00-07 │ POINT (-105.1019 40.1672) │\n", + "│ item-9997 │ 2025-02-20 06:00:00-07 │ POINT (-105.1019 40.1672) │\n", + "│ item-9998 │ 2025-02-20 07:00:00-07 │ POINT (-105.1019 40.1672) │\n", + "│ item-9999 │ 2025-02-20 08:00:00-07 │ POINT (-105.1019 40.1672) │\n", + "├───────────┴──────────────────────────┴───────────────────────────┤\n", + "│ ? rows (>9999 rows, 20 shown) 3 columns │\n", + "└──────────────────────────────────────────────────────────────────┘" + ] + }, + "execution_count": 71, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import duckdb\n", + "\n", + "await rustac.write(\"new-items.parquet\", new_items)\n", + "duckdb.sql(\n", + " \"select id, datetime, geometry from read_parquet(['items.parquet', 'new-items.parquet'])\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "4dcb22d3", + "metadata": {}, + "source": [ + "Even though our old items don't have a `foo` property, we can still query on it with DuckDB by setting `union_by_name = true`." + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "id": "c01c0ef5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "┌──────────────┐\n", + "│ count_star() │\n", + "│ int64 │\n", + "├──────────────┤\n", + "│ 9999 │\n", + "└──────────────┘" + ] + }, + "execution_count": 72, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "duckdb.sql(\n", + " \"select count(*) from read_parquet(['items.parquet', 'new-items.parquet'], union_by_name = true) where foo = 'bar'\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "75c6fd88", + "metadata": {}, + "source": [ + "If we don't set `union_by_name = true`, we get an error because of the schema mismatch." + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "id": "18bc3a4b", + "metadata": {}, + "outputs": [ + { + "ename": "BinderException", + "evalue": "Binder Error: Referenced column \"foo\" not found in FROM clause!\nCandidate bindings: \"bbox\"", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mBinderException\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[73], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mduckdb\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msql\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mselect id, foo from read_parquet([\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mitems.parquet\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43m, \u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mnew-items.parquet\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43m])\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\n", + "\u001b[0;31mBinderException\u001b[0m: Binder Error: Referenced column \"foo\" not found in FROM clause!\nCandidate bindings: \"bbox\"" + ] + } + ], + "source": [ + "duckdb.sql(\"select id, foo from read_parquet(['items.parquet', 'new-items.parquet'])\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "language": "python", + "name": "python3" + }, + "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.13.2" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/notebooks/store.ipynb b/docs/notebooks/store.ipynb new file mode 100644 index 0000000..6f02c1e --- /dev/null +++ b/docs/notebooks/store.ipynb @@ -0,0 +1,127 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "6dd13b76", + "metadata": {}, + "source": [ + "# Using object storage\n", + "\n", + "[obstore](https://github.com/developmentseed/obstore) is a new, powerful Python library for getting from and putting to object storage.\n", + "**rustac** can use anything that implements `obstore.store.ObjectStore`, and also provides its own zero-dependency version in **rustac.store**." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "40c6fc15", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "100\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import contextily\n", + "import pandas\n", + "import rustac\n", + "from rustac.store import HTTPStore\n", + "from geopandas import GeoDataFrame\n", + "\n", + "store = HTTPStore(\n", + " \"https://raw.githubusercontent.com/stac-utils/rustac-py/refs/heads/main/data\"\n", + ")\n", + "items = await rustac.read(\"100-sentinel-2-items.parquet\", store=store)\n", + "print(len(items[\"features\"]))\n", + "\n", + "data_frame = GeoDataFrame.from_features(items)\n", + "data_frame[\"datetime\"] = pandas.to_datetime(data_frame[\"datetime\"])\n", + "axis = data_frame.set_crs(epsg=4326).to_crs(epsg=3857).plot(alpha=0.5, edgecolor=\"k\")\n", + "contextily.add_basemap(axis, source=contextily.providers.CartoDB.Positron)\n", + "axis.set_axis_off()" + ] + }, + { + "cell_type": "markdown", + "id": "a0d4445d", + "metadata": {}, + "source": [ + "There's a whole set of provided object storage backends.\n", + "See for how you might configure authenticate with those backends.\n", + "\n", + "## Using **obstore.store.ObjectStore**.\n", + "\n", + "If you're doing work with **obstore** directly, you can re-use the same `ObjectStore`." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "d24a9492", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/yp/d6xvrkd943dgvqg5s9cpymc40000gn/T/ipykernel_65491/1946367820.py:4: RuntimeWarning: Successfully reconstructed a store defined in another Python module. Connection pooling will not be shared across store instances.\n", + " items = await rustac.read(\"100-sentinel-2-items.parquet\", store=store)\n" + ] + } + ], + "source": [ + "from obstore.store import HTTPStore\n", + "\n", + "store = HTTPStore(\n", + " \"https://raw.githubusercontent.com/stac-utils/rustac-py/refs/heads/main/data\"\n", + ")\n", + "items = await rustac.read(\"100-sentinel-2-items.parquet\", store=store)" + ] + }, + { + "cell_type": "markdown", + "id": "f012b2ed", + "metadata": {}, + "source": [ + "Notice how there's a warning?\n", + "That's because we have to copy the `ObjectStore` when we pass it in to **rustac**.\n", + "This means it can be a bit more efficient to use `rustac.store` if you're only working with **rustac**." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "language": "python", + "name": "python3" + }, + "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.13.2" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/stylesheets/extra.css b/docs/stylesheets/extra.css index ee25974..e89ea96 100644 --- a/docs/stylesheets/extra.css +++ b/docs/stylesheets/extra.css @@ -12,4 +12,8 @@ --md-primary-fg-color--dark: rgb(26, 78, 99); --md-accent-fg-color: rgb(78, 180, 174); --md-accent-fg-color--transparent: rgba(78, 180, 174, 0.5); -} \ No newline at end of file +} + +.jp-InputPrompt, .jp-OutputPrompt { + display: none !important; +} diff --git a/mkdocs.yml b/mkdocs.yml index cf54840..007b52f 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -11,13 +11,19 @@ theme: features: - navigation.indexes - navigation.footer + - toc.integrate palette: scheme: stac primary: custom nav: - Home: index.md - - Examples: generated/gallery + - Notebooks: + - notebooks/index.md + - notebooks/read.ipynb + - notebooks/store.ipynb + - notebooks/stac-geoparquet.ipynb + - notebooks/search.ipynb - API: - api/index.md - arrow: api/arrow.md @@ -41,11 +47,6 @@ nav: - CONTRIBUTING.md plugins: - - gallery: - examples_dirs: docs/examples - gallery_dirs: docs/generated/gallery - filename_pattern: /example_ - - markdown-exec - mike - mkdocstrings: enable_inventory: true @@ -67,6 +68,7 @@ plugins: - https://kylebarron.dev/arro3/latest/objects.inv - https://geopandas.org/en/stable/objects.inv - https://developmentseed.org/obstore/latest/objects.inv + - mkdocs-jupyter - search - social: cards_layout_options: diff --git a/pyproject.toml b/pyproject.toml index aa06707..0847ec4 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -34,7 +34,7 @@ Documentation = "https://stac-utils.github.io/rustac-py" Issues = "https://github.com/stac-utils/rustac-py/issues" [tool.mypy] -files = "tests/**/*.py,docs/examples/**/*.py" +files = "tests/**/*.py" [[tool.mypy.overrides]] module = ["pyarrow.*", "geopandas.*"] @@ -70,13 +70,13 @@ dev = [ docs = [ "arro3-core>=0.4.5", "contextily>=1.6.2", + "duckdb>=1.3.0", "griffe>=1.6.0", "humanize>=4.12.1", "ipykernel>=6.29.5", "jinja2>=3.1.4", - "markdown-exec>=1.10.1", "mike>=2.1.3", - "mkdocs-gallery>=0.10.4", + "mkdocs-jupyter>=0.25.1", "mkdocs-material[imaging]>=9.5.45", "mkdocstrings[python]>=0.27.0", "obstore>=0.6.0", diff --git a/python/rustac/rustac.pyi b/python/rustac/rustac.pyi index 8dde207..fe4e626 100644 --- a/python/rustac/rustac.pyi +++ b/python/rustac/rustac.pyi @@ -1,6 +1,6 @@ """The power of Rust for the Python STAC ecosystem.""" -from collections.abc import AsyncIterator +from collections.abc import AsyncIterator, Sequence from pathlib import Path from typing import Any, Literal @@ -422,7 +422,7 @@ def walk( async def write( href: str, - value: dict[str, Any] | list[dict[str, Any]], + value: dict[str, Any] | Sequence[dict[str, Any]], *, format: str | None = None, store: ObjectStore | None = None, diff --git a/uv.lock b/uv.lock index 0303ff6..9af3deb 100644 --- a/uv.lock +++ b/uv.lock @@ -97,6 +97,36 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/b7/b8/3fe70c75fe32afc4bb507f75563d39bc5642255d1d94f1f23604725780bf/babel-2.17.0-py3-none-any.whl", hash = "sha256:4d0b53093fdfb4b21c92b5213dba5a1b23885afa8383709427046b21c366e5f2", size = 10182537, upload-time = "2025-02-01T15:17:37.39Z" }, ] +[[package]] +name = "beautifulsoup4" +version = "4.13.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "soupsieve" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/d8/e4/0c4c39e18fd76d6a628d4dd8da40543d136ce2d1752bd6eeeab0791f4d6b/beautifulsoup4-4.13.4.tar.gz", hash = "sha256:dbb3c4e1ceae6aefebdaf2423247260cd062430a410e38c66f2baa50a8437195", size = 621067, upload-time = "2025-04-15T17:05:13.836Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/50/cd/30110dc0ffcf3b131156077b90e9f60ed75711223f306da4db08eff8403b/beautifulsoup4-4.13.4-py3-none-any.whl", hash = "sha256:9bbbb14bfde9d79f38b8cd5f8c7c85f4b8f2523190ebed90e950a8dea4cb1c4b", size = 187285, upload-time = "2025-04-15T17:05:12.221Z" }, +] + +[[package]] +name = "bleach" +version = "6.2.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "webencodings" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/76/9a/0e33f5054c54d349ea62c277191c020c2d6ef1d65ab2cb1993f91ec846d1/bleach-6.2.0.tar.gz", hash = "sha256:123e894118b8a599fd80d3ec1a6d4cc7ce4e5882b1317a7e1ba69b56e95f991f", size = 203083, upload-time = "2024-10-29T18:30:40.477Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fc/55/96142937f66150805c25c4d0f31ee4132fd33497753400734f9dfdcbdc66/bleach-6.2.0-py3-none-any.whl", hash = "sha256:117d9c6097a7c3d22fd578fcd8d35ff1e125df6736f554da4e432fdd63f31e5e", size = 163406, upload-time = "2024-10-29T18:30:38.186Z" }, +] + +[package.optional-dependencies] +css = [ + { name = "tinycss2" }, +] + [[package]] name = "cairocffi" version = "1.7.1" @@ -455,6 +485,35 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/a1/74/be1d4d465b22526ecd2d2dc6b6cfa257285ac091a90ac86b99fcd043a7a5/deltalake-0.24.0-cp39-abi3-win_amd64.whl", hash = "sha256:1c423bdab46fa3c01a9364ba5533167d3b58099fd4a0599e6d0c363e9ba64799", size = 36586590, upload-time = "2025-01-15T04:35:12.868Z" }, ] +[[package]] +name = "duckdb" +version = "1.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/3e/82/680b108da1870e48d98464ddcf03820f983421b5bbd8dd8beff98d583db7/duckdb-1.3.0.tar.gz", hash = "sha256:09aaa4b1dca24f4d1f231e7ae66b6413e317b7e04e2753541d42df6c8113fac7", size = 11617648, upload-time = "2025-05-21T16:06:49.93Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/48/a5/0a7dd8f256aa75e254717732905fb96858a9e54e881a5da0966b5760393a/duckdb-1.3.0-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:60a58b85929754abb21db1e739d2f53eaef63e6015e62ba58eae3425030e7935", size = 15497894, upload-time = "2025-05-21T16:05:29.985Z" }, + { url = "https://files.pythonhosted.org/packages/10/b9/5a2275f765f3ca6375797066bc3870bdc8dc3f4c91b84f4230709e012c50/duckdb-1.3.0-cp311-cp311-macosx_12_0_universal2.whl", hash = "sha256:1d46b5a20f078b1b2284243e02a1fde7e12cbb8d205fce62e4700bcfe6a09881", size = 32453581, upload-time = "2025-05-21T16:05:33.055Z" }, + { url = "https://files.pythonhosted.org/packages/a4/f6/20da96bc7e3886cf424461a45de3f76247b7731a5f7552615bd31e73f1ac/duckdb-1.3.0-cp311-cp311-macosx_12_0_x86_64.whl", hash = "sha256:0044e5ffb2d46308099640a92f99980a44e12bb68642aa9e6b08acbf300d64a1", size = 17066778, upload-time = "2025-05-21T16:05:36.561Z" }, + { url = "https://files.pythonhosted.org/packages/43/21/ffe5aeb9d32a49d2de6d368b3fe3e53c2246eccec916375d65c45dc58339/duckdb-1.3.0-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5cb813de2ca2f5e7c77392a67bdcaa174bfd69ebbfdfc983024af270c77a0447", size = 19122797, upload-time = "2025-05-21T16:05:39.16Z" }, + { url = "https://files.pythonhosted.org/packages/60/0c/111dc4a3dcdd7007ca610e41a85634fbfa258ab960a6445e02872b67ab02/duckdb-1.3.0-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7a0c993eb6df2b30b189ad747f3aea1b0b87b78ab7f80c6e7c57117b6e8dbfb0", size = 21069430, upload-time = "2025-05-21T16:05:42.589Z" }, + { url = "https://files.pythonhosted.org/packages/43/00/71c174b65f167af4d77aafa6a01445f08238e84dd679638836472f1141af/duckdb-1.3.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:6728e209570d36ece66dd7249e5d6055326321137cd807f26300733283930cd4", size = 22720601, upload-time = "2025-05-21T16:05:45.601Z" }, + { url = "https://files.pythonhosted.org/packages/2c/cb/c84a617f79bedb2220ea0b0a9826b2fb1a534568c5742789ca2c0812d465/duckdb-1.3.0-cp311-cp311-win_amd64.whl", hash = "sha256:7e652b7c8dbdb91a94fd7d543d3e115d24a25aa0791a373a852e20cb7bb21154", size = 11421756, upload-time = "2025-05-21T16:05:48.871Z" }, + { url = "https://files.pythonhosted.org/packages/e4/b8/0931871f55a10aacd1af024c8d1e5de68337032379438aba05e26e9a1132/duckdb-1.3.0-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:f24038fe9b83dcbaeafb1ed76ec3b3f38943c1c8d27ab464ad384db8a6658b61", size = 15516284, upload-time = "2025-05-21T16:05:51.596Z" }, + { url = "https://files.pythonhosted.org/packages/af/d5/a08f76900391ff248b18fc1d5742db4b7bcf910c4be00314ce7b3069223f/duckdb-1.3.0-cp312-cp312-macosx_12_0_universal2.whl", hash = "sha256:956c85842841bef68f4a5388c6b225b933151a7c06d568390fc895fc44607913", size = 32490915, upload-time = "2025-05-21T16:05:54.731Z" }, + { url = "https://files.pythonhosted.org/packages/05/f1/9dfa45484422bd6c598e76fb2d005de48373aea66b037471b4568c1e938a/duckdb-1.3.0-cp312-cp312-macosx_12_0_x86_64.whl", hash = "sha256:efe883d822ed56fcfbb6a7b397c13f6a0d2eaeb3bc4ef4510f84fadb3dfe416d", size = 17086690, upload-time = "2025-05-21T16:05:57.51Z" }, + { url = "https://files.pythonhosted.org/packages/8e/4e/093944cbca2e4b3fe5da99c46df9f4ae293c6768f15f14a959aaa2064a50/duckdb-1.3.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3872a3a1b80ffba5264ea236a3754d0c41d3c7b01bdf8cdcb1c180fc1b8dc8e2", size = 19140518, upload-time = "2025-05-21T16:06:00.521Z" }, + { url = "https://files.pythonhosted.org/packages/b0/9e/b1a7c086db03f3cc85c513e70034bd515e68e25013875e5f0b40c4bf5d0a/duckdb-1.3.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:30bf45ad78a5a997f378863e036e917b481d18d685e5c977cd0a3faf2e31fbaf", size = 21103893, upload-time = "2025-05-21T16:06:03.643Z" }, + { url = "https://files.pythonhosted.org/packages/5e/b4/5baef852efec9480dcfb44bed5adc56f6fcee09919037cf54fbbe87ac427/duckdb-1.3.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:85cbd8e1d65df8a0780023baf5045d3033fabd154799bc9ea6d9ab5728f41eb3", size = 22753505, upload-time = "2025-05-21T16:06:06.773Z" }, + { url = "https://files.pythonhosted.org/packages/36/4f/f7ab120ecd827fdff59f14e1de9771335aa7656a29c3259fa7949de1f276/duckdb-1.3.0-cp312-cp312-win_amd64.whl", hash = "sha256:8754c40dac0f26d9fb0363bbb5df02f7a61ce6a6728d5efc02c3bc925d7c89c3", size = 11424449, upload-time = "2025-05-21T16:06:09.43Z" }, + { url = "https://files.pythonhosted.org/packages/32/d5/d2666a682cda7152d0f391067e0307eec3e913b3462d2b5b944a3aab4d1d/duckdb-1.3.0-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:176b9818d940c52ac7f31c64a98cf172d7c19d2a006017c9c4e9c06c246e36bf", size = 15516004, upload-time = "2025-05-21T16:06:11.983Z" }, + { url = "https://files.pythonhosted.org/packages/91/60/feb19a432c0b327b3d03171042acbafa688edb9a02f3034f7ae963d0f62d/duckdb-1.3.0-cp313-cp313-macosx_12_0_universal2.whl", hash = "sha256:03981f7e8793f07a4a9a2ba387640e71d0a99ebcaf8693ab09f96d59e628b713", size = 32490147, upload-time = "2025-05-21T16:06:14.751Z" }, + { url = "https://files.pythonhosted.org/packages/07/f8/393beb10a24115347c8a4b75d59e6e1d49f7391722717a614bb71430673a/duckdb-1.3.0-cp313-cp313-macosx_12_0_x86_64.whl", hash = "sha256:a177d55a38a62fdf79b59a0eaa32531a1dbb443265f6d67f64992cc1e82b755c", size = 17086082, upload-time = "2025-05-21T16:06:17.511Z" }, + { url = "https://files.pythonhosted.org/packages/71/45/da77973a7da7747385e16aa88c65a7b0e634585b5f7f92a6bb423838077c/duckdb-1.3.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b1c30e3749823147d5578bc3f01f35d1a0433a1c768908d946056ec8d6e1757e", size = 19141643, upload-time = "2025-05-21T16:06:20.862Z" }, + { url = "https://files.pythonhosted.org/packages/db/51/adc86c800e7ecfe828e94cccc28ac727b54a886124da08e3808cf77bf1b9/duckdb-1.3.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5855f3a564baf22eeeab70c120b51f5a11914f1f1634f03382daeb6b1dea4c62", size = 21102444, upload-time = "2025-05-21T16:06:23.381Z" }, + { url = "https://files.pythonhosted.org/packages/71/9d/ac3a6ddcaaf9bbd5584bb471794f017498326d11f754ee28b3c0a5c7aee8/duckdb-1.3.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9b1fac15a48056f7c2739cf8800873063ba2f691e91a9b2fc167658a401ca76a", size = 22752802, upload-time = "2025-05-21T16:06:26.031Z" }, + { url = "https://files.pythonhosted.org/packages/ab/e9/f83285b0cb3729f24321a038f272490dfb76ca531b7cef832037b7bd077c/duckdb-1.3.0-cp313-cp313-win_amd64.whl", hash = "sha256:fbdfc1c0b83b90f780ae74038187ee696bb56ab727a289752372d7ec42dda65b", size = 11424430, upload-time = "2025-05-21T16:06:28.878Z" }, +] + [[package]] name = "executing" version = "2.2.0" @@ -464,6 +523,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/7b/8f/c4d9bafc34ad7ad5d8dc16dd1347ee0e507a52c3adb6bfa8887e1c6a26ba/executing-2.2.0-py2.py3-none-any.whl", hash = "sha256:11387150cad388d62750327a53d3339fad4888b39a6fe233c3afbb54ecffd3aa", size = 26702, upload-time = "2025-01-22T15:41:25.929Z" }, ] +[[package]] +name = "fastjsonschema" +version = "2.21.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/8b/50/4b769ce1ac4071a1ef6d86b1a3fb56cdc3a37615e8c5519e1af96cdac366/fastjsonschema-2.21.1.tar.gz", hash = "sha256:794d4f0a58f848961ba16af7b9c85a3e88cd360df008c59aac6fc5ae9323b5d4", size = 373939, upload-time = "2024-12-02T10:55:15.133Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/90/2b/0817a2b257fe88725c25589d89aec060581aabf668707a8d03b2e9e0cb2a/fastjsonschema-2.21.1-py3-none-any.whl", hash = "sha256:c9e5b7e908310918cf494a434eeb31384dd84a98b57a30bcb1f535015b554667", size = 23924, upload-time = "2024-12-02T10:55:07.599Z" }, +] + [[package]] name = "filelock" version = "3.18.0" @@ -751,6 +819,31 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/c9/fb/108ecd1fe961941959ad0ee4e12ee7b8b1477247f30b1fdfd83ceaf017f0/jupyter_core-5.7.2-py3-none-any.whl", hash = "sha256:4f7315d2f6b4bcf2e3e7cb6e46772eba760ae459cd1f59d29eb57b0a01bd7409", size = 28965, upload-time = "2024-03-12T12:37:32.36Z" }, ] +[[package]] +name = "jupyterlab-pygments" +version = "0.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/90/51/9187be60d989df97f5f0aba133fa54e7300f17616e065d1ada7d7646b6d6/jupyterlab_pygments-0.3.0.tar.gz", hash = "sha256:721aca4d9029252b11cfa9d185e5b5af4d54772bb8072f9b7036f4170054d35d", size = 512900, upload-time = "2023-11-23T09:26:37.44Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b1/dd/ead9d8ea85bf202d90cc513b533f9c363121c7792674f78e0d8a854b63b4/jupyterlab_pygments-0.3.0-py3-none-any.whl", hash = "sha256:841a89020971da1d8693f1a99997aefc5dc424bb1b251fd6322462a1b8842780", size = 15884, upload-time = "2023-11-23T09:26:34.325Z" }, +] + +[[package]] +name = "jupytext" +version = "1.17.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "markdown-it-py" }, + { name = "mdit-py-plugins" }, + { name = "nbformat" }, + { name = "packaging" }, + { name = "pyyaml" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/6e/d9/b7acd3bed66c194cec1915c5bbec30994dbb50693ec209e5b115c28ddf63/jupytext-1.17.1.tar.gz", hash = "sha256:c02fda8af76ffd6e064a04cf2d3cc8aae242b2f0e38c42b4cd80baf89c3325d3", size = 3746897, upload-time = "2025-04-26T21:16:11.453Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/12/b7/e7e3d34c8095c19228874b1babedfb5d901374e40d51ae66f2a90203be53/jupytext-1.17.1-py3-none-any.whl", hash = "sha256:99145b1e1fa96520c21ba157de7d354ffa4904724dcebdcd70b8413688a312de", size = 164286, upload-time = "2025-04-26T21:16:09.636Z" }, +] + [[package]] name = "kiwisolver" version = "1.4.8" @@ -827,15 +920,15 @@ wheels = [ ] [[package]] -name = "markdown-exec" -version = "1.10.1" +name = "markdown-it-py" +version = "3.0.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "pymdown-extensions" }, + { name = "mdurl" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/b2/8c/6997830571ad95affc934a448e073d123e1f93030c1252a9641e8567cc2d/markdown_exec-1.10.1.tar.gz", hash = "sha256:db1ec4b32c25720bbb418383ba8f8b3ee1a616d0b61090db51b845db1ad21c0d", size = 77711, upload-time = "2025-03-11T11:40:07.915Z" } +sdist = { url = "https://files.pythonhosted.org/packages/38/71/3b932df36c1a044d397a1f92d1cf91ee0a503d91e470cbd670aa66b07ed0/markdown-it-py-3.0.0.tar.gz", hash = "sha256:e3f60a94fa066dc52ec76661e37c851cb232d92f9886b15cb560aaada2df8feb", size = 74596, upload-time = "2023-06-03T06:41:14.443Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/e1/89/c19e85a624689582e8ba794d947729c7a638e3d0459eb59deb75c3a7231b/markdown_exec-1.10.1-py3-none-any.whl", hash = "sha256:f038787a592c262bba7677d3540c340dbca235dc088c4e47d541c0d3c2d9f97c", size = 27453, upload-time = "2025-03-11T11:40:06.317Z" }, + { url = "https://files.pythonhosted.org/packages/42/d7/1ec15b46af6af88f19b8e5ffea08fa375d433c998b8a7639e76935c14f1f/markdown_it_py-3.0.0-py3-none-any.whl", hash = "sha256:355216845c60bd96232cd8d8c40e8f9765cc86f46880e43a8fd22dc1a1a8cab1", size = 87528, upload-time = "2023-06-03T06:41:11.019Z" }, ] [[package]] @@ -973,6 +1066,27 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/44/48/1e88f90750a66825a5ea8fd2e26908e4e4acade0fe5a378c36d14bc0138d/maturin_import_hook-0.2.0-py3-none-any.whl", hash = "sha256:742d882213d6aa24bacf6775ce26ab96bd4ee26ceafbbbad69d60fdc98d95ec8", size = 31134, upload-time = "2024-12-08T12:26:16.895Z" }, ] +[[package]] +name = "mdit-py-plugins" +version = "0.4.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "markdown-it-py" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/19/03/a2ecab526543b152300717cf232bb4bb8605b6edb946c845016fa9c9c9fd/mdit_py_plugins-0.4.2.tar.gz", hash = "sha256:5f2cd1fdb606ddf152d37ec30e46101a60512bc0e5fa1a7002c36647b09e26b5", size = 43542, upload-time = "2024-09-09T20:27:49.564Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a7/f7/7782a043553ee469c1ff49cfa1cdace2d6bf99a1f333cf38676b3ddf30da/mdit_py_plugins-0.4.2-py3-none-any.whl", hash = "sha256:0c673c3f889399a33b95e88d2f0d111b4447bdfea7f237dab2d488f459835636", size = 55316, upload-time = "2024-09-09T20:27:48.397Z" }, +] + +[[package]] +name = "mdurl" +version = "0.1.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba", size = 8729, upload-time = "2022-08-14T12:40:10.846Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979, upload-time = "2022-08-14T12:40:09.779Z" }, +] + [[package]] name = "mercantile" version = "1.2.1" @@ -1013,6 +1127,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/fd/1a/31b7cd6e4e7a02df4e076162e9783620777592bea9e4bb036389389af99d/mike-2.1.3-py3-none-any.whl", hash = "sha256:d90c64077e84f06272437b464735130d380703a76a5738b152932884c60c062a", size = 33754, upload-time = "2024-08-13T05:02:12.515Z" }, ] +[[package]] +name = "mistune" +version = "3.1.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/c4/79/bda47f7dd7c3c55770478d6d02c9960c430b0cf1773b72366ff89126ea31/mistune-3.1.3.tar.gz", hash = "sha256:a7035c21782b2becb6be62f8f25d3df81ccb4d6fa477a6525b15af06539f02a0", size = 94347, upload-time = "2025-03-19T14:27:24.955Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/01/4d/23c4e4f09da849e127e9f123241946c23c1e30f45a88366879e064211815/mistune-3.1.3-py3-none-any.whl", hash = "sha256:1a32314113cff28aa6432e99e522677c8587fd83e3d51c29b82a52409c842bd9", size = 53410, upload-time = "2025-03-19T14:27:23.451Z" }, +] + [[package]] name = "mkdocs" version = "1.6.1" @@ -1051,21 +1174,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/33/0e/a6ff5d3b3ac428fa8c43a356df449f366ff0dbe242dac9f87fa9d20515ed/mkdocs_autorefs-1.4.0-py3-none-any.whl", hash = "sha256:bad19f69655878d20194acd0162e29a89c3f7e6365ffe54e72aa3fd1072f240d", size = 4368332, upload-time = "2025-02-24T15:57:10.772Z" }, ] -[[package]] -name = "mkdocs-gallery" -version = "0.10.4" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "mkdocs" }, - { name = "mkdocs-material" }, - { name = "packaging" }, - { name = "tqdm" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/49/de/ceec460a00f47fc06676c9c2cbc9c95e12c9f85bafa9edbf5b309d392b3c/mkdocs_gallery-0.10.4.tar.gz", hash = "sha256:469f84a0c842ea87aa59e8679bd6237607f2a578788b50a50132abd9937d14d4", size = 423267, upload-time = "2024-09-30T08:31:06.435Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/00/b3/f6aa253503b3147238747672322503b2b529f390861f6184838d18abd51a/mkdocs_gallery-0.10.4-py2.py3-none-any.whl", hash = "sha256:8669d162b412714c52792f2959d4d211bf92bf5f820f5916c0686ff1ccd89806", size = 137833, upload-time = "2024-09-30T08:31:04.959Z" }, -] - [[package]] name = "mkdocs-get-deps" version = "0.2.0" @@ -1080,6 +1188,23 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/9f/d4/029f984e8d3f3b6b726bd33cafc473b75e9e44c0f7e80a5b29abc466bdea/mkdocs_get_deps-0.2.0-py3-none-any.whl", hash = "sha256:2bf11d0b133e77a0dd036abeeb06dec8775e46efa526dc70667d8863eefc6134", size = 9521, upload-time = "2023-11-20T17:51:08.587Z" }, ] +[[package]] +name = "mkdocs-jupyter" +version = "0.25.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "ipykernel" }, + { name = "jupytext" }, + { name = "mkdocs" }, + { name = "mkdocs-material" }, + { name = "nbconvert" }, + { name = "pygments" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/6c/23/6ffb8d2fd2117aa860a04c6fe2510b21bc3c3c085907ffdd851caba53152/mkdocs_jupyter-0.25.1.tar.gz", hash = "sha256:0e9272ff4947e0ec683c92423a4bfb42a26477c103ab1a6ab8277e2dcc8f7afe", size = 1626747, upload-time = "2024-10-15T14:56:32.373Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/08/37/5f1fd5c3f6954b3256f8126275e62af493b96fb6aef6c0dbc4ee326032ad/mkdocs_jupyter-0.25.1-py3-none-any.whl", hash = "sha256:3f679a857609885d322880e72533ef5255561bbfdb13cfee2a1e92ef4d4ad8d8", size = 1456197, upload-time = "2024-10-15T14:56:29.854Z" }, +] + [[package]] name = "mkdocs-material" version = "9.6.5" @@ -1194,6 +1319,61 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/2a/e2/5d3f6ada4297caebe1a2add3b126fe800c96f56dbe5d1988a2cbe0b267aa/mypy_extensions-1.0.0-py3-none-any.whl", hash = "sha256:4392f6c0eb8a5668a69e23d168ffa70f0be9ccfd32b5cc2d26a34ae5b844552d", size = 4695, upload-time = "2023-02-04T12:11:25.002Z" }, ] +[[package]] +name = "nbclient" +version = "0.10.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jupyter-client" }, + { name = "jupyter-core" }, + { name = "nbformat" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/87/66/7ffd18d58eae90d5721f9f39212327695b749e23ad44b3881744eaf4d9e8/nbclient-0.10.2.tar.gz", hash = "sha256:90b7fc6b810630db87a6d0c2250b1f0ab4cf4d3c27a299b0cde78a4ed3fd9193", size = 62424, upload-time = "2024-12-19T10:32:27.164Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/34/6d/e7fa07f03a4a7b221d94b4d586edb754a9b0dc3c9e2c93353e9fa4e0d117/nbclient-0.10.2-py3-none-any.whl", hash = "sha256:4ffee11e788b4a27fabeb7955547e4318a5298f34342a4bfd01f2e1faaeadc3d", size = 25434, upload-time = "2024-12-19T10:32:24.139Z" }, +] + +[[package]] +name = "nbconvert" +version = "7.16.6" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "beautifulsoup4" }, + { name = "bleach", extra = ["css"] }, + { name = "defusedxml" }, + { name = "jinja2" }, + { name = "jupyter-core" }, + { name = "jupyterlab-pygments" }, + { name = "markupsafe" }, + { name = "mistune" }, + { name = "nbclient" }, + { name = "nbformat" }, + { name = "packaging" }, + { name = "pandocfilters" }, + { name = "pygments" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a3/59/f28e15fc47ffb73af68a8d9b47367a8630d76e97ae85ad18271b9db96fdf/nbconvert-7.16.6.tar.gz", hash = "sha256:576a7e37c6480da7b8465eefa66c17844243816ce1ccc372633c6b71c3c0f582", size = 857715, upload-time = "2025-01-28T09:29:14.724Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cc/9a/cd673b2f773a12c992f41309ef81b99da1690426bd2f96957a7ade0d3ed7/nbconvert-7.16.6-py3-none-any.whl", hash = "sha256:1375a7b67e0c2883678c48e506dc320febb57685e5ee67faa51b18a90f3a712b", size = 258525, upload-time = "2025-01-28T09:29:12.551Z" }, +] + +[[package]] +name = "nbformat" +version = "5.10.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "fastjsonschema" }, + { name = "jsonschema" }, + { name = "jupyter-core" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/6d/fd/91545e604bc3dad7dca9ed03284086039b294c6b3d75c0d2fa45f9e9caf3/nbformat-5.10.4.tar.gz", hash = "sha256:322168b14f937a5d11362988ecac2a4952d3d8e3a2cbeb2319584631226d5b3a", size = 142749, upload-time = "2024-04-04T11:20:37.371Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a9/82/0340caa499416c78e5d8f5f05947ae4bc3cba53c9f038ab6e9ed964e22f1/nbformat-5.10.4-py3-none-any.whl", hash = "sha256:3b48d6c8fbca4b299bf3982ea7db1af21580e4fec269ad087b9e81588891200b", size = 78454, upload-time = "2024-04-04T11:20:34.895Z" }, +] + [[package]] name = "nest-asyncio" version = "1.6.0" @@ -1419,6 +1599,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/ba/64/ab61d9ca06ff66c07eb804ec27dec1a2be1978b3c3767caaa91e363438cc/pandas_stubs-2.2.3.250308-py3-none-any.whl", hash = "sha256:a377edff3b61f8b268c82499fdbe7c00fdeed13235b8b71d6a1dc347aeddc74d", size = 158053, upload-time = "2025-03-08T20:51:03.411Z" }, ] +[[package]] +name = "pandocfilters" +version = "1.5.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/70/6f/3dd4940bbe001c06a65f88e36bad298bc7a0de5036115639926b0c5c0458/pandocfilters-1.5.1.tar.gz", hash = "sha256:002b4a555ee4ebc03f8b66307e287fa492e4a77b4ea14d3f934328297bb4939e", size = 8454, upload-time = "2024-01-18T20:08:13.726Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ef/af/4fbc8cab944db5d21b7e2a5b8e9211a03a79852b1157e2c102fcc61ac440/pandocfilters-1.5.1-py2.py3-none-any.whl", hash = "sha256:93be382804a9cdb0a7267585f157e5d1731bbe5545a85b268d6f5fe6232de2bc", size = 8663, upload-time = "2024-01-18T20:08:11.28Z" }, +] + [[package]] name = "parso" version = "0.8.4" @@ -2116,13 +2305,13 @@ dev = [ docs = [ { name = "arro3-core" }, { name = "contextily" }, + { name = "duckdb" }, { name = "griffe" }, { name = "humanize" }, { name = "ipykernel" }, { name = "jinja2" }, - { name = "markdown-exec" }, { name = "mike" }, - { name = "mkdocs-gallery" }, + { name = "mkdocs-jupyter" }, { name = "mkdocs-material", extra = ["imaging"] }, { name = "mkdocstrings", extra = ["python"] }, { name = "obstore" }, @@ -2151,13 +2340,13 @@ dev = [ docs = [ { name = "arro3-core", specifier = ">=0.4.5" }, { name = "contextily", specifier = ">=1.6.2" }, + { name = "duckdb", specifier = ">=1.3.0" }, { name = "griffe", specifier = ">=1.6.0" }, { name = "humanize", specifier = ">=4.12.1" }, { name = "ipykernel", specifier = ">=6.29.5" }, { name = "jinja2", specifier = ">=3.1.4" }, - { name = "markdown-exec", specifier = ">=1.10.1" }, { name = "mike", specifier = ">=2.1.3" }, - { name = "mkdocs-gallery", specifier = ">=0.10.4" }, + { name = "mkdocs-jupyter", specifier = ">=0.25.1" }, { name = "mkdocs-material", extras = ["imaging"], specifier = ">=9.5.45" }, { name = "mkdocstrings", extras = ["python"], specifier = ">=0.27.0" }, { name = "obstore", specifier = ">=0.6.0" }, @@ -2202,6 +2391,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050, upload-time = "2024-12-04T17:35:26.475Z" }, ] +[[package]] +name = "soupsieve" +version = "2.7" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/3f/f4/4a80cd6ef364b2e8b65b15816a843c0980f7a5a2b4dc701fc574952aa19f/soupsieve-2.7.tar.gz", hash = "sha256:ad282f9b6926286d2ead4750552c8a6142bc4c783fd66b0293547c8fe6ae126a", size = 103418, upload-time = "2025-04-20T18:50:08.518Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e7/9c/0e6afc12c269578be5c0c1c9f4b49a8d32770a080260c333ac04cc1c832d/soupsieve-2.7-py3-none-any.whl", hash = "sha256:6e60cc5c1ffaf1cebcc12e8188320b72071e922c2e897f737cadce79ad5d30c4", size = 36677, upload-time = "2025-04-20T18:50:07.196Z" }, +] + [[package]] name = "stac-geoparquet" version = "0.6.0" @@ -2267,18 +2465,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/61/cc/58b1adeb1bb46228442081e746fcdbc4540905c87e8add7c277540934edb/tornado-6.4.2-cp38-abi3-win_amd64.whl", hash = "sha256:908b71bf3ff37d81073356a5fadcc660eb10c1476ee6e2725588626ce7e5ca38", size = 438907, upload-time = "2024-11-22T03:06:36.71Z" }, ] -[[package]] -name = "tqdm" -version = "4.67.1" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "colorama", marker = "sys_platform == 'win32'" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/a8/4b/29b4ef32e036bb34e4ab51796dd745cdba7ed47ad142a9f4a1eb8e0c744d/tqdm-4.67.1.tar.gz", hash = "sha256:f8aef9c52c08c13a65f30ea34f4e5aac3fd1a34959879d7e59e63027286627f2", size = 169737, upload-time = "2024-11-24T20:12:22.481Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/d0/30/dc54f88dd4a2b5dc8a0279bdd7270e735851848b762aeb1c1184ed1f6b14/tqdm-4.67.1-py3-none-any.whl", hash = "sha256:26445eca388f82e72884e0d580d5464cd801a3ea01e63e5601bdff9ba6a48de2", size = 78540, upload-time = "2024-11-24T20:12:19.698Z" }, -] - [[package]] name = "traitlets" version = "5.14.3"