terrakio-core 0.3.3__py3-none-any.whl → 0.3.6__py3-none-any.whl

terrakio_core/{generation → helper}/tiles.py

@@ -1,10 +1,6 @@
-### implementing generation-tiles in python api
-### function should just generate the json file for mass_stats to pick up.
-
 import geopandas as gpd
 import shapely.geometry
 import json
-from rich import print
 
 def escape_newline(string):
     if isinstance(string, list):
@@ -28,7 +24,6 @@ def tile_generator(x_min, y_min, x_max, y_max, aoi, crs, res, tile_size, express
         j_max += 1
     for j in range(0, int(j_max)):
         for i in range(0, int(i_max)):
-            #print(f"Processing tile {i} {j}")
             x = x_min + i*(tile_size*res)
             y = y_max - j*(tile_size*res)
             bbox = shapely.geometry.box(x, y-(tile_size*res), x + (tile_size*res), y)
@@ -62,10 +57,8 @@ def tiles(
     non_interactive: bool = False,
 ):
     
-    # Create requests for each tile
     reqs = []
     x_min, y_min, x_max, y_max, aoi = get_bounds(aoi, crs, to_crs)
-    #print(f"Bounds: {x_min}, {y_min}, {x_max}, {y_max}")
 
     if to_crs is None:
         to_crs = crs
@@ -73,9 +66,6 @@ def tiles(
         req_name = f"{name}_{i:02d}_{j:02d}"
         reqs.append({"group": "tiles", "file": req_name, "request": tile_req})
 
-    #print(f"Generated {len(reqs)} tile requests.")
-
-
     count = len(reqs)
     groups = list(set(dic["group"] for dic in reqs))
 
@@ -91,5 +81,4 @@ def tiles(
     request_json = json.dumps(reqs)
     manifest_json = json.dumps(groups)
 
-    return body, request_json, manifest_json
-    
+    return body, request_json, manifest_json

terrakio_core/sync_client.py

@@ -0,0 +1,370 @@
+import asyncio
+import functools
+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__.
+    """
+    
+    def __init__(self, async_obj, sync_client):
+        self._async_obj = async_obj
+        self._sync_client = sync_client
+    
+    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):
+            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.
+    """
+    
+    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()
+        
+        # Register cleanup on exit
+        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):
+        """
+        Run an async coroutine and return the result synchronously.
+        Ensures the AsyncClient context is properly managed.
+        """
+        async def run_with_context():
+            await self._ensure_context()
+            return await coro
+        
+        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
+        
+        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())
+    
+    def geoquery(
+        self,
+        expr: str,
+        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,
+        **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
+            output (str): Output format ('csv' or 'netcdf')
+            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
+        """
+        coro = self._async_client.geoquery(
+            expr=expr,
+            feature=feature,
+            in_crs=in_crs,
+            out_crs=out_crs,
+            output=output,
+            resolution=resolution,
+            geom_fix=geom_fix,
+            **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,
+    ):
+        """
+        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
+            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)
+            
+        Returns:
+            geopandas.GeoDataFrame: GeoDataFrame with added columns for results, or None if inplace=True
+
+        Raises:
+            ValueError: If concurrency is too high
+            APIError: If the API request fails
+        """
+        coro = self._async_client.zonal_stats(
+            gdf=gdf,
+            expr=expr,
+            conc=conc,
+            inplace=inplace,
+            in_crs=in_crs,
+            out_crs=out_crs,
+            resolution=resolution,
+            geom_fix=geom_fix
+        )
+        return self._run_async(coro)
+    
+    def create_dataset_file(
+        self,
+        aoi: str,
+        expression: str,
+        output: str,
+        in_crs: str = "epsg:4326",
+        res: float = 0.0001,
+        region: str = "aus",
+        to_crs: str = "epsg:4326",
+        overwrite: bool = True,
+        skip_existing: bool = False,
+        non_interactive: bool = True,
+        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
+        """
+        coro = self._async_client.create_dataset_file(
+            aoi=aoi,
+            expression=expression,
+            output=output,
+            in_crs=in_crs,
+            res=res,
+            region=region,
+            to_crs=to_crs,
+            overwrite=overwrite,
+            skip_existing=skip_existing,
+            non_interactive=non_interactive,
+            poll_interval=poll_interval,
+            download_path=download_path,
+        )
+        return self._run_async(coro)
+    
+    def close(self):
+        """
+        Close the underlying async client session (synchronous version).
+        """
+        if not self._closed:
+            async def close_async():
+                await self._exit_context()
+            
+            try:
+                loop = asyncio.get_running_loop()
+                import concurrent.futures
+                with concurrent.futures.ThreadPoolExecutor() as executor:
+                    future = executor.submit(asyncio.run, close_async())
+                    future.result()
+            except RuntimeError:
+                asyncio.run(close_async())
+            
+            self._closed = True
+    
+    def _cleanup(self):
+        """Internal cleanup method called by atexit."""
+        if not self._closed:
+            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()
+        
+        try:
+            loop = asyncio.get_running_loop()
+            import concurrent.futures
+            with concurrent.futures.ThreadPoolExecutor() as executor:
+                future = executor.submit(asyncio.run, enter_async())
+                future.result()
+        except RuntimeError:
+            asyncio.run(enter_async())
+        
+        return self
+    
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Context manager exit."""
+        self.close()
+    
+    def __del__(self):
+        """Destructor to ensure session is closed when object is garbage collected."""
+        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)

{terrakio_core-0.3.3.dist-info → terrakio_core-0.3.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: terrakio-core
-Version: 0.3.3
+Version: 0.3.6
 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.6.dist-info/RECORD

@@ -0,0 +1,21 @@
+terrakio_core/__init__.py,sha256=3MTDxMAQZCgXE5_gREyxTGTNK4WDZHlW91Syr0axr1M,242
+terrakio_core/async_client.py,sha256=0Zz-g5X4B2NZHRJrTuJAwNBUfO596Zvn1Nga3J-PiaE,13092
+terrakio_core/client.py,sha256=h8GW88g6RlGwNFW6MW48c_3BnaeT9nSd19LI1jCn1GU,1008
+terrakio_core/config.py,sha256=r8NARVYOca4AuM88VP_j-8wQxOk1s7VcRdyEdseBlLE,4193
+terrakio_core/exceptions.py,sha256=9S-I20-QiDRj1qgjFyYUwYM7BLic_bxurcDOIm2Fu_0,410
+terrakio_core/sync_client.py,sha256=v1mcBtUaKWACqZgw8dTTVPMxUfKfiY0kjtBKzDwtGTU,13634
+terrakio_core/convenience_functions/convenience_functions.py,sha256=U7bLGwfBF-FUYc0nv49pAViPsBQ6LgPlV6c6b-zeKo8,10616
+terrakio_core/endpoints/auth.py,sha256=e_hdNE6JOGhRVlQMFdEoOmoMHp5EzK6CclOEnc_AmZw,5863
+terrakio_core/endpoints/dataset_management.py,sha256=8uf6cxlSSevqnQWcldtA9Cd24D5VrmWyxkE7Ngx3IEw,13084
+terrakio_core/endpoints/group_management.py,sha256=VFl3jakjQa9OPi351D3DZvLU9M7fHdfjCzGhmyJsx3U,6309
+terrakio_core/endpoints/mass_stats.py,sha256=KDmIlMYy4nkehPU5Ejtb_WN9Cz5mkt_rIsyDZkTWOLA,21351
+terrakio_core/endpoints/model_management.py,sha256=1ZYymaTQ7IY191sLSS7MWvhrHLmy2VeAM2A1Ty5NhU0,15346
+terrakio_core/endpoints/space_management.py,sha256=YWb55nkJnFJGlALJ520DvurxDqVqwYtsvqQPWzxzhDs,2266
+terrakio_core/endpoints/user_management.py,sha256=x0JW6VET7eokngmkhZPukegxoJNR1X09BVehJt2nIdI,3781
+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.6.dist-info/METADATA,sha256=b0a6IvGiQAjaN-iBUu7gmE4-oxaZLIhfw8KQ_xV8tOs,1476
+terrakio_core-0.3.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+terrakio_core-0.3.6.dist-info/top_level.txt,sha256=5cBj6O7rNWyn97ND4YuvvXm0Crv4RxttT4JZvNdOG6Q,14
+terrakio_core-0.3.6.dist-info/RECORD,,

terrakio_core/auth.py

@@ -1,223 +0,0 @@
-import requests
-from typing import Optional, Dict, Any
-from .exceptions import APIError, ConfigurationError
-
-class AuthClient:
-    def __init__(self, base_url: str = "https://dev-au.terrak.io", 
-                 verify: bool = True, timeout: int = 60):
-        """
-        Initialize the Authentication Client for Terrakio API.
-        
-        Args:
-            base_url: Authentication API base URL
-            verify: Verify SSL certificates
-            timeout: Request timeout in seconds
-        """
-        self.base_url = base_url.rstrip('/')
-        self.verify = verify
-        self.timeout = timeout
-        self.session = requests.Session()
-        self.session.headers.update({
-            'Content-Type': 'application/json'
-        })
-        self.token = None
-        self.api_key = None
-    
-    def signup(self, email: str, password: str) -> Dict[str, Any]:
-        """
-        Register a new user account.
-        
-        Args:
-            email: User email address
-            password: User password
-        
-        Returns:
-            API response data
-        
-        Raises:
-            APIError: If signup fails
-        """
-        endpoint = f"{self.base_url}/users/signup"
-        
-        payload = {
-            "email": email,
-            "password": password
-        }
-        print("the payload is ", payload)
-        print("the endpoint is ", endpoint)
-        try:
-            response = self.session.post(
-                endpoint, 
-                json=payload,
-                verify=self.verify,
-                timeout=self.timeout
-            )
-            print("the response is ", response)
-            if not response.ok:
-                error_msg = f"Signup failed: {response.status_code} {response.reason}"
-                try:
-                    error_data = response.json()
-                    if "detail" in error_data:
-                        error_msg += f" - {error_data['detail']}"
-                except:
-                    pass
-                raise APIError(error_msg)
-            
-            return response.json()
-        except requests.RequestException as e:
-            raise APIError(f"Signup request failed: {str(e)}")
-    
-    def login(self, email: str, password: str) -> str:
-        """
-        Log in and obtain authentication token.
-        
-        Args:
-            email: User email address
-            password: User password
-        
-        Returns:
-            Authentication token
-        
-        Raises:
-            APIError: If login fails
-        """
-        endpoint = f"{self.base_url}/users/login"
-        
-        payload = {
-            "email": email,
-            "password": password
-        }
-        
-        try:
-            response = self.session.post(
-                endpoint, 
-                json=payload,
-                verify=self.verify,
-                timeout=self.timeout
-            )
-            
-            if not response.ok:
-                error_msg = f"Login failed: {response.status_code} {response.reason}"
-                try:
-                    error_data = response.json()
-                    if "detail" in error_data:
-                        error_msg += f" - {error_data['detail']}"
-                except:
-                    pass
-                raise APIError(error_msg)
-            
-            result = response.json()
-            self.token = result.get("token")
-            
-            # Update session with authorization header
-            if self.token:
-                self.session.headers.update({
-                    "Authorization": self.token
-                })
-            
-            return self.token
-        except requests.RequestException as e:
-            raise APIError(f"Login request failed: {str(e)}")
-    
-    def refresh_api_key(self) -> str:
-        """
-        Generate or refresh API key.
-        
-        Returns:
-            API key
-        
-        Raises:
-            APIError: If refresh fails
-        """
-        endpoint = f"{self.base_url}/users/refresh_key"
-        
-        try:
-            # Use session with updated headers from login
-            response = self.session.post(
-                endpoint,
-                verify=self.verify,
-                timeout=self.timeout
-            )
-            
-            if not response.ok:
-                error_msg = f"API key generation failed: {response.status_code} {response.reason}"
-                try:
-                    error_data = response.json()
-                    if "detail" in error_data:
-                        error_msg += f" - {error_data['detail']}"
-                except:
-                    pass
-                raise APIError(error_msg)
-            
-            result = response.json()
-            self.api_key = result.get("apiKey")
-            return self.api_key
-        except requests.RequestException as e:
-            raise APIError(f"API key refresh request failed: {str(e)}")
-    
-    def view_api_key(self) -> str:
-        """
-        Retrieve current API key.
-        
-        Returns:
-            API key
-        
-        Raises:
-            APIError: If retrieval fails
-        """
-        endpoint = f"{self.base_url}/users/key"
-        try:
-            # Use session with updated headers from login
-            response = self.session.get(
-                endpoint,
-                verify=self.verify,
-                timeout=self.timeout
-            )
-            
-            if not response.ok:
-                error_msg = f"Failed to retrieve API key: {response.status_code} {response.reason}"
-                try:
-                    error_data = response.json()
-                    if "detail" in error_data:
-                        error_msg += f" - {error_data['detail']}"
-                except:
-                    pass
-                raise APIError(error_msg)
-            
-            result = response.json()
-            self.api_key = result.get("apiKey")
-            return self.api_key
-        except requests.RequestException as e:
-            raise APIError(f"API key retrieval request failed: {str(e)}")
-    
-    def get_user_info(self) -> Dict[str, Any]:
-        """
-        Retrieve the current user's information.
-        
-        Returns:
-            User information data
-        
-        Raises:
-            APIError: If retrieval fails
-        """
-        endpoint = f"{self.base_url}/users/info"
-        try:
-            # Use session with updated headers from login
-            response = self.session.get(
-                endpoint,
-                verify=self.verify,
-                timeout=self.timeout
-            )
-            if not response.ok:
-                error_msg = f"Failed to retrieve user info: {response.status_code} {response.reason}"
-                try:
-                    error_data = response.json()
-                    if "detail" in error_data:
-                        error_msg += f" - {error_data['detail']}"
-                except:
-                    pass
-                raise APIError(error_msg)
-            
-            return response.json()
-        except requests.RequestException as e:
-            raise APIError(f"User info retrieval request failed: {str(e)}")