terrakio-core 0.2.0__tar.gz → 0.2.2__tar.gz

{terrakio_core-0.2.0 → terrakio_core-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: terrakio-core
-Version: 0.2.0
+Version: 0.2.2
 Summary: Core components for Terrakio API clients
 Home-page: https://github.com/HaizeaAnalytics/terrakio-python-api
 Author: Yupeng Chao
@@ -22,6 +22,7 @@ Requires-Dist: aiohttp>=3.8.0
 Requires-Dist: pyyaml>=5.1
 Requires-Dist: xarray>=2023.1.0
 Requires-Dist: shapely>=2.0.0
+Requires-Dist: geopandas>=0.13.0
 Dynamic: author
 Dynamic: home-page
 Dynamic: requires-python

{terrakio_core-0.2.0 → terrakio_core-0.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "terrakio-core"
-version = "0.2.0"
+version = "0.2.2"
 authors = [
     {name = "Yupeng Chao", email = "yupeng@haizea.com.au"},
 ]
@@ -27,6 +27,7 @@ dependencies = [
     "pyyaml>=5.1",
     "xarray>=2023.1.0",
     "shapely>=2.0.0",
+    "geopandas>=0.13.0",
 ]
 
 [project.urls]

{terrakio_core-0.2.0 → terrakio_core-0.2.2}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages  # Make sure to import find_packages
 
 setup(
     name="terrakio_core",
-    version="0.2.0",
+    version="0.2.2",
     author="Yupeng Chao",
     author_email="yupeng@haizea.com.au",
     description="Core components for Terrakio API clients",
@@ -24,6 +24,7 @@ setup(
         "pyyaml>=5.1",
         "xarray>=2023.1.0",
         "shapely>=2.0.0",
+        "geopandas>=0.13.0",
     ],
     metadata_version='2.2'
 ) 

{terrakio_core-0.2.0 → terrakio_core-0.2.2}/terrakio_core/auth.py

@@ -43,7 +43,8 @@ class AuthClient:
             "email": email,
             "password": password
         }
-        
+        print("the payload is ", payload)
+        print("the endpoint is ", endpoint)
         try:
             response = self.session.post(
                 endpoint, 
@@ -51,7 +52,7 @@ class AuthClient:
                 verify=self.verify,
                 timeout=self.timeout
             )
-            
+            print("the response is ", response)
             if not response.ok:
                 error_msg = f"Signup failed: {response.status_code} {response.reason}"
                 try:

{terrakio_core-0.2.0 → terrakio_core-0.2.2}/terrakio_core/client.py

@@ -117,12 +117,7 @@ class BaseClient:
             **kwargs
         }
         
-        if not self.quiet:
-            print(f"Requesting data with expression: {expr}")
-            
-        request_url = f"{self.url}/wcs"
-        print("the payload is ", payload)
-        print("the request url is ", request_url)
+        request_url = f"{self.url}/geoquery"
         
         try:
             # Get the shared aiohttp session
@@ -139,12 +134,10 @@ class BaseClient:
                     raise APIError(error_msg)
                 
                 content = await response.read()
-                print("the content is ", content)
                 
                 if output.lower() == "csv":
                     import pandas as pd
                     df = pd.read_csv(BytesIO(content))
-                    print("the content is ", df)
                     return df
                 elif output.lower() == "netcdf":
                     return xr.open_dataset(BytesIO(content))
@@ -159,10 +152,8 @@ class BaseClient:
                             return content
                             
         except aiohttp.ClientError as e:
-            print(f"Client error in wcs_async: {str(e)}")
             raise APIError(f"Request failed: {str(e)}")
         except Exception as e:
-            print(f"Unexpected error in wcs_async: {str(e)}")
             raise
 
     async def close_async(self):
@@ -217,13 +208,49 @@ class BaseClient:
             raise ConfigurationError("Authentication client not initialized. Please provide auth_url during client initialization.")
         return self.auth_client.signup(email, password)
 
-    def login(self, email: str, password: str) -> str:
+    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.")
-        token = self.auth_client.login(email, password)
-        if not self.quiet:
-            print(f"Successfully authenticated as: {email}")
-        return token
+        
+        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()
+                self.key = api_key_response
+                
+                # Save email and API key to config file
+                import os
+                import json
+                config_path = os.path.join(os.environ.get("HOME", ""), ".tkio_config.json")
+                try:
+                    config = {"EMAIL": email, "TERRAKIO_API_KEY": self.key}
+                    if os.path.exists(config_path):
+                        with open(config_path, 'r') as f:
+                            config = json.load(f)
+                        config["EMAIL"] = email
+                        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"Successfully authenticated as: {email}")
+                        print(f"API key saved to {config_path}")
+                except Exception as e:
+                    if not self.quiet:
+                        print(f"Warning: Failed to update config file: {e}")
+            
+            return {"token": token_response} if token_response else {"error": "Login failed"}
+        except Exception as e:
+            if not self.quiet:
+                print(f"Login failed: {str(e)}")
+            raise
 
     def refresh_api_key(self) -> str:
         if not self.auth_client:
@@ -286,11 +313,7 @@ class BaseClient:
             "expr": expr,
             **kwargs
         }
-        if not self.quiet:
-            print(f"Requesting data with expression: {expr}")
-        request_url = f"{self.url}/wcs"
-        print("the payload is ", payload)
-        print("the request url is ", request_url)
+        request_url = f"{self.url}/geoquery"
         try:
             response = self.session.post(request_url, json=payload, timeout=self.timeout, verify=self.verify)
             if not response.ok:
@@ -486,11 +509,17 @@ class BaseClient:
         return self.dataset_management.delete_dataset(name=name, collection=collection)
 
     def close(self):
+        """Close all client sessions"""
         self.session.close()
         if self.auth_client:
             self.auth_client.session.close()
+        # Close aiohttp session if it exists
+        if self._aiohttp_session and not self._aiohttp_session.closed:
+            asyncio.run(self.close_async())
+
     def __enter__(self):
         return self
+
     def __exit__(self, exc_type, exc_val, exc_tb):
         self.close()
 
@@ -647,8 +676,6 @@ class BaseClient:
         import geopandas as gpd
         from shapely.geometry import mapping
         
-        print(f"Starting zonal_stats_async with {len(gdb)} geometries")
-        
         # Process geometries in batches
         all_results = []
         row_indices = []
@@ -661,20 +688,16 @@ class BaseClient:
                     "geometry": mapping(geom),
                     "properties": {"index": index}
                 }
-                print(f"Processing geometry {index}")
                 result = await self.wcs_async(expr=expr, feature=feature, output=output)
-                print(f"Got result for geometry {index}: {type(result)}")
                 # Add original index to track which geometry this result belongs to
                 if isinstance(result, pd.DataFrame):
                     result['_geometry_index'] = index
                 return result
             except Exception as e:
-                print(f"Error in process_geometry for index {index}: {str(e)}")
                 raise
         
         async def process_batch(batch_indices):
             """Process a batch of geometries concurrently using TaskGroup"""
-            print(f"Processing batch with indices: {list(batch_indices)}")
             try:
                 async with asyncio.TaskGroup() as tg:
                     tasks = []
@@ -688,34 +711,28 @@ class BaseClient:
                 for task in tasks:
                     try:
                         result = task.result()
-                        print(f"Task completed successfully: {type(result)}")
                         results.append(result)
                     except Exception as e:
-                        print(f"Error getting task result: {str(e)}")
                         raise
                 
                 return results
             except* Exception as e:
-                print(f"TaskGroup error: {str(e)}")
                 # Get the actual exceptions from the tasks
                 for task in tasks:
                     if task.done() and task.exception():
-                        print(f"Task exception: {str(task.exception())}")
+                        raise task.exception()
                 raise
             
         # Process in batches to control concurrency
         for i in range(0, len(gdb), conc):
             batch_indices = range(i, min(i + conc, len(gdb)))
             try:
-                print(f"Starting batch {i//conc + 1}")
                 batch_results = await process_batch(batch_indices)
-                print(f"Batch {i//conc + 1} completed successfully")
                 all_results.extend(batch_results)
                 row_indices.extend(batch_indices)
             except Exception as e:
-                print(f"Error processing batch starting at index {i}: {str(e)}")
                 if hasattr(e, 'response'):
-                    print(f"API Response: {e.response.text}")
+                    raise APIError(f"API request failed: {e.response.text}")
                 raise
         
         if not all_results:
@@ -778,7 +795,6 @@ class BaseClient:
             
             if inplace:
                 # Can't really do inplace with multi-temporal results as we're changing the structure
-                print("Warning: inplace=True ignored for temporal results, returning new GeoDataFrame")
                 return result_gdf
             else:
                 return result_gdf
