Update app.py

app.py

@@ -1,9 +1,11 @@
 import gradio as gr
-import requests # Dodajemy od razu, bo będzie potrzebny
-from PIL import Image # Dodajemy od razu
-import io # Dodajemy od razu
-import os # Do odczytu sekretu
-import traceback # Do lepszego śledzenia błędów
+# requests jest nadal w requirements.txt, ale nie jest już bezpośrednio używany do głównego wywołania API
+import requests
+from PIL import Image
+import io
+import os
+import traceback
+# Poprawny import dla gradio_client
 from gradio_client import Client, file
 import uuid
 import shutil
@@ -12,194 +14,236 @@ print("--- Plik app.py - Start ładowania ---")
 
 # --- Konfiguracja ---
 # Odczytanie sekretu (API Token) ustawionego w Space
-# PAMIĘTAJ, ABY DODAĆ TEN SEKRET W USTAWIENIACH SPACE'A!
-# Settings -> Repository secrets -> New secret
-# Name: HUGGINGFACE_API_TOKEN
-# Value: <twój skopiowany token API>
 API_TOKEN = os.getenv("HUGGINGFACE_API_TOKEN")
 
 # Sprawdzenie, czy token został załadowany
 if not API_TOKEN:
-    print("!!! OSTRZEŻENIE: Nie znaleziono sekretu HUGGINGFACE_API_TOKEN !!!")
-    # Można tu rzucić błąd, ale na razie tylko ostrzegamy
-    # raise ValueError("Nie ustawiono sekretu HUGGINGFACE_API_TOKEN w ustawieniach Space!")
-
-# Endpoint modelu InstantID na Hugging Face Inference API
-API_URL = "https://api-inference.huggingface.co/models/InstantX/InstantID"
+    # Nadal ostrzegamy, ale klient może działać anonimowo
+    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. ---")
 
 # Profesjonalny prompt, który chcemy uzyskać
-# Możesz go później dostosować
 LINKEDIN_PROMPT = (
     "linkedin professional profile photo, corporate headshot, high quality, realistic photograph, "
-    "man/woman [choose one or remove] wearing a dark business suit or elegant blouse, plain white background, "
+    "person wearing a dark business suit or elegant blouse, plain white background, " # Usunięto potencjalnie problematyczne tagi
     "soft studio lighting, sharp focus, looking at camera, slight smile, natural skin texture"
 )
 
-TARGET_SPACE_URL = "https://huggingface.co/spaces/InstantX/InstantID"
-# Uwaga: InstantID może nie być idealny w zmianie ubrań, skupia się na twarzy.
-# Prompt pomaga nadać ogólny styl.
+# Adres publicznego Space'a z InstantID
+# Używamy identyfikatora Space'a dla gradio_client
+TARGET_SPACE_ID = "InstantX/InstantID"
+
+# Kontrolny print, aby sprawdzić, czy zmienna jest ładowana na starcie
+# Powinien pojawić się w logach kontenera po restarcie Space'a
+print(f"--- Konfiguracja załadowana. Cel dla gradio_client: {TARGET_SPACE_ID} ---")
 
 # --- Logika aplikacji ---
 def generate_photo(input_selfie, current_prompt):
+    # Ta funkcja jest teraz wywoływana przez Gradio po kliknięciu przycisku
     print("\n--- Funkcja generate_photo (gradio_client) została wywołana ---")
 
     # 1. Walidacja danych wejściowych
     if input_selfie is None:
-        print("Błąd: Nie wgrano zdjęcia wejściowego.")
-        raise gr.Error("Proszę najpierw wgrać swoje selfie!")
+        print("BŁĄD: Nie wgrano zdjęcia wejściowego.")
+        raise gr.Error("Proszę najpierw wgrać swoje selfie!") # Pokaż błąd w interfejsie
     if not current_prompt:
-        print("Błąd: Prompt jest pusty.")
-        raise gr.Error("Prompt nie może być pusty!")
-    # Sprawdźmy też token, bo może być potrzebny do połączenia z klientem
+        print("BŁĄD: Prompt jest pusty.")
+        raise gr.Error("Prompt (opis zdjęcia) nie może być pusty!")
+    # Informacja o tokenie (nie jest już krytyczny dla działania, ale może wpływać na limity)
     if not API_TOKEN:
