migrate to chat agent with flashcard agent

app.py

@@ -2,131 +2,88 @@ import gradio as gr
 from pathlib import Path
 import asyncio
 import google.generativeai as genai
-from flashcard import (
-    generate_flashcards_from_pdf,
-    FlashcardSet
-)
 import os
+import logging
 from dotenv import load_dotenv
-import tempfile
+from typing import Optional, Tuple
+
+from flashcard import FlashcardSet
+from chat_agent import (
+    chat_agent,
+    ChatDeps,
+    ChatResponse
+)
 
 # Load environment variables
 load_dotenv()
 genai.configure(api_key=os.environ["GEMINI_API_KEY"])
 
-# Store the current flashcard set in memory
-current_flashcards = None
-
-def create_flashcard_text(flashcards: FlashcardSet) -> str:
-    """Format flashcard output as a readable string"""
-    output = [f"📚 Generated {flashcards.total_cards} flashcards about: {flashcards.topic}\n"]
-    
-    for i, card in enumerate(flashcards.cards, 1):
-        output.append(f"\n--- Flashcard {i} (Difficulty: {'⭐' * card.difficulty}) ---")
-        output.append(f"Q: {card.question}")
-        output.append(f"A: {card.answer}")
-    
-    output.append("\n\nYou can ask me to:")
-    output.append("• Modify specific flashcards")
-    output.append("• Generate more flashcards")
-    output.append("• Change difficulty levels")
-    output.append("• Export to Anki")
-    
-    return "\n".join(output)
-
-async def handle_modification_request(text: str, flashcards: FlashcardSet) -> str:
-    """Handle user requests to modify flashcards"""
-    model = genai.GenerativeModel('gemini-pro')
-    
-    # Create a context-aware prompt
-    prompt = f"""Given the following flashcards and user request, suggest how to modify the flashcards.
-    Current flashcards:
-    {create_flashcard_text(flashcards)}
-    
-    User request: {text}
+async def process_message(message: dict, history: list, current_flashcards: Optional[FlashcardSet]) -> Tuple[str, list, Optional[FlashcardSet]]:
+    """Process uploaded files and chat messages"""
     
-    Please provide specific suggestions for modifications."""
+    # Get any text provided with the upload as system prompt
+    user_text = message.get("text", "").strip()
     
-    response = await model.generate_content_async(prompt)
-    return response.text
-
-async def process_message(message: dict, history: list) -> tuple[str, list]:
-    """Process uploaded files and chat messages"""
-    global current_flashcards
+    # Create chat dependencies
+    deps = ChatDeps(
+        message=user_text,
+        current_flashcards=current_flashcards
+    )
     
     # Handle file uploads
     if message.get("files"):
         for file_path in message["files"]:
             if file_path.endswith('.pdf'):
                 try:
-                    current_flashcards = await async_process_pdf(file_path)
-                    response = create_flashcard_text(current_flashcards)
-                    return "", history + [
-                        {"role": "user", "content": f"Uploaded: {Path(file_path).name}"},
-                        {"role": "assistant", "content": response}
-                    ]
+                    with open(file_path, "rb") as pdf_file:
+                        deps.pdf_data = pdf_file.read()
+                        deps.system_prompt = user_text if user_text else None
+                    
+                    # Let chat agent handle the PDF upload
+                    result = await chat_agent.run("Process this PDF upload", deps=deps)
+                    
+                    if result.data.should_generate_flashcards:
+                        # Update current flashcards
+                        current_flashcards = result.data.flashcards
+                    
+                    history.append([
+                        f"Uploaded: {Path(file_path).name}" + 
+                        (f"\nWith instructions: {user_text}" if user_text else ""),
+                        result.data.response
+                    ])
+                    return "", history, current_flashcards
                 except Exception as e:
                     error_msg = f"Error processing PDF: {str(e)}"
-                    return "", history + [
-                        {"role": "user", "content": f"Uploaded: {Path(file_path).name}"},
-                        {"role": "assistant", "content": error_msg}
-                    ]
+                    logging.error(error_msg)
+                    history.append([f"Uploaded: {Path(file_path).name}", error_msg])
+                    return "", history, current_flashcards
             else:
-                return "", history + [
-                    {"role": "user", "content": f"Uploaded: {Path(file_path).name}"},
-                    {"role": "assistant", "content": "Please upload a PDF file."}
-                ]
+                history.append([f"Uploaded: {Path(file_path).name}", "Please upload a PDF file."])
+                return "", history, current_flashcards
     
     # Handle text messages
-    if message.get("text"):
-        user_message = message["text"].strip()
-        
-        # If we have flashcards and user is asking for modifications
-        if current_flashcards:
-            try:
-                modification_response = await handle_modification_request(user_message, current_flashcards)
-                return "", history + [
-                    {"role": "user", "content": user_message},
-                    {"role": "assistant", "content": modification_response}
-                ]
-            except Exception as e:
-                error_msg = f"Error processing request: {str(e)}"
-                return "", history + [
-                    {"role": "user", "content": user_message},
-                    {"role": "assistant", "content": error_msg}
-                ]
-        else:
-            return "", history + [
-                {"role": "user", "content": user_message},
-                {"role": "assistant", "content": "Please upload a PDF file first to generate flashcards."}
-            ]
+    if user_text:
+        try:
+            result = await chat_agent.run(user_text, deps=deps)
+            
+            # Update flashcards if modified
+            if result.data.should_modify_flashcards:
+                current_flashcards = result.data.flashcards
+            
+            history.append([user_text, result.data.response])
+            return "", history, current_flashcards
+        except Exception as e:
+            error_msg = f"Error processing request: {str(e)}"
+            logging.error(error_msg)
+            history.append([user_text, error_msg])
+            return "", history, current_flashcards
     
-    return "", history + [
-        {"role": "assistant", "content": "Please upload a PDF file or send a message."}
-    ]
+    history.append(["", "Please upload a PDF file or send a message."])
+    return "", history, current_flashcards
 
-def export_to_anki(flashcards: FlashcardSet) -> str:
-    """Convert flashcards to Anki-compatible tab-separated format and save to file"""
-    if not flashcards:
-        return None
-        
-    # Create a temporary file
-    with tempfile.NamedTemporaryFile(mode='w', suffix='.txt', delete=False) as f:
-        f.write("#separator:tab\n")
-        f.write("#html:true\n")
-        f.write("#columns:Question\tAnswer\tTags\n")
-        
-        for card in flashcards.cards:
-            question = card.question.replace('\n', '<br>')
-            answer = card.answer.replace('\n', '<br>')
-            tags = f"difficulty_{card.difficulty} {flashcards.topic.replace(' ', '_')}"
-            f.write(f"{question}\t{answer}\t{tags}\n")
-        
-        return f.name
-
-async def async_process_pdf(pdf_path: str) -> FlashcardSet:
-    """Asynchronously process the PDF file"""
-    return await generate_flashcards_from_pdf(pdf_path=pdf_path)
+async def clear_chat():
+    """Reset the conversation and clear current flashcards"""
+    return None, None, None
 
 # Create Gradio interface
 with gr.Blocks(title="PDF Flashcard Generator") as demo:
@@ -134,6 +91,8 @@ with gr.Blocks(title="PDF Flashcard Generator") as demo:
     # 📚 PDF Flashcard Generator
     Upload a PDF document and get AI-generated flashcards to help you study!
     