@@ -825,5 +841,133 @@ class BaseClient:
             geopandas.GeoDataFrame: GeoDataFrame with added columns for results, or None if inplace=True
         """
         import asyncio
-        return asyncio.run(self.zonal_stats_async(gdb, expr, conc, inplace, output))
+        result = asyncio.run(self.zonal_stats_async(gdb, expr, conc, inplace, output))
+        # Ensure aiohttp session is closed after running async code
+        try:
+            if self._aiohttp_session and not self._aiohttp_session.closed:
+                asyncio.run(self.close_async())
+        except RuntimeError:
+            # Event loop may already be closed, ignore
+            pass
+        return result
+
+    # Group access management protected methods
+    def _get_group_users_and_datasets(self, group_name: str):
+        if not hasattr(self, "group_access_management") or self.group_access_management is None:
+            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(
+                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)
+
+    def _add_group_to_dataset(self, dataset: str, group: str):
+        if not hasattr(self, "group_access_management") or self.group_access_management is None:
+            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(
+                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)
+
+    def _add_group_to_user(self, uid: str, group: str):
+        if not hasattr(self, "group_access_management") or self.group_access_management is None:
+            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(
+                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)
+
+    def _delete_group_from_user(self, uid: str, group: str):
+        if not hasattr(self, "group_access_management") or self.group_access_management is None:
+            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(
+                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)
+
+    def _delete_group_from_dataset(self, dataset: str, group: str):
+        if not hasattr(self, "group_access_management") or self.group_access_management is None:
+            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(
+                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)
+
+    # Space management protected methods
+    def _get_total_space_used(self):
+        if not hasattr(self, "space_management") or self.space_management is None:
+            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.")
+            self.space_management = SpaceManagement(
+                api_url=self.url,
+                api_key=self.key,
+                verify=self.verify,
+                timeout=self.timeout
+            )
+        return self.space_management.get_total_space_used()
+
+    def _get_space_used_by_job(self, name: str, region: str = None):
+        if not hasattr(self, "space_management") or self.space_management is None:
+            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.")
+            self.space_management = SpaceManagement(
+                api_url=self.url,
+                api_key=self.key,
+                verify=self.verify,
+                timeout=self.timeout
+            )
+        return self.space_management.get_space_used_by_job(name, region)
+
+    def _delete_user_job(self, name: str, region: str = None):
+        if not hasattr(self, "space_management") or self.space_management is None:
+            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.")
+            self.space_management = SpaceManagement(
+                api_url=self.url,
+                api_key=self.key,
+                verify=self.verify,
+                timeout=self.timeout
+            )
+        return self.space_management.delete_user_job(name, region)
+
+    def _delete_data_in_path(self, path: str, region: str = None):
+        if not hasattr(self, "space_management") or self.space_management is None:
+            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.")
+            self.space_management = SpaceManagement(
+                api_url=self.url,
+                api_key=self.key,
+                verify=self.verify,
+                timeout=self.timeout
+            )
+        return self.space_management.delete_data_in_path(path, region)
 

terrakio_core-0.2.2/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)}")
+

terrakio_core-0.2.2/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-0.2.0 → terrakio_core-0.2.2}/terrakio_core/user_management.py

@@ -148,7 +148,7 @@ class UserManagement:
             APIError: If the API request fails
         """
         # Use the base API URL instead of hardcoding
-        endpoint = f"{self.api_url}/admin/users"
+        endpoint = "https://terrakio-server-lark-573248941006.australia-southeast1.run.app/admin/users"
 
         params = {}
         if substring:

{terrakio_core-0.2.0 → terrakio_core-0.2.2}/terrakio_core.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: terrakio-core
-Version: 0.2.0
+Version: 0.2.2
 Summary: Core components for Terrakio API clients
 Home-page: https://github.com/HaizeaAnalytics/terrakio-python-api
 Author: Yupeng Chao
@@ -22,6 +22,7 @@ Requires-Dist: aiohttp>=3.8.0
 Requires-Dist: pyyaml>=5.1
 Requires-Dist: xarray>=2023.1.0
 Requires-Dist: shapely>=2.0.0
+Requires-Dist: geopandas>=0.13.0
 Dynamic: author
 Dynamic: home-page
 Dynamic: requires-python

{terrakio_core-0.2.0 → terrakio_core-0.2.2}/terrakio_core.egg-info/SOURCES.txt

@@ -7,7 +7,9 @@ terrakio_core/client.py
 terrakio_core/config.py
 terrakio_core/dataset_management.py
 terrakio_core/exceptions.py
+terrakio_core/group_access_management.py
 terrakio_core/mass_stats.py
+terrakio_core/space_management.py
 terrakio_core/user_management.py
 terrakio_core.egg-info/PKG-INFO
 terrakio_core.egg-info/SOURCES.txt

{terrakio_core-0.2.0 → terrakio_core-0.2.2}/terrakio_core.egg-info/requires.txt

@@ -3,3 +3,4 @@ aiohttp>=3.8.0
 pyyaml>=5.1
 xarray>=2023.1.0
 shapely>=2.0.0
+geopandas>=0.13.0