datacosmos 0.0.2__py3-none-any.whl → 0.0.4__py3-none-any.whl

config/config.py

@@ -6,7 +6,7 @@ and supports environment variable-based overrides.
 """
 
 import os
-from typing import ClassVar, Optional
+from typing import ClassVar, Literal, Optional
 
 import yaml
 from pydantic import field_validator
@@ -27,6 +27,9 @@ class Config(BaseSettings):
 
     authentication: Optional[M2MAuthenticationConfig] = None
     stac: Optional[URL] = None
+    datacosmos_cloud_storage: Optional[URL] = None
+    mission_id: int = 0
+    environment: Literal["local", "test", "prod"] = "test"
 
     DEFAULT_AUTH_TYPE: ClassVar[str] = "m2m"
     DEFAULT_AUTH_TOKEN_URL: ClassVar[str] = "https://login.open-cosmos.com/oauth/token"
@@ -77,7 +80,20 @@ class Config(BaseSettings):
             path=os.getenv("OC_STAC_PATH", "/api/data/v0/stac"),
         )
 
-        return cls(authentication=authentication_config, stac=stac_config)
+        datacosmos_cloud_storage_config = URL(
+            protocol=os.getenv("DC_CLOUD_STORAGE_PROTOCOL", "https"),
+            host=os.getenv("DC_CLOUD_STORAGE_HOST", "app.open-cosmos.com"),
+            port=int(os.getenv("DC_CLOUD_STORAGE_PORT", "443")),
+            path=os.getenv("DC_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"),
+        )
 
     @field_validator("authentication", mode="before")
     @classmethod
@@ -96,7 +112,7 @@ class Config(BaseSettings):
             ValueError: If authentication is missing or required fields are not set.
         """
         if not auth_data:
-            cls.raise_missing_auth_error()
+            return cls.apply_auth_defaults(M2MAuthenticationConfig())
 
         auth = cls.parse_auth_config(auth_data)
         auth = cls.apply_auth_defaults(auth)
@@ -105,34 +121,24 @@ class Config(BaseSettings):
         return auth
 
     @staticmethod
-    def raise_missing_auth_error():
-        """Raise an error when authentication is missing."""
-        raise ValueError(
-            "M2M authentication is required. Provide it via:\n"
-            "1. Explicit instantiation (Config(authentication=...))\n"
-            "2. A YAML config file (config.yaml)\n"
-            "3. Environment variables (OC_AUTH_CLIENT_ID, OC_AUTH_CLIENT_SECRET, etc.)"
-        )
-
-    @staticmethod
-    def parse_auth_config(auth_data: dict) -> M2MAuthenticationConfig:
-        """Convert dictionary input to M2MAuthenticationConfig object."""
-        return (
-            M2MAuthenticationConfig(**auth_data)
-            if isinstance(auth_data, dict)
-            else auth_data
-        )
-
-    @classmethod
-    def apply_auth_defaults(
-        cls, auth: M2MAuthenticationConfig
-    ) -> M2MAuthenticationConfig:
+    def apply_auth_defaults(auth: M2MAuthenticationConfig) -> M2MAuthenticationConfig:
         """Apply default authentication values if they are missing."""
-        auth.type = auth.type or cls.DEFAULT_AUTH_TYPE
-        auth.token_url = auth.token_url or cls.DEFAULT_AUTH_TOKEN_URL
-        auth.audience = auth.audience or cls.DEFAULT_AUTH_AUDIENCE
+        auth.type = auth.type or Config.DEFAULT_AUTH_TYPE
+        auth.token_url = auth.token_url or Config.DEFAULT_AUTH_TOKEN_URL
+        auth.audience = auth.audience or Config.DEFAULT_AUTH_AUDIENCE
         return auth
 
+    @classmethod
+    def parse_auth_config(cls, auth_data: dict) -> M2MAuthenticationConfig:
+        """Parse authentication config from a dictionary."""
+        return M2MAuthenticationConfig(
+            type=auth_data.get("type", cls.DEFAULT_AUTH_TYPE),
+            token_url=auth_data.get("token_url", cls.DEFAULT_AUTH_TOKEN_URL),
+            audience=auth_data.get("audience", cls.DEFAULT_AUTH_AUDIENCE),
+            client_id=auth_data.get("client_id"),
+            client_secret=auth_data.get("client_secret"),
+        )
+
     @staticmethod
     def check_required_auth_fields(auth: M2MAuthenticationConfig):
         """Ensure required fields (client_id, client_secret) are provided."""
