datacosmos 0.0.18__py3-none-any.whl → 0.0.20__py3-none-any.whl

datacosmos/auth/local_authenticator.py

@@ -7,7 +7,7 @@ import requests
 
 from datacosmos.auth.base_authenticator import AuthResult, BaseAuthenticator
 from datacosmos.auth.local_token_fetcher import LocalTokenFetcher
-from datacosmos.exceptions.datacosmos_exception import DatacosmosException
+from datacosmos.exceptions.datacosmos_error import DatacosmosError
 
 
 class LocalAuthenticator(BaseAuthenticator):
@@ -36,9 +36,7 @@ class LocalAuthenticator(BaseAuthenticator):
                 token_file=Path(auth.cache_file).expanduser(),
             )
         except Exception as e:
-            raise DatacosmosException(
-                f"Failed to initialize LocalTokenFetcher: {e}"
-            ) from e
+            raise DatacosmosError(f"Failed to initialize LocalTokenFetcher: {e}") from e
 
     def authenticate_and_build_session(self) -> AuthResult:
         """Builds an authenticated session using the local token fetcher."""
@@ -52,7 +50,7 @@ class LocalAuthenticator(BaseAuthenticator):
                 http_client=http_client, token=token, token_expiry=token_expiry
             )
         except Exception as e:
-            raise DatacosmosException(f"Local authentication failed: {e}") from e
+            raise DatacosmosError(f"Local authentication failed: {e}") from e
 
     def refresh_token(self) -> AuthResult:
         """Refreshes the local token non-interactively."""
@@ -69,4 +67,4 @@ class LocalAuthenticator(BaseAuthenticator):
                 http_client=http_client, token=token, token_expiry=token_expiry
             )
         except Exception as e:
-            raise DatacosmosException(f"Local token refresh failed: {e}") from e
+            raise DatacosmosError(f"Local token refresh failed: {e}") from e

datacosmos/auth/m2m_authenticator.py

@@ -13,7 +13,7 @@ from tenacity import (
 )
 
 from datacosmos.auth.base_authenticator import AuthResult, BaseAuthenticator
-from datacosmos.exceptions.datacosmos_exception import DatacosmosException
+from datacosmos.exceptions.datacosmos_error import DatacosmosError
 
 
 class M2MAuthenticator(BaseAuthenticator):
@@ -52,9 +52,9 @@ class M2MAuthenticator(BaseAuthenticator):
                 http_client=http_client, token=token, token_expiry=token_expiry
             )
         except (HTTPError, ConnectionError, Timeout) as e:
-            raise DatacosmosException(f"M2M authentication failed: {e}") from e
+            raise DatacosmosError(f"M2M authentication failed: {e}") from e
         except RequestException as e:
-            raise DatacosmosException(
+            raise DatacosmosError(
                 f"Unexpected request failure during M2M authentication: {e}"
             ) from e
 

datacosmos/datacosmos_client.py

@@ -20,7 +20,7 @@ from datacosmos.auth.base_authenticator import BaseAuthenticator
 from datacosmos.auth.local_authenticator import LocalAuthenticator
 from datacosmos.auth.m2m_authenticator import M2MAuthenticator
 from datacosmos.config.config import Config
-from datacosmos.exceptions.datacosmos_exception import DatacosmosException
+from datacosmos.exceptions.datacosmos_error import DatacosmosError
 
 _log = logging.getLogger(__name__)
 
@@ -75,9 +75,7 @@ class DatacosmosClient:
         try:
             return Config.model_validate(cfg)
         except Exception as e:
-            raise DatacosmosException(
-                "Invalid config provided to DatacosmosClient"
-            ) from e
+            raise DatacosmosError("Invalid config provided to DatacosmosClient") from e
 
     def _init_with_injected_session(
         self, http_session: requests.Session | OAuth2Session
@@ -88,7 +86,7 @@ class DatacosmosClient:
         token_data = self._extract_token_data(http_session)
         self.token = token_data.get("access_token")
         if not self.token:
-            raise DatacosmosException(
+            raise DatacosmosError(
                 "Failed to extract access token from injected session"
             )
         self.token_expiry = self._compute_expiry(
@@ -103,11 +101,11 @@ class DatacosmosClient:
         if isinstance(http_session, requests.Session):
             auth_header = http_session.headers.get("Authorization", "")
             if not auth_header.startswith("Bearer "):
-                raise DatacosmosException(
+                raise DatacosmosError(
                     "Injected requests.Session must include a 'Bearer' token in its headers"
                 )
             return {"access_token": auth_header.split(" ", 1)[1]}
-        raise DatacosmosException(f"Unsupported session type: {type(http_session)}")
+        raise DatacosmosError(f"Unsupported session type: {type(http_session)}")
 
     def _compute_expiry(
         self,
@@ -134,7 +132,7 @@ class DatacosmosClient:
         elif auth_type == "local":
             self._authenticator = LocalAuthenticator(self.config)
         else:
-            raise DatacosmosException(f"Unsupported authentication type: {auth_type}")
+            raise DatacosmosError(f"Unsupported authentication type: {auth_type}")
 
         auth_result = self._authenticator.authenticate_and_build_session()
         self.token = auth_result.token
@@ -166,7 +164,7 @@ class DatacosmosClient:
                     {"Authorization": f"Bearer {self.token}"}
                 )
             else:
-                raise DatacosmosException(
+                raise DatacosmosError(
                     "Cannot refresh token, no authenticator initialized."
                 )
 
@@ -196,7 +194,7 @@ class DatacosmosClient:
             requests.Response: The HTTP response.
 
         Raises:
-            DatacosmosException: For any HTTP or request-related errors.
+            DatacosmosError: For any HTTP or request-related errors.
         """
         self._refresh_token_if_needed()
 
@@ -228,16 +226,16 @@ class DatacosmosClient:
                     retry_response.raise_for_status()
                     return retry_response
                 except HTTPError as e:
-                    raise DatacosmosException(
+                    raise DatacosmosError(
                         f"HTTP error during {method.upper()} request to {url} after refresh",
                         response=e.response,
                     ) from e
-            raise DatacosmosException(
+            raise DatacosmosError(
                 f"HTTP error during {method.upper()} request to {url}",
                 response=getattr(e, "response", None),
             ) from e
         except RequestException as e:
-            raise DatacosmosException(
+            raise DatacosmosError(
                 f"Unexpected request failure during {method.upper()} request to {url}: {e}"
             ) from e
 

datacosmos/exceptions/__init__.py

@@ -1 +1,9 @@
 """Exceptions for the datacosmos package."""
+
+from .datacosmos_error import DatacosmosError
+from .stac_validation_error import StacValidationError
+
+__all__ = [
+    "DatacosmosError",
+    "StacValidationError",
+]

datacosmos/exceptions/{datacosmos_exception.py → datacosmos_error.py}

@@ -6,11 +6,11 @@ from requests import Response
 from requests.exceptions import RequestException
 
 
-class DatacosmosException(RequestException):
+class DatacosmosError(RequestException):
     """Base exception class for all Datacosmos SDK exceptions."""
 
     def __init__(self, message: str, response: Optional[Response] = None):
-        """Initialize DatacosmosException.
+        """Initialize DatacosmosError.
 
         Args:
             message (str): The error message.

datacosmos/exceptions/stac_validation_error.py

@@ -0,0 +1,8 @@
+"""Custom exception for STAC validation errors."""
+from datacosmos.exceptions.datacosmos_error import DatacosmosError
+
+
+class StacValidationError(DatacosmosError):
+    """Exception raised for errors in STAC item validation."""
+
+    pass

datacosmos/stac/collection/collection_client.py

@@ -6,7 +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.exceptions.datacosmos_error import DatacosmosError
 from datacosmos.stac.collection.models.collection_update import CollectionUpdate
 from datacosmos.utils.http_response.check_api_response import check_api_response
 
@@ -147,7 +147,7 @@ class CollectionClient:
         try:
             return next_href.split("?")[1].split("=")[-1]
         except (IndexError, AttributeError) as e:
-            raise DatacosmosException(
+            raise DatacosmosError(
                 f"Failed to parse pagination token from {next_href}",
                 response=e.response,
             ) from e

datacosmos/stac/item/item_client.py

@@ -8,7 +8,7 @@ from typing import Generator, Optional
 from pystac import Item
 
 from datacosmos.datacosmos_client import DatacosmosClient
-from datacosmos.exceptions.datacosmos_exception import DatacosmosException
+from datacosmos.exceptions import DatacosmosError, StacValidationError
 from datacosmos.stac.item.models.catalog_search_parameters import (
     CatalogSearchParameters,
 )
@@ -72,17 +72,10 @@ class ItemClient:
 
         Raises:
             ValueError: If the item has no collection set.
+            StacValidationError: If the collection ID in the links doesn't match the item's collection field.
             RequestError: If the API returns an error response.
         """
-        if isinstance(item, Item):
-            collection_id = item.collection_id or (
-                item.get_collection().id if item.get_collection() else None
-            )
-        else:
-            collection_id = item.collection
-
-        if not collection_id:
-            raise ValueError("Cannot create item: no collection_id found on item")
+        collection_id = self._get_validated_collection_id(item, method="create")
 
         url = self.base_url.with_suffix(f"/collections/{collection_id}/items")
         item_json: dict = item.to_dict()
@@ -99,17 +92,13 @@ class ItemClient:
 
         Raises:
             ValueError: If the item has no collection set.
+            StacValidationError: If the collection ID in the links doesn't match the item's collection field.
             RequestError: If the API returns an error response.
         """
-        if isinstance(item, Item):
-            collection_id = item.collection_id or (
-                item.get_collection().id if item.get_collection() else None
-            )
-        else:
-            collection_id = item.collection
+        collection_id = self._get_validated_collection_id(item, method="add")
 
-        if not collection_id:
-            raise ValueError("Cannot create item: no collection_id found on item")
+        if not item.id:
+            raise ValueError("Cannot add item: no item_id found on item")
 
         url = self.base_url.with_suffix(f"/collections/{collection_id}/items/{item.id}")
         item_json: dict = item.to_dict()
@@ -203,12 +192,79 @@ class ItemClient:
             Optional[str]: The extracted token, or None if parsing fails.
 
         Raises:
-            DatacosmosException: If pagination token extraction fails.
+            DatacosmosError: If pagination token extraction fails.
         """
         try:
             return next_href.split("?")[1].split("=")[-1]
         except (IndexError, AttributeError) as e:
-            raise DatacosmosException(
+            raise DatacosmosError(
                 f"Failed to parse pagination token from {next_href}",
                 response=e.response,
             ) from e
+
+    def _get_validated_collection_id(
+        self, item: Item | DatacosmosItem, method: str
+    ) -> str:
+        """Resolves and validates the collection ID from an item, checking for link consistency.
+
+        Args:
+            item: The STAC item.
+            method: The client method calling this helper ("create" or "add").
+
+        Returns:
+            The validated collection_id.
+
+        Raises:
+            ValueError: If collection ID cannot be resolved.
+            StacValidationError: If the collection ID and parent link are inconsistent.
+        """
+        if isinstance(item, Item):
+            collection_id = item.collection_id or (
+                item.get_collection().id if item.get_collection() else None
+            )
+            if collection_id and not self._is_collection_link_consistent_pystac(
+                item, collection_id
+            ):
+                raise StacValidationError(
+                    "Parent link in pystac.Item does not match its collection_id."
+                )
+        else:
+            collection_id = item.collection
+            if collection_id and not self._is_collection_link_consistent_datacosmos(
+                item
+            ):
+                raise StacValidationError(
+                    "Parent link in DatacosmosItem does not match its collection."
+                )
+
+        if not collection_id:
+            if method == "create":
+                raise ValueError("Cannot create item: no collection_id found on item")
+            else:
+                raise ValueError("Cannot add item: no collection_id found on item")
+
+        return collection_id
+
+    def _is_collection_link_consistent_pystac(
+        self, item: Item, collection_id: str
+    ) -> bool:
+        """Helper to check if the parent link matches the pystac item's collection_id."""
+        parent_link = next(
+            (link for link in item.get_links("parent") if link.rel == "parent"), None
+        )
+        if not parent_link:
+            return True
+
+        link_collection_id = parent_link.get_href().rstrip("/").split("/")[-1]
+        return link_collection_id == collection_id
+
+    def _is_collection_link_consistent_datacosmos(self, item: DatacosmosItem) -> bool:
+        """Helper to check if the parent link matches the datacosmos item's collection field."""
+        if not item.collection:
+            return True
+
+        for link in item.links:
+            if link.get("rel") == "parent":
+                link_collection_id = link.get("href", "").rstrip("/").split("/")[-1]
+                return link_collection_id == item.collection
+        return True

datacosmos/stac/item/models/datacosmos_item.py

@@ -8,7 +8,7 @@ from pydantic import BaseModel, ConfigDict, field_validator, model_validator
 from shapely.errors import ShapelyError
 from shapely.geometry import Polygon, shape
 
-from datacosmos.exceptions.datacosmos_exception import DatacosmosException
+from datacosmos.exceptions.stac_validation_error import StacValidationError
 from datacosmos.stac.enums.processing_level import ProcessingLevel
 from datacosmos.stac.item.models.asset import Asset
 
@@ -48,7 +48,7 @@ class DatacosmosItem(BaseModel):
         ]
 
         if missing_keys:
-            raise DatacosmosException(
+            raise StacValidationError(
                 f"Datacosmos-specific properties are missing: {', '.join(missing_keys)}."
             )
         return properties_data
@@ -62,7 +62,7 @@ class DatacosmosItem(BaseModel):
         if geometry_data.get("type") != "Polygon" or not geometry_data.get(
             "coordinates"
         ):
-            raise DatacosmosException("Geometry must be a Polygon with coordinates.")
+            raise StacValidationError("Geometry must be a Polygon with coordinates.")
 
         try:
             # Use shape() for robust GeoJSON parsing and validation
@@ -80,7 +80,7 @@ class DatacosmosItem(BaseModel):
                 )
 
         except (KeyError, ShapelyError, ValueError) as e:
-            raise DatacosmosException(f"Invalid geometry data: {e}") from e
+            raise StacValidationError(f"Invalid geometry data: {e}") from e
 
         return geometry_data
 
@@ -97,12 +97,12 @@ class DatacosmosItem(BaseModel):
                     math.isclose(a, b, rel_tol=1e-9)
                     for a, b in zip(self.bbox, true_bbox)
                 ):
-                    raise DatacosmosException(
+                    raise StacValidationError(
                         "Provided bbox does not match geometry bounds."
                     )
             except Exception as e:
                 # Catch any errors from Shapely or the comparison
-                raise DatacosmosException(f"Invalid bbox or geometry: {e}") from e
+                raise StacValidationError(f"Invalid bbox or geometry: {e}") from e
         return self
 
     def get_property(self, key: str) -> Any | None:
@@ -137,3 +137,11 @@ class DatacosmosItem(BaseModel):
     def to_dict(self) -> dict:
         """Converts the DatacosmosItem instance to a dictionary."""
         return self.model_dump()
+
+    def has_self_link(self) -> bool:
+        """Checks if the item has a 'self' link."""
+        return any(link.get("rel") == "self" for link in self.links)
+
+    def has_parent_link(self) -> bool:
+        """Checks if the item has a 'parent' link."""
+        return any(link.get("rel") == "parent" for link in self.links)

datacosmos/stac/storage/storage_base.py

@@ -1,9 +1,11 @@
 """Base class providing common storage helpers (threading, MIME guess, futures)."""
 
 import mimetypes
-from concurrent.futures import ThreadPoolExecutor, wait
+from concurrent.futures import Future, ThreadPoolExecutor, wait
+from typing import Any, Callable, Dict, Iterable, List, Tuple
 
 from datacosmos.datacosmos_client import DatacosmosClient
+from datacosmos.exceptions.datacosmos_error import DatacosmosError
 
 
 class StorageBase:
@@ -18,23 +20,58 @@ class StorageBase:
         mime, _ = mimetypes.guess_type(src)
         return mime or "application/octet-stream"
 
-    def _run_in_threads(self, fn, fn_args, max_workers: int, timeout: float):
+    def run_in_threads(
+        self,
+        fn: Callable[..., Any],
+        jobs: Iterable[Tuple[Any, ...]],
+        max_workers: int,
+        timeout: float,
+    ) -> Tuple[List[Any], List[Dict[str, Any]]]:
         """Run the callable `fn(*args)` over the iterable of jobs in parallel threads.
 
-        `jobs` should be a list of tuples, each tuple unpacked as fn(*args).
+        Collects successes and failures without aborting the batch on individual errors.
+
+        Args:
+            fn: The function to execute.
+            jobs: An iterable of tuples, where each tuple is unpacked as fn(*args).
+            max_workers: Maximum number of threads to use.
+            timeout: Timeout for the entire batch.
+
+        Returns:
+            A tuple containing (successes: List[Any], failures: List[Dict[str, Any]]).
+            Failures include the exception and job arguments.
+
+        Raises:
+            DatacosmosError: If the entire batch times out.
         """
-        futures = []
-        with ThreadPoolExecutor(max_workers=max_workers) as executor:
-            for args in fn_args:
+        futures: List[Future] = []
+
+        executor = ThreadPoolExecutor(max_workers=max_workers)
+
+        try:
+            for args in jobs:
                 futures.append(executor.submit(fn, *args))
-        done, not_done = wait(futures, timeout=timeout)
-        errors = []
-        for future in done:
-            try:
-                future.result()
-            except Exception as e:
-                errors.append(e)
-        for future in not_done:
-            future.cancel()
-        if errors:
-            raise errors[0]
+
+            # Wait until all futures are done or the timeout is reached
+            done, not_done = wait(futures, timeout=timeout)
+
+            successes = []
+            failures = []
+
+            for future in done:
+                try:
+                    result = future.result()
+                except Exception as e:
+                    failures.append({'error': str(e), 'exception': e})
+                else:
+                    successes.append(result)
+
+            if not_done:
+                # The executor's shutdown wait must be skipped to allow cancellation
+                raise DatacosmosError("Batch processing failed: operation timed out.")
+
+            return successes, failures
+        finally:
+            # Shutdown without waiting to enable timeout handling
+            # The wait call already established which jobs finished
+            executor.shutdown(wait=False)

datacosmos/stac/storage/uploader.py

@@ -1,6 +1,7 @@
 """Handles uploading files to Datacosmos storage and registering STAC items."""
 
 from pathlib import Path
+from typing import Any
 
 from pydantic import TypeAdapter
 
@@ -13,7 +14,7 @@ from datacosmos.stac.storage.storage_base import StorageBase
 
 
 class Uploader(StorageBase):
-    """Upload a STAC item and its assets to Datacosmos storage, then register the item in the STAC API."""
+    """Upload a STAC item and its assets to Datacosmos storage and register the item in the STAC API."""
 
     def __init__(self, client: DatacosmosClient):
         """Initialize the uploader.
@@ -32,17 +33,25 @@ class Uploader(StorageBase):
         included_assets: list[str] | bool = True,
         max_workers: int = 4,
         time_out: float = 60 * 60 * 1,
-    ) -> DatacosmosItem:
-        """Upload a STAC item (and optionally its assets) to Datacosmos.
+    ) -> tuple[DatacosmosItem, list[str], list[dict[str, Any]]]:
+        """Upload a STAC item (and optionally its assets) to Datacosmos in parallel threads.
 
-        `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
+        Args:
+            item (DatacosmosItem | str):
+                - a DatacosmosItem instance, or
+                - the path to an item JSON file on disk.
+            project_id (str): The project ID to upload assets to.
+            assets_path (str | None): Base directory where local asset files are located.
+            included_assets (list[str] | bool):
+                - True → upload every asset in the item.
+                - list[str] → upload only the asset keys in that list.
+                - False → skip asset upload; just register the item.
+            max_workers (int): Maximum number of parallel threads for asset upload.
+            time_out (float): Timeout in seconds for the entire asset batch upload.
+
+        Returns:
+            tuple[DatacosmosItem, list[str], list[dict[str, Any]]]:
+            The updated DatacosmosItem, a list of asset keys that were uploaded successfully, and a list of upload failures.
         """
         if not assets_path and not isinstance(item, str):
             raise ValueError(
@@ -54,23 +63,45 @@ class Uploader(StorageBase):
             item = self._load_item(item_filename)
             assets_path = assets_path or str(Path(item_filename).parent)
 
+        if not isinstance(item, DatacosmosItem):
+            raise TypeError(f"item must be a DatacosmosItem, got {type(item).__name__}")
+
         assets_path = assets_path or str(Path.cwd())
 
-        upload_assets = (
-            included_assets
-            if isinstance(included_assets, list)
-            else item.assets.keys()
-            if included_assets is True
-            else []
-        )
+        if included_assets is False:
+            upload_assets: list[str] = []
+        elif included_assets is True:
+            upload_assets = list(item.assets.keys())
+        elif isinstance(included_assets, list):
+            upload_assets = included_assets
+        else:
+            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
+        if not jobs:
+            self.item_client.add_item(item)
+            return item, [], []
+
+        successes, failures = self.run_in_threads(
+            self._upload_asset, jobs, max_workers, time_out
+        )
+
+        # Register the item if the overall process didn't time out
+        # and there was at least one successful upload.
+        if successes:
+            self.item_client.add_item(item)
+
+        return item, successes, failures
+
+    @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_from_file(
         self, src: str, dst: str, mime_type: str | None = None
@@ -83,19 +114,13 @@ class Uploader(StorageBase):
             response = self.client.put(url, data=f, headers=headers)
         response.raise_for_status()
 
-    @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, project_id: str
-    ) -> None:
+    ) -> str:
         """Upload a single asset file and update its href inside the item object.
 
-        Runs in parallel via _run_in_threads().
+        Returns:
+            str: The asset_key upon successful upload.
         """
         asset = item.assets[asset_key]
 
@@ -117,6 +142,8 @@ class Uploader(StorageBase):
         self._update_asset_href(asset)  # turn href into public URL
         self.upload_from_file(src, str(upload_path), mime_type=asset.type)
 
+        return asset_key
+
     def _update_asset_href(self, asset: Asset) -> None:
         """Convert the storage key to a public HTTPS URL."""
         try:

datacosmos/utils/http_response/check_api_response.py

@@ -1,20 +1,20 @@
-"""Validates an API response and raises a DatacosmosException if an error occurs."""
+"""Validates an API response and raises a DatacosmosError if an error occurs."""
 
 from pydantic import ValidationError
 from requests import Response
 
-from datacosmos.exceptions.datacosmos_exception import DatacosmosException
+from datacosmos.exceptions.datacosmos_error import DatacosmosError
 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.
+    """Validates an API response and raises a DatacosmosError if an error occurs.
 
     Args:
         resp (requests.Response): The response object.
 
     Raises:
-        DatacosmosException: If the response status code indicates an error.
+        DatacosmosError: If the response status code indicates an error.
     """
     if 200 <= response.status_code < 400:
         return
@@ -26,9 +26,9 @@ def check_api_response(response: Response) -> None:
             msg = "\n  * " + "\n  * ".join(
                 error.human_readable() for error in response.errors
             )
-        raise DatacosmosException(msg, response=response)
+        raise DatacosmosError(msg, response=response)
 
     except ValidationError:
-        raise DatacosmosException(
+        raise DatacosmosError(
             f"HTTP {response.status_code}: {response.text}", response=response
         )

{datacosmos-0.0.18.dist-info → datacosmos-0.0.20.dist-info}/METADATA

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

@@ -1,10 +1,10 @@
 datacosmos/__init__.py,sha256=dVHKpbz5FVtfoJAWHRdsUENG6H-vs4UrkuwnIvOGJr4,66
-datacosmos/datacosmos_client.py,sha256=yK9rit_AELs11ReJWm-zXx46wEWyvlDJDUOXy27bP3c,10524
+datacosmos/datacosmos_client.py,sha256=hydaepbjoEHupRv1CUNUOUMF9t_uZNR4Refwzvzfl0s,10446
 datacosmos/auth/__init__.py,sha256=ynCThS9QyLKV9miRdnjm8uF_breiGGiCcI0FaOSw_2o,45
 datacosmos/auth/base_authenticator.py,sha256=bSlb-N-vIUTl4K9KnDd3Dz21MevN_nvpWuwxgifdWBE,1814
-datacosmos/auth/local_authenticator.py,sha256=a3jIBZAMB1UlEFUZyECyJTCgSH2yjbTcrFZuUer0F90,2914
+datacosmos/auth/local_authenticator.py,sha256=ah2DWxHjPYP-aTqGR-kEMMPv1Geeh00weHCGpZWgSig,2864
 datacosmos/auth/local_token_fetcher.py,sha256=E4MI2lTRHAmxIQA7qY6hmpAUZETTzXNO8MViBaXnxGs,5268
-datacosmos/auth/m2m_authenticator.py,sha256=tglT5mbqfciSFQksqduroVirHRHDdev9V-B92O0hd0w,2637
+datacosmos/auth/m2m_authenticator.py,sha256=_n5qpyK9ngqHec8uMDBOKL-U3k989geIQ-rzH9PMhZc,2621
 datacosmos/auth/token.py,sha256=neSV9gnnFa-rxEwMAJlZe_cReV6g4PQf8mq4-1mZzB8,2558
 datacosmos/config/__init__.py,sha256=KCsaTb9-ZgFui1GM8wZFIPLJy0D0O8l8Z1Sv3NRD9UM,140
 datacosmos/config/config.py,sha256=JHWmS6Q_T32iMly7cvJncjPCvtIgamBigKJJcvjGH7g,3465
@@ -18,12 +18,13 @@ datacosmos/config/models/local_user_account_authentication_config.py,sha256=SJZR
 datacosmos/config/models/m2m_authentication_config.py,sha256=4l3Mmgips73rYGX5l7FCoHAWpWSGQYYkzZYvQzbmRz0,782
 datacosmos/config/models/no_authentication_config.py,sha256=x5xikSGPuqQbrf_S2oIWXo5XxAORci2sSE5KyJvZHVw,312
 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/exceptions/__init__.py,sha256=2nS68zE1_AysfbH2S7QtX2pJ984hPLNjSqI_qzod2rc,212
+datacosmos/exceptions/datacosmos_error.py,sha256=6Y9Hzo__aYbjTIpgTaD_Vh6Z271lbxyhoed859LpCY4,915
+datacosmos/exceptions/stac_validation_error.py,sha256=4wmLcJwRraZ6S0JPYxL7jDs8X8k68KmNbcVTl_z1hkI,237
 datacosmos/stac/__init__.py,sha256=B4x_Mr4X7TzQoYtRC-VzI4W-fEON5WUOaz8cWJbk3Fc,214
 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/collection_client.py,sha256=2ritToTSAC2n1nJgd7HpEDNvzda_qc-zsUUV39rbCRs,6052
 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
@@ -33,29 +34,29 @@ datacosmos/stac/enums/processing_level.py,sha256=_k4FO818VlZWtlm-rULhg-CYkbewkOd
 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=HCHl3cHp0u2qxbwLxPk0xkujC1D4uwIBIFI-flpLXfQ,7783
+datacosmos/stac/item/item_client.py,sha256=o05_xHqndaNUrPvHmwkGh1cxe0jnk3tn2Itray7VLh0,10170
 datacosmos/stac/item/models/__init__.py,sha256=bcOrOcIxGxGBrRVIyQVxSM3C3Xj_qzxIHgQeWo6f7Q8,34
 datacosmos/stac/item/models/asset.py,sha256=mvg_fenYCGOTMGwXXpK2nyqBk5RMsUYxl6KhQTWW_b0,631
 datacosmos/stac/item/models/catalog_search_parameters.py,sha256=3HrUm37VezujwuCR45jhMryS5m1FGc1XmX8-fdTy4jU,4870
-datacosmos/stac/item/models/datacosmos_item.py,sha256=MJXUJu_kNJIoaTfIG05OlSys9th3KI4hgbzj2m2xI0Q,5027
+datacosmos/stac/item/models/datacosmos_item.py,sha256=BzuqyHvcCq2ADYkg0F4rsu4Vzj4egPQnttSFw71xGFY,5352
 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/storage/__init__.py,sha256=hivfSpOaoSwCAymgU0rTgvSk9LSPAn1cPLQQ9fLmFX0,151
-datacosmos/stac/storage/storage_base.py,sha256=5ioMKbEltPEWr4dkhZQiUhdBFEhe7ajIYUd9z3K8elU,1483
+datacosmos/stac/storage/storage_base.py,sha256=NpCKAA3qEI212WUNZ2-eG9XfSJKDMiJcu4pEmr10-JI,2843
 datacosmos/stac/storage/storage_client.py,sha256=4boqQ3zVMrk9X2IXus-Cs429juLe0cUQ0XEzg_y3yOA,1205
-datacosmos/stac/storage/uploader.py,sha256=cUe-6DbcEXcENReDMaQe4etVCW1n2kPMxQlCuB8YnqU,4635
+datacosmos/stac/storage/uploader.py,sha256=DawtNn4-uEtpUYPZS1fKv77wu-zNne9ltlGZiArzBFI,5919
 datacosmos/stac/storage/dataclasses/__init__.py,sha256=IjcyA8Vod-z1_Gi1FMZhK58Owman0foL25Hs0YtkYYs,43
 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
-datacosmos/utils/http_response/check_api_response.py,sha256=dKWW01jn2_lWV0xpOBABhEP42CFSsx9dP0iSxykbN54,1186
+datacosmos/utils/http_response/check_api_response.py,sha256=l_yQiiekNcNbhFec_5Ue2mFY3YjwWEJS1gilhEJ3Luw,1158
 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.18.dist-info/licenses/LICENSE.md,sha256=vpbRI-UUbZVQfr3VG_CXt9HpRnL1b5kt8uTVbirxeyI,1486
-datacosmos-0.0.18.dist-info/METADATA,sha256=rTT3QYoHGLf1LxLT7i11oLG68l0KUjXaYeC07hFvjOs,1000
-datacosmos-0.0.18.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-datacosmos-0.0.18.dist-info/top_level.txt,sha256=ueobs5CNeyDbPMgXPcVV0d0yNdm8CvGtDT3CaksRVtA,11
-datacosmos-0.0.18.dist-info/RECORD,,
+datacosmos-0.0.20.dist-info/licenses/LICENSE.md,sha256=vpbRI-UUbZVQfr3VG_CXt9HpRnL1b5kt8uTVbirxeyI,1486
+datacosmos-0.0.20.dist-info/METADATA,sha256=WfpmuajQ7GSenjnr8X04rNXDg6U6NH3pmbFMtJYqFV4,1000
+datacosmos-0.0.20.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+datacosmos-0.0.20.dist-info/top_level.txt,sha256=ueobs5CNeyDbPMgXPcVV0d0yNdm8CvGtDT3CaksRVtA,11
+datacosmos-0.0.20.dist-info/RECORD,,