feat!: run everything through main

src/data_models/image_manager.py

@@ -13,13 +13,13 @@ class ImageManager:
         """Initialise connection and session."""
         self.engine, self.session = get_db_connection()
 
-    def add_image(self, name, created_at, park_id=None):
+    def add_image(self, name: str, created_at: datetime, park_id=None) -> int:
         """
         Add an image to the `images` table.
 
         Args:
             name (str): Image name.
-            created_at (str): Image creation date. Format: "YYYY-MM-DD HH:MM:SS".
+            created_at (datetime): Image creation date.
             park_id (int):id of the park where the image was taken.
         Returns:
             dict: Information of the added image.
@@ -28,18 +28,15 @@ class ImageManager:
             """
             INSERT INTO images (name, created_at, park_id)
             VALUES (:name, :created_at, :park_id)
+            RETURNING id
         """
         )
         try:
-            self.session.execute(
+            response = self.session.execute(
                 query, {"name": name, "created_at": created_at, "park_id": park_id}
-            )
+            ).fetchone()
             self.session.commit()
-            return {
-                "name": name,
-                "created_at": created_at,
-                "park_id": park_id,
-            }
+            return response[0]
         except Exception as e:
             self.session.rollback()
             raise Exception(f"An error occurred while adding the image: {e}")
@@ -54,7 +51,7 @@ class ImageManager:
         """
         query = text("SELECT id FROM images WHERE name = :image_name")
         try:
-            result = self.session.execute(query, {"image_name": image_name}).fetchone()
+            result = self.session.execute(query, {"image_name": image_name})
             return result[0] if result else None
         except Exception as e:
             raise Exception(f"An error occurred while getting the image ID: {e}")

src/data_models/openai_manager.py

@@ -0,0 +1,65 @@
+"""Manage bounding boxes in the database."""
+
+from sqlalchemy import text
+import json
+from data_models.sql_connection import get_db_connection
+
+
+class OpenAIManager:
+    def __init__(self):
+        """Initialise connection and session."""
+        self.engine, self.session = get_db_connection()
+
+    def add_predictions(
+        self,
+        img_id,
+        predictions,
+    ):
+        """
+        Add predictions to the `openai_predictions` table.
+
+        Args:
+            img_id (int): ID of the image where the bounding box was detected.
+            built_elements (dict): Built elements detected in the image.
+            fauna_identification (dict): Fauna identification detected in the image.
+            human_activity (dict): Human activity detected in the image.
+            human_detection (dict): Humans detected in the image.
+            vegetation_detection (dict): Vegetation detected in the image.
+            water_elements (dict): Water elements detected in the image.
+        """
+        query = text(
+            """
+            INSERT INTO openai_predictions (img_id, built_elements, fauna_identification, human_activity, human_detection, vegetation_detection, water_elements)
+            VALUES (:img_id, :built_elements, :fauna_identification, :human_activity, :human_detection, :vegetation_detection, :water_elements)
+        """
+        )
+        try:
+            self.session.execute(
+                query,
+                {
+                    "img_id": img_id,
+                    "built_elements": json.dumps(predictions["built_elements"]),
+                    "fauna_identification": json.dumps(predictions["fauna_identification"]),
+                    "human_activity": json.dumps(predictions["human_activity"]),
+                    "human_detection": json.dumps(predictions["human_detection"]),
+                    "vegetation_detection": json.dumps(predictions["vegetation_detection"]),
+                    "water_elements": json.dumps(predictions["water_elements"])
+                },
+            )
+            self.session.commit()
+            return {
+                "img_id": img_id,
+                "built_elements": predictions["built_elements"],
+                "fauna_identification": predictions["fauna_identification"],
+                "human_activity": predictions["human_activity"],
+                "human_detection": predictions["human_detection"],
+                "vegetation_detection": predictions["vegetation_detection"],
+                "water_elements": predictions["water_elements"],
+            }
+        except Exception as e:
+            self.session.rollback()
+            raise Exception(f"An error occurred while adding the predictions: {e}")
+
+    def close_connection(self):
+        """Close the connection."""
+        self.session.close()

