fimeval 0.1.51__py3-none-any.whl → 0.1.53__py3-none-any.whl

fimeval/BuildingFootprint/evaluationwithBF.py

@@ -1,5 +1,4 @@
 import os
-import ee
 import glob
 import geopandas as gpd
 import rasterio
@@ -21,6 +20,7 @@ def Changeintogpkg(input_path, output_dir, layer_name):
         gdf.to_file(output_gpkg, driver="GPKG")
         return output_gpkg
 
+
 def GetFloodedBuildingCountInfo(
     building_fp_path,
     study_area_path,
@@ -85,7 +85,7 @@ def GetFloodedBuildingCountInfo(
     if "bm" in str(raster1_path).lower():
         count_centroids_in_raster(raster1_path, "Benchmark")
         count_centroids_in_raster(raster2_path, "Candidate")
-        
+
     elif "candidate" in str(raster2_path).lower():
         count_centroids_in_raster(raster1_path, "Candidate")
         count_centroids_in_raster(raster2_path, "Benchmark")
@@ -106,9 +106,10 @@ def GetFloodedBuildingCountInfo(
     CSI = TP / (TP + FP + FN) if (TP + FP + FN) > 0 else 0
     FAR = FP / (TP + FP) if (TP + FP) > 0 else 0
     POD = TP / (TP + FN) if (TP + FN) > 0 else 0
-    
-    
-    BDR = (centroid_counts["Candidate"]- centroid_counts["Benchmark"])/centroid_counts["Benchmark"]
+
+    BDR = (
+        centroid_counts["Candidate"] - centroid_counts["Benchmark"]
+    ) / centroid_counts["Benchmark"]
 
     counts_data = {
         "Category": [
@@ -223,6 +224,7 @@ def GetFloodedBuildingCountInfo(
     print(f"Performance metrics chart is saved as PNG at {output_path}")
     fig.show()
 
+
 def process_TIFF(
     tif_files, contingency_files, building_footprint, boundary, method_path
 ):
@@ -266,22 +268,46 @@ def process_TIFF(
         print("Warning: No benchmark file found.")
     elif not candidate_paths:
         print("Warning: No candidate files found.")
-        
+
+
 def find_existing_footprint(out_dir):
     gpkg_files = list(Path(out_dir).glob("*.gpkg"))
     return gpkg_files[0] if gpkg_files else None
 
-#Incase user defined individual shapefile for each case study
+
+# Incase user defined individual shapefile for each case study
 def detect_shapefile(folder):
-        shapefile = None
-        for ext in (".shp", ".gpkg", ".geojson", ".kml"):
-            for file in os.listdir(folder):
-                if file.lower().endswith(ext):
-                    shapefile = os.path.join(folder, file)
-                    print(f"Auto-detected shapefile: {shapefile}")
-                    return shapefile
-        return None
-    
+    shapefile = None
+    for ext in (".shp", ".gpkg", ".geojson", ".kml"):
+        for file in os.listdir(folder):
+            if file.lower().endswith(ext):
+                shapefile = os.path.join(folder, file)
+                print(f"Auto-detected shapefile: {shapefile}")
+                return shapefile
+    return None
+
+
+def ensure_pyspark(version: str | None = "3.5.4") -> None:
+    """Install pyspark at runtime via `uv pip` into this env (no-op if present)."""
+    import importlib, shutil, subprocess, sys, re
+    try:
+        import importlib.util
+        if importlib.util.find_spec("pyspark"):
+            return
+    except Exception:
+        pass
+    uv = shutil.which("uv")
+    if not uv:
+        raise RuntimeError("`uv` not found on PATH. Please install uv or add it to PATH.")
+    if version is None:
+        spec = "pyspark"
+    else:
+        v = version.strip()
+        spec = f"pyspark{v}" if re.match(r"^[<>=!~]", v) else f"pyspark=={v}"
+    subprocess.check_call([uv, "pip", "install", "--python", sys.executable, spec])
+
+
+
 def EvaluationWithBuildingFootprint(
     main_dir,
     method_name,
@@ -289,6 +315,7 @@ def EvaluationWithBuildingFootprint(
     country=None,
     building_footprint=None,
     shapefile_dir=None,
+    geeprojectID=None,
 ):
     tif_files_main = glob.glob(os.path.join(main_dir, "*.tif"))
     if tif_files_main:
@@ -303,9 +330,7 @@ def EvaluationWithBuildingFootprint(
 
                 if shapefile_dir:
                     boundary = shapefile_dir
-                elif os.path.exists(
-                    os.path.join(method_path, "BoundaryforEvaluation")
-                ):
+                elif os.path.exists(os.path.join(method_path, "BoundaryforEvaluation")):
                     boundary = os.path.join(
                         method_path, "BoundaryforEvaluation", "FIMEvaluatedExtent.shp"
                     )
@@ -313,9 +338,11 @@ def EvaluationWithBuildingFootprint(
                     boundary = detect_shapefile(main_dir)
 
                 building_footprintMS = building_footprint
+                
                 if building_footprintMS is None:
-                    import msfootprint as msf
-
+                    ensure_pyspark()
+                    from .microsoftBF import BuildingFootprintwithISO
+                    
                     out_dir = os.path.join(method_path, "BuildingFootprint")
                     if not os.path.exists(out_dir):
                         os.makedirs(out_dir)
@@ -323,7 +350,15 @@ def EvaluationWithBuildingFootprint(
                     if not EX_building_footprint:
                         boundary_dir = shapefile_dir if shapefile_dir else boundary
 
-                        msf.BuildingFootprintwithISO(country, boundary_dir, out_dir)
+                        if geeprojectID:
+                            BuildingFootprintwithISO(
+                                country,
+                                boundary_dir,
+                                out_dir,
+                                geeprojectID=geeprojectID,
+                            )
+                        else:
+                            BuildingFootprintwithISO(country, boundary_dir, out_dir)
                         building_footprintMS = os.path.join(
                             out_dir, f"building_footprint.gpkg"
                         )
@@ -355,15 +390,19 @@ def EvaluationWithBuildingFootprint(
                             os.path.join(method_path, "BoundaryforEvaluation")
                         ):
                             boundary = os.path.join(
-                                method_path, "BoundaryforEvaluation", "FIMEvaluatedExtent.shp"
+                                method_path,
+                                "BoundaryforEvaluation",
+                                "FIMEvaluatedExtent.shp",
                             )
                         else:
                             boundary = detect_shapefile(os.path.join(main_dir, folder))
 
                         building_footprintMS = building_footprint
+                        
                         if building_footprintMS is None:
-                            import msfootprint as msf
-
+                            ensure_pyspark()
+                            from .microsoftBF import BuildingFootprintwithISO
+                            
                             out_dir = os.path.join(method_path, "BuildingFootprint")
                             if not os.path.exists(out_dir):
                                 os.makedirs(out_dir)
@@ -372,9 +411,17 @@ def EvaluationWithBuildingFootprint(
                                 boundary_dir = (
                                     shapefile_dir if shapefile_dir else boundary
                                 )
-                                msf.BuildingFootprintwithISO(
-                                    country, boundary_dir, out_dir
-                                )
+                                if geeprojectID:
+                                    BuildingFootprintwithISO(
+                                        country,
+                                        boundary_dir,
+                                        out_dir,
+                                        geeprojectID=geeprojectID,
+                                    )
+                                else:
+                                    BuildingFootprintwithISO(
+                                        country, boundary_dir, out_dir
+                                    )
                                 building_footprintMS = os.path.join(
                                     out_dir, f"building_footprint.gpkg"
                                 )

fimeval/BuildingFootprint/microsoftBF.py

@@ -0,0 +1,131 @@
+# Importing necessary libraries
+import geemap
+import ee
+import os
+from shapely.geometry import box
+import pandas as pd
+from pathlib import Path
+import geopandas as gpd
+from pyspark.sql import SparkSession
+from shapely.wkt import loads
+import shutil
+
+# Suppress the warnings
+import warnings
+
+warnings.filterwarnings("ignore")
+
+# Authenticate and initialize Earth Engine
+ee.Authenticate()
+
+# %%
+def split_into_tiles(boundary, tile_size=0.1):
+    bounds = boundary.total_bounds
+    x_min, y_min, x_max, y_max = bounds
+    tiles = []
+    x = x_min
+    while x < x_max:
+        y = y_min
+        while y < y_max:
+            tile = box(x, y, x + tile_size, y + tile_size)
+            if tile.intersects(boundary.unary_union):
+                tiles.append(tile)
+            y += tile_size
+        x += tile_size
+    return gpd.GeoDataFrame(geometry=tiles, crs=boundary.crs)
+
+
+# Merge the final geojson files
+def mergeGeoJSONfiles(output_dir, merged_file):
+    output_dir = Path(output_dir)
+    files = list(output_dir.glob("*.geojson"))
+    gdfs = [gpd.read_file(file) for file in files]
+    merged_gdf = gpd.GeoDataFrame(pd.concat(gdfs, ignore_index=True), crs="EPSG:4326")
+    merged_gdf.to_file(merged_file, driver="GPKG")
+
+
+# Process each batch with number of tiles
+def process_batch(partition, collection_name, output_dir, boundary_wkt, projectID=None):
+    try:
+        if projectID:
+            ee.Initialize(project=projectID)
+        else:
+            ee.Initialize()
+
+    except Exception:
+        print("To initialize, please provide the earth engine project ID")
+
+    # Convert WKT boundary to geometry
+    boundary = loads(boundary_wkt)
+    results = []
+
+    for tile_wkt in partition:
+        try:
+            tile = loads(tile_wkt)
+            aoi = ee.Geometry(tile.__geo_interface__)
+            collection = ee.FeatureCollection(collection_name).filterBounds(aoi)
+
+            # Download features and filter by boundary
+            gdf = geemap.ee_to_gdf(collection)
+            gdf = gdf[gdf.geometry.intersects(boundary)]
+
+            # Save each tile as a GeoJSON file
+            tile_id = f"tile_{hash(tile)}"
+            output_file = Path(output_dir) / f"{tile_id}.geojson"
+            gdf.to_file(output_file, driver="GeoJSON")
+            results.append(f"Saved: {output_file}")
+        except Exception as e:
+            results.append(f"Error processing tile: {e}")
+
+    return results
+
+
+def getBuildingFootprintSpark(
+    countryISO, boundary_file, out_dir, tile_size, projectID=None
+):
+    spark = SparkSession.builder.appName("BuildingFootprints").getOrCreate()
+
+    # Make temporary directory
+    temp_dir = out_dir / "temp"
+    temp_dir.mkdir(parents=True, exist_ok=True)
+
+    # Load and process boundary
+    boundary = gpd.read_file(boundary_file).to_crs("EPSG:4326")
+    tiles = split_into_tiles(boundary, tile_size)
+    boundary_wkt = boundary.unary_union.wkt
+
+    collection_names = [f"projects/sat-io/open-datasets/VIDA_COMBINED/{countryISO}"]
+
+    # Distribute processing
+    for collection_name in collection_names:
+        tiles_rdd = spark.sparkContext.parallelize(
+            tiles.geometry.apply(lambda x: x.wkt).tolist(), numSlices=10
+        )
+        results = tiles_rdd.mapPartitions(
+            lambda partition: process_batch(
+                partition, collection_name, str(temp_dir), boundary_wkt, projectID
+            )
+        ).collect()
+
+    # Merge GeoJSON files
+    mergeGeoJSONfiles(temp_dir, out_dir / "building_footprint.gpkg")
+
+    # Clean up the temp directory
+    shutil.rmtree(temp_dir, ignore_errors=True)
+
+    print(f"Building footprint data saved to {out_dir / 'building_footprint.gpkg'}")
+
+
+# %%
+# Export the building footprint
+def BuildingFootprintwithISO(countryISO, ROI, out_dir, geeprojectID=None):
+    out_dir = Path(out_dir)
+    out_dir.mkdir(parents=True, exist_ok=True)
+    filename = out_dir / "building_footprint.gpkg"
+
+    if filename.exists():
+        os.remove(filename)
+
+    getBuildingFootprintSpark(
+        countryISO, ROI, out_dir, tile_size=0.05, projectID=geeprojectID
+    )

fimeval/ContingencyMap/PWBs3.py

@@ -1,4 +1,4 @@
-#import Libraries
+# import Libraries
 import geopandas as gpd
 import boto3
 import botocore
@@ -7,27 +7,27 @@ import tempfile
 
 # Initialize an anonymous S3 client
 s3 = boto3.client(
-    's3',
-    config=botocore.config.Config(signature_version=botocore.UNSIGNED)
+    "s3", config=botocore.config.Config(signature_version=botocore.UNSIGNED)
 )
 
-bucket_name = 'sdmlab'
-pwb_folder = "PWB/"  
+bucket_name = "sdmlab"
+pwb_folder = "PWB/"
+
 
 def PWB_inS3(s3_client, bucket, prefix):
     """Download all components of a shapefile from S3 into a temporary directory."""
     tmp_dir = tempfile.mkdtemp()
     response = s3_client.list_objects_v2(Bucket=bucket, Prefix=prefix)
-    if 'Contents' not in response:
+    if "Contents" not in response:
         raise ValueError("No files found in the specified S3 folder.")
-    
-    for obj in response['Contents']:
-        file_key = obj['Key']
-        file_name = os.path.basename(file_key) 
-        if file_name.endswith(('.shp', '.shx', '.dbf', '.prj', '.cpg')):
+
+    for obj in response["Contents"]:
+        file_key = obj["Key"]
+        file_name = os.path.basename(file_key)
+        if file_name.endswith((".shp", ".shx", ".dbf", ".prj", ".cpg")):
             local_path = os.path.join(tmp_dir, file_name)
             s3_client.download_file(bucket, file_key, local_path)
-            
+
     shp_files = [f for f in os.listdir(tmp_dir) if f.endswith(".shp")]
     if not shp_files:
         raise ValueError("No .shp file found after download.")
@@ -35,7 +35,8 @@ def PWB_inS3(s3_client, bucket, prefix):
     shp_path = os.path.join(tmp_dir, shp_files[0])
     return shp_path
 
+
 def get_PWB():
     shp_path = PWB_inS3(s3, bucket_name, pwb_folder)
     pwb = gpd.read_file(shp_path)
-    return pwb
+    return pwb

fimeval/ContingencyMap/evaluationFIM.py

@@ -21,12 +21,14 @@ from .metrics import evaluationmetrics
 from .PWBs3 import get_PWB
 from ..utilis import MakeFIMsUniform
 
-#giving the permission to the folder
+
+# giving the permission to the folder
 def is_writable(path):
     """Check if the directory and its contents are writable."""
     path = Path(path)
     return os.access(path, os.W_OK)
 
+
 def fix_permissions(path):
     path = Path(path).resolve()
     script_path = Path(__file__).parent / "fix_permissions.sh"
@@ -35,11 +37,15 @@ def fix_permissions(path):
         raise FileNotFoundError(f"Shell script not found: {script_path}")
 
     if is_writable(path):
-        return 
+        return
 
     try:
-        result = subprocess.run(["bash", str(script_path), str(path)],
-                                check=True, capture_output=True, text=True)
+        result = subprocess.run(
+            ["bash", str(script_path), str(path)],
+            check=True,
+            capture_output=True,
+            text=True,
+        )
         print(result.stdout)
     except subprocess.CalledProcessError as e:
         print(f"Shell script failed:\n{e.stderr}")
@@ -79,7 +85,7 @@ def evaluateFIM(
     # Get the smallest matched raster extent and make a boundary shapefile
     smallest_raster_path = get_smallest_raster_path(benchmark_path, *candidate_paths)
 
-    #If method is AOI, and direct shapefile directory is not provided, then it will search for the shapefile in the folder
+    # If method is AOI, and direct shapefile directory is not provided, then it will search for the shapefile in the folder
     if method.__name__ == "AOI":
         # If shapefile is not provided, search in the folder
         if shapefile is None:
@@ -95,7 +101,6 @@ def evaluateFIM(
                 raise FileNotFoundError(
                     "No shapefile (.shp, .gpkg, .geojson, .kml) found in the folder and none provided. Either provide a shapefile directory or put shapefile inside folder directory."
                 )
-
         # Run AOI with the found or provided shapefile
         bounding_geom = AOI(benchmark_path, shapefile, save_dir)
 
@@ -359,8 +364,10 @@ def evaluateFIM(
     print(f"Evaluation metrics saved to {csv_file}")
     return results
 
-#Safely deleting the folder
+
+# Safely deleting the folder
 def safe_delete_folder(folder_path):
+    fix_permissions(folder_path)
     try:
         shutil.rmtree(folder_path)
     except PermissionError:
@@ -370,19 +377,28 @@ def safe_delete_folder(folder_path):
     except Exception as e:
         print(f"Error deleting {folder_path}: {e}")
 
-def EvaluateFIM(main_dir, method_name, output_dir, PWB_dir=None, shapefile_dir=None, target_crs=None, target_resolution=None):
+
+def EvaluateFIM(
+    main_dir,
+    method_name,
+    output_dir,
+    PWB_dir=None,
+    shapefile_dir=None,
+    target_crs=None,
+    target_resolution=None,
+):
     main_dir = Path(main_dir)
     # Read the permanent water bodies
     if PWB_dir is None:
         gdf = get_PWB()
     else:
         gdf = gpd.read_file(PWB_dir)
-    
-    #Grant the permission to the main directory
+
+    # Grant the permission to the main directory
     print(f"Fixing permissions for {main_dir}...")
     fix_permissions(main_dir)
 
-    #runt the process
+    # runt the process
     def process_TIFF(tif_files, folder_dir):
         benchmark_path = None
         candidate_path = []
@@ -422,7 +438,9 @@ def EvaluateFIM(main_dir, method_name, output_dir, PWB_dir=None, shapefile_dir=N
     # Check if main_dir directly contains tif files
     TIFFfiles_main_dir = list(main_dir.glob("*.tif"))
     if TIFFfiles_main_dir:
-        MakeFIMsUniform(main_dir, target_crs=target_crs, target_resolution=target_resolution)
+        MakeFIMsUniform(
+            main_dir, target_crs=target_crs, target_resolution=target_resolution
+        )
 
         # processing folder
         processing_folder = main_dir / "processing"
@@ -434,15 +452,20 @@ def EvaluateFIM(main_dir, method_name, output_dir, PWB_dir=None, shapefile_dir=N
         for folder in main_dir.iterdir():
             if folder.is_dir():
                 tif_files = list(folder.glob("*.tif"))
-                
+
                 if tif_files:
-                    MakeFIMsUniform(folder, target_crs=target_crs, target_resolution=target_resolution)
-                    
+                    MakeFIMsUniform(
+                        folder,
+                        target_crs=target_crs,
+                        target_resolution=target_resolution,
+                    )
+
                     processing_folder = folder / "processing"
                     TIFFfiles = list(processing_folder.glob("*.tif"))
 
                     process_TIFF(TIFFfiles, folder)
                     safe_delete_folder(processing_folder)
                 else:
-                    print(f"Skipping {folder.name} as it doesn't contain any tif files.")
-
+                    print(
+                        f"Skipping {folder.name} as it doesn't contain any tif files."
+                    )

fimeval/ContingencyMap/metrics.py

@@ -7,21 +7,21 @@ def evaluationmetrics(out_image1, out_image2):
     unique_values, counts = np.unique(merged, return_counts=True)
     class_pixel_counts = dict(zip(unique_values, counts))
     class_pixel_counts
-    TN = class_pixel_counts.get(1,0)
-    FP = class_pixel_counts.get(2,0)
-    FN = class_pixel_counts.get(3,0)
-    TP = class_pixel_counts.get(4,0)
+    TN = class_pixel_counts.get(1, 0)
+    FP = class_pixel_counts.get(2, 0)
+    FN = class_pixel_counts.get(3, 0)
+    TP = class_pixel_counts.get(4, 0)
     epsilon = 1e-8
-    TPR = TP / (TP + FN+epsilon)
-    FNR = FN / (TP + FN+epsilon)
-    Acc = (TP + TN) / (TP + TN + FP + FN+epsilon)
-    Prec = TP / (TP + FP+epsilon)
-    sen = TP / (TP + FN+epsilon)
-    F1_score = 2 * (Prec * sen) / (Prec + sen+epsilon)
-    CSI = TP / (TP + FN + FP+epsilon)
-    POD = TP / (TP + FN+epsilon)
-    FPR = FP / (FP + TN+epsilon)
-    FAR = FP / (TP + FP+epsilon)
+    TPR = TP / (TP + FN + epsilon)
+    FNR = FN / (TP + FN + epsilon)
+    Acc = (TP + TN) / (TP + TN + FP + FN + epsilon)
+    Prec = TP / (TP + FP + epsilon)
+    sen = TP / (TP + FN + epsilon)
+    F1_score = 2 * (Prec * sen) / (Prec + sen + epsilon)
+    CSI = TP / (TP + FN + FP + epsilon)
+    POD = TP / (TP + FN + epsilon)
+    FPR = FP / (FP + TN + epsilon)
+    FAR = FP / (TP + FP + epsilon)
 
     return (
         unique_values,

fimeval/ContingencyMap/printcontingency.py

@@ -65,7 +65,7 @@ def getContingencyMap(raster_path, method_path):
         2: "False positive",
         3: "False negative",
         4: "True positive",
-        5: "Permanent water bodies"
+        5: "Permanent water bodies",
     }
     legend_patches = [
         Patch(

fimeval/__init__.py

@@ -1,11 +1,20 @@
-#Evaluation modules
+# Evaluation modules
 from .ContingencyMap.evaluationFIM import EvaluateFIM
 from .ContingencyMap.printcontingency import PrintContingencyMap
 from .ContingencyMap.plotevaluationmetrics import PlotEvaluationMetrics
 from .ContingencyMap.PWBs3 import get_PWB
 
-#Utility modules
+# Utility modules
 from .utilis import compress_tif_lzw
 
 # Evaluation with Building foorprint module
 from .BuildingFootprint.evaluationwithBF import EvaluationWithBuildingFootprint
+
+__all__ = [
+    "EvaluateFIM",
+    "PrintContingencyMap",
+    "PlotEvaluationMetrics",
+    "get_PWB",
+    "EvaluationWithBuildingFootprint",
+    "compress_tif_lzw",
+]

fimeval/utilis.py

@@ -1,3 +1,4 @@
+import os
 import shutil
 import pyproj
 import rasterio
@@ -5,24 +6,27 @@ from pathlib import Path
 import geopandas as gpd
 from rasterio.warp import calculate_default_transform, reproject, Resampling
 
-#Lossless compression to reduce the file size
+
+# Lossless compression to reduce the file size
 def compress_tif_lzw(tif_path):
     # Read original file
     with rasterio.open(tif_path) as src:
         profile = src.profile.copy()
         data = src.read()
-    profile.update(compress='lzw')
+    profile.update(compress="lzw")
 
-    with rasterio.open(tif_path, 'w', **profile) as dst:
+    with rasterio.open(tif_path, "w", **profile) as dst:
         dst.write(data)
 
-#Check whether it is a projected CRS
+
+# Check whether it is a projected CRS
 def is_projected_crs(crs):
     return crs and crs.is_projected
 
-#Check if the FIM bounds are within the CONUS
+
+# Check if the FIM bounds are within the CONUS
 def is_within_conus(bounds, crs=None):
-    CONUS_BBOX = (-125, 24, -66.5, 49.5) 
+    CONUS_BBOX = (-125, 24, -66.5, 49.5)
     left, bottom, right, top = bounds
 
     if crs and crs.is_projected:
@@ -37,7 +41,8 @@ def is_within_conus(bounds, crs=None):
         and top <= CONUS_BBOX[3]
     )
 
-#Reproject the FIMs to EPSG:5070 if withinUS and user doesnot define any target CRS, else user need to define it
+
+# Reproject the FIMs to EPSG:5070 if withinUS and user doesnot define any target CRS, else user need to define it
 def reprojectFIMs(src_path, dst_path, target_crs):
     with rasterio.open(src_path) as src:
         if src.crs != target_crs:
@@ -45,14 +50,16 @@ def reprojectFIMs(src_path, dst_path, target_crs):
                 src.crs, target_crs, src.width, src.height, *src.bounds
             )
             kwargs = src.meta.copy()
-            kwargs.update({
-                'crs': target_crs,
-                'transform': transform,
-                'width': width,
-                'height': height
-            })
-
-            with rasterio.open(dst_path, 'w', **kwargs) as dst:
+            kwargs.update(
+                {
+                    "crs": target_crs,
+                    "transform": transform,
+                    "width": width,
+                    "height": height,
+                }
+            )
+
+            with rasterio.open(dst_path, "w", **kwargs) as dst:
                 for i in range(1, src.count + 1):
                     reproject(
                         source=rasterio.band(src, i),
@@ -61,29 +68,32 @@ def reprojectFIMs(src_path, dst_path, target_crs):
                         src_crs=src.crs,
                         dst_transform=transform,
                         dst_crs=target_crs,
-                        resampling=Resampling.nearest
+                        resampling=Resampling.nearest,
                     )
         else:
             print(f"Source raster is already in {target_crs}. No reprojection needed.")
             shutil.copy(src_path, dst_path)
         compress_tif_lzw(dst_path)
 
-#Resample into the coarser resoution amoung all FIMS within the case
+
+# Resample into the coarser resoution amoung all FIMS within the case
 def resample_to_resolution(src_path, x_resolution, y_resolution):
+    src_path = Path(src_path)
+    print(src_path)
+    temp_path = src_path.with_name(src_path.stem + "_resampled.tif")
+    print(temp_path)
+
     with rasterio.open(src_path) as src:
-        transform = rasterio.transform.from_origin(src.bounds.left, src.bounds.top, x_resolution, y_resolution)
+        transform = rasterio.transform.from_origin(
+            src.bounds.left, src.bounds.top, x_resolution, y_resolution
+        )
         width = int((src.bounds.right - src.bounds.left) / x_resolution)
         height = int((src.bounds.top - src.bounds.bottom) / y_resolution)
-
         kwargs = src.meta.copy()
-        kwargs.update({
-            'transform': transform,
-            'width': width,
-            'height': height
-        })
-
-        dst_path = src_path
-        with rasterio.open(dst_path, 'w', **kwargs) as dst:
+        kwargs.update({"transform": transform, "width": width, "height": height})
+
+        # Write to temporary file
+        with rasterio.open(temp_path, "w", **kwargs) as dst:
             for i in range(1, src.count + 1):
                 reproject(
                     source=rasterio.band(src, i),
@@ -92,90 +102,87 @@ def resample_to_resolution(src_path, x_resolution, y_resolution):
                     src_crs=src.crs,
                     dst_transform=transform,
                     dst_crs=src.crs,
-                    resampling=Resampling.nearest
+                    resampling=Resampling.nearest,
                 )
-    # compress_tif_lzw(dst_path)
 
-#Check if the FIMs are in the same CRS or not else do further operation
+    os.remove(src_path)  # delete original
+    os.rename(temp_path, src_path)
+
+
+# Check if the FIMs are in the same CRS or not else do further operation
 def MakeFIMsUniform(fim_dir, target_crs=None, target_resolution=None):
     fim_dir = Path(fim_dir)
-    tif_files = list(fim_dir.glob('*.tif'))
+    tif_files = list(fim_dir.glob("*.tif"))
     if not tif_files:
         print(f"No TIFF files found in {fim_dir}")
         return
-    processing_folder = fim_dir / 'processing'
-    processing_folder.mkdir(exist_ok=True)
 
-    crs_list = []
-    projected_status = []
-    bounds_list = []
-    fims_data = []
+    # Create processing folder to save standardized files
+    processing_folder = fim_dir / "processing"
+    processing_folder.mkdir(exist_ok=True)
 
+    # Collect info about each TIFF
+    crs_list, resolutions, bounds_list, projected_flags = [], [], [], []
     for tif_path in tif_files:
         try:
             with rasterio.open(tif_path) as src:
                 crs_list.append(src.crs)
-                projected_status.append(is_projected_crs(src.crs))
+                resolutions.append(src.res)
                 bounds_list.append(src.bounds)
-                fims_data.append((src.bounds, src.crs))
-        except rasterio.RasterioIOError as e:
+                projected_flags.append(is_projected_crs(src.crs))
+        except Exception as e:
             print(f"Error opening {tif_path}: {e}")
             return
 
-    all_projected = all(projected_status)
-    first_crs = crs_list[0] if crs_list else None
-    all_same_crs = all(crs == first_crs for crs in crs_list)
+    # CRS Check & Reproject if needed
+    all_projected = all(projected_flags)
+    all_same_crs = len(set(crs_list)) == 1
 
     if not all_projected or (all_projected and not all_same_crs):
-        if target_crs:
-            print(f"Reprojecting all FIMs to {target_crs}.")
-            for src_path in tif_files:
-                dst_path = processing_folder / src_path.name
-                reprojectFIMs(str(src_path), str(dst_path), target_crs)
-                compress_tif_lzw(dst_path)
-        else:
-            all_within_conus = all(is_within_conus(bounds_list[i], crs_list[i]) for i in range(len(bounds_list)))
-
-            if all_within_conus:
-                default_target_crs = "EPSG:5070"
-                print(f"FIMs are within CONUS, reprojecting all to {default_target_crs} and saving to {processing_folder}")
-                for src_path in tif_files:
-                    dst_path = processing_folder / src_path.name
-                    reprojectFIMs(str(src_path), str(dst_path), default_target_crs)
+        # Decide CRS to use
+        final_crs = target_crs
+        if not final_crs:
+            if all(is_within_conus(b, c) for b, c in zip(bounds_list, crs_list)):
+                final_crs = "EPSG:5070"
+                print(f"Defaulting to CONUS CRS: {final_crs}")
             else:
-                print("All flood maps are not in the projected CRS or are not in the same projected CRS.\n")
-                print("Please provide a target CRS in EPSG format.")
-    else:
-        for src_path in tif_files:
-            dst_path = processing_folder / src_path.name
-            shutil.copy(src_path, dst_path)
-    
-    # Resolution check and resampling
-    processed_tifs = list(processing_folder.glob('*.tif'))
-    if processed_tifs:
-        resolutions = []
-        for tif_path in processed_tifs:
-            try:
-                with rasterio.open(tif_path) as src:
-                    resolutions.append(src.res)
-            except rasterio.RasterioIOError as e:
-                print(f"Error opening {tif_path} in processing folder: {e}")
+                print(
+                    "Mixed or non-CONUS CRS detected. Please provide a valid target CRS."
+                )
                 return
 
-        first_resolution = resolutions[0] if resolutions else None
-        all_same_resolution = all(res == first_resolution for res in resolutions)
+        print(f"Reprojecting all rasters to {final_crs}")
+        for src_path in tif_files:
+            dst_path = processing_folder / src_path.name
+            reprojectFIMs(str(src_path), str(dst_path), final_crs)
+            compress_tif_lzw(dst_path)
 
-        if not all_same_resolution:
-            if target_resolution is not None:
-                for src_path in processed_tifs:
-                    resample_to_resolution(str(src_path), target_resolution, target_resolution)
-            else:
-                coarser_x = max(res[0] for res in resolutions)
-                coarser_y = max(res[1] for res in resolutions)
-                print(f"Using coarser resolution: X={coarser_x}, Y={coarser_y}. Resampling all FIMS to this resolution.")
-                for src_path in processed_tifs:
-                    resample_to_resolution(str(src_path), coarser_x, coarser_y)
-        else:
-            print("All FIMs in the processing folder have the same resolution.")
     else:
-        print("No TIFF files found in the processing folder after CRS standardization.")
+        print(
+            "All rasters are in the same projected CRS. Copying to processing folder."
+        )
+        for src_path in tif_files:
+            shutil.copy(src_path, processing_folder / src_path.name)
+
+    # Resolution Check & Resample if needed
+    processed_tifs = list(processing_folder.glob("*.tif"))
+    final_resolutions = []
+    for tif_path in processed_tifs:
+        with rasterio.open(tif_path) as src:
+            final_resolutions.append(src.res)
+
+    unique_res = set(final_resolutions)
+    if target_resolution:
+        print(f"Resampling all rasters to target resolution: {target_resolution}m.")
+        for src_path in processed_tifs:
+            resample_to_resolution(str(src_path), target_resolution, target_resolution)
+
+    # Otherwise, only resample if resolutions are inconsistent
+    elif len(unique_res) > 1:
+        coarsest_x = max(res[0] for res in final_resolutions)
+        coarsest_y = max(res[1] for res in final_resolutions)
+        print(f"Using coarsest resolution: X={coarsest_x}, Y={coarsest_y}")
+        for src_path in processed_tifs:
+            resample_to_resolution(str(src_path), coarsest_x, coarsest_y)
+    else:
+        print("All rasters already have the same resolution. No resampling needed.")

{fimeval-0.1.51.dist-info → fimeval-0.1.53.dist-info}/METADATA

@@ -1,33 +1,29 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: fimeval
-Version: 0.1.51
+Version: 0.1.53
 Summary: A Framework for Automatic Evaluation of Flood Inundation Mapping Predictions Evaluation
-License: GPLv3
 Author: Surface Dynamics Modeling Lab
-Maintainer: Supath Dhital
-Maintainer-email: sdhital@crimson.ua.edu
-Requires-Python: >=3.10,<4.0
-Classifier: License :: Other/Proprietary License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Requires-Dist: boto3 (>=1.36.16,<2.0.0)
-Requires-Dist: geopandas (>=1.0.1,<2.0.0)
-Requires-Dist: kaleido (==0.2.1)
-Requires-Dist: matplotlib (>=3.9.2,<4.0.0)
-Requires-Dist: msfootprint (>=0.1.27,<0.2.0)
-Requires-Dist: nbformat (>=5.10.4,<6.0.0)
-Requires-Dist: notebook (>=7.3.2,<8.0.0)
-Requires-Dist: numpy (<2)
-Requires-Dist: pathlib (>=1.0.1,<2.0.0)
-Requires-Dist: plotly (>=5.24.1,<6.0.0)
-Requires-Dist: pyproj (>=3.7.0,<4.0.0)
-Requires-Dist: pytest (>=8.3.3,<9.0.0)
-Requires-Dist: rasterio (>=1.4.2,<2.0.0)
-Requires-Dist: shapely (>=2.0.6,<3.0.0)
+Author-email: Supath Dhital <sdhital@crimson.ua.edu>, Dipshika Devi <ddevi@ua.edu>
+Maintainer-email: Supath Dhital <sdhital@crimson.ua.edu>, Dipshika Devi <ddevi@ua.edu>
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: rasterio<2.0.0,>=1.4.2
+Requires-Dist: numpy>=2
+Requires-Dist: geopandas<2.0.0,>=1.0.1
+Requires-Dist: shapely<3.0.0,>=2.0.6
+Requires-Dist: matplotlib<4.0.0,>=3.9.2
+Requires-Dist: plotly<6.0.0,>=5.24.1
+Requires-Dist: kaleido==0.2.1
+Requires-Dist: nbformat<6.0.0,>=5.10.4
+Requires-Dist: pyproj<4.0.0,>=3.7.0
+Requires-Dist: notebook<8.0.0,>=7.3.2
+Requires-Dist: boto3<2.0.0,>=1.36.16
+Requires-Dist: geemap
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Dynamic: license-file
 
 ## Flood Inundation Mapping Predictions Evaluation Framework (FIMeval)
 <hr style="border: 1px solid black; margin: 0;">  
@@ -65,6 +61,7 @@ fimeval/
 ├── src/
 │   └── fimeval/         
 │       ├──BuildingFootprint/ # Contains the evaluation of model predicted FIM with microsoft building footprint
+│       │   └── microsoftBF.py 
 │       │   └── evaluationwithBF.py       
 │       └── ContingencyMap/      # Contains all the metrics calculation and contingency map generation
 │       │   ├── evaluationFIM.py # main evaluation moodule 
@@ -90,7 +87,8 @@ This framework is published as a python package in PyPI (https://pypi.org/projec
 
 ```bash
 #Install to use this framework
-pip install fimeval
+pip install uv #Makes the downloading much faster
+uv pip install fimeval
 
 #Use this framework in your workflows using poetry
 poetry add fimeval
@@ -163,7 +161,7 @@ Table 1: Modules in `fimeval` are in order of execution.
 | `EvaluateFIM` | It runs all the evaluation of FIM between B-FIM and M-FIMs. | `main_dir`: Main directory containing the case study folders, <br> `method_name`: How users wants to evaluate their FIM, <br> `outpur_dir`: Output directory where all the results and the intermidiate files will be saved for further calculation, <br>  *`PWB_dir`*: The permanenet water bodies vectory file directory if user wants to user their own boundary, <br> *`target_crs`*: this fimeval framework needs the floodmaps to be in projected CRS so define the projected CRS in epsg code format, <br> *`target_resolution`*: sometime if the benchmark is very high resolution than candidate FIMs, it needs heavy computational time, so user can define the resolution if there FIMs are in different spatial resolution, else it will use the coarser resolution among all FIMS within that case. |The outputs includes generated files in TIFF, SHP, CSV, and PNG formats, all stored within the output folder. Users can visualize the TIFF files using any geospatial platform. The TIFF files consist of the binary Benchmark-FIM (Benchmark.tif), Model-FIM (Candidate.tif), and Agreement-FIM (Contingency.tif). The shp files contain the boundary of the generated flood extent.|
 | `PlotContingencyMap` | For better understanding, It will print the agreement maps derived in first step. | `main_dir`, `method_name`, `output_dir` : Based on the those arguments, once all the evaluation is done, it will dynamically get the corresponding contingency raster for printing.| This prints the contingency map showing different class of evaluation (TP, FP, no data, PWB etc). The outputs look like- Figure 4 first row.|
 | `PlotEvaluationMetrics` | For quick understanding of the evaluation metrics, to plot bar of evaluation scores. | `main_dir`, `method_name`, `output_dir` : Based on the those arguments, once all the evaluation is done, it will dynamically get the corresponding file for printing based on all those info.| This prints the bar plots which includes different performance metrics calculated by EvaluateFIM module. The outputs look like- Figure 4 second row.|
-| `EvaluationWithBuildingFootprint` | For Building Footprint Analysis, user can specify shapefile of building footprints as .shp or .gpkg format. By default it consider global Microsoft building footprint dataset. Those data are hosted in Google Earth Engine (GEE) so, It pops up to authenticate the GEE account, please allow it and it will download the data based on evaluation boundary and evaluation is done. | `main_dir`, `method_name`, `output_dir`: Those arguments are as it is, same as all other modules. <br> *`building_footprint`*: If user wants to use their own building footprint file then pass the directory here, *`country`*: It is the 3 letter based country ISO code (eg. 'USA', NEP' etc), for the building data automation using GEE based on the evaluation extent, *`shapefile_dir`*: this is the directory of user defined AOI if user is working with their own boundary and automatic Building footprint download and evaluation. | It will calculate the different metrics (e.g. TP, FP, CSI, F1, Accuracy etc) based on hit and miss of building on different M-FIM and B-FIM. Those all metrics will be saved as CSV format in `output_dir` and finally using that info it prints the counts of building foorpint in each FIMs as well as scenario on the evaluation end via bar plot.|
+| `EvaluationWithBuildingFootprint` | For Building Footprint Analysis, user can specify shapefile of building footprints as .shp or .gpkg format. By default it consider global Microsoft building footprint dataset. Those data are hosted in Google Earth Engine (GEE) so, It pops up to authenticate the GEE account, please allow it and it will download the data based on evaluation boundary and evaluation is done. | `main_dir`, `method_name`, `output_dir`: Those arguments are as it is, same as all other modules. <br> *`building_footprint`*: If user wants to use their own building footprint file then pass the directory here, *`country`*: It is the 3 letter based country ISO code (eg. 'USA', NEP' etc), for the building data automation using GEE based on the evaluation extent, *`shapefile_dir`*: this is the directory of user defined AOI if user is working with their own boundary and automatic Building footprint download and evaluation, *`geeprojectID`*: this is the google earth engine google cloud project ID, which helps to access the GEE data and resources to work with building footprint download and process. | It will calculate the different metrics (e.g. TP, FP, CSI, F1, Accuracy etc) based on hit and miss of building on different M-FIM and B-FIM. Those all metrics will be saved as CSV format in `output_dir` and finally using that info it prints the counts of building foorpint in each FIMs as well as scenario on the evaluation end via bar plot.|
 
 <p align="center">
   <img src="./Images/methodsresults_combined.jpg" width="750" />
@@ -171,6 +169,58 @@ Table 1: Modules in `fimeval` are in order of execution.
 
 Figure 4: Combined raw output from framework for different two method. First row (subplot a and b) and second row (subplot c and d) is contingency maps and evaluation metrics of FIM derived using `PrintContingencyMaP` and `PlotEvaluationMetrics` module. Third row (subplot e and f) is the output after processing and calculating of evaluation with BF by unsing `EvaluateWithBuildingFoorprint` module.
 
+## Installation Instructions
+
+### 1. Prerequisites
+
+Before installing `fimeval`, ensure the following software are installed:
+
+- **Python**: Version 3.10 or higher  
+- **Anaconda**: For managing environments and dependencies  
+- **GIS Software**: For Visulalisation
+  - [ArcGIS](https://www.esri.com/en-us/arcgis/products/index) or [QGIS](https://qgis.org/en/site/)
+- **Optional**:
+  - [Google Earth Engine](https://earthengine.google.com/) account
+  - Java Runtime Environment (for using GEE API)
+
+---
+
+### 2. Install Anaconda
+
+If Anaconda is not installed, download and install it from the [official website](https://www.anaconda.com/products/distribution).
+
+---
+
+### 3. Set Up Virtual Environment
+
+#### For Mac Users
+
+Open **Terminal** and run:
+```bash
+# Create a new environment named 'fimeval'
+conda create --name fimeval python=3.10
+
+# Activate the environment
+conda activate fimeval
+
+# Install fimeval package
+pip install uv
+uv pip install fimeval
+```
+
+### Google Colab Version
+
+To use fimeval in Google Colab, follow the steps below:
+
+## Upload Files
+Upload all necessary input files (e.g., raster, shapefiles, model outputs) to your Google Drive.
+## Open Google Colab
+Go to Google Colab and sign in with a valid Google account.
+## Mount Google Drive
+In a new Colab notebook, mount the  Google Drive
+```bash
+pip install fimeval
+```
 ### **Acknowledgements**
 | | |
 | --- | --- |
@@ -181,4 +231,3 @@ Contact <a href="https://geography.ua.edu/people/sagy-cohen/" target="_blank">Sa
  (sagy.cohen@ua.edu)
  Dipsikha Devi, (ddevi@ua.edu)
 Supath Dhital, (sdhital@crimson.ua.edu)
-

fimeval-0.1.53.dist-info/RECORD

@@ -0,0 +1,17 @@
+fimeval/__init__.py,sha256=HZJKq7XEhL6TnwFkhpf8NcEQ5h7zPQ3XJh3z5gF0gQ8,603
+fimeval/utilis.py,sha256=JYpWTJx3WOuC0wRr3nb-cwMPf0SAGIli5dJdKFS23w8,6954
+fimeval/BuildingFootprint/__init__.py,sha256=oP9YWLdo6ANzSQFxYLv7Ku_26AY5NkLNhZLK28ICMLo,109
+fimeval/BuildingFootprint/evaluationwithBF.py,sha256=UjH_Fz38hiIa5NRSr5K7NobGTg-7cjfbzC68QmsmEeo,16050
+fimeval/BuildingFootprint/microsoftBF.py,sha256=gpNX30apn7R48LsZbVyiCbbtKMjNAw3G-Xz7uPTFtrs,4062
+fimeval/ContingencyMap/PWBs3.py,sha256=UFICxO58c2fA9mIffH4ooqphv3ZXe6yX8QzpRjtI6fs,1275
+fimeval/ContingencyMap/__init__.py,sha256=ckps2dyg6aci3TA-3P7oTMcCAcSTz9AA6sndHtZEwdE,259
+fimeval/ContingencyMap/evaluationFIM.py,sha256=IFmY7rCnqpyDVS5Qd6IyNzpt_wLv0po--Uy_PFsflZs,17016
+fimeval/ContingencyMap/methods.py,sha256=kbutfo9FUH-yjvnOXxwLpdErUuebMJ8NjCroNWIYCjo,3299
+fimeval/ContingencyMap/metrics.py,sha256=jwOia0Nl7aU7AuGJFAcQ4fVENnp2G_5W6JSJBzo1-_4,1094
+fimeval/ContingencyMap/plotevaluationmetrics.py,sha256=3bKfPKZnMR39dA3teDVpQBeTFKnF9v_2Vku0JNVGggs,3921
+fimeval/ContingencyMap/printcontingency.py,sha256=-1H_Ze2TbRSER7vy7bd0HvxnziNzPPOIPOm2YhB7r4A,5422
+fimeval-0.1.53.dist-info/licenses/LICENSE.txt,sha256=hIahDEOTzuHCU5J2nd07LWwkLW7Hko4UFO__ffsvB-8,34523
+fimeval-0.1.53.dist-info/METADATA,sha256=-VIziBiACuZ4-pZ7g87HXzl8xrq4TNOxtIo1QW8h_FU,16251
+fimeval-0.1.53.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+fimeval-0.1.53.dist-info/top_level.txt,sha256=F4QW50msI8sRrX_DK3NQ-s3swQ4-2_5Ty3mfm9ZMc6k,8
+fimeval-0.1.53.dist-info/RECORD,,

{fimeval-0.1.51.dist-info → fimeval-0.1.53.dist-info}/WHEEL

@@ -1,4 +1,5 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.9.1
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
+

fimeval-0.1.53.dist-info/top_level.txt

@@ -0,0 +1 @@
+fimeval

fimeval/ContingencyMap/fix_permissions.sh

@@ -1,23 +0,0 @@
-#!/bin/bash
-
-DIR="$1"
-
-if [ -z "$DIR" ]; then
-  echo "No directory provided."
-  exit 1
-fi
-echo "Fixing permissions for: $DIR"
-
-UNAME=$(uname)
-if [[ "$UNAME" == "Darwin" || "$UNAME" == "Linux" ]]; then
-  chmod -R u+rwX "$DIR"
-  echo "Permissions granted for user (u+rwX)"
-
-elif [[ "$UNAME" == *"MINGW"* || "$UNAME" == *"MSYS"* || "$UNAME" == *"CYGWIN"* ]]; then
-  icacls "$DIR" /grant Everyone:F /T > /dev/null
-  echo "Permissions granted for working folder"
-
-else
-  echo "Unsupported OS: $UNAME"
-  exit 1
-fi

fimeval-0.1.51.dist-info/RECORD

@@ -1,16 +0,0 @@
-fimeval/BuildingFootprint/__init__.py,sha256=oP9YWLdo6ANzSQFxYLv7Ku_26AY5NkLNhZLK28ICMLo,109
-fimeval/BuildingFootprint/evaluationwithBF.py,sha256=mnmcfyNPL_XBg9fIDXJjBWsRDKlCZ8HPjIhzCiFJkb8,14352
-fimeval/ContingencyMap/PWBs3.py,sha256=YAg03jzdplYIstG-pZM1MECse7gYjWrJNKAopjgt3uk,1294
-fimeval/ContingencyMap/__init__.py,sha256=ckps2dyg6aci3TA-3P7oTMcCAcSTz9AA6sndHtZEwdE,259
-fimeval/ContingencyMap/evaluationFIM.py,sha256=ZVoSAseQ_tb_WrY0JLZaTc9z3VCjMLt7iw_OY2-Gobc,16796
-fimeval/ContingencyMap/fix_permissions.sh,sha256=prIeJGXwAUO28nhgtCtvcpOxWK-J75rxN4FQ6QjGET4,508
-fimeval/ContingencyMap/methods.py,sha256=kbutfo9FUH-yjvnOXxwLpdErUuebMJ8NjCroNWIYCjo,3299
-fimeval/ContingencyMap/metrics.py,sha256=eEv1zAfmIjyg9OWM1b6-i25q_3jEBmeLZ7JeuvxS1QI,1070
-fimeval/ContingencyMap/plotevaluationmetrics.py,sha256=3bKfPKZnMR39dA3teDVpQBeTFKnF9v_2Vku0JNVGggs,3921
-fimeval/ContingencyMap/printcontingency.py,sha256=Ef0TlGNxvLlrliM2SCkhusgz9BsEGvVOBHAO62YC_QA,5421
-fimeval/__init__.py,sha256=kN114EvzG_BFjd65fKWXg29TqaWvR173EdCN3yj30oc,433
-fimeval/utilis.py,sha256=KNXcR0RvhT_lPqM_8cuAGXMpRtcLMfb_UDqUiMlDevs,7311
-fimeval-0.1.51.dist-info/LICENSE.txt,sha256=hIahDEOTzuHCU5J2nd07LWwkLW7Hko4UFO__ffsvB-8,34523
-fimeval-0.1.51.dist-info/METADATA,sha256=ic6uUVb5xRU0RyZMo-CUQ4YPjA_evv_DRBn_kmIqgIk,14848
-fimeval-0.1.51.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-fimeval-0.1.51.dist-info/RECORD,,