@@ -165,3 +171,25 @@ class Config(BaseSettings):
                 path="/api/data/v0/stac",
             )
         return stac_config
+
+    @field_validator("datacosmos_cloud_storage", mode="before")
+    @classmethod
+    def validate_datacosmos_cloud_storage(
+        cls, datacosmos_cloud_storage_config: Optional[URL]
+    ) -> URL:
+        """Ensure datacosmos cloud storage configuration has a default if not explicitly set.
+
+        Args:
+            datacosmos_cloud_storage_config (Optional[URL]): The datacosmos cloud storage config to validate.
+
+        Returns:
+            URL: The validated datacosmos cloud storage configuration.
+        """
+        if datacosmos_cloud_storage_config is None:
+            return URL(
+                protocol="https",
+                host="app.open-cosmos.com",
+                port=443,
+                path="/api/data/v0/storage",
+            )
+        return datacosmos_cloud_storage_config

datacosmos/stac/collection/collection_client.py

@@ -6,6 +6,7 @@ from pystac import Collection, Extent, SpatialExtent, TemporalExtent
 from pystac.utils import str_to_datetime
 
 from datacosmos.datacosmos_client import DatacosmosClient
+from datacosmos.exceptions.datacosmos_exception import DatacosmosException
 from datacosmos.stac.collection.models.collection_update import CollectionUpdate
 from datacosmos.utils.http_response.check_api_response import check_api_response
 
@@ -145,5 +146,8 @@ class CollectionClient:
         """
         try:
             return next_href.split("?")[1].split("=")[-1]
-        except (IndexError, AttributeError):
-            raise InvalidRequest(f"Failed to parse pagination token from {next_href}")
+        except (IndexError, AttributeError) as e:
+            raise DatacosmosException(
+                f"Failed to parse pagination token from {next_href}",
+                response=e.response,
+            ) from e

datacosmos/stac/collection/models/collection_update.py

@@ -2,6 +2,7 @@
 
 Allows partial updates where only the provided fields are modified.
 """
+
 from typing import Any, Dict, List, Optional
 
 from pydantic import BaseModel, Field

datacosmos/stac/constants/__init__.py

@@ -0,0 +1 @@
+"""Constants for STAC."""

datacosmos/stac/constants/satellite_name_mapping.py

@@ -0,0 +1,20 @@
+"""Satellite name mapping."""
+
+SATELLITE_NAME_MAPPING = {
+    "GEOSAT-2": "2014-033D",
+    "SUPERVIEW-1-01": "2016-083A",
+    "SUPERVIEW-1-02": "2016-083B",
+    "SUPERVIEW-1-03": "2018-002A",
+    "SUPERVIEW-1-04": "2018-002B",
+    "MANTIS": "2023-174B",
+    "MENUT": "2023-001B",
+    "HAMMER": "2024-043BC",
+    "HAMMER-EM": "COSPAR-HAMMER-EM-TBD",
+    "Alisio": "2023-185M",
+    "Platero": "2023-174G",
+    "PHISAT-2": "2024-149C",
+    "PHISAT-2 EM": "COSPAR-PHISAT2-EM-TBD",
+    "Sentinel-2A": "2015-028A",
+    "Sentinel-2B": "2017-013A",
+    "Sentinel-2C": "2024-157A",
+}

datacosmos/stac/enums/__init__.py

@@ -0,0 +1 @@
+"""Enums for STAC."""

datacosmos/stac/enums/processing_level.py

@@ -0,0 +1,15 @@
+"""Level enum class."""
+
+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"

datacosmos/stac/enums/product_type.py

@@ -0,0 +1,11 @@
+"""Product type enum class."""
+
+from enum import Enum
+
+
+class ProductType(str, Enum):
+    """Different product types."""
+
+    SATELLITE = "Satellite"
+    VECTOR = "Vector"
+    INSIGHT = "Insight"

