updates

agent.py

@@ -14,8 +14,9 @@ from tools import (absolute, add, analyze_csv_file, analyze_excel_file,
                    factorial, floor_divide, get_current_time_in_timezone,
                    greatest_common_divisor, is_prime, least_common_multiple,
                    logarithm, modulus, multiply, percentage_calculator, power,
-                   python_code_parser, roman_calculator_converter, square_root,
-                   subtract, web_search, wiki_search)
+                   python_code_parser, reverse_sentence,
+                   roman_calculator_converter, square_root, subtract,
+                   web_search, wiki_search)
 
 # Load Constants
 load_dotenv()
@@ -31,7 +32,7 @@ tools = [
     is_prime, least_common_multiple, percentage_calculator,
     wiki_search, analyze_excel_file, arvix_search,
     audio_transcription, python_code_parser, analyze_csv_file,
-    extract_text
+    extract_text, reverse_sentence
 ]
 
 # Load system prompt

app.py

@@ -16,24 +16,46 @@ DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 # --- Basic Agent Definition ---
 # ----- THIS IS WERE YOU CAN BUILD WHAT YOU WANT ------
 class BasicAgent:
+    """A basic agent that uses a pre-built graph to answer questions.
+
+    This agent is initialized with a graph structure that defines its
+    reasoning and processing flow. When called, it takes a user's question,
+    invokes the graph with it, and returns the final response.
+
+    Attributes:
+        graph: The compiled graph from `build_graph()` that processes messages.
+    """
     def __init__(self):
+        """Initializes the BasicAgent by building its processing graph."""
         print("BasicAgent initialized.")
+        # This function should be defined elsewhere in the code.
+        # It is expected to return a compiled LangChain graph.
         self.graph = build_graph()
 
     def __call__(self, question: str) -> str:
+        """Processes a question using the agent's graph and returns the answer.
+
+        This method makes the agent instance callable. It wraps the user's
+        question in a HumanMessage, sends it through the processing graph,
+        and extracts the content from the final message in the response.
+
+        Args:
+            question: The question to be processed by the agent.
+
+        Returns:
+            The answer generated by the agent's graph as a string.
+        """
         print(f"Agent received question (first 50 chars): {question[:50]}...")
         # Wrap the question in a HumanMessage from langchain_core
         messages = [HumanMessage(content=question)]
-        messages = self.graph.invoke({"messages": messages})
-        answer = messages['messages'][-1].content
+        # The graph.invoke method takes a dictionary with the key "messages"
+        # and returns a dictionary with the processed messages.
+        response_messages = self.graph.invoke({"messages": messages})
+        # The answer is expected to be in the 'content' of the last message.
+        answer = response_messages['messages'][-1].content
         print(f"Agent full response: {answer}")
+        return answer
         
-        # Optionally trim the "Final Answer: " prefix only if it exists
-        if answer.startswith("Final Answer:"):
-            return answer[len("Final Answer:"):].strip()
-        else:
-            return answer.strip()
-
 
 
 def run_and_submit_all( profile: gr.OAuthProfile | None):

requirements.txt

@@ -35,6 +35,22 @@ assemblyai # For AssemblyAIAudioTranscriptLoader
 
 # Additional utilities
 typing-extensions
-asyncio-throttle
-tenacity
-loguru
+# asyncio-throttle
+#tenacity
+# loguru
+
+torch
+torchvision
+opencv-python
+pytube
+
+# YOLOv5 and dependencies
+numpy
+matplotlib
+scipy
+seaborn
+tqdm
+pyyaml
+pillow
+
+git+https://github.com/ultralytics/yolov5.git

tools.py

@@ -2,10 +2,13 @@ import base64
 import datetime
 import math
 import os
-from typing import List, Union
+import tempfile
+from typing import Dict, Union
 
+import cv2
 import pandas
 import pytz
+import torch
 from langchain.schema import HumanMessage
 from langchain_community.document_loaders import (
     ArxivLoader, AssemblyAIAudioTranscriptLoader, WikipediaLoader)
@@ -14,6 +17,7 @@ from langchain_community.document_loaders.parsers import LanguageParser
 from langchain_community.tools import DuckDuckGoSearchRun
 from langchain_core.tools import tool
 from langchain_google_genai import ChatGoogleGenerativeAI
+from pytube import YouTube
 
 
 @tool
@@ -748,3 +752,79 @@ def extract_text(img_path: str) -> str:
         error_msg = f"Error extracting text: {str(e)}"
         print(error_msg)
         return ""
+
+
+@tool
+def reverse_sentence(text: str) -> str:
+    """
+    Reverses the input text.
+    Args:
+        text (str): The input string to be reversed.
+    Returns:
+        str: The reversed string.
+    """
+    return text[::-1]
+
+
+def get_max_bird_species_count_from_video(url: str) -> Dict:
+    """
+    Downloads a YouTube video and returns the maximum number of unique bird species 
+    visible in any frame, along with the timestamp.
+
+    Parameters:
+        url (str): YouTube video URL
+
+    Returns:
+        dict: {
+            "max_species_count": int,
+            "timestamp": str,
+            "species_list": List[str],
+        }
+    """
+    # 1. Download YouTube video
+    yt = YouTube(url)
+    stream = yt.streams.filter(file_extension='mp4').get_highest_resolution()
+    temp_video_path = os.path.join(tempfile.gettempdir(), "video.mp4")
+    stream.download(filename=temp_video_path)
+
+    # 2. Load object detection model for bird species
+    # Load a fine-tuned YOLOv5 model or similar pretrained on bird species
+    model = torch.hub.load('ultralytics/yolov5', 'custom', path='best_birds.pt')  # path to your trained model
+
+    # 3. Process video frames
+    cap = cv2.VideoCapture(temp_video_path)
+    fps = cap.get(cv2.CAP_PROP_FPS)
+    frame_interval = int(fps * 1)  # 1 frame per second
+
+    max_species_count = 0
+    max_species_frame_time = 0
+    species_at_max = []
+
+    frame_idx = 0
+    while cap.isOpened():
+        ret, frame = cap.read()
+        if not ret:
+            break
+        if frame_idx % frame_interval == 0:
+            # Run detection
+            results = model(frame)
+            detected_species = set()
+            for *box, conf, cls in results.xyxy[0]:
+                species_name = model.names[int(cls)]
+                detected_species.add(species_name)
+
+            if len(detected_species) > max_species_count:
+                max_species_count = len(detected_species)
+                max_species_frame_time = int(cap.get(cv2.CAP_PROP_POS_MSEC)) // 1000
+                species_at_max = list(detected_species)
+
+        frame_idx += 1
+
+    cap.release()
+    os.remove(temp_video_path)
+
+    return {
+        "max_species_count": max_species_count,
+        "timestamp": f"{max_species_frame_time}s",
+        "species_list": species_at_max
+    }