Update app.py

app.py

@@ -1,457 +1,190 @@
-"""
-Module: blockchain_analyzer_app
-Description: A Gradio-based web application for blockchain wallet analysis
-             using Etherscan's API and OpenAI for conversational insights.
-"""
-
-import os
-import re
-import aiohttp
-import asyncio
-import openai
-import plotly.graph_objects as go
-from datetime import datetime
-from typing import List, Dict, Tuple, Any, Optional
-from decimal import Decimal
-import time
-
-import gradio as gr
-
-###############################################################################
-#                               CONSTANTS                                       #
-###############################################################################
-
-SYSTEM_PROMPT: str = """
-You are LOSS DOG 🐕 (Learning & Observing Smart Systems Digital Output Generator), an adorable blockchain-sniffing puppy!
-Your personality:
-- Friendly and enthusiastic
-- Explain findings in fun, simple ways
+from PyPDF2 import PdfReader
+from markdownify import markdownify
+
+# Persistent System Prompt
+LOSSDOG_PROMPT = """
+<LossDogFramework version="3.0">
+    <Identity>
+        <Description>
+            You are Loss Dog, a cutting-edge AI career advisor, resume analyzer, and builder. Your primary role is to:
+            - Read and analyze the user's resume thoroughly.
+            - Use the resume as a knowledge context for all interactions.
+            - Engage with the user by answering questions, identifying areas of improvement, and offering suggestions.
+        </Description>
+    </Identity>
+    <CoreDirectives>
+        <Mission>
+            Your mission is to provide actionable resume advice. Always leverage the uploaded resume to give feedback,
+            highlight strengths, and identify weaknesses.
+        </Mission>
+    </CoreDirectives>
+</LossDogFramework>
 """
 
-ETHERSCAN_BASE_URL: str = "https://api.etherscan.io/api"
-ETHEREUM_ADDRESS_REGEX: str = r"0x[a-fA-F0-9]{40}"
-
-###############################################################################
-#                          ETHERSCAN CLIENT                                    #
-###############################################################################
-
-class EtherscanClient:
-    def __init__(self, api_key: str):
-        self.api_key = api_key
-        self.base_url = ETHERSCAN_BASE_URL
-        self.last_request_time = 0
-        self.rate_limit_delay = 0.2  # 5 requests per second max for free tier
-
-    async def _rate_limit(self):
-        """Implement rate limiting for Etherscan API"""
-        current_time = time.time()
-        time_passed = current_time - self.last_request_time
-        if time_passed < self.rate_limit_delay:
-            await asyncio.sleep(self.rate_limit_delay - time_passed)
-        self.last_request_time = time.time()
-
-    async def fetch_data(self, params: Dict[str, str]) -> Dict[str, Any]:
-        """Generic method to fetch data from Etherscan API"""
-        params["apikey"] = self.api_key
-        
-        await self._rate_limit()
-        
+def extract_text_from_file(file_path: str, file_name: str) -> str:
+    """Extract text from a PDF or TXT file."""
+    if file_name.endswith(".pdf"):
         try:
-            async with aiohttp.ClientSession() as session:
-                async with session.get(self.base_url, params=params) as response:
-                    if response.status != 200:
-                        return {"error": f"API request failed: {response.status}"}
-                        
-                    data = await response.json()
-                    if data["status"] == "0":
-                        error_msg = data.get('message', 'Unknown error')
-                        if "Max rate limit reached" in error_msg:
-                            await asyncio.sleep(1)
-                            return await self.fetch_data(params)
-                        return {"error": f"API error: {error_msg}"}
-                        
-                    return data
+            pdf_reader = PdfReader(file_path)
+                return f.read()
         except Exception as e:
-            return {"error": f"Error fetching data: {str(e)}"}
-
-    async def get_eth_balance(self, address: str) -> Decimal:
-        """Get ETH balance for address"""
-        params = {
-            "module": "account",
-            "action": "balance",
-            "address": address,
-            "tag": "latest"
-        }
-        
-        data = await self.fetch_data(params)
-        if "error" not in data and "result" in data:
-            return Decimal(data["result"]) / Decimal("1000000000000000000")  # Convert from Wei
-        return Decimal(0)
-
-    async def get_token_transfers(self, address: str) -> List[Dict[str, Any]]:
-        """Get ERC20 token transfers"""
-        params = {
-            "module": "account",
-            "action": "tokentx",
-            "address": address,
-            "sort": "desc"
-        }
-        
-        data = await self.fetch_data(params)
-        return data.get("result", []) if "error" not in data else []
-
-    async def get_nfts(self, address: str) -> List[Dict[str, Any]]:
-        """Get NFT (ERC721 and ERC1155) tokens"""
-        params = {
-            "module": "account",
-            "action": "tokennfttx",
-            "address": address,
-            "sort": "desc"
-        }
-        
-        data = await self.fetch_data(params)
-        return data.get("result", []) if "error" not in data else []
+            return f"Error reading text file: {str(e)}"
+    return "Unsupported file format. Please upload a PDF or TXT file."
+
+
+def convert_to_markdown(text: str) -> str:
+    """Convert extracted file text to Markdown for neat display."""
+    return markdownify(text, heading_style="ATX")
+
+def interact_with_lossdog(
+    user_message: str,
+    markdown_text: str,
+    api_key: str,
+    history: list
+) -> list:
+    """
+    Generates the assistant's response, always including the resume content as context
+    alongside the conversation history.
+    """
+
+
+
+
+
+
 
-    def format_nfts(self, nft_transfers: List[Dict[str, Any]], wallet_address: str) -> List[Dict[str, Any]]:
-        """Format NFT transfers into current holdings"""
-        nft_holdings = {}
-        
-        for transfer in nft_transfers:
-            token_id = transfer["tokenID"]
-            contract = transfer["contractAddress"]
-            key = f"{contract}_{token_id}"
-            
-            if transfer["to"].lower() == wallet_address.lower():
-                nft_holdings[key] = {
-                    "token_id": token_id,
-                    "contract": contract,
-                    "name": transfer.get("tokenName", "Unknown NFT"),
-                    "symbol": transfer.get("tokenSymbol", ""),
-                    "from": transfer["from"],
-                    "timestamp": transfer["timeStamp"]
-                }
-            elif transfer["from"].lower() == wallet_address.lower():
-                nft_holdings.pop(key, None)
-
-        return list(nft_holdings.values())
-
-    async def get_portfolio(self, address: str) -> Dict[str, Any]:
-        """Get complete portfolio including ETH, tokens, and NFTs"""
-        eth_balance, token_transfers, nft_transfers = await asyncio.gather(
-            self.get_eth_balance(address),
-            self.get_token_transfers(address),
-            self.get_nfts(address)
-        )
 
-        # Process token transfers to get current holdings
-        token_holdings = {}
-        for transfer in token_transfers:
-            contract = transfer["contractAddress"]
-            if contract not in token_holdings:
-                token_holdings[contract] = {
-                    "name": transfer["tokenName"],
-                    "symbol": transfer["tokenSymbol"],
-                    "decimals": int(transfer["tokenDecimal"]),
-                    "contract": contract,
-                    "balance": Decimal(0)
-                }
-
-            amount = Decimal(transfer["value"]) / Decimal(10 ** int(transfer["tokenDecimal"]))
-            if transfer["to"].lower() == address.lower():
-                token_holdings[contract]["balance"] += amount
-            elif transfer["from"].lower() == address.lower():
-                token_holdings[contract]["balance"] -= amount
-
-        # Remove tokens with zero balance
-        token_holdings = {k: v for k, v in token_holdings.items() if v["balance"] > 0}
-
-        return {
-            "eth_balance": eth_balance,
-            "tokens": list(token_holdings.values()),
-            "nfts": self.format_nfts(nft_transfers, address)
-        }
-
-###############################################################################
-#                          HELPER FUNCTIONS                                     #
-###############################################################################
-
-def validate_openai_key(api_key: str) -> Tuple[bool, str]:
-    """Validate OpenAI API key by making a minimal API request."""
-    if not api_key:
-        return False, "OpenAI API key is required!"
-    try:
-        client = openai.OpenAI(api_key=api_key)
-        # Make a minimal request to validate the key
-        client.chat.completions.create(
-            model="gpt-3.5-turbo",
-            messages=[{"role": "user", "content": "test"}],
-            max_tokens=1
-        )
-        return True, "OpenAI API key is valid! 🎉"
-    except Exception as e:
-        return False, f"OpenAI API key validation failed: {str(e)}"
-
-def validate_etherscan_key(api_key: str) -> Tuple[bool, str]:
-    """Validate Etherscan API key by checking the API."""
-    if not api_key:
-        return False, "Etherscan API key is required!"
-    
-    async def validate():
-        client = EtherscanClient(api_key)
-        params = {
-            "module": "stats",
-            "action": "ethsupply"
-        }
-        result = await client.fetch_data(params)
-        return "error" not in result
-    
-    try:
-        result = asyncio.run(validate())
-        return (True, "Etherscan API key is valid! 🎉") if result else (False, "Invalid Etherscan API key")
-    except Exception as e:
-        return False, f"Etherscan API key validation failed: {str(e)}"
 
-def create_visualizations(portfolio: Dict[str, Any]) -> Dict[str, go.Figure]:
-    """Generate Plotly visualizations for portfolio and NFTs."""
-    figures = {}
-    
     try:
-        # Portfolio Distribution
-        assets = []
-        values = []
+        openai.api_key = api_key
         
-        # Add ETH
-        if portfolio["eth_balance"] > 0:
-            assets.append("Ethereum")
-            values.append(float(portfolio["eth_balance"]))
+        # Validate existing history entries
+        validated_history = []
+        for msg in history:
+            if isinstance(msg, dict) and "role" in msg and "content" in msg:
+                validated_history.append({"role": msg["role"], "content": msg["content"]})
         
-        # Add tokens
-        for token in portfolio["tokens"]:
-            assets.append(f"{token['name']} ({token['symbol']})")
-            values.append(float(token["balance"]))
+        # Build the messages for OpenAI Chat
+        messages = [
+            {"role": "system", "content": LOSSDOG_PROMPT},
+            {"role": "system", "content": f"Resume Content:\n{markdown_text}"}
+        ] + validated_history
         
-        if assets and values:
-            portfolio_fig = go.Figure(data=[go.Pie(
-                labels=assets,
-                values=values,
-                hole=0.3,
-                textinfo='label+percent'
-            )])
-            portfolio_fig.update_layout(
-                title="Portfolio Distribution",
-                showlegend=True
-            )
-            figures["portfolio"] = portfolio_fig
-
-        # NFT Collections
-        nfts = portfolio["nfts"]
-        if nfts:
-            collections = {}
-            for nft in nfts:
-                collection = nft["name"]
-                collections[collection] = collections.get(collection, 0) + 1
-            
-            if collections:
-                nft_fig = go.Figure(data=[go.Bar(
-                    x=list(collections.keys()),
-                    y=list(collections.values()),
-                    text=list(collections.values()),
-                    textposition='auto',
-                )])
-                nft_fig.update_layout(
-                    title="NFT Collections",
-                    xaxis_title="Collection",
-                    yaxis_title="Count",
-                    showlegend=False
-                )
-                figures["nfts"] = nft_fig
+        # Add the new user message at the end
+        messages.append({"role": "user", "content": user_message})
 
-    except Exception as e:
-        print(f"Error generating visualizations: {str(e)}")
-    
-    return figures
-
-async def process_message(
-    message: str,
-    openai_key: str,
-    etherscan_key: str,
-    history: List[Dict[str, str]]
-) -> Tuple[List[Dict[str, str]], Optional[go.Figure], Optional[go.Figure], str]:
-    """Process user input, analyze wallet, and generate responses."""
-    if not message.strip():
-        return history, None, None, ""
-
-    # Check for Ethereum wallet address
-    match = re.search(ETHEREUM_ADDRESS_REGEX, message)
-    if match:
-        address = match.group(0)
-        client = EtherscanClient(etherscan_key)
-        
-        try:
-            portfolio = await client.get_portfolio(address)
-            visuals = create_visualizations(portfolio)
-            
-            # Create summary text
-            summary = []
-            summary.append(f"📊 Portfolio Summary for {address[:8]}...{address[-6:]}")
-            summary.append(f"💎 ETH Balance: {portfolio['eth_balance']:.4f} ETH")
-            summary.append(f"🪙 Tokens: {len(portfolio['tokens'])} different tokens")
-            summary.append(f"🎨 NFTs: {len(portfolio['nfts'])} NFTs in collection")
-            
-            bot_message = "\n".join(summary)
-            
-            history.append({"role": "user", "content": message})
-            history.append({"role": "assistant", "content": bot_message})
-            return history, visuals.get("portfolio"), visuals.get("nfts"), ""
-            
-        except Exception as e:
-            error_message = f"Error analyzing wallet: {str(e)}"
-            history.append({"role": "user", "content": message})
-            history.append({"role": "assistant", "content": error_message})
-            return history, None, None, ""
-
-    # Generate response using OpenAI
-    try:
-        client = openai.OpenAI(api_key=openai_key)
-        response = client.chat.completions.create(
+        # Create ChatCompletion
+        response = openai.ChatCompletion.create(
             model="gpt-4o-mini",
-            messages=[
-                {"role": "system", "content": SYSTEM_PROMPT},
-                {"role": "user", "content": message}
-            ],
-            temperature=0.7,
-            max_tokens=150
+            messages=messages,
+            max_tokens=4000  # You can adjust this as needed
         )
-        bot_message = response.choices[0].message.content
-        history.append({"role": "user", "content": message})
-        history.append({"role": "assistant", "content": bot_message})
-        return history, None, None, ""
+        assistant_response = response.choices[0].message.content
+        
+        # Update local (Gradio) history
+        validated_history.append({"role": "user", "content": user_message})
+        validated_history.append({"role": "assistant", "content": assistant_response})
+
+
+
+        return validated_history
     except Exception as e:
-        error_message = f"Error generating response: {str(e)}"
-        history.append({"role": "user", "content": message})
-        history.append({"role": "assistant", "content": error_message})
-        return history, None, None, ""
-
-###############################################################################
-#                               GRADIO UI                                       #
-###############################################################################
-
-def create_interface() -> gr.Blocks:
-    """Create and return the Gradio interface for the application."""
-    with gr.Blocks(theme=gr.themes.Soft()) as demo:
+        # Append the error as an assistant message (for visibility)
+        history.append({"role": "assistant", "content": f"Error: {str(e)}"})
+        return history
+
+def create_demo():
+    """Build the Gradio app."""
+    with gr.Blocks(css="#resume-preview {height:300px; overflow-y:auto; border:1px solid #ccc; padding:10px;}") as demo:
         gr.Markdown("""
