terrakio-core 0.4.98__tar.gz → 0.5.8__tar.gz

{terrakio_core-0.4.98 → terrakio_core-0.5.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: terrakio-core
-Version: 0.4.98
+Version: 0.5.8
 Summary: Core package for the terrakio-python-api
 Requires-Python: >=3.11
 Requires-Dist: aiofiles>=24.1.0
@@ -10,10 +10,13 @@ Requires-Dist: h5netcdf>=1.6.3
 Requires-Dist: h5py>=3.14.0
 Requires-Dist: nest-asyncio>=1.6.0
 Requires-Dist: netcdf4>=1.7.2
-Requires-Dist: onnxruntime>=1.22.1
+Requires-Dist: onnxruntime>=1.23.1
 Requires-Dist: psutil>=7.0.0
+Requires-Dist: python-snappy>=0.7.3
+Requires-Dist: rasterio>=1.4.3
 Requires-Dist: scipy>=1.16.1
 Requires-Dist: shapely>=2.1.1
+Requires-Dist: typer>=0.19.2
 Requires-Dist: xarray>=2025.7.1
 Provides-Extra: ml
 Requires-Dist: scikit-learn>=1.7.1; extra == 'ml'

{terrakio_core-0.4.98 → terrakio_core-0.5.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "terrakio-core"
-version = "0.4.98"
+version = "0.5.8"
 description = "Core package for the terrakio-python-api"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -11,15 +11,15 @@ dependencies = [
     "h5netcdf>=1.6.3",
     "h5py>=3.14.0",
     "netcdf4>=1.7.2",
-    "h5py>=3.14.0",
-    "netcdf4>=1.7.2",
-    "onnxruntime>=1.22.1",
     "psutil>=7.0.0",
     "scipy>=1.16.1",
-    "scipy>=1.16.1",
     "shapely>=2.1.1",
     "xarray>=2025.7.1",
     "nest-asyncio>=1.6.0",
+    "typer>=0.19.2",
+    "onnxruntime>=1.23.1",
+    "rasterio>=1.4.3",
+    "python-snappy>=0.7.3",
 ]
 
 [project.optional-dependencies]

{terrakio_core-0.4.98 → terrakio_core-0.5.8}/terrakio_core/__init__.py

@@ -5,13 +5,15 @@ Terrakio Core
 Core components for Terrakio API clients.
 """
 
-__version__ = "0.4.98"
+# Suppress ONNX Runtime GPU device discovery warnings - MUST BE FIRST!
+import os
+os.environ['ORT_LOGGING_LEVEL'] = '3'
+__version__ = "0.5.8"
 
 from .async_client import AsyncClient
 from .sync_client import SyncClient as Client
 from . import accessors
 
-
 __all__ = [
     "AsyncClient", 
     "Client"

{terrakio_core-0.4.98 → terrakio_core-0.5.8}/terrakio_core/accessors.py

@@ -12,7 +12,7 @@ import xarray as xr
 
 # Local/relative imports
 from .convenience_functions.zonal_stats import cloud_object
-from .endpoints.mass_stats import MassStats
+from .endpoints.collections import Collections
 
 @pd.api.extensions.register_dataframe_accessor("geo")
 class GeoXarrayAccessor:
@@ -686,7 +686,7 @@ class GeoXarrayAccessor:
                 asyncio.set_event_loop(loop)
                 try:
                     return loop.run_until_complete(
-                        self._client.mass_stats.track_job([self._obj.job_id])
+                        self._client.collections.track_job([self._obj.job_id])
                     )
                 finally:
                     loop.close()
@@ -845,7 +845,7 @@ class GeoXarrayAccessor:
             script_content = self._generate_post_processing_script()
             client = self._client
             if client:
-                mass_stats = MassStats(client)
+                collections = Collections(client)
                 
                 import asyncio
                 import concurrent.futures
@@ -856,7 +856,7 @@ class GeoXarrayAccessor:
                     # we don't actually have the dataset name, currently it is just getting job named zonal stats job
                     try:
                         return loop.run_until_complete(
-                            mass_stats.zonal_stats_transform(
+                            collections.zonal_stats_transform(
                                 data_name=self._obj.job_name,
                                 output="netcdf",
                                 consumer = script_content.encode('utf-8'),

{terrakio_core-0.4.98 → terrakio_core-0.5.8}/terrakio_core/async_client.py

@@ -9,10 +9,10 @@ from geopandas import GeoDataFrame
 from shapely.geometry.base import BaseGeometry as ShapelyGeometry
 from shapely.geometry import mapping
 from .client import BaseClient
-from .exceptions import APIError
+from .exceptions import APIError, NetworkError, GeoQueryError
 from .endpoints.dataset_management import DatasetManagement
 from .endpoints.user_management import UserManagement
-from .endpoints.mass_stats import MassStats
+from .endpoints.collections import Collections
 from .endpoints.group_management import GroupManagement
 from .endpoints.space_management import SpaceManagement
 from .endpoints.model_management import ModelManagement
@@ -26,7 +26,7 @@ class AsyncClient(BaseClient):
         super().__init__(url, api_key, verbose)
         self.datasets = DatasetManagement(self)
         self.users = UserManagement(self)
-        self.mass_stats = MassStats(self)
+        self.collections = Collections(self)
         self.groups = GroupManagement(self)
         self.space = SpaceManagement(self)
         self.model = ModelManagement(self)
@@ -36,13 +36,10 @@ class AsyncClient(BaseClient):
 
     async def _terrakio_request(self, method: str, endpoint: str, **kwargs):
         if self.session is None:
-            # To this:
             headers = {
                 'x-api-key': self.key, 
                 'Authorization': self.token
             }
-
-            # Only add Content-Type if it's a JSON request
             if 'json' in kwargs:
                 headers['Content-Type'] = 'application/json'
             clean_headers = {k: v for k, v in headers.items() if v is not None}
@@ -57,20 +54,16 @@ class AsyncClient(BaseClient):
         for attempt in range(self.retry + 1):
             try:
                 async with session.request(method, url, **kwargs) as response:
+                    
                     if not response.ok and self._should_retry(response.status, attempt):
                         self.logger.info(f"Request failed (attempt {attempt+1}/{self.retry+1}): {response.status}. Retrying...")
                         continue
-                    if not response.ok:
-                        error_msg = f"API request failed: {response.status} {response.reason}"
-                        try:
-                            error_data = await response.json()
-                            if "detail" in error_data:
-                                error_msg += f" - {error_data['detail']}"
-                        except:
-                            pass
-                        raise APIError(error_msg, status_code=response.status)
-                    return await self._parse_response(response)
-                    
+                    if response.ok:
+                        data = await self._parse_response(response)
+                        return data, response.status
+                    else:
+                        error_data = await response.json()
+                        return error_data, response.status
             except aiohttp.ClientError as e:
                 last_exception = e
                 if attempt < self.retry:
@@ -78,8 +71,8 @@ class AsyncClient(BaseClient):
                     continue
                 else:
                     break
-        
-        raise APIError(f"Networking error, request failed after {self.retry+1} attempts: {last_exception}", status_code=None)
+
+        raise NetworkError(f"Network failure after {self.retry+1} attempts: {last_exception}")
     
     def _should_retry(self, status_code: int, attempt: int) -> bool:
         """Determine if the request should be retried based on status code."""
@@ -189,162 +182,28 @@ class AsyncClient(BaseClient):
             "validated": validated,
             **kwargs
         }
-        result = await self._terrakio_request("POST", "geoquery", json=payload)
-
-        return result
-
-    async def zonal_stats(
-            self,
-            gdf: GeoDataFrame,
-            expr: str,
-            conc: int = 20,
-            in_crs: str = "epsg:4326",
-            out_crs: str = "epsg:4326",
-            resolution: int = -1,
-            geom_fix: bool = False,
-            mass_stats: bool = False,
-            id_column: Optional[str] = None,
-    ):
-        """
-        Compute zonal statistics for all geometries in a GeoDataFrame.
-
-        Args:
-            gdf (GeoDataFrame): GeoDataFrame containing geometries
-            expr (str): Terrakio expression to evaluate, can include spatial aggregations
-            conc (int): Number of concurrent requests to make
-            in_crs (str): Input coordinate reference system
-            out_crs (str): Output coordinate reference system
-            resolution (int): Resolution parameter
-            geom_fix (bool): Whether to fix the geometry (default False)
-            mass_stats (bool): Whether to use mass stats for processing (default False)
-            id_column (Optional[str]): Name of the ID column to use (default None)
-
-        Returns:
-            geopandas.GeoDataFrame: GeoDataFrame with added columns for results
-
-        Raises:
-            ValueError: If concurrency is too high or if data exceeds memory limit without streaming
-            APIError: If the API request fails
-        """
-        # the sync client didn't pass the self here, so the client is now async
-        return await _zonal_stats(
-            client=self,
-            gdf=gdf,
-            expr=expr,
-            conc=conc,
-            in_crs=in_crs,
-            out_crs=out_crs,
-            resolution=resolution,
-            geom_fix=geom_fix,
-            mass_stats=mass_stats,
-            id_column=id_column,
-        )
+        result, status_code = await self._terrakio_request("POST", "geoquery", json=payload)
 
-    async def create_dataset_file(
-        self,
-        name: str,
-        aoi: str,
-        expression: str,
-        output: str,
-        in_crs: str = "epsg:4326",
-        res: float = 0.0001,
-        region: str = "aus",
-        to_crs: str = "epsg:4326",
-        overwrite: bool = True,
-        skip_existing: bool = False,
-        non_interactive: bool = True,
-        poll_interval: int = 30,
-        download_path: str = "/home/user/Downloads",
-        mask = True,
-        max_file_size_mb: int = 5120,  # Default to 5GB
-        tile_size: int = 1024,
-    ) -> dict:
-        """
-        Create a dataset file using mass stats operations.
-
-        Args:
-            aoi (str): Area of interest
-            expression (str): Terrakio expression to evaluate
-            output (str): Output format
-            in_crs (str): Input coordinate reference system (default "epsg:4326")
-            res (float): Resolution (default 0.0001)
-            region (str): Region (default "aus")
-            to_crs (str): Target coordinate reference system (default "epsg:4326")
-            overwrite (bool): Whether to overwrite existing files (default True)
-            skip_existing (bool): Whether to skip existing files (default False)
-            non_interactive (bool): Whether to run non-interactively (default True)
-            poll_interval (int): Polling interval in seconds (default 30)
-            download_path (str): Download path (default "/home/user/Downloads")
-
-        Returns:
-            dict: Dictionary containing generation_task_id and combine_task_id
-
-        Raises:
-            ConfigurationError: If mass stats client is not properly configured
-            RuntimeError: If job fails
-        """
-        return await _create_dataset_file(
-            client=self,
-            aoi=aoi,
-            expression=expression,
-            output=output,
-            in_crs=in_crs,
-            res=res,
-            region=region,
-            to_crs=to_crs,
-            overwrite=overwrite,
-            skip_existing=skip_existing,
-            non_interactive=non_interactive,
-            poll_interval=poll_interval,
-            download_path=download_path,
-            name=name,
-            mask=mask,
-            max_file_size_mb=max_file_size_mb,
-            tile_size=tile_size
-        )
-
-    async def geo_queries(
-        self,
-        queries: list[dict],
-        conc: int = 20,
-    ):
-        """
-        Execute multiple geo queries concurrently.
+        if status_code != 200:
+            raise GeoQueryError(result['detail'], status_code=status_code)
 
-        Args:
-            queries (list[dict]): List of dictionaries containing query parameters.
-                                  Each query must have 'expr', 'feature', and 'in_crs' keys.
-            conc (int): Number of concurrent requests to make (default 20, max 100)
-
-        Returns:
-            Union[float, geopandas.GeoDataFrame]: 
-                - float: Average of all results if results are integers
-                - GeoDataFrame: GeoDataFrame with geometry and dataset columns if results are xarray datasets
-
-        Raises:
-            ValueError: If queries list is empty, concurrency is too high, or queries are malformed
-            APIError: If the API request fails
+        return result
 
-        Example:
-            queries = [
-                {
-                    'expr': 'WCF.wcf',
-                    'feature': {'type': 'Feature', 'geometry': {...}, 'properties': {}},
-                    'in_crs': 'epsg:4326'
-                },
-                {
-                    'expr': 'NDVI.ndvi',
-                    'feature': {'type': 'Feature', 'geometry': {...}, 'properties': {}},
-                    'in_crs': 'epsg:4326'
-                }
-            ]
-            result = await client.geo_queries(queries)
-        """
-        return await _request_geoquery_list(
-            client=self,
-            quries=queries,  # Note: keeping original parameter name for compatibility
-            conc=conc,
-        )
+    async def zonal_stats(self, *args, **kwargs):
+        """Proxy to convenience zonal_stats with full argument passthrough."""
+        return await _zonal_stats(self, *args, **kwargs)
+
+    async def create_dataset_file(self, *args, **kwargs) -> dict:
+        """Proxy to convenience create_dataset_file with full argument passthrough."""
+        kwargs.setdefault('download_path', "/home/user/Downloads")
+        kwargs.setdefault('region', "aus")
+        return await _create_dataset_file(self, *args, **kwargs)
+
+    async def geo_queries(self, *args, **kwargs):
+        """Proxy to convenience request_geoquery_list with full argument passthrough."""
+        if 'queries' in kwargs:
+            kwargs['quries'] = kwargs.pop('queries')
+        return await _request_geoquery_list(self, *args, **kwargs)
 
     async def __aenter__(self):
         if self._session is None:

{terrakio_core-0.4.98 → terrakio_core-0.5.8}/terrakio_core/config.py

@@ -7,7 +7,7 @@ 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"
+DEFAULT_API_URL = "https://dev-au.terrak.io"
 
 def read_config_file(config_file: str = DEFAULT_CONFIG_FILE, logger: logging.Logger = None) -> Dict[str, Any]:
     """
@@ -27,14 +27,8 @@ def read_config_file(config_file: str = DEFAULT_CONFIG_FILE, logger: logging.Log
         file if one doesn't exist and returns appropriate status flags.
     """
     config_path = Path(os.path.expanduser(config_file))
-    # the first circumstance is that the config file does not exist
-    # that we need to login before using any of the functions
-    # Check if config file exists
+    
     if not config_path.exists():
-        # Create an empty config file
-        config_path.parent.mkdir(parents=True, exist_ok=True)
-        with open(config_path, 'w') as f:
-            json.dump({}, f)
         logger.info("No API key found. Please provide an API key to use this client.")
         return {
             'url': DEFAULT_API_URL,
@@ -45,12 +39,9 @@ def read_config_file(config_file: str = DEFAULT_CONFIG_FILE, logger: logging.Log
         }
     
     try:
-        # Read the config file
         with open(config_path, 'r') as f:
             config_data = json.load(f)
         
-        # Read the config file data
-        # Check if config has an API key
         if not config_data or 'TERRAKIO_API_KEY' not in config_data or not config_data.get('TERRAKIO_API_KEY'):
             logger.info("No API key found. Please provide an API key to use this client.")
             return {
@@ -61,11 +52,8 @@ def read_config_file(config_file: str = DEFAULT_CONFIG_FILE, logger: logging.Log
                 'token': config_data.get('PERSONAL_TOKEN')
             }
         logger.info(f"Currently logged in as: {config_data.get('EMAIL')}")
-        # this meanb that we have already logged in to the tkio account
         
-        # Convert the JSON config to our expected format
         config = {
-            # Always use the default URL, not from config file
             'url': DEFAULT_API_URL,
             'key': config_data.get('TERRAKIO_API_KEY'),
             'is_logged_in': True,
@@ -84,33 +72,4 @@ def read_config_file(config_file: str = DEFAULT_CONFIG_FILE, logger: logging.Log
             'is_logged_in': False,
             'user_email': None,
             'token': None
-        }
-
-def create_default_config(email: str, api_key: str, config_file: str = DEFAULT_CONFIG_FILE) -> None:
-    """
-    Create a default configuration file in JSON format.
-    
-    Args:
-        email: User email
-        api_key: Terrakio API key
-        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
-        }
-        
-        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-0.4.98 → terrakio_core-0.5.8}/terrakio_core/convenience_functions/create_dataset_file.py

@@ -48,7 +48,7 @@ async def create_dataset_file(
         tempreq.write(reqs)
         tempreqname = tempreq.name
 
-    task_id = await client.mass_stats.execute_job(
+    task_id = await client.collections.execute_job(
         name=body["name"],
         region=body["region"],
         output=body["output"],
@@ -64,7 +64,7 @@ async def create_dataset_file(
     while True:
         try:
             taskid = task_id['task_id']
-            trackinfo = await client.mass_stats.track_job([taskid])
+            trackinfo = await client.collections.track_job([taskid])
             status = trackinfo[taskid]['status']
             if status == 'Completed':
                 client.logger.info('Data generated successfully!')
@@ -86,14 +86,14 @@ async def create_dataset_file(
 
     os.unlink(tempreqname)
 
-    combine_result = await client.mass_stats.combine_tiles(body["name"], body["overwrite"], body["output"], max_file_size_mb=max_file_size_mb)
+    combine_result = await client.collections.combine_tiles(body["name"], body["overwrite"], body["output"], max_file_size_mb=max_file_size_mb)
     combine_task_id = combine_result.get("task_id")
 
     combine_start_time = time.time()
     client.logger.info(f"Tracking file generation job {combine_task_id}...")
     while True:
         try:
-            trackinfo = await client.mass_stats.track_job([combine_task_id])
+            trackinfo = await client.collections.track_job([combine_task_id])
             if body["output"] == "netcdf":
                 download_file_name = trackinfo[combine_task_id]['folder'] + '.nc'
             elif body["output"] == "geotiff":
@@ -117,7 +117,7 @@ async def create_dataset_file(
             raise
 
     if download_path:
-        await client.mass_stats.download_file(
+        await client.collections.download_file(
             job_name=body["name"],
             bucket=bucket,
             file_type='processed',

{terrakio_core-0.4.98 → terrakio_core-0.5.8}/terrakio_core/convenience_functions/zonal_stats.py

@@ -92,7 +92,7 @@ class cloud_object(gpd.GeoDataFrame):
             GeoDataFrame: A GeoDataFrame containing the first n files.
         """
 
-        track_info = await self.client.mass_stats.track_job([self.job_id])
+        track_info = await self.client.collections.track_job([self.job_id])
         job_info = track_info[self.job_id]
         status = job_info['status']
         
@@ -491,7 +491,7 @@ def gdf_to_json(
     id_column: Optional[str] = None,
 ):
     """
-    Convert a GeoDataFrame to a list of JSON requests for mass_stats processing.
+    Convert a GeoDataFrame to a list of JSON requests for collections processing.
     
     Args:
         gdf: GeoDataFrame containing geometries and optional metadata
@@ -503,9 +503,9 @@ def gdf_to_json(
         id_column: Optional column name to use for group and file names
         
     Returns:
-        list: List of dictionaries formatted for mass_stats requests
+        list: List of dictionaries formatted for collections requests
     """
-    mass_stats_requests = []
+    collections_requests = []
     
     for idx, row in gdf.iterrows():
         request_feature = {
@@ -535,11 +535,11 @@ def gdf_to_json(
             "request": request_feature,
         }
         
-        mass_stats_requests.append(request_entry)
+        collections_requests.append(request_entry)
         
-    return mass_stats_requests
+    return collections_requests
 
-async def handle_mass_stats(
+async def handle_collections(
     client,
     gdf: GeoDataFrame,
     expr: str,
@@ -552,7 +552,7 @@ async def handle_mass_stats(
     request_json = gdf_to_json(gdf=gdf, expr=expr, in_crs=in_crs, out_crs=out_crs, 
                               resolution=resolution, geom_fix=geom_fix, id_column=id_column)
     
-    job_response = await client.mass_stats.execute_job(
+    job_response = await client.collections.execute_job(
         name=f"zonal-stats-{str(uuid.uuid4())[:6]}",
         output="netcdf",
         config={},
@@ -581,7 +581,7 @@ async def zonal_stats(
 ):
     """Compute zonal statistics for all geometries in a GeoDataFrame."""
     if mass_stats:
-        mass_stats_id = await handle_mass_stats(
+        collections_id = await handle_collections(
             client = client,
             gdf = gdf,
             expr = expr,
@@ -591,9 +591,9 @@ async def zonal_stats(
             geom_fix = geom_fix,
             id_column = id_column,
         )
-        job_name = await client.mass_stats.track_job([mass_stats_id])
-        job_name = job_name[mass_stats_id]["name"]
-        cloud_files_object = cloud_object(job_id = mass_stats_id, job_name = job_name, client = client)
+        job_name = await client.collections.track_job([collections_id])
+        job_name = job_name[collections_id]["name"]
+        cloud_files_object = cloud_object(job_id = collections_id, job_name = job_name, client = client)
 
         return cloud_files_object