# pip install gradio
import gradio as gr

# ===========================
# 1. Minimal — literally 3 lines!
# ===========================
def greet(name):
    return f"Hello, {name}! Welcome to Hugging Face 🤗"

demo = gr.Interface(fn=greet, inputs="text", outputs="text")
demo.launch()
# → Opens http://127.0.0.1:7860 in browser!
# → Beautiful UI with textbox input, submit button, output area
# → Auto-generated API at /api/predict

# ===========================
# 2. With HF model — sentiment analysis app!
# ===========================
from transformers import pipeline
classifier = pipeline("sentiment-analysis")

def analyze_sentiment(text):
    result = classifier(text)[0]
    return f"{result['label']} ({result['score']:.1%})"

demo = gr.Interface(
    fn=analyze_sentiment,
    inputs=gr.Textbox(label="Enter text", placeholder="Type something...", lines=3),
    outputs=gr.Textbox(label="Sentiment"),
    title="🎭 Sentiment Analyzer",
    description="Analyze the sentiment of any English text using DistilBERT.",
    examples=[
        ["I absolutely love this product!"],
        ["This was the worst experience ever."],
        ["The movie was okay, nothing special."],
    ],
    theme=gr.themes.Soft(),   # built-in themes: Default, Soft, Glass, Monochrome
)
demo.launch(share=True)      # share=True → public URL (72 hours)!
# → "Running on public URL: https://xxxxx.gradio.live"
# Share this URL with anyone! They can use your model from their phone!

import gradio as gr
from transformers import pipeline

classifier = pipeline("sentiment-analysis")

def analyze(text):
    result = classifier(text)[0]
    return {result["label"]: result["score"], "OPPOSITE": 1 - result["score"]}

demo = gr.Interface(
    fn=analyze,
    inputs=gr.Textbox(label="Enter text", lines=3, placeholder="Type a review..."),
    outputs=gr.Label(num_top_classes=2, label="Sentiment"),
    title="🎭 Sentiment Analyzer",
    examples=[["I love this!"], ["Terrible product."], ["It's okay."]],
)
demo.launch()

import gradio as gr
from transformers import pipeline

ner = pipeline("ner", grouped_entities=True)

def extract_entities(text):
    entities = ner(text)
    # Format for HighlightedText: list of (text, label) tuples
    highlights = []
    last_end = 0
    for e in entities:
        if e["start"] > last_end:
            highlights.append((text[last_end:e["start"]], None))
        highlights.append((text[e["start"]:e["end"]], e["entity_group"]))
        last_end = e["end"]
    if last_end < len(text):
        highlights.append((text[last_end:], None))
    return highlights

demo = gr.Interface(
    fn=extract_entities,
    inputs=gr.Textbox(label="Text", lines=3,
        placeholder="Joko Widodo visited Google in California..."),
    outputs=gr.HighlightedText(label="Entities",
        color_map={"PER": "#ff6b6b", "ORG": "#4ecdc4",
                   "LOC": "#45b7d1", "MISC": "#f9ca24"}),
    title="🏷️ Named Entity Recognition",
    examples=[["Elon Musk founded SpaceX in California."]],
)
demo.launch()

import gradio as gr
from transformers import pipeline

generator = pipeline("text-generation", model="gpt2")

def generate(prompt, temperature, max_tokens):
    result = generator(prompt, max_new_tokens=int(max_tokens),
                       temperature=temperature, do_sample=True, top_p=0.9)
    return result[0]["generated_text"]

demo = gr.Interface(
    fn=generate,
    inputs=[
        gr.Textbox(label="Prompt", lines=2, placeholder="Once upon a time..."),
        gr.Slider(0.1, 2.0, value=0.7, step=0.1, label="Temperature"),
        gr.Slider(10, 200, value=50, step=10, label="Max Tokens"),
    ],
    outputs=gr.Textbox(label="Generated Text", lines=8),
    title="✍️ GPT-2 Text Generator",
    examples=[["The future of AI is", 0.7, 80], ["Once upon a time", 0.9, 100]],
)
demo.launch()

import gradio as gr
from transformers import pipeline

qa = pipeline("question-answering")

def answer_question(context, question):
    result = qa(question=question, context=context)
    return f"**{result['answer']}** (confidence: {result['score']:.1%})"

