eotdl 2025.3.25__py3-none-any.whl → 2025.4.2.post2__py3-none-any.whl

eotdl/access/sentinelhub/parameters.py

@@ -2,15 +2,27 @@
 Utils
 """
 
-from sentinelhub import DataCollection, MosaickingOrder
-
+from sentinelhub import DataCollection, MosaickingOrder, MimeType
 from .evalscripts import EvalScripts
 
 
+class OUTPUT_FORMAT:
+    TIFF = MimeType.TIFF
+    JPG = MimeType.JPG
+    PNG = MimeType.PNG
+
+
 class SHParameters:
     """
     Sentinel Hub Parameters base class
     """
+
+    MAX_CLOUD_COVERAGE: float = None
+    FIELDS = None
+    MOSAICKING_ORDER = MosaickingOrder.MOST_RECENT
+    EVALSCRIPT = None
+    OUTPUT_FORMAT = MimeType.TIFF
+
     def __init__(self):
         pass
 
@@ -19,8 +31,8 @@ class SHS2L2AParameters(SHParameters):
     """
     Sentinel-2-L2A parameters
     """
+
     DATA_COLLECTION = DataCollection.SENTINEL2_L2A
-    RESOLUTION = 10
     MOSAICKING_ORDER = MosaickingOrder.LEAST_CC
     EVALSCRIPT = EvalScripts.SENTINEL_2_L2A
     FIELDS = {
@@ -28,14 +40,17 @@ class SHS2L2AParameters(SHParameters):
         "exclude": [],
     }
     FILTER = None
+    RESOLUTION = 10
+    BASE_URL = "https://services.sentinel-hub.com"
+    CLOUD_COVERAGE = True
 
 
 class SHS2L1CParameters(SHParameters):
     """
     Sentinel-2-L1C parameters
     """
+
     DATA_COLLECTION = DataCollection.SENTINEL2_L1C
-    RESOLUTION = 10
     MOSAICKING_ORDER = MosaickingOrder.LEAST_CC
     EVALSCRIPT = EvalScripts.SENTINEL_2_L1C
     FIELDS = {
@@ -43,47 +58,110 @@ class SHS2L1CParameters(SHParameters):
         "exclude": [],
     }
     FILTER = None
+    RESOLUTION = 10
+    BASE_URL = "https://services.sentinel-hub.com"
+    CLOUD_COVERAGE = True
+
 
 class SHS1Parameters(SHParameters):
     """
     Sentinel-1 parameters
     """
+
     DATA_COLLECTION = DataCollection.SENTINEL1
-    RESOLUTION = 3
     EVALSCRIPT = EvalScripts.SENTINEL_1
-    MOSAICKING_ORDER = None
+    MOSAICKING_ORDER = MosaickingOrder.MOST_RECENT
     FIELDS = {
-            "include": [
-                "id",
-                "properties.datetime",
-                "sar:instrument_mode",
-                "s1:polarization",
-                "sat:orbit_state",
-                "s1:resolution",
-                "s1:timeliness",
-            ],
-            "exclude": [],
-        }
+        "include": [
+            "id",
+            "properties.datetime",
+            "sar:instrument_mode",
+            "s1:polarization",
+            "sat:orbit_state",
+            "s1:resolution",
+            "s1:timeliness",
+        ],
+        "exclude": [],
+    }
     FILTER = None
+    RESOLUTION = 3
+    BASE_URL = "https://services.sentinel-hub.com"
+    CLOUD_COVERAGE = False
 
 
 class SHDEMParameters(SHParameters):
     """
     Copernicus DEM parameters
     """
+
     DATA_COLLECTION = DataCollection.DEM_COPERNICUS_30
-    RESOLUTION = 3
     MOSAICKING_ORDER = None
     EVALSCRIPT = EvalScripts.DEM
+    FIELDS = None
+    FILTER = None
+    RESOLUTION = 3
+    BASE_URL = "https://services.sentinel-hub.com"
+    CLOUD_COVERAGE = False
+
+
+class SHHarmonizedLandsatSentinel(SHParameters):
+    """
+    Harmonized Landsat Sentinel parameters
+    """
+
+    DATA_COLLECTION = DataCollection.HARMONIZED_LANDSAT_SENTINEL
+    MOSAICKING_ORDER = MosaickingOrder.LEAST_CC
+    EVALSCRIPT = EvalScripts.HLS_TRUE_COLOR
+    FIELDS = None
     FILTER = None
+    RESOLUTION = 10
+    BASE_URL = "https://services-uswest2.sentinel-hub.com"
+    CLOUD_COVERAGE = True
+
+
+class SHLandsatOTL2(SHParameters):
+    """
+    Landsat 8-9 Collection 2 imagery processed to level 2
+    """
+
+    DATA_COLLECTION = DataCollection.LANDSAT_OT_L2
+    MOSAICKING_ORDER = MosaickingOrder.LEAST_CC
+    EVALSCRIPT = EvalScripts.LANDSAT_OT_L2_TRUE_COLOR
     FIELDS = None
+    FILTER = None
+    RESOLUTION = 10
+    BASE_URL = "https://services-uswest2.sentinel-hub.com"
+    CLOUD_COVERAGE = True
+
 
+class DATA_COLLECTION_ID:
+    SENTINEL_1_GRD = DataCollection.SENTINEL1.api_id
+    SENTINEL_2_L1C = DataCollection.SENTINEL2_L1C.api_id
+    SENTINEL_2_L2A = DataCollection.SENTINEL2_L2A.api_id
+    DEM = DataCollection.DEM_COPERNICUS_30.api_id
+    HLS = DataCollection.HARMONIZED_LANDSAT_SENTINEL.api_id
+    LANDSAT_OT_L2 = DataCollection.LANDSAT_OT_L2.api_id
 
-SUPPORTED_SENSORS = ("sentinel-1-grd", "sentinel-2-l1c", "sentinel-2-l2a", "dem")
+
+SUPPORTED_COLLECTION_IDS = [
+    value
+    for name, value in DATA_COLLECTION_ID.__dict__.items()
+    if not name.startswith("__")
+]
 
 SH_PARAMETERS_DICT = {
-    "sentinel-1-grd": SHS1Parameters,
-    "sentinel-2-l1c": SHS2L1CParameters,
-    "sentinel-2-l2a": SHS2L2AParameters,
-    "dem": SHDEMParameters,
+    DATA_COLLECTION_ID.SENTINEL_1_GRD: SHS1Parameters,
+    DATA_COLLECTION_ID.SENTINEL_2_L1C: SHS2L1CParameters,
+    DATA_COLLECTION_ID.SENTINEL_2_L2A: SHS2L2AParameters,
+    DATA_COLLECTION_ID.DEM: SHDEMParameters,
+    DATA_COLLECTION_ID.HLS: SHHarmonizedLandsatSentinel,
+    DATA_COLLECTION_ID.LANDSAT_OT_L2: SHLandsatOTL2,
 }
+
+
+def get_default_parameters(collection_id: str) -> SHParameters:
+    return SH_PARAMETERS_DICT[collection_id]()
+
+
+def supports_cloud_coverage(collection_id: str):
+    return SH_PARAMETERS_DICT[collection_id]().CLOUD_COVERAGE

eotdl/access/sentinelhub/utils.py

@@ -5,22 +5,23 @@ Utils for Sentinel Hub access
 import json
 
 from os import makedirs
-from datetime import datetime
-from typing import Union, Optional
+from datetime import datetime, timedelta
+from typing import Union, Optional, Iterable, List
 from glob import glob
 from shutil import copyfile, rmtree
 
-from .parameters import SUPPORTED_SENSORS
+from .parameters import SUPPORTED_COLLECTION_IDS, SHParameters, OUTPUT_FORMAT
 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,
+    collection_id: Optional[str] = None,
     output: Optional[str] = None,
     output_needed: Optional[bool] = True,
+    parameters: Optional[SHParameters] = None,
 ) -> None:
     """
     Evaluate parameters for Sentinel Hub access
