Upload app.py

app.py

@@ -53,8 +53,8 @@ HF_ENDPOINT_URL = "https://evxgv66ksxjlfrts.us-east-1.aws.endpoints.huggingface.
 HF_MODEL = "lmstudio-community/Llama-3.3-70B-Instruct-GGUF"  # Correct model name for your endpoint
 
 # AI Correction Configuration
-MAX_CORRECTION_ATTEMPTS = 3  # Maximum number of attempts to generate valid RDF
-ENABLE_VALIDATION_LOOP = True  # Set to False to disable validation loop for debugging
+MAX_CORRECTION_ATTEMPTS = 2  # Reduced from 3 to speed up processing
+ENABLE_VALIDATION_LOOP = False  # Disable validation loop to prevent hanging
 
 # OpenAI client configuration for the endpoint
 def get_openai_client():
@@ -168,7 +168,7 @@ def validate_rdf_tool(rdf_content: str, template: str = "monograph") -> dict:
             "conforms": False
         }
 
-def get_ai_suggestions(validation_results: str, rdf_content: str) -> str:
+def get_ai_suggestions(validation_results: str, rdf_content: str, include_warnings: bool = False) -> str:
     """
     Generate AI-powered fix suggestions for invalid RDF/XML.
     
@@ -178,6 +178,7 @@ def get_ai_suggestions(validation_results: str, rdf_content: str) -> str:
     Args:
         validation_results (str): The validation error messages
         rdf_content (str): The original RDF/XML content that failed validation
+        include_warnings (bool): Whether to include warnings in suggestions
     
     Returns:
         str: Detailed suggestions for fixing the RDF validation issues
@@ -205,8 +206,12 @@ def get_ai_suggestions(validation_results: str, rdf_content: str) -> str:
 {generate_manual_suggestions(validation_results)}
 """
         
+        severity_instruction = "Focus only on violations (errors) and ignore any warnings." if not include_warnings else "Address both violations and warnings."
+        
         prompt = f"""You are an expert in RDF/XML and SHACL validation. Analyze the following validation results and provide clear, actionable suggestions for fixing the RDF issues.
 
+{severity_instruction}
+
 Validation Results:
 {validation_results}
 
@@ -224,7 +229,7 @@ Format your response in a helpful, structured way using markdown."""
         # Make API call using OpenAI client
         print(f"🔄 Making API call to: {HF_ENDPOINT_URL}")
         print(f"🔄 Using model: {HF_MODEL}")
