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

terrakio_core/mass_stats.py

@@ -0,0 +1,262 @@
+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() 
+    

terrakio_core/space_management.py

@@ -0,0 +1,101 @@
+import requests
+from typing import Dict, Any, Optional
+from .exceptions import APIError
+
+class SpaceManagement:
+    def __init__(self, api_url: str, api_key: str, verify: bool = True, timeout: int = 60):
+        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_total_space_used(self) -> Dict[str, Any]:
+        """
+        Get total space used by the user.
+        Returns a dict with user, total, and jobs breakdown.
+        """
+        endpoint = f"{self.api_url}/users/jobs"
+        try:
+            response = self.session.get(endpoint, 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 get_space_used_by_job(self, name: str, region: Optional[str] = None) -> Dict[str, Any]:
+        """
+        Get space used by a specific job.
+        """
+        endpoint = f"{self.api_url}/users/jobs/{name}"
+        params = {"region": region} if region else {}
+        try:
+            response = self.session.get(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_user_job(self, name: str, region: Optional[str] = None) -> Dict[str, Any]:
+        """
+        Delete a user job by name and region.
+        """
+        endpoint = f"{self.api_url}/users/job/{name}"
+        params = {"region": region} if region else {}
+        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_data_in_path(self, path: str, region: Optional[str] = None) -> Dict[str, Any]:
+        """
+        Delete data in a GCS path for a given region.
+        """
+        endpoint = f"{self.api_url}/users/jobs"
+        params = {"path": path}
+        if region:
+            params["region"] = region
+        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)}") 

terrakio_core/user_management.py

