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

terrakio_core/__init__.py

@@ -4,4 +4,4 @@ Terrakio Core
 Core components for Terrakio API clients.
 """
 
-__version__ = "0.3.2"
+__version__ = "0.3.4"

terrakio_core/auth.py

@@ -127,12 +127,8 @@ class AuthClient:
             API key
         
         Raises:
-            ConfigurationError: If not authenticated
             APIError: If refresh fails
         """
-        if not self.token:
-            raise ConfigurationError("Not authenticated. Call login() first.")
-        
         endpoint = f"{self.base_url}/users/refresh_key"
         
         try:
@@ -167,14 +163,9 @@ class AuthClient:
             API key
         
         Raises:
-            ConfigurationError: If not authenticated
             APIError: If retrieval fails
         """
-        if not self.token:
-            raise ConfigurationError("Not authenticated. Call login() first.")
-        
         endpoint = f"{self.base_url}/users/key"
-        
         try:
             # Use session with updated headers from login
             response = self.session.get(
@@ -207,14 +198,9 @@ class AuthClient:
             User information data
         
         Raises:
-            ConfigurationError: If not authenticated
             APIError: If retrieval fails
         """
-        if not self.token:
-            raise ConfigurationError("Not authenticated. Call login() first.")
-        
         endpoint = f"{self.base_url}/users/info"
-        
         try:
             # Use session with updated headers from login
             response = self.session.get(
@@ -222,7 +208,6 @@ class AuthClient:
                 verify=self.verify,
                 timeout=self.timeout
             )
-            
             if not response.ok:
                 error_msg = f"Failed to retrieve user info: {response.status_code} {response.reason}"
                 try:

terrakio_core/client.py

@@ -2,6 +2,7 @@ import json
 import asyncio
 from io import BytesIO
 from typing import Dict, Any, Optional, Union
+from functools import wraps
 
 import requests
 import aiohttp
@@ -18,8 +19,39 @@ import logging
 import textwrap
 
 
+def require_api_key(func):
+    """
+    Decorator to ensure an API key is available before a method can be executed.
+    Will check for the presence of an API key before allowing the function to be called.
+    """
+    @wraps(func)
+    def wrapper(self, *args, **kwargs):
+        # Check if the API key is set
+        if not self.key:
+            error_msg = "No API key found. Please provide an API key to use this client."
+            if not self.quiet:
+                print(error_msg)
+                print("API key is required for this function.")
+                print("You can set an API key by either:")
+                print("1. Loading from a config file")
+                print("2. Using the login() method: client.login(email='your-email@example.com', password='your-password')")
+            raise ConfigurationError(error_msg)
+            
+        # Check if URL is set (required for API calls)
+        if not self.url:
+            if not self.quiet:
+                print("API URL is not set. Using default API URL: https://api.terrak.io")
+            self.url = "https://api.terrak.io"
+            
+        return func(self, *args, **kwargs)
+    
+    # Mark as decorated to avoid double decoration
+    wrapper._is_decorated = True
+    return wrapper
+
+
 class BaseClient:
