feat: update HuggingFace space with new API and features

- Use analyze_text_detailed() instead of temp file workaround
- Add output format toggle (XML/JSON)
- Add token budget control for LLM context fitting
- Add max blocks and min score filtering controls
- Set show_progress=False since Gradio handles progress
- Use result.blocks for richer output summary
- Update documentation with new CLI and API examples

Co-authored-by: Cursor <cursoragent@cursor.com>

app.py

@@ -6,7 +6,6 @@ HuggingFace Space Demo (ZeroGPU)
 import logging
 import os
 import sys
-import tempfile
 import time
 from pathlib import Path
 
@@ -66,106 +65,118 @@ def analyze_logs(
     anomaly_percentile: float,
     range_min: float,
     range_max: float,
+    output_format: str = "xml",
+    token_budget: float | None = None,
+    max_blocks: float | None = None,
+    min_score: float = 0.0,
     progress=gr.Progress(),
 ):
     """Analyze log content and return results.
-    
+
     This function is decorated with @spaces.GPU to run on ZeroGPU.
     The GPU is allocated when this function is called.
-    
+
     IMPORTANT: torch and cordon are imported here (not at module level)
     because ZeroGPU only allocates GPU resources inside @spaces.GPU functions.
     """
     # Lazy imports - only load when GPU is allocated
     import torch
     from cordon import AnalysisConfig, SemanticLogAnalyzer
-    
+
     start_time = time.time()
     logger.info("=" * 60)
     logger.info("Analysis started - GPU allocated by ZeroGPU")
-    
+
     if not log_content.strip():
         logger.warning("Empty log content provided")
         return "", "Anomalous Sections"
-    
-    logger.info(f"Log content size: {len(log_content)} characters ({len(log_content.splitlines())} lines)")
-    
-    progress(0.05, desc="Preparing log file...")
-    
-    # Write content to temp file
-    with tempfile.NamedTemporaryFile(mode="w", suffix=".log", delete=False) as f:
-        f.write(log_content)
-        temp_path = Path(f.name)
-    
-    logger.info(f"Temporary log file created: {temp_path}")
-    
+
+    logger.info(
+        f"Log content size: {len(log_content)} characters "
+        f"({len(log_content.splitlines())} lines)"
+    )
+
+    progress(0.1, desc="Configuring analyzer...")
+
+    # Check if CUDA is available (should be True on ZeroGPU)
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+    batch_size = 128 if device == "cuda" else 32
+
+    logger.info(f"Device: {device}")
+    logger.info(f"Batch size: {batch_size}")
+
+    config_kwargs: dict = {
+        "window_size": window_size,
+        "k_neighbors": k_neighbors,
+        "device": device,
+        "batch_size": batch_size,
+        "show_progress": False,
+        "output_format": output_format,
+    }
+
+    if token_budget is not None and token_budget > 0:
+        config_kwargs["token_budget"] = int(token_budget)
+    if max_blocks is not None and max_blocks > 0:
+        config_kwargs["max_blocks"] = int(max_blocks)
+    if min_score > 0:
+        config_kwargs["min_score"] = min_score
+
+    if mode == "Percentile":
+        config_kwargs["anomaly_percentile"] = anomaly_percentile
+    else:
+        config_kwargs["anomaly_range_min"] = range_min
+        config_kwargs["anomaly_range_max"] = range_max
+
+    config = AnalysisConfig(**config_kwargs)
+    logger.info(f"Configuration: mode={mode}, {config_kwargs}")
+
     try:
-        progress(0.1, desc="Configuring analyzer...")
-        
-        # Check if CUDA is available (should be True on ZeroGPU)
-        device = "cuda" if torch.cuda.is_available() else "cpu"
-        # Use larger batch size on GPU for better throughput
-        batch_size = 128 if device == "cuda" else 32
-        
-        logger.info(f"Device: {device}")
-        logger.info(f"Batch size: {batch_size}")
-        
-        if mode == "Percentile":
-            config = AnalysisConfig(
-                window_size=window_size,
-                k_neighbors=k_neighbors,
-                anomaly_percentile=anomaly_percentile,
-                device=device,
-                batch_size=batch_size,
-            )
-            logger.info(f"Configuration: mode=Percentile, window_size={window_size}, k_neighbors={k_neighbors}, percentile={anomaly_percentile}")
-        else:
-            config = AnalysisConfig(
-                window_size=window_size,
-                k_neighbors=k_neighbors,
-                anomaly_range_min=range_min,
-                anomaly_range_max=range_max,
-                device=device,
-                batch_size=batch_size,
-            )
-            logger.info(f"Configuration: mode=Range, window_size={window_size}, k_neighbors={k_neighbors}, range=[{range_min}, {range_max}]")
-        
         progress(0.15, desc="Loading embedding model...")
         logger.info("Loading embedding model...")
         model_load_start = time.time()
         analyzer = SemanticLogAnalyzer(config)
         logger.info(f"Embedding model loaded in {time.time() - model_load_start:.2f}s")
