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

terrakio_core/endpoints/space_management.py

@@ -0,0 +1,72 @@
+from typing import Dict, Any, Optional
+from ..helper.decorators import require_token, require_api_key, require_auth
+class SpaceManagement:
+    def __init__(self, client):
+        self._client = client
+
+    @require_api_key
+    def get_total_space_used(self) -> Dict[str, Any]:
+        """
+        Get total space used by the user.
+        
+        Returns:
+            Dict[str, Any]: Total space used by the user.
+
+        Raises:
+            APIError: If the API request fails
+        """
+        return self._client._terrakio_request("GET", "/users/jobs")
+
+    @require_api_key
+    def get_space_used_by_job(self, name: str, region: str) -> Dict[str, Any]:
+        """
+        Get space used by a specific job.
+
+        Args:
+            name: The name of the job
+            region: The region of the job
+
+        Returns:
+            Dict[str, Any]: Space used by the job.
+        
+        Raises:
+            APIError: If the API request fails
+        """
+        params = {"region": region}
+        return self._client._terrakio_request("GET", f"/users/jobs/{name}", params=params)
+    
+    @require_api_key
+    def delete_user_job(self, name: str, region: str) -> Dict[str, Any]:
+        """
+        Delete a user job by name and region.
+        
+        Args:
+            name: The name of the job
+            region: The region of the job
+            
+        Returns:
+            Dict[str, Any]: Response from the delete operation.
+        
+        Raises:
+            APIError: If the API request fails
+        """
+        params = {"region": region}
+        return self._client._terrakio_request("DELETE", f"/users/jobs/{name}", params=params)
+
+    @require_api_key
+    def delete_data_in_path(self, path: str, region: str) -> Dict[str, Any]:
+        """
+        Delete data in a GCS path for a given region.
+        
+        Args:
+            path: The GCS path to delete data from
+            region: The region where the data is located
+            
+        Returns:
+            Dict[str, Any]: Response from the delete operation.
+        
+        Raises:
+            APIError: If the API request fails
+        """
+        params = {"path": path, "region": region}
+        return self._client._terrakio_request("DELETE", "/users/jobs", params=params)

terrakio_core/endpoints/user_management.py

