def add_child(
self,
child: Union["Catalog", "Collection_Type"],
title: Optional[str] = None,
strategy: Optional[HrefLayoutStrategy] = None,
) -> None:
"""Adds a link to a child :class:`~pystac.Catalog` or
:class:`~pystac.Collection`. This method will set the child's parent to this
object, and its root to this Catalog's root.
Args:
child : The child to add.
title : Optional title to give to the :class:`~pystac.Link`
strategy : The layout strategy to use for setting the
self href of the child.
"""
# Prevent typo confusion
if isinstance(child, pystac.Item):
raise pystac.STACError("Cannot add item as child. Use add_item instead.")
if strategy is None:
strategy = BestPracticesLayoutStrategy()
child.set_root(self.get_root())
child.set_parent(self)
# set self link
self_href = self.get_self_href()
if self_href:
child_href = strategy.get_href(child, os.path.dirname(self_href))
child.set_self_href(child_href)
self.add_link(Link.child(child, title=title))
def add_item(
self,
item: "Item_Type",
title: Optional[str] = None,
strategy: Optional[HrefLayoutStrategy] = None,
) -> None:
"""Adds a link to an :class:`~pystac.Item`.
This method will set the item's parent to this object, and its root to
this Catalog's root.
Args:
item : The item to add.
title : Optional title to give to the :class:`~pystac.Link`
"""
# Prevent typo confusion
if isinstance(item, pystac.Catalog):
raise pystac.STACError("Cannot add catalog as item. Use add_child instead.")
if strategy is None:
strategy = BestPracticesLayoutStrategy()
item.set_root(self.get_root())
item.set_parent(self)
# set self link
self_href = self.get_self_href()
if self_href:
item_href = strategy.get_href(item, os.path.dirname(self_href))
item.set_self_href(item_href)
self.add_link(Link.item(item, title=title))
def counts(self, v: Optional[List[LabelCount]]) -> None:
if v is None:
self.properties.pop("counts", None)
else:
if not isinstance(v, list):
raise pystac.STACError(
"counts must be a list! Invalid input: {}".format(v))
self.properties["counts"] = [c.to_dict() for c in v]
def label_classes(self, v: Optional[List[LabelClasses]]) -> None:
if v is None:
self.obj.properties.pop(CLASSES_PROP, None)
else:
if not isinstance(v, list):
raise pystac.STACError(
"label_classes must be a list! Invalid input: {}".format(
v))
classes = [x.to_dict() for x in v]
self.obj.properties[CLASSES_PROP] = classes
def get_href(self, stac_object, parent_dir, is_root=False):
stac_object_type = stac_object.STAC_OBJECT_TYPE
if stac_object_type == pystac.STACObjectType.CATALOG:
return self.get_catalog_href(stac_object, parent_dir, is_root)
elif stac_object_type == pystac.STACObjectType.COLLECTION:
return self.get_collection_href(stac_object, parent_dir, is_root)
elif stac_object_type == pystac.STACObjectType.ITEM:
return self.get_item_href(stac_object, parent_dir)
else:
raise pystac.STACError(
'Unknown STAC object type {}'.format(stac_object_type))
def get_href(self,
stac_object: "STACObject_Type",
parent_dir: str,
is_root: bool = False) -> str:
if isinstance(stac_object, pystac.Item):
return self.get_item_href(stac_object, parent_dir)
elif isinstance(stac_object, pystac.Collection):
return self.get_collection_href(stac_object, parent_dir, is_root)
elif isinstance(stac_object, pystac.Catalog):
return self.get_catalog_href(stac_object, parent_dir, is_root)
else:
raise pystac.STACError(
"Unknown STAC object type {}".format(stac_object))
def _set_field(self, prop_name: str, v: Optional[Any]) -> None:
if hasattr(self.object, prop_name):
setattr(self.object, prop_name, v)
elif hasattr(self.object, "properties"):
item = cast("Item_Type", self.object)
if v is None:
item.properties.pop(prop_name, None)
else:
item.properties[prop_name] = v
elif hasattr(self.object, "extra_fields") and isinstance(
self.object.extra_fields, Dict):
if v is None:
self.object.extra_fields.pop(prop_name, None)
else:
self.object.extra_fields[prop_name] = v
else:
raise pystac.STACError(f"Cannot set field {prop_name} on {self}.")
def apply(self, published=None, expires=None, unpublished=None):
"""Applies timestamps extension properties to the extended Item.
Args:
published (datetime or None): Date and time the corresponding data
was published the first time.
expires (datetime or None): Date and time the corresponding data
expires (is not valid any longer).
unpublished (datetime or None): Date and time the corresponding data
was unpublished.
"""
if published is None and expires is None and unpublished is None:
raise pystac.STACError(
"timestamps extension needs at least one property value.")
self.published = published
self.expires = expires
self.unpublished = unpublished
def validate_owner_has_extension(cls, asset: pystac.Asset,
add_if_missing: bool) -> None:
"""Given an :class:`~pystac.Asset`, checks if the asset's owner has this
extension's schema URI in its :attr:`~pystac.STACObject.stac_extensions` list.
If ``add_if_missing`` is ``True``, the schema URI will be added to the owner.
Raises:
STACError : If ``add_if_missing`` is ``True`` and ``asset.owner`` is
``None``.
"""
if asset.owner is None:
if add_if_missing:
raise pystac.STACError(
"Attempted to use add_if_missing=True for an Asset with no owner. "
"Use Asset.set_owner or set add_if_missing=False.")
else:
return
return cls.validate_has_extension(cast(S, asset.owner), add_if_missing)
def resolve_stac_object(self,
root: Optional["Catalog_Type"] = None) -> "Link":
"""Resolves a STAC object from the HREF of this link, if the link is not
already resolved.
Args:
root : Optional root of the catalog for this link.
If provided, the root's resolved object cache is used to search for
previously resolved instances of the STAC object.
"""
if self._target_object:
pass
elif self._target_href:
target_href = self._target_href
# If it's a relative link, base it off the parent.
if not is_absolute_href(target_href):
if self.owner is None:
raise pystac.STACError(
"Relative path {} encountered "
"without owner or start_href.".format(target_href))
start_href = self.owner.get_self_href()
if start_href is None:
raise pystac.STACError(
"Relative path {} encountered "
'without owner "self" link set.'.format(target_href))
target_href = make_absolute_href(target_href, start_href)
obj = None
stac_io: Optional[pystac.StacIO] = None
if root is not None:
obj = root._resolved_objects.get_by_href(target_href)
stac_io = root._stac_io
if obj is None:
if stac_io is None:
if self.owner is not None:
if isinstance(self.owner, pystac.Catalog):
stac_io = self.owner._stac_io
elif self.rel != pystac.RelType.ROOT:
owner_root = self.owner.get_root()
if owner_root is not None:
stac_io = owner_root._stac_io
if stac_io is None:
stac_io = pystac.StacIO.default()
obj = stac_io.read_stac_object(target_href, root=root)
obj.set_self_href(target_href)
if root is not None:
obj = root._resolved_objects.get_or_cache(obj)
obj.set_root(root)
self._target_object = obj
else:
raise ValueError("Cannot resolve STAC object without a target")
if (self.owner
and self.rel in [pystac.RelType.CHILD, pystac.RelType.ITEM]
and isinstance(self.owner, pystac.Catalog)):
assert self._target_object
self._target_object.set_parent(self.owner)
return self
def size(self, v: int) -> None:
if not isinstance(v, int):
raise pystac.STACError(
"size must be an int! Invalid input: {}".format(v))
self.properties["size"] = v
def polarizations(self, values: List[Polarization]) -> None:
if not isinstance(values, list):
raise pystac.STACError(
f'polarizations must be a list. Invalid "{values}"')
self.item.properties[POLARIZATIONS] = [v.value for v in values]
def polarizations(self, values: List[Polarization]) -> None:
if not isinstance(values, list):
raise pystac.STACError(
f'polarizations must be a list. Invalid "{values}"')
self._set_property(POLARIZATIONS_PROP, [v.value for v in values],
pop_if_none=False)
