eotdl 2023.11.2.post5__py3-none-any.whl → 2023.11.3.post2__py3-none-any.whl

eotdl/curation/stac/extensions/label/base.py

@@ -1,26 +1,32 @@
-'''
+"""
 Module for the STAC label extension base object
-'''
+"""
+
+from typing import List, Union
 
 import pystac
+from pystac.extensions.label import (
+    LabelClasses,
+    LabelExtension,
+    SummariesLabelExtension,
+)
 
-from typing import List,  Union
 from ..base import STACExtensionObject
-from pystac.extensions.label import (LabelClasses, LabelExtension, SummariesLabelExtension)
 
 
 class LabelExtensionObject(STACExtensionObject):
+    """
+    STAC Label extension base object in EOTDL
+    """
     def __init__(self) -> None:
         super().__init__()
 
     @classmethod
-    def generate_stac_labels(
-        self
-    ) -> None:
+    def generate_stac_labels(cls) -> None:
         """
         Generate a labels collection from a STAC dataframe.
         """
-        pass
+        return
 
     def add_extension_to_item(
         self,
@@ -46,13 +52,14 @@ class LabelExtensionObject(STACExtensionObject):
 
         :return: the item with the label extension
         """
-        label_item = pystac.Item(id=obj.id,
-                                 geometry=obj.geometry,
-                                 bbox=obj.bbox,
-                                 properties=dict(),
-                                 datetime=obj.datetime
-                                 )
-        
+        label_item = pystac.Item(
+            id=obj.id,
+            geometry=obj.geometry,
+            bbox=obj.bbox,
+            properties={},
+            datetime=obj.datetime,
+        )
+
         # Add the label extension to the item
         LabelExtension.add_to(label_item)
 
@@ -72,22 +79,30 @@ class LabelExtensionObject(STACExtensionObject):
         # Add the label type
         label_ext.label_type = label_type
         # Add the label properties, if any
-        label_ext.label_properties = kwargs.get('label_properties') if kwargs.get('label_properties', None) else label_names
+        label_ext.label_properties = (
+            kwargs.get("label_properties")
+            if kwargs.get("label_properties", None)
+            else label_names
+        )
         # Add the label methods, if any
-        label_ext.label_methods = kwargs.get('label_methods') if kwargs.get('label_methods', None) else None
+        label_ext.label_methods = (
+            kwargs.get("label_methods") if kwargs.get("label_methods", None) else None
+        )
         # Add the label tasks, if any
-        label_ext.label_tasks = kwargs.get('label_tasks') if kwargs.get('label_tasks', None) else None
+        label_ext.label_tasks = (
+            kwargs.get("label_tasks") if kwargs.get("label_tasks", None) else None
+        )
         # Add the source
         label_ext.add_source(obj)
 
         return label_item
 
     def add_extension_to_collection(
-            self,
-            obj: pystac.Collection,
-            label_names: List[str],
-            label_classes: List[Union[list, tuple]],
-            label_type: str
+        self,
+        obj: pystac.Collection,
+        label_names: List[str],
+        label_classes: List[Union[list, tuple]],
+        label_type: str,
     ) -> None:
         """
         Add the label extension to the given collection
@@ -113,10 +128,9 @@ class LabelExtensionObject(STACExtensionObject):
         # Add the label type
         label_ext.label_type = label_type
 
-    def add_geojson_to_items(self
-                             ) -> None:
+    def add_geojson_to_items(self) -> None:
         """
         Add a GeoJSON FeatureCollection to every label item, as recommended by the spec
         https://github.com/stac-extensions/label#assets
         """
-        pass
+        return

eotdl/curation/stac/extensions/label/image_name_labeler.py

@@ -1,20 +1,24 @@
-'''
+"""
 Module for the STAC label extension ImageNameLabeler object
