[Feat]: Implement memories features end to end backend and frontend both.

backend/app/routes/memories.py

@@ -0,0 +1,193 @@
+from fastapi import APIRouter, HTTPException
+from typing import List, Dict, Any
+from datetime import datetime
+import math
+
+from app.database.images import db_get_all_images
+
+router = APIRouter()
+
+# -------------------------------------------------
+# Helpers
+# -------------------------------------------------
+
+
+def haversine_distance(lat1, lon1, lat2, lon2) -> float:
+    R = 6371
+    lat1, lon1, lat2, lon2 = map(math.radians, [lat1, lon1, lat2, lon2])
+    dlat = lat2 - lat1
+    dlon = lon2 - lon1
+    a = (
+        math.sin(dlat / 2) ** 2
+        + math.cos(lat1) * math.cos(lat2) * math.sin(dlon / 2) ** 2
+    )
+    return 2 * R * math.asin(math.sqrt(a))
+
+
+def decide_memory_type(mem: Dict[str, Any]) -> str:
+    now = datetime.now()
+    date = mem["anchor_date"]
+    lat = mem["lat"]
+    lon = mem["lon"]
+
+    if date.month == now.month and date.day == now.day and date.year != now.year:
+        return "on_this_day"
+
+    if lat is not None and lon is not None:
+        return "trip"
+
+    return "date_range"
+
+
+def generate_title(mem: Dict[str, Any]) -> str:
+    mtype = decide_memory_type(mem)
+    date = mem["anchor_date"]
+    now = datetime.now()
+
+    if mtype == "on_this_day":
+        years = now.year - date.year
+        return (
+            "On this day last year"
+            if years == 1
+            else f"On this day · {years} years ago"
+        )
+
+    if mtype == "trip":
+        return f"Trip · {date.strftime('%B %Y')}"
+
+    return f"Memories from {date.strftime('%B %Y')}"
+
+
+# -------------------------------------------------
+# Core Logic
+# -------------------------------------------------
+
+
+def group_images(images: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    memories: List[Dict[str, Any]] = []
+
+    for img in images:
+        metadata = img.get("metadata", {})
+        date_str = metadata.get("date_created")
+        lat = metadata.get("latitude")
+        lon = metadata.get("longitude")
+
+        if not date_str:
+            continue
+
+        try:
+            date = datetime.fromisoformat(date_str.replace("Z", "+00:00"))
+        except Exception:
+            continue
+
+        matched = None
+
+        for mem in memories:
+            day_diff = abs((date - mem["anchor_date"]).days)
+
+            # 1️⃣ Same-day / near-day memory
+            if day_diff <= 1:
+                matched = mem
+                break
+
+            # 2️⃣ Trip memory (GPS + time proximity)
+            if (
+                day_diff <= 3
+                and lat is not None
+                and lon is not None
+                and mem["lat"] is not None
+                and mem["lon"] is not None
+                and haversine_distance(lat, lon, mem["lat"], mem["lon"]) <= 10
+            ):
+                matched = mem
+                break
+
+        if not matched:
+            matched = {
+                "memory_id": f"memory_{len(memories)}",
+                "anchor_date": date,
+                "date_range_start": date,
+                "date_range_end": date,
+                "lat": lat,
+                "lon": lon,
+                "images": [],
+            }
+            memories.append(matched)
+
+        matched["images"].append(img)
+        matched["date_range_start"] = min(matched["date_range_start"], date)
+        matched["date_range_end"] = max(matched["date_range_end"], date)
+
+    # -------------------------------------------------
+    # Final formatting (IMPORTANT)
+    # -------------------------------------------------
+
+    result: List[Dict[str, Any]] = []
+
+    for mem in memories:
+        # ❗ Google Photos rule: at least 2 images
+        if len(mem["images"]) < 2:
+            continue
+
+        images_sorted = sorted(
+            mem["images"], key=lambda i: i.get("metadata", {}).get("date_created") or ""
+        )
+
+        highlights = images_sorted[:5]
+        cover = highlights[0]
+
+        result.append(
+            {
+                "id": mem["memory_id"],
+                "title": generate_title(mem),
+                "memory_type": decide_memory_type(mem),
+                "date_range_start": mem["date_range_start"].isoformat(),
+                "date_range_end": mem["date_range_end"].isoformat(),
+                "image_count": len(mem["images"]),
+                "representative_image": {
+                    "id": cover["id"],
+                    "path": cover["path"],
+                    "thumbnailPath": cover["thumbnailPath"],
+                    "metadata": cover["metadata"],
+                },
+                "images": mem["images"],
+            }
+        )
+
+    result.sort(key=lambda m: m["date_range_start"], reverse=True)
+    return result
+
+
+# -------------------------------------------------
+# API
+# -------------------------------------------------
+
+
+@router.get("/")
+def get_memories():
+    try:
+        images = db_get_all_images()
+        return {
+            "success": True,
+            "data": group_images(images),
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/{memory_id}/images")
+def get_memory_images(memory_id: str):
+    try:
+        images = db_get_all_images()
+        grouped_memories = group_images(images)
+
+        for mem in grouped_memories:
+            if mem["id"] == memory_id:
+                return {
+                    "success": True,
+                    "data": mem["images"],
+                }
+
+        raise HTTPException(status_code=404, detail="Memory not found")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

backend/main.py

@@ -26,6 +26,7 @@
 from app.routes.images import router as images_router
 from app.routes.face_clusters import router as face_clusters_router
 from app.routes.user_preferences import router as user_preferences_router
+from app.routes.memories import router as memories_router
 from fastapi.openapi.utils import get_openapi
 from app.logging.setup_logging import (
     configure_uvicorn_logging,
@@ -132,6 +133,7 @@ async def root():
 app.include_router(
     user_preferences_router, prefix="/user-preferences", tags=["User Preferences"]
 )
+app.include_router(memories_router, prefix="/memories", tags=["Memories"])
 
 
 # Entry point for running with: python3 main.py

docs/backend/backend_python/openapi.json

@@ -1117,9 +1117,14 @@
             "in": "query",
             "required": false,
             "schema": {
-              "$ref": "#/components/schemas/InputType",
+              "allOf": [
+                {
+                  "$ref": "#/components/schemas/InputType"
+                }
+              ],
               "description": "Choose input type: 'path' or 'base64'",
-              "default": "path"
+              "default": "path",
+              "title": "Input Type"
             },
             "description": "Choose input type: 'path' or 'base64'"
           }
@@ -1299,6 +1304,65 @@
           }
         }
       }
