app.py

# import gradio as gr
# import requests
# import base64
# from PIL import Image
# import io

# gr.set_page_config(page_title="AI Image Detector", page_icon="🔍")

# gr.title("AI Image Detector")
# gr.write("Upload an image to check if it's AI-generated")


# api_key = NVIDIA_API_KEY
# gr.session_state.api_key = api_key

# def process_image(image_bytes, api_key):
#     header_auth = f"Bearer {api_key}"
#     invoke_url = "https://ai.api.nvidia.com/v1/cv/hive/ai-generated-image-detection"
    
#     # Convert image bytes to base64
#     image_b64 = base64.b64encode(image_bytes).decode()
    
#     payload = {
#         "input": [f"data:image/png;base64,{image_b64}"]
#     }

#     headers = {
#         "Content-Type": "application/json",
#         "Authorization": header_auth,
#         "Accept": "application/json",
#     }
    
#     try:
#         response = requests.post(invoke_url, headers=headers, json=payload)
#         response.raise_for_status()
#         result = response.json()
        
#         # Check if response contains the expected structure
#         if 'data' in result and len(result['data']) > 0:
#             first_result = result['data'][0]
#             if 'is_ai_generated' in first_result:
#                 return {
#                     'confidence': first_result['is_ai_generated'],
#                     'sources': first_result.get('possible_sources', {}),
#                     'status': first_result.get('status', 'UNKNOWN')
#                 }
        
#         gr.error("Unexpected response format from API")
#         return None
            
#     except requests.exceptions.RequestException as e:
#         gr.error(f"Error processing image: {str(e)}")
#         return None

# # File uploader
# uploaded_file = gr.file_uploader("Choose an image...", type=['png', 'jpg', 'jpeg'])

# if uploaded_file is not None and api_key:
#     # Display the uploaded image
#     image = Image.open(uploaded_file)
#     gr.image(image, caption="Uploaded Image", use_container_width=True)
    
#     # Convert image to bytes
#     img_byte_arr = io.BytesIO()
#     image.save(img_byte_arr, format=image.format)
#     img_byte_arr = img_byte_arr.getvalue()
    
#     # Process the image
#     with gr.spinner("Analyzing image..."):

#         result = process_image(img_byte_arr, api_key)
        
#         if result and result['status'] == 'SUCCESS':
#             confidence = result['confidence']
#             sources = result['sources']
            
#             gr.write("---")
#             gr.write("### Result")
            
#             # Determine if image is AI-generated (using 50% threshold)
#             is_ai_generated = "Yes" if confidence >= 0.5 else "No"
            
#             # Display result with appropriate styling
#             if is_ai_generated == "Yes":
#                 gr.error(f"Is this image AI-generated? **{is_ai_generated}**")
                
#                 # Show top 3 possible sources if AI-generated
#                 if sources:
#                     gr.write("Top possible AI models used:")
#                     sorted_sources = sorted(sources.items(), key=lambda x: x[1], reverse=True)[:3]
#                     for source, prob in sorted_sources:
#                         if prob > 0.01:  # Only show sources with >1% probability
#                             gr.write(f"- {source}: {prob:.1%}")
#             else:
#                 gr.success(f"Is this image AI-generated? **{is_ai_generated}**")
            
#             # Show confidence score in smaller text
#             gr.caption(f"Confidence score: {confidence:.2%}")

# elif not api_key and uploaded_file is not None:
#     gr.warning("Please enter your NVIDIA API key first")

# # Add footer with instructions
# gr.markdown("---")
# gr.markdown("""
# ---
# ### How to use:

# 1. Upload an image (PNG, JPG, or JPEG)
# 2. Wait for the analysis result
# 3. Get a ** Yes/No ** answer based on whether the image is AI-generated

# """)

import gradio as gr
import requests

import base64
from PIL import Image
import io
import os

def process_image(image):
    """Process the uploaded image using NVIDIA's AI detection API"""
    # Get API key from environment variable for security
    api_key = os.getenv('NVIDIA_API_KEY')
    if not api_key:
        raise ValueError("NVIDIA API key not found in environment variables")
    
    header_auth = f"Bearer {api_key}"
    invoke_url = "https://ai.api.nvidia.com/v1/cv/hive/ai-generated-image-detection"
    
    # Convert PIL Image to bytes
    img_byte_arr = io.BytesIO()
    image.save(img_byte_arr, format='PNG')
    image_bytes = img_byte_arr.getvalue()
    
    # Convert image bytes to base64
    image_b64 = base64.b64encode(image_bytes).decode()
    
    payload = {
        "input": [f"data:image/png;base64,{image_b64}"]
    }
    headers = {
        "Content-Type": "application/json",
        "Authorization": header_auth,
        "Accept": "application/json",
    }
    
    try:
        response = requests.post(invoke_url, headers=headers, json=payload)
        response.raise_for_status()
        result = response.json()
        
        if 'data' in result and len(result['data']) > 0:
            first_result = result['data'][0]
            if 'is_ai_generated' in first_result:
                confidence = first_result['is_ai_generated']
                sources = first_result.get('possible_sources', {})
                
                # Format the result message
                is_ai_generated = "<span style='color:red'>### Yes</span>" if confidence >= 0.5 else "<span style='color:green'>### No</span>"
                result_message = f"\n ### Is this image AI-generated? {is_ai_generated}\n"
                result_message += f"\n Confidence score: {confidence:.2%}\n\n"

                if is_ai_generated == "Yes" and sources:
                    result_message += "\n **Top possible AI models used** :\n"
                    sorted_sources = sorted(sources
                    .items(), key=lambda x: x[1], reverse=True)[:3]
                    for source, prob in sorted_sources:
                        if prob > 0.01:
                            result_message += f"- {source}: {prob:.1%}\n"
                
                return image, result_message
                
        return image, "Error: Unable to process image analysis results"
            
    except requests.exceptions.RequestException as e:
        return image, f"Error processing image: {str(e)}"

def create_demo():
    """Create and return the Gradio interface"""
    demo = gr.Interface(
        fn=process_image,
        inputs=gr.Image(type="pil", label="Upload Image"),
        outputs=[
            gr.Image(type="pil", label="Analyzed Image"
),
            gr.Markdown(label=" ## Analysis Results")
        ],
        title="AI Image Detector",
        
        description="Upload an image to check if it's AI-generated",
        article="""
        ### How to use:
        1. Upload an image (PNG, JPG, or JPEG)
        2. Click the 'Submit' button
        3. Get a detailed analysis of whether the image is AI-generated alongside the Model that might be used in generation.
        """,
        css=".footer {display: none;}"
    )
    return demo

# Create and launch the application
if __name__ == "__main__":
    demo= create_demo()
    demo.launch(
        show_api=False,
        show_error=False,
        share=False,
        quiet=True
        
        
    )