terrakio-core 0.4.98__py3-none-any.whl → 0.4.98.1b3__py3-none-any.whl

terrakio_core/async_client.py

@@ -9,7 +9,7 @@ from geopandas import GeoDataFrame
 from shapely.geometry.base import BaseGeometry as ShapelyGeometry
 from shapely.geometry import mapping
 from .client import BaseClient
-from .exceptions import APIError
+from .exceptions import APIError, NetworkError
 from .endpoints.dataset_management import DatasetManagement
 from .endpoints.user_management import UserManagement
 from .endpoints.mass_stats import MassStats
@@ -36,13 +36,10 @@ class AsyncClient(BaseClient):
 
     async def _terrakio_request(self, method: str, endpoint: str, **kwargs):
         if self.session is None:
-            # To this:
             headers = {
                 'x-api-key': self.key, 
                 'Authorization': self.token
             }
-
-            # Only add Content-Type if it's a JSON request
             if 'json' in kwargs:
                 headers['Content-Type'] = 'application/json'
             clean_headers = {k: v for k, v in headers.items() if v is not None}
@@ -57,20 +54,17 @@ class AsyncClient(BaseClient):
         for attempt in range(self.retry + 1):
             try:
                 async with session.request(method, url, **kwargs) as response:
+                    content = await response.text()
+                    
                     if not response.ok and self._should_retry(response.status, attempt):
                         self.logger.info(f"Request failed (attempt {attempt+1}/{self.retry+1}): {response.status}. Retrying...")
                         continue
-                    if not response.ok:
-                        error_msg = f"API request failed: {response.status} {response.reason}"
-                        try:
-                            error_data = await response.json()
-                            if "detail" in error_data:
-                                error_msg += f" - {error_data['detail']}"
-                        except:
-                            pass
-                        raise APIError(error_msg, status_code=response.status)
-                    return await self._parse_response(response)
-                    
+                    if response.ok:
+                        data = await self._parse_response(response)
+                        return data, response.status
+                    else:
+                        error_data = await response.json()
+                        return error_data, response.status
             except aiohttp.ClientError as e:
                 last_exception = e
                 if attempt < self.retry:
@@ -78,8 +72,8 @@ class AsyncClient(BaseClient):
                     continue
                 else:
                     break
-        
-        raise APIError(f"Networking error, request failed after {self.retry+1} attempts: {last_exception}", status_code=None)
+
+        raise NetworkError(f"Network failure after {self.retry+1} attempts: {last_exception}")
     
     def _should_retry(self, status_code: int, attempt: int) -> bool:
         """Determine if the request should be retried based on status code."""
@@ -193,158 +187,21 @@ class AsyncClient(BaseClient):
 
         return result
 
