datacosmos 0.0.17__tar.gz → 0.0.19__tar.gz

{datacosmos-0.0.17 → datacosmos-0.0.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datacosmos
-Version: 0.0.17
+Version: 0.0.19
 Summary: A library for interacting with DataCosmos from Python code
 Author-email: Open Cosmos <support@open-cosmos.com>
 Classifier: Programming Language :: Python :: 3
@@ -16,6 +16,7 @@ Requires-Dist: pystac==1.12.1
 Requires-Dist: pyyaml==6.0.2
 Requires-Dist: structlog==24.4.0
 Requires-Dist: tenacity>=8.2.3
+Requires-Dist: shapely>=1.8.0
 Provides-Extra: dev
 Requires-Dist: black==22.3.0; extra == "dev"
 Requires-Dist: ruff==0.9.5; extra == "dev"

{datacosmos-0.0.17 → datacosmos-0.0.19}/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-0.0.17 → datacosmos-0.0.19}/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-0.0.17 → datacosmos-0.0.19}/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-0.0.19/datacosmos/exceptions/__init__.py

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

datacosmos-0.0.17/datacosmos/exceptions/datacosmos_exception.py → datacosmos-0.0.19/datacosmos/exceptions/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-0.0.19/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-0.0.17 → datacosmos-0.0.19}/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-0.0.19/datacosmos/stac/enums/processing_level.py

@@ -0,0 +1,28 @@
+"""Level enum class."""
+
+from enum import Enum
+
+
+class CaseInsensitiveEnum(Enum):
+    """An enum that can be initialized with case-insensitive strings."""
+
+    @classmethod
+    def _missing_(cls, value: object):
+        if isinstance(value, str):
+            for member in cls:
+                if member.value.lower() == value.lower():
+                    return member
+        return super()._missing_(value)
+
+
+class ProcessingLevel(CaseInsensitiveEnum):
+    """Enum class for the processing levels of the data."""
+
+    RAW = "RAW"
+    L0 = "l0"
+    L1A = "l1A"
+    L2A = "l2A"
+    L1B = "l1B"
+    L1C = "l1C"
+    L1D = "l1D"
+    L3 = "l3"

{datacosmos-0.0.17 → datacosmos-0.0.19}/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-0.0.19/datacosmos/stac/item/models/datacosmos_item.py

