datacosmos 0.0.1__tar.gz → 0.0.2__tar.gz

{datacosmos-0.0.1 → datacosmos-0.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: datacosmos
-Version: 0.0.1
+Version: 0.0.2
 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.1 → datacosmos-0.0.2}/README.md

@@ -11,7 +11,7 @@ The **DataCosmos SDK** allows Open Cosmos' customers to interact with the **Data
 The easiest way to install the SDK is via **pip**:
 
 ```sh
-pip install datacosmos
+pip install datacosmos=={version}
 ```
 
 ## Getting Started
@@ -22,7 +22,7 @@ The recommended way to initialize the SDK is by passing a `Config` object with a
 
 ```python
 from datacosmos.datacosmos_client import DatacosmosClient
-from datacosmos.config import Config
+from config.config import Config
 
 config = Config(
     authentication={
@@ -114,7 +114,7 @@ stac_client.delete_collection(collection_id)
 #### 1. **Search Items**
 
 ```python
-from datacosmos.stac.models.search_parameters import SearchParameters
+from datacosmos.stac.item.models.search_parameters import SearchParameters
 
 parameters = SearchParameters(collections=["example-collection"], limit=1)
 items = list(stac_client.search_items(parameters=parameters))
@@ -135,35 +135,53 @@ items = stac_client.fetch_collection_items(collection_id="example-collection")
 #### 4. **Create a New STAC Item**
 
 ```python
-from pystac import Item, Asset
 from datetime import datetime
+from pystac import Item, Asset
+from pystac.utils import str_to_datetime
 
 stac_item = Item(
-    id="new-item",
-    geometry={"type": "Point", "coordinates": [102.0, 0.5]},
-    bbox=[101.0, 0.0, 103.0, 1.0],
-    datetime=datetime.utcnow(),
-    properties={},
-    collection="example-collection"
+    id="MENUT_000001418_20240211120920_20240211120932_new_release.tiff",
+    geometry={
+        "type": "Polygon",
+        "coordinates": [
+            [
+                [-24.937406454761664, 64.5931773445667],
+                [-19.6596824245997, 64.5931773445667],
+                [-19.6596824245997, 63.117895100111724],
+                [-24.937406454761664, 63.117895100111724],
+                [-24.937406454761664, 64.5931773445667]
+            ]
+        ]
+    },
+    bbox=[
+        -24.937406454761664,
+        63.117895100111724,
+        -19.6596824245997,
+        64.5931773445667
+    ],
+    datetime=str_to_datetime("2024-02-11T12:09:32Z"),
+    properties={"processing:level": "L0"},
+    collection="menut-l0",
 )
 
 stac_item.add_asset(
-    "image",
+    "thumbnail",
     Asset(
-        href="https://example.com/sample-image.tiff",
-        media_type="image/tiff",
-        roles=["data"],
-        title="Sample Image"
+        href="https://test.app.open-cosmos.com/api/data/v0/storage/full/menut/l0/2024/02/11/MENUT_000001418_20240211120920_20240211120932.tiff/thumbnail.webp",
+        media_type="image/webp",
+        roles=["thumbnail"],
+        title="Thumbnail",
+        description="Thumbnail of the image"
     )
 )
 
-stac_client.create_item(collection_id="example-collection", item=stac_item)
+stac_client.create_item(collection_id="menutl-l0", item=stac_item)
 ```
 
 #### 5. **Update an Existing STAC Item**
 
 ```python
-from datacosmos.stac.models.item_update import ItemUpdate
+from datacosmos.stac.item.models.item_update import ItemUpdate
 from pystac import Asset, Link
 
 update_payload = ItemUpdate(

datacosmos-0.0.2/config/__init__.py

@@ -0,0 +1,5 @@
+"""Configuration package for the Datacosmos SDK.
+
+This package includes modules for loading and managing authentication
+configurations.
+"""

datacosmos-0.0.2/config/config.py

@@ -0,0 +1,167 @@
+"""Configuration module for the Datacosmos SDK.
+
+Handles configuration management using Pydantic and Pydantic Settings.
+It loads default values, allows overrides via YAML configuration files,
+and supports environment variable-based overrides.
+"""
+
+import os
+from typing import ClassVar, Optional
+
+import yaml
+from pydantic import field_validator
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+from config.models.m2m_authentication_config import M2MAuthenticationConfig
+from config.models.url import URL
+
+
+class Config(BaseSettings):
+    """Centralized configuration for the Datacosmos SDK."""
+
+    model_config = SettingsConfigDict(
+        env_nested_delimiter="__",
+        nested_model_default_partial_update=True,
+        extra="allow",
+    )
+
+    authentication: Optional[M2MAuthenticationConfig] = None
+    stac: Optional[URL] = None
+
+    DEFAULT_AUTH_TYPE: ClassVar[str] = "m2m"
+    DEFAULT_AUTH_TOKEN_URL: ClassVar[str] = "https://login.open-cosmos.com/oauth/token"
+    DEFAULT_AUTH_AUDIENCE: ClassVar[str] = "https://beeapp.open-cosmos.com"
+
+    @classmethod
+    def from_yaml(cls, file_path: str = "config/config.yaml") -> "Config":
+        """Load configuration from a YAML file and override defaults.
+
+        Args:
+            file_path (str): The path to the YAML configuration file.
+
+        Returns:
+            Config: An instance of the Config class with loaded settings.
+        """
+        config_data: dict = {}
+        if os.path.exists(file_path):
+            with open(file_path, "r") as f:
+                yaml_data = yaml.safe_load(f) or {}
+                # Remove empty values from YAML to avoid overwriting with `None`
+                config_data = {
+                    key: value
+                    for key, value in yaml_data.items()
+                    if value not in [None, ""]
+                }
+
+        return cls(**config_data)
+
+    @classmethod
+    def from_env(cls) -> "Config":
+        """Load configuration from environment variables.
+
+        Returns:
+            Config: An instance of the Config class with settings loaded from environment variables.
+        """
+        authentication_config = M2MAuthenticationConfig(
+            type=os.getenv("OC_AUTH_TYPE", cls.DEFAULT_AUTH_TYPE),
+            client_id=os.getenv("OC_AUTH_CLIENT_ID"),
+            client_secret=os.getenv("OC_AUTH_CLIENT_SECRET"),
+            token_url=os.getenv("OC_AUTH_TOKEN_URL", cls.DEFAULT_AUTH_TOKEN_URL),
+            audience=os.getenv("OC_AUTH_AUDIENCE", cls.DEFAULT_AUTH_AUDIENCE),
+        )
+
+        stac_config = URL(
+            protocol=os.getenv("OC_STAC_PROTOCOL", "https"),
+            host=os.getenv("OC_STAC_HOST", "app.open-cosmos.com"),
+            port=int(os.getenv("OC_STAC_PORT", "443")),
+            path=os.getenv("OC_STAC_PATH", "/api/data/v0/stac"),
+        )
+
+        return cls(authentication=authentication_config, stac=stac_config)
+
+    @field_validator("authentication", mode="before")
+    @classmethod
+    def validate_authentication(
+        cls, auth_data: Optional[dict]
+    ) -> M2MAuthenticationConfig:
+        """Ensure authentication is provided and apply defaults.
+
+        Args:
+            auth_data (Optional[dict]): The authentication config as a dictionary.
+
+        Returns:
+            M2MAuthenticationConfig: The validated authentication configuration.
+
+        Raises:
+            ValueError: If authentication is missing or required fields are not set.
+        """
+        if not auth_data:
+            cls.raise_missing_auth_error()
+
+        auth = cls.parse_auth_config(auth_data)
+        auth = cls.apply_auth_defaults(auth)
+
+        cls.check_required_auth_fields(auth)
+        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:
+        """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
+        return auth
+
+    @staticmethod
+    def check_required_auth_fields(auth: M2MAuthenticationConfig):
+        """Ensure required fields (client_id, client_secret) are provided."""
+        missing_fields = [
+            field
+            for field in ("client_id", "client_secret")
+            if not getattr(auth, field)
+        ]
+        if missing_fields:
+            raise ValueError(
+                f"Missing required authentication fields: {', '.join(missing_fields)}"
+            )
+
+    @field_validator("stac", mode="before")
+    @classmethod
+    def validate_stac(cls, stac_config: Optional[URL]) -> URL:
+        """Ensure STAC configuration has a default if not explicitly set.
+
+        Args:
+            stac_config (Optional[URL]): The STAC config to validate.
+
+        Returns:
+            URL: The validated STAC configuration.
+        """
+        if stac_config is None:
+            return URL(
+                protocol="https",
+                host="app.open-cosmos.com",
+                port=443,
+                path="/api/data/v0/stac",
+            )
+        return stac_config

datacosmos-0.0.2/config/models/__init__.py

@@ -0,0 +1 @@
+"""Models for configuration settings."""

datacosmos-0.0.2/config/models/m2m_authentication_config.py

@@ -0,0 +1,23 @@
+"""Module for configuring machine-to-machine (M2M) authentication.
+
+Used when running scripts in the cluster that require automated authentication
+without user interaction.
+"""
+
+from typing import Literal
+
+from pydantic import BaseModel
+
+
+class M2MAuthenticationConfig(BaseModel):
+    """Configuration for machine-to-machine authentication.
+
+    This is used when running scripts in the cluster that require authentication
+    with client credentials.
+    """
+
+    type: Literal["m2m"]
+    client_id: str
+    token_url: str
+    audience: str
+    client_secret: str

datacosmos-0.0.2/config/models/url.py

@@ -0,0 +1,35 @@
+"""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.2/datacosmos/exceptions/__init__.py

@@ -0,0 +1 @@
+"""Exceptions for the datacosmos package."""

datacosmos-0.0.2/datacosmos/exceptions/datacosmos_exception.py

@@ -0,0 +1,27 @@
+"""Base exception class for all Datacosmos SDK exceptions."""
+
+from typing import Optional
+
+from requests import Response
+from requests.exceptions import RequestException
+
+
+class DatacosmosException(RequestException):
+    """Base exception class for all Datacosmos SDK exceptions."""
+
+    def __init__(self, message: str, response: Optional[Response] = None):
+        """Initialize DatacosmosException.
+
+        Args:
+            message (str): The error message.
+            response (Optional[Response]): The HTTP response object, if available.
+        """
+        self.response = response
+        self.status_code = response.status_code if response else None
+        self.details = response.text if response else None
+        full_message = (
+            f"{message} (Status: {self.status_code}, Details: {self.details})"
+            if response
+            else message
+        )
+        super().__init__(full_message)

datacosmos-0.0.2/datacosmos/stac/__init__.py

@@ -0,0 +1,5 @@
+"""STAC package for interacting with the STAC API, providing query and fetch functionalities.
+
+It enables interaction with STAC (SpatioTemporal Asset Catalog) services
+using an authenticated Datacosmos client.
+"""

datacosmos-0.0.2/datacosmos/stac/collection/__init__.py

@@ -0,0 +1,4 @@
+"""STAC package for interacting with collections from the STAC API, providing query and fetch functionalities.
+
+It enables interaction with collections from the STAC using an authenticated Datacosmos client.
+"""

datacosmos-0.0.2/datacosmos/stac/collection/collection_client.py

@@ -0,0 +1,149 @@
+"""Handles operations related to STAC collections."""
+
+from typing import Generator, Optional
+
+from pystac import Collection, Extent, SpatialExtent, TemporalExtent
+from pystac.utils import str_to_datetime
+
+from datacosmos.datacosmos_client import DatacosmosClient
+from datacosmos.stac.collection.models.collection_update import CollectionUpdate
+from datacosmos.utils.http_response.check_api_response import check_api_response
+
+
+class CollectionClient:
+    """Handles operations related to STAC collections."""
+
+    def __init__(self, client: DatacosmosClient):
+        """Initialize the CollectionClient with a DatacosmosClient."""
+        self.client = client
+        self.base_url = client.config.stac.as_domain_url()
+
+    def fetch_collection(self, collection_id: str) -> Collection:
+        """Fetch details of an existing STAC collection."""
+        url = self.base_url.with_suffix(f"/collections/{collection_id}")
+        response = self.client.get(url)
+        check_api_response(response)
+        return Collection.from_dict(response.json())
+
+    def create_collection(self, collection: Collection) -> None:
+        """Create a new STAC collection.
+
+        Args:
+            collection (Collection): The STAC collection to create.
+
+        Raises:
+            InvalidRequest: If the collection data is malformed.
+        """
+        if isinstance(collection.extent, dict):
+            spatial_data = collection.extent.get("spatial", {}).get("bbox", [[]])
+            temporal_data = collection.extent.get("temporal", {}).get("interval", [[]])
+
+            # Convert string timestamps to datetime objects
+            parsed_temporal = []
+            for interval in temporal_data:
+                start = str_to_datetime(interval[0]) if interval[0] else None
+                end = (
+                    str_to_datetime(interval[1])
+                    if len(interval) > 1 and interval[1]
+                    else None
+                )
+                parsed_temporal.append([start, end])
+
+            collection.extent = Extent(
+                spatial=SpatialExtent(spatial_data),
+                temporal=TemporalExtent(parsed_temporal),
+            )
+
+        url = self.base_url.with_suffix("/collections")
+        response = self.client.post(url, json=collection.to_dict())
+        check_api_response(response)
+
+    def update_collection(
+        self, collection_id: str, update_data: CollectionUpdate
+    ) -> None:
+        """Update an existing STAC collection."""
+        url = self.base_url.with_suffix(f"/collections/{collection_id}")
+        response = self.client.patch(
+            url, json=update_data.model_dump(by_alias=True, exclude_none=True)
+        )
+        check_api_response(response)
+
+    def delete_collection(self, collection_id: str) -> None:
+        """Delete a STAC collection by its ID."""
+        url = self.base_url.with_suffix(f"/collections/{collection_id}")
+        response = self.client.delete(url)
+        check_api_response(response)
+
+    def fetch_all_collections(self) -> Generator[Collection, None, None]:
+        """Fetch all STAC collections with pagination support."""
+        url = self.base_url.with_suffix("/collections")
+        params = {"limit": 10}
+
+        while True:
+            data = self._fetch_collections_page(url, params)
+            yield from self._parse_collections(data)
+
+            next_cursor = self._get_next_pagination_cursor(data)
+            if not next_cursor:
+                break
+
+            params["cursor"] = next_cursor
+
+    def _fetch_collections_page(self, url: str, params: dict) -> dict:
+        """Fetch a single page of collections from the API."""
+        response = self.client.get(url, params=params)
+        check_api_response(response)
+
+        data = response.json()
+
+        if isinstance(data, list):
+            return {"collections": data}
+
+        return data
+
+    def _parse_collections(self, data: dict) -> Generator[Collection, None, None]:
+        """Convert API response data to STAC Collection objects, ensuring required fields exist."""
+        return (
+            Collection.from_dict(
+                {
+                    **collection,
+                    "type": collection.get("type", "Collection"),
+                    "id": collection.get("id", ""),
+                    "stac_version": collection.get("stac_version", "1.0.0"),
+                    "extent": collection.get(
+                        "extent",
+                        {"spatial": {"bbox": []}, "temporal": {"interval": []}},
+                    ),
+                    "links": collection.get("links", []) or [],
+                    "properties": collection.get("properties", {}),
+                }
+            )
+            for collection in data.get("collections", [])
+            if collection.get("type") == "Collection"
+        )
+
+    def _get_next_pagination_cursor(self, data: dict) -> Optional[str]:
+        """Extract the next pagination token from the response."""
+        next_href = self._get_next_link(data)
+        return self._extract_pagination_token(next_href) if next_href else None
+
+    def _get_next_link(self, data: dict) -> Optional[str]:
+        """Extract the next page link from the response."""
+        next_link = next(
+            (link for link in data.get("links", []) if link.get("rel") == "next"), None
+        )
+        return next_link.get("href", "") if next_link else None
+
+    def _extract_pagination_token(self, next_href: str) -> Optional[str]:
+        """Extract the pagination token from the next link URL.
+
+        Args:
+            next_href (str): The next page URL.
+
+        Returns:
+            Optional[str]: The extracted token, or None if parsing fails.
+        """
+        try:
+            return next_href.split("?")[1].split("=")[-1]
+        except (IndexError, AttributeError):
+            raise InvalidRequest(f"Failed to parse pagination token from {next_href}")

datacosmos-0.0.2/datacosmos/stac/collection/models/__init__.py

@@ -0,0 +1 @@
+"""Models for the Collection Client."""

datacosmos-0.0.2/datacosmos/stac/collection/models/collection_update.py

@@ -0,0 +1,46 @@
+"""Represents a structured update model for STAC collections.
+
+Allows partial updates where only the provided fields are modified.
+"""
+from typing import Any, Dict, List, Optional
+
+from pydantic import BaseModel, Field
+from pystac import Extent, Link, Provider, Summaries
+
+
+class CollectionUpdate(BaseModel):
+    """Represents a structured update model for STAC collections.
+
+    Allows partial updates where only the provided fields are modified.
+    """
+
+    model_config = {"arbitrary_types_allowed": True}
+
+    title: Optional[str] = Field(None, description="Title of the STAC collection.")
+    description: Optional[str] = Field(
+        None, description="Description of the collection."
+    )
+    keywords: Optional[List[str]] = Field(
+        None, description="List of keywords associated with the collection."
+    )
+    license: Optional[str] = Field(None, description="Collection license information.")
+    providers: Optional[List[Provider]] = Field(
+        None, description="List of data providers."
+    )
+    extent: Optional[Extent] = Field(
+        None, description="Spatial and temporal extent of the collection."
+    )
+    summaries: Optional[Summaries] = Field(
+        None, description="Summaries for the collection."
+    )
+    links: Optional[List[Link]] = Field(
+        None, description="List of links associated with the collection."
+    )
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert the model into a dictionary, excluding `None` values.
+
+        Returns:
+            Dict[str, Any]: Dictionary representation of the update payload.
+        """
+        return self.model_dump(by_alias=True, exclude_none=True)

datacosmos-0.0.2/datacosmos/stac/item/__init__.py

@@ -0,0 +1,4 @@
+"""STAC package for interacting with items from the STAC API, providing query and fetch functionalities.
+
+It enables interaction with items from the STAC using an authenticated Datacosmos client.
+"""

datacosmos-0.0.2/datacosmos/stac/item/item_client.py

@@ -0,0 +1,185 @@
+"""STAC Client module for interacting with a STAC (SpatioTemporal Asset Catalog) API.
+
+Provides methods for querying, fetching, creating, updating, and deleting STAC items.
+"""
+
+from typing import Generator, Optional
+
+from pystac import Item
+
+from datacosmos.datacosmos_client import DatacosmosClient
+from datacosmos.exceptions.datacosmos_exception import DatacosmosException
+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
+
+
+class ItemClient:
+    """Client for interacting with the STAC API."""
+
+    def __init__(self, client: DatacosmosClient):
+        """Initialize the STACClient with a DatacosmosClient.
+
+        Args:
+            client (DatacosmosClient): The authenticated Datacosmos client instance.
+        """
+        self.client = client
+        self.base_url = client.config.stac.as_domain_url()
+
+    def fetch_item(self, item_id: str, collection_id: str) -> Item:
+        """Fetch a single STAC item by ID.
+
+        Args:
+            item_id (str): The ID of the item to fetch.
+            collection_id (str): The ID of the collection containing the item.
+
+        Returns:
+            Item: The fetched STAC item.
+        """
+        url = self.base_url.with_suffix(f"/collections/{collection_id}/items/{item_id}")
+        response = self.client.get(url)
+        check_api_response(response)
+        return Item.from_dict(response.json())
+
+    def fetch_collection_items(
+        self, collection_id: str, parameters: Optional[SearchParameters] = None
+    ) -> Generator[Item, None, None]:
+        """Fetch all items in a collection with optional filtering.
+
+        Args:
+            collection_id (str): The ID of the collection.
+            parameters (Optional[SearchParameters]): Filtering parameters (spatial, temporal, etc.).
+
+        Yields:
+            Item: Parsed STAC item.
+        """
+        if parameters is None:
+            parameters = SearchParameters(collections=[collection_id])
+
+        return self.search_items(parameters)
+
+    def search_items(self, parameters: SearchParameters) -> Generator[Item, None, None]:
+        """Query the STAC catalog using the POST endpoint with filtering and pagination.
+
+        Args:
+            parameters (SearchParameters): 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)
+        return self._paginate_items(url, body)
+
+    def create_item(self, collection_id: str, item: Item) -> None:
+        """Create a new STAC item in a specified collection.
+
+        Args:
+            collection_id (str): The ID of the collection where the item will be created.
+            item (Item): The STAC Item to be created.
+
+        Raises:
+            RequestError: If the API returns an error response.
+        """
+        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 update_item(
+        self, item_id: str, collection_id: str, update_data: ItemUpdate
+    ) -> None:
+        """Partially update an existing STAC item.
+
+        Args:
+            item_id (str): The ID of the item to update.
+            collection_id (str): The ID of the collection containing the item.
+            update_data (ItemUpdate): The structured update payload.
+        """
+        url = self.base_url.with_suffix(f"/collections/{collection_id}/items/{item_id}")
+
+        update_payload = update_data.model_dump(by_alias=True, exclude_none=True)
+
+        if "assets" in update_payload:
+            update_payload["assets"] = {
+                key: asset.to_dict() for key, asset in update_payload["assets"].items()
+            }
+        if "links" in update_payload:
+            update_payload["links"] = [
+                link.to_dict() for link in update_payload["links"]
+            ]
+
+        response = self.client.patch(url, json=update_payload)
+        check_api_response(response)
+
+    def delete_item(self, item_id: str, collection_id: str) -> None:
+        """Delete a STAC item by its ID.
+
+        Args:
+            item_id (str): The ID of the item to delete.
+            collection_id (str): The ID of the collection containing the item.
+
+        Raises:
+            OCError: If the item is not found or deletion is forbidden.
+        """
+        url = self.base_url.with_suffix(f"/collections/{collection_id}/items/{item_id}")
+        response = self.client.delete(url)
+        check_api_response(response)
+
+    def _paginate_items(self, url: str, body: dict) -> Generator[Item, None, None]:
+        """Handle pagination for the STAC search POST endpoint.
+
+        Fetches items one page at a time using the 'next' link.
+
+        Args:
+            url (str): The base URL for the search endpoint.
+            body (dict): The request body containing search parameters.
+
+        Yields:
+            Item: Parsed STAC item.
+        """
+        params = {"limit": body.get("limit", 10)}
+
+        while True:
+            response = self.client.post(url, json=body, params=params)
+            check_api_response(response)
+            data = response.json()
+
+            yield from (Item.from_dict(feature) for feature in data.get("features", []))
+
+            next_href = self._get_next_link(data)
+            if not next_href:
+                break
+
+            token = self._extract_pagination_token(next_href)
+            if not token:
+                break
+            params["cursor"] = token
+
+    def _get_next_link(self, data: dict) -> Optional[str]:
+        """Extract the next page link from the response."""
+        next_link = next(
+            (link for link in data.get("links", []) if link.get("rel") == "next"), None
+        )
+        return next_link.get("href", "") if next_link else None
+
+    def _extract_pagination_token(self, next_href: str) -> Optional[str]:
+        """Extract the pagination token from the next link URL.
+
+        Args:
+            next_href (str): The next page URL.
+
+        Returns:
+            Optional[str]: The extracted token, or None if parsing fails.
+
+        Raises:
+            DatacosmosException: If pagination token extraction fails.
+        """
+        try:
+            return next_href.split("?")[1].split("=")[-1]
+        except (IndexError, AttributeError) as e:
+            raise DatacosmosException(
+                f"Failed to parse pagination token from {next_href}",
+                response=e.response,
+            ) from e

datacosmos-0.0.2/datacosmos/stac/item/models/__init__.py

@@ -0,0 +1 @@
+"""Models for the Item Client."""

datacosmos-0.0.2/datacosmos/stac/item/models/item_update.py

@@ -0,0 +1,57 @@
+"""Model representing a partial update for a STAC item."""
+
+from typing import Any, Optional
+
+from pydantic import BaseModel, Field, model_validator
+from pystac import Asset, Link
+
+
+class ItemUpdate(BaseModel):
+    """Model representing a partial update for a STAC item."""
+
+    model_config = {"arbitrary_types_allowed": True}
+
+    stac_extensions: Optional[list[str]] = None
+    geometry: Optional[dict[str, Any]] = None
+    bbox: Optional[list[float]] = Field(
+        None, min_items=4, max_items=4
+    )  # Must be [minX, minY, maxX, maxY]
+    properties: Optional[dict[str, Any]] = None
+    assets: Optional[dict[str, Asset]] = None
+    links: Optional[list[Link]] = None
+
+    def set_geometry(self, geom_type: str, coordinates: list[Any]) -> None:
+        """Set the geometry manually without using shapely.
+
+        Args:
+            geom_type (str): The type of geometry (e.g., 'Point', 'Polygon').
+            coordinates (list[Any]): The coordinates defining the geometry.
+        """
+        self.geometry = {"type": geom_type, "coordinates": coordinates}
+
+    @staticmethod
+    def has_valid_datetime(properties: dict[str, Any]) -> bool:
+        """Check if 'datetime' is present and not None."""
+        return properties.get("datetime") is not None
+
+    @staticmethod
+    def has_valid_datetime_range(properties: dict[str, Any]) -> bool:
+        """Check if both 'start_datetime' and 'end_datetime' are present and not None."""
+        return all(
+            properties.get(key) is not None
+            for key in ["start_datetime", "end_datetime"]
+        )
+
+    @model_validator(mode="before")
+    def validate_datetime_fields(cls, values):
+        """Ensure at least one of 'datetime' or 'start_datetime'/'end_datetime' exists."""
+        properties = values.get("properties", {})
+
+        if not cls.has_valid_datetime(properties) and not cls.has_valid_datetime_range(
+            properties
+        ):
+            raise ValueError(
+                "Either 'datetime' or both 'start_datetime' and 'end_datetime' must be provided."
+            )
+
+        return values

datacosmos-0.0.2/datacosmos/stac/item/models/search_parameters.py

@@ -0,0 +1,58 @@
+"""Module defining the SearchParameters model for STAC API queries, encapsulating filtering criteria.
+
+It includes spatial, temporal, and property-based filters for querying STAC items efficiently.
+"""
+
+from typing import Optional, Union
+
+from pydantic import BaseModel, Field, model_validator
+
+
+class SearchParameters(BaseModel):
+    """Encapsulates the parameters for the STAC search API with validation."""
+
+    bbox: Optional[list[float]] = Field(
+        None,
+        description="Bounding box filter [minX, minY, maxX, maxY]. Optional six values for 3D bounding box.",
+        example=[-180.0, -90.0, 180.0, 90.0],
+    )
+    datetime_range: Optional[str] = Field(
+        None,
+        alias="datetime",
+        description=(
+            "Temporal filter, either a single RFC 3339 datetime or an interval. "
+            'Example: "2025-01-01T00:00:00Z/.."'
+        ),
+    )
+    intersects: Optional[dict] = Field(
+        None, description="GeoJSON geometry filter, e.g., a Polygon or Point."
+    )
+    ids: Optional[list[str]] = Field(
+        None,
+        description="Array of item IDs to filter by.",
+        example=["item1", "item2"],
+    )
+    collections: Optional[list[str]] = Field(
+        None,
+        description="Array of collection IDs to filter by.",
+        example=["collection1", "collection2"],
+    )
+    limit: Optional[int] = Field(
+        None,
+        ge=1,
+        le=10000,
+        description="Maximum number of items per page. Default: 10, Max: 10000.",
+        example=10,
+    )
+    query: Optional[dict[str, dict[str, Union[str, int, float]]]] = Field(
+        None,
+        description="Additional property filters, e.g., { 'cloud_coverage': { 'lt': 10 } }.",
+    )
+
+    @model_validator(mode="before")
+    def validate_bbox(cls, values):
+        """Validate that the `bbox` field contains either 4 or 6 values."""
+        bbox = values.get("bbox")
+        if bbox and len(bbox) not in {4, 6}:
+            raise ValueError("bbox must contain 4 or 6 values.")
+        return values

datacosmos-0.0.2/datacosmos/stac/stac_client.py

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

datacosmos-0.0.2/datacosmos/utils/__init__.py

@@ -0,0 +1 @@
+"""Http response and url utils for datacosmos."""

datacosmos-0.0.2/datacosmos/utils/http_response/__init__.py

@@ -0,0 +1 @@
+"""Validates an API response."""

datacosmos-0.0.2/datacosmos/utils/http_response/check_api_response.py

@@ -0,0 +1,34 @@
+"""Validates an API response and raises a DatacosmosException if an error occurs."""
+
+from pydantic import ValidationError
+from requests import Response
+
+from datacosmos.exceptions.datacosmos_exception import DatacosmosException
+from datacosmos.utils.http_response.models.datacosmos_response import DatacosmosResponse
+
+
+def check_api_response(response: Response) -> None:
+    """Validates an API response and raises a DatacosmosException if an error occurs.
+
+    Args:
+        resp (requests.Response): The response object.
+
+    Raises:
+        DatacosmosException: If the response status code indicates an error.
+    """
+    if 200 <= response.status_code < 400:
+        return
+
+    try:
+        response = DatacosmosResponse.model_validate_json(response.text)
+        msg = response.errors[0].human_readable()
+        if len(response.errors) > 1:
+            msg = "\n  * " + "\n  * ".join(
+                error.human_readable() for error in response.errors
+            )
+        raise DatacosmosException(msg, response=response)
+
+    except ValidationError:
+        raise DatacosmosException(
+            f"HTTP {response.status_code}: {response.text}", response=response
+        )

datacosmos-0.0.2/datacosmos/utils/http_response/models/__init__.py

@@ -0,0 +1 @@
+"""Models for validation of API response."""

datacosmos-0.0.2/datacosmos/utils/http_response/models/datacosmos_error.py

@@ -0,0 +1,26 @@
+"""Structured API error message for Datacosmos."""
+
+from pydantic import BaseModel
+
+
+class DatacosmosError(BaseModel):
+    """Structured API error message for Datacosmos."""
+
+    message: str
+    field: str | None = None
+    type: str | None = None
+    source: str | None = None
+    trace_id: str | None = None
+
+    def human_readable(self) -> str:
+        """Formats the error message into a readable format."""
+        msg = self.message
+        if self.type:
+            msg += f" (type: {self.type})"
+        if self.field:
+            msg += f" (field: {self.field})"
+        if self.source:
+            msg += f" (source: {self.source})"
+        if self.trace_id:
+            msg += f" (trace_id: {self.trace_id})"
+        return msg

datacosmos-0.0.2/datacosmos/utils/http_response/models/datacosmos_response.py

@@ -0,0 +1,11 @@
+"""Structured response for Datacosmos handling multiple API errors."""
+
+from pydantic import BaseModel
+
+from datacosmos.utils.http_response.models.datacosmos_error import DatacosmosError
+
+
+class DatacosmosResponse(BaseModel):
+    """Structured response for Datacosmos handling multiple API errors."""
+
+    errors: list[DatacosmosError]

datacosmos-0.0.2/datacosmos/utils/url.py

@@ -0,0 +1,37 @@
+"""URL utility class for building and handling URLs in the SDK."""
+
+
+class URL:
+    """Class to represent and build URLs in a convenient way."""
+
+    def __init__(self, protocol: str, host: str, port: int, base: str):
+        """Creates a new basis to build URLs.
+
+        Args:
+            protocol (str): Protocol to use in the URL (http/https).
+            host (str): Hostname (e.g., example.com).
+            port (int): Port number.
+            base (str): Base path (e.g., /api/v1).
+        """
+        self.protocol = protocol
+        self.host = host
+        self.port = port
+        self.base = base
+
+    def string(self) -> str:
+        """Returns the full URL as a string."""
+        port = "" if self.port in [80, 443] else f":{self.port}"
+        base = f"/{self.base.lstrip('/')}" if self.base else ""
+        return f"{self.protocol}://{self.host}{port}{base}"
+
+    def with_suffix(self, suffix: str) -> str:
+        """Appends a suffix to the URL, ensuring proper formatting.
+
+        Args:
+            suffix (str): The path to append.
+
+        Returns:
+            str: Full URL with the suffix.
+        """
+        base = self.string()
+        return f"{base.rstrip('/')}/{suffix.lstrip('/')}"

{datacosmos-0.0.1 → datacosmos-0.0.2}/datacosmos.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: datacosmos
-Version: 0.0.1
+Version: 0.0.2
 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.2/datacosmos.egg-info/SOURCES.txt

@@ -0,0 +1,36 @@
+LICENSE.md
+README.md
+pyproject.toml
+config/__init__.py
+config/config.py
+config/models/__init__.py
+config/models/m2m_authentication_config.py
+config/models/url.py
+datacosmos/__init__.py
+datacosmos/datacosmos_client.py
+datacosmos.egg-info/PKG-INFO
+datacosmos.egg-info/SOURCES.txt
+datacosmos.egg-info/dependency_links.txt
+datacosmos.egg-info/requires.txt
+datacosmos.egg-info/top_level.txt
+datacosmos/exceptions/__init__.py
+datacosmos/exceptions/datacosmos_exception.py
+datacosmos/stac/__init__.py
+datacosmos/stac/stac_client.py
+datacosmos/stac/collection/__init__.py
+datacosmos/stac/collection/collection_client.py
+datacosmos/stac/collection/models/__init__.py
+datacosmos/stac/collection/models/collection_update.py
+datacosmos/stac/item/__init__.py
+datacosmos/stac/item/item_client.py
+datacosmos/stac/item/models/__init__.py
+datacosmos/stac/item/models/item_update.py
+datacosmos/stac/item/models/search_parameters.py
+datacosmos/utils/__init__.py
+datacosmos/utils/url.py
+datacosmos/utils/http_response/__init__.py
+datacosmos/utils/http_response/check_api_response.py
+datacosmos/utils/http_response/models/__init__.py
+datacosmos/utils/http_response/models/datacosmos_error.py
+datacosmos/utils/http_response/models/datacosmos_response.py
+tests/test_pass.py

{datacosmos-0.0.1 → datacosmos-0.0.2}/datacosmos.egg-info/top_level.txt

@@ -1 +1,2 @@
+config
 datacosmos

{datacosmos-0.0.1 → datacosmos-0.0.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "datacosmos"
-version = "0.0.1"
+version = "0.0.2"
 authors = [
     { name="Open Cosmos", email="support@open-cosmos.com" },
 ]
@@ -33,8 +33,8 @@ dev = [
     "pydocstyle==6.1.1"
 ]
 
-[tool.setuptools]
-packages = ["datacosmos"]
+[tool.setuptools.packages.find]
+include = ["datacosmos*", "config*"]
 
 [tool.bandit]
 exclude_dirs = [".venv"]

datacosmos-0.0.1/datacosmos.egg-info/SOURCES.txt

@@ -1,11 +0,0 @@
-LICENSE.md
-README.md
-pyproject.toml
-datacosmos/__init__.py
-datacosmos/datacosmos_client.py
-datacosmos.egg-info/PKG-INFO
-datacosmos.egg-info/SOURCES.txt
-datacosmos.egg-info/dependency_links.txt
-datacosmos.egg-info/requires.txt
-datacosmos.egg-info/top_level.txt
-tests/test_pass.py