-    def __init__(self, url: Optional[str] = None, key: Optional[str] = None, 
+    def __init__(self, url: Optional[str] = None,
                 auth_url: Optional[str] = "https://dev-au.terrak.io",
                 quiet: bool = False, config_file: Optional[str] = None,
                 verify: bool = True, timeout: int = 300):
@@ -28,57 +60,96 @@ class BaseClient:
         self.verify = verify
         self.timeout = timeout
         self.auth_client = None
-        if auth_url:
-            from terrakio_core.auth import AuthClient
-            self.auth_client = AuthClient(
-                base_url=auth_url,
-                verify=verify,
-                timeout=timeout
-            )
+        # Initialize session early to avoid AttributeError
+        self.session = requests.Session()
+        self.user_management = None
+        self.dataset_management = None
+        self.mass_stats = None
+        self._aiohttp_session = None
+        
+        # if auth_url:
+        #     from terrakio_core.auth import AuthClient
+        #     self.auth_client = AuthClient(
+        #         base_url=auth_url,
+        #         verify=verify,
+        #         timeout=timeout
+        #     )
         self.url = url
-        self.key = key
-        if self.url is None or self.key is None:
-            from terrakio_core.config import read_config_file, DEFAULT_CONFIG_FILE
-            if config_file is None:
-                config_file = DEFAULT_CONFIG_FILE
-            try:
-                config = read_config_file(config_file)
-                if self.url is None:
-                    self.url = config.get('url')
-                if self.key is None:
-                    self.key = config.get('key')
-            except Exception as e:
-                raise ConfigurationError(
-                    f"Failed to read configuration: {e}\n\n"
-                    "To fix this issue:\n"
-                    "1. Create a file at ~/.terrakioapirc with:\n"
-                    "url: https://api.terrak.io\n"
-                    "key: your-api-key\n\n"
-                    "OR\n\n"
-                    "2. Initialize the client with explicit parameters:\n"
-                    "client = terrakio_api.Client(\n"
-                    "    url='https://api.terrak.io',\n"
-                    "    key='your-api-key'\n"
-                    ")"
-                )
-        if not self.url:
-            raise ConfigurationError("Missing API URL in configuration")
+        self.key = None
+        
+        # Load configuration from file
+        from terrakio_core.config import read_config_file, DEFAULT_CONFIG_FILE
+        
+        if config_file is None:
+            config_file = DEFAULT_CONFIG_FILE
+        
+        # Get config using the read_config_file function that now handles all cases
+        config = read_config_file(config_file, quiet=self.quiet)
+        
+        # If URL is not provided, try to get it from config
+        if self.url is None:
+            self.url = config.get('url')
+            
+        # Get API key from config file (never from parameters)
+        self.key = config.get('key')
+
+        self.token = config.get('token')
+        
+        # Update auth_client with token if it exists
+        if self.auth_client and self.token:
+            self.auth_client.token = self.token
+            self.auth_client.session.headers.update({
+                "Authorization": self.token
+            })
+        
+        # If we have a key, we're good to go even if not logged in
+        if self.key:
+            # If URL is missing but we have a key, use the default URL
+            if not self.url:
+                self.url = "https://api.terrak.io"
+            print("the token is! ", self.token)
+            print("the key is! ", self.key)
+            # Update session headers with the key
+            headers = {
+                'Content-Type': 'application/json',
+                'x-api-key': self.key
+            }
+            
+            # Only add Authorization header if token exists and is not None
+            if self.token:
+                headers['Authorization'] = self.token
+                
+            self.session.headers.update(headers)
+            print("the session headers are ", self.session.headers)
+
+            
+            if not self.quiet and config.get('user_email'):
+                print(f"Using API key for: {config.get('user_email')}")
+                
+            return
+
+        # Check if we have the required configuration
         if not self.key:
-            raise ConfigurationError("Missing API key in configuration")
+            # No API key available - inform the user
+            if not self.quiet:
+                print("API key is required to use this client.")
+                print("You can set an API key by either:")
+                print("1. Loading from a config file")
+                print("2. Using the login() method: client.login(email='your-email@example.com', password='your-password')")
+            return
+            
         self.url = self.url.rstrip('/')
         if not self.quiet:
             print(f"Using Terrakio API at: {self.url}")
-        self.session = requests.Session()
+            
+        # Update the session headers with API key
         self.session.headers.update({
             'Content-Type': 'application/json',
             'x-api-key': self.key
         })
-        self.user_management = None
-        self.dataset_management = None
-        self.mass_stats = None
-        self._aiohttp_session = None
 
     @property
+    @require_api_key
     async def aiohttp_session(self):
         if self._aiohttp_session is None or self._aiohttp_session.closed:
             self._aiohttp_session = aiohttp.ClientSession(
@@ -90,6 +161,7 @@ class BaseClient:
             )
         return self._aiohttp_session
 
+    @require_api_key
     async def wcs_async(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, buffer: bool = False, 
@@ -130,7 +202,6 @@ class BaseClient:
             "resolution": resolution,
             **kwargs
         }
-        print("the payload is ", payload)
         request_url = f"{self.url}/geoquery"
         for attempt in range(retry + 1):
             try:
@@ -187,38 +258,67 @@ class BaseClient:
                     raise
                 continue
 
+    @require_api_key
     async def close_async(self):
         """Close the aiohttp session"""
         if self._aiohttp_session and not self._aiohttp_session.closed:
             await self._aiohttp_session.close()
             self._aiohttp_session = None
 
+    @require_api_key
     async def __aenter__(self):
         return self
 
+    @require_api_key
     async def __aexit__(self, exc_type, exc_val, exc_tb):
         await self.close_async()
 
     def signup(self, email: str, password: str) -> Dict[str, Any]:
         if not self.auth_client:
-            raise ConfigurationError("Authentication client not initialized. Please provide auth_url during client initialization.")
+            from terrakio_core.auth import AuthClient
+            self.auth_client = AuthClient(
+                base_url=self.url,
+                verify=self.verify,
+                timeout=self.timeout
+            )
+            self.auth_client.session = self.session
         return self.auth_client.signup(email, password)
 
     def login(self, email: str, password: str) -> Dict[str, str]:
+
         if not self.auth_client:
-            raise ConfigurationError("Authentication client not initialized. Please provide auth_url during client initialization.")
-        
+            from terrakio_core.auth import AuthClient
+            self.auth_client = AuthClient(
+                base_url=self.url,
+                verify=self.verify,
+                timeout=self.timeout
+            )
+            self.auth_client.session = self.session
         try:
             # First attempt to login
             token_response = self.auth_client.login(email, password)
             
-            print("the token response is ", token_response)
             # Only proceed with API key retrieval if login was successful
             if token_response:
                 # After successful login, get the API key
-                api_key_response = self.view_api_key()
+                api_key_response = self.auth_client.view_api_key()
                 self.key = api_key_response
                 
+                # Make sure URL is set
+                if not self.url:
+                    self.url = "https://api.terrak.io"
+                
+                # Make sure session headers are updated with the new key
+                self.session.headers.update({
+                    'Content-Type': 'application/json',
+                    'x-api-key': self.key
+                })
+                
+                # Set URL if not already set
+                if not self.url:
+                    self.url = "https://api.terrak.io"
+                    self.url = self.url.rstrip('/')
+                
                 # Save email and API key to config file
                 import os
                 import json
@@ -230,6 +330,7 @@ class BaseClient:
                             config = json.load(f)
                         config["EMAIL"] = email
                         config["TERRAKIO_API_KEY"] = self.key
+                        config["PERSONAL_TOKEN"] = token_response
                     
                     os.makedirs(os.path.dirname(config_path), exist_ok=True)
                     with open(config_path, 'w') as f:
@@ -237,6 +338,7 @@ class BaseClient:
                     
                     if not self.quiet:
                         print(f"Successfully authenticated as: {email}")
+                        print(f"Using Terrakio API at: {self.url}")
                         print(f"API key saved to {config_path}")
                 except Exception as e:
                     if not self.quiet:
@@ -248,47 +350,81 @@ class BaseClient:
                 print(f"Login failed: {str(e)}")
             raise
 
+    @require_api_key
     def refresh_api_key(self) -> str:
-        if not self.auth_client:
-            raise ConfigurationError("Authentication client not initialized. Please provide auth_url during client initialization.")
-        if not self.auth_client.token:
-            raise ConfigurationError("Not authenticated. Call login() first.")
-        self.key = self.auth_client.refresh_api_key()
-        self.session.headers.update({'x-api-key': self.key})
-        import os
-        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.key
-            os.makedirs(os.path.dirname(config_path), exist_ok=True)
-            with open(config_path, 'w') as f:
-                json.dump(config, f, indent=4)
-            if not self.quiet:
-                print(f"API key generated successfully and updated in {config_path}")
-        except Exception as e:
-            if not self.quiet:
-                print(f"Warning: Failed to update config file: {e}")
+        # If we have auth_client and it has a token, refresh the key
+        if self.auth_client and self.auth_client.token:
+            self.key = self.auth_client.refresh_api_key()
+            self.session.headers.update({'x-api-key': self.key})
+            
+            # Update the config file with the new key
+            import os
+            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.key
+                os.makedirs(os.path.dirname(config_path), exist_ok=True)
+                with open(config_path, 'w') as f:
+                    json.dump(config, f, indent=4)
+                if not self.quiet:
+                    print(f"API key generated successfully and updated in {config_path}")
+            except Exception as e:
+                if not self.quiet:
+                    print(f"Warning: Failed to update config file: {e}")
+            return self.key
+        else:
+            # If we don't have auth_client with a token but have a key already, return it
+            if self.key:
+                if not self.quiet:
+                    print("Using existing API key from config file.")
+                return self.key
+            else:
+                raise ConfigurationError("No authentication token available. Please login first to refresh the API key.")
+
+    @require_api_key
+    def view_api_key(self) -> str:
+        # If we have the auth client and token, refresh the key
+        if self.auth_client and self.auth_client.token:
+            self.key = self.auth_client.view_api_key()
+            self.session.headers.update({'x-api-key': self.key})
+        
         return self.key
 
+    @require_api_key
     def view_api_key(self) -> str:
+        # If we have the auth client and token, refresh the key
         if not self.auth_client:
-            raise ConfigurationError("Authentication client not initialized. Please provide auth_url during client initialization.")
-        if not self.auth_client.token:
-            raise ConfigurationError("Not authenticated. Call login() first.")
-        self.key = self.auth_client.view_api_key()
-        self.session.headers.update({'x-api-key': self.key})
-        return self.key
+            from terrakio_core.auth import AuthClient
+            self.auth_client = AuthClient(
+                base_url=self.url,
+                verify=self.verify,
+                timeout=self.timeout
+            )
+            self.auth_client.session = self.session
+        return self.auth_client.view_api_key()
 
+    # @require_api_key
+    # def get_user_info(self) -> Dict[str, Any]:
+    #     return self.auth_client.get_user_info()
+    @require_api_key
     def get_user_info(self) -> Dict[str, Any]:
+        # Initialize auth_client if it doesn't exist
         if not self.auth_client:
-            raise ConfigurationError("Authentication client not initialized. Please provide auth_url during client initialization.")
-        if not self.auth_client.token:
-            raise ConfigurationError("Not authenticated. Call login() first.")
+            from terrakio_core.auth import AuthClient
+            self.auth_client = AuthClient(
+                base_url=self.url,
+                verify=self.verify,
+                timeout=self.timeout
+            )
+            # Use the same session as the base client
+            self.auth_client.session = self.session
+            
         return self.auth_client.get_user_info()
 
+    @require_api_key
     def wcs(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,
             **kwargs):
@@ -310,8 +446,6 @@ class BaseClient:
         }
         request_url = f"{self.url}/geoquery"
         try:
-            print("the request url is ", request_url)
-            print("the payload is ", payload)
             response = self.session.post(request_url, json=payload, timeout=self.timeout, verify=self.verify)
             print("the response is ", response.text)
             if not response.ok:
@@ -341,6 +475,7 @@ class BaseClient:
             raise APIError(f"Request failed: {str(e)}")
 
     # Admin/protected methods
+    @require_api_key
     def _get_user_by_id(self, user_id: str):
         if not self.user_management:
             from terrakio_core.user_management import UserManagement
@@ -354,6 +489,7 @@ class BaseClient:
             )
         return self.user_management.get_user_by_id(user_id)
 
+    @require_api_key
     def _get_user_by_email(self, email: str):
         if not self.user_management:
             from terrakio_core.user_management import UserManagement
@@ -367,6 +503,7 @@ class BaseClient:
             )
         return self.user_management.get_user_by_email(email)
 
+    @require_api_key
     def _list_users(self, substring: str = None, uid: bool = False):
         if not self.user_management:
             from terrakio_core.user_management import UserManagement
@@ -380,6 +517,7 @@ class BaseClient:
             )
         return self.user_management.list_users(substring=substring, uid=uid)
 
+    @require_api_key
     def _edit_user(self, user_id: str, uid: str = None, email: str = None, role: str = None, apiKey: str = None, groups: list = None, quota: int = None):
         if not self.user_management:
             from terrakio_core.user_management import UserManagement
