Add missing Sat Extension fields

Author: duckontheweb

pystac/extensions/sat.py

@@ -4,6 +4,7 @@
 """
 
 import enum
+from datetime import datetime as Datetime
 from typing import Dict, Any, Generic, Iterable, Optional, Set, TypeVar, cast
 
 import pystac
@@ -12,15 +13,20 @@
     PropertiesExtension,
 )
 from pystac.extensions.hooks import ExtensionHooks
-from pystac.utils import map_opt
+from pystac.utils import str_to_datetime, datetime_to_str, map_opt
 
 T = TypeVar("T", pystac.Item, pystac.Asset)
 
 SCHEMA_URI = "https://stac-extensions.github.io/sat/v1.0.0/schema.json"
 
 PREFIX: str = "sat:"
-ORBIT_STATE: str = PREFIX + "orbit_state"
-RELATIVE_ORBIT: str = PREFIX + "relative_orbit"
+PLATFORM_INTERNATIONAL_DESIGNATOR_PROP: str = (
+    PREFIX + "platform_international_designator"
+)
+ABSOLUTE_ORBIT_PROP: str = PREFIX + "absolute_orbit"
+ORBIT_STATE_PROP: str = PREFIX + "orbit_state"
+RELATIVE_ORBIT_PROP: str = PREFIX + "relative_orbit"
+ANX_DATETIME_PROP: str = PREFIX + "anx_datetime"
 
 
 class OrbitState(str, enum.Enum):
@@ -51,6 +57,9 @@ def apply(
         self,
         orbit_state: Optional[OrbitState] = None,
         relative_orbit: Optional[int] = None,
+        absolute_orbit: Optional[int] = None,
+        platform_international_designator: Optional[str] = None,
+        anx_datetime: Optional[Datetime] = None,
     ) -> None:
         """Applies ext extension properties to the extended :class:`~pystac.Item` or
         class:`~pystac.Asset`.