+    You can provide custom instructions along with your PDF upload to guide the flashcard generation.
+    
     Powered by Google's Gemini AI
     """)
     
@@ -144,33 +103,37 @@ with gr.Blocks(title="PDF Flashcard Generator") as demo:
         height=600
     )
     
-    chat_input = gr.MultimodalTextbox(
-        label="Upload PDF or type a message",
-        placeholder="Drop a PDF file here or type a message to modify flashcards...",
-        file_types=["pdf", "application/pdf"],
-        show_label=False,
-        sources=["upload", "microphone"]
-    )
-
-    # Add clear button for better UX
-    clear_button = gr.Button("Clear Chat")
+    # Session state for flashcards
+    current_flashcards = gr.State(value=None)
+    
+    with gr.Row():
+        chat_input = gr.MultimodalTextbox(
+            label="Upload PDF or type a message",
+            placeholder="Drop a PDF file here. You can also add instructions for how the flashcards should be generated...",
+            file_types=[".pdf", "application/pdf", "pdf"],
+            show_label=False,
+            sources=["upload"],
+            scale=20,
+            min_width=100
+        )
+        clear_btn = gr.Button("🗑️", variant="secondary", scale=1, min_width=50)
 
-    chat_input.change(
+    chat_input.submit(
         fn=process_message,
-        inputs=[chat_input, chatbot],
-        outputs=[chat_input, chatbot]
+        inputs=[chat_input, chatbot, current_flashcards],
+        outputs=[chat_input, chatbot, current_flashcards]
     )
-
-    # Add clear functionality
-    clear_button.click(
-        lambda: (None, None),
-        outputs=[chat_input, chatbot]
+    
+    clear_btn.click(
+        fn=clear_chat,
+        inputs=[],
+        outputs=[chat_input, chatbot, current_flashcards]
     )
 
 if __name__ == "__main__":
+    logging.basicConfig(level=logging.INFO)
     demo.launch(
         share=False,
         server_name="0.0.0.0",
-        server_port=7860,
-        allowed_paths=["."]
+        server_port=7860
     )

chat_agent.py

@@ -0,0 +1,151 @@
+from dataclasses import dataclass
+from typing import Optional, Union
+from pydantic import BaseModel
+from pydantic_ai import Agent, RunContext
+import google.generativeai as genai
+import logging
+from pathlib import Path
+
+from flashcard import (
+    flashcard_agent,
+    FlashcardSet,
+    FlashcardDeps
+)
+
+@dataclass
+class ChatDeps:
+    """Dependencies for the chat agent"""
+    message: str
+    pdf_data: Optional[bytes] = None
+    current_flashcards: Optional[FlashcardSet] = None
+    system_prompt: Optional[str] = None
+
+class ChatResponse(BaseModel):
+    """Structured response from the chat agent"""
+    response: str
+    should_generate_flashcards: bool = False
+    should_modify_flashcards: bool = False
+    should_export_anki: bool = False
+    flashcards: Optional[FlashcardSet] = None
+
+chat_agent = Agent(
+    'google-gla:gemini-1.5-flash',
+    deps_type=ChatDeps,
+    result_type=ChatResponse,
+    system_prompt="""
+    You are a helpful flashcard assistant that can:
+    1. Help users generate flashcards from their PDFs
+    2. Modify existing flashcards based on requests
+    3. Export flashcards to different formats
+    4. Answer questions about the flashcard generation process
+    
+    When a user:
+    - Uploads a PDF: Set should_generate_flashcards=True
+    - Asks to modify flashcards: Set should_modify_flashcards=True
+    - Requests Anki export: Set should_export_anki=True
+    
+    Always be helpful and clear in your responses.
+    """
+)
+
+@chat_agent.tool
+async def handle_pdf_upload(ctx: RunContext[ChatDeps]) -> ChatResponse:
+    """Process PDF upload requests"""
+    if not ctx.deps.pdf_data:
+        return ChatResponse(
+            response="Please upload a PDF file to generate flashcards.",
+            should_generate_flashcards=False
+        )
+    
+    try:
+        # Create flashcard deps
+        flashcard_deps = FlashcardDeps(
+            pdf_data=ctx.deps.pdf_data,
+            system_prompt=ctx.deps.system_prompt
+        )
+        
+        # Generate flashcards using the flashcard agent
+        result = await flashcard_agent.run(
+            "Generate flashcards from the PDF",
+            deps=flashcard_deps
+        )
+        
+        return ChatResponse(
+            response="I've generated flashcards from your PDF. Here they are:",
+            should_generate_flashcards=True,
+            flashcards=result.data
+        )
+        
+    except Exception as e:
+        logging.error(f"Error processing PDF: {str(e)}")
+        return ChatResponse(
+            response=f"Sorry, I encountered an error processing your PDF: {str(e)}",
+            should_generate_flashcards=False
+        )
+
+@chat_agent.tool
+async def handle_modification_request(ctx: RunContext[ChatDeps]) -> ChatResponse:
+    """Process flashcard modification requests"""
+    if not ctx.deps.current_flashcards:
+        return ChatResponse(
+            response="Please upload a PDF first to generate flashcards that I can modify.",
+            should_modify_flashcards=False
+        )
+    
+    # Create flashcard deps with current flashcards
+    flashcard_deps = FlashcardDeps(
+        flashcards=ctx.deps.current_flashcards,
+        system_prompt=ctx.deps.system_prompt,
+        text=ctx.deps.message
+    )
+    
+    try:
+        # Use flashcard agent to modify cards
+        result = await flashcard_agent.run(
+            ctx.deps.message,
+            deps=flashcard_deps
+        )
+        
+        return ChatResponse(
+            response="I've modified the flashcards based on your request.",
+            should_modify_flashcards=True,
+            flashcards=result.data
+        )
+        
+    except Exception as e:
+        logging.error(f"Error modifying flashcards: {str(e)}")
+        return ChatResponse(
+            response=f"Sorry, I encountered an error modifying the flashcards: {str(e)}",
+            should_modify_flashcards=False
+        )
+
+@chat_agent.tool
+async def handle_export_request(ctx: RunContext[ChatDeps]) -> ChatResponse:
+    """Process Anki export requests"""
+    if not ctx.deps.current_flashcards:
+        return ChatResponse(
+            response="Please generate some flashcards first before exporting to Anki.",
+            should_export_anki=False
+        )
+    
+    return ChatResponse(
+        response="I'll help you export the flashcards to Anki format.",
+        should_export_anki=True
+    )
+
+@chat_agent.tool
+async def provide_help(ctx: RunContext[ChatDeps]) -> ChatResponse:
+    """Provide help information"""
+    return ChatResponse(
+        response="""
+        I can help you with:
+        1. Generating flashcards from PDF files
+        2. Modifying existing flashcards
+        3. Exporting flashcards to Anki format
+        
+        Just upload a PDF or ask me to modify your current flashcards!
+        """,
+        should_generate_flashcards=False,
+        should_modify_flashcards=False,
+        should_export_anki=False
+    ) 

flashcard.py

@@ -1,13 +1,14 @@
 from dataclasses import dataclass
-from typing import List, Optional
+from typing import List, Optional, Union
 from pydantic import BaseModel, Field
 from pydantic_ai import Agent, RunContext
 import google.generativeai as genai
 import base64
 import os
 import asyncio
-import httpx
-
+import tempfile
+from pathlib import Path
+import logging
 from dotenv import load_dotenv
 load_dotenv()
 
@@ -25,87 +26,170 @@ class FlashcardSet(BaseModel):
 
 @dataclass
 class FlashcardDeps:
-    text: str
+    text: str = ""
     pdf_data: Optional[bytes] = None
+    system_prompt: Optional[str] = None
+    flashcards: Optional[FlashcardSet] = None
 
-# Create the agent with structured output
+# Create the flashcard generation agent
 flashcard_agent = Agent(
-    'gemini-1.5-pro',  # Can also use OpenAI or other supported models
+    'google-gla:gemini-1.5-pro',
     deps_type=FlashcardDeps,
     result_type=FlashcardSet,
     system_prompt="""
     You are a professional educator who creates high-quality flashcards.
