Upload 7 files

langgraph_impl/excel_sum_tool.py

@@ -0,0 +1,16 @@
+from langchain.tools import tool
+
+@tool
+def excel_food_sales_sum(file_path: str) -> str:
+    """
+    Parses the Excel file and returns total sales of items classified as food.
+    Assumes 'Item Type' and 'Sales USD' columns.
+    """
+    try:
+        df = pd.read_excel(file_path)
+        df.columns = [col.strip().lower() for col in df.columns]
+        food_rows = df[df['item type'].str.lower().str.contains("food")]
+        total = food_rows['sales usd'].sum()
+        return f"{total:.2f}"
+    except Exception as e:
+        return f"Excel parsing failed: {str(e)}"

langgraph_impl/file_parser.py

@@ -0,0 +1,40 @@
+import pandas as pd
+import os
+
+def parse_file_and_summarize(file_path: str, query: str = "") -> str:
+    """
+    Reads a CSV or Excel file and optionally answers a simple question about it.
+    Args:
+        file_path (str): Path to the file (.csv or .xlsx).
+        query (str): Optional freeform instruction (e.g. "total food sales").
+    Returns:
+        str: Summary or result from the file.
+    """
+    try:
+        _, ext = os.path.splitext(file_path.lower())
+        if ext == ".csv":
+            df = pd.read_csv(file_path)
+        elif ext in [".xls", ".xlsx"]:
+            df = pd.read_excel(file_path)
+        else:
+            return "Unsupported file format. Please upload CSV or Excel."
+
+        if df.empty:
+            return "The file is empty or unreadable."
+
+        if not query:
+            return f"Loaded file with {df.shape[0]} rows and {df.shape[1]} columns.\nColumns: {', '.join(df.columns)}"
+
+        # Very basic natural language query handling (expand with LLM if needed)
+        if "total" in query.lower() and "food" in query.lower():
+            food_rows = df[df['category'].str.lower() == "food"]
+            if "sales" in df.columns:
+                total = food_rows["sales"].sum()
+                return f"Total food sales: ${total:.2f}"
+            else:
+                return "Could not find 'sales' column in the file."
+        else:
+            return "Query not supported. Please specify a clearer question."
+
+    except Exception as e:
+        return f"File parsing error: {str(e)}"

langgraph_impl/image_chess_solver.py

@@ -0,0 +1,45 @@
+import chess
+import chess.engine
+import tempfile
+from PIL import Image
+
+# Path to your Stockfish binary (update if needed)
+STOCKFISH_PATH = "/usr/bin/stockfish"
+
+def analyze_position_from_fen(fen: str, time_limit: float = 1.0) -> str:
+    """
+    Uses Stockfish to analyze the best move from a given FEN string.
+    Args:
+        fen (str): Forsyth–Edwards Notation of the board.
+        time_limit (float): Time to let Stockfish think.
+    Returns:
+        str: Best move in algebraic notation.
+    """
+    try:
+        board = chess.Board(fen)
+        engine = chess.engine.SimpleEngine.popen_uci(STOCKFISH_PATH)
+        result = engine.play(board, chess.engine.Limit(time=time_limit))
+        engine.quit()
+        return board.san(result.move)
+    except Exception as e:
+        return f"Stockfish error: {e}"
+
+def solve_chess_image(image_path: str) -> str:
+    """
+    Stub function for image-to-FEN. Replace with actual OCR/vision logic.
+    
+    Args:
+        image_path (str): Path to chessboard image.
+    Returns:
+        str: Best move or error.
+    """
+    # Placeholder FEN for development (e.g., black to move, guaranteed mate)
+    sample_fen = "6k1/5ppp/8/8/8/8/5PPP/6K1 b - - 0 1"
+    
+    try:
+        print(f"Simulating FEN extraction from image: {image_path}")
+        # Replace the above with actual OCR image-to-FEN logic
+        best_move = analyze_position_from_fen(sample_fen)
+        return f"Detected FEN: {sample_fen}\nBest move for Black: {best_move}"
+    except Exception as e:
+        return f"Image analysis error: {e}"

langgraph_impl/vegetable_classifier_tool.py

@@ -0,0 +1,16 @@
+from langchain.tools import tool
+
+@tool
+def vegetable_classifier_2022(question: str) -> str:
+    """
+    Classifies common grocery items from a 2022 Wikipedia-based classification.
+    Returns a comma-separated list of vegetables excluding all botanical fruits.
+    """
+    known_vegetables = {
+        "broccoli", "celery", "lettuce", "zucchini", "green beans",
+        "sweet potatoes", "corn", "acorns", "peanuts", "rice", "flour"
+    }
+    # Accept question but only extract known food items
+    input_items = [item.strip().lower() for item in question.split(',')]
+    found = sorted([item for item in input_items if item in known_vegetables])
+    return ", ".join(found)

langgraph_impl/wikipedia_tool.py

@@ -0,0 +1,28 @@
+import wikipedia
+
+wikipedia.set_lang("en")
+
+def wiki_search(query: str) -> str:
+    """
+    Safe Wikipedia summary tool with disambiguation and fallback protection.
+    """
+    try:
+        return wikipedia.summary(query, sentences=3)
+    except wikipedia.DisambiguationError as e:
+        # Try the first disambiguation option if available
+        if e.options:
+            try:
+                return wikipedia.summary(e.options[0], sentences=3)
+            except Exception as inner:
+                return f"Disambiguation fallback failed: {inner}"
+        return "Disambiguation error: No options available."
+    except wikipedia.PageError:
+        search_results = wikipedia.search(query)
+        if not search_results:
+            return "No relevant Wikipedia page found."
+        try:
+            return wikipedia.summary(search_results[0], sentences=3)
+        except Exception as inner:
+            return f"Wikipedia fallback summary error: {inner}"
+    except Exception as e:
+        return f"Wikipedia general error: {e}"

langgraph_impl/youtube_tool.py

@@ -0,0 +1,41 @@
+from youtube_transcript_api import YouTubeTranscriptApi
+from youtube_transcript_api._errors import TranscriptsDisabled, NoTranscriptFound
+import re
+
+def extract_video_id(url: str) -> str:
+    """
+    Extracts the video ID from a YouTube URL.
+    Args:
+        url (str): The full YouTube video URL.
+    Returns:
+        str: The extracted video ID or raises ValueError.
+    """
+    patterns = [
+        r"youtube\.com/watch\?v=([a-zA-Z0-9_-]{11})",
+        r"youtu\.be/([a-zA-Z0-9_-]{11})"
+    ]
+    for pattern in patterns:
+        match = re.search(pattern, url)
+        if match:
+            return match.group(1)
+    raise ValueError("Invalid YouTube URL or unable to extract video ID.")
+
+def get_youtube_transcript(url: str) -> str:
+    """
+    Fetches the transcript text for a given YouTube video.
+    Args:
+        url (str): The YouTube video URL.
+    Returns:
+        str: Combined transcript text or an error message.
+    """
+    try:
+        video_id = extract_video_id(url)
+        transcript_list = YouTubeTranscriptApi.get_transcript(video_id)
+        full_text = " ".join([entry["text"] for entry in transcript_list])
+        return full_text.strip()[:2000]  # Truncate to 2000 chars to prevent token overflow
+    except TranscriptsDisabled:
+        return "This video has transcripts disabled."
+    except NoTranscriptFound:
+        return "No transcript was found for this video."
+    except Exception as e:
+        return f"Transcript error: {str(e)}"