-         print("OSTRZEŻENIE: Brak API Tokena. Połączenie z publicznym Space może działać, ale może być ograniczone.")
-         # Nie rzucamy błędu, spróbujemy połączyć się anonimowo
+         print("INFO: Brak API Tokena. Połączenie z publicznym Space jako anonimowy użytkownik.")
 
     print(f"Otrzymano obrazek typu: {type(input_selfie)}, Rozmiar: {input_selfie.size}")
     print(f"Otrzymano prompt (początek): {current_prompt[:100]}...")
 
     # 2. Przygotowanie pliku tymczasowego dla obrazka wejściowego
     temp_dir = f"temp_input_{uuid.uuid4()}" # Unikalny folder tymczasowy
-    os.makedirs(temp_dir, exist_ok=True)
-    input_image_path = os.path.join(temp_dir, "input_selfie.jpg")
+    input_image_path = None # Inicjalizacja na wypadek błędu przed przypisaniem
     try:
+        os.makedirs(temp_dir, exist_ok=True)
+        # Pełna ścieżka do pliku tymczasowego
+        input_image_path = os.path.join(temp_dir, "input_selfie.jpg")
+
         # Upewnijmy się, że obraz jest w RGB przed zapisem jako JPEG
+        # To ważne, bo format JPEG nie obsługuje przezroczystości (kanału alfa)
         rgb_image = input_selfie
         if input_selfie.mode == 'RGBA':
             print("Konwertuję obraz RGBA na RGB z białym tłem przed zapisem...")
+            # Stwórz nowy obraz RGB wypełniony białym kolorem
             rgb_image = Image.new("RGB", input_selfie.size, (255, 255, 255))
+            # Wklej oryginalny obraz używając jego kanału alfa jako maski
             rgb_image.paste(input_selfie, mask=input_selfie.split()[3])
 
+        # Zapisz przetworzony obraz jako JPEG
         rgb_image.save(input_image_path, format="JPEG")
         print(f"Obrazek wejściowy zapisany tymczasowo w: {input_image_path}")
+
     except Exception as e:
         print(f"BŁĄD podczas zapisywania obrazu tymczasowego: {e}")
-        traceback.print_exc()
-        # Spróbuj posprzątać folder tymczasowy
-        if os.path.exists(temp_dir):
-            shutil.rmtree(temp_dir)
+        traceback.print_exc() # Pokaż pełny błąd w logach
+        # Spróbuj posprzątać folder tymczasowy nawet jeśli zapis się nie udał
+        if temp_dir and os.path.exists(temp_dir):
+             try:
+                 shutil.rmtree(temp_dir)
+                 print(f"Folder tymczasowy {temp_dir} usunięty po błędzie zapisu.")
+             except Exception as e_clean:
+                 print(f"OSTRZEŻENIE: Nie udało się usunąć folderu tymczasowego {temp_dir} po błędzie zapisu: {e_clean}")
+        # Pokaż błąd użytkownikowi
         raise gr.Error(f"Problem z przygotowaniem obrazu do wysłania: {e}")
 
     # 3. Wywołanie zdalnego API Gradio za pomocą gradio_client
-    output_image = None
+    output_image = None # Zmienna na wynikowy obrazek
+    client = None # Zmienna na obiekt klienta
     try:
+        # Używamy TARGET_SPACE_ID zdefiniowanej globalnie
         print(f"Łączenie z docelowym Space Gradio: {TARGET_SPACE_ID}")
-        # Inicjalizujemy klienta, przekazując token (może pomóc z limitami)
+        # Inicjalizujemy klienta, przekazując ID Space'a i token (jeśli jest)
         client = Client(TARGET_SPACE_ID, hf_token=API_TOKEN)
-        # Możesz spróbować bez tokena, jeśli są problemy: client = Client(TARGET_SPACE_URL)
-        TARGET_SPACE_ID = "InstantX/InstantID"
-        
-        print("Połączono. Próbuję wywołać funkcję predict...")
 