-        print(f"🔄 Client base_url: {client.base_url}")
+        print(f"🔄 Include warnings: {include_warnings}")
         
         chat_completion = client.chat.completions.create(
             model=HF_MODEL,
@@ -241,7 +246,7 @@ Format your response in a helpful, structured way using markdown."""
         
         print("✅ API call successful")
         generated_text = chat_completion.choices[0].message.content
-        return f"🤖 **AI-Powered Suggestions:**\n\n{generated_text}"
+        return f"🤖 **AI-Powered Suggestions ({('Violations + Warnings' if include_warnings else 'Violations Only')}):**\n\n{generated_text}"
         
     except Exception as e:
         logger.error(f"OpenAI/HF Inference Endpoint error: {str(e)}")
@@ -280,7 +285,7 @@ def extract_rdf_from_response(response: str) -> str:
     # If no code blocks found, return the response as-is
     return response
 
-def get_ai_correction(validation_results: str, rdf_content: str, template: str = 'monograph', max_attempts: int = None) -> str:
+def get_ai_correction(validation_results: str, rdf_content: str, template: str = 'monograph', max_attempts: int = None, include_warnings: bool = False) -> str:
     """
     Generate AI-powered corrected RDF/XML based on validation errors.
     
@@ -293,6 +298,7 @@ def get_ai_correction(validation_results: str, rdf_content: str, template: str =
         rdf_content (str): The original invalid RDF/XML content
         template (str): The validation template to use
         max_attempts (int): Maximum number of attempts to generate valid RDF (uses MAX_CORRECTION_ATTEMPTS if None)
+        include_warnings (bool): Whether to fix warnings in addition to violations
     
     Returns:
         str: Corrected RDF/XML that should pass validation
@@ -323,10 +329,26 @@ def get_ai_correction(validation_results: str, rdf_content: str, template: str =
 
 {generate_manual_correction_hints(validation_results, rdf_content)}"""
         
+        # Add timeout protection
+        import time
+        start_time = time.time()
+        timeout = 60  # 60 second timeout
+        
+        severity_instruction = "Fix only the violations (errors) and ignore any warnings." if not include_warnings else "Fix both violations and warnings."
+        
         # Try multiple attempts to generate valid RDF
         for attempt in range(max_attempts):
+            # Check timeout
+            if time.time() - start_time > timeout:
+                print(f"⏰ Timeout reached after {timeout} seconds")
+                break
+                
+            print(f"🔄 Correction attempt {attempt + 1}/{max_attempts}")
+            
             prompt = f"""You are an expert in RDF/XML. Fix the following RDF/XML based on the validation errors provided.
 
+{severity_instruction}
+
 Validation Errors:
 {validation_results}
 
@@ -342,53 +364,59 @@ Please provide the corrected RDF/XML that addresses all validation issues.
 - Add any missing required properties
 - Fix any syntax or structural issues"""
             
-            print(f"🔄 Correction attempt {attempt + 1}/{max_attempts}")
-            print(f"🔄 Using endpoint: {HF_ENDPOINT_URL}")
-            print(f"🔄 Using model: {HF_MODEL}")
-            
-            chat_completion = client.chat.completions.create(
-                model=HF_MODEL,
-                messages=[
-                    {
-                        "role": "user", 
-                        "content": prompt
-                    }
-                ],
-                max_tokens=2000,
-                temperature=0.3  # Lower temperature for more consistent output
-            )
-            
-            corrected_rdf = chat_completion.choices[0].message.content.strip()
-            
-            # Extract RDF content if it's wrapped in code blocks
-            corrected_rdf = extract_rdf_from_response(corrected_rdf)
-            
-            # Validate the corrected RDF
-            if VALIDATOR_AVAILABLE:
-                try:
-                    # Validate the corrected RDF using the same template
-                    conforms, new_results = validate_rdf(corrected_rdf.encode('utf-8'), template)
-                    
-                    if conforms:
-                        print(f"✅ Correction validated successfully on attempt {attempt + 1}")
-                        return f"""<!-- AI-generated correction validated successfully -->
-{corrected_rdf}"""
-                    else:
-                        print(f"❌ Correction attempt {attempt + 1} still has validation errors")
-                        # Update validation_results for next attempt
-                        validation_results = new_results
+            try:
+                chat_completion = client.chat.completions.create(
+                    model=HF_MODEL,
+                    messages=[
+                        {
+                            "role": "user", 
+                            "content": prompt
+                        }
+                    ],
+                    max_tokens=2000,
+                    temperature=0.3,
+                    timeout=30  # 30 second timeout per API call
+                )
+                
+                corrected_rdf = chat_completion.choices[0].message.content.strip()
+                
+                # Extract RDF content if it's wrapped in code blocks
+                corrected_rdf = extract_rdf_from_response(corrected_rdf)
+                
+                # Only validate if we have the validator and haven't hit timeout
+                if VALIDATOR_AVAILABLE and (time.time() - start_time < timeout - 10):
+                    try:
+                        # Quick validation check
+                        conforms, new_results = validate_rdf(corrected_rdf.encode('utf-8'), template)
                         
-                except Exception as e:
-                    print(f"⚠️ Error validating correction attempt {attempt + 1}: {str(e)}")
-                    # Continue to next attempt
-            else:
-                # If validator not available, return the first attempt
-                print("⚠️ Validator not available, returning unvalidated correction")
-                return corrected_rdf
-        
-        # All attempts failed
-        return f"""<!-- AI correction failed after {max_attempts} attempts to generate valid RDF -->
-<!-- The AI-generated corrections still contained validation errors -->
+                        if conforms:
+                            print(f"✅ Correction validated successfully on attempt {attempt + 1}")
+                            return f"""<!-- AI-generated correction validated successfully -->
+{corrected_rdf}"""
+                        else:
+                            print(f"❌ Correction attempt {attempt + 1} still has validation errors")
+                            # Update validation_results for next attempt
+                            validation_results = new_results
+                            
+                    except Exception as e:
+                        print(f"⚠️ Error validating correction attempt {attempt + 1}: {str(e)}")
+                        # If validation fails, return the correction anyway
+                        return f"""<!-- AI-generated correction (validation check failed) -->
+{corrected_rdf}"""
+                else:
+                    # If validator not available or timeout approaching, return the correction
+                    print("⚠️ Returning correction without validation")
+                    return f"""<!-- AI-generated correction (validation skipped) -->
+{corrected_rdf}"""
+                    
+            except Exception as api_error:
+                print(f"❌ API error on attempt {attempt + 1}: {str(api_error)}")
+                if attempt == max_attempts - 1:  # Last attempt
+                    raise api_error
+                continue
+        
+        # All attempts failed or timed out
+        return f"""<!-- AI correction failed after {max_attempts} attempts or timeout -->
 <!-- Please correct manually using the validation results as a guide -->
 
 {generate_manual_correction_hints(validation_results, rdf_content)}"""
@@ -461,7 +489,7 @@ MANUAL CORRECTION STEPS:
 5. Validate data types
 -->"""
 
-def validate_rdf_interface(rdf_content: str, template: str, use_ai: bool = True):
+def validate_rdf_interface(rdf_content: str, template: str, use_ai: bool = True, include_warnings: bool = False):
     """
     Main validation function for Gradio interface and MCP server.
     
@@ -473,6 +501,7 @@ def validate_rdf_interface(rdf_content: str, template: str, use_ai: bool = True)
         rdf_content (str): The RDF/XML content to validate
         template (str): Validation template to use ('monograph' or 'custom')
         use_ai (bool): Whether to enable AI-powered suggestions and corrections
+        include_warnings (bool): Whether to include warnings in AI corrections (violations only by default)
     
     Returns:
         tuple: (status, results_text, suggestions, corrected_rdf) containing:
@@ -493,16 +522,36 @@ def validate_rdf_interface(rdf_content: str, template: str, use_ai: bool = True)
     status = result["status"]
     results_text = result["results"]
     
+    # Filter results if warnings should be excluded
+    filtered_results = results_text
+    if not include_warnings and "Warning" in results_text:
+        # Split results into lines and filter out warnings
+        lines = results_text.split('\n')
+        filtered_lines = []
+        skip_until_next_section = False
+        
+        for line in lines:
+            if "Warning" in line and ("Constraint Violation" in line or "sh:Warning" in line):
+                skip_until_next_section = True
+            elif "Constraint Violation" in line and "Warning" not in line:
+                skip_until_next_section = False
+                filtered_lines.append(line)
+            elif not skip_until_next_section:
+                filtered_lines.append(line)
+        
+        filtered_results = '\n'.join(filtered_lines)
+    
     if result["conforms"]:
         suggestions = "✅ No issues found! Your RDF/XML is valid according to the selected template."
         corrected_rdf = "✅ Your RDF/XML is already valid - no corrections needed!"
     else:
         if use_ai:
-            suggestions = get_ai_suggestions(results_text, rdf_content)
-            corrected_rdf = get_ai_correction(results_text, rdf_content, template)
+            # Pass filtered results to AI functions
+            suggestions = get_ai_suggestions(filtered_results, rdf_content, include_warnings)
+            corrected_rdf = get_ai_correction(filtered_results, rdf_content, template, include_warnings=include_warnings)
         else:
-            suggestions = generate_manual_suggestions(results_text)
-            corrected_rdf = generate_manual_correction_hints(results_text, rdf_content)
+            suggestions = generate_manual_suggestions(filtered_results)
+            corrected_rdf = generate_manual_correction_hints(filtered_results, rdf_content)
     
     return status, results_text, suggestions, corrected_rdf
 
@@ -626,6 +675,12 @@ def create_interface():
                         value=True,
                         info="Enable AI-powered suggestions and corrections"
                     )
+                    
+                    include_warnings_checkbox = gr.Checkbox(
+                        label="Include Warnings",
+                        value=False,
+                        info="Include warnings in AI corrections (violations only by default)"
+                    )
                 
                 validate_btn = gr.Button("🔍 Validate RDF", variant="primary", size="lg")
                 
@@ -679,16 +734,16 @@ def create_interface():
         # Event handlers
         validate_btn.click(
             fn=validate_rdf_interface,
-            inputs=[rdf_input, template_dropdown, use_ai_checkbox],
+            inputs=[rdf_input, template_dropdown, use_ai_checkbox, include_warnings_checkbox],
             outputs=[status_output, results_output, suggestions_output, corrected_output]
         )
         
-        # Auto-validate on input change (debounced)
-        rdf_input.change(
-            fn=validate_rdf_interface,
-            inputs=[rdf_input, template_dropdown, use_ai_checkbox],
-            outputs=[status_output, results_output, suggestions_output, corrected_output]
-        )
+        # Remove auto-validation to prevent processing loops
+        # rdf_input.change(
+        #     fn=validate_rdf_interface,
+        #     inputs=[rdf_input, template_dropdown, use_ai_checkbox],
+        #     outputs=[status_output, results_output, suggestions_output, corrected_output]
+        # )
         
         # Example buttons
         example1_btn.click(
@@ -758,7 +813,7 @@ def create_interface():
         - ✅ Real-time RDF/XML validation against SHACL schemas
         - 🤖 AI-powered error suggestions and corrections (with HF Inference Endpoint)
         - 📚 Built-in examples and templates
-        - 🔄 Auto-validation as you type
+        - � Manual validation on-demand (click to validate)
         - 📋 Copy results with one click
         
         **Note:** AI features require a valid Hugging Face API key (HF_API_KEY) set as a Secret. Manual suggestions are provided as fallback.