terrakio-core 0.4.93__tar.gz → 0.4.95__tar.gz

{terrakio_core-0.4.93 → terrakio_core-0.4.95}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: terrakio-core
-Version: 0.4.93
+Version: 0.4.95
 Summary: Core package for the terrakio-python-api
 Requires-Python: >=3.11
 Requires-Dist: aiofiles>=24.1.0
@@ -8,6 +8,7 @@ Requires-Dist: aiohttp>=3.12.15
 Requires-Dist: geopandas>=1.1.1
 Requires-Dist: h5netcdf>=1.6.3
 Requires-Dist: h5py>=3.14.0
+Requires-Dist: nest-asyncio>=1.6.0
 Requires-Dist: netcdf4>=1.7.2
 Requires-Dist: onnxruntime>=1.22.1
 Requires-Dist: psutil>=7.0.0

{terrakio_core-0.4.93 → terrakio_core-0.4.95}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "terrakio-core"
-version = "0.4.93"
+version = "0.4.95"
 description = "Core package for the terrakio-python-api"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -11,11 +11,15 @@ dependencies = [
     "h5netcdf>=1.6.3",
     "h5py>=3.14.0",
     "netcdf4>=1.7.2",
+    "h5py>=3.14.0",
+    "netcdf4>=1.7.2",
     "onnxruntime>=1.22.1",
     "psutil>=7.0.0",
     "scipy>=1.16.1",
+    "scipy>=1.16.1",
     "shapely>=2.1.1",
     "xarray>=2025.7.1",
+    "nest-asyncio>=1.6.0",
 ]
 
 [project.optional-dependencies]

{terrakio_core-0.4.93 → terrakio_core-0.4.95}/terrakio_core/__init__.py

@@ -5,7 +5,7 @@ Terrakio Core
 Core components for Terrakio API clients.
 """
 
-__version__ = "0.4.93"
+__version__ = "0.4.95"
 
 from .async_client import AsyncClient
 from .sync_client import SyncClient as Client

{terrakio_core-0.4.93 → terrakio_core-0.4.95}/terrakio_core/async_client.py

@@ -17,7 +17,9 @@ from .endpoints.group_management import GroupManagement
 from .endpoints.space_management import SpaceManagement
 from .endpoints.model_management import ModelManagement
 from .endpoints.auth import AuthClient
-from .convenience_functions.convenience_functions import zonal_stats as _zonal_stats, create_dataset_file as _create_dataset_file, request_geoquery_list as _request_geoquery_list
+from .convenience_functions.zonal_stats import zonal_stats as _zonal_stats
+from .convenience_functions.geoquries import request_geoquery_list as _request_geoquery_list
+from .convenience_functions.create_dataset_file import create_dataset_file as _create_dataset_file
 
 class AsyncClient(BaseClient):
     def __init__(self, url: Optional[str] = None, api_key: Optional[str] = None, verbose: bool = False, session: Optional[aiohttp.ClientSession] = None):
@@ -224,6 +226,7 @@ class AsyncClient(BaseClient):
             ValueError: If concurrency is too high or if data exceeds memory limit without streaming
             APIError: If the API request fails
         """
