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

datacosmos/config/models/url.py

@@ -1,32 +1,51 @@
-"""Module defining a structured URL configuration model.
+"""Structured URL configuration model for the Datacosmos SDK.
 
-Ensures that URLs contain required components such as protocol, host,
-port, and path.
+The model accepts *either* a mapping of fields
+(protocol, host, port, path) **or** a raw URL string such as
+``"https://example.com/api/v1"`` and converts it into a fully featured
+:class:`datacosmos.utils.url.URL` instance via :py:meth:`as_domain_url`.
 """
 
-from pydantic import BaseModel
+from urllib.parse import urlparse
+
+from pydantic import BaseModel, model_validator
 
 from datacosmos.utils.url import URL as DomainURL
 
 
 class URL(BaseModel):
-    """Generic configuration model for a URL.
-
-    This class provides attributes to store URL components and a method
-    to convert them into a `DomainURL` instance.
-    """
+    """Generic configuration model for a URL."""
 
     protocol: str
     host: str
     port: int
     path: str
 
-    def as_domain_url(self) -> DomainURL:
-        """Convert the URL instance to a `DomainURL` object.
+    @model_validator(mode="before")
+    @classmethod
+    def _coerce_from_string(cls, data):
+        """Convert a raw URL string into the dict expected by the model."""
+        if isinstance(data, cls):
+            return data
+
+        if isinstance(data, str):
+            parts = urlparse(data)
+            if not parts.scheme or not parts.hostname:
+                raise ValueError(f"'{data}' is not a valid absolute URL")
 