-        
+
         progress(0.4, desc="Analyzing patterns...")
         logger.info("Starting log analysis...")
         analysis_start = time.time()
-        result = analyzer.analyze_file_detailed(temp_path)
+        result = analyzer.analyze_text_detailed(log_content)
         logger.info(f"Analysis completed in {time.time() - analysis_start:.2f}s")
-        
+
         progress(0.9, desc="Formatting output...")
         progress(1.0, desc="Complete!")
-        
+
         # Calculate token counts
         input_tokens = estimate_tokens(log_content)
         output_tokens = estimate_tokens(result.output)
-        reduction = ((input_tokens - output_tokens) / input_tokens * 100) if input_tokens > 0 else 0
-        
-        label = f"Anomalous Sections — {input_tokens:,} → {output_tokens:,} tokens ({reduction:.0f}% reduction)"
-        
+        reduction = (
+            (input_tokens - output_tokens) / input_tokens * 100
+            if input_tokens > 0 else 0
+        )
+
+        block_count = len(result.blocks)
+        if block_count > 0:
+            scores = [b.max_score for b in result.blocks]
+            score_range = f"scores: {min(scores):.3f}-{max(scores):.3f}"
+        else:
+            score_range = "no anomalies"
+
+        label = (
+            f"Anomalous Sections — {input_tokens:,} → {output_tokens:,} tokens "
+            f"({reduction:.0f}% reduction) | {block_count} blocks, {score_range}"
+        )
+
         total_time = time.time() - start_time
         logger.info(f"Total analysis time: {total_time:.2f}s")
         logger.info(f"Token reduction: {input_tokens:,} → {output_tokens:,} ({reduction:.0f}%)")
         logger.info("=" * 60)
-        
+
         return gr.update(value=result.output, label=label)
-        
+
     except Exception as e:
         logger.error(f"Error during analysis: {str(e)}", exc_info=True)
         error_msg = f"Analysis failed: {str(e)}"
         return gr.update(value=error_msg, label="Error")
-    finally:
-        temp_path.unlink(missing_ok=True)
-        logger.info("Temporary file cleaned up")
 
 
 CUSTOM_CSS = """
@@ -204,9 +215,9 @@ THEME = gr.themes.Base(
 
 def create_interface():
     """Create the Gradio interface."""
-    
+
     with gr.Blocks(title="Cordon", theme=THEME, css=CUSTOM_CSS) as demo:
-        
+
         # Header
         gr.HTML("""
         <div style="text-align: center; padding: 16px 0 24px 0;">
@@ -216,10 +227,10 @@ def create_interface():
             <p style="color: #94a3b8; margin: 0;">Reduce logs to their semantically anomalous parts.</p>
         </div>
         """)
-        
+
         # Main content - two equal columns
         with gr.Row():
-            
+
             # Left: Input
             with gr.Column(scale=1):
                 log_input = gr.Textbox(
@@ -227,15 +238,15 @@ def create_interface():
                     placeholder="Paste your log content here...",
                     lines=22,
                 )
-                
+
                 with gr.Row():
                     load_sample_btn = gr.Button("📂 Load Sample", size="sm")
                     clear_btn = gr.Button("Clear", size="sm")
-                
+
                 with gr.Row():
                     window_size = gr.Slider(2, 20, value=4, step=1, label="Window Size")
                     k_neighbors = gr.Slider(2, 20, value=5, step=1, label="k Neighbors")
-                
+
                 with gr.Row():
                     mode_select = gr.Dropdown(
                         choices=["Percentile", "Range"],
@@ -246,21 +257,53 @@ def create_interface():
                     anomaly_percentile = gr.Slider(0.01, 0.5, value=0.1, step=0.01, label="Top N%", scale=2)
                     range_min = gr.Slider(0.0, 0.49, value=0.05, step=0.01, label="Min %", visible=False, scale=1)
                     range_max = gr.Slider(0.01, 0.5, value=0.15, step=0.01, label="Max %", visible=False, scale=1)
-                
+
                 def toggle_mode(mode):
                     if mode == "Percentile":
                         return gr.update(visible=True), gr.update(visible=False), gr.update(visible=False)
                     else:
                         return gr.update(visible=False), gr.update(visible=True), gr.update(visible=True)
-                
+
                 mode_select.change(
                     fn=toggle_mode,
                     inputs=[mode_select],
                     outputs=[anomaly_percentile, range_min, range_max]
                 )
-                
+
+                with gr.Accordion("Advanced Options", open=False):
+                    with gr.Row():
+                        output_format = gr.Dropdown(
+                            choices=["xml", "json"],
+                            value="xml",
+                            label="Output Format",
+                            scale=1,
+                        )
+                        token_budget = gr.Number(
+                            value=None,
+                            label="Token Budget",
+                            precision=0,
+                            minimum=1,
+                            info="Max tokens for output (auto-adjusts percentile)",
+                            scale=1,
+                        )
+                    with gr.Row():
+                        max_blocks = gr.Number(
+                            value=None,
+                            label="Max Blocks",
+                            precision=0,
+                            minimum=1,
+                            info="Limit to top N blocks by score",
+                            scale=1,
+                        )
+                        min_score = gr.Slider(
+                            0.0, 1.0, value=0.0, step=0.01,
+                            label="Min Score",
+                            info="Filter blocks below this score",
+                            scale=1,
+                        )
+
                 analyze_btn = gr.Button("🔍 Analyze", variant="primary", size="lg")
-            
+
             # Right: Output
             with gr.Column(scale=1):
                 output_text = gr.Textbox(
@@ -268,8 +311,8 @@ def create_interface():
                     placeholder="Results will appear here...",
                     lines=37,
                 )
-        
-        
+
+
         # Documentation section
         gr.Markdown("""
 ---
