save

app_with_debug.py

@@ -0,0 +1,183 @@
+import os
+import gradio as gr
+import asyncio
+import tempfile
+import traceback
+from dotenv import find_dotenv, load_dotenv
+
+# Load environment variables
+load_dotenv(find_dotenv())
+
+print("🔍 DEBUG: Starting DataForge with debug information")
+print(f"🔍 DEBUG: Python version: {os.sys.version}")
+print(f"🔍 DEBUG: Working directory: {os.getcwd()}")
+
+# Import with debug info
+print("🔍 DEBUG: Importing langchain...")
+try:
+    from langchain.chat_models import init_chat_model
+    print("✅ DEBUG: langchain imported successfully")
+except Exception as e:
+    print(f"❌ DEBUG: langchain import failed: {e}")
+    traceback.print_exc()
+
+print("🔍 DEBUG: Importing agent...")
+try:
+    from agent import FileInjectedPyodideSandbox, create_pyodide_eval_fn, create_codeact
+    print("✅ DEBUG: agent imported successfully")
+except Exception as e:
+    print(f"❌ DEBUG: agent import failed: {e}")
+    traceback.print_exc()
+
+print("🔍 DEBUG: Importing graph...")
+try:
+    from graph import analyze_file_with_guidance_sync, guided_analysis_graph
+    print("✅ DEBUG: graph imported successfully")
+except Exception as e:
+    print(f"❌ DEBUG: graph import failed: {e}")
+    traceback.print_exc()
+
+# Initialize model with debug info
+print("🔍 DEBUG: Initializing model...")
+try:
+    codeact_model = init_chat_model("gpt-4.1-2025-04-14", model_provider="openai")
+    print("✅ DEBUG: Model initialized successfully")
+except Exception as e:
+    print(f"❌ DEBUG: Model initialization failed: {e}")
+    traceback.print_exc()
+
+# Store uploaded file path globally
+uploaded_file_path = None
+
+def handle_file_upload(file):
+    """Handle file upload and store the path globally"""
+    global uploaded_file_path
+    try:
+        print(f"🔍 DEBUG: File upload called with: {file}")
+        if file is not None:
+            uploaded_file_path = file
+            filename = os.path.basename(file)
+            print(f"✅ DEBUG: File uploaded: {filename}")
+            return f"✅ File uploaded successfully: {filename}"
+        else:
+            uploaded_file_path = None
+            print("❌ DEBUG: No file provided")
+            return "❌ No file uploaded"
+    except Exception as e:
+        uploaded_file_path = None
+        print(f"❌ DEBUG: Upload error: {e}")
+        traceback.print_exc()
+        return f"❌ Upload error: {str(e)}"
+
+def analyze_file_with_question(user_question):
+    """
+    Analyze the uploaded file using the guided approach with debug info
+    """
+    global uploaded_file_path
+    
+    try:
+        print(f"🔍 DEBUG: Analysis called with question: {user_question}")
+        print(f"🔍 DEBUG: Uploaded file path: {uploaded_file_path}")
+        
+        if not uploaded_file_path or not os.path.exists(uploaded_file_path):
+            print("❌ DEBUG: No file available for analysis")
+            return "❌ No file uploaded or file not found. Please upload a file first."
+        
+        if not user_question or user_question.strip() == "":
+            user_question = "Provide a comprehensive analysis of this file including security, performance, and data insights."
+        
+        print("🔍 DEBUG: Calling analyze_file_with_guidance_sync...")
+        result = analyze_file_with_guidance_sync(uploaded_file_path, user_question)
+        print(f"✅ DEBUG: Analysis completed, result length: {len(result) if result else 0}")
+        return result
+        
+    except Exception as e:
+        print(f"❌ DEBUG: Analysis error: {e}")
+        traceback.print_exc()
+        return f"❌ Error in guided analysis: {str(e)}\n\nFull traceback:\n{traceback.format_exc()}"
+
+print("🔍 DEBUG: Creating Gradio interface...")
+
+# Create the Gradio interface with debug wrapper
+try:
+    with gr.Blocks(title="DataForge - AI-Powered File Analysis (Debug Mode)") as demo:
+        gr.Markdown("# 🔍 DataForge - AI-Powered File Analysis (Debug Mode)")
+        gr.Markdown("""
+        **This is a debug version to help identify Hugging Face Spaces deployment issues.**
+        
+        Upload any file and ask specific questions for targeted AI analysis.
+        """)
+        
+        with gr.Row():
+            with gr.Column(scale=1):
+                gr.Markdown("### 📤 File Upload")
+                file_upload = gr.File(
+                    label="Upload File for Analysis",
+                    type="filepath"
+                )
+                upload_status = gr.Textbox(
+                    label="Upload Status",
+                    value="No file uploaded",
+                    interactive=False
+                )
+                
+                gr.Markdown("### ❓ Ask Your Question")
+                user_question = gr.Textbox(
+                    label="Your Question about the File",
+                    placeholder="What would you like to know about this file?",
+                    lines=4,
+                    value=""
+                )
+                
+                analyze_btn = gr.Button("🔍 Run Analysis (Debug)", variant="primary", size="lg")
+                
+            with gr.Column(scale=2):
+                analysis_output = gr.Textbox(
+                    label="📊 Analysis Results (Debug Mode)",
+                    lines=25,
+                    max_lines=35,
+                    placeholder="Upload a file, type your question, and click 'Run Analysis' to see results...",
+                    interactive=False
+                )
+        
+        # Event handlers
+        file_upload.change(
+            fn=handle_file_upload,
+            inputs=[file_upload],
+            outputs=[upload_status]
+        )
+        
+        analyze_btn.click(
+            fn=analyze_file_with_question,
+            inputs=[user_question],
+            outputs=[analysis_output]
+        )
+        
+        gr.Markdown("---")
+        gr.Markdown("## 🐞 Debug Information")
+        gr.Markdown("""
+        This debug version includes:
+        - Detailed import and initialization logging
+        - Exception tracebacks
+        - Step-by-step execution tracking
+        - Version and environment information
+        
+        Check the console/logs for detailed debug output.
+        """)
+    
+    print("✅ DEBUG: Gradio interface created successfully")
+    
+except Exception as e:
+    print(f"❌ DEBUG: Gradio interface creation failed: {e}")
+    traceback.print_exc()
+    raise
+
+if __name__ == "__main__":
+    print("🔍 DEBUG: Starting application launch...")
+    try:
+        demo.launch()
+        print("✅ DEBUG: Application launched successfully")
+    except Exception as e:
+        print(f"❌ DEBUG: Application launch failed: {e}")
+        traceback.print_exc()
+        raise 

