terrakio-core 0.4.93__py3-none-any.whl → 0.4.95__py3-none-any.whl

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/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/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/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:

{terrakio_core-0.4.93.dist-info → terrakio_core-0.4.95.dist-info}/METADATA

@@ -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.dist-info → terrakio_core-0.4.95.dist-info}/RECORD

@@ -1,23 +1,23 @@
-terrakio_core/__init__.py,sha256=o4vKquQP9qQviGKLdJcg5h9blwUjrTAIrbhSJpz2bGQ,274
+terrakio_core/__init__.py,sha256=oQmSomwovopKB9FJwxuboCtt6Sd5BwiCuROUTTR92WI,274
 terrakio_core/accessors.py,sha256=pVZ7qqkkiZdUN5DwqDFwWNHRMfzT9pLnDehI8yiUNVw,43595
-terrakio_core/async_client.py,sha256=SZHAGGlhRUFN2JzFxpVLUmuSOt1eG44ZA_uz5ma2GLo,14782
+terrakio_core/async_client.py,sha256=txdSsX3IwqtHlcS86u6N6vjV0-PIiermxNOIjEMQ3Yg,14950
 terrakio_core/client.py,sha256=VXP7BtJWIfpPPZR7_yNdSTcGwNgTwhb7KorusqkQrzk,5603
 terrakio_core/config.py,sha256=r8NARVYOca4AuM88VP_j-8wQxOk1s7VcRdyEdseBlLE,4193
 terrakio_core/exceptions.py,sha256=4qnpOM1gOxsNIXDXY4qwY1d3I4Myhp7HBh7b2D0SVrU,529
 terrakio_core/sync_client.py,sha256=jbG2sMnbR3QPvhAxQX2dBWeX_6f-Qx_MFSRLLpvfRh4,14604
 terrakio_core/convenience_functions/create_dataset_file.py,sha256=RDTAQnKUigyczv3EKhKrs34VMDZDCgL4iz0bge1d9e4,4774
 terrakio_core/convenience_functions/geoquries.py,sha256=zIgt4fDCBgOIUM_h7-a6brOG-Mi2C_bQdnqcSliTVDs,3766
-terrakio_core/convenience_functions/zonal_stats.py,sha256=KuhgjbFQyKVK2cmpIUDZGkRD-kFa39uJAb5D1O-h6PY,19712
+terrakio_core/convenience_functions/zonal_stats.py,sha256=B0c95M5yqGE3uC2_Cad3FKXeaz97hVHdnaWSMdJdKsU,19496
 terrakio_core/endpoints/auth.py,sha256=FdLsPScPIBo-Gxl6ZnE-46cp2molggAJtL72LssN3fg,6049
 terrakio_core/endpoints/dataset_management.py,sha256=BUm8IIlW_Q45vDiQp16CiJGeSLheI8uWRVRQtMdhaNk,13161
 terrakio_core/endpoints/group_management.py,sha256=VFl3jakjQa9OPi351D3DZvLU9M7fHdfjCzGhmyJsx3U,6309
-terrakio_core/endpoints/mass_stats.py,sha256=tHlb1EnyrbHRscpmm0X__btdxA1cDwbQPvREJ5ebkdo,24224
+terrakio_core/endpoints/mass_stats.py,sha256=Vb6Tf8kKf5Hlch4ddsrQnfayfiK6z7NSjO8D0pop4p8,25699
 terrakio_core/endpoints/model_management.py,sha256=LH_gHPrqYA-_45KWpDBRcFbwHgm-Kg0zk1ealy7P_C0,52379
 terrakio_core/endpoints/space_management.py,sha256=YWb55nkJnFJGlALJ520DvurxDqVqwYtsvqQPWzxzhDs,2266
 terrakio_core/endpoints/user_management.py,sha256=WlFr3EfK8iI6DfkpMuYLHZUPk2n7_DHHO6z1hndmZB4,3816
 terrakio_core/helper/bounded_taskgroup.py,sha256=wiTH10jhKZgrsgrFUNG6gig8bFkUEPHkGRT2XY7Rgmo,677
 terrakio_core/helper/decorators.py,sha256=L6om7wmWNgCei3Wy5U0aZ-70OzsCwclkjIf7SfQuhCg,2289
 terrakio_core/helper/tiles.py,sha256=lcLCO6KiP05lCI9vngo3zCZJ6Z9C0pUxHSQS4H58EHc,2699
-terrakio_core-0.4.93.dist-info/METADATA,sha256=TqtR-8kJp4tCxIjg7Wbg5u922ADf9DzrrpdpyIBJBx0,1116
-terrakio_core-0.4.93.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-terrakio_core-0.4.93.dist-info/RECORD,,
+terrakio_core-0.4.95.dist-info/METADATA,sha256=gAjc5wDDg2a8vmkBVZWSK1QdtMTlaq9EGFY9qyQ16q4,1151
+terrakio_core-0.4.95.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+terrakio_core-0.4.95.dist-info/RECORD,,