coastseg 1.0.0.dev6__tar.gz → 1.0.0.dev7__tar.gz

{coastseg-1.0.0.dev6/src/coastseg.egg-info → coastseg-1.0.0.dev7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: coastseg
-Version: 1.0.0.dev6
+Version: 1.0.0.dev7
 Summary: An interactive jupyter notebook for downloading satellite imagery
 Author-email:  Sharon Fitzpatrick <sharon.fitzpatrick23@gmail.com>
 License: MIT License
@@ -35,7 +35,7 @@ Classifier: Topic :: Scientific/Engineering :: GIS
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: coastsat-package>=0.1.16
+Requires-Dist: coastsat-package>=0.1.18
 Requires-Dist: area
 Requires-Dist: doodleverse-utils>=0.0.35
 Requires-Dist: ipyfilechooser>=0.6.0

{coastseg-1.0.0.dev6 → coastseg-1.0.0.dev7}/pyproject.toml

@@ -5,14 +5,14 @@ build-backend = "setuptools.build_meta"
 [project]
 name = "coastseg"
 dynamic = ["readme"]
-version = "1.0.0dev6" 
+version = "1.0.0dev7" 
 authors = [
   { name=" Sharon Fitzpatrick", email="sharon.fitzpatrick23@gmail.com" },
 ]
 # find` directive with `include` or `exclude`
 description = "An interactive jupyter notebook for downloading satellite imagery"
 dependencies = [
-  "coastsat-package>=0.1.16",
+  "coastsat-package>=0.1.18",
   "area",
   "doodleverse-utils>=0.0.35",
   "ipyfilechooser>=0.6.0",

{coastseg-1.0.0.dev6 → coastseg-1.0.0.dev7}/src/coastseg/coastseg_map.py

@@ -35,7 +35,7 @@ from coastseg import (
     exception_handler,
 )
 from coastsat import SDS_download
-
+from coastsat.SDS_download import get_metadata
 
 logger = logging.getLogger(__name__)
 
@@ -207,6 +207,63 @@ class CoastSeg_Map:
         else:
             print("\ntidal corrections completed")
 
+    def load_metadata(self, settings: dict = {}, ids: Collection = set([])):
+        """
+        Loads metadata either based on user-provided settings or a collection of ROI IDs.
+
+        This method either takes in a dictionary with site-specific settings to load metadata
+        for a particular site, or iterates over a collection of ROI IDs to load their respective
+        metadata using the settings associated with those ROI IDs.
+
+        Note that coastsat's `get_metadata` is used to actually perform the metadata loading.
+
+        Parameters:
+        -----------
+        settings: dict, optional
+            A dictionary containing settings for a specific site. The settings should
+            include 'sitename' and 'filepath_data' keys, among others. Default is an empty dict.
+
+        ids: Collection, optional
+            A collection (e.g., set, list) of ROI IDs to load metadata for. Default is an empty set.
+
+        Raises:
+        -----------
+        FileNotFoundError:
+            If the directory specified in the settings or by ROI IDs does not exist.
+
+        Exception:
+            If neither settings nor ids are provided.
+
+        Returns:
+        -----------
+        None
+            metadata dictionary
+
+        Examples:
+        -----------
+        >>> load_metadata(settings={'sitename': 'site1', 'filepath_data': '/path/to/data'})
+        >>> load_metadata(ids={1, 2, 3})
+
+        """
+        if settings and isinstance(settings, dict):
+            return get_metadata(settings)
+        elif ids:
+            for roi_id in ids:
+                # if the ROI directory did not exist then print a warning and proceed
+                try:
+                    logger.info(
+                        f"Loading metadata using {self.rois.roi_settings[str(roi_id)]}"
+                    )
+                    metadata = get_metadata(self.rois.roi_settings[str(roi_id)])
+                    logger.info(f"Metadata for ROI ID {str(roi_id)}:{metadata}")
+                    return metadata
+                except FileNotFoundError as e:
+                    logger.error(f"Metadata not loaded for ROI ID {str(roi_id)} {e}")
+                    print(f"Metadata not loaded for ROI ID {str(roi_id)} {e}")
+
+        else:
+            raise Exception(f"Must provide settings or list of IDs to load metadata.")
+
     def load_session_files(self, dir_path: str) -> None:
         """
         Load the configuration files from the given directory.
@@ -229,6 +286,11 @@ class CoastSeg_Map:
             # load the config files if they exist
             data_path = file_utilities.create_directory(os.getcwd(), "data")
             config_loaded = self.load_config_files(dir_path, data_path)
+            # create metadata files for each ROI loaded in using coastsat's get_metadata()
+            if self.rois and getattr(self.rois, "roi_settings"):
+                self.load_metadata(ids=list(self.rois.roi_settings.keys()))
+            else:
+                logger.warning(f"No ROIs were able to have their metadata loaded.")
             # load in settings files
             for file_name in os.listdir(dir_path):
                 file_path = os.path.join(dir_path, file_name)
@@ -612,15 +674,15 @@ class CoastSeg_Map:
         """
 
         self.validate_download_imagery_inputs()
-        # selected_layer contains the selected ROIs
-        selected_layer = self.map.find_layer(ROI.SELECTED_LAYER_NAME)
-        logger.info(f"selected_layer: {selected_layer}")
 
         # Get the location where the downloaded imagery will be saved
         file_path = os.path.abspath(os.path.join(os.getcwd(), "data"))
         date_str = file_utilities.generate_datestring()
-
         settings = self.get_settings()
+
+        # selected_layer contains the selected ROIs
+        selected_layer = self.map.find_layer(ROI.SELECTED_LAYER_NAME)
+        logger.info(f"selected_layer: {selected_layer}")
         # Create a list of download settings for each ROI
         roi_settings = common.create_roi_settings(
             settings, selected_layer.data, file_path, date_str
@@ -633,6 +695,9 @@ class CoastSeg_Map:
         inputs_list = list(roi_settings.values())
         logger.info(f"inputs_list {inputs_list}")
 
+        # Save settings used to download rois and the objects on map to config files
+        self.save_config()
+
         # 2. For each ROI use download settings to download imagery and save to jpg
         print("Download in progress")
         # for each ROI use the ROI settings to download imagery and save to jpg
@@ -644,8 +709,6 @@ class CoastSeg_Map:
                 save_jpg=True,
                 apply_cloud_mask=settings.get("apply_cloud_mask", True),
             )
-        # 3.save settings used to download rois and the objects on map to config files
-        self.save_config()
         logger.info("Done downloading")
 
     def _extract_and_validate_roi_settings(
@@ -794,6 +857,8 @@ class CoastSeg_Map:
         exception_handler.check_empty_roi_layer(selected_layer)
         logger.info(f"self.rois.roi_settings: {self.rois.roi_settings}")
 
+        # @todo can this be removed since we don't have a save_config button anymore?
+        # if the rois do not have any settings then save the currently loaded settings to the ROIs
         if not self.rois.roi_settings:
             filepath = filepath or os.path.abspath(os.getcwd())
             roi_settings = common.create_roi_settings(
@@ -801,20 +866,23 @@ class CoastSeg_Map:
             )
             self.rois.set_roi_settings(roi_settings)
 
-        # create dictionary to be saved to config.json
+        # create dictionary of settings for each ROI to be saved to config.json
         roi_ids = self.get_selected_roi_ids()
         selected_roi_settings = {
             roi_id: self.rois.roi_settings[roi_id] for roi_id in roi_ids
         }
+        # combine the settings for each ROI with the rest of the currently loaded settings
         config_json = common.create_json_config(selected_roi_settings, settings)
 
-        shorelines_gdf = self.shoreline.gdf if self.shoreline else None
-        transects_gdf = self.transects.gdf if self.transects else None
-        bbox_gdf = self.bbox.gdf if self.bbox else None
+        shorelines_gdf = (
+            getattr(self.shoreline, "gdf", None) if self.shoreline else None
+        )
+        transects_gdf = getattr(self.transects, "gdf", None) if self.transects else None
+        bbox_gdf = getattr(self.bbox, "gdf", None) if self.bbox else None
         selected_rois = self.get_selected_rois(roi_ids)
+        logger.info(f"selected_rois: {selected_rois}")
 
         # save all selected rois, shorelines, transects and bbox to config geodataframe
-        logger.info(f"selected_rois: {selected_rois}")
         if selected_rois is not None:
             if not selected_rois.empty:
                 epsg_code = selected_rois.crs
@@ -828,13 +896,17 @@ class CoastSeg_Map:
         logger.info(f"config_gdf: {config_gdf} ")
         is_downloaded = common.were_rois_downloaded(self.rois.roi_settings, roi_ids)
 
-        if filepath is not None:
-            # if a filepath is provided then save the config.json and config_gdf.geojson immediately
-            file_utilities.config_to_file(config_json, filepath)
-            file_utilities.config_to_file(config_gdf, filepath)
-        elif filepath is None:
-            # data has been downloaded before so inputs have keys 'filepath' and 'sitename'
-            if is_downloaded == True:
+        def save_config_files(config_json, config_gdf, path):
+            """Helper function to save config files."""
+            file_utilities.config_to_file(config_json, path)
+            file_utilities.config_to_file(config_gdf, path)
+
+        if filepath:
+            # If a filepath is provided then save the config.json and config_gdf.geojson immediately
+            save_config_files(config_json, config_gdf, filepath)
+        else:
+            # if  data has been downloaded before then inputs have keys 'filepath' and 'sitename'
+            if is_downloaded:
                 # write config_json file to each directory where a roi was saved
                 roi_ids = config_json["roi_ids"]
                 for roi_id in roi_ids:
@@ -842,19 +914,13 @@ class CoastSeg_Map:
                     filepath = os.path.abspath(
                         os.path.join(config_json[roi_id]["filepath"], sitename)
                     )
-                    # save to config.json
-                    file_utilities.config_to_file(config_json, filepath)
-                    # save to config_gdf.geojson
-                    file_utilities.config_to_file(config_gdf, filepath)
+                    save_config_files(config_json, config_gdf, filepath)
                 print("Saved config files for each ROI")
-            elif is_downloaded == False:
+            else:
                 # if data is not downloaded save to coastseg directory
                 filepath = os.path.abspath(os.getcwd())
-                # save to config.json
-                file_utilities.config_to_file(config_json, filepath)
-                # save to config_gdf.geojson
-                file_utilities.config_to_file(config_gdf, filepath)
-                print("Saved config files for each ROI")
+                save_config_files(config_json, config_gdf, filepath)
+                print(f"Saved config files for each ROI to {filepath}")
 
     def set_settings(self, **kwargs):
         """

{coastseg-1.0.0.dev6 → coastseg-1.0.0.dev7}/src/coastseg/common.py

@@ -1343,10 +1343,17 @@ def create_json_config(inputs: dict, settings: dict, roi_ids: list[str] = []) ->
     config = {**inputs}
     config["roi_ids"] = roi_ids
     config["settings"] = settings
-    logger.info(f"config_json: {config} ")
+    logger.info(f"config_json: {config}")
     return config
 
 
+def set_crs_or_initialize_empty(gdf: gpd.GeoDataFrame, epsg_code: str):
+    """Set the CRS for the given GeoDataFrame or initialize an empty one."""
+    if gdf is not None and not gdf.empty:
+        return gdf.to_crs(epsg_code)
+    return gpd.GeoDataFrame(geometry=[], crs=epsg_code)
+
+
 def create_config_gdf(
     rois_gdf: gpd.GeoDataFrame,
     shorelines_gdf: gpd.GeoDataFrame = None,
@@ -1354,48 +1361,54 @@ def create_config_gdf(
     bbox_gdf: gpd.GeoDataFrame = None,
     epsg_code: int = None,
 ) -> gpd.GeoDataFrame:
-    if epsg_code is None and rois_gdf is None:
-        raise ValueError(
-            "Cannot create config GeoDataFrame without a CRS or an empty ROI GeoDataFrame"
-        )
-    # Check if CRS is provided or if the ROI GeoDataFrame is empty
-    if epsg_code is None and rois_gdf.empty:
+    """
+    Create a concatenated GeoDataFrame from provided GeoDataFrames with a consistent CRS.
+
+    Parameters:
+    - rois_gdf (gpd.GeoDataFrame): The GeoDataFrame containing Regions of Interest (ROIs).
+    - shorelines_gdf (gpd.GeoDataFrame, optional): The GeoDataFrame containing shorelines. Defaults to None.
+    - transects_gdf (gpd.GeoDataFrame, optional): The GeoDataFrame containing transects. Defaults to None.
+    - bbox_gdf (gpd.GeoDataFrame, optional): The GeoDataFrame containing bounding boxes. Defaults to None.
+    - epsg_code (int, optional): The EPSG code for the desired CRS. If not provided and rois_gdf is non-empty,
+      the CRS of rois_gdf will be used. If not provided and rois_gdf is empty, an error will be raised.
+
+    Returns:
+    - gpd.GeoDataFrame: A concatenated GeoDataFrame with a consistent CRS, and a "type" column
+      indicating the type of each geometry (either "roi", "shoreline", "transect", or "bbox").
+
+    Raises:
+    - ValueError: If both epsg_code is None and rois_gdf is None or empty.
+
+    Notes:
+    - The function will convert each provided GeoDataFrame to the specified CRS.
+    - If any of the input GeoDataFrames is None or empty, it will be initialized as an empty GeoDataFrame
+      with the specified CRS.
+    """
+    # Determine CRS
+    if not epsg_code and (rois_gdf is None or rois_gdf.empty):
         raise ValueError(
-            "Cannot create config GeoDataFrame without a CRS or an empty ROI GeoDataFrame"
+            "Either provide a valid epsg code or a non-empty rois_gdf to determine the CRS."
         )
-    if epsg_code is None:
+    if not epsg_code:
         epsg_code = rois_gdf.crs
 
-    # Set CRS for the non-empty GeoDataFrames
-    if rois_gdf is not None and not rois_gdf.empty:
-        rois_gdf = rois_gdf.to_crs(epsg_code)
-    else:
-        rois_gdf = gpd.GeoDataFrame(geometry=[], crs=epsg_code)
-    if shorelines_gdf is not None and not shorelines_gdf.empty:
-        shorelines_gdf = shorelines_gdf.to_crs(epsg_code)
-    else:
-        shorelines_gdf = gpd.GeoDataFrame(geometry=[], crs=epsg_code)
-    if transects_gdf is not None and not transects_gdf.empty:
-        transects_gdf = transects_gdf.to_crs(epsg_code)
-    else:
-        transects_gdf = gpd.GeoDataFrame(geometry=[], crs=epsg_code)
-    if bbox_gdf is not None and not bbox_gdf.empty:
-        bbox_gdf = bbox_gdf.to_crs(epsg_code)
-    else:
-        bbox_gdf = gpd.GeoDataFrame(geometry=[], crs=epsg_code)
+    # Dictionary to map gdf variables to their types
+    gdfs = {
+        "roi": rois_gdf,
+        "shoreline": shorelines_gdf,
+        "transect": transects_gdf,
+        "bbox": bbox_gdf,
+    }
 
-    # Assign "type" column values
-    rois_gdf["type"] = "roi"
-    shorelines_gdf["type"] = "shoreline"
-    transects_gdf["type"] = "transect"
-    bbox_gdf["type"] = "bbox"
+    # Process each GeoDataFrame
+    for gdf_type, gdf in gdfs.items():
+        gdfs[gdf_type] = set_crs_or_initialize_empty(gdf, epsg_code)
+        gdfs[gdf_type]["type"] = gdf_type
 
     # Concatenate GeoDataFrames
-    config_gdf = pd.concat(
-        [rois_gdf, shorelines_gdf, transects_gdf, bbox_gdf], ignore_index=True
-    )
+    config_gdf = pd.concat(gdfs.values(), ignore_index=True)
 
-    return gpd.GeoDataFrame(config_gdf)
+    return config_gdf
 
 
 def get_jpgs_from_data() -> str:

{coastseg-1.0.0.dev6 → coastseg-1.0.0.dev7}/src/coastseg/file_utilities.py

@@ -272,23 +272,24 @@ def find_parent_directory(
         path = parent_dir
 
 
-def config_to_file(config: Union[dict, gpd.GeoDataFrame], file_path: str):
+def config_to_file(config: Union[dict, gpd.GeoDataFrame], filepath: str):
     """Saves config to config.json or config_gdf.geojson
     config's type is dict or geodataframe respectively
 
     Args:
         config (Union[dict, gpd.GeoDataFrame]): data to save to config file
-        file_path (str): full path to directory to save config file
+        filepath (str): full path to directory to save config file
     """
     if isinstance(config, dict):
         filename = f"config.json"
-        save_path = os.path.abspath(os.path.join(file_path, filename))
+        save_path = os.path.abspath(os.path.join(filepath, filename))
         write_to_json(save_path, config)
         logger.info(f"Saved config json: {filename} \nSaved to {save_path}")
     elif isinstance(config, gpd.GeoDataFrame):
         filename = f"config_gdf.geojson"
-        save_path = os.path.abspath(os.path.join(file_path, filename))
+        save_path = os.path.abspath(os.path.join(filepath, filename))
         logger.info(f"Saving config gdf:{config} \nSaved to {save_path}")
+        os.makedirs(os.path.dirname(filepath), exist_ok=True)
         config.to_file(save_path, driver="GeoJSON")
 
 
@@ -497,6 +498,7 @@ def create_directory(file_path: str, name: str) -> str:
 
 def write_to_json(filepath: str, settings: dict):
     """ "Write the  settings dictionary to json file"""
+    os.makedirs(os.path.dirname(filepath), exist_ok=True)
     to_file(settings, filepath)
     # with open(filepath, "w", encoding="utf-8") as output_file:
     #     json.dump(settings, output_file)

{coastseg-1.0.0.dev6 → coastseg-1.0.0.dev7/src/coastseg.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: coastseg
-Version: 1.0.0.dev6
+Version: 1.0.0.dev7
 Summary: An interactive jupyter notebook for downloading satellite imagery
 Author-email:  Sharon Fitzpatrick <sharon.fitzpatrick23@gmail.com>
 License: MIT License
@@ -35,7 +35,7 @@ Classifier: Topic :: Scientific/Engineering :: GIS
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: coastsat-package>=0.1.16
+Requires-Dist: coastsat-package>=0.1.18
 Requires-Dist: area
 Requires-Dist: doodleverse-utils>=0.0.35
 Requires-Dist: ipyfilechooser>=0.6.0

{coastseg-1.0.0.dev6 → coastseg-1.0.0.dev7}/src/coastseg.egg-info/requires.txt

@@ -1,4 +1,4 @@
-coastsat-package>=0.1.16
+coastsat-package>=0.1.18
 area
 doodleverse-utils>=0.0.35
 ipyfilechooser>=0.6.0

{coastseg-1.0.0.dev6 → coastseg-1.0.0.dev7}/tests/test_common.py

@@ -14,6 +14,123 @@ import geopandas as gpd
 import numpy as np
 from shapely import geometry
 
+import geopandas as gpd
+import pandas as pd
+from shapely.geometry import Point
+import pytest
+
+
+def test_valid_input():
+    rois = gpd.GeoDataFrame({"geometry": [Point(1, 1)]}, crs="EPSG:4326")
+
+    result = common.create_config_gdf(rois)
+    assert not result.empty
+    assert result.crs == "EPSG:4326"
+    assert "type" in result.columns
+    assert result["type"][0] == "roi"
+
+
+def test_with_multiple_gdfs():
+    rois = gpd.GeoDataFrame({"geometry": [Point(1, 1), Point(2, 2)]}, crs="EPSG:4326")
+
+    shorelines = gpd.GeoDataFrame(
+        {"geometry": [LineString([(0, 0), (1, 1)])]}, crs="EPSG:4326"
+    )
+
+    result = common.create_config_gdf(rois, shorelines_gdf=shorelines, epsg_code=3857)
+
+    assert not result.empty
+    assert result.crs == "EPSG:3857"
+    assert result["type"].nunique() == 2
+    assert set(result["type"].unique()) == {"roi", "shoreline"}
+
+
+def test_with_empty_rois_and_no_epsg():
+    with pytest.raises(ValueError):
+        result = common.create_config_gdf(None)
+
+
+def test_with_empty_rois_and_valid_epsg():
+    result = common.create_config_gdf(None, epsg_code=3857)
+    assert result.empty
+    assert result.crs == "EPSG:3857"
+
+
+def test_with_all_gdfs():
+    rois = gpd.GeoDataFrame({"geometry": [Point(1, 1), Point(2, 2)]}, crs="EPSG:4326")
+
+    shorelines = gpd.GeoDataFrame(
+        {"geometry": [LineString([(0, 0), (1, 1)])]}, crs="EPSG:4326"
+    )
+
+    transects = gpd.GeoDataFrame(
+        {"geometry": [LineString([(2, 2), (3, 3)])]}, crs="EPSG:4326"
+    )
+
+    bbox = gpd.GeoDataFrame({"geometry": [Point(3, 3), Point(4, 4)]}, crs="EPSG:4326")
+
+    result = common.create_config_gdf(
+        rois,
+        shorelines_gdf=shorelines,
+        transects_gdf=transects,
+        bbox_gdf=bbox,
+        epsg_code=3857,
+    )
+
+    assert not result.empty
+    assert result.crs == "EPSG:3857"
+    assert result["type"].nunique() == 4
+    assert set(result["type"].unique()) == {"roi", "shoreline", "transect", "bbox"}
+
+
+def test_set_crs_for_non_empty_gdf_with_same_epsg():
+    # Create a GeoDataFrame with some data
+    gdf = gpd.GeoDataFrame({"geometry": [Point(1, 1)]}, crs="EPSG:4326")
+
+    result = common.set_crs_or_initialize_empty(gdf, "EPSG:4326")
+
+    # Check that the resulting GeoDataFrame has the correct CRS
+    assert result.crs == "EPSG:4326"
+    # Check that the data remains unchanged
+    assert not result.empty
+
+
+def test_set_crs_for_non_empty_gdf():
+    # Create a GeoDataFrame with some data
+    gdf = gpd.GeoDataFrame({"geometry": [Point(1, 1)]}, crs="EPSG:4326")
+
+    result = common.set_crs_or_initialize_empty(gdf, "EPSG:3857")
+
+    # Check that the resulting GeoDataFrame has the correct CRS
+    assert result.crs == "EPSG:3857"
+    # Check that the data remains unchanged
+    assert not result.empty
+
+
+def test_initialize_empty_for_none_gdf():
+    result = common.set_crs_or_initialize_empty(None, "EPSG:3857")
+
+    # Check that the resulting GeoDataFrame is empty but has the correct CRS
+    assert result.crs == "EPSG:3857"
+    assert result.empty
+
+
+def test_initialize_empty_for_empty_gdf():
+    gdf = gpd.GeoDataFrame(geometry=[], crs="EPSG:4326")
+    result = common.set_crs_or_initialize_empty(gdf, "EPSG:3857")
+
+    # Check that the resulting GeoDataFrame is empty but has the correct CRS
+    assert result.crs == "EPSG:3857"
+    assert result.empty
+
+
+def test_raise_exception_on_invalid_crs():
+    gdf = gpd.GeoDataFrame({"geometry": [Point(1, 1)]}, crs="EPSG:4326")
+
+    with pytest.raises(Exception):
+        # Attempt to convert to a non-existent EPSG code
+        common.set_crs_or_initialize_empty(gdf, "EPSG:999999")
+
 
 # Test data
 @pytest.fixture(scope="function")