demo = gr.Interface(
    fn=answer_question,
    inputs=[
        gr.Textbox(label="Context", lines=5,
            value="Indonesia is a country in Southeast Asia. Jakarta is the capital."),
        gr.Textbox(label="Question", placeholder="What is the capital?"),
    ],
    outputs=gr.Markdown(label="Answer"),
    title="❓ Question Answering",
)
demo.launch()

import gradio as gr
from transformers import pipeline

sentiment = pipeline("sentiment-analysis")
ner_pipe = pipeline("ner", grouped_entities=True)
generator = pipeline("text-generation", model="gpt2")

with gr.Blocks(title="🤗 NLP Toolkit", theme=gr.themes.Soft()) as demo:
    gr.Markdown("# 🤗 NLP Toolkit\nMultiple NLP tools in one app!")

    with gr.Tab("🎭 Sentiment"):
        with gr.Row():
            sent_input = gr.Textbox(label="Text", lines=3)
            sent_output = gr.Label(num_top_classes=2)
        sent_btn = gr.Button("Analyze", variant="primary")
        sent_btn.click(lambda t: {r["label"]: r["score"] for r in sentiment(t)},
                       sent_input, sent_output)

    with gr.Tab("🏷️ NER"):
        ner_input = gr.Textbox(label="Text", lines=3)
        ner_output = gr.JSON(label="Entities")
        ner_btn = gr.Button("Extract", variant="primary")
        ner_btn.click(lambda t: ner_pipe(t), ner_input, ner_output)

    with gr.Tab("✍️ Generate"):
        with gr.Row():
            gen_input = gr.Textbox(label="Prompt", lines=2, scale=3)
            gen_temp = gr.Slider(0.1, 2.0, value=0.7, label="Temp", scale=1)
        gen_output = gr.Textbox(label="Result", lines=6)
        gen_btn = gr.Button("Generate", variant="primary")
        gen_btn.click(
            lambda p, t: generator(p, max_new_tokens=80, temperature=t,
                                  do_sample=True)[0]["generated_text"],
            [gen_input, gen_temp], gen_output)

demo.launch()

import gradio as gr
from transformers import pipeline

generator = pipeline("text-generation", model="gpt2")

# ===========================
# 1. Basic ChatInterface
# ===========================
def respond(message, history):
    """
    message: user's latest message (str)
    history: list of [user_msg, bot_msg] pairs
    """
    # Build conversation context
    prompt = ""
    for user_msg, bot_msg in history[-3:]:  # last 3 turns for context
        prompt += f"User: {user_msg}\nAssistant: {bot_msg}\n"
    prompt += f"User: {message}\nAssistant:"

    result = generator(prompt, max_new_tokens=100, do_sample=True,
                       temperature=0.7, top_p=0.9, repetition_penalty=1.2)
    response = result[0]["generated_text"][len(prompt):]

    # Stop at next "User:" to prevent multi-turn generation
    if "User:" in response:
        response = response[:response.index("User:")]
    return response.strip()

demo = gr.ChatInterface(
    fn=respond,
    title="🤖 GPT-2 Chatbot",
    description="Chat with GPT-2. (Small model — limited quality, for demo purposes.)",
    examples=["What is machine learning?", "Tell me a joke", "Explain Python in one sentence"],
    retry_btn="🔄 Retry",
    undo_btn="↩️ Undo",
    clear_btn="🗑️ Clear",
)
demo.launch()
# → Beautiful ChatGPT-style UI with message bubbles!
# → History automatically maintained
# → Retry, Undo, Clear buttons built-in

# ===========================
# 2. Streaming ChatInterface (token-by-token like ChatGPT!)
# ===========================
def respond_streaming(message, history):
    # Use yield for streaming!
    prompt = f"User: {message}\nAssistant:"
    partial = ""
    # Simulate streaming (real streaming needs TextIteratorStreamer)
    result = generator(prompt, max_new_tokens=80, do_sample=True, temperature=0.7)
    text = result[0]["generated_text"][len(prompt):]
    for char in text:
        partial += char
        yield partial  # ← yield for streaming!

demo_stream = gr.ChatInterface(fn=respond_streaming, title="🤖 Streaming Chatbot")
demo_stream.launch()