@@ -66,26 +75,58 @@ def apply(
                 the time of acquisition.
         """
 
+        self.platform_international_designator = platform_international_designator
         self.orbit_state = orbit_state
+        self.absolute_orbit = absolute_orbit
         self.relative_orbit = relative_orbit
+        self.anx_datetime = anx_datetime
+
+    @property
+    def platform_international_designator(self) -> Optional[str]:
+        """Gets or sets the International Designator, also known as COSPAR ID, and
+        NSSDCA ID."""
+        return self._get_property(PLATFORM_INTERNATIONAL_DESIGNATOR_PROP, str)
+
+    @platform_international_designator.setter
+    def platform_international_designator(self, v: Optional[str]) -> None:
+        self._set_property(PLATFORM_INTERNATIONAL_DESIGNATOR_PROP, v)
 
     @property
     def orbit_state(self) -> Optional[OrbitState]:
         """Get or sets an orbit state of the object."""
-        return map_opt(lambda x: OrbitState(x), self._get_property(ORBIT_STATE, str))
+        return map_opt(
+            lambda x: OrbitState(x), self._get_property(ORBIT_STATE_PROP, str)
+        )
 
     @orbit_state.setter
     def orbit_state(self, v: Optional[OrbitState]) -> None:
-        self._set_property(ORBIT_STATE, map_opt(lambda x: x.value, v))
+        self._set_property(ORBIT_STATE_PROP, map_opt(lambda x: x.value, v))
+
+    @property
+    def absolute_orbit(self) -> Optional[int]:
+        """Get or sets a absolute orbit number of the item."""
+        return self._get_property(ABSOLUTE_ORBIT_PROP, int)
+
+    @absolute_orbit.setter
+    def absolute_orbit(self, v: Optional[int]) -> None:
+        self._set_property(ABSOLUTE_ORBIT_PROP, v)
 
     @property
     def relative_orbit(self) -> Optional[int]:
         """Get or sets a relative orbit number of the item."""
-        return self._get_property(RELATIVE_ORBIT, int)
+        return self._get_property(RELATIVE_ORBIT_PROP, int)
 
     @relative_orbit.setter
     def relative_orbit(self, v: Optional[int]) -> None:
-        self._set_property(RELATIVE_ORBIT, v)
+        self._set_property(RELATIVE_ORBIT_PROP, v)
+
+    @property
+    def anx_datetime(self) -> Optional[Datetime]:
+        return map_opt(str_to_datetime, self._get_property(ANX_DATETIME_PROP, str))
+
+    @anx_datetime.setter
+    def anx_datetime(self, v: Optional[Datetime]) -> None:
+        self._set_property(ANX_DATETIME_PROP, map_opt(datetime_to_str, v))
 
     @classmethod
     def get_schema_uri(cls) -> str:

tests/extensions/test_sat.py

@@ -5,6 +5,7 @@
 import unittest
 
 import pystac
+from pystac.utils import str_to_datetime
 from pystac import ExtensionTypeError
 from pystac.extensions import sat
 from pystac.extensions.sat import SatExtension
@@ -32,6 +33,21 @@ def setUp(self) -> None:
     def test_stac_extensions(self) -> None:
         self.assertTrue(SatExtension.has_extension(self.item))
 
+    def test_item_repr(self) -> None:
+        sat_item_ext = SatExtension.ext(self.item)
+        self.assertEqual(
+            f"<ItemSatExtension Item id={self.item.id}>", sat_item_ext.__repr__()
+        )
+
+    def test_asset_repr(self) -> None:
+        item = pystac.Item.from_file(self.sentinel_example_uri)
+        asset = item.assets["measurement_iw1_vh"]
+        sat_asset_ext = SatExtension.ext(asset)
+
+        self.assertEqual(
+            f"<AssetSatExtension Asset href={asset.href}>", sat_asset_ext.__repr__()
+        )
+
     def test_no_args_fails(self) -> None:
         SatExtension.ext(self.item).apply()
         with self.assertRaises(pystac.STACValidationError):
@@ -41,16 +57,45 @@ def test_orbit_state(self) -> None:
         orbit_state = sat.OrbitState.ASCENDING
         SatExtension.ext(self.item).apply(orbit_state)
         self.assertEqual(orbit_state, SatExtension.ext(self.item).orbit_state)
-        self.assertNotIn(sat.RELATIVE_ORBIT, self.item.properties)
-        self.assertFalse(SatExtension.ext(self.item).relative_orbit)
+        self.assertNotIn(sat.RELATIVE_ORBIT_PROP, self.item.properties)
+        self.assertIsNone(SatExtension.ext(self.item).relative_orbit)
         self.item.validate()
 
     def test_relative_orbit(self) -> None:
         relative_orbit = 1234
         SatExtension.ext(self.item).apply(None, relative_orbit)
         self.assertEqual(relative_orbit, SatExtension.ext(self.item).relative_orbit)
-        self.assertNotIn(sat.ORBIT_STATE, self.item.properties)
-        self.assertFalse(SatExtension.ext(self.item).orbit_state)
+        self.assertNotIn(sat.ORBIT_STATE_PROP, self.item.properties)
+        self.assertIsNone(SatExtension.ext(self.item).orbit_state)
+        self.item.validate()
+
+    def test_absolute_orbit(self) -> None:
+        absolute_orbit = 1234
+        SatExtension.ext(self.item).apply(absolute_orbit=absolute_orbit)
+        self.assertEqual(absolute_orbit, SatExtension.ext(self.item).absolute_orbit)
+        self.assertNotIn(sat.RELATIVE_ORBIT_PROP, self.item.properties)
+        self.assertIsNone(SatExtension.ext(self.item).relative_orbit)
+        self.item.validate()
+
+    def test_anx_datetime(self) -> None:
+        anx_datetime = str_to_datetime("2020-01-01T00:00:00Z")
+        SatExtension.ext(self.item).apply(anx_datetime=anx_datetime)
+        self.assertEqual(anx_datetime, SatExtension.ext(self.item).anx_datetime)
+        self.assertNotIn(sat.RELATIVE_ORBIT_PROP, self.item.properties)
+        self.assertIsNone(SatExtension.ext(self.item).relative_orbit)
+        self.item.validate()
+
+    def test_platform_international_designator(self) -> None:
+        platform_international_designator = "2018-080A"
+        SatExtension.ext(self.item).apply(
+            platform_international_designator=platform_international_designator
+        )
+        self.assertEqual(
+            platform_international_designator,
+            SatExtension.ext(self.item).platform_international_designator,
+        )
+        self.assertNotIn(sat.ORBIT_STATE_PROP, self.item.properties)
+        self.assertIsNone(SatExtension.ext(self.item).orbit_state)
         self.item.validate()
 
     def test_relative_orbit_no_negative(self) -> None:
@@ -104,8 +149,8 @@ def test_to_from_dict(self) -> None:
         relative_orbit = 1002
         SatExtension.ext(self.item).apply(orbit_state, relative_orbit)
         d = self.item.to_dict()
-        self.assertEqual(orbit_state.value, d["properties"][sat.ORBIT_STATE])
-        self.assertEqual(relative_orbit, d["properties"][sat.RELATIVE_ORBIT])
+        self.assertEqual(orbit_state.value, d["properties"][sat.ORBIT_STATE_PROP])
+        self.assertEqual(relative_orbit, d["properties"][sat.RELATIVE_ORBIT_PROP])
 
         item = pystac.Item.from_dict(d)
         self.assertEqual(orbit_state, SatExtension.ext(item).orbit_state)