@@ -401,6 +539,7 @@ class BaseClient:
             quota=quota
         )
 
+    @require_api_key
     def _reset_quota(self, email: str, quota: int = None):
         if not self.user_management:
             from terrakio_core.user_management import UserManagement
@@ -414,6 +553,7 @@ class BaseClient:
             )
         return self.user_management.reset_quota(email=email, quota=quota)
 
+    @require_api_key
     def _delete_user(self, uid: str):
         if not self.user_management:
             from terrakio_core.user_management import UserManagement
@@ -428,6 +568,7 @@ class BaseClient:
         return self.user_management.delete_user(uid=uid)
 
     # Dataset management protected methods
+    @require_api_key
     def _get_dataset(self, name: str, collection: str = "terrakio-datasets"):
         if not self.dataset_management:
             from terrakio_core.dataset_management import DatasetManagement
@@ -441,6 +582,7 @@ class BaseClient:
             )
         return self.dataset_management.get_dataset(name=name, collection=collection)
 
+    @require_api_key
     def _list_datasets(self, substring: str = None, collection: str = "terrakio-datasets"):
         if not self.dataset_management:
             from terrakio_core.dataset_management import DatasetManagement
@@ -454,6 +596,7 @@ class BaseClient:
             )
         return self.dataset_management.list_datasets(substring=substring, collection=collection)
 
+    @require_api_key
     def _create_dataset(self, name: str, collection: str = "terrakio-datasets", **kwargs):
         if not self.dataset_management:
             from terrakio_core.dataset_management import DatasetManagement
@@ -467,6 +610,7 @@ class BaseClient:
             )
         return self.dataset_management.create_dataset(name=name, collection=collection, **kwargs)
 
+    @require_api_key
     def _update_dataset(self, name: str, append: bool = True, collection: str = "terrakio-datasets", **kwargs):
         if not self.dataset_management:
             from terrakio_core.dataset_management import DatasetManagement
@@ -480,6 +624,7 @@ class BaseClient:
             )
         return self.dataset_management.update_dataset(name=name, append=append, collection=collection, **kwargs)
 
+    @require_api_key
     def _overwrite_dataset(self, name: str, collection: str = "terrakio-datasets", **kwargs):
         if not self.dataset_management:
             from terrakio_core.dataset_management import DatasetManagement
@@ -493,6 +638,7 @@ class BaseClient:
             )
         return self.dataset_management.overwrite_dataset(name=name, collection=collection, **kwargs)
 
+    @require_api_key
     def _delete_dataset(self, name: str, collection: str = "terrakio-datasets"):
         if not self.dataset_management:
             from terrakio_core.dataset_management import DatasetManagement
@@ -506,6 +652,7 @@ class BaseClient:
             )
         return self.dataset_management.delete_dataset(name=name, collection=collection)
 
+    @require_api_key
     def close(self):
         """Close all client sessions"""
         self.session.close()
@@ -532,13 +679,16 @@ class BaseClient:
                 # Event loop may already be closed, ignore
                 pass
 
+    @require_api_key
     def __enter__(self):
         return self
 
+    @require_api_key
     def __exit__(self, exc_type, exc_val, exc_tb):
         self.close()
 
     @admin_only_params('location', 'force_loc', 'server')
+    @require_api_key
     def execute_job(self, name, region, output, config, overwrite=False, skip_existing=False, request_json=None, manifest_json=None, location=None, force_loc=None, server="dev-au.terrak.io"):
         if not self.mass_stats:
             from terrakio_core.mass_stats import MassStats
@@ -553,6 +703,7 @@ class BaseClient:
         return self.mass_stats.execute_job(name, region, output, config, overwrite, skip_existing, request_json, manifest_json, location, force_loc, server)
 
 
+    @require_api_key
     def get_mass_stats_task_id(self, name, stage, uid=None):
         if not self.mass_stats:
             from terrakio_core.mass_stats import MassStats
@@ -566,6 +717,7 @@ class BaseClient:
             )
         return self.mass_stats.get_task_id(name, stage, uid)
 
+    @require_api_key
     def track_mass_stats_job(self, ids: Optional[list] = None):
         if not self.mass_stats:
             from terrakio_core.mass_stats import MassStats
@@ -579,6 +731,7 @@ class BaseClient:
             )
         return self.mass_stats.track_job(ids)
 
+    @require_api_key
     def get_mass_stats_history(self, limit=100):
         if not self.mass_stats:
             from terrakio_core.mass_stats import MassStats
@@ -592,6 +745,7 @@ class BaseClient:
             )
         return self.mass_stats.get_history(limit)
 
+    @require_api_key
     def start_mass_stats_post_processing(self, process_name, data_name, output, consumer_path, overwrite=False):
         if not self.mass_stats:
             from terrakio_core.mass_stats import MassStats
@@ -605,6 +759,7 @@ class BaseClient:
             )
         return self.mass_stats.start_post_processing(process_name, data_name, output, consumer_path, overwrite)
 
+    @require_api_key
     def download_mass_stats_results(self, id=None, force_loc=False, **kwargs):
         if not self.mass_stats:
             from terrakio_core.mass_stats import MassStats
@@ -618,6 +773,7 @@ class BaseClient:
             )
         return self.mass_stats.download_results(id, force_loc, **kwargs)
 
+    @require_api_key
     def cancel_mass_stats_job(self, id):
         if not self.mass_stats:
             from terrakio_core.mass_stats import MassStats
