Spaces:
Sleeping
Sleeping
| # -*- 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 ---") |