app.py

# -*- coding: utf-8 -*-

import gradio as gr
# import requests # Nadal nieużywany bezpośrednio
from PIL import Image, ImageOps
import io
import os
import traceback
from gradio_client import Client, handle_file
import uuid
import shutil
from gradio_client.exceptions import AppError

print("--- Plik app.py - Start ładowania ---")

# --- Konfiguracja ---
API_TOKEN = os.getenv("HUGGINGFACE_API_TOKEN")
if not API_TOKEN:
    print("!!! OSTRZEŻENIE: Nie znaleziono sekretu HUGGINGFACE_API_TOKEN. Klient Gradio spróbuje połączyć się anonimowo (mogą obowiązywać limity). !!!")
else:
    print("--- Sekret HUGGINGFACE_API_TOKEN załadowany. ---")

LINKEDIN_PROMPT = (
    "linkedin professional profile photo, corporate headshot, high quality, realistic photograph, "
    "person wearing a dark business suit or elegant blouse, plain white background, "
    "soft studio lighting, sharp focus, looking at camera, slight smile, natural skin texture"
)
TARGET_SPACE_ID = "InstantX/InstantID"
print(f"--- Konfiguracja załadowana. Cel dla gradio_client: {TARGET_SPACE_ID} ---")


# --- Logika aplikacji ---
def generate_photo(input_selfie, current_prompt):
    print("\n--- Funkcja generate_photo (gradio_client) została wywołana ---")

    # 1. Walidacja
    if input_selfie is None:
        print("BŁĄD: Nie wgrano zdjęcia wejściowego.")
        raise gr.Error("Proszę najpierw wgrać swoje selfie!")
    if not current_prompt:
        print("BŁĄD: Prompt jest pusty.")
        raise gr.Error("Prompt (opis zdjęcia) nie może być pusty!")
    if not API_TOKEN:
         print("INFO: Brak API Tokena. Połączenie z publicznym Space jako anonimowy użytkownik.")

    print(f"Otrzymano obrazek typu: {type(input_selfie)}, Oryginalny rozmiar: {input_selfie.size}")
    print(f"Otrzymano prompt (początek): {current_prompt[:100]}...")

    # 2. Skalowanie obrazka
    input_selfie_resized = None
    try:
        max_size = (1024, 1024)
        input_selfie_resized = input_selfie.copy()
        input_selfie_resized.thumbnail(max_size, Image.Resampling.LANCZOS)
        print(f"Obrazek przeskalowany do (maksymalnie) {max_size}. Nowy rozmiar: {input_selfie_resized.size}")
    except Exception as e_resize:
         print(f"BŁĄD podczas skalowania obrazka: {e_resize}")
         traceback.print_exc()
         raise gr.Error(f"Nie można przeskalować obrazka wejściowego: {e_resize}")

    # 3. Przygotowanie pliku tymczasowego
    temp_dir = f"temp_input_{uuid.uuid4()}"
    input_image_path = None
    try:
        os.makedirs(temp_dir, exist_ok=True)
        input_image_path = os.path.join(temp_dir, "input_selfie.jpg")
        rgb_image = input_selfie_resized
        if rgb_image.mode == 'RGBA':
            print("Konwertuję przeskalowany obraz RGBA na RGB z białym tłem...")
            final_image = Image.new("RGB", rgb_image.size, (255, 255, 255))
            final_image.paste(rgb_image, mask=rgb_image.split()[3])
        elif rgb_image.mode != 'RGB':
            print(f"Konwertuję przeskalowany obraz z trybu {rgb_image.mode} na RGB...")
            final_image = rgb_image.convert('RGB')
        else:
             final_image = rgb_image
        final_image.save(input_image_path, format="JPEG")
        print(f"Przeskalowany obrazek wejściowy zapisany tymczasowo w: {input_image_path}")
    except Exception as e_save:
        print(f"BŁĄD podczas zapisywania obrazu tymczasowego: {e_save}")
        traceback.print_exc()
        if os.path.exists(temp_dir):
             try: shutil.rmtree(temp_dir)
             except Exception as e_clean: print(f"OSTRZEŻENIE: Nie udało się usunąć {temp_dir}: {e_clean}")
        raise gr.Error(f"Problem z przygotowaniem obrazu do wysłania: {e_save}")

    # 4. Wywołanie zdalnego API Gradio
    output_image = None
    client = None
    try:
        print(f"Łączenie z docelowym Space Gradio: {TARGET_SPACE_ID}")
        client = Client(TARGET_SPACE_ID, hf_token=API_TOKEN)
        # Usunięto odwołanie do client.space_host, zastąpiono prostszym printem:
        print(f"Połączono z {TARGET_SPACE_ID}. Klient zainicjalizowany.")

        print("Próbuję wywołać funkcję na zdalnym Space...")
        negative_prompt = "ugly, deformed, noisy, blurry, low contrast, text, signature, watermark, duplicate, multiple people, cartoon, drawing, illustration, sketch, bad anatomy, worst quality, low quality"
        style_name = "Realistic"
        cn_scale = 0.8
        ip_scale = 0.8
        api_endpoint_name = "/generate_image"

        print(f"Wywołuję endpoint '{api_endpoint_name}' z parametrami:")
        print(f"  Input image path: {input_image_path}")
        print(f"  Prompt (start): {current_prompt[:60]}...")
        print(f"  Negative Prompt (start): {negative_prompt[:60]}...")
        print(f"  Style: {style_name}")
        print(f"  ControlNet Scale: {cn_scale}")
        print(f"  IP-Adapter Scale: {ip_scale}")

        # UWAGA: file() jest przestarzałe. Jeśli pojawią się błędy, spróbuj Client(..., serialize=False)
        # i przekazuj pełną ścieżkę jako string: input_image_path zamiast file(input_image_path)
        # Ale na razie zostawiamy file()
        result = client.predict(
                        handle_file(input_image_path),
                        None,
                        current_prompt,
                        negative_prompt,
                        style_name,
                        cn_scale,
                        ip_scale,
                        api_name=api_endpoint_name
        )

        print(f"Otrzymano wynik od klienta: {type(result)}")
        print(f"Wynik (fragment): {str(result)[:500]}")

        if isinstance(result, list) and len(result) > 0 and isinstance(result[0], str) and os.path.exists(result[0]):
            output_file_path = result[0]
            print(f"Przetwarzam pierwszy obrazek wynikowy ze ścieżki: {output_file_path}")
            output_image = Image.open(output_file_path)
            print(f"Obrazek wynikowy załadowany pomyślnie. Rozmiar: {output_image.size}")
        elif isinstance(result, str) and os.path.exists(result):
             output_file_path = result
             print(f"Przetwarzam obrazek wynikowy ze ścieżki: {output_file_path}")
             output_image = Image.open(output_file_path)
             print(f"Obrazek wynikowy załadowany pomyślnie. Rozmiar: {output_image.size}")
        else:
            print(f"BŁĄD: Otrzymano nieoczekiwany format wyniku od gradio_client: {type(result)}")
            raise gr.Error(f"Nie udało się przetworzyć wyniku ze zdalnego API. Otrzymano: {str(result)[:200]}")

    except AppError as e:
        print(f"BŁĄD APLIKACJI ZDALNEJ (AppError): {e}")
        traceback.print_exc()
        error_message = f"Zdalny serwis ({TARGET_SPACE_ID}) zgłosił wewnętrzny błąd. Może to być spowodowane problemami z obrazkiem (np. brak wykrytej twarzy, nietypowy format), niedostępnością modelu lub przeciążeniem serwisu. Spróbuj z innym, wyraźnym zdjęciem twarzy lub spróbuj ponownie później."
        raise gr.Error(error_message)
    except ValueError as e:
        print(f"BŁĄD WARTOŚCI (ValueError): {e}")
        traceback.print_exc()
        error_message = f"Wystąpił błąd wartości: {e}. "
        if "Could not fetch config" in str(e):
             error_message = f"Nie można pobrać konfiguracji zdalnego serwisu ({TARGET_SPACE_ID}). Może być chwilowo niedostępny, niekompatybilny lub wymagać logowania. Sprawdź status serwisu lub spróbuj później."
        raise gr.Error(error_message)
    except Exception as e:
        print(f"NIEOCZEKIWANY BŁĄD: {e}")
        traceback.print_exc()
        error_message = f"Wystąpił nieoczekiwany błąd: {e}. Sprawdź logi aplikacji."
        if "timed out" in str(e).lower():
             error_message = "Przekroczono limit czasu oczekiwania na odpowiedź ze zdalnego serwisu. Może być przeciążony. Spróbuj ponownie."
        elif "queue full" in str(e).lower():
             error_message = "Kolejka w zdalnym serwisie jest pełna. Spróbuj ponownie za chwilę."
        raise gr.Error(error_message)

    finally:
        # 5. Sprzątanie
        if input_image_path and os.path.exists(temp_dir):
            try:
                shutil.rmtree(temp_dir)
                print(f"Folder tymczasowy {temp_dir} usunięty.")
            except Exception as e_clean:
                print(f"OSTRZEŻENIE: Nie udało się usunąć folderu tymczasowego {temp_dir}: {e_clean}")

    # 6. Zwróć wynik
    if output_image:
        print("Zwracam wygenerowany obrazek do interfejsu Gradio.")
        return output_image
    else:
        print("BŁĄD KRYTYCZNY: Brak obrazka wynikowego, a nie zgłoszono błędu.")
        raise gr.Error("Nie udało się uzyskać obrazka wynikowego z nieznanego powodu.")


