terrakio-core 0.3.9__py3-none-any.whl → 0.4.2__py3-none-any.whl

terrakio_core/endpoints/user_management.py

@@ -61,11 +61,11 @@ class UserManagement:
     def edit_user(
         self,
         uid: str,
-        email: Optional[str],
-        role: Optional[str],
-        apiKey: Optional[str],
-        groups: Optional[List[str]],
-        quota: Optional[int]
+        email: Optional[str] = None,
+        role: Optional[str] = None,
+        apiKey: Optional[str] = None,
+        groups: Optional[List[str]] = None,
+        quota: Optional[int] = None
     ) -> Dict[str, Any]:
         """
         Edit user info. Only provided fields will be updated.

terrakio_core/sync_client.py

@@ -1,164 +1,95 @@
 import asyncio
 import functools
+import inspect
 from typing import Optional, Dict, Any, Union
 from geopandas import GeoDataFrame
 from shapely.geometry.base import BaseGeometry as ShapelyGeometry
 from .async_client import AsyncClient
-from typing import Dict
-
-
-def sync_wrapper(async_func):
-    """
-    Decorator to convert async functions to sync functions.
-    """
-    @functools.wraps(async_func)
-    def wrapper(*args, **kwargs):
-        # Get or create event loop
-        try:
-            loop = asyncio.get_running_loop()
-            # If we're in an async context, we need to run in a new thread
-            import concurrent.futures
-            with concurrent.futures.ThreadPoolExecutor() as executor:
-                future = executor.submit(asyncio.run, async_func(*args, **kwargs))
-                return future.result()
-        except RuntimeError:
-            # No running loop, we can create a new one
-            return asyncio.run(async_func(*args, **kwargs))
-    return wrapper
 
 
 class SyncWrapper:
     """
-    Generic synchronous wrapper for any async object.
-    Automatically converts all async methods to sync using __getattr__.
+    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.
+        """
+        # Get all public attributes from the wrapped async object
+        async_attrs = [attr for attr in dir(self._async_obj) if not attr.startswith('_')]
+        
+        # Get all attributes from this wrapper instance
+        wrapper_attrs = [attr for attr in object.__dir__(self) if not attr.startswith('_')]
+        
+        # Combine and return unique attributes
+        return list(set(async_attrs + wrapper_attrs))
+    
     def __getattr__(self, name):
         """
         Dynamically wrap any method call to convert async to sync.
         """
         attr = getattr(self._async_obj, name)
         
-        # If it's a callable (method), wrap it
         if callable(attr):
+            @functools.wraps(attr)
             def sync_wrapper(*args, **kwargs):
                 result = attr(*args, **kwargs)
-                # If the result is a coroutine, run it synchronously
                 if hasattr(result, '__await__'):
                     return self._sync_client._run_async(result)
                 return result
             return sync_wrapper
         
-        # If it's not a callable (like a property), return as-is
         return attr
 
 
 class SyncClient:
     """
-    Synchronous wrapper around AsyncClient that converts all async methods to sync.
-    Uses the AsyncClient as a context manager to properly handle session lifecycle.
+    Synchronous wrapper with __dir__ support for runtime autocomplete.
+    Works best in interactive environments like Jupyter/iPython.
     """
     
     def __init__(self, url: Optional[str] = None, api_key: Optional[str] = None, verbose: bool = False):
-        """
-        Initialize the synchronous client.
-        
-        Args:
-            url (Optional[str]): The API base URL
-            api_key (Optional[str]): The API key for authentication
-            verbose (bool): Whether to enable verbose logging
-        """
         self._async_client = AsyncClient(url=url, api_key=api_key, verbose=verbose)
         self._context_entered = False
         self._closed = False
         
         # Initialize endpoint managers
-        self._init_endpoints()
+        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)
+        self.groups = SyncWrapper(self._async_client.groups, self)
+        self.space = SyncWrapper(self._async_client.space, self)
+        self.model = SyncWrapper(self._async_client.model, self)
+        self.auth = SyncWrapper(self._async_client.auth, self)
         
-        # Register cleanup on exit
+        # Register cleanup
         import atexit
         atexit.register(self._cleanup)
-
-    def __getattr__(self, name):
-        """
-        Delegate attribute access to the underlying async client.
-        """
-        if hasattr(self._async_client, name):
-            attr = getattr(self._async_client, name)
-            
-            # If it's a callable (method), wrap it to run synchronously
-            if callable(attr):
-                def sync_method(*args, **kwargs):
-                    result = attr(*args, **kwargs)
-                    # If the result is a coroutine, run it synchronously
-                    if hasattr(result, '__await__'):
-                        return self._run_async(result)
-                    return result
-                return sync_method
-            
-            # If it's not a callable (like a property), return as-is
-            return attr
-        
-        # If the attribute doesn't exist, raise AttributeError
-        raise AttributeError(f"'{self.__class__.__name__}' object has no attribute '{name}'")
-    
-    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):
+    def __dir__(self):
         """
