datacosmos 0.0.10__tar.gz → 0.0.12__tar.gz

{datacosmos-0.0.10 → datacosmos-0.0.12}/PKG-INFO

@@ -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.12/datacosmos/config/models/url.py

@@ -0,0 +1,54 @@
+"""Structured URL configuration model for the Datacosmos SDK.
+
+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 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."""
+
+    protocol: str
+    host: str
+    port: int
+    path: str
+
+    @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")
+
+            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,
+            port=self.port,
+            base=self.path,
+        )

{datacosmos-0.0.10 → datacosmos-0.0.12}/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-0.0.12/datacosmos/stac/storage/dataclasses/upload_path.py

@@ -0,0 +1,42 @@
+"""Dataclass for generating the upload key of an asset."""
+
+from dataclasses import dataclass
+from pathlib import Path
+
+from datacosmos.stac.item.models.datacosmos_item import DatacosmosItem
+
+
+@dataclass
+class UploadPath:
+    """Storage key in the form: project/<project-id>/<item-id>/<asset-name>."""
+
+    project_id: str
+    item_id: str
+    asset_name: str
+
+    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,
+        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) -> "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-0.0.10 → datacosmos-0.0.12}/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-0.0.10 → datacosmos-0.0.12}/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 → datacosmos-0.0.12}/datacosmos.egg-info/PKG-INFO

@@ -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 → datacosmos-0.0.12}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "datacosmos"
-version = "0.0.10"
+version = "0.0.12"
 authors = [
     { name="Open Cosmos", email="support@open-cosmos.com" },
 ]

datacosmos-0.0.10/datacosmos/config/models/url.py

@@ -1,35 +0,0 @@
-"""Module defining a structured URL configuration model.
-
-Ensures that URLs contain required components such as protocol, host,
-port, and path.
-"""
-
-from pydantic import BaseModel
-
-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.
-    """
-
-    protocol: str
-    host: str
-    port: int
-    path: str
-
-    def as_domain_url(self) -> DomainURL:
-        """Convert the URL instance to a `DomainURL` object.
-
-        Returns:
-            DomainURL: A domain-specific URL object.
-        """
-        return DomainURL(
-            protocol=self.protocol,
-            host=self.host,
-            port=self.port,
-            base=self.path,
-        )

datacosmos-0.0.10/datacosmos/stac/storage/dataclasses/upload_path.py

@@ -1,63 +0,0 @@
-"""Dataclass for retrieving the upload path of a file."""
-
-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."""
-
-    mission: str
-    level: ProcessingLevel
-    day: int
-    month: int
-    year: int
-    id: str
-    path: 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("/")
-
-    @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__)
-
-    @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:]),
-        )