@@ -0,0 +1,131 @@
+from typing import Dict, Any, List, Optional
+from ..helper.decorators import require_token, require_api_key, require_auth
+
+class UserManagement:
+    def __init__(self, client):
+        self._client = client
+
+    @require_api_key
+    def get_user_by_id(self, id: str) -> Dict[str, Any]:
+        """
+        Get user by ID.
+
+        Args:
+            user_id: User ID
+        
+        Returns:
+            User information
+            
+        Raises:
+            APIError: If the API request fails
+        """
+        return self._client._terrakio_request("GET", f"admin/users/{id}")
+    
+    @require_api_key
+    def get_user_by_email(self, email: str) -> Dict[str, Any]:
+        """
+        Get user by email.
+
+        Args:
+            email: User email
+        
+        Returns:
+            User information
+            
+        Raises:
+            APIError: If the API request fails
+        """
+        return self._client._terrakio_request("GET", f"admin/users/email/{email}")
+    
+    @require_api_key
+    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
+        """
+        params = {"uid": str(uid).lower()}
+        if substring:
+            params['substring'] = substring
+        return self._client._terrakio_request("GET", "admin/users", params=params)
+    
+    @require_api_key
+    def edit_user(
+        self,
+        uid: str,
+        email: Optional[str],
+        role: Optional[str],
+        apiKey: Optional[str],
+        groups: Optional[List[str]],
+        quota: Optional[int]
+    ) -> Dict[str, Any]:
+        """
+        Edit user info. Only provided fields will be updated.
+        
+        Args:
+            uid: User ID
+            email: New user email
+            role: New user role
+            apiKey: New API key
+            groups: New list of groups
+            quota: New quota
+        
+        Returns:
+            Updated user information
+            
+        Raises:
+            APIError: If the API request fails
+        """
+        payload = {"uid": uid}
+        payload_mapping = {
+            "email": email,
+            "role": role,
+            "apiKey": apiKey,
+            "groups": groups,
+            "quota": quota
+        }
+        for key, value in payload_mapping.items():
+            if value is not None:
+                payload[key] = value
+        return self._client._terrakio_request("PATCH", "admin/users", json=payload)
+    
+    @require_api_key
+    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
+        """
+        payload = {"email": email}
+        if quota is not None:
+            payload["quota"] = quota
+        return self._client._terrakio_request("PATCH", f"admin/users/reset_quota/{email}", json=payload)
+    
+    @require_api_key
+    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
+        """
+        return self._client._terrakio_request("DELETE", f"admin/users/{uid}")

terrakio_core/exceptions.py

@@ -1,7 +1,9 @@
 class APIError(Exception):
     """Exception raised for errors in the API responses."""
-    pass
-
+    
+    def __init__(self, message, status_code=None):
+        super().__init__(message)
+        self.status_code = status_code
 
 class ConfigurationError(Exception):
     """Exception raised for errors in the configuration."""

terrakio_core/helper/bounded_taskgroup.py

@@ -0,0 +1,20 @@
+import asyncio
+
+# Adapted from https://discuss.python.org/t/boundedtaskgroup-to-control-parallelism/27171
+
+class BoundedTaskGroup(asyncio.TaskGroup):
+    def __init__(self, *args, max_concurrency = 0, **kwargs):
+        super().__init__(*args)
+        if max_concurrency:
+            self._sem = asyncio.Semaphore(max_concurrency)
+        else:
+            self._sem = None
+    
+    def create_task(self, coro, *args, **kwargs):
+        if self._sem:
+            async def _wrapped_coro(sem, coro):
+                async with sem:
+                    return await coro
+            coro = _wrapped_coro(self._sem, coro)
+
+        return super().create_task(coro, *args, **kwargs)

terrakio_core/helper/decorators.py

@@ -0,0 +1,58 @@
+# terrakio_core/decorators.py
+from functools import wraps
+from ..exceptions import ConfigurationError
+
+def require_token(func):
+    """Decorator to ensure a token is available before a method can be executed."""
+    @wraps(func)
+    def wrapper(self, *args, **kwargs):
+        # Check both direct token and client token
+        has_token = False
+        if hasattr(self, 'token') and self.token:
+            has_token = True
+        elif hasattr(self, '_client') and hasattr(self._client, 'token') and self._client.token:
+            has_token = True
+            
+        if not has_token:
+            raise ConfigurationError("Authentication token required. Please login first.")
+        return func(self, *args, **kwargs)
+    
+    wrapper._is_decorated = True
+    return wrapper
+
+def require_api_key(func):
+    """Decorator to ensure an API key is available before a method can be executed."""
+    @wraps(func)
+    def wrapper(self, *args, **kwargs):
+        # Check both direct key and client key
+        has_key = False
+        if hasattr(self, 'key') and self.key:
+            has_key = True
+        elif hasattr(self, '_client') and hasattr(self._client, 'key') and self._client.key:
+            has_key = True
+            
+        if not has_key:
+            raise ConfigurationError("API key required. Please provide an API key or login first.")
+        return func(self, *args, **kwargs)
+    
+    wrapper._is_decorated = True
+    return wrapper
+
+def require_auth(func):
+    """Decorator that requires either a token OR an API key"""
+    @wraps(func)
+    def wrapper(self, *args, **kwargs):
+        # Check both direct auth and client auth
+        has_token = (hasattr(self, 'token') and self.token) or \
+                   (hasattr(self, '_client') and hasattr(self._client, 'token') and self._client.token)
+        has_api_key = (hasattr(self, 'key') and self.key) or \
+                     (hasattr(self, '_client') and hasattr(self._client, 'key') and self._client.key)
+        
+        if not has_token and not has_api_key:
+            raise ConfigurationError(
+                "Authentication required. Please provide either an API key or login to get a token."
+            )
+        return func(self, *args, **kwargs)
+    
+    wrapper._is_decorated = True
+    return wrapper

terrakio_core/{generation → helper}/tiles.py

@@ -1,10 +1,6 @@
-### implementing generation-tiles in python api
-### function should just generate the json file for mass_stats to pick up.
-
 import geopandas as gpd
 import shapely.geometry
 import json
-from rich import print
 
 def escape_newline(string):
     if isinstance(string, list):
@@ -28,7 +24,6 @@ def tile_generator(x_min, y_min, x_max, y_max, aoi, crs, res, tile_size, express
         j_max += 1
     for j in range(0, int(j_max)):
         for i in range(0, int(i_max)):
-            #print(f"Processing tile {i} {j}")
             x = x_min + i*(tile_size*res)
             y = y_max - j*(tile_size*res)
             bbox = shapely.geometry.box(x, y-(tile_size*res), x + (tile_size*res), y)
@@ -62,10 +57,8 @@ def tiles(
     non_interactive: bool = False,
 ):
     
-    # Create requests for each tile
     reqs = []
     x_min, y_min, x_max, y_max, aoi = get_bounds(aoi, crs, to_crs)
-    #print(f"Bounds: {x_min}, {y_min}, {x_max}, {y_max}")
 
     if to_crs is None:
         to_crs = crs
@@ -73,9 +66,6 @@ def tiles(
         req_name = f"{name}_{i:02d}_{j:02d}"
         reqs.append({"group": "tiles", "file": req_name, "request": tile_req})
 
-    #print(f"Generated {len(reqs)} tile requests.")
-
-
     count = len(reqs)
     groups = list(set(dic["group"] for dic in reqs))
 
@@ -91,5 +81,4 @@ def tiles(
     request_json = json.dumps(reqs)
     manifest_json = json.dumps(groups)
 
-    return body, request_json, manifest_json
-    
+    return body, request_json, manifest_json