@@ -0,0 +1,147 @@
+"""Model representing a datacosmos item."""
+
+import math
+from datetime import datetime
+from typing import Any
+
+from pydantic import BaseModel, ConfigDict, field_validator, model_validator
+from shapely.errors import ShapelyError
+from shapely.geometry import Polygon, shape
+
+from datacosmos.exceptions.stac_validation_error import StacValidationError
+from datacosmos.stac.enums.processing_level import ProcessingLevel
+from datacosmos.stac.item.models.asset import Asset
+
+_REQUIRED_DATACOSMOS_PROPERTIES = [
+    "datetime",
+    "processing:level",
+    "sat:platform_international_designator",
+]
+
+
+class DatacosmosItem(BaseModel):
+    """Model representing a flexible Datacosmos STAC item with mandatory business fields."""
+
+    model_config = ConfigDict(extra="allow")
+
+    id: str
+    type: str
+    geometry: dict[str, Any]
+    bbox: list[float]
+    properties: dict[str, Any]
+
+    links: list[dict[str, Any]]
+    assets: dict[str, Asset]
+
+    stac_version: str | None = None
+    stac_extensions: list[str] | None = None
+    collection: str | None = None
+
+    @field_validator("properties", mode="before")
+    @classmethod
+    def validate_datacosmos_properties(
+        cls, properties_data: dict[str, Any]
+    ) -> dict[str, Any]:
+        """Validates that Datacosmos-specific properties exist."""
+        missing_keys = [
+            key for key in _REQUIRED_DATACOSMOS_PROPERTIES if key not in properties_data
+        ]
+
+        if missing_keys:
+            raise StacValidationError(
+                f"Datacosmos-specific properties are missing: {', '.join(missing_keys)}."
+            )
+        return properties_data
+
+    @field_validator("geometry", mode="before")
+    @classmethod
+    def validate_geometry_is_polygon(
+        cls, geometry_data: dict[str, Any]
+    ) -> dict[str, Any]:
+        """Validates that the geometry is a Polygon with coordinates and correct winding order."""
+        if geometry_data.get("type") != "Polygon" or not geometry_data.get(
+            "coordinates"
+        ):
+            raise StacValidationError("Geometry must be a Polygon with coordinates.")
+
+        try:
+            # Use shape() for robust GeoJSON parsing and validation
+            polygon = shape(geometry_data)
+
+            if not polygon.is_valid:
+                raise ValueError(f"Polygon geometry is invalid: {polygon.geom_type}")
+
+            # right-hand rule validation:
+            # The right-hand rule means exterior ring must be counter-clockwise (CCW).
+            # Shapely's Polygon stores the exterior as CCW if the input is valid.
+            if not polygon.exterior.is_ccw:
+                raise ValueError(
+                    "Polygon winding order violates GeoJSON Right-Hand Rule (Exterior ring is clockwise)."
+                )
+
+        except (KeyError, ShapelyError, ValueError) as e:
+            raise StacValidationError(f"Invalid geometry data: {e}") from e
+
+        return geometry_data
+
+    @model_validator(mode="after")
+    def validate_bbox_vs_geometry(self) -> "DatacosmosItem":
+        """Validates that the bbox tightly encloses the geometry."""
+        if self.geometry and self.bbox:
+            try:
+                geom_shape = shape(self.geometry)
+                true_bbox = list(geom_shape.bounds)
+
+                # Check for floating point equality within a tolerance
+                if not all(
+                    math.isclose(a, b, rel_tol=1e-9)
+                    for a, b in zip(self.bbox, true_bbox)
+                ):
+                    raise StacValidationError(
+                        "Provided bbox does not match geometry bounds."
+                    )
+            except Exception as e:
+                # Catch any errors from Shapely or the comparison
+                raise StacValidationError(f"Invalid bbox or geometry: {e}") from e
+        return self
+
+    def get_property(self, key: str) -> Any | 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."""
+        return self.properties["sat:platform_international_designator"]
+
+    @property
+    def polygon(self) -> Polygon:
+        """Returns the polygon of the item."""
+        coordinates = self.geometry["coordinates"][0]
+        return Polygon(coordinates)
+
+    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-0.0.17 → datacosmos-0.0.19}/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.17 → datacosmos-0.0.19}/datacosmos.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datacosmos
-Version: 0.0.17
+Version: 0.0.19
 Summary: A library for interacting with DataCosmos from Python code
 Author-email: Open Cosmos <support@open-cosmos.com>
 Classifier: Programming Language :: Python :: 3
@@ -16,6 +16,7 @@ Requires-Dist: pystac==1.12.1
 Requires-Dist: pyyaml==6.0.2
 Requires-Dist: structlog==24.4.0
 Requires-Dist: tenacity>=8.2.3
+Requires-Dist: shapely>=1.8.0
 Provides-Extra: dev
 Requires-Dist: black==22.3.0; extra == "dev"
 Requires-Dist: ruff==0.9.5; extra == "dev"

{datacosmos-0.0.17 → datacosmos-0.0.19}/datacosmos.egg-info/SOURCES.txt

@@ -27,7 +27,8 @@ datacosmos/config/models/m2m_authentication_config.py
 datacosmos/config/models/no_authentication_config.py
 datacosmos/config/models/url.py
 datacosmos/exceptions/__init__.py
-datacosmos/exceptions/datacosmos_exception.py
+datacosmos/exceptions/datacosmos_error.py
+datacosmos/exceptions/stac_validation_error.py
 datacosmos/stac/__init__.py
 datacosmos/stac/stac_client.py
 datacosmos/stac/collection/__init__.py

{datacosmos-0.0.17 → datacosmos-0.0.19}/datacosmos.egg-info/requires.txt

@@ -7,6 +7,7 @@ pystac==1.12.1
 pyyaml==6.0.2
 structlog==24.4.0
 tenacity>=8.2.3
+shapely>=1.8.0
 
 [dev]
 black==22.3.0

{datacosmos-0.0.17 → datacosmos-0.0.19}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "datacosmos"
-version = "0.0.17"
+version = "0.0.19"
 authors = [
     { name="Open Cosmos", email="support@open-cosmos.com" },
 ]
@@ -23,7 +23,8 @@ dependencies = [
     "pystac==1.12.1",
     "pyyaml==6.0.2",
     "structlog==24.4.0",
-    "tenacity>=8.2.3"
+    "tenacity>=8.2.3",
+    "shapely>=1.8.0"
 ]
 
 [project.optional-dependencies]

datacosmos-0.0.17/datacosmos/exceptions/__init__.py

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

datacosmos-0.0.17/datacosmos/stac/enums/processing_level.py

@@ -1,16 +0,0 @@
-"""Level enum class."""
-
-from enum import Enum
-
-
-class ProcessingLevel(Enum):
-    """Enum class for the processing levels of the data."""
-
-    RAW = "RAW"
-    L0 = "l0"
-    L1A = "l1A"
-    L2A = "l2A"
-    L1B = "l1B"
-    L1C = "l1C"
-    L1D = "l1D"
-    L3 = "l3"

datacosmos-0.0.17/datacosmos/stac/item/models/datacosmos_item.py

@@ -1,55 +0,0 @@
-"""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()