Update app.py

app.py

@@ -8,6 +8,12 @@ from langgraph.graph import StateGraph, END
 from typing import TypedDict
 import re
 import string
+from duckduckgo_search import ddg
+from pytube import YouTube
+import cv2
+from ultralytics import YOLO
+import tempfile
+import os
 
 
 # (Keep Constants as is)
@@ -121,6 +127,76 @@ class SuperSmartAgent:
             print(f"Fallback triggered. Final question state: {state['question']}")
             state["response"] = "This question doesn't require Python or is unclear."
             return state
+
+        ###################
+        model = YOLO("yolov8n.pt")  # lightweight object detector
+        
+        def check_special_tools(state):
+            q = state["question"].lower()
+            if "search the web" in q or "look up" in q:
+                state["use_tool"] = "web"
+            elif "how many objects" in q and "video" in q:
+                state["use_tool"] = "video"
+            else:
+                state["use_tool"] = None
+            return state
+
+        def use_web_search(state):
+            query = state["question"].replace("search the web for", "").replace("look up", "").strip()
+            print(f"Searching DuckDuckGo for: {query}")
+            results = ddg(query, max_results=3)
+            if results:
+                snippets = [r['title'] + ": " + r['body'] for r in results]
+                state["response"] = "\n".join(snippets)
+            else:
+                state["response"] = "No results found."
+            return state
+        
+        def use_video_analysis(state):
+            import re
+        
+            url_match = re.search(r"(https?://[^\s]+)", state["question"])
+            url = url_match.group(1) if url_match else None
+        
+            if not url:
+                state["response"] = "Could not find a video URL in the question."
+                return state
+
+            print(f"Analyzing video from: {url}")
+            
+            try:
+                yt = YouTube(url)
+                stream = yt.streams.filter(file_extension="mp4", progressive=True).order_by('resolution').desc().first()
+                temp_file = tempfile.NamedTemporaryFile(suffix=".mp4", delete=False)
+                stream.download(filename=temp_file.name)
+        
+                cap = cv2.VideoCapture(temp_file.name)
+                frames = []
+                frame_count = 0
+        
+                while True:
+                    ret, frame = cap.read()
+                    if not ret or frame_count >= 5:  # analyze only first 5 frames
+                        break
+                    frames.append(frame)
+                    frame_count += 1
+                cap.release()
+                os.remove(temp_file.name)
+        
+                object_counts = []
+                for frame in frames:
+                    results = model(frame)
+                    count = len(results[0].boxes)
+                    object_counts.append(count)
+        
+                state["response"] = f"Objects per frame (first {len(object_counts)} frames): {object_counts}"
+            except Exception as e:
+                state["response"] = f"Error processing video: {e}"
+            return state
+
+
+
+        ##################
         
         class AgentState(TypedDict, total=False):
             question: str
@@ -141,6 +217,7 @@ class SuperSmartAgent:
         builder.add_node("fallback", fallback)
         
         # Edges
+        ####################################################
         builder.set_entry_point("check_reversed")
         builder.add_edge("check_reversed", "fix_question")
         
@@ -157,6 +234,21 @@ class SuperSmartAgent:
         )
         builder.add_edge("generate_code", END)
         builder.add_edge("fallback", END)
+        #####################################################
+        builder.add_node("check_special_tools", check_special_tools)
+        builder.add_node("use_web_search", use_web_search)
+        builder.add_node("use_video_analysis", use_video_analysis)
+        
+        builder.set_entry_point("check_special_tools")
+        builder.add_conditional_edges(
+            "check_special_tools",
+            lambda s: "use_web_search" if s.get("use_tool") == "web"
+            else "use_video_analysis" if s.get("use_tool") == "video"
+            else "check_reversed"
+        )
+        
+        builder.add_edge("use_web_search", END)
+        builder.add_edge("use_video_analysis", END)
             
         graph = builder.compile()
         return graph