eotdl 2025.2.10__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-2025.2.10.dist-info → eotdl-2025.3.25.dist-info}/METADATA

@@ -1,23 +1,36 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.3
 Name: eotdl
-Version: 2025.2.10
+Version: 2025.3.25
 Summary: Earth Observation Training Data Lab
-Author-email: earthpulse <it@earthpulse.es>
-License-Expression: MIT
-Requires-Python: >=3.8
-Requires-Dist: geomet>=1.1.0
-Requires-Dist: geopandas>=0.13.2
-Requires-Dist: markdown>=3.7
-Requires-Dist: pydantic>=2.10.6
-Requires-Dist: pyjwt>=2.9.0
-Requires-Dist: pystac>=1.8.4
-Requires-Dist: python-frontmatter>=1.1.0
-Requires-Dist: pyyaml>=6.0.2
-Requires-Dist: rasterio>=1.3.11
-Requires-Dist: requests>=2.32.3
-Requires-Dist: sentinelhub>=3.11.1
-Requires-Dist: tqdm>=4.67.1
-Requires-Dist: typer>=0.15.1
+License: MIT
+Author: EarthPulse
+Author-email: it@earthpulse.es
+Requires-Python: >=3.8,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+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)
+Requires-Dist: markdown (>=3.5.2,<4.0.0)
+Requires-Dist: markdownify (>=0.11.6,<0.12.0)
+Requires-Dist: mypy (>=1.6.1,<2.0.0)
+Requires-Dist: openeo (>=0.31.0,<0.32.0)
+Requires-Dist: pydantic (>=1.10.6,<2.0.0)
+Requires-Dist: pyjwt (>=2.6.0,<3.0.0)
+Requires-Dist: pystac[validation] (==1.8.2)
+Requires-Dist: python-frontmatter (>=1.1.0,<2.0.0)
+Requires-Dist: pyyaml (>=6.0.1,<7.0.0)
+Requires-Dist: rasterio (>=1.3.9,<2.0.0)
+Requires-Dist: requests (>=2.28.2,<3.0.0)
+Requires-Dist: sentinelhub (>=3.9.1,<4.0.0)
+Requires-Dist: tqdm (>=4.65.0,<5.0.0)
+Requires-Dist: typer[all] (>=0.9.0,<0.10.0)
 Description-Content-Type: text/markdown
 
 <p align="center">
@@ -50,4 +63,4 @@ One of the most limiting factors of AI for EO applications is the scarcity of su
 
 Generating TDS is time consuming and expensive. Data access is usually limited and costly, especially for Very High Resolution (VHR) images that allow objects like trees to be clearly identified. In some cases, domain experts or even in-person (in-situ) trips are required to manually confirm the objects in a satellite image are correctly annotated with a high degree of quality. This results in the field of AI for EO applications lagging when compared to other fields, impeding the development of new applications and limiting the full potential of AI in EO.
 
-The European Space Agency (ESA) Earth Observation Training Data Lab (EOTDL) will address key limitations and capability gaps for working with Machine Learning (ML) training data in EO by providing a set of open-source tools to create, share, and improve datasets as well as training ML algorithms in the cloud. EOTDL will also offer an online repository where datasets and models can be explored and accessed.
+The European Space Agency (ESA) Earth Observation Training Data Lab (EOTDL) will address key limitations and capability gaps for working with Machine Learning (ML) training data in EO by providing a set of open-source tools to create, share, and improve datasets as well as training ML algorithms in the cloud. EOTDL will also offer an online repository where datasets and models can be explored and accessed.

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-2025.2.10.dist-info → eotdl-2025.3.25.dist-info}/WHEEL

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

eotdl-2025.3.25.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+eotdl=eotdl.cli:app
+