-        Returns:
-            DomainURL: A domain-specific URL object.
-        """
+            default_port = 443 if parts.scheme == "https" else 80
+
+            return {
+                "protocol": parts.scheme,
+                "host": parts.hostname,
+                "port": parts.port or default_port,
+                "path": parts.path.rstrip("/"),
+            }
+
+        return data
+
+    def as_domain_url(self) -> DomainURL:
+        """Convert this Pydantic model to the utility `DomainURL` object."""
         return DomainURL(
             protocol=self.protocol,
             host=self.host,

datacosmos/stac/stac_client.py

@@ -1,5 +1,6 @@
 """Unified interface for STAC API, combining Item & Collection operations."""
 
+from datacosmos.datacosmos_client import DatacosmosClient
 from datacosmos.stac.collection.collection_client import CollectionClient
 from datacosmos.stac.item.item_client import ItemClient
 from datacosmos.stac.storage.storage_client import StorageClient
@@ -8,7 +9,7 @@ from datacosmos.stac.storage.storage_client import StorageClient
 class STACClient(ItemClient, CollectionClient, StorageClient):
     """Unified interface for STAC API, combining Item & Collection operations."""
 
-    def __init__(self, client):
+    def __init__(self, client: DatacosmosClient):
         """Initialize the STACClient with a DatacosmosClient."""
         ItemClient.__init__(self, client)
         CollectionClient.__init__(self, client)

datacosmos/stac/storage/dataclasses/upload_path.py

@@ -1,63 +1,42 @@
-"""Dataclass for retrieving the upload path of a file."""
+"""Dataclass for generating the upload key of an asset."""
 
 from dataclasses import dataclass
-from datetime import datetime
 from pathlib import Path
 
-import structlog
-
-from datacosmos.stac.enums.processing_level import ProcessingLevel
 from datacosmos.stac.item.models.datacosmos_item import DatacosmosItem
 
-logger = structlog.get_logger()
-
 
 @dataclass
 class UploadPath:
-    """Dataclass for retrieving the upload path of a file."""
+    """Storage key in the form: project/<project-id>/<item-id>/<asset-name>."""
 
-    mission: str
-    level: ProcessingLevel
-    day: int
-    month: int
-    year: int
-    id: str
-    path: str
+    project_id: str
+    item_id: str
+    asset_name: str
 
-    def __str__(self):
-        """Return a human-readable string representation of the Path."""
-        path = f"full/{self.mission.lower()}/{self.level.value.lower()}/{self.year:02}/{self.month:02}/{self.day:02}/{self.id}/{self.path}"
-        return path.removesuffix("/")
+    def __str__(self) -> str:
+        """Path in the form: project/<project-id>/<item-id>/<asset-name>."""
+        return f"project/{self.project_id}/{self.item_id}/{self.asset_name}".rstrip("/")
 
     @classmethod
     def from_item_path(
-        cls, item: DatacosmosItem, mission: str, item_path: str
-    ) -> "Path":
-        """Create a Path instance from a DatacosmosItem and a path."""
-        dt = datetime.strptime(item.properties["datetime"], "%Y-%m-%dT%H:%M:%SZ")
-        path = UploadPath(
-            mission=mission,
-            level=ProcessingLevel(item.properties["processing:level"]),
-            day=dt.day,
-            month=dt.month,
-            year=dt.year,
-            id=item.id,
-            path=item_path,
-        )
-        return cls(**path.__dict__)
+        cls,
+        item: DatacosmosItem,
+        project_id: str,
+        asset_name: str,
+    ) -> "UploadPath":
+        """Create an UploadPath for the given item/asset."""
+        return cls(project_id=project_id, item_id=item.id, asset_name=asset_name)
 
     @classmethod
-    def from_path(cls, path: str) -> "Path":
-        """Create a Path instance from a string path."""
-        parts = path.split("/")
-        if len(parts) < 7:
-            raise ValueError(f"Invalid path {path}")
-        return cls(
-            mission=parts[0],
-            level=ProcessingLevel(parts[1]),
-            day=int(parts[4]),
-            month=int(parts[3]),
-            year=int(parts[2]),
-            id=parts[5],
-            path="/".join(parts[6:]),
-        )
+    def from_path(cls, path: str) -> "UploadPath":
+        """Reverse-parse a storage key back into its components."""
+        parts = Path(path).parts
+        if len(parts) < 4 or parts[0] != "project":
+            raise ValueError(f"Invalid path: {path}")
+
+        project_id, item_id, *rest = parts[1:]
+        asset_name = "/".join(rest)
+        if not asset_name:
+            raise ValueError(f"Asset name is missing in path: {path}")
+        return cls(project_id=project_id, item_id=item_id, asset_name=asset_name)

datacosmos/stac/storage/storage_client.py

@@ -16,6 +16,7 @@ class StorageClient:
     def upload_item(
         self,
         item: DatacosmosItem,
+        project_id: str,
         assets_path: str | None = None,
         included_assets: list[str] | bool = True,
         max_workers: int = 4,
@@ -24,6 +25,7 @@ class StorageClient:
         """Proxy to Uploader.upload_item, without needing to pass client each call."""
         return self.uploader.upload_item(
             item=item,
+            project_id=project_id,
             assets_path=assets_path,
             included_assets=included_assets,
             max_workers=max_workers,

datacosmos/stac/storage/uploader.py

@@ -13,22 +13,37 @@ from datacosmos.stac.storage.storage_base import StorageBase
 
 
 class Uploader(StorageBase):
-    """Handles uploading files to Datacosmos storage and registering STAC items."""
+    """Upload a STAC item and its assets to Datacosmos storage, then register the item in the STAC API."""
 
     def __init__(self, client: DatacosmosClient):
-        """Handles uploading files to Datacosmos storage and registering STAC items."""
+        """Initialize the uploader.
+
+        Args:
+            client (DatacosmosClient): Pre-configured DatacosmosClient.
+        """
         super().__init__(client)
         self.item_client = ItemClient(client)
 
     def upload_item(
         self,
-        item: DatacosmosItem,
+        item: DatacosmosItem | str,
+        project_id: str,
         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."""
+        """Upload a STAC item (and optionally its assets) to Datacosmos.
+
+        `item` can be either:
+          • a DatacosmosItem instance, or
+          • the path to an item JSON file on disk.
+
+        If `included_assets` is:
+          • True  → upload every asset in the item
+          • list  → upload only the asset keys in that list
+          • False → upload nothing; just register the item
+        """
         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."
@@ -37,8 +52,7 @@ class Uploader(StorageBase):
         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(item_filename).parent)
 
         assets_path = assets_path or str(Path.cwd())
 
@@ -50,18 +64,18 @@ class Uploader(StorageBase):
             else []
         )
 
