Update app.py

app.py

@@ -4,6 +4,9 @@ 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
+import gradio_client import Client, file
+import uuid
+import shutil
 
 print("--- Plik app.py - Start ładowania ---")
 
@@ -31,13 +34,15 @@ LINKEDIN_PROMPT = (
     "man/woman [choose one or remove] 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_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.
 
 # --- Logika aplikacji ---
-# Na razie pusta funkcja, którą podłączymy do przycisku
-def generate_photo(input_selfie, current_prompt): # Dodajemy prompt jako wejście
-    print("\n--- Funkcja generate_photo została wywołana ---")
+def generate_photo(input_selfie, current_prompt):
+    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.")
@@ -45,118 +50,112 @@ def generate_photo(input_selfie, current_prompt): # Dodajemy prompt jako wejści
     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
     if not API_TOKEN:
-        print("KRYTYCZNY BŁĄD: Brak API Tokena!")
-        raise gr.Error("Błąd konfiguracji serwera: Brak API Tokena. Skontaktuj się z administratorem.")
+         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(f"Otrzymano obrazek typu: {type(input_selfie)}, Rozmiar: {input_selfie.size}")
     print(f"Otrzymano prompt (początek): {current_prompt[:100]}...")
-    print("Przygotowuję dane do wysłania do API...")
 
-    # 2. Przygotowanie danych do wysłania (Obrazek jako bajty)
+    # 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")
     try:
-        buffered = io.BytesIO()
-        # Sprawdźmy format i ewentualnie skonwertujmy tło dla PNG z przezroczystością
-        image_format = "JPEG" # Preferowany format dla wielu API
-        processed_image = input_selfie
+        # Upewnijmy się, że obraz jest w RGB przed zapisem jako JPEG
+        rgb_image = input_selfie
         if input_selfie.mode == 'RGBA':
-            print("Konwertuję obraz RGBA na RGB z białym tłem...")
-            processed_image = Image.new("RGB", input_selfie.size, (255, 255, 255))
-            processed_image.paste(input_selfie, mask=input_selfie.split()[3]) # Wklej z maską alfa
+            print("Konwertuję obraz RGBA na RGB z białym tłem przed zapisem...")
+            rgb_image = Image.new("RGB", input_selfie.size, (255, 255, 255))
+            rgb_image.paste(input_selfie, mask=input_selfie.split()[3])
 
-        processed_image.save(buffered, format=image_format)
-        buffered.seek(0)
-        print(f"Obrazek przekonwertowany do formatu {image_format} i zapisany w buforze.")
+        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 przetwarzania obrazu: {e}")
-        traceback.print_exc() # Wydrukuj pełny ślad błędu w logach
-        raise gr.Error(f"Wystąpił błąd podczas przetwarzania Twojego zdjęcia: {e}")
-
-    # 3. Przygotowanie nagłówków i danych dla API
-    headers = {
-        "Authorization": f"Bearer {API_TOKEN}"
-        # Content-Type zostanie ustawiony automatycznie przez requests dla multipart/form-data
-    }
-
-    # InstantID (i wiele modeli image-to-image w Inference API) oczekuje
-    # obrazu w 'files' i parametrów (jak prompt) w 'data'.
-    # WAŻNE: Nazwa klucza dla obrazu ('image') i promptu ('prompt')
-    # MUSI odpowiadać temu, czego oczekuje API modelu Sxela/instant-id.
-    # Sprawdź dokumentację modelu na HF, jeśli to nie zadziała!
-    files = {
-        'image': ('input_selfie.jpg', buffered, f'image/{image_format.lower()}')
-    }
-    payload = {
-        'prompt': current_prompt
-        # Możesz tu dodać inne parametry wspierane przez model, np.:
-        # 'negative_prompt': 'cartoon, drawing, illustration, sketch, duplicate heads, multiple people',
-        # 'num_inference_steps': 30,
-        # 'guidance_scale': 5.0,
-    }
-
-    print(f"Wysyłam zapytanie POST do: {API_URL}")
-    print(f"Payload (parametry tekstowe): {payload}")
-    # Nie drukujemy 'files', bo zawiera dane binarne
-
-    # 4. Wywołanie API i obsługa odpowiedzi
-    try:
-        # Zwiększamy timeout, bo generowanie może chwilę potrwać
-        response = requests.post(API_URL, headers=headers, data=payload, files=files, timeout=180) # 3 minuty timeout
-
-        print(f"Otrzymano odpowiedź od API. Status: {response.status_code}")
-        # Zawsze sprawdzaj content-type odpowiedzi!
-        content_type = response.headers.get('Content-Type', '')
-        print(f"Content-Type odpowiedzi: {content_type}")
-
-        # Rzuć wyjątek dla złych statusów (4xx, 5xx)
-        response.raise_for_status()
-
-        # Sprawdź, czy odpowiedź to na pewno obrazek
-        if 'image' not in content_type:
-            # Jeśli API zwróciło sukces (200), ale nie obrazek, to prawdopodobnie błąd w JSON
-            print(f"BŁĄD: API zwróciło status {response.status_code} ale nie obrazek (Content-Type: {content_type}). Treść:")
-            # Spróbuj wydrukować treść jako tekst (może zawierać komunikat błędu)
-            try:
-                print(response.text[:1000]) # Pokaż do 1000 znaków
-                raise gr.Error(f"API zwróciło nieoczekiwany format danych zamiast obrazka. Szczegóły: {response.text[:200]}")
-            except Exception as json_err:
-                print(f"Nie można odczytać treści odpowiedzi jako tekst: {json_err}")
-                raise gr.Error(f"API zwróciło nieoczekiwany format danych (Content-Type: {content_type}).")
-
-        # Jeśli status OK i Content-Type to obrazek, otwórz go
-        print("Próbuję otworzyć obrazek z odpowiedzi API...")
-        generated_image = Image.open(io.BytesIO(response.content))
-        print(f"Sukces! Otworzono wygenerowany obrazek. Rozmiar: {generated_image.size}")
-
-        # Zwróć wygenerowany obrazek do interfejsu Gradio
-        return generated_image # Zwracamy obiekt PIL
-
-    # Obsługa błędów z biblioteki requests (np. timeout, problem z połączeniem, błąd statusu z raise_for_status)
-    except requests.exceptions.RequestException as e:
-        print(f"BŁĄD podczas komunikacji z API: {e}")
-        # Spróbujmy wyświetlić odpowiedź błędu z API, jeśli jest dostępna
-        error_details = str(e)
-        if e.response is not None:
-            print(f"Odpowiedź błędu API (status {e.response.status_code}):")
-            try:
-                # Spróbuj zdekodować JSON jeśli to możliwe
-                error_json = e.response.json()
-                print(error_json)
-                error_details = f"API Error (status {e.response.status_code}): {error_json.get('error', e.response.text)}"
-            except ValueError: # Not JSON
-                error_text = e.response.text[:500] # Pokaż fragment tekstu błędu
-                print(error_text)
-                error_details = f"API Error (status {e.response.status_code}): {error_text}"
-
+        print(f"BŁĄD podczas zapisywania obrazu tymczasowego: {e}")
         traceback.print_exc()
-        raise gr.Error(f"Problem z połączeniem lub błąd API: {error_details}")
+        # Spróbuj posprzątać folder tymczasowy
+        if os.path.exists(temp_dir):
+            shutil.rmtree(temp_dir)
+        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
+    try:
+        print(f"Łączenie z docelowym Space Gradio: {TARGET_SPACE_URL}")
+        # Inicjalizujemy klienta, przekazując token (może pomóc z limitami)
+        client = Client(TARGET_SPACE_URL, hf_token=API_TOKEN)
+        # Możesz spróbować bez tokena, jeśli są problemy: client = Client(TARGET_SPACE_URL)
+
+        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.
+
+        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!
+
+        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
+        )
+
+        # `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.
+        print(f"Otrzymano wynik od klienta: {type(result)}")
+        print(f"Wynik (fragment): {str(result)[:500]}") # Wydrukuj fragment wyniku
+
+        # Sprawdźmy, czy wynik to lista i czy zawiera ścieżkę do pliku
+        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_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ę
+             output_file_path = result
+             print(f"Wygląda na to, że otrzymano ścieżkę do obrazka: {output_file_path}")
+             output_image = Image.open(output_file_path)
+             print(f"Obrazek wynikowy załadowany. Rozmiar: {output_image.size}")
+        else:
+            # Jeśli wynik nie jest oczekiwaną ścieżką, zgłoś błąd
+            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]}")
 
-    # Obsługa innych, nieoczekiwanych błędów
     except Exception as e:
-        print(f"Nieoczekiwany BŁĄD w funkcji generate_photo: {e}")
-        traceback.print_exc() # Wypisz pełny ślad błędu w logach
-        raise gr.Error(f"Wystąpił wewnętrzny błąd aplikacji: {e}")
+        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}")
 
+    finally:
+        # 4. Sprzątanie - usuń folder tymczasowy z plikiem wejściowym
+        if 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}")
+
+    # 5. Zwróć wynik (załadowany obrazek PIL)
+    if output_image:
+        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.")
 
 # --- Budowa Interfejsu Gradio ---
 print("--- Definiowanie interfejsu Gradio ---")