Add deprecated warning and update tests

Author: jsignell

pystac/extensions/item_assets.py

@@ -2,9 +2,11 @@
 
 from __future__ import annotations
 
+import warnings
 from typing import TYPE_CHECKING, Any, Literal
 
 import pystac
+from pystac.errors import DeprecatedWarning
 from pystac.extensions.base import ExtensionManagementMixin
 from pystac.extensions.hooks import ExtensionHooks
 from pystac.item_assets import ItemAssetDefinition
@@ -30,6 +32,13 @@ class ItemAssetsExtension(ExtensionManagementMixin[pystac.Collection]):
     collection: pystac.Collection
 
     def __init__(self, collection: pystac.Collection) -> None:
+        warnings.warn(
+            (
+                "The ``item_assets`` extension is deprecated. "
+                "``item_assets`` are now top-level collection properties."
+            ),
+            DeprecatedWarning,
+        )
         self.collection = collection
 
     @property

tests/extensions/test_classification.py

@@ -18,7 +18,6 @@
     Classification,
     ClassificationExtension,
 )
-from pystac.extensions.item_assets import ItemAssetsExtension
 from pystac.extensions.raster import RasterBand, RasterExtension
 from tests.utils import TestCases
 
@@ -51,7 +50,7 @@ def plain_item() -> Item:
 
 
 @pytest.fixture
-def collection() -> Collection:
+def classification_collection() -> Collection:
     return Collection.from_file(CLASSIFICATION_COLLECTION_RASTER_URI)
 
 
@@ -108,12 +107,12 @@ def test_ext_raises_if_item_does_not_conform(plain_item: Item) -> None:
         ClassificationExtension.ext(plain_item)
 
 
-def test_ext_raises_on_collection(collection: pystac.Collection) -> None:
+def test_ext_raises_on_collection(classification_collection: Collection) -> None:
     with pytest.raises(
         pystac.errors.ExtensionTypeError,
         match="ClassificationExtension does not apply to type 'Collection'",
     ) as e:
-        ClassificationExtension.ext(collection)  # type:ignore
+        ClassificationExtension.ext(classification_collection)  # type:ignore
     assert "Hint" in str(e.value)
 
 
@@ -311,24 +310,27 @@ def test_add_asset_classes(plain_item: Item) -> None:
     assert asset.extra_fields[CLASSES_PROP] == [{"value": 0, "name": "dummy"}]
 
 
-def test_item_asset_raster_classes(collection: Collection) -> None:
-    item_asset = ItemAssetsExtension.ext(collection, add_if_missing=True).item_assets[
-        "cloud-mask-raster"
-    ]
+def test_item_asset_raster_classes(classification_collection: Collection) -> None:
+    assert classification_collection.item_assets
+    item_asset = classification_collection.item_assets["cloud-mask-raster"]
     raster_bands = cast(list[RasterBand], RasterExtension.ext(item_asset).bands)
     raster_bands_ext = ClassificationExtension.ext(raster_bands[0])
     raster_bands_ext.__repr__()
     assert raster_bands_ext.classes is not None
 
 
-def test_item_assets_extension(collection: Collection) -> None:
-    item_asset = ItemAssetsExtension.ext(collection, add_if_missing=True).item_assets[
-        "cloud-mask-raster"
-    ]
+def test_item_assets_extension(classification_collection: Collection) -> None:
+    assert classification_collection.item_assets
+    item_asset = classification_collection.item_assets["cloud-mask-raster"]
     ext = ClassificationExtension.ext(item_asset)
     ext.__repr__()
-    assert ClassificationExtension.get_schema_uri() in collection.stac_extensions
-    assert collection.ext.item_assets["cloud-mask-raster"].ext.has("classification")
+    assert (
+        ClassificationExtension.get_schema_uri()
+        in classification_collection.stac_extensions
+    )
+    assert classification_collection.item_assets["cloud-mask-raster"].ext.has(
+        "classification"
+    )
 
 
 def test_older_extension_version(landsat_item: Item) -> None:

tests/extensions/test_raster.py

@@ -5,7 +5,6 @@
 
 import pystac
 from pystac import ExtensionTypeError, Item
