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

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):
@@ -33,7 +33,6 @@ class AsyncClient(BaseClient):
         self._owns_session = session is None
 
     async def _terrakio_request(self, method: str, endpoint: str, **kwargs):
-        # if self.session is None:
         if self.session is None:
             headers = {
                 'Content-Type': 'application/json',
@@ -49,7 +48,6 @@ class AsyncClient(BaseClient):
     async def _make_request_with_retry(self, session: aiohttp.ClientSession, method: str, endpoint: str, **kwargs) -> Dict[Any, Any]:
         url = f"{self.url}/{endpoint.lstrip('/')}"    
         last_exception = None
-        
         for attempt in range(self.retry + 1):
             try:
                 async with session.request(method, url, **kwargs) as response:
@@ -103,23 +101,38 @@ class AsyncClient(BaseClient):
                 return xr.open_dataset(BytesIO(content))
             except:
                 raise APIError(f"Unknown response format: {content_type}", status_code=response.status)
-            
+
     async def _regular_request(self, method: str, endpoint: str, **kwargs):
         url = endpoint.lstrip('/')
+        
         if self._session is None:
-
             async with aiohttp.ClientSession() as session:
                 try:
                     async with session.request(method, url, **kwargs) as response:
                         response.raise_for_status()
-                        return response
+                        
+                        content = await response.read()
+                        
+                        return type('Response', (), {
+                            'status': response.status,
+                            'content': content,
+                            'text': lambda: content.decode('utf-8'),
+                            'json': lambda: json.loads(content.decode('utf-8'))
+                        })()
                 except aiohttp.ClientError as e:
                     raise APIError(f"Request failed: {e}")
         else:
             try:
                 async with self._session.request(method, url, **kwargs) as response:
                     response.raise_for_status()
-                    return response
+                    content = await response.read()
+                    
+                    return type('Response', (), {
+                        'status': response.status,
+                        'content': content,
+                        'text': lambda: content.decode('utf-8'),
+                        'json': lambda: json.loads(content.decode('utf-8'))
+                    })()
             except aiohttp.ClientError as e:
                 raise APIError(f"Request failed: {e}")
         
@@ -170,23 +183,19 @@ class AsyncClient(BaseClient):
             "validated": validated,
             **kwargs
         }
-        return await self._terrakio_request("POST", "geoquery", json=payload)
+        result = await self._terrakio_request("POST", "geoquery", json=payload)
+
+        return result
 
     async def zonal_stats(
             self,
             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.
@@ -195,22 +204,13 @@ class AsyncClient(BaseClient):
             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)
 
         Returns:
-            geopandas.GeoDataFrame: GeoDataFrame with added columns for results, or None if inplace=True
-                                If stream_to_disk=True, large datasets are saved as NetCDF files with file paths stored.
+            geopandas.GeoDataFrame: GeoDataFrame with added columns for results
 
         Raises:
             ValueError: If concurrency is too high or if data exceeds memory limit without streaming
@@ -221,16 +221,10 @@ class AsyncClient(BaseClient):
             gdf=gdf,
             expr=expr,
             conc=conc,
-            inplace=inplace,
             in_crs=in_crs,
             out_crs=out_crs,
             resolution=resolution,
             geom_fix=geom_fix,