@@ -0,0 +1,227 @@
+import requests
+from typing import Dict, Any, List, Optional
+from .exceptions import APIError, ConfigurationError
+
+class UserManagement:
+    def __init__(self, api_url: str, api_key: str, verify: bool = True, timeout: int = 60):
+        """
+        Initialize the User 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_user_by_id(self, user_id: str) -> Dict[str, Any]:
+        """
+        Retrieve user info by user ID.
+        
+        Args:
+            user_id: User ID to retrieve
+        
+        Returns:
+            User information as a dictionary
+            
+        Raises:
+            APIError: If the API request fails
+        """
+        endpoint = f"{self.api_url}/admin/users/{user_id}"
+        try:
+            response = self.session.get(
+                endpoint, 
+                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 get_user_by_email(self, email: str) -> Dict[str, Any]:
+        """
+        Retrieve user info by email.
+        
+        Args:
+            email: User email to retrieve
+            
+        Returns:
+            User information as a dictionary
+            
+        Raises:
+            APIError: If the API request fails
+        """
+
+        endpoint = f"{self.api_url}/admin/users/email/{email}"
+        try:
+            response = self.session.get(
+                endpoint, 
+                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 edit_user(
+        self,
+        user_id: str,
+        uid: Optional[str] = None,
+        email: Optional[str] = None,
+        role: Optional[str] = None,
+        apiKey: Optional[str] = None,
+        groups: Optional[List[str]] = None,
+        quota: Optional[int] = None
+    ) -> Dict[str, Any]:
+        """
+        Edit user info. Only provided fields will be updated.
+        
+        Args:
+            user_id: User ID (required)
+            uid: New user ID (optional)
+            email: New user email (optional)
+            role: New user role (optional)
+            apiKey: New API key (optional)
+            groups: New list of groups (optional)
+            quota: New quota value (optional)
+            
+        Returns:
+            Updated user information
+            
+        Raises:
+            APIError: If the API request fails
+        """
+        endpoint = f"{self.api_url}/admin/users"
+        payload = {"uid": user_id}
+
+        if uid is not None:
+            payload["uid"] = uid
+        if email is not None:
+            payload["email"] = email
+        if role is not None:
+            payload["role"] = role
+        if apiKey is not None:
+            payload["apiKey"] = apiKey
+        if groups is not None:
+            payload["groups"] = groups
+        if quota is not None:
+            payload["quota"] = quota
+
+        try:
+            response = self.session.patch(
+                endpoint,
+                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 list_users(self, substring: Optional[str] = None, uid: bool = False) -> List[Dict[str, Any]]:
+        """
+        List users, optionally filtering by a substring.
+        
+        Args:
+            substring: Optional substring to filter users
+            uid: If True, includes the user ID in the response (default: False)
+        
+        Returns:
+            List of users
+            
+        Raises:
+            APIError: If the API request fails
+        """
+        # Use the base API URL instead of hardcoding
+        endpoint = "https://terrakio-server-lark-573248941006.australia-southeast1.run.app/admin/users"
+
+        params = {}
+        if substring:
+            params["substring"] = substring
+        if uid:
+            params["uid"] = "true"
+
+        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 reset_quota(self, email: str, quota: Optional[int] = None) -> Dict[str, Any]:
+        """
+        Reset the quota for a user by email.
+        
+        Args:
+            email: The user's email (required)
+            quota: The new quota value (optional)
+            
+        Returns:
+            API response as a dictionary
+            
+        Raises:
+            APIError: If the API request fails
+        """
+        endpoint = f"{self.api_url}/admin/users/reset_quota/{email}"
+        payload = {"email": email}
+        if quota is not None:
+            payload["quota"] = quota
+        try:
+            response = self.session.patch(
+                endpoint,
+                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_user(self, uid: str) -> Dict[str, Any]:
+        """
+        Delete a user by UID.
+        
+        Args:
+            uid: The user's UID (required)
+            
+        Returns:
+            API response as a dictionary
+            
+        Raises:
+            APIError: If the API request fails
+        """
+        endpoint = f"{self.api_url}/admin/users/{uid}"
+        try:
+            response = self.session.delete(
+                endpoint,
+                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)}")

{terrakio_core-0.2.3.dist-info → terrakio_core-0.2.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: terrakio-core
-Version: 0.2.3
+Version: 0.2.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.2.4.dist-info/RECORD

@@ -0,0 +1,14 @@
+terrakio_core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+terrakio_core/auth.py,sha256=Nuj0_X3Hiy17svYgGxrSAR-LXpTlP0J0dSrfMnkPUbI,7717
+terrakio_core/client.py,sha256=ChKbsGsCbkngRZ8mWgAijhKzElL0ZSdRHU2_XF9C7Ss,44850
+terrakio_core/config.py,sha256=AwJ1VgR5K7N32XCU5k7_Dp1nIv_FYt8MBonq9yKlGzA,2658
+terrakio_core/dataset_management.py,sha256=hhO35fwStS6HYFQdKP9wkr3DxHgjvpctmIU8UWH6w6U,8742
+terrakio_core/exceptions.py,sha256=9S-I20-QiDRj1qgjFyYUwYM7BLic_bxurcDOIm2Fu_0,410
+terrakio_core/group_access_management.py,sha256=NJ7SX4keUzZAUENmJ5L6ynKf4eRlqtyir5uoKFyY17A,7315
+terrakio_core/mass_stats.py,sha256=AqYJsd6nqo2BDh4vEPUDgsv4T0UR1_TPDoXa3WO3gTU,9284
+terrakio_core/space_management.py,sha256=wlUUQrlj_4U_Lpjn9lbF5oj0Rv3NPvvnrd5mWej5kmA,4211
+terrakio_core/user_management.py,sha256=MMNWkz0V_9X7ZYjjteuRU4H4W3F16iuQw1dpA2wVTGg,7400
+terrakio_core-0.2.4.dist-info/METADATA,sha256=dMdHIPIFLVF1UMfTSa7D3GMLOw6nVJwl4hMeMcs0FdQ,1405
+terrakio_core-0.2.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+terrakio_core-0.2.4.dist-info/top_level.txt,sha256=5cBj6O7rNWyn97ND4YuvvXm0Crv4RxttT4JZvNdOG6Q,14
+terrakio_core-0.2.4.dist-info/RECORD,,

terrakio_core-0.2.4.dist-info/top_level.txt

@@ -0,0 +1 @@
+terrakio_core

terrakio_core-0.2.3.dist-info/RECORD

@@ -1,4 +0,0 @@
-terrakio_core-0.2.3.dist-info/METADATA,sha256=y2lq4MvHKznM_bVtqtlrTW92lVpaOO9MpRz-e2wPVPQ,1405
-terrakio_core-0.2.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-terrakio_core-0.2.3.dist-info/top_level.txt,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-terrakio_core-0.2.3.dist-info/RECORD,,

terrakio_core-0.2.3.dist-info/top_level.txt

@@ -1 +0,0 @@
-