@@ -28,10 +29,20 @@ def evaluate_sentinel_parameters(
     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}"
-        )
+        if parameters and not parameters.OUTPUT_FORMAT:
+            raise ValueError("Output format must be specified.")
+    if collection_id:
+        if collection_id not in SUPPORTED_COLLECTION_IDS:
+            raise ValueError(
+                f"Collection id {collection_id} is not supported. Supported collections ids are: {SUPPORTED_COLLECTION_IDS}"
+            )
+    else:
+        if not (
+            parameters
+            and hasattr(parameters, "DATA_COLLECTION")
+            and hasattr(parameters.DATA_COLLECTION, "api_id")
+        ):
+            raise ValueError(f"Data collection is not defined properly.")
     if not time_interval:
         raise ValueError("Time interval must be specified.")
     else:
@@ -46,26 +57,34 @@ def evaluate_sentinel_parameters(
             raise ValueError(
                 "Bounding box must be a list or tuple with four elements in format (lon_min, lat_min, lon_max, lat_max)."
             )
+    if parameters and parameters.MAX_CLOUD_COVERAGE:
+        if not isinstance(parameters.MAX_CLOUD_COVERAGE, (int, float)) or (
+            parameters.MAX_CLOUD_COVERAGE < 0 or parameters.MAX_CLOUD_COVERAGE > 100
+        ):
+            raise ValueError("Max cloud coverage must be a number between 0 and 100.")
 
 
 def imagery_from_tmp_to_dir(
     output_dir: str,
-    tmp_dir: Optional[str] = "/tmp/sentinelhub",
+    bounding_box: List[Union[int, float]],
+    tmp_dir: Optional[str],
     name: Optional[str] = None,
     bulk: Optional[bool] = False,
+    output_format: Optional[str] = OUTPUT_FORMAT.TIFF,
 ) -> None:
     """
     Copy imagery from tmp to output dir
     """
-    downloaded_files = glob(f"{tmp_dir}/**/response.tiff")
+    format = output_format
+    downloaded_files = glob(f"{tmp_dir}/**/response." + format)
+
     if len(downloaded_files) == 0:
         return
-
     makedirs(output_dir, exist_ok=True)
-
     for downloaded_file in downloaded_files:
-        request_json = downloaded_file.replace("response.tiff", "request.json")
-        metadata = generate_raster_metadata(downloaded_file, request_json)
+        request_json = downloaded_file.replace("response." + format, "request.json")
+        metadata = generate_raster_metadata(request_json, bounding_box)
+
         if name and not bulk:
             output_filename = name
         elif name and bulk:
@@ -75,19 +94,16 @@ def imagery_from_tmp_to_dir(
                 output_filename = f"{metadata['type']}_{metadata['acquisition-date']}"
             else:
                 output_filename = metadata["type"]
-
-        copyfile(downloaded_file, f"{output_dir}/{output_filename}.tif")
+        copyfile(downloaded_file, f"{output_dir}/{output_filename}." + format)
         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(request_json: str, bounding_box) -> None:
     """
     Generate metadata for raster
     """
-    bbox = get_image_bbox(raster)
     with open(request_json, "r", encoding="utf-8") as f:
         json_content = json.load(f)
 
@@ -102,8 +118,27 @@ def generate_raster_metadata(raster: str, request_json: str) -> None:
 
     metadata = {
         "acquisition-date": acquisition_date,
-        "bounding-box": bbox,
+        "bounding-box": bounding_box,
         "type": sensor_type,
     }
 
     return metadata
+
+
+def filter_times(
+    timestamps: Iterable[datetime], time_difference: timedelta
+) -> list[datetime]:
+    """
+    Filters out timestamps within time_difference, preserving only the oldest timestamp.
+    """
+    timestamps = sorted(set(timestamps))
+
+    filtered_timestamps: list[datetime] = []
+    for current_timestamp in timestamps:
+        if (
+            not filtered_timestamps
+            or current_timestamp - filtered_timestamps[-1] > time_difference
+        ):
+            filtered_timestamps.append(current_timestamp)
+
+    return filtered_timestamps

eotdl/curation/stac/stac.py

@@ -11,7 +11,7 @@ def create_stac_catalog(parquet_catalog_path, stac_catalog = None):
 	items = []
 	for item in tqdm(stac_geoparquet.arrow.stac_table_to_items(table), total=len(table)):
 		item = pystac.Item.from_dict(item)
-		item.validate()
+		# item.validate()
 		# collection.add_item(item)
 		if stac_catalog is not None:
 			stac_catalog.add_item(item)

eotdl/datasets/__init__.py

@@ -1,3 +1,3 @@
 from .retrieve import retrieve_datasets, retrieve_dataset, retrieve_dataset_files
-from .ingest import ingest_dataset
+from .ingest import ingest_dataset, ingest_virtual_dataset
 from .stage import stage_dataset, stage_dataset_file

eotdl/datasets/ingest.py

@@ -1,12 +1,11 @@
 from pathlib import Path
 
 from ..repos import DatasetsAPIRepo
-from ..files.ingest import prep_ingest_stac, prep_ingest_folder, ingest
+from ..files.ingest import prep_ingest_stac, prep_ingest_folder, ingest, ingest_virtual
 
 def retrieve_dataset(metadata, user):
 	repo = DatasetsAPIRepo()
 	data, error = repo.retrieve_dataset(metadata.name)
-	# print(data, error)
 	if data and data["uid"] != user["uid"]:
 		raise Exception("Dataset already exists.")
 	if error and error == "Dataset doesn't exist":
@@ -34,3 +33,11 @@ def ingest_dataset(
 	return ingest(path, DatasetsAPIRepo(), retrieve_dataset, 'datasets')
 
 
+def ingest_virtual_dataset( # could work for a list of paths with minimal changes...
+	path,
+	links,
+	metadata = None, 
+	logger=print,
+	user=None,
+):
+	return ingest_virtual(path, links, DatasetsAPIRepo(), retrieve_dataset, 'datasets', metadata, logger)

eotdl/datasets/stage.py

@@ -6,6 +6,7 @@ import geopandas as gpd
 from ..auth import with_auth
 from .retrieve import retrieve_dataset
 from ..repos import FilesAPIRepo
+from ..files.metadata import Metadata
 
 @with_auth
 def stage_dataset(
@@ -42,19 +43,18 @@ def stage_dataset(
         raise Exception(
             f"Dataset `{dataset['name']}` already exists at {download_path}. To force download, use force=True or -f in the CLI."
         )
-
     # stage metadata
     repo = FilesAPIRepo()
     catalog_path = repo.stage_file(dataset["id"], f"catalog.v{version}.parquet", user, download_path)
-
-    # TODO: stage README.md
-
+    # stage README.md
+    metadata = Metadata(**dataset['metadata'], name=dataset['name'])
+    metadata.save_metadata(download_path)
+    # stage assets
     if assets:
         gdf = gpd.read_parquet(catalog_path)
         for _, row in tqdm(gdf.iterrows(), total=len(gdf), desc="Staging assets"):
             for k, v in row["assets"].items():
                 stage_dataset_file(v["href"], download_path)
-
     return download_path
 
 

eotdl/files/ingest.py

@@ -56,6 +56,15 @@ def prep_ingest_stac(path, logger=None): # in theory should work with a remote c
 		# iterate over items
 		for item in tqdm(collection.get_items(), desc=f"Ingesting items from collection {collection.id}"):
 			assert isinstance(item, pystac.Item)
+			# Process each asset in the item
+			for asset in item.assets.values():
+				if not asset.href.startswith(('http://', 'https://')):
+					# Asset is a local file
+					file_path = Path(asset.href)
+					# Calculate and add file size
+					asset.extra_fields['size'] = file_path.stat().st_size
+					# Calculate and add checksum
+					asset.extra_fields['checksum'] = calculate_checksum(str(file_path))
 			items.append(item)
 	# save parquet file
 	record_batch_reader = stac_geoparquet.arrow.parse_stac_items_to_arrow(items)
@@ -63,13 +72,14 @@ def prep_ingest_stac(path, logger=None): # in theory should work with a remote c
 	stac_geoparquet.arrow.to_parquet(record_batch_reader, output_path)
 	return output_path
 
-@with_auth
-def ingest_virutal_dataset( # could work for a list of paths with minimal changes...
+def ingest_virtual( # could work for a list of paths with minimal changes...
 	path,
 	links,
+	repo,
+	retrieve,
+	mode,
 	metadata = None, 
 	logger=print,
-	user=None,
 ):
 	path = Path(path)
 	if metadata is None:
@@ -88,7 +98,7 @@ def ingest_virutal_dataset( # could work for a list of paths with minimal change
 	data.append(create_stac_item('README.md', str(path / "README.md")))
 	gdf = gpd.GeoDataFrame(data, geometry='geometry')
 	gdf.to_parquet(path / "catalog.parquet")
-	return ingest(path)
+	return ingest(path, repo, retrieve, mode)
 
 @with_auth
 def ingest(path, repo, retrieve, mode, user):
@@ -104,8 +114,6 @@ def ingest(path, repo, retrieve, mode, user):
 	# retrieve dataset (create if doesn't exist)
 	dataset_or_model = retrieve(metadata, user)
 	current_version = sorted([v['version_id'] for v in dataset_or_model["versions"]])[-1]
-	print("current version: ", current_version)
-
 	# TODO: update README if metadata changed in UI (db)
 	# update_metadata = True
 	# if "description" in dataset:
@@ -118,12 +126,10 @@ def ingest(path, repo, retrieve, mode, user):
 	# return ingest_files(
 	#     repo, dataset["id"], folder, verbose, logger, user, endpoint="datasets"
 	# )
-
 	catalog_path = path.joinpath("catalog.parquet")
 	gdf = gpd.read_parquet(catalog_path)
 	files_repo = FilesAPIRepo()
-	catalog_url = files_repo.generate_presigned_url(f'catalog.v{current_version}.parquet', dataset_or_model['id'], user)
-
+	catalog_url = files_repo.generate_presigned_url(f'catalog.v{current_version}.parquet', dataset_or_model['id'], user, endpoint=mode)
 	# first time ingesting
 	if catalog_url is None:
 		total_size = 0
@@ -149,7 +155,7 @@ def ingest(path, repo, retrieve, mode, user):
 				print(f"Error uploading asset {row[0]}: {e}")
 				break
 		gdf.to_parquet(catalog_path)
-		files_repo.ingest_file(str(catalog_path), f'catalog.v{current_version}.parquet', dataset_or_model['id'], user, "datasets")
+		files_repo.ingest_file(str(catalog_path), f'catalog.v{current_version}.parquet', dataset_or_model['id'], user, mode)
 		data, error = repo.complete_ingestion(dataset_or_model['id'], current_version, total_size, user)
 		if error:
 			raise Exception(error)
@@ -174,7 +180,7 @@ def ingest(path, repo, retrieve, mode, user):
 				if len(df) > 0: # file exists in previous versions
 					if df.iloc[0]['assets'][k]["checksum"] == v["checksum"]: # file is the same
 						# still need to update the required fields
-						file_url = f"{repo.url}datasets/{dataset_or_model['id']}/stage/{item_id}"
+						file_url = f"{repo.url}{mode}/{dataset_or_model['id']}/stage/{item_id}"
 						gdf.loc[row[0], "assets"][k]["href"] = file_url
 						total_size += v["size"]
 						continue

eotdl/models/download.py

@@ -0,0 +1,101 @@
+import os
+from pathlib import Path
+from tqdm import tqdm
+
+from ..auth import with_auth
+from .retrieve import retrieve_model, retrieve_model_files
+from ..shared import calculate_checksum
+from ..repos import FilesAPIRepo, ModelsAPIRepo
+from .metadata import generate_metadata
+from ..curation.stac import STACDataFrame
+
+
+@with_auth
+def download_model(
+    model_name,
+    version=None,
+    path=None,
+    logger=None,
+    assets=False,
+    force=False,
+    verbose=False,
+    user=None,
+    file=None,
+):
+    model = retrieve_model(model_name)
+    if version is None:
+        version = sorted(model["versions"], key=lambda v: v["version_id"])[-1][
+            "version_id"
+        ]
+    else:
+        assert version in [
+            v["version_id"] for v in model["versions"]
+        ], f"Version {version} not found"
+    download_base_path = os.getenv(
+        "EOTDL_DOWNLOAD_PATH", str(Path.home()) + "/.cache/eotdl/models"
+    )
+    if path is None:
+        download_path = download_base_path + "/" + model_name + "/v" + str(version)
+    else:
+        download_path = path + "/" + model_name + "/v" + str(version)
+    # check if model already exists
+    if os.path.exists(download_path) and not force:
+        os.makedirs(download_path, exist_ok=True)
+        raise Exception(
+            f"model `{model['name']} v{str(version)}` already exists at {download_path}. To force download, use force=True or -f in the CLI."
+        )
+    if model["quality"] == 0:
+        if file:
+            raise NotImplementedError("Downloading a specific file is not implemented")
+        model_files = retrieve_model_files(model["id"], version)
+        repo = FilesAPIRepo()
+        for file in tqdm(model_files, disable=verbose, unit="file"):
+            filename, file_version = file["filename"], file["version"]
+            if verbose:
+                logger(f"Downloading {file['filename']}...")
+            dst_path = repo.download_file(
+                model["id"],
+                filename,
+                user,
+                download_path,
+                file_version,
+                endpoint="models",
+            )
+            if verbose:
+                logger("Generating README.md ...")
+            generate_metadata(download_path, model)
+    else:
+        if verbose:
+            logger("Downloading STAC metadata...")
+        repo = ModelsAPIRepo()
+        gdf, error = repo.download_stac(
+            model["id"],
+            user,
+        )
+        if error:
+            raise Exception(error)
+        # print(gdf)
+        df = STACDataFrame(gdf)
+        # df.geometry = df.geometry.apply(lambda x: Polygon() if x is None else x)
+        df.to_stac(download_path)
+        # print("----")
+        # print(df)
+        # download assets
+        if assets:
+            if verbose:
+                logger("Downloading assets...")
+            repo = FilesAPIRepo()
+            df = df.dropna(subset=["assets"])
+            for row in tqdm(df.iterrows(), total=len(df)):
+                for k, v in row[1]["assets"].items():
+                    href = v["href"]
+                    _, filename = href.split("/download/")
+                    # will overwrite assets with same name :(
+                    repo.download_file_url(
+                        href, filename, f"{download_path}/assets", user
+                    )
+        else:
+            logger("To download assets, set assets=True or -a in the CLI.")
+    if verbose:
+        logger("Done")
+    return download_path

eotdl/models/ingest.py

@@ -1,7 +1,7 @@
 from pathlib import Path
 
 from ..repos import ModelsAPIRepo
-from ..files.ingest import prep_ingest_stac, prep_ingest_folder, ingest
+from ..files.ingest import prep_ingest_stac, prep_ingest_folder, ingest, ingest_virtual
 
 def retrieve_model(metadata, user):
 	repo = ModelsAPIRepo()
@@ -12,7 +12,6 @@ def retrieve_model(metadata, user):
 	if error and error == "Model doesn't exist":
 		# create model
 		data, error = repo.create_model(metadata.dict(), user)
-		# print(data, error)
 		if error:
 			raise Exception(error)
 	return data
@@ -31,4 +30,13 @@ def ingest_model(
 		prep_ingest_stac(path, logger)
 	else:
 		prep_ingest_folder(path, verbose, logger, force_metadata_update, sync_metadata)
-	return ingest(path, ModelsAPIRepo(), retrieve_model, 'models')
+	return ingest(path, ModelsAPIRepo(), retrieve_model, 'models')
+
+def ingest_virtual_model( # could work for a list of paths with minimal changes...
+	path,
+	links,
+	metadata = None, 
+	logger=print,
+	user=None,
+):
+	return ingest_virtual(path, links, ModelsAPIRepo(), retrieve_model, 'models', metadata, logger)

eotdl/models/stage.py

@@ -6,6 +6,7 @@ import geopandas as gpd
 from ..auth import with_auth
 from .retrieve import retrieve_model
 from ..repos import FilesAPIRepo
+from ..files.metadata import Metadata
 
 @with_auth
 def stage_model(
@@ -44,7 +45,9 @@ def stage_model(
     repo = FilesAPIRepo()
     catalog_path = repo.stage_file(model["id"], f"catalog.v{version}.parquet", user, download_path)
 
-    # TODO: stage README.md
+    # stage README.md
+    metadata = Metadata(**model['metadata'], name=model['name'])
+    metadata.save_metadata(download_path)
 
     if assets:
         gdf = gpd.read_parquet(catalog_path)