src/data_models/park_manager.py

@@ -10,17 +10,18 @@ class ParkManager:
         """Initialise connection and session."""
         self.engine, self.session = get_db_connection()
 
-    def add_park(self, name):
+    def add_park(self, name) -> int:
         query = text(
             """
             INSERT INTO parks (name)
             VALUES (:name)
+            RETURNING id
         """
         )
         try:
-            self.session.execute(query, {"name": name})
+            response = self.session.execute(query, {"name": name})
             self.session.commit()
-            return {"name": name}
+            return response.all()[0][0]
         except Exception as e:
             self.session.rollback()
             raise Exception(f"An error occurred while adding the park: {e}")
@@ -32,12 +33,12 @@ class ParkManager:
         Returns:
             list[dict]: list of parks.
         """
-        query = text("SELECT * FROM parks")
         try:
+            query = text("SELECT * FROM parks")
             result = self.session.execute(query)
-            return [dict(row) for row in result]
+            return [row for row in result.fetchall()]
         except Exception as e:
-            raise Exception(f"An error occurred while adding the park: {e}")
+            raise Exception(f"An error occurred while fetching the parks: {e}")
 
     def get_park_id(self, park_name):
         """Get the park ID from the park name.

src/fetch_places.py

@@ -1,8 +1,18 @@
 import os
 import requests
 import json
+from datetime import datetime
 
 from typing import Tuple
+from data_models.park_manager import ParkManager
+from data_models.image_manager import ImageManager
+from data_models.openai_manager import OpenAIManager
+from openai_predictions import process_agent_predictions
+
+
+park_manager = ParkManager()
+image_manager = ImageManager()
+prediction_manager = OpenAIManager()
 
 
 def nearby_search(coordinates: tuple) -> Tuple[str, str, dict]:
@@ -110,7 +120,7 @@ def fetch_photo(place_id: str, photo_id: str, max_width: int, max_height: int) -
     return response.content
 
 
-def fetch_place_photos(place_id: str, place_name:str, photos: dict, folder: str = "images") -> str:
+def fetch_place_photos(place_id: str, place_name: str, photos: dict) -> int:
     """Fetch all photos from place datas
 
     Args:
@@ -122,19 +132,25 @@ def fetch_place_photos(place_id: str, place_name:str, photos: dict, folder: str
     Returns:
         str: Place ID
     """
-    folder_path = f"{place_name}/{place_id}"
+    folder_path = f"images/{place_name}"
     os.makedirs(folder_path, exist_ok=True)
 
+    park_id = park_manager.add_park(place_name)
     for photo in photos:
         photo_id = photo["name"].replace(f"places/{place_id}/photos/", "")
+        photo_id = photo_id.replace("/", "_")
 
         max_width = photo["widthPx"]
         max_height = photo["heightPx"]
 
         photo_binary = fetch_photo(place_id, photo_id, max_width, max_height)
-        with open(f"{folder_path}/{photo_id[:150]}.jpg", "wb") as f:
+        file_name = f"{folder_path}/{photo_id[:150]}.jpg"
+        with open(file_name, "wb") as f:
             f.write(photo_binary)
 
-    print(f"{len(photos)} photos fetched for place: {place_id}")
+        image_id = image_manager.add_image(file_name, datetime.now(), park_id=park_id)
+        predictions = process_agent_predictions(file_name)
+        prediction_manager.add_predictions(image_id, predictions)
 
-    return place_id
+    print(f"{len(photos)} photos fetched for place: {place_name}")
+    return len(photos)

src/main.py

@@ -7,11 +7,10 @@ if __name__ == "__main__":
     file_path = "datas/Espaces_verts_SCAI.kml"
     kml_data = parse_kml(file_path)
     coordinates = get_coordinates(kml_data)
-    print(coordinates["Al Khaldiyah Park"])
 
     for place_name, coordinate in tqdm(coordinates.items()):
         try:
             place_id, _, photos = nearby_search(coordinate)