-        # WAŻNE: Musimy zgadnąć lub sprawdzić (np. przez client.view_api() lub patrząc na UI/API zdalnego Space'a),
-        # jakich dokładnie argumentów i w jakiej kolejności oczekuje funkcja 'predict' w zdalnym Space.
-        # Poniżej jest ZGADYWANA struktura bazująca na typowym demo InstantID. Może wymagać dostosowania!
-        # Argumenty: (Twarz, Poza, Prompt, NegPrompt, Styl, Skala CN, Skala IP)
-        # Używamy `file()` do przekazania ścieżki pliku obrazka.
+        print("Połączono. Próbuję wywołać funkcję na zdalnym Space...")
+
+        # --- Konfiguracja parametrów dla InstantX/InstantID ---
+        # Te wartości mogą wymagać dostosowania w zależności od dokładnej
+        # konfiguracji zdalnego Space'a i pożądanych efektów.
+        negative_prompt = "ugly, deformed, noisy, blurry, low contrast, text, signature, watermark, duplicate, multiple people, cartoon, drawing, illustration, sketch"
+        # Popularne style w demo InstantID: Realistic, (No style), Comic book, Disney, Pixar
+        style_name = "Realistic"
+        # Skale ControlNet i IP-Adapter (siła tożsamości) - typowe wartości to 0.6-1.0
+        cn_scale = 0.8
+        ip_scale = 0.8
+        # Nazwa endpointu API w zdalnym Space'u (często '/predict' lub specyficzna jak '/generate_image')
+        # Dla InstantX/InstantID wydaje się, że to '/generate_image'
+        api_endpoint_name = "/generate_image"
+        # -------------------------------------------------------
 
-        negative_prompt = "ugly, deformed, noisy, blurry, low contrast, text, signature, watermark, duplicate, multiple people"
-        style_name = "Realistic" # Lub "(No style)", "Comic book" etc. - sprawdź opcje w docelowym Space!
+        print(f"Wywołuję endpoint '{api_endpoint_name}' z parametrami:")
+        print(f"  Input image path: {input_image_path}")
+        # Nie drukujemy całego promptu, bo może być długi
+        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}")
 
+        # Wywołanie funkcji 'predict' na zdalnym kliencie
         result = client.predict(
-                        file(input_image_path),  # Argument 1: Obraz twarzy (jako plik)
-                        None,                    # Argument 2: Obraz pozy (opcjonalny, dajemy None)
-                        current_prompt,          # Argument 3: Prompt
-                        negative_prompt,         # Argument 4: Negative prompt
-                        style_name,              # Argument 5: Nazwa stylu
-                        0.8, # Argument 6: Skala ControlNet (zgadnięta wartość domyślna)
-                        0.8, # Argument 7: Skala IdentityNet (IP Adapter) (zgadnięta wartość domyślna)
-                        api_name="/generate_image"	# Zwykle nazywa się '/predict', ale InstantX używa '/generate_image'
-                        # Sprawdź API docelowego space jeśli to nie działa! Może być "/predict"
-                        # Można sprawdzić programowo: client.view_api(all_endpoints=True) i wydrukować w logach
+                        file(input_image_path),  # Obraz twarzy (jako obiekt pliku Gradio)
+                        None,                    # Obraz pozy (opcjonalny, dajemy None)
+                        current_prompt,          # Prompt tekstowy
+                        negative_prompt,         # Negatywny prompt
+                        style_name,              # Nazwa stylu
+                        cn_scale,                # Skala ControlNet
+                        ip_scale,                # Skala IP-Adapter (siła tożsamości)
+                        api_name=api_endpoint_name # Nazwa endpointu API
         )
 
-        # `predict` zwraca wynik zgodny z wyjściami zdalnego API.
-        # Dla InstantID zwykle jest to lista obrazów (nawet jeśli jest jeden).
-        # Często zwraca ścieżkę do pliku (lub listę ścieżek) zapisanego tymczasowo przez gradio_client.
+        # Przetwarzanie wyniku zwróconego przez klienta
         print(f"Otrzymano wynik od klienta: {type(result)}")
-        print(f"Wynik (fragment): {str(result)[:500]}") # Wydrukuj fragment wyniku
+        # Wydrukuj fragment wyniku, aby zobaczyć jego strukturę
+        print(f"Wynik (fragment): {str(result)[:500]}")
 
-        # Sprawdźmy, czy wynik to lista i czy zawiera ścieżkę do pliku
+        # Sprawdzamy, czy wynik jest listą ścieżek do plików (typowe dla Gradio)
         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"Wygląda na to, że otrzymano ścieżkę do obrazka: {output_file_path}")
