terrakio-core 0.3.4__py3-none-any.whl → 0.3.7__py3-none-any.whl

terrakio_core/config.py

@@ -2,21 +2,20 @@ import os
 import json
 from pathlib import Path
 from typing import Dict, Any, Optional
-
+import logging
 from .exceptions import ConfigurationError
 
 # Default configuration file locations
 DEFAULT_CONFIG_FILE = os.path.join(os.environ.get("HOME", ""), ".tkio_config.json")
 DEFAULT_API_URL = "https://api.terrak.io"
 
-def read_config_file(config_file: str = DEFAULT_CONFIG_FILE, quiet: bool = False) -> Dict[str, Any]:
+def read_config_file(config_file: str = DEFAULT_CONFIG_FILE, logger: logging.Logger = None) -> Dict[str, Any]:
     """
     Read and parse the configuration file.
     
     Args:
         config_file: Path to the configuration file
-        quiet: If True, suppress informational messages
-        
+        logger: Logger object to log messages
     Returns:
         Dict[str, Any]: Configuration parameters with additional flags:
                        'is_logged_in': True if user is logged in
@@ -36,8 +35,7 @@ def read_config_file(config_file: str = DEFAULT_CONFIG_FILE, quiet: bool = False
         config_path.parent.mkdir(parents=True, exist_ok=True)
         with open(config_path, 'w') as f:
             json.dump({}, f)
-        if not quiet:
-            print("No API key found. Please provide an API key to use this client.")
+        logger.info("No API key found. Please provide an API key to use this client.")
         return {
             'url': DEFAULT_API_URL,
             'key': None,
@@ -54,8 +52,7 @@ def read_config_file(config_file: str = DEFAULT_CONFIG_FILE, quiet: bool = False
         # Read the config file data
         # Check if config has an API key
         if not config_data or 'TERRAKIO_API_KEY' not in config_data or not config_data.get('TERRAKIO_API_KEY'):
-            if not quiet:
-                print("No API key found. Please provide an API key to use this client.")
+            logger.info("No API key found. Please provide an API key to use this client.")
             return {
                 'url': DEFAULT_API_URL,
                 'key': None,
@@ -63,10 +60,7 @@ def read_config_file(config_file: str = DEFAULT_CONFIG_FILE, quiet: bool = False
                 'user_email': None,
                 'token': config_data.get('PERSONAL_TOKEN')
             }
-        
-        # If we have config values, use them
-        if not quiet:
-            print(f"Currently logged in as: {config_data.get('EMAIL')}")
+        logger.info(f"Currently logged in as: {config_data.get('EMAIL')}")
         # this meanb that we have already logged in to the tkio account
         
         # Convert the JSON config to our expected format
@@ -82,9 +76,8 @@ def read_config_file(config_file: str = DEFAULT_CONFIG_FILE, quiet: bool = False
             
 
     except Exception as e:
-        if not quiet:
-            print(f"Error reading config: {e}")
-            print("No API key found. Please provide an API key to use this client.")
+        logger.info(f"Error reading config: {e}")
+        logger.info("No API key found. Please provide an API key to use this client.")
         return {
             'url': DEFAULT_API_URL,
             'key': None,

terrakio_core/convenience_functions/convenience_functions.py

@@ -0,0 +1,296 @@
+import os
+import asyncio
+import tempfile
+import time
+import pandas as pd
+from geopandas import GeoDataFrame
+from shapely.geometry import mapping
+from ..exceptions import APIError, ConfigurationError
+from ..helper.bounded_taskgroup import BoundedTaskGroup
+from ..helper.tiles import tiles
+import uuid
+
+async def zonal_stats(
+        client,
+        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.
+
+    Args:
+        client: The AsyncClient instance
+        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
+    """
+    if conc > 100:
+        raise ValueError("Concurrency (conc) is too high. Please set conc to 100 or less.")
+    
+    total_geometries = len(gdf)
+    
+    client.logger.info(f"Processing {total_geometries} geometries with concurrency {conc}")
+    
+    completed_count = 0
+    lock = asyncio.Lock()
+    
+    async def process_geometry(geom, index):
+        """Process a single geometry"""
+        nonlocal completed_count
+        
+        try:
+            feature = {
+                "type": "Feature",
+                "geometry": mapping(geom),
+                "properties": {"index": index}
+            }
+            result = await client.geoquery(expr=expr, feature=feature, output="csv",
+                                        in_crs=in_crs, out_crs=out_crs, resolution=resolution, geom_fix=geom_fix)
+            
+            if isinstance(result, dict) and result.get("error"):
+                error_msg = f"Request {index} failed: {result.get('error_message', 'Unknown error')}"
+                if result.get('status_code'):
+                    error_msg = f"Request {index} failed with status {result['status_code']}: {result.get('error_message', 'Unknown error')}"
+                raise APIError(error_msg)
+            
+            if isinstance(result, pd.DataFrame):
+                result['_geometry_index'] = index
+            
+            async with lock:
+                completed_count += 1
+                if completed_count % max(1, total_geometries // 10) == 0:
+                    client.logger.info(f"Progress: {completed_count}/{total_geometries} geometries processed")
+            
+            return result
+            
+        except Exception as e:
+            async with lock:
+                completed_count += 1
+            raise
+    
+    try:
+        async with BoundedTaskGroup(max_concurrency=conc) as tg:
+            tasks = [
+                tg.create_task(process_geometry(gdf.geometry.iloc[idx], idx))
+                for idx in range(len(gdf))
+            ]
+        all_results = [task.result() for task in tasks]
+        
+    except* Exception as eg:
+        for e in eg.exceptions:
+            if hasattr(e, 'response'):
+                raise APIError(f"API request failed: {e.response.text}")
+        raise
+    
+    client.logger.info("All requests completed! Processing results...")
+    
+    if not all_results:
+        raise ValueError("No valid results were returned for any geometry")
+        
+    combined_df = pd.concat(all_results, ignore_index=True)
+    
+    has_time = 'time' in combined_df.columns
+    
+    if has_time:
+        if '_geometry_index' not in combined_df.columns:
+            raise ValueError("Missing geometry index in results")
+        
+        combined_df.set_index(['_geometry_index', 'time'], inplace=True)
+        
+        result_cols = combined_df.columns
+        
+        result_rows = []
+        geometries = []
+        
+        for (geom_idx, time_val), row in combined_df.iterrows():
+            new_row = {}
+            
+            for col in gdf.columns:
+                if col != 'geometry':
+                    new_row[col] = gdf.loc[geom_idx, col]
+            
+            for col in result_cols:
+                new_row[col] = row[col]
+            
+            result_rows.append(new_row)
+            geometries.append(gdf.geometry.iloc[geom_idx])
+        
+        multi_index = pd.MultiIndex.from_tuples(
+            combined_df.index.tolist(),
+            names=['geometry_index', 'time']
+        )
+        
+        result_gdf = GeoDataFrame(
+            result_rows, 
+            geometry=geometries,
+            index=multi_index
+        )
+        
+        if inplace:
+            return result_gdf
+        else:
+            return result_gdf
+    else:
+        result_gdf = gdf.copy() if not inplace else gdf
+        
+        result_cols = [col for col in combined_df.columns if col not in ['_geometry_index']]
+        
+        geom_idx_to_row = {}
+        for idx, row in combined_df.iterrows():
+            geom_idx = int(row['_geometry_index'])
+            geom_idx_to_row[geom_idx] = row
+        
+        for col in result_cols:
+            if col not in result_gdf.columns:
+                result_gdf[col] = None
+            
+            for geom_idx, row in geom_idx_to_row.items():
+                result_gdf.loc[geom_idx, col] = row[col]
+        if inplace:
+            return None
+        else:
+            return result_gdf
+
+async def create_dataset_file(
+    client,
+    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:
+    
+    name = f"tiles-{uuid.uuid4().hex[:8]}"
+    
+    body, reqs, groups = tiles(
+        name = name, 
+        aoi = aoi, 
+        expression = expression,
+        output = output,
+        tile_size = 128,
+        crs = in_crs,
+        res = res,
+        region = region,
+        to_crs = to_crs,
+        fully_cover = True,
+        overwrite = overwrite,
+        skip_existing = skip_existing,
+        non_interactive = non_interactive
+    )
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as tempreq:
+        tempreq.write(reqs)
+        tempreqname = tempreq.name
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as tempmanifest:
+        tempmanifest.write(groups)
+        tempmanifestname = tempmanifest.name
+
+    task_id = await client.mass_stats.execute_job(
+        name=body["name"],
+        region=body["region"],
+        output=body["output"],
+        config = {},
+        overwrite=body["overwrite"],
+        skip_existing=body["skip_existing"],
+        request_json=tempreqname,
+        manifest_json=tempmanifestname,
+    )
+
+    start_time = time.time()
+    status = None
+    
+    while True:
+        try:
+            taskid = task_id['task_id']
+            trackinfo = await client.mass_stats.track_job([taskid])
+            client.logger.info("the trackinfo is: ", trackinfo)
+            status = trackinfo[taskid]['status']
+            
+            if status == 'Completed':
+                client.logger.info('Tiles generated successfully!')
+                break
+            elif status in ['Failed', 'Cancelled', 'Error']:
+                raise RuntimeError(f"Job {taskid} failed with status: {status}")
+            else:
+                elapsed_time = time.time() - start_time
+                client.logger.info(f"Job status: {status} - Elapsed time: {elapsed_time:.1f}s", end='\r')
+                
+                await asyncio.sleep(poll_interval)
+                
+                
+        except KeyboardInterrupt:
+            client.logger.info(f"\nInterrupted! Job {taskid} is still running in the background.")
+            raise
+        except Exception as e:
+            client.logger.info(f"\nError tracking job: {e}")
+            raise
+
+    os.unlink(tempreqname)
+    os.unlink(tempmanifestname)
+
+    combine_result = await client.mass_stats.combine_tiles(body["name"], body["overwrite"], body["output"])
+    combine_task_id = combine_result.get("task_id")
+
+    combine_start_time = time.time()
+    while True:
+        try:
+            trackinfo = await client.mass_stats.track_job([combine_task_id])
+            client.logger.info('client create dataset file track info:', trackinfo)
+            if body["output"] == "netcdf":
+                download_file_name = trackinfo[combine_task_id]['folder'] + '.nc'
+            elif body["output"] == "geotiff":
+                download_file_name = trackinfo[combine_task_id]['folder'] + '.tif'
+            bucket = trackinfo[combine_task_id]['bucket']
+            combine_status = trackinfo[combine_task_id]['status']
+            if combine_status == 'Completed':
+                client.logger.info('Tiles combined successfully!')
+                break
+            elif combine_status in ['Failed', 'Cancelled', 'Error']:
+                raise RuntimeError(f"Combine job {combine_task_id} failed with status: {combine_status}")
+            else:
+                elapsed_time = time.time() - combine_start_time
+                client.logger.info(f"Combine job status: {combine_status} - Elapsed time: {elapsed_time:.1f}s", end='\r')
+                time.sleep(poll_interval)
+        except KeyboardInterrupt:
+            client.logger.info(f"\nInterrupted! Combine job {combine_task_id} is still running in the background.")
+            raise
+        except Exception as e:
+            client.logger.info(f"\nError tracking combine job: {e}")
+            raise
+
+    if download_path:
+        await client.mass_stats.download_file(
+            job_name=body["name"],
+            bucket=bucket,
+            file_type='processed',
+            page_size=10,
+            output_path=download_path,
+        )
+    else:
+        path = f"{body['name']}/outputs/merged/{download_file_name}"
+        client.logger.info(f"Combined file is available at {path}")
+
+    return {"generation_task_id": task_id, "combine_task_id": combine_task_id}

terrakio_core/endpoints/auth.py

@@ -0,0 +1,180 @@
+import os
+import json
+from typing import Dict, Any
+from ..exceptions import APIError
+from ..helper.decorators import require_token, require_api_key, require_auth
+
+class AuthClient:
+    def __init__(self, client):
+        self._client = client
+
+    async def signup(self, email: str, password: str) -> Dict[str, str]:
+        """
+        Signup a new user with email and password.
+
+        Args:
+            email: User's email address
+            password: User's password
+            
+        Returns:
+            Dict containing the authentication token
+            
+        Raises:
+            APIError: If the signup request fails
+        """
+        payload = {
+            "email": email,
+            "password": password
+        }
+
+        
+        try:
+            result = await self._client._terrakio_request("POST", "/users/signup", json=payload)
+        except Exception as e:
+            self._client.logger.info(f"Signup failed: {str(e)}")
+            raise APIError(f"Signup request failed: {str(e)}")
+            
+
+    async def login(self, email: str, password: str) -> Dict[str, str]:
+        """
+        Login a user with email and password.
+        
+        Args:
+            email: User's email address
+            password: User's password
+            
+        Returns:
+            Dict containing the authentication token
+            
+        Raises:
+            APIError: If the login request fails
+        """
+        payload = {
+            "email": email,
+            "password": password
+        }
+        
+        try:
+            result = await self._client._terrakio_request("POST", "/users/login", json=payload)
+            token_response = result.get("token")
+            
+            if token_response:
+                self._client.token = token_response
+
+                api_key_response = await self.view_api_key()
+                self._client.key = api_key_response
+ 
+                if not self._client.url:
+                    self._client.url = "https://api.terrak.io"
+                
+                self._save_config(email, token_response)
+                
+                self._client.logger.info(f"Successfully authenticated as: {email}")
+                self._client.logger.info(f"Using Terrakio API at: {self._client.url}")
+                
+            return {"token": token_response} if token_response else {"error": "Login failed"}
+            
+        except Exception as e:
+            self._client.logger.info(f"Login failed: {str(e)}")
+            raise APIError(f"Login request failed: {str(e)}")
+
+    @require_token
+    async def view_api_key(self) -> str:
+        """
+        View the current API key for the authenticated user.
+        
+        Returns:
+            str: The API key
+            
+        Raises:
+            APIError: If the API request fails
+        """
+        result = await self._client._terrakio_request("GET", "/users/key")
+        api_key = result.get("apiKey")
+        return api_key
+
+    @require_api_key
+    @require_token
+    async def refresh_api_key(self) -> str:
+        """
+        Refresh the API key for the authenticated user.
+        
+        Returns:
+            str: The new API key
+            
+        Raises:
+            APIError: If the API request fails
+        """
+        result = await self._client._terrakio_request("POST", "/users/refresh_key")
+        self._client.key = result.get("apiKey")
+                
+        self._update_config_key()
+        
+        return self._client.key
+
+    @require_api_key
+    def get_user_info(self) -> Dict[str, Any]:
+        """
+        Get information about the authenticated user.
+        
+        Returns:
+            Dict[str, Any]: User information
+            
+        Raises:
+            APIError: If the API request fails
+        """
+        return self._client._terrakio_request("GET", "/users/info")
+
+    def _save_config(self, email: str, token: str):
+        """
+        Helper method to save config file.
+        
+        Args:
+            email: User's email address
+            token: Authentication token
+        """
+        config_path = os.path.join(os.environ.get("HOME", ""), ".tkio_config.json")
+        
+        try:
+            config = {"EMAIL": email, "TERRAKIO_API_KEY": self._client.key}
+            if os.path.exists(config_path):
+                with open(config_path, 'r') as f:
+                    config = json.load(f)
+                    
+            config["EMAIL"] = email
+            config["TERRAKIO_API_KEY"] = self._client.key
+            config["PERSONAL_TOKEN"] = token
+            os.makedirs(os.path.dirname(config_path), exist_ok=True)
+            
+            with open(config_path, 'w') as f:
+                json.dump(config, f, indent=4)
+                
+            self._client.logger.info(f"API key saved to {config_path}")
+            
+        except Exception as e:
+            self._client.logger.info(f"Warning: Failed to update config file: {e}")
+
+    def _update_config_key(self):
+        """
+        Helper method to update just the API key in config.
+        """
+        config_path = os.path.join(os.environ.get("HOME", ""), ".tkio_config.json")
+        
+        try:
+            config = {"EMAIL": "", "TERRAKIO_API_KEY": ""}
+            
+            if os.path.exists(config_path):
+                with open(config_path, 'r') as f:
+                    config = json.load(f)
+                    
+            config["TERRAKIO_API_KEY"] = self._client.key
+            
+            os.makedirs(os.path.dirname(config_path), exist_ok=True)
+            
+            with open(config_path, 'w') as f:
+                json.dump(config, f, indent=4)
+                
+            self._client.logger.info(f"API key updated in {config_path}")
+            
+        except Exception as e:
+            self._client.logger.info(f"Warning: Failed to update config file: {e}")