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

terrakio_core/convenience_functions/convenience_functions.py

@@ -1,132 +1,282 @@
+
 import os
 import asyncio
 import tempfile
 import time
 import pandas as pd
+import geopandas as gpd
 from geopandas import GeoDataFrame
 from shapely.geometry import mapping
+from pathlib import Path
 from ..exceptions import APIError, ConfigurationError
 from ..helper.bounded_taskgroup import BoundedTaskGroup
 from ..helper.tiles import tiles
 import uuid
 import xarray as xr
+import random
+import psutil
+import copy
+from shapely.geometry import shape
+from shapely.ops import transform
+from shapely.geometry import box
+import pyproj
 
-async def request_data(
-        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,
-        max_memory_mb: int = 500,
-        stream_to_disk: bool = None,
-):
+import pandas as pd
+import geopandas as gpd
+
+def expand_on_time(gdf):
+    """
+    Expand datasets on time dimension - each time becomes a new row.
+    
+    Input: GeoDataFrame with 'geometry' and 'dataset' columns (or variable columns)
+    Output: GeoDataFrame with time in multi-index and datasets without time coordinate
     """
-    Request xarray datasets for all geometries in a GeoDataFrame.
+    rows = []
+    
+    for idx, row in gdf.iterrows():
+        if 'geometry' in gdf.columns:
+            geometry = row['geometry']
+        elif gdf.index.name == 'geometry':
+            geometry = idx
+        else:
+            raise ValueError(f"Cannot find geometry in columns: {list(gdf.columns)} or index: {gdf.index.name}")
+        
+        if 'dataset' in gdf.columns:
+            dataset = row['dataset']
+            
+            if 'time' in dataset.dims:
+                for time_val in dataset.time.values:
+                    time_slice = dataset.sel(time=time_val).drop_vars('time')
+                    rows.append({
+                        'geometry': geometry,
+                        'time': time_val,
+                        'dataset': time_slice
+                    })
+            else:
+                rows.append({
+                    'geometry': geometry,
+                    'dataset': dataset
+                })
+        else:
+            variable_columns = list(gdf.columns)
+            
+            first_dataset = row[variable_columns[0]]
+            if 'time' in first_dataset.dims:
+                time_values = first_dataset.time.values
+                
+                for time_val in time_values:
+                    row_data = {'geometry': geometry, 'time': time_val}
+                    
+                    for var_col in variable_columns:
+                        dataset = row[var_col]
+                        time_slice = dataset.sel(time=time_val).drop_vars('time')
+                        row_data[var_col] = time_slice
+                    
+                    rows.append(row_data)
+            else:
+                row_data = {'geometry': geometry}
+                for var_col in variable_columns:
+                    row_data[var_col] = row[var_col]
+                rows.append(row_data)
+    
+    result_df = pd.DataFrame(rows)
+    
+    if 'time' in result_df.columns:
+        result_gdf = gpd.GeoDataFrame(result_df, geometry='geometry')
+        result_gdf = result_gdf.set_index(['geometry', 'time'])
+    else:
+        result_gdf = gpd.GeoDataFrame(result_df, geometry='geometry')
+        result_gdf = result_gdf.set_index(['geometry'])
+    
+    return result_gdf
 
