eotdl 2024.10.7__py3-none-any.whl → 2025.3.25__py3-none-any.whl

eotdl/repos/FilesAPIRepo.py

@@ -11,190 +11,283 @@ class FilesAPIRepo(APIRepo):
     def __init__(self, url=None):
         super().__init__(url)
 
-    def ingest_files_batch(
-        self,
-        batch,  # ziped batch of files
-        checksums,
-        dataset_or_model_id,
-        user,
-        endpoint,
-        version=None,
-    ):
-        url = self.url + f"{endpoint}/{dataset_or_model_id}/batch"
-        if version is not None:
-            url += "?version=" + str(version)
-        reponse = requests.post(
-            url,
-            files={"batch": ("batch.zip", batch)},
-            data={"checksums": checksums},
-            headers=self.generate_headers(user),
-        )
-        return self.format_response(reponse)
-
-    def add_files_batch_to_version(
-        self,
-        batch,
-        dataset_or_model_id,
-        version,
-        user,
-        endpoint,
-    ):
-        reponse = requests.post(
-            self.url + f"{endpoint}/{dataset_or_model_id}/files?version={str(version)}",
-            data={
-                "filenames": [f["path"] for f in batch],
-                "checksums": [f["checksum"] for f in batch],
-            },
-            headers=self.generate_headers(user),
-        )
-        return self.format_response(reponse)
-
     def ingest_file(
-        self, file, dataset_or_model_id, user, checksum, endpoint, version=None
+        self, file_path_or_bytes, file_name, dataset_or_model_id, user, endpoint, version=None
     ):
-        # TODO: ingest file URL
         url = self.url + f"{endpoint}/{dataset_or_model_id}"
         if version is not None:
             url += "?version=" + str(version)
+        # get a presigned url to upload the file directly to the bucket
         reponse = requests.post(
             url,
-            files={"file": open(file, "rb")},
-            data={"checksum": checksum},
+            json={
+                "file_name": file_name,
+                # "file_size": files_size,
+                # "checksum": checksum
+            },
             headers=self.generate_headers(user),
         )
-        return self.format_response(reponse)
+        data, error = self.format_response(reponse)
+        if error:
+            raise Exception(error)
+        # ingest the file
+        error = None
+        try:
+            presigned_url = data["presigned_url"]
+            if isinstance(file_path_or_bytes, (str, bytes)):
+                if isinstance(file_path_or_bytes, str):
+                    # Handle file path
+                    with open(file_path_or_bytes, 'rb') as f:
+                        file_data = f.read()
+                else:
+                    # Handle bytes directly
+                    file_data = file_path_or_bytes
+                # Send file data to presigned URL
+                response = requests.put(presigned_url, data=file_data)
+                response.raise_for_status()
+            else:
+                raise TypeError("file_path_or_bytes must be either a file path string or bytes")
+        except Exception as e:
+            error = str(e)
+        return data, error
 