-'''
+"""
+
+import json
+from os.path import join, dirname
+from typing import List, Optional, Union
 
 import pystac
 import pandas as pd
-import json
 
 from tqdm import tqdm
-from os.path import join, dirname
-from typing import List, Optional, Union
+from pystac.extensions.label import LabelExtension
 from ...extent import get_unknow_extent
 from .base import LabelExtensionObject
-from pystac.extensions.label import LabelExtension
 
 
 class ImageNameLabeler(LabelExtensionObject):
+    """
+    STAC label extension ImageNameLabeler object in EOTDL
+    """
     def __init__(self) -> None:
         super().__init__()
 
@@ -22,16 +26,16 @@ class ImageNameLabeler(LabelExtensionObject):
         self,
         catalog: Union[pystac.Catalog, str],
         stac_dataframe: Optional[pd.DataFrame] = None,
-        collection: Optional[Union[pystac.Collection, str]] = 'source',
+        collection: Optional[Union[pystac.Collection, str]] = "source",
         label_description: Optional[str] = "Item label",
         label_type: Optional[str] = "vector",
         label_names: Optional[List[str]] = ["label"],
-        **kwargs
+        **kwargs,
     ) -> None:
         """
-        Generate a labels collection from a STAC dataframe. 
+        Generate a labels collection from a STAC dataframe.
         This class uses the label column of the dataframe as the label names.
-        
+
         :param catalog: catalog to add the labels collection to
         :param stac_dataframe: dataframe with the STAC metadata of a given directory containing the assets to generate metadata
         :param collection: collection to add the labels collection to
@@ -74,7 +78,7 @@ class ImageNameLabeler(LabelExtensionObject):
         print("Generating labels collection...")
         for source_item in tqdm(source_items):
             # There must be an item ID column in the STAC dataframe
-            if not 'id' in stac_dataframe.columns:
+            if "id" not in stac_dataframe.columns:
                 raise ValueError(
                     "No item ID column found in the STAC dataframe, please provide a STAC dataframe with the item ID column"
                 )
@@ -87,7 +91,7 @@ class ImageNameLabeler(LabelExtensionObject):
                 label_type=label_type,
                 label_names=[label_names],
                 label_classes=[label_classes],
-                **kwargs
+                **kwargs,
             )
             # Add the self href to the label item, following the Best Practices Layout
             # https://github.com/radiantearth/stac-spec/blob/master/best-practices.md
@@ -95,8 +99,8 @@ class ImageNameLabeler(LabelExtensionObject):
                 join(
                     dirname(collection.get_self_href()),
                     label_item.id,
-                    f"{label_item.id}.json"
-                    )
+                    f"{label_item.id}.json",
+                )
             )
             collection.add_item(label_item)
 
@@ -113,23 +117,23 @@ class ImageNameLabeler(LabelExtensionObject):
         # and then iterate over the items to add the geojson
         try:
             pystac.validation.validate(catalog)
-            catalog.normalize_and_save(dirname(catalog.get_self_href()), pystac.CatalogType.SELF_CONTAINED)
+            catalog.normalize_and_save(
+                dirname(catalog.get_self_href()), pystac.CatalogType.SELF_CONTAINED
+            )
         except pystac.STACValidationError as e:
             raise pystac.STACError(f"Catalog validation error: {e}")
-        
+
         # Add a GeoJSON FeatureCollection to every label item, as recommended by the spec
         # https://github.com/stac-extensions/label#assets
-        self.add_geojson_to_items(collection, 
-                                  stac_dataframe,
-                                  label_type=label_type)
-        catalog.normalize_and_save(dirname(catalog.get_self_href()), pystac.CatalogType.SELF_CONTAINED)
-        print('Success on labels generation!')
-
-    def add_geojson_to_items(self, 
-                             collection: pystac.Collection,
-                             df: pd.DataFrame,
-                             label_type: str
-                             ) -> None:
+        self.add_geojson_to_items(collection, stac_dataframe, label_type=label_type)
+        catalog.normalize_and_save(
+            dirname(catalog.get_self_href()), pystac.CatalogType.SELF_CONTAINED
+        )
+        print("Success on labels generation!")
+
+    def add_geojson_to_items(
+        self, collection: pystac.Collection, df: pd.DataFrame, label_type: str
+    ) -> None:
         """
         Add a GeoJSON FeatureCollection to every label item, as recommended by the spec
         https://github.com/stac-extensions/label#assets
@@ -139,33 +143,50 @@ class ImageNameLabeler(LabelExtensionObject):
         :param label_type: label type
         """
         for item in collection.get_all_items():
-            geojson_path = join(dirname(item.get_self_href()), f'{item.id}.geojson')
+            geojson_path = join(dirname(item.get_self_href()), f"{item.id}.geojson")
 
-            properties = {'roles': ['labels', f'labels-{label_type}']}
+            properties = {"roles": ["labels", f"labels-{label_type}"]}
 
             # TODO depending on the tasks, there must be extra fields
             # https://github.com/stac-extensions/label#assets
-            if 'label:tasks' in item.properties:
-                tasks = item.properties['label:tasks']
-                if 'tile_regression' in tasks:
+            if "label:tasks" in item.properties:
+                tasks = item.properties["label:tasks"]
+                if "tile_regression" in tasks:
                     pass
-                elif any(task in tasks for task in ('tile_classification', 'object_detection', 'segmentation')):
+                elif any(
+                    task in tasks
+                    for task in (
+                        "tile_classification",
+                        "object_detection",
+                        "segmentation",
+                    )
+                ):
                     pass
 
             label_ext = LabelExtension.ext(item)
-            label_ext.add_geojson_labels(href=geojson_path, 
-                                         title='Label', 
-                                         properties=properties)
+            label_ext.add_geojson_labels(
+                href=geojson_path, title="Label", properties=properties
+            )
             item.make_asset_hrefs_relative()
-            
+
             item_id = item.id
             geometry = item.geometry
-            labels = [df[df['id'] == item_id]['label'].values[0]]
+            labels = [df[df["id"] == item_id]["label"].values[0]]
             # There is data like DEM data that does not have datetime but start and end datetime
-            datetime = item.datetime.isoformat() if item.datetime else (item.properties.start_datetime.isoformat(),
-                                                                        item.properties.end_datetime.isoformat())
-            labels_properties = dict(zip(item.properties['label:properties'], labels)) if label_type == 'vector' else dict()
-            labels_properties['datetime'] = datetime
+            datetime = (
+                item.datetime.isoformat()
+                if item.datetime
+                else (
+                    item.properties.start_datetime.isoformat(),
+                    item.properties.end_datetime.isoformat(),
+                )
+            )
+            labels_properties = (
+                dict(zip(item.properties["label:properties"], labels))
+                if label_type == "vector"
+                else {}
+            )
+            labels_properties["datetime"] = datetime
 
             geojson = {
                 "type": "FeatureCollection",
@@ -178,5 +199,5 @@ class ImageNameLabeler(LabelExtensionObject):
                 ],
             }
 
-            with open(geojson_path, "w") as f:
+            with open(geojson_path, "w", encoding="utf-8") as f:
                 json.dump(geojson, f)

eotdl/curation/stac/extensions/label/scaneo.py

@@ -1,15 +1,15 @@
-'''
+"""
 Module for the STAC label extension ScaneoLabeler object
-'''
+"""
 