-    Args:
-        client: The AsyncClient instance
-        gdf (GeoDataFrame): GeoDataFrame containing geometries
-        expr (str): Terrakio expression to evaluate, can include spatial aggregations
-        conc (int): Number of concurrent requests to make
-        in_crs (str): Input coordinate reference system
-        out_crs (str): Output coordinate reference system
-        resolution (int): Resolution parameter
-        geom_fix (bool): Whether to fix the geometry (default False)
-        max_memory_mb (int): Maximum memory threshold in MB (default 500MB)
-        stream_to_disk (bool): Whether to stream large datasets to disk. If None, will be determined automatically.
+def expand_on_variables(gdf):
+    """
+    Expand datasets on variables dimension - each variable becomes a new column.
+    
+    Input: GeoDataFrame with 'geometry' and 'dataset' columns (or already time-expanded)
+    Output: GeoDataFrame with separate column for each variable
+    """
+    rows = []
+    
+    for idx, row in gdf.iterrows():
+        if 'geometry' in gdf.columns:
+            geometry = row['geometry']
+        elif hasattr(gdf.index, 'names') and 'geometry' in gdf.index.names:
+            if isinstance(idx, tuple):
+                geometry_idx = gdf.index.names.index('geometry')
+                geometry = idx[geometry_idx]
+                time_idx = gdf.index.names.index('time')
+                time_val = idx[time_idx]
+            else:
+                geometry = idx
+                time_val = None
+        else:
+            raise ValueError(f"Cannot find geometry in columns: {list(gdf.columns)} or index: {gdf.index.names}")
+        
+        if 'dataset' in gdf.columns:
+            dataset = row['dataset']
+            
+            var_names = list(dataset.data_vars.keys())
+            
+            if len(var_names) <= 1:
+                if len(var_names) == 0:
+                    continue
+            
+            if hasattr(gdf.index, 'names') and 'time' in gdf.index.names:
+                row_data = {'geometry': geometry, 'time': time_val}
+            else:
+                row_data = {'geometry': geometry}
+            
+            for var_name in var_names:
+                var_dataset = dataset[[var_name]]
+                
+                if len(var_dataset.dims) == 0:
+                    row_data[var_name] = float(var_dataset[var_name].values)
+                else:
+                    row_data[var_name] = var_dataset
+            
+            rows.append(row_data)
+        else:
+            raise ValueError("Expected 'dataset' column for variable expansion")
+    
+    result_df = pd.DataFrame(rows)
+    
+    if 'time' in result_df.columns:
+        result_gdf = gpd.GeoDataFrame(result_df, geometry='geometry')
+        result_gdf = result_gdf.set_index(['geometry', 'time'])
+    else:
+        result_gdf = gpd.GeoDataFrame(result_df, geometry='geometry')
+        result_gdf = result_gdf.set_index(['geometry'])
+    
+    return result_gdf
 
-    Returns:
-        geopandas.GeoDataFrame: Copy of input GeoDataFrame with additional 'dataset' column
-                               containing the xarray Dataset for each geometry.
 
-    Raises:
-        ValueError: If concurrency is too high or if data exceeds memory limit without streaming
-        APIError: If the API request fails
+def expand_on_variables_and_time(gdf):
     """
-    if conc > 100:
-        raise ValueError("Concurrency (conc) is too high. Please set conc to 100 or less.")
+    Convenience function to expand on both variables and time.
+    Automatically detects which expansions are possible.
+    """
+    try:
+        expanded_on_time = expand_on_time(gdf)
+    except Exception as e:
+        expanded_on_time = gdf
     
-    total_geometries = len(gdf)
+    try:
+        expanded_on_variables_and_time = expand_on_variables(expanded_on_time)
+        return expanded_on_variables_and_time
+    except Exception as e:
+        return expanded_on_time
+
+def estimate_geometry_size_ratio(queries: list):
+    """Calculate size ratios for all geometries relative to the first geometry using bounding box area."""
     
-    # First, make a request with the first geometry to estimate total memory usage
-    client.logger.info("Estimating total memory usage...")
-    first_geom = gdf.geometry.iloc[0]
-    feature = {
-        "type": "Feature",
-        "geometry": mapping(first_geom),
-        "properties": {}
-    }
+    areas = []
     
-    try:
-        first_result = await client.geoquery(expr=expr, feature=feature,
-                                           in_crs=in_crs, out_crs=out_crs, resolution=resolution, geom_fix=geom_fix)
-        if isinstance(first_result, dict) and first_result.get("error"):
-            error_msg = f"Request failed: {first_result.get('error_message', 'Unknown error')}"
-            if first_result.get('status_code'):
-                error_msg = f"Request failed with status {first_result['status_code']}: {first_result.get('error_message', 'Unknown error')}"
-            raise APIError(error_msg)
+    for query in queries:
+        geom = shape(query["feature"]["geometry"])
+        in_crs = query["in_crs"]
         
-        if not isinstance(first_result, xr.Dataset):
-            raise ValueError(f"Expected xarray Dataset, got {type(first_result)}")
+        if in_crs and in_crs != 'EPSG:3857':
+            transformer = pyproj.Transformer.from_crs(in_crs, 'EPSG:3857', always_xy=True)
+            transformed_geom = transform(transformer.transform, geom)
+            bbox = box(*transformed_geom.bounds)
+            area = bbox.area
+        else:
+            bbox = box(*geom.bounds)
+            area = bbox.area
         