+    },
+    "/memories/": {
+      "get": {
+        "tags": [
+          "Memories"
+        ],
+        "summary": "Get Memories",
+        "operationId": "get_memories_memories__get",
+        "responses": {
+          "200": {
+            "description": "Successful Response",
+            "content": {
+              "application/json": {
+                "schema": {}
+              }
+            }
+          }
+        }
+      }
+    },
+    "/memories/{memory_id}/images": {
+      "get": {
+        "tags": [
+          "Memories"
+        ],
+        "summary": "Get Memory Images",
+        "operationId": "get_memory_images_memories__memory_id__images_get",
+        "parameters": [
+          {
+            "name": "memory_id",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "string",
+              "title": "Memory Id"
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "Successful Response",
+            "content": {
+              "application/json": {
+                "schema": {}
+              }
+            }
+          },
+          "422": {
+            "description": "Validation Error",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/HTTPValidationError"
+                }
+              }
+            }
+          }
+        }
+      }
     }
   },
   "components": {
@@ -2199,7 +2263,6 @@
           "metadata": {
             "anyOf": [
               {
-                "additionalProperties": true,
                 "type": "object"
               },
               {

frontend/src/api/api-functions/index.ts

@@ -4,3 +4,4 @@ export * from './images';
 export * from './folders';
 export * from './user_preferences';
 export * from './health';
+export * from './memories';

frontend/src/api/api-functions/memories.ts

@@ -0,0 +1,17 @@
+import { apiClient } from '../axiosConfig';
+import {
+  MemoriesApiResponse,
+  MemoryImagesApiResponse,
+} from '@/types/memories';
+
+export const fetchAllMemories = async (): Promise<MemoriesApiResponse> => {
+  const response = await apiClient.get('/memories/');
+  return response.data;
+};
+
+export const fetchMemoryImages = async (
+  memoryId: string
+): Promise<MemoryImagesApiResponse> => {
+  const response = await apiClient.get(`/memories/${memoryId}/images`);
+  return response.data;
+};

frontend/src/api/api-functions/togglefav.ts

@@ -2,10 +2,10 @@ import { imagesEndpoints } from '../apiEndpoints';
 import { apiClient } from '../axiosConfig';
 import { APIResponse } from '@/types/API';
 
-export const togglefav = async (image_id: string): Promise<APIResponse> => {
+export const togglefav = async (image_id: number): Promise<APIResponse> => {
   const response = await apiClient.post<APIResponse>(
     imagesEndpoints.setFavourite,
-    { image_id },
+    { image_id: image_id.toString() },
   );
   return response.data;
 };

frontend/src/api/apiEndpoints.ts

@@ -30,3 +30,8 @@ export const userPreferencesEndpoints = {
 export const healthEndpoints = {
   healthCheck: '/health',
 };
+
+export const memoriesEndpoints = {
+  getAllMemories: '/memories/',
+  getMemoryImages: (memoryId: string) => `/memories/${memoryId}/images`,
+};

frontend/src/components/Media/ChronologicalGallery.tsx

@@ -59,7 +59,7 @@ export const ChronologicalGallery = ({
   }, [sortedGrouped]);
 
   const imageIndexMap = useMemo(() => {
-    const map = new Map<string, number>();
+    const map = new Map<number, number>();
     chronologicallySortedImages.forEach((img, idx) => {
       map.set(img.id, idx);
     });

frontend/src/components/Media/MediaThumbnails.tsx

@@ -3,7 +3,7 @@ import { convertFileSrc } from '@tauri-apps/api/core';
 
 interface MediaThumbnailsProps {
   images: Array<{
-    id: string;
+    id: number;
     path: string;
     thumbnailPath: string;
   }>;

frontend/src/hooks/useToggleFav.ts

@@ -4,15 +4,15 @@ import { togglefav } from '@/api/api-functions/togglefav';
 
 export const useToggleFav = () => {
   const toggleFavouriteMutation = usePictoMutation({
-    mutationFn: async (image_id: string) => togglefav(image_id),
+    mutationFn: async (image_id: number) => togglefav(image_id),
     autoInvalidateTags: ['images'],
   });
   useMutationFeedback(toggleFavouriteMutation, {
     showLoading: false,
     showSuccess: false,
   });
   return {
-    toggleFavourite: (id: any) => toggleFavouriteMutation.mutate(id),
+    toggleFavourite: (id: number) => toggleFavouriteMutation.mutate(id),
     toggleFavouritePending: toggleFavouriteMutation.isPending,
   };
 };