datacosmos/stac/enums/season.py

@@ -0,0 +1,14 @@
+"""Season enum class."""
+
+from enum import Enum
+
+
+class Season(str, Enum):
+    """Different Open Cosmos seasons."""
+
+    SUMMER = "Summer"
+    WINTER = "Winter"
+    AUTUMN = "Autumn"
+    SPRING = "Spring"
+    RAINY = "Rainy"
+    DRY = "Dry"

datacosmos/stac/item/item_client.py

@@ -9,6 +9,10 @@ from pystac import Item
 
 from datacosmos.datacosmos_client import DatacosmosClient
 from datacosmos.exceptions.datacosmos_exception import DatacosmosException
+from datacosmos.stac.item.models.catalog_search_parameters import (
+    CatalogSearchParameters,
+)
+from datacosmos.stac.item.models.datacosmos_item import DatacosmosItem
 from datacosmos.stac.item.models.item_update import ItemUpdate
 from datacosmos.stac.item.models.search_parameters import SearchParameters
 from datacosmos.utils.http_response.check_api_response import check_api_response
@@ -58,20 +62,23 @@ class ItemClient:
 
         return self.search_items(parameters)
 
-    def search_items(self, parameters: SearchParameters) -> Generator[Item, None, None]:
+    def search_items(
+        self, parameters: CatalogSearchParameters, project_id: str
+    ) -> Generator[Item, None, None]:
         """Query the STAC catalog using the POST endpoint with filtering and pagination.
 
         Args:
-            parameters (SearchParameters): The search parameters.
+            parameters (CatalogSearchParameters): The search parameters.
 
         Yields:
             Item: Parsed STAC item.
         """
         url = self.base_url.with_suffix("/search")
-        body = parameters.model_dump(by_alias=True, exclude_none=True)
+        parameters_query = parameters.to_query()
+        body = {"project": project_id, "limit": 50, "query": parameters_query}
         return self._paginate_items(url, body)
 
