terrakio-core 0.1.9__py3-none-any.whl → 0.2.0__py3-none-any.whl

terrakio_core/client.py

@@ -3,6 +3,8 @@ import xarray as xr
 from io import BytesIO
 from typing import Dict, Any, Optional, Union
 import json
+import aiohttp
+import asyncio
 from shapely.geometry import shape
 from shapely.geometry.base import BaseGeometry as ShapelyGeometry
 from .exceptions import APIError, ConfigurationError
@@ -63,6 +65,117 @@ class BaseClient:
         })
         self.user_management = None
         self.dataset_management = None
+        self.mass_stats = None
+        self._aiohttp_session = None
+
+    @property
+    async def aiohttp_session(self):
+        if self._aiohttp_session is None or self._aiohttp_session.closed:
+            self._aiohttp_session = aiohttp.ClientSession(
+                headers={
+                    'Content-Type': 'application/json',
+                    'x-api-key': self.key
+                },
+                timeout=aiohttp.ClientTimeout(total=self.timeout)
+            )
+        return self._aiohttp_session
+
+    async def wcs_async(self, expr: str, feature: Union[Dict[str, Any], ShapelyGeometry], 
+                       in_crs: str = "epsg:4326", out_crs: str = "epsg:4326", 
+                       output: str = "csv", resolution: int = -1, **kwargs):
+        """
+        Asynchronous version of the wcs() method using aiohttp.
+        
+        Args:
+            expr (str): The WCS expression to evaluate
+            feature (Union[Dict[str, Any], ShapelyGeometry]): The geographic feature
+            in_crs (str): Input coordinate reference system
+            out_crs (str): Output coordinate reference system
+            output (str): Output format ('csv' or 'netcdf')
+            resolution (int): Resolution parameter
+            **kwargs: Additional parameters to pass to the WCS request
+            
+        Returns:
+            Union[pd.DataFrame, xr.Dataset, bytes]: The response data in the requested format
+        """
+        if hasattr(feature, 'is_valid'):
+            from shapely.geometry import mapping
+            feature = {
+                "type": "Feature",
+                "geometry": mapping(feature),
+                "properties": {}
+            }
+        self.validate_feature(feature)
+        
+        payload = {
+            "feature": feature,
+            "in_crs": in_crs,
+            "out_crs": out_crs,
+            "output": output,
+            "resolution": resolution,
+            "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)
+        
+        try:
+            # Get the shared aiohttp session
+            session = await self.aiohttp_session
+            async with session.post(request_url, json=payload, ssl=self.verify) as response:
+                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)
+                
+                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))
+                else:
+                    try:
+                        return xr.open_dataset(BytesIO(content))
+                    except ValueError:
+                        import pandas as pd
+                        try:
+                            return pd.read_csv(BytesIO(content))
+                        except:
+                            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):
+        """Close the aiohttp session"""
+        if self._aiohttp_session and not self._aiohttp_session.closed:
+            await self._aiohttp_session.close()
+            self._aiohttp_session = None
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self.close_async()
 
     def validate_feature(self, feature: Dict[str, Any]) -> None:
         if hasattr(feature, 'is_valid'):
@@ -176,6 +289,8 @@ class BaseClient:
         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)
         try:
             response = self.session.post(request_url, json=payload, timeout=self.timeout, verify=self.verify)
             if not response.ok:
@@ -378,3 +493,337 @@ class BaseClient:
         return self
     def __exit__(self, exc_type, exc_val, exc_tb):
         self.close()
+
+    # Mass Stats methods
+    def upload_mass_stats(self, name, size, bucket, output, location=None, **kwargs):
+        if not self.mass_stats:
+            from terrakio_core.mass_stats import MassStats
+            if not self.url or not self.key:
+                raise ConfigurationError("Mass Stats client not initialized. Make sure API URL and key are set.")
+            self.mass_stats = MassStats(
+                base_url=self.url,
+                api_key=self.key,
+                verify=self.verify,
+                timeout=self.timeout
+            )
+        return self.mass_stats.upload_request(name, size, bucket, output, location, **kwargs)
+
+    def start_mass_stats_job(self, task_id):
+        if not self.mass_stats:
+            from terrakio_core.mass_stats import MassStats
+            if not self.url or not self.key:
+                raise ConfigurationError("Mass Stats client not initialized. Make sure API URL and key are set.")
+            self.mass_stats = MassStats(
+                base_url=self.url,
+                api_key=self.key,
+                verify=self.verify,
+                timeout=self.timeout
+            )
+        return self.mass_stats.start_job(task_id)
+
+    def get_mass_stats_task_id(self, name, stage, uid=None):
+        if not self.mass_stats:
+            from terrakio_core.mass_stats import MassStats
+            if not self.url or not self.key:
+                raise ConfigurationError("Mass Stats client not initialized. Make sure API URL and key are set.")
+            self.mass_stats = MassStats(
+                base_url=self.url,
+                api_key=self.key,
+                verify=self.verify,
+                timeout=self.timeout
+            )
+        return self.mass_stats.get_task_id(name, stage, uid)
+
+    def track_mass_stats_job(self, ids=None):
+        if not self.mass_stats:
+            from terrakio_core.mass_stats import MassStats
+            if not self.url or not self.key:
+                raise ConfigurationError("Mass Stats client not initialized. Make sure API URL and key are set.")
+            self.mass_stats = MassStats(
+                base_url=self.url,
+                api_key=self.key,
+                verify=self.verify,
+                timeout=self.timeout
+            )
+        return self.mass_stats.track_job(ids)
+
+    def get_mass_stats_history(self, limit=100):
+        if not self.mass_stats:
+            from terrakio_core.mass_stats import MassStats
+            if not self.url or not self.key:
+                raise ConfigurationError("Mass Stats client not initialized. Make sure API URL and key are set.")
+            self.mass_stats = MassStats(
+                base_url=self.url,
+                api_key=self.key,
+                verify=self.verify,
+                timeout=self.timeout
+            )
+        return self.mass_stats.get_history(limit)
+
+    def start_mass_stats_post_processing(self, process_name, data_name, output, consumer_path, overwrite=False):
+        if not self.mass_stats:
+            from terrakio_core.mass_stats import MassStats
+            if not self.url or not self.key:
+                raise ConfigurationError("Mass Stats client not initialized. Make sure API URL and key are set.")
+            self.mass_stats = MassStats(
+                base_url=self.url,
+                api_key=self.key,
+                verify=self.verify,
+                timeout=self.timeout
+            )
+        return self.mass_stats.start_post_processing(process_name, data_name, output, consumer_path, overwrite)
+
+    def download_mass_stats_results(self, id=None, force_loc=False, **kwargs):
+        if not self.mass_stats:
+            from terrakio_core.mass_stats import MassStats
+            if not self.url or not self.key:
+                raise ConfigurationError("Mass Stats client not initialized. Make sure API URL and key are set.")
+            self.mass_stats = MassStats(
+                base_url=self.url,
+                api_key=self.key,
+                verify=self.verify,
+                timeout=self.timeout
+            )
+        return self.mass_stats.download_results(id, force_loc, **kwargs)
+
+    def cancel_mass_stats_job(self, id):
+        if not self.mass_stats:
+            from terrakio_core.mass_stats import MassStats
+            if not self.url or not self.key:
+                raise ConfigurationError("Mass Stats client not initialized. Make sure API URL and key are set.")
+            self.mass_stats = MassStats(
+                base_url=self.url,
+                api_key=self.key,
+                verify=self.verify,
+                timeout=self.timeout
+            )
+        return self.mass_stats.cancel_job(id)
+
+    def cancel_all_mass_stats_jobs(self):
+        if not self.mass_stats:
+            from terrakio_core.mass_stats import MassStats
+            if not self.url or not self.key:
+                raise ConfigurationError("Mass Stats client not initialized. Make sure API URL and key are set.")
+            self.mass_stats = MassStats(
+                base_url=self.url,
+                api_key=self.key,
+                verify=self.verify,
+                timeout=self.timeout
+            )
+        return self.mass_stats.cancel_all_jobs()
+
+    def _create_pyramids(self, name, levels, config):
+        if not self.mass_stats:
+            from terrakio_core.mass_stats import MassStats
+            if not self.url or not self.key:
+                raise ConfigurationError("Mass Stats client not initialized. Make sure API URL and key are set.")
+            self.mass_stats = MassStats(
+                base_url=self.url,
+                api_key=self.key,
+                verify=self.verify,
+                timeout=self.timeout
+            )
+        return self.mass_stats.create_pyramids(name, levels, config)
+
+    def random_sample(self, name, **kwargs):
+        if not self.mass_stats:
+            from terrakio_core.mass_stats import MassStats
+            if not self.url or not self.key:
+                raise ConfigurationError("Mass Stats client not initialized. Make sure API URL and key are set.")
+            self.mass_stats = MassStats(
+                base_url=self.url,
+                api_key=self.key,
+                verify=self.verify,
+                timeout=self.timeout
+            )
+        return self.mass_stats.random_sample(name, **kwargs)
+
+    async def zonal_stats_async(self, gdb, expr, conc=20, inplace=False, output="csv"):
+        """
+        Compute zonal statistics for all geometries in a GeoDataFrame using asyncio for concurrency.
+        """
+        import asyncio
+        import pandas as pd
+        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 = []
+        
+        async def process_geometry(geom, index):
+            """Process a single geometry"""
+            try:
+                feature = {
+                    "type": "Feature",
+                    "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 = []
+                    for idx in batch_indices:
+                        geom = gdb.geometry.iloc[idx]
+                        task = tg.create_task(process_geometry(geom, idx))
+                        tasks.append(task)
+                
+                # Get results from completed tasks
+                results = []
+                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
+            
+        # 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
+        
+        if not all_results:
+            raise ValueError("No valid results were returned for any geometry")
+            
+        # Combine all results
+        combined_df = pd.concat(all_results, ignore_index=True)
+        
+        # Check if we have temporal results
+        has_time = 'time' in combined_df.columns
+        
+        # Create a result GeoDataFrame
+        if has_time:
+            # For temporal data, we'll create a hierarchical index
+            # First make sure we have the geometry index and time columns
+            if '_geometry_index' not in combined_df.columns:
+                raise ValueError("Missing geometry index in results")
+            
+            # Create hierarchical index on geometry_index and time
+            combined_df.set_index(['_geometry_index', 'time'], inplace=True)
+            
+            # For each unique geometry index, we need the corresponding geometry
+            geometry_series = gdb.geometry.copy()
+            
+            # Get columns that will become new attributes (exclude index/utility columns)
+            result_cols = combined_df.columns
+            
+            # Create a new GeoDataFrame with multi-index
+            result_rows = []
+            geometries = []
+            
+            # Iterate through the hierarchical index
+            for (geom_idx, time_val), row in combined_df.iterrows():
+                # Create a new row with geometry properties + result columns
+                new_row = {}
+                
+                # Add original GeoDataFrame columns (except geometry)
+                for col in gdb.columns:
+                    if col != 'geometry':
+                        new_row[col] = gdb.loc[geom_idx, col]
+                
+                # Add result columns
+                for col in result_cols:
+                    new_row[col] = row[col]
+                
+                result_rows.append(new_row)
+                geometries.append(gdb.geometry.iloc[geom_idx])
+            
+            # Create a new GeoDataFrame with multi-index
+            multi_index = pd.MultiIndex.from_tuples(
+                combined_df.index.tolist(),
+                names=['geometry_index', 'time']
+            )
+            
+            result_gdf = gpd.GeoDataFrame(
+                result_rows, 
+                geometry=geometries,
+                index=multi_index
+            )
+            
+            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
+        else:
+            # Non-temporal data - just add new columns to the existing GeoDataFrame
+            result_gdf = gdb.copy() if not inplace else gdb
+            
+            # Get column names from the results (excluding utility columns)
+            result_cols = [col for col in combined_df.columns if col not in ['_geometry_index']]
+            
+            # Create a mapping from geometry index to result rows
+            geom_idx_to_row = {}
+            for idx, row in combined_df.iterrows():
+                geom_idx = int(row['_geometry_index'])
+                geom_idx_to_row[geom_idx] = row
+            
+            # Add results as new columns to the GeoDataFrame
+            for col in result_cols:
+                # Initialize the column with None or appropriate default
+                if col not in result_gdf.columns:
+                    result_gdf[col] = None
+                
+                # Fill in values from results
+                for geom_idx, row in geom_idx_to_row.items():
+                    result_gdf.loc[geom_idx, col] = row[col]
+            
+            if inplace:
+                return None
+            else:
+                return result_gdf
+
+    def zonal_stats(self, gdb, expr, conc=20, inplace=False, output="csv"):
+        """
+        Compute zonal statistics for all geometries in a GeoDataFrame.
+        
+        Args:
+            gdb (geopandas.GeoDataFrame): GeoDataFrame containing geometries
+            expr (str): Terrakio expression to evaluate, can include spatial aggregations
+            conc (int): Number of concurrent requests to make
+            inplace (bool): Whether to modify the input GeoDataFrame in place
+            output (str): Output format (csv or netcdf)
+            
+        Returns:
+            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))
+

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-0.1.9.dist-info → terrakio_core-0.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: terrakio-core
-Version: 0.1.9
+Version: 0.2.0
 Summary: Core components for Terrakio API clients
 Home-page: https://github.com/HaizeaAnalytics/terrakio-python-api
 Author: Yupeng Chao
@@ -18,6 +18,7 @@ Classifier: Development Status :: 4 - Beta
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 Requires-Dist: requests>=2.25.0
+Requires-Dist: aiohttp>=3.8.0
 Requires-Dist: pyyaml>=5.1
 Requires-Dist: xarray>=2023.1.0
 Requires-Dist: shapely>=2.0.0

{terrakio_core-0.1.9.dist-info → terrakio_core-0.2.0.dist-info}/RECORD

@@ -1,11 +1,12 @@
 terrakio_core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 terrakio_core/auth.py,sha256=Y3X5CcRUO7rAsrv995cSedZFKJAsW6ObDinYCbcQMpc,7605
-terrakio_core/client.py,sha256=hjWxttPlrKfq5myHqWq2GT23pBGxRplm2FAY5j5YHCA,17441
+terrakio_core/client.py,sha256=A8W-Tun8ZeMnQhr7d6i2ekyl4sylWTVq5amVLUhV6kE,36446
 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/mass_stats.py,sha256=AqYJsd6nqo2BDh4vEPUDgsv4T0UR1_TPDoXa3WO3gTU,9284
 terrakio_core/user_management.py,sha256=Sl7wJOg1eUVUpcsgRjeknibYiIleLJk1VgJI7Mdpsss,7345
-terrakio_core-0.1.9.dist-info/METADATA,sha256=AjBJ_avgfU8vz0ZPzHgQEJZMJboE0F3e1ggGRuw6djM,1488
-terrakio_core-0.1.9.dist-info/WHEEL,sha256=0CuiUZ_p9E4cD6NyLD6UG80LBXYyiSYZOKDm5lp32xk,91
-terrakio_core-0.1.9.dist-info/top_level.txt,sha256=5cBj6O7rNWyn97ND4YuvvXm0Crv4RxttT4JZvNdOG6Q,14
-terrakio_core-0.1.9.dist-info/RECORD,,
+terrakio_core-0.2.0.dist-info/METADATA,sha256=vvW6ODeKysnCJ0FbE2Uf2XbtYn2Tx9SaBlWcLbb50Ds,1518
+terrakio_core-0.2.0.dist-info/WHEEL,sha256=QZxptf4Y1BKFRCEDxD4h2V0mBFQOVFLFEpvxHmIs52A,91
+terrakio_core-0.2.0.dist-info/top_level.txt,sha256=5cBj6O7rNWyn97ND4YuvvXm0Crv4RxttT4JZvNdOG6Q,14
+terrakio_core-0.2.0.dist-info/RECORD,,

{terrakio_core-0.1.9.dist-info → terrakio_core-0.2.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.3.1)
+Generator: setuptools (80.6.0)
 Root-Is-Purelib: true
 Tag: py3-none-any