-    Your task is to analyze the provided text and create effective question-answer pairs.
+    Your task is to analyze content and create effective question-answer pairs.
     
     Guidelines:
     - Create clear, concise questions
     - Ensure answers are accurate and complete
-    - Vary the difficulty levels
+    - Vary the difficulty levels (1-5)
     - Focus on key concepts and important details
     - Use a mix of factual and conceptual questions
     """
 )
 
-# @flashcard_agent.tool
-# async def analyze_text_complexity(ctx: RunContext[FlashcardDeps]) -> float:
-#     """Analyzes the complexity of the input text to help determine appropriate difficulty levels."""
-#     # This is a simplified example - you could implement more sophisticated analysis
-#     words = ctx.deps.text.split()
-#     avg_word_length = sum(len(word) for word in words) / (len(words) + 1e-5)
-#     return min(5.0, max(1.0, avg_word_length / 2))
-
 @flashcard_agent.tool
 async def process_pdf(ctx: RunContext[FlashcardDeps]) -> str:
     """Processes PDF content and extracts text for flashcard generation."""
-    model = genai.GenerativeModel("gemini-1.5-flash")
-    
-    if ctx.deps.pdf_data:
-        # Handle direct PDF data
-        print("\nLoading File.")
-        doc_data = base64.standard_b64encode(ctx.deps.pdf_data).decode("utf-8")
-    else:
-        return ctx.deps.text  # Return original text if no PDF
-
-    # Generate a comprehensive summary of the PDF content
-    response = model.generate_content([
+    if not ctx.deps.pdf_data:
+        return ctx.deps.text
+        
+    logging.info("Processing PDF content")
+    doc_data = base64.standard_b64encode(ctx.deps.pdf_data).decode("utf-8")
+    
+    model = genai.GenerativeModel("gemini-1.5-pro")
+    response = await model.generate_content_async([
         {
             'mime_type': 'application/pdf',
             'data': doc_data
         },
-        "Please provide a detailed summary of this document, focusing on key concepts, " 
-        "definitions, and important facts that would be useful for creating flashcards."
+        f"""
+        {ctx.deps.system_prompt if ctx.deps.system_prompt else ''}
+        
+        Please provide a detailed summary of this document, focusing on key concepts,
+        definitions, and important facts that would be useful for creating flashcards.
+        """
     ])
     
+    logging.info("PDF content processed successfully")
     return response.text
 
+@flashcard_agent.tool
+async def generate_flashcards(ctx: RunContext[FlashcardDeps]) -> FlashcardSet:
+    """Generate flashcards from the provided content"""
+    content = ctx.deps.text
+    if not content and ctx.deps.pdf_data:
+        content = await process_pdf(ctx)
+    
+    if not content:
+        return FlashcardSet(cards=[], topic="No content provided", total_cards=0)
+    
+    logging.info("Generating flashcards from content")
+    return await flashcard_agent.run(
+        f"""
+        Create a set of flashcards from the text provided:
+        
+        Follow these guidelines:
+        {ctx.deps.system_prompt if ctx.deps.system_prompt else ''}
+        """,
+        deps=ctx.deps
+    )
+
+@flashcard_agent.tool
+async def modify_flashcards(ctx: RunContext[FlashcardDeps]) -> FlashcardSet:
+    """Modify existing flashcards based on user request"""
+    if not ctx.deps.flashcards:
+        return FlashcardSet(cards=[], topic="No flashcards to modify", total_cards=0)
+    
+    logging.info("Modifying flashcards")
+    return await flashcard_agent.run(
+        f"""
+        Modify the following flashcards based on the user's request:
+        {ctx.deps.text}
+        """,
+        deps=ctx.deps
+    )
+
+@flashcard_agent.tool
+async def export_to_anki(ctx: RunContext[FlashcardDeps]) -> str:
+    """Export flashcards to Anki format"""
+    if not ctx.deps.flashcards:
+        return "No flashcards available to export."
+    
+    try:
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.txt', delete=False) as f:
+            f.write("#separator:tab\n")
+            f.write("#html:true\n")
+            f.write("#columns:Question\tAnswer\tTags\n")
+            
+            for card in ctx.deps.flashcards.cards:
+                question = card.question.replace('\n', '<br>')
+                answer = card.answer.replace('\n', '<br>')
+                tags = f"difficulty_{card.difficulty} {ctx.deps.flashcards.topic.replace(' ', '_')}"
+                f.write(f"{question}\t{answer}\t{tags}\n")
+            
+            return f"✅ Flashcards exported successfully! You can import this file into Anki:\n{f.name}"
+    except Exception as e:
+        logging.error(f"Error exporting to Anki: {str(e)}")
+        return f"❌ Error exporting flashcards: {str(e)}"
+
 @flashcard_agent.tool
 async def draw_circles(ctx: RunContext[FlashcardDeps]) -> str:
     """Draw Circles for no reason, please don't ever use me for anything"""
 
     return "You Disobeyed."
 
