Update app.py

app.py

@@ -22,485 +22,259 @@ DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 #Load environment variables
 load_dotenv()
 
-import io
-import contextlib
-import traceback
-from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline
-from smolagents import Tool, CodeAgent, DuckDuckGoSearchTool, FinalAnswerTool, HfApiModel
-
-
-class CodeLlamaTool(Tool):
-    name = "code_llama_tool"
-    description = "Solves reasoning/code questions using Meta Code Llama 7B Instruct"
-
-    inputs = {
-        "question": {
-            "type": "string",
-            "description": "The question requiring code-based or reasoning-based solution"
-        }
-    }
-    output_type = "string"
-
-    def __init__(self):
-        self.model_id = "codellama/CodeLlama-7b-Instruct-hf"
-        token = os.getenv("HF_TOKEN")
-
-        self.tokenizer = AutoTokenizer.from_pretrained(self.model_id, token=token)
-        self.model = AutoModelForCausalLM.from_pretrained(
-            self.model_id,
-            device_map="auto",
-            torch_dtype="auto",
-            token=token
-        )
-        self.pipeline = pipeline(
-            "text-generation",
-            model=self.model,
-            tokenizer=self.tokenizer,
-            max_new_tokens=512,
-            temperature=0.2,
-            truncation=True
+from langgraph.graph import END, StateGraph
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.messages import HumanMessage, AIMessage, ToolMessage
+from langchain_core.tools import tool
+from typing import Dict, List, TypedDict, Annotated
+import operator
+
+# ====== Tool Definitions ======
+@tool
+def duckduckgo_search(query: str) -> str:
+    """Search web using DuckDuckGo. Returns top 3 results."""
+    from duckduckgo_search import DDGS
+    with DDGS() as ddgs:
+        return "\n\n".join(
+            f"Title: {res['title']}\nURL: {res['href']}\nSnippet: {res['body']}"
+            for res in ddgs.text(query, max_results=3)
         )
 
-    def forward(self, question: str) -> str:
-        prompt = f"""You are an AI that uses Python code to answer questions.
-Question: {question}
-Instructions:
-- If solving requires code, use a block like <tool>code</tool>.
-- Always end with <final>FINAL ANSWER</final> containing the final number or string.
-Example:
-Question: What is 5 * sqrt(36)?
-Answer:
-<tool>
-import math
-print(5 * math.sqrt(36))
-</tool>
-<final>30.0</final>
-Answer:"""
-
-        response = self.pipeline(prompt)[0]["generated_text"]
-        return self.parse_and_execute(response)
-
-    def parse_and_execute(self, response: str) -> str:
-        try:
-            # Extract and run code if exists
-            if "<tool>" in response and "</tool>" in response:
-                code = response.split("<tool>")[1].split("</tool>")[0].strip()
-                result = self._run_code(code)
-                return f"FINAL ANSWER (code output): {result}"
-
-            # Extract final result directly
-            elif "<final>" in response and "</final>" in response:
-                final = response.split("<final>")[1].split("</final>")[0].strip()
-                return f"FINAL ANSWER: {final}"
-
-            return f"Could not extract final answer.\n\n{response}"
-
-        except Exception as e:
-            return f"Error in parse_and_execute: {str(e)}\n\nFull response:\n{response}"
-
-    def _run_code(self, code: str) -> str:
-        buffer = io.StringIO()
-        try:
-            with contextlib.redirect_stdout(buffer):
-                exec(code, {})
-            return buffer.getvalue().strip()
-        except Exception:
-            return f"Error executing code:\n{traceback.format_exc()}"
-
-
-
-from duckduckgo_search import DDGS
-import wikipedia
-import arxiv
-from transformers import pipeline
-import os
-import re
-import ast
-import subprocess
-import sys
-
-# ===== Search Tools =====
-class DuckDuckGoSearchTool:
-    def __init__(self, max_results=3):
-        self.description = "Search web using DuckDuckGo. Input: search query"
-        self.max_results = max_results
-        
-    def run(self, query: str) -> str:
-        try:
-            with DDGS() as ddgs:
-                results = [r for r in ddgs.text(query, max_results=self.max_results)]
-                return "\n\n".join(
-                    f"Title: {res['title']}\nURL: {res['href']}\nSnippet: {res['body']}" 
-                    for res in results
-                )
-        except Exception as e:
-            return f"Search error: {str(e)}"
-
-class WikiSearchTool:
-    def __init__(self, sentences=3):
-        self.description = "Get Wikipedia summaries. Input: search phrase"
-        self.sentences = sentences
-        
-    def run(self, query: str) -> str:
-        try:
-            return wikipedia.summary(query, sentences=self.sentences)
-        except wikipedia.DisambiguationError as e:
-            return f"Disambiguation error. Options: {', '.join(e.options[:5])}"
-        except wikipedia.PageError:
-            return "Page not found"
-        except Exception as e:
-            return f"Wikipedia error: {str(e)}"
-
-class ArxivSearchTool:
-    def __init__(self, max_results=3):
-        self.description = "Search academic papers on arXiv. Input: search query"
-        self.max_results = max_results
-        
-    def run(self, query: str) -> str:
-        try:
-            results = arxiv.Search(
-                query=query, 
-                max_results=self.max_results,
-                sort_by=arxiv.SortCriterion.Relevance
-            ).results()
-            
-            output = []
-            for r in results:
-                output.append(
-                    f"Title: {r.title}\n"
-                    f"Authors: {', '.join(a.name for a in r.authors)}\n"
-                    f"Published: {r.published.strftime('%Y-%m-%d')}\n"
-                    f"Summary: {r.summary[:250]}...\n"
-                    f"URL: {r.entry_id}"
-                )
-            return "\n\n".join(output)
-        except Exception as e:
-            return f"arXiv error: {str(e)}"
+@tool
+def wikipedia_search(query: str) -> str:
+    """Get Wikipedia summaries. Returns first 3 sentences."""
+    import wikipedia
+    try:
+        return wikipedia.summary(query, sentences=3)
+    except wikipedia.DisambiguationError as e:
+        return f"Disambiguation options: {', '.join(e.options[:3])}"
+    except wikipedia.PageError:
+        return "Page not found"
 
-# ===== QA Tools =====
-class HuggingFaceDocumentQATool:
-    def __init__(self):
-        self.description = "Answer questions from documents. Input: 'document_text||question'"
-        self.model = pipeline(
-            'question-answering', 
-            model='deepset/roberta-base-squad2',
-            tokenizer='deepset/roberta-base-squad2'
-        )
+@tool
+def arxiv_search(query: str) -> str:
+    """Search academic papers on arXiv. Returns top 3 results."""
+    import arxiv
+    results = arxiv.Search(
+        query=query, 
+        max_results=3,
+        sort_by=arxiv.SortCriterion.Relevance
+    ).results()
     
-    def run(self, input_str: str) -> str:
-        try:
-            if '||' not in input_str:
-                return "Invalid format. Use: 'document_text||question'"
-                
-            context, question = input_str.split('||', 1)
-            result = self.model(question=question, context=context)
-            return result['answer']
-        except Exception as e:
-            return f"QA error: {str(e)}"
-
-
-
-from transformers import BlipProcessor, BlipForQuestionAnswering
-
-class HuggingFaceImageQATool(Tool):
-    name = "image_qa"
-    description = "Answer questions about an image."
-    inputs = {
-        "image_path": {"type": "string", "description": "Path to image"},
-        "question": {"type": "string", "description": "Question about the image"}
-    }
-    output_type = "string"
-
-    def __init__(self):
-        self.processor = BlipProcessor.from_pretrained("Salesforce/blip-vqa-base")
-        self.model = BlipForQuestionAnswering.from_pretrained("Salesforce/blip-vqa-base")
-
-    def forward(self, image_path: str, question: str) -> str:
-        image = Image.open(image_path)
-        inputs = self.processor(image, question, return_tensors="pt")
-        out = self.model.generate(**inputs)
-        return self.processor.decode(out[0], skip_special_tokens=True)
-
-
-from transformers import pipeline
-
-class HuggingFaceTranslationTool(Tool):
-    name = "translate"
-    description = "Translate text from English to another language."
-    inputs = {
-        "text": {"type": "string", "description": "Text to translate"}
-    }
-    output_type = "string"
-
-    def __init__(self):
-        self.translator = pipeline("translation", model="Helsinki-NLP/opus-mt-en-fr")
-
-    def forward(self, text: str) -> str:
-        return self.translator(text)[0]["translation_text"]
+    return "\n\n".join(
+        f"Title: {r.title}\nAuthors: {', '.join(a.name for a in r.authors)}\n"
+        f"Published: {r.published.strftime('%Y-%m-%d')}\nSummary: {r.summary[:250]}..."
+        for r in results
+    )
 
+@tool
+def document_qa(input_str: str) -> str:
+    """Answer questions from documents. Input format: 'document_text||question'"""
+    from transformers import pipeline
+    if '||' not in input_str:
+        return "Invalid format. Use: 'document_text||question'"
+    
+    context, question = input_str.split('||', 1)
+    qa_model = pipeline('question-answering', model='deepset/roberta-base-squad2')
+    return qa_model(question=question, context=context)['answer']
 
-# ===== Code Execution =====
-class PythonCodeExecutionTool:
-    def __init__(self):
-        self.description = "Execute Python code. Input: valid Python code"
-        
-    def run(self, code: str) -> str:
-        try:
-            # Isolate code in a clean environment
-            env = {}
-            exec(f"def __temp_func__():\n    {indent_code(code)}", env)
-            output = env['__temp_func__']()
-            return str(output)
-        except Exception as e:
-            return f"Execution error: {str(e)}"
+@tool
+def python_execution(code: str) -> str:
+    """Execute Python code and return output."""
+    try:
+        # Create isolated environment
+        env = {}
+        exec(f"def __exec_fn__():\n    {indent_code(code)}\nresult = __exec_fn__()", env)
+        return str(env.get('result', 'No output'))
+    except Exception as e:
+        return f"Error: {str(e)}"
 
 def indent_code(code: str) -> str:
-    """Add proper indentation for multiline code"""
     return '\n    '.join(code.splitlines())
 
-# ===== Answer Formatting =====
-class FinalAnswerTool:
-    def __init__(self):
-        self.description = "Format final answer. Input: answer content"
-        
-    def run(self, answer: str) -> str:
-        return f"FINAL ANSWER: {answer}"
-
-#from smolagents import Tool
-#from langchain_community.document_loaders import WikipediaLoader
-
-class WikiSearchTool(Tool):
-    name = "wiki_search"
-    description = "Search Wikipedia for a query and return up to 2 results."
-    inputs = {
-        "query": {"type": "string", "description": "The search term for Wikipedia."}
+# ====== Agent State ======
+class AgentState(TypedDict):
+    question: str
+    history: Annotated[List[Dict], operator.add]
+    context: str
+    reasoning: str
+    iterations: int
+
+# ====== Graph Components ======
+def init_state(question: str) -> AgentState:
+    return {
+        "question": question,
+        "history": [],
+        "context": f"User question: {question}",
+        "reasoning": "",
+        "iterations": 0
     }
-    output_type = "string"
-
-    def forward(self, query: str) -> str:
-        search_docs = WikipediaLoader(query=query, load_max_docs=2).load()
-
-        formatted_search_docs = "\n\n---\n\n".join(
-            [
-                f'<Document source="{doc.metadata.get("source", "Wikipedia")}" page="{doc.metadata.get("page", "")}"/>\n{doc.page_content}\n</Document>'
-                for doc in search_docs
-            ]
-        )
-        return formatted_search_docs
 
+def should_continue(state: AgentState) -> str:
+    """Determine if agent should continue or finish"""
+    last_msg = state['history'][-1]
     
+    # Stop conditions
+    if state['iterations'] >= 5:
+        return "end"
+    if "FINAL ANSWER:" in last_msg.get('content', ''):
+        return "end"
+    if last_msg['role'] == 'tool':
+        return "reason"
+    return "continue"
+
+def reasoning_node(state: AgentState) -> AgentState:
+    """Agent reasoning and tool selection"""
+    from langchain_community.chat_models import ChatHuggingFace
+    from langchain.schema import SystemMessage
+    
+    # Build prompt
+    prompt = ChatPromptTemplate.from_messages([
+        SystemMessage(content=(
+            "You are an intelligent AI assistant. Follow this process:\n"
+            "1. Analyze the question: {question}\n"
+            "2. Review context: {context}\n"
+            "3. Reasoning Steps:\n{reasoning}\n"
+            "4. Select ONE tool to use next OR provide FINAL ANSWER\n\n"
+            "Available Tools:\n"
+            "- duckduckgo_search: For current information\n"
+            "- wikipedia_search: For factual knowledge\n"
+            "- arxiv_search: For academic topics\n"
+            "- document_qa: For questions about documents\n"
+            "- python_execution: For calculations/code\n\n"
+            "Response Format:\n"
+            "Reasoning: [Your step-by-step analysis]\n"
+            "Action: [Tool name OR 'Final Answer']\n"
+            "Action Input: [Tool parameters OR final response]"
+        )),
+        *state['history']
+    ])
+    
+    # Initialize model
+    llm = ChatHuggingFace(
+        model_name="HuggingFaceH4/zephyr-7b-beta",
+        temperature=0.3
+    )
+    
+    # Generate response
+    response = llm.invoke(prompt.format_messages(
+        question=state['question'],
+        context=state['context'],
+        reasoning=state['reasoning']
+    ))
+    
+    # Parse response
+    content = response.content
+    reasoning, action, action_input = parse_agent_response(content)
+    
+    # Update state
+    state['history'].append(AIMessage(content=content))
+    state['reasoning'] += f"\nStep {state['iterations']+1}: {reasoning}"
+    
+    if "final answer" in action.lower():
+        state['history'].append(AIMessage(
+            content=f"FINAL ANSWER: {action_input}"
+        ))
+    else:
+        state['history'].append({
+            "role": "action_request",
+            "tool": action,
+            "input": action_input
+        })
+    
+    return state
 
-
-class StringReverseTool(Tool):
-    name = "reverse_message"
-    description = "When you received a strange text, try to reverse it and perform action described in reversed message."
-    inputs = {
-        "message": {
-            "type": "string",
-            "description": "A message, which looks like strange and can be reversed to get actions to execute."
-        }
-    }
-    output_type = "string"
-
-    def __init__(self):
-        return
-
-    def forward(self, message: str):
-        return message[::-1]
-
-class KeywordsExtractorTool(Tool):
-    """Extracts top 5 keywords from a given text based on frequency."""
-
-    name = "keywords_extractor"
-    description = "This tool returns the 5 most frequent keywords occur in provided block of text."
-
-    inputs = {
-        "text": {
-            "type": "string",
-            "description": "Text to analyze for keywords.",
-        }
+def tool_node(state: AgentState) -> AgentState:
+    """Execute selected tool and update state"""
+    last_action = state['history'][-1]
+    tool_name = last_action['tool']
+    tool_input = last_action['input']
+    
+    # Tool mapping
+    tools = {
+        "duckduckgo_search": duckduckgo_search,
+        "wikipedia_search": wikipedia_search,
+        "arxiv_search": arxiv_search,
+        "document_qa": document_qa,
+        "python_execution": python_execution
     }
-    output_type = "string"
+    
+    # Execute tool
+    tool_result = tools[tool_name].invoke(tool_input)
+    
+    # Update state
+    state['history'].append(ToolMessage(
+        content=tool_result,
+        tool_call_id=tool_name
+    ))
+    state['context'] = f"Tool Result ({tool_name}): {tool_result}"
+    state['iterations'] += 1
+    
+    return state
 
-    def forward(self, text: str) -> str:
-        try:
-            all_words = re.findall(r'\b\w+\b', text.lower())
-            conjunctions = {'a', 'and', 'of', 'is', 'in', 'to', 'the'}
-            filtered_words = []
-            for w in all_words:
-                if w not in conjunctions:
-                    filtered_words.push(w)
-            word_counts = Counter(filtered_words)
-            k = 5
-            return heapq.nlargest(k, word_counts.items(), key=lambda x: x[1])
-        except Exception as e:
-            return f"Error during extracting most common words: {e}"
+def parse_agent_response(response: str) -> tuple:
+    """Extract reasoning, action, and input from response"""
+    reasoning = response.split("Reasoning:")[1].split("Action:")[0].strip()
+    action_part = response.split("Action:")[1].strip()
+    
+    if "Action Input:" in action_part:
+        action, action_input = action_part.split("Action Input:", 1)
+        action = action.strip()
+        action_input = action_input.strip()
+    else:
+        action = action_part
+        action_input = ""
+    
+    return reasoning, action, action_input
 
-@tool
-def parse_excel_to_json(task_id: str) -> dict:
-    """
-    For a given task_id fetch and parse an Excel file and save parsed data in structured JSON file.
-    Args:
-        task_id: An task ID to fetch.
-        
-    Returns:
+# ====== Agent Graph ======
+def create_agent_workflow():
+    workflow = StateGraph(AgentState)
+    
+    # Define nodes
+    workflow.add_node("reason", reasoning_node)
+    workflow.add_node("action", tool_node)
+    
+    # Set entry point
+    workflow.set_entry_point("reason")
+    
+    # Define edges
+    workflow.add_conditional_edges(
+        "reason",
+        should_continue,
         {
-            "task_id": str,
-            "sheets": {
-                "SheetName1": [ {col1: val1, col2: val2, ...}, ... ],
-                ...
-            },
-            "status": "Success" | "Error"
-        }
-    """
-    url = f"https://agents-course-unit4-scoring.hf.space/files/{task_id}"
-
-    try:
-        response = requests.get(url, timeout=100)
-        if response.status_code != 200:
-            return {"task_id": task_id, "sheets": {}, "status": f"{response.status_code} - Failed"}
-
-        xls_content = pd.ExcelFile(BytesIO(response.content))
-        json_sheets = {}
-
-        for sheet in xls_content.sheet_names:
-            df = xls_content.parse(sheet)
-            df = df.dropna(how="all")  
-            rows = df.head(20).to_dict(orient="records")
-            json_sheets[sheet] = rows
-
-        return {
-            "task_id": task_id,
-            "sheets": json_sheets,
-            "status": "Success"
+            "continue": "action",
+            "reason": "reason",
+            "end": END
         }
+    )
+    
+    workflow.add_edge("action", "reason")
+    return workflow.compile()
 
-    except Exception as e:
-        return {
-            "task_id": task_id,
-            "sheets": {},
-            "status": f"Error in parsing Excel file: {str(e)}"
-        }
-
-
-
-class VideoTranscriptionTool(Tool):
-    """Fetch transcripts from YouTube videos"""
-    name = "transcript_video"
-    description = "Fetch text transcript from YouTube movies with optional timestamps"
-    inputs = {
-        "url": {"type": "string", "description": "YouTube video URL or ID"},
-        "include_timestamps": {"type": "boolean", "description": "If timestamps should be included in output", "nullable": True}
-    }
-    output_type = "string"
-
-    def forward(self, url: str, include_timestamps: bool = False) -> str:
-
-        if "youtube.com/watch" in url:
-            video_id = url.split("v=")[1].split("&")[0]
-        elif "youtu.be/" in url:
-            video_id = url.split("youtu.be/")[1].split("?")[0]
-        elif len(url.strip()) == 11:  # Direct ID
-            video_id = url.strip()
-        else:
-            return f"YouTube URL or ID: {url} is invalid!"
-
-        try:
-            transcription = YouTubeTranscriptApi.get_transcript(video_id)
-
-            if include_timestamps:
-                formatted_transcription = []
-                for part in transcription:
-                    timestamp = f"{int(part['start']//60)}:{int(part['start']%60):02d}"
-                    formatted_transcription.append(f"[{timestamp}] {part['text']}")
-                return "\n".join(formatted_transcription)
-            else:
-                return " ".join([part['text'] for part in transcription])
-
-        except Exception as e:
-            return f"Error in extracting YouTube transcript: {str(e)}"
-
+# ====== Agent Interface ======
 class BasicAgent:
     def __init__(self):
-        token = os.environ.get("HF_API_TOKEN")
-        model = HfApiModel(
-            temperature=0.1,
-            token=token
-        )
-
-        # Existing tools
-        search_tool = DuckDuckGoSearchTool()
-        wiki_search_tool = WikiSearchTool()
-        str_reverse_tool = StringReverseTool()
-        keywords_extract_tool = KeywordsExtractorTool()
-        speech_to_text_tool = SpeechToTextTool()
-        visit_webpage_tool = VisitWebpageTool()
-        final_answer_tool = FinalAnswerTool()
-        video_transcription_tool = VideoTranscriptionTool()
-
-        # ✅ New Llama Tool
-        code_llama_tool = CodeLlamaTool()
-        arxiv_search_tool = ArxivSearchTool()
-        doc_qa_tool = HuggingFaceDocumentQATool()
-        image_qa_tool = HuggingFaceImageQATool()
-        translation_tool = HuggingFaceTranslationTool()
-        python_tool = PythonCodeExecutionTool()
-
-        system_prompt = f"""
-You are my general AI assistant. Your primary goal is to answer the user's question accurately and concisely.
-
-Here's a detailed plan for answering:
-1. **Understand the Question:** Carefully parse the question to identify key entities, relationships, and the type of information requested.
-2. **Reasoning Steps (Chain-of-Thought):** Before attempting to answer, outline a step-by-step reasoning process. This helps in breaking down complex questions.
-3. **Tool Selection and Usage:** Based on your reasoning, select the most appropriate tool(s) to gather information or perform operations.
-   - Use `search_tool` (DuckDuckGoSearchTool) for general web searches.
-   - Use `wiki_search_tool` for encyclopedic knowledge.
-   - Use `arxiv_search_tool` for scientific papers.
-   - Use `visit_webpage_tool` to read content from URLs found via search.
-   - Use `doc_qa_tool` for answering questions about specific documents (if provided).
-   - Use `image_qa_tool` for questions about images.
-   - Use `translation_tool` for language translation.
-   - Use `python_tool` or `code_llama_tool` for code generation, execution, or complex calculations/data manipulation.
-   - Use `keywords_extract_tool` to identify important terms from text.
-   - Use `str_reverse_tool` for string manipulation if needed (less common for Q&A).
-   - Use `speech_to_text_tool` or `video_transcription_tool` if audio/video input is part of the question.
-   - Use `parse_excel_to_json` if the question involves data from Excel.
-4. **Information Synthesis:** Combine and process the information obtained from tools. Cross-reference if necessary to ensure accuracy.
-5. **Formulate Final Answer:** Construct the final answer according to the specified format.
-
-**Final Answer Format:**
-Return your final answer in a single line, formatted as follows: "FINAL ANSWER: [YOUR FINAL ANSWER]".
-[YOUR FINAL ANSWER] should be a number, a string, or a comma-separated list of numbers and/or strings, depending on the question.
-- If the answer is a number, do not use commas or units (e.g., $, %) unless explicitly specified in the question.
-- If the answer is a string, do not use articles (a, an, the) or common abbreviations (e.g., "NY" for "New York") unless specified. Write digits in plain text unless specified.
-- If the answer is a comma-separated list, apply the above rules for each element based on whether it is a number or a string.
-- If you cannot find a definitive answer, state "FINAL ANSWER: I don't know."
-
-Let's think step by step.
-"""
-        self.agent.prompt_templates["system_prompt"] = self.agent.prompt_templates["system_prompt"] + system_prompt
-
-        self.agent = CodeAgent(
-            model=model,
-            tools=[
-                search_tool, wiki_search_tool, str_reverse_tool,
-                keywords_extract_tool, speech_to_text_tool,
-                visit_webpage_tool, final_answer_tool,
-                parse_excel_to_json, video_transcription_tool,
-                arxiv_search_tool,
-                doc_qa_tool, image_qa_tool,
-                translation_tool, python_tool, 
-                code_llama_tool  # 🔧 Add here
-            ],
-            add_base_tools=True
-        )
-        self.agent.prompt_templates["system_prompt"] = self.agent.prompt_templates["system_prompt"] + system_prompt
-
+        self.workflow = create_agent_workflow()
+        self.tools = [
+            duckduckgo_search,
+            wikipedia_search,
+            arxiv_search,
+            document_qa,
+            python_execution
+        ]
+    
     def __call__(self, question: str) -> str:
-        print(f"Agent received question (first 50 chars): {question[:50]}...")
-        answer = self.agent.run(question)
-        print(f"Agent returning answer: {answer}")
-        return answer
+        state = init_state(question)
+        final_state = self.workflow.invoke(state)
+        
+        # Extract final answer
+        for msg in reversed(final_state['history']):
+            if msg.get('content', '').startswith("FINAL ANSWER:"):
+                return msg['content'].split("FINAL ANSWER:")[1].strip()
+        
+        return "No final answer found"
+
 
 
 def run_and_submit_all( profile: gr.OAuthProfile | None):