-    def retrieve_files(self, dataset_or_model_id, endpoint, version=None):
-        url = f"{self.url}{endpoint}/{dataset_or_model_id}/files"
-        if version is not None:
-            url += "?version=" + str(version)
-        response = requests.get(url)
-        return self.format_response(response)
-
-    def download_file(
+    def stage_file(
         self,
         dataset_or_model_id,
         file_name,
         user,
         path,
-        file_version,
         endpoint="datasets",
         progress=False,
     ):
-        url = self.url + f"{endpoint}/{dataset_or_model_id}/download/{file_name}"
-        if file_version is not None:
-            url += "?version=" + str(file_version)
-        return self.download_file_url(url, file_name, path, user, progress=progress)
-
-    def download_file_url(self, url, filename, path, user, progress=False):
-        headers = self.generate_headers(user)
-        path = f"{path}/{filename}"
-        for i in range(1, len(path.split("/")) - 1):
-            # print("/".join(path.split("/")[: i + 1]))
-            os.makedirs("/".join(path.split("/")[: i + 1]), exist_ok=True)
-        with requests.get(url, headers=headers, stream=True) as r:
-            r.raise_for_status()
-            total_size = int(r.headers.get("content-length", 0))
-            block_size = 1024 * 1024 * 10
-            progress = progress and total_size > 1024 * 1024 * 16
-            if progress:
-                progress_bar = tqdm(
-                    total=total_size,
-                    unit="iB",
-                    unit_scale=True,
-                    unit_divisor=1024,
-                    position=1,
-                )
-            with open(path, "wb") as f:
-                for chunk in r.iter_content(block_size):
-                    if progress:
-                        progress_bar.update(len(chunk))
-                    if chunk:
-                        f.write(chunk)
-            if progress:
-                progress_bar.close()
-            return path
-
-    def prepare_large_upload(
-        self, filename, dataset_or_model_id, checksum, user, endpoint
-    ):
-        response = requests.post(
-            self.url + f"{endpoint}/{dataset_or_model_id}/uploadId",
-            json={"filname": filename, "checksum": checksum},
-            headers=self.generate_headers(user),
-        )
-        if response.status_code != 200:
-            raise Exception(response.json()["detail"])
-        data = response.json()
-        upload_id, parts = (
-            data["upload_id"],
-            data["parts"] if "parts" in data else [],
-        )
-        return upload_id, parts
-
-    def get_chunk_size(self, content_size):
-        # adapt chunk size to content size to avoid S3 limits (10000 parts, 500MB per part, 5TB per object)
-        chunk_size = 1024 * 1024 * 10  # 10 MB (up to 100 GB, 10000 parts)
-        if content_size >= 1024 * 1024 * 1024 * 100:  # 100 GB
-            chunk_size = 1024 * 1024 * 100  # 100 MB (up to 1 TB, 10000 parts)
-        elif content_size >= 1024 * 1024 * 1024 * 1000:  # 1 TB
-            chunk_size = 1024 * 1024 * 500  # 0.5 GB (up to 5 TB, 10000 parts)
-        return chunk_size
-
-    def read_in_chunks(self, file_object, CHUNK_SIZE):
-        while True:
-            data = file_object.read(CHUNK_SIZE)
-            if not data:
-                break
-            yield data
-
-    def ingest_large_file(
-        self, file_path, files_size, upload_id, user, parts, endpoint
+        url = self.url + f"{endpoint}/{dataset_or_model_id}/stage/{file_name}"
+        # if file_version is not None:
+        #     url += "?version=" + str(file_version)
+        return self.stage_file_url(url, path, user)
+
+
+    def stage_file_url(
+        self,
+        url,
+        path,
+        user,
     ):
-        print(endpoint)
-        # content_path = os.path.abspath(file)
-        # content_size = os.stat(content_path).st_size
-        chunk_size = self.get_chunk_size(files_size)
-        total_chunks = files_size // chunk_size
-        # upload chunks sequentially
-        pbar = tqdm(
-            self.read_in_chunks(open(file_path, "rb"), chunk_size),
-            total=total_chunks,
-        )
-        index = 0
-        for chunk in pbar:
-            part = index // chunk_size + 1
-            offset = index + len(chunk)
-            index = offset
-            if part not in parts:
-                checksum = hashlib.md5(chunk).hexdigest()
-                response = requests.post(
-                    f"{self.url}{endpoint}/chunk/{upload_id}",
-                    files={"file": chunk},
-                    data={"part_number": part, "checksum": checksum},
-                    headers=self.generate_headers(user),
-                )
-                if response.status_code != 200:
-                    raise Exception(response.json()["detail"])
-            pbar.set_description(
-                "{:.2f}/{:.2f} MB".format(
-                    offset / 1024 / 1024, files_size / 1024 / 1024
-                )
-            )
-        pbar.close()
-        return
-
-    def complete_upload(self, user, upload_id, version, endpoint):
-        r = requests.post(
-            f"{self.url}{endpoint}/complete/{upload_id}?version={version}",
-            headers=self.generate_headers(user),
-        )
-        return self.format_response(r)
+        if '/stage/' in url:  # asset is in EOTDL (can do better...)
+            file_name = url.split("/stage/")[-1] 
+            reponse = requests.get(url, headers=self.generate_headers(user))
+            data, error = self.format_response(reponse)
+            if error:
+                raise Exception(error)
+            presigned_url = data["presigned_url"]
+        else:
+            file_name = url.split("//")[-1]
+            presigned_url = url
+        file_path = f"{path}/{file_name}"
+        for i in range(1, len(file_path.split("/")) - 1):
+            os.makedirs("/".join(file_path.split("/")[: i + 1]), exist_ok=True)
+        try:
+            response = requests.get(presigned_url)
+            response.raise_for_status()  # This will raise an HTTPError for 4XX and 5XX status codes
+            with open(file_path, 'wb') as f:
+                f.write(response.content)
+        except requests.exceptions.HTTPError as e:
+            raise Exception(f"Failed to stage file: {str(e)}")
+        except Exception as e:
+            raise Exception(f"Unexpected error while staging file: {str(e)}")
+        return file_path
     
-    def get_file_stream(self, dataset_id, filename, user, version=None):
-        url = self.url + f"datasets/{dataset_id}/download/{filename}"
-        if version is not None:
-            url += "?version=" + str(version)
-        headers = self.generate_headers(user)
-        response = requests.get(url, headers=headers, stream=True)
-        return BytesIO(response.content)
+    def generate_presigned_url(self, filename, dataset_or_model_id, user, endpoint="datasets"):
+        url = f"{self.url}{endpoint}/{dataset_or_model_id}/stage/{filename}"
+        reponse = requests.get(url, headers=self.generate_headers(user))
+        data, error = self.format_response(reponse)
+        if error:
+            print("ERROR generate_presigned_url", error)
+            return None
+        return data["presigned_url"]
+
+        # can we download large files?
+
+        # with requests.get(presigned_url, headers=headers, stream=True) as r:
+        #     r.raise_for_status()
+        #     total_size = int(r.headers.get("content-length", 0))
+        #     block_size = 1024 * 1024 * 10
+        #     progress = progress and total_size > 1024 * 1024 * 16
+        #     if progress:
+        #         progress_bar = tqdm(
+        #             total=total_size,
+        #             unit="iB",
+        #             unit_scale=True,
+        #             unit_divisor=1024,
+        #             position=1,
+        #         )
+        #     with open(path, "wb") as f:
+        #         for chunk in r.iter_content(block_size):
+        #             if progress:
+        #                 progress_bar.update(len(chunk))
+        #             if chunk:
+        #                 f.write(chunk)
+        #     if progress:
+        #         progress_bar.close()
+        #     return path
+
+
+
+    # def ingest_files_batch(
+    #     self,
+    #     batch,  # ziped batch of files
+    #     checksums,
+    #     dataset_or_model_id,
+    #     user,
+    #     endpoint,
+    #     version=None,
+    # ):
+    #     url = self.url + f"{endpoint}/{dataset_or_model_id}/batch"
+    #     if version is not None:
+    #         url += "?version=" + str(version)
+    #     reponse = requests.post(
+    #         url,
+    #         files={"batch": ("batch.zip", batch)},
+    #         data={"checksums": checksums},
+    #         headers=self.generate_headers(user),
+    #     )
+    #     return self.format_response(reponse)
+
+    # def add_files_batch_to_version(
+    #     self,
+    #     batch,
+    #     dataset_or_model_id,
+    #     version,
+    #     user,
+    #     endpoint,
+    # ):
+    #     reponse = requests.post(
+    #         self.url + f"{endpoint}/{dataset_or_model_id}/files?version={str(version)}",
+    #         data={
+    #             "filenames": [f["path"] for f in batch],
+    #             "checksums": [f["checksum"] for f in batch],
+    #         },
+    #         headers=self.generate_headers(user),
+    #     )
+    #     return self.format_response(reponse)
+
+    # def retrieve_files(self, dataset_or_model_id, endpoint, version=None):
+    #     url = f"{self.url}{endpoint}/{dataset_or_model_id}/files"
+    #     if version is not None:
+    #         url += "?version=" + str(version)
+    #     response = requests.get(url)
+    #     return self.format_response(response)
+
+
+
+    # def download_file_url(self, url, filename, path, user, progress=False):
+    #     headers = self.generate_headers(user)
+    #     path = f"{path}/{filename}"
+    #     for i in range(1, len(path.split("/")) - 1):
+    #         # print("/".join(path.split("/")[: i + 1]))
+    #         os.makedirs("/".join(path.split("/")[: i + 1]), exist_ok=True)
+    #     with requests.get(url, headers=headers, stream=True) as r:
+    #         r.raise_for_status()
+    #         total_size = int(r.headers.get("content-length", 0))
+    #         block_size = 1024 * 1024 * 10
+    #         progress = progress and total_size > 1024 * 1024 * 16
+    #         if progress:
+    #             progress_bar = tqdm(
+    #                 total=total_size,
+    #                 unit="iB",
+    #                 unit_scale=True,
+    #                 unit_divisor=1024,
+    #                 position=1,
+    #             )
+    #         with open(path, "wb") as f:
+    #             for chunk in r.iter_content(block_size):
+    #                 if progress:
+    #                     progress_bar.update(len(chunk))
+    #                 if chunk:
+    #                     f.write(chunk)
+    #         if progress:
+    #             progress_bar.close()
+    #         return path
+
+    # def prepare_large_upload(
+    #     self, filename, dataset_or_model_id, checksum, user, endpoint
+    # ):
+    #     response = requests.post(
+    #         self.url + f"{endpoint}/{dataset_or_model_id}/uploadId",
+    #         json={"filname": filename, "checksum": checksum},
+    #         headers=self.generate_headers(user),
+    #     )
+    #     if response.status_code != 200:
+    #         raise Exception(response.json()["detail"])
+    #     data = response.json()
+    #     upload_id, parts = (
+    #         data["upload_id"],
+    #         data["parts"] if "parts" in data else [],
+    #     )
+    #     return upload_id, parts
+
+    # def get_chunk_size(self, content_size):
+    #     # adapt chunk size to content size to avoid S3 limits (10000 parts, 500MB per part, 5TB per object)
+    #     chunk_size = 1024 * 1024 * 10  # 10 MB (up to 100 GB, 10000 parts)
+    #     if content_size >= 1024 * 1024 * 1024 * 100:  # 100 GB
+    #         chunk_size = 1024 * 1024 * 100  # 100 MB (up to 1 TB, 10000 parts)
+    #     elif content_size >= 1024 * 1024 * 1024 * 1000:  # 1 TB
+    #         chunk_size = 1024 * 1024 * 500  # 0.5 GB (up to 5 TB, 10000 parts)
+    #     return chunk_size
+
+    # def read_in_chunks(self, file_object, CHUNK_SIZE):
+    #     while True:
+    #         data = file_object.read(CHUNK_SIZE)
+    #         if not data:
+    #             break
+    #         yield data
+
+    # def ingest_large_file(
+    #     self, file_path, files_size, upload_id, user, parts, endpoint
+    # ):
+    #     print(endpoint)
+    #     # content_path = os.path.abspath(file)
+    #     # content_size = os.stat(content_path).st_size
+    #     chunk_size = self.get_chunk_size(files_size)
+    #     total_chunks = files_size // chunk_size
+    #     # upload chunks sequentially
+    #     pbar = tqdm(
+    #         self.read_in_chunks(open(file_path, "rb"), chunk_size),
+    #         total=total_chunks,
+    #     )
+    #     index = 0
+    #     for chunk in pbar:
+    #         part = index // chunk_size + 1
+    #         offset = index + len(chunk)
+    #         index = offset
+    #         if part not in parts:
+    #             checksum = hashlib.md5(chunk).hexdigest()
+    #             response = requests.post(
+    #                 f"{self.url}{endpoint}/chunk/{upload_id}",
+    #                 files={"file": chunk},
+    #                 data={"part_number": part, "checksum": checksum},
+    #                 headers=self.generate_headers(user),
+    #             )
+    #             if response.status_code != 200:
+    #                 raise Exception(response.json()["detail"])
+    #         pbar.set_description(
+    #             "{:.2f}/{:.2f} MB".format(
+    #                 offset / 1024 / 1024, files_size / 1024 / 1024
+    #             )
+    #         )
+    #     pbar.close()
+    #     return
+
+    # def complete_upload(self, user, upload_id, version, endpoint):
+    #     r = requests.post(
+    #         f"{self.url}{endpoint}/complete/{upload_id}?version={version}",
+    #         headers=self.generate_headers(user),
+    #     )
+    #     return self.format_response(r)
+    
+    # def get_file_stream(self, dataset_id, filename, user, version=None):
+    #     url = self.url + f"datasets/{dataset_id}/download/{filename}"
+    #     if version is not None:
+    #         url += "?version=" + str(version)
+    #     headers = self.generate_headers(user)
+    #     response = requests.get(url, headers=headers, stream=True)
+    #     return BytesIO(response.content)

eotdl/repos/STACAPIRepo.py

@@ -0,0 +1,40 @@
+import requests
+import geopandas as gpd
+
+from ..repos import APIRepo
+
+
+class STACAPIRepo(APIRepo):
+    def __init__(self, url=None):
+        super().__init__(url)
+
+    def status(self):
+        response = requests.get(self.url + "stac")
+        return self.format_response(response)
+    
+    def collections(self):
+        response = requests.get(self.url + "stac/collections")
+        return self.format_response(response)
+
+    def collection(self, collection_id):
+        response = requests.get(self.url + f"stac/collections/{collection_id}")
+        return self.format_response(response)
+
+    def items(self, collection_id):
+        response = requests.get(self.url + f"stac/collections/{collection_id}/items")
+        return self.format_response(response)
+
+    def item(self, collection_id, item_id):
+        response = requests.get(self.url + f"stac/collections/{collection_id}/items/{item_id}")
+        return self.format_response(response)
+    
+    def search(self, collection_id, query):
+        body = {"collection_id": collection_id}
+        if query is not None:
+            body["query"] = query
+        response = requests.post(self.url + f"stac/search", json=body)
+        return self.format_response(response)
+    
+    def search_columns(self, collection_id):
+        response = requests.get(self.url + f"stac/search?collection={collection_id}")
+        return self.format_response(response)

eotdl/repos/__init__.py

@@ -4,3 +4,4 @@ from .AuthAPIRepo import AuthAPIRepo
 from .DatasetsAPIRepo import DatasetsAPIRepo
 from .FilesAPIRepo import FilesAPIRepo
 from .ModelsAPIRepo import ModelsAPIRepo
+from .STACAPIRepo import STACAPIRepo

eotdl/tools/geo_utils.py

@@ -127,6 +127,11 @@ def bbox_from_centroid(
     width_m = width * pixel_size
     heigth_m = height * pixel_size
 
+    # Initialise the transformers
+    utm_crs = CRS.get_utm_from_wgs84(y, x).ogc_string()
+    from_4326_transformer = Transformer.from_crs("EPSG:4326", utm_crs)
+    to_4326_transformer = Transformer.from_crs(utm_crs, "EPSG:4326")
+
     # Transform the centroid coordinates to meters
     centroid_m = from_4326_transformer.transform(x, y)
 
@@ -137,8 +142,8 @@ def bbox_from_centroid(
     max_y = centroid_m[1] + heigth_m / 2
 
     # Convert the bounding box coordinates back to degrees
-    min_x, min_y = from_3857_transformer.transform(min_x, min_y)
-    max_x, max_y = from_3857_transformer.transform(max_x, max_y)
+    min_x, min_y = to_4326_transformer.transform(min_x, min_y)
+    max_x, max_y = to_4326_transformer.transform(max_x, max_y)
 
     return [min_y, min_x, max_y, max_x]
 

{eotdl-2024.10.7.dist-info → eotdl-2025.3.25.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: eotdl
-Version: 2024.10.7
+Version: 2025.3.25
 Summary: Earth Observation Training Data Lab
 License: MIT
 Author: EarthPulse
@@ -13,6 +13,7 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: black (>=23.10.1,<24.0.0)
 Requires-Dist: geomet (>=1.0.0,<2.0.0)
 Requires-Dist: geopandas (>=0.13.2,<0.14.0)
@@ -49,10 +50,10 @@ Description-Content-Type: text/markdown
 
 This is the main library and CLI for the **Earth Observation Training Data Lab** (EOTDL), a complete environment that allows you, among other things, to:
 
-- Explore and download Training Datasets (TDS) for Earth Observation (EO) applications.
+- Explore and stage Training Datasets (TDS) for Earth Observation (EO) applications.
 - Create and upload your own TDS by combining and annotating EO data from different sources.
 - Train Machine Learning (ML) models using the hosted TDS in the cloud with multi-GPU machines.
-- Explore and download pre-trianed ML models for EO applications.
+- Explore and stage pre-trianed ML models for EO applications.
 
 In our blog you will find tutorials to learn how leverage the EOTDL to create and use TDS and ML models for your own EO applications.
 

eotdl-2025.3.25.dist-info/RECORD

@@ -0,0 +1,65 @@
+eotdl/__init__.py,sha256=5OBv4eVG7bKLTl5AtMeoKzr4tllf7-R_Vp-xqXk87VQ,27
+eotdl/access/__init__.py,sha256=jbyjD7BRGJURlTNmtcbBBhw3Xk4EiZvkqmEykM-bJ1k,231
+eotdl/access/airbus/__init__.py,sha256=G_kkRS9eFjXbQ-aehmTLXeAxh7zpAxz_rgB7J_w0NRg,107
+eotdl/access/airbus/client.py,sha256=zjfgB_NTsCCIszoQesYkyLJgheKg-eTh28vbleXYxfw,12018
+eotdl/access/airbus/parameters.py,sha256=Z8XIrxG5wAOuOoH-fkdKfdNMEMLFp6PaxJN7v4MefMI,1009
+eotdl/access/airbus/utils.py,sha256=oh_N1Rn4fhcvUgNPpH2QzVvpe4bA0gqRgNguzRVqUps,652
+eotdl/access/download.py,sha256=DgemJKafNOlCUVW8OxpSP4br9ij5F1iSrSD-x0B5qFU,1845
+eotdl/access/search.py,sha256=JW4MnM3xbXxvsaNCFkRKxPhxhNKJgZAutE2wna6qUpo,631
+eotdl/access/sentinelhub/__init__.py,sha256=YpvaUBTRXM26WrXipo51ZUBCDv9WjRIdT8l1Pklpt_M,238
+eotdl/access/sentinelhub/client.py,sha256=g40avqlUpIa-WLjD7tK8CL8_SohBA2v3m8NZ0KbIFxc,4098
+eotdl/access/sentinelhub/evalscripts.py,sha256=m6cnZ6ryXHgdH2B7RDVSlDHXWfvKi7HMGkTHXEcJsTw,4142
+eotdl/access/sentinelhub/parameters.py,sha256=SEal7mCPkADc7lhQL-63t2h5-XCssYpGMvK5Eo3etFU,2078
+eotdl/access/sentinelhub/utils.py,sha256=X9Q1YvErBdMsRKszXyaOaG6ZMvPdM2Nl_0SH-dWSFo0,3560
+eotdl/auth/__init__.py,sha256=OuGNfJQ-8Kymn4zIywlHQfImEO8DJMJIwOwTQm-u_dc,99
+eotdl/auth/auth.py,sha256=EjbVFREA2H0sjFJhVqjFZrwjKPzxRJ2x83MTjizpRBs,2029
+eotdl/auth/errors.py,sha256=E1lv3Igk--J-SOgNH18i8Xx9bXrrMyBSHKt_CAUmGPo,308
+eotdl/auth/is_logged.py,sha256=QREuhkoDnarZoUZwCxVCNoESGb_Yukh0lJo1pXvrV9Q,115
+eotdl/auth/logout.py,sha256=P_Sp6WmVvnG3R9V1L9541KNyHFko9DtQPqAKD2vaguw,161
+eotdl/cli.py,sha256=1wtNmiuqjwDB1Me-eSio--dnOabrbdpMiO9dQoIbOoc,702
+eotdl/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+eotdl/commands/auth.py,sha256=WzA0aFGRoscy7fPKQTxiphBc0LJztJxBBl7rjDBRVfI,1544
+eotdl/commands/datasets.py,sha256=rFdimg_AOp_sf8N1dPHOfwHoqiGBXPOY7bHhg3022v0,5208
+eotdl/commands/models.py,sha256=Me1xyCHHO9Wy-Nd_p4KY09l6pYwUPrBbm6hsYwqHQKY,4864
+eotdl/commands/stac.py,sha256=Nt7WDzANgcaxJYwr-5XOv887jLrYXlut5dHbh5rKNPU,1440
+eotdl/curation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+eotdl/curation/stac/__init__.py,sha256=FMi-qzd6v1sdsqZsBRRnedccaJFXJGCPCH3uTctyLYU,37
+eotdl/curation/stac/api.py,sha256=wAn_oDuvGJOjHOSauLIiXZ9ym8n4jyk-OTIGvCcRAzo,1424
+eotdl/curation/stac/stac.py,sha256=eap9aqdLepEdhkoY7PCD1VD-4KwaU7F4rLMeIo7c7F4,1011
+eotdl/datasets/__init__.py,sha256=IKEcRM6TFgEU5mnT-VrR90TGJgyDp1nby1qrdshy9wk,170
+eotdl/datasets/ingest.py,sha256=7hFkCZuN2fNbiJ0hX0bqVgx2k5vVtxwDqjmtquR7CFs,1008
+eotdl/datasets/retrieve.py,sha256=dhNbBJu0vE0l-LsGQNQF5Vc_WzZDRbXPzvd66GNlV6U,691
+eotdl/datasets/stage.py,sha256=7FYAG_k41WYyXilW8gEZ7f77DUkMkqAeHNAqDB6VrY8,2004
+eotdl/datasets/update.py,sha256=x-rpfxnavn9X-7QYkFMGtbn1b3bKmAZydOeS7Tjr5AQ,386
+eotdl/files/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+eotdl/files/ingest.bck,sha256=dgjZfd-ACCKradDo2B02CPahwEhFtWvnKvTm372K5eo,6185
+eotdl/files/ingest.py,sha256=2wEtp6x4jToUkFXW6qREg-C1KzmxYDGGPKGQr8B3LRk,8915
+eotdl/files/metadata.py,sha256=C-NDr-zjM58fP8QcHB1N1QyLRUeYyMbT6wPPnxGk8LI,1370
+eotdl/models/__init__.py,sha256=5mriPl64bzRwcY4O4Bnjt2WeKpX4ab5yXZ3uKzapJfA,158
+eotdl/models/ingest.py,sha256=OnXpYHABJHHIGnu-qSunCb5Usg8pXZFhrHbCVZJx7lk,981
+eotdl/models/retrieve.py,sha256=-Ij7dT4J1p7MW4n13OlPB9OW4tBaBXPwk9dW8IuCZPc,664
+eotdl/models/stage.py,sha256=nlLL5kYOMJPDPR3orhm5ZOZnZrqw0Q37nV6gWylBIbE,1805
+eotdl/models/update.py,sha256=4FWeD95cXvRpefRjw3Foqb30e30otxqWUZ6nQM9cbmM,374
+eotdl/repos/APIRepo.py,sha256=fcMpVbatfJgAq12bGWM828n8UDOixBbf5ueleB_Hrc4,791
+eotdl/repos/AuthAPIRepo.py,sha256=vYCqFawe3xUm2cx4SqVXCvzl8J_sr9rs_MkipYC0bXE,957
+eotdl/repos/AuthRepo.py,sha256=jpzzhINCcDZHRCyrPDsp49h17IlXp2HvX3BB3f5cnb4,1154
+eotdl/repos/DatasetsAPIRepo.py,sha256=Yy22IoiASPmca93r4Rt5lzq28TFQkq3aOl_M4u8VJw8,3236
+eotdl/repos/FilesAPIRepo.py,sha256=le8Xzt1zgB3MmLYoCN46zxcFLQvJXJoOeXQULj1DkCI,11079
+eotdl/repos/ModelsAPIRepo.py,sha256=79euf5WsfUxG5KSIGhKT8T7kSl-NtISwxvqHnck-bq0,2616
+eotdl/repos/STACAPIRepo.py,sha256=YtLd-Wl2mOM4MtT7nCFHd26oeNleq9POKajJuhEt-74,1407
+eotdl/repos/__init__.py,sha256=GIzk62681dvNzYgVzvJgrMzVRhrep4-kJH6lTOtfnT8,258
+eotdl/shared/__init__.py,sha256=mF7doJC8Z5eTPmB01UQvPivThZac32DRY33T6qshXfg,41
+eotdl/shared/checksum.py,sha256=4IB6N9jRO0chMDNJzpdnFDhC9wcFF9bO5oHq2HodcHw,479
+eotdl/tools/__init__.py,sha256=_p3n2dw3ulwyr1OlVw5d_jMV64cNYfajQMUbzFfvIpU,178
+eotdl/tools/geo_utils.py,sha256=JKHUAnqkwiIrvh5voDclWAW-i57qVqH2FUjeOt1TQf4,7547
+eotdl/tools/metadata.py,sha256=RvNmoMdfEKoo-DzhEAqL-f9ZCjIe_bsdHQwACMk6w1E,1664
+eotdl/tools/paths.py,sha256=yWhOtVxX4NxrDrrBX2fuye5N1mAqrxXFy_eA7dffd84,1152
+eotdl/tools/stac.py,sha256=ovXdrPm4Sn9AAJmrP88WnxDmq2Ut-xPoscjphxz3Iyo,5763
+eotdl/tools/time_utils.py,sha256=qJ3-rk1I7ne722SLfAP6-59kahQ0vLQqIf9VpOi0Kpg,4691
+eotdl/tools/tools.py,sha256=Tl4_v2ejkQo_zyZek8oofJwoYcdVosdOwW1C0lvWaNM,6354
+eotdl/wrappers/__init__.py,sha256=IY3DK_5LMbc5bIQFleQA9kzFbPhWuTLesJ8dwfvpkdA,32
+eotdl/wrappers/models.py,sha256=kNO4pYw9KKKmElE7bZWWHGs7FIThNUXj8XciKh_3rNw,6432
+eotdl-2025.3.25.dist-info/METADATA,sha256=zGb2kpfJo_dacJpUd4_GGaznMSJ3QamvXlbbqGP-Iak,4189
+eotdl-2025.3.25.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
+eotdl-2025.3.25.dist-info/entry_points.txt,sha256=s6sfxUfRrSX2IP2UbrzTFTvRCtLgw3_OKcHlOKf_5F8,39
+eotdl-2025.3.25.dist-info/RECORD,,

{eotdl-2024.10.7.dist-info → eotdl-2025.3.25.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.9.0
+Generator: poetry-core 2.1.1
 Root-Is-Purelib: true
 Tag: py3-none-any