-        # Estimate total memory usage
-        single_dataset_size_bytes = estimate_dataset_size(first_result)
-        total_size_bytes = single_dataset_size_bytes * total_geometries
-        total_size_mb = total_size_bytes / (1024 * 1024)
-        
-        client.logger.info(f"Estimated total memory usage: {total_size_mb:.2f} MB for {total_geometries} geometries")
+        areas.append(area)    
+    base_area = areas[0]
+    
+    if base_area == 0:
+        non_zero_areas = [area for area in areas if area > 0]
+        base_area = non_zero_areas[0] if non_zero_areas else 1.0
+    
+    ratios = []
+    for area in areas:
+        if area == 0:
+            ratios.append(0.1)
+        else:
+            ratios.append(area / base_area)
+    
+    return ratios
+
+async def estimate_query_size(
+    client,
+    quries: list[dict],
+):
+    first_query = quries[0]
+
+    first_query_dataset = await client.geoquery(**first_query)
+    ratios = estimate_geometry_size_ratio(quries)
+    total_size_mb = 0
+    for i in range(len(ratios)):
+        total_size_mb += first_query_dataset.nbytes * ratios[i] / (1024**2)
+    return total_size_mb
+
+async def request_geoquery_list(
+        client,
+        quries: list[dict],
+        conc: int = 20,
+):
+    """
+    Execute multiple geo queries.
+    
+    Args:
+        client: The Terrakio client instance
+        quries: List of dictionaries containing query parameters
+        conc: The concurrency level for the requests
         
-        # Check if we need to stream to disk
-        if stream_to_disk is None:
-            # Auto-determine based on memory usage
-            if total_size_mb > max_memory_mb:
-                client.logger.warning(f"The data you are requesting exceeds {max_memory_mb} MB, we recommend you to set the stream_to_disk parameter to True")
-                raise ValueError(f"The data you are requesting exceeds {max_memory_mb} MB, we recommend you to set the stream_to_disk parameter to True")
+    Returns:
+        List of query results
         
-    except Exception as e:
-        if "recommend you to set the stream_to_disk parameter to True" in str(e):
-            raise
-        client.logger.error(f"Failed to estimate memory usage: {e}")
-        raise
-    
-    client.logger.info(f"Processing {total_geometries} geometries with concurrency {conc}")
+    Raises:
+        ValueError: If the queries list is empty
+    """
+    if not quries:
+        raise ValueError("Queries list cannot be empty")
+    if conc > 100:
+        raise ValueError("Concurrency (conc) is too high. Please set conc to 100 or less.")
+
+    for i, query in enumerate(quries):
+        if 'expr' not in query:
+            raise ValueError(f"Query at index {i} is missing the required 'expr' key")
+        if 'feature' not in query:
+            raise ValueError(f"Query at index {i} is missing the required 'feature' key")
+        if 'in_crs' not in query:
+            raise ValueError(f"Query at index {i} is missing the required 'in_crs' key")
     
     completed_count = 0
     lock = asyncio.Lock()
-    
-    async def process_geometry(geom):
-        """Process a single geometry and return the dataset"""
-        nonlocal completed_count
+    async def single_geo_query(query):
+        """
+        Execute multiple geo queries concurrently.
         
+        Args:
+            quries: List of dictionaries containing query parameters
+        """
+        total_number_of_requests = len(quries)
+        nonlocal completed_count
         try:
-            feature = {
-                "type": "Feature",
-                "geometry": mapping(geom),
-                "properties": {}
-            }
-            # Request xarray dataset
-            result = await client.geoquery(expr=expr, feature=feature,
-                                        in_crs=in_crs, out_crs=out_crs, resolution=resolution, geom_fix=geom_fix)
+            result = await client.geoquery(**query)
             if isinstance(result, dict) and result.get("error"):
                 error_msg = f"Request failed: {result.get('error_message', 'Unknown error')}"
                 if result.get('status_code'):
                     error_msg = f"Request failed with status {result['status_code']}: {result.get('error_message', 'Unknown error')}"
                 raise APIError(error_msg)
-            
-            # Ensure we got an xarray Dataset
+            if isinstance(result, list):
+                result = result[0]
+                timestamp_number = result['request_count']
+                return timestamp_number
             if not isinstance(result, xr.Dataset):
                 raise ValueError(f"Expected xarray Dataset, got {type(result)}")
             
             async with lock:
                 completed_count += 1
