terrakio-core 0.4.98.1b7__tar.gz → 0.5.8__tar.gz

terrakio_core-0.5.8/.gitignore

@@ -0,0 +1,166 @@
+# Python bytecode cache directories
+__pycache__/
+*.py[cod]
+*$py.class
+
+# Distribution / packaging
+dist/
+build/
+*.egg-info/
+*.egg
+eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.dist-info/
+
+# UV package manager
+.python-version
+.python-versions
+
+# Virtual environments
+venv/
+env/
+ENV/
+.venv/
+.env/
+api_venv/
+*.venv
+virtualenv/
+pipenv/
+
+# PyInstaller
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+Pipfile.lock
+
+# poetry
+poetry.lock
+
+# Celery
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# IDE specific files
+.idea/
+.vscode/
+*.swp
+*.swo
+*~
+
+# OS specific files
+.DS_Store
+.DS_Store?
+Thumbs.db
+ehthumbs.db
+Desktop.ini
+
+# macOS specific files
+.AppleDouble
+.LSOverride
+Icon
+._*
+.DocumentRevisions-V100
+.fseventsd
+.Spotlight-V100
+.TemporaryItems
+.Trashes
+.VolumeIcon.icns
+.com.apple.timemachine.donotpresent
+
+# Windows specific files
+Thumbs.db
+ehthumbs.db
+Desktop.ini
+$RECYCLE.BIN/
+*.cab
+*.msi
+*.msix
+*.msm
+*.msp
+*.lnk
+
+# Linux specific files
+*~
+.fuse_hidden*
+.directory
+.Trash-*
+.nfs*
+
+# Temporary files
+*.tmp
+*.temp
+*.log
+*.bak
+*.swp
+*.swo
+
+# Local configuration files
+.local/
+local_settings.py
+instance/
+.webassets-cache
+
+# Database files
+*.db
+*.sqlite3
+*.sqlite
+
+# Secrets and sensitive files
+.secrets/
+secrets.json
+.env.secrets

