hsclient 0.3.4__tar.gz → 1.0.0__tar.gz

{hsclient-0.3.4 → hsclient-1.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hsclient
-Version: 0.3.4
+Version: 1.0.0
 Summary: A python client for managing HydroShare resources
 Home-page: https://github.com/hydroshare/hsclient
 Author: Scott Black
@@ -13,12 +13,25 @@ Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: hsmodels>=1.0.0
+Requires-Dist: requests
+Requires-Dist: requests_oauthlib
 Provides-Extra: pandas
+Requires-Dist: pandas; extra == "pandas"
 Provides-Extra: xarray
+Requires-Dist: netCDF4; extra == "xarray"
+Requires-Dist: xarray; extra == "xarray"
 Provides-Extra: rasterio
+Requires-Dist: rasterio; extra == "rasterio"
 Provides-Extra: fiona
+Requires-Dist: fiona; extra == "fiona"
 Provides-Extra: all
-License-File: LICENSE.txt
+Requires-Dist: pandas; extra == "all"
+Requires-Dist: netCDF4; extra == "all"
+Requires-Dist: xarray; extra == "all"
+Requires-Dist: rasterio; extra == "all"
+Requires-Dist: fiona; extra == "all"
 
 # hsclient
 A python client for interacting with HydroShare in an object oriented way.

{hsclient-0.3.4 → hsclient-1.0.0}/hsclient/hydroshare.py

@@ -393,7 +393,7 @@ class DataObjectSupportingAggregation(Aggregation):
 
     @staticmethod
     def create(aggr_cls, base_aggr):
-        """creates a type specific aggregation object from an instance of Aggregation"""
+        """Creates a type specific aggregation object from an instance of Aggregation"""
         aggr = aggr_cls(base_aggr._map_path, base_aggr._hs_session, base_aggr._parsed_checksums)
         aggr._retrieved_map = base_aggr._retrieved_map
         aggr._retrieved_metadata = base_aggr._retrieved_metadata
@@ -410,6 +410,8 @@ class DataObjectSupportingAggregation(Aggregation):
     @property
     def data_object(self) -> \
             Union['pandas.DataFrame', 'fiona.Collection', 'rasterio.DatasetReader', 'xarray.Dataset', None]:
+        """Returns the data object for the aggregation if the aggregation has been loaded as
+        a data object, otherwise None"""
         return self._data_object
 
     def _get_file_path(self, agg_path):
@@ -478,18 +480,32 @@ class DataObjectSupportingAggregation(Aggregation):
 
 
 class NetCDFAggregation(DataObjectSupportingAggregation):
+    """Represents a Multidimensional Aggregation in HydroShare"""
 
     @classmethod
     def create(cls, base_aggr):
         return super().create(aggr_cls=cls, base_aggr=base_aggr)
 
     def as_data_object(self, agg_path: str) -> 'xarray.Dataset':
+        """
+        Loads the Multidimensional aggregation to a xarray Dataset object
+        :param agg_path: the path to the Multidimensional aggregation
+        :return: the Multidimensional aggregation as a xarray Dataset object
+        """
         if xarray is None:
             raise Exception("xarray package was not found")
         return self._get_data_object(agg_path=agg_path, func=xarray.open_dataset)
 
     def save_data_object(self, resource: 'Resource', agg_path: str, as_new_aggr: bool = False,
                          destination_path: str = "") -> 'Aggregation':
+        """
+        Saves the xarray Dataset object to the Multidimensional aggregation
+        :param resource: the resource containing the aggregation
+        :param agg_path: the path to the Multidimensional aggregation
+        :param as_new_aggr: Defaults False, set to True to create a new Multidimensional aggregation
+        :param destination_path: the destination path in Hydroshare to save the new aggregation
+        :return: the updated or new Multidimensional aggregation
+        """
 
         self._validate_aggregation_for_update(resource, AggregationType.MultidimensionalAggregation)
         file_path = self._validate_aggregation_path(agg_path, for_save_data=True)
@@ -526,12 +542,18 @@ class NetCDFAggregation(DataObjectSupportingAggregation):
 
 
 class TimeseriesAggregation(DataObjectSupportingAggregation):
-
+    """Represents a Time Series Aggregation in HydroShare"""
     @classmethod
     def create(cls, base_aggr):
         return super().create(aggr_cls=cls, base_aggr=base_aggr)
 
     def as_data_object(self, agg_path: str, series_id: str = "") -> 'pandas.DataFrame':
+        """
+        Loads the Time Series aggregation to a pandas DataFrame object
+        :param agg_path: the path to the Time Series aggregation
+        :param series_id: the series id of the time series to retrieve
+        :return: the Time Series aggregation as a pandas DataFrame object
+        """
         if pandas is None:
             raise Exception("pandas package not found")
 
@@ -548,6 +570,14 @@ class TimeseriesAggregation(DataObjectSupportingAggregation):
     def save_data_object(self, resource: 'Resource', agg_path: str, as_new_aggr: bool = False,
                          destination_path: str = "") -> 'Aggregation':
 
+        """
+        Saves the pandas DataFrame object to the Time Series aggregation
+        :param resource: the resource containing the aggregation
+        :param agg_path: the path to the Time Series aggregation
+        :param as_new_aggr: Defaults False, set to True to create a new Time Series aggregation
+        :param destination_path: the destination path in Hydroshare to save the new aggregation
+        :return: the updated or new Time Series aggregation
+        """
         self._validate_aggregation_for_update(resource, AggregationType.TimeSeriesAggregation)
         file_path = self._validate_aggregation_path(agg_path, for_save_data=True)
         with closing(sqlite3.connect(file_path)) as conn:
@@ -597,7 +627,7 @@ class TimeseriesAggregation(DataObjectSupportingAggregation):
 
 
 class GeoFeatureAggregation(DataObjectSupportingAggregation):
-
+    """Represents a Geo Feature Aggregation in HydroShare"""
     @classmethod
     def create(cls, base_aggr):
         return super().create(aggr_cls=cls, base_aggr=base_aggr)
@@ -616,12 +646,25 @@ class GeoFeatureAggregation(DataObjectSupportingAggregation):
         return file_path
 
     def as_data_object(self, agg_path: str) -> 'fiona.Collection':
+        """
+        Loads the Geo Feature aggregation to a fiona Collection object
+        :param agg_path: the path to the Geo Feature aggregation
+        :return: the Geo Feature aggregation as a fiona Collection object
+        """
         if fiona is None:
             raise Exception("fiona package was not found")
         return self._get_data_object(agg_path=agg_path, func=fiona.open)
 
     def save_data_object(self, resource: 'Resource', agg_path: str, as_new_aggr: bool = False,
                          destination_path: str = "") -> 'Aggregation':
+        """
+        Saves the fiona Collection object to the Geo Feature aggregation
+        :param resource: the resource containing the aggregation
+        :param agg_path: the path to the Geo Feature aggregation
+        :param as_new_aggr: Defaults False, set to True to create a new Geo Feature aggregation
+        :param destination_path: the destination path in Hydroshare to save the new aggregation
+        :return: the updated or new Geo Feature aggregation
+        """
         def upload_shape_files(main_file_path, dst_path=""):
             shp_file_dir_path = os.path.dirname(main_file_path)
             filename_starts_with = f"{pathlib.Path(main_file_path).stem}."
@@ -685,7 +728,7 @@ class GeoFeatureAggregation(DataObjectSupportingAggregation):
 
 
 class GeoRasterAggregation(DataObjectSupportingAggregation):
-
+    """Represents a Geo Raster Aggregation in HydroShare"""
     @classmethod
     def create(cls, base_aggr):
         return super().create(aggr_cls=cls, base_aggr=base_aggr)
@@ -741,12 +784,25 @@ class GeoRasterAggregation(DataObjectSupportingAggregation):
         return file_path
 
     def as_data_object(self, agg_path: str) -> 'rasterio.DatasetReader':
+        """
+        Loads the Geo Raster aggregation to a rasterio DatasetReader object
+        :param agg_path: the path to the Geo Raster aggregation
+        :return: the Geo Raster aggregation as a rasterio DatasetReader object
+        """
         if rasterio is None:
             raise Exception("rasterio package was not found")
         return self._get_data_object(agg_path=agg_path, func=rasterio.open)
 
     def save_data_object(self, resource: 'Resource', agg_path: str, as_new_aggr: bool = False,
                          destination_path: str = "") -> 'Aggregation':
+        """
+        Saves the rasterio DatasetReader object to the Geo Raster aggregation
+        :param resource: the resource containing the aggregation
+        :param agg_path: the path to the Geo Raster aggregation
+        :param as_new_aggr: Defaults False, set to True to create a new Geo Raster aggregation
+        :param destination_path: the destination path in Hydroshare to save the new aggregation
+        :return: the updated or new Geo Raster aggregation
+        """
         def upload_raster_files(dst_path=""):
             raster_files = []
             for item in os.listdir(agg_path):
@@ -808,7 +864,7 @@ class Resource(Aggregation):
 
     @property
     def _hsapi_path(self):
-        path = urlparse(self.metadata.identifier).path
+        path = urlparse(str(self.metadata.identifier)).path
         return '/hsapi' + path
 
     def _upload(self, file, destination_path):
@@ -1308,9 +1364,9 @@ class HydroShareSession:
         of OAuth2 token dropping optional fields that are None."""
         if isinstance(token, dict) or isinstance(token, Token):
             # try to coerce into Token model
-            o = Token.parse_obj(token)
+            o = Token.model_validate(token)
             # drop None fields from output
-            return o.dict(exclude_none=True)
+            return o.model_dump(exclude_none=True)
         else:
             error_message = "token must be hsclient.Token or dictionary following schema:\n" "{}".format(
                 pformat(Token.__annotations__, sort_dicts=False)
@@ -1446,15 +1502,19 @@ class HydroShare:
         if to_date:
             params["to_date"] = to_date.strftime('%Y-%m-%d')
         if spatial_coverage:
-            params["coverage_type"] = spatial_coverage.type
-            if spatial_coverage.type == "point":
-                params["north"] = spatial_coverage.north
-                params["east"] = spatial_coverage.east
-            else:
-                params["north"] = spatial_coverage.northlimit
-                params["east"] = spatial_coverage.eastlimit
-                params["south"] = spatial_coverage.southlimit
-                params["west"] = spatial_coverage.westlimit
+            yield Exception(
+                "Bad Request, status_code 400, spatial_coverage queries are disabled."
+            )
+            # TODO: re-enable after resolution of https://github.com/hydroshare/hydroshare/issues/5240
+            # params["coverage_type"] = spatial_coverage.type
+            # if spatial_coverage.type == "point":
+            #     params["north"] = spatial_coverage.north
+            #     params["east"] = spatial_coverage.east
+            # else:
+            #     params["north"] = spatial_coverage.northlimit
+            #     params["east"] = spatial_coverage.eastlimit
+            #     params["south"] = spatial_coverage.southlimit
+            #     params["west"] = spatial_coverage.westlimit
         response = self._hs_session.get("/hsapi/resource/", 200, params=params)
 
         res = response.json()

{hsclient-0.3.4 → hsclient-1.0.0}/hsclient/json_models.py

@@ -2,7 +2,7 @@ from datetime import datetime
 from typing import Dict, List, Tuple
 
 from hsmodels.schemas.enums import UserIdentifierType
-from pydantic import AnyUrl, BaseModel, validator
+from pydantic import AnyUrl, BaseModel, HttpUrl, field_validator
 
 
 class User(BaseModel):
@@ -12,13 +12,13 @@ class User(BaseModel):
     phone: str = None
     address: str = None
     organization: str = None
-    website: str = None
-    identifiers: Dict[UserIdentifierType, str] = {}
+    website: HttpUrl = None
+    identifiers: Dict[UserIdentifierType, AnyUrl] = {}
     type: str = None
     subject_areas: List[str] = []
     date_joined: datetime = None
 
-    @validator("subject_areas", pre=True)
+    @field_validator("subject_areas", mode='before')
     def split_subject_areas(cls, value):
         return value.split(", ") if value else []
 
@@ -43,7 +43,7 @@ class ResourcePreview(BaseModel):
     resource_map_url: str = None
     resource_metadata_url: str = None
 
-    @validator("authors", pre=True)
+    @field_validator("authors", mode='before')
     def handle_null_author(cls, v):
         # return empty list when supplied authors field is None.
         if v is None:

{hsclient-0.3.4 → hsclient-1.0.0}/hsclient.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hsclient
-Version: 0.3.4
+Version: 1.0.0
 Summary: A python client for managing HydroShare resources
 Home-page: https://github.com/hydroshare/hsclient
 Author: Scott Black
@@ -13,12 +13,25 @@ Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: hsmodels>=1.0.0
+Requires-Dist: requests
+Requires-Dist: requests_oauthlib
 Provides-Extra: pandas
+Requires-Dist: pandas; extra == "pandas"
 Provides-Extra: xarray
+Requires-Dist: netCDF4; extra == "xarray"
+Requires-Dist: xarray; extra == "xarray"
 Provides-Extra: rasterio
+Requires-Dist: rasterio; extra == "rasterio"
 Provides-Extra: fiona
+Requires-Dist: fiona; extra == "fiona"
 Provides-Extra: all
-License-File: LICENSE.txt
+Requires-Dist: pandas; extra == "all"
+Requires-Dist: netCDF4; extra == "all"
+Requires-Dist: xarray; extra == "all"
+Requires-Dist: rasterio; extra == "all"
+Requires-Dist: fiona; extra == "all"
 
 # hsclient
 A python client for interacting with HydroShare in an object oriented way.

{hsclient-0.3.4 → hsclient-1.0.0}/hsclient.egg-info/SOURCES.txt

@@ -11,4 +11,7 @@ hsclient.egg-info/PKG-INFO
 hsclient.egg-info/SOURCES.txt
 hsclient.egg-info/dependency_links.txt
 hsclient.egg-info/requires.txt
-hsclient.egg-info/top_level.txt
+hsclient.egg-info/top_level.txt
+tests/test_data_objects.py
+tests/test_functional.py
+tests/test_json_models.py

{hsclient-0.3.4 → hsclient-1.0.0}/hsclient.egg-info/requires.txt

@@ -1,4 +1,4 @@
-hsmodels>=0.5.5
+hsmodels>=1.0.0
 requests
 requests_oauthlib
 

{hsclient-0.3.4 → hsclient-1.0.0}/setup.py

@@ -5,11 +5,11 @@ README = (pathlib.Path(__file__).parent / "README.md").read_text()
 
 setup(
     name='hsclient',
-    version='0.3.4',
+    version='1.0.0',
     packages=find_packages(include=['hsclient', 'hsclient.*'],
                            exclude=("tests",)),
     install_requires=[
-        'hsmodels>=0.5.5',
+        'hsmodels>=1.0.0',
         'requests',
         'requests_oauthlib',
     ],

hsclient-1.0.0/tests/test_data_objects.py

@@ -0,0 +1,320 @@
+import os
+import pathlib
+import tempfile
+
+import fiona
+import pytest
+import rasterio
+from fiona.model import to_dict
+from hsmodels.schemas.enums import AggregationType
+from rasterio.windows import Window
+
+from hsclient import GeoFeatureAggregation, GeoRasterAggregation, NetCDFAggregation, TimeseriesAggregation
+
+
+@pytest.mark.parametrize("search_by", ["type", "file_path"])
+def test_timeseries_as_data_object(timeseries_resource, search_by):
+    timeseries_resource.refresh()
+    if search_by == 'type':
+        aggr = timeseries_resource.aggregation(type=AggregationType.TimeSeriesAggregation)
+    else:
+        file_path = "ODM2_Multi_Site_One_Variable.sqlite"
+        aggr = timeseries_resource.aggregation(file__path=file_path)
+
+    assert type(aggr) is TimeseriesAggregation
+    series_result = next(
+        r for r in aggr.metadata.time_series_results if r.series_id == "2837b7d9-1ebc-11e6-a16e-f45c8999816f"
+    )
+
+    with tempfile.TemporaryDirectory() as tmp:
+        # download aggregation
+        unzip_to = os.path.join(tmp, "unzipped_aggr")
+        os.makedirs(unzip_to)
+        agg_path = timeseries_resource.aggregation_download(aggregation=aggr, save_path=tmp, unzip_to=unzip_to)
+        # load timseries data for the specified series to pandas DataFrame
+        pd_dataframe = aggr.as_data_object(agg_path=agg_path, series_id=series_result.series_id)
+        assert len(pd_dataframe) == 1333
+
+
+@pytest.mark.parametrize("as_new_aggr", [False, True])
+def test_timeseries_save_data_object(timeseries_resource, as_new_aggr):
+    timeseries_resource.refresh()
+    file_path = "ODM2_Multi_Site_One_Variable.sqlite"
+    aggr = timeseries_resource.aggregation(file__path=file_path)
+    assert aggr is not None
+    assert type(aggr) is TimeseriesAggregation
+    series_id = '4a6f095c-1ebc-11e6-8a10-f45c8999816f'
+    with tempfile.TemporaryDirectory() as tmp:
+        # download aggregation
+        unzip_to = os.path.join(tmp, "unzipped_aggr")
+        os.makedirs(unzip_to)
+        agg_path = timeseries_resource.aggregation_download(aggregation=aggr, save_path=tmp, unzip_to=unzip_to)
+        pd_dataframe = aggr.as_data_object(agg_path=agg_path, series_id=series_id)
+        assert pd_dataframe.__class__.__name__ == "DataFrame"
+        rows, columns = pd_dataframe.shape
+        # delete 10 rows
+        pd_dataframe.drop(pd_dataframe.index[0:10], axis=0, inplace=True)
+        dst_path = ""
+        if as_new_aggr:
+            dst_path = "raster_aggr_folder"
+            timeseries_resource.folder_create(dst_path)
+
+        aggr = aggr.save_data_object(resource=timeseries_resource, agg_path=agg_path, as_new_aggr=as_new_aggr,
+                                     destination_path=dst_path)
+        assert type(aggr) is TimeseriesAggregation
+
+    # check the updated/new timeseries aggregation
+    with tempfile.TemporaryDirectory() as tmp:
+        # download aggregation
+        unzip_to = os.path.join(tmp, "unzipped_aggr")
+        os.makedirs(unzip_to)
+        if as_new_aggr:
+            file_path = f"{dst_path}/{file_path}"
+
+        aggr = timeseries_resource.aggregation(file__path=file_path)
+        assert aggr is not None
+        assert type(aggr) is TimeseriesAggregation
+
+        agg_path = timeseries_resource.aggregation_download(aggregation=aggr, save_path=tmp, unzip_to=unzip_to)
+        pd_dataframe = aggr.as_data_object(agg_path=agg_path, series_id=series_id)
+        updated_rows, update_columns = pd_dataframe.shape
+        assert rows == updated_rows + 10
+        assert columns == update_columns
+
+
+@pytest.mark.parametrize("search_by", ["type", "file_path"])
+def test_raster_as_data_object(resource_with_raster_aggr, search_by):
+    resource_with_raster_aggr.refresh()
+    if search_by == "type":
+        aggr = resource_with_raster_aggr.aggregation(type=AggregationType.GeographicRasterAggregation)
+    else:
+        file_path = "logan.vrt"
+        aggr = resource_with_raster_aggr.aggregation(file__path=file_path)
+
+    assert type(aggr) is GeoRasterAggregation
+
+    with tempfile.TemporaryDirectory() as tmp:
+        # download aggregation
+        unzip_to = os.path.join(tmp, "unzipped_aggr")
+        os.makedirs(unzip_to)
+        agg_path = resource_with_raster_aggr.aggregation_download(aggregation=aggr, save_path=tmp, unzip_to=unzip_to)
+
+        dataset = aggr.as_data_object(agg_path=agg_path)
+        assert dataset.__class__.__name__ == "DatasetReader"
+        # raster should have 1 band
+        assert dataset.count == 1
+
+
+@pytest.mark.parametrize("as_new_aggr", [False, True])
+def test_raster_save_data_object(resource_with_raster_aggr, as_new_aggr):
+    resource_with_raster_aggr.refresh()
+    file_path = "logan.vrt"
+    aggr = resource_with_raster_aggr.aggregation(file__path=file_path)
+    assert aggr is not None
+    assert type(aggr) is GeoRasterAggregation
+    with tempfile.TemporaryDirectory() as tmp:
+        # download aggregation
+        unzip_to = os.path.join(tmp, "unzipped_aggr")
+        os.makedirs(unzip_to)
+        agg_path = resource_with_raster_aggr.aggregation_download(aggregation=aggr, save_path=tmp, unzip_to=unzip_to)
+        rasterio_reader = aggr.as_data_object(agg_path=agg_path)
+        assert rasterio_reader.__class__.__name__ == "DatasetReader"
+        # edit raster data - sub-setting the dataset
+        new_width = rasterio_reader.width - 9
+        new_height = rasterio_reader.height - 10
+        updated_width = new_width
+        updated_height = new_height
+        subset_window = Window(0, 0, new_width, new_height)
+        subset_band = rasterio_reader.read(1, window=subset_window)
+        output_raster_dir_path = os.path.join(tmp, "updated_aggr")
+        os.makedirs(output_raster_dir_path)
+        update_raster_filename = "updated_logan.tif"
+        output_raster_file_path = os.path.join(output_raster_dir_path, update_raster_filename)
+        profile = rasterio_reader.profile
+        rasterio_reader.close()
+        profile['driver'] = "GTiff"
+        profile['width'] = new_width
+        profile['height'] = new_height
+
+        with rasterio.open(output_raster_file_path, "w", **profile) as dst:
+            dst.write(subset_band, 1)
+
+        dst_path = ""
+        if as_new_aggr:
+            dst_path = "raster_aggr_folder"
+            resource_with_raster_aggr.folder_create(dst_path)
+
+        # save the new tif file to update the aggregation or create a new aggregation
+        aggr = aggr.save_data_object(resource=resource_with_raster_aggr, agg_path=output_raster_dir_path,
+                                     as_new_aggr=as_new_aggr, destination_path=dst_path)
+        assert aggr is not None
+        assert type(aggr) is GeoRasterAggregation
+
+    # check the updated raster aggregation
+    with tempfile.TemporaryDirectory() as tmp:
+        # download aggregation
+        unzip_to = os.path.join(tmp, "unzipped_aggr")
+        os.makedirs(unzip_to)
+        file_path = pathlib.Path(update_raster_filename).stem + ".vrt"
+        if as_new_aggr:
+            file_path = f"{dst_path}/{file_path}"
+
+        aggr = resource_with_raster_aggr.aggregation(file__path=file_path)
+        assert aggr is not None
+        assert type(aggr) is GeoRasterAggregation
+
+        agg_path = resource_with_raster_aggr.aggregation_download(aggregation=aggr, save_path=tmp, unzip_to=unzip_to)
+        rasterio_reader = aggr.as_data_object(agg_path=agg_path)
+        assert updated_height == rasterio_reader.height
+        assert updated_width == rasterio_reader.width
+
+
+@pytest.mark.parametrize("search_by", ["type", "file_path"])
+def test_netcdf_as_data_object(resource_with_netcdf_aggr, search_by):
+    resource_with_netcdf_aggr.refresh()
+    if search_by == 'type':
+        aggr = resource_with_netcdf_aggr.aggregation(type=AggregationType.MultidimensionalAggregation)
+    else:
+        file_path = "SWE_time.nc"
+        aggr = resource_with_netcdf_aggr.aggregation(file__path=file_path)
+
+    assert type(aggr) is NetCDFAggregation
+
+    with tempfile.TemporaryDirectory() as tmp:
+        # download aggregation
+        unzip_to = os.path.join(tmp, "unzipped_aggr")
+        os.makedirs(unzip_to)
+        agg_path = resource_with_netcdf_aggr.aggregation_download(aggregation=aggr, save_path=tmp, unzip_to=unzip_to)
+        dataset = aggr.as_data_object(agg_path=agg_path)
+        assert dataset.__class__.__name__ == "Dataset"
+        # netcdf dimensions
+        assert dataset.dims['time'] == 2184
+
+
+@pytest.mark.parametrize("as_new_aggr", [False, True])
+def test_netcdf_save_data_object(resource_with_netcdf_aggr, as_new_aggr):
+    resource_with_netcdf_aggr.refresh()
+    file_path = "SWE_time.nc"
+    aggr = resource_with_netcdf_aggr.aggregation(file__path=file_path)
+    assert aggr is not None
+    assert type(aggr) is NetCDFAggregation
+    with tempfile.TemporaryDirectory() as tmp:
+        # download aggregation
+        unzip_to = os.path.join(tmp, "unzipped_aggr")
+        os.makedirs(unzip_to)
+        agg_path = resource_with_netcdf_aggr.aggregation_download(aggregation=aggr, save_path=tmp, unzip_to=unzip_to)
+        xr_dataset = aggr.as_data_object(agg_path=agg_path)
+        assert xr_dataset.__class__.__name__ == "Dataset"
+        agg_title = "This is a modified title for this aggregation by hsclient"
+        xr_dataset.attrs["title"] = agg_title
+        dst_path = ""
+        if as_new_aggr:
+            dst_path = "netcdf_aggr_folder"
+            resource_with_netcdf_aggr.folder_create(dst_path)
+
+        aggr = aggr.save_data_object(resource=resource_with_netcdf_aggr, agg_path=agg_path, as_new_aggr=as_new_aggr,
+                                     destination_path=dst_path)
+
+        assert type(aggr) is NetCDFAggregation
+        xr_dataset = aggr.as_data_object(agg_path=agg_path)
+        assert xr_dataset.attrs["title"] == agg_title
+
+    # check the updated/new netcdf aggregation
+    with tempfile.TemporaryDirectory() as tmp:
+        # download aggregation
+        unzip_to = os.path.join(tmp, "unzipped_aggr")
+        os.makedirs(unzip_to)
+        if as_new_aggr:
+            file_path = f"{dst_path}/{file_path}"
+
+        aggr = resource_with_netcdf_aggr.aggregation(file__path=file_path)
+        assert aggr is not None
+        assert type(aggr) is NetCDFAggregation
+
+        agg_path = resource_with_netcdf_aggr.aggregation_download(aggregation=aggr, save_path=tmp, unzip_to=unzip_to)
+        xr_dataset = aggr.as_data_object(agg_path=agg_path)
+        assert xr_dataset.attrs["title"] == agg_title
+
+
+@pytest.mark.parametrize("search_by", ["type", "file_path"])
+def test_geofeature_as_data_object(resource_with_geofeature_aggr, search_by):
+    resource_with_geofeature_aggr.refresh()
+    if search_by == "type":
+        aggr = resource_with_geofeature_aggr.aggregation(type=AggregationType.GeographicFeatureAggregation)
+    else:
+        file_path = "watersheds.shp"
+        aggr = resource_with_geofeature_aggr.aggregation(file__path=file_path)
+
+    assert aggr is not None
+    assert type(aggr) is GeoFeatureAggregation
+    with tempfile.TemporaryDirectory() as tmp:
+        # download aggregation
+        unzip_to = os.path.join(tmp, "unzipped_aggr")
+        os.makedirs(unzip_to)
+        agg_path = resource_with_geofeature_aggr.aggregation_download(aggregation=aggr, save_path=tmp,
+                                                                      unzip_to=unzip_to)
+        fn_collection = aggr.as_data_object(agg_path=agg_path)
+        assert fn_collection.__class__.__name__ == "Collection"
+        # check projection type
+        assert str(fn_collection.crs) == "EPSG:26912"
+        # close the fiona collection object so that the temp dir can be cleaned up.
+        fn_collection.close()
+
+
+@pytest.mark.parametrize("as_new_aggr", [False, True])
+def test_geofeature_save_data_object(resource_with_geofeature_aggr, as_new_aggr):
+    resource_with_geofeature_aggr.refresh()
+    file_path = "watersheds.shp"
+    aggr = resource_with_geofeature_aggr.aggregation(file__path=file_path)
+    assert aggr is not None
+    assert type(aggr) is GeoFeatureAggregation
+    with tempfile.TemporaryDirectory() as tmp:
+        # download aggregation
+        unzip_to = os.path.join(tmp, "unzipped_aggr")
+        os.makedirs(unzip_to)
+        agg_path = resource_with_geofeature_aggr.aggregation_download(aggregation=aggr, save_path=tmp,
+                                                                      unzip_to=unzip_to)
+        fn_collection = aggr.as_data_object(agg_path=agg_path)
+        assert fn_collection.__class__.__name__ == "Collection"
+        original_shp_filename = os.path.basename(fn_collection.path)
+        updated_shp_file_dir = os.path.join(tmp, "updated_aggr")
+        os.makedirs(updated_shp_file_dir)
+        output_shp_file_path = os.path.join(updated_shp_file_dir, original_shp_filename)
+        with fiona.open(output_shp_file_path, 'w', schema=fn_collection.schema, driver=fn_collection.driver,
+                        crs=fn_collection.crs) as out_shp_file:
+            for feature in fn_collection:
+                ft_dict = to_dict(feature)
+                if ft_dict['properties']['Id'] < 5:
+                    out_shp_file.write(feature)
+
+        dst_path = ""
+        if as_new_aggr:
+            dst_path = "geo_aggr_folder"
+            resource_with_geofeature_aggr.folder_create(dst_path)
+
+        aggr = aggr.save_data_object(resource=resource_with_geofeature_aggr, agg_path=updated_shp_file_dir,
+                                     as_new_aggr=as_new_aggr,  destination_path=dst_path)
+        assert aggr is not None
+        assert type(aggr) is GeoFeatureAggregation
+        assert aggr.data_object is None
+
+    # check the updated geo-feature aggregation
+    with tempfile.TemporaryDirectory() as tmp:
+        # download aggregation
+        unzip_to = os.path.join(tmp, "unzipped_aggr")
+        os.makedirs(unzip_to)
+        if as_new_aggr:
+            file_path = f"{dst_path}/{file_path}"
+
+        aggr = resource_with_geofeature_aggr.aggregation(file__path=file_path)
+        assert aggr is not None
+        assert type(aggr) is GeoFeatureAggregation
+
+        agg_path = resource_with_geofeature_aggr.aggregation_download(aggregation=aggr, save_path=tmp,
+                                                                      unzip_to=unzip_to)
+        fn_collection = aggr.as_data_object(agg_path=agg_path)
+        for feature in fn_collection:
+            ft_dict = to_dict(feature)
+            assert ft_dict['properties']['Id'] < 5
+        # need to close the data object so that the tmp directory can be cleaned up
+        fn_collection.close()