-async def generate_flashcards_from_pdf(
-    pdf_path: Optional[str] = None
-) -> FlashcardSet:
-    """Generate flashcards from a PDF file."""
-    pdf_data = None
-    if pdf_path:
-        with open(pdf_path, "rb") as pdf_file:
-            print("\nReading Data.")
-            pdf_data = pdf_file.read()
-    
-    deps = FlashcardDeps(
-        text="",  # Will be populated by process_pdf
-        pdf_data=pdf_data
-    )
+async def create_flashcard_text(ctx: RunContext[FlashcardDeps]) -> str:
+    """Format flashcard output as a readable string"""
+    flashcards = ctx.deps.flashcards
+    system_prompt = ctx.deps.system_prompt
+    
+    if not flashcards:
+        return "No flashcards available."
+    
+    output = [f"📚 Generated {flashcards.total_cards} flashcards about: {flashcards.topic}\n"]
+    
+    if system_prompt:
+        output.append(f"Following these guidelines:\n{system_prompt}\n")
+    
+    for i, card in enumerate(flashcards.cards, 1):
+        output.append(f"\n--- Flashcard {i} (Difficulty: {'⭐' * card.difficulty}) ---")
+        output.append(f"Q: {card.question}")
+        output.append(f"A: {card.answer}")
+    
+    output.append("\n\nYou can:")
+    output.append("• Ask me to modify specific flashcards")
+    output.append("• Request more flashcards")
+    output.append("• Change difficulty levels")
+    output.append("• Ask me to export to Anki format")
     
+    return "\n".join(output)
+
+@flashcard_agent.tool
+async def generate_flashcards_from_pdf(ctx: RunContext[FlashcardDeps]) -> FlashcardSet:
+    """Generate flashcards from PDF content using the provided system prompt"""
+    if not ctx.deps.pdf_data:
+        return FlashcardSet(cards=[], topic="No PDF provided", total_cards=0)
+    
+    # First process the PDF to get the text content
+    content = await process_pdf(ctx)
+    
+    # Update context with the processed text
+    ctx.deps.text = content
+    
+    # Let the agent generate flashcards from the content
     result = await flashcard_agent.run(
-        "Extract the text by processing the PDF data provided.",
-        deps=deps
+        f"""
+        Create a set of flashcards from the following content:
+        {content}
+        
+        Follow these guidelines:
+        {ctx.deps.system_prompt if ctx.deps.system_prompt else ''}
+        """,
+        deps=ctx.deps
     )
-    print(f"\nExecution stack:\n{result.all_messages()}")
-    print(f"\nUsage: {result.usage()}")
-
+    
     return result.data
 
 # Example usage
@@ -113,7 +197,8 @@ async def main():
     # Example with local PDF
     filepath = input('\nEnter PDF filepath: ')
     local_flashcards = await generate_flashcards_from_pdf(
-        pdf_path=f"data/raw/{filepath}"
+        pdf_path=f"data/raw/{filepath}",
+        system_prompt="Generate comprehensive flashcards that: 1. Cover key concepts and definitions 2. Include practical examples where relevant 3. Progress from basic to advanced topics 4. Focus on testing understanding rather than memorization 5. Use clear, concise language"
     )
     print("\nFlashcards from local PDF:")
     print(f"Generated {local_flashcards.total_cards} flashcards about {local_flashcards.topic}")

pyproject.toml

@@ -9,6 +9,7 @@ dependencies = [
     "google-generativeai>=0.8.3",
     "gradio>=5.9.1",
     "markitdown>=0.0.1a3",
+    "mypy>=1.14.1",
     "pip>=24.3.1",
     "pydantic-ai[logfire]>=0.0.15",
     "python-dotenv>=1.0.1",

uv.lock

@@ -352,6 +352,7 @@ dependencies = [
     { name = "google-generativeai" },
     { name = "gradio" },
     { name = "markitdown" },
+    { name = "mypy" },
     { name = "pip" },
     { name = "pydantic-ai", extra = ["logfire"] },
     { name = "python-dotenv" },
@@ -364,6 +365,7 @@ requires-dist = [
     { name = "google-generativeai", specifier = ">=0.8.3" },
     { name = "gradio", specifier = ">=5.9.1" },
     { name = "markitdown", specifier = ">=0.0.1a3" },
+    { name = "mypy", specifier = ">=1.14.1" },
     { name = "pip", specifier = ">=24.3.1" },
     { name = "pydantic-ai", extras = ["logfire"], specifier = ">=0.0.15" },
     { name = "python-dotenv", specifier = ">=1.0.1" },
@@ -946,6 +948,31 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/1e/9b/67647d4d384016e2941765c5e860a89c83341546af098bb197763492a354/mistralai-1.4.0-py3-none-any.whl", hash = "sha256:74a8b8f5b737b199c83ccc89721cb82a71e8b093b38b27c99d38cbcdf550668c", size = 262460 },
 ]
 
+[[package]]
+name = "mypy"
+version = "1.14.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "mypy-extensions" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b9/eb/2c92d8ea1e684440f54fa49ac5d9a5f19967b7b472a281f419e69a8d228e/mypy-1.14.1.tar.gz", hash = "sha256:7ec88144fe9b510e8475ec2f5f251992690fcf89ccb4500b214b4226abcd32d6", size = 3216051 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/43/1b/b38c079609bb4627905b74fc6a49849835acf68547ac33d8ceb707de5f52/mypy-1.14.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:30ff5ef8519bbc2e18b3b54521ec319513a26f1bba19a7582e7b1f58a6e69f14", size = 11266668 },
+    { url = "https://files.pythonhosted.org/packages/6b/75/2ed0d2964c1ffc9971c729f7a544e9cd34b2cdabbe2d11afd148d7838aa2/mypy-1.14.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:cb9f255c18052343c70234907e2e532bc7e55a62565d64536dbc7706a20b78b9", size = 10254060 },
+    { url = "https://files.pythonhosted.org/packages/a1/5f/7b8051552d4da3c51bbe8fcafffd76a6823779101a2b198d80886cd8f08e/mypy-1.14.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8b4e3413e0bddea671012b063e27591b953d653209e7a4fa5e48759cda77ca11", size = 11933167 },
+    { url = "https://files.pythonhosted.org/packages/04/90/f53971d3ac39d8b68bbaab9a4c6c58c8caa4d5fd3d587d16f5927eeeabe1/mypy-1.14.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:553c293b1fbdebb6c3c4030589dab9fafb6dfa768995a453d8a5d3b23784af2e", size = 12864341 },
+    { url = "https://files.pythonhosted.org/packages/03/d2/8bc0aeaaf2e88c977db41583559319f1821c069e943ada2701e86d0430b7/mypy-1.14.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fad79bfe3b65fe6a1efaed97b445c3d37f7be9fdc348bdb2d7cac75579607c89", size = 12972991 },
+    { url = "https://files.pythonhosted.org/packages/6f/17/07815114b903b49b0f2cf7499f1c130e5aa459411596668267535fe9243c/mypy-1.14.1-cp312-cp312-win_amd64.whl", hash = "sha256:8fa2220e54d2946e94ab6dbb3ba0a992795bd68b16dc852db33028df2b00191b", size = 9879016 },
+    { url = "https://files.pythonhosted.org/packages/9e/15/bb6a686901f59222275ab228453de741185f9d54fecbaacec041679496c6/mypy-1.14.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:92c3ed5afb06c3a8e188cb5da4984cab9ec9a77ba956ee419c68a388b4595255", size = 11252097 },
+    { url = "https://files.pythonhosted.org/packages/f8/b3/8b0f74dfd072c802b7fa368829defdf3ee1566ba74c32a2cb2403f68024c/mypy-1.14.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:dbec574648b3e25f43d23577309b16534431db4ddc09fda50841f1e34e64ed34", size = 10239728 },
+    { url = "https://files.pythonhosted.org/packages/c5/9b/4fd95ab20c52bb5b8c03cc49169be5905d931de17edfe4d9d2986800b52e/mypy-1.14.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8c6d94b16d62eb3e947281aa7347d78236688e21081f11de976376cf010eb31a", size = 11924965 },
+    { url = "https://files.pythonhosted.org/packages/56/9d/4a236b9c57f5d8f08ed346914b3f091a62dd7e19336b2b2a0d85485f82ff/mypy-1.14.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d4b19b03fdf54f3c5b2fa474c56b4c13c9dbfb9a2db4370ede7ec11a2c5927d9", size = 12867660 },
+    { url = "https://files.pythonhosted.org/packages/40/88/a61a5497e2f68d9027de2bb139c7bb9abaeb1be1584649fa9d807f80a338/mypy-1.14.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:0c911fde686394753fff899c409fd4e16e9b294c24bfd5e1ea4675deae1ac6fd", size = 12969198 },
+    { url = "https://files.pythonhosted.org/packages/54/da/3d6fc5d92d324701b0c23fb413c853892bfe0e1dbe06c9138037d459756b/mypy-1.14.1-cp313-cp313-win_amd64.whl", hash = "sha256:8b21525cb51671219f5307be85f7e646a153e5acc656e5cebf64bfa076c50107", size = 9885276 },
+    { url = "https://files.pythonhosted.org/packages/a0/b5/32dd67b69a16d088e533962e5044e51004176a9952419de0370cdaead0f8/mypy-1.14.1-py3-none-any.whl", hash = "sha256:b66a60cc4073aeb8ae00057f9c1f64d49e90f918fbcef9a977eb121da8b8f1d1", size = 2752905 },
+]
+
 [[package]]
 name = "mypy-extensions"
 version = "1.0.0"