@@ -631,6 +787,7 @@ class BaseClient:
             )
         return self.mass_stats.cancel_job(id)
 
+    @require_api_key
     def cancel_all_mass_stats_jobs(self):
         if not self.mass_stats:
             from terrakio_core.mass_stats import MassStats
@@ -644,6 +801,7 @@ class BaseClient:
             )
         return self.mass_stats.cancel_all_jobs()
 
+    @require_api_key
     def _create_pyramids(self, name, levels, config):
         if not self.mass_stats:
             from terrakio_core.mass_stats import MassStats
@@ -657,6 +815,7 @@ class BaseClient:
             )
         return self.mass_stats.create_pyramids(name, levels, config)
 
+    @require_api_key
     def random_sample(self, name, **kwargs):
         if not self.mass_stats:
             from terrakio_core.mass_stats import MassStats
@@ -670,6 +829,7 @@ class BaseClient:
             )
         return self.mass_stats.random_sample(name, **kwargs)
 
+    @require_api_key
     async def zonal_stats_async(self, gdb, expr, conc=20, inplace=False, output="csv", 
                                in_crs="epsg:4326", out_crs="epsg:4326", resolution=-1, buffer=False):
         """
@@ -858,6 +1018,7 @@ class BaseClient:
             else:
                 return result_gdf
 
+    @require_api_key
     def zonal_stats(self, gdb, expr, conc=20, inplace=False, output="csv", 
                    in_crs="epsg:4326", out_crs="epsg:4326", resolution=-1, buffer=False):
         """
@@ -920,75 +1081,80 @@ class BaseClient:
         return result
 
     # Group access management protected methods
+    @require_api_key
     def _get_group_users_and_datasets(self, group_name: str):
-        if not hasattr(self, "group_access_management") or self.group_access_management is None:
+        if not self.group_access:
             from terrakio_core.group_access_management import GroupAccessManagement
             if not self.url or not self.key:
                 raise ConfigurationError("Group access management client not initialized. Make sure API URL and key are set.")
