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

terrakio_core/config.py

@@ -1,81 +0,0 @@
-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

@@ -1,235 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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/mass_stats.py

@@ -1,262 +0,0 @@
-import requests
-from typing import Optional, Dict, Any
-
-class MassStats:
-    def __init__(self, base_url: str, api_key: str, verify: bool = True, timeout: int = 60):
-        self.base_url = base_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
-        })
-
-    def upload_request(
-        self,
-        name: str,
-        size: int,
-        bucket: str,
-        output: str,
-        location: Optional[str] = None,
-        force_loc: bool = False,
-        config: Optional[Dict[str, Any]] = None,
-        overwrite: bool = False,
-        server: Optional[str] = None,
-        skip_existing: bool = False
-    ) -> Dict[str, Any]:
-        """
-        Initiate a mass stats upload job.
-        
-        Args:
-            name: Name of the job
-            size: Size of the data
-            bucket: Storage bucket
-            output: Output path or identifier
-            location: (Optional) Location for the upload
-            force_loc: Force location usage
-            config: Optional configuration dictionary
-            overwrite: Overwrite existing data
-            server: Optional server
-            skip_existing: Skip existing files
-        """
-        url = f"{self.base_url}/mass_stats/upload"
-        data = {
-            "name": name,
-            "size": size,
-            "bucket": bucket,
-            "output": output,
-            "force_loc": force_loc,
-            "overwrite": overwrite,
-            "skip_existing": skip_existing
-        }
-        if location is not None:
-            data["location"] = location
-        if config is not None:
-            data["config"] = config
-        if server is not None:
-            data["server"] = server
-        response = self.session.post(url, json=data, verify=self.verify, timeout=self.timeout)
-        print("the response is ", response.text)
-        # response.raise_for_status()
-        return response.json()
-
-    def start_job(self, task_id: str) -> Dict[str, Any]:
-        """
-        Start a mass stats job by task ID.
-        """
-        url = f"{self.base_url}/mass_stats/start/{task_id}"
-        print("the self session header is ", self.session.headers)
-        response = self.session.post(url, verify=self.verify, timeout=self.timeout)
-        response.raise_for_status()
-        return response.json()
-
-    def get_task_id(self, name: str, stage: str, uid: Optional[str] = None) -> Dict[str, Any]:
-        """
-        Get the task ID for a mass stats job by name and stage (and optionally user ID).
-        """
-        url = f"{self.base_url}/mass_stats/job_id?name={name}&stage={stage}"
-        if uid is not None:
-            url += f"&uid={uid}"
-        response = self.session.get(url, verify=self.verify, timeout=self.timeout)
-        print("response text is ", response.text)
-        return response.json()
-
-    def track_job(self, ids: Optional[list] = None) -> Dict[str, Any]:
-        """
-        Track the status of one or more mass stats jobs.
-        If ids is None, gets progress for all of the user's jobs.
-        """
-        url = f"{self.base_url}/mass_stats/track"
-        data = {"ids": ids} if ids is not None else {}
-        response = self.session.post(url, json=data, verify=self.verify, timeout=self.timeout)
-        response.raise_for_status()
-        return response.json()
-
-    def get_history(self, limit: int = 100) -> Dict[str, Any]:
-        """
-        Get the history of mass stats jobs.
-        """
-        url = f"{self.base_url}/mass_stats/history"
-        params = {"limit": limit}
-        response = self.session.get(url, params=params, verify=self.verify, timeout=self.timeout)
-        response.raise_for_status()
-        return response.json()
-
-    def start_post_processing(
-        self,
-        process_name: str,
-        data_name: str,
-        output: str,
-        consumer_path: str,
-        overwrite: bool = False
-    ) -> Dict[str, Any]:
-        """
-        Start post processing for a mass stats job.
-        Args:
-            process_name: Folder to store output
-            data_name: Name of job used to create data
-            output: Output type
-            consumer_path: Path to the post processing script (Python file)
-            overwrite: Overwrite existing post processing output in same location
-        Returns:
-            Dict with task_id
-        """
-        url = f"{self.base_url}/mass_stats/post_process"
-        files = {
-            'consumer': (consumer_path, open(consumer_path, 'rb'), 'text/x-python')
-        }
-        data = {
-            'process_name': process_name,
-            'data_name': data_name,
-            'output': output,
-            'overwrite': str(overwrite).lower()
-        }
-        response = self.session.post(url, data=data, files=files, verify=self.verify, timeout=self.timeout)
-        print("the response is ", response.text)
-        # response.raise_for_status()
-        return response.json()
-
-    def download_results(
-        self,
-        id: Optional[str] = None,
-        force_loc: bool = False,
-        bucket: Optional[str] = None,
-        location: Optional[str] = None,
-        output: Optional[str] = None,
-        file_name: Optional[str] = None
-    ) -> bytes:
-        """
-        Download results from a mass stats job or arbitrary results if force_loc is True.
-        Returns the content of the .zip file.
-        """
-        url = f"{self.base_url}/mass_stats/download"
-        data = {}
-        if id is not None:
-            data["id"] = id
-        if force_loc:
-            data["force_loc"] = True
-            if bucket is not None:
-                data["bucket"] = bucket
-            if location is not None:
-                data["location"] = location
-            if output is not None:
-                data["output"] = output
-        if file_name is not None:
-            data["file_name"] = file_name
-        response = self.session.post(url, json=data, verify=self.verify, timeout=self.timeout)
-        print("the response is ", response.text)
-        # response.raise_for_status()
-        print("the response content is ", response.content)
-        return response.content
-
-    def cancel_job(self, id: str) -> Dict[str, Any]:
-        """
-        Cancel a mass stats job by ID.
-        """
-        url = f"{self.base_url}/mass_stats/cancel/{id}"
-        response = self.session.post(url, verify=self.verify, timeout=self.timeout)
-        response.raise_for_status()
-        return response.json()
-
-    def cancel_all_jobs(self) -> Dict[str, Any]:
-        """
-        Cancel all mass stats jobs for the user.
-        """
-        url = f"{self.base_url}/mass_stats/cancel"
-        response = self.session.post(url, verify=self.verify, timeout=self.timeout)
-        response.raise_for_status()
-        return response.json()
-
-    def create_pyramids(self, name: str, levels: int, config: Dict[str, Any]) -> Dict[str, Any]:
-        """
-        Create pyramids for a dataset.
-        Args:
-            name: Name for the pyramid job
-            levels: Number of zoom levels to compute
-            config: Dataset config (mapping)
-        Returns:
-            Dict with task_id
-        """
-        url = f"{self.base_url}/pyramids/create"
-        data = {
-            "name": name,
-            "levels": levels,
-            "config": config
-        }
-        response = self.session.post(url, json=data, verify=self.verify, timeout=self.timeout)
-        print("the url is   ", url)
-        print("the response is ", response.text)
-        print("the response status code is ", response.status_code)
-        # response.raise_for_status()
-        return response.json()
-
-    def random_sample(
-        self,
-        name: str,
-        config: dict,
-        aoi: dict,
-        samples: int,
-        year_range: list,
-        crs: str,
-        tile_size: int,
-        res: float,
-        output: str,
-        server: str,
-        region: str,
-        bucket: str,
-        overwrite: bool = False
-    ) -> Dict[str, Any]:
-        """
-        Submit a random sample job.
-        """
-        if year_range is None or len(year_range) != 2:
-            raise ValueError("year_range must be a list of two integers")
-        start_year, end_year = year_range
-        if start_year is None or end_year is None:
-            raise ValueError("Both start_year and end_year must be provided for year_range.")
-
-        url = f"{self.base_url}/random_sample"
-        data = {
-            "name": name,
-            "overwrite": overwrite,
-            "config": config,
-            "aoi": aoi,
-            "samples": samples,
-            "year_range": [start_year, end_year],
-            "crs": crs,
-            "tile_size": tile_size,
-            "res": res,
-            "output": output,
-            "server": server,
-            "region": region,
-            "bucket": bucket
-        }
-        print("the data is ", data)
-        print("the url is ", url)
-        response = self.session.post(url, json=data, verify=self.verify, timeout=self.timeout)
-        print("Status code:", response.status_code)
-        print("Response text:", response.text)
-        # response.raise_for_status()
-        return response.json() 
-