-                if completed_count % max(1, total_geometries // 10) == 0:
-                    client.logger.info(f"Progress: {completed_count}/{total_geometries} geometries processed")
-            
-            return result
-            
+                if completed_count % max(1, total_number_of_requests // 10) == 0:
+                    client.logger.info(f"Progress: {completed_count}/{total_number_of_requests} requests processed")
+            return result   
         except Exception as e:
             async with lock:
                 completed_count += 1
@@ -134,10 +284,7 @@ async def request_data(
     
     try:
         async with BoundedTaskGroup(max_concurrency=conc) as tg:
-            tasks = [
-                tg.create_task(process_geometry(gdf.geometry.iloc[idx]))
-                for idx in range(len(gdf))
-            ]
+            tasks = [tg.create_task(single_geo_query(quries[idx])) for idx in range(len(quries))]
         all_results = [task.result() for task in tasks]
 
     except* Exception as eg:
@@ -145,261 +292,106 @@ async def request_data(
             if hasattr(e, 'response'):
                 raise APIError(f"API request failed: {e.response.text}")
         raise
-    
     client.logger.info("All requests completed!")
-
+     
     if not all_results:
         raise ValueError("No valid results were returned for any geometry")
-    
-    # Create a copy of the input GeoDataFrame
-    result_gdf = gdf.copy()
-    
-    # Add the dataset column with the xarray datasets
-    result_gdf['dataset'] = all_results
-    
-    return result_gdf
-
+    if isinstance(all_results, list) and type(all_results[0]) == int:
+        return sum(all_results)/len(all_results)
+    else:
+        geometries = []
+        for query in quries:
+            feature = query['feature']
+            geometry = shape(feature['geometry'])
+            geometries.append(geometry)
+        result_gdf = gpd.GeoDataFrame({
+            'geometry': geometries,
+            'dataset': all_results
+        })
+        return result_gdf
 
-import os
-from pathlib import Path
+async def estimate_timestamp_number(
+        client,
+        quries: list[dict],
+):
+    if len(quries) <= 3:
+        return quries
+    sampled_queries = [query.copy() for query in random.sample(quries, 3)]
+    for query in sampled_queries:
+        query['debug'] = 'grpc'
+    result = await request_geoquery_list(client = client, quries = sampled_queries, conc = 5)
+    total_estimated_number_of_timestamps = result * len(quries)
+    return total_estimated_number_of_timestamps
 
-def estimate_dataset_size(dataset):
-    """
-    Estimate the memory size of an xarray dataset in bytes.
-    
-    Args:
-        dataset: xarray Dataset
-        
-    Returns:
-        int: Estimated size in bytes
-    """
-    total_size = 0
-    for var_name, var in dataset.data_vars.items():
-        # Get the dtype size in bytes
-        dtype_size = var.dtype.itemsize
-        # Get the total number of elements
-        total_elements = var.size
-        # Calculate total size for this variable
-        total_size += dtype_size * total_elements
-    
-    # Add coordinate sizes
-    for coord_name, coord in dataset.coords.items():
-        if coord_name not in dataset.dims:  # Don't double count dimension coordinates
-            dtype_size = coord.dtype.itemsize
-            total_elements = coord.size
-            total_size += dtype_size * total_elements
-    
-    return total_size
 
-def save_dataset_to_file(dataset, filepath):
+def get_available_memory_mb():
     """
-    Save dataset to NetCDF file.
+    Get available system memory in MB
     
-    Args:
-        dataset: xarray Dataset
-        filepath: Path to save the file
-        
     Returns:
-        str: Path to saved file
+        float: Available memory in MB
     """
-    filepath = Path(filepath)
-    
-    if not str(filepath).endswith('.nc'):
-        filepath = filepath.with_suffix('.nc')
-    
-    dataset.to_netcdf(filepath)
-    return str(filepath)
+    memory = psutil.virtual_memory()
+    available_mb = memory.available / (1024 * 1024)
+    return round(available_mb, 2)
 
-def post_processing(
-        gdf_with_datasets: GeoDataFrame,
-        spatial_reduction: str = None,
-        temporal_reduction: str = None,
-        drop_nan: bool = False,
-        inplace: bool = False,
-        stream_to_disk: bool = False,
+async def local_or_remote(
+        client,
+        quries: list[dict],
 ):
-    """
-    Post-process the GeoDataFrame with datasets to extract variables with optional reductions.
-
-    Args:
-        gdf_with_datasets (GeoDataFrame): GeoDataFrame with 'dataset' column containing xarray Datasets
-        spatial_reduction (str): Reduction operation for spatial dimensions (x, y). 
-                               Options: 'mean', 'median', 'min', 'max', 'std', 'var', 'sum', 'count'
-        temporal_reduction (str): Reduction operation for temporal dimension (time).
-                                Options: 'mean', 'median', 'min', 'max', 'std', 'var', 'sum', 'count'
-        drop_nan (bool): Whether to drop NaN values from the results (default False)
-        inplace (bool): Whether to modify the input GeoDataFrame in place
-        stream_to_disk (bool): Whether to stream datasets to disk as NetCDF files (default False)
-
-    Returns:
-        geopandas.GeoDataFrame: GeoDataFrame with variable dataarrays/values or file paths in separate columns.
-                               If stream_to_disk=True, large datasets are saved as NetCDF files with file paths stored.
-    """
-    if 'dataset' not in gdf_with_datasets.columns:
-        raise ValueError("Input GeoDataFrame must contain a 'dataset' column")
-    
-    # Validate reduction parameters
-    valid_reductions = ['mean', 'median', 'min', 'max', 'std', 'var', 'sum', 'count']
-    if spatial_reduction and spatial_reduction not in valid_reductions:
-        raise ValueError(f"spatial_reduction must be one of {valid_reductions}")
-    if temporal_reduction and temporal_reduction not in valid_reductions:
-        raise ValueError(f"temporal_reduction must be one of {valid_reductions}")
-    
-    result_rows = []
-    geometries = []
-    
-    # Process each row (geometry + dataset)
-    for i, row in gdf_with_datasets.iterrows():
-        dataset = row['dataset']
-        
-        # Create new row for this geometry
-        new_row = {}
-        
-        # Copy original GeoDataFrame attributes (excluding dataset column)
-        for col in gdf_with_datasets.columns:
-            if col not in ['geometry', 'dataset']:
-                new_row[col] = row[col]
-        
-        # Process each variable in the dataset
-        data_vars = list(dataset.data_vars.keys())
-        for var_name in data_vars:
-            var_data = dataset[var_name]
-            
-            # Apply drop_nan if requested
-            if drop_nan:
-                # Drop spatial dimensions where all values are NaN
-                var_data = var_data.dropna(dim='x', how='all').dropna(dim='y', how='all')
-                
-                # Drop time dimensions where all values are NaN
-                if 'time' in var_data.dims:
-                    var_data = var_data.dropna(dim='time', how='all')
-            
-            # Check current dimensions to determine if aggregation is needed
-            current_dims = set(var_data.dims)
-            has_spatial_dims = bool(current_dims.intersection(['x', 'y']))
-            has_temporal_dim = 'time' in current_dims
-            
-            # Apply spatial reduction only if spatial dimensions exist and reduction is requested
-            if spatial_reduction and has_spatial_dims:
-                spatial_dims = [dim for dim in ['x', 'y'] if dim in var_data.dims]
-                if spatial_dims:
-                    if spatial_reduction == 'count':
-                        var_data = var_data.count(dim=spatial_dims)
-                    else:
-                        var_data = getattr(var_data, spatial_reduction)(dim=spatial_dims)
-            
-            # Apply temporal reduction only if time dimension exists and reduction is requested
-            if temporal_reduction and has_temporal_dim:
-                if temporal_reduction == 'count':
-                    var_data = var_data.count(dim='time')
-                else:
-                    var_data = getattr(var_data, temporal_reduction)(dim='time')
-            
-            # Handle streaming to disk if requested
-            if stream_to_disk:
-                # Create a single-variable dataset for saving
-                single_var_dataset = var_data.to_dataset(name=var_name)
-                
-                # Generate filename based on row index and variable name
-                filename = f"geometry_{i}_{var_name}.nc"
-                filepath = os.path.join(os.getcwd(), filename)
-                
-                # Save to disk and store file path
-                saved_path = save_dataset_to_file(single_var_dataset, filepath)
-                new_row[var_name] = f"file://{saved_path}"
-                
-                print(f"Dataset for geometry {i}, variable '{var_name}' saved to: {saved_path}")
-            else:
-                # Keep in memory
-                new_row[var_name] = var_data
-        
-        result_rows.append(new_row)
-        geometries.append(row['geometry'])
-    
-    # Create the result GeoDataFrame with default integer index
-    result_gdf = GeoDataFrame(result_rows, geometry=geometries)
-    
-    if inplace:
-        # Clear original gdf and replace with result_gdf content
-        gdf_with_datasets.drop(gdf_with_datasets.index, inplace=True)
-        gdf_with_datasets.drop(gdf_with_datasets.columns, axis=1, inplace=True)
-        
-        # Copy all data from result_gdf to gdf
-        for col in result_gdf.columns:
-            gdf_with_datasets[col] = result_gdf[col].values
-        
-        # Ensure it remains a GeoDataFrame with correct geometry
-        gdf_with_datasets.geometry = result_gdf.geometry
-        
-        return None
+    if len(quries) > 1000:
+        return {
+            "local_or_remote": "remote",
+            "reason": "The number of the requests is too large(>1000), please set the mass_stats parameter to True",
+        }
+    elif await estimate_timestamp_number(client = client, quries = quries) > 25000:
+        return {
+            "local_or_remote": "remote",
+            "reason": "The time taking for making these requests is too long, please set the mass_stats parameter to True",
+        }
+    elif await estimate_query_size(client = client, quries = quries) > get_available_memory_mb():
+        return {
+            "local_or_remote": "remote",
+            "reason": "The size of the dataset is too large, please set the mass_stats parameter to True",
+        }
     else:
-        return result_gdf
-
+        return {
+            "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",
+        }
 
-# Updated zonal_stats function that uses both parts
 async def zonal_stats(
         client,
         gdf: GeoDataFrame,
         expr: str,
         conc: int = 20,
-        inplace: bool = False,
         in_crs: str = "epsg:4326",
         out_crs: str = "epsg:4326",
         resolution: int = -1,
         geom_fix: bool = False,
-        drop_nan: bool = False,
-        spatial_reduction: str = None,
-        temporal_reduction: str = None,
-        max_memory_mb: int = 500,
-        stream_to_disk: bool = False,
 ):
-    """
-    Compute zonal statistics for all geometries in a GeoDataFrame.
-    This is a convenience function that combines request_data and post_processing.
-    
-    Args:
-        client: The AsyncClient instance
-        gdf (GeoDataFrame): GeoDataFrame containing geometries
-        expr (str): Terrakio expression to evaluate, can include spatial aggregations
-        conc (int): Number of concurrent requests to make
-        inplace (bool): Whether to modify the input GeoDataFrame in place
-        in_crs (str): Input coordinate reference system
-        out_crs (str): Output coordinate reference system
-        resolution (int): Resolution parameter
-        geom_fix (bool): Whether to fix the geometry (default False)
-        drop_nan (bool): Whether to drop NaN values from the results (default False)
-        spatial_reduction (str): Reduction operation for spatial dimensions (x, y). 
-                               Options: 'mean', 'median', 'min', 'max', 'std', 'var', 'sum', 'count'
-        temporal_reduction (str): Reduction operation for temporal dimension (time).
-                                Options: 'mean', 'median', 'min', 'max', 'std', 'var', 'sum', 'count'
-        max_memory_mb (int): Maximum memory threshold in MB (default 500MB)
-        stream_to_disk (bool): Whether to stream datasets to disk as NetCDF files (default False)
-    """
-    # Step 1: Request data (with memory estimation)
-    gdf_with_datasets = await request_data(
-        client=client,
-        gdf=gdf,
-        expr=expr,
-        conc=conc,
-        in_crs=in_crs,
-        out_crs=out_crs,
-        resolution=resolution,
-        geom_fix=geom_fix,
-        max_memory_mb=max_memory_mb,
-        stream_to_disk=stream_to_disk
-    )
-    
-    # Step 2: Post-process with reductions and optional streaming
-    result = post_processing(
-        gdf_with_datasets=gdf_with_datasets,
-        spatial_reduction=spatial_reduction,
-        temporal_reduction=temporal_reduction,
-        drop_nan=drop_nan,
-        inplace=inplace,
-        stream_to_disk=stream_to_disk
-    )
-    
-    return result
+    """Compute zonal statistics for all geometries in a GeoDataFrame."""
+    quries = []
+    for i in range(len(gdf)):
+        quries.append({
+            "expr": expr,
+            "feature": {
+                "type": "Feature",
+                "geometry": mapping(gdf.geometry.iloc[i]),
+                "properties": {}
+            },
+            "in_crs": in_crs,
+            "out_crs": out_crs,
+            "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"])
+    else:
+        gdf_with_datasets = await request_geoquery_list(client = client, quries = quries, conc = conc)
+        gdf_with_datasets = expand_on_variables_and_time(gdf_with_datasets)
+    return gdf_with_datasets
 
 async def create_dataset_file(
     client,