Upload app.py

app.py

@@ -12,8 +12,8 @@ import insightface
 import onnxruntime
 import numpy as np
 import gradio as gr
-# import threading # Not explicitly used, can be removed if StreamerThread is not used
-# import queue # Not explicitly used, can be removed if StreamerThread is not used
+import threading
+import queue
 
 from datasets import Dataset, Features, Image as DatasetImage, Value, load_dataset, concatenate_datasets
 from PIL import Image
@@ -25,7 +25,7 @@ import concurrent.futures
 from moviepy.editor import VideoFileClip
 
 from face_swapper import Inswapper, paste_to_whole
-from face_analyser import detect_conditions, get_analysed_data, swap_options_list as original_swap_options_list
+from face_analyser import detect_conditions, get_analysed_data, swap_options_list
 from face_parsing import init_parsing_model, get_parsed_mask, mask_regions, mask_regions_to_list
 from face_enhancer import get_available_enhancer_names, load_face_enhancer_model, cv2_interpolations
 from utils import trim_video, StreamerThread, ProcessBar, open_directory, split_list_by_lengths, merge_img_sequence_from_ref, create_image_grid
@@ -35,7 +35,7 @@ from utils import trim_video, StreamerThread, ProcessBar, open_directory, split_
 parser = argparse.ArgumentParser(description="Free Face Swapper")
 parser.add_argument("--out_dir", help="Default Output directory", default=os.getcwd())
 parser.add_argument("--batch_size", help="Gpu batch size", default=32)
-parser.add_argument("--cuda", action="store_true", help="Enable cuda", default=True) # Default changed to True based on original
+parser.add_argument("--cuda", action="store_true", help="Enable cuda", default=True)
 parser.add_argument(
     "--colab", action="store_true", help="Enable colab mode", default=False
 )
@@ -49,12 +49,12 @@ DEF_OUTPUT_PATH = user_args.out_dir
 BATCH_SIZE = int(user_args.batch_size)
 WORKSPACE = None
 OUTPUT_FILE = None
-CURRENT_FRAME = None # Seems unused
-STREAMER = None # Related to Stream input type, which is hidden
+CURRENT_FRAME = None
+STREAMER = None
 DETECT_CONDITION = "best detection"
 DETECT_SIZE = 640
 DETECT_THRESH = 0.7
