pystac-ext-table 1.2.0__tar.gz

pystac_ext_table-1.2.0/.gitignore

@@ -0,0 +1,163 @@
+*.pyc
+*.egg-info
+*.eggs
+.DS_Store
+data
+config.json
+stdout*
+/integration*
+.idea
+.vscode
+.actrc
+
+
+# Sphinx documentation
+.ipynb_checkpoints/
+
+docs/tutorials/pystac-example*
+docs/tutorials/spacenet-stac/
+docs/tutorials/spacenet-cog-stac/
+docs/tutorials/data/
+docs/quickstart_stac/
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+# Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# asv environments
+.asv

pystac_ext_table-1.2.0/PKG-INFO

@@ -0,0 +1,37 @@
+Metadata-Version: 2.4
+Name: pystac-ext-table
+Version: 1.2.0
+Summary: Table extension for PySTAC
+Project-URL: Documentation, https://pystac.readthedocs.io
+Project-URL: Repository, https://github.com/stac-utils/pystac
+Project-URL: Issues, https://github.com/stac-utils/pystac/issues
+Project-URL: Changelog, https://github.com/stac-utils/pystac/blob/main/CHANGELOG.md
+Project-URL: Discussions, https://github.com/radiantearth/stac-spec/discussions/categories/stac-software
+License: Apache-2.0
+Keywords: STAC,catalog,imagery,pystac,raster,table
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Natural Language :: English
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.10
+Requires-Dist: pystac-core
+Description-Content-Type: text/markdown
+
+# pystac-ext-table
+
+[PySTAC](https://pypi.org/project/pystac/) extension package for the [Table Extension](https://github.com/stac-extensions/table).
+This extension provides fields for describing tabular data assets, including column definitions, row counts, primary/foreign keys, and storage formats.
+
+## Supported versions
+
+- [v1.2.0](https://stac-extensions.github.io/table/v1.2.0/schema.json)
+
+## Versioning
+
+This package's version corresponds to the version of the extension specification it targets.
+When we release updates to the package code without changing the target extension version, we use [post releases](https://packaging.python.org/en/latest/discussions/versioning/#post-releases), e.g. `1.2.0.post1`.

pystac_ext_table-1.2.0/README.md

@@ -0,0 +1,13 @@
+# pystac-ext-table
+
+[PySTAC](https://pypi.org/project/pystac/) extension package for the [Table Extension](https://github.com/stac-extensions/table).
+This extension provides fields for describing tabular data assets, including column definitions, row counts, primary/foreign keys, and storage formats.
+
+## Supported versions
+
+- [v1.2.0](https://stac-extensions.github.io/table/v1.2.0/schema.json)
+
+## Versioning
+
+This package's version corresponds to the version of the extension specification it targets.
+When we release updates to the package code without changing the target extension version, we use [post releases](https://packaging.python.org/en/latest/discussions/versioning/#post-releases), e.g. `1.2.0.post1`.

pystac_ext_table-1.2.0/pyproject.toml

@@ -0,0 +1,36 @@
+[project]
+name = "pystac-ext-table"
+description = "Table extension for PySTAC"
+readme = "README.md"
+version = "1.2.0"
+authors = []
+maintainers = []
+keywords = ["pystac", "imagery", "raster", "catalog", "STAC", "table"]
+license = { text = "Apache-2.0" }
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: Apache Software License",
+    "Natural Language :: English",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+]
+requires-python = ">=3.10"
+dependencies = ["pystac-core"]
+
+[project.urls]
+Documentation = "https://pystac.readthedocs.io"
+Repository = "https://github.com/stac-utils/pystac"
+Issues = "https://github.com/stac-utils/pystac/issues"
+Changelog = "https://github.com/stac-utils/pystac/blob/main/CHANGELOG.md"
+Discussions = "https://github.com/radiantearth/stac-spec/discussions/categories/stac-software"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["pystac"]

pystac_ext_table-1.2.0/pystac/extensions/table.py

@@ -0,0 +1,324 @@
+"""Implements the :stac-ext:`Table Extension <table>`."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+from typing import Any, Generic, Literal, TypeVar, cast
+
+import pystac
+from pystac.extensions.base import ExtensionManagementMixin, PropertiesExtension
+from pystac.extensions.hooks import ExtensionHooks
+from pystac.utils import get_required
+
+#: Generalized version of :class:`~pystac.Collection`, :class:`~pystac.Item`,
+#: :class:`~pystac.Asset` or :class:`~pystac.ItemAssetDefinition`
+T = TypeVar(
+    "T", pystac.Collection, pystac.Item, pystac.Asset, pystac.ItemAssetDefinition
+)
+
+SCHEMA_URI = "https://stac-extensions.github.io/table/v1.2.0/schema.json"
+
+PREFIX: str = "table:"
+COLUMNS_PROP = PREFIX + "columns"
+PRIMARY_GEOMETRY_PROP = PREFIX + "primary_geometry"
+ROW_COUNT_PROP = PREFIX + "row_count"
+STORAGE_OPTIONS_PROP = PREFIX + "storage_options"
+TABLES_PROP = PREFIX + "tables"
+
+# Column properties
+COL_NAME_PROP = "name"
+COL_DESCRIPTION_PROP = "description"
+COL_TYPE_PROP = "type"
+
+# Table properties
+TBL_NAME_PROP = "name"
+TBL_DESCRIPTION_PROP = "description"
+
+
+class Column:
+    """Object representing a column of a table."""
+
+    properties: dict[str, Any]
+
+    def __init__(self, properties: dict[str, Any]):
+        self.properties = properties
+
+    @property
+    def name(self) -> str:
+        """The column name"""
+        return cast(
+            str,
+            get_required(
+                self.properties.get(COL_NAME_PROP), "table:column", COL_NAME_PROP
+            ),
+        )
+
+    @name.setter
+    def name(self, v: str) -> None:
+        self.properties[COL_NAME_PROP] = v
+
+    @property
+    def description(self) -> str | None:
+        """Detailed multi-line description to explain the column. `CommonMark 0.29
+        <http://commonmark.org/>`__ syntax MAY be used for rich text representation."""
+        return self.properties.get(COL_DESCRIPTION_PROP)
+
+    @description.setter
+    def description(self, v: str | None) -> None:
+        if v is None:
+            self.properties.pop(COL_DESCRIPTION_PROP, None)
+        else:
+            self.properties[COL_DESCRIPTION_PROP] = v
+
+    @property
+    def col_type(self) -> str | None:
+        """Data type of the column. If using a file format with a type system (like
+        Parquet), we recommend you use those types"""
+        return self.properties.get(COL_TYPE_PROP)
+
+    @col_type.setter
+    def col_type(self, v: str | None) -> None:
+        if v is None:
+            self.properties.pop(COL_TYPE_PROP, None)
+        else:
+            self.properties[COL_TYPE_PROP] = v
+
+    def to_dict(self) -> dict[str, Any]:
+        """Returns a dictionary representing this ``Column``."""
+        return self.properties
+
+
+class Table:
+    """Object containing a high-level summary about a table"""
+
+    properties: dict[str, Any]
+
+    def __init__(self, properties: dict[str, Any]):
+        self.properties = properties
+
+    @property
+    def name(self) -> str:
+        """The table name"""
+        return cast(
+            str, get_required(self.properties.get(TBL_NAME_PROP), self, TBL_NAME_PROP)
+        )
+
+    @name.setter
+    def name(self, v: str) -> None:
+        self.properties[COL_NAME_PROP] = v
+
+    @property
+    def description(self) -> str | None:
+        """Detailed multi-line description to explain the table. `CommonMark 0.29
+        <http://commonmark.org/>`__ syntax MAY be used for rich text representation."""
+        return self.properties.get(COL_DESCRIPTION_PROP)
+
+    @description.setter
+    def description(self, v: str | None) -> None:
+        if v is None:
+            self.properties.pop(COL_DESCRIPTION_PROP, None)
+        else:
+            self.properties[COL_DESCRIPTION_PROP] = v
+
+    def to_dict(self) -> dict[str, Any]:
+        """Returns a dictionary representing this ``Table``."""
+        return self.properties
+
+
+class TableExtension(
+    Generic[T],
+    PropertiesExtension,
+    ExtensionManagementMixin[pystac.Item | pystac.Collection],
+):
+    """An abstract class that can be used to extend the properties of a
+    :class:`~pystac.Collection`, :class:`~pystac.Item`, or :class:`~pystac.Asset` with
+    properties from the :stac-ext:`Datacube Extension <datacube>`. This class is
+    generic over the type of STAC Object to be extended (e.g. :class:`~pystac.Item`,
+    :class:`~pystac.Asset`).
+
+    To create a concrete instance of :class:`TableExtension`, use the
+    :meth:`TableExtension.ext` method. For example:
+
+    .. code-block:: python
+
+        >>> item: pystac.Item = ...
+        >>> tbl_ext = TableExtension.ext(item)
+
+    """
+
+    name: Literal["table"] = "table"
+
+    @classmethod
+    def get_schema_uri(cls) -> str:
+        return SCHEMA_URI
+
+    @classmethod
+    def ext(cls, obj: T, add_if_missing: bool = False) -> TableExtension[T]:
+        """Extend the given STAC Object with properties from the
+        :stac-ext:`Table Extension <table>`.
+
+        This extension can be applied to instances of :class:`~pystac.Collection`,
+        :class:`~pystac.Item` or :class:`~pystac.Asset`.
+
+        Raises:
+            pystac.ExtensionTypeError : If an invalid object type is passed.
+        """
+        if isinstance(obj, pystac.Collection):
+            cls.ensure_has_extension(obj, add_if_missing)
+            return cast(TableExtension[T], CollectionTableExtension(obj))
+        if isinstance(obj, pystac.Item):
+            cls.ensure_has_extension(obj, add_if_missing)
+            return cast(TableExtension[T], ItemTableExtension(obj))
+        if isinstance(obj, pystac.Asset):
+            cls.ensure_owner_has_extension(obj, add_if_missing)
+            return cast(TableExtension[T], AssetTableExtension(obj))
+        elif isinstance(obj, pystac.ItemAssetDefinition):
+            cls.ensure_owner_has_extension(obj, add_if_missing)
+            return cast(TableExtension[T], ItemAssetsTableExtension(obj))
+        else:
+            raise pystac.ExtensionTypeError(cls._ext_error_message(obj))
+
+    @property
+    def columns(self) -> list[Column] | None:
+        """A list of :class:`Column` objects describing each column"""
+        v = self.properties.get(COLUMNS_PROP)
+        if v is None:
+            return None
+        return [Column(x) for x in v]
+
+    @columns.setter
+    def columns(self, v: list[Column] | None) -> None:
+        self._set_property(COLUMNS_PROP, v)
+
+    @property
+    def primary_geometry(self) -> str | None:
+        """The primary geometry column name"""
+        return self._get_property(PRIMARY_GEOMETRY_PROP, str)
+
+    @primary_geometry.setter
+    def primary_geometry(self, v: str | None) -> None:
+        if v is None:
+            self.properties.pop(PRIMARY_GEOMETRY_PROP, None)
+        else:
+            self.properties[PRIMARY_GEOMETRY_PROP] = v
+
+    @property
+    def row_count(self) -> int | None:
+        """The number of rows in the dataset"""
+        return self._get_property(ROW_COUNT_PROP, int)
+
+    @row_count.setter
+    def row_count(self, v: int | None) -> None:
+        if v is None:
+            self.properties.pop(ROW_COUNT_PROP, None)
+        else:
+            self.properties[ROW_COUNT_PROP] = v
+
+
+class CollectionTableExtension(TableExtension[pystac.Collection]):
+    """A concrete implementation of :class:`TableExtension` on a
+    :class:`~pystac.Collection` that extends the properties of the Item to include
+    properties defined in the :stac-ext:`Table Extension <table>`.
+
+    This class should generally not be instantiated directly. Instead, call
+    :meth:`TableExtension.ext` on an :class:`~pystac.Collection` to extend it.
+    """
+
+    collection: pystac.Collection
+    properties: dict[str, Any]
+
+    def __init__(self, collection: pystac.Collection):
+        self.collection = collection
+        self.properties = collection.extra_fields
+
+    @property
+    def tables(self) -> dict[str, Table]:
+        """A mapping of table names to table objects"""
+        return get_required(self.properties.get(TABLES_PROP), self, TABLES_PROP)
+
+    @tables.setter
+    def tables(self, v: dict[str, Table]) -> None:
+        self.properties[TABLES_PROP] = v
+
+    def __repr__(self) -> str:
+        return f"<CollectionTableExtension Item id={self.collection.id}>"
+
+
+class ItemTableExtension(TableExtension[pystac.Item]):
+    """A concrete implementation of :class:`TableExtension` on an
+    :class:`~pystac.Item` that extends the properties of the Item to include properties
+    defined in the :stac-ext:`Table Extension <table>`.
+
+    This class should generally not be instantiated directly. Instead, call
+    :meth:`TableExtension.ext` on an :class:`~pystac.Item` to extend it.
+    """
+
+    item: pystac.Item
+    properties: dict[str, Any]
+
+    def __init__(self, item: pystac.Item):
+        self.item = item
+        self.properties = item.properties
+
+    def __repr__(self) -> str:
+        return f"<ItemTableExtension Item id={self.item.id}>"
+
+
+class AssetTableExtension(TableExtension[pystac.Asset]):
+    """A concrete implementation of :class:`TableExtension` on an
+    :class:`~pystac.Asset` that extends the Asset fields to include properties defined
+    in the :stac-ext:`Table Extension <table>`.
+
+    This class should generally not be instantiated directly. Instead, call
+    :meth:`TableExtension.ext` on an :class:`~pystac.Asset` to extend it.
+    """
+
+    asset_href: str
+    properties: dict[str, Any]
+    additional_read_properties: Iterable[dict[str, Any]] | None
+
+    def __init__(self, asset: pystac.Asset):
+        self.asset_href = asset.href
+        self.properties = asset.extra_fields
+        if asset.owner and isinstance(asset.owner, pystac.Item):
+            self.additional_read_properties = [asset.owner.properties]
+        else:
+            self.additional_read_properties = None
+
+    @property
+    def storage_options(self) -> dict[str, Any] | None:
+        """Additional keywords for opening the dataset"""
+        return self.properties.get(STORAGE_OPTIONS_PROP)
+
+    @storage_options.setter
+    def storage_options(self, v: dict[str, Any] | None) -> Any:
+        if v is None:
+            self.properties.pop(STORAGE_OPTIONS_PROP, None)
+        else:
+            self.properties[STORAGE_OPTIONS_PROP] = v
+
+    def __repr__(self) -> str:
+        return f"<AssetTableExtension Item id={self.asset_href}>"
+
+
+class ItemAssetsTableExtension(TableExtension[pystac.ItemAssetDefinition]):
+    properties: dict[str, Any]
+    asset_defn: pystac.ItemAssetDefinition
+
+    def __init__(self, item_asset: pystac.ItemAssetDefinition):
+        self.asset_defn = item_asset
+        self.properties = item_asset.properties
+
+
+class TableExtensinoHooks(ExtensionHooks):
+    schema_uri: str = SCHEMA_URI
+    prev_extension_ids = {
+        "table",
+        "https://stac-extensions.github.io/table/v1.0.0/schema.json",
+        "https://stac-extensions.github.io/table/v1.0.1/schema.json",
+        "https://stac-extensions.github.io/table/v1.1.0/schema.json",
+    }
+    stac_object_types = {pystac.STACObjectType.COLLECTION, pystac.STACObjectType.ITEM}
+
+
+TABLE_EXTENSION_HOOKS: ExtensionHooks = TableExtensinoHooks()

pystac_ext_table-1.2.0/tests/cassettes/test_table/test_validate.yaml

@@ -0,0 +1,90 @@
+interactions:
+- request:
+    body: null
+    headers: {}
+    method: GET
+    uri: https://stac-extensions.github.io/table/v1.2.0/schema.json
+  response:
+    body:
+      string: "{\n  \"$schema\": \"http://json-schema.org/draft-07/schema#\",\n  \"$id\":
+        \"https://stac-extensions.github.io/table/v1.2.0/schema.json#\",\n  \"title\":
+        \"Table Extension\",\n  \"description\": \"STAC Table Extension for STAC Items
+        and STAC Collections.\",\n  \"oneOf\": [\n    {\n      \"$comment\": \"This
+        is the schema for STAC Items. Remove this object if this extension only applies
+        to Collections.\",\n      \"allOf\": [\n        {\n          \"$ref\": \"#/definitions/stac_extensions\"\n
+        \       },\n        {\n          \"type\": \"object\",\n          \"required\":
+        [\n            \"type\",\n            \"properties\",\n            \"assets\"\n
+        \         ],\n          \"properties\": {\n            \"type\": {\n              \"const\":
+        \"Feature\"\n            },\n            \"properties\": {\n              \"allOf\":
+        [\n                {\n                  \"$comment\": \"Require fields here
+        for Item Properties.\",\n                  \"required\": []\n                },\n
+        \               {\n                  \"$ref\": \"#/definitions/fields\"\n
+        \               }\n              ]\n            },\n            \"assets\":
+        {\n              \"$comment\": \"This validates the fields in Item Assets,
+        but does not require them.\",\n              \"type\": \"object\",\n              \"additionalProperties\":
+        {\n                \"$ref\": \"#/definitions/fields\"\n              }\n            }\n
+        \         }\n        }\n      ]\n    },\n    {\n      \"$comment\": \"This
+        is the schema for STAC Collections.\",\n      \"type\": \"object\",\n      \"allOf\":
+        [\n        {\n          \"required\": [\n            \"type\"\n          ],\n
+        \         \"properties\": {\n            \"type\": {\n              \"const\":
+        \"Collection\"\n            }\n          }\n        },\n        {\n          \"$ref\":
+        \"#/definitions/stac_extensions\"\n        }\n      ],\n      \"anyOf\": [\n
+        \       {\n          \"$comment\": \"This is the schema for the top-level
+        fields in a Collection. Remove this if this extension does not define top-level
+        fields for Collections.\",\n          \"allOf\": [\n            {\n              \"$comment\":
+        \"Require fields here for Collections (top-level).\",\n              \"required\":
+        []\n            },\n            {\n              \"$ref\": \"#/definitions/fields\"\n
+        \           }\n          ]\n        },\n        {\n          \"$comment\":
+        \"This validates the fields in Collection Assets, but does not require them.\",\n
+        \         \"required\": [\n            \"assets\"\n          ],\n          \"properties\":
+        {\n            \"assets\": {\n              \"type\": \"object\",\n              \"not\":
+        {\n                \"additionalProperties\": {\n                  \"not\":
+        {\n                    \"allOf\": [\n                      {\n                        \"$ref\":
+        \"#/definitions/require_any_field\"\n                      },\n                      {\n
+        \                       \"$ref\": \"#/definitions/fields\"\n                      }\n
+        \                   ]\n                  }\n                }\n              }\n
+        \           }\n          }\n        },\n        {\n          \"$comment\":
+        \"This is the schema for the fields in Item Asset Definitions. It doesn't
+        require any fields.\",\n          \"required\": [\n            \"item_assets\"\n
+        \         ],\n          \"properties\": {\n            \"item_assets\": {\n
+        \             \"type\": \"object\",\n              \"not\": {\n                \"additionalProperties\":
+        {\n                  \"not\": {\n                    \"allOf\": [\n                      {\n
+        \                       \"$ref\": \"#/definitions/require_any_field\"\n                      },\n
+        \                     {\n                        \"$ref\": \"#/definitions/fields\"\n
+        \                     }\n                    ]\n                  }\n                }\n
+        \             }\n            }\n          }\n        },\n        {\n          \"$comment\":
+        \"This is the schema for the fields in Summaries. By default, only checks
+        the existence of the properties, but not the schema of the summaries.\",\n
+        \         \"required\": [\n            \"summaries\"\n          ],\n          \"properties\":
+        {\n            \"summaries\": {\n              \"$ref\": \"#/definitions/require_any_field\"\n
+        \           }\n          }\n        }\n      ]\n    }\n  ],\n  \"definitions\":
+        {\n    \"stac_extensions\": {\n      \"type\": \"object\",\n      \"required\":
+        [\n        \"stac_extensions\"\n      ],\n      \"properties\": {\n        \"stac_extensions\":
+        {\n          \"type\": \"array\",\n          \"contains\": {\n            \"const\":
+        \"https://stac-extensions.github.io/table/v1.2.0/schema.json\"\n          }\n
+        \       }\n      }\n    },\n    \"require_any_field\": {\n      \"$comment\":
+        \"Please list all fields here so that we can force the existence of one of
+        them in other parts of the schemas.\",\n      \"anyOf\": [\n        {\n          \"required\":
+        []\n        }\n      ]\n    },\n    \"fields\": {\n      \"$comment\": \"Add
+        your new fields here. Don't require them here, do that above in the corresponding
+        schema.\",\n      \"type\": \"object\",\n      \"properties\": {\n        \"table:tables\":
+        {\n          \"type\": \"array\",\n          \"items\": {\n            \"type\":
+        \"object\",\n            \"required\": [\n              \"name\"\n            ],\n
+        \           \"properties\": {\n              \"name\": {\n                \"type\":
+        \"string\"\n              },\n              \"description\": {\n                \"type\":
+        \"string\"\n              }\n            }\n          },\n          \"additionalProperties\":
+        false\n        },\n        \"table:columns\": {\n          \"type\": \"array\",\n
+        \         \"items\": {\n            \"type\": \"object\",\n            \"required\":
+        [\n              \"name\"\n            ],\n            \"properties\": {\n
+        \             \"name\": {\n                \"type\": \"string\"\n              },\n
+        \             \"description\": {\n                \"type\": \"string\"\n              },\n
+        \             \"type\": {\n                \"type\": \"string\"\n              }\n
+        \           }\n          },\n          \"additionalProperties\": false\n        },\n
+        \       \"table:primary_geometry\": {\n          \"type\": \"string\"\n        },\n
+        \       \"table:row_count\": {\n          \"type\": \"number\"\n        }\n
+        \     }\n    }\n  }\n}\n"
+    headers: {}
+    status:
+      code: 200
+      message: OK
+version: 1

pystac_ext_table-1.2.0/tests/data-files/README.md

@@ -0,0 +1,5 @@
+# Source information
+
+Example files yanked from the Table extension STAC specification:
+
+https://github.com/stac-extensions/table/tree/f962838a51c0ce78c9aa180b7973e538e6ef900e/examples

pystac_ext_table-1.2.0/tests/data-files/collection-2.json

@@ -0,0 +1,33 @@
+{
+  "type": "Collection",
+  "id": "id",
+  "stac_version": "1.1.0",
+  "description": "desc",
+  "links": [],
+  "stac_extensions": [
+    "https://stac-extensions.github.io/table/v1.2.0/schema.json"
+  ],
+  "extent": {
+    "spatial": {
+      "bbox": [
+        [
+          1,
+          2,
+          3,
+          4
+        ]
+      ]
+    },
+    "temporal": {
+      "interval": [
+        [
+          null,
+          null
+        ]
+      ]
+    }
+  },
+  "license": "other",
+  "item_assets": {},
+  "table:columns": []
+}

pystac_ext_table-1.2.0/tests/data-files/collection.json

@@ -0,0 +1,75 @@
+{
+  "stac_version": "1.1.0",
+  "stac_extensions": [
+    "https://stac-extensions.github.io/table/v1.2.0/schema.json"
+  ],
+  "type": "Collection",
+  "id": "collection",
+  "title": "A title",
+  "description": "A description",
+  "license": "Apache-2.0",
+  "extent": {
+    "spatial": {
+      "bbox": [
+        [
+          172.9,
+          1.3,
+          173,
+          1.4
+        ]
+      ]
+    },
+    "temporal": {
+      "interval": [
+        [
+          "2015-06-23T00:00:00Z",
+          null
+        ]
+      ]
+    }
+  },
+  "assets": {
+    "example": {
+      "href": "https://example.com/examples/file.xyz"
+    }
+  },
+  "item_assets": {
+    "data": {
+      "roles": [
+        "data"
+      ],
+      "description": "description"
+    }
+  },
+  "summaries": {
+    "datetime": {
+      "minimum": "2015-06-23T00:00:00Z",
+      "maximum": "2019-07-10T13:44:56Z"
+    }
+  },
+  "table:columns": [
+    {
+      "name": "geometry",
+      "description": "The observation location.",
+      "type": "int64"
+    },
+    {
+      "name": "id",
+      "description": "The numerical identifier"
+    },
+    {
+      "name": "value"
+    }
+  ],
+  "table:primary_geometry": "geometry",
+  "links": [
+    {
+      "href": "https://example.com/examples/collection.json",
+      "rel": "self"
+    },
+    {
+      "href": "https://example.com/examples/item.json",
+      "rel": "item"
+    }
+  ]
+}

pystac_ext_table-1.2.0/tests/data-files/item.json

@@ -0,0 +1,74 @@
+{
+  "stac_version": "1.1.0",
+  "stac_extensions": [
+    "https://stac-extensions.github.io/table/v1.2.0/schema.json"
+  ],
+  "type": "Feature",
+  "id": "item",
+  "bbox": [
+    172.9,
+    1.3,
+    173,
+    1.4
+  ],
+  "geometry": {
+    "type": "Polygon",
+    "coordinates": [
+      [
+        [
+          172.9,
+          1.3
+        ],
+        [
+          173,
+          1.3
+        ],
+        [
+          173,
+          1.4
+        ],
+        [
+          172.9,
+          1.4
+        ],
+        [
+          172.9,
+          1.3
+        ]
+      ]
+    ]
+  },
+  "properties": {
+    "datetime": "2020-12-11T22:38:32Z",
+    "table:columns": [
+      {
+        "name": "geometry",
+        "description": "The observation location.",
+        "type": "byte_array"
+      },
+      {
+        "name": "id",
+        "description": "The numerical identifier",
+        "type": "int64"
+      },
+      {
+        "name": "value",
+        "description": "The observed value",
+        "type": "float64"
+      }
+    ],
+    "table:primary_geometry": "geometry",
+    "table:row_count": 100
+  },
+  "links": [
+    {
+      "href": "https://example.com/examples/item.json",
+      "rel": "self"
+    }
+  ],
+  "assets": {
+    "data": {
+      "href": "https://example.com/examples/file.xyz"
+    }
+  }
+}

pystac_ext_table-1.2.0/tests/data-files/table-collection.json

@@ -0,0 +1,69 @@
+{
+  "stac_version": "1.1.0",
+  "stac_extensions": [
+    "https://stac-extensions.github.io/table/v1.2.0/schema.json"
+  ],
+  "type": "Collection",
+  "id": "collection",
+  "title": "A title",
+  "description": "A description",
+  "license": "Apache-2.0",
+  "extent": {
+    "spatial": {
+      "bbox": [
+        [
+          172.9,
+          1.3,
+          173,
+          1.4
+        ]
+      ]
+    },
+    "temporal": {
+      "interval": [
+        [
+          "2015-06-23T00:00:00Z",
+          null
+        ]
+      ]
+    }
+  },
+  "assets": {
+    "example": {
+      "href": "https://example.com/examples/file.xyz"
+    }
+  },
+  "item_assets": {
+    "data": {
+      "roles": [
+        "data"
+      ],
+      "description": "description"
+    }
+  },
+  "summaries": {
+    "datetime": {
+      "minimum": "2015-06-23T00:00:00Z",
+      "maximum": "2019-07-10T13:44:56Z"
+    }
+  },
+  "table:tables": [
+    {
+      "name": "first table",
+      "description": "This is my first table"
+    },
+    {
+      "name": "Second table"
+    }
+  ],
+  "links": [
+    {
+      "href": "https://example.com/examples/collection.json",
+      "rel": "self"
+    },
+    {
+      "href": "https://example.com/examples/item.json",
+      "rel": "item"
+    }
+  ]
+}

pystac_ext_table-1.2.0/tests/test_table.py

@@ -0,0 +1,98 @@
+from pathlib import Path
+
+import pytest
+
+import pystac
+from pystac import ExtensionTypeError, Item
+from pystac.extensions.table import Column, TableExtension
+
+DATA_FILES = Path(__file__).resolve().parent / "data-files"
+
+
+@pytest.fixture
+def table_item() -> Item:
+    return pystac.Item.from_file(str(DATA_FILES / "item.json"))
+
+
+@pytest.mark.vcr()
+def test_validate(table_item: Item) -> None:
+    table_item.validate()
+
+
+def test_extension_not_implemented(table_item: Item) -> None:
+    # Should raise exception if item does not include extension URI
+    table_item.stac_extensions.remove(TableExtension.get_schema_uri())
+
+    with pytest.raises(pystac.ExtensionNotImplemented):
+        _ = TableExtension.ext(table_item)
+
+    # Should raise exception if owning item does not include extension URI
+    asset = table_item.assets["data"]
+
+    with pytest.raises(pystac.ExtensionNotImplemented):
+        _ = TableExtension.ext(asset)
+
+    # Should succeed if Asset has no owner
+    ownerless_asset = pystac.Asset.from_dict(asset.to_dict())
+    _ = TableExtension.ext(ownerless_asset)
+
+
+def test_item_ext_add_to(table_item: Item) -> None:
+    table_item.stac_extensions.remove(TableExtension.get_schema_uri())
+
+    _ = TableExtension.ext(table_item, add_if_missing=True)
+
+    assert TableExtension.get_schema_uri() in table_item.stac_extensions
+
+
+def test_asset_ext_add_to(table_item: Item) -> None:
+    table_item.stac_extensions.remove(TableExtension.get_schema_uri())
+
+    assert TableExtension.get_schema_uri() not in table_item.stac_extensions
+    asset = table_item.assets["data"]
+
+    _ = TableExtension.ext(asset, add_if_missing=True)
+    assert TableExtension.get_schema_uri() in table_item.stac_extensions
+
+
+def test_should_raise_when_passing_invalid_extension_object() -> None:
+    with pytest.raises(
+        ExtensionTypeError, match=r"^TableExtension does not apply to type 'object'$"
+    ):
+        # calling it wrong on purpose so ------v
+        TableExtension.ext(object())  # type: ignore
+
+
+def test_item_with_table_extension_is_serilalizable_and_roundtrips(
+    tmp_path: Path,
+    table_item: Item,
+) -> None:
+    # add column metadata
+    tab_ext = TableExtension.ext(table_item, add_if_missing=True)
+    columns = [
+        Column({"name": "col_1", "type": "str"}),
+        Column({"name": "col_2", "type": "byte_array"}),
+    ]
+    tab_ext.columns = columns
+    table_item.save_object(dest_href=str(tmp_path / "item.json"))
+    assert all(isinstance(c, Column) for c in tab_ext.columns)
+    assert all(
+        before.properties == after.properties
+        for before, after in zip(columns, tab_ext.columns)
+    )
+
+
+@pytest.mark.parametrize(
+    "schema_uri",
+    (
+        "https://stac-extensions.github.io/table/v1.0.0/schema.json",
+        "https://stac-extensions.github.io/table/v1.0.1/schema.json",
+        "https://stac-extensions.github.io/table/v1.1.0/schema.json",
+    ),
+)
+def test_migrate(schema_uri: str, table_item: Item) -> None:
+    item_dict = table_item.to_dict(include_self_link=False, transform_hrefs=False)
+    item_dict["stac_extensions"] = [schema_uri]
+    assert Item.from_dict(item_dict, migrate=True).stac_extensions == [
+        "https://stac-extensions.github.io/table/v1.2.0/schema.json"
+    ]