-        Run an async coroutine and return the result synchronously.
-        Ensures the AsyncClient context is properly managed.
+        Return list of attributes for autocomplete in interactive environments.
+        This includes all methods from the async client plus the endpoint managers.
         """
-        async def run_with_context():
-            await self._ensure_context()
-            return await coro
+        # Get default attributes from this class
+        default_attrs = [attr for attr in object.__dir__(self) if not attr.startswith('_')]
         
-        try:
-            loop = asyncio.get_running_loop()
-            # If we're already in an async context, run in a new thread
-            import concurrent.futures
-            
-            with concurrent.futures.ThreadPoolExecutor() as executor:
-                future = executor.submit(asyncio.run, run_with_context())
-                return future.result()
-        except RuntimeError:
-            # No running loop, create a new one
-            return asyncio.run(run_with_context())
-    
-    def _run_async_single_use(self, coro):
-        """
-        Run an async coroutine with its own context manager for one-off operations.
-        This is useful when you don't want to maintain a persistent session.
-        """
-        async def run_with_own_context():
-            async with self._async_client:
-                return await coro
+        # Get all public methods from the async client
+        async_client_attrs = [attr for attr in dir(self._async_client) if not attr.startswith('_')]
         
-        try:
-            loop = asyncio.get_running_loop()
-            # If we're already in an async context, run in a new thread
-            import concurrent.futures
-            
-            with concurrent.futures.ThreadPoolExecutor() as executor:
-                future = executor.submit(asyncio.run, run_with_own_context())
-                return future.result()
-        except RuntimeError:
-            # No running loop, create a new one
-            return asyncio.run(run_with_own_context())
+        # Add endpoint managers
+        endpoint_attrs = ['datasets', 'users', 'mass_stats', 'groups', 'space', 'model', 'auth']
+        
+        # Combine all attributes
+        all_attrs = default_attrs + async_client_attrs + endpoint_attrs
+        
+        return list(set(all_attrs))
     
     def geoquery(
         self,
@@ -170,24 +101,7 @@ class SyncClient:
         geom_fix: bool = False,
         **kwargs
     ):
-        """
-        Compute WCS query for a single geometry (synchronous version).
-
-        Args:
-            expr (str): The WCS expression to evaluate
-            feature (Union[Dict[str, Any], ShapelyGeometry]): The geographic feature
-            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)
-            **kwargs: Additional parameters to pass to the WCS request
-            
-        Returns:
-            Union[pd.DataFrame, xr.Dataset, bytes]: The response data in the requested format
-
-        Raises:
-            APIError: If the API request fails
-        """
+        """Compute WCS query for a single geometry (synchronous version)."""
         coro = self._async_client.geoquery(
             expr=expr,
             feature=feature,
@@ -199,21 +113,26 @@ class SyncClient:
             **kwargs
         )
         return self._run_async(coro)
-    
+
     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,
+            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 (synchronous version).
-
+        
         Args:
             gdf (GeoDataFrame): GeoDataFrame containing geometries
             expr (str): Terrakio expression to evaluate, can include spatial aggregations
@@ -223,12 +142,20 @@ class SyncClient:
             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
         """
         coro = self._async_client.zonal_stats(
@@ -239,7 +166,12 @@ class SyncClient:
             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
         )
         return self._run_async(coro)
     
@@ -258,30 +190,7 @@ class SyncClient:
         poll_interval: int = 30,
         download_path: str = "/home/user/Downloads",
     ) -> dict:
-        """
-        Create a dataset file using mass stats operations (synchronous version).
-
-        Args:
-            aoi (str): Area of interest
-            expression (str): Terrakio expression to evaluate
-            output (str): Output format
-            in_crs (str): Input coordinate reference system (default "epsg:4326")
-            res (float): Resolution (default 0.0001)
-            region (str): Region (default "aus")
-            to_crs (str): Target coordinate reference system (default "epsg:4326")
-            overwrite (bool): Whether to overwrite existing files (default True)
-            skip_existing (bool): Whether to skip existing files (default False)
-            non_interactive (bool): Whether to run non-interactively (default True)
-            poll_interval (int): Polling interval in seconds (default 30)
-            download_path (str): Download path (default "/home/user/Downloads")
-
-        Returns:
-            dict: Dictionary containing generation_task_id and combine_task_id
-
-        Raises:
-            ConfigurationError: If mass stats client is not properly configured
-            RuntimeError: If job fails
-        """
+        """Create a dataset file using mass stats operations (synchronous version)."""
         coro = self._async_client.create_dataset_file(
             aoi=aoi,
             expression=expression,
@@ -297,11 +206,37 @@ class SyncClient:
             download_path=download_path,
         )
         return self._run_async(coro)