-from pystac.extensions.item_assets import ItemAssetsExtension
 from pystac.extensions.raster import (
     DataType,
     Histogram,
@@ -282,11 +281,13 @@ def test_summaries_adds_uri(self) -> None:
     def test_collection_item_asset(self) -> None:
         coll = pystac.Collection.from_file(self.LANDSAT_COLLECTION_EXAMPLE_URI)
 
-        qa = ItemAssetsExtension.ext(coll).item_assets["qa"]
-        ang = ItemAssetsExtension.ext(coll).item_assets["ang"]
+        assert coll.item_assets
 
-        assert RasterExtension.ext(qa).bands is not None
-        assert RasterExtension.ext(ang).bands is None
+        qa = coll.item_assets["qa"]
+        ang = coll.item_assets["ang"]
+
+        assert qa.ext.raster.bands is not None
+        assert ang.ext.raster.bands is None
 
 
 @pytest.fixture

tests/extensions/test_item_assets.py renamed to tests/test_item_assets.py

@@ -1,11 +1,19 @@
 import unittest
 
+import pytest
+
 from pystac import Collection
-from pystac.extensions.item_assets import AssetDefinition, ItemAssetsExtension
+from pystac.errors import DeprecatedWarning
+from pystac.extensions.item_assets import ItemAssetsExtension
+from pystac.item_assets import ItemAssetDefinition
 from tests.utils import TestCases
 
+CLASSIFICATION_COLLECTION_RASTER_URI = TestCases.get_path(
+    "data-files/classification/collection-item-assets-raster-bands.json"
+)
+
 
-class TestItemAssetsExtension(unittest.TestCase):
+class TestItemAssets(unittest.TestCase):
     def setUp(self) -> None:
         self.maxDiff = None
         self.collection = Collection.from_file(
@@ -14,13 +22,13 @@ def setUp(self) -> None:
 
     def test_example(self) -> None:
         collection = self.collection.clone()
-        item_ext = ItemAssetsExtension.ext(collection)
 
-        self.assertEqual(len(item_ext.item_assets), 13)
+        assert collection.item_assets
+        self.assertEqual(len(collection.item_assets), 13)
 
         self.assertEqual(
-            item_ext.item_assets["B1"],
-            AssetDefinition(
+            collection.item_assets["B1"],
+            ItemAssetDefinition(
                 {
                     "type": "image/tiff; application=geotiff",
                     "eo:bands": [
@@ -50,7 +58,7 @@ def test_create(self) -> None:
         description = "Coastal Band Top Of the Atmosphere"
         media_type = "image/tiff; application=geotiff"
         roles = ["data"]
-        asset_defn = AssetDefinition.create(
+        asset_defn = ItemAssetDefinition.create(
             title=title, description=description, media_type=media_type, roles=roles
         )
         self.assertEqual(asset_defn.title, title)
@@ -59,7 +67,7 @@ def test_create(self) -> None:
         self.assertEqual(asset_defn.roles, roles)
 
     def test_title(self) -> None:
-        asset_defn = AssetDefinition({})
+        asset_defn = ItemAssetDefinition({})
         title = "Very Important Asset"
 
         asset_defn.title = title
@@ -68,7 +76,7 @@ def test_title(self) -> None:
         self.assertEqual(asset_defn.to_dict()["title"], title)
 
     def test_description(self) -> None:
-        asset_defn = AssetDefinition({})
+        asset_defn = ItemAssetDefinition({})
         description = "What an incredibly important asset this is!"
 
         asset_defn.description = description
@@ -77,7 +85,7 @@ def test_description(self) -> None:
         self.assertEqual(asset_defn.to_dict()["description"], description)
 
     def test_media_type(self) -> None:
-        asset_defn = AssetDefinition({})
+        asset_defn = ItemAssetDefinition({})
         media_type = "application/json"
 
         asset_defn.media_type = media_type
@@ -86,7 +94,7 @@ def test_media_type(self) -> None:
         self.assertEqual(asset_defn.to_dict()["type"], media_type)
 
     def test_roles(self) -> None:
-        asset_defn = AssetDefinition({})
+        asset_defn = ItemAssetDefinition({})
         roles = ["thumbnail"]
 
         asset_defn.roles = roles
@@ -96,23 +104,37 @@ def test_roles(self) -> None:
 
 
 def test_extra_fields(collection: Collection) -> None:
-    asset_definition = AssetDefinition.create(
+    asset_definition = ItemAssetDefinition.create(
         title=None,
         description=None,
         media_type=None,
         roles=None,
         extra_fields={"raster:bands": [{"nodata": 42}]},
     )
-    item_assets = ItemAssetsExtension.ext(collection, add_if_missing=True)
-    item_assets.item_assets = {"data": asset_definition}
+    collection.item_assets = {"data": asset_definition}
     collection_as_dict = collection.to_dict()
     assert collection_as_dict["item_assets"]["data"]["raster:bands"] == [{"nodata": 42}]
     asset = asset_definition.create_asset("asset.tif")
     assert asset.extra_fields["raster:bands"] == [{"nodata": 42}]
 
-    collection.ext.item_assets["data"].ext.add("raster")
-    assert (bands := collection.ext.item_assets["data"].ext.raster.bands)
+    collection.item_assets["data"].ext.add("raster")
+    assert (bands := collection.item_assets["data"].ext.raster.bands)
     assert bands[0].nodata == 42
 
-    assert collection.ext.item_assets["data"].ext.has("raster")
+    assert collection.item_assets["data"].ext.has("raster")
     assert collection.ext.has("raster")
+
+
+def test_item_assets_extension_is_deprecated() -> None:
+    collection = Collection.from_file(CLASSIFICATION_COLLECTION_RASTER_URI)
+    with pytest.warns(DeprecatedWarning, match="top-level collection properties"):
+        item_asset = ItemAssetsExtension.ext(
+            collection, add_if_missing=True
+        ).item_assets["cloud-mask-raster"]
+
+    assert item_asset.ext.has("eo")
+
+    with pytest.warns(DeprecatedWarning, match="top-level collection properties"):
+        assert collection.ext.item_assets["cloud-mask-raster"].ext.has("eo")
+
+    assert ItemAssetsExtension.get_schema_uri() in collection.stac_extensions