datacosmos 0.0.7__py3-none-any.whl → 0.0.9__py3-none-any.whl

datacosmos/config/config.py

@@ -29,7 +29,7 @@ class Config(BaseSettings):
     authentication: Optional[AuthenticationConfig] = None
     stac: Optional[URL] = None
     datacosmos_cloud_storage: Optional[URL] = None
-    mission_id: int = 0
+    datacosmos_public_cloud_storage: Optional[URL] = None
 
     DEFAULT_AUTH_TYPE: ClassVar[str] = "m2m"
     DEFAULT_AUTH_TOKEN_URL: ClassVar[str] = "https://login.open-cosmos.com/oauth/token"
@@ -87,12 +87,18 @@ class Config(BaseSettings):
             path=os.getenv("DC_CLOUD_STORAGE_PATH", "/api/data/v0/storage"),
         )
 
+        datacosmos_public_cloud_storage_config = URL(
+            protocol=os.getenv("DC_PUBLIC_CLOUD_STORAGE_PROTOCOL", "https"),
+            host=os.getenv("DC_PUBLIC_CLOUD_STORAGE_HOST", "app.open-cosmos.com"),
+            port=int(os.getenv("DC_PUBLIC_CLOUD_STORAGE_PORT", "443")),
+            path=os.getenv("DC_PUBLIC_CLOUD_STORAGE_PATH", "/api/data/v0/storage"),
+        )
+
         return cls(
             authentication=authentication_config,
             stac=stac_config,
             datacosmos_cloud_storage=datacosmos_cloud_storage_config,
-            mission_id=int(os.getenv("MISSION_ID", "0")),
-            environment=os.getenv("ENVIRONMENT", "test"),
+            datacosmos_public_cloud_storage=datacosmos_public_cloud_storage_config,
         )
 
     @field_validator("authentication", mode="after")
@@ -192,3 +198,25 @@ class Config(BaseSettings):
                 path="/api/data/v0/storage",
             )
         return datacosmos_cloud_storage_config
+
+    @field_validator("datacosmos_public_cloud_storage", mode="before")
+    @classmethod
+    def validate_datacosmos_public_cloud_storage(
+        cls, datacosmos_public_cloud_storage_config: Optional[URL]
+    ) -> URL:
+        """Ensure datacosmos cloud storage configuration has a default if not explicitly set.
+
+        Args:
+            datacosmos_public_cloud_storage_config (Optional[URL]): The datacosmos public cloud storage config to validate.
+
+        Returns:
+            URL: The validated datacosmos public cloud storage configuration.
+        """
+        if datacosmos_public_cloud_storage_config is None:
+            return URL(
+                protocol="https",
+                host="app.open-cosmos.com",
+                port=443,
+                path="/api/data/v0/storage",
+            )
+        return datacosmos_public_cloud_storage_config

datacosmos/datacosmos_client.py

@@ -1,8 +1,4 @@
-"""DatacosmosClient handles authenticated interactions with the Datacosmos API.
-
-Automatically manages token refreshing and provides HTTP convenience
-methods.
-"""
+"""Client to interact with the Datacosmos API with authentication and request handling."""
 
 from datetime import datetime, timedelta, timezone
 from typing import Any, Optional
@@ -19,23 +15,57 @@ from datacosmos.exceptions.datacosmos_exception import DatacosmosException
 class DatacosmosClient:
     """Client to interact with the Datacosmos API with authentication and request handling."""
 
-    def __init__(self, config: Optional[Config] = None):
+    def __init__(
+        self,
+        config: Optional[Config | Any] = None,
+        http_session: Optional[requests.Session | OAuth2Session] = None,
+    ):
         """Initialize the DatacosmosClient.
 
         Args:
-            config (Optional[Config]): Configuration object.
+            config (Optional[Config]): Configuration object (only needed when SDK creates its own session).
+            http_session (Optional[requests.Session]): Pre-authenticated session.
         """
