Spaces:
Sleeping
Sleeping
| import gradio as gr | |
| # 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, ImageOps | |
| import io | |
| import os | |
| import traceback | |
| # Poprawny import dla gradio_client | |
| from gradio_client import Client, file | |
| import uuid | |
| import shutil | |
| print("--- Plik app.py - Start ładowania ---") | |
| # --- Konfiguracja --- | |
| # Odczytanie sekretu (API Token) ustawionego w Space | |
| API_TOKEN = os.getenv("HUGGINGFACE_API_TOKEN") | |
| # Sprawdzenie, czy token został załadowany | |
| if not API_TOKEN: | |
| # 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ć | |
| LINKEDIN_PROMPT = ( | |
| "linkedin professional profile photo, corporate headshot, high quality, realistic photograph, " | |
| "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" | |
| ) | |
| # 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): | |
| print(f"Otrzymano obrazek typu: {type(input_selfie)}, Oryginalny rozmiar: {input_selfie.size}") | |
| print(f"Otrzymano prompt (początek): {current_prompt[:100]}...") | |
| # --- Dodany Krok: Przeskalowanie obrazka wejściowego --- | |
| try: | |
| max_size = (1024, 1024) # Maksymalny rozmiar (szerokość, wysokość) | |
| # Używamy thumbnail, aby zachować proporcje i zmniejszyć tylko jeśli jest większy | |
| input_selfie_resized = input_selfie.copy() # Pracuj na kopii | |
| 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}") | |
| # --------------------------------------------------------- | |
| # 2. Przygotowanie pliku tymczasowego dla obrazka wejściowego | |
| # (Używamy teraz przeskalowanego obrazka: input_selfie_resized) | |
| 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") | |
| # Upewnijmy się, że obraz jest w RGB przed zapisem jako JPEG | |
| rgb_image = input_selfie_resized # Używamy przeskalowanego! | |
| if rgb_image.mode == 'RGBA': | |
| print("Konwertuję przeskalowany obraz RGBA na RGB z białym tłem...") | |
| # Stwórz nowy obraz RGB wypełniony białym kolorem | |
| final_image = Image.new("RGB", rgb_image.size, (255, 255, 255)) | |
| # Wklej oryginalny obraz używając jego kanału alfa jako maski | |
| final_image.paste(rgb_image, mask=rgb_image.split()[3]) | |
| else: | |
| final_image = rgb_image # Już jest w odpowiednim trybie | |
| # Zapisz przeskalowany i skonwertowany obraz jako JPEG | |
| final_image.save(input_image_path, format="JPEG") | |
| print(f"Przeskalowany obrazek wejściowy zapisany tymczasowo w: {input_image_path}") | |
| except Exception as e: | |
| # ... (reszta obsługi błędu zapisu bez zmian) ... | |
| # 3. Wywołanie zdalnego API Gradio za pomocą gradio_client | |
| # ... (reszta kodu bez zmian, aż do obsługi błędu AppError) ... | |
| except Exception as e: | |
| print(f"BŁĄD podczas komunikacji z klientem Gradio lub przetwarzania wyniku: {e}") | |
| traceback.print_exc() | |
| # Dodajmy podpowiedź o możliwej przyczynie błędu AppError | |
| error_message = f"Problem podczas generowania przez zdalny serwis InstantID: {e}" | |
| if isinstance(e, AppError): # Sprawdzamy czy to ten konkretny błąd | |
| error_message = f"Zdalny serwis ({TARGET_SPACE_ID}) zgłosił wewnętrzny błąd. Najczęstszą przyczyną są problemy z obrazkiem wejściowym (np. brak wykrytej twarzy, nietypowy format) lub przeciążenie serwisu. Spróbuj z innym zdjęciem lub ponownie później." | |
| elif "Could not fetch config" in str(e): | |
| # ... (reszta obsługi błędów bez zmian) | |
| raise gr.Error(error_message) # Pokaż (potencjalnie bardziej pomocny) błąd | |
| # 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!") # Pokaż błąd w interfejsie | |
| if not current_prompt: | |
| 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("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 | |
| 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() # 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 # 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 ID Space'a i token (jeśli jest) | |
| client = Client(TARGET_SPACE_ID, hf_token=API_TOKEN) | |
| 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" | |
| # ------------------------------------------------------- | |
| 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), # 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 | |
| ) | |
| # Przetwarzanie wyniku zwróconego przez klienta | |
| print(f"Otrzymano wynik od klienta: {type(result)}") | |
| # Wydrukuj fragment wyniku, aby zobaczyć jego strukturę | |
| print(f"Wynik (fragment): {str(result)[:500]}") | |
| # 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] # 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 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"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: | |
| # 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() # 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 - 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), jeśli się udało | |
| if output_image: | |
| print("Zwracam wygenerowany obrazek do interfejsu Gradio.") | |
| return output_image | |
| else: | |
| # 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 (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 | |
| ) | |
| # 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 | |
| ) | |
| # 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 | |
| ) | |
| # --- Podłączenie akcji do przycisku --- | |
| # Definiujemy, co ma się stać po kliknięciu przycisku 'generate_button' | |
| generate_button.click( | |
| 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 ---") | |
| # --- Uruchomienie aplikacji --- | |
| if __name__ == "__main__": | |
| print("--- Uruchamianie demo.launch() ---") | |
| # 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) ---") |