-    async def zonal_stats(
-            self,
-            gdf: GeoDataFrame,
-            expr: str,
-            conc: int = 20,
-            in_crs: str = "epsg:4326",
-            out_crs: str = "epsg:4326",
-            resolution: int = -1,
-            geom_fix: bool = False,
-            mass_stats: bool = False,
-            id_column: Optional[str] = None,
-    ):
-        """
-        Compute zonal statistics for all geometries in a GeoDataFrame.
-
-        Args:
-            gdf (GeoDataFrame): GeoDataFrame containing geometries
-            expr (str): Terrakio expression to evaluate, can include spatial aggregations
-            conc (int): Number of concurrent requests to make
-            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)
-            mass_stats (bool): Whether to use mass stats for processing (default False)
-            id_column (Optional[str]): Name of the ID column to use (default None)
-
-        Returns:
-            geopandas.GeoDataFrame: GeoDataFrame with added columns for results
-
-        Raises:
-            ValueError: If concurrency is too high or if data exceeds memory limit without streaming
-            APIError: If the API request fails
-        """
-        # the sync client didn't pass the self here, so the client is now async
-        return await _zonal_stats(
-            client=self,
-            gdf=gdf,
-            expr=expr,
-            conc=conc,
-            in_crs=in_crs,
-            out_crs=out_crs,
-            resolution=resolution,
-            geom_fix=geom_fix,
-            mass_stats=mass_stats,
-            id_column=id_column,
-        )
-
-    async def create_dataset_file(
-        self,
-        name: str,
-        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",
-        mask = True,
-        max_file_size_mb: int = 5120,  # Default to 5GB
-        tile_size: int = 1024,
-    ) -> dict:
-        """
-        Create a dataset file using mass stats operations.
-
-        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
-        """
-        return await _create_dataset_file(
-            client=self,
-            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,
-            name=name,
-            mask=mask,
-            max_file_size_mb=max_file_size_mb,
-            tile_size=tile_size
-        )
-
-    async def geo_queries(
-        self,
-        queries: list[dict],
-        conc: int = 20,
-    ):
-        """
-        Execute multiple geo queries concurrently.
-
-        Args:
-            queries (list[dict]): List of dictionaries containing query parameters.
-                                  Each query must have 'expr', 'feature', and 'in_crs' keys.
-            conc (int): Number of concurrent requests to make (default 20, max 100)
-
-        Returns:
-            Union[float, geopandas.GeoDataFrame]: 
-                - float: Average of all results if results are integers
-                - GeoDataFrame: GeoDataFrame with geometry and dataset columns if results are xarray datasets
-
-        Raises:
-            ValueError: If queries list is empty, concurrency is too high, or queries are malformed
-            APIError: If the API request fails
-
-        Example:
-            queries = [
-                {
-                    'expr': 'WCF.wcf',
-                    'feature': {'type': 'Feature', 'geometry': {...}, 'properties': {}},
-                    'in_crs': 'epsg:4326'
-                },
-                {
-                    'expr': 'NDVI.ndvi',
-                    'feature': {'type': 'Feature', 'geometry': {...}, 'properties': {}},
-                    'in_crs': 'epsg:4326'
-                }
-            ]
-            result = await client.geo_queries(queries)
-        """
-        return await _request_geoquery_list(
-            client=self,
-            quries=queries,  # Note: keeping original parameter name for compatibility
-            conc=conc,
-        )
+    async def zonal_stats(self, *args, **kwargs):
+        """Proxy to convenience zonal_stats with full argument passthrough."""
+        return await _zonal_stats(self, *args, **kwargs)
+
+    async def create_dataset_file(self, *args, **kwargs) -> dict:
+        """Proxy to convenience create_dataset_file with full argument passthrough."""
+        kwargs.setdefault('download_path', "/home/user/Downloads")
+        kwargs.setdefault('region', "aus")
+        return await _create_dataset_file(self, *args, **kwargs)
+
+    async def geo_queries(self, *args, **kwargs):
+        """Proxy to convenience request_geoquery_list with full argument passthrough."""
+        if 'queries' in kwargs:
+            kwargs['quries'] = kwargs.pop('queries')
+        return await _request_geoquery_list(self, *args, **kwargs)
 
     async def __aenter__(self):
         if self._session is None:

terrakio_core/config.py

@@ -7,7 +7,7 @@ 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"
+DEFAULT_API_URL = "https://dev-au.terrak.io"
 
 def read_config_file(config_file: str = DEFAULT_CONFIG_FILE, logger: logging.Logger = None) -> Dict[str, Any]:
     """
@@ -27,14 +27,8 @@ def read_config_file(config_file: str = DEFAULT_CONFIG_FILE, logger: logging.Log
         file if one doesn't exist and returns appropriate status flags.
     """
     config_path = Path(os.path.expanduser(config_file))
-    # the first circumstance is that the config file does not exist
-    # that we need to login before using any of the functions
-    # Check if config file exists
+    
     if not config_path.exists():
