Merge branch 'main' into docs/refactor

Author: wherop

backend/.vscode/settings.json

@@ -4,6 +4,9 @@
     "files.trimFinalNewlines": true,
     "python.analysis.autoImportCompletions": true,
     "python.analysis.typeCheckingMode": "basic",
+    "python.analysis.diagnosticSeverityOverrides": {
+    "reportPrivateImportUsage": "none"
+    },
     "[python]": {
         "editor.formatOnSave": true,
         "editor.codeActionsOnSave": {

backend/src/cache/msavi_cache.py

@@ -1,30 +1,99 @@
-import json
-
-content = [
-    {"timestamp": 1493251200, "value": 0.6265267304234295},
-    {"timestamp": 1494720000, "value": 0.68603163673333},
-    {"timestamp": 1494979200, "value": 0.755257128311451},
-]
-var_name = "msavi_daily_cache"
-file_name = "../cache/temp_cache.py"
-INDENT = "    "
-
-def combine_chache_with_update():
-    # update existing cache
-    return
-
-def write_year(file, year, results):
-    file.write(f"{INDENT}# Year {year}\n")
-
-def write_results_to_cache(results: list, var_name: str, file_name: str):
-    with open(file_name, "w") as file:
-        file.write(f"{var_name} = [\n")
-        for day in results:
-            file.write(f"{INDENT}{json.dumps(day)},\n")
+import os
+from enum import Enum
+
+from ..constants import IndexType
+from ..cache import ndvi_cache
+from ..cache import msavi_cache
+
+
+TIMESTAMP = "timestamp"
+CACHE_PATH = "../cache/"
+
+
+class ChosenCache(Enum):
+    NDVI = ndvi_cache.ndvi_daily_cache
+    MSAVI = msavi_cache.msavi_daily_cache
+
+
+index_type_to_cache = {
+    IndexType.NDVI: ChosenCache.NDVI,
+    IndexType.MSAVI: ChosenCache.MSAVI,
+}
+
+
+class CacheName(Enum):
+    NDVI = "ndvi_daily_cache"
+    MSAVI = "msavi_daily_cache"
+
+
+index_type_to_cache_name = {
+    IndexType.NDVI: CacheName.NDVI,
+    IndexType.MSAVI: CacheName.MSAVI,
+}
+
+
+class CacheFileName(Enum):
+    NDVI = "ndvi_cache.py"
+    MSAVI = "msavi_cache.py"
+
+
+index_type_to_cache_file = {
+    IndexType.NDVI: CacheFileName.NDVI,
+    IndexType.MSAVI: CacheFileName.MSAVI,
+}
+
+
+def load_cache_file(index_type):
+    try:
+        cache_list = index_type_to_cache[index_type].value
+        if isinstance(cache_list, list) and all(
+            isinstance(item, dict) for item in cache_list
+        ):
+            return cache_list
+    except (SyntaxError, ValueError, IndexError):
+        pass
+
+    return []
+
+
+def save_cache_to_file(cache, index_type):
+    """Save the updated cache to the file, maintaining the variable structure."""
+    dirname = os.path.dirname(__file__)
+    filepath = os.path.join(
+        dirname, CACHE_PATH, index_type_to_cache_file[index_type].value
+    )
+    with open(filepath, "w") as file:
+        cache_name = index_type_to_cache_name[index_type].value
+        file.write(f"{cache_name} = [\n")
+        for entry in cache:
+            file.write(f"    {entry},\n")
         file.write("]\n")
-    file.close()
 
-    return
+
+def update_cache_file(data, index_type: IndexType):
+    """Update the cache with new data while maintaining chronological order."""
+    cache = load_cache_file(index_type)
+    existing_timestamps = {entry[TIMESTAMP] for entry in cache}
+
+    # Add only new entries
+    new_entries = [
+        entry for entry in data if entry[TIMESTAMP] not in existing_timestamps
+    ]
+    cache.extend(new_entries)
+
+    # Sort the cache by timestamp
+    cache.sort(key=lambda x: x[TIMESTAMP])
+
+    # Save back to the file
+    save_cache_to_file(cache, index_type)
 
 
-# write_results_to_cache(content, var_name, file_name)
+def update_cache(input: list[dict], index_type: IndexType):
+    try:
+        if isinstance(input, list) and all(isinstance(item, dict) for item in input):
+            update_cache_file(input, index_type)
+            print("Cache updated successfully.")
+        else:
+            print("Invalid input format. Expected a list of dictionaries.")
+    except ValueError as e:
+        print(f"Error parsing input data: {e}")

backend/src/controller/__init__.py

@@ -9,13 +9,13 @@
 def get_index_image_by_index_type(index_type: IndexType, image: ee.Image):
     match index_type:
         case IndexType.NDVI:
-            return image.normalizedDifference(["B8", "B4"]).rename("NDVI")
+            return image.normalizedDifference(["B8", "B4"]).rename("NDVI") # B8 = NIR, B4 = RED
         case IndexType.MSAVI:
             return image.expression(
                 expression="((2 * NIR + 1) - ((2 * NIR + 1)**2 - 8 * (NIR - RED))**0.5) / 2",
                 opt_map={
-                    "NIR": image.select("B4"),
-                    "RED": image.select("B8"),
+                    "NIR": image.select("B8"),
+                    "RED": image.select("B4"),
                 },
             ).rename("MSAVI")
         case _:

backend/src/controller/sat_index_controller.py

@@ -169,6 +169,7 @@ def sat_index_service(
         sat_index_time_series = get_sat_index_info(
             masked_images, LocationPolygon[location.value].value, index_type
         )
+        # call caching script here
 
     # Get cached range
     if cache_start_date:

backend/src/gee/caching_script.py

@@ -26,17 +26,3 @@ def validate_timestamp_start_date_before_end_date(startDate, endDate):
         raise HTTPException(
             status_code=400, detail="endDate must be after startDate")
     return endDate
-
-
-def validate_temperature_timestamp_in_range(start, end):
-    min_timestamp = -946771200  # 01/01/1940
-    max_timestamp = int(time.time()) # now
-    print(end)
-    print(max_timestamp)
-    if (start < min_timestamp or end > max_timestamp):
-        raise HTTPException(
-            status_code=400, detail=f"Timestamp must be between {min_timestamp} and {max_timestamp}")
-    elif end <= start:
-        raise HTTPException(
-            status_code=400, detail="endDate must be after startDate")
-    return end