{terrakio_core-0.4.98.1b7 → terrakio_core-0.5.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: terrakio-core
-Version: 0.4.98.1b7
+Version: 0.5.8
 Summary: Core package for the terrakio-python-api
 Requires-Python: >=3.11
 Requires-Dist: aiofiles>=24.1.0
@@ -10,8 +10,10 @@ 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

{terrakio_core-0.4.98.1b7 → terrakio_core-0.5.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "terrakio-core"
-version = "0.4.98.1b7"
+version = "0.5.8"
 description = "Core package for the terrakio-python-api"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -11,16 +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.1b7/build/lib → terrakio_core-0.5.8}/terrakio_core/__init__.py

@@ -5,13 +5,15 @@ Terrakio Core
 Core components for Terrakio API clients.
 """
 
-__version__ = "0.4.5"
+# 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.1b7 → 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.1b7 → 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, NetworkError
+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)
@@ -54,7 +54,6 @@ class AsyncClient(BaseClient):
         for attempt in range(self.retry + 1):
             try:
                 async with session.request(method, url, **kwargs) as response:
-                    content = await response.text()
                     
                     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...")
@@ -183,7 +182,10 @@ class AsyncClient(BaseClient):
             "validated": validated,
             **kwargs
         }
-        result = await self._terrakio_request("POST", "geoquery", json=payload)
+        result, status_code = await self._terrakio_request("POST", "geoquery", json=payload)
+
+        if status_code != 200:
+            raise GeoQueryError(result['detail'], status_code=status_code)
 
         return result
 

{terrakio_core-0.4.98.1b7 → 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.1b7 → 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
     

{terrakio_core-0.4.98.1b7 → terrakio_core-0.5.8}/terrakio_core/endpoints/auth.py

@@ -68,6 +68,7 @@ class AuthClient:
             "password": password
         }
         response, status = await self._client._terrakio_request("POST", "/users/login", json=payload)
+
         if status != 200:
             if status == 401:
                 raise InvalidUsernamePasswordError(f"Invalid username or password: {response}", status_code=status)

terrakio_core-0.5.8/terrakio_core/endpoints/collections/__init__.py

@@ -0,0 +1,72 @@
+from rich.console import Console
+
+from .collections import CollectionsMixin
+from .common import Dataset_Dtype, OutputTypes, Region, regions
+from .data_operations import DataOperationsMixin
+from .generation import DataGenerationMixin
+from .ingestion import IngestionMixin
+from .tasks import TasksMixin
+from .zonal_stats import ZonalStatsMixin
+
+# Import methods directly for better IDE navigation support
+from .collections import (
+    CollectionsMixin as _CollectionsMixin,
+)
+from .tasks import (
+    TasksMixin as _TasksMixin,
+)
+from .data_operations import (
+    DataOperationsMixin as _DataOperationsMixin,
+)
+from .zonal_stats import (
+    ZonalStatsMixin as _ZonalStatsMixin,
+)
+from .ingestion import (
+    IngestionMixin as _IngestionMixin,
+)
+from .generation import (
+    DataGenerationMixin as _DataGenerationMixin,
+)
+
+
+class Collections(
+    CollectionsMixin,
+    TasksMixin,
+    DataOperationsMixin,
+    ZonalStatsMixin,
+    DataGenerationMixin,
+    IngestionMixin
+):
+    """
+    Collections and collection management client.
+    
+    This class provides methods for managing collections, tasks, data operations,
+    zonal statistics, data generation, and ingestion operations.
+    
+    All methods are inherited from the following mixins:
+    - CollectionsMixin: Collection CRUD operations (create_collection, get_collection, list_collections, delete_collection)
+    - TasksMixin: Task management operations (track_progress, list_tasks, get_task, cancel_task, etc.)
+    - DataOperationsMixin: Data generation and processing (generate_data, post_processing, gen_and_process, download_files, upload_artifacts)
+    - ZonalStatsMixin: Zonal statistics operations (zonal_stats, zonal_stats_transform)
+    - DataGenerationMixin: Data generation operations (training_samples, dataset, tiles, polygons)
+    - IngestionMixin: Data ingestion and visualization (create_pyramids, tif)
+    
+    Note: Methods are defined in their respective mixin modules:
+    - Collection methods: .collections module
+    - Task methods: .tasks module
+    - Data operation methods: .data_operations module
+    - Zonal stats methods: .zonal_stats module
+    - Data generation methods: .generation module
+    - Ingestion methods: .ingestion module
+    """
+    
+    def __init__(self, client):
+        self._client = client
+        self.console = Console()
+        self.OutputTypes = OutputTypes
+        self.Region = Region
+        self.regions = regions
+        self.Dataset_Dtype = Dataset_Dtype
+
+# Explicitly re-export for better IDE support
+__all__ = ['Collections', 'OutputTypes', 'Region', 'Dataset_Dtype', 'regions']

terrakio_core-0.5.8/terrakio_core/endpoints/collections/collections.py

@@ -0,0 +1,166 @@
+from typing import Any, Dict, List, Optional
+
+from ...exceptions import (
+    CollectionAlreadyExistsError,
+    CollectionNotFoundError,
+    CreateCollectionError,
+    DeleteCollectionError,
+    GetCollectionError,
+    InvalidCollectionTypeError,
+    ListCollectionsError,
+)
+from ...helper.decorators import require_api_key
+
+
+class CollectionsMixin:
+    """Collection CRUD operations."""
+    
+    @require_api_key
+    async def create_collection(
+        self, 
+        collection: str, 
+        bucket: Optional[str] = None, 
+        location: Optional[str] = None, 
+        collection_type: str = "basic"
+    ) -> Dict[str, Any]:
+        """
+        Create a collection for the current user.
+
+        Args:
+            collection: The name of the collection (required)
+            bucket: The bucket to use (optional, admin only)
+            location: The location to use (optional, admin only)
+            collection_type: The type of collection to create (optional, defaults to "basic")
+            
+        Returns:
+            API response as a dictionary containing the collection id
+            
+        Raises:
+            CollectionAlreadyExistsError: If the collection already exists
+            InvalidCollectionTypeError: If the collection type is invalid
+            CreateCollectionError: If the API request fails due to unknown reasons
+        """
+        payload = {
+            "collection_type": collection_type
+        }
+        
+        if bucket is not None:
+            payload["bucket"] = bucket
+        
+        if location is not None:
+            payload["location"] = location
+        
+        response, status = await self._client._terrakio_request("POST", f"collections/{collection}", json=payload)
+        if status != 200:
+            if status == 400 or status == 409:
+                raise CollectionAlreadyExistsError(f"Collection {collection} already exists", status_code=status)
+            if status == 422:
+                raise InvalidCollectionTypeError(f"Invalid collection type: {collection_type}", status_code=status)
+            raise CreateCollectionError(f"Create collection failed with status {status}", status_code=status)
+
+        return response
+
+    @require_api_key
+    async def get_collection(self, collection: str) -> Dict[str, Any]:
+        """
+        Get a collection by name.
+
+        Args:
+            collection: The name of the collection to retrieve(required)
+            
+        Returns:
+            API response as a dictionary containing collection information
+            
+        Raises:
+            CollectionNotFoundError: If the collection is not found
+            GetCollectionError: If the API request fails due to unknown reasons
+        """
+        response, status = await self._client._terrakio_request("GET", f"collections/{collection}")
+
+        if status != 200:
+            if status == 404:
+                raise CollectionNotFoundError(f"Collection {collection} not found", status_code=status)
+            raise GetCollectionError(f"Get collection failed with status {status}", status_code=status)
+        
+        return response
+
+    @require_api_key
+    async def list_collections(
+        self,
+        collection_type: Optional[str] = None,
+        limit: Optional[int] = 10,
+        page: Optional[int] = 0
+    ) -> List[Dict[str, Any]]:
+        """
+        List collections for the current user.
+
+        Args:
+            collection_type: Filter by collection type (optional)
+            limit: Number of collections to return (optional, defaults to 10)
+            page: Page number (optional, defaults to 0)
+            
+        Returns:
+            API response as a list of dictionaries containing collection information
+            
+        Raises:
+            ListCollectionsError: If the API request fails due to unknown reasons
+        """
+        params = {}
+        
+        if collection_type is not None:
+            params["collection_type"] = collection_type
+        
+        if limit is not None:
+            params["limit"] = limit
+            
+        if page is not None:
+            params["page"] = page
+        
+        response, status = await self._client._terrakio_request("GET", "collections", params=params)
+
+        if status != 200:
+            raise ListCollectionsError(f"List collections failed with status {status}", status_code=status)
+        
+        return response
+
+    @require_api_key
+    async def delete_collection(
+        self, 
+        collection: str, 
+        full: Optional[bool] = False, 
+        outputs: Optional[list] = [], 
+        data: Optional[bool] = False
+    ) -> Dict[str, Any]:
+        """
+        Delete a collection by name.
+
+        Args:
+            collection: The name of the collection to delete (required)
+            full: Delete the full collection (optional, defaults to False)
+            outputs: Specific output folders to delete (optional, defaults to empty list)
+            data: Whether to delete raw data (xdata folder) (optional, defaults to False)
+            
+        Returns:
+            API response as a dictionary confirming deletion
+            
+        Raises:
+            CollectionNotFoundError: If the collection is not found
+            DeleteCollectionError: If the API request fails due to unknown reasons
+        """
+        params = {
+            "full": str(full).lower(),
+            "data": str(data).lower()
+        }
+        
+        if outputs:
+            params["outputs"] = outputs
+        
+        response, status = await self._client._terrakio_request("DELETE", f"collections/{collection}", params=params)
+
+        if status != 200:
+            if status == 404:
+                raise CollectionNotFoundError(f"Collection {collection} not found", status_code=status)
+            raise DeleteCollectionError(f"Delete collection failed with status {status}", status_code=status)
+
+        return response
+