+
+    # Rest of the methods remain the same...
+    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 (synchronous version).
-        """
+        """Close the underlying async client session."""
         if not self._closed:
             async def close_async():
                 await self._exit_context()
@@ -323,12 +258,10 @@ class SyncClient:
             try:
                 self.close()
             except Exception:
-                # Ignore errors during cleanup
                 pass
     
     def __enter__(self):
         """Context manager entry."""
-        # Ensure context is entered when used as context manager
         async def enter_async():
             await self._ensure_context()
         
@@ -348,21 +281,9 @@ class SyncClient:
         self.close()
     
     def __del__(self):
-        """Destructor to ensure session is closed when object is garbage collected."""
+        """Destructor to ensure session is closed."""
         if not self._closed:
             try:
                 self._cleanup()
             except Exception:
-                # If we can't close gracefully, ignore the error during cleanup
-                pass
-    
-    # Initialize endpoint managers (these can be overridden by subclasses)
-    def _init_endpoints(self):
-        """Initialize endpoint managers. Can be overridden by subclasses."""
-        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)
-        self.groups = SyncWrapper(self._async_client.groups, self)
-        self.space = SyncWrapper(self._async_client.space, self)
-        self.model = SyncWrapper(self._async_client.model, self)
-        self.auth = SyncWrapper(self._async_client.auth, self)
+                pass

{terrakio_core-0.3.9.dist-info → terrakio_core-0.4.2.dist-info}/METADATA

@@ -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.dist-info → terrakio_core-0.4.2.dist-info}/RECORD

@@ -1,21 +1,21 @@
-terrakio_core/__init__.py,sha256=k4gCdlDIDUWLAMA94FU5EsVDzxQJGgYGlx8y9QgD48M,248
-terrakio_core/async_client.py,sha256=7Ir_icai4AcAvaE-GsKj50xywbMAcSYigBAw-sQ-ZYA,12554
-terrakio_core/client.py,sha256=gVEQr2o00s1CU7xUZtKRKdxZ4_Z0ihbdLj7p0nDEBio,1046
+terrakio_core/__init__.py,sha256=3u7gNX5T8lS09r7SNC2GfJoGhopey8IGP0YDyCxqFJ8,248
+terrakio_core/async_client.py,sha256=T0AEyhh5EwZ2_okRiHuXkLgCqovxl-fuQSejH7hXU0I,13801
+terrakio_core/client.py,sha256=-tGffOKGMyuowsvBwaV7Wtc_EZSWuSwv26_I5FkUank,5446
 terrakio_core/config.py,sha256=r8NARVYOca4AuM88VP_j-8wQxOk1s7VcRdyEdseBlLE,4193
 terrakio_core/exceptions.py,sha256=4qnpOM1gOxsNIXDXY4qwY1d3I4Myhp7HBh7b2D0SVrU,529
-terrakio_core/sync_client.py,sha256=glMNMFCtYTIJWg-926F0i1v4h75iI-KE5_1AyR8nH10,13547
-terrakio_core/convenience_functions/convenience_functions.py,sha256=4C7FR8l4BkaNQU5Q9w_A3fJ6Gf-dk5L3AmSVjKtbkuQ,10246
+terrakio_core/sync_client.py,sha256=UpPn9rHp6x6otxj3QJ1Scnac4stgIpTtb__gmXszYCA,10787
+terrakio_core/convenience_functions/convenience_functions.py,sha256=sBY2g7Vv3jakkuXnuFomXBWP0y6Q7q1K4ay3g4TxIoQ,21068
 terrakio_core/endpoints/auth.py,sha256=e_hdNE6JOGhRVlQMFdEoOmoMHp5EzK6CclOEnc_AmZw,5863
 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=y1w3QLkDD0sKP1tBcFDqgLYLNxX94I-LYbNotaKhLYM,21356
-terrakio_core/endpoints/model_management.py,sha256=Q2bqsVfBILu-hZVw1tr5WjOR68qoYF6m326YJXgAOeo,33886
+terrakio_core/endpoints/mass_stats.py,sha256=yhLCYRrdQPiWwJVCIPbzU5NV3xU5m62pxhYY1FucYjI,23130
+terrakio_core/endpoints/model_management.py,sha256=xB5i8LHYUgRIShHBRS1WhYOQpn0UiB_znP7LVDpMzOI,44616
 terrakio_core/endpoints/space_management.py,sha256=YWb55nkJnFJGlALJ520DvurxDqVqwYtsvqQPWzxzhDs,2266
-terrakio_core/endpoints/user_management.py,sha256=x0JW6VET7eokngmkhZPukegxoJNR1X09BVehJt2nIdI,3781
+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.3.9.dist-info/METADATA,sha256=SSyRx4J6AiK2QDS827SMGTNM3kPg-9KTYJGz3phZ61k,1756
-terrakio_core-0.3.9.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-terrakio_core-0.3.9.dist-info/top_level.txt,sha256=5cBj6O7rNWyn97ND4YuvvXm0Crv4RxttT4JZvNdOG6Q,14
-terrakio_core-0.3.9.dist-info/RECORD,,
+terrakio_core-0.4.2.dist-info/METADATA,sha256=4LwE_mXfB0r9XHp0DFsFeLZM4q1X8kEnu4FeJOkO-90,1756
+terrakio_core-0.4.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+terrakio_core-0.4.2.dist-info/top_level.txt,sha256=5cBj6O7rNWyn97ND4YuvvXm0Crv4RxttT4JZvNdOG6Q,14
+terrakio_core-0.4.2.dist-info/RECORD,,