Update app.py

app.py

@@ -1,135 +1,108 @@
-import time
-import requests
-from selenium import webdriver
-from bs4 import BeautifulSoup
-from selenium.webdriver.chrome.options import Options
-from selenium.webdriver.chrome.service import Service # New: Import Service for modern Selenium setup
-from fastapi import FastAPI, Response, HTTPException
-from fastapi.responses import FileResponse
-from fastapi.staticfiles import StaticFiles
+"""
+Gradio + Hugging Face Inference API example app
+File: gradio_hf_inference_app.py
+
+How it works
+- Uses the official Hugging Face Inference API endpoint: https://api-inference.huggingface.co/models/{model}
+- Reads the token from the environment variable HUGGINGFACE_API_TOKEN (or HF_API_TOKEN)
+- Provides a small Gradio UI to choose model, enter prompt and parameters, and shows generated text
+
+Instructions to run locally
+1. Install dependencies: pip install -r requirements.txt
+2. Export your HF token: export HUGGINGFACE_API_TOKEN="hf_..."
+3. Run: python gradio_hf_inference_app.py
+
+Instructions to deploy on Hugging Face Spaces (Gradio)
+1. Create a new Space on Hugging Face and choose the Gradio template.
+2. Upload this file and requirements.txt to the repository, or push via git.
+3. Add a secret in the Space settings named HUGGINGFACE_API_TOKEN with your token value.
+4. (Optional) If using large models, choose GPU hardware for the Space.
+5. The Space will start and you can use the UI.
+
+Notes
+- This example uses the simple REST Inference API via requests. For higher throughput or advanced use-cases, consider using the
+  huggingface_hub library and caching, or hosted endpoints provided by Hugging Face (inference endpoints) for production.
+
+"""
+
 import os
-import uvicorn # Required for explicit startup
-
-# Initialize the FastAPI app
-app = FastAPI()
-
-def getimage(url: str) -> str:
-    """
-    Scrapes the profile image from a given URL using Selenium and BeautifulSoup,
-    and saves it to the local filesystem.
-    """
-    
-    # 1. Setup Selenium Options
-    chrome_options = Options()
-    # REQUIRED for deployment on servers like Hugging Face Spaces or Docker
-    chrome_options.add_argument('--headless')
-    chrome_options.add_argument('--no-sandbox')
-    chrome_options.add_argument('--disable-dev-shm-usage')
-    chrome_options.add_argument("--window-size=1200x800")
-    
-    driver = None
-    try:
-        # 2. Initialize the WebDriver
-        # Note: If 'chromedriver' is not in the system PATH, 
-        # this will fail. For custom environments, you may need to 
-        # specify the driver path using Service(executable_path='...')
-        driver = webdriver.Chrome(options=chrome_options)
-
-        # 3. Navigate and Wait
-        driver.get(url)
-        # Wait long enough for the dynamic content (profile picture) to load
-        time.sleep(5) 
-        page_source = driver.page_source
-
-        # 4. Parse the Source
-        soup = BeautifulSoup(page_source, 'html.parser')
-
-        # 5. Targeted Thumbnail/Profile Picture Selection Logic
-        # Strategy: Search for an image with 'alt' text related to the profile
-        def is_profile_image(tag):
-            alt_text = tag.get('alt', '').lower()
-            # Common alt texts used for the main profile picture
-            return tag.name == 'img' and ('profile picture' in alt_text or 'avatar' in alt_text)
-
-        img_tag = soup.find(is_profile_image)
-
-        # Fallback Strategy: If the profile-specific search fails, take the largest available image
-        if not img_tag:
-            print("Fallback to finding the first image with a 'src' attribute.")
-            img_tag = soup.find('img', src=True)
-            
-        if not img_tag:
-            raise ValueError("Could not find a suitable image tag on the page.")
-
-        img_url = img_tag['src']
-
-        # 6. Download the Image
-        r = requests.get(img_url, stream=True)
-        r.raise_for_status() # Raise an exception for bad status codes (4xx or 5xx)
-
-        filename = "instagram_profile.png"
-        with open(filename, 'wb') as f:
-            for chunk in r.iter_content(chunk_size=8192):
-                f.write(chunk)
-                
-        return filename
-
-    except Exception as e:
-        # Clean up the browser instance in case of an error
-        raise RuntimeError(f"Scraping failed for URL {url}: {e}") from e
-    finally:
-        if driver:
-            driver.quit()
-
-
-# --- FastAPI Endpoints ---
-
-# Endpoint to trigger the image scraping
-@app.get("/fetch_profile_image")
-def fetch_image_endpoint(input_url: str):
-    """
-    Accepts a URL, scrapes the profile image, and returns the result.
-    """
-    if not input_url.startswith("http"):
-         raise HTTPException(status_code=400, detail="Input must be a valid URL starting with http:// or https://")
+import requests
+import gradio as gr
+from typing import Optional
+
+# Read token from environment
+HF_TOKEN = os.environ.get("HUGGINGFACE_API_TOKEN") or os.environ.get("HF_API_TOKEN")
+DEFAULT_MODEL = "gpt2"  # change to a different default if you prefer (e.g. "gpt-neo-125M")
+
+
+def call_hf_inference(model: str, prompt: str, max_new_tokens: int = 128, temperature: float = 1.0, top_k: Optional[int] = None):
+    """Call the Hugging Face Inference API and return generated text or error message."""
+    if not HF_TOKEN:
+        return "ERROR: HUGGINGFACE_API_TOKEN environment variable is not set.\nSet it and restart the app."
+
+    url = f"https://api-inference.huggingface.co/models/{model}"
+    headers = {"Authorization": f"Bearer {HF_TOKEN}"}
+    payload = {
+        "inputs": prompt,
+        "parameters": {
+            "max_new_tokens": int(max_new_tokens),
+            "temperature": float(temperature),
+        },
+        "options": {"use_cache": False}
+    }
+
+    # Add optional top_k
+    if top_k is not None:
+        payload["parameters"]["top_k"] = int(top_k)
 
     try:
-        saved_filename = getimage(input_url)
-        
-        # We can also return the image itself, but for simplicity, 
-        # we'll confirm the file was saved.
-        return {
-            "status": "success",
-            "message": f"Profile picture successfully caught and saved as {saved_filename}",
-            "filename": saved_filename
-        }
-    except Exception as e:
-        # We catch the RuntimeError raised in getimage and return a 500 status
-        raise HTTPException(status_code=500, detail=str(e))
-
-# Ensure the 'static' directory exists for mounting, preventing the RuntimeError
-STATIC_DIR = "static"
-if not os.path.exists(STATIC_DIR):
-    os.makedirs(STATIC_DIR)
-
-# This part serves the static files (like a frontend HTML page)
-# Note: You would need a 'static' folder with an 'index.html' file to see a UI.
-app.mount("/", StaticFiles(directory=STATIC_DIR, html=True), name="static")
-
-# The root endpoint serves the main HTML page
-@app.get("/")
-def index() -> FileResponse:
-    # Ensure the path exists, otherwise the app will fail to start
-    if os.path.exists("static/index.html"):
-        return FileResponse(path="static/index.html", media_type="text/html")
+        resp = requests.post(url, headers=headers, json=payload, timeout=120)
+    except requests.exceptions.RequestException as e:
+        return f"Request error: {e}"
+
+    if resp.status_code == 200:
+        try:
+            data = resp.json()
+        except ValueError:
+            return f"Invalid JSON response:\n{resp.text}"
+
+        # The Inference API usually returns a list of objects for text generation: [{"generated_text": "..."}]
+        if isinstance(data, list) and len(data) > 0 and isinstance(data[0], dict) and "generated_text" in data[0]:
+            return data[0]["generated_text"]
+        # Some models return plain text or different structure
+        if isinstance(data, dict) and "error" in data:
+            return f"API error: {data['error']}"
+        return str(data)
     else:
-        # If running without a UI, just return a simple message
-        return {"message": "Image Scraper API Running. Access /fetch_profile_image?input_url=<URL> to test."}
+        # Helpful debug info
+        try:
+            err = resp.json()
+        except ValueError:
+            err = resp.text
+        return f"HTTP {resp.status_code}: {err}"
+
+
+# Gradio interface
+with gr.Blocks(title="Hugging Face Inference (Gradio)") as demo:
+    gr.Markdown("# Hugging Face Inference API — Gradio demo\nEnter a model name and a prompt, then generate text using the official API token stored in environment variables.")
+
+    with gr.Row():
+        with gr.Column(scale=2):
+            model_input = gr.Textbox(label="Model name (eg. gpt2, bigscience/bloom, facebook/opt-350m)", value=DEFAULT_MODEL)
+            prompt_input = gr.Textbox(label="Prompt", placeholder="Write a short story about a curious robot...", lines=6)
+            run_btn = gr.Button("Generate")
+
+        with gr.Column(scale=1):
+            max_tokens = gr.Slider(minimum=1, maximum=1024, step=1, value=128, label="Max new tokens")
+            temperature = gr.Slider(minimum=0.0, maximum=2.0, step=0.1, value=1.0, label="Temperature")
+            top_k = gr.Number(value=None, label="top_k (optional)")
+            output_box = gr.Textbox(label="Generated text / API response", lines=12)
+
+    def on_generate(model, prompt, max_new_tokens, temperature, top_k):
+        return call_hf_inference(model.strip(), prompt, max_new_tokens, temperature, None if top_k is None else int(top_k))
+
+    run_btn.click(on_generate, inputs=[model_input, prompt_input, max_tokens, temperature, top_k], outputs=[output_box])
 
 
-# --- Explicit Uvicorn Startup Block (CRITICAL FIX) ---
 if __name__ == "__main__":
-    # This block ensures the application starts listening on a network port, 
-    # resolving the "application does not seem to be initialized" error.
-    # We use 0.0.0.0 for compatibility with containerized/sandboxed environments.
-    uvicorn.run(app, host="0.0.0.0", port=8000)
+    demo.launch()