datacosmos 0.0.8__py3-none-any.whl → 0.0.10__py3-none-any.whl

datacosmos/config/config.py

@@ -29,6 +29,7 @@ class Config(BaseSettings):
     authentication: Optional[AuthenticationConfig] = None
     stac: Optional[URL] = None
     datacosmos_cloud_storage: Optional[URL] = None
+    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"
@@ -86,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")
@@ -191,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/stac/enums/processing_level.py

@@ -6,10 +6,11 @@ from enum import Enum
 class ProcessingLevel(Enum):
     """Enum class for the processing levels of the data."""
 
-    L0 = "L0"
-    L1A = "L1A"
-    L2A = "L2A"
-    L1B = "L1B"
-    L1C = "L1C"
-    L1D = "L1D"
-    L3 = "L3"
+    RAW = "RAW"
+    L0 = "l0"
+    L1A = "l1A"
+    L2A = "l2A"
+    L1B = "l1B"
+    L1C = "l1C"
+    L1D = "l1D"
+    L3 = "l3"

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

@@ -37,7 +37,7 @@ class UploadPath:
         dt = datetime.strptime(item.properties["datetime"], "%Y-%m-%dT%H:%M:%SZ")
         path = UploadPath(
             mission=mission,
-            level=ProcessingLevel(item.properties["processing:level"].upper()),
+            level=ProcessingLevel(item.properties["processing:level"]),
             day=dt.day,
             month=dt.month,
             year=dt.year,

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.8.dist-info → datacosmos-0.0.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datacosmos
-Version: 0.0.8
+Version: 0.0.10
 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.8.dist-info → datacosmos-0.0.10.dist-info}/RECORD

@@ -1,7 +1,7 @@
 datacosmos/__init__.py,sha256=dVHKpbz5FVtfoJAWHRdsUENG6H-vs4UrkuwnIvOGJr4,66
 datacosmos/datacosmos_client.py,sha256=3BurTz1fPk1Dzp8B5xt5gZZrFiqk1AT5oaqKeYmXPec,6517
 datacosmos/config/__init__.py,sha256=KCsaTb9-ZgFui1GM8wZFIPLJy0D0O8l8Z1Sv3NRD9UM,140
-datacosmos/config/config.py,sha256=qj9e68enxX61Iw8lqEXUUCNJ2O7vy-1j9nAoBIB-4Ao,7219
+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
@@ -19,11 +19,11 @@ datacosmos/stac/collection/models/collection_update.py,sha256=XC6-29nLz1VGWMxYAw
 datacosmos/stac/constants/__init__.py,sha256=dDRSsF7CKqNF44yIlNdE-PD1sp0Q5mhTEPT7hHIK7YE,26
 datacosmos/stac/constants/satellite_name_mapping.py,sha256=EJqNdO9uW5B-sIeDF72AjnW7va5BM9mm4oNwijtl51w,575
 datacosmos/stac/enums/__init__.py,sha256=GUEL2xGtdjsrszrxivs0X6daxkaZs2JsTu2JoBtsvB4,22
-datacosmos/stac/enums/processing_level.py,sha256=5gHG-0kG5rCUxmXYwF3t94ALKk6zUqguOdyTL-jwgps,247
+datacosmos/stac/enums/processing_level.py,sha256=kWGhpMXgzoyTzwR4yoSFd3UQ5IBw3cUf3TaM1FaOtUg,263
 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,10 +31,12 @@ 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=FDBUSZ9mpieXi3dms3RM17aIrnRuAKd0rFkD7Jwl1pY,4195
-datacosmos/uploader/dataclasses/__init__.py,sha256=IjcyA8Vod-z1_Gi1FMZhK58Owman0foL25Hs0YtkYYs,43
-datacosmos/uploader/dataclasses/upload_path.py,sha256=5QadynHxkJrnOk1lyPtLyiVAHdzBshEuhjA9hwVF0NI,1903
+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=2Nvk51j4s6Cyse9y9sKmN3rQLV7oIMNtokpnt4_qTaw,1895
 datacosmos/utils/__init__.py,sha256=XQbAnoqJrPpnSpEzAbjh84yqYWw8cBM8mNp8ynTG-54,50
 datacosmos/utils/url.py,sha256=iQwZr6mYRoePqUZg-k3KQSV9o2wju5ZuCa5WS_GyJo4,2114
 datacosmos/utils/http_response/__init__.py,sha256=BvOWwC5coYqq_kFn8gIw5m54TLpdfJKlW9vgRkfhXiA,33
@@ -42,8 +44,8 @@ datacosmos/utils/http_response/check_api_response.py,sha256=dKWW01jn2_lWV0xpOBAB
 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.8.dist-info/licenses/LICENSE.md,sha256=vpbRI-UUbZVQfr3VG_CXt9HpRnL1b5kt8uTVbirxeyI,1486
-datacosmos-0.0.8.dist-info/METADATA,sha256=tK8nQIG9_5zJ-gCQPQB7S2q6z7HabdgYdpPLfkinP9g,896
-datacosmos-0.0.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-datacosmos-0.0.8.dist-info/top_level.txt,sha256=ueobs5CNeyDbPMgXPcVV0d0yNdm8CvGtDT3CaksRVtA,11
-datacosmos-0.0.8.dist-info/RECORD,,
+datacosmos-0.0.10.dist-info/licenses/LICENSE.md,sha256=vpbRI-UUbZVQfr3VG_CXt9HpRnL1b5kt8uTVbirxeyI,1486
+datacosmos-0.0.10.dist-info/METADATA,sha256=9LtN2v3bq397TTrDhL4MZ-euAt6S8YixPT6nXqy2UZs,897
+datacosmos-0.0.10.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+datacosmos-0.0.10.dist-info/top_level.txt,sha256=ueobs5CNeyDbPMgXPcVV0d0yNdm8CvGtDT3CaksRVtA,11
+datacosmos-0.0.10.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,101 +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
-
-
-class DatacosmosUploader:
-    """Handles uploading files to Datacosmos storage and registering STAC items."""
-
-    def __init__(self, client: DatacosmosClient):
-        """Initialize the uploader with DatacosmosClient."""
-        self.environment = client.config.environment
-
-        self.datacosmos_client = client
-        self.item_client = ItemClient(client)
-        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, mission_name: str = "") -> str:
-        """Constructs the storage upload path based on the item and mission name."""
-        return UploadPath.from_item_path(item, 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