# --- Budowa Interfejsu Gradio ---
print("--- Definiowanie interfejsu Gradio ---")
with gr.Blocks(css="footer {display: none !important;}", title="Generator Zdjęć Biznesowych") as demo:
    gr.Markdown(
        """
        # Generator Profesjonalnych Zdjęć Profilowych
        Wgraj swoje selfie, a my (korzystając z modelu InstantID) postaramy się stworzyć profesjonalne zdjęcie w stylu LinkedIn!
        **Wskazówki:**
        *   Użyj wyraźnego zdjęcia twarzy, patrzącej w miarę prosto, dobrze oświetlonej.
        *   Unikaj zdjęć grupowych, bardzo małych lub z mocno zasłoniętą twarzą.
        *   Generowanie może potrwać **od 30 sekund do kilku minut** (zwłaszcza za pierwszym razem). Bądź cierpliwy!
        """
    )
    with gr.Row():
        with gr.Column(scale=1):
            input_image = gr.Image(label="1. Wgraj swoje selfie (JPG/PNG)", type="pil", sources=["upload", "webcam"])
            prompt_input = gr.Textbox(label="2. Opis pożądanego zdjęcia (prompt)", value=LINKEDIN_PROMPT, lines=4)
            generate_button = gr.Button("✨ Generuj Zdjęcie Biznesowe ✨", variant="primary", scale=1)
        with gr.Column(scale=1):
            output_image = gr.Image(label="Oto Twoje wygenerowane zdjęcie:", type="pil")

    generate_button.click(
        fn=generate_photo,
        inputs=[input_image, prompt_input],
        outputs=[output_image]
    )
print("--- Interfejs Gradio zdefiniowany ---")

# --- Uruchomienie aplikacji ---
if __name__ == "__main__":
    print("--- Uruchamianie demo.launch() ---")
    demo.launch()
    print("--- Aplikacja Gradio zakończyła działanie ---")