-        jobs = [(item, asset_key, assets_path) for asset_key in upload_assets]
-
+        jobs = [
+            (item, asset_key, assets_path, project_id) 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."""
+        """Upload a single file to the specified destination path in storage."""
         url = self.base_url.with_suffix(dst)
         mime = mime_type or self._guess_mime(src)
         headers = {"Content-Type": mime}
@@ -71,25 +85,40 @@ class Uploader(StorageBase):
 
     @staticmethod
     def _load_item(item_json_file_path: str) -> DatacosmosItem:
+        """Load a DatacosmosItem from a JSON file on disk."""
         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
+        self, item: DatacosmosItem, asset_key: str, assets_path: str, project_id: str
     ) -> None:
+        """Upload a single asset file and update its href inside the item object.
+
+        Runs in parallel via _run_in_threads().
+        """
         asset = item.assets[asset_key]
-        upload_path = UploadPath.from_item_path(item, "", Path(asset.href).name)
+
+        # Build storage key: project/<project_id>/<item_id>/<asset_name>
+        upload_path = UploadPath.from_item_path(
+            item,
+            project_id,
+            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:
+            # fallback: try matching just the filename inside assets_path
             src = str(Path(assets_path) / Path(asset.href).name)
-        self._update_asset_href(asset)
+
+        self._update_asset_href(asset)  # turn href into public URL
         self.upload_from_file(src, str(upload_path), mime_type=asset.type)
 
     def _update_asset_href(self, asset: Asset) -> None:
+        """Convert the storage key to a public HTTPS URL."""
         try:
             url = self.client.config.datacosmos_public_cloud_storage.as_domain_url()
             new_href = url.with_base(asset.href)  # type: ignore

{datacosmos-0.0.10.dist-info → datacosmos-0.0.12.dist-info}/METADATA

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

@@ -7,11 +7,11 @@ datacosmos/config/models/authentication_config.py,sha256=01Q90-yupbJ5orYDtatZIm9
 datacosmos/config/models/local_user_account_authentication_config.py,sha256=8WApn720MBXMKQa6w7bCd7Z37GRmYR-I7mBUgUI20lQ,701
 datacosmos/config/models/m2m_authentication_config.py,sha256=n76N4bakpPPycTOeKpiM8pazYtNqiJGMzZXmI_ogbHM,847
 datacosmos/config/models/no_authentication_config.py,sha256=x5xikSGPuqQbrf_S2oIWXo5XxAORci2sSE5KyJvZHVw,312
-datacosmos/config/models/url.py,sha256=fwr2C06e_RDS8AWxOV_orVxMWhc57bzYoWSjFxQbkwg,835
+datacosmos/config/models/url.py,sha256=bBeulXQ2c-tLJyIoo3sTi9SPsZIyIDn_D2zmkCGWp9s,1597
 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=J4k4aJdakwVK1sorBxeK8KbPtYvjIGa68iqKA_itSgU,654
+datacosmos/stac/stac_client.py,sha256=S0HESbZhlIdS0x_VSCeOSuOFaB50U4CMnTOX_0zLjn8,730
 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
@@ -33,10 +33,10 @@ datacosmos/stac/item/models/item_update.py,sha256=_CpjQn9SsfedfuxlHSiGeptqY4M-p1
 datacosmos/stac/item/models/raster_band.py,sha256=CoEVs-YyPE5Fse0He9DdOs4dGZpzfCsCuVzOcdXa_UM,354
 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/storage_client.py,sha256=4boqQ3zVMrk9X2IXus-Cs429juLe0cUQ0XEzg_y3yOA,1205
+datacosmos/stac/storage/uploader.py,sha256=cUe-6DbcEXcENReDMaQe4etVCW1n2kPMxQlCuB8YnqU,4635
 datacosmos/stac/storage/dataclasses/__init__.py,sha256=IjcyA8Vod-z1_Gi1FMZhK58Owman0foL25Hs0YtkYYs,43
-datacosmos/stac/storage/dataclasses/upload_path.py,sha256=2Nvk51j4s6Cyse9y9sKmN3rQLV7oIMNtokpnt4_qTaw,1895
+datacosmos/stac/storage/dataclasses/upload_path.py,sha256=gbpV67FECFNyXn-yGUSuLvGGWHtibbZq7Qu9yGod3C0,1398
 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
@@ -44,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.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-0.0.12.dist-info/licenses/LICENSE.md,sha256=vpbRI-UUbZVQfr3VG_CXt9HpRnL1b5kt8uTVbirxeyI,1486
+datacosmos-0.0.12.dist-info/METADATA,sha256=HvFc03wc5mu0XRmfl5Xw7iP8qxyC7Cmz-VFXQJjxQuo,897
+datacosmos-0.0.12.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+datacosmos-0.0.12.dist-info/top_level.txt,sha256=ueobs5CNeyDbPMgXPcVV0d0yNdm8CvGtDT3CaksRVtA,11
+datacosmos-0.0.12.dist-info/RECORD,,