-        if config:
-            self.config = config
-        else:
+        if http_session is not None:
+            self._http_client = http_session
+            self._owns_session = False
+            if isinstance(http_session, OAuth2Session):
+                token_data = http_session.token
+            elif isinstance(http_session, requests.Session):
+                auth_header = http_session.headers.get("Authorization", "")
+                if not auth_header.startswith("Bearer "):
+                    raise DatacosmosException(
+                        "Injected requests.Session must include a 'Bearer' token in its headers"
+                    )
+                token_data = {"access_token": auth_header.split(" ", 1)[1]}
+            else:
+                raise DatacosmosException(
+                    f"Unsupported session type: {type(http_session)}"
+                )
             try:
-                self.config = Config.from_yaml()
-            except ValueError:
-                self.config = Config.from_env()
+                self.token = token_data.get("access_token")
+                self.token_expiry = token_data.get("expires_at") or token_data.get(
+                    "expires_in"
+                )
+            except Exception:
+                raise DatacosmosException(
+                    "Failed to extract token from injected session"
+                )
 
-        self.token = None
-        self.token_expiry = None
-        self._http_client = self._authenticate_and_initialize_client()
+            self.config = config
+        else:
+            if config:
+                self.config = config
+            else:
+                try:
+                    self.config = Config.from_yaml()
+                except ValueError:
+                    self.config = Config.from_env()
+
+            self._owns_session = True
+            self.token = None
+            self.token_expiry = None
+            self._http_client = self._authenticate_and_initialize_client()
 
     def _authenticate_and_initialize_client(self) -> requests.Session:
         """Authenticate and initialize the HTTP client with a valid token."""
@@ -68,8 +98,10 @@ class DatacosmosClient:
             ) from e
 
     def _refresh_token_if_needed(self):