-import pystac
-import pandas as pd
 import json
-
-from glob import glob
-from tqdm import tqdm
 from os.path import join, dirname, exists, splitext, basename, abspath
 from typing import List, Optional, Union
+from glob import glob
+
+import pystac
+
+from tqdm import tqdm
 from pystac.extensions.label import LabelExtension
 
 from .base import LabelExtensionObject
@@ -17,6 +17,9 @@ from ...extent import get_unknow_extent
 
 
 class ScaneoLabeler(LabelExtensionObject):
+    """
+    STAC label extension ScaneoLabeler object in EOTDL
+    """
     def __init__(self) -> None:
         super().__init__()
 
@@ -24,17 +27,17 @@ class ScaneoLabeler(LabelExtensionObject):
         self,
         catalog: Union[pystac.Catalog, str],
         root_folder: str,
-        collection: Optional[Union[pystac.Collection, str]] = 'source',
+        collection: Optional[Union[pystac.Collection, str]] = "source",
         label_description: Optional[str] = "Item label",
         label_type: Optional[str] = "vector",
         label_names: Optional[List[str]] = ["label"],
-        **kwargs
+        **kwargs,
     ) -> None:
         """
-        Generate a labels collection from a STAC dataframe. 
+        Generate a labels collection from a STAC dataframe.
         This class should be used when the items have been labeled using SCANEO, as is implemented
         taking into account the SCANEO labeling format.
-        
+
         :param catalog: catalog to add the labels collection to
         :param root_folder: root folder where are the images and the labels as GeoJSON files, following the SCANEO labeling format
         :param stac_dataframe: dataframe with the STAC metadata of a given directory containing the assets to generate metadata
@@ -84,9 +87,9 @@ class ScaneoLabeler(LabelExtensionObject):
             # Get the GeoJSON label of the item
             geojson_label = self.get_geojson_of_item(source_item, geojson_files)
             # Get the tasks from the GeoJSON label
-            tasks = self.get_tasks_from_geojson(geojson_label)
+            tasks = self.get_tasks_from_geojson(geojson_label) if geojson_label else None
             # Add the tasks to the kwargs
-            kwargs['label_tasks'] = tasks
+            kwargs["label_tasks"] = tasks
 
             # Create the label item
             label_item = self.add_extension_to_item(
@@ -95,7 +98,7 @@ class ScaneoLabeler(LabelExtensionObject):
                 label_type=label_type,
                 label_names=label_names,
                 label_classes=label_classes,
-                **kwargs
+                **kwargs,
             )
             # Add the self href to the label item, following the Best Practices Layout
             # https://github.com/radiantearth/stac-spec/blob/master/best-practices.md
@@ -103,11 +106,12 @@ class ScaneoLabeler(LabelExtensionObject):
                 join(
                     dirname(collection.get_self_href()),
                     label_item.id,
-                    f"{label_item.id}.json"
-                    )
+                    f"{label_item.id}.json",
+                )
             )
-            # Match the GeoJSON label with the label item
-            self.add_geojson_to_item(label_item, geojson_label, label_type)
+            # Match the GeoJSON label with the label item, if exists
+            if geojson_label and exists(geojson_label):
+                self.add_geojson_to_item(label_item, geojson_label, label_type)
             # Add the item to the collection
             collection.add_item(label_item)
 
@@ -124,16 +128,16 @@ class ScaneoLabeler(LabelExtensionObject):
         # and then iterate over the items to add the geojson
         try:
             pystac.validation.validate(catalog)
-            catalog.normalize_and_save(dirname(catalog.get_self_href()), pystac.CatalogType.SELF_CONTAINED)
-            print('Success on labels generation!')
+            catalog.normalize_and_save(
+                dirname(catalog.get_self_href()), pystac.CatalogType.SELF_CONTAINED
+            )
+            print("Success on labels generation!")
         except pystac.STACValidationError as e:
             raise pystac.STACError(f"Catalog validation error: {e}")
 
-    def add_geojson_to_item(self, 
-                            item: pystac.Item,
-                            geojson_path: str,
-                            label_type: str
-                            ) -> None:
+    def add_geojson_to_item(
+        self, item: pystac.Item, geojson_path: str, label_type: str
+    ) -> None:
         """
         Add a GeoJSON FeatureCollection to every label item, as recommended by the spec
         https://github.com/stac-extensions/label#assets