@@ -314,14 +357,26 @@ pip install cordon
 # Basic usage
 cordon system.log
 
-# Customize parameters  
+# Customize parameters
 cordon --window-size 10 --k-neighbors 10 --anomaly-percentile 0.05 app.log
 
 # Use range mode (exclude top 5%, keep next 10%)
 cordon --anomaly-range 0.05 0.15 app.log
 
-# Save to file
-cordon --output anomalies.xml system.log
+# JSON output
+cordon --format json system.log
+
+# Quiet mode for CI
+cordon --quiet -o anomalies.json --format json app.log
+
+# Token budget (fit output in 2000 tokens)
+cordon --token-budget 2000 system.log
+
+# Filter output
+cordon --max-blocks 10 --min-score 0.1 system.log
+
+# Read from stdin
+kubectl logs pod-name | cordon -
 ```
 
 ### Python API
@@ -331,28 +386,39 @@ from cordon import SemanticLogAnalyzer, AnalysisConfig
 
 config = AnalysisConfig(window_size=4, k_neighbors=5, anomaly_percentile=0.1)
 analyzer = SemanticLogAnalyzer(config)
-result = analyzer.analyze_file(Path("system.log"))
+
+# From file
+result = analyzer.analyze_file_detailed(Path("system.log"))
+
+# From text (no temp file needed)
+result = analyzer.analyze_text_detailed(log_text)
+
+# Access structured blocks
+for block in result.blocks:
+    print(f"Lines {block.start_line}-{block.end_line}: score={block.max_score:.4f}")
 ```
 
 ### Links
 
 - [GitHub Repository](https://github.com/calebevans/cordon)
-- [PyPI Package](https://pypi.org/project/cordon/)  
+- [PyPI Package](https://pypi.org/project/cordon/)
 - [Red Hat Developer Article](https://developers.redhat.com/articles/2025/12/09/semantic-anomaly-detection-log-files-cordon)
         """)
-        
+
         # Events
         load_sample_btn.click(fn=load_sample_log, outputs=[log_input])
         clear_btn.click(fn=lambda: "", outputs=[log_input])
-        
-        # Use analyze_logs directly - it's decorated with @spaces.GPU
-        # Don't wrap it in another function or ZeroGPU won't allocate GPU properly
+
         analyze_btn.click(
             fn=analyze_logs,
-            inputs=[log_input, window_size, k_neighbors, mode_select, anomaly_percentile, range_min, range_max],
+            inputs=[
+                log_input, window_size, k_neighbors, mode_select,
+                anomaly_percentile, range_min, range_max,
+                output_format, token_budget, max_blocks, min_score,
+            ],
             outputs=[output_text],
         )
-    
+
     return demo
 
 
@@ -371,10 +437,10 @@ try:
     logger.info("Creating Gradio interface...")
     demo = create_interface()
     logger.info("Gradio interface created successfully")
-    
+
     # Detect if running on HuggingFace Spaces
     is_hf_space = os.getenv("SPACE_ID") is not None
-    
+
     if is_hf_space:
         # On HuggingFace: use strict port binding for health checks
         logger.info("Running on HuggingFace Spaces - using port 7860")

requirements.txt

@@ -1,5 +1,5 @@
 # Cordon package from PyPI
-cordon==0.3.1
+cordon>=1.0.2
 
 # UI dependencies
 gradio==6.2.0