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

eotdl/access/sentinelhub/utils.py

@@ -15,35 +15,44 @@ from ...tools.geo_utils import is_bounding_box, get_image_bbox
 from ...tools.time_utils import is_time_interval, get_day_between
 
 
-def evaluate_sentinel_parameters(sensor: str,
-                                 time_interval: Union[str, datetime],
-                                 bounding_box: list,
-                                 output: Optional[str] = None,
-                                 output_needed: Optional[bool] = True
-                                 ) -> None:
+def evaluate_sentinel_parameters(
+    sensor: str,
+    time_interval: Union[str, datetime],
+    bounding_box: list,
+    output: Optional[str] = None,
+    output_needed: Optional[bool] = True,
+) -> None:
     """
+    Evaluate parameters for Sentinel Hub access
     """
     if output_needed:
         if not output:
             raise ValueError("Output path must be specified.")
     if sensor not in SUPPORTED_SENSORS:
-        raise ValueError(f"Sensor {sensor} is not supported. Supported sensors are: {SUPPORTED_SENSORS}")
+        raise ValueError(
+            f"Sensor {sensor} is not supported. Supported sensors are: {SUPPORTED_SENSORS}"
+        )
     if not time_interval:
         raise ValueError("Time interval must be specified.")
     else:
         if len(time_interval) == 2 and not is_time_interval(time_interval):
-            raise ValueError(f"Time interval must be a list or tuple with two elements in format YYYY-MM-DD.")
+            raise ValueError(
+                "Time interval must be a list or tuple with two elements in format YYYY-MM-DD."
+            )
     if not bounding_box:
         raise ValueError("Bounding box must be specified.")
     else:
         if not is_bounding_box(bounding_box):
-            raise ValueError(f"Bounding box must be a list or tuple with four elements in format (lon_min, lat_min, lon_max, lat_max).")
+            raise ValueError(
+                "Bounding box must be a list or tuple with four elements in format (lon_min, lat_min, lon_max, lat_max)."
+            )
 
 
-def imagery_from_tmp_to_dir(output_dir: str,
-                            tmp_dir: Optional[str] = '/tmp/sentinelhub'
-                            ) -> None:
+def imagery_from_tmp_to_dir(
+    output_dir: str, tmp_dir: Optional[str] = "/tmp/sentinelhub"
+) -> None:
     """
+    Copy imagery from tmp to output dir
     """
     downloaded_files = glob(f"{tmp_dir}/**/response.tiff")
     assert len(downloaded_files) > 0, "No files downloaded"