debug_app.py

@@ -0,0 +1,147 @@
+import os
+import gradio as gr
+import tempfile
+from dotenv import find_dotenv, load_dotenv
+
+# Load environment variables
+load_dotenv(find_dotenv())
+
+# Store uploaded file path globally
+uploaded_file_path = None
+
+def handle_file_upload(file):
+    """Handle file upload and store the path globally"""
+    global uploaded_file_path
+    try:
+        if file is not None:
+            uploaded_file_path = file
+            filename = os.path.basename(file)
+            return f"✅ File uploaded successfully: {filename}"
+        else:
+            uploaded_file_path = None
+            return "❌ No file uploaded"
+    except Exception as e:
+        uploaded_file_path = None
+        return f"❌ Upload error: {str(e)}"
+
+def simple_file_analysis(user_question):
+    """
+    Simple file analysis without complex schemas - for debugging
+    """
+    global uploaded_file_path
+    
+    try:
+        if not uploaded_file_path or not os.path.exists(uploaded_file_path):
+            return "❌ No file uploaded or file not found. Please upload a file first."
+        
+        if not user_question or user_question.strip() == "":
+            user_question = "Provide basic analysis of this file."
+        
+        # Basic file info without complex processing
+        file_size = os.path.getsize(uploaded_file_path)
+        filename = os.path.basename(uploaded_file_path)
+        
+        # Read first few lines
+        try:
+            with open(uploaded_file_path, 'r', encoding='utf-8') as f:
+                first_lines = []
+                for i, line in enumerate(f):
+                    if i >= 5:
+                        break
+                    first_lines.append(line.rstrip())
+        except Exception as e:
+            first_lines = [f"Error reading file: {str(e)}"]
+        
+        result = f"""
+📊 Basic File Analysis Results:
+
+📁 File Information:
+- Name: {filename}
+- Size: {file_size} bytes
+- Path: {uploaded_file_path}
+
+❓ Your Question: {user_question}
+
+📝 First 5 lines:
+{chr(10).join(first_lines)}
+
+✅ This is a debug version to test Gradio deployment.
+If you see this, the basic Gradio functionality works.
+"""
+        return result
+        
+    except Exception as e:
+        return f"❌ Error in analysis: {str(e)}"
+
+# Create a minimal Gradio interface for debugging
+with gr.Blocks(title="DataForge Debug - Basic File Analysis") as demo:
+    gr.Markdown("# 🔍 DataForge Debug Version")
+    gr.Markdown("""
+    **This is a debug version to test Gradio deployment issues.**
+    
+    This version removes complex Pydantic models and LangGraph processing 
+    to isolate the schema generation issue in Hugging Face Spaces.
+    """)
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            gr.Markdown("### 📤 File Upload")
+            file_upload = gr.File(
+                label="Upload File for Basic Analysis",
+                type="filepath"
+            )
+            upload_status = gr.Textbox(
+                label="Upload Status",
+                value="No file uploaded",
+                interactive=False
+            )
+            
+            gr.Markdown("### ❓ Ask Your Question")
+            user_question = gr.Textbox(
+                label="Your Question about the File",
+                placeholder="What would you like to know about this file?",
+                lines=3,
+                value=""
+            )
+            
+            analyze_btn = gr.Button("🔍 Run Basic Analysis", variant="primary")
+        
+        with gr.Column(scale=2):
+            analysis_output = gr.Textbox(
+                label="📊 Basic Analysis Results",
+                lines=20,
+                placeholder="Upload a file and click 'Run Basic Analysis' to see results...",
+                interactive=False
+            )
+    
+    # Event handlers
+    file_upload.change(
+        fn=handle_file_upload,
+        inputs=[file_upload],
+        outputs=[upload_status]
+    )
+    
+    analyze_btn.click(
+        fn=simple_file_analysis,
+        inputs=[user_question],
+        outputs=[analysis_output]
+    )
+    
+    gr.Markdown("---")
+    gr.Markdown("""
+    ## 🐞 Debug Information
+    
+    **Purpose**: This debug version helps identify if the issue is related to:
+    - ✅ Basic Gradio functionality (this should work)
+    - ❌ Complex Pydantic models used in the full version
+    - ❌ LangGraph state management
+    - ❌ Version conflicts between local and HF Spaces
+    
+    **Next Steps**: 
+    1. If this version works on HF Spaces, the issue is in complex schema handling
+    2. If this fails too, it's a basic Gradio/environment issue
+    """)
+
+if __name__ == "__main__":
+    print("Starting DataForge Debug application...")
+    demo.launch() 

