terrakio-core 0.3.9__tar.gz → 0.4.2__tar.gz

{terrakio_core-0.3.9 → terrakio_core-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: terrakio-core
-Version: 0.3.9
+Version: 0.4.2
 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

{terrakio_core-0.3.9 → terrakio_core-0.4.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "terrakio-core"
-version = "0.3.9"
+version = "0.4.2"
 authors = [
     {name = "Yupeng Chao", email = "yupeng@haizea.com.au"},
 ]

{terrakio_core-0.3.9 → terrakio_core-0.4.2}/terrakio_core/__init__.py

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

{terrakio_core-0.3.9 → terrakio_core-0.4.2}/terrakio_core/async_client.py

@@ -182,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.
@@ -195,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(
@@ -211,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.2/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