-            # Wczytaj obrazek wynikowy z tej ścieżki
+            output_file_path = result[0] # Bierzemy pierwszą ścieżkę z listy
+            print(f"Przetwarzam pierwszy obrazek wynikowy ze ścieżki: {output_file_path}")
+            # Wczytaj obrazek wynikowy z tej ścieżki za pomocą Pillow
             output_image = Image.open(output_file_path)
-            print(f"Obrazek wynikowy załadowany. Rozmiar: {output_image.size}")
-        elif isinstance(result, str) and os.path.exists(result): # Czasem zwraca tylko jedną ścieżkę
+            print(f"Obrazek wynikowy załadowany pomyślnie. Rozmiar: {output_image.size}")
+        # Sprawdzamy, czy wynik jest pojedynczą ścieżką do pliku
+        elif isinstance(result, str) and os.path.exists(result):
              output_file_path = result
-             print(f"Wygląda na to, że otrzymano ścieżkę do obrazka: {output_file_path}")
+             print(f"Przetwarzam obrazek wynikowy ze ścieżki: {output_file_path}")
              output_image = Image.open(output_file_path)
-             print(f"Obrazek wynikowy załadowany. Rozmiar: {output_image.size}")
+             print(f"Obrazek wynikowy załadowany pomyślnie. Rozmiar: {output_image.size}")
         else:
-            # Jeśli wynik nie jest oczekiwaną ścieżką, zgłoś błąd
+            # Jeśli wynik nie jest ani listą ścieżek, ani pojedynczą ścieżką
             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 Exception as e:
+        # Obsługa wszelkich błędów podczas komunikacji z klientem lub przetwarzania wyniku
         print(f"BŁĄD podczas komunikacji z klientem Gradio lub przetwarzania wyniku: {e}")
-        traceback.print_exc()
-        raise gr.Error(f"Problem podczas generowania przez zdalny serwis InstantID: {e}")
+        traceback.print_exc() # Pokaż pełny błąd w logach
+        # Spróbuj dać użytkownikowi bardziej pomocny komunikat
+        error_message = f"Problem podczas generowania przez zdalny serwis InstantID: {e}"
+        if "Could not fetch config" in str(e):
+             error_message = f"Nie można połączyć się z konfiguracją zdalnego serwisu ({TARGET_SPACE_ID}). Może być chwilowo niedostępny, przeciążony lub wymagać logowania. Spróbuj ponownie później."
+        elif "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ę."
+        # Pokaż błąd w interfejsie Gradio
+        raise gr.Error(error_message)
 
     finally:
-        # 4. Sprzątanie - usuń folder tymczasowy z plikiem wejściowym
-        if os.path.exists(temp_dir):
+        # 4. Sprzątanie - ZAWSZE próbuj usunąć folder tymczasowy, nawet jeśli był błąd
+        if temp_dir and os.path.exists(temp_dir):
             try:
                 shutil.rmtree(temp_dir)
                 print(f"Folder tymczasowy {temp_dir} usunięty.")
             except Exception as e_clean:
+                # Tylko ostrzeżenie, jeśli sprzątanie się nie uda
                 print(f"OSTRZEŻENIE: Nie udało się usunąć folderu tymczasowego {temp_dir}: {e_clean}")
 
-    # 5. Zwróć wynik (załadowany obrazek PIL)
+    # 5. Zwróć wynik (załadowany obrazek PIL), jeśli się udało
     if output_image:
+        print("Zwracam wygenerowany obrazek do interfejsu Gradio.")
         return output_image
     else:
-        # To nie powinno się zdarzyć, jeśli nie było błędu wcześniej, ale dla pewności:
-        print("BŁĄD: Brak obrazka wynikowego po zakończeniu funkcji.")
-        raise gr.Error("Nie udało się uzyskać obrazka wynikowego.")
+        # Ten kod nie powinien zostać osiągnięty, jeśli błędy są poprawnie obsługiwane
+        print("BŁĄD KRYTYCZNY: Brak obrazka wynikowego po zakończeniu funkcji, 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 ---")
+# Tworzymy główny blok aplikacji Gradio
 with gr.Blocks(css="footer {display: none !important}") as demo: # Ukrywamy domyślny footer Gradio
