Delete fixed-audit-app.py

fixed-audit-app.py

@@ -1,373 +0,0 @@
-import gradio as gr
-import os
-import tempfile
-import pandas as pd
-import boto3
-from langchain_community.document_loaders import PyPDFLoader, Docx2txtLoader, UnstructuredPowerPointLoader, UnstructuredExcelLoader
-from langchain.text_splitter import RecursiveCharacterTextSplitter
-from langchain_community.embeddings import OpenAIEmbeddings
-from langchain_community.vectorstores import FAISS
-from langchain.chains import RetrievalQA
-from langchain_aws import ChatBedrock  # Updated import
-from langchain_openai import ChatOpenAI
-from langchain_ollama import OllamaLLM  # Updated import
-import logging
-from huggingface_hub import HfApi
-from huggingface_hub.utils import RepositoryNotFoundError
-
-# Set up logging
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(levelname)s - %(message)s'
-)
-
-def get_api_keys():
-    """Get API keys from Hugging Face Spaces secrets."""
-    aws_access_key = os.environ.get("AWS_ACCESS_KEY_ID")
-    aws_secret_key = os.environ.get("AWS_SECRET_ACCESS_KEY")
-    aws_region = os.environ.get("AWS_REGION", "us-east-1")  # Default to us-east-1 if not specified
-    openai_key = os.environ.get("OPENAI_API_KEY")
-    
-    if not aws_access_key or not aws_secret_key or not openai_key:
-        return {
-            "status": "error",
-            "message": "Please set AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, and OPENAI_API_KEY in your Hugging Face Space secrets."
-        }
-    
-    return {
-        "status": "success",
-        "aws_access_key": aws_access_key,
-        "aws_secret_key": aws_secret_key,
-        "aws_region": aws_region,
-        "openai_key": openai_key
-    }
-
-class AuditAgent:
-    def __init__(self, model_name, provider):
-        self.model_name = model_name
-        self.provider = provider
-        self.document_store = None
-        
-        # Get API keys
-        api_keys = get_api_keys()
-        if api_keys["status"] == "error":
-            raise ValueError(api_keys["message"])
-        
-        if provider == "bedrock":
-            # Initialize AWS Bedrock client
-            try:
-                self.bedrock_client = boto3.client(
-                    service_name="bedrock-runtime",
-                    aws_access_key_id=api_keys["aws_access_key"],
-                    aws_secret_access_key=api_keys["aws_secret_key"],
-                    region_name=api_keys["aws_region"]
-                )
-                
-                self.llm = ChatBedrock(
-                    client=self.bedrock_client,
-                    model_id="anthropic.claude-3-sonnet-20240229-v1:0",
-                    model_kwargs={"temperature": 0.2}
-                )
-            except Exception as e:
-                logging.error(f"Bedrock initialization error: {str(e)}")
-                raise ValueError(f"Bedrock initialization error: {str(e)}")
-        elif provider == "openai":
-            self.llm = ChatOpenAI(
-                model_name=model_name,
-                openai_api_key=api_keys["openai_key"],
-                temperature=0.2
-            )
-        elif provider == "ollama":
-            try:
-                self.llm = OllamaLLM(model=model_name)
-            except Exception as e:
-                raise ValueError(f"Failed to initialize Ollama model: {str(e)}")
-        else:
-            raise ValueError(f"Unsupported provider: {provider}")
-
-    def process_query(self, query):
-        """Process a general query or numerical problem."""
-        if not query.strip():
-            return "Please provide a non-empty query."
-            
-        system_prompt = """You are an expert auditor assistant. Provide clear, detailed responses to audit-related queries. 
-        For numerical problems, show your calculations step by step. Always consider relevant accounting standards and auditing principles."""
-        
-        try:
-            if self.provider == "bedrock":
-                response = self.llm.invoke(
-                    f"{system_prompt}\n\nUser: {query}\nAssistant:"
-                )
-                return response.content
-            elif self.provider == "openai":
-                response = self.llm.invoke(
-                    [
-                        {"role": "system", "content": system_prompt},
-                        {"role": "user", "content": query}
-                    ]
-                )
-                return response.content
-            else:  # Ollama
-                full_prompt = f"{system_prompt}\n\nUser: {query}\nAssistant:"
-                response = self.llm.invoke(full_prompt)
-                return response
-        except Exception as e:
-            return f"Error processing query: {str(e)}"
-
-    def process_documents(self, file):
-        """Process uploaded documents and create a vector store."""
-        if not file:
-            return "Please upload a file"
-            
-        try:
-            documents = []
-            
-            # Create temporary directory
-            temp_dir = tempfile.mkdtemp()
-            temp_path = os.path.join(temp_dir, file.name)
-            
-            # Save uploaded file
-            with open(temp_path, 'wb') as f:
-                f.write(file.read())
-            
-            # Get file extension and check it's supported
-            file_ext = os.path.splitext(file.name.lower())[1]
-            supported_exts = ['.pdf', '.docx', '.pptx', '.xlsx', '.xls']
-            
-            if file_ext not in supported_exts:
-                os.remove(temp_path)
-                os.rmdir(temp_dir)
-                return f"Unsupported file type. Please upload one of: {', '.join(supported_exts)}"
-            
-            # Select appropriate loader
-            if file_ext == '.pdf':
-                loader = PyPDFLoader(temp_path)
-            elif file_ext == '.docx':
-                loader = Docx2txtLoader(temp_path)
-            elif file_ext == '.pptx':
-                loader = UnstructuredPowerPointLoader(temp_path)
-            elif file_ext in ['.xlsx', '.xls']:
-                loader = UnstructuredExcelLoader(temp_path)
-            
-            # Load and process document
-            documents.extend(loader.load())
-            
-            # Cleanup
-            os.remove(temp_path)
-            os.rmdir(temp_dir)
-            
-            # Split documents
-            text_splitter = RecursiveCharacterTextSplitter(
-                chunk_size=1000,
-                chunk_overlap=200
-            )
-            splits = text_splitter.split_documents(documents)
-            
-            # Create vector store
-            api_keys = get_api_keys()
-            embeddings = OpenAIEmbeddings(openai_api_key=api_keys["openai_key"])
-            self.document_store = FAISS.from_documents(splits, embeddings)
-            
-            return "Document processed successfully"
-        except Exception as e:
-            return f"Error processing document: {str(e)}"
-
-    def query_documents(self, query):
-        """Query the processed documents."""
-        if not self.document_store:
-            return "Please upload and process documents first"
-        
-        try:
-            qa_chain = RetrievalQA.from_chain_type(
-                llm=self.llm,
-                chain_type="stuff",
-                retriever=self.document_store.as_retriever(),
-                return_source_documents=True
-            )
-            
-            response = qa_chain({"query": query})
-            
-            result = response['result']
-            source_docs = response.get('source_documents', [])
-            
-            if source_docs:
-                result += "\n\nSources:\n"
-                for i, doc in enumerate(source_docs, 1):
-                    result += f"{i}. {doc.metadata.get('source', 'Unknown source')}\n"
-            
-            return result
-        except Exception as e:
-            return f"Error querying documents: {str(e)}"
-
-# Available LLM configurations
-llm_configs = {
-    "claude-3-sonnet": {
-        "name": "anthropic.claude-3-sonnet-20240229-v1:0",
-        "provider": "bedrock",
-        "description": "Balanced performance (AWS Bedrock)"
-    },
-    "gpt-4": {
-        "name": "gpt-4",
-        "provider": "openai",
-        "description": "Advanced reasoning"
-    },
-    "gpt-3.5-turbo": {
-        "name": "gpt-3.5-turbo",
-        "provider": "openai",
-        "description": "Fast responses"
-    },
-    "openorca-mini": {
-        "name": "openorca-mini",
-        "provider": "ollama",
-        "description": "Local lightweight model"
-    }
-}
-
-def create_interface():
-    # Check API keys first
-    api_keys = get_api_keys()
-    if api_keys["status"] == "error":
-        with gr.Blocks(theme=gr.themes.Base()) as demo:
-            gr.Markdown("# ⚠️ Configuration Error")
-            gr.Markdown(api_keys["message"])
-            gr.Markdown("""
-            To set up your Hugging Face Space:
-            1. Go to your Space's Settings
-            2. Add your API keys as secrets:
-               - AWS_ACCESS_KEY_ID
-               - AWS_SECRET_ACCESS_KEY
-               - AWS_REGION
-               - OPENAI_API_KEY
-            3. Restart your Space
-            """)
-        return demo
-
-    # Initialize agents - changed to initialize lazily to avoid startup errors
-    audit_agents = {}
-    
-    with gr.Blocks(theme=gr.themes.Base()) as demo:
-        gr.Markdown("# 🔍 Amy - Your Audit Copilot")
-        
-        with gr.Row():
-            with gr.Column(scale=1):
-                file_upload = gr.File(
-                    label="Upload Audit Documents",
-                    file_types=["pdf", "docx", "pptx", "xlsx", "xls"]
-                )
-        
-        # Use tabs for model selection instead of dropdown
-        with gr.Tabs() as model_tabs:
-            model_tab_dict = {}
-            for model_id, config in llm_configs.items():
-                with gr.Tab(f"{model_id} - {config['description']}") as tab:
-                    model_tab_dict[model_id] = tab
-        
-        with gr.Tabs() as feature_tabs:
-            with gr.Tab("💬 General Chat"):
-                chat_input = gr.Textbox(
-                    lines=3,
-                    label="Ask your audit question",
-                    placeholder="Enter your question here..."
-                )
-                chat_button = gr.Button("Send")
-                chat_output = gr.Markdown(label="Response")
-            
-            with gr.Tab("🔢 Numerical Problem"):
-                problem_input = gr.Textbox(
-                    lines=5,
-                    label="Describe the Problem",
-                    placeholder="Enter your numerical audit problem..."
-                )
-                solve_button = gr.Button("Solve")
-                solution_output = gr.Markdown(label="Solution")
-            
-            with gr.Tab("📑 Document Query"):
-                query_input = gr.Textbox(
-                    lines=3,
-                    label="Query Documents",
-                    placeholder="Ask about your uploaded documents..."
-                )
-                query_button = gr.Button("Query")
-                query_output = gr.Markdown(label="Response")
-                
-        # Status indicator for initialization and operations
-        status_message = gr.Textbox(label="Status", value="Ready")
-        
-        # Function to get the currently selected model
-        def get_selected_model():
-            for model_id, tab in model_tab_dict.items():
-                if tab.is_selected:
-                    return model_id
-            return "claude-3-sonnet"  # Default fallback
-        
-        # Lazy initialization of models when first used
-        def get_or_initialize_agent(model_name):
-            if model_name not in audit_agents:
-                try:
-                    status_message.update(value=f"Initializing {model_name}...")
-                    config = llm_configs[model_name]
-                    audit_agents[model_name] = AuditAgent(config["name"], config["provider"])
-                    status_message.update(value=f"{model_name} initialized successfully")
-                except Exception as e:
-                    status_message.update(value=f"Error initializing {model_name}: {str(e)}")
-                    return None
-            return audit_agents[model_name]
-
-        def handle_chat(query):
-            model_name = get_selected_model()
-            agent = get_or_initialize_agent(model_name)
-            if not agent:
-                return f"Could not initialize {model_name}. Please check logs for details."
-            return agent.process_query(query)
-
-        def handle_problem(problem):
-            model_name = get_selected_model()
-            agent = get_or_initialize_agent(model_name)
-            if not agent:
-                return f"Could not initialize {model_name}. Please check logs for details."
-            return agent.process_query(problem)
-
-        def handle_file_upload(file):
-            model_name = get_selected_model()
-            agent = get_or_initialize_agent(model_name)
-            if not agent:
-                return f"Could not initialize {model_name}. Please check logs for details."
-            return agent.process_documents(file)
-
-        def handle_query(query):
-            model_name = get_selected_model()
-            agent = get_or_initialize_agent(model_name)
-            if not agent:
-                return f"Could not initialize {model_name}. Please check logs for details."
-            return agent.query_documents(query)
-
-        # Set up event handlers
-        chat_button.click(
-            handle_chat,
-            inputs=[chat_input],
-            outputs=[chat_output]
-        )
-        
-        solve_button.click(
-            handle_problem,
-            inputs=[problem_input],
-            outputs=[solution_output]
-        )
-        
-        file_upload.upload(
-            handle_file_upload,
-            inputs=[file_upload],
-            outputs=[status_message]
-        )
-        
-        query_button.click(
-            handle_query,
-            inputs=[query_input],
-            outputs=[query_output]
-        )
-
-    return demo
-
-if __name__ == "__main__":
-    demo = create_interface()
-    demo.launch(share=False)  # Set share=False on Hugging Face Spaces