updates

agent.py

@@ -1,144 +1,266 @@
-"""LangGraph Agent"""
-import os
 from dotenv import load_dotenv
-from langgraph.graph import START, StateGraph, MessagesState
-from langgraph.prebuilt import tools_condition
-from langgraph.prebuilt import ToolNode
-from langchain_anthropic import ChatAnthropic
-from langchain_google_genai import ChatGoogleGenerativeAI
-from langchain_groq import ChatGroq
-from langchain_huggingface import ChatHuggingFace, HuggingFaceEndpoint, HuggingFaceEmbeddings
-from langchain_community.tools.tavily_search import TavilySearchResults
+
+from langchain_openai import ChatOpenAI
+from langchain_core.tools import tool
 from langchain_community.document_loaders import WikipediaLoader
 from langchain_community.document_loaders import ArxivLoader
-from langchain_community.vectorstores import SupabaseVectorStore
-from langchain_core.messages import SystemMessage, HumanMessage, AIMessage
-from langchain_core.tools import tool
-from langchain.tools.retriever import create_retriever_tool
-from supabase.client import Client, create_client
-import re
+from langchain_community.tools.tavily_search import TavilySearchResults
+from langchain_tavily import TavilyExtract
+from youtube_transcript_api import YouTubeTranscriptApi
 
-load_dotenv()
+from langchain_core.messages import SystemMessage, HumanMessage
+from langgraph.graph import START, StateGraph, MessagesState
+from langgraph.prebuilt import ToolNode
+from langgraph.prebuilt import tools_condition
+import base64
+import httpx
 
-# === Tools ===
-@tool
-def multiply(a: int, b: int) -> int:
-    """Multiplies two integers and returns the result."""
-    return a * b
+
+load_dotenv()
 
 @tool
 def add(a: int, b: int) -> int:
-    """Adds two integers and returns the sum."""
+    """
+    Add b to a.
+    
+    Args:
+        a: first int number
+        b: second int number
+    """
     return a + b
 
 @tool
-def subtract(a: int, b: int) -> int:
-    """Subtracts the second integer from the first and returns the result."""
+def substract(a: int, b: int) -> int:
+    """
+    Subtract b from a.
+    
+    Args:
+        a: first int number
+        b: second int number
+    """
     return a - b
 
 @tool
-def divide(a: int, b: int) -> float:
-    """Divides the first integer by the second and returns the result as a float."""
+def multiply(a: int, b: int) -> int:
+    """
+    Multiply a by b.
+    
+    Args:
+        a: first int number
+        b: second int number
+    """
+    return a * b
+
+@tool
+def divide(a: int, b: int) -> int:
+    """
+    Divide a by b.
+    
+    Args:
+        a: first int number
+        b: second int number
+    """
     if b == 0:
-        raise ValueError("Cannot divide by zero.")
+        raise ValueError("Can't divide by zero.")
     return a / b
 
 @tool
-def modulus(a: int, b: int) -> int:
-    """Returns the remainder of dividing the first integer by the second."""
+def mod(a: int, b: int) -> int:
+    """
+    Remainder of a devided by b.
+    
+    Args:
+        a: first int number
+        b: second int number
+    """
     return a % b
 
 @tool
 def wiki_search(query: str) -> str:
-    """Searches Wikipedia for a query and returns the top 2 results as a formatted string."""
-    search_docs = WikipediaLoader(query=query, load_max_docs=2).load()
-    return "\n\n---\n\n".join([doc.page_content for doc in search_docs])
+    """
+    Search Wikipedia.
+    
+    Args:
+        query: what to search for
+    """
+    search_docs = WikipediaLoader(query=query, load_max_docs=3).load()
+    formatted_search_docs = "".join(
+        [
+            f'<START source="{doc.metadata["source"]}">{doc.page_content[:1000]}<END>'
+            for doc in search_docs
+        ])
+    return {"wiki_results": formatted_search_docs}
+
+@tool
+def arvix_search(query: str) -> str:
+    """
+    Search arXiv which is online archive of preprint and postprint manuscripts 
+    for different fields of science.
+    
+    Args:
+        query: what to search for
+    """
+    search_docs = ArxivLoader(query=query, load_max_docs=3).load()
+    formatted_search_docs = "".join(
+        [
+            f'<START source="{doc.metadata["source"]}">{doc.page_content[:1000]}<END>'
+            for doc in search_docs
+        ])
+    return {"arvix_results": formatted_search_docs}
 
 @tool
 def web_search(query: str) -> str:
-    """Uses Tavily to search the web for a query and returns the top 3 result snippets."""
-    search_docs = TavilySearchResults(max_results=3).invoke(query=query)
-    return "\n\n---\n\n".join([doc.page_content for doc in search_docs])
+    """
+    Search WEB.
+    
+    Args:
+        query: what to search for
+    """
+    search_docs = TavilySearchResults(max_results=3, include_answer=True).invoke({"query": query})
+    formatted_search_docs = "".join(
+        [
+            f'<START source="{doc["url"]}">{doc["content"][:1000]}<END>'
+            for doc in search_docs
+        ])
+    return {"web_results": formatted_search_docs}
 
 @tool
-def arvix_search(query: str) -> str:
-    """Searches Arxiv for academic papers related to the query and returns the top 3 abstracts."""
-    search_docs = ArxivLoader(query=query, load_max_docs=3).load()
-    return "\n\n---\n\n".join([doc.page_content[:1000] for doc in search_docs])
-
-# === System Prompt ===
-with open("system_prompt.txt", "r", encoding="utf-8") as f:
-    system_prompt = f.read()
-sys_msg = SystemMessage(content=system_prompt)
-
-# === Embeddings & Vector Store ===
-embeddings = HuggingFaceEmbeddings(model_name="sentence-transformers/all-mpnet-base-v2")
-supabase: Client = create_client(os.getenv("SUPABASE_URL"), os.getenv("SUPABASE_SERVICE_KEY"))
-vector_store = SupabaseVectorStore(
-    client=supabase,
-    embedding=embeddings,
-    table_name="Vector_Test",
-    query_name="match_documents_langchain",
-)
-
-# === Tools ===
-tools = [multiply, add, subtract, divide, modulus, wiki_search, web_search, arvix_search]
-
-# === LangGraph Builder ===
-def build_graph(provider: str = "huggingface"):
-    if provider == "huggingface":
-        llm = ChatHuggingFace(
-            llm=HuggingFaceEndpoint(
-                repo_id="Qwen/Qwen2.5-Coder-32B-Instruct",
-                temperature=0,
-                huggingfacehub_api_token=os.getenv("HF_TOKEN")
-            )
-        )
-    else:
-        raise ValueError("Only 'huggingface' (Qwen3) is supported in this build.")
-
-    llm_with_tools = llm.bind_tools(tools)
-
-    def retriever(state: MessagesState):
-        query = state["messages"][-1].content
-        similar = vector_store.similarity_search(query)
-        return {
-            "messages": [
-                sys_msg,
-                state["messages"][-1],
-                HumanMessage(content=f"Reference: {similar[0].page_content}")
-            ]
-        }
+def open_web_page(url: str) -> str:
+    """
+    Open web page and get its content.
+    
+    Args:
+        url: web page url in ""
+    """
+    search_docs = TavilyExtract().invoke({"urls": [url]})
+    formatted_search_docs = f'<START source="{search_docs["results"][0]["url"]}">{search_docs["results"][0]["raw_content"][:1000]}<END>'
+    return {"web_page_content": formatted_search_docs}
 
-    def assistant(state: MessagesState):
-        response = llm_with_tools.invoke(state["messages"])
-        return {"messages": state["messages"] + [response]}
+@tool
+def youtube_transcript(url: str) -> str:
+    """
+    Get transcript of YouTube video.
+    Args:
+        url: YouTube video url in ""
+    """    
+    video_id = url.partition("https://www.youtube.com/watch?v=")[2]
+    transcript = YouTubeTranscriptApi.get_transcript(video_id)
+    transcript_text = " ".join([item["text"] for item in transcript])
+    return {"youtube_transcript": transcript_text}
+
+
+tools = [
+    add,
+    substract,
+    multiply,
+    divide,
+    mod,
+    wiki_search,
+    arvix_search,
+    web_search,
+    open_web_page,
+    youtube_transcript,
+]
 
-    def formatter(state: MessagesState):
-        last = state["messages"][-1].content.strip()
-        cleaned = re.sub(r"<.*?>", "", last)
-        cleaned = re.sub(r"(Final\s*Answer:|Answer:)", "", cleaned, flags=re.IGNORECASE)
-        cleaned = cleaned.strip().split("\n")[0].strip()
-        return {"messages": [AIMessage(content=cleaned)]}
+# System prompt
+system_prompt = f"""
+You are a general AI assistant. I will ask you a question.
+First, provide a step-by-step explanation of your reasoning to arrive at the answer.
+Then, respond with 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 specified.
+If the answer is a string, do not use articles or abbreviations (e.g., for cities), and 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.
+"""
+system_message = SystemMessage(content=system_prompt)
 
+# Build graph
+def build_graph():
+    """Build LangGrapth graph of agent."""
+
+    # Language model and tools
+    llm = ChatOpenAI(
+        model="gpt-4.1",
+        temperature=0,
+        max_retries=2
+    )
+    llm_with_tools = llm.bind_tools(tools, strict=True)
+
+    # Nodes
+    def assistant(state: MessagesState):
+        """Assistant node."""
+        return {"messages": [llm_with_tools.invoke([system_message] + state["messages"])]}
+
+    # Graph
     builder = StateGraph(MessagesState)
-    builder.add_node("retriever", retriever)
     builder.add_node("assistant", assistant)
     builder.add_node("tools", ToolNode(tools))
-    builder.add_node("formatter", formatter)
-
-    builder.add_edge(START, "retriever")
-    builder.add_edge("retriever", "assistant")
+    builder.add_edge(START, "assistant")
     builder.add_conditional_edges("assistant", tools_condition)
     builder.add_edge("tools", "assistant")
-    builder.add_edge("assistant", "formatter")
 
+    # Compile graph
     return builder.compile()
 
-# === Run Test ===
+
+# Testing and solving particular tasks
 if __name__ == "__main__":
-    graph = build_graph()
-    result = graph.invoke({"messages": [HumanMessage(content="What is the capital of France?")]})
-    for m in result["messages"]:
-        m.pretty_print()
 
+    agent = build_graph()
+    
+    question = """
+Review the chess position provided in the image. It is black's turn. 
+Provide the correct next move for black which guarantees a win. 
+Please provide your response in algebraic notation.
+"""
+    content_urls = {
+        "image": "https://agents-course-unit4-scoring.hf.space/files/cca530fc-4052-43b2-b130-b30968d8aa44",
+        "audio": None
+    }
+    
+    # Define user message and add all the content
+    content = [
+        {
+            "type": "text",
+            "text": question
+        }
+    ]
+    if content_urls["image"]:
+        image_data = base64.b64encode(httpx.get(content_urls["image"]).content).decode("utf-8")
+        content.append(
+            {
+                "type": "image",
+                "source_type": "base64",
+                "data": image_data,
+                "mime_type": "image/jpeg"
+            }
+        )
+    if content_urls["audio"]:
+        audio_data = base64.b64encode(httpx.get(content_urls["audio"]).content).decode("utf-8")
+        content.append(
+            {
+                "type": "audio",
+                "source_type": "base64",
+                "data": audio_data,
+                "mime_type": "audio/wav"
+            }
+        )
+    messages = {
+        "role": "user",
+        "content": content
+    }
+
+    # Run agent on the question
+    messages = agent.invoke({"messages": messages})
+    for message in messages["messages"]:
+        message.pretty_print()
+
+    answer = messages["messages"][-1].content
+    index = answer.find("FINAL ANSWER: ")
+    
+    print("\n")
+    print("="*30)
+    if index == -1:
+        print(answer)
+    print(answer[index+14:])
+    print("="*30)

app.py

@@ -1,130 +1,223 @@
 import os
 import gradio as gr
-import pandas as pd
 import requests
-from dotenv import load_dotenv
-from langchain_core.messages import HumanMessage
+import inspect
+import pandas as pd
 from agent import build_graph
+from langchain_core.messages import HumanMessage
+import time
+import csv
 
-load_dotenv()
-
+# (Keep Constants as is)
+# --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
-cached_answers = []
 
-class ChatAgent:
+# --- Basic Agent Definition ---
+class BasicAgent:
     def __init__(self):
-        print("ChatAgent initialized with Qwen LangGraph workflow.")
-        self.graph = build_graph("huggingface")  # Uses Qwen endpoint
-
+        print("BasicAgent initialized.")
+        self.agent = build_graph()
+        
     def __call__(self, question: str) -> str:
-        print(f"Processing question: {question[:60]}...")
+        print(f"Agent received question (first 50 chars): {question[:50]}...")
         messages = [HumanMessage(content=question)]
-        results = self.graph.invoke({"messages": messages})
-        answer = results['messages'][-1].content.strip()
-        return answer
-
-def run_agent_only(profile: gr.OAuthProfile | None):
-    global cached_answers
-    cached_answers = []
-    results_log = []
+        messages = self.agent.invoke({"messages": messages})
+        answer = messages['messages'][-1].content
+
+        index = answer.find("FINAL ANSWER: ")
+        if index == -1:
+            return answer
+        return answer[index+14:]
+
+# --- Upload answers solved locally ---
+def csv_to_dict(file_path):
+    result = {}
+    with open(file_path, 'r') as file:
+        csv_reader = csv.reader(file)
+        header = next(csv_reader)  # Skip header row
+        for row in csv_reader:
+            result[row[0]] = row[1]
+    return result
+
+    
+def run_and_submit_all( profile: gr.OAuthProfile | None):
+    """
+    Fetches all questions, runs the BasicAgent on them, submits all answers,
+    and displays the results.
+    """
+    # --- Determine HF Space Runtime URL and Repo URL ---
+    space_id = os.getenv("SPACE_ID") # Get the SPACE_ID for sending link to the code
+
+    if profile:
+        username= f"{profile.username}"
+        print(f"User logged in: {username}")
+    else:
+        print("User not logged in.")
+        return "Please log in to Hugging Face with the button.", None
 
-    if not profile:
-        return "Please login first.", None
+    api_url = DEFAULT_API_URL
+    questions_url = f"{api_url}/questions"
+    submit_url = f"{api_url}/submit"
 
+    # 1. Instantiate Agent (modify this part to create your agent)
     try:
-        agent = ChatAgent()
+        agent = BasicAgent()
     except Exception as e:
-        return f"Agent Init Error: {e}", None
+        print(f"Error instantiating agent: {e}")
+        return f"Error initializing agent: {e}", None
+    
+    # In the case of an app running as a Hugging Face space, this link points toward your codebase (usefull for others so please keep it public)
+    agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main"
+    print(agent_code)
 
+    # 2. Fetch questions
+    print(f"Fetching questions from: {questions_url}")
     try:
-        response = requests.get(f"{DEFAULT_API_URL}/questions", timeout=15)
+        response = requests.get(questions_url, timeout=15)
+        response.raise_for_status()
         questions_data = response.json()
-    except Exception as e:
+        if not questions_data:
+             print("Fetched questions list is empty.")
+             return "Fetched questions list is empty or invalid format.", None
+        print(f"Fetched {len(questions_data)} questions.")
+    except requests.exceptions.RequestException as e:
+        print(f"Error fetching questions: {e}")
         return f"Error fetching questions: {e}", None
+    except requests.exceptions.JSONDecodeError as e:
+         print(f"Error decoding JSON response from questions endpoint: {e}")
+         print(f"Response text: {response.text[:500]}")
+         return f"Error decoding server response for questions: {e}", None
+    except Exception as e:
+        print(f"An unexpected error occurred fetching questions: {e}")
+        return f"An unexpected error occurred fetching questions: {e}", None
 
+    # 3. Run your agent
+    results_log = []
+    answers_payload = []
+
+    answers = csv_to_dict("answers.csv")
+    
+    print(f"Running agent on {len(questions_data)} questions...")
     for item in questions_data:
         task_id = item.get("task_id")
-        question = item.get("question")
-        file_name = item.get("file_name")
-
-        if not task_id or question is None:
+        question_text = item.get("question")
+        if not task_id or question_text is None:
+            print(f"Skipping item with missing task_id or question: {item}")
             continue
-
         try:
-            user_message = question
-            if file_name:
-                user_message += f"\n\nFile to use: {file_name}"
-
-            answer = agent(user_message)
-            cached_answers.append({"task_id": task_id, "submitted_answer": answer})
-            results_log.append({"Task ID": task_id, "Question": question, "Submitted Answer": answer})
+            #submitted_answer = agent(question_text)
+            submitted_answer = answers[task_id]
+            
+            answers_payload.append({"task_id": task_id, "submitted_answer": submitted_answer})
+            results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": submitted_answer})
+            time.sleep(10)
         except Exception as e:
-            results_log.append({
-                "Task ID": task_id,
-                "Question": question,
-                "Submitted Answer": f"AGENT ERROR: {e}"
-            })
-
-    return "Agent finished. Now click 'Submit Cached Answers'", pd.DataFrame(results_log)
+            print(f"Error running agent on task {task_id}: {e}")
+            results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": f"AGENT ERROR: {e}"})
+            time.sleep(10)
 
-def submit_cached_answers(profile: gr.OAuthProfile | None):
-    global cached_answers
-    if not profile or not cached_answers:
-        return "No cached answers to submit. Run the agent first.", None
+    if not answers_payload:
+        print("Agent did not produce any answers to submit.")
+        return "Agent did not produce any answers to submit.", pd.DataFrame(results_log)
 
-    space_id = os.getenv("SPACE_ID")
-    username = profile.username
-    agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main"
-
-    payload = {
-        "username": username,
-        "agent_code": agent_code,
-        "answers": cached_answers
-    }
+    # 4. Prepare submission 
+    submission_data = {"username": username.strip(), "agent_code": agent_code, "answers": answers_payload}
+    status_update = f"Agent finished. Submitting {len(answers_payload)} answers for user '{username}'..."
+    print(status_update)
 
+    # 5. Submit answers
+    print(f"Submitting {len(answers_payload)} answers to: {submit_url}")
     try:
-        response = requests.post(f"{DEFAULT_API_URL}/submit", json=payload, timeout=60)
-        result = response.json()
+        response = requests.post(submit_url, json=submission_data, timeout=60)
+        response.raise_for_status()
+        result_data = response.json()
         final_status = (
-            f"Submission Successful!\nUser: {result.get('username')}\n"
-            f"Score: {result.get('score', 'N/A')}% "
-            f"({result.get('correct_count', '?')}/{result.get('total_attempted', '?')})"
+            f"Submission Successful!\n"
+            f"User: {result_data.get('username')}\n"
+            f"Overall Score: {result_data.get('score', 'N/A')}% "
+            f"({result_data.get('correct_count', '?')}/{result_data.get('total_attempted', '?')} correct)\n"
+            f"Message: {result_data.get('message', 'No message received.')}"
         )
-        return final_status, None
+        print("Submission successful.")
+        results_df = pd.DataFrame(results_log)
+        return final_status, results_df
+    except requests.exceptions.HTTPError as e:
+        error_detail = f"Server responded with status {e.response.status_code}."
+        try:
+            error_json = e.response.json()
+            error_detail += f" Detail: {error_json.get('detail', e.response.text)}"
+        except requests.exceptions.JSONDecodeError:
+            error_detail += f" Response: {e.response.text[:500]}"
+        status_message = f"Submission Failed: {error_detail}"
+        print(status_message)
+        results_df = pd.DataFrame(results_log)
+        return status_message, results_df
+    except requests.exceptions.Timeout:
+        status_message = "Submission Failed: The request timed out."
+        print(status_message)
+        results_df = pd.DataFrame(results_log)
+        return status_message, results_df
+    except requests.exceptions.RequestException as e:
+        status_message = f"Submission Failed: Network error - {e}"
+        print(status_message)
+        results_df = pd.DataFrame(results_log)
+        return status_message, results_df
     except Exception as e:
-        return f"Submission failed: {e}", None
+        status_message = f"Unexpected error occurred during submission: {e}"
+        print(status_message)
+        results_df = pd.DataFrame(results_log)
+        return status_message, results_df
 
-# --- Gradio UI ---
+
+# --- Build Gradio interface using Blocks ---
 with gr.Blocks() as demo:
-    gr.Markdown("# LangGraph ChatAgent Evaluation")
-    gr.Markdown("Run the agent on all tasks, then submit for scoring.")
+    gr.Markdown("# Basic Agent Evaluation Runner")
+    gr.Markdown(
+        """
+        **Instructions:**
+        1.  Please clone this space, then modify the code to define your agent's logic, the tools, the necessary packages, etc ...
+        2.  Log in to your Hugging Face account using the button below. This uses your HF username for submission.
+        3.  Click 'Run Evaluation & Submit All Answers' to fetch questions, run your agent, submit answers, and see the score.
+        ---
+        **Disclaimers:**
+        Once clicking on the "submit button, it can take quite some time ( this is the time for the agent to go through all the questions).
+        This space provides a basic setup and is intentionally sub-optimal to encourage you to develop your own, more robust solution. For instance for the delay process of the submit button, a solution could be to cache the answers and submit in a seperate action or even to answer the questions in async.
+        """
+    )
+
     gr.LoginButton()
 
-    run_button = gr.Button("\U0001F9E0 Run Agent")
-    submit_button = gr.Button("\U0001F4E4 Submit Answers")
+    run_button = gr.Button("Run Evaluation & Submit All Answers")
 
-    status_box = gr.Textbox(label="Status", lines=3)
-    table = gr.DataFrame(label="Results", wrap=True)
+    status_output = gr.Textbox(label="Run Status / Submission Result", lines=5, interactive=False)
+    # Removed max_rows=10 from DataFrame constructor
+    results_table = gr.DataFrame(label="Questions and Agent Answers", wrap=True)
 
-    run_button.click(fn=run_agent_only, outputs=[status_box, table])
-    submit_button.click(fn=submit_cached_answers, outputs=[status_box, table])
+    run_button.click(
+        fn=run_and_submit_all,
+        outputs=[status_output, results_table]
+    )
 
 if __name__ == "__main__":
     print("\n" + "-"*30 + " App Starting " + "-"*30)
+    # Check for SPACE_HOST and SPACE_ID at startup for information
     space_host_startup = os.getenv("SPACE_HOST")
-    space_id_startup = os.getenv("SPACE_ID")
+    space_id_startup = os.getenv("SPACE_ID") # Get SPACE_ID at startup
 
     if space_host_startup:
         print(f"✅ SPACE_HOST found: {space_host_startup}")
-        print(f"   Runtime URL: https://{space_host_startup}.hf.space")
+        print(f"   Runtime URL should be: https://{space_host_startup}.hf.space")
     else:
-        print("ℹ️  No SPACE_HOST found.")
+        print("ℹ️  SPACE_HOST environment variable not found (running locally?).")
 
-    if space_id_startup:
+    if space_id_startup: # Print repo URLs if SPACE_ID is found
         print(f"✅ SPACE_ID found: {space_id_startup}")
         print(f"   Repo URL: https://huggingface.co/spaces/{space_id_startup}")
+        print(f"   Repo Tree URL: https://huggingface.co/spaces/{space_id_startup}/tree/main")
     else:
-        print("ℹ️  No SPACE_ID found.")
+        print("ℹ️  SPACE_ID environment variable not found (running locally?). Repo URL cannot be determined.")
+
+    print("-"*(60 + len(" App Starting ")) + "\n")
 
-    print("Launching Gradio Interface...")
+    print("Launching Gradio interface for Basic Agent evaluation...")
     demo.launch(debug=True, share=False)

requirements.txt

@@ -1,21 +1,14 @@
 gradio
 requests
+python-dotenv
 langchain
-langchain-community
 langchain-core
-langchain-google-genai
-langchain-huggingface
-langchain-groq
-langchain-anthropic
+langchain-community
 langchain-tavily
-langchain-chroma
+langchain-google-genai
+langchain-openai
 langgraph
-huggingface_hub
-sentence-transformers
-supabase
-arxiv
-pymupdf
 wikipedia
-pgvector
-python-dotenv
-tqdm
+arxiv
+youtube_transcript_api
+httpx