# ===========================
# Method 1: Melalui website (PALING MUDAH)
# ===========================
# 1. Buka huggingface.co/new-space
# 2. Isi: Space name, License, SDK = "Gradio"
# 3. Klik "Create Space"
# 4. Upload 2 file:
#    - app.py (kode Gradio Anda)
#    - requirements.txt (dependencies)
# 5. Otomatis build & deploy!
# 6. URL: https://huggingface.co/spaces/USERNAME/SPACE_NAME

# ===========================
# Method 2: Melalui git (LEBIH BAIK untuk iterasi)
# ===========================
# 1. Create space di website
# 2. Clone:
git clone https://huggingface.co/spaces/USERNAME/my-sentiment-app
cd my-sentiment-app

# 3. Buat app.py:
cat > app.py <<'EOF'
import gradio as gr
from transformers import pipeline

classifier = pipeline("sentiment-analysis")

def analyze(text):
    result = classifier(text)[0]
    return {result["label"]: result["score"]}

demo = gr.Interface(fn=analyze, inputs="text", outputs=gr.Label(),
                    title="🎭 Sentiment Analyzer")
demo.launch()
EOF

# 4. Buat requirements.txt:
cat > requirements.txt <<'EOF'
transformers
torch
gradio
EOF

# 5. Push!
git add . && git commit -m "Initial deploy" && git push
# → Auto-build (~2-3 menit pertama kali)
# → Live di: https://USERNAME-my-sentiment-app.hf.space

# ===========================
# Pricing
# ===========================
# CPU basic:   GRATIS! (2 vCPU, 16GB RAM)
# CPU upgrade:  $0.03/hr (8 vCPU, 32GB RAM)
# GPU T4:       $0.60/hr (for inference)
# GPU A10G:     $1.05/hr
# GPU A100:     $4.13/hr
#
# Untuk sentiment/NER/QA → CPU GRATIS sudah cukup!
# Untuk text generation → perlu GPU

import gradio as gr
import faiss, numpy as np
from sentence_transformers import SentenceTransformer
from transformers import pipeline

# ===========================
# 1. Setup retriever + generator
# ===========================
retriever = SentenceTransformer("all-MiniLM-L6-v2")
generator = pipeline("text2text-generation", model="google/flan-t5-small")

# Knowledge base (replace with your own documents!)
knowledge_base = [
    "Jakarta is the capital of Indonesia with a population of 10.56 million.",
    "Indonesia declared independence on August 17, 1945.",
    "Python was created by Guido van Rossum and released in 1991.",
    "TensorFlow is an open-source ML framework developed by Google.",
    "Hugging Face provides the Transformers library for NLP tasks.",
    "BERT was published by Google in 2018 for bidirectional language understanding.",
    "Mount Bromo is an active volcano in East Java, standing at 2,329 meters.",
    "Bali is Indonesia's most popular tourist destination, known for temples.",
]

# Build FAISS index
kb_embeddings = retriever.encode(knowledge_base, convert_to_numpy=True)
faiss.normalize_L2(kb_embeddings)
index = faiss.IndexFlatIP(kb_embeddings.shape[1])
index.add(kb_embeddings)

# ===========================
# 2. RAG function
# ===========================
def rag_chat(message, history):
    # Retrieve relevant documents
    q_emb = retriever.encode([message], convert_to_numpy=True)
    faiss.normalize_L2(q_emb)
    scores, indices = index.search(q_emb, 2)
    context = " ".join([knowledge_base[i] for i in indices[0]])

    # Generate answer
    prompt = f"Based on this context, answer the question.\nContext: {context}\nQuestion: {message}\nAnswer:"
    result = generator(prompt, max_length=150)
    answer = result[0]["generated_text"]

    # Add source info
    sources = "\n\n📚 Sources:\n" + "\n".join(
        [f"- {knowledge_base[i][:80]}..." for i in indices[0]])

    return answer + sources

# ===========================
# 3. Gradio ChatInterface
# ===========================
demo = gr.ChatInterface(
    fn=rag_chat,
    title="🧩 RAG Chatbot — Knowledge-Grounded QA",
    description="Ask questions about Indonesia, Python, or AI. Answers grounded in a knowledge base!",
    examples=[
        "What is the capital of Indonesia?",
        "When did Indonesia become independent?",
        "What is TensorFlow?",
        "Tell me about Mount Bromo",
    ],
    theme=gr.themes.Soft(),
)
demo.launch()
# → RAG chatbot with knowledge-grounded answers!
# → Shows sources for each answer
# → Deploy to HF Spaces → free public RAG chatbot!