@@ -51,36 +60,37 @@ def imagery_from_tmp_to_dir(output_dir: str,
     makedirs(output_dir, exist_ok=True)
 
     for downloaded_file in downloaded_files:
-        request_json = downloaded_file.replace('response.tiff', 'request.json')
+        request_json = downloaded_file.replace("response.tiff", "request.json")
         metadata = generate_raster_metadata(downloaded_file, request_json)
-        if metadata['acquisition-date']:
+        if metadata["acquisition-date"]:
             output_filename = f"{metadata['type']}_{metadata['acquisition-date']}"
         else:
-            output_filename = metadata['type']
+            output_filename = metadata["type"]
 
         copyfile(downloaded_file, f"{output_dir}/{output_filename}.tif")
-        json.dump(metadata, open(f"{output_dir}/{output_filename}.json", "w"))
-    
+        with open(f"{output_dir}/{output_filename}.json", "w", encoding="utf-8") as f:
+            json.dump(metadata, f)
+
     rmtree(tmp_dir)
 
 
-def generate_raster_metadata(raster: str,
-                             request_json: str
-                             ) -> None:
+def generate_raster_metadata(raster: str, request_json: str) -> None:
     """
+    Generate metadata for raster
     """
     bbox = get_image_bbox(raster)
-    json_content = json.load(open(request_json))
+    with open(request_json, "r", encoding="utf-8") as f:
+        json_content = json.load(f)
 
-    payload_data = json_content['request']['payload']['input']['data'][0]
-    sensor_type = payload_data['type']
+    payload_data = json_content["request"]["payload"]["input"]["data"][0]
+    sensor_type = payload_data["type"]
     # Get day between from and to
-    if 'timeRange' in payload_data['dataFilter'] and sensor_type != 'dem':
-        time_range = payload_data['dataFilter']['timeRange']
-        acquisition_date = get_day_between(time_range['from'], time_range['to'])
-    else:   # DEM data does not have a timeRange
+    if "timeRange" in payload_data["dataFilter"] and sensor_type != "dem":
+        time_range = payload_data["dataFilter"]["timeRange"]
+        acquisition_date = get_day_between(time_range["from"], time_range["to"])
+    else:  # DEM data does not have a timeRange
         acquisition_date = None
-    
+
     metadata = {
         "acquisition-date": acquisition_date,
         "bounding-box": bbox,

eotdl/auth/errors.py

@@ -3,7 +3,8 @@ class LoginError(Exception):
         self.message = message
         super().__init__(self.message)
 
+
 class AuthTimeOut(Exception):
     def __init__(self, message='Authentication timed out'):
         self.message = message
-        super().__init__(self.message)
+        super().__init__(self.message)

eotdl/commands/auth.py

@@ -37,14 +37,14 @@ def logout():
     user = is_logged()
     if user:
         typer.echo(f"You are logged in as {user['email']}")
-        typer.confirm(f"Are you sure you want to logout?", abort=True)
+        typer.confirm("Are you sure you want to logout?", abort=True)
         logout_url = logout_user()
-        typer.echo(f"You are logged out.")
+        typer.echo("You are logged out.")
         typer.echo(
             f"If you want to login with a different account, visit {logout_url} and login again."
         )
     else:
-        typer.echo(f"You are not logged in.")
+        typer.echo("You are not logged in.")
 
 
 if __name__ == "__main__":

eotdl/curation/__init__.py

@@ -1,4 +1,8 @@
+"""
+Curation module
+"""
+
 from .stac.dataframe import STACDataFrame  # , read_stac
 from .stac.stac import STACGenerator
 from .stac.parsers import STACIdParser, StructuredParser, UnestructuredParser
-from .stac.dataframe_labeling import UnlabeledStrategy, LabeledStrategy
+from .stac.dataframe_labeling import UnlabeledStrategy, LabeledStrategy

eotdl/curation/stac/__init__.py

@@ -1,4 +1,8 @@
+"""
+STAC module
+"""
+
 # from .stac import STACGenerator
 # from .utils import format_time_acquired
 # from .parsers import STACIdParser, StructuredParser, UnestructuredParser
-from .dataframe import STACDataFrame, read_stac
+from .dataframe import STACDataFrame, read_stac

eotdl/curation/stac/assets.py

@@ -1,35 +1,38 @@
-'''
+"""
 Module for STAC Asset Generators
-'''
+"""
 
 from os import remove, listdir
 from os.path import dirname, join, basename, abspath
-from ...tools.metadata import remove_raster_metadata
-from typing import List
 
 import pandas as pd
 import rasterio
 import pystac
 
+from ...tools.metadata import remove_raster_metadata
+
 
 MEDIA_TYPES_DICT = {
-    'tif': pystac.MediaType.GEOTIFF,
-    'tiff': pystac.MediaType.GEOTIFF,
-    'png': pystac.MediaType.PNG,
-    'jpg': pystac.MediaType.JPEG,
-    'jpeg': pystac.MediaType.JPEG,
+    "tif": pystac.MediaType.GEOTIFF,
+    "tiff": pystac.MediaType.GEOTIFF,
+    "png": pystac.MediaType.PNG,
+    "jpg": pystac.MediaType.JPEG,
+    "jpeg": pystac.MediaType.JPEG,
 }
 
 
 class STACAssetGenerator:
+    """
+    Standard STAC Asset Generator
+    """
+
+    type = "None"
 
-    type = 'None'
-    
     def __init__(self):
         pass
 
     @classmethod
-    def extract_assets(self, obj_info: pd.DataFrame):
+    def extract_assets(cls, obj_info: pd.DataFrame):
         """
         Generate a single asset from the raster file
 
@@ -37,24 +40,29 @@ class STACAssetGenerator:
         """
         # If there is no bands, create a single band asset from the file, assuming thats a singleband raster
         raster_path = obj_info["image"].values[0]
-        title = basename(raster_path).split('.')[0]
+        title = basename(raster_path).split(".")[0]
         # Get the file extension
-        raster_format = raster_path.split('.')[-1]
-        asset = pystac.Asset(href=abspath(raster_path), 
-                             title=title, 
-                             media_type=MEDIA_TYPES_DICT[raster_format], 
-                             roles=['data'])
+        raster_format = raster_path.split(".")[-1]
+        asset = pystac.Asset(
+            href=abspath(raster_path),
+            title=title,
+            media_type=MEDIA_TYPES_DICT[raster_format],
+            roles=["data"],
+        )
 
         return [asset]
 
 
 class BandsAssetGenerator(STACAssetGenerator):
+    """
+    Bands STAC Asset Generator
+    """
 
-    type = 'Bands'
+    type = "Bands"
 
     def __init__(self) -> None:
         super().__init__()
-    
+
     def extract_assets(self, obj_info: pd.DataFrame):
         """
         Extract the assets from the raster file from the bands column
@@ -69,17 +77,19 @@ class BandsAssetGenerator(STACAssetGenerator):
         bands = bands[0] if bands else None
 
         if bands:
-            with rasterio.open(raster_path, 'r') as raster:
+            with rasterio.open(raster_path, "r") as raster:
                 if isinstance(bands, str):
                     bands = [bands]
                 for band in bands:
                     i = bands.index(band)
-                    raster_format = raster_path.split('.')[-1]   # Will be used later to save the bands files
+                    raster_format = raster_path.split(".")[
+                        -1
+                    ]  # Will be used later to save the bands files
                     try:
                         single_band = raster.read(i + 1)
                     except IndexError:
                         single_band = raster.read(1)
-                    band_name = f'{band}.{raster_format}'
+                    band_name = f"{band}.{raster_format}"
                     output_band = join(dirname(raster_path), band_name)
                     # Copy the metadata
                     metadata = raster.meta.copy()
@@ -88,9 +98,13 @@ class BandsAssetGenerator(STACAssetGenerator):
                     with rasterio.open(output_band, "w", **metadata) as dest:
                         dest.write(single_band, 1)
                     # Instantiate pystac asset and append it to the list
-                    asset_list.append(pystac.Asset(href=output_band, 
-                                                   title=band, 
-                                                   media_type=MEDIA_TYPES_DICT[raster_format]))
+                    asset_list.append(
+                        pystac.Asset(
+                            href=output_band,
+                            title=band,
+                            media_type=MEDIA_TYPES_DICT[raster_format],
+                        )
+                    )
 
             # Remove the original raster file and its metadata
             remove(raster_path)
@@ -100,8 +114,11 @@ class BandsAssetGenerator(STACAssetGenerator):
 
 
 class ExtractedAssets(STACAssetGenerator):
+    """
+    Extracted STAC Asset Generator
+    """
 
-    type = 'Extracted'
+    type = "Extracted"
 
     def __init__(self) -> None:
         super().__init__()
@@ -115,13 +132,19 @@ class ExtractedAssets(STACAssetGenerator):
         raster_path = obj_info["image"].values[0]
         raster_dir = dirname(raster_path)
         # Get the files with the same extension as the image file
-        files = [f for f in listdir(raster_dir) if f.endswith(raster_path.split('.')[-1])]
+        files = [
+            f for f in listdir(raster_dir) if f.endswith(raster_path.split(".")[-1])
+        ]
         # Instantiate pystac asset and append it to the list
         for file in files:
             # Get the file extension
-            raster_format = file.split('.')[-1]
-            asset_list.append(pystac.Asset(href=join(raster_dir, file), 
-                                           title=basename(file), 
-                                           media_type=MEDIA_TYPES_DICT[raster_format]))
+            raster_format = file.split(".")[-1]
+            asset_list.append(
+                pystac.Asset(
+                    href=join(raster_dir, file),
+                    title=basename(file),
+                    media_type=MEDIA_TYPES_DICT[raster_format],
+                )
+            )
 
         return asset_list

eotdl/curation/stac/dataframe.py

@@ -2,26 +2,31 @@
 Module for the STAC dataframe
 """
 
-import pandas as pd
-import geopandas as gpd
-import pystac
 import json
-from geomet import wkt
+
 from os.path import join
 from os import makedirs
 from typing import Union, Optional
-
 from math import isnan
-from ...tools import convert_df_geom_to_shape, get_all_children
 from pathlib import Path
 
+import pandas as pd
+import geopandas as gpd
+import pystac
+from geomet import wkt
+
+from ...tools import convert_df_geom_to_shape, get_all_children
+
 
 class STACDataFrame(gpd.GeoDataFrame):
+    """
+    STACDataFrame class
+    """
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
 
     @classmethod
-    def from_stac_file(self, stac_file: pystac.STACObject):
+    def from_stac_file(cls, stac_file: pystac.STACObject):
         """
         Create a STACDataFrame from a STAC file
 
@@ -56,11 +61,11 @@ class STACDataFrame(gpd.GeoDataFrame):
                 # Curate the json row
                 row_json = self.curate_json_row(row_json, stac_id_exists)
 
-                with open(join(root_output_folder, f"catalog.json"), "w") as f:
+                with open(join(root_output_folder, "catalog.json"), "w", encoding="utf-8") as f:
                     json.dump(row_json, f)
 
         # Second, create the collections and their folders, if exist
-        collections = dict()
+        collections = {}
         collections_df = df[df["type"] == "Collection"]
         for _, row in collections_df.iterrows():
             stac_output_folder = join(root_output_folder, row[id_column])
@@ -71,7 +76,7 @@ class STACDataFrame(gpd.GeoDataFrame):
             # Curate the json row
             row_json = self.curate_json_row(row_json, stac_id_exists)
 
-            with open(join(stac_output_folder, f"collection.json"), "w") as f:
+            with open(join(stac_output_folder, "collection.json"), "w", encoding="utf-8") as f:
                 json.dump(row_json, f)
 
         # Then, create the items and their folders, if exist
@@ -89,7 +94,7 @@ class STACDataFrame(gpd.GeoDataFrame):
             # Curate the json row
             row_json = self.curate_json_row(row_json, stac_id_exists)
 
-            with open(join(stac_output_folder, f'{row_json["id"]}.json'), "w") as f:
+            with open(join(stac_output_folder, f'{row_json["id"]}.json'), "w", encoding="utf-8") as f:
                 json.dump(row_json, f)
 
     def curate_json_row(self, row: dict, stac_id_exists: bool) -> dict:
@@ -99,7 +104,7 @@ class STACDataFrame(gpd.GeoDataFrame):
         :param row: row of a STACDataFrame
         :param stac_id_exists: if the stac_id column exists
         """
-        keys_to_remove = list()
+        keys_to_remove = []
 
         # Remove the created_at and modified_at columns, if the STACDataFrame comes from GeoDB
         for i in "created_at", "modified_at":
@@ -130,6 +135,7 @@ class STACDataFrame(gpd.GeoDataFrame):
 
         return row
 
+
 def read_stac(
     stac_file: Union[pystac.Catalog, pystac.Collection, str],
     geometry_column: Optional[str] = "geometry",
@@ -140,8 +146,8 @@ def read_stac(
     :param stac_file: STAC file to read
     :param geometry_column: name of the geometry column
     """
-    if isinstance(stac_file, str) or isinstance(stac_file, Path):
-        stac_file = pystac.read_file(stac_file) # we assume this is always a catalog
+    if isinstance(stac_file, (str, Path)):
+        stac_file = pystac.read_file(stac_file)  # we assume this is always a catalog
     stac_file.make_all_asset_hrefs_absolute()
     children = get_all_children(stac_file)
 

eotdl/curation/stac/dataframe_bck.py

@@ -161,7 +161,7 @@ class STACDataFrame(gpd.GeoDataFrame):
                 # Curate the json row
                 row_json = self.curate_json_row(row_json, stac_id_exists)
 
-                with open(join(root_output_folder, f"catalog.json"), "w") as f:
+                with open(join(root_output_folder, "catalog.json"), "w") as f:
                     json.dump(row_json, f)
 
         # Second, create the collections and their folders, if exist
@@ -176,7 +176,7 @@ class STACDataFrame(gpd.GeoDataFrame):
             # Curate the json row
             row_json = self.curate_json_row(row_json, stac_id_exists)
 
-            with open(join(stac_output_folder, f"collection.json"), "w") as f:
+            with open(join(stac_output_folder, "collection.json"), "w") as f:
                 json.dump(row_json, f)
 
         # Then, create the items and their folders, if exist

eotdl/curation/stac/dataframe_labeling.py

@@ -1,8 +1,7 @@
-'''
+"""
 Module for the labeling strategy when creating a STAC catalog from a dataframe
-'''
+"""
 
-import pystac
 from os.path import basename
 
 
@@ -11,11 +10,11 @@ class LabelingStrategy:
     Labeling strategy interface to be implemented by concrete labeling strategies
     """
 
-    def __init__(self):
-        pass
-
     def get_images_labels(self, images):
-        pass
+        """
+        Get the labels of the images
+        """
+        return
 
 
 class UnlabeledStrategy(LabelingStrategy):
@@ -28,10 +27,11 @@ class UnlabeledStrategy(LabelingStrategy):
 
     def get_images_labels(self, images):
         """
+        Get the labels of the images
         """
-        labels = list()
+        labels = []
         for image in images:
-            labels.append(basename(image).split('.')[0])
+            labels.append(basename(image).split(".")[0])
         ixs = [labels.index(x) for x in labels]
 
         return labels, ixs
@@ -48,11 +48,14 @@ class LabeledStrategy(LabelingStrategy):
 
     def get_images_labels(self, images):
         """
+        Get the labels of the images
         """
-        labels = list()
+        labels = []
         for image in images:
-            image_basename = basename(image).split('.')[0]   # Get filename without extension
-            label = image_basename.split('_')[0]
+            image_basename = basename(image).split(".")[
+                0
+            ]  # Get filename without extension
+            label = image_basename.split("_")[0]
             labels.append(label)
 
         ixs = [labels.index(x) for x in labels]

eotdl/curation/stac/extensions/__init__.py

@@ -1,3 +1,7 @@
+"""
+STAC extensions module
+"""
+
 from .sar import SarExtensionObject
 from .raster import RasterExtensionObject
 from .projection import ProjExtensionObject
@@ -7,7 +11,7 @@ from .label import LabelExtensionObject, ImageNameLabeler, ScaneoLabeler
 from .ml_dataset import add_ml_extension, MLDatasetQualityMetrics
 
 
-SUPPORTED_EXTENSIONS = ('eo', 'sar', 'proj', 'raster')
+SUPPORTED_EXTENSIONS = ("eo", "sar", "proj", "raster")
 
 
 type_stac_extensions_dict = {
@@ -15,5 +19,5 @@ type_stac_extensions_dict = {
     "eo": EOS2ExtensionObject(),
     "dem": DEMExtensionObject(),
     "raster": RasterExtensionObject(),
-    "proj": ProjExtensionObject()
+    "proj": ProjExtensionObject(),
 }

eotdl/curation/stac/extensions/base.py

@@ -9,13 +9,17 @@ import pandas as pd
 
 
 class STACExtensionObject:
+    """
+    Base model for STAC extensions objects
+    """
     def __init__(self) -> None:
         super().__init__()
-        self.properties = dict()
+        self.properties = {}
 
     def add_extension_to_object(
-        self, obj: Union[pystac.Item, pystac.Asset],
-        obj_info: Optional[pd.DataFrame] = None
+        self,
+        obj: Union[pystac.Item, pystac.Asset],
+        obj_info: Optional[pd.DataFrame] = None,
     ) -> Union[pystac.Item, pystac.Asset]:
         """
         Add the extension to the given object
@@ -23,4 +27,4 @@ class STACExtensionObject:
         :param obj: object to add the extension
         :param obj_info: object info from the STACDataFrame
         """
-        pass
+        return

eotdl/curation/stac/extensions/dem.py

@@ -1,15 +1,18 @@
-'''
+"""
 Module for DEM STAC extensions object
-'''
+"""
 
 from .base import STACExtensionObject
 
 
 class DEMExtensionObject(STACExtensionObject):
+    """
+    DEM STAC extension object
+    """
     DEM_DATE_ACQUIRED = {
         "start_datetime": "2011-01-01T00:00:00Z",
         "end_datetime": "2015-01-07T00:00:00Z",
     }
 
     def __init__(self) -> None:
-        super().__init__()
+        super().__init__()

eotdl/curation/stac/extensions/eo.py

@@ -1,16 +1,21 @@
-'''
+"""
 Module for EO STAC extensions object
-'''
+"""
+
+from typing import Union
 
 import pystac
 import pandas as pd
 
-from typing import Union
-from .base import STACExtensionObject
 from pystac.extensions.eo import Band, EOExtension
 
+from .base import STACExtensionObject
+
 
 class EOS2ExtensionObject(STACExtensionObject):
+    """
+    EO STAC extension object
+    """
     def __init__(self) -> None:
         super().__init__()
         self.bands_dict = {
@@ -82,8 +87,7 @@ class EOS2ExtensionObject(STACExtensionObject):
         }
 
     def add_extension_to_object(
-        self, obj: Union[pystac.Item, pystac.Asset],
-        obj_info: pd.DataFrame
+        self, obj: Union[pystac.Item, pystac.Asset], obj_info: pd.DataFrame
     ) -> Union[pystac.Item, pystac.Asset]:
         """
         Add the extension to the given object

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

@@ -1,3 +1,7 @@
+"""
+STAC label extension module
+"""
+
 from .base import LabelExtensionObject
 from .image_name_labeler import ImageNameLabeler
-from .scaneo import ScaneoLabeler
+from .scaneo import ScaneoLabeler