datacosmos 0.0.3__tar.gz → 0.0.5__tar.gz

{datacosmos-0.0.3/datacosmos.egg-info → datacosmos-0.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datacosmos
-Version: 0.0.3
+Version: 0.0.5
 Summary: A library for interacting with DataCosmos from Python code
 Author-email: Open Cosmos <support@open-cosmos.com>
 Classifier: Programming Language :: Python :: 3
@@ -13,6 +13,8 @@ Requires-Dist: oauthlib==3.2.0
 Requires-Dist: requests-oauthlib==1.3.1
 Requires-Dist: pydantic==2.10.6
 Requires-Dist: pystac==1.12.1
+Requires-Dist: pyyaml==6.0.2
+Requires-Dist: structlog==25.3.0
 Provides-Extra: dev
 Requires-Dist: black==22.3.0; extra == "dev"
 Requires-Dist: ruff==0.9.5; extra == "dev"

datacosmos-0.0.5/README.md

@@ -0,0 +1,385 @@
+# DataCosmos SDK
+
+## Overview
+
+The **DataCosmos SDK** enables Open Cosmos customers to interact with the **DataCosmos APIs** for efficient data management and retrieval. It provides authentication handling, HTTP request utilities, and a client for interacting with the **STAC API** (SpatioTemporal Asset Catalog).
+
+## Installation
+
+Install the SDK using **pip**:
+
+```sh
+pip install datacosmos=={version}
+```
+
+## Initializing the Client
+
+To start using the SDK, initialize the client. The easiest way to do this is by loading the configuration from a YAML file. Alternatively, you can manually instantiate the Config object or use environment variables.
+
+### Default Initialization (Recommended)
+
+By default, the client loads configuration from a YAML file (`config/config.yaml`).
+
+```python
+from datacosmos.datacosmos_client import DatacosmosClient
+
+client = DatacosmosClient()
+```
+
+### Loading from YAML (Recommended)
+
+Create a YAML file (`config/config.yaml`) with the following content:
+
+```yaml
+authentication:
+    client_id: {client_id}  
+    client_secret: {client_secret}
+```
+
+The client will automatically read this file when initialized.
+
+### Loading from Environment Variables
+
+Set the following environment variables:
+
+```sh
+export OC_AUTH_CLIENT_ID={client_id}
+export OC_AUTH_CLIENT_SECRET={client_secret}
+```
+
+The client will automatically read these values when initialized.
+
+### Manual Instantiation
+
+If manually instantiating `Config`, default values are now applied where possible.
+
+```python
+from datacosmos.datacosmos_client import DatacosmosClient
+from config.config import Config
+from config.models.m2m_authentication_config import M2MAuthenticationConfig
+from config.models.url import URL
+
+config = Config(
+    authentication=M2MAuthenticationConfig(
+        client_id="your-client-id",
+        client_secret="your-client-secret"
+    )
+)
+
+client = DatacosmosClient(config=config)
+```
+
+### Configuration Options and Defaults
+
+| Setting                      | Default Value                                     | Override Method |
+|------------------------------|-------------------------------------------------|----------------|
+| `authentication.type`        | `m2m`                                           | YAML / ENV     |
+| `authentication.client_id`   | _Required in manual instantiation_              | YAML / ENV     |
+| `authentication.client_secret` | _Required in manual instantiation_            | YAML / ENV     |
+| `stac.protocol`              | `https`                                         | YAML / ENV     |
+| `stac.host`                  | `app.open-cosmos.com`                           | YAML / ENV     |
+| `stac.port`                  | `443`                                           | YAML / ENV     |
+| `stac.path`                  | `/api/data/v0/stac`                             | YAML / ENV     |
+| `datacosmos_cloud_storage.protocol` | `https`                                 | YAML / ENV     |
+| `datacosmos_cloud_storage.host`     | `app.open-cosmos.com`                   | YAML / ENV     |
+| `datacosmos_cloud_storage.port`     | `443`                                   | YAML / ENV     |
+| `datacosmos_cloud_storage.path`     | `/api/data/v0/storage`                 | YAML / ENV     |
+| `mission_id`                | `0`                                             | YAML / ENV     |
+| `environment`               | `test`                                          | YAML / ENV     |
+
+## STAC Client
+
+The `STACClient` enables interaction with the STAC API, allowing for searching, retrieving, creating, updating, and deleting STAC items and collections.
+
+### Initialize STACClient
+
+```python
+from datacosmos.datacosmos_client import DatacosmosClient
+from datacosmos.stac.stac_client import STACClient
+
+client = DatacosmosClient()
+stac_client = STACClient(client)
+```
+
+### STACClient Methods
+
+#### 1. **Search Items**
+```python
+from datacosmos.stac.item.models.catalog_search_parameters import CatalogSearchParameters
+from datacosmos.datacosmos_client import DatacosmosClient
+from datacosmos.stac.stac_client import STACClient
+
+client = DatacosmosClient()
+stac_client = STACClient(client)
+
+params = CatalogSearchParameters(
+     start_date="2/9/2025",
+     end_date="2/9/2025",
+     satellite=["MANTIS"],
+     product_type=["Satellite"],
+     processing_level=["L1A"],
+     collections=["mantis-l1a"]
+)
+
+items = list(stac_client.search_items(parameters=params, project_id="your-project-id"))
+```
+
+#### 2. **Fetch a Single Item**
+```python
+from datacosmos.datacosmos_client import DatacosmosClient
+from datacosmos.stac.stac_client import STACClient
+
+client = DatacosmosClient()
+stac_client = STACClient(client)
+
+item = stac_client.fetch_item(item_id="example-item", collection_id="example-collection")
+```
+#### 3. **Create a New STAC Item**
+```python
+from pystac import Item, Asset
+from datetime import datetime
+
+from datacosmos.datacosmos_client import DatacosmosClient
+from datacosmos.stac.stac_client import STACClient
+
+client = DatacosmosClient()
+stac_client = STACClient(client)
+
+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={"datetime": datetime.utcnow(), "processing:level": "example-processing-level"},
+    collection="example-collection"
+)
+
+stac_item.add_asset(
+    "image",
+    Asset(
+        href="https://example.com/sample-image.tiff",
+        media_type="image/tiff",
+        roles=["data"],
+        title="Sample Image"
+    )
+)
+
+stac_client.create_item(collection_id="example-collection", item=stac_item)
+```
+
+#### 4. **Update an Existing STAC Item**
+```python
+from datacosmos.stac.item.models.item_update import ItemUpdate
+from pystac import Asset, Link
+
+from datacosmos.datacosmos_client import DatacosmosClient
+from datacosmos.stac.stac_client import STACClient
+
+client = DatacosmosClient()
+stac_client = STACClient(client)
+
+update_payload = ItemUpdate(
+    properties={
+        "new_property": "updated_value",
+        "datetime": "2024-11-10T14:58:00Z"
+    },
+    assets={
+        "image": Asset(
+            href="https://example.com/updated-image.tiff",
+            media_type="image/tiff"
+        )
+    },
+    links=[
+        Link(rel="self", target="https://example.com/updated-image.tiff")
+    ],
+    geometry={
+        "type": "Point",
+        "coordinates": [10, 20]
+    },
+    bbox=[10.0, 20.0, 30.0, 40.0]
+)
+
+stac_client.update_item(item_id="new-item", collection_id="example-collection", update_data=update_payload)
+```
+
+#### 5. **Delete an Item**
+```python
+
+from datacosmos.datacosmos_client import DatacosmosClient
+from datacosmos.stac.stac_client import STACClient
+
+client = DatacosmosClient()
+stac_client = STACClient(client)
+
+stac_client.delete_item(item_id="new-item", collection_id="example-collection")
+```
+
+#### 6. Fetch a Collection
+
+```python
+
+from datacosmos.datacosmos_client import DatacosmosClient
+from datacosmos.stac.stac_client import STACClient
+
+client = DatacosmosClient()
+stac_client = STACClient(client)
+
+collection = stac_client.fetch_collection("test-collection")
+```
+
+#### 7. Fetch All Collections
+
+```python
+
+from datacosmos.datacosmos_client import DatacosmosClient
+from datacosmos.stac.stac_client import STACClient
+
+client = DatacosmosClient()
+stac_client = STACClient(client)
+
+collections = list(stac_client.fetch_all_collections())
+```
+
+#### 8. Create a Collection
+
+```python
+from pystac import Collection
+
+from datacosmos.datacosmos_client import DatacosmosClient
+from datacosmos.stac.stac_client import STACClient
+
+client = DatacosmosClient()
+stac_client = STACClient(client)
+
+new_collection = Collection(
+    id="test-collection",
+    title="Test Collection",
+    description="This is a test collection",
+    license="proprietary",
+    extent={
+        "spatial": {"bbox": [[-180, -90, 180, 90]]},
+        "temporal": {"interval": [["2023-01-01T00:00:00Z", None]]},
+    },
+)
+
+stac_client.create_collection(new_collection)
+```
+
+#### 9. Update a Collection
+
+```python
+from datacosmos.stac.collection.models.collection_update import CollectionUpdate
+
+from datacosmos.datacosmos_client import DatacosmosClient
+from datacosmos.stac.stac_client import STACClient
+
+client = DatacosmosClient()
+stac_client = STACClient(client)
+
+update_data = CollectionUpdate(
+    title="Updated Collection Title",
+    description="Updated description",
+)
+
+stac_client.update_collection("test-collection", update_data)
+```
+
+#### 10. Delete a Collection
+
+```python
+
+from datacosmos.datacosmos_client import DatacosmosClient
+from datacosmos.stac.stac_client import STACClient
+
+client = DatacosmosClient()
+stac_client = STACClient(client)
+
+stac_client.delete_collection("test-collection")
+```
+
+## Uploading Files and Registering STAC Items
+
+You can use the `DatacosmosUploader` class to upload files to the DataCosmos cloud storage and register a STAC item. The `upload_and_register_item` method will take care of both uploading files and creating the STAC item.
+
+### **Upload Files and Register STAC Item**
+
+1. Make sure you have a directory with the same name as your STAC item JSON file (this directory should contain the files you want to upload).
+2. Call the `upload_and_register_item` method, providing the path to the STAC item JSON file.
+
+```python
+from datacosmos.datacosmos_client import DatacosmosClient
+from datacosmos.uploader.datacosmos_uploader import DatacosmosUploader
+
+# Initialize the client with the configuration
+client = DatacosmosClient(config=config)
+
+# Create the uploader instance
+uploader = DatacosmosUploader(client)
+
+# Path to your STAC item JSON file
+item_json_file_path = "/home/peres/repos/datacosmos-sdk/MENUT_L1A_000001943_20250304134812_20250304134821_49435814.json"
+
+# Upload the item and its assets, and register it in the STAC API
+uploader.upload_and_register_item(item_json_file_path)
+```
+
+### **Folder Structure**
+
+For the `upload_and_register_item` method to work correctly, ensure that the directory structure matches the name of the STAC item JSON file. For example:
+
+```
+/home/peres/repos/datacosmos-sdk/MENUT_L1A_000001943_20250304134812_20250304134821_49435814.json
+/home/peres/repos/datacosmos-sdk/MENUT_L1A_000001943_20250304134812_20250304134821_49435814/
+    ├── asset1.tiff
+    ├── asset2.tiff
+    └── ...
+```
+
+The folder `MENUT_L1A_000001943_20250304134812_20250304134821_49435814` should contain the assets (files) for upload.
+
+The `upload_and_register_item` method will:
+1. Delete any existing item with the same ID (if it exists).
+2. Upload the assets in the folder to DataCosmos cloud storage.
+3. Register the item in the STAC API.
+
+## Error Handling
+
+Use `try-except` blocks to handle API errors gracefully:
+
+```python
+try:
+    data = client.get_data("dataset_id")
+    print(data)
+except Exception as e:
+    print(f"An error occurred: {e}")
+```
+
+## Contributing
+
+To contribute:
+
+1. Fork the repository.
+2. Create a feature branch.
+3. Submit a pull request.
+
+### Development Setup
+
+Use `uv` for dependency management:
+
+```sh
+pip install uv
+uv venv
+uv pip install -r pyproject.toml .[dev]
+source .venv/bin/activate
+```
+
+Before making changes, run:
+
+```sh
+black .
+isort .
+ruff check .
+pydocstyle .
+bandit -r -c pyproject.toml .
+pytest
+```

{datacosmos-0.0.3 → datacosmos-0.0.5}/config/config.py

@@ -6,7 +6,7 @@ and supports environment variable-based overrides.
 """
 
 import os
-from typing import ClassVar, Literal, Optional
+from typing import ClassVar, Optional
 
 import yaml
 from pydantic import field_validator
@@ -29,7 +29,6 @@ class Config(BaseSettings):
     stac: Optional[URL] = None
     datacosmos_cloud_storage: Optional[URL] = None
     mission_id: int = 0
-    environment: Literal["local", "test", "prod"] = "test"
 
     DEFAULT_AUTH_TYPE: ClassVar[str] = "m2m"
     DEFAULT_AUTH_TOKEN_URL: ClassVar[str] = "https://login.open-cosmos.com/oauth/token"

{datacosmos-0.0.3 → datacosmos-0.0.5}/config/models/m2m_authentication_config.py

@@ -6,7 +6,7 @@ without user interaction.
 
 from typing import Literal
 
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 
 
 class M2MAuthenticationConfig(BaseModel):
@@ -16,8 +16,12 @@ class M2MAuthenticationConfig(BaseModel):
     with client credentials.
     """
 
-    type: Literal["m2m"]
+    DEFAULT_TYPE: Literal["m2m"] = "m2m"
+    DEFAULT_TOKEN_URL: str = "https://login.open-cosmos.com/oauth/token"
+    DEFAULT_AUDIENCE: str = "https://beeapp.open-cosmos.com"
+
+    type: Literal["m2m"] = Field(default=DEFAULT_TYPE)
     client_id: str
-    token_url: str
-    audience: str
+    token_url: str = Field(default=DEFAULT_TOKEN_URL)
+    audience: str = Field(default=DEFAULT_AUDIENCE)
     client_secret: str

{datacosmos-0.0.3 → datacosmos-0.0.5}/datacosmos/stac/collection/collection_client.py

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

{datacosmos-0.0.3 → datacosmos-0.0.5}/datacosmos/stac/collection/models/collection_update.py

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

datacosmos-0.0.5/datacosmos/stac/constants/__init__.py

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

datacosmos-0.0.5/datacosmos/stac/constants/satellite_name_mapping.py

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

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

@@ -0,0 +1,15 @@
+"""Level enum class."""
+
+from enum import Enum
+
+
+class ProcessingLevel(Enum):
+    """Enum class for the processing levels of the data."""
+
+    L0 = "L0"
+    L1A = "L1A"
+    L2A = "L2A"
+    L1B = "L1B"
+    L1C = "L1C"
+    L1D = "L1D"
+    L3 = "L3"

datacosmos-0.0.5/datacosmos/stac/enums/product_type.py

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

datacosmos-0.0.5/datacosmos/stac/enums/season.py

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

{datacosmos-0.0.3 → datacosmos-0.0.5}/datacosmos/stac/item/item_client.py

@@ -9,9 +9,11 @@ from pystac import Item
 
 from datacosmos.datacosmos_client import DatacosmosClient
 from datacosmos.exceptions.datacosmos_exception import DatacosmosException
+from datacosmos.stac.item.models.catalog_search_parameters import (
+    CatalogSearchParameters,
+)
 from datacosmos.stac.item.models.datacosmos_item import DatacosmosItem
 from datacosmos.stac.item.models.item_update import ItemUpdate
-from datacosmos.stac.item.models.search_parameters import SearchParameters
 from datacosmos.utils.http_response.check_api_response import check_api_response
 
 
@@ -42,34 +44,22 @@ class ItemClient:
         check_api_response(response)
         return Item.from_dict(response.json())
 
-    def fetch_collection_items(
-        self, collection_id: str, parameters: Optional[SearchParameters] = None
+    def search_items(
+        self, parameters: CatalogSearchParameters, project_id: str
     ) -> 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.
+            parameters (CatalogSearchParameters): The search parameters.
 
         Yields:
             Item: Parsed STAC item.
         """
         url = self.base_url.with_suffix("/search")
-        body = parameters.model_dump(by_alias=True, exclude_none=True)
+        parameters_query = parameters.to_query()
+        body = {"project": project_id, "limit": 50, "query": parameters_query}
+        if parameters.collections is not None:
+            body = body | {"collections": parameters.collections}
         return self._paginate_items(url, body)
 
     def create_item(self, collection_id: str, item: Item | DatacosmosItem) -> None:
@@ -84,7 +74,6 @@ class ItemClient:
         """
         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)
 

datacosmos-0.0.5/datacosmos/stac/item/models/catalog_search_parameters.py

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

{datacosmos-0.0.3 → datacosmos-0.0.5}/datacosmos/stac/item/models/datacosmos_item.py

@@ -4,7 +4,7 @@ from datetime import datetime
 
 from pydantic import BaseModel
 
-from datacosmos.stac.enums.level import Level
+from datacosmos.stac.enums.processing_level import ProcessingLevel
 from datacosmos.stac.item.models.asset import Asset
 
 
@@ -36,9 +36,9 @@ class DatacosmosItem(BaseModel):
         return datetime.strptime(self.properties["datetime"], "%Y-%m-%dT%H:%M:%SZ")
 
     @property
-    def level(self) -> Level:
+    def level(self) -> ProcessingLevel:
         """Get the processing level of the Datacosmos item."""
-        return Level(self.properties["processing:level"].lower())
+        return ProcessingLevel(self.properties["processing:level"].lower())
 
     @property
     def sat_int_designator(self) -> str:

{datacosmos-0.0.3 → datacosmos-0.0.5}/datacosmos/uploader/dataclasses/upload_path.py

@@ -6,7 +6,7 @@ from pathlib import Path
 
 import structlog
 
-from datacosmos.stac.enums.level import Level
+from datacosmos.stac.enums.processing_level import ProcessingLevel
 from datacosmos.stac.item.models.datacosmos_item import DatacosmosItem
 from datacosmos.utils.missions import get_mission_id
 
@@ -18,7 +18,7 @@ class UploadPath:
     """Dataclass for retrieving the upload path of a file."""
 
     mission: str
-    level: Level
+    level: ProcessingLevel
     day: int
     month: int
     year: int
@@ -43,7 +43,7 @@ class UploadPath:
         dt = datetime.strptime(item.properties["datetime"], "%Y-%m-%dT%H:%M:%SZ")
         path = UploadPath(
             mission=mission,
-            level=Level(item.properties["processing:level"].lower()),
+            level=ProcessingLevel(item.properties["processing:level"].upper()),
             day=dt.day,
             month=dt.month,
             year=dt.year,
@@ -60,7 +60,7 @@ class UploadPath:
             raise ValueError(f"Invalid path {path}")
         return cls(
             mission=parts[0],
-            level=Level(parts[1]),
+            level=ProcessingLevel(parts[1]),
             day=int(parts[4]),
             month=int(parts[3]),
             year=int(parts[2]),

{datacosmos-0.0.3 → datacosmos-0.0.5/datacosmos.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datacosmos
-Version: 0.0.3
+Version: 0.0.5
 Summary: A library for interacting with DataCosmos from Python code
 Author-email: Open Cosmos <support@open-cosmos.com>
 Classifier: Programming Language :: Python :: 3
@@ -13,6 +13,8 @@ Requires-Dist: oauthlib==3.2.0
 Requires-Dist: requests-oauthlib==1.3.1
 Requires-Dist: pydantic==2.10.6
 Requires-Dist: pystac==1.12.1
+Requires-Dist: pyyaml==6.0.2
+Requires-Dist: structlog==25.3.0
 Provides-Extra: dev
 Requires-Dist: black==22.3.0; extra == "dev"
 Requires-Dist: ruff==0.9.5; extra == "dev"

{datacosmos-0.0.3 → datacosmos-0.0.5}/datacosmos.egg-info/SOURCES.txt

@@ -21,17 +21,21 @@ 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/constants/__init__.py
+datacosmos/stac/constants/satellite_name_mapping.py
 datacosmos/stac/enums/__init__.py
-datacosmos/stac/enums/level.py
+datacosmos/stac/enums/processing_level.py
+datacosmos/stac/enums/product_type.py
+datacosmos/stac/enums/season.py
 datacosmos/stac/item/__init__.py
 datacosmos/stac/item/item_client.py
 datacosmos/stac/item/models/__init__.py
 datacosmos/stac/item/models/asset.py
+datacosmos/stac/item/models/catalog_search_parameters.py
 datacosmos/stac/item/models/datacosmos_item.py
 datacosmos/stac/item/models/eo_band.py
 datacosmos/stac/item/models/item_update.py
 datacosmos/stac/item/models/raster_band.py
-datacosmos/stac/item/models/search_parameters.py
 datacosmos/uploader/__init__.py
 datacosmos/uploader/datacosmos_uploader.py
 datacosmos/uploader/dataclasses/__init__.py

{datacosmos-0.0.3 → datacosmos-0.0.5}/datacosmos.egg-info/requires.txt

@@ -4,6 +4,8 @@ oauthlib==3.2.0
 requests-oauthlib==1.3.1
 pydantic==2.10.6
 pystac==1.12.1
+pyyaml==6.0.2
+structlog==25.3.0
 
 [dev]
 black==22.3.0

{datacosmos-0.0.3 → datacosmos-0.0.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "datacosmos"
-version = "0.0.3"
+version = "0.0.5"
 authors = [
     { name="Open Cosmos", email="support@open-cosmos.com" },
 ]
@@ -20,7 +20,9 @@ dependencies = [
     "oauthlib==3.2.0",
     "requests-oauthlib==1.3.1",
     "pydantic==2.10.6",
-    "pystac==1.12.1"
+    "pystac==1.12.1",
+    "pyyaml==6.0.2",
+    "structlog==25.3.0"
 ]
 
 [project.optional-dependencies]

datacosmos-0.0.3/README.md

@@ -1,209 +0,0 @@
-# DataCosmos SDK
-
-## Overview
-
-The **DataCosmos SDK** enables Open Cosmos customers to interact with the **DataCosmos APIs** for efficient data management and retrieval. It provides authentication handling, HTTP request utilities, and a client for interacting with the **STAC API** (SpatioTemporal Asset Catalog).
-
-## Installation
-
-Install the SDK using **pip**:
-
-```sh
-pip install datacosmos=={version}
-```
-
-## Initializing the Client
-
-To start using the SDK, initialize the client. The easiest way to do this is by loading the configuration from a YAML file. Alternatively, you can manually instantiate the Config object or use environment variables.
-
-### Default Initialization (Recommended)
-
-By default, the client loads configuration from a YAML file (`config/config.yaml`).
-
-```python
-from datacosmos.datacosmos_client import DatacosmosClient
-
-client = DatacosmosClient()
-```
-
-### Loading from YAML (Recommended)
-
-Create a YAML file (`config/config.yaml`) with the following content:
-
-```yaml
-authentication:
-    client_id: {client_id}  
-    client_secret: {client_secret}
-```
-
-The client will automatically read this file when initialized.
-
-### Loading from Environment Variables
-
-Set the following environment variables:
-
-```sh
-export OC_AUTH_CLIENT_ID={client_id}
-export OC_AUTH_CLIENT_SECRET={client_secret}
-```
-
-The client will automatically read these values when initialized.
-
-### Manual Instantiation
-
-If manually instantiating `Config`, default values are now applied where possible.
-
-```python
-from config.config import Config
-from config.models.m2m_authentication_config import M2MAuthenticationConfig
-from config.models.url import URL
-
-config = Config(
-    authentication=M2MAuthenticationConfig(
-        client_id="your-client-id",
-        client_secret="your-client-secret"
-    )
-)
-
-client = DatacosmosClient(config=config)
-```
-
-### Configuration Options and Defaults
-
-| Setting                      | Default Value                                     | Override Method |
-|------------------------------|-------------------------------------------------|----------------|
-| `authentication.type`        | `m2m`                                           | YAML / ENV     |
-| `authentication.client_id`   | _Required in manual instantiation_              | YAML / ENV     |
-| `authentication.client_secret` | _Required in manual instantiation_            | YAML / ENV     |
-| `stac.protocol`              | `https`                                         | YAML / ENV     |
-| `stac.host`                  | `app.open-cosmos.com`                           | YAML / ENV     |
-| `stac.port`                  | `443`                                           | YAML / ENV     |
-| `stac.path`                  | `/api/data/v0/stac`                             | YAML / ENV     |
-| `datacosmos_cloud_storage.protocol` | `https`                                 | YAML / ENV     |
-| `datacosmos_cloud_storage.host`     | `app.open-cosmos.com`                   | YAML / ENV     |
-| `datacosmos_cloud_storage.port`     | `443`                                   | YAML / ENV     |
-| `datacosmos_cloud_storage.path`     | `/api/data/v0/storage`                 | YAML / ENV     |
-| `mission_id`                | `0`                                             | YAML / ENV     |
-| `environment`               | `test`                                          | YAML / ENV     |
-
-## STAC Client
-
-The `STACClient` enables interaction with the STAC API, allowing for searching, retrieving, creating, updating, and deleting STAC items and collections.
-
-### Initialize STACClient
-
-```python
-from datacosmos.datacosmos_client import DatacosmosClient
-from datacosmos.stac.stac_client import STACClient
-
-client = DatacosmosClient()
-stac_client = STACClient(client)
-```
-
-### STACClient Methods
-
-#### 1. Fetch a Collection
-
-```python
-collection = stac_client.fetch_collection("test-collection")
-```
-
-#### 2. Fetch All Collections
-
-```python
-collections = list(stac_client.fetch_all_collections())
-```
-
-#### 3. Create a Collection
-
-```python
-from pystac import Collection
-
-new_collection = Collection(
-    id="test-collection",
-    title="Test Collection",
-    description="This is a test collection",
-    license="proprietary",
-    extent={
-        "spatial": {"bbox": [[-180, -90, 180, 90]]},
-        "temporal": {"interval": [["2023-01-01T00:00:00Z", None]]},
-    },
-)
-
-stac_client.create_collection(new_collection)
-```
-
-#### 4. Update a Collection
-
-```python
-from datacosmos.stac.collection.models.collection_update import CollectionUpdate
-
-update_data = CollectionUpdate(
-    title="Updated Collection Title",
-    description="Updated description",
-)
-
-stac_client.update_collection("test-collection", update_data)
-```
-
-#### 5. Delete a Collection
-
-```python
-stac_client.delete_collection("test-collection")
-```
-
-### Uploading Files and Registering STAC Items
-
-You can use the `DatacosmosUploader` class to upload files to the DataCosmos cloud storage and register a STAC item.
-
-#### Upload Files and Register STAC Item
-
-```python
-from datacosmos.uploader.datacosmos_uploader import DatacosmosUploader
-
-uploader = DatacosmosUploader(client)
-item_json_file_path = "/path/to/stac_item.json"
-uploader.upload_and_register_item(item_json_file_path)
-```
-
-## Error Handling
-
-Use `try-except` blocks to handle API errors gracefully:
-
-```python
-try:
-    data = client.get_data("dataset_id")
-    print(data)
-except Exception as e:
-    print(f"An error occurred: {e}")
-```
-
-## Contributing
-
-To contribute:
-
-1. Fork the repository.
-2. Create a feature branch.
-3. Submit a pull request.
-
-### Development Setup
-
-Use `uv` for dependency management:
-
-```sh
-pip install uv
-uv venv
-uv pip install -r pyproject.toml .[dev]
-source .venv/bin/activate
-```
-
-Before making changes, run:
-
-```sh
-black .
-isort .
-ruff check .
-pydocstyle .
-bandit -r -c pyproject.toml .
-pytest
-```

datacosmos-0.0.3/datacosmos/stac/enums/level.py

@@ -1,15 +0,0 @@
-"""Level enum class."""
-
-from enum import Enum
-
-
-class Level(Enum):
-    """Enum class for the processing levels of the data."""
-
-    L0 = "l0"
-    L1A = "l1a"
-    L2A = "l2a"
-    L1B = "l1b"
-    L1C = "l1c"
-    L1D = "l1d"
-    L3 = "l3"

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

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