-        """Refresh the token if it has expired."""
-        if not self.token or self.token_expiry <= datetime.now(timezone.utc):
+        """Refresh the token if it has expired (only if SDK created it)."""
+        if self._owns_session and (
+            not self.token or self.token_expiry <= datetime.now(timezone.utc)
+        ):
             self._http_client = self._authenticate_and_initialize_client()
 
     def request(

datacosmos/stac/item/item_client.py

@@ -62,21 +62,60 @@ class ItemClient:
             body = body | {"collections": parameters.collections}
         return self._paginate_items(url, body)
 
-    def create_item(self, collection_id: str, item: Item | DatacosmosItem) -> None:
-        """Create a new STAC item in a specified collection.
+    def create_item(self, item: Item | DatacosmosItem) -> None:
+        """Create a new STAC item in its own collection.
+
+        The collection ID is inferred from the item.
 
         Args:
-            collection_id (str): The ID of the collection where the item will be created.
-            item (Item): The STAC Item to be created.
+            item (Item | DatacosmosItem): The STAC item to be created.
 
         Raises:
+            ValueError: If the item has no collection set.
             RequestError: If the API returns an error response.
         """
+        if isinstance(item, Item):
+            collection_id = item.collection_id or (
+                item.get_collection().id if item.get_collection() else None
+            )
+        else:
+            collection_id = item.collection
+
+        if not collection_id:
+            raise ValueError("Cannot create item: no collection_id found on item")
+
         url = self.base_url.with_suffix(f"/collections/{collection_id}/items")
         item_json: dict = item.to_dict()
         response = self.client.post(url, json=item_json)
         check_api_response(response)
 
+    def add_item(self, item: Item | DatacosmosItem) -> None:
+        """Adds item to catalog.
+
+        The collection ID is inferred from the item.
+
+        Args:
+            item (Item | DatacosmosItem): The STAC item to be created.
+
+        Raises:
+            ValueError: If the item has no collection set.
+            RequestError: If the API returns an error response.
+        """
+        if isinstance(item, Item):
+            collection_id = item.collection_id or (
+                item.get_collection().id if item.get_collection() else None
+            )
+        else:
+            collection_id = item.collection
+
+        if not collection_id:
+            raise ValueError("Cannot create item: no collection_id found on item")
+
+        url = self.base_url.with_suffix(f"/collections/{collection_id}/items/{item.id}")
+        item_json: dict = item.to_dict()
+        response = self.client.put(url, json=item_json)
+        check_api_response(response)
+
     def update_item(
         self, item_id: str, collection_id: str, update_data: ItemUpdate
     ) -> None:

datacosmos/stac/stac_client.py

@@ -2,11 +2,14 @@
 
 from datacosmos.stac.collection.collection_client import CollectionClient
 from datacosmos.stac.item.item_client import ItemClient
+from datacosmos.stac.storage.storage_client import StorageClient
 
 
-class STACClient(ItemClient, CollectionClient):
+class STACClient(ItemClient, CollectionClient, StorageClient):
     """Unified interface for STAC API, combining Item & Collection operations."""
 
     def __init__(self, client):
         """Initialize the STACClient with a DatacosmosClient."""
-        super().__init__(client)
+        ItemClient.__init__(self, client)
+        CollectionClient.__init__(self, client)
+        StorageClient.__init__(self, client)

datacosmos/stac/storage/__init__.py

@@ -0,0 +1,5 @@
+"""Facade module for all storage-related operations."""
+
+from datacosmos.stac.storage.storage_client import StorageClient
+
+__all__ = ["StorageClient"]

datacosmos/{uploader → stac/storage}/dataclasses/upload_path.py

@@ -8,7 +8,6 @@ import structlog
 
 from datacosmos.stac.enums.processing_level import ProcessingLevel
 from datacosmos.stac.item.models.datacosmos_item import DatacosmosItem
-from datacosmos.utils.missions import get_mission_id
 
 logger = structlog.get_logger()
 
@@ -35,11 +34,6 @@ class UploadPath:
         cls, item: DatacosmosItem, mission: str, item_path: str
     ) -> "Path":
         """Create a Path instance from a DatacosmosItem and a path."""
-        for asset in item.assets.values():
-            if mission == "":
-                mission = cls._get_mission_name(asset.href)
-            else:
-                break
         dt = datetime.strptime(item.properties["datetime"], "%Y-%m-%dT%H:%M:%SZ")
         path = UploadPath(
             mission=mission,
@@ -67,27 +61,3 @@ class UploadPath:
             id=parts[5],
             path="/".join(parts[6:]),
         )
-
-    @classmethod
-    def _get_mission_name(cls, href: str) -> str:
-        mission = ""
-        # bruteforce mission name from asset path
-        # traverse the path and check if any part is a mission name (generates a mission id)
-        href_parts = href.split("/")
-        for idx, part in enumerate(href_parts):
-            try:
-                # when an id is found, then the mission name is valid
-                get_mission_id(
-                    part, "test"
-                )  # using test as it is more wide and anything on prod should exists on test
-            except KeyError:
-                continue
-            # validate the mission name by checking if the path is correct
-            # using the same logic as the __str__ method
-            mission = part.lower()
-            h = "/".join(["full", *href_parts[idx:]])
-            p = UploadPath.from_path("/".join([mission, *href_parts[idx + 1 :]]))
-            if str(p) != h:
-                raise ValueError(f"Could not find mission name in asset path {href}")
-            break
-        return mission

datacosmos/stac/storage/storage_base.py

@@ -0,0 +1,40 @@
+"""Base class providing common storage helpers (threading, MIME guess, futures)."""
+
+import mimetypes
+from concurrent.futures import ThreadPoolExecutor, wait
+
+from datacosmos.datacosmos_client import DatacosmosClient
+
+
+class StorageBase:
+    """Base class providing common storage helpers (threading, MIME guess, futures)."""
+
+    def __init__(self, client: DatacosmosClient):
+        """Base class providing common storage helpers (threading, MIME guess, futures)."""
+        self.client = client
+        self.base_url = client.config.datacosmos_cloud_storage.as_domain_url()
+
+    def _guess_mime(self, src: str) -> str:
+        mime, _ = mimetypes.guess_type(src)
+        return mime or "application/octet-stream"
+
+    def _run_in_threads(self, fn, fn_args, max_workers: int, timeout: float):
+        """Run the callable `fn(*args)` over the iterable of jobs in parallel threads.
+
+        `jobs` should be a list of tuples, each tuple unpacked as fn(*args).
+        """
+        futures = []
+        with ThreadPoolExecutor(max_workers=max_workers) as executor:
+            for args in fn_args:
+                futures.append(executor.submit(fn, *args))
+        done, not_done = wait(futures, timeout=timeout)
+        errors = []
+        for future in done:
+            try:
+                future.result()
+            except Exception as e:
+                errors.append(e)
+        for future in not_done:
+            future.cancel()
+        if errors:
+            raise errors[0]

datacosmos/stac/storage/storage_client.py

@@ -0,0 +1,31 @@
+"""Generic StorageClient for all storage operations (upload, download, etc.)."""
+
+from datacosmos.datacosmos_client import DatacosmosClient
+from datacosmos.stac.item.models.datacosmos_item import DatacosmosItem
+from datacosmos.stac.storage.uploader import Uploader
+
+
+class StorageClient:
+    """Generic StorageClient for all storage operations (upload, download, etc.)."""
+
+    def __init__(self, client: DatacosmosClient):
+        """Generic StorageClient for all storage operations (upload, download, etc.)."""
+        self.client = client
+        self.uploader = Uploader(client)
+
+    def upload_item(
+        self,
+        item: DatacosmosItem,
+        assets_path: str | None = None,
+        included_assets: list[str] | bool = True,
+        max_workers: int = 4,
+        time_out: float = 60 * 60 * 1,
+    ) -> DatacosmosItem:
+        """Proxy to Uploader.upload_item, without needing to pass client each call."""
+        return self.uploader.upload_item(
+            item=item,
+            assets_path=assets_path,
+            included_assets=included_assets,
+            max_workers=max_workers,
+            time_out=time_out,
+        )

datacosmos/stac/storage/uploader.py

@@ -0,0 +1,98 @@
+"""Handles uploading files to Datacosmos storage and registering STAC items."""
+
+from pathlib import Path
+
+from pydantic import TypeAdapter
+
+from datacosmos.datacosmos_client import DatacosmosClient
+from datacosmos.stac.item.item_client import ItemClient
+from datacosmos.stac.item.models.asset import Asset
+from datacosmos.stac.item.models.datacosmos_item import DatacosmosItem
+from datacosmos.stac.storage.dataclasses.upload_path import UploadPath
+from datacosmos.stac.storage.storage_base import StorageBase
+
+
+class Uploader(StorageBase):
+    """Handles uploading files to Datacosmos storage and registering STAC items."""
+
+    def __init__(self, client: DatacosmosClient):
+        """Handles uploading files to Datacosmos storage and registering STAC items."""
+        super().__init__(client)
+        self.item_client = ItemClient(client)
+
+    def upload_item(
+        self,
+        item: DatacosmosItem,
+        assets_path: str | None = None,
+        included_assets: list[str] | bool = True,
+        max_workers: int = 4,
+        time_out: float = 60 * 60 * 1,
+    ) -> DatacosmosItem:
+        """Upload a STAC item and its assets to Datacosmos."""
+        if not assets_path and not isinstance(item, str):
+            raise ValueError(
+                "assets_path must be provided if item is not the path to an item file."
+            )
+
+        if isinstance(item, str):
+            item_filename = item
+            item = self._load_item(item_filename)
+            if not assets_path:
+                assets_path = str(Path(item_filename).parent)
+
+        assets_path = assets_path or str(Path.cwd())
+
+        upload_assets = (
+            included_assets
+            if isinstance(included_assets, list)
+            else item.assets.keys()
+            if included_assets is True
+            else []
+        )
+
+        jobs = [(item, asset_key, assets_path) for asset_key in upload_assets]
+
+        self._run_in_threads(self._upload_asset, jobs, max_workers, time_out)
+
+        self.item_client.add_item(item)
+
+        return item
+
+    def upload_from_file(
+        self, src: str, dst: str, mime_type: str | None = None
+    ) -> None:
+        """Uploads a single file to the specified destination path."""
+        url = self.base_url.with_suffix(dst)
+        mime = mime_type or self._guess_mime(src)
+        headers = {"Content-Type": mime}
+        with open(src, "rb") as f:
+            response = self.client.put(url, data=f, headers=headers)
+        response.raise_for_status()
+
+    @staticmethod
+    def _load_item(item_json_file_path: str) -> DatacosmosItem:
+        with open(item_json_file_path, "rb") as file:
+            data = file.read().decode("utf-8")
+        return TypeAdapter(DatacosmosItem).validate_json(data)
+
+    def _upload_asset(
+        self, item: DatacosmosItem, asset_key: str, assets_path: str
+    ) -> None:
+        asset = item.assets[asset_key]
+        upload_path = UploadPath.from_item_path(item, "", Path(asset.href).name)
+        local_src = Path(assets_path) / asset.href
+        if local_src.exists():
+            src = str(local_src)
+            asset.href = f"file:///{upload_path}"
+        else:
+            src = str(Path(assets_path) / Path(asset.href).name)
+        self._update_asset_href(asset)
+        self.upload_from_file(src, str(upload_path), mime_type=asset.type)
+
+    def _update_asset_href(self, asset: Asset) -> None:
+        try:
+            url = self.client.config.datacosmos_public_cloud_storage.as_domain_url()
+            new_href = url.with_base(asset.href)  # type: ignore
+            asset.href = str(new_href)
+        except ValueError:
+            pass

{datacosmos-0.0.7.dist-info → datacosmos-0.0.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datacosmos
-Version: 0.0.7
+Version: 0.0.9
 Summary: A library for interacting with DataCosmos from Python code
 Author-email: Open Cosmos <support@open-cosmos.com>
 Classifier: Programming Language :: Python :: 3

{datacosmos-0.0.7.dist-info → datacosmos-0.0.9.dist-info}/RECORD

@@ -1,7 +1,7 @@
 datacosmos/__init__.py,sha256=dVHKpbz5FVtfoJAWHRdsUENG6H-vs4UrkuwnIvOGJr4,66
-datacosmos/datacosmos_client.py,sha256=Uage-PRVRrDWy5frefcR2FClDsdpbFBS4JQC3OCupJU,4978
+datacosmos/datacosmos_client.py,sha256=3BurTz1fPk1Dzp8B5xt5gZZrFiqk1AT5oaqKeYmXPec,6517
 datacosmos/config/__init__.py,sha256=KCsaTb9-ZgFui1GM8wZFIPLJy0D0O8l8Z1Sv3NRD9UM,140
-datacosmos/config/config.py,sha256=xSzri8sr_hRK1JlG0mxuBW5dLQ4ExL00uk3-77Z4wHo,7243
+datacosmos/config/config.py,sha256=3iet6ou0vrcreaJjIFn0s59fyXHnolf026r1qe9PEvY,8487
 datacosmos/config/models/__init__.py,sha256=r3lThPkyKjBjUZXRNscFzOrmn_-m_i9DvG3RePfCFYc,41
 datacosmos/config/models/authentication_config.py,sha256=01Q90-yupbJ5orYDtatZIm9EaL7roQ-oUMoZfFMRzIM,499
 datacosmos/config/models/local_user_account_authentication_config.py,sha256=8WApn720MBXMKQa6w7bCd7Z37GRmYR-I7mBUgUI20lQ,701
@@ -11,7 +11,7 @@ datacosmos/config/models/url.py,sha256=fwr2C06e_RDS8AWxOV_orVxMWhc57bzYoWSjFxQbk
 datacosmos/exceptions/__init__.py,sha256=Crz8W7mOvPUXYcfDVotvjUt_3HKawBpmJA_-uel9UJk,45
 datacosmos/exceptions/datacosmos_exception.py,sha256=rKjJvQDvCEbxXWWccxB5GI_sth662bW8Yml0hX-vRw4,923
 datacosmos/stac/__init__.py,sha256=B4x_Mr4X7TzQoYtRC-VzI4W-fEON5WUOaz8cWJbk3Fc,214
-datacosmos/stac/stac_client.py,sha256=Cz_p96RmAgWX8t7Sye4OJRanQpCLihKStvfEw7IgYZc,472
+datacosmos/stac/stac_client.py,sha256=J4k4aJdakwVK1sorBxeK8KbPtYvjIGa68iqKA_itSgU,654
 datacosmos/stac/collection/__init__.py,sha256=VQMLnsU3sER5kh4YxHrHP7XCA3DG1y0n9yoSmvycOY0,212
 datacosmos/stac/collection/collection_client.py,sha256=-Nn3yqL4mQS05YAMd0IUmv03hdHKYBtVG2_EqoaAQWc,6064
 datacosmos/stac/collection/models/__init__.py,sha256=TQaihUS_CM9Eaekm4SbzFTNfv7BmabHv3Z-f37Py5Qs,40
@@ -23,7 +23,7 @@ datacosmos/stac/enums/processing_level.py,sha256=5gHG-0kG5rCUxmXYwF3t94ALKk6zUqg
 datacosmos/stac/enums/product_type.py,sha256=7lL0unJ1hxevW8Pepn9rmydUUWIORu2x4MEtp6rSFbA,196
 datacosmos/stac/enums/season.py,sha256=QvUzXBYtPEfixhlbV0SAw2u_HK3tRFEnHKshJyIatdg,241
 datacosmos/stac/item/__init__.py,sha256=lRuD_yp-JxoLqBA23q0XMkCNImf4T-X3BJnSw9u_3Yk,200
-datacosmos/stac/item/item_client.py,sha256=mFcbXqV1Ascd5hUSlZFzNgni_DncHAIyIvhtUHpgHI0,6457
+datacosmos/stac/item/item_client.py,sha256=HCHl3cHp0u2qxbwLxPk0xkujC1D4uwIBIFI-flpLXfQ,7783
 datacosmos/stac/item/models/__init__.py,sha256=bcOrOcIxGxGBrRVIyQVxSM3C3Xj_qzxIHgQeWo6f7Q8,34
 datacosmos/stac/item/models/asset.py,sha256=mvg_fenYCGOTMGwXXpK2nyqBk5RMsUYxl6KhQTWW_b0,631
 datacosmos/stac/item/models/catalog_search_parameters.py,sha256=3HrUm37VezujwuCR45jhMryS5m1FGc1XmX8-fdTy4jU,4870
@@ -31,21 +31,21 @@ datacosmos/stac/item/models/datacosmos_item.py,sha256=AImz0GRxrpZfIETdzzNfaKX35w
 datacosmos/stac/item/models/eo_band.py,sha256=YC3Scn_wFhIo51pIVcJeuJienF7JGWoEv39JngDM6rI,309
 datacosmos/stac/item/models/item_update.py,sha256=_CpjQn9SsfedfuxlHSiGeptqY4M-p15t9YX__mBRueI,2088
 datacosmos/stac/item/models/raster_band.py,sha256=CoEVs-YyPE5Fse0He9DdOs4dGZpzfCsCuVzOcdXa_UM,354
-datacosmos/uploader/__init__.py,sha256=ZtfCVJ_pWKKh2F1r_NArnbG3_JtpcEiXcA_tmSwSKmQ,128
-datacosmos/uploader/datacosmos_uploader.py,sha256=QFFzR9Z2KFu_G5EcmvEn251IiwbPAfZSrOYZ_vC3NSg,4393
-datacosmos/uploader/dataclasses/__init__.py,sha256=IjcyA8Vod-z1_Gi1FMZhK58Owman0foL25Hs0YtkYYs,43
-datacosmos/uploader/dataclasses/upload_path.py,sha256=X8zkfw3_FO9qTiKHu-nL_uDmQJYfaov6e4Y2-f-opaU,3204
+datacosmos/stac/storage/__init__.py,sha256=hivfSpOaoSwCAymgU0rTgvSk9LSPAn1cPLQQ9fLmFX0,151
+datacosmos/stac/storage/storage_base.py,sha256=5ioMKbEltPEWr4dkhZQiUhdBFEhe7ajIYUd9z3K8elU,1483
+datacosmos/stac/storage/storage_client.py,sha256=GeWJoa8ALqelZHvmnop_sSuyU7ntFNFXMFQfplIo0kU,1145
+datacosmos/stac/storage/uploader.py,sha256=5W4Wcx2yzdkU9sg93jnwYP0TiZcuxQXB9owfjL2NsBg,3630
+datacosmos/stac/storage/dataclasses/__init__.py,sha256=IjcyA8Vod-z1_Gi1FMZhK58Owman0foL25Hs0YtkYYs,43
+datacosmos/stac/storage/dataclasses/upload_path.py,sha256=5QadynHxkJrnOk1lyPtLyiVAHdzBshEuhjA9hwVF0NI,1903
 datacosmos/utils/__init__.py,sha256=XQbAnoqJrPpnSpEzAbjh84yqYWw8cBM8mNp8ynTG-54,50
-datacosmos/utils/constants.py,sha256=f7pOqCpdXk7WFGoaTyuCpr65jb-TtfhoVGuYTz3_T6Y,272
-datacosmos/utils/missions.py,sha256=7GOnrjxB8V11C_Jr3HHI4vpXifgkOSeirNjIDx17C58,940
 datacosmos/utils/url.py,sha256=iQwZr6mYRoePqUZg-k3KQSV9o2wju5ZuCa5WS_GyJo4,2114
 datacosmos/utils/http_response/__init__.py,sha256=BvOWwC5coYqq_kFn8gIw5m54TLpdfJKlW9vgRkfhXiA,33
 datacosmos/utils/http_response/check_api_response.py,sha256=dKWW01jn2_lWV0xpOBABhEP42CFSsx9dP0iSxykbN54,1186
 datacosmos/utils/http_response/models/__init__.py,sha256=Wj8YT6dqw7rAz_rctllxo5Or_vv8DwopvQvBzwCTvpw,45
 datacosmos/utils/http_response/models/datacosmos_error.py,sha256=Uqi2uM98nJPeCbM7zngV6vHSk97jEAb_nkdDEeUjiQM,740
 datacosmos/utils/http_response/models/datacosmos_response.py,sha256=oV4n-sue7K1wwiIQeHpxdNU8vxeqF3okVPE2rydw5W0,336
-datacosmos-0.0.7.dist-info/licenses/LICENSE.md,sha256=vpbRI-UUbZVQfr3VG_CXt9HpRnL1b5kt8uTVbirxeyI,1486
-datacosmos-0.0.7.dist-info/METADATA,sha256=tCAZlxKlDV8qI9pjgvdREZBffzkwJ4Ko0CMiK9oe2Bg,896
-datacosmos-0.0.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-datacosmos-0.0.7.dist-info/top_level.txt,sha256=ueobs5CNeyDbPMgXPcVV0d0yNdm8CvGtDT3CaksRVtA,11
-datacosmos-0.0.7.dist-info/RECORD,,
+datacosmos-0.0.9.dist-info/licenses/LICENSE.md,sha256=vpbRI-UUbZVQfr3VG_CXt9HpRnL1b5kt8uTVbirxeyI,1486
+datacosmos-0.0.9.dist-info/METADATA,sha256=1vpXTtgxF7gG1CdXSg0nsprKapv5LocXA2lvXaSZFp0,896
+datacosmos-0.0.9.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+datacosmos-0.0.9.dist-info/top_level.txt,sha256=ueobs5CNeyDbPMgXPcVV0d0yNdm8CvGtDT3CaksRVtA,11
+datacosmos-0.0.9.dist-info/RECORD,,

datacosmos/uploader/__init__.py

@@ -1 +0,0 @@
-"""Uploader package for interacting with the Uploader API, providing upload functionalities to the datacosmos cloud storage."""

datacosmos/uploader/datacosmos_uploader.py

@@ -1,106 +0,0 @@
-"""Module for uploading files to Datacosmos cloud storage and registering STAC items."""
-
-from concurrent.futures import ThreadPoolExecutor
-from pathlib import Path
-
-from pydantic import TypeAdapter
-
-from datacosmos.datacosmos_client import DatacosmosClient
-from datacosmos.stac.item.item_client import ItemClient
-from datacosmos.stac.item.models.datacosmos_item import DatacosmosItem
-from datacosmos.uploader.dataclasses.upload_path import UploadPath
-from datacosmos.utils.missions import get_mission_name
-
-
-class DatacosmosUploader:
-    """Handles uploading files to Datacosmos storage and registering STAC items."""
-
-    def __init__(self, client: DatacosmosClient):
-        """Initialize the uploader with DatacosmosClient."""
-        mission_id = client.config.mission_id
-        environment = client.config.environment
-
-        self.datacosmos_client = client
-        self.item_client = ItemClient(client)
-        self.mission_name = (
-            get_mission_name(mission_id, environment) if mission_id != 0 else ""
-        )
-        self.base_url = client.config.datacosmos_cloud_storage.as_domain_url()
-
-    def upload_and_register_item(self, item_json_file_path: str) -> None:
-        """Uploads files to Datacosmos storage and registers a STAC item.
-
-        Args:
-            item_json_file_path (str): Path to the STAC item JSON file.
-        """
-        item = self._load_item(item_json_file_path)
-        collection_id, item_id = item.collection, item.id
-        dirname = str(Path(item_json_file_path).parent / Path(item_json_file_path).stem)
-
-        self._delete_existing_item(collection_id, item_id)
-        upload_path = self._get_upload_path(item)
-        self.upload_from_folder(dirname, upload_path)
-
-        self._update_item_assets(item)
-
-        self.item_client.create_item(collection_id, item)
-
-    def upload_file(self, src: str, dst: str) -> None:
-        """Uploads a single file to the specified destination path."""
-        url = self.base_url.with_suffix(dst)
-
-        with open(src, "rb") as f:
-            response = self.datacosmos_client.put(url, data=f)
-        response.raise_for_status()
-
-    def upload_from_folder(self, src: str, dst: UploadPath, workers: int = 4) -> None:
-        """Uploads all files from a folder to the destination path in parallel."""
-        if Path(dst.path).is_file():
-            raise ValueError(f"Destination path should not be a file path {dst}")
-
-        if Path(src).is_file():
-            raise ValueError(f"Source path should not be a file path {src}")
-
-        with ThreadPoolExecutor(max_workers=workers) as executor:
-            futures = []
-            for file in Path(src).rglob("*"):
-                if file.is_file():
-                    dst = UploadPath(
-                        mission=dst.mission,
-                        level=dst.level,
-                        day=dst.day,
-                        month=dst.month,
-                        year=dst.year,
-                        id=dst.id,
-                        path=str(file.relative_to(src)),
-                    )
-                    futures.append(executor.submit(self.upload_file, str(file), dst))
-            for future in futures:
-                future.result()
-
-    @staticmethod
-    def _load_item(item_json_file_path: str) -> DatacosmosItem:
-        """Loads and validates the STAC item from a JSON file."""
-        with open(item_json_file_path, "rb") as file:
-            data = file.read().decode("utf-8")
-        return TypeAdapter(DatacosmosItem).validate_json(data)
-
-    def _delete_existing_item(self, collection_id: str, item_id: str) -> None:
-        """Deletes an existing item if it already exists."""
-        try:
-            self.item_client.delete_item(item_id, collection_id)
-        except Exception:  # nosec
-            pass  # Ignore if item doesn't exist
-
-    def _get_upload_path(self, item: DatacosmosItem) -> str:
-        """Constructs the storage upload path based on the item and mission name."""
-        return UploadPath.from_item_path(item, self.mission_name, "")
-
-    def _update_item_assets(self, item: DatacosmosItem) -> None:
-        """Updates the item's assets with uploaded file URLs."""
-        for asset in item.assets.values():
-            try:
-                url = self.base_url
-                asset.href = url.with_base(asset.href)  # type: ignore
-            except ValueError:
-                pass

datacosmos/utils/constants.py

@@ -1,16 +0,0 @@
-"""Package for storing constants."""
-
-TEST_MISSION_NAMES = {
-    55: "MENUT",
-    56: "PHISAT-2",
-    57: "HAMMER",
-    63: "MANTIS",
-    64: "PLATERO",
-}
-PROD_MISSION_NAMES = {
-    23: "MENUT",
-    29: "MANTIS",
-    35: "PHISAT-2",
-    37: "PLATERO",
-    48: "HAMMER",
-}

datacosmos/utils/missions.py

@@ -1,27 +0,0 @@
-"""Package for storing mission specific information."""
-
-from datacosmos.utils.constants import PROD_MISSION_NAMES, TEST_MISSION_NAMES
-
-
-def get_mission_name(mission: int, env: str) -> str:
-    """Get the mission name from the mission number."""
-    if env == "test" or env == "local":
-        return TEST_MISSION_NAMES[mission]
-    elif env == "prod":
-        return PROD_MISSION_NAMES[mission]
-    else:
-        raise ValueError(f"Unsupported environment: {env}")
-
-
-def get_mission_id(mission_name: str, env: str) -> int:
-    """Get the mission number from the mission name."""
-    if env == "test" or env == "local":
-        return {v.upper(): k for k, v in TEST_MISSION_NAMES.items()}[
-            mission_name.upper()
-        ]
-    elif env == "prod":
-        return {v.upper(): k for k, v in PROD_MISSION_NAMES.items()}[
-            mission_name.upper()
-        ]
-    else:
-        raise ValueError(f"Unsupported environment: {env}")