Add Sat Extension summaries

Author: duckontheweb

pystac/extensions/sat.py

@@ -5,12 +5,14 @@
 
 import enum
 from datetime import datetime as Datetime
-from typing import Dict, Any, Generic, Iterable, Optional, Set, TypeVar, cast
+from pystac.summaries import RangeSummary
+from typing import Dict, Any, List, Generic, Iterable, Optional, Set, TypeVar, cast
 
 import pystac
 from pystac.extensions.base import (
     ExtensionManagementMixin,
     PropertiesExtension,
+    SummariesExtension,
 )
 from pystac.extensions.hooks import ExtensionHooks
 from pystac.utils import str_to_datetime, datetime_to_str, map_opt
@@ -159,6 +161,11 @@ def ext(cls, obj: T, add_if_missing: bool = False) -> "SatExtension[T]":
                 f"Satellite extension does not apply to type '{type(obj).__name__}'"
             )
 
+    @staticmethod
+    def summaries(obj: pystac.Collection) -> "SummariesSatExtension":
+        """Returns the extended summaries object for the given collection."""
+        return SummariesSatExtension(obj)
+
 
 class ItemSatExtension(SatExtension[pystac.Item]):
     """A concrete implementation of :class:`SatExtension` on an :class:`~pystac.Item`
@@ -214,6 +221,75 @@ def __repr__(self) -> str:
         return "<AssetSatExtension Asset href={}>".format(self.asset_href)
 
 
+class SummariesSatExtension(SummariesExtension):
+    """A concrete implementation of :class:`~SummariesExtension` that extends
+    the ``summaries`` field of a :class:`~pystac.Collection` to include properties
+    defined in the :stac-ext:`Satellite Extension <sat>`.
+    """
+
+    @property
+    def platform_international_designator(self) -> Optional[List[str]]:
+        """Get or sets the summary of
+        :attr:`SatExtension.platform_international_designator` values for this
+        Collection.
+        """
+
+        return self.summaries.get_list(PLATFORM_INTERNATIONAL_DESIGNATOR_PROP)
+
+    @platform_international_designator.setter
+    def platform_international_designator(self, v: Optional[List[str]]) -> None:
+        self._set_summary(PLATFORM_INTERNATIONAL_DESIGNATOR_PROP, v)
+
+    @property
+    def orbit_state(self) -> Optional[List[OrbitState]]:
+        """Get or sets the summary of :attr:`SatExtension.orbit_state` values
+        for this Collection.
+        """
+
+        return self.summaries.get_list(ORBIT_STATE_PROP)
+
+    @orbit_state.setter
+    def orbit_state(self, v: Optional[List[OrbitState]]) -> None:
+        self._set_summary(ORBIT_STATE_PROP, v)
+
+    @property
+    def absolute_orbit(self) -> Optional[RangeSummary[int]]:
+        return self.summaries.get_range(ABSOLUTE_ORBIT_PROP)
+
+    @absolute_orbit.setter
+    def absolute_orbit(self, v: Optional[RangeSummary[int]]) -> None:
+        self._set_summary(ABSOLUTE_ORBIT_PROP, v)
+
+    @property
+    def relative_orbit(self) -> Optional[RangeSummary[int]]:
+        return self.summaries.get_range(RELATIVE_ORBIT_PROP)
+
+    @relative_orbit.setter
+    def relative_orbit(self, v: Optional[RangeSummary[int]]) -> None:
+        self._set_summary(RELATIVE_ORBIT_PROP, v)
+
+    @property
+    def anx_datetime(self) -> Optional[RangeSummary[Datetime]]:
+        return map_opt(
+            lambda s: RangeSummary(
+                str_to_datetime(s.minimum), str_to_datetime(s.maximum)
+            ),
+            self.summaries.get_range(ANX_DATETIME_PROP),
+        )
+
+    @anx_datetime.setter
+    def anx_datetime(self, v: Optional[RangeSummary[Datetime]]) -> None:
+        self._set_summary(
+            ANX_DATETIME_PROP,
+            map_opt(
+                lambda s: RangeSummary(
+                    datetime_to_str(s.minimum), datetime_to_str(s.maximum)
+                ),
+                v,
+            ),
+        )
+
+
 class SatExtensionHooks(ExtensionHooks):
     schema_uri: str = SCHEMA_URI
     prev_extension_ids: Set[str] = set(["sat"])

tests/extensions/test_sat.py

@@ -1,14 +1,15 @@
 """Tests for pystac.extensions.sat."""
 
 import datetime
+from pystac.summaries import RangeSummary
 from typing import Any, Dict
 import unittest
 
 import pystac
-from pystac.utils import str_to_datetime
+from pystac.utils import str_to_datetime, datetime_to_str
 from pystac import ExtensionTypeError
 from pystac.extensions import sat
-from pystac.extensions.sat import SatExtension
+from pystac.extensions.sat import OrbitState, SatExtension
 from tests.utils import TestCases
 
 
@@ -216,3 +217,108 @@ def test_should_raise_exception_when_passing_invalid_extension_object(
             SatExtension.ext,
             object(),
         )
+
+
+class SatSummariesTest(unittest.TestCase):
+    def setUp(self) -> None:
+        self.maxDiff = None
+
+        self.collection = pystac.Collection.from_file(
+            TestCases.get_path("data-files/collections/multi-extent.json")
+        )
+
+    def test_platform_international_designation(self) -> None:
+        summaries_ext = SatExtension.summaries(self.collection)
+        platform_international_designator_list = ["2018-080A"]
+
+        summaries_ext.platform_international_designator = ["2018-080A"]
+
+        self.assertEqual(
+            summaries_ext.platform_international_designator,
+            platform_international_designator_list,
+        )
+
+        summaries_dict = self.collection.to_dict()["summaries"]
+
+        self.assertEqual(
+            summaries_dict["sat:platform_international_designator"],
+            platform_international_designator_list,
+        )
+
+    def test_orbit_state(self) -> None:
+        summaries_ext = SatExtension.summaries(self.collection)
+        orbit_state_list = [OrbitState.ASCENDING]
+
+        summaries_ext.orbit_state = orbit_state_list
+
+        self.assertEqual(
+            summaries_ext.orbit_state,
+            orbit_state_list,
+        )
+
+        summaries_dict = self.collection.to_dict()["summaries"]
+
+        self.assertEqual(
+            summaries_dict["sat:orbit_state"],
+            orbit_state_list,
+        )
+
+    def test_absolute_orbit(self) -> None:
+        summaries_ext = SatExtension.summaries(self.collection)
+        absolute_orbit_range = RangeSummary(2000, 3000)
+
+        summaries_ext.absolute_orbit = absolute_orbit_range
+
+        self.assertEqual(
+            summaries_ext.absolute_orbit,
+            absolute_orbit_range,
+        )
+
+        summaries_dict = self.collection.to_dict()["summaries"]
+
+        self.assertEqual(
+            summaries_dict["sat:absolute_orbit"],
+            absolute_orbit_range.to_dict(),
+        )
+
+    def test_relative_orbit(self) -> None:
+        summaries_ext = SatExtension.summaries(self.collection)
+        relative_orbit_range = RangeSummary(50, 100)
+
+        summaries_ext.relative_orbit = relative_orbit_range
+
+        self.assertEqual(
+            summaries_ext.relative_orbit,
+            relative_orbit_range,
+        )
+
+        summaries_dict = self.collection.to_dict()["summaries"]
+
+        self.assertEqual(
+            summaries_dict["sat:relative_orbit"],
+            relative_orbit_range.to_dict(),
+        )
+
+    def test_anx_datetime(self) -> None:
+        summaries_ext = SatExtension.summaries(self.collection)
+        anx_datetime_range = RangeSummary(
+            str_to_datetime("2020-01-01T00:00:00.000Z"),
+            str_to_datetime("2020-01-02T00:00:00.000Z"),
+        )
+
+        summaries_ext.anx_datetime = anx_datetime_range
+
+        self.assertEqual(
+            summaries_ext.anx_datetime,
+            anx_datetime_range,
+        )
+
+        summaries_dict = self.collection.to_dict()["summaries"]
+
+        self.assertDictEqual(
+            summaries_dict["sat:anx_datetime"],
+            {
+                "minimum": datetime_to_str(anx_datetime_range.minimum),
+                "maximum": datetime_to_str(anx_datetime_range.maximum),
+            },
+        )