Update app.py

using binary search

app.py

@@ -133,61 +133,122 @@ class ModelWrapper:
 MODEL_NAME = "Qwen/Qwen3-0.6B"
 model = ModelWrapper(MODEL_NAME)
 
+def safe_truncate_to_bytes(text, max_bytes=3000, safety_buffer=100):
+    """
+    Safely truncate text to fit within byte limit with proper UTF-8 handling
+    """
+    # Apply safety buffer to avoid edge cases
+    target_bytes = max_bytes - safety_buffer
+    
+    # If text is already short enough, return as is
+    if len(text.encode('utf-8')) <= target_bytes:
+        return text
+    
+    # Binary search for the largest substring that fits
+    left, right = 0, len(text)
+    result = ""
+    
+    while left <= right:
+        mid = (left + right) // 2
+        candidate = text[:mid]
+        candidate_bytes = len(candidate.encode('utf-8'))
+        
+        if candidate_bytes <= target_bytes:
+            result = candidate
+            left = mid + 1
+        else:
+            right = mid - 1
+    
+    # Add truncation notice
+    if result != text:
+        result += "\n\n[Response truncated to prevent server errors]"
+    
+    return result
+
 # — Gradio inference function —
 def compliance_check(rules_text, transcript_text, thinking):
-    # This is the general byte limit for any response leaving this function
-    MAX_RESPONSE_BYTES = 4096 
+    """
+    Enhanced compliance check with robust error handling and response size management
+    """
+    # Conservative byte limit with safety margin
+    MAX_RESPONSE_BYTES = 3000
 
     try:
-        rules = [r for r in rules_text.split("\n") if r.strip()]
+        # Input validation
+        if not rules_text.strip():
+            return "Error: Please provide at least one rule."
+        
+        if not transcript_text.strip():
+            return "Error: Please provide a transcript to analyze."
+        
+        rules = [r.strip() for r in rules_text.split("\n") if r.strip()]
+        if not rules:
+            return "Error: No valid rules found. Please enter rules separated by newlines."
+        
         inp = format_rules(rules) + format_transcript(transcript_text)
         
-        out = model.get_response(inp, enable_thinking=thinking, max_new_tokens=256)
+        # Generate response with conservative token limit
+        out = model.get_response(inp, enable_thinking=thinking, max_new_tokens=200)
         
-        # Clean up the successful output
+        # Clean up the output
         out = str(out).strip()
         if not out:
-            out = "No response generated. Please try with different input."
+            out = "No response generated. Please try with different input or check your model configuration."
             
+    except torch.cuda.OutOfMemoryError:
+        out = "Error: GPU out of memory. Try with shorter input text or restart the application."
+        
     except Exception as e:
-        # If any error happens, create an error message instead
-        full_error = str(e)
-        print(f"Full error: {full_error}") # Log the full error for debugging
-        # The output 'out' will now be this error message
-        out = f"An error occurred: {full_error}"
-
-    # --- UNIVERSAL BYTE CHECK FOR ALL OUTPUTS ---
-    # This block now runs for both successful results and error messages.
+        # Create a concise error message
+        error_msg = str(e)
+        if len(error_msg) > 200:
+            error_msg = error_msg[:200] + "..."
+        out = f"Processing error: {error_msg}"
+        print(f"Full error details: {str(e)}")  # Log full error for debugging
+
+    # Apply safe truncation to ALL outputs (success and error cases)
+    out = safe_truncate_to_bytes(out, MAX_RESPONSE_BYTES)
     
-    # Encode the final output (whether result or error) to bytes
-    out_bytes = out.encode('utf-8')
-
-    # Check if the byte length exceeds our limit
-    if len(out_bytes) > MAX_RESPONSE_BYTES:
-        # Truncate the byte string safely
-        truncated_bytes = out_bytes[:MAX_RESPONSE_BYTES]
-        out = truncated_bytes.decode('utf-8', errors='ignore')
-        # Add a clear message indicating it was truncated
-        out += "\n\n[Response truncated to prevent server errors]"
-            
     return out
 
-
-
-# — build Gradio interface —
+# — build Gradio interface with better configuration —
 demo = gr.Interface(
     fn=compliance_check,
     inputs=[
-        gr.Textbox(lines=5, label="Rules (one per line)", max_lines=10),
-        gr.Textbox(lines=10, label="Transcript", max_lines=15),
+        gr.Textbox(
+            lines=5, 
+            label="Rules (one per line)", 
+            max_lines=10,
+            placeholder="Enter compliance rules, one per line..."
+        ),
+        gr.Textbox(
+            lines=10, 
+            label="Transcript", 
+            max_lines=15,
+            placeholder="Paste the transcript to analyze..."
+        ),
         gr.Checkbox(label="Enable ⟨think⟩ mode", value=True)
     ],
-    outputs=gr.Textbox(label="Compliance Output", lines=10, max_lines=15),
+    outputs=gr.Textbox(
+        label="Compliance Output", 
+        lines=10, 
+        max_lines=15,
+        show_copy_button=True
+    ),
     title="DynaGuard Compliance Checker",
-    description="Paste your rules & transcript, then hit Submit.",
+    description="Paste your rules & transcript, then hit Submit. Responses are automatically sized for optimal performance.",
     allow_flagging="never",
-    show_progress=True
+    show_progress=True,
+    # Add these parameters for better stability
+    cache_examples=False
 )
 
 if __name__ == "__main__":
-    demo.launch()
+    # Launch with more conservative settings
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        show_error=True,
+        quiet=False,
+        inbrowser=False
+    )