terrakio-core 0.2.3__py3-none-any.whl → 0.2.4__py3-none-any.whl

terrakio_core/config.py

@@ -0,0 +1,81 @@
+import os
+import json
+from pathlib import Path
+from typing import Dict, Any, Optional
+
+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) -> Dict[str, Any]:
+    """
+    Read and parse the configuration file.
+    
+    Args:
+        config_file: Path to the configuration file
+        
+    Returns:
+        Dict[str, Any]: Configuration parameters
+        
+    Raises:
+        ConfigurationError: If the configuration file can't be read or parsed
+    """
+    config_path = Path(os.path.expanduser(config_file))
+    
+    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}'
+        )
+    
+    try:
+        with open(config_path, 'r') as f:
+            config_data = json.load(f)
+            
+        # 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')
+        }
+        return config
+            
+    except Exception as e:
+        raise ConfigurationError(f"Failed to parse configuration file: {e}")
+
+def create_default_config(email: str, api_key: str, api_url: Optional[str] = None, 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:
+        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
+        }
+        
+        # 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)
+            
+    except Exception as e:
+        raise ConfigurationError(f"Failed to create configuration file: {e}")

terrakio_core/dataset_management.py

@@ -0,0 +1,235 @@
+import requests
+from typing import Dict, Any, List, Optional
+from .exceptions import APIError
+
+class DatasetManagement:
+    def __init__(self, api_url: str, api_key: str, verify: bool = True, timeout: int = 60):
+        """
+        Initialize the Dataset Management client.
+        
+        Args:
+            api_url: API base URL
+            api_key: API key for authentication
+            verify: Verify SSL certificates
+            timeout: Request timeout in seconds
+        """
+        self.api_url = api_url.rstrip('/')
+        self.api_key = api_key
+        self.verify = verify
+        self.timeout = timeout
+        self.session = requests.Session()
+        self.session.headers.update({
+            'x-api-key': self.api_key,
+            'Content-Type': 'application/json'
+        })
+
+    def get_dataset(self, name: str, collection: str = "terrakio-datasets") -> Dict[str, Any]:
+        """
+        Retrieve dataset info by dataset name.
+        
+        Args:
+            name: The name of the dataset (required)
+            collection: The dataset collection (default: 'terrakio-datasets')
+            
+        Returns:
+            Dataset information as a dictionary
+            
+        Raises:
+            APIError: If the API request fails
+        """
+        endpoint = f"{self.api_url}/datasets/{name}"
+        params = {"collection": collection} if collection else {}
+        try:
+            response = self.session.get(
+                endpoint,
+                params=params,
+                timeout=self.timeout,
+                verify=self.verify
+            )
+            if not response.ok:
+                raise APIError(f"API request failed: {response.status_code} {response.reason}")
+            return response.json()
+        except requests.RequestException as e:
+            raise APIError(f"Request failed: {str(e)}")
+
+    def list_datasets(self, substring: Optional[str] = None, collection: str = "terrakio-datasets") -> List[Dict[str, Any]]:
+        """
+        List datasets, optionally filtering by a substring and collection.
+        
+        Args:
+            substring: Substring to filter by (optional)
+            collection: Dataset collection (default: 'terrakio-datasets')
+            
+        Returns:
+            List of datasets matching the criteria
+            
+        Raises:
+            APIError: If the API request fails
+        """
+        endpoint = f"{self.api_url}/datasets"
+        params = {"collection": collection}
+        if substring:
+            params["substring"] = substring
+        try:
+            response = self.session.get(
+                endpoint,
+                params=params,
+                timeout=self.timeout,
+                verify=self.verify
+            )
+            if not response.ok:
+                raise APIError(f"API request failed: {response.status_code} {response.reason}")
+            return response.json()
+        except requests.RequestException as e:
+            raise APIError(f"Request failed: {str(e)}")
+
+    def create_dataset(self, name: str, collection: str = "terrakio-datasets", **kwargs) -> Dict[str, Any]:
+        """
+        Create a new dataset.
+        
+        Args:
+            name: Name of the dataset (required)
+            collection: Dataset collection (default: 'terrakio-datasets')
+            **kwargs: Additional dataset parameters including:
+                - products: List of products
+                - dates_iso8601: List of dates
+                - bucket: Storage bucket
+                - path: Storage path
+                - data_type: Data type
+                - no_data: No data value
+                - l_max: Maximum level
+                - y_size: Y size
+                - x_size: X size
+                - proj4: Projection string
+                - abstract: Dataset abstract
+                - geotransform: Geotransform parameters
+                
+        Returns:
+            Created dataset information
+            
+        Raises:
+            APIError: If the API request fails
+        """
+        endpoint = f"{self.api_url}/datasets"
+        params = {"collection": collection}
+        # Create payload with required name parameter
+        payload = {"name": name}
+        
+        # Add optional parameters if provided
+        for param in ["products", "dates_iso8601", "bucket", "path", "data_type", 
+                     "no_data", "l_max", "y_size", "x_size", "proj4", "abstract", "geotransform"]:
+            if param in kwargs:
+                payload[param] = kwargs[param]
+        
+        try:
+            response = self.session.post(
+                endpoint,
+                params=params,
+                json=payload,
+                timeout=self.timeout,
+                verify=self.verify
+            )
+            
+            if not response.ok:
+                raise APIError(f"API request failed: {response.status_code} {response.reason}")
+            return response.json()
+        except requests.RequestException as e:
+            raise APIError(f"Request failed: {str(e)}")
+
+    def update_dataset(self, name: str, append: bool = True, collection: str = "terrakio-datasets", **kwargs) -> Dict[str, Any]:
+        """
+        Update a dataset. By default, values are appended unless append is set to False.
+        
+        Args:
+            name: Name of the dataset (required)
+            append: Whether to append values (default: True)
+            collection: Dataset collection (default: 'terrakio-datasets')
+            **kwargs: Additional dataset parameters to update
+                
+        Returns:
+            Updated dataset information
+            
+        Raises:
+            APIError: If the API request fails
+        """
+        endpoint = f"{self.api_url}/datasets"
+        params = {"append": str(append).lower(), "collection": collection}
+        payload = {"name": name}
+        payload.update(kwargs)
+        try:
+            response = self.session.patch(
+                endpoint,
+                params=params,
+                json=payload,
+                timeout=self.timeout,
+                verify=self.verify
+            )
+            if not response.ok:
+                raise APIError(f"API request failed: {response.status_code} {response.reason}")
+            return response.json()
+        except requests.RequestException as e:
+            raise APIError(f"Request failed: {str(e)}")
+
+    def overwrite_dataset(self, name: str, collection: str = "terrakio-datasets", **kwargs) -> Dict[str, Any]:
+        """
+        Overwrite a dataset (replace all values).
+        
+        Args:
+            name: Name of the dataset (required)
+            collection: Dataset collection (default: 'terrakio-datasets')
+            **kwargs: New dataset parameters
+                
+        Returns:
+            Updated dataset information
+            
+        Raises:
+            APIError: If the API request fails
+        """
+        endpoint = f"{self.api_url}/datasets"
+        params = {"collection": collection}
+        payload = {"name": name}
+        payload.update(kwargs)
+        try:
+            response = self.session.put(
+                endpoint,
+                params=params,
+                json=payload,
+                timeout=self.timeout,
+                verify=self.verify
+            )
+            if not response.ok:
+                raise APIError(f"API request failed: {response.status_code} {response.reason}")
+            return response.json()
+        except requests.RequestException as e:
+            raise APIError(f"Request failed: {str(e)}")
+
+    def delete_dataset(self, name: str, collection: str = "terrakio-datasets") -> Dict[str, Any]:
+        """
+        Delete a dataset by name.
+        
+        Args:
+            name: The name of the dataset (required)
+            collection: Dataset collection (default: 'terrakio-datasets')
+                
+        Returns:
+            API response as a dictionary
+            
+        Raises:
+            APIError: If the API request fails
+        """
+        endpoint = f"{self.api_url}/datasets/{name}"
+        params = {"collection": collection}
+        try:
+            response = self.session.delete(
+                endpoint,
+                params=params,
+                timeout=self.timeout,
+                verify=self.verify
+            )
+            if response.status_code == 404:
+                return {"status": "error", "message": f"Dataset '{name}' does not exist in collection '{collection}'"}
+            if not response.ok:
+                raise APIError(f"API request failed: {response.status_code} {response.reason}")
+            return response.json()
+        except requests.RequestException as e:
+            raise APIError(f"Request failed: {str(e)}") 

