Create app.py

app.py

@@ -0,0 +1,372 @@
+import gradio as gr
+import requests
+import json
+import re
+import time
+from typing import List, Dict, Tuple, Optional
+from urllib.parse import quote
+
+class GGUFModelFinder:
+    def __init__(self):
+        self.popular_gguf_creators = [
+            "TheBloke",
+            "bartowski", 
+            "mradermacher",
+            "microsoft",
+            "QuantFactory",
+            "lmstudio-ai",
+            "huggingface",
+            "mlabonne",
+            "NousResearch",
+            "MaziyarPanahi"
+        ]
+        
+        self.api_base = "https://huggingface.co/api"
+        self.headers = {
+            "User-Agent": "GGUF-Model-Finder/1.0"
+        }
+    
+    def clean_model_name(self, model_name: str) -> str:
+        """Clean and normalize model name for better searching"""
+        # Remove common prefixes and suffixes
+        cleaned = model_name.strip()
+        
+        # Remove author/organization prefix if present
+        if "/" in cleaned:
+            cleaned = cleaned.split("/")[-1]
+        
+        # Remove common suffixes
+        suffixes_to_remove = [
+            "-GGUF", "-gguf", "-GPTQ", "-gptq", "-AWQ", "-awq", 
+            "-HF", "-hf", "-chat", "-instruct", "-base", "-v1", 
+            "-v2", "-v3", "-uncensored", "-finetune"
+        ]
+        
+        for suffix in suffixes_to_remove:
+            if cleaned.lower().endswith(suffix.lower()):
+                cleaned = cleaned[:-len(suffix)]
+        
+        return cleaned.strip()
+    
+    def search_models(self, query: str, author: str = None, limit: int = 20) -> List[Dict]:
+        """Search for models using HuggingFace API"""
+        try:
+            search_url = f"{self.api_base}/models"
+            params = {
+                "search": query,
+                "filter": "gguf",
+                "limit": limit,
+                "sort": "downloads"
+            }
+            
+            if author:
+                params["author"] = author
+            
+            response = requests.get(search_url, params=params, headers=self.headers, timeout=10)
+            
+            if response.status_code == 200:
+                return response.json()
+            else:
+                return []
+        except Exception as e:
+            print(f"Error searching models: {e}")
+            return []
+    
+    def search_gguf_variants(self, model_name: str) -> List[Dict]:
+        """Search for GGUF variants of a given model"""
+        cleaned_name = self.clean_model_name(model_name)
+        all_results = []
+        
+        # Search with different query variations
+        search_terms = [
+            cleaned_name,
+            f"{cleaned_name} GGUF",
+            f"{cleaned_name}-GGUF",
+            f"{cleaned_name}_GGUF"
+        ]
+        
+        # Search through popular GGUF creators
+        for creator in self.popular_gguf_creators:
+            for term in search_terms:
+                results = self.search_models(term, author=creator, limit=10)
+                all_results.extend(results)
+                time.sleep(0.1)  # Rate limiting
+        
+        # Also search generally without author filter
+        for term in search_terms:
+            results = self.search_models(term, limit=15)
+            all_results.extend(results)
+            time.sleep(0.1)
+        
+        # Remove duplicates and filter relevant results
+        seen_ids = set()
+        filtered_results = []
+        
+        for model in all_results:
+            model_id = model.get('id', '')
+            if model_id not in seen_ids and 'gguf' in model_id.lower():
+                seen_ids.add(model_id)
+                
+                # Check if model name is relevant
+                model_name_clean = self.clean_model_name(model_id)
+                if self.is_relevant_match(cleaned_name, model_name_clean):
+                    filtered_results.append(model)
+        
+        # Sort by downloads (descending)
+        filtered_results.sort(key=lambda x: x.get('downloads', 0), reverse=True)
+        
+        return filtered_results[:20]  # Return top 20 results
+    
+    def is_relevant_match(self, original: str, candidate: str) -> bool:
+        """Check if candidate model is a relevant match for original"""
+        original_lower = original.lower()
+        candidate_lower = candidate.lower()
+        
+        # Direct substring match
+        if original_lower in candidate_lower or candidate_lower in original_lower:
+            return True
+        
+        # Check word overlap
+        original_words = set(re.findall(r'\w+', original_lower))
+        candidate_words = set(re.findall(r'\w+', candidate_lower))
+        
+        # If most words overlap, it's likely a match
+        if len(original_words) > 0:
+            overlap_ratio = len(original_words.intersection(candidate_words)) / len(original_words)
+            return overlap_ratio >= 0.6
+        
+        return False
+    
+    def get_model_details(self, model_id: str) -> Dict:
+        """Get detailed information about a specific model"""
+        try:
+            url = f"{self.api_base}/models/{model_id}"
+            response = requests.get(url, headers=self.headers, timeout=10)
+            
+            if response.status_code == 200:
+                return response.json()
+            return {}
+        except Exception as e:
+            print(f"Error getting model details: {e}")
+            return {}
+    
+    def format_model_info(self, model: Dict) -> str:
+        """Format model information for display"""
+        model_id = model.get('id', 'Unknown')
+        downloads = model.get('downloads', 0)
+        likes = model.get('likes', 0)
+        updated = model.get('lastModified', 'Unknown')
+        
+        # Format the date
+        if updated != 'Unknown':
+            try:
+                from datetime import datetime
+                date_obj = datetime.fromisoformat(updated.replace('Z', '+00:00'))
+                updated = date_obj.strftime('%Y-%m-%d')
+            except:
+                pass
+        
+        # Get model size info if available
+        size_info = ""
+        if 'siblings' in model:
+            total_size = 0
+            file_count = 0
+            for sibling in model['siblings']:
+                if sibling.get('rfilename', '').endswith('.gguf'):
+                    file_count += 1
+                    if 'size' in sibling:
+                        total_size += sibling['size']
+            
+            if total_size > 0:
+                size_gb = total_size / (1024**3)
+                size_info = f" | Size: {size_gb:.1f}GB ({file_count} GGUF files)"
+        
+        model_url = f"https://huggingface.co/{model_id}"
+        
+        return f"""
+**[{model_id}]({model_url})**
+- Downloads: {downloads:,} | Likes: {likes} | Updated: {updated}{size_info}
+"""
+
+def find_gguf_models(model_name: str, progress=gr.Progress()) -> Tuple[str, str]:
+    """Main function to find GGUF models"""
+    if not model_name.strip():
+        return "Please enter a model name to search for.", ""
+    
+    progress(0.1, desc="Initializing search...")
+    
+    finder = GGUFModelFinder()
+    
+    progress(0.3, desc="Searching for GGUF variants...")
+    results = finder.search_gguf_variants(model_name)
+    
+    progress(0.8, desc="Formatting results...")
+    
+    if not results:
+        no_results = f"""
+# No GGUF Models Found 😞
+
+Could not find any GGUF variants for **{model_name}**.
+
+## Suggestions:
+1. **Check the spelling** of the model name
+2. **Try a simpler name** (e.g., just "llama-2-7b" instead of "meta-llama/Llama-2-7b-chat-hf")
+3. **Search manually** on [Hugging Face](https://huggingface.co/models?other=gguf) with the GGUF filter
+4. **Check popular GGUF creators**:
+   - [TheBloke](https://huggingface.co/TheBloke)
+   - [bartowski](https://huggingface.co/bartowski)
+   - [mradermacher](https://huggingface.co/mradermacher)
+   - [QuantFactory](https://huggingface.co/QuantFactory)
+
+The model you're looking for might not have been converted to GGUF format yet, or might be available under a different name.
+"""
+        return no_results, ""
+    
+    # Create main results
+    results_md = f"""
+# GGUF Models Found for "{model_name}" 🎯
+
+Found **{len(results)}** GGUF variant(s):
+
+"""
+    
+    for i, model in enumerate(results, 1):
+        results_md += f"{i}. {finder.format_model_info(model)}\n"
+    
+    # Create additional info
+    additional_info = f"""
+## 📋 What is GGUF?
+
+GGUF (GPT-Generated Unified Format) is a file format for storing models for inference with GGML and llama.cpp. It's designed to be fast to load and save, and to be extensible.
+
+## 🔧 How to Use These Models
+
+### With llama.cpp:
+```bash
+./main -m model.gguf -p "Your prompt here"
+```
+
+### With Ollama:
+```bash
+ollama create mymodel -f Modelfile
+ollama run mymodel
+```
+
+### With Python (llama-cpp-python):
+```python
+from llama_cpp import Llama
+
+llm = Llama(model_path="model.gguf")
+output = llm("Your prompt here")
+```
+
+## 💡 Tips for Choosing a Model
+
+- **Q4_K_M**: Good balance of quality and size
+- **Q5_K_M**: Higher quality, larger size  
+- **Q6_K**: Even higher quality, larger size
+- **Q8_0**: Highest quality, largest size
+
+Lower numbers = smaller file size but lower quality
+Higher numbers = larger file size but higher quality
+
+## 🌟 Popular GGUF Model Creators
+
+The results above are from trusted model quantizers who regularly convert popular models to GGUF format.
+"""
+    
+    progress(1.0, desc="Complete!")
+    
+    return results_md, additional_info
+
+# Create the Gradio interface
+def create_interface():
+    with gr.Blocks(
+        title="GGUF Model Finder", 
+        theme=gr.themes.Soft(),
+        css="""
+        .container { max-width: 1200px; margin: auto; }
+        .header { text-align: center; margin: 20px 0; }
+        .search-box { margin: 20px 0; }
+        """
+    ) as iface:
+        
+        gr.HTML("""
+        <div class="header">
+            <h1>🔍 GGUF Model Finder</h1>
+            <p>Find GGUF (quantized) versions of your favorite language models for local inference</p>
+        </div>
+        """)
+        
+        with gr.Row():
+            with gr.Column(scale=3):
+                model_input = gr.Textbox(
+                    label="Model Name",
+                    placeholder="e.g., llama-2-7b, mistral-7b, codellama-34b, deepseek-coder-6.7b",
+                    info="Enter the name of the model you want to find GGUF versions for",
+                    lines=1
+                )
+            
+            with gr.Column(scale=1):
+                search_btn = gr.Button("🔍 Search GGUF Models", variant="primary", size="lg")
+        
+        gr.HTML("""
+        <div style="margin: 20px 0; padding: 15px; background-color: #f0f0f0; border-radius: 8px;">
+            <strong>💡 Quick Examples:</strong><br>
+            • <code>llama-2-7b</code> - Meta's Llama 2 7B model<br>
+            • <code>mistral-7b</code> - Mistral AI's 7B model<br>
+            • <code>codellama-34b</code> - Code Llama 34B model<br>
+            • <code>neural-chat-7b</code> - Intel's Neural Chat model<br>
+            • <code>deepseek-coder</code> - DeepSeek Coder model
+        </div>
+        """)
+        
+        with gr.Row():
+            with gr.Column(scale=2):
+                results_output = gr.Markdown(
+                    label="Search Results",
+                    value="Enter a model name above and click 'Search GGUF Models' to find quantized versions.",
+                    height=400
+                )
+            
+            with gr.Column(scale=1):
+                info_output = gr.Markdown(
+                    label="Additional Information",
+                    value="",
+                    height=400
+                )
+        
+        # Event handlers
+        search_btn.click(
+            fn=find_gguf_models,
+            inputs=[model_input],
+            outputs=[results_output, info_output],
+            show_progress=True
+        )
+        
+        model_input.submit(
+            fn=find_gguf_models,
+            inputs=[model_input],
+            outputs=[results_output, info_output],
+            show_progress=True
+        )
+        
+        gr.HTML("""
+        <div style="margin-top: 30px; text-align: center; color: #666;">
+            <p>Made with ❤️ using Gradio | Data from <a href="https://huggingface.co">Hugging Face</a></p>
+            <p>GGUF format by the <a href="https://github.com/ggerganov/llama.cpp">llama.cpp</a> team</p>
+        </div>
+        """)
+    
+    return iface
+
+if __name__ == "__main__":
+    # Create and launch the interface
+    demo = create_interface()
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=True,
+        show_error=True,
+        show_tips=True
+    )