@@ -142,43 +146,41 @@ class ScaneoLabeler(LabelExtensionObject):
         :param df: dataframe with the STAC metadata of a given directory containing the assets to generate metadata
         :param label_type: label type
         """
-        properties = {'roles': ['labels', f'labels-{label_type}']}
+        properties = {"roles": ["labels", f"labels-{label_type}"]}
 
         label_ext = LabelExtension.ext(item, add_if_missing=True)
         item.make_asset_hrefs_absolute()
-        label_ext.add_geojson_labels(href=abspath(geojson_path), 
-                                     title='Label', 
-                                     properties=properties)
+        label_ext.add_geojson_labels(
+            href=abspath(geojson_path), title="Label", properties=properties
+        )
         item.make_asset_hrefs_relative()
-        
-    def get_label_classes(self,
-                          root_folder: str,
-                          geojsons: List[str]
-                          ) -> List[str]:
+
+    def get_label_classes(self, root_folder: str, geojsons: List[str]) -> List[str]:
         """
         Get the label classes from the labels.json file if exists, or from the GeoJSON files instead
         """
-        label_classes = list()
+        label_classes = []
 
         labels_json = glob(join(root_folder, "labels.json"))[0]
         if exists(labels_json):
-            with open(labels_json, 'r') as f:
+            with open(labels_json, "r", encoding="utf-8") as f:
                 labels = json.load(f)
-            for value in labels['labels']:
-                label_classes.append(value['name']) if value['name'] not in label_classes else None
+            for value in labels["labels"]:
+                label_classes.append(value["name"]) if value[
+                    "name"
+                ] not in label_classes else None
         else:
             for geojson in geojsons:
-                with open(geojson, 'r') as f:
+                with open(geojson, "r", encoding="utf-8") as f:
                     labels = json.load(f)
-                for value in labels['features']:
-                    label_classes.append(value['properties']['labels']) if value['properties']['labels'] not in label_classes else None
+                for value in labels["features"]:
+                    label_classes.append(value["properties"]["labels"]) if value[
+                        "properties"
+                    ]["labels"] not in label_classes else None
 
         return [label_classes]
 
-    def get_geojson_of_item(self,
-                            item: pystac.Item,
-                            geojsons: List[str]
-                            ) -> str:
+    def get_geojson_of_item(self, item: pystac.Item, geojsons: List[str]) -> str:
         """
         Get the GeoJSON label of the item from a list of GeoJSON files
 
