terrakio-core 0.3.8__tar.gz → 0.4.0__tar.gz

{terrakio_core-0.3.8 → terrakio_core-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: terrakio-core
-Version: 0.3.8
+Version: 0.4.0
 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
@@ -22,6 +22,7 @@ Requires-Dist: xarray>=2023.1.0
 Requires-Dist: shapely>=2.0.0
 Requires-Dist: geopandas>=0.13.0
 Requires-Dist: google-cloud-storage>=2.0.0
+Requires-Dist: scipy>=1.7.0
 Requires-Dist: nest_asyncio
 Provides-Extra: ml
 Requires-Dist: torch>=2.7.1; extra == "ml"

{terrakio_core-0.3.8 → terrakio_core-0.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "terrakio-core"
-version = "0.3.8"
+version = "0.4.0"
 authors = [
     {name = "Yupeng Chao", email = "yupeng@haizea.com.au"},
 ]
@@ -29,6 +29,7 @@ dependencies = [
     "shapely>=2.0.0",
     "geopandas>=0.13.0",
     "google-cloud-storage>=2.0.0",
+    "scipy>=1.7.0",
     "nest_asyncio",
 ]
 

{terrakio_core-0.3.8 → terrakio_core-0.4.0}/terrakio_core/__init__.py

@@ -5,12 +5,12 @@ Terrakio Core
 Core components for Terrakio API clients.
 """
 
-__version__ = "0.3.8"
+__version__ = "0.4.0"
 
 from .async_client import AsyncClient
-from .sync_client import SyncClient
+from .sync_client import SyncClient as Client
 
 __all__ = [
     "AsyncClient", 
-    "SyncClient"
+    "Client"
 ]

{terrakio_core-0.3.8 → terrakio_core-0.4.0}/terrakio_core/async_client.py

@@ -90,7 +90,6 @@ class AsyncClient(BaseClient):
         """Parse response based on content type."""
         content_type = response.headers.get('content-type', '').lower()
         content = await response.read()
-
         if 'json' in content_type:
             return json.loads(content.decode('utf-8'))
         elif 'csv' in content_type:
@@ -117,7 +116,6 @@ class AsyncClient(BaseClient):
                 except aiohttp.ClientError as e:
                     raise APIError(f"Request failed: {e}")
         else:
-            # this means that we used the with statement, and we already have a session
             try:
                 async with self._session.request(method, url, **kwargs) as response:
                     response.raise_for_status()
@@ -131,7 +129,6 @@ class AsyncClient(BaseClient):
         feature: Union[Dict[str, Any], ShapelyGeometry],
         in_crs: str = "epsg:4326",
         out_crs: str = "epsg:4326",
-        output: str = "csv",
         resolution: int = -1,
         geom_fix: bool = False,
         validated: bool = True,
@@ -145,7 +142,6 @@ class AsyncClient(BaseClient):
             feature (Union[Dict[str, Any], ShapelyGeometry]): The geographic feature
             in_crs (str): Input coordinate reference system
             out_crs (str): Output coordinate reference system
-            output (str): Output format ('csv' or 'netcdf')
             resolution (int): Resolution parameter
             geom_fix (bool): Whether to fix the geometry (default False)
             validated (bool): Whether to use validated data (default True)
@@ -167,7 +163,7 @@ class AsyncClient(BaseClient):
             "feature": feature,
             "in_crs": in_crs,
             "out_crs": out_crs,
-            "output": output,
+            "output": "netcdf",
             "resolution": resolution,
             "expr": expr,
             "buffer": geom_fix,
@@ -186,6 +182,11 @@ class AsyncClient(BaseClient):
             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.
@@ -199,11 +200,20 @@ class AsyncClient(BaseClient):
             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.
 
         Raises:
-            ValueError: If concurrency is too high
+            ValueError: If concurrency is too high or if data exceeds memory limit without streaming
             APIError: If the API request fails
         """
         return await _zonal_stats(
@@ -215,7 +225,12 @@ class AsyncClient(BaseClient):
             in_crs=in_crs,
             out_crs=out_crs,
             resolution=resolution,
-            geom_fix=geom_fix
+            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(

terrakio_core-0.4.0/terrakio_core/client.py

@@ -0,0 +1,134 @@
+from typing import Optional
+import logging
+import warnings
+from terrakio_core.config import read_config_file, DEFAULT_CONFIG_FILE
+from abc import abstractmethod
+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:
+            self.logger.setLevel(logging.INFO)
+        else:
+            self.logger.setLevel(logging.WARNING)
+
+        self.timeout = 300
+        self.retry = 3
+
+        self.session = None
+
+        self.url = url
+        self.key = api_key
+
+        config = read_config_file(DEFAULT_CONFIG_FILE, logger=self.logger)
+                
+        if self.url is None:
+            self.url = config.get('url')
+                
+        if self.key is None:
+            self.key = config.get('key')
+
+        self.token = config.get('token')
+        
+        # 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:
+            
+            # 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__
+            
+            # 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
+            
+            # 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
+            
+            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)
+    
+    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
+                
+                # 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")
+                    
+        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