-        # Create an empty config file
-        config_path.parent.mkdir(parents=True, exist_ok=True)
-        with open(config_path, 'w') as f:
-            json.dump({}, f)
         logger.info("No API key found. Please provide an API key to use this client.")
         return {
             'url': DEFAULT_API_URL,
@@ -45,12 +39,9 @@ def read_config_file(config_file: str = DEFAULT_CONFIG_FILE, logger: logging.Log
         }
     
     try:
-        # Read the config file
         with open(config_path, 'r') as f:
             config_data = json.load(f)
         
-        # 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'):
             logger.info("No API key found. Please provide an API key to use this client.")
             return {
@@ -61,11 +52,8 @@ def read_config_file(config_file: str = DEFAULT_CONFIG_FILE, logger: logging.Log
                 'token': config_data.get('PERSONAL_TOKEN')
             }
         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
         config = {
-            # Always use the default URL, not from config file
             'url': DEFAULT_API_URL,
             'key': config_data.get('TERRAKIO_API_KEY'),
             'is_logged_in': True,
@@ -84,33 +72,4 @@ def read_config_file(config_file: str = DEFAULT_CONFIG_FILE, logger: logging.Log
             'is_logged_in': False,
             'user_email': None,
             'token': None
-        }
-
-def create_default_config(email: str, api_key: str, config_file: str = DEFAULT_CONFIG_FILE) -> None:
-    """
-    Create a default configuration file in JSON format.
-    
-    Args:
-        email: User email
-        api_key: Terrakio API key
-        config_file: Path to configuration file
-        
-    Raises:
-        ConfigurationError: If the configuration file can't be created
-    """
-    config_path = Path(os.path.expanduser(config_file))
-    
-    # Ensure directory exists
-    config_path.parent.mkdir(parents=True, exist_ok=True)
-    
-    try:
-        config_data = {
-            "EMAIL": email,
-            "TERRAKIO_API_KEY": api_key
-        }
-        
-        with open(config_path, 'w') as f:
-            json.dump(config_data, f, indent=2)
-            
-    except Exception as e:
-        raise ConfigurationError(f"Failed to create configuration file: {e}")
+        }

terrakio_core/endpoints/auth.py

@@ -1,8 +1,21 @@
-import os
 import json
-from typing import Dict, Any
-from ..exceptions import APIError
-from ..helper.decorators import require_token, require_api_key, require_auth
+import os
+from typing import Any, Dict
+
+from ..exceptions import (
+    APIKeyError,
+    AuthenticationExpireError,
+    InvalidUsernamePasswordError,
+    LoginError,
+    QuotaError,
+    RefreshAPIKeyError,
+    ResetPasswordError,
+    SignupError,
+    UserInfoError,
+    InvalidEmailFormatError,
+    EmailAlreadyExistsError,
+)
+from ..helper.decorators import require_api_key, require_auth, require_token
 
 class AuthClient:
     def __init__(self, client):
@@ -20,22 +33,23 @@ class AuthClient:
             Dict containing the authentication token
             
         Raises:
-            APIError: If the signup request fails
+            SignupError: If the signup request fails
         """
         payload = {
             "email": email,
             "password": password
         }
+        response, status = await self._client._terrakio_request("POST", "/users/signup", json=payload)
+        if status != 200:
+            if status == 422:
+                raise InvalidEmailFormatError(f"Invalid email format: {response}", status_code=status)
+            elif status == 409:
+                raise EmailAlreadyExistsError(f"Email already exists: {response}", status_code=status)
+            raise SignupError(f"Signup request failed: {response}", status_code=status)
+        else:
+            return response
 
-        
-        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]:
+    async def login(self, email: str, password: str) -> None:
         """
         Login a user with email and password.
         
@@ -44,7 +58,7 @@ class AuthClient:
             password: User's password
             
         Returns:
-            Dict containing the authentication token
+            None
             
         Raises:
             APIError: If the login request fails
@@ -53,10 +67,14 @@ class AuthClient:
             "email": email,
             "password": password
         }
-        
-        try:
-            result = await self._client._terrakio_request("POST", "/users/login", json=payload)
-            token_response = result.get("token")
+        response, status = await self._client._terrakio_request("POST", "/users/login", json=payload)
+        if status != 200:
+            if status == 401:
+                raise InvalidUsernamePasswordError(f"Invalid username or password: {response}", status_code=status)
+            else:
+                raise LoginError(f"Login request failed: {response}", status_code=status)
+        else:
+            token_response = response.get("token")
             
             if token_response:
                 self._client.token = token_response
@@ -72,11 +90,6 @@ class AuthClient:
                 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:
@@ -87,11 +100,18 @@ class AuthClient:
             str: The API key
             
         Raises:
-            APIError: If the API request fails
+            AuthenticationExpireError: If authentication expired
+            APIKeyError: If the API key request fails
         """
-        result = await self._client._terrakio_request("GET", "/users/key")
-        api_key = result.get("apiKey")
-        return api_key
+        response, status = await self._client._terrakio_request("GET", "/users/key")
+        api_key = response.get("apiKey")
+        if status != 200:
+            if status == 400 and response.get("detail")["message"] == "Not authenticated":
+                raise AuthenticationExpireError(f"Authentication expired, please login again: {response}")
+            else:
+                raise APIKeyError(f"Error fetching API key: {response}", status_code=status)
+        else:
+            return api_key
 
     @require_api_key
     @require_token
@@ -103,17 +123,18 @@ class AuthClient:
             str: The new API key
             
         Raises:
-            APIError: If the API request fails
+            RefreshAPIKeyError: If the API key refresh 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
+        response, status = await self._client._terrakio_request("POST", "/users/refresh_key")
+        self._client.key = response.get("apiKey")
+        if status != 200:
+            raise RefreshAPIKeyError(f"Error refreshing API key: {response}", status_code=status)
+        else:
+            self._update_config_key()
+            return self._client.key
 
     @require_api_key
-    def get_user_info(self) -> Dict[str, Any]:
+    async def get_user_info(self) -> Dict[str, Any]:
         """
         Get information about the authenticated user.
         
@@ -121,9 +142,45 @@ class AuthClient:
             Dict[str, Any]: User information
             
         Raises:
-            APIError: If the API request fails
+            AuthenticationExpireError: If authentication expired
+            UserInfoError: If the user info request fails
         """
-        return self._client._terrakio_request("GET", "/users/info")
+        response, status = await self._client._terrakio_request("GET", "/users/info")
+        if status != 200:
+            if status == 400 and response.get("detail")["message"] == "Not authenticated":
+                raise AuthenticationExpireError(f"Authentication expired, please login again: {response}", status_code=status)
+            else:
+                raise UserInfoError(f"Error fetching user info: {response}", status_code=status)
+        else:
+            return response
+    
+    @require_api_key
+    async def reset_password(self, email : str) -> Dict[str, Any]:
+        """
+        Reset the password for a user by email.
+        """
+        response, status = await self._client._terrakio_request("GET", f"/users/reset-password?email={email}")
+        if status != 200:
+            raise ResetPasswordError(f"Error resetting password: {response}", status_code=status)
+        else:
+            return response['message']
+
+    @require_api_key
+    async def get_user_quota(self):
+        """
+        Get the user's quota.
+
+        Returns:
+            Dict: User's quota
+
+        Raises:
+            QuotaError: If the quota request fails
+        """
+        response, status = await self._client._terrakio_request("GET", "/users/quota")
+        if status != 200:
+            raise QuotaError(f"Error fetching quota: {response}", status_code = status)
+        else:
+            return response
 
     def _save_config(self, email: str, token: str):
         """
@@ -145,7 +202,6 @@ class AuthClient:
             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)
                 
@@ -177,11 +233,4 @@ class AuthClient:
             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}")
-
-
-# we have four different circumstances:
-# same expression, different region
-# same expression, same region
-# different expression, same region
-# different expression, different region
+            self._client.logger.info(f"Warning: Failed to update config file: {e}")