-            photos = fetch_place_photos(place_id, place_name, photos)
+            fetch_place_photos(place_id, place_name, photos)
         except Exception as e:
             print(f"Error: {e} for {place_name}")

src/openai_predictions.py

@@ -1,9 +1,8 @@
 import os
 import base64
+from tqdm import tqdm
 
 from openai_agent import Agent
-from data_models.park_manager import ParkManager
-from data_models.image_manager import ImageManager, add_image_to_db
 
 agent = Agent("./prompts")
 
@@ -17,7 +16,7 @@ def encode_image(image_path: str):
         return base64.b64encode(image_file.read()).decode("utf-8")
 
 
-def _process_agent_predictions(file_path):
+def process_agent_predictions(file_path):
     base64_image = encode_image(file_path)
 
     prompts = [
@@ -38,42 +37,3 @@ def _process_agent_predictions(file_path):
         responses[prompt] = response.as_json()
 
     return responses
-
-
-def process_agent_predictions(list_folder: list[str]):
-    """
-    Process predictions for a list of image folders, adding images and bounding boxes to the database.
-
-    Args:
-        list_folder (list): List of image folders.
-        model_file (str): Path to the YOLO model.
-
-    Raises:
-        Exception: If an error occurs during processing.
-    """
-    park_manager = ParkManager()
-    image_manager = ImageManager()
-    print(f"Initializing processing of predictions...")
-
-    for folder in list_folder:
-        print(f"Processing folder: {folder}...")
-        park_name = folder.split("/")[-1]
-        print(park_name)
-
-        print(f"Retrieving park ID for '{park_name}'...")
-        park_id = park_manager.get_park_id(park_name)
-        if not park_id:
-            print(f"Park '{park_name}' not found in the database. Skipping folder.")
-            continue
-
-        for file in os.listdir(folder):
-            file_path = os.path.join(folder, file)
-            print(file_path)
-            predictions = _process_agent_predictions(file_path)
-
-            for result in predictions:
-                print(f"Processing result for image: {result.path.split('/')[-1]}...")
-                if 
-                image_id = add_image_to_db(result, image_manager, park_id)
-
-    print(f"Processing complete. Closing database connections.")

src/predict.py

@@ -1,58 +0,0 @@
-import os
-from tqdm import tqdm
-from yolo_predictions import process_YOLO_predictions
-from openai_predictions import process_agent_predictions
-from data_models.park_manager import ParkManager
-
-
-def load_images_from_folder(folder):
-    """
-    Load images from a folder.
-
-    Args:
-        folder (str): Path to the folder.
-
-    Returns:
-        list: List of image paths.
-    """
-    for file in os.listdir(folder):
-        if file.endswith(".jpg") or file.endswith(".png"):
-            yield os.path.join(folder, file)
-
-
-def process_predictions(list_folder, model_file):
-    """
-    Process predictions for a list of image folders, adding images and bounding boxes to the database.
-
-    Args:
-        list_folder (list): List of image folders.
-        model_file (str): Path to the YOLO model.
-
-    Raises:
-        Exception: If an error occurs during processing.
-    """
-    park_manager = ParkManager()
-
-    for folder in list_folder:
-        print(f"Loading images from folder: {folder}...")
-
-        park_name = folder.split("/")[-1]
-
-        print(f"Retrieving park ID for '{park_name}'...")
-        park_id = park_manager.get_park_id(park_name)
-        if not park_id:
-            print(f"Park '{park_name}' not found in the database. Skipping folder.")
-            continue
-
-        for image in tqdm(load_images_from_folder(folder)):
-            process_YOLO_predictions(park_id, image, model_file)
-            # process_agent_predictions(park_id, image)
-        print(f"Folders {folder} processed successfully!")
-    park_manager.close_connection()
-
-
-if __name__ == "__main__":
-    list_folder = ["./images/Al Khaldiyah Park", "./images/Family Park"]
-    model_file = "yolo11s.pt"
-
-    process_predictions(list_folder, model_file)