-    def create_item(self, collection_id: str, item: Item) -> None:
+    def create_item(self, collection_id: str, item: Item | DatacosmosItem) -> None:
         """Create a new STAC item in a specified collection.
 
         Args:

datacosmos/stac/item/models/asset.py

@@ -0,0 +1,23 @@
+"""Model representing a datacosmos item asset."""
+
+from pydantic import BaseModel, Field
+
+from datacosmos.stac.item.models.eo_band import EoBand
+from datacosmos.stac.item.models.raster_band import RasterBand
+
+
+class Asset(BaseModel):
+    """Model representing a datacosmos item asset."""
+
+    href: str
+    title: str
+    description: str
+    type: str
+    roles: list[str] | None
+    eo_bands: list[EoBand] | None = Field(default=None, alias="eo:bands")
+    raster_bands: list[RasterBand] | None = Field(default=None, alias="raster:bands")
+
+    class Config:
+        """Pydantic configuration."""
+
+        populate_by_name = True

datacosmos/stac/item/models/catalog_search_parameters.py

@@ -0,0 +1,132 @@
+"""Query parameters for catalog search."""
+
+from datetime import datetime, timedelta
+from typing import Any, List, Optional
+
+from pydantic import BaseModel, field_validator, model_validator
+
+from datacosmos.stac.constants.satellite_name_mapping import SATELLITE_NAME_MAPPING
+from datacosmos.stac.enums.processing_level import ProcessingLevel
+from datacosmos.stac.enums.product_type import ProductType
+from datacosmos.stac.enums.season import Season
+
+
+class CatalogSearchParameters(BaseModel):
+    """Query parameters for catalog search."""
+
+    start_date: Optional[str] = None
+    end_date: Optional[str] = None
+    seasons: Optional[List[Season]] = None
+    satellite: Optional[List[str]] = None
+    product_type: Optional[List[ProductType]] = None
+    processing_level: Optional[List[ProcessingLevel]] = None
+
+    # --- Field Validators ---
+
+    @field_validator("seasons", mode="before")
+    @classmethod
+    def parse_seasons(cls, value):
+        """Parses seasons values into a list of Season object."""
+        if value is None:
+            return None
+        return [Season(v) if not isinstance(v, Season) else v for v in value]
+
+    @field_validator("product_type", mode="before")
+    @classmethod
+    def parse_product_types(cls, value):
+        """Parses product types values into a list of ProductType object."""
+        if value is None:
+            return None
+        return [ProductType(v) if not isinstance(v, ProductType) else v for v in value]
+
+    @field_validator("processing_level", mode="before")
+    @classmethod
+    def parse_processing_levels(cls, value):
+        """Parses processing levels values into a list of ProcessingLevel object."""
+        if value is None:
+            return None
+        return [
+            ProcessingLevel(v) if not isinstance(v, ProcessingLevel) else v
+            for v in value
+        ]
+
+    @field_validator("start_date", mode="before")
+    @classmethod
+    def parse_start_date(cls, value: Any) -> Optional[str]:
+        """Validations on start_date."""
+        if value is None:
+            return None
+        try:
+            dt = datetime.strptime(value, "%m/%d/%Y")
+            if dt < datetime(2015, 5, 15):
+                raise ValueError("Date must be 5/15/2015 or later.")
+            return dt.isoformat() + "Z"
+        except ValueError:
+            raise ValueError(
+                "Invalid start_date format. Use mm/dd/yyyy (e.g., 05/15/2024)"
+            )
+
+    @field_validator("end_date", mode="before")
+    @classmethod
+    def parse_end_date(cls, value: Any) -> Optional[str]:
+        """Validations on end_date."""
+        if value is None:
+            return None
+        try:
+            dt = datetime.strptime(value, "%m/%d/%Y")
+            if dt < datetime(2015, 5, 15):
+                raise ValueError("Date must be 5/15/2015 or later.")
+            dt = dt + timedelta(days=1) - timedelta(milliseconds=1)
+            return dt.isoformat() + "Z"
+        except ValueError:
+            raise ValueError(
+                "Invalid end_date format. Use mm/dd/yyyy (e.g., 05/15/2024)"
+            )
+
+    # --- Model Validator ---
+
+    @model_validator(mode="after")
+    def validate_date_range(self) -> "CatalogSearchParameters":
+        """Checks if end_date is after the start_date."""
+        if self.start_date and self.end_date:
+            start_dt = datetime.fromisoformat(self.start_date.rstrip("Z"))
+            end_dt = datetime.fromisoformat(self.end_date.rstrip("Z"))
+            if start_dt > end_dt:
+                raise ValueError("end_date cannot be before start_date.")
+        return self
+
+    # --- Query Mapper ---
+
+    def to_query(self) -> dict:
+        """Map user-friendly input to STAC query structure."""
+        query = {}
+
+        if self.start_date or self.end_date:
+            query["datetime"] = {"gte": self.start_date, "lte": self.end_date}
+
+        if self.seasons:
+            query["opencosmos:season"] = {
+                "in": [seasons.value for seasons in self.seasons]
+            }
+
+        if self.product_type:
+            query["opencosmos:product_type"] = {
+                "in": [product_type.value for product_type in self.product_type]
+            }
+
+        if self.processing_level:
+            query["processing:level"] = {
+                "in": [
+                    processing_level.value for processing_level in self.processing_level
+                ]
+            }
+
+        if self.satellite:
+            cospars = [
+                SATELLITE_NAME_MAPPING[ui]
+                for ui in self.satellite
+                if ui in SATELLITE_NAME_MAPPING
+            ]
+            query["sat:platform_international_designator"] = {"in": cospars}
+
+        return query

datacosmos/stac/item/models/datacosmos_item.py

@@ -0,0 +1,55 @@
+"""Model representing a datacosmos item."""
+
+from datetime import datetime
+
+from pydantic import BaseModel
+
+from datacosmos.stac.enums.processing_level import ProcessingLevel
+from datacosmos.stac.item.models.asset import Asset
+
+
+class DatacosmosItem(BaseModel):
+    """Model representing a datacosmos item."""
+
+    id: str
+    type: str
+    stac_version: str
+    stac_extensions: list | None
+    geometry: dict
+    properties: dict
+    links: list
+    assets: dict[str, Asset]
+    collection: str
+    bbox: tuple[float, float, float, float]
+
+    def get_property(self, key: str) -> str | None:
+        """Get a property value from the Datacosmos item."""
+        return self.properties.get(key)
+
+    def get_asset(self, key: str) -> Asset | None:
+        """Get an asset from the Datacosmos item."""
+        return self.assets.get(key)
+
+    @property
+    def datetime(self) -> datetime:
+        """Get the datetime of the Datacosmos item."""
+        return datetime.strptime(self.properties["datetime"], "%Y-%m-%dT%H:%M:%SZ")
+
+    @property
+    def level(self) -> ProcessingLevel:
+        """Get the processing level of the Datacosmos item."""
+        return ProcessingLevel(self.properties["processing:level"].lower())
+
+    @property
+    def sat_int_designator(self) -> str:
+        """Get the satellite international designator of the Datacosmos item."""
+        property = self.get_property("sat:platform_international_designator")
+        if property is None:
+            raise ValueError(
+                "sat:platform_international_designator is missing in STAC item"
+            )
+        return property
+
+    def to_dict(self) -> dict:
+        """Converts the DatacosmosItem instance to a dictionary."""
+        return self.model_dump()

datacosmos/stac/item/models/eo_band.py

@@ -0,0 +1,15 @@
+"""Model representing an EO band."""
+
+from typing import Optional
+
+from pydantic import BaseModel
+
+
+class EoBand(BaseModel):
+    """Model representing an EO band."""
+
+    name: str
+    common_name: str
+    center_wavelength: float
+    full_width_half_max: float
+    solar_illumination: Optional[float] = None

datacosmos/stac/item/models/raster_band.py

@@ -0,0 +1,17 @@
+"""Model representing a raster band."""
+
+from pydantic import BaseModel, Field
+
+
+class RasterBand(BaseModel):
+    """Model representing a raster band."""
+
+    gain: float = Field(alias="scale")
+    bias: float = Field(alias="offset")
+    nodata: int
+    unit: str
+
+    class Config:
+        """Pydantic configuration."""
+
+        populate_by_name = True

datacosmos/uploader/__init__.py

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

datacosmos/uploader/dataclasses/__init__.py

@@ -0,0 +1 @@
+"""Dataclasses for the uploader module."""

datacosmos/uploader/dataclasses/upload_path.py

@@ -0,0 +1,93 @@
+"""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.level import Level
+from datacosmos.stac.item.models.datacosmos_item import DatacosmosItem
+from datacosmos.utils.missions import get_mission_id
+
+logger = structlog.get_logger()
+
+
+@dataclass
+class UploadPath:
+    """Dataclass for retrieving the upload path of a file."""
+
+    mission: str
+    level: Level
+    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."""
+        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,
+            level=Level(item.properties["processing:level"].lower()),
+            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=Level(parts[1]),
+            day=int(parts[4]),
+            month=int(parts[3]),
+            year=int(parts[2]),
+            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/uploader/datacosmos_uploader.py

@@ -0,0 +1,106 @@
+"""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(str(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

@@ -0,0 +1,16 @@
+"""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

@@ -0,0 +1,27 @@
+"""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}")

datacosmos/utils/url.py

@@ -35,3 +35,26 @@ class URL:
         """
         base = self.string()
         return f"{base.rstrip('/')}/{suffix.lstrip('/')}"
+
+    def with_base(self, url: str) -> str:
+        """Replaces the base of the url with the base stored in the URL object. (migrates url from one base to another).
+
+        Args:
+            url (str): url to migrate to the base of the URL object
+
+        Returns (str):
+            url with the base of the URL object
+        """
+        split_url = url.split("/")
+        if len(split_url) < 3 or url.find("://") == -1:
+            raise ValueError(f"URL '{url}' does not meet the minimum requirements")
+        # get the whole path
+        url_path = "/".join(split_url[3:])
+        # simple case, matching self.base at url
+        b = self.base.lstrip("/")
+        if (base_pos := url_path.find(b)) != -1:
+            # remove the base from the url
+            url_suffix = url_path[len(b) + base_pos :]
+        else:
+            url_suffix = url_path
+        return self.with_suffix(url_suffix)

{datacosmos-0.0.2.dist-info → datacosmos-0.0.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: datacosmos
-Version: 0.0.2
+Version: 0.0.4
 Summary: A library for interacting with DataCosmos from Python code
 Author-email: Open Cosmos <support@open-cosmos.com>
 Classifier: Programming Language :: Python :: 3
@@ -13,6 +13,7 @@ Requires-Dist: oauthlib==3.2.0
 Requires-Dist: requests-oauthlib==1.3.1
 Requires-Dist: pydantic==2.10.6
 Requires-Dist: pystac==1.12.1
+Requires-Dist: pyyaml==6.0.2
 Provides-Extra: dev
 Requires-Dist: black==22.3.0; extra == "dev"
 Requires-Dist: ruff==0.9.5; extra == "dev"
@@ -20,3 +21,4 @@ Requires-Dist: pytest==7.2.0; extra == "dev"
 Requires-Dist: bandit[toml]==1.7.4; extra == "dev"
 Requires-Dist: isort==5.11.4; extra == "dev"
 Requires-Dist: pydocstyle==6.1.1; extra == "dev"
+Dynamic: license-file

datacosmos-0.0.4.dist-info/RECORD

@@ -0,0 +1,49 @@
+config/__init__.py,sha256=KCsaTb9-ZgFui1GM8wZFIPLJy0D0O8l8Z1Sv3NRD9UM,140
+config/config.py,sha256=h5XwNSA6QFBCDyennyFDNMAmbQOdtg8DsFAvjHlSEx4,7233
+config/models/__init__.py,sha256=r3lThPkyKjBjUZXRNscFzOrmn_-m_i9DvG3RePfCFYc,41
+config/models/m2m_authentication_config.py,sha256=1eJ_9df7Twn5WeWPbqMuR63ZdxhnTpBtKzqAPMnzP_k,565
+config/models/url.py,sha256=fwr2C06e_RDS8AWxOV_orVxMWhc57bzYoWSjFxQbkwg,835
+datacosmos/__init__.py,sha256=dVHKpbz5FVtfoJAWHRdsUENG6H-vs4UrkuwnIvOGJr4,66
+datacosmos/datacosmos_client.py,sha256=sivVYf45QEHTkUO62fnb1fnObKVmUngTR1Ga-ZRnoQE,4967
+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/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
+datacosmos/stac/collection/models/collection_update.py,sha256=XC6-29nLz1VGWMxYAw7r1OuL8PdJ3b2oI-RPvnM-XXI,1657
+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/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=ib848Pb2j6njvbx97vFFw7AWeKyBnBlK-05D3pFmIdU,7027
+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=VKMBnaTYjpn_zAM6wdk3P69ZoGBcqdzPcTGBlYPFvVk,4704
+datacosmos/stac/item/models/datacosmos_item.py,sha256=AImz0GRxrpZfIETdzzNfaKX35wpr39Q4f4u0z6r8eys,1745
+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/stac/item/models/search_parameters.py,sha256=yMmcb-Tr2as8585MD5wuZLWcqzwtRRkj07WBkootVS0,2022
+datacosmos/uploader/__init__.py,sha256=ZtfCVJ_pWKKh2F1r_NArnbG3_JtpcEiXcA_tmSwSKmQ,128
+datacosmos/uploader/datacosmos_uploader.py,sha256=LUtBDvAjZI7AYxKnC9TZQDP4z6lV2aHusz92XqivFGw,4398
+datacosmos/uploader/dataclasses/__init__.py,sha256=IjcyA8Vod-z1_Gi1FMZhK58Owman0foL25Hs0YtkYYs,43
+datacosmos/uploader/dataclasses/upload_path.py,sha256=WPl9u-oB-ti07ssKNDjL4vRQXhlOmLCgjt8MxFGrf3A,3153
+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.4.dist-info/licenses/LICENSE.md,sha256=vpbRI-UUbZVQfr3VG_CXt9HpRnL1b5kt8uTVbirxeyI,1486
+datacosmos-0.0.4.dist-info/METADATA,sha256=8yM44qsv1vBDxutLlUte916Z6zgPVT0mnyR1Bz2drJ8,872
+datacosmos-0.0.4.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
+datacosmos-0.0.4.dist-info/top_level.txt,sha256=Iu5b533Fmdfz0rFKTnuBPjSUOQL2lEkTfHxsokP72s4,18
+datacosmos-0.0.4.dist-info/RECORD,,

{datacosmos-0.0.2.dist-info → datacosmos-0.0.4.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.8.0)
+Generator: setuptools (80.7.1)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

datacosmos-0.0.2.dist-info/RECORD

@@ -1,32 +0,0 @@
-config/__init__.py,sha256=KCsaTb9-ZgFui1GM8wZFIPLJy0D0O8l8Z1Sv3NRD9UM,140
-config/config.py,sha256=0M2wKmrcCJjte3UmLNQVags_qce7Id2ampBPqadzPJw,5908
-config/models/__init__.py,sha256=r3lThPkyKjBjUZXRNscFzOrmn_-m_i9DvG3RePfCFYc,41
-config/models/m2m_authentication_config.py,sha256=1eJ_9df7Twn5WeWPbqMuR63ZdxhnTpBtKzqAPMnzP_k,565
-config/models/url.py,sha256=fwr2C06e_RDS8AWxOV_orVxMWhc57bzYoWSjFxQbkwg,835
-datacosmos/__init__.py,sha256=dVHKpbz5FVtfoJAWHRdsUENG6H-vs4UrkuwnIvOGJr4,66
-datacosmos/datacosmos_client.py,sha256=sivVYf45QEHTkUO62fnb1fnObKVmUngTR1Ga-ZRnoQE,4967
-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/collection/__init__.py,sha256=VQMLnsU3sER5kh4YxHrHP7XCA3DG1y0n9yoSmvycOY0,212
-datacosmos/stac/collection/collection_client.py,sha256=XTO2s309-cktJosvnwnFFXHDVmJc4vjvbEsZjpsCDmY,5904
-datacosmos/stac/collection/models/__init__.py,sha256=TQaihUS_CM9Eaekm4SbzFTNfv7BmabHv3Z-f37Py5Qs,40
-datacosmos/stac/collection/models/collection_update.py,sha256=Tqmfg4H4UQj5jsgy1dpKJCR59NSfWeiCSi9y8CY8-Cg,1656
-datacosmos/stac/item/__init__.py,sha256=lRuD_yp-JxoLqBA23q0XMkCNImf4T-X3BJnSw9u_3Yk,200
-datacosmos/stac/item/item_client.py,sha256=AYyRR92Wy-rDwc9wFoljb6lAgSCuWft4VT5muqGeyv8,6738
-datacosmos/stac/item/models/__init__.py,sha256=bcOrOcIxGxGBrRVIyQVxSM3C3Xj_qzxIHgQeWo6f7Q8,34
-datacosmos/stac/item/models/item_update.py,sha256=_CpjQn9SsfedfuxlHSiGeptqY4M-p15t9YX__mBRueI,2088
-datacosmos/stac/item/models/search_parameters.py,sha256=yMmcb-Tr2as8585MD5wuZLWcqzwtRRkj07WBkootVS0,2022
-datacosmos/utils/__init__.py,sha256=XQbAnoqJrPpnSpEzAbjh84yqYWw8cBM8mNp8ynTG-54,50
-datacosmos/utils/url.py,sha256=luaGa6UqPIf0h_1u2z3CZ32YQXNl7nGV03lVW7mlRIM,1214
-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.2.dist-info/LICENSE.md,sha256=vpbRI-UUbZVQfr3VG_CXt9HpRnL1b5kt8uTVbirxeyI,1486
-datacosmos-0.0.2.dist-info/METADATA,sha256=SIuvO1SE647Q9OvrKYuj1VmzWFgKjErvrRxrKoNgcyk,821
-datacosmos-0.0.2.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-datacosmos-0.0.2.dist-info/top_level.txt,sha256=Iu5b533Fmdfz0rFKTnuBPjSUOQL2lEkTfHxsokP72s4,18
-datacosmos-0.0.2.dist-info/RECORD,,