@@ -188,16 +190,17 @@ class ScaneoLabeler(LabelExtensionObject):
         :return: path to the GeoJSON label of the item
         """
         item_id = item.id
+        geojson_name = f"{item_id}_labels"
         # Get a dict with <geojson_filename>: <geojson_path>, as the geojson_filename
         # must match the item ID
-        geojsons_dict = dict(zip([splitext(basename(geojson))[0] for geojson in geojsons], geojsons))
-        geojson_path = geojsons_dict.get(item_id)
-        
+        geojsons_dict = dict(
+            zip([splitext(basename(geojson))[0] for geojson in geojsons], geojsons)
+        )
+        geojson_path = geojsons_dict.get(geojson_name)
+
         return geojson_path
 
-    def get_tasks_from_geojson(self, 
-                               geojson_path: str
-                               ) -> List[str]:
+    def get_tasks_from_geojson(self, geojson_path: str) -> List[str]:
         """
         Get the tasks from the GeoJSON label
 
@@ -205,11 +208,11 @@ class ScaneoLabeler(LabelExtensionObject):
 
         :return: list of tasks
         """
-        with open(geojson_path, 'r') as f:
+        with open(geojson_path, "r", encoding="utf-8") as f:
             geojson = json.load(f)
-            tasks = list()
-            for feature in geojson['features']:
-                for task in feature['properties']['tasks']:
+            tasks = []
+            for feature in geojson["features"]:
+                for task in feature["properties"]["tasks"]:
                     tasks.append(task) if task not in tasks else None
-        
+
         return tasks