terrakio_core/exceptions.py

@@ -0,0 +1,18 @@
+class APIError(Exception):
+    """Exception raised for errors in the API responses."""
+    pass
+
+
+class ConfigurationError(Exception):
+    """Exception raised for errors in the configuration."""
+    pass
+
+
+class DownloadError(Exception):
+    """Exception raised for errors during data download."""
+    pass
+
+
+class ValidationError(Exception):
+    """Exception raised for invalid request parameters."""
+    pass

terrakio_core/group_access_management.py

@@ -0,0 +1,232 @@
+import requests
+from typing import Dict, Any, List
+from .exceptions import APIError
+
+class GroupAccessManagement:
+    def __init__(self, api_url: str, api_key: str, verify: bool = True, timeout: int = 60):
+        """
+        Initialize the Group Access Management client.
+        
+        Args:
+            api_url: API base URL
+            api_key: API key for authentication
+            verify: Verify SSL certificates
+            timeout: Request timeout in seconds
+        """
+        self.api_url = api_url.rstrip('/')
+        self.api_key = api_key
+        self.verify = verify
+        self.timeout = timeout
+        self.session = requests.Session()
+        self.session.headers.update({
+            'x-api-key': self.api_key,
+            'Content-Type': 'application/json'
+        })
+
+    def get_group_users_and_datasets(self, group_name: str) -> Dict[str, Any]:
+        """
+        Get users and datasets of a group.
+        
+        Args:
+            group_name: Name of the group
+        
+        Returns:
+            Dictionary containing lists of users and datasets associated with the group
+            {
+                "users": [UID, ...],
+                "datasets": [DATASET_NAME, ...]
+            }
+            
+        Raises:
+            APIError: If the API request fails
+        """
+        endpoint = f"https://dev-au.terrak.io/groups/{group_name}"
+        print("the endpoint is ", endpoint)
+        print
+        try:
+            response = self.session.get(
+                endpoint,
+                timeout=self.timeout,
+                verify=self.verify
+            )
+            print("the response is ", response.text)
+            if not response.ok:
+                error_msg = f"API request failed: {response.status_code} {response.reason}"
+                try:
+                    error_data = response.json()
+                    if "detail" in error_data:
+                        error_msg += f" - {error_data['detail']}"
+                except:
+                    pass
+                raise APIError(error_msg)
+            
+            return response.json()
+            
+        except requests.RequestException as e:
+            raise APIError(f"Request failed: {str(e)}")
+
+    def add_group_to_dataset(self, dataset: str, group: str) -> Dict[str, Any]:
+        """
+        Add a group to a dataset.
+        
+        Args:
+            dataset: Name of the dataset
+            group: Name of the group to add to the dataset
+        
+        Returns:
+            API response data
+            
+        Raises:
+            APIError: If the API request fails
+        """
+        endpoint = f"{self.api_url}/groups/dataset/{dataset}"
+        print("hello")
+        print("the endpoint is ", endpoint)
+        params = {"group": group}
+        print("the endpoint is ", endpoint)
+        print("!!!!!!!!!!!")
+        print("the params are ", params)
+        try:
+            response = self.session.post(
+                endpoint,
+                params=params,
+                timeout=self.timeout,
+                verify=self.verify
+            )
+            
+            if not response.ok:
+                error_msg = f"API request failed: {response.status_code} {response.reason}"
+                try:
+                    error_data = response.json()
+                    if "detail" in error_data:
+                        error_msg += f" - {error_data['detail']}"
+                except:
+                    pass
+                raise APIError(error_msg)
+            
+            return response.json()
+            
+        except requests.RequestException as e:
+            raise APIError(f"Request failed: {str(e)}")
+
+    def add_group_to_user(self, uid: str, group: str) -> Dict[str, Any]:
+        """
+        Add a group to a user.
+
+        Args:
+            uid: User UID
+            group: Name of the group to add to the user
+
+        Returns:
+            API response data
+
+        Raises:
+            APIError: If the API request fails
+        """
+        endpoint = f"{self.api_url}/groups/users/{uid}"
+        params = {"group": group}
+        print("the endpoint is ", endpoint)
+        print("the params are ", params)
+        try:
+            response = self.session.post(
+                endpoint,
+                params=params,
+                timeout=self.timeout,
+                verify=self.verify
+            )
+
+            if not response.ok:
+                error_msg = f"API request failed: {response.status_code} {response.reason}"
+                try:
+                    error_data = response.json()
+                    if "detail" in error_data:
+                        error_msg += f" - {error_data['detail']}"
+                except:
+                    pass
+                raise APIError(error_msg)
+
+            return response.json()
+
+        except requests.RequestException as e:
+            raise APIError(f"Request failed: {str(e)}")
+
+    def delete_group_from_user(self, uid: str, group: str) -> Dict[str, Any]:
+        """
+        Delete a group from a user.
+
+        Args:
+            uid: User UID
+            group: Name of the group to remove from the user
+
+        Returns:
+            API response data
+
+        Raises:
+            APIError: If the API request fails
+        """
+        endpoint = f"{self.api_url}/groups/users/{uid}"
+        params = {"group": group}
+
+        try:
+            response = self.session.delete(
+                endpoint,
+                params=params,
+                timeout=self.timeout,
+                verify=self.verify
+            )
+
+            if not response.ok:
+                error_msg = f"API request failed: {response.status_code} {response.reason}"
+                try:
+                    error_data = response.json()
+                    if "detail" in error_data:
+                        error_msg += f" - {error_data['detail']}"
+                except:
+                    pass
+                raise APIError(error_msg)
+
+            return response.json()
+
+        except requests.RequestException as e:
+            raise APIError(f"Request failed: {str(e)}")
+
+    def delete_group_from_dataset(self, dataset: str, group: str) -> Dict[str, Any]:
+        """
+        Delete a group from a dataset.
+
+        Args:
+            dataset: Name of the dataset
+            group: Name of the group to remove from the dataset
+
+        Returns:
+            API response data
+
+        Raises:
+            APIError: If the API request fails
+        """
+        endpoint = f"{self.api_url}/groups/datasets/{dataset}"
+        params = {"group": group}
+
+        try:
+            response = self.session.delete(
+                endpoint,
+                params=params,
+                timeout=self.timeout,
+                verify=self.verify
+            )
+
+            if not response.ok:
+                error_msg = f"API request failed: {response.status_code} {response.reason}"
+                try:
+                    error_data = response.json()
+                    if "detail" in error_data:
+                        error_msg += f" - {error_data['detail']}"
+                except:
+                    pass
+                raise APIError(error_msg)
+
+            return response.json()
+
+        except requests.RequestException as e:
+            raise APIError(f"Request failed: {str(e)}")
+