+    # Tytuł i opis aplikacji wyświetlany użytkownikowi
     gr.Markdown(
         """
         # Generator Profesjonalnych Zdjęć Profilowych
-        Wgraj swoje selfie, a my postaramy się stworzyć profesjonalne zdjęcie w stylu LinkedIn!
-        **Ważne:** Najlepsze efekty uzyskasz wgrywając wyraźne zdjęcie twarzy, patrzącej w miarę prosto, dobrze oświetlonej.
+        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, bądź cierpliwy!
         """
     )
 
+    # Układ interfejsu w dwóch kolumnach
     with gr.Row():
+        # Kolumna lewa (wejście)
         with gr.Column(scale=1):
+            # Komponent do wgrywania obrazka
             input_image = gr.Image(
                 label="1. Wgraj swoje selfie (JPG/PNG)",
                 type="pil" # Chcemy obiekt PIL w funkcji Pythona
             )
-            prompt_input = gr.Textbox( # Dodajemy pole na prompt, z domyślną wartością
-                label="Opcjonalnie: Dostosuj opis zdjęcia (prompt)",
-                value=LINKEDIN_PROMPT,
-                lines=4
+            # Pole tekstowe do wpisania promptu (opisu zdjęcia)
+            prompt_input = gr.Textbox(
+                label="2. Opis pożądanego zdjęcia (prompt)",
+                value=LINKEDIN_PROMPT, # Ustawiamy domyślny prompt
+                lines=4 # Określamy wysokość pola
             )
-            generate_button = gr.Button("✨ Generuj Zdjęcie Biznesowe ✨", variant="primary")
+            # Przycisk uruchamiający generowanie
+            generate_button = gr.Button("✨ Generuj Zdjęcie Biznesowe ✨", variant="primary") # Wyróżniony przycisk
 
+        # Kolumna prawa (wyjście)
         with gr.Column(scale=1):
+            # Komponent do wyświetlania wyniku (obrazka)
             output_image = gr.Image(
                 label="Oto Twoje wygenerowane zdjęcie:",
                 type="pil" # Oczekujemy obiektu PIL jako wynik
             )
-            # Można dodać informację o stanie
-            status_info = gr.Textbox(label="Status", interactive=False)
 
     # --- Podłączenie akcji do przycisku ---
-    # Kiedy przycisk zostanie kliknięty, wywołaj funkcję 'generate_photo'
-    # Przekaż zawartość 'input_image' jako argument do funkcji
-    # Wynik funkcji umieść w komponencie 'output_image'
+    # Definiujemy, co ma się stać po kliknięciu przycisku 'generate_button'
     generate_button.click(
-        fn=generate_photo,
-        inputs=[input_image, prompt_input],       # Lista komponentów wejściowych
-        outputs=[output_image]     # Lista komponentów wyjściowych (na razie jeden)
-        # inputs=[input_image, prompt_input], # Jeśli chcemy przekazać też prompt
-        # outputs=[output_image, status_info] # Jeśli chcemy aktualizować też status
+        fn=generate_photo,                   # Wywołaj funkcję 'generate_photo'
+        inputs=[input_image, prompt_input],  # Przekaż zawartość 'input_image' i 'prompt_input' jako argumenty
+        outputs=[output_image]               # Wynik funkcji umieść w komponencie 'output_image'
     )
 
 print("--- Interfejs Gradio zdefiniowany ---")
@@ -207,5 +251,8 @@ print("--- Interfejs Gradio zdefiniowany ---")
 # --- Uruchomienie aplikacji ---
 if __name__ == "__main__":
     print("--- Uruchamianie demo.launch() ---")
-    demo.launch() # Uruchamia aplikację Gradio
-    print("--- demo.launch() zakończone (?) ---") # Ten print może się nie pojawić od razu w logach
+    # Uruchamiamy aplikację Gradio
+    # share=False: nie generuj publicznego linku (zalecane dla bezpieczeństwa)
+    # debug=False: wyłącz tryb debugowania Gradio (zalecane dla produkcji)
+    demo.launch(share=False, debug=False)
+    print("--- Aplikacja Gradio zakończyła działanie (jeśli nie jest w trybie ciągłym serwera) ---")