+        # the sync client didn't pass the self here, so the client is now async
         return await _zonal_stats(
             client=self,
             gdf=gdf,

{terrakio_core-0.4.93 → terrakio_core-0.4.95}/terrakio_core/convenience_functions/zonal_stats.py

@@ -56,88 +56,90 @@ class cloud_object(gpd.GeoDataFrame):
         track_info = await self.client.mass_stats.track_job([self.job_id])
         job_info = track_info[self.job_id]
         status = job_info['status']
+        
         if status == "Completed":
-                payload = {
-                    "job_name": job_info["name"],
-                    "file_type": "raw",
-                    "bucket": job_info["bucket"],
-                }
-                result = await self.client._terrakio_request("POST", "mass_stats/download_files", json=payload)
-                download_urls = result["download_urls"][:n]
-                datasets = []
+            payload = {
+                "job_name": job_info["name"],
+                "file_type": "raw",
+                "bucket": job_info["bucket"],
+            }
+            result = await self.client._terrakio_request("POST", "mass_stats/download_files", json=payload)
+            download_urls = result["download_urls"][:n]
+            datasets = []
 
-                async with aiohttp.ClientSession() as session:
-                    for i, url in enumerate(download_urls):
-                        try:
-                            self.client.logger.info(f"Downloading dataset {i+1}/{len(download_urls)}...")
-                            async with session.get(url) as response:
-                                if response.status == 200:
-                                    content = await response.read()
-                                    dataset = xr.open_dataset(BytesIO(content))
-                                    datasets.append(dataset)
-                                    self.client.logger.info(f"Successfully processed dataset {i+1}")
-                                else:
-                                    self.client.logger.warning(f"Failed to download dataset {i+1}: HTTP {response.status}")
-                        except Exception as e:
-                            self.client.logger.error(f"Error downloading dataset {i+1}: {e}")
-                            continue
-                    if not datasets:
-                        self.client.logger.warning("No datasets were successfully downloaded")
-                        return gpd.GeoDataFrame({'geometry': [], 'dataset': []})
+            async with aiohttp.ClientSession() as session:
+                for i, url in enumerate(download_urls):
                     try:
-                        json_response = await self.client._terrakio_request(
-                            "POST", "mass_stats/download_json", 
-                            params={"job_name": job_info['name']}
-                        )
-                        json_url = json_response["download_url"]
-                        
-                        async with session.get(json_url) as response:
+                        self.client.logger.info(f"Downloading dataset {i+1}/{len(download_urls)}...")
+                        async with session.get(url) as response:
                             if response.status == 200:
-                                json_data = await response.json()
-                                self.client.logger.info("Successfully downloaded geometry data")
-                                
-                                geometries = []
-                                max_geometries = min(n, len(json_data), len(datasets))
-                                
-                                for i in range(max_geometries):
-                                    try:
-                                        geom_dict = json_data[i]["request"]["feature"]["geometry"]
-                                        shapely_geom = shape(geom_dict)
-                                        geometries.append(shapely_geom)
-                                    except (KeyError, ValueError) as e:
-                                        self.client.logger.warning(f"Error parsing geometry {i}: {e}")
-                                        continue
-                                
-                                min_length = min(len(datasets), len(geometries))
-                                if min_length == 0:
-                                    self.client.logger.warning("No matching datasets and geometries found")
-                                    return gpd.GeoDataFrame({'geometry': [], 'dataset': []})
-                                
-                                gdf = gpd.GeoDataFrame({
-                                    'geometry': geometries[:min_length],
-                                    'dataset': datasets[:min_length]
-                                })
-                                
-                                self.client.logger.info(f"Created GeoDataFrame with {len(gdf)} rows")
-                                try:
-                                    expanded_gdf = expand_on_variables_and_time(gdf)
-                                    return expanded_gdf
-                                except NameError:
-                                    self.client.logger.warning("expand_on_variables_and_time function not found, returning raw GeoDataFrame")
-                                    return gdf
-                                
+                                content = await response.read()
+                                dataset = xr.open_dataset(BytesIO(content))
+                                datasets.append(dataset)
+                                self.client.logger.info(f"Successfully processed dataset {i+1}")
                             else:
-                                self.client.logger.warning(f"Failed to download geometry data: HTTP {response.status}")
-                                return gpd.GeoDataFrame({'geometry': [], 'dataset': []})
-                                    
+                                self.client.logger.warning(f"Failed to download dataset {i+1}: HTTP {response.status}")
                     except Exception as e:
-                            self.client.logger.error(f"Error downloading geometry data: {e}")
+                        self.client.logger.error(f"Error downloading dataset {i+1}: {e}")
+                        continue
+                if not datasets:
+                    self.client.logger.warning("No datasets were successfully downloaded")
+                    return gpd.GeoDataFrame({'geometry': [], 'dataset': []})
+                try:
+                    json_response = await self.client._terrakio_request(
+                        "POST", "mass_stats/download_json", 
+                        params={"job_name": job_info['name']}
+                    )
+                    json_url = json_response["download_url"]
+                    
+                    async with session.get(json_url) as response:
+                        if response.status == 200:
+                            json_data = await response.json()
+                            self.client.logger.info("Successfully downloaded geometry data")
+                            
+                            geometries = []
+                            max_geometries = min(n, len(json_data), len(datasets))
+                            
+                            for i in range(max_geometries):
+                                try:
+                                    geom_dict = json_data[i]["request"]["feature"]["geometry"]
+                                    shapely_geom = shape(geom_dict)
+                                    geometries.append(shapely_geom)
+                                except (KeyError, ValueError) as e:
+                                    self.client.logger.warning(f"Error parsing geometry {i}: {e}")
+                                    continue
+                            
+                            min_length = min(len(datasets), len(geometries))
+                            if min_length == 0:
+                                self.client.logger.warning("No matching datasets and geometries found")
+                                return gpd.GeoDataFrame({'geometry': [], 'dataset': []})
+                            
+                            gdf = gpd.GeoDataFrame({
+                                'geometry': geometries[:min_length],
+                                'dataset': datasets[:min_length]
+                            })
+                            
+                            self.client.logger.info(f"Created GeoDataFrame with {len(gdf)} rows")
+                            try:
+                                expanded_gdf = expand_on_variables_and_time(gdf)
+                                return expanded_gdf
+                            except NameError:
+                                self.client.logger.warning("expand_on_variables_and_time function not found, returning raw GeoDataFrame")
+                                return gdf
+                                
+                        else:
+                            self.client.logger.warning(f"Failed to download geometry data: HTTP {response.status}")
                             return gpd.GeoDataFrame({'geometry': [], 'dataset': []})
+                                    
+                except Exception as e:
+                        self.client.logger.error(f"Error downloading geometry data: {e}")
+                        return gpd.GeoDataFrame({'geometry': [], 'dataset': []})
+        
         elif status in ["Failed", "Cancelled", "Error"]:
-            return "The zonal stats job(for preparing the data) has failed, please check the job status!"
+            raise RuntimeError(f"The zonal stats job (job_id: {self.job_id}) has failed, cancelled, or errored. Please check the job status!")
+        
         else:
-            return "The zonal stats job(for preparing the data) is still runningm, please come back at a later time!"
-
+            raise RuntimeError(f"The zonal stats job (job_id: {self.job_id}) is still running. Please come back at a later time!")
 
 def expand_on_time(gdf):
     """

{terrakio_core-0.4.93 → terrakio_core-0.4.95}/terrakio_core/endpoints/mass_stats.py

@@ -3,6 +3,7 @@ import json
 import gzip        
 import os
 import weakref
+import weakref
 from pathlib import Path
 from urllib.parse import urlparse
 from ..helper.decorators import require_token, require_api_key, require_auth
@@ -13,7 +14,6 @@ import xarray as xr
 from io import BytesIO
 import geopandas as gpd
 from shapely.geometry import shape
-from ..convenience_functions.convenience_functions import expand_on_variables_and_time
 
 class MassStats:
     def __init__(self, client):
@@ -145,6 +145,7 @@ class MassStats:
         params = {"limit": limit}
         return self._client._terrakio_request("GET", "mass_stats/history", params=params)
     
+
     @require_api_key     
     async def start_post_processing(
         self,
@@ -174,7 +175,6 @@ class MassStats:
     @require_api_key     
     async def zonal_stats_transform(
         self,
-        process_name: str,
         data_name: str,
         output: str,
         consumer: bytes,
@@ -182,7 +182,6 @@ class MassStats:
     ) -> Dict[str, Any]:
                 
         data = aiohttp.FormData()
-        data.add_field('process_name', process_name)
         data.add_field('data_name', data_name) 
         data.add_field('output', output)
         data.add_field('overwrite', str(overwrite).lower())
@@ -393,11 +392,22 @@ class MassStats:
         except Exception as e:
             raise Exception(f"Error in download process: {e}")
 
-    def validate_request(self, request_json_path: str):
-        with open(request_json_path, 'r') as file:
-            request_data = json.load(file)
+    def validate_request(self, request_json: Union[str, List[Dict]]):
+        # Handle both file path and direct JSON data
+        if isinstance(request_json, str):
+            # It's a file path
+            with open(request_json, 'r') as file:
+                request_data = json.load(file)
+        elif isinstance(request_json, list):
+            # It's already JSON data
+            request_data = request_json
+        else:
+            raise ValueError("request_json must be either a file path (str) or JSON data (list)")
+        
+        # Rest of validation logic stays exactly the same
         if not isinstance(request_data, list):
-            raise ValueError(f"Request JSON file {request_json_path} should contain a list of dictionaries")
+            raise ValueError("Request JSON should contain a list of dictionaries")
+        
         for i, request in enumerate(request_data):
             if not isinstance(request, dict):
                 raise ValueError(f"Request {i} should be a dictionary")
@@ -421,7 +431,7 @@ class MassStats:
         name: str, 
         output: str, 
         config: Dict[str, Any],
-        request_json: str,  # Path to request JSON file
+        request_json: Union[str, List[Dict]],  # ← Accept both file path OR data
         region: str = None, 
         overwrite: bool = False, 
         skip_existing: bool = False,  
@@ -469,19 +479,38 @@ class MassStats:
                     
             return groups
         
-        # Load and validate request JSON
+        # # Load and validate request JSON
+        # try:
+        #     with open(request_json, 'r') as file:
+        #         request_data = json.load(file)
+        #         if isinstance(request_data, list):
+        #             size = len(request_data)
+        #         else:
+        #             raise ValueError(f"Request JSON file {request_json} should contain a list of dictionaries")
+        # except FileNotFoundError as e:
+        #     return e
+        # except json.JSONDecodeError as e:
+        #     return e
         try:
-            with open(request_json, 'r') as file:
-                request_data = json.load(file)
-                if isinstance(request_data, list):
-                    size = len(request_data)
-                else:
-                    raise ValueError(f"Request JSON file {request_json} should contain a list of dictionaries")
+            if isinstance(request_json, str):
+                # It's a file path
+                with open(request_json, 'r') as file:
+                    request_data = json.load(file)
+            elif isinstance(request_json, list):
+                # It's already JSON data
+                request_data = request_json
+            else:
+                raise ValueError("request_json must be either a file path (str) or JSON data (list)")
+                
+            if isinstance(request_data, list):
+                size = len(request_data)
+            else:
+                raise ValueError("Request JSON should contain a list of dictionaries")
         except FileNotFoundError as e:
             return e
         except json.JSONDecodeError as e:
             return e
-        
+
         # Generate manifest from request data (kept in memory)
         try:
             manifest_groups = extract_manifest_from_request(request_data)
@@ -516,8 +545,16 @@ class MassStats:
         # Upload request JSON file
         try:
             self.validate_request(request_json)
-            requests_response = await self._upload_file(request_json, requests_url, use_gzip=True)
+            
+            if isinstance(request_json, str):
+                # File path - use existing _upload_file method
+                requests_response = await self._upload_file(request_json, requests_url, use_gzip=True)
+            else:
+                # JSON data - use _upload_json_data method
+                requests_response = await self._upload_json_data(request_json, requests_url, use_gzip=True)
+                
             if requests_response.status not in [200, 201, 204]:
+                # ... rest stays the same
                 self._client.logger.error(f"Requests upload error: {requests_response.text()}")
                 raise Exception(f"Failed to upload request JSON: {requests_response.text()}")
         except Exception as e: