terrakio-core 0.4.4__py3-none-any.whl → 0.4.6__py3-none-any.whl

terrakio_core/__init__.py

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

terrakio_core/async_client.py

@@ -17,7 +17,7 @@ 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
+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
 
 class AsyncClient(BaseClient):
     def __init__(self, url: Optional[str] = None, api_key: Optional[str] = None, verbose: bool = False, session: Optional[aiohttp.ClientSession] = None):
@@ -196,6 +196,8 @@ class AsyncClient(BaseClient):
             out_crs: str = "epsg:4326",
             resolution: int = -1,
             geom_fix: bool = False,
+            mass_stats: bool = False,
+            id_column: Optional[str] = None,
     ):
         """
         Compute zonal statistics for all geometries in a GeoDataFrame.
@@ -208,6 +210,8 @@ class AsyncClient(BaseClient):
             out_crs (str): Output coordinate reference system
             resolution (int): Resolution parameter
             geom_fix (bool): Whether to fix the geometry (default False)
+            mass_stats (bool): Whether to use mass stats for processing (default False)
+            id_column (Optional[str]): Name of the ID column to use (default None)
 
         Returns:
             geopandas.GeoDataFrame: GeoDataFrame with added columns for results
@@ -225,6 +229,8 @@ class AsyncClient(BaseClient):
             out_crs=out_crs,
             resolution=resolution,
             geom_fix=geom_fix,
+            mass_stats=mass_stats,
+            id_column=id_column,
         )
 
     async def create_dataset_file(
@@ -282,6 +288,49 @@ class AsyncClient(BaseClient):
             download_path=download_path,
         )
 
+    async def geo_queries(
+        self,
+        queries: list[dict],
+        conc: int = 20,
+    ):
+        """
+        Execute multiple geo queries concurrently.
+
+        Args:
+            queries (list[dict]): List of dictionaries containing query parameters.
+                                  Each query must have 'expr', 'feature', and 'in_crs' keys.
+            conc (int): Number of concurrent requests to make (default 20, max 100)
+
+        Returns:
+            Union[float, geopandas.GeoDataFrame]: 
+                - float: Average of all results if results are integers
+                - GeoDataFrame: GeoDataFrame with geometry and dataset columns if results are xarray datasets
+
+        Raises:
+            ValueError: If queries list is empty, concurrency is too high, or queries are malformed
+            APIError: If the API request fails
+
+        Example:
+            queries = [
+                {
+                    'expr': 'WCF.wcf',
+                    'feature': {'type': 'Feature', 'geometry': {...}, 'properties': {}},
+                    'in_crs': 'epsg:4326'
+                },
+                {
+                    'expr': 'NDVI.ndvi',
+                    'feature': {'type': 'Feature', 'geometry': {...}, 'properties': {}},
+                    'in_crs': 'epsg:4326'
+                }
+            ]
+            result = await client.geo_queries(queries)
+        """
+        return await _request_geoquery_list(
+            client=self,
+            quries=queries,  # Note: keeping original parameter name for compatibility
+            conc=conc,
+        )
+
     async def __aenter__(self):
         if self._session is None:
             headers = {

terrakio_core/convenience_functions/convenience_functions.py

@@ -24,6 +24,8 @@ import pyproj
 import pandas as pd
 import geopandas as gpd
 
+from typing import Optional
+
 def expand_on_time(gdf):
     """
     Expand datasets on time dimension - each time becomes a new row.
@@ -359,18 +361,153 @@ async def local_or_remote(
             "local_or_remote": "local",
             "reason": "The number of the requests is not too large, and the time taking for making these requests is not too long, and the size of the dataset is not too large",
         }
+    
+def gdf_to_json(
+    gdf: GeoDataFrame,
+    expr: str,
+    in_crs: str = "epsg:4326",
+    out_crs: str = "epsg:4326",
+    resolution: int = -1,
+    geom_fix: bool = False,
+    id_column: Optional[str] = None,
+):
+    """
+    Convert a GeoDataFrame to a list of JSON requests for mass_stats processing.
+    
+    Args:
+        gdf: GeoDataFrame containing geometries and optional metadata
+        expr: Expression to evaluate
+        in_crs: Input coordinate reference system
+        out_crs: Output coordinate reference system
+        resolution: Resolution parameter
+        geom_fix: Whether to fix geometry issues
+        id_column: Optional column name to use for group and file names
+        
+    Returns:
+        list: List of dictionaries formatted for mass_stats requests
+    """
+    mass_stats_requests = []
+    
+    # Loop through each row in the GeoDataFrame
+    for idx, row in gdf.iterrows():
+        # Create the request feature
+        request_feature = {
+            "expr": expr,
+            "feature": {
+                "type": "Feature",
+                "geometry": mapping(gdf.geometry.iloc[idx]),
+                "properties": {}
+            },
+            "in_crs": in_crs,
+            "out_crs": out_crs,
+            "resolution": resolution,
+            "geom_fix": geom_fix,
+        }
+        
+        # Determine group name and file name based on id_column
+        if id_column is not None and id_column in gdf.columns:
+            # Use the value from the specified column as group and file name
+            identifier = str(row[id_column])
+            group_name = f"group_{identifier}"
+            file_name = f"file_{identifier}"
+        else:
+            # Use the index as group and file name
+            group_name = f"group_{idx}"
+            file_name = f"file_{idx}"
+            
+        # Create the complete request entry
+        request_entry = {
+            "group": group_name,
+            "file": file_name,
+            "request": request_feature,
+        }
+        
+        # Add the request to our list
+        mass_stats_requests.append(request_entry)
+        
+    return mass_stats_requests
+    
+async def handle_mass_stats(
+    client,
+    gdf: GeoDataFrame,
+    expr: str,
+    in_crs: str = "epsg:4326",
+    out_crs: str = "epsg:4326",
+    resolution: int = -1,
+    geom_fix: bool = False,
+    id_column: Optional[str] = None,
+
+):
+    # we have the handle mass stats function, we need to have the list of quries, and we need to pass the quries to the mass stats function
+    # we have the three different variables
+    
+    # Check if id_column is provided
+    # if id_column is None:
+        # Handle case where no ID column is specified
+        # this means that the id column is none, so we could just use the default value of 1 2 3 4
+    request_json = gdf_to_json(gdf = gdf, expr = expr, in_crs = in_crs, out_crs = out_crs, resolution = resolution, geom_fix = geom_fix, id_column = id_column)
+    # we need to call the execute job function
+    job_id =await client.mass_stats.execute_job(
+        name = "zonal_stats_job",
+        output = "netcdf",
+        config = {},
+        request_json = request_json,
+        overwrite = True,
+    )
+    return job_id
+# async def test_regular_async_mass_stats(regular_async_client):
+#     """Test mass statistics with regular client async"""
+#     start_result = await regular_async_client.mass_stats.execute_job(
+#         name="test_regular_mass_stats_test",
+#         region="aus",
+#         output="csv",
+#         config={},
+#         request_json = "./test_config.json",
+#         manifest_json = "./test_manifest.json",
+#         overwrite=True,
+#     )
+#     assert isinstance(start_result, dict)
+#     assert 'task_id' in start_result
+        
+        # return 
+    # else:
+    #     # Handle case where ID column is specified
+    #     # Verify the column exists in the GeoDataFrame
+        
+    #     if id_column not in gdf.columns:
+    #         raise ValueError(f"ID column '{id_column}' not found in GeoDataFrame columns: {list(gdf.columns)}")
+    # pass
+    # the second case is that we have an id_column, we need to use the id_column to create the group name
 
+# we have the mass stats as one of the parameters, so that when a user wants a mass 
+# for both cases we need to have the list of quries
 async def zonal_stats(
-        client,
-        gdf: GeoDataFrame,
-        expr: str,
-        conc: int = 20,
-        in_crs: str = "epsg:4326",
-        out_crs: str = "epsg:4326",
-        resolution: int = -1,
-        geom_fix: bool = False,
+    client,
+    gdf: GeoDataFrame,
+    expr: str,
+    conc: int = 20,
+    in_crs: str = "epsg:4326",
+    out_crs: str = "epsg:4326",
+    resolution: int = -1,
+    geom_fix: bool = False,
+    mass_stats: bool = False,
+    id_column: Optional[str] = None,
 ):
     """Compute zonal statistics for all geometries in a GeoDataFrame."""
+
+    if mass_stats:
+        mass_stats_id = await handle_mass_stats(
+            client = client,
+            gdf = gdf,
+            expr = expr,
+            in_crs = in_crs,
+            out_crs = out_crs,
+            resolution = resolution,
+            geom_fix = geom_fix,
+            id_column = id_column
+        )
+        # if we started the mass stats job, we need to return the job id 
+        return mass_stats_id
     quries = []
     for i in range(len(gdf)):
         quries.append({
@@ -385,6 +522,7 @@ async def zonal_stats(
             "resolution": resolution,
             "geom_fix": geom_fix,
         })
+
     local_or_remote_result = await local_or_remote(client= client, quries = quries)
     if local_or_remote_result["local_or_remote"] == "remote":
         raise ValueError(local_or_remote_result["reason"])

terrakio_core/endpoints/mass_stats.py

@@ -328,7 +328,7 @@ class MassStats:
                     resp.raise_for_status()
                     import aiofiles
                     async with aiofiles.open(file_save_path, 'wb') as file:
-                        async for chunk in resp.content.iter_chunked(1048576):  # 1 MB
+                        async for chunk in resp.content.iter_chunked(1048576):
                             if chunk:
                                 await file.write(chunk)
 
@@ -363,7 +363,7 @@ class MassStats:
                     if total_files is not None and downloaded_files >= total_files:
                         break
                     if len(download_urls) < page_size:
-                        break  # Last page
+                        break
                     page += 1
             return output_files
         except Exception as e:
@@ -389,7 +389,6 @@ class MassStats:
                 raise ValueError("Request must be a dictionary")
             if not isinstance(request["file"], (str, int, list)):
                 raise ValueError("'file' must be a string or a list of strings")
-            # Only check the first 3 requests
             if i == 3:
                 break
 
@@ -397,10 +396,9 @@ class MassStats:
     async def execute_job(
         self, 
         name: str, 
-        # region: str, 
         output: str, 
         config: Dict[str, Any],
-        request_json: str,  # Path to request JSON file
+        request_json: Union[str, list[Dict[str, Any]]],
         overwrite: bool = False, 
         skip_existing: bool = False,  
         location: str = None, 
@@ -427,7 +425,6 @@ class MassStats:
         Raises:
             APIError: If the API request fails
         """
-        
         def extract_manifest_from_request(request_data: List[Dict[str, Any]]) -> List[str]:
             """Extract unique group names from request data to create manifest list."""
             groups = []
@@ -447,34 +444,35 @@ class MassStats:
                     
             return groups
         
-        # 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
+        if isinstance(request_json, str):
+            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
+            request_json_path = request_json
+        else:
+            request_data = request_json
+            size = len(request_data)
+            request_json_path = None
         
-        # Generate manifest from request data (kept in memory)
         try:
             manifest_groups = extract_manifest_from_request(request_data)
         except Exception as e:
             raise ValueError(f"Error extracting manifest from request JSON: {e}")
         
-        # Extract the first expression
-        first_request = request_data[0]  # Changed from data[0] to request_data[0]
+        first_request = request_data[0]
         first_expression = first_request["request"]["expr"]
         
-        # Get upload URLs
         upload_result = await self._upload_request(
             name=name, 
             size=size, 
-            # region=region, 
             sample = first_expression,
             output=output, 
             config=config, 
@@ -490,21 +488,21 @@ class MassStats:
         
         if not requests_url:
             raise ValueError("No requests_url returned from server for request JSON upload")
-        
-        # Upload request JSON file
         try:
-            self.validate_request(request_json)
-            requests_response = await self._upload_file(request_json, requests_url, use_gzip=True)
+            if request_json_path:
+                self.validate_request(request_json_path)
+                requests_response = await self._upload_file(request_json_path, requests_url, use_gzip=True)
+            else:
+                requests_response = await self._upload_json_data(request_data, requests_url, use_gzip=True)
             if requests_response.status not in [200, 201, 204]:
                 self._client.logger.error(f"Requests upload error: {requests_response.text()}")
-                raise Exception(f"Failed to upload request JSON: {requests_response.text()}")
+                raise Exception(f"Failed to upload request data: {requests_response.text()}")
         except Exception as e:
             raise Exception(f"Error uploading request JSON file {request_json}: {e}")
-        
+
         if not manifest_url:
             raise ValueError("No manifest_url returned from server for manifest JSON upload")
         
-        # Upload manifest JSON data directly (no temporary file needed)
         try:
             manifest_response = await self._upload_json_data(manifest_groups, manifest_url, use_gzip=False)
             if manifest_response.status not in [200, 201, 204]:
@@ -513,7 +511,6 @@ class MassStats:
         except Exception as e:
             raise Exception(f"Error uploading manifest JSON: {e}")
         
-        # Start the job
         start_job_task_id = await self.start_job(upload_result.get("id"))
         return start_job_task_id
 
@@ -557,7 +554,6 @@ class MassStats:
         tile_size: int,
         res: float,
         output: str,
-        # region: str,
         year_range: list[int] = None,
         overwrite: bool = False,
         server: str = None,
@@ -600,7 +596,6 @@ class MassStats:
         payload_mapping = {
             "year_range": year_range,
             "server": server,
-            # "region": region,
             "bucket": bucket,
         }
         for key, value in payload_mapping.items():

terrakio_core/sync_client.py

@@ -339,37 +339,41 @@
 
 
 import asyncio
+import concurrent.futures
+import threading
 import functools
-from typing import Optional, Dict, Any, Union
+import inspect
+from typing import Optional, Dict, Any, Union, TYPE_CHECKING
 from geopandas import GeoDataFrame
 from shapely.geometry.base import BaseGeometry as ShapelyGeometry
 from .async_client import AsyncClient
 
+# Add type checking imports for better IDE support
+if TYPE_CHECKING:
+    from .endpoints.dataset_management import DatasetManagement
+    from .endpoints.user_management import UserManagement
+    from .endpoints.mass_stats import MassStats
+    from .endpoints.group_management import GroupManagement
+    from .endpoints.space_management import SpaceManagement
+    from .endpoints.model_management import ModelManagement
+    from .endpoints.auth import AuthClient
+
 
 class SyncWrapper:
-    """
-    Generic synchronous wrapper with __dir__ support for runtime autocomplete.
-    """
+    """Generic synchronous wrapper with __dir__ support for runtime autocomplete."""
     
     def __init__(self, async_obj, sync_client):
         self._async_obj = async_obj
         self._sync_client = sync_client
     
     def __dir__(self):
-        """
-        Return list of attributes for autocomplete in interactive environments.
-        This enables autocomplete in Jupyter/iPython after instantiation.
-        """
+        """Return list of attributes for autocomplete in interactive environments."""
         async_attrs = [attr for attr in dir(self._async_obj) if not attr.startswith('_')]
-        
         wrapper_attrs = [attr for attr in object.__dir__(self) if not attr.startswith('_')]
-        
         return list(set(async_attrs + wrapper_attrs))
     
     def __getattr__(self, name):
-        """
-        Dynamically wrap any method call to convert async to sync.
-        """
+        """Dynamically wrap any method call to convert async to sync."""
         attr = getattr(self._async_obj, name)
         
         if callable(attr):
@@ -386,15 +390,32 @@ class SyncWrapper:
 
 class SyncClient:
     """
-    Synchronous wrapper with __dir__ support for runtime autocomplete.
-    Works best in interactive environments like Jupyter/iPython.
+    Thread-safe synchronous wrapper for AsyncClient.
+    Uses a persistent event loop in a dedicated thread to avoid event loop conflicts.
     """
+
+    # Add explicit type annotations for endpoint managers
+    datasets: 'DatasetManagement'
+    users: 'UserManagement' 
+    mass_stats: 'MassStats'
+    groups: 'GroupManagement'
+    space: 'SpaceManagement'
+    model: 'ModelManagement'
+    auth: 'AuthClient'
     
     def __init__(self, url: Optional[str] = None, api_key: Optional[str] = None, verbose: bool = False):
         self._async_client = AsyncClient(url=url, api_key=api_key, verbose=verbose)
         self._context_entered = False
         self._closed = False
         
+        # Thread and event loop management
+        self._loop = None
+        self._thread = None
+        self._loop_ready = None
+        self._loop_exception = None
+        
+        # Initialize endpoint managers with proper typing
+
         self.datasets = SyncWrapper(self._async_client.datasets, self)
         self.users = SyncWrapper(self._async_client.users, self)
         self.mass_stats = SyncWrapper(self._async_client.mass_stats, self)
@@ -406,21 +427,150 @@ class SyncClient:
         import atexit
         atexit.register(self._cleanup)
     
-    def __dir__(self):
+    def _ensure_event_loop(self) -> None:
+        """Ensure we have a persistent event loop in a dedicated thread."""
+        if self._loop is None or self._loop.is_closed():
+            self._loop_ready = threading.Event()
+            self._loop_exception = None
+            
+            def run_loop():
+                """Run the event loop in a dedicated thread."""
+                try:
+                    # Create a new event loop for this thread
+                    self._loop = asyncio.new_event_loop()
+                    asyncio.set_event_loop(self._loop)
+                    
+                    # Signal that the loop is ready
+                    self._loop_ready.set()
+                    
+                    # Run the loop forever (until stopped)
+                    self._loop.run_forever()
+                except Exception as e:
+                    self._loop_exception = e
+                    self._loop_ready.set()
+                finally:
+                    # Clean up when the loop stops
+                    if self._loop and not self._loop.is_closed():
+                        self._loop.close()
+            
+            # Start the thread
+            self._thread = threading.Thread(target=run_loop, daemon=True)
+            self._thread.start()
+            
+            # Wait for the loop to be ready
+            self._loop_ready.wait(timeout=10)
+            
+            if self._loop_exception:
+                raise self._loop_exception
+            
+            if not self._loop_ready.is_set():
+                raise RuntimeError("Event loop failed to start within timeout")
+    
+    def _run_async(self, coro):
         """
-        Return list of attributes for autocomplete in interactive environments.
-        This includes all methods from the async client plus the endpoint managers.
+        Run async coroutine using persistent event loop.
+        This is the core method that makes everything work.
         """
-        default_attrs = [attr for attr in object.__dir__(self) if not attr.startswith('_')]
+        # Ensure we have an event loop
+        self._ensure_event_loop()
         
-        async_client_attrs = [attr for attr in dir(self._async_client) if not attr.startswith('_')]
+        if self._loop.is_closed():
+            raise RuntimeError("Event loop is closed")
         
-        endpoint_attrs = ['datasets', 'users', 'mass_stats', 'groups', 'space', 'model', 'auth']
+        # Create a future to get the result back from the event loop thread
+        future = concurrent.futures.Future()
         
-        all_attrs = default_attrs + async_client_attrs + endpoint_attrs
+        async def run_with_context():
+            """Run the coroutine with proper context management."""
+            try:
+                # Ensure the async client is properly initialized
+                await self._ensure_context()
+                
+                # Run the actual coroutine
+                result = await coro
+                
+                # Set the result on the future
+                future.set_result(result)
+            except Exception as e:
+                # Set the exception on the future
+                future.set_exception(e)
+        
+        # Schedule the coroutine on the persistent event loop
+        self._loop.call_soon_threadsafe(
+            lambda: asyncio.create_task(run_with_context())
+        )
+
         
+        # Wait for the result (with timeout to avoid hanging)
+        try:
+            return future.result(timeout=300)  # 5 minute timeout
+        except concurrent.futures.TimeoutError:
+            raise RuntimeError("Async operation timed out after 5 minutes")
+    
+    async def _ensure_context(self) -> None:
+        """Ensure the async client context is entered."""
+        if not self._context_entered and not self._closed:
+            await self._async_client.__aenter__()
+            self._context_entered = True
+    
+    async def _exit_context(self) -> None:
+        """Exit the async client context."""
+        if self._context_entered and not self._closed:
+            await self._async_client.__aexit__(None, None, None)
+            self._context_entered = False
+    
+    def close(self) -> None:
+        """Close the underlying async client session and stop the event loop."""
+        if not self._closed:
+            if self._loop and not self._loop.is_closed():
+                # Schedule cleanup on the event loop
+                future = concurrent.futures.Future()
+                
+                async def cleanup():
+                    """Clean up the async client."""
+                    try:
+                        await self._exit_context()
+                        future.set_result(None)
+                    except Exception as e:
+                        future.set_exception(e)
+                
+                # Run cleanup
+                self._loop.call_soon_threadsafe(
+                    lambda: asyncio.create_task(cleanup())
+                )
+                
+                # Wait for cleanup to complete
+                try:
+                    future.result(timeout=10)
+                except:
+                    pass  # Ignore cleanup errors
+                
+                # Stop the event loop
+                self._loop.call_soon_threadsafe(self._loop.stop)
+                
+                # Wait for thread to finish
+                if self._thread and self._thread.is_alive():
+                    self._thread.join(timeout=5)
+            
+            self._closed = True
+    
+    def _cleanup(self) -> None:
+        """Internal cleanup method called by atexit."""
+        if not self._closed:
+            try:
+                self.close()
+            except Exception:
+                pass  # Ignore cleanup errors
+    
+    def __dir__(self):
+        """Return list of attributes for autocomplete in interactive environments."""
+        default_attrs = [attr for attr in object.__dir__(self) if not attr.startswith('_')]
+        async_client_attrs = [attr for attr in dir(self._async_client) if not attr.startswith('_')]
+        endpoint_attrs = ['datasets', 'users', 'mass_stats', 'groups', 'space', 'model', 'auth']
+        all_attrs = default_attrs + async_client_attrs + endpoint_attrs
         return list(set(all_attrs))
     
+    # Your existing methods with proper type annotations
     def geoquery(
         self,
         expr: str,
@@ -445,15 +595,18 @@ class SyncClient:
         return self._run_async(coro)
 
     def zonal_stats(
-            self,
-            gdf: GeoDataFrame,
-            expr: str,
-            conc: int = 20,
-            in_crs: str = "epsg:4326",
-            out_crs: str = "epsg:4326",
-            resolution: int = -1,
-            geom_fix: bool = False,
-    ):
+        self,
+        gdf: GeoDataFrame,
+        expr: str,
+        conc: int = 20,
+        in_crs: str = "epsg:4326",
+        out_crs: str = "epsg:4326",
+        resolution: int = -1,
+        geom_fix: bool = False,
+        mass_stats: bool = False,
+        id_column: Optional[str] = None,
+    ) -> GeoDataFrame:
+
         """
         Compute zonal statistics for all geometries in a GeoDataFrame (synchronous version).
         
@@ -465,6 +618,8 @@ class SyncClient:
             out_crs (str): Output coordinate reference system
             resolution (int): Resolution parameter
             geom_fix (bool): Whether to fix the geometry (default False)
+            mass_stats (bool): Whether to use mass stats for processing (default False)
+            id_column (Optional[str]): Name of the ID column to use (default None)
 
         Returns:
             geopandas.GeoDataFrame: GeoDataFrame with added columns for results
@@ -481,6 +636,8 @@ class SyncClient:
             out_crs=out_crs,
             resolution=resolution,
             geom_fix=geom_fix,
+            mass_stats=mass_stats,
+            id_column=id_column,
         )
         return self._run_async(coro)
     
@@ -516,79 +673,59 @@ class SyncClient:
         )
         return self._run_async(coro)
 
-    async def _ensure_context(self):
-        """Ensure the async client context is entered."""
-        if not self._context_entered and not self._closed:
-            await self._async_client.__aenter__()
-            self._context_entered = True
-    
-    async def _exit_context(self):
-        """Exit the async client context."""
-        if self._context_entered and not self._closed:
-            await self._async_client.__aexit__(None, None, None)
-            self._context_entered = False
-    
-    def _run_async(self, coro):
-        """Run an async coroutine and return the result synchronously."""
-        async def run_with_context():
-            await self._ensure_context()
-            return await coro
-        
-        try:
-            loop = asyncio.get_running_loop()
-            import concurrent.futures
-            with concurrent.futures.ThreadPoolExecutor() as executor:
-                future = executor.submit(asyncio.run, run_with_context())
-                return future.result()
-        except RuntimeError:
-            return asyncio.run(run_with_context())
-    
-    def close(self):
-        """Close the underlying async client session."""
-        if not self._closed:
-            async def close_async():
-                await self._exit_context()
-            
-            try:
-                loop = asyncio.get_running_loop()
-                import concurrent.futures
-                with concurrent.futures.ThreadPoolExecutor() as executor:
-                    future = executor.submit(asyncio.run, close_async())
-                    future.result()
-            except RuntimeError:
-                asyncio.run(close_async())
-            
-            self._closed = True
-    
-    def _cleanup(self):
-        """Internal cleanup method called by atexit."""
-        if not self._closed:
-            try:
-                self.close()
-            except Exception:
-                pass
+    def geo_queries(
+        self,
+        queries: list[dict],
+        conc: int = 20,
+    ) -> Union[float, GeoDataFrame]:
+        """
+        Execute multiple geo queries concurrently (synchronous version).
+
+        Args:
+            queries (list[dict]): List of dictionaries containing query parameters.
+                                  Each query must have 'expr', 'feature', and 'in_crs' keys.
+            conc (int): Number of concurrent requests to make (default 20, max 100)
+
+        Returns:
+            Union[float, geopandas.GeoDataFrame]: 
+                - float: Average of all results if results are integers
+                - GeoDataFrame: GeoDataFrame with geometry and dataset columns if results are xarray datasets
+
+        Raises:
+            ValueError: If queries list is empty, concurrency is too high, or queries are malformed
+            APIError: If the API request fails
+
+        Example:
+            queries = [
+                {
+                    'expr': 'WCF.wcf',
+                    'feature': {'type': 'Feature', 'geometry': {...}, 'properties': {}},
+                    'in_crs': 'epsg:4326'
+                },
+                {
+                    'expr': 'NDVI.ndvi',
+                    'feature': {'type': 'Feature', 'geometry': {...}, 'properties': {}},
+                    'in_crs': 'epsg:4326'
+                }
+            ]
+            result = client.geo_queries(queries)
+        """
+        coro = self._async_client.geo_queries(
+            queries=queries,
+            conc=conc,
+        )
+        return self._run_async(coro)
     
-    def __enter__(self):
+    # Context manager support
+    def __enter__(self) -> 'SyncClient':
         """Context manager entry."""
-        async def enter_async():
-            await self._ensure_context()
-        
-        try:
-            loop = asyncio.get_running_loop()
-            import concurrent.futures
-            with concurrent.futures.ThreadPoolExecutor() as executor:
-                future = executor.submit(asyncio.run, enter_async())
-                future.result()
-        except RuntimeError:
-            asyncio.run(enter_async())
-        
         return self
     
-    def __exit__(self, exc_type, exc_val, exc_tb):
+    def __exit__(self, exc_type, exc_val, exc_tb) -> None:
         """Context manager exit."""
         self.close()
     
-    def __del__(self):
+    def __del__(self) -> None:
         """Destructor to ensure session is closed."""
         if not self._closed:
             try:

{terrakio_core-0.4.4.dist-info → terrakio_core-0.4.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: terrakio-core
-Version: 0.4.4
+Version: 0.4.6
 Summary: Core components for Terrakio API clients
 Author-email: Yupeng Chao <yupeng@haizea.com.au>
 Project-URL: Homepage, https://github.com/HaizeaAnalytics/terrakio-python-api
@@ -25,6 +25,9 @@ Requires-Dist: google-cloud-storage>=2.0.0
 Requires-Dist: scipy>=1.7.0
 Requires-Dist: nest_asyncio
 Requires-Dist: onnxruntime>=1.10.0
+Requires-Dist: psutil>=5.0.0
+Requires-Dist: h5netcdf>=1.0.0
+Requires-Dist: netcdf4>=1.5.0
 Provides-Extra: ml
 Requires-Dist: torch>=2.7.1; extra == "ml"
 Requires-Dist: scikit-learn>=1.7.0; extra == "ml"

{terrakio_core-0.4.4.dist-info → terrakio_core-0.4.6.dist-info}/RECORD

@@ -1,22 +1,22 @@
-terrakio_core/__init__.py,sha256=tHjogyeQC-EKWpfPNnQqieQWGYRagVnj_LBiPP8vZrw,273
+terrakio_core/__init__.py,sha256=sDV0scHKE3D6FSA6XwNAjORdpmGd8bF-ft8Bb6RpjFI,273
 terrakio_core/accessors.py,sha256=qWLljU83YO7EUOefo_f6_P6ba6uiYMXwou0ihAHKBHQ,23706
-terrakio_core/async_client.py,sha256=FYUuN1IboFkygylo0jFjEmhBGoHhzhAwG_KznkQR2y4,12449
+terrakio_core/async_client.py,sha256=zX_RtgE-i8yWSdunrmcQXa-lO96VuW2cuwrF5eQ2CS4,14404
 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=HkLavfbT1sXGE1kTkiCDgNJxL9bErgOD6WihFrM-2xI,21873
-terrakio_core/convenience_functions/convenience_functions.py,sha256=B7qbObjP4OuAUtrVf4Gi58c0q2EkTwOCOE568P0Q-EE,18607
+terrakio_core/sync_client.py,sha256=DV4lhkdJgCRTQ1hWt0lVhZmRvF03fBY7_MvzT_6h3Q4,27506
+terrakio_core/convenience_functions/convenience_functions.py,sha256=bT4cYIUOQfXDeC6n2tTP-qj6P_Yk78EW5LFcOnoiZqg,23404
 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=6PSWWCpKLKMcFOoXfOAuROX8iSuG_dLyTYcw7gzhhZ4,23464
+terrakio_core/endpoints/mass_stats.py,sha256=o41cFR96xGVBiiOMBPgkBKVFITIHkNZpCgAvvh3AKqE,23356
 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=xNtp3oDD912PN_FQV5fb6uQYhwfHANuXyIcxoVCCfZU,2632
-terrakio_core-0.4.4.dist-info/METADATA,sha256=y2xrfAhs9JnlPKMyqj34QXXxS_AvY2tUyTrSM9SDFCY,1791
-terrakio_core-0.4.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-terrakio_core-0.4.4.dist-info/top_level.txt,sha256=5cBj6O7rNWyn97ND4YuvvXm0Crv4RxttT4JZvNdOG6Q,14
-terrakio_core-0.4.4.dist-info/RECORD,,
+terrakio_core-0.4.6.dist-info/METADATA,sha256=4vvBdO8MQmsc38ImtH490UwYTL0shC-vT7tjfhUQWyg,1881
+terrakio_core-0.4.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+terrakio_core-0.4.6.dist-info/top_level.txt,sha256=5cBj6O7rNWyn97ND4YuvvXm0Crv4RxttT4JZvNdOG6Q,14
+terrakio_core-0.4.6.dist-info/RECORD,,