terrakio-core 0.4.98.1b6__tar.gz → 0.4.98.1b8__tar.gz

{terrakio_core-0.4.98.1b6 → terrakio_core-0.4.98.1b8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: terrakio-core
-Version: 0.4.98.1b6
+Version: 0.4.98.1b8
 Summary: Core package for the terrakio-python-api
 Requires-Python: >=3.11
 Requires-Dist: aiofiles>=24.1.0

{terrakio_core-0.4.98.1b6 → terrakio_core-0.4.98.1b8}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "terrakio-core"
-version = "0.4.98.1b6"
+version = "0.4.98.1b8"
 description = "Core package for the terrakio-python-api"
 readme = "README.md"
 requires-python = ">=3.11"

{terrakio_core-0.4.98.1b6 → terrakio_core-0.4.98.1b8}/terrakio_core/endpoints/mass_stats.py

@@ -1,7 +1,7 @@
 import json
 import os
 import time
-from typing import Dict, Any, Optional, List
+from typing import Dict, Any, Optional, List, Union
 
 import aiohttp
 import typer
@@ -985,4 +985,146 @@ class MassStats:
             'collection': collection,
             'downloaded_files': downloaded_files,
             'total': len(downloaded_files)
-        }
+        }
+
+    @require_api_key
+    async def gen_and_process(
+        self,
+        collection: str,
+        requests_file: Union[str, Any],
+        output: str,
+        folder: str,
+        consumer: Union[str, Any],
+        extra: Optional[Dict[str, Any]] = None,
+        force_loc: Optional[bool] = False,
+        skip_existing: Optional[bool] = True,
+        server: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """
+        Generate data and run post-processing in a single task.
+
+        Args:
+            collection: Name of collection
+            requests_file: Path to JSON file or file object containing request configurations
+            output: Output type (str)
+            folder: Folder to store output
+            consumer: Path to post processing script or file object
+            extra: Additional configuration parameters (optional)
+            force_loc: Write data directly to the cloud under this folder (optional, defaults to False)
+            skip_existing: Skip existing data (optional, defaults to True)
+            server: Server to use (optional)
+
+        Returns:
+            API response as a dictionary containing task information
+
+        Raises:
+            CollectionNotFoundError: If the collection is not found
+            GetTaskError: If the API request fails due to unknown reasons
+        """
+        await self.create_collection(collection=collection)
+
+        upload_urls = await self._upload_requests(collection=collection)
+        url = upload_urls['url']
+        
+        # Handle requests_file - either file path (str) or file object
+        if isinstance(requests_file, str):
+            await self._upload_file(requests_file, url)
+        else:
+            # File object - read JSON and upload directly
+            json_data = json.load(requests_file)
+            await self._upload_json_data(json_data, url)
+
+        # Handle consumer - either file path (str) or file object
+        if isinstance(consumer, str):
+            with open(consumer, 'rb') as f:
+                consumer_content = f.read()
+        else:
+            # Assume it's a file object
+            consumer_content = consumer.read()
+        
+        form = aiohttp.FormData()
+        form.add_field('output', output)
+        form.add_field('force_loc', str(force_loc).lower())
+        form.add_field('skip_existing', str(skip_existing).lower())
+        
+        if server is not None:
+            form.add_field('server', server)
+        
+        form.add_field('extra', json.dumps(extra or {}))
+        form.add_field('folder', folder)
+        form.add_field(
+            'consumer',
+            consumer_content,
+            filename='consumer.py',
+            content_type='text/x-python'
+        )
+        
+        response, status = await self._client._terrakio_request(
+            "POST",
+            f"collections/{collection}/gen_and_process",
+            data=form
+        )
+        
+        if status != 200:
+            if status == 404:
+                raise CollectionNotFoundError(f"Collection {collection} not found", status_code=status)
+            raise GetTaskError(f"Gen and process failed with status {status}", status_code=status)
+
+        return response
+
+    @require_api_key
+    async def create_pyramids(
+        self,
+        name: str,
+        levels: int,
+        config: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """
+        Create pyramid tiles for a dataset.
+
+        Args:
+            name: Dataset name
+            levels: Maximum zoom level for pyramid (e.g., 8)
+            config: Full pyramid configuration dictionary containing:
+                - name: Dataset name (will override the name parameter)
+                - bucket: GCS bucket name (e.g., "terrakio")
+                - products: List of product names (e.g., ["air_temp", "prec"])
+                - path: Path pattern (e.g., "pyramids/%s_%s_%03d_%03d_%02d.snp")
+                - data_type: Data type (e.g., "float32")
+                - i_max: Maximum i index
+                - j_max: Maximum j index
+                - x_size: Tile size in x (e.g., 400)
+                - y_size: Tile size in y (e.g., 400)
+                - dates_iso8601: List of ISO8601 date strings
+                - no_data: No data value (e.g., -9999.0)
+
+        Returns:
+            API response with task_id
+
+        Raises:
+            GetTaskError: If the API request fails
+        """
+        await self.create_collection(collection = name)
+        
+        pyramid_request = {
+            'name': name,
+            'max_zoom': levels,
+            **config
+        }
+        
+        response, status = await self._client._terrakio_request(
+            "POST",
+            "tasks/pyramids",
+            json=pyramid_request
+        )
+        
+        if status != 200:
+            raise GetTaskError(
+                f"Pyramid creation failed with status {status}: {response}", 
+                status_code=status
+            )
+        
+        task_id = response["task_id"]
+        await self.track_progress(task_id)
+
+        return {"task_id": task_id}