requirements_debug.txt

@@ -0,0 +1,2 @@
+gradio
+python-dotenv 

version_check.py

@@ -0,0 +1,62 @@
+#!/usr/bin/env python3
+
+import sys
+import pkg_resources
+
+print("🔍 Version Information:")
+print(f"Python: {sys.version}")
+print()
+
+packages_to_check = [
+    'gradio', 'gradio-client', 'pydantic', 'pydantic-core', 
+    'langchain', 'langchain-core', 'langgraph', 'typing-extensions',
+    'fastapi', 'starlette', 'uvicorn'
+]
+
+for package in packages_to_check:
+    try:
+        version = pkg_resources.get_distribution(package).version
+        print(f"{package}: {version}")
+    except pkg_resources.DistributionNotFound:
+        print(f"{package}: NOT INSTALLED")
+    except Exception as e:
+        print(f"{package}: ERROR - {e}")
+
+print()
+print("🔍 Critical Type Checking:")
+try:
+    from typing_extensions import TypedDict
+    print("✅ TypedDict import successful")
+except Exception as e:
+    print(f"❌ TypedDict import failed: {e}")
+
+try:
+    from pydantic import BaseModel, Field
+    print("✅ Pydantic imports successful")
+    
+    # Test schema generation
+    class TestModel(BaseModel):
+        name: str = Field(description="Test field")
+    
+    schema = TestModel.model_json_schema()
+    print(f"✅ Pydantic schema generation successful: {type(schema)}")
+    
+    # Check for boolean values in schema
+    def check_schema_values(obj, path=""):
+        if isinstance(obj, dict):
+            for k, v in obj.items():
+                if isinstance(v, bool):
+                    print(f"🔍 Found boolean in schema at {path}.{k}: {v}")
+                elif isinstance(v, (dict, list)):
+                    check_schema_values(v, f"{path}.{k}")
+        elif isinstance(obj, list):
+            for i, item in enumerate(obj):
+                if isinstance(item, (dict, list)):
+                    check_schema_values(item, f"{path}[{i}]")
+    
+    check_schema_values(schema)
+    
+except Exception as e:
+    print(f"❌ Pydantic test failed: {e}")
+    import traceback
+    traceback.print_exc()