Add application file

app.py

@@ -0,0 +1,176 @@
+import gradio as gr
+import json
+from llama_cpp import Llama
+import os
+from huggingface_hub import hf_hub_download
+
+# Global variable to store the model
+llm = None
+
+def load_model():
+    """Load the llama.cpp model"""
+    global llm
+    try:
+        # You can replace this with any GGUF model from Hugging Face
+        # For example, using a small model for demonstration
+        model_name = "microsoft/DialoGPT-medium"
+        
+        # For now, we'll use a local model path or download one
+        # This is a placeholder - you'll need to specify the actual model
+        print("Loading llama.cpp model...")
+        
+        # Initialize with basic settings
+        # Note: You'll need to provide an actual GGUF model file
+        # llm = Llama(
+        #     model_path="path/to/your/model.gguf",
+        #     n_ctx=2048,
+        #     n_threads=2,
+        #     verbose=False
+        # )
+        
+        print("Model loaded successfully!")
+        return "Model loaded successfully!"
+        
+    except Exception as e:
+        print(f"Error loading model: {e}")
+        return f"Error loading model: {e}"
+
+def text_to_json(input_text, max_tokens=512, temperature=0.7):
+    """Convert plain text to structured JSON using llama.cpp"""
+    global llm
+    
+    if llm is None:
+        return {"error": "Model not loaded. Please load the model first."}
+    
+    try:
+        # Create a prompt for JSON generation
+        prompt = f"""Convert the following text into a structured JSON format. Extract key information and organize it logically:
+
+Text: {input_text}
+
+JSON:"""
+
+        # Generate response using llama.cpp
+        response = llm(
+            prompt,
+            max_tokens=max_tokens,
+            temperature=temperature,
+            stop=["```", "\n\n\n"],
+            echo=False
+        )
+        
+        generated_text = response['choices'][0]['text'].strip()
+        
+        # Try to parse as JSON to validate
+        try:
+            parsed_json = json.loads(generated_text)
+            return json.dumps(parsed_json, indent=2)
+        except json.JSONDecodeError:
+            # If not valid JSON, return as a structured attempt
+            return generated_text
+            
+    except Exception as e:
+        return f"Error generating JSON: {str(e)}"
+
+def demo_without_model(input_text):
+    """Demo function that works without loading a model"""
+    try:
+        # Simple rule-based JSON conversion for demonstration
+        words = input_text.strip().split()
+        
+        # Create a basic JSON structure
+        result = {
+            "input_text": input_text,
+            "word_count": len(words),
+            "words": words,
+            "character_count": len(input_text),
+            "sentences": input_text.split('.'),
+            "metadata": {
+                "processed_by": "llama.cpp demo",
+                "timestamp": "demo_mode"
+            }
+        }
+        
+        return json.dumps(result, indent=2)
+        
+    except Exception as e:
+        return f"Error processing text: {str(e)}"
+
+# Create Gradio interface
+with gr.Blocks(title="Plain Text to JSON with llama.cpp") as demo:
+    gr.Markdown("# Plain Text to JSON Converter")
+    gr.Markdown("Convert plain text into structured JSON format using llama.cpp")
+    
+    with gr.Tab("Text to JSON"):
+        with gr.Row():
+            with gr.Column():
+                input_text = gr.Textbox(
+                    label="Input Text",
+                    placeholder="Enter your text here...",
+                    lines=5
+                )
+                
+                with gr.Row():
+                    max_tokens = gr.Slider(
+                        minimum=50,
+                        maximum=1000,
+                        value=512,
+                        label="Max Tokens"
+                    )
+                    temperature = gr.Slider(
+                        minimum=0.1,
+                        maximum=1.0,
+                        value=0.7,
+                        label="Temperature"
+                    )
+                
+                convert_btn = gr.Button("Convert to JSON", variant="primary")
+                demo_btn = gr.Button("Demo (No Model)", variant="secondary")
+                
+            with gr.Column():
+                output_json = gr.Textbox(
+                    label="Generated JSON",
+                    lines=10,
+                    interactive=False
+                )
+    
+    with gr.Tab("Model Management"):
+        load_btn = gr.Button("Load Model", variant="primary")
+        model_status = gr.Textbox(
+            label="Model Status",
+            value="Model not loaded",
+            interactive=False
+        )
+        
+        gr.Markdown("""
+        ### Instructions:
+        1. Click "Load Model" to initialize llama.cpp (requires a GGUF model file)
+        2. Use "Demo (No Model)" for basic functionality without loading a model
+        3. For full functionality, you need to provide a GGUF model file
+        
+        ### Notes:
+        - This space uses llama.cpp for efficient CPU inference
+        - Models should be in GGUF format
+        - Adjust max_tokens and temperature for different outputs
+        """)
+    
+    # Event handlers
+    convert_btn.click(
+        fn=text_to_json,
+        inputs=[input_text, max_tokens, temperature],
+        outputs=output_json
+    )
+    
+    demo_btn.click(
+        fn=demo_without_model,
+        inputs=input_text,
+        outputs=output_json
+    )
+    
+    load_btn.click(
+        fn=load_model,
+        outputs=model_status
+    )
+
+if __name__ == "__main__":
+    demo.launch()