-        # 🐕 LOSS DOG: Blockchain Wallet Analyzer
-        
-        Welcome to LOSS DOG - Your friendly blockchain analysis companion!
-        - Enter your API keys below to get started
-        - Input an Ethereum wallet address or ask questions about crypto
-        - View portfolio distribution and NFT collection visualizations
+        # 🐕 LOSS Dog: AI-Powered Resume Advisor
+
+        **Steps**:
+        1. Upload your resume (PDF/TXT). It will appear in a scrollable box on the right.
+        2. Ask any questions or request feedback. LOSS Dog always references the uploaded resume.
+        3. Enjoy a back-and-forth conversation to refine your resume!
         """)
 
-        # API Keys and Validation
-        with gr.Row():
-            with gr.Column():
-                openai_key = gr.Textbox(
-                    label="OpenAI API Key",
-                    type="password",
-                    placeholder="Enter your OpenAI API key...",
-                    show_label=True
-                )
-            with gr.Column():
-                etherscan_key = gr.Textbox(
-                    label="Etherscan API Key",
-                    type="password",
-                    placeholder="Enter your Etherscan API key...",
-                    show_label=True
-                )
-
-        # Validation Status and Button
-        validation_status = gr.Textbox(
-            label="Validation Status",
-            interactive=False,
-            show_label=True
-        )
-        validate_btn = gr.Button("Validate API Keys", variant="primary")
-
-        # Chat Interface
-        chatbot = gr.Chatbot(
-            label="Chat History",
-            show_label=True,
-            height=400,
-            type="messages"
+        # API Key
+        api_key = gr.Textbox(
+            label="OpenAI API Key",
+            placeholder="Enter your OpenAI API key...",
+            type="password"
         )
 
-        # Visualization Area
+        # Layout
+        with gr.Row():
+            with gr.Column(scale=3):
+                chatbot = gr.Chatbot(label="Chat with LOSS Dog", type="messages")
+            with gr.Column(scale=1):
+                markdown_preview = gr.Markdown(label="Resume Preview", elem_id="resume-preview")
+
+        # User Input
         with gr.Row():
-            portfolio_plot = gr.Plot(label="Portfolio Distribution")
-            nft_plot = gr.Plot(label="NFT Collections")
+            user_input = gr.Textbox(label="Your Message", lines=1)
+            send_button = gr.Button("Send 🐾")
 
-        # Message Input
+        # File Upload
         with gr.Row():
-            msg_input = gr.Textbox(
-                label="Message",
-                placeholder="Enter Ethereum wallet address or ask about crypto...",
-                show_label=True
-            )
-            send_btn = gr.Button("Send", variant="primary")
-
-        # Set initial state
-        msg_input.interactive = False
-        send_btn.interactive = False
-
-        def validate_keys(openai_k: str, etherscan_k: str) -> Tuple[str, gr.update, gr.update]:
-            """Validate both API keys and return status message and interactive states."""
-            openai_valid, openai_msg = validate_openai_key(openai_k)
-            etherscan_valid, etherscan_msg = validate_etherscan_key(etherscan_k)
+            upload = gr.File(label="Upload Your Resume (PDF or TXT)")
+
+        # States
+        history_state = gr.State([])  # Chat History
+        markdown_state = gr.State("") # Stored resume text in Markdown
+
+        # 1) File Upload Handler
+        def handle_upload(file, api_key):
+            """
+            Extract text -> convert to Markdown -> display in the right pane.
+            We do NOT modify the chat history here; user can start fresh or continue.
+            """
+            if not file:
+                return "No file uploaded.", gr.update(value=[])
             
-            if openai_valid and etherscan_valid:
-                return (
-                    "✅ Both API keys are valid! You can start chatting now.",
-                    gr.update(interactive=True),
-                    gr.update(interactive=True)
-                )
-            else:
-                return (
-                    f"❌ Validation failed:\n{openai_msg}\n{etherscan_msg}",
-                    gr.update(interactive=False),
-                    gr.update(interactive=False)
-                )
-
-        # Event Handlers
-        validate_btn.click(
-            fn=validate_keys,
-            inputs=[openai_key, etherscan_key],
-            outputs=[validation_status, msg_input, send_btn]
+            text = extract_text_from_file(file.name, file.name)
+            if text.startswith("Error"):
+                # Show error in preview
+                return text, gr.update(value=[])
+            
+            resume_md = convert_to_markdown(text)
+            # Keep the conversation? Up to you. We'll keep existing conversation.
+            return resume_md, gr.update(value=[])
+
+        # 2) Chat Message Handler
+        def handle_message(user_message, api_key, markdown_text, history):
+            """
+            Called when the user sends a new message. We pass the stored resume + history.
+            """
+            updated_history = interact_with_lossdog(user_message, markdown_text, api_key, history)
+
+            return updated_history, updated_history
+
+        # Link File Upload -> handle_upload
+        upload.change(
+            handle_upload,
+            inputs=[upload, api_key],
+            outputs=[markdown_preview, history_state]
         )
 
-        async def handle_message(message: str, openai_k: str, etherscan_k: str, chat_history: List[Dict[str, str]]):
-            """Async wrapper for process_message"""
-            return await process_message(message, openai_k, etherscan_k, chat_history)
-
-        send_btn.click(
-            fn=handle_message,
-            inputs=[msg_input, openai_key, etherscan_key, chatbot],
-            outputs=[chatbot, portfolio_plot, nft_plot, msg_input]
+        # Link Send Button -> handle_message
+        send_button.click(
+            handle_message,
+            inputs=[user_input, api_key, markdown_state, history_state],
+            outputs=[chatbot, history_state]
         )
 
-        # Allow sending message with Enter key
-        msg_input.submit(
-            fn=handle_message,
-            inputs=[msg_input, openai_key, etherscan_key, chatbot],
-            outputs=[chatbot, portfolio_plot, nft_plot, msg_input]
+        # Any time the user uploads a file, also store the resume text in markdown_state
+        # so subsequent messages can see it.
+        def store_resume_in_state(markdown_content):
+            return markdown_content
+
+        # We'll create a small chain that ensures markdown_preview -> markdown_state
+        markdown_preview.change(
+            store_resume_in_state,
+            inputs=[markdown_preview],
+            outputs=[markdown_state]
         )
 
     return demo
 
-###############################################################################
-#                             MAIN EXECUTION                                    #
-###############################################################################
-
-if __name__ == "__main__":
-    interface = create_interface()
-    interface.queue()  # Enable queuing for handling async operations
-    interface.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        share=True
-    )
+if __name__ == "__main__":