-            drop_nan=drop_nan,
-            spatial_reduction=spatial_reduction,
-            temporal_reduction=temporal_reduction,
-            max_memory_mb=max_memory_mb,
-            stream_to_disk=stream_to_disk
         )
 
     async def create_dataset_file(
@@ -288,33 +282,67 @@ 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 there is no session, we create a session
         if self._session is None:
             headers = {
                 'Content-Type': 'application/json',
                 'x-api-key': self.key,
                 'Authorization': self.token
             }
-            # Remove None values from headers
             clean_headers = {k: v for k, v in headers.items() if v is not None}
-            # we are creating the header and clean any value that is none
-            # now we create the session
             self._session = aiohttp.ClientSession(
                 headers=clean_headers,
                 timeout=aiohttp.ClientTimeout(total=self.timeout)
             )
         return self
-    # if there is no session, we create a session
 
-    # now lets create the aexit function, this function is used when a user uses with, and this function will be automatically called when the with statement is done
     async def __aexit__(self, exc_type, exc_val, exc_tb):
-        #  so if the session is not being passed in, and we created it by ourselves, we are responsible for closing the session
-        #  if the session is being passed in, we are not responsible for closing the session
         if self._owns_session and self._session:
             await self._session.close()
             self._session = None
-            # we close the session and set the session value to none
 
     async def close(self):
         if self._owns_session and self._session:

terrakio_core/client.py

@@ -8,7 +8,6 @@ import xarray as xr
 
 class BaseClient():
     def __init__(self, url: Optional[str] = None, api_key: Optional[str] = None, verbose: bool = False):
-        
         self.verbose = verbose
         self.logger = logging.getLogger("terrakio")
         if verbose:
@@ -34,101 +33,101 @@ class BaseClient():
 
         self.token = config.get('token')
         
-        # Apply xarray printing fix to prevent crashes with GeoDataFrames
-        self._apply_xarray_fix()
+    #     # Apply xarray printing fix to prevent crashes with GeoDataFrames
+    #     self._apply_xarray_fix()
     
-    def _apply_xarray_fix(self):
-        """
-        Apply xarray printing fix to prevent crashes when GeoDataFrames contain xarray objects.
-        This fix is applied automatically when the client is initialized.
-        """
-        try:
+    # def _apply_xarray_fix(self):
+    #     """
+    #     Apply xarray printing fix to prevent crashes when GeoDataFrames contain xarray objects.
+    #     This fix is applied automatically when the client is initialized.
+    #     """
+    #     try:
             
-            # Check if fix is already applied globally
-            if hasattr(xr.DataArray, '_terrakio_fix_applied'):
-                if self.verbose:
-                    self.logger.info("xarray printing fix already applied")
-                return
+    #         # Check if fix is already applied globally
+    #         if hasattr(xr.DataArray, '_terrakio_fix_applied'):
+    #             if self.verbose:
+    #                 self.logger.info("xarray printing fix already applied")
+    #             return
             
-            # Store original methods for potential restoration
-            if not hasattr(xr.DataArray, '_original_iter'):
-                xr.DataArray._original_iter = xr.DataArray.__iter__
-                xr.Dataset._original_iter = xr.Dataset.__iter__
+    #         # Store original methods for potential restoration
+    #         if not hasattr(xr.DataArray, '_original_iter'):
+    #             xr.DataArray._original_iter = xr.DataArray.__iter__
+    #             xr.Dataset._original_iter = xr.Dataset.__iter__
             
-            # Define safe iteration methods that prevent pandas from iterating
-            # but leave __repr__ and __str__ untouched for normal xarray printing
-            def safe_dataarray_iter(self):
-                # Return infinite iterator that always yields the same safe value
-                name = getattr(self, 'name', None) or 'unnamed'
-                shape_str = 'x'.join(map(str, self.shape)) if hasattr(self, 'shape') else 'unknown'
-                placeholder = f"<DataArray '{name}' {shape_str}>"
-                while True:
-                    yield placeholder
+    #         # Define safe iteration methods that prevent pandas from iterating
+    #         # but leave __repr__ and __str__ untouched for normal xarray printing
+    #         def safe_dataarray_iter(self):
+    #             # Return infinite iterator that always yields the same safe value
+    #             name = getattr(self, 'name', None) or 'unnamed'
+    #             shape_str = 'x'.join(map(str, self.shape)) if hasattr(self, 'shape') else 'unknown'
+    #             placeholder = f"<DataArray '{name}' {shape_str}>"
+    #             while True:
+    #                 yield placeholder
             
-            def safe_dataset_iter(self):
-                # Return infinite iterator that always yields the same safe value
-                num_vars = len(self.data_vars) if hasattr(self, 'data_vars') else 0
-                num_dims = len(self.dims) if hasattr(self, 'dims') else 0
-                placeholder = f"<Dataset: {num_vars} vars, {num_dims} dims>"
-                while True:
-                    yield placeholder
+    #         def safe_dataset_iter(self):
+    #             # Return infinite iterator that always yields the same safe value
+    #             num_vars = len(self.data_vars) if hasattr(self, 'data_vars') else 0
+    #             num_dims = len(self.dims) if hasattr(self, 'dims') else 0
+    #             placeholder = f"<Dataset: {num_vars} vars, {num_dims} dims>"
+    #             while True:
+    #                 yield placeholder
             
-            # Apply only the iteration fix - leave __repr__ and __str__ untouched
-            xr.DataArray.__iter__ = safe_dataarray_iter
-            xr.Dataset.__iter__ = safe_dataset_iter
+    #         # Apply only the iteration fix - leave __repr__ and __str__ untouched
+    #         xr.DataArray.__iter__ = safe_dataarray_iter
+    #         xr.Dataset.__iter__ = safe_dataset_iter
             
-            # Mark as applied to avoid duplicate applications
-            xr.DataArray._terrakio_fix_applied = True
-            xr.Dataset._terrakio_fix_applied = True
+    #         # Mark as applied to avoid duplicate applications
+    #         xr.DataArray._terrakio_fix_applied = True
+    #         xr.Dataset._terrakio_fix_applied = True
             
-            if self.verbose:
-                self.logger.info("xarray iteration fix applied - GeoDataFrames with xarray objects will print safely, direct xarray printing unchanged")
+    #         if self.verbose:
+    #             self.logger.info("xarray iteration fix applied - GeoDataFrames with xarray objects will print safely, direct xarray printing unchanged")
                 
-        except ImportError:
-            # xarray not installed, skip the fix
-            if self.verbose:
-                self.logger.info("xarray not installed, skipping printing fix")
-        except Exception as e:
-            # Log warning but don't fail initialization
-            warning_msg = f"Failed to apply xarray printing fix: {e}"
-            warnings.warn(warning_msg)
-            if self.verbose:
-                self.logger.warning(warning_msg)
+    #     except ImportError:
+    #         # xarray not installed, skip the fix
+    #         if self.verbose:
+    #             self.logger.info("xarray not installed, skipping printing fix")
+    #     except Exception as e:
+    #         # Log warning but don't fail initialization
+    #         warning_msg = f"Failed to apply xarray printing fix: {e}"
+    #         warnings.warn(warning_msg)
+    #         if self.verbose:
+    #             self.logger.warning(warning_msg)
     
-    def restore_xarray_printing(self):
-        """
-        Restore original xarray printing behavior.
-        Call this method if you want to see full xarray representations again.
-        """
-        try:
-            import xarray as xr
+    # def restore_xarray_printing(self):
+    #     """
+    #     Restore original xarray printing behavior.
+    #     Call this method if you want to see full xarray representations again.
+    #     """
+    #     try:
+    #         import xarray as xr
             
-            if hasattr(xr.DataArray, '_original_iter'):
-                xr.DataArray.__iter__ = xr.DataArray._original_iter
-                xr.Dataset.__iter__ = xr.Dataset._original_iter
+    #         if hasattr(xr.DataArray, '_original_iter'):
+    #             xr.DataArray.__iter__ = xr.DataArray._original_iter
+    #             xr.Dataset.__iter__ = xr.Dataset._original_iter
                 
-                # Remove the fix markers
-                if hasattr(xr.DataArray, '_terrakio_fix_applied'):
-                    delattr(xr.DataArray, '_terrakio_fix_applied')
-                if hasattr(xr.Dataset, '_terrakio_fix_applied'):
-                    delattr(xr.Dataset, '_terrakio_fix_applied')
+    #             # Remove the fix markers
+    #             if hasattr(xr.DataArray, '_terrakio_fix_applied'):
+    #                 delattr(xr.DataArray, '_terrakio_fix_applied')
+    #             if hasattr(xr.Dataset, '_terrakio_fix_applied'):
+    #                 delattr(xr.Dataset, '_terrakio_fix_applied')
                 
-                if self.verbose:
-                    self.logger.info("Original xarray iteration behavior restored")
-            else:
-                if self.verbose:
-                    self.logger.info("No xarray fix to restore")
+    #             if self.verbose:
+    #                 self.logger.info("Original xarray iteration behavior restored")
+    #         else:
+    #             if self.verbose:
+    #                 self.logger.info("No xarray fix to restore")
                     
-        except ImportError:
-            if self.verbose:
-                self.logger.info("xarray not available")
-        except Exception as e:
-            warning_msg = f"Failed to restore xarray printing: {e}"
-            warnings.warn(warning_msg)
-            if self.verbose:
-                self.logger.warning(warning_msg)
+    #     except ImportError:
+    #         if self.verbose:
+    #             self.logger.info("xarray not available")
+    #     except Exception as e:
+    #         warning_msg = f"Failed to restore xarray printing: {e}"
+    #         warnings.warn(warning_msg)
+    #         if self.verbose:
+    #             self.logger.warning(warning_msg)
     
-    @abstractmethod
-    def _setup_session(self):
-        """Initialize the HTTP session - implemented by sync/async clients"""
-        pass
+    # @abstractmethod
+    # def _setup_session(self):
+    #     """Initialize the HTTP session - implemented by sync/async clients"""
+    #     pass