-            self.group_access_management = GroupAccessManagement(
+            self.group_access = GroupAccessManagement(
                 api_url=self.url,
                 api_key=self.key,
                 verify=self.verify,
                 timeout=self.timeout
             )
-        return self.group_access_management.get_group_users_and_datasets(group_name)
+        return self.group_access.get_group_users_and_datasets(group_name=group_name)
 
+    @require_api_key
     def _add_group_to_dataset(self, dataset: str, group: str):
-        if not hasattr(self, "group_access_management") or self.group_access_management is None:
+        if not self.group_access:
             from terrakio_core.group_access_management import GroupAccessManagement
             if not self.url or not self.key:
                 raise ConfigurationError("Group access management client not initialized. Make sure API URL and key are set.")
-            self.group_access_management = GroupAccessManagement(
+            self.group_access = GroupAccessManagement(
                 api_url=self.url,
                 api_key=self.key,
                 verify=self.verify,
                 timeout=self.timeout
             )
-        return self.group_access_management.add_group_to_dataset(dataset, group)
+        return self.group_access.add_group_to_dataset(dataset=dataset, group=group)
 
+    @require_api_key
     def _add_group_to_user(self, uid: str, group: str):
-        if not hasattr(self, "group_access_management") or self.group_access_management is None:
+        if not self.group_access:
             from terrakio_core.group_access_management import GroupAccessManagement
             if not self.url or not self.key:
                 raise ConfigurationError("Group access management client not initialized. Make sure API URL and key are set.")
-            self.group_access_management = GroupAccessManagement(
+            self.group_access = GroupAccessManagement(
                 api_url=self.url,
                 api_key=self.key,
                 verify=self.verify,
                 timeout=self.timeout
             )
-        print("the uid is and the group is ", uid, group)
-        return self.group_access_management.add_group_to_user(uid, group)
+        return self.group_access.add_group_to_user(uid=uid, group=group)
 
+    @require_api_key
     def _delete_group_from_user(self, uid: str, group: str):
-        if not hasattr(self, "group_access_management") or self.group_access_management is None:
+        if not self.group_access:
             from terrakio_core.group_access_management import GroupAccessManagement
             if not self.url or not self.key:
                 raise ConfigurationError("Group access management client not initialized. Make sure API URL and key are set.")
-            self.group_access_management = GroupAccessManagement(
+            self.group_access = GroupAccessManagement(
                 api_url=self.url,
                 api_key=self.key,
                 verify=self.verify,
                 timeout=self.timeout
             )
-        return self.group_access_management.delete_group_from_user(uid, group)
+        return self.group_access.delete_group_from_user(uid=uid, group=group)
 
+    @require_api_key
     def _delete_group_from_dataset(self, dataset: str, group: str):
-        if not hasattr(self, "group_access_management") or self.group_access_management is None:
+        if not self.group_access:
             from terrakio_core.group_access_management import GroupAccessManagement
             if not self.url or not self.key:
                 raise ConfigurationError("Group access management client not initialized. Make sure API URL and key are set.")
-            self.group_access_management = GroupAccessManagement(
+            self.group_access = GroupAccessManagement(
                 api_url=self.url,
                 api_key=self.key,
                 verify=self.verify,
                 timeout=self.timeout
             )
-        return self.group_access_management.delete_group_from_dataset(dataset, group)
+        return self.group_access.delete_group_from_dataset(dataset=dataset, group=group)
 
     # Space management protected methods
+    @require_api_key
     def _get_total_space_used(self):
-        if not hasattr(self, "space_management") or self.space_management is None:
+        if not self.space_management:
             from terrakio_core.space_management import SpaceManagement
             if not self.url or not self.key:
                 raise ConfigurationError("Space management client not initialized. Make sure API URL and key are set.")
@@ -1000,8 +1166,9 @@ class BaseClient:
             )
         return self.space_management.get_total_space_used()
 
+    @require_api_key
     def _get_space_used_by_job(self, name: str, region: str = None):
-        if not hasattr(self, "space_management") or self.space_management is None:
+        if not self.space_management:
             from terrakio_core.space_management import SpaceManagement
             if not self.url or not self.key:
                 raise ConfigurationError("Space management client not initialized. Make sure API URL and key are set.")
@@ -1013,8 +1180,9 @@ class BaseClient:
             )
         return self.space_management.get_space_used_by_job(name, region)
 
+    @require_api_key
     def _delete_user_job(self, name: str, region: str = None):
-        if not hasattr(self, "space_management") or self.space_management is None:
+        if not self.space_management:
             from terrakio_core.space_management import SpaceManagement
             if not self.url or not self.key:
                 raise ConfigurationError("Space management client not initialized. Make sure API URL and key are set.")
@@ -1026,8 +1194,9 @@ class BaseClient:
             )
         return self.space_management.delete_user_job(name, region)
 
+    @require_api_key
     def _delete_data_in_path(self, path: str, region: str = None):
-        if not hasattr(self, "space_management") or self.space_management is None:
+        if not self.space_management:
             from terrakio_core.space_management import SpaceManagement
             if not self.url or not self.key:
                 raise ConfigurationError("Space management client not initialized. Make sure API URL and key are set.")
@@ -1039,6 +1208,7 @@ class BaseClient:
             )
         return self.space_management.delete_data_in_path(path, region)
     
+    @require_api_key
     def start_mass_stats_job(self, task_id):
         if not self.mass_stats:
             from terrakio_core.mass_stats import MassStats
@@ -1053,6 +1223,7 @@ class BaseClient:
         return self.mass_stats.start_job(task_id)
 
     
+    @require_api_key
     def generate_ai_dataset(
         self,
         name: str,
@@ -1147,6 +1318,7 @@ class BaseClient:
         # print("the task id is ", task_id)
         return task_id
 
+    @require_api_key
     def train_model(self, model_name: str, training_dataset: str, task_type: str, model_category: str, architecture: str, region: str, hyperparameters: dict = None) -> dict:
         """
         Train a model using the external model training API.
@@ -1173,7 +1345,6 @@ class BaseClient:
             "hyperparameters": hyperparameters
         }
         endpoint = f"{self.url.rstrip('/')}/train_model"
-        print("the payload is ", payload)
         try:
             response = self.session.post(endpoint, json=payload, timeout=self.timeout, verify=self.verify)
             if not response.ok:
@@ -1191,6 +1362,7 @@ class BaseClient:
             raise APIError(f"Model training request failed: {str(e)}")
 
     # Mass Stats methods
+    @require_api_key
     def combine_tiles(self, 
         data_name: str,
         usezarr: bool,
@@ -1211,6 +1383,7 @@ class BaseClient:
     
 
 
+    @require_api_key
     def create_dataset_file(
         self,
         name: str,
@@ -1226,9 +1399,22 @@ class BaseClient:
         skip_existing: bool = False,
         non_interactive: bool = True,
         usezarr: bool = False,
-        poll_interval: int = 30   # seconds between job status checks
+        poll_interval: int = 30,
+        download_path: str = "/home/user/Downloads",
     ) -> dict:
         
+        if not self.mass_stats:
+            from terrakio_core.mass_stats import MassStats
+            if not self.url or not self.key:
+                raise ConfigurationError("Mass Stats client not initialized. Make sure API URL and key are set.")
+            self.mass_stats = MassStats(
+                base_url=self.url,
+                api_key=self.key,
+                verify=self.verify,
+                timeout=self.timeout
+            )
+        
+        
         from terrakio_core.generation.tiles import tiles
         import tempfile
         import time
@@ -1317,26 +1503,60 @@ class BaseClient:
         os.unlink(tempmanifestname)
 
 
+        # return self.mass_stats.combine_tiles(body["name"], usezarr, body["overwrite"], body["output"])
+    
         # Start combining tiles
-        if not self.mass_stats:
-            from terrakio_core.mass_stats import MassStats
-            if not self.url or not self.key:
-                raise ConfigurationError("Mass Stats client not initialized. Make sure API URL and key are set.")
-            self.mass_stats = MassStats(
-                base_url=self.url,
-                api_key=self.key,
-                verify=self.verify,
-                timeout=self.timeout
-            )
-        
-        return self.mass_stats.combine_tiles(body["name"], usezarr, body["overwrite"], body["output"])
+        combine_result = self.mass_stats.combine_tiles(body["name"], usezarr, body["overwrite"], body["output"])
+        combine_task_id = combine_result.get("task_id")
+
+        # Poll combine_tiles job status
+        combine_start_time = time.time()
+        while True:
+            try:
+                trackinfo = self.mass_stats.track_job([combine_task_id])
+                download_file_name = trackinfo[combine_task_id]['folder'] + '.nc'
+                bucket = trackinfo[combine_task_id]['bucket']
+                combine_status = trackinfo[combine_task_id]['status']
+                if combine_status == 'Completed':
+                    print('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
+                    print(f"Combine job status: {combine_status} - Elapsed time: {elapsed_time:.1f}s", end='\r')
+                    time.sleep(poll_interval)
+            except KeyboardInterrupt:
+                print(f"\nInterrupted! Combine job {combine_task_id} is still running in the background.")
+                raise
+            except Exception as e:
+                print(f"\nError tracking combine job: {e}")
+                raise
+
+        # Download the resulting file
+        if download_path:
+            self.mass_stats.download_file(body["name"], bucket, download_file_name, download_path)
+        else:
+            path = f"{body['name']}/combinedOutput/{download_file_name}"
+            print(f"Combined file is available at {path}")
+
+        return {"generation_task_id": task_id, "combine_task_id": combine_task_id}
+
+
+        # taskid = self.mass_stats.get_task_id(job_name, stage).get('task_id')
+        # trackinfo = self.mass_stats.track_job([taskid])
+        # bucket = trackinfo[taskid]['bucket']
+        # return self.mass_stats.download_file(job_name, bucket, file_name, output_path)
 
+
+    @require_api_key
     def deploy_model(self, dataset: str, product:str, model_name:str, input_expression: str, model_training_job_name: str, uid: str, dates_iso8601: list):
         script_content = self._generate_script(model_name, product, model_training_job_name, uid)
         script_name = f"{product}.py"
         self._upload_script_to_bucket(script_content, script_name, model_training_job_name, uid)
         self._create_dataset(name = dataset, collection = "terrakio-datasets", products = [product], path = f"gs://terrakio-mass-requests/{uid}/{model_training_job_name}/inference_scripts", input = input_expression, dates_iso8601 = dates_iso8601, padding = 0)
 
+    @require_api_key
     def _generate_script(self, model_name: str, product: str, model_training_job_name: str, uid: str) -> str:
         return textwrap.dedent(f'''
             import logging
@@ -1443,6 +1663,7 @@ class BaseClient:
                 return result
             ''').strip()
     
+    @require_api_key
     def _upload_script_to_bucket(self, script_content: str, script_name: str, model_training_job_name: str, uid: str):
         """Upload the generated script to Google Cloud Storage"""
 
@@ -1455,6 +1676,7 @@ class BaseClient:
 
 
 
+    @require_api_key
     def download_file_to_path(self, job_name, stage, file_name, output_path):
         if not self.mass_stats:
             from terrakio_core.mass_stats import MassStats
@@ -1472,4 +1694,34 @@ class BaseClient:
         taskid = self.mass_stats.get_task_id(job_name, stage).get('task_id')
         trackinfo = self.mass_stats.track_job([taskid])
         bucket = trackinfo[taskid]['bucket']
-        return self.mass_stats.download_file(job_name, bucket, file_name, output_path)
+        return self.mass_stats.download_file(job_name, bucket, file_name, output_path)
+
+
+# Apply the @require_api_key decorator to ALL methods in BaseClient
+# except only the absolute minimum that shouldn't require auth
+def _apply_api_key_decorator():
+    # Only these methods can be used without API key
+    skip_auth_methods = [
+        '__init__', 'login', 'signup'
+    ]
+    
+    # Get all attributes of BaseClient
+    for attr_name in dir(BaseClient):
+        # Skip special methods and methods in skip list
+        if attr_name.startswith('__') and attr_name not in ['__enter__', '__exit__', '__aenter__', '__aexit__'] or attr_name in skip_auth_methods:
+            continue
+            
+        # Get the attribute
+        attr = getattr(BaseClient, attr_name)
+        
+        # Skip if not callable (not a method) or already decorated
+        if not callable(attr) or hasattr(attr, '_is_decorated'):
+            continue
+            
+        # Apply decorator to EVERY method not in skip list
+        setattr(BaseClient, attr_name, require_api_key(attr))
+        # Mark as decorated to avoid double decoration
+        getattr(BaseClient, attr_name)._is_decorated = True
+
+# Run the decorator application
+_apply_api_key_decorator()

terrakio_core/config.py

@@ -9,51 +9,97 @@ from .exceptions import ConfigurationError
 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) -> Dict[str, Any]:
+def read_config_file(config_file: str = DEFAULT_CONFIG_FILE, quiet: bool = False) -> Dict[str, Any]:
     """
     Read and parse the configuration file.
     
     Args:
         config_file: Path to the configuration file
+        quiet: If True, suppress informational messages
         
     Returns:
-        Dict[str, Any]: Configuration parameters
+        Dict[str, Any]: Configuration parameters with additional flags:
+                       'is_logged_in': True if user is logged in
+                       'user_email': The email of the logged in user
+                       'token': Personal token if available
         
-    Raises:
-        ConfigurationError: If the configuration file can't be read or parsed
+    Note:
+        This function no longer raises ConfigurationError. Instead, it creates an empty config
+        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():
-        raise ConfigurationError(
-            f"Configuration file not found: {config_file}\n"
-            f"Please create a file at {config_file} with the following format:\n"
-            '{\n  "EMAIL": "your-email@example.com",\n  "TERRAKIO_API_KEY": "your-api-key-here"\n}'
-        )
+        # Create an empty config file
+        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.")
+        return {
+            'url': DEFAULT_API_URL,
+            'key': None,
+            'is_logged_in': False,
+            'user_email': None,
+            'token': None
+        }
     
     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'):
+            if not quiet:
+                print("No API key found. Please provide an API key to use this client.")
+            return {
+                'url': DEFAULT_API_URL,
+                'key': None,
+                'is_logged_in': 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')}")
+        # this meanb that we have already logged in to the tkio account
+        
         # Convert the JSON config to our expected format
         config = {
-            # Allow config to override default URL if provided
-            'url': config_data.get('TERRAKIO_API_URL', DEFAULT_API_URL),
-            'key': config_data.get('TERRAKIO_API_KEY')
+            # Always use the default URL, not from config file
+            'url': DEFAULT_API_URL,
+            'key': config_data.get('TERRAKIO_API_KEY'),
+            'is_logged_in': True,
+            'user_email': config_data.get('EMAIL'),
+            'token': config_data.get('PERSONAL_TOKEN')
         }
         return config
             
+
     except Exception as e:
-        raise ConfigurationError(f"Failed to parse configuration file: {e}")
+        if not quiet:
+            print(f"Error reading config: {e}")
+            print("No API key found. Please provide an API key to use this client.")
+        return {
+            'url': DEFAULT_API_URL,
+            'key': None,
+            'is_logged_in': False,
+            'user_email': None,
+            'token': None
+        }
 
-def create_default_config(email: str, api_key: str, api_url: Optional[str] = None, config_file: str = DEFAULT_CONFIG_FILE) -> 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
-        api_url: Optional API URL (if different from default)
         config_file: Path to configuration file
         
     Raises:
@@ -70,10 +116,6 @@ def create_default_config(email: str, api_key: str, api_url: Optional[str] = Non
             "TERRAKIO_API_KEY": api_key
         }
         
-        # Add API URL if provided
-        if api_url:
-            config_data["TERRAKIO_API_URL"] = api_url
-        
         with open(config_path, 'w') as f:
             json.dump(config_data, f, indent=2)
             

{terrakio_core-0.3.2.dist-info → terrakio_core-0.3.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: terrakio-core
-Version: 0.3.2
+Version: 0.3.4
 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.2.dist-info → terrakio_core-0.3.4.dist-info}/RECORD

@@ -1,7 +1,7 @@
-terrakio_core/__init__.py,sha256=faOeYeL7Lmg3aTRVxVEBT6Dbhi62N4eeXK3mAluD3pA,88
-terrakio_core/auth.py,sha256=Nuj0_X3Hiy17svYgGxrSAR-LXpTlP0J0dSrfMnkPUbI,7717
-terrakio_core/client.py,sha256=oJPg4hcdCBaPwYN0SKQy57YUsJBTTA-SbQ4aaHaNq8E,65578
-terrakio_core/config.py,sha256=AwJ1VgR5K7N32XCU5k7_Dp1nIv_FYt8MBonq9yKlGzA,2658
+terrakio_core/__init__.py,sha256=Pn9_C8YL77990JgyJlSu_zCafX8L-zCDjnFiKl_SDUY,88
+terrakio_core/auth.py,sha256=tqviZwtW7qWSo1TEjvv0dMDkegUtaEN_tfdrJ6cPJtc,7182
+terrakio_core/client.py,sha256=YMbLyevSdxAKlX7K93aOhvfjnM7NCCb4ohetcYzigJM,73676
+terrakio_core/config.py,sha256=MKTGSQRji8ty9dJlX8SOP7_3K2iR-3BXL-hUG7PsZQY,4324
 terrakio_core/dataset_management.py,sha256=Hdk3nkwd70jw3lBNEaGixrqNVhUWOmsIYktzm_8vXdc,10913
 terrakio_core/decorators.py,sha256=QeNOUX6WEAmdgBL5Igt5DXyYduh3jnmLbodttmwvXhE,785
 terrakio_core/exceptions.py,sha256=9S-I20-QiDRj1qgjFyYUwYM7BLic_bxurcDOIm2Fu_0,410
@@ -10,7 +10,7 @@ terrakio_core/mass_stats.py,sha256=UGZo8BH4hzWe3k7pevsYAdRwnVZl-08lXjTlHD4nMgQ,1
 terrakio_core/space_management.py,sha256=wlUUQrlj_4U_Lpjn9lbF5oj0Rv3NPvvnrd5mWej5kmA,4211
 terrakio_core/user_management.py,sha256=MMNWkz0V_9X7ZYjjteuRU4H4W3F16iuQw1dpA2wVTGg,7400
 terrakio_core/generation/tiles.py,sha256=eiiMNzqaga-c42kG_7zHXTF2o8ZInCPUj0Vu4Ye30Ts,2980
-terrakio_core-0.3.2.dist-info/METADATA,sha256=QaQJrukRnVgy2jAqNr-BDCUaybrqFMbjOlr2KqLlhJI,1476
-terrakio_core-0.3.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-terrakio_core-0.3.2.dist-info/top_level.txt,sha256=5cBj6O7rNWyn97ND4YuvvXm0Crv4RxttT4JZvNdOG6Q,14
-terrakio_core-0.3.2.dist-info/RECORD,,
+terrakio_core-0.3.4.dist-info/METADATA,sha256=yC1XxiHDyyzVvXsqgYP7T2mvXHuN_w6h7UYp4rO-fBY,1476
+terrakio_core-0.3.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+terrakio_core-0.3.4.dist-info/top_level.txt,sha256=5cBj6O7rNWyn97ND4YuvvXm0Crv4RxttT4JZvNdOG6Q,14
+terrakio_core-0.3.4.dist-info/RECORD,,