-NUM_OF_SRC_SPECIFIC = 10 # For hidden specific face UI
+NUM_OF_SRC_SPECIFIC = 10
 MASK_INCLUDE = [
     "Skin",
     "R-Eyebrow",
@@ -73,17 +73,15 @@ MASK_ERODE_AMOUNT = 0.05
 
 FACE_SWAPPER = None
 FACE_ANALYSER = None
-# FACE_ENHANCER = "GFPGAN" # This is a default string, the model object is FACE_ENHANCER_MODEL
-FACE_ENHANCER_MODEL = None # To store the loaded enhancer model object
+FACE_ENHANCER = "GFPGAN"
 FACE_PARSER = None
-FACE_ENHANCER_LIST = ["None"] # "None" as a string option
+FACE_ENHANCER_LIST = ["None"]
 FACE_ENHANCER_LIST.extend(get_available_enhancer_names())
 FACE_ENHANCER_LIST.extend(cv2_interpolations)
 
-swap_options_list_ui = [opt for opt in original_swap_options_list if opt != "Specific Face"]
-
-
 ## ------------------------------ SET EXECUTION PROVIDER ------------------------------
+# Note: Non CUDA users may change settings here
+
 PROVIDER = ["CPUExecutionProvider"]
 if USE_CUDA:
     available_providers = onnxruntime.get_available_providers()
@@ -91,781 +89,982 @@ if USE_CUDA:
     if "CUDAExecutionProvider" in available_providers:
         print("\n********** Running on CUDA **********\n")
         PROVIDER = ["CUDAExecutionProvider", "CPUExecutionProvider"]
+        
     else:
-        USE_CUDA = False # Correctly set USE_CUDA to False if provider not found
+        USE_CUDA = False
         print("\n********** CUDA unavailable running on CPU **********\n")
 else:
-    # USE_CUDA = False # Already false or set by arg
+    USE_CUDA = False
     print("\n********** Running on CPU **********\n")
 
 device = "cuda" if USE_CUDA else "cpu"
-EMPTY_CACHE = lambda: torch.cuda.empty_cache() if device == "cuda" and torch.cuda.is_available() else None # Added torch.cuda.is_available() check
-
-# print(onnxruntime.get_available_providers())
-# print(f"Torch CUDA available: {torch.cuda.is_available()}")
-# if torch.cuda.is_available():
-#     print(f"Torch CUDA device count: {torch.cuda.device_count()}")
-#     print(f"Torch current CUDA device: {torch.cuda.current_device()}")
-#     if torch.cuda.device_count() > 0:
-#          print(f"Torch CUDA device name: {torch.cuda.get_device_name(0)}")
+EMPTY_CACHE = lambda: torch.cuda.empty_cache() if device == "cuda" else None
+print(onnxruntime.get_available_providers())
+print(torch.cuda.is_available())
+print(torch.cuda.device_count())
+print(torch.cuda.current_device())
+print(torch.cuda.get_device_name(0))
 
 ## ------------------------------ LOAD MODELS ------------------------------
 
 def load_face_analyser_model(name="buffalo_l"):
     global FACE_ANALYSER
     if FACE_ANALYSER is None:
-        print("Loading face analyser model...")
         FACE_ANALYSER = insightface.app.FaceAnalysis(name=name, providers=PROVIDER)
         FACE_ANALYSER.prepare(
             ctx_id=0, det_size=(DETECT_SIZE, DETECT_SIZE), det_thresh=DETECT_THRESH
         )
-        print("Face analyser model loaded.")
 
 
-def load_face_swapper_model(model_path="./assets/pretrained_models/inswapper_128.onnx"): # Renamed arg for clarity
+def load_face_swapper_model(path="./assets/pretrained_models/inswapper_128.onnx"):
     global FACE_SWAPPER
     if FACE_SWAPPER is None:
-        print(f"Loading face swapper model from {model_path}...")
         batch = int(BATCH_SIZE) if device == "cuda" else 1
-        FACE_SWAPPER = Inswapper(model_file=model_path, batch_size=batch, providers=PROVIDER)
-        print("Face swapper model loaded.")
+        FACE_SWAPPER = Inswapper(model_file=path, batch_size=batch, providers=PROVIDER)
 
 
-def load_face_parser_model(model_path="./assets/pretrained_models/79999_iter.pth"): # Renamed arg for clarity
+def load_face_parser_model(path="./assets/pretrained_models/79999_iter.pth"):
     global FACE_PARSER
     if FACE_PARSER is None:
-        print(f"Loading face parsing model from {model_path}...")
-        FACE_PARSER = init_parsing_model(model_path, device=device)
-        print("Face parsing model loaded.")
+        FACE_PARSER = init_parsing_model(path, device=device)
+
 
-# Pre-load models at startup
 load_face_analyser_model()
 load_face_swapper_model()
-# Face parser and enhancer are loaded on demand by process function
 
 ## ------------------------------ MAIN PROCESS ------------------------------
+
+
 def process(
-    # input_type, # REMOVED - hardcoded to "Image"
+    input_type,
     image_path,
-    video_path, # Will be None as UI is hidden
-    directory_path, # Will be None as UI is hidden
+    video_path,
+    directory_path,
     source_path,
     output_path,
     output_name,
-    keep_output_sequence, # From hidden UI, relevant for video
-    condition, # Swap condition from UI
-    age, # From UI, visibility controlled
-    distance, # From hidden UI (specific face)
-    face_enhancer_name, # From UI dropdown
-    enable_face_parser, # From UI checkbox
-    mask_includes, # From UI dropdown
-    mask_soft_kernel_ui, # Renamed to avoid clash with global, from UI (hidden)
-    mask_soft_iterations_ui, # Renamed, from UI
-    blur_amount, # From UI slider
-    erode_amount, # From UI slider
-    face_scale, # From UI slider
-    enable_laplacian_blend, # From UI checkbox
-    crop_top, # From UI slider
-    crop_bott, # From UI slider
-    crop_left, # From UI slider
-    crop_right, # From UI slider
-    *specifics_components, # Tuple of Gradio components for specific faces (hidden UI)
+    keep_output_sequence,
+    condition,
+    age,
+    distance,
+    face_enhancer_name,
+    enable_face_parser,
+    mask_includes,
+    mask_soft_kernel,
+    mask_soft_iterations,
+    blur_amount,
+    erode_amount,
+    face_scale,
+    enable_laplacian_blend,
+    crop_top,
+    crop_bott,
+    crop_left,
+    crop_right,
+    *specifics,
 ):
-    global WORKSPACE, OUTPUT_FILE, PREVIEW, FACE_ENHANCER_MODEL, FACE_PARSER
-
+    global WORKSPACE
+    global OUTPUT_FILE
+    global PREVIEW
     WORKSPACE, OUTPUT_FILE, PREVIEW = None, None, None
-    input_type = "Image" # Hardcoded
 
-    # Use UI values for mask kernel and iterations
-    current_mask_soft_kernel = int(mask_soft_kernel_ui)
-    current_mask_soft_iterations = int(mask_soft_iterations_ui)
+    ## ------------------------------ GUI UPDATE FUNC ------------------------------
 
-
-    def ui_before(): # Updates for UI elements during processing
+    def ui_before():
         return (
-            gr.update(visible=True, value=PREVIEW), # preview_image (Output image)
-            gr.update(interactive=False),           # Corresponds to output_directory_button in original swap_outputs
-            gr.update(interactive=False),           # Corresponds to output_video_button in original swap_outputs
-            gr.update(visible=False),               # preview_video (Output video)
+            gr.update(visible=True, value=PREVIEW),
+            gr.update(interactive=False),
+            gr.update(interactive=False),
+            gr.update(visible=False),
         )
 
-    def ui_after(): # Updates for UI elements after successful image processing
+    def ui_after():
         return (
-            gr.update(visible=True, value=PREVIEW), # preview_image
-            gr.update(interactive=True),            # output_directory_button
-            gr.update(interactive=True),            # output_video_button (though for image, this might stay hidden)
-            gr.update(visible=False),               # preview_video
+            gr.update(visible=True, value=PREVIEW),
+            gr.update(interactive=True),
+            gr.update(interactive=True),
+            gr.update(visible=False),
         )
 
-    def ui_after_vid(): # Updates for UI elements after successful video processing (currently unused)
+    def ui_after_vid():
         return (
-            gr.update(visible=False),               # preview_image
-            gr.update(interactive=True),            # output_directory_button
-            gr.update(interactive=True),            # output_video_button
-            gr.update(value=OUTPUT_FILE, visible=True), # preview_video
+            gr.update(visible=False),
+            gr.update(interactive=True),
+            gr.update(interactive=True),
+            gr.update(value=OUTPUT_FILE, visible=True),
         )
 
     start_time = time.time()
-    total_exec_time = lambda st: divmod(time.time() - st, 60)
-    get_finsh_text = lambda st: f"✔️ Completed in {int(total_exec_time(st)[0])} min {int(total_exec_time(st)[1])} sec."
+    total_exec_time = lambda start_time: divmod(time.time() - start_time, 60)
+    get_finsh_text = lambda start_time: f"✔️ Completed in {int(total_exec_time(start_time)[0])} min {int(total_exec_time(start_time)[1])} sec."
+
+    ## ------------------------------ PREPARE INPUTS & LOAD MODELS ------------------------------
 
-    try: # Wrap main processing in try-except
-        yield "### \n 🌀 Ensuring face analyser model is loaded...", *ui_before()
-        load_face_analyser_model() # Ensures it's loaded, doesn't reload if already there
+    
+
+    yield "### \n 🌀 Loading face analyser model...", *ui_before()
+    load_face_analyser_model()
 
-        yield "### \n ⚙️ Ensuring face swapper model is loaded...", *ui_before()
-        load_face_swapper_model() # Ensures it's loaded
+    yield "### \n ⚙️ Loading face swapper model...", *ui_before()
+    load_face_swapper_model()
 
-        global FACE_ENHANCER_MODEL # Ensure we are using the global for the loaded model
-        if face_enhancer_name != "None": # String "None" from dropdown
-            if face_enhancer_name not in cv2_interpolations:
-                yield f"### \n 💡 Loading {face_enhancer_name} model...", *ui_before()
-            FACE_ENHANCER_MODEL = load_face_enhancer_model(name=face_enhancer_name, device=device)
+    if face_enhancer_name != "NONE":
+        if face_enhancer_name not in cv2_interpolations:
+            yield f"### \n 💡 Loading {face_enhancer_name} model...", *ui_before()
+        FACE_ENHANCER = load_face_enhancer_model(name=face_enhancer_name, device=device)
+    else:
+        FACE_ENHANCER = None
+
+    if enable_face_parser:
+        yield "### \n 📀 Loading face parsing model...", *ui_before()
+        load_face_parser_model()
+
+    includes = mask_regions_to_list(mask_includes)
+    specifics = list(specifics)
+    half = len(specifics) // 2
+    sources = specifics[:half]
+    specifics = specifics[half:]
+    if crop_top > crop_bott:
+        crop_top, crop_bott = crop_bott, crop_top
+    if crop_left > crop_right:
+        crop_left, crop_right = crop_right, crop_left
+    crop_mask = (crop_top, 511-crop_bott, crop_left, 511-crop_right)
+
+    def swap_process(image_sequence):
+        ## ------------------------------ CONTENT CHECK ------------------------------
+
+    
+        yield "### \n 🧿 Analysing face data...", *ui_before()
+        if condition != "Specific Face":
+            source_data = source_path, age
         else:
-            FACE_ENHANCER_MODEL = None
+            source_data = ((sources, specifics), distance)
+        analysed_targets, analysed_sources, whole_frame_list, num_faces_per_frame = get_analysed_data(
+            FACE_ANALYSER,
+            image_sequence,
+            source_data,
+            swap_condition=condition,
+            detect_condition=DETECT_CONDITION,
+            scale=face_scale
+        )
 
-        if enable_face_parser:
-            yield "### \n 📀 Loading face parsing model...", *ui_before()
-            load_face_parser_model() # Ensures it's loaded
-
-        includes = mask_regions_to_list(mask_includes)
-
-        # Specifics components are passed, but their values will be None as UI is hidden
-        # The logic for 'Specific Face' condition might not be fully reachable if it relies on UI input for these.
-        # For now, we assume `condition` will not be "Specific Face" or handles None for sources/specifics.
-        # If `specifics_components` are needed, their .value would be accessed.
-        # Since they are hidden, this part of logic for "Specific Face" may need review if that condition is used.
-        # For now, `sources` and `specific_face_targets_from_ui` will be empty if condition != "Specific Face".
-        sources_from_ui = []
-        specific_face_targets_from_ui = []
-        # If specific_components were populated (e.g. if UI was visible):
-        # half_len = len(specifics_components) // 2
-        # sources_from_ui = [comp.value for comp in specifics_components[:half_len] if comp.value is not None]
-        # specific_face_targets_from_ui = [comp.value for comp in specifics_components[half_len:] if comp.value is not None]
-
-
-        if crop_top > crop_bott: crop_top, crop_bott = crop_bott, crop_top
-        if crop_left > crop_right: crop_left, crop_right = crop_right, crop_left
-        crop_mask_dims = (crop_top, 511-crop_bott, crop_left, 511-crop_right) # Renamed for clarity
-
-        # Inner function for the core swapping logic (on a sequence of image paths)
-        def swap_process_on_sequence(image_path_sequence):
-            nonlocal PREVIEW # Allow modification of PREVIEW
-            yield "### \n 🧿 Analysing face data...", *ui_before()
-
-            current_source_data = None
-            if condition == "Specific Face":
-                # This branch is problematic if UI for specifics is hidden,
-                # as sources_from_ui and specific_face_targets_from_ui will be empty or contain Nones.
-                # The get_analysed_data must handle this.
-                # For now, assuming `distance` (from hidden slider) is the primary input.
-                # This path needs robust handling if "Specific Face" is ever re-enabled or used programmatically.
-                print("Warning: 'Specific Face' condition selected, but UI for specific faces is hidden.")
-                # `source_path` (the single source image) might be used as a fallback or primary source here.
-                # This part of the logic is unclear without knowing how `get_analysed_data` uses `source_data` for "Specific Face"
-                # when `specifics_components` are effectively None.
-                # Assuming it might use `source_path` if other specifics are missing.
-                # If `sources_from_ui` and `specific_face_targets_from_ui` are empty, this will likely fail or misbehave.
-                # For safety, if "Specific Face" is chosen and specifics are empty, one might default to another behavior or error.
-                if not source_path: # If even the main source_path is missing
-                     yield "### \n ❌ 'Specific Face' requires at least one source face image.", *ui_after()
-                     raise ValueError("'Specific Face' requires at least one source face image.")
-                # Simplified: if specific_face_targets_from_ui is empty, it implies swapping all faces in target with source_path
-                # This is a guess; original logic for `source_data = ((sources, specifics), distance)` needs `sources` and `specifics`
-                # For now, we'll pass what we have.
-                # `sources` would be a list of numpy arrays for source faces from specific_face UI.
-                # `specifics` would be a list of numpy arrays for target faces from specific_face UI.
-                # Since these UI elements are hidden, they will be None or empty.
-                # The original `specifics` variable in `process` was from `*specifics_components`.
-                # We should use `sources_from_ui` and `specific_face_targets_from_ui` here.
-                source_data = ((sources_from_ui, specific_face_targets_from_ui), distance)
-
-            else: # For other conditions like "Age", "Gender", etc.
-                if not source_path:
-                    yield "### \n ❌ Source face image is required for this swap condition.", *ui_after()
-                    raise ValueError("Source face image is required for this swap condition.")
-                source_data = source_path, age # `age` from UI
-
-            analysed_targets, analysed_sources, whole_frame_list, num_faces_per_frame = get_analysed_data(
-                FACE_ANALYSER,
-                image_path_sequence, # List of image file paths
-                source_data,
-                swap_condition=condition,
-                detect_condition=DETECT_CONDITION,
-                scale=face_scale
-            )
+        ## ------------------------------ SWAP FUNC ------------------------------
 
-            if not analysed_targets: # No faces detected in target, or other issue
-                 yield "### \n ⚠️ No target faces found or error in analysis. Cannot proceed with swap.", *ui_after()
-                 return # Stop processing for this sequence
+        yield "### \n 🧶 Generating faces...", *ui_before()
+        preds = []
+        matrs = []
+        count = 0
+        global PREVIEW
+        for batch_pred, batch_matr in FACE_SWAPPER.batch_forward(whole_frame_list, analysed_targets, analysed_sources):
+            preds.extend(batch_pred)
+            matrs.extend(batch_matr)
+            EMPTY_CACHE()
+            count += 1
 
+            if USE_CUDA:
+                image_grid = create_image_grid(batch_pred, size=128)
+                PREVIEW = image_grid[:, :, ::-1]
+                yield f"### \n 🧩 Generating face Batch {count}", *ui_before()
 
-            yield "### \n 🧶 Generating faces...", *ui_before()
-            preds, matrs = [], []
-            batch_count = 0
-            # Ensure whole_frame_list, analysed_targets, analysed_sources are not empty/None before batch_forward
-            if not whole_frame_list or not analysed_targets or analysed_sources is None: # analysed_sources can be tricky (single vs multiple)
-                 yield "### \n ⚠️ Missing data for face generation. Cannot proceed.", *ui_after()
-                 return
+        ## ------------------------------ FACE ENHANCEMENT ------------------------------
 
+        generated_len = len(preds)
+        if face_enhancer_name != "NONE":
+            yield f"### \n 🎲 Upscaling faces with {face_enhancer_name}...", *ui_before()
+            for idx, pred in tqdm(enumerate(preds), total=generated_len, desc=f"Upscaling with {face_enhancer_name}"):
+                enhancer_model, enhancer_model_runner = FACE_ENHANCER
+                pred = enhancer_model_runner(pred, enhancer_model)
+                preds[idx] = cv2.resize(pred, (512,512))
+        EMPTY_CACHE()
 
-            for batch_pred, batch_matr in FACE_SWAPPER.batch_forward(whole_frame_list, analysed_targets, analysed_sources):
-                preds.extend(batch_pred)
-                matrs.extend(batch_matr)
-                EMPTY_CACHE()
-                batch_count += 1
-                if USE_CUDA and batch_pred: # Check if batch_pred is not empty
-                    image_grid = create_image_grid(batch_pred, size=128) # Ensure batch_pred is list of images
-                    PREVIEW = image_grid[:, :, ::-1]
-                    yield f"### \n 🧩 Generating face Batch {batch_count}", *ui_before()
-
-            generated_len = len(preds)
-            if generated_len == 0:
-                yield "### \n ⚠️ No faces were generated. Check source and target images/faces.", *ui_after()
-                return # Nothing to enhance or parse or paste
-
-            if FACE_ENHANCER_MODEL is not None and face_enhancer_name != "None": # Check model object
-                yield f"### \n 🎲 Upscaling faces with {face_enhancer_name}...", *ui_before()
-                # tqdm description should be clear
-                for idx, pred_img in tqdm(enumerate(preds), total=generated_len, desc=f"Upscaling with {face_enhancer_name}"):
-                    enhancer_model_obj, enhancer_model_runner_func = FACE_ENHANCER_MODEL # Unpack
-                    enhanced_pred = enhancer_model_runner_func(pred_img, enhancer_model_obj)
-                    preds[idx] = cv2.resize(enhanced_pred, (512,512))
-            EMPTY_CACHE()
+        ## ------------------------------ FACE PARSING ------------------------------
 
-            parsed_masks = [None] * generated_len # Initialize with Nones
-            if enable_face_parser and FACE_PARSER is not None:
-                yield "### \n 🎨 Face-parsing mask...", *ui_before()
-                temp_masks_list = [] # To collect batches of masks
-                parse_batch_count = 0
-                for batch_mask_data in get_parsed_mask(FACE_PARSER, preds, classes=includes, device=device, batch_size=BATCH_SIZE, softness=int(current_mask_soft_iterations)):
-                    temp_masks_list.append(batch_mask_data) # batch_mask_data is likely a numpy array of masks
-                    EMPTY_CACHE()
-                    parse_batch_count += 1
-                    if len(batch_mask_data) > 0: # Check if batch_mask_data is not empty
-                        # Assuming batch_mask_data is a list/array of single-channel masks
-                        # For create_image_grid, masks might need to be converted to 3-channel grayscale if they are not already
-                        displayable_masks = []
-                        for msk in batch_mask_data:
-                            if msk.ndim == 2: displayable_masks.append(cv2.cvtColor(msk, cv2.COLOR_GRAY2BGR))
-                            elif msk.ndim == 3 and msk.shape[2] == 1: displayable_masks.append(cv2.cvtColor(msk, cv2.COLOR_GRAY2BGR))
-                            else: displayable_masks.append(msk) # Assume it's already displayable
-
-                        if displayable_masks:
-                             image_grid = create_image_grid(displayable_masks, size=128)
-                             PREVIEW = image_grid[:, :, ::-1]
-                             yield f"### \n 🪙 Face parsing Batch {parse_batch_count}", *ui_before()
-                if temp_masks_list: # If any masks were generated
-                    parsed_masks = np.concatenate(temp_masks_list, axis=0)
-
-
-            split_preds = split_list_by_lengths(preds, num_faces_per_frame)
-            del preds
-            split_matrs = split_list_by_lengths(matrs, num_faces_per_frame)
-            del matrs
-            # Ensure parsed_masks has the correct structure for split_list_by_lengths
-            # If parsed_masks is a single concatenated array, it needs to be a list of masks first if not already.
-            # Assuming get_parsed_mask and concatenate result in a flat list/array that split_list can handle.
-            if isinstance(parsed_masks, np.ndarray) and parsed_masks.ndim > 1 and len(parsed_masks) == generated_len : # Check if it's an array of masks
-                parsed_masks_list = [parsed_masks[i] for i in range(generated_len)]
-            elif isinstance(parsed_masks, list) and len(parsed_masks) == generated_len:
-                parsed_masks_list = parsed_masks
-            else: # Fallback if structure is unexpected or it remained all Nones
-                parsed_masks_list = [None] * generated_len
-
-            split_masks = split_list_by_lengths(parsed_masks_list, num_faces_per_frame)
-            del parsed_masks, parsed_masks_list
-
-
-            yield "### \n 🧿 Pasting back...", *ui_before()
-            def post_process_frame(frame_idx, frame_img_path, current_split_preds, current_split_matrs, current_split_masks):
-                whole_img = cv2.imread(frame_img_path)
-                if whole_img is None:
-                    print(f"Error: Could not read frame for pasting: {frame_img_path}")
-                    return
-
-                blend_method = 'laplacian' if enable_laplacian_blend else 'linear'
-                # Ensure frame_idx is within bounds of all lists
-                if frame_idx < len(current_split_preds) and \
-                   frame_idx < len(current_split_matrs) and \
-                   frame_idx < len(current_split_masks):
-
-                    for p_img, m_data, mask_img in zip(current_split_preds[frame_idx], current_split_matrs[frame_idx], current_split_masks[frame_idx]):
-                        p_resized = cv2.resize(p_img, (512,512))
-                        mask_resized = cv2.resize(mask_img, (512,512)) if mask_img is not None else None
-                        m_data_scaled = m_data / 0.25 # Transformation matrix scaling
-                        whole_img = paste_to_whole(p_resized, whole_img, m_data_scaled, mask=mask_resized,
-                                                   crop_mask=crop_mask_dims, blend_method=blend_method,
-                                                   blur_amount=blur_amount, erode_amount=erode_amount)
-                cv2.imwrite(frame_img_path, whole_img) # Overwrite the frame in the sequence
+        if enable_face_parser:
+            yield "### \n 🎨 Face-parsing mask...", *ui_before()
+            masks = []
+            count = 0
+            for batch_mask in get_parsed_mask(FACE_PARSER, preds, classes=includes, device=device, batch_size=BATCH_SIZE, softness=int(mask_soft_iterations)):
+                masks.append(batch_mask)
+                EMPTY_CACHE()
+                count += 1
 
+                if len(batch_mask) > 1:
+                    image_grid = create_image_grid(batch_mask, size=128)
+                    PREVIEW = image_grid[:, :, ::-1]
+                    yield f"### \n 🪙 Face parsing Batch {count}", *ui_before()
+            masks = np.concatenate(masks, axis=0) if len(masks) >= 1 else masks
+        else:
+            masks = [None] * generated_len
+
+        ## ------------------------------ SPLIT LIST ------------------------------
+
+        split_preds = split_list_by_lengths(preds, num_faces_per_frame)
+        del preds
+        split_matrs = split_list_by_lengths(matrs, num_faces_per_frame)
+        del matrs
+        split_masks = split_list_by_lengths(masks, num_faces_per_frame)
+        del masks
+
+        ## ------------------------------ PASTE-BACK ------------------------------
+
+        yield "### \n 🧿 Pasting back...", *ui_before()
+        def post_process(frame_idx, frame_img, split_preds, split_matrs, split_masks, enable_laplacian_blend, crop_mask, blur_amount, erode_amount):
+            whole_img_path = frame_img
+            whole_img = cv2.imread(whole_img_path)
+            blend_method = 'laplacian' if enable_laplacian_blend else 'linear'
+            for p, m, mask in zip(split_preds[frame_idx], split_matrs[frame_idx], split_masks[frame_idx]):
+                p = cv2.resize(p, (512,512))
+                mask = cv2.resize(mask, (512,512)) if mask is not None else None
+                m /= 0.25
+                whole_img = paste_to_whole(p, whole_img, m, mask=mask, crop_mask=crop_mask, blend_method=blend_method, blur_amount=blur_amount, erode_amount=erode_amount)
+            cv2.imwrite(whole_img_path, whole_img)
+
+        def concurrent_post_process(image_sequence, *args):
             with concurrent.futures.ThreadPoolExecutor() as executor:
-                futures = [executor.submit(post_process_frame, idx, img_path, split_preds, split_matrs, split_masks)
-                           for idx, img_path in enumerate(image_path_sequence)]
+                futures = []
+                for idx, frame_img in enumerate(image_sequence):
+                    future = executor.submit(post_process, idx, frame_img, *args)
+                    futures.append(future)
+
                 for future in tqdm(concurrent.futures.as_completed(futures), total=len(futures), desc="Pasting back"):
-                    future.result() # Wait for completion and raise exceptions if any
+                    result = future.result()
+
+        concurrent_post_process(
+            image_sequence,
+            split_preds,
+            split_matrs,
+            split_masks,
+            enable_laplacian_blend,
+            crop_mask,
+            blur_amount,
+            erode_amount
+        )
 
-        # IMAGE INPUT PROCESSING
-        if input_type == "Image":
-            if not image_path:
-                yield "### \n ❌ Target image not provided.", *ui_after()
-                return
 
-            os.makedirs(output_path, exist_ok=True)
-            # Create a working copy of the target image for processing
-            # to avoid modifying the original if it's in a restricted location.
-            base_name, ext = os.path.splitext(os.path.basename(image_path))
-            processing_image_filename = f"processing_copy_{base_name}{ext}"
-            processing_image_path = os.path.join(output_path, processing_image_filename)
+    ## ------------------------------ IMAGE ------------------------------
 
-            try:
-                shutil.copyfile(image_path, processing_image_path)
-            except Exception as e:
-                yield f"### \n ❌ Failed to copy target image for processing: {str(e)}", *ui_after()
-                return
-
-            # Call swap_process_on_sequence with a list containing the single image path
-            for info_update in swap_process_on_sequence([processing_image_path]):
-                yield info_update
-
-            # Define final output file path (e.g., result.png)
-            final_output_file_path = os.path.join(output_path, output_name + ".png") # Assuming PNG output for images
-            # Move the processed image (which overwrote processing_image_path) to the final path
-            try:
-                if os.path.exists(final_output_file_path) and final_output_file_path != processing_image_path:
-                    os.remove(final_output_file_path) # Remove if exists and is different file
-                shutil.move(processing_image_path, final_output_file_path)
-            except Exception as e:
-                 yield f"### \n ❌ Failed to save final image: {str(e)}", *ui_after()
-                 # Try to provide the temp file if move fails
-                 if os.path.exists(processing_image_path):
-                    final_output_file_path = processing_image_path # Fallback to the temp file
-                 else: # No file available
-                    return
-
-
-            OUTPUT_FILE = final_output_file_path
-            WORKSPACE = output_path
-            # Load the final image for PREVIEW
-            final_image_preview = cv2.imread(OUTPUT_FILE)
-            if final_image_preview is not None:
-                PREVIEW = final_image_preview[:, :, ::-1]
-            else: # Fallback if reading the final output fails
-                PREVIEW = None
-                yield "### \n ⚠️ Could not load final image for preview.", *ui_after()
-                # Still yield finish text
-                yield get_finsh_text(start_time), *ui_after()
-                return
-
-            yield get_finsh_text(start_time), *ui_after()
-
-        # VIDEO INPUT PROCESSING (Currently Unreachable via UI)
-        elif input_type == "Video":
-            if not video_path:
-                yield "### \n ❌ Target video not provided.", *ui_after_vid() # Use ui_after_vid for consistency
-                return
-
-            temp_sequence_path = os.path.join(output_path, output_name, "sequence")
-            os.makedirs(temp_sequence_path, exist_ok=True)
-
-            yield "### \n ⌛ Extracting video frames...", *ui_before()
-            extracted_image_paths = []
-            cap = cv2.VideoCapture(video_path)
-            frame_idx = 0
-            while True:
-                ret, frame = cap.read()
-                if not ret: break
-                frame_file_path = os.path.join(temp_sequence_path, f"frame_{frame_idx:06d}.jpg") # Padded frame numbers
-                cv2.imwrite(frame_file_path, frame)
-                extracted_image_paths.append(frame_file_path)
-                frame_idx += 1
-            cap.release()
-            # cv2.destroyAllWindows() # Not needed for backend processing
-
-            if not extracted_image_paths:
-                yield "### \n ❌ Video is empty or could not extract frames.", *ui_after_vid()
-                if os.path.exists(temp_sequence_path): shutil.rmtree(temp_sequence_path)
-                return
-
-            for info_update in swap_process_on_sequence(extracted_image_paths):
-                yield info_update
-
-            yield "### \n ⌛ Merging sequence...", *ui_before()
-            output_video_file_path = os.path.join(output_path, output_name + ".mp4")
-            # Ensure merge_img_sequence_from_ref handles cases where video_path might be an UploadFile object
-            original_video_for_ref = video_path.name if hasattr(video_path, 'name') else video_path
-
-            merge_img_sequence_from_ref(original_video_for_ref, extracted_image_paths, output_video_file_path)
-
-            if os.path.exists(temp_sequence_path) and not keep_output_sequence:
-                yield "### \n ⌛ Removing temporary files...", *ui_before()
-                shutil.rmtree(temp_sequence_path)
-
-            WORKSPACE = output_path
-            OUTPUT_FILE = output_video_file_path
-            # For video, PREVIEW is handled by ui_after_vid making preview_video visible with OUTPUT_FILE
-
-            yield get_finsh_text(start_time), *ui_after_vid()
-
-        # DIRECTORY INPUT PROCESSING (Currently Unreachable via UI)
-        elif input_type == "Directory":
-            # ... (Directory processing logic, similar structure to video) ...
-            # Ensure it uses swap_process_on_sequence
-            yield "### \n ⚠️ Directory processing is not fully implemented in this UI path.", *ui_after()
-            return
-
-        # STREAM INPUT PROCESSING (Currently Unreachable via UI)
-        elif input_type == "Stream":
-            # ... (Stream processing logic) ...
-            yield "### \n ⚠️ Stream processing is not implemented.", *ui_after()
-            return
+    if input_type == "Image":
+        target = cv2.imread(image_path)
+        output_file = os.path.join(output_path, output_name + ".png")
+        cv2.imwrite(output_file, target)
 
-    except Exception as e:
-        import traceback
-        traceback.print_exc()
-        yield f"### \n 🔥 An error occurred: {str(e)}", *ui_after() # Use ui_after for image mode fallback
+        for info_update in swap_process([output_file]):
+            yield info_update
+
+        OUTPUT_FILE = output_file
+        WORKSPACE = output_path
+        PREVIEW = cv2.imread(output_file)[:, :, ::-1]
+
+        yield get_finsh_text(start_time), *ui_after()
+
+    ## ------------------------------ VIDEO ------------------------------
+
+    elif input_type == "Video":
+        temp_path = os.path.join(output_path, output_name, "sequence")
+        os.makedirs(temp_path, exist_ok=True)
+
+        yield "### \n ⌛ Extracting video frames...", *ui_before()
+        image_sequence = []
+        cap = cv2.VideoCapture(video_path)
+        curr_idx = 0
+        while True:
+            ret, frame = cap.read()
+            if not ret:break
+            frame_path = os.path.join(temp_path, f"frame_{curr_idx}.jpg")
+            cv2.imwrite(frame_path, frame)
+            image_sequence.append(frame_path)
+            curr_idx += 1
+        cap.release()
+        cv2.destroyAllWindows()
+
+        for info_update in swap_process(image_sequence):
+            yield info_update
+
+        yield "### \n ⌛ Merging sequence...", *ui_before()
+        output_video_path = os.path.join(output_path, output_name + ".mp4")
+        merge_img_sequence_from_ref(video_path, image_sequence, output_video_path)
+
+        if os.path.exists(temp_path) and not keep_output_sequence:
+            yield "### \n ⌛ Removing temporary files...", *ui_before()
+            shutil.rmtree(temp_path)
+
+        WORKSPACE = output_path
+        OUTPUT_FILE = output_video_path
+
+        yield get_finsh_text(start_time), *ui_after_vid()
+
+    ## ------------------------------ DIRECTORY ------------------------------
+
+    elif input_type == "Directory":
+        extensions = ["jpg", "jpeg", "png", "bmp", "tiff", "ico", "webp"]
+        temp_path = os.path.join(output_path, output_name)
+        if os.path.exists(temp_path):
+            shutil.rmtree(temp_path)
+        os.mkdir(temp_path)
+
+        file_paths =[]
+        for file_path in glob.glob(os.path.join(directory_path, "*")):
+            if any(file_path.lower().endswith(ext) for ext in extensions):
+                img = cv2.imread(file_path)
+                new_file_path = os.path.join(temp_path, os.path.basename(file_path))
+                cv2.imwrite(new_file_path, img)
+                file_paths.append(new_file_path)
+
+        for info_update in swap_process(file_paths):
+            yield info_update
+
+        PREVIEW = cv2.imread(file_paths[-1])[:, :, ::-1]
+        WORKSPACE = temp_path
+        OUTPUT_FILE = file_paths[-1]
+
+        yield get_finsh_text(start_time), *ui_after()
+
+    ## ------------------------------ STREAM ------------------------------
+
+    elif input_type == "Stream":
+        pass
 
 
 ## ------------------------------ GRADIO FUNC ------------------------------
-# update_radio is not called as input_type.change is removed
+
+
 def update_radio(value):
-    if value == "Image": return gr.update(visible=True), gr.update(visible=False), gr.update(visible=False)
-    elif value == "Video": return gr.update(visible=False), gr.update(visible=True), gr.update(visible=False)
-    elif value == "Directory": return gr.update(visible=False), gr.update(visible=False), gr.update(visible=True)
-    return gr.update(visible=True), gr.update(visible=False), gr.update(visible=False) # Default to image
+    if value == "Image":
+        return (
+            gr.update(visible=True),
+            gr.update(visible=False),
+            gr.update(visible=False),
+        )
+    elif value == "Video":
+        return (
+            gr.update(visible=False),
+            gr.update(visible=True),
+            gr.update(visible=False),
+        )
+    elif value == "Directory":
+        return (
+            gr.update(visible=False),
+            gr.update(visible=False),
+            gr.update(visible=True),
+        )
+    elif value == "Stream":
+        return (
+            gr.update(visible=False),
+            gr.update(visible=False),
+            gr.update(visible=True),
+        )
+
 
 def swap_option_changed(value):
-    age_visible = bool(value and value.startswith("Age"))
-    # specific_face group is always hidden, source_image_input visibility depends on whether age is shown
-    source_input_visible = True # Generally source image is needed unless it's specific face mode without main source.
-                                # Since "Specific Face" is hidden, source_image_input should generally be visible.
-    if value == "Specific Face": # This option is removed from UI, but keep logic if used internally
-        source_input_visible = False # For "Specific Face", the individual src images are used.
+    if value.startswith("Age"):
+        return (
+            gr.update(visible=True),
+            gr.update(visible=False),
+            gr.update(visible=True),
+        )
+    elif value == "Specific Face":
+        return (
+            gr.update(visible=False),
+            gr.update(visible=True),
+            gr.update(visible=False),
+        )
+    return gr.update(visible=False), gr.update(visible=False), gr.update(visible=True)
 
-    return gr.update(visible=age_visible), gr.update(visible=False), gr.update(visible=source_input_visible)
 
-def video_changed(video_file_obj): # Input is Gradio's FileData object for gr.Video
+def video_changed(video_path):
     sliders_update = gr.Slider.update
+    button_update = gr.Button.update
     number_update = gr.Number.update
 
-    if video_file_obj is None or not hasattr(video_file_obj, 'name') or video_file_obj.name is None:
-        return sliders_update(minimum=0, maximum=0, value=0), \
-               sliders_update(minimum=1, maximum=1, value=1), \
-               number_update(value=1)
-    video_path = video_file_obj.name # Get filepath from FileData
+    if video_path is None:
+        return (
+            sliders_update(minimum=0, maximum=0, value=0),
+            sliders_update(minimum=1, maximum=1, value=1),
+            number_update(value=1),
+        )
     try:
-        if not os.path.exists(video_path):
-            print(f"Video path from Gradio object does not exist: {video_path}")
-            return sliders_update(minimum=0, maximum=0, value=0), \
-                   sliders_update(minimum=1, maximum=1, value=1), \
-                   number_update(value=1)
         clip = VideoFileClip(video_path)
-        fps = clip.fps if clip.fps is not None else 30
-        total_frames = clip.reader.nframes if clip.reader.nframes is not None else 0
-        max_slider = total_frames if total_frames > 0 else 1
+        fps = clip.fps
+        total_frames = clip.reader.nframes
         clip.close()
-        return sliders_update(minimum=0, maximum=max_slider, value=0, interactive=True), \
-               sliders_update(minimum=0, maximum=max_slider, value=max_slider, interactive=True), \
-               number_update(value=fps)
-    except Exception as e:
-        print(f"Error processing video for metadata: {e}")
-        return sliders_update(value=0, minimum=0, maximum=0), \
-               sliders_update(value=0, minimum=1, maximum=1), \
-               number_update(value=1)
-
-def analyse_settings_changed(det_cond, det_size, det_thresh): # Args renamed for clarity
-    yield "### \n ⌛ Applying new detection values..."
-    global FACE_ANALYSER, DETECT_CONDITION, DETECT_SIZE, DETECT_THRESH # Ensure globals are updated
-    DETECT_CONDITION = det_cond
-    DETECT_SIZE = int(det_size)
-    DETECT_THRESH = float(det_thresh)
-    # Force reload of analyser with new settings
-    FACE_ANALYSER = None # Set to None to force re-initialization
-    load_face_analyser_model()
-    yield f"### \n ✔️ Applied: Cond:{det_cond}, Size:{det_size}, Thresh:{det_thresh}"
+        return (
+            sliders_update(minimum=0, maximum=total_frames, value=0, interactive=True),
+            sliders_update(
+                minimum=0, maximum=total_frames, value=total_frames, interactive=True
+            ),
+            number_update(value=fps),
+        )
+    except:
+        return (
+            sliders_update(value=0),
+            sliders_update(value=0),
+            number_update(value=1),
+        )
 
-def stop_running():
-    global STREAMER # Streamer is for hidden stream type
-    if hasattr(STREAMER, "stop"): STREAMER.stop()
-    STREAMER = None
-    # Optionally, could try to interrupt the current 'process' if it's in a separate thread.
-    # For Gradio's default handling, returning "Cancelled" and having the event in `cancels` list is key.
-    return "Processing cancelled by user."
-
-def slider_changed(show_preview_frame, video_file_obj, frame_idx_val):
-    if not show_preview_frame or video_file_obj is None or not hasattr(video_file_obj, 'name') or video_file_obj.name is None:
-        return gr.Image.update(value=None, visible=show_preview_frame if show_preview_frame else False), gr.Video.update(visible=not show_preview_frame if show_preview_frame is not None else True)
-
-    video_path = video_file_obj.name
-    try:
-        if not os.path.exists(video_path): return gr.Image.update(value=None), gr.Video.update()
-        clip = VideoFileClip(video_path)
-        time_sec = frame_idx_val / clip.fps if clip.fps and clip.fps > 0 else 0
-        if time_sec > clip.duration: time_sec = clip.duration
-        frame_arr = clip.get_frame(time_sec)
-        clip.close()
-        return gr.Image.update(value=frame_arr, visible=True), gr.Video.update(visible=False)
-    except Exception as e:
-        print(f"Error in slider_changed: {e}")
-        return gr.Image.update(value=None, visible=True), gr.Video.update(visible=False)
 
-def trim_and_reload(video_file_obj, out_dir, out_name_base, start_f, stop_f): # Args renamed
-    if video_file_obj is None or not hasattr(video_file_obj, 'name') or video_file_obj.name is None:
-        return None, "### \n 🔥 Video not provided for trimming."
-    
-    original_video_path = video_file_obj.name
-    os.makedirs(out_dir, exist_ok=True)
-    # Use a unique name for the trimmed video to avoid overwriting
-    timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
-    trimmed_video_filename = f"{os.path.splitext(out_name_base)[0]}_trimmed_{timestamp}.mp4"
-    trimmed_video_full_path = os.path.join(out_dir, trimmed_video_filename)
-
-    yield original_video_path, f"### \n 🌈 Trimming video frame {start_f} to {stop_f}..."
+def analyse_settings_changed(detect_condition, detection_size, detection_threshold):
+    yield "### \n ⌛ Applying new values..."
+    global FACE_ANALYSER
+    global DETECT_CONDITION
+    DETECT_CONDITION = detect_condition
+    FACE_ANALYSER = insightface.app.FaceAnalysis(name="buffalo_l", providers=PROVIDER)
+    FACE_ANALYSER.prepare(
+        ctx_id=0,
+        det_size=(int(detection_size), int(detection_size)),
+        det_thresh=float(detection_threshold),
+    )
+    yield f"### \n ✔️ Applied detect condition:{detect_condition}, detection size: {detection_size}, detection threshold: {detection_threshold}"
+
+
+def stop_running():
+    global STREAMER
+    if hasattr(STREAMER, "stop"):
+        STREAMER.stop()
+        STREAMER = None
+    return "Cancelled"
+
+
+def slider_changed(show_frame, video_path, frame_index):
+    if not show_frame:
+        return None, None
+    if video_path is None:
+        return None, None
+    clip = VideoFileClip(video_path)
+    frame = clip.get_frame(frame_index / clip.fps)
+    frame_array = np.array(frame)
+    clip.close()
+    return gr.Image.update(value=frame_array, visible=True), gr.Video.update(
+        visible=False
+    )
+
+
+def trim_and_reload(video_path, output_path, output_name, start_frame, stop_frame):
+    yield video_path, f"### \n 🌈 Trimming video frame {start_frame} to {stop_frame}..."
     try:
-        if not os.path.exists(original_video_path):
-            raise ValueError(f"Original video for trimming not found: {original_video_path}")
-        
-        # trim_video should return the path to the new trimmed video
-        new_trimmed_path = trim_video(original_video_path, trimmed_video_full_path, start_f, stop_f)
-        yield new_trimmed_path, "### \n ✔️ Video trimmed and reloaded." # Return path for gr.Video
+        output_path = os.path.join(output_path, output_name)
+        trimmed_video = trim_video(video_path, output_path, start_frame, stop_frame)
+        yield trimmed_video, "### \n ✔️ Video trimmed and reloaded."
     except Exception as e:
-        print(f"Video trimming error: {e}")
-        yield original_video_path, f"### \n 🔥 Video trimming failed: {str(e)}. See console."
+        print(e)
+        yield video_path, "### \n 🔥 Video trimming failed. See console for more info."
 
 
-def load_latest_image_from_repo(repo_choice_val):
-    dataset_repo1_env = os.environ.get("DATASET_REPO") # Env var for repo1
-    dataset_repo2_env = os.environ.get("DATASET_REPO2") # Env var for repo2
+#
+def load_latest_image_from_repo(repo_choice): # 引数を追加
+    dataset_repo = os.environ.get("DATASET_REPO")
+    dataset_repo2 = os.environ.get("DATASET_REPO2") # dataset_repo2 を追加
     hf_token = os.environ.get("HF_TOKEN")
 
-    if not hf_token: return None, "❌ 環境変数 HF_TOKEN が設定されていません"
+    if not hf_token:
+        return None, "❌ 環境変数 HF_TOKEN が設定されていません"
 
-    target_repo_id = None
-    if repo_choice_val == "repo1": target_repo_id = dataset_repo1_env
-    elif repo_choice_val == "repo2": target_repo_id = dataset_repo2_env
-
-    if not target_repo_id:
-        return None, f"❌ 選択されたリポジトリ ({repo_choice_val}) の環境変数 (DATASET_REPO/DATASET_REPO2) が未設定です"
+    if repo_choice == "repo1" and dataset_repo: # 選択されたリポジトリに応じて切り替え
+        target_repo = dataset_repo
+    elif repo_choice == "repo2" and dataset_repo2:
+        target_repo = dataset_repo2
+    else:
+        return None, f"❌ 選択されたリポジトリの環境変数が設定されていません (選択: {repo_choice})"
 
     try:
-        last_update_url = f"https://huggingface.co/datasets/{target_repo_id}/resolve/main/images/last_update.txt"
+        # last_update.txt の URL を作成
+        last_update_url = f"https://huggingface.co/datasets/{target_repo}/resolve/main/images/last_update.txt"        
         headers = {'Authorization': f'Bearer {hf_token}'}
+        
+        # last_update.txt を取得
         print(f"Fetching last_update.txt from {last_update_url}")
-        response_txt = requests.get(last_update_url, headers=headers, timeout=10)
-        response_txt.raise_for_status()
-        image_file_url = response_txt.text.strip() # This should be the full URL from the text file
-
-        if not image_file_url: return None, "❌ last_update.txt が空か無効なURLです"
-        print(f"Image URL from last_update.txt: {image_file_url}")
-
-        print(f"Fetching image from {image_file_url}")
-        response_img = requests.get(image_file_url, headers=headers, timeout=20) # Longer timeout for image
-        response_img.raise_for_status()
-        pil_image = Image.open(BytesIO(response_img.content))
-        print("✔️ 画像の取得に成功しました")
-        return pil_image, "✔️ 最新の画像をロードしました"
-    except requests.exceptions.RequestException as e:
-        print(f"RequestException: {str(e)}")
-        return None, f"❌ ネットワーク/HTTPエラー: {str(e)}"
+        response = requests.get(last_update_url, headers=headers)
+        print(f"Status code for last_update.txt: {response.status_code}")
+        if response.status_code != 200:
+            return None, f"❌ last_update.txt を取得できません (HTTP {response.status_code})"
+        
+        image_url = response.text.strip()
+        if not image_url:
+            return None, "❌ last_update.txt が空です"
+        print(f"Image URL from last_update.txt: {image_url}")
+        
+        # 画像を取得
+        print(f"Fetching image from {image_url}")
+        response = requests.get(image_url, headers=headers)
+        print(f"Status code for image: {response.status_code}")
+        if response.status_code == 200:
+            img = Image.open(BytesIO(response.content))
+            print("✔️ 画像の取得に成功しました")
+            return img, "✔️ 最新の画像をロードしました"
+        else:
+            return None, f"❌ 画像を取得できません (HTTP {response.status_code})"
     except Exception as e:
-        print(f"Exception: {str(e)}")
-        return None, f"❌ 一般エラー: {str(e)}"
+        print(f"Exception occurred: {str(e)}")
+        return None, f"❌ エラーが発生しました: {str(e)}"
+
+def load_target_image():
+    img, message = load_latest_image_from_repo()
+    if img is None:
+        return None, f"### {message}"
+    return img, f"### {message}"
+
 
 ## ------------------------------ GRADIO GUI ------------------------------
+
 css = """
-.gradio-container { width: 100%; margin: 0 auto !important; padding: 20px !important; max-width: 100% !important; }
+.gradio-container {
+    width: 100%;
+    height: 100vh;
+    overflow: hidden;
+    margin: 0 auto !important;
+    padding: 20px !important;
+    max-width: 100% !important;
+}
+
 """
 
 with gr.Blocks(css=css) as interface:
+    #
     with gr.Row():
-        with gr.Column(scale=0.5, min_width=100): # Left column
-            with gr.Group(): # Input Area Group
-                with gr.Group(visible=True) as input_image_group: # Image input always visible
-                    repo_choice_radio = gr.Radio(["repo1", "repo2"], label="リポジトリを選択", value="repo1")
-                    target_load_button = gr.Button("TARGET_LOAD", variant="primary")
-                    target_load_info = gr.Markdown(value="...", visible=True)
-                    image_input = gr.Image(label="Target Image", interactive=True, type="filepath")
-                    # Hidden input_type radio, defaults to "Image"
-                    input_type_radio_hidden = gr.Radio(["Image", "Video"], label="Target Type", value="Image", visible=False)
-
-                with gr.Group(visible=False) as input_video_group: # Video input hidden
-                    video_input = gr.Video(label="Target Video", interactive=True) # Value will be FileData obj
+        ##左の列
+        with gr.Column(scale=0.5, min_width=100):
+
+            ##ターゲット画像入力エリア
+            with gr.Group():
+                with gr.Group(visible=True) as input_image_group:
+                    # ラジオボタンを追加
+                    repo_choice_radio = gr.Radio(
+                        ["repo1", "repo2"],
+                        label="リポジトリを選択",
+                        value="repo1"  # デフォルト値
+                    )
+
+                    target_load_button = gr.Button("TARGET_LOAD" , variant="primary")
+                    target_load_info = gr.Markdown(value="...",visible=False)
+                    image_input = gr.Image(
+                        label="Target Image", interactive=True, type="filepath"
+                    )
+
+                    
+                    input_type = gr.Radio(
+                        ["Image", "Video"],
+                        label="Target Type",
+                        value="Image",
+                        #visible=False
+                    )    
+
+                with gr.Group(visible=False) as input_video_group:
+                    vid_widget = gr.Video if USE_COLAB else gr.Text
+                    video_input = gr.Video(
+                        label="Target Video", interactive=True
+                    )
                     with gr.Accordion("Trim video", open=False):
-                        set_slider_range_btn = gr.Button("Set frame range")
-                        show_trim_preview_btn = gr.Checkbox(label="Show frame on slider change", value=True)
-                        video_fps_num = gr.Number(value=30, interactive=False, label="Fps", visible=False)
-                        start_frame_slider = gr.Slider(minimum=0, maximum=1, value=0, step=1, label="Start Frame")
-                        end_frame_slider = gr.Slider(minimum=0, maximum=1, value=1, step=1, label="End Frame")
-                        trim_and_reload_btn = gr.Button("Trim and Reload")
-
-                with gr.Group(visible=False) as input_directory_group: # Directory input hidden
-                    direc_input_text = gr.Text(label="Path", interactive=True)
-
-            source_image_input = gr.Image(label="Source face", type="filepath", interactive=True)
-
-            with gr.Group(visible=False) as specific_face_group: # Specific face selection hidden
-                # Dynamically create TabItems for specific faces (these will be hidden)
-                # Need to store these components if they were to be used.
-                # For now, they are defined but not collected into a list for `swap_inputs` in a new way
-                # The `exec` below defines `src1, trg1, ...` etc. in the current scope.
+                        with gr.Column():
+                            with gr.Row():
+                                set_slider_range_btn = gr.Button(
+                                    "Set frame range", interactive=True
+                                )
+                                show_trim_preview_btn = gr.Checkbox(
+                                    label="Show frame when slider change",
+                                    value=True,
+                                    interactive=True,
+                                )
+
+                            video_fps = gr.Number(
+                                value=30,
+                                interactive=False,
+                                label="Fps",
+                                visible=False,
+                            )
+                            start_frame = gr.Slider(
+                                minimum=0,
+                                maximum=1,
+                                    value=0,
+                                step=1,
+                                interactive=True,
+                                label="Start Frame",
+                                info="",
+                            )
+                            end_frame = gr.Slider(
+                                minimum=0,
+                                maximum=1,
+                                value=1,
+                                step=1,
+                                interactive=True,
+                                label="End Frame",
+                                info="",
+                            )
+                            trim_and_reload_btn = gr.Button(
+                                "Trim and Reload", interactive=True
+                            )
+
+                with gr.Group(visible=False) as input_directory_group:
+                
+                    direc_input = gr.Text(label="Path", interactive=True)
+            ##画像入力エリア終了    
+            
+            ##ソース画像入力エリア
+            source_image_input = gr.Image(
+                label="Source face", type="filepath", interactive=True
+            )
+
+            with gr.Group(visible=False) as specific_face:
                 for i in range(NUM_OF_SRC_SPECIFIC):
                     idx = i + 1
-                    exec(
-                        f"with gr.Tab(label='({idx})'):\n"
-                        f"\twith gr.Row():\n"
-                        f"\t\tsrc{idx} = gr.Image(interactive=True, type='numpy', label='Source Face {idx}')\n"
-                        f"\t\ttrg{idx} = gr.Image(interactive=True, type='numpy', label='Specific Face {idx}')"
-                    )
-                distance_slider_specific = gr.Slider(minimum=0, maximum=2, value=0.6, interactive=True, label="Distance")
+                    code = "\n"
+                    code += f"with gr.Tab(label='({idx})'):"
+                    code += "\n\twith gr.Row():"
+                    code += f"\n\t\tsrc{idx} = gr.Image(interactive=True, type='numpy', label='Source Face {idx}')"
+                    code += f"\n\t\ttrg{idx} = gr.Image(interactive=True, type='numpy', label='Specific Face {idx}')"
+                    exec(code)
+
+                distance_slider = gr.Slider(
+                    minimum=0,
+                    maximum=2,
+                    value=0.6,
+                    interactive=True,
+                    label="Distance",
+                    info="Lower distance is more similar and higher distance is less similar to the target face.",
+                )
+            ##ソース画像入力エリア終了
 
-        with gr.Column(scale=0.5, min_width=100): # Right column
-            with gr.Row():
-                swap_button = gr.Button("Swap", variant="primary")
-                cancel_button = gr.Button("Cancel") # Should always be interactive
 
-            preview_image_output = gr.Image(label="Output", interactive=False) # For image result
-            save_button_hf = gr.Button("Save", variant="primary") # To save to HF dataset
-            preview_video_output = gr.Video(label="Output", interactive=False, visible=False) # For video result
 
-            with gr.Row(): # Buttons to open output locations
-                # Visibility of these buttons could be controlled based on WORKSPACE/OUTPUT_FILE
-                output_directory_open_button = gr.Button("💚 Open Output Dir", interactive=True, visible=True) # Simplified
-                output_file_open_button = gr.Button("💘 Open Output File", interactive=True, visible=True) # Simplified
 
-            info_markdown = gr.Markdown(value="...") # For status messages
 
+
+
+        ##右の列    
+        with gr.Column(scale=0.5, min_width=100):
+            ##画像出力パート
+            with gr.Row():
+                swap_button = gr.Button("Swap", variant="primary")
+                cancel_button = gr.Button("Cancel")
+
+            preview_image = gr.Image(label="Output", interactive=False)
+            save_button = gr.Button("Save" , variant="primary")  # 新しく追加するボタン
+            preview_video = gr.Video(
+                label="Output", interactive=False, visible=False
+            )
+
+            with gr.Row():
+                output_directory_button = gr.Button(
+                    "💚", interactive=False, visible=False
+                )
+                output_video_button = gr.Button(
+                    "💘", interactive=False, visible=False
+                )
+            info = gr.Markdown(value="...")
+            ##画像出力パート終了
+
+            ##４つのタブパート
             with gr.Tab("Swap Condition"):
-                swap_option_dropdown = gr.Dropdown(swap_options_list_ui, # Use UI-specific list
-                                             value=swap_options_list_ui[0] if swap_options_list_ui else None,
-                                             label="Swap Condition", interactive=True, show_label=False)
-                age_number_input = gr.Number(value=25, label="Value for Age", interactive=True, visible=False)
-
-            with gr.Tab("Detection Settings", visible=False): # Hidden Tab
-                detect_condition_dropdown = gr.Dropdown(detect_conditions, label="Condition", value=DETECT_CONDITION)
-                detection_size_number = gr.Number(label="Detection Size", value=DETECT_SIZE)
-                detection_threshold_number = gr.Number(label="Detection Threshold", value=DETECT_THRESH)
-                apply_detection_settings_btn = gr.Button("Apply Detection Settings")
-
-            with gr.Tab("Output Settings", visible=False): # Hidden Tab
-                output_directory_text = gr.Text(label="Output Directory", value=DEF_OUTPUT_PATH)
-                output_name_text = gr.Text(label="Output Name", value="Result")
-                keep_output_sequence_check = gr.Checkbox(label="Keep output sequence (for video)", value=True)
-
-            with gr.Tab("Other Settings"): # Visible Tab
-                face_scale_slider = gr.Slider(label="Face Scale", minimum=0, maximum=2, value=0.98, interactive=True)
-                face_enhancer_name_dropdown = gr.Dropdown(FACE_ENHANCER_LIST, label="Face Enhancer", value="GFPGAN")
+                swap_option = gr.Dropdown(
+                    swap_options_list,
+                    info="Choose which face or faces in the target image to swap.",
+                    multiselect=False,
+                    show_label=False,
+                    value=swap_options_list[0],
+                    interactive=True,
+                )
+                age = gr.Number(
+                    value=25, label="Value", interactive=True, visible=False
+                )
+
+            with gr.Tab("Detection Settings",visible=False):
+                detect_condition_dropdown = gr.Dropdown(
+                    detect_conditions,
+                    label="Condition",
+                    value=DETECT_CONDITION,
+                    interactive=True,
+                    info="This condition is only used when multiple faces are detected on source or specific image.",
+                )
+                detection_size = gr.Number(
+                    label="Detection Size", value=DETECT_SIZE, interactive=True
+                )
+                detection_threshold = gr.Number(
+                    label="Detection Threshold",
+                    value=DETECT_THRESH,
+                    interactive=True,
+                )
+                apply_detection_settings = gr.Button("Apply settings")
+
+            with gr.Tab("Output Settings",visible=False):
+                output_directory = gr.Text(
+                    label="Output Directory",
+                    value=DEF_OUTPUT_PATH,
+                    interactive=True,
+                )
+                output_name = gr.Text(
+                    label="Output Name", value="Result", interactive=True
+                )
+                keep_output_sequence = gr.Checkbox(
+                    label="Keep output sequence", value=True, interactive=True
+                )
+
+            with gr.Tab("Other Settings"):
+                face_scale = gr.Slider(
+                    label="Face Scale",
+                    minimum=0,
+                    maximum=2,
+                    value=0.98,
+                    interactive=True,
+                )
+
+                face_enhancer_name = gr.Dropdown(
+                    FACE_ENHANCER_LIST, label="Face Enhancer", value="GFPGAN", multiselect=False, interactive=True
+                )
 
                 with gr.Accordion("Advanced Mask", open=False):
-                    enable_face_parser_mask_check = gr.Checkbox(label="Enable Face Parsing", value=True)
-                    mask_include_dropdown = gr.Dropdown(list(mask_regions.keys()), value=MASK_INCLUDE, multiselect=True, label="Include Regions")
-                    mask_soft_kernel_number = gr.Number(label="Soft Erode Kernel", value=MASK_SOFT_KERNEL, minimum=3, visible=False) # Hidden as per original
-                    mask_soft_iterations_number = gr.Number(label="Soft Erode Iterations", value=MASK_SOFT_ITERATIONS, minimum=0)
+                    enable_face_parser_mask = gr.Checkbox(
+                        label="Enable Face Parsing",
+                        value=True,
+                        interactive=True,
+                    )
+
+                    mask_include = gr.Dropdown(
+                        mask_regions.keys(),
+                        value=MASK_INCLUDE,
+                        multiselect=True,
+                        label="Include",
+                        interactive=True,
+                    )
+                    mask_soft_kernel = gr.Number(
+                        label="Soft Erode Kernel",
+                        value=MASK_SOFT_KERNEL,
+                        minimum=3,
+                        interactive=True,
+                        visible = False
+                    )
+                    mask_soft_iterations = gr.Number(
+                        label="Soft Erode Iterations",
+                        value=MASK_SOFT_ITERATIONS,
+                        minimum=0,
+                        interactive=True,
+
+                    )
+
 
                 with gr.Accordion("Crop Mask", open=False):
-                    crop_top_slider = gr.Slider(label="Top", minimum=0, maximum=511, value=0, step=1)
-                    crop_bott_slider = gr.Slider(label="Bottom", minimum=0, maximum=511, value=511, step=1)
-                    crop_left_slider = gr.Slider(label="Left", minimum=0, maximum=511, value=0, step=1)
-                    crop_right_slider = gr.Slider(label="Right", minimum=0, maximum=511, value=511, step=1)
+                    crop_top = gr.Slider(label="Top", minimum=0, maximum=511, value=0, step=1, interactive=True)
+                    crop_bott = gr.Slider(label="Bottom", minimum=0, maximum=511, value=511, step=1, interactive=True)
+                    crop_left = gr.Slider(label="Left", minimum=0, maximum=511, value=0, step=1, interactive=True)
+                    crop_right = gr.Slider(label="Right", minimum=0, maximum=511, value=511, step=1, interactive=True)
+
+
+                erode_amount = gr.Slider(
+                        label="Mask Erode",
+                        minimum=0,
+                        maximum=1,
+                        value=MASK_ERODE_AMOUNT,
+                        step=0.05,
+                        interactive=True,
+                    )
+
+                blur_amount = gr.Slider(
+                        label="Mask Blur",
+                        minimum=0,
+                        maximum=1,
+                        value=MASK_BLUR_AMOUNT,
+                        step=0.05,
+                        interactive=True,
+                    )
+
+                enable_laplacian_blend = gr.Checkbox(
+                    label="Laplacian Blending",
+                    value=True,
+                    interactive=True,
+                )
+            ##４つのタブパート終了
+
+
+
+
 
-                erode_amount_slider = gr.Slider(label="Mask Erode", minimum=0, maximum=1, value=MASK_ERODE_AMOUNT, step=0.05)
-                blur_amount_slider = gr.Slider(label="Mask Blur", minimum=0, maximum=1, value=MASK_BLUR_AMOUNT, step=0.05)
-                enable_laplacian_blend_check = gr.Checkbox(label="Laplacian Blending", value=True)
 
     ## ------------------------------ GRADIO EVENTS ------------------------------
-    # Events for hidden video UI - they will still be set up but might not be triggered by user
-    set_slider_range_event = set_slider_range_btn.click(video_changed, inputs=[video_input], outputs=[start_frame_slider, end_frame_slider, video_fps_num])
-    trim_and_reload_event = trim_and_reload_btn.click(fn=trim_and_reload, inputs=[video_input, output_directory_text, output_name_text, start_frame_slider, end_frame_slider], outputs=[video_input, info_markdown])
-    start_frame_slider.release(fn=slider_changed, inputs=[show_trim_preview_btn, video_input, start_frame_slider], outputs=[preview_image_output, preview_video_output])
-    end_frame_slider.release(fn=slider_changed, inputs=[show_trim_preview_btn, video_input, end_frame_slider], outputs=[preview_image_output, preview_video_output])
-
-    # Input type change is disabled as UI is hidden
-    # input_type_radio_hidden.change(...)
-
-    swap_option_dropdown.change(swap_option_changed, inputs=[swap_option_dropdown], outputs=[age_number_input, specific_face_group, source_image_input])
-    apply_detection_settings_btn.click(analyse_settings_changed, inputs=[detect_condition_dropdown, detection_size_number, detection_threshold_number], outputs=[info_markdown])
-
-    # Collect specific face components (src1, trg1, etc.) which are defined by exec() earlier
-    _src_specific_components_tuple = ()
-    _s_names = []
-    for i in range(NUM_OF_SRC_SPECIFIC): _s_names.append(f"src{i+1}")
-    for i in range(NUM_OF_SRC_SPECIFIC): _s_names.append(f"trg{i+1}")
-    exec(f"_src_specific_components_tuple = ({','.join(_s_names)})")
-
-    swap_inputs_list = [
-        image_input, video_input, direc_input_text, source_image_input,
-        output_directory_text, output_name_text, keep_output_sequence_check,
-        swap_option_dropdown, age_number_input, distance_slider_specific,
-        face_enhancer_name_dropdown, enable_face_parser_mask_check, mask_include_dropdown,
-        mask_soft_kernel_number, mask_soft_iterations_number, # UI names
-        blur_amount_slider, erode_amount_slider, face_scale_slider, enable_laplacian_blend_check,
-        crop_top_slider, crop_bott_slider, crop_left_slider, crop_right_slider,
-        *_src_specific_components_tuple
+
+    set_slider_range_event = set_slider_range_btn.click(
+        video_changed,
+        inputs=[video_input],
+        outputs=[start_frame, end_frame, video_fps],
+    )
+
+    trim_and_reload_event = trim_and_reload_btn.click(
+        fn=trim_and_reload,
+        inputs=[video_input, output_directory, output_name, start_frame, end_frame],
+        outputs=[video_input, info],
+    )
+
+    start_frame_event = start_frame.release(
+        fn=slider_changed,
+        inputs=[show_trim_preview_btn, video_input, start_frame],
+        outputs=[preview_image, preview_video],
+        show_progress=True,
+    )
+
+    end_frame_event = end_frame.release(
+        fn=slider_changed,
+        inputs=[show_trim_preview_btn, video_input, end_frame],
+        outputs=[preview_image, preview_video],
+        show_progress=True,
+    )
+
+    input_type.change(
+        update_radio,
+        inputs=[input_type],
+        outputs=[input_image_group, input_video_group, input_directory_group],
+    )
+    swap_option.change(
+        swap_option_changed,
+        inputs=[swap_option],
+        outputs=[age, specific_face, source_image_input],
+    )
+
+    apply_detection_settings.click(
+        analyse_settings_changed,
+        inputs=[detect_condition_dropdown, detection_size, detection_threshold],
+        outputs=[info],
+    )
+
+    src_specific_inputs = []
+    gen_variable_txt = ",".join(
+        [f"src{i+1}" for i in range(NUM_OF_SRC_SPECIFIC)]
+        + [f"trg{i+1}" for i in range(NUM_OF_SRC_SPECIFIC)]
+    )
+    exec(f"src_specific_inputs = ({gen_variable_txt})")
+    swap_inputs = [
+        input_type,
+        image_input,
+        video_input,
+        direc_input,
+        source_image_input,
+        output_directory,
+        output_name,
+        keep_output_sequence,
+        swap_option,
+        age,
+        distance_slider,
+        face_enhancer_name,
+        enable_face_parser_mask,
+        mask_include,
+        mask_soft_kernel,
+        mask_soft_iterations,
+        blur_amount,
+        erode_amount,
+        face_scale,
+        enable_laplacian_blend,
+        crop_top,
+        crop_bott,
+        crop_left,
+        crop_right,
+        *src_specific_inputs,
     ]
 
-    # Outputs for the process function's yield.
-    # Matches: message, preview_image_update, dir_btn_update, vid_btn_update, preview_vid_update
-    # The ui_before/after functions return updates for these specific components in order.
-    swap_outputs_list = [
-        info_markdown,
-        preview_image_output,       # Updated by ui_before[0] etc.
-        output_directory_open_button, # Updated by ui_before[1] etc. (interactive toggle)
-        output_file_open_button,      # Updated by ui_before[2] etc. (interactive toggle)
-        preview_video_output        # Updated by ui_before[3] etc.
+    swap_outputs = [
+        info,
+        preview_image,
+        output_directory_button,
+        output_video_button,
+        preview_video,
     ]
 
-    swap_event = swap_button.click(fn=process, inputs=swap_inputs_list, outputs=swap_outputs_list, show_progress=True)
+    swap_event = swap_button.click(
+        fn=process, inputs=swap_inputs, outputs=swap_outputs, show_progress=True
+    )
     
-    cancel_event = cancel_button.click(fn=stop_running, inputs=None, outputs=[info_markdown],
-                                   cancels=[swap_event, trim_and_reload_event, set_slider_range_event]) # Removed slider events from cancel as they are minor
-
-    output_directory_open_button.click(lambda: open_directory(path=WORKSPACE) if WORKSPACE and os.path.isdir(WORKSPACE) else print(f"Workspace '{WORKSPACE}' not set or not a directory."), inputs=None, outputs=None)
-    output_file_open_button.click(lambda: open_directory(path=OUTPUT_FILE) if OUTPUT_FILE and os.path.exists(OUTPUT_FILE) else print(f"Output file '{OUTPUT_FILE}' not set or does not exist."), inputs=None, outputs=None)
-
-
-    def save_to_huggingface_dataset(image_numpy_array):
-        if image_numpy_array is None: return "❌ 出力画像がありません。"
-        save_repo_id = os.environ.get("SAVE_REPO")
+    
+    cancel_button.click(
+        fn=stop_running,
+        inputs=None,
+        outputs=[info],
+        cancels=[
+            swap_event,
+            trim_and_reload_event,
+            set_slider_range_event,
+            start_frame_event,
+            end_frame_event,
+        ],
+        show_progress=True,
+        
+    )
+    output_directory_button.click(
+        lambda: open_directory(path=WORKSPACE), inputs=None, outputs=None
+    )
+    output_video_button.click(
+        lambda: open_directory(path=OUTPUT_FILE), inputs=None, outputs=None
+    )
+
+    # Save ボタンのコールバック関数
+    def save_to_huggingface(image):
+        import os
+        from datasets import Dataset, Features, Image as DatasetImage, Value, load_dataset, concatenate_datasets
+        import datetime
+        from PIL import Image  # 追加
+
+        save_repo = os.environ.get("SAVE_REPO")
         hf_token = os.environ.get("HF_TOKEN")
-        if not save_repo_id or not hf_token: return "❌ 環境変数 SAVE_REPO または HF_TOKEN が未設定"
+
+        if not save_repo or not hf_token:
+            return "❌ 環境変数 SAVE_REPO または HF_TOKEN が設定されていません"
 
         try:
-            cache_dir = os.path.join(os.getcwd(), ".hf_datasets_cache_save")
-            os.makedirs(cache_dir, exist_ok=True)
+            # 既存のデータセットをロード
             try:
-                dataset = load_dataset(save_repo_id, split='train', use_auth_token=hf_token, cache_dir=cache_dir)
-            except Exception: # If dataset doesn't exist or other loading error
-                print(f"Dataset {save_repo_id} not found or error loading, creating new one.")
-                ds_features = Features({"image": DatasetImage(), "timestamp": Value("string")})
-                dataset = Dataset.from_dict({"image": [], "timestamp": []}, features=ds_features)
-
-            pil_img_to_save = Image.fromarray(image_numpy_array.astype('uint8'), 'RGB')
-            temp_img_path = os.path.join(os.getcwd(), "temp_hf_upload.png")
-            pil_img_to_save.save(temp_img_path)
-
-            new_data_entry = Dataset.from_dict({
-                "image": [temp_img_path],
-                "timestamp": [str(datetime.datetime.now())]},
-                features=dataset.features # Use existing dataset features
-            )
-            updated_dataset = concatenate_datasets([dataset, new_data_entry])
-            updated_dataset.push_to_hub(save_repo_id, token=hf_token)
-            os.remove(temp_img_path)
+                ds = load_dataset(save_repo, split='train', use_auth_token=hf_token)
+            except:
+                # データセットがまだ存在しない場合、新規作成
+                ds = Dataset.from_dict({"image": [], "timestamp": []})
+            
+            # 画像を保存し、新しいデータを追加
+            image_pil = Image.fromarray(image.astype('uint8'), 'RGB')  # numpy 配列を PIL 画像に変換
+            image_path = "temp_output_image.png"
+            image_pil.save(image_path)
+            new_data = Dataset.from_dict({
+                "image": [image_path],
+                "timestamp": [str(datetime.datetime.now())]
+            }, features=Features({
+                "image": DatasetImage(),
+                "timestamp": Value("string"),
+            }))
+            
+            # データセットを更新
+            ds = concatenate_datasets([ds, new_data])
+            
+            # データセットをプッシュ
+            ds.push_to_hub(save_repo, token=hf_token)
+            
+            # 一時ファイルを削除
+            os.remove(image_path)
+            
             return "✔️ 画像をHugging Faceデータセットに保存しました"
         except Exception as e:
-            if 'temp_img_path' in locals() and os.path.exists(temp_img_path): os.remove(temp_img_path)
-            return f"❌ HFへの保存中にエラー: {str(e)}"
-
-    save_button_hf.click(fn=save_to_huggingface_dataset, inputs=[preview_image_output], outputs=[info_markdown], show_progress=True)
-
-    def load_target_from_hf_with_choice(repo_choice_val):
-        pil_img, msg = load_latest_image_from_repo(repo_choice_val)
-        # image_input (gr.Image) can take PIL image directly
-        return pil_img, f"### {msg}" # Update image_input and target_load_info
+            return f"❌ エラーが発生しました: {str(e)}"
+
+    # Save ボタンのイベント設定
+    save_button.click(
+        fn=save_to_huggingface,
+        inputs=[preview_image],
+        outputs=[info],
+        show_progress=True
+    )
+    
+    def load_target_image_with_choice(repo_choice): # 引数を追加
+        img, message = load_latest_image_from_repo(repo_choice)
+        if img is None:
+            return None, f"### {message}"
+        return img, f"### {message}"
+
+    target_load_button.click(
+        fn=load_target_image_with_choice, # 関数名を変更
+        inputs=[repo_choice_radio], # ラジオボタンの値を入力として渡す
+        outputs=[image_input, target_load_info],
+        show_progress=True,
+    )
+
+    repo_choice_radio.change( # ラジオボタンの変更イベントを追加
+        fn=load_target_image_with_choice,
+        inputs=[repo_choice_radio],
+        outputs=[image_input, target_load_info],
+        show_progress=True,
+    )
 
-    target_load_button.click(fn=load_target_from_hf_with_choice, inputs=[repo_choice_radio], outputs=[image_input, target_load_info], show_progress=True)
-    repo_choice_radio.change(fn=load_target_from_hf_with_choice, inputs=[repo_choice_radio], outputs=[image_input, target_load_info], show_progress=True)
 
 if __name__ == "__main__":
-    if USE_COLAB: print("Running in colab mode, share=True might be set by launch()")
-    # Use debug=True for more detailed Gradio logs if needed
-    interface.queue(concurrency_count=2, max_size=20).launch(share=USE_COLAB, debug=True)
+    if USE_COLAB:
+        print("Running in colab mode")
+
+    interface.queue(concurrency_count=2, max_size=20).launch(share=USE_COLAB)