Upload 44 files

uis/components/about.py

@@ -0,0 +1,41 @@
+import random
+from typing import Optional
+
+import gradio
+
+from facefusion import metadata, translator
+
+METADATA_BUTTON : Optional[gradio.Button] = None
+ACTION_BUTTON : Optional[gradio.Button] = None
+
+
+def render() -> None:
+	global METADATA_BUTTON
+	global ACTION_BUTTON
+
+	action = random.choice(
+	[
+		{
+			'translator': translator.get('about.fund'),
+			'url': 'https://fund.facefusion.io'
+		},
+		{
+			'translator': translator.get('about.subscribe'),
+			'url': 'https://subscribe.facefusion.io'
+		},
+		{
+			'translator': translator.get('about.join'),
+			'url': 'https://join.facefusion.io'
+		}
+	])
+
+	METADATA_BUTTON = gradio.Button(
+		value = metadata.get('name') + ' ' + metadata.get('version'),
+		variant = 'primary',
+		link = metadata.get('url')
+	)
+	ACTION_BUTTON = gradio.Button(
+		value = action.get('translator'),
+		link = action.get('url'),
+		size = 'sm'
+	)

uis/components/age_modifier_options.py

@@ -0,0 +1,64 @@
+from typing import List, Optional, Tuple
+
+import gradio
+
+from facefusion import state_manager, translator
+from facefusion.common_helper import calculate_float_step
+from facefusion.processors.core import load_processor_module
+from facefusion.processors.modules.age_modifier import choices as age_modifier_choices
+from facefusion.processors.modules.age_modifier.types import AgeModifierModel
+from facefusion.uis.core import get_ui_component, register_ui_component
+
+AGE_MODIFIER_MODEL_DROPDOWN : Optional[gradio.Dropdown] = None
+AGE_MODIFIER_DIRECTION_SLIDER : Optional[gradio.Slider] = None
+
+
+def render() -> None:
+	global AGE_MODIFIER_MODEL_DROPDOWN
+	global AGE_MODIFIER_DIRECTION_SLIDER
+
+	has_age_modifier = 'age_modifier' in state_manager.get_item('processors')
+	AGE_MODIFIER_MODEL_DROPDOWN = gradio.Dropdown(
+		label = translator.get('uis.model_dropdown', 'facefusion.processors.modules.age_modifier'),
+		choices = age_modifier_choices.age_modifier_models,
+		value = state_manager.get_item('age_modifier_model'),
+		visible = has_age_modifier
+	)
+	AGE_MODIFIER_DIRECTION_SLIDER = gradio.Slider(
+		label = translator.get('uis.direction_slider', 'facefusion.processors.modules.age_modifier'),
+		value = state_manager.get_item('age_modifier_direction'),
+		step = calculate_float_step(age_modifier_choices.age_modifier_direction_range),
+		minimum = age_modifier_choices.age_modifier_direction_range[0],
+		maximum = age_modifier_choices.age_modifier_direction_range[-1],
+		visible = has_age_modifier
+	)
+	register_ui_component('age_modifier_model_dropdown', AGE_MODIFIER_MODEL_DROPDOWN)
+	register_ui_component('age_modifier_direction_slider', AGE_MODIFIER_DIRECTION_SLIDER)
+
+
+def listen() -> None:
+	AGE_MODIFIER_MODEL_DROPDOWN.change(update_age_modifier_model, inputs = AGE_MODIFIER_MODEL_DROPDOWN, outputs = AGE_MODIFIER_MODEL_DROPDOWN)
+	AGE_MODIFIER_DIRECTION_SLIDER.release(update_age_modifier_direction, inputs = AGE_MODIFIER_DIRECTION_SLIDER)
+
+	processors_checkbox_group = get_ui_component('processors_checkbox_group')
+	if processors_checkbox_group:
+		processors_checkbox_group.change(remote_update, inputs = processors_checkbox_group, outputs = [ AGE_MODIFIER_MODEL_DROPDOWN, AGE_MODIFIER_DIRECTION_SLIDER ])
+
+
+def remote_update(processors : List[str]) -> Tuple[gradio.Dropdown, gradio.Slider]:
+	has_age_modifier = 'age_modifier' in processors
+	return gradio.Dropdown(visible = has_age_modifier), gradio.Slider(visible = has_age_modifier)
+
+
+def update_age_modifier_model(age_modifier_model : AgeModifierModel) -> gradio.Dropdown:
+	age_modifier_module = load_processor_module('age_modifier')
+	age_modifier_module.clear_inference_pool()
+	state_manager.set_item('age_modifier_model', age_modifier_model)
+
+	if age_modifier_module.pre_check():
+		return gradio.Dropdown(value = state_manager.get_item('age_modifier_model'))
+	return gradio.Dropdown()
+
+
+def update_age_modifier_direction(age_modifier_direction : float) -> None:
+	state_manager.set_item('age_modifier_direction', int(age_modifier_direction))

uis/components/background_remover_options.py

@@ -0,0 +1,165 @@
+from typing import List, Optional, Tuple
+
+import gradio
+
+from facefusion import state_manager, translator
+from facefusion.common_helper import calculate_int_step
+from facefusion.processors.core import load_processor_module
+from facefusion.processors.modules.background_remover import choices as background_remover_choices
+from facefusion.processors.modules.background_remover.types import BackgroundRemoverModel
+from facefusion.sanitizer import sanitize_int_range
+from facefusion.uis.core import get_ui_component, register_ui_component
+
+BACKGROUND_REMOVER_MODEL_DROPDOWN : Optional[gradio.Dropdown] = None
+BACKGROUND_REMOVER_FILL_COLOR_WRAPPER : Optional[gradio.Group] = None
+BACKGROUND_REMOVER_FILL_COLOR_RED_NUMBER : Optional[gradio.Number] = None
+BACKGROUND_REMOVER_FILL_COLOR_GREEN_NUMBER : Optional[gradio.Number] = None
+BACKGROUND_REMOVER_FILL_COLOR_BLUE_NUMBER : Optional[gradio.Number] = None
+BACKGROUND_REMOVER_FILL_COLOR_ALPHA_NUMBER : Optional[gradio.Number] = None
+BACKGROUND_REMOVER_DESPILL_COLOR_WRAPPER : Optional[gradio.Group] = None
+BACKGROUND_REMOVER_DESPILL_COLOR_RED_NUMBER : Optional[gradio.Number] = None
+BACKGROUND_REMOVER_DESPILL_COLOR_GREEN_NUMBER : Optional[gradio.Number] = None
+BACKGROUND_REMOVER_DESPILL_COLOR_BLUE_NUMBER : Optional[gradio.Number] = None
+BACKGROUND_REMOVER_DESPILL_COLOR_ALPHA_NUMBER : Optional[gradio.Number] = None
+
+
+def render() -> None:
+	global BACKGROUND_REMOVER_MODEL_DROPDOWN
+	global BACKGROUND_REMOVER_FILL_COLOR_WRAPPER
+	global BACKGROUND_REMOVER_FILL_COLOR_RED_NUMBER
+	global BACKGROUND_REMOVER_FILL_COLOR_GREEN_NUMBER
+	global BACKGROUND_REMOVER_FILL_COLOR_BLUE_NUMBER
+	global BACKGROUND_REMOVER_FILL_COLOR_ALPHA_NUMBER
+	global BACKGROUND_REMOVER_DESPILL_COLOR_WRAPPER
+	global BACKGROUND_REMOVER_DESPILL_COLOR_RED_NUMBER
+	global BACKGROUND_REMOVER_DESPILL_COLOR_GREEN_NUMBER
+	global BACKGROUND_REMOVER_DESPILL_COLOR_BLUE_NUMBER
+	global BACKGROUND_REMOVER_DESPILL_COLOR_ALPHA_NUMBER
+
+	has_background_remover = 'background_remover' in state_manager.get_item('processors')
+	background_remover_fill_color = state_manager.get_item('background_remover_fill_color')
+	background_remover_despill_color = state_manager.get_item('background_remover_despill_color')
+	BACKGROUND_REMOVER_MODEL_DROPDOWN = gradio.Dropdown(
+		label = translator.get('uis.model_dropdown', 'facefusion.processors.modules.background_remover'),
+		choices = background_remover_choices.background_remover_models,
+		value = state_manager.get_item('background_remover_model'),
+		visible = has_background_remover
+	)
+	with gradio.Group(visible = has_background_remover) as BACKGROUND_REMOVER_FILL_COLOR_WRAPPER:
+		with gradio.Row():
+			BACKGROUND_REMOVER_FILL_COLOR_RED_NUMBER = gradio.Number(
+				label = translator.get('uis.fill_color_red_number', 'facefusion.processors.modules.background_remover'),
+				value = background_remover_fill_color[0],
+				minimum = background_remover_choices.background_remover_color_range[0],
+				maximum = background_remover_choices.background_remover_color_range[-1],
+				step = calculate_int_step(background_remover_choices.background_remover_color_range)
+			)
+			BACKGROUND_REMOVER_FILL_COLOR_GREEN_NUMBER = gradio.Number(
+				label = translator.get('uis.fill_color_green_number', 'facefusion.processors.modules.background_remover'),
+				value = background_remover_fill_color[1],
+				minimum = background_remover_choices.background_remover_color_range[0],
+				maximum = background_remover_choices.background_remover_color_range[-1],
+				step = calculate_int_step(background_remover_choices.background_remover_color_range)
+			)
+		with gradio.Row():
+			BACKGROUND_REMOVER_FILL_COLOR_BLUE_NUMBER = gradio.Number(
+				label = translator.get('uis.fill_color_blue_number', 'facefusion.processors.modules.background_remover'),
+				value = background_remover_fill_color[2],
+				minimum = background_remover_choices.background_remover_color_range[0],
+				maximum = background_remover_choices.background_remover_color_range[-1],
+				step = calculate_int_step(background_remover_choices.background_remover_color_range)
+			)
+			BACKGROUND_REMOVER_FILL_COLOR_ALPHA_NUMBER = gradio.Number(
+				label = translator.get('uis.fill_color_alpha_number', 'facefusion.processors.modules.background_remover'),
+				value = background_remover_fill_color[3],
+				minimum = background_remover_choices.background_remover_color_range[0],
+				maximum = background_remover_choices.background_remover_color_range[-1],
+				step = calculate_int_step(background_remover_choices.background_remover_color_range)
+			)
+	with gradio.Group(visible = has_background_remover) as BACKGROUND_REMOVER_DESPILL_COLOR_WRAPPER:
+		with gradio.Row():
+			BACKGROUND_REMOVER_DESPILL_COLOR_RED_NUMBER = gradio.Number(
+				label = translator.get('uis.despill_color_red_number', 'facefusion.processors.modules.background_remover'),
+				value = background_remover_despill_color[0],
+				minimum = background_remover_choices.background_remover_color_range[0],
+				maximum = background_remover_choices.background_remover_color_range[-1],
+				step = calculate_int_step(background_remover_choices.background_remover_color_range)
+			)
+			BACKGROUND_REMOVER_DESPILL_COLOR_GREEN_NUMBER = gradio.Number(
+				label = translator.get('uis.despill_color_green_number', 'facefusion.processors.modules.background_remover'),
+				value = background_remover_despill_color[1],
+				minimum = background_remover_choices.background_remover_color_range[0],
+				maximum = background_remover_choices.background_remover_color_range[-1],
+				step = calculate_int_step(background_remover_choices.background_remover_color_range)
+			)
+		with gradio.Row():
+			BACKGROUND_REMOVER_DESPILL_COLOR_BLUE_NUMBER = gradio.Number(
+				label = translator.get('uis.despill_color_blue_number', 'facefusion.processors.modules.background_remover'),
+				value = background_remover_despill_color[2],
+				minimum = background_remover_choices.background_remover_color_range[0],
+				maximum = background_remover_choices.background_remover_color_range[-1],
+				step = calculate_int_step(background_remover_choices.background_remover_color_range)
+			)
+			BACKGROUND_REMOVER_DESPILL_COLOR_ALPHA_NUMBER = gradio.Number(
+				label = translator.get('uis.despill_color_alpha_number', 'facefusion.processors.modules.background_remover'),
+				value = background_remover_despill_color[3],
+				minimum = background_remover_choices.background_remover_color_range[0],
+				maximum = background_remover_choices.background_remover_color_range[-1],
+				step = calculate_int_step(background_remover_choices.background_remover_color_range)
+			)
+	register_ui_component('background_remover_model_dropdown', BACKGROUND_REMOVER_MODEL_DROPDOWN)
+	register_ui_component('background_remover_fill_color_red_number', BACKGROUND_REMOVER_FILL_COLOR_RED_NUMBER)
+	register_ui_component('background_remover_fill_color_green_number', BACKGROUND_REMOVER_FILL_COLOR_GREEN_NUMBER)
+	register_ui_component('background_remover_fill_color_blue_number', BACKGROUND_REMOVER_FILL_COLOR_BLUE_NUMBER)
+	register_ui_component('background_remover_fill_color_alpha_number', BACKGROUND_REMOVER_FILL_COLOR_ALPHA_NUMBER)
+	register_ui_component('background_remover_despill_color_red_number', BACKGROUND_REMOVER_DESPILL_COLOR_RED_NUMBER)
+	register_ui_component('background_remover_despill_color_green_number', BACKGROUND_REMOVER_DESPILL_COLOR_GREEN_NUMBER)
+	register_ui_component('background_remover_despill_color_blue_number', BACKGROUND_REMOVER_DESPILL_COLOR_BLUE_NUMBER)
+	register_ui_component('background_remover_despill_color_alpha_number', BACKGROUND_REMOVER_DESPILL_COLOR_ALPHA_NUMBER)
+
+
+def listen() -> None:
+	BACKGROUND_REMOVER_MODEL_DROPDOWN.change(update_background_remover_model, inputs = BACKGROUND_REMOVER_MODEL_DROPDOWN, outputs = BACKGROUND_REMOVER_MODEL_DROPDOWN)
+	background_remover_fill_color_inputs = [ BACKGROUND_REMOVER_FILL_COLOR_RED_NUMBER, BACKGROUND_REMOVER_FILL_COLOR_GREEN_NUMBER, BACKGROUND_REMOVER_FILL_COLOR_BLUE_NUMBER, BACKGROUND_REMOVER_FILL_COLOR_ALPHA_NUMBER ]
+	background_remover_despill_color_inputs = [ BACKGROUND_REMOVER_DESPILL_COLOR_RED_NUMBER, BACKGROUND_REMOVER_DESPILL_COLOR_GREEN_NUMBER, BACKGROUND_REMOVER_DESPILL_COLOR_BLUE_NUMBER, BACKGROUND_REMOVER_DESPILL_COLOR_ALPHA_NUMBER ]
+
+	for background_remover_fill_color_input in background_remover_fill_color_inputs:
+		background_remover_fill_color_input.change(update_background_remover_fill_color, inputs = background_remover_fill_color_inputs)
+
+	for background_remover_despill_color_input in background_remover_despill_color_inputs:
+		background_remover_despill_color_input.change(update_background_remover_despill_color, inputs = background_remover_despill_color_inputs)
+
+	processors_checkbox_group = get_ui_component('processors_checkbox_group')
+	if processors_checkbox_group:
+		processors_checkbox_group.change(remote_update, inputs = processors_checkbox_group, outputs = [ BACKGROUND_REMOVER_MODEL_DROPDOWN, BACKGROUND_REMOVER_FILL_COLOR_WRAPPER, BACKGROUND_REMOVER_DESPILL_COLOR_WRAPPER ])
+
+
+def remote_update(processors : List[str]) -> Tuple[gradio.Dropdown, gradio.Group, gradio.Group]:
+	has_background_remover = 'background_remover' in processors
+	return gradio.Dropdown(visible = has_background_remover), gradio.Group(visible = has_background_remover), gradio.Group(visible = has_background_remover)
+
+
+def update_background_remover_model(background_remover_model : BackgroundRemoverModel) -> gradio.Dropdown:
+	background_remover_module = load_processor_module('background_remover')
+	background_remover_module.clear_inference_pool()
+	state_manager.set_item('background_remover_model', background_remover_model)
+
+	if background_remover_module.pre_check():
+		return gradio.Dropdown(value = state_manager.get_item('background_remover_model'))
+	return gradio.Dropdown()
+
+
+def update_background_remover_fill_color(red : int, green : int, blue : int, alpha : int) -> None:
+	red = sanitize_int_range(red, background_remover_choices.background_remover_color_range)
+	green = sanitize_int_range(green, background_remover_choices.background_remover_color_range)
+	blue = sanitize_int_range(blue, background_remover_choices.background_remover_color_range)
+	alpha = sanitize_int_range(alpha, background_remover_choices.background_remover_color_range)
+	state_manager.set_item('background_remover_fill_color', (red, green, blue, alpha))
+
+
+def update_background_remover_despill_color(red : int, green : int, blue : int, alpha : int) -> None:
+	red = sanitize_int_range(red, background_remover_choices.background_remover_color_range)
+	green = sanitize_int_range(green, background_remover_choices.background_remover_color_range)
+	blue = sanitize_int_range(blue, background_remover_choices.background_remover_color_range)
+	alpha = sanitize_int_range(alpha, background_remover_choices.background_remover_color_range)
+	state_manager.set_item('background_remover_despill_color', (red, green, blue, alpha))

uis/components/benchmark.py

@@ -0,0 +1,51 @@
+from typing import Any, Iterator, List, Optional
+
+import gradio
+
+from facefusion import benchmarker, state_manager, translator
+
+BENCHMARK_BENCHMARKS_DATAFRAME : Optional[gradio.Dataframe] = None
+BENCHMARK_START_BUTTON : Optional[gradio.Button] = None
+
+
+def render() -> None:
+	global BENCHMARK_BENCHMARKS_DATAFRAME
+	global BENCHMARK_START_BUTTON
+
+	BENCHMARK_BENCHMARKS_DATAFRAME = gradio.Dataframe(
+		headers =
+		[
+			'target_path',
+			'cycle_count',
+			'average_run',
+			'fastest_run',
+			'slowest_run',
+			'relative_fps'
+		],
+		datatype =
+		[
+			'str',
+			'number',
+			'number',
+			'number',
+			'number',
+			'number'
+		],
+		show_label = False
+	)
+	BENCHMARK_START_BUTTON = gradio.Button(
+		value = translator.get('uis.start_button'),
+		variant = 'primary',
+		size = 'sm'
+	)
+
+
+def listen() -> None:
+	BENCHMARK_START_BUTTON.click(start, outputs = BENCHMARK_BENCHMARKS_DATAFRAME)
+
+
+def start() -> Iterator[List[Any]]:
+	state_manager.sync_state()
+
+	for benchmark in benchmarker.run():
+		yield [ list(benchmark_set.values()) for benchmark_set in benchmark ]

uis/components/benchmark_options.py

@@ -0,0 +1,54 @@
+from typing import List, Optional
+
+import gradio
+
+import facefusion.choices
+from facefusion import state_manager, translator
+from facefusion.common_helper import calculate_int_step
+from facefusion.types import BenchmarkMode, BenchmarkResolution
+
+BENCHMARK_MODE_DROPDOWN : Optional[gradio.Dropdown] = None
+BENCHMARK_RESOLUTIONS_CHECKBOX_GROUP : Optional[gradio.CheckboxGroup] = None
+BENCHMARK_CYCLE_COUNT_SLIDER : Optional[gradio.Button] = None
+
+
+def render() -> None:
+	global BENCHMARK_MODE_DROPDOWN
+	global BENCHMARK_RESOLUTIONS_CHECKBOX_GROUP
+	global BENCHMARK_CYCLE_COUNT_SLIDER
+
+	BENCHMARK_MODE_DROPDOWN = gradio.Dropdown(
+		label = translator.get('uis.benchmark_mode_dropdown'),
+		choices = facefusion.choices.benchmark_modes,
+		value = state_manager.get_item('benchmark_mode')
+	)
+	BENCHMARK_RESOLUTIONS_CHECKBOX_GROUP = gradio.CheckboxGroup(
+		label = translator.get('uis.benchmark_resolutions_checkbox_group'),
+		choices = facefusion.choices.benchmark_resolutions,
+		value = state_manager.get_item('benchmark_resolutions')
+	)
+	BENCHMARK_CYCLE_COUNT_SLIDER = gradio.Slider(
+		label = translator.get('uis.benchmark_cycle_count_slider'),
+		value = state_manager.get_item('benchmark_cycle_count'),
+		step = calculate_int_step(facefusion.choices.benchmark_cycle_count_range),
+		minimum = facefusion.choices.benchmark_cycle_count_range[0],
+		maximum = facefusion.choices.benchmark_cycle_count_range[-1]
+	)
+
+
+def listen() -> None:
+	BENCHMARK_MODE_DROPDOWN.change(update_benchmark_mode, inputs = BENCHMARK_MODE_DROPDOWN)
+	BENCHMARK_RESOLUTIONS_CHECKBOX_GROUP.change(update_benchmark_resolutions, inputs = BENCHMARK_RESOLUTIONS_CHECKBOX_GROUP)
+	BENCHMARK_CYCLE_COUNT_SLIDER.release(update_benchmark_cycle_count, inputs = BENCHMARK_CYCLE_COUNT_SLIDER)
+
+
+def update_benchmark_mode(benchmark_mode : BenchmarkMode) -> None:
+	state_manager.set_item('benchmark_mode', benchmark_mode)
+
+
+def update_benchmark_resolutions(benchmark_resolutions : List[BenchmarkResolution]) -> None:
+	state_manager.set_item('benchmark_resolutions', benchmark_resolutions)
+
+
+def update_benchmark_cycle_count(benchmark_cycle_count : int) -> None:
+	state_manager.set_item('benchmark_cycle_count', benchmark_cycle_count)

uis/components/deep_swapper_options.py

@@ -0,0 +1,64 @@
+from typing import List, Optional, Tuple
+
+import gradio
+
+from facefusion import state_manager, translator
+from facefusion.common_helper import calculate_int_step
+from facefusion.processors.core import load_processor_module
+from facefusion.processors.modules.deep_swapper import choices as deep_swapper_choices
+from facefusion.processors.modules.deep_swapper.types import DeepSwapperModel
+from facefusion.uis.core import get_ui_component, register_ui_component
+
+DEEP_SWAPPER_MODEL_DROPDOWN : Optional[gradio.Dropdown] = None
+DEEP_SWAPPER_MORPH_SLIDER : Optional[gradio.Slider] = None
+
+
+def render() -> None:
+	global DEEP_SWAPPER_MODEL_DROPDOWN
+	global DEEP_SWAPPER_MORPH_SLIDER
+
+	has_deep_swapper = 'deep_swapper' in state_manager.get_item('processors')
+	DEEP_SWAPPER_MODEL_DROPDOWN = gradio.Dropdown(
+		label = translator.get('uis.model_dropdown', 'facefusion.processors.modules.deep_swapper'),
+		choices = deep_swapper_choices.deep_swapper_models,
+		value = state_manager.get_item('deep_swapper_model'),
+		visible = has_deep_swapper
+	)
+	DEEP_SWAPPER_MORPH_SLIDER = gradio.Slider(
+		label = translator.get('uis.morph_slider', 'facefusion.processors.modules.deep_swapper'),
+		value = state_manager.get_item('deep_swapper_morph'),
+		step = calculate_int_step(deep_swapper_choices.deep_swapper_morph_range),
+		minimum = deep_swapper_choices.deep_swapper_morph_range[0],
+		maximum = deep_swapper_choices.deep_swapper_morph_range[-1],
+		visible = has_deep_swapper and load_processor_module('deep_swapper').get_inference_pool() and load_processor_module('deep_swapper').has_morph_input()
+	)
+	register_ui_component('deep_swapper_model_dropdown', DEEP_SWAPPER_MODEL_DROPDOWN)
+	register_ui_component('deep_swapper_morph_slider', DEEP_SWAPPER_MORPH_SLIDER)
+
+
+def listen() -> None:
+	DEEP_SWAPPER_MODEL_DROPDOWN.change(update_deep_swapper_model, inputs = DEEP_SWAPPER_MODEL_DROPDOWN, outputs = [ DEEP_SWAPPER_MODEL_DROPDOWN, DEEP_SWAPPER_MORPH_SLIDER ])
+	DEEP_SWAPPER_MORPH_SLIDER.release(update_deep_swapper_morph, inputs = DEEP_SWAPPER_MORPH_SLIDER)
+
+	processors_checkbox_group = get_ui_component('processors_checkbox_group')
+	if processors_checkbox_group:
+		processors_checkbox_group.change(remote_update, inputs = processors_checkbox_group, outputs = [ DEEP_SWAPPER_MODEL_DROPDOWN, DEEP_SWAPPER_MORPH_SLIDER ])
+
+
+def remote_update(processors : List[str]) -> Tuple[gradio.Dropdown, gradio.Slider]:
+	has_deep_swapper = 'deep_swapper' in processors
+	return gradio.Dropdown(visible = has_deep_swapper), gradio.Slider(visible = has_deep_swapper and load_processor_module('deep_swapper').get_inference_pool() and load_processor_module('deep_swapper').has_morph_input())
+
+
+def update_deep_swapper_model(deep_swapper_model : DeepSwapperModel) -> Tuple[gradio.Dropdown, gradio.Slider]:
+	deep_swapper_module = load_processor_module('deep_swapper')
+	deep_swapper_module.clear_inference_pool()
+	state_manager.set_item('deep_swapper_model', deep_swapper_model)
+
+	if deep_swapper_module.pre_check():
+		return gradio.Dropdown(value = state_manager.get_item('deep_swapper_model')), gradio.Slider(visible = deep_swapper_module.has_morph_input())
+	return gradio.Dropdown(), gradio.Slider()
+
+
+def update_deep_swapper_morph(deep_swapper_morph : int) -> None:
+	state_manager.set_item('deep_swapper_morph', deep_swapper_morph)

uis/components/download.py

@@ -0,0 +1,48 @@
+from typing import List, Optional
+
+import gradio
+
+import facefusion.choices
+from facefusion import content_analyser, face_classifier, face_detector, face_landmarker, face_masker, face_recognizer, state_manager, translator, voice_extractor
+from facefusion.filesystem import get_file_name, resolve_file_paths
+from facefusion.processors.core import get_processors_modules
+from facefusion.types import DownloadProvider
+
+DOWNLOAD_PROVIDERS_CHECKBOX_GROUP : Optional[gradio.CheckboxGroup] = None
+
+
+def render() -> None:
+	global DOWNLOAD_PROVIDERS_CHECKBOX_GROUP
+
+	DOWNLOAD_PROVIDERS_CHECKBOX_GROUP = gradio.CheckboxGroup(
+		label = translator.get('uis.download_providers_checkbox_group'),
+		choices = facefusion.choices.download_providers,
+		value = state_manager.get_item('download_providers')
+	)
+
+
+def listen() -> None:
+	DOWNLOAD_PROVIDERS_CHECKBOX_GROUP.change(update_download_providers, inputs = DOWNLOAD_PROVIDERS_CHECKBOX_GROUP, outputs = DOWNLOAD_PROVIDERS_CHECKBOX_GROUP)
+
+
+def update_download_providers(download_providers : List[DownloadProvider]) -> gradio.CheckboxGroup:
+	common_modules =\
+	[
+		content_analyser,
+		face_classifier,
+		face_detector,
+		face_landmarker,
+		face_recognizer,
+		face_masker,
+		voice_extractor
+	]
+	available_processors = [ get_file_name(file_path) for file_path in resolve_file_paths('facefusion/processors/modules') ]
+	processor_modules = get_processors_modules(available_processors)
+
+	for module in common_modules + processor_modules:
+		if hasattr(module, 'create_static_model_set'):
+			module.create_static_model_set.cache_clear()
+
+	download_providers = download_providers or facefusion.choices.download_providers
+	state_manager.set_item('download_providers', download_providers)
+	return gradio.CheckboxGroup(value = state_manager.get_item('download_providers'))

uis/components/execution.py

@@ -0,0 +1,48 @@
+from typing import List, Optional
+
+import gradio
+
+from facefusion import content_analyser, face_classifier, face_detector, face_landmarker, face_masker, face_recognizer, state_manager, translator, voice_extractor
+from facefusion.execution import get_available_execution_providers
+from facefusion.filesystem import get_file_name, resolve_file_paths
+from facefusion.processors.core import get_processors_modules
+from facefusion.types import ExecutionProvider
+
+EXECUTION_PROVIDERS_CHECKBOX_GROUP : Optional[gradio.CheckboxGroup] = None
+
+
+def render() -> None:
+	global EXECUTION_PROVIDERS_CHECKBOX_GROUP
+
+	EXECUTION_PROVIDERS_CHECKBOX_GROUP = gradio.CheckboxGroup(
+		label = translator.get('uis.execution_providers_checkbox_group'),
+		choices = get_available_execution_providers(),
+		value = state_manager.get_item('execution_providers')
+	)
+
+
+def listen() -> None:
+	EXECUTION_PROVIDERS_CHECKBOX_GROUP.change(update_execution_providers, inputs = EXECUTION_PROVIDERS_CHECKBOX_GROUP, outputs = EXECUTION_PROVIDERS_CHECKBOX_GROUP)
+
+
+def update_execution_providers(execution_providers : List[ExecutionProvider]) -> gradio.CheckboxGroup:
+	common_modules =\
+	[
+		content_analyser,
+		face_classifier,
+		face_detector,
+		face_landmarker,
+		face_masker,
+		face_recognizer,
+		voice_extractor
+	]
+	available_processors = [ get_file_name(file_path) for file_path in resolve_file_paths('facefusion/processors/modules') ]
+	processor_modules = get_processors_modules(available_processors)
+
+	for module in common_modules + processor_modules:
+		if hasattr(module, 'clear_inference_pool'):
+			module.clear_inference_pool()
+
+	execution_providers = execution_providers or get_available_execution_providers()
+	state_manager.set_item('execution_providers', execution_providers)
+	return gradio.CheckboxGroup(value = state_manager.get_item('execution_providers'))

uis/components/execution_thread_count.py

@@ -0,0 +1,29 @@
+from typing import Optional
+
+import gradio
+
+import facefusion.choices
+from facefusion import state_manager, translator
+from facefusion.common_helper import calculate_int_step
+
+EXECUTION_THREAD_COUNT_SLIDER : Optional[gradio.Slider] = None
+
+
+def render() -> None:
+	global EXECUTION_THREAD_COUNT_SLIDER
+
+	EXECUTION_THREAD_COUNT_SLIDER = gradio.Slider(
+		label = translator.get('uis.execution_thread_count_slider'),
+		value = state_manager.get_item('execution_thread_count'),
+		step = calculate_int_step(facefusion.choices.execution_thread_count_range),
+		minimum = facefusion.choices.execution_thread_count_range[0],
+		maximum = facefusion.choices.execution_thread_count_range[-1]
+	)
+
+
+def listen() -> None:
+	EXECUTION_THREAD_COUNT_SLIDER.release(update_execution_thread_count, inputs = EXECUTION_THREAD_COUNT_SLIDER)
+
+
+def update_execution_thread_count(execution_thread_count : float) -> None:
+	state_manager.set_item('execution_thread_count', int(execution_thread_count))

uis/components/expression_restorer_options.py

@@ -0,0 +1,80 @@
+from typing import List, Optional, Tuple
+
+import gradio
+
+from facefusion import state_manager, translator
+from facefusion.common_helper import calculate_float_step
+from facefusion.processors.core import load_processor_module
+from facefusion.processors.modules.expression_restorer import choices as expression_restorer_choices
+from facefusion.processors.modules.expression_restorer.types import ExpressionRestorerArea, ExpressionRestorerModel
+from facefusion.uis.core import get_ui_component, register_ui_component
+
+EXPRESSION_RESTORER_MODEL_DROPDOWN : Optional[gradio.Dropdown] = None
+EXPRESSION_RESTORER_FACTOR_SLIDER : Optional[gradio.Slider] = None
+EXPRESSION_RESTORER_AREAS_CHECKBOX_GROUP : Optional[gradio.CheckboxGroup] = None
+
+
+def render() -> None:
+	global EXPRESSION_RESTORER_MODEL_DROPDOWN
+	global EXPRESSION_RESTORER_FACTOR_SLIDER
+	global EXPRESSION_RESTORER_AREAS_CHECKBOX_GROUP
+
+	has_expression_restorer = 'expression_restorer' in state_manager.get_item('processors')
+	EXPRESSION_RESTORER_MODEL_DROPDOWN = gradio.Dropdown(
+		label = translator.get('uis.model_dropdown', 'facefusion.processors.modules.expression_restorer'),
+		choices = expression_restorer_choices.expression_restorer_models,
+		value = state_manager.get_item('expression_restorer_model'),
+		visible = has_expression_restorer
+	)
+	EXPRESSION_RESTORER_FACTOR_SLIDER = gradio.Slider(
+		label = translator.get('uis.factor_slider', 'facefusion.processors.modules.expression_restorer'),
+		value = state_manager.get_item('expression_restorer_factor'),
+		step = calculate_float_step(expression_restorer_choices.expression_restorer_factor_range),
+		minimum = expression_restorer_choices.expression_restorer_factor_range[0],
+		maximum = expression_restorer_choices.expression_restorer_factor_range[-1],
+		visible = has_expression_restorer
+	)
+	EXPRESSION_RESTORER_AREAS_CHECKBOX_GROUP = gradio.CheckboxGroup(
+		label = translator.get('uis.areas_checkbox_group', 'facefusion.processors.modules.expression_restorer'),
+		choices = expression_restorer_choices.expression_restorer_areas,
+		value = state_manager.get_item('expression_restorer_areas'),
+		visible = has_expression_restorer
+	)
+	register_ui_component('expression_restorer_model_dropdown', EXPRESSION_RESTORER_MODEL_DROPDOWN)
+	register_ui_component('expression_restorer_factor_slider', EXPRESSION_RESTORER_FACTOR_SLIDER)
+	register_ui_component('expression_restorer_areas_checkbox_group', EXPRESSION_RESTORER_AREAS_CHECKBOX_GROUP)
+
+
+def listen() -> None:
+	EXPRESSION_RESTORER_MODEL_DROPDOWN.change(update_expression_restorer_model, inputs = EXPRESSION_RESTORER_MODEL_DROPDOWN, outputs = EXPRESSION_RESTORER_MODEL_DROPDOWN)
+	EXPRESSION_RESTORER_FACTOR_SLIDER.release(update_expression_restorer_factor, inputs = EXPRESSION_RESTORER_FACTOR_SLIDER)
+	EXPRESSION_RESTORER_AREAS_CHECKBOX_GROUP.change(update_expression_restorer_areas, inputs = EXPRESSION_RESTORER_AREAS_CHECKBOX_GROUP, outputs = EXPRESSION_RESTORER_AREAS_CHECKBOX_GROUP)
+
+	processors_checkbox_group = get_ui_component('processors_checkbox_group')
+	if processors_checkbox_group:
+		processors_checkbox_group.change(remote_update, inputs = processors_checkbox_group, outputs = [ EXPRESSION_RESTORER_MODEL_DROPDOWN, EXPRESSION_RESTORER_FACTOR_SLIDER, EXPRESSION_RESTORER_AREAS_CHECKBOX_GROUP ])
+
+
+def remote_update(processors : List[str]) -> Tuple[gradio.Dropdown, gradio.Slider, gradio.CheckboxGroup]:
+	has_expression_restorer = 'expression_restorer' in processors
+	return gradio.Dropdown(visible = has_expression_restorer), gradio.Slider(visible = has_expression_restorer), gradio.CheckboxGroup(visible = has_expression_restorer)
+
+
+def update_expression_restorer_model(expression_restorer_model : ExpressionRestorerModel) -> gradio.Dropdown:
+	expression_restorer_module = load_processor_module('expression_restorer')
+	expression_restorer_module.clear_inference_pool()
+	state_manager.set_item('expression_restorer_model', expression_restorer_model)
+
+	if expression_restorer_module.pre_check():
+		return gradio.Dropdown(value = state_manager.get_item('expression_restorer_model'))
+	return gradio.Dropdown()
+
+
+def update_expression_restorer_factor(expression_restorer_factor : float) -> None:
+	state_manager.set_item('expression_restorer_factor', int(expression_restorer_factor))
+
+
+def update_expression_restorer_areas(expression_restorer_areas : List[ExpressionRestorerArea]) -> gradio.CheckboxGroup:
+	expression_restorer_areas = expression_restorer_areas or expression_restorer_choices.expression_restorer_areas
+	state_manager.set_item('expression_restorer_areas', expression_restorer_areas)
+	return gradio.CheckboxGroup(value = state_manager.get_item('expression_restorer_areas'))

uis/components/face_debugger_options.py

@@ -0,0 +1,40 @@
+from typing import List, Optional
+
+import gradio
+
+from facefusion import state_manager, translator
+from facefusion.processors.modules.face_debugger import choices as face_debugger_choices
+from facefusion.processors.modules.face_debugger.types import FaceDebuggerItem
+from facefusion.uis.core import get_ui_component, register_ui_component
+
+FACE_DEBUGGER_ITEMS_CHECKBOX_GROUP : Optional[gradio.CheckboxGroup] = None
+
+
+def render() -> None:
+	global FACE_DEBUGGER_ITEMS_CHECKBOX_GROUP
+
+	has_face_debugger = 'face_debugger' in state_manager.get_item('processors')
+	FACE_DEBUGGER_ITEMS_CHECKBOX_GROUP = gradio.CheckboxGroup(
+		label = translator.get('uis.items_checkbox_group', 'facefusion.processors.modules.face_debugger'),
+		choices = face_debugger_choices.face_debugger_items,
+		value = state_manager.get_item('face_debugger_items'),
+		visible = has_face_debugger
+	)
+	register_ui_component('face_debugger_items_checkbox_group', FACE_DEBUGGER_ITEMS_CHECKBOX_GROUP)
+
+
+def listen() -> None:
+	FACE_DEBUGGER_ITEMS_CHECKBOX_GROUP.change(update_face_debugger_items, inputs = FACE_DEBUGGER_ITEMS_CHECKBOX_GROUP)
+
+	processors_checkbox_group = get_ui_component('processors_checkbox_group')
+	if processors_checkbox_group:
+		processors_checkbox_group.change(remote_update, inputs = processors_checkbox_group, outputs = FACE_DEBUGGER_ITEMS_CHECKBOX_GROUP)
+
+
+def remote_update(processors : List[str]) -> gradio.CheckboxGroup:
+	has_face_debugger = 'face_debugger' in processors
+	return gradio.CheckboxGroup(visible = has_face_debugger)
+
+
+def update_face_debugger_items(face_debugger_items : List[FaceDebuggerItem]) -> None:
+	state_manager.set_item('face_debugger_items', face_debugger_items)

uis/components/face_detector.py

@@ -0,0 +1,103 @@
+from typing import Optional, Sequence, Tuple
+
+import gradio
+
+import facefusion.choices
+from facefusion import face_detector, state_manager, translator
+from facefusion.common_helper import calculate_float_step, get_last
+from facefusion.sanitizer import sanitize_int_range
+from facefusion.types import Angle, FaceDetectorModel, Score
+from facefusion.uis.core import register_ui_component
+from facefusion.uis.types import ComponentOptions
+
+FACE_DETECTOR_MODEL_DROPDOWN : Optional[gradio.Dropdown] = None
+FACE_DETECTOR_SIZE_DROPDOWN : Optional[gradio.Dropdown] = None
+FACE_DETECTOR_MARGIN_SLIDER : Optional[gradio.Slider] = None
+FACE_DETECTOR_ANGLES_CHECKBOX_GROUP : Optional[gradio.CheckboxGroup] = None
+FACE_DETECTOR_SCORE_SLIDER : Optional[gradio.Slider] = None
+
+
+def render() -> None:
+	global FACE_DETECTOR_MODEL_DROPDOWN
+	global FACE_DETECTOR_SIZE_DROPDOWN
+	global FACE_DETECTOR_MARGIN_SLIDER
+	global FACE_DETECTOR_ANGLES_CHECKBOX_GROUP
+	global FACE_DETECTOR_SCORE_SLIDER
+
+	face_detector_size_dropdown_options : ComponentOptions =\
+	{
+		'label': translator.get('uis.face_detector_size_dropdown'),
+		'value': state_manager.get_item('face_detector_size')
+	}
+	if state_manager.get_item('face_detector_size') in facefusion.choices.face_detector_set[state_manager.get_item('face_detector_model')]:
+		face_detector_size_dropdown_options['choices'] = facefusion.choices.face_detector_set[state_manager.get_item('face_detector_model')]
+	with gradio.Row():
+		FACE_DETECTOR_MODEL_DROPDOWN = gradio.Dropdown(
+			label = translator.get('uis.face_detector_model_dropdown'),
+			choices = facefusion.choices.face_detector_models,
+			value = state_manager.get_item('face_detector_model')
+		)
+		FACE_DETECTOR_SIZE_DROPDOWN = gradio.Dropdown(**face_detector_size_dropdown_options)
+	FACE_DETECTOR_MARGIN_SLIDER = gradio.Slider(
+		label = translator.get('uis.face_detector_margin_slider'),
+		value = state_manager.get_item('face_detector_margin')[0],
+		step = calculate_float_step(facefusion.choices.face_detector_margin_range),
+		minimum = facefusion.choices.face_detector_margin_range[0],
+		maximum = facefusion.choices.face_detector_margin_range[-1]
+	)
+	FACE_DETECTOR_ANGLES_CHECKBOX_GROUP = gradio.CheckboxGroup(
+		label = translator.get('uis.face_detector_angles_checkbox_group'),
+		choices = facefusion.choices.face_detector_angles,
+		value = state_manager.get_item('face_detector_angles')
+	)
+	FACE_DETECTOR_SCORE_SLIDER = gradio.Slider(
+		label = translator.get('uis.face_detector_score_slider'),
+		value = state_manager.get_item('face_detector_score'),
+		step = calculate_float_step(facefusion.choices.face_detector_score_range),
+		minimum = facefusion.choices.face_detector_score_range[0],
+		maximum = facefusion.choices.face_detector_score_range[-1]
+	)
+	register_ui_component('face_detector_model_dropdown', FACE_DETECTOR_MODEL_DROPDOWN)
+	register_ui_component('face_detector_size_dropdown', FACE_DETECTOR_SIZE_DROPDOWN)
+	register_ui_component('face_detector_margin_slider', FACE_DETECTOR_MARGIN_SLIDER)
+	register_ui_component('face_detector_angles_checkbox_group', FACE_DETECTOR_ANGLES_CHECKBOX_GROUP)
+	register_ui_component('face_detector_score_slider', FACE_DETECTOR_SCORE_SLIDER)
+
+
+def listen() -> None:
+	FACE_DETECTOR_MODEL_DROPDOWN.change(update_face_detector_model, inputs = FACE_DETECTOR_MODEL_DROPDOWN, outputs = [ FACE_DETECTOR_MODEL_DROPDOWN, FACE_DETECTOR_SIZE_DROPDOWN ])
+	FACE_DETECTOR_SIZE_DROPDOWN.change(update_face_detector_size, inputs = FACE_DETECTOR_SIZE_DROPDOWN)
+	FACE_DETECTOR_MARGIN_SLIDER.release(update_face_detector_margin, inputs=FACE_DETECTOR_MARGIN_SLIDER)
+	FACE_DETECTOR_ANGLES_CHECKBOX_GROUP.change(update_face_detector_angles, inputs = FACE_DETECTOR_ANGLES_CHECKBOX_GROUP, outputs = FACE_DETECTOR_ANGLES_CHECKBOX_GROUP)
+	FACE_DETECTOR_SCORE_SLIDER.release(update_face_detector_score, inputs = FACE_DETECTOR_SCORE_SLIDER)
+
+
+def update_face_detector_model(face_detector_model : FaceDetectorModel) -> Tuple[gradio.Dropdown, gradio.Dropdown]:
+	face_detector.clear_inference_pool()
+	state_manager.set_item('face_detector_model', face_detector_model)
+
+	if face_detector.pre_check():
+		face_detector_size_choices = facefusion.choices.face_detector_set.get(state_manager.get_item('face_detector_model'))
+		state_manager.set_item('face_detector_size', get_last(face_detector_size_choices))
+		return gradio.Dropdown(value = state_manager.get_item('face_detector_model')), gradio.Dropdown(value = state_manager.get_item('face_detector_size'), choices = face_detector_size_choices)
+	return gradio.Dropdown(), gradio.Dropdown()
+
+
+def update_face_detector_size(face_detector_size : str) -> None:
+	state_manager.set_item('face_detector_size', face_detector_size)
+
+
+def update_face_detector_margin(face_detector_margin : int) -> None:
+	face_detector_margin = sanitize_int_range(face_detector_margin, facefusion.choices.face_detector_margin_range)
+	state_manager.set_item('face_detector_margin', (face_detector_margin, face_detector_margin, face_detector_margin, face_detector_margin))
+
+
+def update_face_detector_angles(face_detector_angles : Sequence[Angle]) -> gradio.CheckboxGroup:
+	face_detector_angles = face_detector_angles or facefusion.choices.face_detector_angles
+
+	state_manager.set_item('face_detector_angles', face_detector_angles)
+	return gradio.CheckboxGroup(value = state_manager.get_item('face_detector_angles'))
+
+
+def update_face_detector_score(face_detector_score : Score) -> None:
+	state_manager.set_item('face_detector_score', face_detector_score)

uis/components/face_editor_options.py

@@ -0,0 +1,272 @@
+from typing import List, Optional, Tuple
+
+import gradio
+
+from facefusion import state_manager, translator
+from facefusion.common_helper import calculate_float_step
+from facefusion.processors.core import load_processor_module
+from facefusion.processors.modules.face_editor import choices as face_editor_choices
+from facefusion.processors.modules.face_editor.types import FaceEditorModel
+from facefusion.uis.core import get_ui_component, register_ui_component
+
+FACE_EDITOR_MODEL_DROPDOWN : Optional[gradio.Dropdown] = None
+FACE_EDITOR_EYEBROW_DIRECTION_SLIDER : Optional[gradio.Slider] = None
+FACE_EDITOR_EYE_GAZE_HORIZONTAL_SLIDER : Optional[gradio.Slider] = None
+FACE_EDITOR_EYE_GAZE_VERTICAL_SLIDER : Optional[gradio.Slider] = None
+FACE_EDITOR_EYE_OPEN_RATIO_SLIDER : Optional[gradio.Slider] = None
+FACE_EDITOR_LIP_OPEN_RATIO_SLIDER : Optional[gradio.Slider] = None
+FACE_EDITOR_MOUTH_GRIM_SLIDER : Optional[gradio.Slider] = None
+FACE_EDITOR_MOUTH_POUT_SLIDER : Optional[gradio.Slider] = None
+FACE_EDITOR_MOUTH_PURSE_SLIDER : Optional[gradio.Slider] = None
+FACE_EDITOR_MOUTH_SMILE_SLIDER : Optional[gradio.Slider] = None
+FACE_EDITOR_MOUTH_POSITION_HORIZONTAL_SLIDER : Optional[gradio.Slider] = None
+FACE_EDITOR_MOUTH_POSITION_VERTICAL_SLIDER : Optional[gradio.Slider] = None
+FACE_EDITOR_HEAD_PITCH_SLIDER : Optional[gradio.Slider] = None
+FACE_EDITOR_HEAD_YAW_SLIDER : Optional[gradio.Slider] = None
+FACE_EDITOR_HEAD_ROLL_SLIDER : Optional[gradio.Slider] = None
+
+
+def render() -> None:
+	global FACE_EDITOR_MODEL_DROPDOWN
+	global FACE_EDITOR_EYEBROW_DIRECTION_SLIDER
+	global FACE_EDITOR_EYE_GAZE_HORIZONTAL_SLIDER
+	global FACE_EDITOR_EYE_GAZE_VERTICAL_SLIDER
+	global FACE_EDITOR_EYE_OPEN_RATIO_SLIDER
+	global FACE_EDITOR_LIP_OPEN_RATIO_SLIDER
+	global FACE_EDITOR_MOUTH_GRIM_SLIDER
+	global FACE_EDITOR_MOUTH_POUT_SLIDER
+	global FACE_EDITOR_MOUTH_PURSE_SLIDER
+	global FACE_EDITOR_MOUTH_SMILE_SLIDER
+	global FACE_EDITOR_MOUTH_POSITION_HORIZONTAL_SLIDER
+	global FACE_EDITOR_MOUTH_POSITION_VERTICAL_SLIDER
+	global FACE_EDITOR_HEAD_PITCH_SLIDER
+	global FACE_EDITOR_HEAD_YAW_SLIDER
+	global FACE_EDITOR_HEAD_ROLL_SLIDER
+
+	has_face_editor = 'face_editor' in state_manager.get_item('processors')
+	FACE_EDITOR_MODEL_DROPDOWN = gradio.Dropdown(
+		label = translator.get('uis.model_dropdown', 'facefusion.processors.modules.face_editor'),
+		choices = face_editor_choices.face_editor_models,
+		value = state_manager.get_item('face_editor_model'),
+		visible = has_face_editor
+	)
+	FACE_EDITOR_EYEBROW_DIRECTION_SLIDER = gradio.Slider(
+		label = translator.get('uis.eyebrow_direction_slider', 'facefusion.processors.modules.face_editor'),
+		value = state_manager.get_item('face_editor_eyebrow_direction'),
+		step = calculate_float_step(face_editor_choices.face_editor_eyebrow_direction_range),
+		minimum = face_editor_choices.face_editor_eyebrow_direction_range[0],
+		maximum = face_editor_choices.face_editor_eyebrow_direction_range[-1],
+		visible = has_face_editor
+	)
+	FACE_EDITOR_EYE_GAZE_HORIZONTAL_SLIDER = gradio.Slider(
+		label = translator.get('uis.eye_gaze_horizontal_slider', 'facefusion.processors.modules.face_editor'),
+		value = state_manager.get_item('face_editor_eye_gaze_horizontal'),
+		step = calculate_float_step(face_editor_choices.face_editor_eye_gaze_horizontal_range),
+		minimum = face_editor_choices.face_editor_eye_gaze_horizontal_range[0],
+		maximum = face_editor_choices.face_editor_eye_gaze_horizontal_range[-1],
+		visible = has_face_editor
+	)
+	FACE_EDITOR_EYE_GAZE_VERTICAL_SLIDER = gradio.Slider(
+		label = translator.get('uis.eye_gaze_vertical_slider', 'facefusion.processors.modules.face_editor'),
+		value = state_manager.get_item('face_editor_eye_gaze_vertical'),
+		step = calculate_float_step(face_editor_choices.face_editor_eye_gaze_vertical_range),
+		minimum = face_editor_choices.face_editor_eye_gaze_vertical_range[0],
+		maximum = face_editor_choices.face_editor_eye_gaze_vertical_range[-1],
+		visible = has_face_editor
+	)
+	FACE_EDITOR_EYE_OPEN_RATIO_SLIDER = gradio.Slider(
+		label = translator.get('uis.eye_open_ratio_slider', 'facefusion.processors.modules.face_editor'),
+		value = state_manager.get_item('face_editor_eye_open_ratio'),
+		step = calculate_float_step(face_editor_choices.face_editor_eye_open_ratio_range),
+		minimum = face_editor_choices.face_editor_eye_open_ratio_range[0],
+		maximum = face_editor_choices.face_editor_eye_open_ratio_range[-1],
+		visible = has_face_editor
+	)
+	FACE_EDITOR_LIP_OPEN_RATIO_SLIDER = gradio.Slider(
+		label = translator.get('uis.lip_open_ratio_slider', 'facefusion.processors.modules.face_editor'),
+		value = state_manager.get_item('face_editor_lip_open_ratio'),
+		step = calculate_float_step(face_editor_choices.face_editor_lip_open_ratio_range),
+		minimum = face_editor_choices.face_editor_lip_open_ratio_range[0],
+		maximum = face_editor_choices.face_editor_lip_open_ratio_range[-1],
+		visible = has_face_editor
+	)
+	FACE_EDITOR_MOUTH_GRIM_SLIDER = gradio.Slider(
+		label = translator.get('uis.mouth_grim_slider', 'facefusion.processors.modules.face_editor'),
+		value = state_manager.get_item('face_editor_mouth_grim'),
+		step = calculate_float_step(face_editor_choices.face_editor_mouth_grim_range),
+		minimum = face_editor_choices.face_editor_mouth_grim_range[0],
+		maximum = face_editor_choices.face_editor_mouth_grim_range[-1],
+		visible = has_face_editor
+	)
+	FACE_EDITOR_MOUTH_POUT_SLIDER = gradio.Slider(
+		label = translator.get('uis.mouth_pout_slider', 'facefusion.processors.modules.face_editor'),
+		value = state_manager.get_item('face_editor_mouth_pout'),
+		step = calculate_float_step(face_editor_choices.face_editor_mouth_pout_range),
+		minimum = face_editor_choices.face_editor_mouth_pout_range[0],
+		maximum = face_editor_choices.face_editor_mouth_pout_range[-1],
+		visible = has_face_editor
+	)
+	FACE_EDITOR_MOUTH_PURSE_SLIDER = gradio.Slider(
+		label = translator.get('uis.mouth_purse_slider', 'facefusion.processors.modules.face_editor'),
+		value = state_manager.get_item('face_editor_mouth_purse'),
+		step = calculate_float_step(face_editor_choices.face_editor_mouth_purse_range),
+		minimum = face_editor_choices.face_editor_mouth_purse_range[0],
+		maximum = face_editor_choices.face_editor_mouth_purse_range[-1],
+		visible = has_face_editor
+	)
+	FACE_EDITOR_MOUTH_SMILE_SLIDER = gradio.Slider(
+		label = translator.get('uis.mouth_smile_slider', 'facefusion.processors.modules.face_editor'),
+		value = state_manager.get_item('face_editor_mouth_smile'),
+		step = calculate_float_step(face_editor_choices.face_editor_mouth_smile_range),
+		minimum = face_editor_choices.face_editor_mouth_smile_range[0],
+		maximum = face_editor_choices.face_editor_mouth_smile_range[-1],
+		visible = has_face_editor
+	)
+	FACE_EDITOR_MOUTH_POSITION_HORIZONTAL_SLIDER = gradio.Slider(
+		label = translator.get('uis.mouth_position_horizontal_slider', 'facefusion.processors.modules.face_editor'),
+		value = state_manager.get_item('face_editor_mouth_position_horizontal'),
+		step = calculate_float_step(face_editor_choices.face_editor_mouth_position_horizontal_range),
+		minimum = face_editor_choices.face_editor_mouth_position_horizontal_range[0],
+		maximum = face_editor_choices.face_editor_mouth_position_horizontal_range[-1],
+		visible = has_face_editor
+	)
+	FACE_EDITOR_MOUTH_POSITION_VERTICAL_SLIDER = gradio.Slider(
+		label = translator.get('uis.mouth_position_vertical_slider', 'facefusion.processors.modules.face_editor'),
+		value = state_manager.get_item('face_editor_mouth_position_vertical'),
+		step = calculate_float_step(face_editor_choices.face_editor_mouth_position_vertical_range),
+		minimum = face_editor_choices.face_editor_mouth_position_vertical_range[0],
+		maximum = face_editor_choices.face_editor_mouth_position_vertical_range[-1],
+		visible = has_face_editor
+	)
+	FACE_EDITOR_HEAD_PITCH_SLIDER = gradio.Slider(
+		label = translator.get('uis.head_pitch_slider', 'facefusion.processors.modules.face_editor'),
+		value = state_manager.get_item('face_editor_head_pitch'),
+		step = calculate_float_step(face_editor_choices.face_editor_head_pitch_range),
+		minimum = face_editor_choices.face_editor_head_pitch_range[0],
+		maximum = face_editor_choices.face_editor_head_pitch_range[-1],
+		visible = has_face_editor
+	)
+	FACE_EDITOR_HEAD_YAW_SLIDER = gradio.Slider(
+		label = translator.get('uis.head_yaw_slider', 'facefusion.processors.modules.face_editor'),
+		value = state_manager.get_item('face_editor_head_yaw'),
+		step = calculate_float_step(face_editor_choices.face_editor_head_yaw_range),
+		minimum = face_editor_choices.face_editor_head_yaw_range[0],
+		maximum = face_editor_choices.face_editor_head_yaw_range[-1],
+		visible = has_face_editor
+	)
+	FACE_EDITOR_HEAD_ROLL_SLIDER = gradio.Slider(
+		label = translator.get('uis.head_roll_slider', 'facefusion.processors.modules.face_editor'),
+		value = state_manager.get_item('face_editor_head_roll'),
+		step = calculate_float_step(face_editor_choices.face_editor_head_roll_range),
+		minimum = face_editor_choices.face_editor_head_roll_range[0],
+		maximum = face_editor_choices.face_editor_head_roll_range[-1],
+		visible = has_face_editor
+	)
+	register_ui_component('face_editor_model_dropdown', FACE_EDITOR_MODEL_DROPDOWN)
+	register_ui_component('face_editor_eyebrow_direction_slider', FACE_EDITOR_EYEBROW_DIRECTION_SLIDER)
+	register_ui_component('face_editor_eye_gaze_horizontal_slider', FACE_EDITOR_EYE_GAZE_HORIZONTAL_SLIDER)
+	register_ui_component('face_editor_eye_gaze_vertical_slider', FACE_EDITOR_EYE_GAZE_VERTICAL_SLIDER)
+	register_ui_component('face_editor_eye_open_ratio_slider', FACE_EDITOR_EYE_OPEN_RATIO_SLIDER)
+	register_ui_component('face_editor_lip_open_ratio_slider', FACE_EDITOR_LIP_OPEN_RATIO_SLIDER)
+	register_ui_component('face_editor_mouth_grim_slider', FACE_EDITOR_MOUTH_GRIM_SLIDER)
+	register_ui_component('face_editor_mouth_pout_slider', FACE_EDITOR_MOUTH_POUT_SLIDER)
+	register_ui_component('face_editor_mouth_purse_slider', FACE_EDITOR_MOUTH_PURSE_SLIDER)
+	register_ui_component('face_editor_mouth_smile_slider', FACE_EDITOR_MOUTH_SMILE_SLIDER)
+	register_ui_component('face_editor_mouth_position_horizontal_slider', FACE_EDITOR_MOUTH_POSITION_HORIZONTAL_SLIDER)
+	register_ui_component('face_editor_mouth_position_vertical_slider', FACE_EDITOR_MOUTH_POSITION_VERTICAL_SLIDER)
+	register_ui_component('face_editor_head_pitch_slider', FACE_EDITOR_HEAD_PITCH_SLIDER)
+	register_ui_component('face_editor_head_yaw_slider', FACE_EDITOR_HEAD_YAW_SLIDER)
+	register_ui_component('face_editor_head_roll_slider', FACE_EDITOR_HEAD_ROLL_SLIDER)
+
+
+def listen() -> None:
+	FACE_EDITOR_MODEL_DROPDOWN.change(update_face_editor_model, inputs = FACE_EDITOR_MODEL_DROPDOWN, outputs = FACE_EDITOR_MODEL_DROPDOWN)
+	FACE_EDITOR_EYEBROW_DIRECTION_SLIDER.release(update_face_editor_eyebrow_direction, inputs = FACE_EDITOR_EYEBROW_DIRECTION_SLIDER)
+	FACE_EDITOR_EYE_GAZE_HORIZONTAL_SLIDER.release(update_face_editor_eye_gaze_horizontal, inputs = FACE_EDITOR_EYE_GAZE_HORIZONTAL_SLIDER)
+	FACE_EDITOR_EYE_GAZE_VERTICAL_SLIDER.release(update_face_editor_eye_gaze_vertical, inputs = FACE_EDITOR_EYE_GAZE_VERTICAL_SLIDER)
+	FACE_EDITOR_EYE_OPEN_RATIO_SLIDER.release(update_face_editor_eye_open_ratio, inputs = FACE_EDITOR_EYE_OPEN_RATIO_SLIDER)
+	FACE_EDITOR_LIP_OPEN_RATIO_SLIDER.release(update_face_editor_lip_open_ratio, inputs = FACE_EDITOR_LIP_OPEN_RATIO_SLIDER)
+	FACE_EDITOR_MOUTH_GRIM_SLIDER.release(update_face_editor_mouth_grim, inputs = FACE_EDITOR_MOUTH_GRIM_SLIDER)
+	FACE_EDITOR_MOUTH_POUT_SLIDER.release(update_face_editor_mouth_pout, inputs = FACE_EDITOR_MOUTH_POUT_SLIDER)
+	FACE_EDITOR_MOUTH_PURSE_SLIDER.release(update_face_editor_mouth_purse, inputs = FACE_EDITOR_MOUTH_PURSE_SLIDER)
+	FACE_EDITOR_MOUTH_SMILE_SLIDER.release(update_face_editor_mouth_smile, inputs = FACE_EDITOR_MOUTH_SMILE_SLIDER)
+	FACE_EDITOR_MOUTH_POSITION_HORIZONTAL_SLIDER.release(update_face_editor_mouth_position_horizontal, inputs = FACE_EDITOR_MOUTH_POSITION_HORIZONTAL_SLIDER)
+	FACE_EDITOR_MOUTH_POSITION_VERTICAL_SLIDER.release(update_face_editor_mouth_position_vertical, inputs = FACE_EDITOR_MOUTH_POSITION_VERTICAL_SLIDER)
+	FACE_EDITOR_HEAD_PITCH_SLIDER.release(update_face_editor_head_pitch, inputs = FACE_EDITOR_HEAD_PITCH_SLIDER)
+	FACE_EDITOR_HEAD_YAW_SLIDER.release(update_face_editor_head_yaw, inputs = FACE_EDITOR_HEAD_YAW_SLIDER)
+	FACE_EDITOR_HEAD_ROLL_SLIDER.release(update_face_editor_head_roll, inputs = FACE_EDITOR_HEAD_ROLL_SLIDER)
+
+	processors_checkbox_group = get_ui_component('processors_checkbox_group')
+	if processors_checkbox_group:
+		processors_checkbox_group.change(remote_update, inputs = processors_checkbox_group, outputs = [ FACE_EDITOR_MODEL_DROPDOWN, FACE_EDITOR_EYEBROW_DIRECTION_SLIDER, FACE_EDITOR_EYE_GAZE_HORIZONTAL_SLIDER, FACE_EDITOR_EYE_GAZE_VERTICAL_SLIDER, FACE_EDITOR_EYE_OPEN_RATIO_SLIDER, FACE_EDITOR_LIP_OPEN_RATIO_SLIDER, FACE_EDITOR_MOUTH_GRIM_SLIDER, FACE_EDITOR_MOUTH_POUT_SLIDER, FACE_EDITOR_MOUTH_PURSE_SLIDER, FACE_EDITOR_MOUTH_SMILE_SLIDER, FACE_EDITOR_MOUTH_POSITION_HORIZONTAL_SLIDER, FACE_EDITOR_MOUTH_POSITION_VERTICAL_SLIDER, FACE_EDITOR_HEAD_PITCH_SLIDER, FACE_EDITOR_HEAD_YAW_SLIDER, FACE_EDITOR_HEAD_ROLL_SLIDER ])
+
+
+def remote_update(processors : List[str]) -> Tuple[gradio.Dropdown, gradio.Slider, gradio.Slider, gradio.Slider, gradio.Slider, gradio.Slider, gradio.Slider, gradio.Slider, gradio.Slider, gradio.Slider, gradio.Slider, gradio.Slider, gradio.Slider, gradio.Slider, gradio.Slider]:
+	has_face_editor = 'face_editor' in processors
+	return gradio.Dropdown(visible = has_face_editor), gradio.Slider(visible = has_face_editor), gradio.Slider(visible = has_face_editor), gradio.Slider(visible = has_face_editor), gradio.Slider(visible = has_face_editor), gradio.Slider(visible = has_face_editor), gradio.Slider(visible = has_face_editor), gradio.Slider(visible = has_face_editor), gradio.Slider(visible = has_face_editor), gradio.Slider(visible = has_face_editor), gradio.Slider(visible = has_face_editor), gradio.Slider(visible = has_face_editor), gradio.Slider(visible = has_face_editor), gradio.Slider(visible = has_face_editor), gradio.Slider(visible = has_face_editor)
+
+
+def update_face_editor_model(face_editor_model : FaceEditorModel) -> gradio.Dropdown:
+	face_editor_module = load_processor_module('face_editor')
+	face_editor_module.clear_inference_pool()
+	state_manager.set_item('face_editor_model', face_editor_model)
+
+	if face_editor_module.pre_check():
+		return gradio.Dropdown(value = state_manager.get_item('face_editor_model'))
+	return gradio.Dropdown()
+
+
+def update_face_editor_eyebrow_direction(face_editor_eyebrow_direction : float) -> None:
+	state_manager.set_item('face_editor_eyebrow_direction', face_editor_eyebrow_direction)
+
+
+def update_face_editor_eye_gaze_horizontal(face_editor_eye_gaze_horizontal : float) -> None:
+	state_manager.set_item('face_editor_eye_gaze_horizontal', face_editor_eye_gaze_horizontal)
+
+
+def update_face_editor_eye_gaze_vertical(face_editor_eye_gaze_vertical : float) -> None:
+	state_manager.set_item('face_editor_eye_gaze_vertical', face_editor_eye_gaze_vertical)
+
+
+def update_face_editor_eye_open_ratio(face_editor_eye_open_ratio : float) -> None:
+	state_manager.set_item('face_editor_eye_open_ratio', face_editor_eye_open_ratio)
+
+
+def update_face_editor_lip_open_ratio(face_editor_lip_open_ratio : float) -> None:
+	state_manager.set_item('face_editor_lip_open_ratio', face_editor_lip_open_ratio)
+
+
+def update_face_editor_mouth_grim(face_editor_mouth_grim : float) -> None:
+	state_manager.set_item('face_editor_mouth_grim', face_editor_mouth_grim)
+
+
+def update_face_editor_mouth_pout(face_editor_mouth_pout : float) -> None:
+	state_manager.set_item('face_editor_mouth_pout', face_editor_mouth_pout)
+
+
+def update_face_editor_mouth_purse(face_editor_mouth_purse : float) -> None:
+	state_manager.set_item('face_editor_mouth_purse', face_editor_mouth_purse)
+
+
+def update_face_editor_mouth_smile(face_editor_mouth_smile : float) -> None:
+	state_manager.set_item('face_editor_mouth_smile', face_editor_mouth_smile)
+
+
+def update_face_editor_mouth_position_horizontal(face_editor_mouth_position_horizontal : float) -> None:
+	state_manager.set_item('face_editor_mouth_position_horizontal', face_editor_mouth_position_horizontal)
+
+
+def update_face_editor_mouth_position_vertical(face_editor_mouth_position_vertical : float) -> None:
+	state_manager.set_item('face_editor_mouth_position_vertical', face_editor_mouth_position_vertical)
+
+
+def update_face_editor_head_pitch(face_editor_head_pitch : float) -> None:
+	state_manager.set_item('face_editor_head_pitch', face_editor_head_pitch)
+
+
+def update_face_editor_head_yaw(face_editor_head_yaw : float) -> None:
+	state_manager.set_item('face_editor_head_yaw', face_editor_head_yaw)
+
+
+def update_face_editor_head_roll(face_editor_head_roll : float) -> None:
+	state_manager.set_item('face_editor_head_roll', face_editor_head_roll)

uis/components/face_enhancer_options.py

@@ -0,0 +1,81 @@
+from typing import List, Optional, Tuple
+
+import gradio
+
+from facefusion import state_manager, translator
+from facefusion.common_helper import calculate_float_step, calculate_int_step
+from facefusion.processors.core import load_processor_module
+from facefusion.processors.modules.face_enhancer import choices as face_enhancer_choices
+from facefusion.processors.modules.face_enhancer.types import FaceEnhancerModel, FaceEnhancerWeight
+from facefusion.uis.core import get_ui_component, register_ui_component
+
+FACE_ENHANCER_MODEL_DROPDOWN : Optional[gradio.Dropdown] = None
+FACE_ENHANCER_BLEND_SLIDER : Optional[gradio.Slider] = None
+FACE_ENHANCER_WEIGHT_SLIDER : Optional[gradio.Slider] = None
+
+
+def render() -> None:
+	global FACE_ENHANCER_MODEL_DROPDOWN
+	global FACE_ENHANCER_BLEND_SLIDER
+	global FACE_ENHANCER_WEIGHT_SLIDER
+
+	has_face_enhancer = 'face_enhancer' in state_manager.get_item('processors')
+	FACE_ENHANCER_MODEL_DROPDOWN = gradio.Dropdown(
+		label = translator.get('uis.model_dropdown', 'facefusion.processors.modules.face_enhancer'),
+		choices = face_enhancer_choices.face_enhancer_models,
+		value = state_manager.get_item('face_enhancer_model'),
+		visible = has_face_enhancer
+	)
+	FACE_ENHANCER_BLEND_SLIDER = gradio.Slider(
+		label = translator.get('uis.blend_slider', 'facefusion.processors.modules.face_enhancer'),
+		value = state_manager.get_item('face_enhancer_blend'),
+		step = calculate_int_step(face_enhancer_choices.face_enhancer_blend_range),
+		minimum = face_enhancer_choices.face_enhancer_blend_range[0],
+		maximum = face_enhancer_choices.face_enhancer_blend_range[-1],
+		visible = has_face_enhancer
+	)
+	FACE_ENHANCER_WEIGHT_SLIDER = gradio.Slider(
+		label = translator.get('uis.weight_slider', 'facefusion.processors.modules.face_enhancer'),
+		value = state_manager.get_item('face_enhancer_weight'),
+		step = calculate_float_step(face_enhancer_choices.face_enhancer_weight_range),
+		minimum = face_enhancer_choices.face_enhancer_weight_range[0],
+		maximum = face_enhancer_choices.face_enhancer_weight_range[-1],
+		visible = has_face_enhancer and load_processor_module('face_enhancer').get_inference_pool() and load_processor_module('face_enhancer').has_weight_input()
+	)
+	register_ui_component('face_enhancer_model_dropdown', FACE_ENHANCER_MODEL_DROPDOWN)
+	register_ui_component('face_enhancer_blend_slider', FACE_ENHANCER_BLEND_SLIDER)
+	register_ui_component('face_enhancer_weight_slider', FACE_ENHANCER_WEIGHT_SLIDER)
+
+
+def listen() -> None:
+	FACE_ENHANCER_MODEL_DROPDOWN.change(update_face_enhancer_model, inputs = FACE_ENHANCER_MODEL_DROPDOWN, outputs = [ FACE_ENHANCER_MODEL_DROPDOWN, FACE_ENHANCER_WEIGHT_SLIDER ])
+	FACE_ENHANCER_BLEND_SLIDER.release(update_face_enhancer_blend, inputs = FACE_ENHANCER_BLEND_SLIDER)
+	FACE_ENHANCER_WEIGHT_SLIDER.release(update_face_enhancer_weight, inputs = FACE_ENHANCER_WEIGHT_SLIDER)
+
+	processors_checkbox_group = get_ui_component('processors_checkbox_group')
+	if processors_checkbox_group:
+		processors_checkbox_group.change(remote_update, inputs = processors_checkbox_group, outputs = [ FACE_ENHANCER_MODEL_DROPDOWN, FACE_ENHANCER_BLEND_SLIDER, FACE_ENHANCER_WEIGHT_SLIDER ])
+
+
+def remote_update(processors : List[str]) -> Tuple[gradio.Dropdown, gradio.Slider, gradio.Slider]:
+	has_face_enhancer = 'face_enhancer' in processors
+	return gradio.Dropdown(visible = has_face_enhancer), gradio.Slider(visible = has_face_enhancer), gradio.Slider(visible = has_face_enhancer and load_processor_module('face_enhancer').get_inference_pool() and load_processor_module('face_enhancer').has_weight_input())
+
+
+def update_face_enhancer_model(face_enhancer_model : FaceEnhancerModel) -> Tuple[gradio.Dropdown, gradio.Slider]:
+	face_enhancer_module = load_processor_module('face_enhancer')
+	face_enhancer_module.clear_inference_pool()
+	state_manager.set_item('face_enhancer_model', face_enhancer_model)
+
+	if face_enhancer_module.pre_check():
+		return gradio.Dropdown(value = state_manager.get_item('face_enhancer_model')), gradio.Slider(visible = face_enhancer_module.has_weight_input())
+	return gradio.Dropdown(), gradio.Slider()
+
+
+def update_face_enhancer_blend(face_enhancer_blend : float) -> None:
+	state_manager.set_item('face_enhancer_blend', int(face_enhancer_blend))
+
+
+def update_face_enhancer_weight(face_enhancer_weight : FaceEnhancerWeight) -> None:
+	state_manager.set_item('face_enhancer_weight', face_enhancer_weight)
+

uis/components/face_landmarker.py

@@ -0,0 +1,50 @@
+from typing import Optional
+
+import gradio
+
+import facefusion.choices
+from facefusion import face_landmarker, state_manager, translator
+from facefusion.common_helper import calculate_float_step
+from facefusion.types import FaceLandmarkerModel, Score
+from facefusion.uis.core import register_ui_component
+
+FACE_LANDMARKER_MODEL_DROPDOWN : Optional[gradio.Dropdown] = None
+FACE_LANDMARKER_SCORE_SLIDER : Optional[gradio.Slider] = None
+
+
+def render() -> None:
+	global FACE_LANDMARKER_MODEL_DROPDOWN
+	global FACE_LANDMARKER_SCORE_SLIDER
+
+	FACE_LANDMARKER_MODEL_DROPDOWN = gradio.Dropdown(
+		label = translator.get('uis.face_landmarker_model_dropdown'),
+		choices = facefusion.choices.face_landmarker_models,
+		value = state_manager.get_item('face_landmarker_model')
+	)
+	FACE_LANDMARKER_SCORE_SLIDER = gradio.Slider(
+		label = translator.get('uis.face_landmarker_score_slider'),
+		value = state_manager.get_item('face_landmarker_score'),
+		step = calculate_float_step(facefusion.choices.face_landmarker_score_range),
+		minimum = facefusion.choices.face_landmarker_score_range[0],
+		maximum = facefusion.choices.face_landmarker_score_range[-1]
+	)
+	register_ui_component('face_landmarker_model_dropdown', FACE_LANDMARKER_MODEL_DROPDOWN)
+	register_ui_component('face_landmarker_score_slider', FACE_LANDMARKER_SCORE_SLIDER)
+
+
+def listen() -> None:
+	FACE_LANDMARKER_MODEL_DROPDOWN.change(update_face_landmarker_model, inputs = FACE_LANDMARKER_MODEL_DROPDOWN, outputs = FACE_LANDMARKER_MODEL_DROPDOWN)
+	FACE_LANDMARKER_SCORE_SLIDER.release(update_face_landmarker_score, inputs = FACE_LANDMARKER_SCORE_SLIDER)
+
+
+def update_face_landmarker_model(face_landmarker_model : FaceLandmarkerModel) -> gradio.Dropdown:
+	face_landmarker.clear_inference_pool()
+	state_manager.set_item('face_landmarker_model', face_landmarker_model)
+
+	if face_landmarker.pre_check():
+		gradio.Dropdown(value = state_manager.get_item('face_landmarker_model'))
+	return gradio.Dropdown()
+
+
+def update_face_landmarker_score(face_landmarker_score : Score) -> None:
+	state_manager.set_item('face_landmarker_score', face_landmarker_score)

uis/components/face_masker.py

@@ -0,0 +1,181 @@
+from typing import List, Optional, Tuple
+
+import gradio
+
+import facefusion.choices
+from facefusion import face_masker, state_manager, translator
+from facefusion.common_helper import calculate_float_step, calculate_int_step
+from facefusion.sanitizer import sanitize_int_range
+from facefusion.types import FaceMaskArea, FaceMaskRegion, FaceMaskType, FaceOccluderModel, FaceParserModel
+from facefusion.uis.core import register_ui_component
+
+FACE_OCCLUDER_MODEL_DROPDOWN : Optional[gradio.Dropdown] = None
+FACE_PARSER_MODEL_DROPDOWN : Optional[gradio.Dropdown] = None
+FACE_MASK_TYPES_CHECKBOX_GROUP : Optional[gradio.CheckboxGroup] = None
+FACE_MASK_AREAS_CHECKBOX_GROUP : Optional[gradio.CheckboxGroup] = None
+FACE_MASK_REGIONS_CHECKBOX_GROUP : Optional[gradio.CheckboxGroup] = None
+FACE_MASK_BOX_WRAPPER : Optional[gradio.Group] = None
+FACE_MASK_BLUR_SLIDER : Optional[gradio.Slider] = None
+FACE_MASK_PADDING_TOP_SLIDER : Optional[gradio.Slider] = None
+FACE_MASK_PADDING_RIGHT_SLIDER : Optional[gradio.Slider] = None
+FACE_MASK_PADDING_BOTTOM_SLIDER : Optional[gradio.Slider] = None
+FACE_MASK_PADDING_LEFT_SLIDER : Optional[gradio.Slider] = None
+
+
+def render() -> None:
+	global FACE_OCCLUDER_MODEL_DROPDOWN
+	global FACE_PARSER_MODEL_DROPDOWN
+	global FACE_MASK_TYPES_CHECKBOX_GROUP
+	global FACE_MASK_AREAS_CHECKBOX_GROUP
+	global FACE_MASK_REGIONS_CHECKBOX_GROUP
+	global FACE_MASK_BOX_WRAPPER
+	global FACE_MASK_BLUR_SLIDER
+	global FACE_MASK_PADDING_TOP_SLIDER
+	global FACE_MASK_PADDING_RIGHT_SLIDER
+	global FACE_MASK_PADDING_BOTTOM_SLIDER
+	global FACE_MASK_PADDING_LEFT_SLIDER
+
+	has_box_mask = 'box' in state_manager.get_item('face_mask_types')
+	has_region_mask = 'region' in state_manager.get_item('face_mask_types')
+	has_area_mask = 'area' in state_manager.get_item('face_mask_types')
+	with gradio.Row():
+		FACE_OCCLUDER_MODEL_DROPDOWN = gradio.Dropdown(
+			label = translator.get('uis.face_occluder_model_dropdown'),
+			choices = facefusion.choices.face_occluder_models,
+			value = state_manager.get_item('face_occluder_model')
+		)
+		FACE_PARSER_MODEL_DROPDOWN = gradio.Dropdown(
+			label = translator.get('uis.face_parser_model_dropdown'),
+			choices = facefusion.choices.face_parser_models,
+			value = state_manager.get_item('face_parser_model')
+		)
+	FACE_MASK_TYPES_CHECKBOX_GROUP = gradio.CheckboxGroup(
+		label = translator.get('uis.face_mask_types_checkbox_group'),
+		choices = facefusion.choices.face_mask_types,
+		value = state_manager.get_item('face_mask_types')
+	)
+	FACE_MASK_AREAS_CHECKBOX_GROUP = gradio.CheckboxGroup(
+		label = translator.get('uis.face_mask_areas_checkbox_group'),
+		choices = facefusion.choices.face_mask_areas,
+		value = state_manager.get_item('face_mask_areas'),
+		visible = has_area_mask
+	)
+	FACE_MASK_REGIONS_CHECKBOX_GROUP = gradio.CheckboxGroup(
+		label = translator.get('uis.face_mask_regions_checkbox_group'),
+		choices = facefusion.choices.face_mask_regions,
+		value = state_manager.get_item('face_mask_regions'),
+		visible = has_region_mask
+	)
+	FACE_MASK_BLUR_SLIDER = gradio.Slider(
+		label = translator.get('uis.face_mask_blur_slider'),
+		step = calculate_float_step(facefusion.choices.face_mask_blur_range),
+		minimum = facefusion.choices.face_mask_blur_range[0],
+		maximum = facefusion.choices.face_mask_blur_range[-1],
+		value = state_manager.get_item('face_mask_blur'),
+		visible = has_box_mask
+	)
+	with gradio.Group(visible = has_box_mask) as FACE_MASK_BOX_WRAPPER:
+		with gradio.Row():
+			FACE_MASK_PADDING_TOP_SLIDER = gradio.Slider(
+				label = translator.get('uis.face_mask_padding_top_slider'),
+				step = calculate_int_step(facefusion.choices.face_mask_padding_range),
+				minimum = facefusion.choices.face_mask_padding_range[0],
+				maximum = facefusion.choices.face_mask_padding_range[-1],
+				value = state_manager.get_item('face_mask_padding')[0]
+			)
+			FACE_MASK_PADDING_RIGHT_SLIDER = gradio.Slider(
+				label = translator.get('uis.face_mask_padding_right_slider'),
+				step = calculate_int_step(facefusion.choices.face_mask_padding_range),
+				minimum = facefusion.choices.face_mask_padding_range[0],
+				maximum = facefusion.choices.face_mask_padding_range[-1],
+				value = state_manager.get_item('face_mask_padding')[1]
+			)
+		with gradio.Row():
+			FACE_MASK_PADDING_BOTTOM_SLIDER = gradio.Slider(
+				label = translator.get('uis.face_mask_padding_bottom_slider'),
+				step = calculate_int_step(facefusion.choices.face_mask_padding_range),
+				minimum = facefusion.choices.face_mask_padding_range[0],
+				maximum = facefusion.choices.face_mask_padding_range[-1],
+				value = state_manager.get_item('face_mask_padding')[2]
+			)
+			FACE_MASK_PADDING_LEFT_SLIDER = gradio.Slider(
+				label = translator.get('uis.face_mask_padding_left_slider'),
+				step = calculate_int_step(facefusion.choices.face_mask_padding_range),
+				minimum = facefusion.choices.face_mask_padding_range[0],
+				maximum = facefusion.choices.face_mask_padding_range[-1],
+				value = state_manager.get_item('face_mask_padding')[3]
+			)
+	register_ui_component('face_occluder_model_dropdown', FACE_OCCLUDER_MODEL_DROPDOWN)
+	register_ui_component('face_parser_model_dropdown', FACE_PARSER_MODEL_DROPDOWN)
+	register_ui_component('face_mask_types_checkbox_group', FACE_MASK_TYPES_CHECKBOX_GROUP)
+	register_ui_component('face_mask_areas_checkbox_group', FACE_MASK_AREAS_CHECKBOX_GROUP)
+	register_ui_component('face_mask_regions_checkbox_group', FACE_MASK_REGIONS_CHECKBOX_GROUP)
+	register_ui_component('face_mask_blur_slider', FACE_MASK_BLUR_SLIDER)
+	register_ui_component('face_mask_padding_top_slider', FACE_MASK_PADDING_TOP_SLIDER)
+	register_ui_component('face_mask_padding_right_slider', FACE_MASK_PADDING_RIGHT_SLIDER)
+	register_ui_component('face_mask_padding_bottom_slider', FACE_MASK_PADDING_BOTTOM_SLIDER)
+	register_ui_component('face_mask_padding_left_slider', FACE_MASK_PADDING_LEFT_SLIDER)
+
+
+def listen() -> None:
+	FACE_OCCLUDER_MODEL_DROPDOWN.change(update_face_occluder_model, inputs = FACE_OCCLUDER_MODEL_DROPDOWN)
+	FACE_PARSER_MODEL_DROPDOWN.change(update_face_parser_model, inputs = FACE_PARSER_MODEL_DROPDOWN)
+	FACE_MASK_TYPES_CHECKBOX_GROUP.change(update_face_mask_types, inputs = FACE_MASK_TYPES_CHECKBOX_GROUP, outputs = [ FACE_MASK_TYPES_CHECKBOX_GROUP, FACE_MASK_AREAS_CHECKBOX_GROUP, FACE_MASK_REGIONS_CHECKBOX_GROUP, FACE_MASK_BLUR_SLIDER, FACE_MASK_BOX_WRAPPER ])
+	FACE_MASK_AREAS_CHECKBOX_GROUP.change(update_face_mask_areas, inputs = FACE_MASK_AREAS_CHECKBOX_GROUP, outputs = FACE_MASK_AREAS_CHECKBOX_GROUP)
+	FACE_MASK_REGIONS_CHECKBOX_GROUP.change(update_face_mask_regions, inputs = FACE_MASK_REGIONS_CHECKBOX_GROUP, outputs = FACE_MASK_REGIONS_CHECKBOX_GROUP)
+	FACE_MASK_BLUR_SLIDER.release(update_face_mask_blur, inputs = FACE_MASK_BLUR_SLIDER)
+
+	face_mask_padding_sliders = [ FACE_MASK_PADDING_TOP_SLIDER, FACE_MASK_PADDING_RIGHT_SLIDER, FACE_MASK_PADDING_BOTTOM_SLIDER, FACE_MASK_PADDING_LEFT_SLIDER ]
+	for face_mask_padding_slider in face_mask_padding_sliders:
+		face_mask_padding_slider.release(update_face_mask_padding, inputs = face_mask_padding_sliders)
+
+
+def update_face_occluder_model(face_occluder_model : FaceOccluderModel) -> gradio.Dropdown:
+	face_masker.clear_inference_pool()
+	state_manager.set_item('face_occluder_model', face_occluder_model)
+
+	if face_masker.pre_check():
+		return gradio.Dropdown(value = state_manager.get_item('face_occluder_model'))
+	return gradio.Dropdown()
+
+
+def update_face_parser_model(face_parser_model : FaceParserModel) -> gradio.Dropdown:
+	face_masker.clear_inference_pool()
+	state_manager.set_item('face_parser_model', face_parser_model)
+
+	if face_masker.pre_check():
+		return gradio.Dropdown(value = state_manager.get_item('face_parser_model'))
+	return gradio.Dropdown()
+
+
+def update_face_mask_types(face_mask_types : List[FaceMaskType]) -> Tuple[gradio.CheckboxGroup, gradio.CheckboxGroup, gradio.CheckboxGroup, gradio.Slider, gradio.Group]:
+	face_mask_types = face_mask_types or facefusion.choices.face_mask_types
+	state_manager.set_item('face_mask_types', face_mask_types)
+	has_box_mask = 'box' in face_mask_types
+	has_area_mask = 'area' in face_mask_types
+	has_region_mask = 'region' in face_mask_types
+	return gradio.CheckboxGroup(value = state_manager.get_item('face_mask_types')), gradio.CheckboxGroup(visible = has_area_mask), gradio.CheckboxGroup(visible = has_region_mask), gradio.Slider(visible = has_box_mask), gradio.Group(visible = has_box_mask)
+
+
+def update_face_mask_areas(face_mask_areas : List[FaceMaskArea]) -> gradio.CheckboxGroup:
+	face_mask_areas = face_mask_areas or facefusion.choices.face_mask_areas
+	state_manager.set_item('face_mask_areas', face_mask_areas)
+	return gradio.CheckboxGroup(value = state_manager.get_item('face_mask_areas'))
+
+
+def update_face_mask_regions(face_mask_regions : List[FaceMaskRegion]) -> gradio.CheckboxGroup:
+	face_mask_regions = face_mask_regions or facefusion.choices.face_mask_regions
+	state_manager.set_item('face_mask_regions', face_mask_regions)
+	return gradio.CheckboxGroup(value = state_manager.get_item('face_mask_regions'))
+
+
+def update_face_mask_blur(face_mask_blur : float) -> None:
+	state_manager.set_item('face_mask_blur', face_mask_blur)
+
+
+def update_face_mask_padding(face_mask_padding_top : float, face_mask_padding_right : float, face_mask_padding_bottom : float, face_mask_padding_left : float) -> None:
+	face_mask_padding_top = sanitize_int_range(int(face_mask_padding_top), facefusion.choices.face_mask_padding_range)
+	face_mask_padding_right = sanitize_int_range(int(face_mask_padding_right), facefusion.choices.face_mask_padding_range)
+	face_mask_padding_bottom = sanitize_int_range(int(face_mask_padding_bottom), facefusion.choices.face_mask_padding_range)
+	face_mask_padding_left = sanitize_int_range(int(face_mask_padding_left), facefusion.choices.face_mask_padding_range)
+	state_manager.set_item('face_mask_padding', (face_mask_padding_top, face_mask_padding_right, face_mask_padding_bottom, face_mask_padding_left))

uis/components/face_selector.py

@@ -0,0 +1,236 @@
+from typing import List, Optional, Tuple
+
+import cv2
+import gradio
+from gradio_rangeslider import RangeSlider
+
+import facefusion.choices
+from facefusion import state_manager, translator
+from facefusion.common_helper import calculate_float_step, calculate_int_step
+from facefusion.face_creator import get_many_faces
+from facefusion.face_selector import sort_and_filter_faces
+from facefusion.face_store import clear_faces
+from facefusion.filesystem import filter_image_paths, is_image, is_video
+from facefusion.types import FaceSelectorGender, FaceSelectorMode, FaceSelectorOrder, FaceSelectorRace, VisionFrame
+from facefusion.uis.core import get_ui_component, get_ui_components, register_ui_component
+from facefusion.uis.types import ComponentOptions
+from facefusion.uis.ui_helper import convert_str_none
+from facefusion.vision import fit_cover_frame, read_static_image, read_static_images, read_video_frame
+
+FACE_SELECTOR_MODE_DROPDOWN : Optional[gradio.Dropdown] = None
+FACE_SELECTOR_ORDER_DROPDOWN : Optional[gradio.Dropdown] = None
+FACE_SELECTOR_GENDER_DROPDOWN : Optional[gradio.Dropdown] = None
+FACE_SELECTOR_RACE_DROPDOWN : Optional[gradio.Dropdown] = None
+FACE_SELECTOR_AGE_RANGE_SLIDER : Optional[RangeSlider] = None
+REFERENCE_FACE_POSITION_GALLERY : Optional[gradio.Gallery] = None
+REFERENCE_FACE_DISTANCE_SLIDER : Optional[gradio.Slider] = None
+
+
+def render() -> None:
+	global FACE_SELECTOR_MODE_DROPDOWN
+	global FACE_SELECTOR_ORDER_DROPDOWN
+	global FACE_SELECTOR_GENDER_DROPDOWN
+	global FACE_SELECTOR_RACE_DROPDOWN
+	global FACE_SELECTOR_AGE_RANGE_SLIDER
+	global REFERENCE_FACE_POSITION_GALLERY
+	global REFERENCE_FACE_DISTANCE_SLIDER
+
+	reference_face_gallery_options : ComponentOptions =\
+	{
+		'label': translator.get('uis.reference_face_gallery'),
+		'object_fit': 'cover',
+		'allow_preview': False,
+		'elem_classes': 'box-face-selector',
+		'visible': 'reference' in state_manager.get_item('face_selector_mode')
+	}
+	source_vision_frames = read_static_images(filter_image_paths(state_manager.get_item('source_paths')))
+
+	if is_image(state_manager.get_item('target_path')):
+		target_vision_frame = read_static_image(state_manager.get_item('target_path'))
+		reference_face_gallery_options['value'] = extract_gallery_frames(source_vision_frames, target_vision_frame)
+	if is_video(state_manager.get_item('target_path')):
+		target_vision_frame = read_video_frame(state_manager.get_item('target_path'), state_manager.get_item('reference_frame_number'))
+		reference_face_gallery_options['value'] = extract_gallery_frames(source_vision_frames, target_vision_frame)
+	FACE_SELECTOR_MODE_DROPDOWN = gradio.Dropdown(
+		label = translator.get('uis.face_selector_mode_dropdown'),
+		choices = facefusion.choices.face_selector_modes,
+		value = state_manager.get_item('face_selector_mode')
+	)
+	REFERENCE_FACE_POSITION_GALLERY = gradio.Gallery(**reference_face_gallery_options)
+	with gradio.Group():
+		with gradio.Row():
+			FACE_SELECTOR_ORDER_DROPDOWN = gradio.Dropdown(
+				label = translator.get('uis.face_selector_order_dropdown'),
+				choices = facefusion.choices.face_selector_orders,
+				value = state_manager.get_item('face_selector_order')
+			)
+			FACE_SELECTOR_GENDER_DROPDOWN = gradio.Dropdown(
+				label = translator.get('uis.face_selector_gender_dropdown'),
+				choices = [ 'none' ] + facefusion.choices.face_selector_genders,
+				value = state_manager.get_item('face_selector_gender') or 'none'
+			)
+			FACE_SELECTOR_RACE_DROPDOWN = gradio.Dropdown(
+				label = translator.get('uis.face_selector_race_dropdown'),
+				choices = [ 'none' ] + facefusion.choices.face_selector_races,
+				value = state_manager.get_item('face_selector_race') or 'none'
+			)
+		with gradio.Row():
+			face_selector_age_start = state_manager.get_item('face_selector_age_start') or facefusion.choices.face_selector_age_range[0]
+			face_selector_age_end = state_manager.get_item('face_selector_age_end') or facefusion.choices.face_selector_age_range[-1]
+			FACE_SELECTOR_AGE_RANGE_SLIDER = RangeSlider(
+				label = translator.get('uis.face_selector_age_range_slider'),
+				minimum = facefusion.choices.face_selector_age_range[0],
+				maximum = facefusion.choices.face_selector_age_range[-1],
+				value = (face_selector_age_start, face_selector_age_end),
+				step = calculate_int_step(facefusion.choices.face_selector_age_range)
+			)
+	REFERENCE_FACE_DISTANCE_SLIDER = gradio.Slider(
+		label = translator.get('uis.reference_face_distance_slider'),
+		value = state_manager.get_item('reference_face_distance'),
+		step = calculate_float_step(facefusion.choices.reference_face_distance_range),
+		minimum = facefusion.choices.reference_face_distance_range[0],
+		maximum = facefusion.choices.reference_face_distance_range[-1],
+		visible = 'reference' in state_manager.get_item('face_selector_mode')
+	)
+	register_ui_component('face_selector_mode_dropdown', FACE_SELECTOR_MODE_DROPDOWN)
+	register_ui_component('face_selector_order_dropdown', FACE_SELECTOR_ORDER_DROPDOWN)
+	register_ui_component('face_selector_gender_dropdown', FACE_SELECTOR_GENDER_DROPDOWN)
+	register_ui_component('face_selector_race_dropdown', FACE_SELECTOR_RACE_DROPDOWN)
+	register_ui_component('face_selector_age_range_slider', FACE_SELECTOR_AGE_RANGE_SLIDER)
+	register_ui_component('reference_face_position_gallery', REFERENCE_FACE_POSITION_GALLERY)
+	register_ui_component('reference_face_distance_slider', REFERENCE_FACE_DISTANCE_SLIDER)
+
+
+def listen() -> None:
+	FACE_SELECTOR_MODE_DROPDOWN.change(update_face_selector_mode, inputs = FACE_SELECTOR_MODE_DROPDOWN, outputs = [ REFERENCE_FACE_POSITION_GALLERY, REFERENCE_FACE_DISTANCE_SLIDER ])
+	FACE_SELECTOR_ORDER_DROPDOWN.change(update_face_selector_order, inputs = FACE_SELECTOR_ORDER_DROPDOWN, outputs = REFERENCE_FACE_POSITION_GALLERY)
+	FACE_SELECTOR_GENDER_DROPDOWN.change(update_face_selector_gender, inputs = FACE_SELECTOR_GENDER_DROPDOWN, outputs = REFERENCE_FACE_POSITION_GALLERY)
+	FACE_SELECTOR_RACE_DROPDOWN.change(update_face_selector_race, inputs = FACE_SELECTOR_RACE_DROPDOWN, outputs = REFERENCE_FACE_POSITION_GALLERY)
+	FACE_SELECTOR_AGE_RANGE_SLIDER.release(update_face_selector_age_range, inputs = FACE_SELECTOR_AGE_RANGE_SLIDER, outputs = REFERENCE_FACE_POSITION_GALLERY)
+	REFERENCE_FACE_DISTANCE_SLIDER.release(update_reference_face_distance, inputs = REFERENCE_FACE_DISTANCE_SLIDER)
+
+	preview_frame_slider = get_ui_component('preview_frame_slider')
+	if preview_frame_slider:
+		REFERENCE_FACE_POSITION_GALLERY.select(update_reference_frame_number, inputs = preview_frame_slider)
+		REFERENCE_FACE_POSITION_GALLERY.select(update_reference_face_position)
+
+	for ui_component in get_ui_components(
+	[
+		'target_image',
+		'target_video'
+	]):
+		for method in [ 'change', 'clear' ]:
+			getattr(ui_component, method)(clear_reference_frame_number)
+			getattr(ui_component, method)(clear_reference_face_position)
+			getattr(ui_component, method)(update_reference_position_gallery, outputs = REFERENCE_FACE_POSITION_GALLERY)
+
+	for ui_component in get_ui_components(
+	[
+		'face_detector_model_dropdown',
+		'face_detector_size_dropdown',
+		'face_detector_angles_checkbox_group'
+	]):
+		ui_component.change(clear_and_update_reference_position_gallery, outputs = REFERENCE_FACE_POSITION_GALLERY)
+
+	face_detector_score_slider = get_ui_component('face_detector_score_slider')
+	if face_detector_score_slider:
+		face_detector_score_slider.release(update_reference_position_gallery, outputs = REFERENCE_FACE_POSITION_GALLERY)
+
+	preview_frame_slider = get_ui_component('preview_frame_slider')
+	if preview_frame_slider:
+		for method in [ 'change', 'release' ]:
+			getattr(preview_frame_slider, method)(update_reference_position_gallery, inputs = preview_frame_slider, outputs = REFERENCE_FACE_POSITION_GALLERY, show_progress = 'hidden')
+
+
+def update_face_selector_mode(face_selector_mode : FaceSelectorMode) -> Tuple[gradio.Gallery, gradio.Slider]:
+	state_manager.set_item('face_selector_mode', face_selector_mode)
+	if face_selector_mode == 'many':
+		return gradio.Gallery(visible = False), gradio.Slider(visible = False)
+	if face_selector_mode == 'one':
+		return gradio.Gallery(visible = False), gradio.Slider(visible = False)
+	if face_selector_mode == 'reference':
+		return gradio.Gallery(visible = True), gradio.Slider(visible = True)
+
+
+def update_face_selector_order(face_analyser_order : FaceSelectorOrder) -> gradio.Gallery:
+	state_manager.set_item('face_selector_order', convert_str_none(face_analyser_order))
+	return update_reference_position_gallery()
+
+
+def update_face_selector_gender(face_selector_gender : FaceSelectorGender) -> gradio.Gallery:
+	state_manager.set_item('face_selector_gender', convert_str_none(face_selector_gender))
+	return update_reference_position_gallery()
+
+
+def update_face_selector_race(face_selector_race : FaceSelectorRace) -> gradio.Gallery:
+	state_manager.set_item('face_selector_race', convert_str_none(face_selector_race))
+	return update_reference_position_gallery()
+
+
+def update_face_selector_age_range(face_selector_age_range : Tuple[float, float]) -> gradio.Gallery:
+	face_selector_age_start, face_selector_age_end = face_selector_age_range
+	state_manager.set_item('face_selector_age_start', int(face_selector_age_start))
+	state_manager.set_item('face_selector_age_end', int(face_selector_age_end))
+	return update_reference_position_gallery()
+
+
+def update_reference_face_position(event : gradio.SelectData) -> None:
+	state_manager.set_item('reference_face_position', event.index)
+
+
+def clear_reference_face_position() -> None:
+	state_manager.set_item('reference_face_position', 0)
+
+
+def update_reference_face_distance(reference_face_distance : float) -> None:
+	state_manager.set_item('reference_face_distance', reference_face_distance)
+
+
+def update_reference_frame_number(reference_frame_number : int = 0) -> None:
+	state_manager.set_item('reference_frame_number', reference_frame_number)
+
+
+def clear_reference_frame_number() -> None:
+	state_manager.set_item('reference_frame_number', 0)
+
+
+def clear_and_update_reference_position_gallery() -> gradio.Gallery:
+	clear_faces()
+	return update_reference_position_gallery()
+
+
+def update_reference_position_gallery(frame_number : int = 0) -> gradio.Gallery:
+	gallery_vision_frames = []
+	source_vision_frames = read_static_images(filter_image_paths(state_manager.get_item('source_paths')))
+
+	if is_image(state_manager.get_item('target_path')):
+		target_vision_frame = read_static_image(state_manager.get_item('target_path'))
+		gallery_vision_frames = extract_gallery_frames(source_vision_frames, target_vision_frame)
+	if is_video(state_manager.get_item('target_path')):
+		target_vision_frame = read_video_frame(state_manager.get_item('target_path'), frame_number)
+		gallery_vision_frames = extract_gallery_frames(source_vision_frames, target_vision_frame)
+	if gallery_vision_frames:
+		return gradio.Gallery(value = gallery_vision_frames)
+	return gradio.Gallery(value = None)
+
+
+def extract_gallery_frames(source_vision_frames : List[VisionFrame], target_vision_frame : VisionFrame) -> List[VisionFrame]:
+	gallery_vision_frames = []
+	source_faces = get_many_faces(source_vision_frames)
+	target_faces = get_many_faces([ target_vision_frame ])
+	target_faces = sort_and_filter_faces(source_faces, target_faces)
+
+	for target_face in target_faces:
+		start_x, start_y, end_x, end_y = map(int, target_face.bounding_box)
+		padding_x = int((end_x - start_x) * 0.25)
+		padding_y = int((end_y - start_y) * 0.25)
+		start_x = max(0, start_x - padding_x)
+		start_y = max(0, start_y - padding_y)
+		end_x = max(0, end_x + padding_x)
+		end_y = max(0, end_y + padding_y)
+		crop_vision_frame = target_vision_frame[start_y:end_y, start_x:end_x]
+		crop_vision_frame = fit_cover_frame(crop_vision_frame, (128, 128))
+		crop_vision_frame = cv2.cvtColor(crop_vision_frame, cv2.COLOR_BGR2RGB)
+		gallery_vision_frames.append(crop_vision_frame)
+
+	return gallery_vision_frames

uis/components/face_swapper_options.py

@@ -0,0 +1,84 @@
+from typing import List, Optional, Tuple
+
+import gradio
+
+from facefusion import state_manager, translator
+from facefusion.common_helper import calculate_float_step, get_first
+from facefusion.processors.core import load_processor_module
+from facefusion.processors.modules.face_swapper import choices as face_swapper_choices
+from facefusion.processors.modules.face_swapper.types import FaceSwapperModel, FaceSwapperWeight
+from facefusion.uis.core import get_ui_component, register_ui_component
+
+FACE_SWAPPER_MODEL_DROPDOWN : Optional[gradio.Dropdown] = None
+FACE_SWAPPER_PIXEL_BOOST_DROPDOWN : Optional[gradio.Dropdown] = None
+FACE_SWAPPER_WEIGHT_SLIDER : Optional[gradio.Slider] = None
+
+
+def render() -> None:
+	global FACE_SWAPPER_MODEL_DROPDOWN
+	global FACE_SWAPPER_PIXEL_BOOST_DROPDOWN
+	global FACE_SWAPPER_WEIGHT_SLIDER
+
+	has_face_swapper = 'face_swapper' in state_manager.get_item('processors')
+	FACE_SWAPPER_MODEL_DROPDOWN = gradio.Dropdown(
+		label = translator.get('uis.model_dropdown', 'facefusion.processors.modules.face_swapper'),
+		choices = face_swapper_choices.face_swapper_models,
+		value = state_manager.get_item('face_swapper_model'),
+		visible = has_face_swapper
+	)
+	FACE_SWAPPER_PIXEL_BOOST_DROPDOWN = gradio.Dropdown(
+		label = translator.get('uis.pixel_boost_dropdown', 'facefusion.processors.modules.face_swapper'),
+		choices = face_swapper_choices.face_swapper_set.get(state_manager.get_item('face_swapper_model')),
+		value = state_manager.get_item('face_swapper_pixel_boost'),
+		visible = has_face_swapper
+	)
+	FACE_SWAPPER_WEIGHT_SLIDER = gradio.Slider(
+		label = translator.get('uis.weight_slider', 'facefusion.processors.modules.face_swapper'),
+		value = state_manager.get_item('face_swapper_weight'),
+		minimum = face_swapper_choices.face_swapper_weight_range[0],
+		maximum = face_swapper_choices.face_swapper_weight_range[-1],
+		step = calculate_float_step(face_swapper_choices.face_swapper_weight_range),
+		visible = has_face_swapper and has_face_swapper_weight()
+	)
+	register_ui_component('face_swapper_model_dropdown', FACE_SWAPPER_MODEL_DROPDOWN)
+	register_ui_component('face_swapper_pixel_boost_dropdown', FACE_SWAPPER_PIXEL_BOOST_DROPDOWN)
+	register_ui_component('face_swapper_weight_slider', FACE_SWAPPER_WEIGHT_SLIDER)
+
+
+def listen() -> None:
+	FACE_SWAPPER_MODEL_DROPDOWN.change(update_face_swapper_model, inputs = FACE_SWAPPER_MODEL_DROPDOWN, outputs = [ FACE_SWAPPER_MODEL_DROPDOWN, FACE_SWAPPER_PIXEL_BOOST_DROPDOWN, FACE_SWAPPER_WEIGHT_SLIDER ])
+	FACE_SWAPPER_PIXEL_BOOST_DROPDOWN.change(update_face_swapper_pixel_boost, inputs = FACE_SWAPPER_PIXEL_BOOST_DROPDOWN)
+	FACE_SWAPPER_WEIGHT_SLIDER.change(update_face_swapper_weight, inputs = FACE_SWAPPER_WEIGHT_SLIDER)
+
+	processors_checkbox_group = get_ui_component('processors_checkbox_group')
+	if processors_checkbox_group:
+		processors_checkbox_group.change(remote_update, inputs = processors_checkbox_group, outputs = [ FACE_SWAPPER_MODEL_DROPDOWN, FACE_SWAPPER_PIXEL_BOOST_DROPDOWN, FACE_SWAPPER_WEIGHT_SLIDER ])
+
+
+def remote_update(processors : List[str]) -> Tuple[gradio.Dropdown, gradio.Dropdown, gradio.Slider]:
+	has_face_swapper = 'face_swapper' in processors
+	return gradio.Dropdown(visible = has_face_swapper), gradio.Dropdown(visible = has_face_swapper), gradio.Slider(visible = has_face_swapper)
+
+
+def update_face_swapper_model(face_swapper_model : FaceSwapperModel) -> Tuple[gradio.Dropdown, gradio.Dropdown, gradio.Slider]:
+	face_swapper_module = load_processor_module('face_swapper')
+	face_swapper_module.clear_inference_pool()
+	state_manager.set_item('face_swapper_model', face_swapper_model)
+
+	if face_swapper_module.pre_check():
+		face_swapper_pixel_boost_dropdown_choices = face_swapper_choices.face_swapper_set.get(state_manager.get_item('face_swapper_model'))
+		state_manager.set_item('face_swapper_pixel_boost', get_first(face_swapper_pixel_boost_dropdown_choices))
+		return gradio.Dropdown(value = state_manager.get_item('face_swapper_model')), gradio.Dropdown(value = state_manager.get_item('face_swapper_pixel_boost'), choices = face_swapper_pixel_boost_dropdown_choices), gradio.Slider(visible = has_face_swapper_weight())
+	return gradio.Dropdown(), gradio.Dropdown(), gradio.Slider()
+
+
+def update_face_swapper_pixel_boost(face_swapper_pixel_boost : str) -> None:
+	state_manager.set_item('face_swapper_pixel_boost', face_swapper_pixel_boost)
+
+
+def update_face_swapper_weight(face_swapper_weight : FaceSwapperWeight) -> None:
+	state_manager.set_item('face_swapper_weight', face_swapper_weight)
+
+
+def has_face_swapper_weight() -> bool:
+	return state_manager.get_item('face_swapper_model') in [ 'ghost_1_256', 'ghost_2_256', 'ghost_3_256', 'hififace_unofficial_256', 'hyperswap_1a_256', 'hyperswap_1b_256', 'hyperswap_1c_256', 'inswapper_128', 'inswapper_128_fp16', 'simswap_256', 'simswap_unofficial_512' ]

uis/components/face_tracker.py

@@ -0,0 +1,32 @@
+from typing import Optional
+
+import gradio
+
+import facefusion.choices
+from facefusion import state_manager, translator
+from facefusion.common_helper import calculate_float_step
+from facefusion.types import Score
+from facefusion.uis.core import register_ui_component
+
+FACE_TRACKER_SCORE_SLIDER : Optional[gradio.Slider] = None
+
+
+def render() -> None:
+	global FACE_TRACKER_SCORE_SLIDER
+
+	FACE_TRACKER_SCORE_SLIDER = gradio.Slider(
+		label = translator.get('uis.face_tracker_score_slider'),
+		value = state_manager.get_item('face_tracker_score'),
+		step = calculate_float_step(facefusion.choices.face_tracker_score_range),
+		minimum = facefusion.choices.face_tracker_score_range[0],
+		maximum = facefusion.choices.face_tracker_score_range[-1]
+	)
+	register_ui_component('face_tracker_score_slider', FACE_TRACKER_SCORE_SLIDER)
+
+
+def listen() -> None:
+	FACE_TRACKER_SCORE_SLIDER.release(update_face_tracker_score, inputs = FACE_TRACKER_SCORE_SLIDER)
+
+
+def update_face_tracker_score(face_tracker_score : Score) -> None:
+	state_manager.set_item('face_tracker_score', face_tracker_score)

uis/components/frame_colorizer_options.py

@@ -0,0 +1,81 @@
+from typing import List, Optional, Tuple
+
+import gradio
+
+from facefusion import state_manager, translator
+from facefusion.common_helper import calculate_int_step
+from facefusion.processors.core import load_processor_module
+from facefusion.processors.modules.frame_colorizer import choices as frame_colorizer_choices
+from facefusion.processors.modules.frame_colorizer.types import FrameColorizerModel
+from facefusion.uis.core import get_ui_component, register_ui_component
+
+FRAME_COLORIZER_MODEL_DROPDOWN : Optional[gradio.Dropdown] = None
+FRAME_COLORIZER_SIZE_DROPDOWN : Optional[gradio.Dropdown] = None
+FRAME_COLORIZER_BLEND_SLIDER : Optional[gradio.Slider] = None
+
+
+def render() -> None:
+	global FRAME_COLORIZER_MODEL_DROPDOWN
+	global FRAME_COLORIZER_SIZE_DROPDOWN
+	global FRAME_COLORIZER_BLEND_SLIDER
+
+	has_frame_colorizer = 'frame_colorizer' in state_manager.get_item('processors')
+	FRAME_COLORIZER_MODEL_DROPDOWN = gradio.Dropdown(
+		label = translator.get('uis.model_dropdown', 'facefusion.processors.modules.frame_colorizer'),
+		choices = frame_colorizer_choices.frame_colorizer_models,
+		value = state_manager.get_item('frame_colorizer_model'),
+		visible = has_frame_colorizer
+	)
+	FRAME_COLORIZER_SIZE_DROPDOWN = gradio.Dropdown(
+		label = translator.get('uis.size_dropdown', 'facefusion.processors.modules.frame_colorizer'),
+		choices = frame_colorizer_choices.frame_colorizer_sizes,
+		value = state_manager.get_item('frame_colorizer_size'),
+		visible = has_frame_colorizer
+	)
+	FRAME_COLORIZER_BLEND_SLIDER = gradio.Slider(
+		label = translator.get('uis.blend_slider', 'facefusion.processors.modules.frame_colorizer'),
+		value = state_manager.get_item('frame_colorizer_blend'),
+		step = calculate_int_step(frame_colorizer_choices.frame_colorizer_blend_range),
+		minimum = frame_colorizer_choices.frame_colorizer_blend_range[0],
+		maximum = frame_colorizer_choices.frame_colorizer_blend_range[-1],
+		visible = has_frame_colorizer
+	)
+	register_ui_component('frame_colorizer_model_dropdown', FRAME_COLORIZER_MODEL_DROPDOWN)
+	register_ui_component('frame_colorizer_size_dropdown', FRAME_COLORIZER_SIZE_DROPDOWN)
+	register_ui_component('frame_colorizer_blend_slider', FRAME_COLORIZER_BLEND_SLIDER)
+
+
+def listen() -> None:
+	FRAME_COLORIZER_MODEL_DROPDOWN.change(update_frame_colorizer_model, inputs = FRAME_COLORIZER_MODEL_DROPDOWN, outputs = FRAME_COLORIZER_MODEL_DROPDOWN)
+	FRAME_COLORIZER_SIZE_DROPDOWN.change(update_frame_colorizer_size, inputs = FRAME_COLORIZER_SIZE_DROPDOWN)
+	FRAME_COLORIZER_BLEND_SLIDER.release(update_frame_colorizer_blend, inputs = FRAME_COLORIZER_BLEND_SLIDER)
+
+	processors_checkbox_group = get_ui_component('processors_checkbox_group')
+	if processors_checkbox_group:
+		processors_checkbox_group.change(remote_update, inputs = processors_checkbox_group, outputs = [ FRAME_COLORIZER_MODEL_DROPDOWN, FRAME_COLORIZER_BLEND_SLIDER, FRAME_COLORIZER_SIZE_DROPDOWN ])
+
+
+def remote_update(processors : List[str]) -> Tuple[gradio.Dropdown, gradio.Slider, gradio.Dropdown]:
+	has_frame_colorizer = 'frame_colorizer' in processors
+	return gradio.Dropdown(visible = has_frame_colorizer), gradio.Slider(visible = has_frame_colorizer), gradio.Dropdown(visible = has_frame_colorizer)
+
+
+def update_frame_colorizer_model(frame_colorizer_model : FrameColorizerModel) -> gradio.Dropdown:
+	frame_colorizer_module = load_processor_module('frame_colorizer')
+	frame_colorizer_module.clear_inference_pool()
+	state_manager.set_item('frame_colorizer_model', frame_colorizer_model)
+
+	if frame_colorizer_module.pre_check():
+		return gradio.Dropdown(value = state_manager.get_item('frame_colorizer_model'))
+	return gradio.Dropdown()
+
+
+def update_frame_colorizer_size(frame_colorizer_size : str) -> None:
+	state_manager.set_item('frame_colorizer_size', frame_colorizer_size)
+
+
+def update_frame_colorizer_blend(frame_colorizer_blend : float) -> None:
+	state_manager.set_item('frame_colorizer_blend', int(frame_colorizer_blend))
+
+
+

uis/components/frame_enhancer_options.py

@@ -0,0 +1,64 @@
+from typing import List, Optional, Tuple
+
+import gradio
+
+from facefusion import state_manager, translator
+from facefusion.common_helper import calculate_int_step
+from facefusion.processors.core import load_processor_module
+from facefusion.processors.modules.frame_enhancer import choices as frame_enhancer_choices
+from facefusion.processors.modules.frame_enhancer.types import FrameEnhancerModel
+from facefusion.uis.core import get_ui_component, register_ui_component
+
+FRAME_ENHANCER_MODEL_DROPDOWN : Optional[gradio.Dropdown] = None
+FRAME_ENHANCER_BLEND_SLIDER : Optional[gradio.Slider] = None
+
+
+def render() -> None:
+	global FRAME_ENHANCER_MODEL_DROPDOWN
+	global FRAME_ENHANCER_BLEND_SLIDER
+
+	has_frame_enhancer = 'frame_enhancer' in state_manager.get_item('processors')
+	FRAME_ENHANCER_MODEL_DROPDOWN = gradio.Dropdown(
+		label = translator.get('uis.model_dropdown', 'facefusion.processors.modules.frame_enhancer'),
+		choices = frame_enhancer_choices.frame_enhancer_models,
+		value = state_manager.get_item('frame_enhancer_model'),
+		visible = has_frame_enhancer
+	)
+	FRAME_ENHANCER_BLEND_SLIDER = gradio.Slider(
+		label = translator.get('uis.blend_slider', 'facefusion.processors.modules.frame_enhancer'),
+		value = state_manager.get_item('frame_enhancer_blend'),
+		step = calculate_int_step(frame_enhancer_choices.frame_enhancer_blend_range),
+		minimum = frame_enhancer_choices.frame_enhancer_blend_range[0],
+		maximum = frame_enhancer_choices.frame_enhancer_blend_range[-1],
+		visible = has_frame_enhancer
+	)
+	register_ui_component('frame_enhancer_model_dropdown', FRAME_ENHANCER_MODEL_DROPDOWN)
+	register_ui_component('frame_enhancer_blend_slider', FRAME_ENHANCER_BLEND_SLIDER)
+
+
+def listen() -> None:
+	FRAME_ENHANCER_MODEL_DROPDOWN.change(update_frame_enhancer_model, inputs = FRAME_ENHANCER_MODEL_DROPDOWN, outputs = FRAME_ENHANCER_MODEL_DROPDOWN)
+	FRAME_ENHANCER_BLEND_SLIDER.release(update_frame_enhancer_blend, inputs = FRAME_ENHANCER_BLEND_SLIDER)
+
+	processors_checkbox_group = get_ui_component('processors_checkbox_group')
+	if processors_checkbox_group:
+		processors_checkbox_group.change(remote_update, inputs = processors_checkbox_group, outputs = [ FRAME_ENHANCER_MODEL_DROPDOWN, FRAME_ENHANCER_BLEND_SLIDER ])
+
+
+def remote_update(processors : List[str]) -> Tuple[gradio.Dropdown, gradio.Slider]:
+	has_frame_enhancer = 'frame_enhancer' in processors
+	return gradio.Dropdown(visible = has_frame_enhancer), gradio.Slider(visible = has_frame_enhancer)
+
+
+def update_frame_enhancer_model(frame_enhancer_model : FrameEnhancerModel) -> gradio.Dropdown:
+	frame_enhancer_module = load_processor_module('frame_enhancer')
+	frame_enhancer_module.clear_inference_pool()
+	state_manager.set_item('frame_enhancer_model', frame_enhancer_model)
+
+	if frame_enhancer_module.pre_check():
+		return gradio.Dropdown(value = state_manager.get_item('frame_enhancer_model'))
+	return gradio.Dropdown()
+
+
+def update_frame_enhancer_blend(frame_enhancer_blend : float) -> None:
+	state_manager.set_item('frame_enhancer_blend', int(frame_enhancer_blend))

uis/components/instant_runner.py

@@ -0,0 +1,110 @@
+from time import sleep
+from typing import Optional, Tuple
+
+import gradio
+
+from facefusion import process_manager, state_manager, translator
+from facefusion.args import collect_step_args
+from facefusion.core import process_step
+from facefusion.filesystem import is_directory, is_image, is_video
+from facefusion.jobs import job_helper, job_manager, job_runner, job_store
+from facefusion.temp_helper import clear_temp_directory
+from facefusion.types import Args, UiWorkflow
+from facefusion.uis.core import get_ui_component
+from facefusion.uis.ui_helper import suggest_output_path
+
+INSTANT_RUNNER_WRAPPER : Optional[gradio.Row] = None
+INSTANT_RUNNER_START_BUTTON : Optional[gradio.Button] = None
+INSTANT_RUNNER_STOP_BUTTON : Optional[gradio.Button] = None
+INSTANT_RUNNER_CLEAR_BUTTON : Optional[gradio.Button] = None
+
+
+def render() -> None:
+	global INSTANT_RUNNER_WRAPPER
+	global INSTANT_RUNNER_START_BUTTON
+	global INSTANT_RUNNER_STOP_BUTTON
+	global INSTANT_RUNNER_CLEAR_BUTTON
+
+	if job_manager.init_jobs(state_manager.get_item('jobs_path')):
+		is_instant_runner = state_manager.get_item('ui_workflow') == 'instant_runner'
+
+		with gradio.Row(visible = is_instant_runner) as INSTANT_RUNNER_WRAPPER:
+			INSTANT_RUNNER_START_BUTTON = gradio.Button(
+				value = translator.get('uis.start_button'),
+				variant = 'primary',
+				size = 'sm'
+			)
+			INSTANT_RUNNER_STOP_BUTTON = gradio.Button(
+				value = translator.get('uis.stop_button'),
+				variant = 'primary',
+				size = 'sm',
+				visible = False
+			)
+			INSTANT_RUNNER_CLEAR_BUTTON = gradio.Button(
+				value = translator.get('uis.clear_button'),
+				size = 'sm'
+			)
+
+
+def listen() -> None:
+	output_image = get_ui_component('output_image')
+	output_video = get_ui_component('output_video')
+	ui_workflow_dropdown = get_ui_component('ui_workflow_dropdown')
+
+	if output_image and output_video:
+		INSTANT_RUNNER_START_BUTTON.click(start, outputs = [ INSTANT_RUNNER_START_BUTTON, INSTANT_RUNNER_STOP_BUTTON ])
+		INSTANT_RUNNER_START_BUTTON.click(run, outputs = [ INSTANT_RUNNER_START_BUTTON, INSTANT_RUNNER_STOP_BUTTON, output_image, output_video ])
+		INSTANT_RUNNER_STOP_BUTTON.click(stop, outputs = [ INSTANT_RUNNER_START_BUTTON, INSTANT_RUNNER_STOP_BUTTON, output_image, output_video ])
+		INSTANT_RUNNER_CLEAR_BUTTON.click(clear, outputs = [ output_image, output_video ])
+	if ui_workflow_dropdown:
+		ui_workflow_dropdown.change(remote_update, inputs = ui_workflow_dropdown, outputs = INSTANT_RUNNER_WRAPPER)
+
+
+def remote_update(ui_workflow : UiWorkflow) -> gradio.Row:
+	is_instant_runner = ui_workflow == 'instant_runner'
+
+	return gradio.Row(visible = is_instant_runner)
+
+
+def start() -> Tuple[gradio.Button, gradio.Button]:
+	while not process_manager.is_processing():
+		sleep(0.5)
+	return gradio.Button(visible = False), gradio.Button(visible = True)
+
+
+def run() -> Tuple[gradio.Button, gradio.Button, gradio.Image, gradio.Video]:
+	step_args = collect_step_args()
+	output_path = step_args.get('output_path')
+
+	if is_directory(step_args.get('output_path')):
+		step_args['output_path'] = suggest_output_path(step_args.get('output_path'), state_manager.get_item('target_path'))
+	if job_manager.init_jobs(state_manager.get_item('jobs_path')):
+		create_and_run_job(step_args)
+		state_manager.set_item('output_path', output_path)
+	if is_image(step_args.get('output_path')):
+		return gradio.Button(visible = True), gradio.Button(visible = False), gradio.Image(value = step_args.get('output_path'), visible = True), gradio.Video(value = None, visible = False)
+	if is_video(step_args.get('output_path')):
+		return gradio.Button(visible = True), gradio.Button(visible = False), gradio.Image(value = None, visible = False), gradio.Video(value = step_args.get('output_path'), visible = True)
+	return gradio.Button(visible = True), gradio.Button(visible = False), gradio.Image(value = None), gradio.Video(value = None)
+
+
+def create_and_run_job(step_args : Args) -> bool:
+	job_id = job_helper.suggest_job_id('ui')
+
+	for key in job_store.get_job_keys():
+		state_manager.sync_item(key) #type:ignore[arg-type]
+
+	return job_manager.create_job(job_id) and job_manager.add_step(job_id, step_args) and job_manager.submit_job(job_id) and job_runner.run_job(job_id, process_step)
+
+
+def stop() -> Tuple[gradio.Button, gradio.Button, gradio.Image, gradio.Video]:
+	process_manager.stop()
+	return gradio.Button(visible = True), gradio.Button(visible = False), gradio.Image(value = None), gradio.Video(value = None)
+
+
+def clear() -> Tuple[gradio.Image, gradio.Video]:
+	while process_manager.is_processing():
+		sleep(0.5)
+	if state_manager.get_item('target_path'):
+		clear_temp_directory(state_manager.get_item('target_path'))
+	return gradio.Image(value = None), gradio.Video(value = None)

uis/components/job_list.py

@@ -0,0 +1,50 @@
+from typing import List, Optional
+
+import gradio
+
+import facefusion.choices
+from facefusion import state_manager, translator
+from facefusion.common_helper import get_first
+from facefusion.jobs import job_list, job_manager
+from facefusion.types import JobStatus
+from facefusion.uis.core import get_ui_component
+
+JOB_LIST_JOBS_DATAFRAME : Optional[gradio.Dataframe] = None
+JOB_LIST_REFRESH_BUTTON : Optional[gradio.Button] = None
+
+
+def render() -> None:
+	global JOB_LIST_JOBS_DATAFRAME
+	global JOB_LIST_REFRESH_BUTTON
+
+	if job_manager.init_jobs(state_manager.get_item('jobs_path')):
+		job_status = get_first(facefusion.choices.job_statuses)
+		job_headers, job_contents = job_list.compose_job_list(job_status)
+
+		JOB_LIST_JOBS_DATAFRAME = gradio.Dataframe(
+			headers = job_headers,
+			value = job_contents,
+			datatype = [ 'str', 'number', 'date', 'date', 'str' ],
+			show_label = False
+		)
+		JOB_LIST_REFRESH_BUTTON = gradio.Button(
+			value = translator.get('uis.refresh_button'),
+			variant = 'primary',
+			size = 'sm'
+		)
+
+
+def listen() -> None:
+	job_list_job_status_checkbox_group = get_ui_component('job_list_job_status_checkbox_group')
+	if job_list_job_status_checkbox_group:
+		job_list_job_status_checkbox_group.change(update_job_dataframe, inputs = job_list_job_status_checkbox_group, outputs = JOB_LIST_JOBS_DATAFRAME)
+		JOB_LIST_REFRESH_BUTTON.click(update_job_dataframe, inputs = job_list_job_status_checkbox_group, outputs = JOB_LIST_JOBS_DATAFRAME)
+
+
+def update_job_dataframe(job_statuses : List[JobStatus]) -> gradio.Dataframe:
+	all_job_contents = []
+
+	for job_status in job_statuses:
+		_, job_contents = job_list.compose_job_list(job_status)
+		all_job_contents.extend(job_contents)
+	return gradio.Dataframe(value = all_job_contents)

uis/components/job_list_options.py

@@ -0,0 +1,35 @@
+from typing import List, Optional
+
+import gradio
+
+import facefusion.choices
+from facefusion import state_manager, translator
+from facefusion.common_helper import get_first
+from facefusion.jobs import job_manager
+from facefusion.types import JobStatus
+from facefusion.uis.core import register_ui_component
+
+JOB_LIST_JOB_STATUS_CHECKBOX_GROUP : Optional[gradio.CheckboxGroup] = None
+
+
+def render() -> None:
+	global JOB_LIST_JOB_STATUS_CHECKBOX_GROUP
+
+	if job_manager.init_jobs(state_manager.get_item('jobs_path')):
+		job_status = get_first(facefusion.choices.job_statuses)
+
+		JOB_LIST_JOB_STATUS_CHECKBOX_GROUP = gradio.CheckboxGroup(
+			label = translator.get('uis.job_list_status_checkbox_group'),
+			choices = facefusion.choices.job_statuses,
+			value = job_status
+		)
+		register_ui_component('job_list_job_status_checkbox_group', JOB_LIST_JOB_STATUS_CHECKBOX_GROUP)
+
+
+def listen() -> None:
+	JOB_LIST_JOB_STATUS_CHECKBOX_GROUP.change(update_job_status_checkbox_group, inputs = JOB_LIST_JOB_STATUS_CHECKBOX_GROUP, outputs = JOB_LIST_JOB_STATUS_CHECKBOX_GROUP)
+
+
+def update_job_status_checkbox_group(job_statuses : List[JobStatus]) -> gradio.CheckboxGroup:
+	job_statuses = job_statuses or facefusion.choices.job_statuses
+	return gradio.CheckboxGroup(value = job_statuses)

uis/components/job_manager.py

@@ -0,0 +1,194 @@
+from typing import List, Optional, Tuple
+
+import gradio
+
+from facefusion import logger, state_manager, translator
+from facefusion.args import collect_step_args
+from facefusion.common_helper import get_first, get_last
+from facefusion.filesystem import is_directory
+from facefusion.jobs import job_manager
+from facefusion.types import UiWorkflow
+from facefusion.uis import choices as uis_choices
+from facefusion.uis.core import get_ui_component
+from facefusion.uis.types import JobManagerAction
+from facefusion.uis.ui_helper import convert_int_none, convert_str_none, suggest_output_path
+
+JOB_MANAGER_WRAPPER : Optional[gradio.Column] = None
+JOB_MANAGER_JOB_ACTION_DROPDOWN : Optional[gradio.Dropdown] = None
+JOB_MANAGER_JOB_ID_TEXTBOX : Optional[gradio.Textbox] = None
+JOB_MANAGER_JOB_ID_DROPDOWN : Optional[gradio.Dropdown] = None
+JOB_MANAGER_STEP_INDEX_DROPDOWN : Optional[gradio.Dropdown] = None
+JOB_MANAGER_APPLY_BUTTON : Optional[gradio.Button] = None
+
+
+def render() -> None:
+	global JOB_MANAGER_WRAPPER
+	global JOB_MANAGER_JOB_ACTION_DROPDOWN
+	global JOB_MANAGER_JOB_ID_TEXTBOX
+	global JOB_MANAGER_JOB_ID_DROPDOWN
+	global JOB_MANAGER_STEP_INDEX_DROPDOWN
+	global JOB_MANAGER_APPLY_BUTTON
+
+	if job_manager.init_jobs(state_manager.get_item('jobs_path')):
+		is_job_manager = state_manager.get_item('ui_workflow') == 'job_manager'
+		drafted_job_ids = job_manager.find_job_ids('drafted') or [ 'none' ]
+
+		with gradio.Column(visible = is_job_manager) as JOB_MANAGER_WRAPPER:
+			JOB_MANAGER_JOB_ACTION_DROPDOWN = gradio.Dropdown(
+				label = translator.get('uis.job_manager_job_action_dropdown'),
+				choices = uis_choices.job_manager_actions,
+				value = get_first(uis_choices.job_manager_actions)
+			)
+			JOB_MANAGER_JOB_ID_TEXTBOX = gradio.Textbox(
+				label = translator.get('uis.job_manager_job_id_dropdown'),
+				max_lines = 1,
+				interactive = True
+			)
+			JOB_MANAGER_JOB_ID_DROPDOWN = gradio.Dropdown(
+				label = translator.get('uis.job_manager_job_id_dropdown'),
+				choices = drafted_job_ids,
+				value = get_last(drafted_job_ids),
+				interactive = True,
+				visible = False
+			)
+			JOB_MANAGER_STEP_INDEX_DROPDOWN = gradio.Dropdown(
+				label = translator.get('uis.job_manager_step_index_dropdown'),
+				choices = [ 'none' ],
+				value = 'none',
+				interactive = True,
+				visible = False
+			)
+			JOB_MANAGER_APPLY_BUTTON = gradio.Button(
+				value = translator.get('uis.apply_button'),
+				variant = 'primary',
+				size = 'sm'
+			)
+
+
+def listen() -> None:
+	JOB_MANAGER_JOB_ACTION_DROPDOWN.change(update, inputs = [ JOB_MANAGER_JOB_ACTION_DROPDOWN, JOB_MANAGER_JOB_ID_DROPDOWN ], outputs = [ JOB_MANAGER_JOB_ID_TEXTBOX, JOB_MANAGER_JOB_ID_DROPDOWN, JOB_MANAGER_STEP_INDEX_DROPDOWN ])
+	JOB_MANAGER_JOB_ID_DROPDOWN.change(update_step_index, inputs = JOB_MANAGER_JOB_ID_DROPDOWN, outputs = JOB_MANAGER_STEP_INDEX_DROPDOWN)
+	JOB_MANAGER_APPLY_BUTTON.click(apply, inputs = [ JOB_MANAGER_JOB_ACTION_DROPDOWN, JOB_MANAGER_JOB_ID_TEXTBOX, JOB_MANAGER_JOB_ID_DROPDOWN, JOB_MANAGER_STEP_INDEX_DROPDOWN ], outputs = [ JOB_MANAGER_JOB_ACTION_DROPDOWN, JOB_MANAGER_JOB_ID_TEXTBOX, JOB_MANAGER_JOB_ID_DROPDOWN, JOB_MANAGER_STEP_INDEX_DROPDOWN ])
+
+	ui_workflow_dropdown = get_ui_component('ui_workflow_dropdown')
+	if ui_workflow_dropdown:
+		ui_workflow_dropdown.change(remote_update, inputs = ui_workflow_dropdown, outputs = [ JOB_MANAGER_WRAPPER, JOB_MANAGER_JOB_ACTION_DROPDOWN, JOB_MANAGER_JOB_ID_TEXTBOX, JOB_MANAGER_JOB_ID_DROPDOWN, JOB_MANAGER_STEP_INDEX_DROPDOWN ])
+
+
+def remote_update(ui_workflow : UiWorkflow) -> Tuple[gradio.Row, gradio.Dropdown, gradio.Textbox, gradio.Dropdown, gradio.Dropdown]:
+	is_job_manager = ui_workflow == 'job_manager'
+	return gradio.Row(visible = is_job_manager), gradio.Dropdown(value = get_first(uis_choices.job_manager_actions)), gradio.Textbox(value = None, visible = True), gradio.Dropdown(visible = False), gradio.Dropdown(visible = False)
+
+
+def apply(job_action : JobManagerAction, created_job_id : str, selected_job_id : str, selected_step_index : int) -> Tuple[gradio.Dropdown, gradio.Textbox, gradio.Dropdown, gradio.Dropdown]:
+	created_job_id = convert_str_none(created_job_id)
+	selected_job_id = convert_str_none(selected_job_id)
+	selected_step_index = convert_int_none(selected_step_index)
+	step_args = collect_step_args()
+	output_path = step_args.get('output_path')
+
+	if is_directory(step_args.get('output_path')):
+		step_args['output_path'] = suggest_output_path(step_args.get('output_path'), state_manager.get_item('target_path'))
+
+	if job_action == 'job-create':
+		if created_job_id and job_manager.create_job(created_job_id):
+			updated_job_ids = job_manager.find_job_ids('drafted') or [ 'none' ]
+
+			logger.info(translator.get('job_created').format(job_id = created_job_id), __name__)
+			return gradio.Dropdown(value = 'job-add-step'), gradio.Textbox(visible = False), gradio.Dropdown(value = created_job_id, choices = updated_job_ids, visible = True), gradio.Dropdown()
+		else:
+			logger.error(translator.get('job_not_created').format(job_id = created_job_id), __name__)
+
+	if job_action == 'job-submit':
+		if selected_job_id and job_manager.submit_job(selected_job_id):
+			updated_job_ids = job_manager.find_job_ids('drafted') or [ 'none' ]
+
+			logger.info(translator.get('job_submitted').format(job_id = selected_job_id), __name__)
+			return gradio.Dropdown(), gradio.Textbox(), gradio.Dropdown(value = get_last(updated_job_ids), choices = updated_job_ids, visible = True), gradio.Dropdown()
+		else:
+			logger.error(translator.get('job_not_submitted').format(job_id = selected_job_id), __name__)
+
+	if job_action == 'job-delete':
+		if selected_job_id and job_manager.delete_job(selected_job_id):
+			updated_job_ids = job_manager.find_job_ids('drafted') + job_manager.find_job_ids('queued') + job_manager.find_job_ids('failed') + job_manager.find_job_ids('completed') or [ 'none' ]
+
+			logger.info(translator.get('job_deleted').format(job_id = selected_job_id), __name__)
+			return gradio.Dropdown(), gradio.Textbox(), gradio.Dropdown(value = get_last(updated_job_ids), choices = updated_job_ids, visible = True), gradio.Dropdown()
+		else:
+			logger.error(translator.get('job_not_deleted').format(job_id = selected_job_id), __name__)
+
+	if job_action == 'job-add-step':
+		if selected_job_id and job_manager.add_step(selected_job_id, step_args):
+			state_manager.set_item('output_path', output_path)
+			logger.info(translator.get('job_step_added').format(job_id = selected_job_id), __name__)
+			return gradio.Dropdown(), gradio.Textbox(), gradio.Dropdown(visible = True), gradio.Dropdown(visible = False)
+		else:
+			state_manager.set_item('output_path', output_path)
+			logger.error(translator.get('job_step_not_added').format(job_id = selected_job_id), __name__)
+
+	if job_action == 'job-remix-step':
+		if selected_job_id and job_manager.has_step(selected_job_id, selected_step_index) and job_manager.remix_step(selected_job_id, selected_step_index, step_args):
+			updated_step_choices = get_step_choices(selected_job_id) or [ 'none' ] #type:ignore[list-item]
+
+			state_manager.set_item('output_path', output_path)
+			logger.info(translator.get('job_remix_step_added').format(job_id = selected_job_id, step_index = selected_step_index), __name__)
+			return gradio.Dropdown(), gradio.Textbox(), gradio.Dropdown(visible = True), gradio.Dropdown(value = get_last(updated_step_choices), choices = updated_step_choices, visible = True)
+		else:
+			state_manager.set_item('output_path', output_path)
+			logger.error(translator.get('job_remix_step_not_added').format(job_id = selected_job_id, step_index = selected_step_index), __name__)
+
+	if job_action == 'job-insert-step':
+		if selected_job_id and job_manager.has_step(selected_job_id, selected_step_index) and job_manager.insert_step(selected_job_id, selected_step_index, step_args):
+			updated_step_choices = get_step_choices(selected_job_id) or [ 'none' ] #type:ignore[list-item]
+
+			state_manager.set_item('output_path', output_path)
+			logger.info(translator.get('job_step_inserted').format(job_id = selected_job_id, step_index = selected_step_index), __name__)
+			return gradio.Dropdown(), gradio.Textbox(), gradio.Dropdown(visible = True), gradio.Dropdown(value = get_last(updated_step_choices), choices = updated_step_choices, visible = True)
+		else:
+			state_manager.set_item('output_path', output_path)
+			logger.error(translator.get('job_step_not_inserted').format(job_id = selected_job_id, step_index = selected_step_index), __name__)
+
+	if job_action == 'job-remove-step':
+		if selected_job_id and job_manager.has_step(selected_job_id, selected_step_index) and job_manager.remove_step(selected_job_id, selected_step_index):
+			updated_step_choices = get_step_choices(selected_job_id) or [ 'none' ] #type:ignore[list-item]
+
+			logger.info(translator.get('job_step_removed').format(job_id = selected_job_id, step_index = selected_step_index), __name__)
+			return gradio.Dropdown(), gradio.Textbox(), gradio.Dropdown(visible = True), gradio.Dropdown(value = get_last(updated_step_choices), choices = updated_step_choices, visible = True)
+		else:
+			logger.error(translator.get('job_step_not_removed').format(job_id = selected_job_id, step_index = selected_step_index), __name__)
+	return gradio.Dropdown(), gradio.Textbox(), gradio.Dropdown(), gradio.Dropdown()
+
+
+def get_step_choices(job_id : str) -> List[int]:
+	steps = job_manager.get_steps(job_id)
+	return [ index for index, _ in enumerate(steps) ]
+
+
+def update(job_action : JobManagerAction, selected_job_id : str) -> Tuple[gradio.Textbox, gradio.Dropdown, gradio.Dropdown]:
+	if job_action == 'job-create':
+		return gradio.Textbox(value = None, visible = True), gradio.Dropdown(visible = False), gradio.Dropdown(visible = False)
+
+	if job_action == 'job-delete':
+		updated_job_ids = job_manager.find_job_ids('drafted') + job_manager.find_job_ids('queued') + job_manager.find_job_ids('failed') + job_manager.find_job_ids('completed') or [ 'none' ]
+		updated_job_id = selected_job_id if selected_job_id in updated_job_ids else get_last(updated_job_ids)
+
+		return gradio.Textbox(visible = False), gradio.Dropdown(value = updated_job_id, choices = updated_job_ids, visible = True), gradio.Dropdown(visible = False)
+
+	if job_action in [ 'job-submit', 'job-add-step' ]:
+		updated_job_ids = job_manager.find_job_ids('drafted') or [ 'none' ]
+		updated_job_id = selected_job_id if selected_job_id in updated_job_ids else get_last(updated_job_ids)
+
+		return gradio.Textbox(visible = False), gradio.Dropdown(value = updated_job_id, choices = updated_job_ids, visible = True), gradio.Dropdown(visible = False)
+
+	if job_action in [ 'job-remix-step', 'job-insert-step', 'job-remove-step' ]:
+		updated_job_ids = job_manager.find_job_ids('drafted') or [ 'none' ]
+		updated_job_id = selected_job_id if selected_job_id in updated_job_ids else get_last(updated_job_ids)
+		updated_step_choices = get_step_choices(updated_job_id) or [ 'none' ] #type:ignore[list-item]
+
+		return gradio.Textbox(visible = False), gradio.Dropdown(value = updated_job_id, choices = updated_job_ids, visible = True), gradio.Dropdown(value = get_last(updated_step_choices), choices = updated_step_choices, visible = True)
+	return gradio.Textbox(visible = False), gradio.Dropdown(visible = False), gradio.Dropdown(visible = False)
+
+
+def update_step_index(job_id : str) -> gradio.Dropdown:
+	step_choices = get_step_choices(job_id) or [ 'none' ] #type:ignore[list-item]
+	return gradio.Dropdown(value = get_last(step_choices), choices = step_choices)

uis/components/job_runner.py

@@ -0,0 +1,142 @@
+from time import sleep
+from typing import Optional, Tuple
+
+import gradio
+
+from facefusion import logger, process_manager, state_manager, translator
+from facefusion.common_helper import get_first, get_last
+from facefusion.core import process_step
+from facefusion.jobs import job_manager, job_runner, job_store
+from facefusion.types import UiWorkflow
+from facefusion.uis import choices as uis_choices
+from facefusion.uis.core import get_ui_component
+from facefusion.uis.types import JobRunnerAction
+from facefusion.uis.ui_helper import convert_str_none
+
+JOB_RUNNER_WRAPPER : Optional[gradio.Column] = None
+JOB_RUNNER_JOB_ACTION_DROPDOWN : Optional[gradio.Dropdown] = None
+JOB_RUNNER_JOB_ID_DROPDOWN : Optional[gradio.Dropdown] = None
+JOB_RUNNER_START_BUTTON : Optional[gradio.Button] = None
+JOB_RUNNER_STOP_BUTTON : Optional[gradio.Button] = None
+
+
+def render() -> None:
+	global JOB_RUNNER_WRAPPER
+	global JOB_RUNNER_JOB_ACTION_DROPDOWN
+	global JOB_RUNNER_JOB_ID_DROPDOWN
+	global JOB_RUNNER_START_BUTTON
+	global JOB_RUNNER_STOP_BUTTON
+
+	if job_manager.init_jobs(state_manager.get_item('jobs_path')):
+		is_job_runner = state_manager.get_item('ui_workflow') == 'job_runner'
+		queued_job_ids = job_manager.find_job_ids('queued') or [ 'none' ]
+
+		with gradio.Column(visible = is_job_runner) as JOB_RUNNER_WRAPPER:
+			JOB_RUNNER_JOB_ACTION_DROPDOWN = gradio.Dropdown(
+				label = translator.get('uis.job_runner_job_action_dropdown'),
+				choices = uis_choices.job_runner_actions,
+				value = get_first(uis_choices.job_runner_actions)
+			)
+			JOB_RUNNER_JOB_ID_DROPDOWN = gradio.Dropdown(
+				label = translator.get('uis.job_runner_job_id_dropdown'),
+				choices = queued_job_ids,
+				value = get_last(queued_job_ids)
+			)
+			with gradio.Row():
+				JOB_RUNNER_START_BUTTON = gradio.Button(
+					value = translator.get('uis.start_button'),
+					variant = 'primary',
+					size = 'sm'
+				)
+				JOB_RUNNER_STOP_BUTTON = gradio.Button(
+					value = translator.get('uis.stop_button'),
+					variant = 'primary',
+					size = 'sm',
+					visible = False
+				)
+
+
+def listen() -> None:
+	JOB_RUNNER_JOB_ACTION_DROPDOWN.change(update_job_action, inputs = JOB_RUNNER_JOB_ACTION_DROPDOWN, outputs = JOB_RUNNER_JOB_ID_DROPDOWN)
+	JOB_RUNNER_START_BUTTON.click(start, outputs = [ JOB_RUNNER_START_BUTTON, JOB_RUNNER_STOP_BUTTON ])
+	JOB_RUNNER_START_BUTTON.click(run, inputs = [ JOB_RUNNER_JOB_ACTION_DROPDOWN, JOB_RUNNER_JOB_ID_DROPDOWN ], outputs = [ JOB_RUNNER_START_BUTTON, JOB_RUNNER_STOP_BUTTON, JOB_RUNNER_JOB_ID_DROPDOWN ])
+	JOB_RUNNER_STOP_BUTTON.click(stop, outputs = [ JOB_RUNNER_START_BUTTON, JOB_RUNNER_STOP_BUTTON ])
+
+	ui_workflow_dropdown = get_ui_component('ui_workflow_dropdown')
+	if ui_workflow_dropdown:
+		ui_workflow_dropdown.change(remote_update, inputs = ui_workflow_dropdown, outputs = [ JOB_RUNNER_WRAPPER, JOB_RUNNER_JOB_ACTION_DROPDOWN, JOB_RUNNER_JOB_ID_DROPDOWN ])
+
+
+def remote_update(ui_workflow : UiWorkflow) -> Tuple[gradio.Row, gradio.Dropdown, gradio.Dropdown]:
+	is_job_runner = ui_workflow == 'job_runner'
+	queued_job_ids = job_manager.find_job_ids('queued') or [ 'none' ]
+
+	return gradio.Row(visible = is_job_runner), gradio.Dropdown(value = get_first(uis_choices.job_runner_actions), choices = uis_choices.job_runner_actions), gradio.Dropdown(value = get_last(queued_job_ids), choices = queued_job_ids)
+
+
+def start() -> Tuple[gradio.Button, gradio.Button]:
+	while not process_manager.is_processing():
+		sleep(0.5)
+	return gradio.Button(visible = False), gradio.Button(visible = True)
+
+
+def run(job_action : JobRunnerAction, job_id : str) -> Tuple[gradio.Button, gradio.Button, gradio.Dropdown]:
+	job_id = convert_str_none(job_id)
+
+	for key in job_store.get_job_keys():
+		state_manager.sync_item(key) #type:ignore[arg-type]
+
+	if job_action == 'job-run':
+		logger.info(translator.get('running_job').format(job_id = job_id), __name__)
+		if job_id and job_runner.run_job(job_id, process_step):
+			logger.info(translator.get('processing_job_succeeded').format(job_id = job_id), __name__)
+		else:
+			logger.info(translator.get('processing_job_failed').format(job_id = job_id), __name__)
+		updated_job_ids = job_manager.find_job_ids('queued') or [ 'none' ]
+
+		return gradio.Button(visible = True), gradio.Button(visible = False), gradio.Dropdown(value = get_last(updated_job_ids), choices = updated_job_ids)
+
+	if job_action == 'job-run-all':
+		logger.info(translator.get('running_jobs'), __name__)
+		halt_on_error = False
+		if job_runner.run_jobs(process_step, halt_on_error):
+			logger.info(translator.get('processing_jobs_succeeded'), __name__)
+		else:
+			logger.info(translator.get('processing_jobs_failed'), __name__)
+
+	if job_action == 'job-retry':
+		logger.info(translator.get('retrying_job').format(job_id = job_id), __name__)
+		if job_id and job_runner.retry_job(job_id, process_step):
+			logger.info(translator.get('processing_job_succeeded').format(job_id = job_id), __name__)
+		else:
+			logger.info(translator.get('processing_job_failed').format(job_id = job_id), __name__)
+		updated_job_ids = job_manager.find_job_ids('failed') or [ 'none' ]
+
+		return gradio.Button(visible = True), gradio.Button(visible = False), gradio.Dropdown(value = get_last(updated_job_ids), choices = updated_job_ids)
+
+	if job_action == 'job-retry-all':
+		logger.info(translator.get('retrying_jobs'), __name__)
+		halt_on_error = False
+		if job_runner.retry_jobs(process_step, halt_on_error):
+			logger.info(translator.get('processing_jobs_succeeded'), __name__)
+		else:
+			logger.info(translator.get('processing_jobs_failed'), __name__)
+	return gradio.Button(visible = True), gradio.Button(visible = False), gradio.Dropdown()
+
+
+def stop() -> Tuple[gradio.Button, gradio.Button]:
+	process_manager.stop()
+	return gradio.Button(visible = True), gradio.Button(visible = False)
+
+
+def update_job_action(job_action : JobRunnerAction) -> gradio.Dropdown:
+	if job_action == 'job-run':
+		updated_job_ids = job_manager.find_job_ids('queued') or [ 'none' ]
+
+		return gradio.Dropdown(value = get_last(updated_job_ids), choices = updated_job_ids, visible = True)
+
+	if job_action == 'job-retry':
+		updated_job_ids = job_manager.find_job_ids('failed') or [ 'none' ]
+
+		return gradio.Dropdown(value = get_last(updated_job_ids), choices = updated_job_ids, visible = True)
+	return gradio.Dropdown(visible = False)

uis/components/lip_syncer_options.py

@@ -0,0 +1,64 @@
+from typing import List, Optional, Tuple
+
+import gradio
+
+from facefusion import state_manager, translator
+from facefusion.common_helper import calculate_float_step
+from facefusion.processors.core import load_processor_module
+from facefusion.processors.modules.lip_syncer import choices as lip_syncer_choices
+from facefusion.processors.modules.lip_syncer.types import LipSyncerModel, LipSyncerWeight
+from facefusion.uis.core import get_ui_component, register_ui_component
+
+LIP_SYNCER_MODEL_DROPDOWN : Optional[gradio.Dropdown] = None
+LIP_SYNCER_WEIGHT_SLIDER : Optional[gradio.Slider] = None
+
+
+def render() -> None:
+	global LIP_SYNCER_MODEL_DROPDOWN
+	global LIP_SYNCER_WEIGHT_SLIDER
+
+	has_lip_syncer = 'lip_syncer' in state_manager.get_item('processors')
+	LIP_SYNCER_MODEL_DROPDOWN = gradio.Dropdown(
+		label = translator.get('uis.model_dropdown', 'facefusion.processors.modules.lip_syncer'),
+		choices = lip_syncer_choices.lip_syncer_models,
+		value = state_manager.get_item('lip_syncer_model'),
+		visible = has_lip_syncer
+	)
+	LIP_SYNCER_WEIGHT_SLIDER = gradio.Slider(
+		label = translator.get('uis.weight_slider', 'facefusion.processors.modules.lip_syncer'),
+		value = state_manager.get_item('lip_syncer_weight'),
+		step = calculate_float_step(lip_syncer_choices.lip_syncer_weight_range),
+		minimum = lip_syncer_choices.lip_syncer_weight_range[0],
+		maximum = lip_syncer_choices.lip_syncer_weight_range[-1],
+		visible = has_lip_syncer
+	)
+	register_ui_component('lip_syncer_model_dropdown', LIP_SYNCER_MODEL_DROPDOWN)
+	register_ui_component('lip_syncer_weight_slider', LIP_SYNCER_WEIGHT_SLIDER)
+
+
+def listen() -> None:
+	LIP_SYNCER_MODEL_DROPDOWN.change(update_lip_syncer_model, inputs = LIP_SYNCER_MODEL_DROPDOWN, outputs = LIP_SYNCER_MODEL_DROPDOWN)
+	LIP_SYNCER_WEIGHT_SLIDER.release(update_lip_syncer_weight, inputs = LIP_SYNCER_WEIGHT_SLIDER)
+
+	processors_checkbox_group = get_ui_component('processors_checkbox_group')
+	if processors_checkbox_group:
+		processors_checkbox_group.change(remote_update, inputs = processors_checkbox_group, outputs = [ LIP_SYNCER_MODEL_DROPDOWN, LIP_SYNCER_WEIGHT_SLIDER ])
+
+
+def remote_update(processors : List[str]) -> Tuple[gradio.Dropdown, gradio.Slider]:
+	has_lip_syncer = 'lip_syncer' in processors
+	return gradio.Dropdown(visible = has_lip_syncer), gradio.Slider(visible = has_lip_syncer)
+
+
+def update_lip_syncer_model(lip_syncer_model : LipSyncerModel) -> gradio.Dropdown:
+	lip_syncer_module = load_processor_module('lip_syncer')
+	lip_syncer_module.clear_inference_pool()
+	state_manager.set_item('lip_syncer_model', lip_syncer_model)
+
+	if lip_syncer_module.pre_check():
+		return gradio.Dropdown(value = state_manager.get_item('lip_syncer_model'))
+	return gradio.Dropdown()
+
+
+def update_lip_syncer_weight(lip_syncer_weight : LipSyncerWeight) -> None:
+	state_manager.set_item('lip_syncer_weight', lip_syncer_weight)

uis/components/memory.py

@@ -0,0 +1,27 @@
+from typing import Optional
+
+import gradio
+
+import facefusion.choices
+from facefusion import state_manager, translator
+from facefusion.types import VideoMemoryStrategy
+
+VIDEO_MEMORY_STRATEGY_DROPDOWN : Optional[gradio.Dropdown] = None
+
+
+def render() -> None:
+	global VIDEO_MEMORY_STRATEGY_DROPDOWN
+
+	VIDEO_MEMORY_STRATEGY_DROPDOWN = gradio.Dropdown(
+		label = translator.get('uis.video_memory_strategy_dropdown'),
+		choices = facefusion.choices.video_memory_strategies,
+		value = state_manager.get_item('video_memory_strategy')
+	)
+
+
+def listen() -> None:
+	VIDEO_MEMORY_STRATEGY_DROPDOWN.change(update_video_memory_strategy, inputs = VIDEO_MEMORY_STRATEGY_DROPDOWN)
+
+
+def update_video_memory_strategy(video_memory_strategy : VideoMemoryStrategy) -> None:
+	state_manager.set_item('video_memory_strategy', video_memory_strategy)

uis/components/output.py

@@ -0,0 +1,48 @@
+import tempfile
+from pathlib import Path
+from typing import Optional
+
+import gradio
+
+from facefusion import state_manager, translator
+from facefusion.uis.core import register_ui_component
+
+OUTPUT_PATH_TEXTBOX : Optional[gradio.Textbox] = None
+OUTPUT_IMAGE : Optional[gradio.Image] = None
+OUTPUT_VIDEO : Optional[gradio.Video] = None
+
+
+def render() -> None:
+	global OUTPUT_PATH_TEXTBOX
+	global OUTPUT_IMAGE
+	global OUTPUT_VIDEO
+
+	if not state_manager.get_item('output_path'):
+		documents_directory = Path.home().joinpath('Documents')
+
+		if documents_directory.exists():
+			state_manager.set_item('output_path', documents_directory)
+		else:
+			state_manager.set_item('output_path', tempfile.gettempdir())
+	OUTPUT_PATH_TEXTBOX = gradio.Textbox(
+		label = translator.get('uis.output_path_textbox'),
+		value = state_manager.get_item('output_path'),
+		max_lines = 1
+	)
+	OUTPUT_IMAGE = gradio.Image(
+		label = translator.get('uis.output_image_or_video'),
+		visible = False
+	)
+	OUTPUT_VIDEO = gradio.Video(
+		label = translator.get('uis.output_image_or_video')
+	)
+
+
+def listen() -> None:
+	OUTPUT_PATH_TEXTBOX.change(update_output_path, inputs = OUTPUT_PATH_TEXTBOX)
+	register_ui_component('output_image', OUTPUT_IMAGE)
+	register_ui_component('output_video', OUTPUT_VIDEO)
+
+
+def update_output_path(output_path : str) -> None:
+	state_manager.set_item('output_path', output_path)

uis/components/output_options.py

@@ -0,0 +1,184 @@
+from typing import Optional, Tuple
+
+import gradio
+
+import facefusion.choices
+from facefusion import state_manager, translator
+from facefusion.common_helper import calculate_float_step, calculate_int_step
+from facefusion.ffmpeg import get_available_encoder_set
+from facefusion.filesystem import is_image, is_video
+from facefusion.types import AudioEncoder, Fps, Scale, VideoEncoder, VideoPreset
+from facefusion.uis.core import get_ui_components, register_ui_component
+from facefusion.vision import detect_video_fps
+
+OUTPUT_IMAGE_QUALITY_SLIDER : Optional[gradio.Slider] = None
+OUTPUT_IMAGE_SCALE_SLIDER : Optional[gradio.Slider] = None
+OUTPUT_AUDIO_ENCODER_DROPDOWN : Optional[gradio.Dropdown] = None
+OUTPUT_AUDIO_QUALITY_SLIDER : Optional[gradio.Slider] = None
+OUTPUT_AUDIO_VOLUME_SLIDER : Optional[gradio.Slider] = None
+OUTPUT_VIDEO_ENCODER_DROPDOWN : Optional[gradio.Dropdown] = None
+OUTPUT_VIDEO_PRESET_DROPDOWN : Optional[gradio.Dropdown] = None
+OUTPUT_VIDEO_SCALE_SLIDER : Optional[gradio.Slider] = None
+OUTPUT_VIDEO_QUALITY_SLIDER : Optional[gradio.Slider] = None
+OUTPUT_VIDEO_FPS_SLIDER : Optional[gradio.Slider] = None
+
+
+def render() -> None:
+	global OUTPUT_IMAGE_QUALITY_SLIDER
+	global OUTPUT_IMAGE_SCALE_SLIDER
+	global OUTPUT_AUDIO_ENCODER_DROPDOWN
+	global OUTPUT_AUDIO_QUALITY_SLIDER
+	global OUTPUT_AUDIO_VOLUME_SLIDER
+	global OUTPUT_VIDEO_ENCODER_DROPDOWN
+	global OUTPUT_VIDEO_PRESET_DROPDOWN
+	global OUTPUT_VIDEO_SCALE_SLIDER
+	global OUTPUT_VIDEO_QUALITY_SLIDER
+	global OUTPUT_VIDEO_FPS_SLIDER
+
+	available_encoder_set = get_available_encoder_set()
+
+	OUTPUT_IMAGE_QUALITY_SLIDER = gradio.Slider(
+		label = translator.get('uis.output_image_quality_slider'),
+		value = state_manager.get_item('output_image_quality'),
+		step = calculate_int_step(facefusion.choices.output_image_quality_range),
+		minimum = facefusion.choices.output_image_quality_range[0],
+		maximum = facefusion.choices.output_image_quality_range[-1],
+		visible = is_image(state_manager.get_item('target_path'))
+	)
+	OUTPUT_IMAGE_SCALE_SLIDER = gradio.Slider(
+		label = translator.get('uis.output_image_scale_slider'),
+		step = calculate_float_step(facefusion.choices.output_image_scale_range),
+		value = state_manager.get_item('output_image_scale'),
+		minimum = facefusion.choices.output_image_scale_range[0],
+		maximum = facefusion.choices.output_image_scale_range[-1],
+		visible = is_image(state_manager.get_item('target_path'))
+	)
+	OUTPUT_AUDIO_ENCODER_DROPDOWN = gradio.Dropdown(
+		label = translator.get('uis.output_audio_encoder_dropdown'),
+		choices = available_encoder_set.get('audio'),
+		value = state_manager.get_item('output_audio_encoder'),
+		visible = is_video(state_manager.get_item('target_path'))
+	)
+	OUTPUT_AUDIO_QUALITY_SLIDER = gradio.Slider(
+		label = translator.get('uis.output_audio_quality_slider'),
+		value = state_manager.get_item('output_audio_quality'),
+		step = calculate_int_step(facefusion.choices.output_audio_quality_range),
+		minimum = facefusion.choices.output_audio_quality_range[0],
+		maximum = facefusion.choices.output_audio_quality_range[-1],
+		visible = is_video(state_manager.get_item('target_path'))
+	)
+	OUTPUT_AUDIO_VOLUME_SLIDER = gradio.Slider(
+		label = translator.get('uis.output_audio_volume_slider'),
+		value = state_manager.get_item('output_audio_volume'),
+		step = calculate_int_step(facefusion.choices.output_audio_volume_range),
+		minimum = facefusion.choices.output_audio_volume_range[0],
+		maximum = facefusion.choices.output_audio_volume_range[-1],
+		visible = is_video(state_manager.get_item('target_path'))
+	)
+	OUTPUT_VIDEO_ENCODER_DROPDOWN = gradio.Dropdown(
+		label = translator.get('uis.output_video_encoder_dropdown'),
+		choices = available_encoder_set.get('video'),
+		value = state_manager.get_item('output_video_encoder'),
+		visible = is_video(state_manager.get_item('target_path'))
+	)
+	OUTPUT_VIDEO_PRESET_DROPDOWN = gradio.Dropdown(
+		label = translator.get('uis.output_video_preset_dropdown'),
+		choices = facefusion.choices.output_video_presets,
+		value = state_manager.get_item('output_video_preset'),
+		visible = is_video(state_manager.get_item('target_path'))
+	)
+	OUTPUT_VIDEO_QUALITY_SLIDER = gradio.Slider(
+		label = translator.get('uis.output_video_quality_slider'),
+		value = state_manager.get_item('output_video_quality'),
+		step = calculate_int_step(facefusion.choices.output_video_quality_range),
+		minimum = facefusion.choices.output_video_quality_range[0],
+		maximum = facefusion.choices.output_video_quality_range[-1],
+		visible = is_video(state_manager.get_item('target_path'))
+	)
+	OUTPUT_VIDEO_SCALE_SLIDER = gradio.Slider(
+		label = translator.get('uis.output_video_scale_slider'),
+		step = calculate_float_step(facefusion.choices.output_video_scale_range),
+		value = state_manager.get_item('output_video_scale'),
+		minimum = facefusion.choices.output_video_scale_range[0],
+		maximum = facefusion.choices.output_video_scale_range[-1],
+		visible = is_video(state_manager.get_item('target_path'))
+	)
+	OUTPUT_VIDEO_FPS_SLIDER = gradio.Slider(
+		label = translator.get('uis.output_video_fps_slider'),
+		value = state_manager.get_item('output_video_fps'),
+		step = 0.01,
+		minimum = 1,
+		maximum = 60,
+		visible = is_video(state_manager.get_item('target_path'))
+	)
+	register_ui_component('output_video_fps_slider', OUTPUT_VIDEO_FPS_SLIDER)
+
+
+def listen() -> None:
+	OUTPUT_IMAGE_QUALITY_SLIDER.release(update_output_image_quality, inputs = OUTPUT_IMAGE_QUALITY_SLIDER)
+	OUTPUT_IMAGE_SCALE_SLIDER.release(update_output_image_scale, inputs = OUTPUT_IMAGE_SCALE_SLIDER)
+	OUTPUT_AUDIO_ENCODER_DROPDOWN.change(update_output_audio_encoder, inputs = OUTPUT_AUDIO_ENCODER_DROPDOWN)
+	OUTPUT_AUDIO_QUALITY_SLIDER.release(update_output_audio_quality, inputs = OUTPUT_AUDIO_QUALITY_SLIDER)
+	OUTPUT_AUDIO_VOLUME_SLIDER.release(update_output_audio_volume, inputs = OUTPUT_AUDIO_VOLUME_SLIDER)
+	OUTPUT_VIDEO_ENCODER_DROPDOWN.change(update_output_video_encoder, inputs = OUTPUT_VIDEO_ENCODER_DROPDOWN)
+	OUTPUT_VIDEO_PRESET_DROPDOWN.change(update_output_video_preset, inputs = OUTPUT_VIDEO_PRESET_DROPDOWN)
+	OUTPUT_VIDEO_QUALITY_SLIDER.release(update_output_video_quality, inputs = OUTPUT_VIDEO_QUALITY_SLIDER)
+	OUTPUT_VIDEO_SCALE_SLIDER.release(update_output_video_scale, inputs = OUTPUT_VIDEO_SCALE_SLIDER)
+	OUTPUT_VIDEO_FPS_SLIDER.release(update_output_video_fps, inputs = OUTPUT_VIDEO_FPS_SLIDER)
+
+	for ui_component in get_ui_components(
+	[
+		'target_image',
+		'target_video'
+	]):
+		for method in [ 'change', 'clear' ]:
+			getattr(ui_component, method)(remote_update, outputs = [ OUTPUT_IMAGE_QUALITY_SLIDER, OUTPUT_IMAGE_SCALE_SLIDER, OUTPUT_AUDIO_ENCODER_DROPDOWN, OUTPUT_AUDIO_QUALITY_SLIDER, OUTPUT_AUDIO_VOLUME_SLIDER, OUTPUT_VIDEO_ENCODER_DROPDOWN, OUTPUT_VIDEO_PRESET_DROPDOWN, OUTPUT_VIDEO_QUALITY_SLIDER, OUTPUT_VIDEO_SCALE_SLIDER, OUTPUT_VIDEO_FPS_SLIDER ])
+
+
+def remote_update() -> Tuple[gradio.Slider, gradio.Slider, gradio.Dropdown, gradio.Slider, gradio.Slider, gradio.Dropdown, gradio.Dropdown, gradio.Slider, gradio.Slider, gradio.Slider]:
+	if is_image(state_manager.get_item('target_path')):
+		return gradio.Slider(visible = True), gradio.Slider(visible = True), gradio.Dropdown(visible = False), gradio.Slider(visible = False), gradio.Slider(visible = False), gradio.Dropdown(visible = False), gradio.Dropdown(visible = False), gradio.Slider(visible = False), gradio.Slider(visible = False), gradio.Slider(visible = False)
+	if is_video(state_manager.get_item('target_path')):
+		state_manager.set_item('output_video_fps', detect_video_fps(state_manager.get_item('target_path')))
+		return gradio.Slider(visible = False), gradio.Slider(visible = False), gradio.Dropdown(visible = True), gradio.Slider(visible = True), gradio.Slider(visible = True), gradio.Dropdown(visible = True), gradio.Dropdown(visible = True), gradio.Slider(visible = True), gradio.Slider(visible = True), gradio.Slider(value = state_manager.get_item('output_video_fps'), visible = True)
+	return gradio.Slider(visible = False), gradio.Slider(visible = False), gradio.Dropdown(visible = False), gradio.Slider(visible = False), gradio.Slider(visible = False), gradio.Dropdown(visible = False), gradio.Dropdown(visible = False), gradio.Slider(visible = False), gradio.Slider(visible = False), gradio.Slider(visible = False)
+
+
+def update_output_image_quality(output_image_quality : float) -> None:
+	state_manager.set_item('output_image_quality', int(output_image_quality))
+
+
+def update_output_image_scale(output_image_scale : Scale) -> None:
+	state_manager.set_item('output_image_scale', output_image_scale)
+
+
+def update_output_audio_encoder(output_audio_encoder : AudioEncoder) -> None:
+	state_manager.set_item('output_audio_encoder', output_audio_encoder)
+
+
+def update_output_audio_quality(output_audio_quality : float) -> None:
+	state_manager.set_item('output_audio_quality', int(output_audio_quality))
+
+
+def update_output_audio_volume(output_audio_volume: float) -> None:
+	state_manager.set_item('output_audio_volume', int(output_audio_volume))
+
+
+def update_output_video_encoder(output_video_encoder : VideoEncoder) -> None:
+	state_manager.set_item('output_video_encoder', output_video_encoder)
+
+
+def update_output_video_preset(output_video_preset : VideoPreset) -> None:
+	state_manager.set_item('output_video_preset', output_video_preset)
+
+
+def update_output_video_quality(output_video_quality : float) -> None:
+	state_manager.set_item('output_video_quality', int(output_video_quality))
+
+
+def update_output_video_scale(output_video_scale : Scale) -> None:
+	state_manager.set_item('output_video_scale', output_video_scale)
+
+
+def update_output_video_fps(output_video_fps : Fps) -> None:
+	state_manager.set_item('output_video_fps', output_video_fps)

uis/components/preview.py

@@ -0,0 +1,306 @@
+from time import sleep
+from typing import List, Optional, Tuple
+
+import cv2
+import gradio
+import numpy
+
+from facefusion import logger, process_manager, state_manager, translator
+from facefusion.audio import create_empty_audio_frame, get_voice_frame
+from facefusion.common_helper import get_first, get_middle
+from facefusion.content_analyser import analyse_frame
+from facefusion.face_creator import get_one_face
+from facefusion.face_selector import select_faces
+from facefusion.face_store import clear_faces
+from facefusion.filesystem import filter_audio_paths, is_image, is_video
+from facefusion.processors.core import get_processors_modules
+from facefusion.types import AudioFrame, Face, Mask, VisionFrame
+from facefusion.uis import choices as uis_choices
+from facefusion.uis.core import get_ui_component, get_ui_components, register_ui_component
+from facefusion.uis.types import ComponentOptions, PreviewMode
+from facefusion.vision import detect_frame_orientation, extract_vision_mask, fit_cover_frame, is_vision_frame, merge_vision_mask, obscure_frame, read_static_image, read_static_images, read_video_frame, restrict_frame, select_video_frames, unpack_resolution
+
+PREVIEW_IMAGE : Optional[gradio.Image] = None
+
+
+def render() -> None:
+	global PREVIEW_IMAGE
+
+	preview_image_options : ComponentOptions =\
+	{
+		'label': translator.get('uis.preview_image')
+	}
+
+	source_vision_frames = read_static_images(state_manager.get_item('source_paths'))
+	source_audio_path = get_first(filter_audio_paths(state_manager.get_item('source_paths')))
+	source_audio_frame = create_empty_audio_frame()
+	source_voice_frame = create_empty_audio_frame()
+
+	if source_audio_path and state_manager.get_item('output_video_fps'):
+		temp_voice_frame = get_voice_frame(source_audio_path, state_manager.get_item('output_video_fps'), state_manager.get_item('reference_frame_number'))
+		if numpy.any(temp_voice_frame):
+			source_voice_frame = temp_voice_frame
+
+	if is_image(state_manager.get_item('target_path')):
+		target_vision_frame = read_static_image(state_manager.get_item('target_path'))
+		reference_vision_frame = read_static_image(state_manager.get_item('target_path'))
+		preview_vision_frame = process_preview_frame(reference_vision_frame, source_vision_frames, source_audio_frame, source_voice_frame, [ target_vision_frame ], uis_choices.preview_modes[0], uis_choices.preview_resolutions[-1])
+		preview_image_options['value'] = cv2.cvtColor(preview_vision_frame, cv2.COLOR_BGR2RGB)
+		preview_image_options['elem_classes'] = [ 'image-preview', 'is-' + detect_frame_orientation(preview_vision_frame) ]
+
+	if is_video(state_manager.get_item('target_path')):
+		reference_vision_frame = read_video_frame(state_manager.get_item('target_path'), state_manager.get_item('reference_frame_number'))
+		target_vision_frames = select_video_frames(state_manager.get_item('target_path'), state_manager.get_item('reference_frame_number'), state_manager.get_item('target_frame_amount'))
+		preview_vision_frame = process_preview_frame(reference_vision_frame, source_vision_frames, source_audio_frame, source_voice_frame, target_vision_frames, uis_choices.preview_modes[0], uis_choices.preview_resolutions[-1])
+		preview_image_options['value'] = cv2.cvtColor(preview_vision_frame, cv2.COLOR_BGR2RGB)
+		preview_image_options['elem_classes'] = [ 'image-preview', 'is-' + detect_frame_orientation(preview_vision_frame) ]
+		preview_image_options['visible'] = True
+	PREVIEW_IMAGE = gradio.Image(**preview_image_options)
+	register_ui_component('preview_image', PREVIEW_IMAGE)
+
+
+def listen() -> None:
+	preview_frame_slider = get_ui_component('preview_frame_slider')
+	preview_mode_dropdown = get_ui_component('preview_mode_dropdown')
+	preview_resolution_dropdown = get_ui_component('preview_resolution_dropdown')
+
+	if preview_mode_dropdown:
+		preview_mode_dropdown.change(update_preview_image, inputs = [ preview_mode_dropdown, preview_resolution_dropdown, preview_frame_slider ], outputs = PREVIEW_IMAGE)
+
+	if preview_resolution_dropdown:
+		preview_resolution_dropdown.change(update_preview_image, inputs = [ preview_mode_dropdown, preview_resolution_dropdown, preview_frame_slider ], outputs = PREVIEW_IMAGE)
+
+	if preview_frame_slider:
+		preview_frame_slider.release(update_preview_image, inputs = [ preview_mode_dropdown, preview_resolution_dropdown, preview_frame_slider ], outputs = PREVIEW_IMAGE, show_progress = 'hidden')
+		preview_frame_slider.change(update_preview_image, inputs = [ preview_mode_dropdown, preview_resolution_dropdown, preview_frame_slider ], outputs = PREVIEW_IMAGE, show_progress = 'hidden', trigger_mode = 'once')
+
+		reference_face_position_gallery = get_ui_component('reference_face_position_gallery')
+		if reference_face_position_gallery:
+			reference_face_position_gallery.select(clear_and_update_preview_image, inputs = [ preview_mode_dropdown, preview_resolution_dropdown, preview_frame_slider ], outputs = PREVIEW_IMAGE)
+
+	for ui_component in get_ui_components(
+	[
+		'source_audio',
+		'source_image',
+		'target_image',
+		'target_video'
+	]):
+		for method in [ 'change', 'clear' ]:
+			getattr(ui_component, method)(update_preview_image, inputs = [ preview_mode_dropdown, preview_resolution_dropdown, preview_frame_slider ], outputs = PREVIEW_IMAGE)
+
+	for ui_component in get_ui_components(
+	[
+		'background_remover_fill_color_red_number',
+		'background_remover_fill_color_green_number',
+		'background_remover_fill_color_blue_number',
+		'background_remover_fill_color_alpha_number',
+		'background_remover_despill_color_red_number',
+		'background_remover_despill_color_green_number',
+		'background_remover_despill_color_blue_number',
+		'background_remover_despill_color_alpha_number',
+		'face_debugger_items_checkbox_group',
+		'frame_colorizer_size_dropdown',
+		'face_mask_types_checkbox_group',
+		'face_mask_areas_checkbox_group',
+		'face_mask_regions_checkbox_group',
+		'expression_restorer_areas_checkbox_group'
+	]):
+		ui_component.change(update_preview_image, inputs = [ preview_mode_dropdown, preview_resolution_dropdown, preview_frame_slider ], outputs = PREVIEW_IMAGE)
+
+	for ui_component in get_ui_components(
+	[
+		'age_modifier_direction_slider',
+		'deep_swapper_morph_slider',
+		'expression_restorer_factor_slider',
+		'face_editor_eyebrow_direction_slider',
+		'face_editor_eye_gaze_horizontal_slider',
+		'face_editor_eye_gaze_vertical_slider',
+		'face_editor_eye_open_ratio_slider',
+		'face_editor_lip_open_ratio_slider',
+		'face_editor_mouth_grim_slider',
+		'face_editor_mouth_pout_slider',
+		'face_editor_mouth_purse_slider',
+		'face_editor_mouth_smile_slider',
+		'face_editor_mouth_position_horizontal_slider',
+		'face_editor_mouth_position_vertical_slider',
+		'face_editor_head_pitch_slider',
+		'face_editor_head_yaw_slider',
+		'face_editor_head_roll_slider',
+		'face_enhancer_blend_slider',
+		'face_enhancer_weight_slider',
+		'face_swapper_weight_slider',
+		'frame_colorizer_blend_slider',
+		'frame_enhancer_blend_slider',
+		'lip_syncer_weight_slider',
+		'reference_face_distance_slider',
+		'face_selector_age_range_slider',
+		'face_tracker_score_slider',
+		'face_mask_blur_slider',
+		'face_mask_padding_top_slider',
+		'face_mask_padding_bottom_slider',
+		'face_mask_padding_left_slider',
+		'face_mask_padding_right_slider',
+		'output_video_fps_slider'
+	]):
+		ui_component.release(update_preview_image, inputs = [ preview_mode_dropdown, preview_resolution_dropdown, preview_frame_slider ], outputs = PREVIEW_IMAGE)
+
+	for ui_component in get_ui_components(
+	[
+		'age_modifier_model_dropdown',
+		'background_remover_model_dropdown',
+		'deep_swapper_model_dropdown',
+		'expression_restorer_model_dropdown',
+		'processors_checkbox_group',
+		'face_editor_model_dropdown',
+		'face_enhancer_model_dropdown',
+		'face_swapper_model_dropdown',
+		'face_swapper_pixel_boost_dropdown',
+		'frame_colorizer_model_dropdown',
+		'frame_enhancer_model_dropdown',
+		'lip_syncer_model_dropdown',
+		'face_selector_mode_dropdown',
+		'face_selector_order_dropdown',
+		'face_selector_gender_dropdown',
+		'face_selector_race_dropdown',
+		'face_detector_model_dropdown',
+		'face_detector_size_dropdown',
+		'face_detector_angles_checkbox_group',
+		'face_landmarker_model_dropdown',
+		'face_occluder_model_dropdown',
+		'face_parser_model_dropdown',
+		'voice_extractor_model_dropdown'
+	]):
+		ui_component.change(clear_and_update_preview_image, inputs = [ preview_mode_dropdown, preview_resolution_dropdown, preview_frame_slider ], outputs = PREVIEW_IMAGE)
+
+	for ui_component in get_ui_components(
+	[
+		'face_detector_margin_slider',
+		'face_detector_score_slider',
+		'face_landmarker_score_slider'
+	]):
+		ui_component.release(clear_and_update_preview_image, inputs = [ preview_mode_dropdown, preview_resolution_dropdown, preview_frame_slider ], outputs = PREVIEW_IMAGE)
+
+
+def update_preview_image(preview_mode : PreviewMode, preview_resolution : str, frame_number : int = 0) -> gradio.Image:
+	while process_manager.is_checking():
+		sleep(0.5)
+
+	source_vision_frames = read_static_images(state_manager.get_item('source_paths'))
+	source_audio_path = get_first(filter_audio_paths(state_manager.get_item('source_paths')))
+	source_audio_frame = create_empty_audio_frame()
+	source_voice_frame = create_empty_audio_frame()
+
+	if source_audio_path and state_manager.get_item('output_video_fps'):
+		audio_frame_number = frame_number
+		if state_manager.get_item('trim_frame_start'):
+			audio_frame_number -= state_manager.get_item('trim_frame_start')
+		temp_voice_frame = get_voice_frame(source_audio_path, state_manager.get_item('output_video_fps'), audio_frame_number)
+		if numpy.any(temp_voice_frame):
+			source_voice_frame = temp_voice_frame
+
+	if is_image(state_manager.get_item('target_path')):
+		reference_vision_frame = read_static_image(state_manager.get_item('target_path'))
+		target_vision_frame = read_static_image(state_manager.get_item('target_path'), 'rgba')
+		preview_vision_frame = process_preview_frame(reference_vision_frame, source_vision_frames, source_audio_frame, source_voice_frame, [ target_vision_frame ], preview_mode, preview_resolution)
+		preview_vision_frame = cv2.cvtColor(preview_vision_frame, cv2.COLOR_BGRA2RGBA)
+		return gradio.Image(value = preview_vision_frame, elem_classes = [ 'image-preview', 'is-' + detect_frame_orientation(preview_vision_frame) ])
+
+	if is_video(state_manager.get_item('target_path')):
+		reference_vision_frame = read_video_frame(state_manager.get_item('target_path'), state_manager.get_item('reference_frame_number'))
+		target_vision_frames = select_video_frames(state_manager.get_item('target_path'), frame_number, state_manager.get_item('target_frame_amount'))
+		preview_vision_frame = process_preview_frame(reference_vision_frame, source_vision_frames, source_audio_frame, source_voice_frame, target_vision_frames, preview_mode, preview_resolution)
+		preview_vision_frame = cv2.cvtColor(preview_vision_frame, cv2.COLOR_BGRA2RGBA)
+		return gradio.Image(value = preview_vision_frame, elem_classes = [ 'image-preview', 'is-' + detect_frame_orientation(preview_vision_frame) ])
+	return gradio.Image(value = None, elem_classes = None)
+
+
+def clear_and_update_preview_image(preview_mode : PreviewMode, preview_resolution : str, frame_number : int = 0) -> gradio.Image:
+	clear_faces()
+	return update_preview_image(preview_mode, preview_resolution, frame_number)
+
+
+def process_preview_frame(reference_vision_frame : VisionFrame, source_vision_frames : List[VisionFrame], source_audio_frame : AudioFrame, source_voice_frame : AudioFrame, target_vision_frames : List[VisionFrame], preview_mode : PreviewMode, preview_resolution : str) -> VisionFrame:
+	target_vision_frame = get_middle(target_vision_frames)
+	target_vision_frame = restrict_frame(target_vision_frame, unpack_resolution(preview_resolution))
+	temp_vision_mask = extract_vision_mask(target_vision_frame)
+	target_vision_frame = merge_vision_mask(target_vision_frame, temp_vision_mask)
+	target_vision_frames = [ restrict_frame(vision_frame, unpack_resolution(preview_resolution))[:, :, :3] for vision_frame in target_vision_frames ]
+	temp_vision_frame = target_vision_frame.copy()
+
+	if analyse_frame(target_vision_frame[:, :, :3]):
+		if preview_mode == 'frame-by-frame':
+			temp_vision_frame = obscure_frame(temp_vision_frame[:, :, :3])
+			return numpy.hstack((temp_vision_frame, temp_vision_frame))
+
+		if preview_mode == 'face-by-face':
+			target_crop_vision_frame, output_crop_vision_frame = create_face_by_face(reference_vision_frame, source_vision_frames, target_vision_frame[:, :, :3], temp_vision_frame[:, :, :3])
+			target_crop_vision_frame = obscure_frame(target_crop_vision_frame)
+			output_crop_vision_frame = obscure_frame(output_crop_vision_frame)
+			return numpy.hstack((target_crop_vision_frame, output_crop_vision_frame))
+
+		temp_vision_frame = obscure_frame(temp_vision_frame)
+		return temp_vision_frame
+
+	for processor_module in get_processors_modules(state_manager.get_item('processors')):
+		logger.disable()
+		if processor_module.pre_process('preview'):
+			logger.enable()
+			temp_vision_frame, temp_vision_mask = processor_module.process_frame(
+			{
+				'reference_vision_frame': reference_vision_frame,
+				'source_audio_frame': source_audio_frame,
+				'source_voice_frame': source_voice_frame,
+				'source_vision_frames': source_vision_frames,
+				'target_vision_frames': target_vision_frames,
+				'temp_vision_frame': temp_vision_frame[:, :, :3],
+				'temp_vision_mask': temp_vision_mask
+			})
+		logger.enable()
+
+	temp_vision_frame = prepare_output_frame(target_vision_frame, temp_vision_frame, temp_vision_mask)
+
+	if preview_mode == 'frame-by-frame':
+		return numpy.hstack((target_vision_frame, temp_vision_frame))
+
+	if preview_mode == 'face-by-face':
+		target_crop_vision_frame, output_crop_vision_frame = create_face_by_face(reference_vision_frame, source_vision_frames, target_vision_frame, temp_vision_frame)
+		return numpy.hstack((target_crop_vision_frame, output_crop_vision_frame))
+
+	return temp_vision_frame
+
+
+def create_face_by_face(reference_vision_frame : VisionFrame, source_vision_frames : List[VisionFrame], target_vision_frame : VisionFrame, temp_vision_frame : VisionFrame) -> Tuple[VisionFrame, VisionFrame]:
+	target_faces = select_faces(reference_vision_frame[:, :, :3], source_vision_frames, [ target_vision_frame[:, :, :3] ])
+	target_face = get_one_face(target_faces)
+
+	if target_face:
+		target_crop_vision_frame = extract_crop_frame(target_vision_frame, target_face)
+		output_crop_vision_frame = extract_crop_frame(temp_vision_frame, target_face)
+
+		if is_vision_frame(target_crop_vision_frame) and is_vision_frame(output_crop_vision_frame):
+			target_crop_dimension = min(target_crop_vision_frame.shape[:2])
+			target_crop_vision_frame = fit_cover_frame(target_crop_vision_frame, (target_crop_dimension, target_crop_dimension))
+			output_crop_vision_frame = fit_cover_frame(output_crop_vision_frame, (target_crop_dimension, target_crop_dimension))
+			return target_crop_vision_frame, output_crop_vision_frame
+
+	empty_vision_frame = numpy.zeros((512, 512, 4), dtype = numpy.uint8)
+	return empty_vision_frame, empty_vision_frame
+
+
+def extract_crop_frame(vision_frame : VisionFrame, face : Face) -> Optional[VisionFrame]:
+	start_x, start_y, end_x, end_y = map(int, face.bounding_box)
+	padding_x = int((end_x - start_x) * 0.25)
+	padding_y = int((end_y - start_y) * 0.25)
+	start_x = max(0, start_x - padding_x)
+	start_y = max(0, start_y - padding_y)
+	end_x = max(0, end_x + padding_x)
+	end_y = max(0, end_y + padding_y)
+	crop_vision_frame = vision_frame[start_y:end_y, start_x:end_x]
+	return crop_vision_frame
+
+
+def prepare_output_frame(target_vision_frame : VisionFrame, temp_vision_frame : VisionFrame, temp_vision_mask : Mask) -> VisionFrame:
+	temp_vision_mask = temp_vision_mask.clip(state_manager.get_item('background_remover_fill_color')[-1], 255)
+	temp_vision_frame = merge_vision_mask(temp_vision_frame, temp_vision_mask)
+	temp_vision_frame = cv2.resize(temp_vision_frame, target_vision_frame.shape[1::-1])
+	return temp_vision_frame

uis/components/preview_options.py

@@ -0,0 +1,62 @@
+from typing import Optional
+
+import gradio
+
+from facefusion import state_manager, translator
+from facefusion.filesystem import is_video
+from facefusion.uis import choices as uis_choices
+from facefusion.uis.core import get_ui_components, register_ui_component
+from facefusion.uis.types import ComponentOptions
+from facefusion.vision import count_video_frame_total
+
+PREVIEW_FRAME_SLIDER: Optional[gradio.Slider] = None
+PREVIEW_MODE_DROPDOWN: Optional[gradio.Dropdown] = None
+PREVIEW_RESOLUTION_DROPDOWN: Optional[gradio.Dropdown] = None
+
+
+def render() -> None:
+	global PREVIEW_FRAME_SLIDER, PREVIEW_MODE_DROPDOWN, PREVIEW_RESOLUTION_DROPDOWN
+
+	preview_frame_slider_options : ComponentOptions =\
+	{
+		'label': translator.get('uis.preview_frame_slider'),
+		'step': 1,
+		'minimum': 0,
+		'maximum': 100,
+		'visible': False
+	}
+	if is_video(state_manager.get_item('target_path')):
+		video_frame_total = count_video_frame_total(state_manager.get_item('target_path'))
+		preview_frame_slider_options['value'] = state_manager.get_item('reference_frame_number')
+		preview_frame_slider_options['maximum'] = video_frame_total - 1
+		preview_frame_slider_options['visible'] = True
+	PREVIEW_FRAME_SLIDER = gradio.Slider(**preview_frame_slider_options)
+	with gradio.Row():
+		PREVIEW_MODE_DROPDOWN = gradio.Dropdown(
+			label = translator.get('uis.preview_mode_dropdown'),
+			value = uis_choices.preview_modes[0],
+			choices = uis_choices.preview_modes,
+			visible = True
+		)
+		PREVIEW_RESOLUTION_DROPDOWN = gradio.Dropdown(
+			label = translator.get('uis.preview_resolution_dropdown'),
+			value = uis_choices.preview_resolutions[-1],
+			choices = uis_choices.preview_resolutions,
+			visible = True
+		)
+	register_ui_component('preview_mode_dropdown', PREVIEW_MODE_DROPDOWN)
+	register_ui_component('preview_resolution_dropdown', PREVIEW_RESOLUTION_DROPDOWN)
+	register_ui_component('preview_frame_slider', PREVIEW_FRAME_SLIDER)
+
+
+def listen() -> None:
+	for ui_component in get_ui_components([ 'target_image', 'target_video' ]):
+		for method in [ 'change', 'clear' ]:
+			getattr(ui_component, method)(update_preview_frame_slider, outputs = PREVIEW_FRAME_SLIDER)
+
+
+def update_preview_frame_slider() -> gradio.Slider:
+	if is_video(state_manager.get_item('target_path')):
+		video_frame_total = count_video_frame_total(state_manager.get_item('target_path'))
+		return gradio.Slider(maximum = video_frame_total - 1, visible = True)
+	return gradio.Slider(value = 0, visible = False)

uis/components/processors.py

@@ -0,0 +1,49 @@
+from typing import List, Optional
+
+import gradio
+
+from facefusion import state_manager, translator
+from facefusion.filesystem import get_file_name, resolve_file_paths
+from facefusion.processors.core import get_processors_modules
+from facefusion.uis.core import register_ui_component
+
+PROCESSORS_CHECKBOX_GROUP : Optional[gradio.CheckboxGroup] = None
+
+
+def render() -> None:
+	global PROCESSORS_CHECKBOX_GROUP
+
+	PROCESSORS_CHECKBOX_GROUP = gradio.CheckboxGroup(
+		label = translator.get('uis.processors_checkbox_group'),
+		choices = sort_processors(state_manager.get_item('processors')),
+		value = state_manager.get_item('processors')
+	)
+	register_ui_component('processors_checkbox_group', PROCESSORS_CHECKBOX_GROUP)
+
+
+def listen() -> None:
+	PROCESSORS_CHECKBOX_GROUP.change(update_processors, inputs = PROCESSORS_CHECKBOX_GROUP, outputs = PROCESSORS_CHECKBOX_GROUP)
+
+
+def update_processors(processors : List[str]) -> gradio.CheckboxGroup:
+	for processor_module in get_processors_modules(state_manager.get_item('processors')):
+		if hasattr(processor_module, 'clear_inference_pool'):
+			processor_module.clear_inference_pool()
+
+	for processor_module in get_processors_modules(processors):
+		if not processor_module.pre_check():
+			return gradio.CheckboxGroup()
+
+	state_manager.set_item('processors', processors)
+	return gradio.CheckboxGroup(value = state_manager.get_item('processors'), choices = sort_processors(state_manager.get_item('processors')))
+
+
+def sort_processors(processors : List[str]) -> List[str]:
+	available_processors = [ get_file_name(file_path) for file_path in resolve_file_paths('facefusion/processors/modules') ]
+	current_processors = []
+
+	for processor in processors + available_processors:
+		if processor in available_processors and processor not in current_processors:
+			current_processors.append(processor)
+
+	return current_processors

uis/components/source.py

@@ -0,0 +1,61 @@
+from typing import List, Optional, Tuple
+
+import gradio
+
+from facefusion import state_manager, translator
+from facefusion.common_helper import get_first
+from facefusion.filesystem import filter_audio_paths, filter_image_paths, has_audio, has_image
+from facefusion.uis.core import register_ui_component
+from facefusion.uis.types import File
+
+SOURCE_FILE : Optional[gradio.File] = None
+SOURCE_AUDIO : Optional[gradio.Audio] = None
+SOURCE_IMAGE : Optional[gradio.Image] = None
+
+
+def render() -> None:
+	global SOURCE_FILE
+	global SOURCE_AUDIO
+	global SOURCE_IMAGE
+
+	has_source_audio = has_audio(state_manager.get_item('source_paths'))
+	has_source_image = has_image(state_manager.get_item('source_paths'))
+	SOURCE_FILE = gradio.File(
+		label = translator.get('uis.source_file'),
+		file_count = 'multiple',
+		value = state_manager.get_item('source_paths') if has_source_audio or has_source_image else None
+	)
+	source_file_names = [ source_file_value.get('path') for source_file_value in SOURCE_FILE.value ] if SOURCE_FILE.value else None
+	source_audio_path = get_first(filter_audio_paths(source_file_names))
+	source_image_path = get_first(filter_image_paths(source_file_names))
+	SOURCE_AUDIO = gradio.Audio(
+		value = source_audio_path if has_source_audio else None,
+		visible = has_source_audio,
+		show_label = False
+	)
+	SOURCE_IMAGE = gradio.Image(
+		value = source_image_path if has_source_image else None,
+		visible = has_source_image,
+		show_label = False
+	)
+	register_ui_component('source_audio', SOURCE_AUDIO)
+	register_ui_component('source_image', SOURCE_IMAGE)
+
+
+def listen() -> None:
+	SOURCE_FILE.change(update, inputs = SOURCE_FILE, outputs = [ SOURCE_AUDIO, SOURCE_IMAGE ])
+
+
+def update(files : List[File]) -> Tuple[gradio.Audio, gradio.Image]:
+	file_names = [ file.name for file in files ] if files else None
+	has_source_audio = has_audio(file_names)
+	has_source_image = has_image(file_names)
+
+	if has_source_audio or has_source_image:
+		source_audio_path = get_first(filter_audio_paths(file_names))
+		source_image_path = get_first(filter_image_paths(file_names))
+		state_manager.set_item('source_paths', file_names)
+		return gradio.Audio(value = source_audio_path, visible = has_source_audio), gradio.Image(value = source_image_path, visible = has_source_image)
+
+	state_manager.clear_item('source_paths')
+	return gradio.Audio(value = None, visible = False), gradio.Image(value = None, visible = False)

uis/components/target.py

@@ -0,0 +1,65 @@
+from typing import Optional, Tuple
+
+import gradio
+
+from facefusion import state_manager, translator
+from facefusion.face_store import clear_faces
+from facefusion.filesystem import is_image, is_video
+from facefusion.uis.core import register_ui_component
+from facefusion.uis.types import ComponentOptions, File
+
+TARGET_FILE : Optional[gradio.File] = None
+TARGET_IMAGE : Optional[gradio.Image] = None
+TARGET_VIDEO : Optional[gradio.Video] = None
+
+
+def render() -> None:
+	global TARGET_FILE
+	global TARGET_IMAGE
+	global TARGET_VIDEO
+
+	is_target_image = is_image(state_manager.get_item('target_path'))
+	is_target_video = is_video(state_manager.get_item('target_path'))
+	TARGET_FILE = gradio.File(
+		label = translator.get('uis.target_file'),
+		value = state_manager.get_item('target_path') if is_target_image or is_target_video else None
+	)
+	target_image_options : ComponentOptions =\
+	{
+		'show_label': False,
+		'visible': False
+	}
+	target_video_options : ComponentOptions =\
+	{
+		'show_label': False,
+		'visible': False
+	}
+	if is_target_image:
+		target_image_options['value'] = TARGET_FILE.value.get('path')
+		target_image_options['visible'] = True
+	if is_target_video:
+		target_video_options['value'] = TARGET_FILE.value.get('path')
+		target_video_options['visible'] = True
+	TARGET_IMAGE = gradio.Image(**target_image_options)
+	TARGET_VIDEO = gradio.Video(**target_video_options)
+	register_ui_component('target_image', TARGET_IMAGE)
+	register_ui_component('target_video', TARGET_VIDEO)
+
+
+def listen() -> None:
+	TARGET_FILE.change(update, inputs = TARGET_FILE, outputs = [ TARGET_IMAGE, TARGET_VIDEO ])
+
+
+def update(file : File) -> Tuple[gradio.Image, gradio.Video]:
+	clear_faces()
+
+	if file and is_image(file.name):
+		state_manager.set_item('target_path', file.name)
+		return gradio.Image(value = file.name, visible = True), gradio.Video(value = None, visible = False)
+
+	if file and is_video(file.name):
+		state_manager.set_item('target_path', file.name)
+		return gradio.Image(value = None, visible = False), gradio.Video(value = file.name, visible = True)
+
+	state_manager.clear_item('target_path')
+	return gradio.Image(value = None, visible = False), gradio.Video(value = None, visible = False)

uis/components/temp_frame.py

@@ -0,0 +1,42 @@
+from typing import Optional
+
+import gradio
+
+import facefusion.choices
+from facefusion import state_manager, translator
+from facefusion.filesystem import is_video
+from facefusion.types import TempFrameFormat
+from facefusion.uis.core import get_ui_component
+
+TEMP_FRAME_FORMAT_DROPDOWN : Optional[gradio.Dropdown] = None
+
+
+def render() -> None:
+	global TEMP_FRAME_FORMAT_DROPDOWN
+
+	TEMP_FRAME_FORMAT_DROPDOWN = gradio.Dropdown(
+		label = translator.get('uis.temp_frame_format_dropdown'),
+		choices = facefusion.choices.temp_frame_formats,
+		value = state_manager.get_item('temp_frame_format'),
+		visible = is_video(state_manager.get_item('target_path'))
+	)
+
+
+def listen() -> None:
+	TEMP_FRAME_FORMAT_DROPDOWN.change(update_temp_frame_format, inputs = TEMP_FRAME_FORMAT_DROPDOWN)
+
+	target_video = get_ui_component('target_video')
+	if target_video:
+		for method in [ 'change', 'clear' ]:
+			getattr(target_video, method)(remote_update, outputs = TEMP_FRAME_FORMAT_DROPDOWN)
+
+
+def remote_update() -> gradio.Dropdown:
+	if is_video(state_manager.get_item('target_path')):
+		return gradio.Dropdown(visible = True)
+	return gradio.Dropdown(visible = False)
+
+
+def update_temp_frame_format(temp_frame_format : TempFrameFormat) -> None:
+	state_manager.set_item('temp_frame_format', temp_frame_format)
+

uis/components/terminal.py

@@ -0,0 +1,80 @@
+import io
+import logging
+import math
+import os
+from typing import Optional
+
+import gradio
+from tqdm import tqdm
+
+import facefusion.choices
+from facefusion import logger, state_manager, translator
+from facefusion.types import LogLevel
+
+LOG_LEVEL_DROPDOWN : Optional[gradio.Dropdown] = None
+TERMINAL_TEXTBOX : Optional[gradio.Textbox] = None
+LOG_BUFFER = io.StringIO()
+LOG_HANDLER = logging.StreamHandler(LOG_BUFFER)
+TQDM_UPDATE = tqdm.update
+
+
+def render() -> None:
+	global LOG_LEVEL_DROPDOWN
+	global TERMINAL_TEXTBOX
+
+	LOG_LEVEL_DROPDOWN = gradio.Dropdown(
+		label = translator.get('uis.log_level_dropdown'),
+		choices = facefusion.choices.log_levels,
+		value = state_manager.get_item('log_level')
+	)
+	TERMINAL_TEXTBOX = gradio.Textbox(
+		label = translator.get('uis.terminal_textbox'),
+		value = read_logs,
+		lines = 8,
+		max_lines = 8,
+		every = 0.5,
+		show_copy_button = True
+	)
+
+
+def listen() -> None:
+	LOG_LEVEL_DROPDOWN.change(update_log_level, inputs = LOG_LEVEL_DROPDOWN)
+	logger.get_package_logger().addHandler(LOG_HANDLER)
+	tqdm.update = tqdm_update
+
+
+def update_log_level(log_level : LogLevel) -> None:
+	state_manager.set_item('log_level', log_level)
+	logger.init(state_manager.get_item('log_level'))
+
+
+def tqdm_update(self : tqdm, n : int = 1) -> None:
+	TQDM_UPDATE(self, n)
+	output = create_tqdm_output(self)
+
+	if output:
+		LOG_BUFFER.seek(0)
+		log_buffer = LOG_BUFFER.read()
+		lines = log_buffer.splitlines()
+		if lines and lines[-1].startswith(self.desc):
+			position = log_buffer.rfind(lines[-1])
+			LOG_BUFFER.seek(position)
+		else:
+			LOG_BUFFER.seek(0, os.SEEK_END)
+		LOG_BUFFER.write(output + os.linesep)
+		LOG_BUFFER.flush()
+
+
+def create_tqdm_output(self : tqdm) -> Optional[str]:
+	if not self.disable and self.desc and self.total:
+		percentage = math.floor(self.n / self.total * 100)
+		return self.desc + translator.get('colon') + ' ' + str(percentage) + '% (' + str(self.n) + '/' + str(self.total) + ')'
+	if not self.disable and self.desc and self.unit:
+		return self.desc + translator.get('colon') + ' ' + str(self.n) + ' ' + self.unit
+	return None
+
+
+def read_logs() -> str:
+	LOG_BUFFER.seek(0)
+	logs = LOG_BUFFER.read().strip()
+	return logs

uis/components/trim_frame.py

@@ -0,0 +1,62 @@
+from typing import Optional, Tuple
+
+from gradio_rangeslider import RangeSlider
+
+from facefusion import state_manager, translator
+from facefusion.face_store import clear_faces
+from facefusion.filesystem import is_video
+from facefusion.uis.core import get_ui_components
+from facefusion.uis.types import ComponentOptions
+from facefusion.vision import count_video_frame_total
+
+TRIM_FRAME_RANGE_SLIDER : Optional[RangeSlider] = None
+
+
+def render() -> None:
+	global TRIM_FRAME_RANGE_SLIDER
+
+	trim_frame_range_slider_options : ComponentOptions =\
+	{
+		'label': translator.get('uis.trim_frame_slider'),
+		'minimum': 0,
+		'step': 1,
+		'visible': False
+	}
+	if is_video(state_manager.get_item('target_path')):
+		video_frame_total = count_video_frame_total(state_manager.get_item('target_path'))
+		trim_frame_start = state_manager.get_item('trim_frame_start') or 0
+		trim_frame_end = state_manager.get_item('trim_frame_end') or video_frame_total
+		trim_frame_range_slider_options['maximum'] = video_frame_total
+		trim_frame_range_slider_options['value'] = (trim_frame_start, trim_frame_end)
+		trim_frame_range_slider_options['visible'] = True
+	TRIM_FRAME_RANGE_SLIDER = RangeSlider(**trim_frame_range_slider_options)
+
+
+def listen() -> None:
+	TRIM_FRAME_RANGE_SLIDER.release(update_trim_frame, inputs = TRIM_FRAME_RANGE_SLIDER)
+	for ui_component in get_ui_components(
+	[
+		'target_image',
+		'target_video'
+	]):
+		for method in [ 'change', 'clear' ]:
+			getattr(ui_component, method)(remote_update, outputs = [ TRIM_FRAME_RANGE_SLIDER ])
+
+
+def remote_update() -> RangeSlider:
+	if is_video(state_manager.get_item('target_path')):
+		video_frame_total = count_video_frame_total(state_manager.get_item('target_path'))
+		state_manager.clear_item('trim_frame_start')
+		state_manager.clear_item('trim_frame_end')
+		return RangeSlider(value = (0, video_frame_total), maximum = video_frame_total, visible = True)
+	return RangeSlider(visible = False)
+
+
+def update_trim_frame(trim_frame : Tuple[float, float]) -> None:
+	clear_faces()
+	trim_frame_start, trim_frame_end = trim_frame
+	video_frame_total = count_video_frame_total(state_manager.get_item('target_path'))
+	trim_frame_start = int(trim_frame_start) if trim_frame_start > 0 else None
+	trim_frame_end = int(trim_frame_end) if trim_frame_end < video_frame_total else None
+	state_manager.set_item('trim_frame_start', trim_frame_start)
+	state_manager.set_item('trim_frame_end', trim_frame_end)

uis/components/ui_workflow.py

@@ -0,0 +1,21 @@
+from typing import Optional
+
+import gradio
+
+import facefusion
+from facefusion import state_manager, translator
+from facefusion.uis.core import register_ui_component
+
+UI_WORKFLOW_DROPDOWN : Optional[gradio.Dropdown] = None
+
+
+def render() -> None:
+	global UI_WORKFLOW_DROPDOWN
+
+	UI_WORKFLOW_DROPDOWN = gradio.Dropdown(
+		label = translator.get('uis.ui_workflow'),
+		choices = facefusion.choices.ui_workflows,
+		value = state_manager.get_item('ui_workflow'),
+		interactive = True
+	)
+	register_ui_component('ui_workflow_dropdown', UI_WORKFLOW_DROPDOWN)

uis/components/voice_extractor.py

@@ -0,0 +1,56 @@
+from typing import List, Optional
+
+import gradio
+
+import facefusion.choices
+from facefusion import state_manager, translator, voice_extractor
+from facefusion.filesystem import is_video
+from facefusion.types import VoiceExtractorModel
+from facefusion.uis.core import get_ui_component, get_ui_components, register_ui_component
+
+VOICE_EXTRACTOR_MODEL_DROPDOWN : Optional[gradio.Dropdown] = None
+
+
+def render() -> None:
+	global VOICE_EXTRACTOR_MODEL_DROPDOWN
+
+	has_lip_syncer = 'lip_syncer' in state_manager.get_item('processors')
+	VOICE_EXTRACTOR_MODEL_DROPDOWN = gradio.Dropdown(
+		label = translator.get('uis.voice_extractor_model_dropdown'),
+		choices = facefusion.choices.voice_extractor_models,
+		value = state_manager.get_item('voice_extractor_model'),
+		visible = is_video(state_manager.get_item('target_path')) and has_lip_syncer
+	)
+	register_ui_component('voice_extractor_model_dropdown', VOICE_EXTRACTOR_MODEL_DROPDOWN)
+
+
+def listen() -> None:
+	VOICE_EXTRACTOR_MODEL_DROPDOWN.change(update_voice_extractor_model, inputs = VOICE_EXTRACTOR_MODEL_DROPDOWN, outputs = VOICE_EXTRACTOR_MODEL_DROPDOWN)
+
+	processors_checkbox_group = get_ui_component('processors_checkbox_group')
+	if processors_checkbox_group:
+		processors_checkbox_group.change(remote_update, inputs = processors_checkbox_group, outputs = VOICE_EXTRACTOR_MODEL_DROPDOWN)
+
+		for ui_component in get_ui_components(
+		[
+			'target_image',
+			'target_video'
+		]):
+			for method in [ 'change', 'clear' ]:
+				getattr(ui_component, method)(remote_update, inputs = processors_checkbox_group, outputs = VOICE_EXTRACTOR_MODEL_DROPDOWN)
+
+
+def remote_update(processors : List[str]) -> gradio.Dropdown:
+	has_lip_syncer = 'lip_syncer' in processors
+	if is_video(state_manager.get_item('target_path')) and has_lip_syncer:
+		return gradio.Dropdown(visible = True)
+	return gradio.Dropdown(visible = False)
+
+
+def update_voice_extractor_model(voice_extractor_model : VoiceExtractorModel) -> gradio.Dropdown:
+	voice_extractor.clear_inference_pool()
+	state_manager.set_item('voice_extractor_model', voice_extractor_model)
+
+	if voice_extractor.pre_check():
+		gradio.Dropdown(value = state_manager.get_item('voice_extractor_model'))
+	return gradio.Dropdown()

uis/components/webcam.py

@@ -0,0 +1,116 @@
+from typing import Iterator, List, Optional, Tuple
+
+import cv2
+import gradio
+
+from facefusion import state_manager, translator
+from facefusion.camera_manager import clear_camera_pool, get_local_camera_capture
+from facefusion.filesystem import has_image
+from facefusion.streamer import multi_process_capture, open_stream
+from facefusion.types import Fps, VisionFrame, WebcamMode
+from facefusion.uis.core import get_ui_component
+from facefusion.uis.types import File
+from facefusion.vision import fit_cover_frame, unpack_resolution
+
+SOURCE_FILE : Optional[gradio.File] = None
+WEBCAM_IMAGE : Optional[gradio.Image] = None
+WEBCAM_START_BUTTON : Optional[gradio.Button] = None
+WEBCAM_STOP_BUTTON : Optional[gradio.Button] = None
+
+
+def render() -> None:
+	global SOURCE_FILE
+	global WEBCAM_IMAGE
+	global WEBCAM_START_BUTTON
+	global WEBCAM_STOP_BUTTON
+
+	has_source_image = has_image(state_manager.get_item('source_paths'))
+	SOURCE_FILE = gradio.File(
+		label = translator.get('uis.source_file'),
+		file_count = 'multiple',
+		value = state_manager.get_item('source_paths') if has_source_image else None
+	)
+	WEBCAM_IMAGE = gradio.Image(
+		label = translator.get('uis.webcam_image'),
+		format = 'jpeg',
+		visible = False
+	)
+	WEBCAM_START_BUTTON = gradio.Button(
+		value = translator.get('uis.start_button'),
+		variant = 'primary',
+		size = 'sm'
+	)
+	WEBCAM_STOP_BUTTON = gradio.Button(
+		value = translator.get('uis.stop_button'),
+		size = 'sm',
+		visible = False
+	)
+
+
+def listen() -> None:
+	SOURCE_FILE.change(update_source, inputs = SOURCE_FILE, outputs = SOURCE_FILE)
+	webcam_device_id_dropdown = get_ui_component('webcam_device_id_dropdown')
+	webcam_mode_radio = get_ui_component('webcam_mode_radio')
+	webcam_resolution_dropdown = get_ui_component('webcam_resolution_dropdown')
+	webcam_fps_slider = get_ui_component('webcam_fps_slider')
+
+	if webcam_device_id_dropdown and webcam_mode_radio and webcam_resolution_dropdown and webcam_fps_slider:
+		WEBCAM_START_BUTTON.click(pre_start, outputs = [ SOURCE_FILE, WEBCAM_IMAGE, WEBCAM_START_BUTTON, WEBCAM_STOP_BUTTON ])
+		start_event = WEBCAM_START_BUTTON.click(start, inputs = [ webcam_device_id_dropdown, webcam_mode_radio, webcam_resolution_dropdown, webcam_fps_slider ], outputs = WEBCAM_IMAGE)
+		start_event.then(pre_stop)
+		WEBCAM_STOP_BUTTON.click(stop, cancels = start_event, outputs = WEBCAM_IMAGE)
+		WEBCAM_STOP_BUTTON.click(pre_stop, outputs = [ SOURCE_FILE, WEBCAM_IMAGE, WEBCAM_START_BUTTON, WEBCAM_STOP_BUTTON ])
+
+
+def update_source(files : List[File]) -> gradio.File:
+	file_names = [ file.name for file in files ] if files else None
+	has_source_image = has_image(file_names)
+
+	if has_source_image:
+		state_manager.set_item('source_paths', file_names)
+		return gradio.File(value = file_names)
+
+	state_manager.clear_item('source_paths')
+	return gradio.File(value = None)
+
+
+def pre_start() -> Tuple[gradio.File, gradio.Image, gradio.Button, gradio.Button]:
+	return gradio.File(visible = False), gradio.Image(visible = True), gradio.Button(visible = False), gradio.Button(visible = True)
+
+
+def pre_stop() -> Tuple[gradio.File, gradio.Image, gradio.Button, gradio.Button]:
+	return gradio.File(visible = True), gradio.Image(visible = False), gradio.Button(visible = True), gradio.Button(visible = False)
+
+
+def start(webcam_device_id : int, webcam_mode : WebcamMode, webcam_resolution : str, webcam_fps : Fps) -> Iterator[VisionFrame]:
+	state_manager.init_item('face_selector_mode', 'one')
+	state_manager.sync_state()
+
+	camera_capture = get_local_camera_capture(webcam_device_id)
+	stream = None
+
+	if webcam_mode in [ 'udp', 'v4l2' ]:
+		stream = open_stream(webcam_mode, webcam_resolution, webcam_fps) #type:ignore[arg-type]
+	webcam_width, webcam_height = unpack_resolution(webcam_resolution)
+
+	if camera_capture and camera_capture.isOpened():
+		camera_capture.set(cv2.CAP_PROP_FRAME_WIDTH, webcam_width)
+		camera_capture.set(cv2.CAP_PROP_FRAME_HEIGHT, webcam_height)
+		camera_capture.set(cv2.CAP_PROP_FPS, webcam_fps)
+
+		for capture_vision_frame in multi_process_capture(camera_capture, webcam_fps):
+			capture_vision_frame = cv2.cvtColor(capture_vision_frame, cv2.COLOR_BGR2RGB)
+			capture_vision_frame = fit_cover_frame(capture_vision_frame, (webcam_width, webcam_height))
+
+			if webcam_mode == 'inline':
+				yield capture_vision_frame
+			if webcam_mode in [ 'udp', 'v4l2' ]:
+				try:
+					stream.stdin.write(capture_vision_frame.data)
+				except Exception:
+					pass
+
+
+def stop() -> gradio.Image:
+	clear_camera_pool()
+	return gradio.Image(value = None)

uis/components/webcam_options.py

@@ -0,0 +1,49 @@
+from typing import Optional
+
+import gradio
+
+from facefusion import translator
+from facefusion.camera_manager import detect_local_camera_ids
+from facefusion.common_helper import get_first
+from facefusion.uis import choices as uis_choices
+from facefusion.uis.core import register_ui_component
+
+WEBCAM_DEVICE_ID_DROPDOWN : Optional[gradio.Dropdown] = None
+WEBCAM_MODE_RADIO : Optional[gradio.Radio] = None
+WEBCAM_RESOLUTION_DROPDOWN : Optional[gradio.Dropdown] = None
+WEBCAM_FPS_SLIDER : Optional[gradio.Slider] = None
+
+
+def render() -> None:
+	global WEBCAM_DEVICE_ID_DROPDOWN
+	global WEBCAM_MODE_RADIO
+	global WEBCAM_RESOLUTION_DROPDOWN
+	global WEBCAM_FPS_SLIDER
+
+	local_camera_ids = detect_local_camera_ids(0, 10) or [ 'none' ] #type:ignore[list-item]
+	WEBCAM_DEVICE_ID_DROPDOWN = gradio.Dropdown(
+		value = get_first(local_camera_ids),
+		label = translator.get('uis.webcam_device_id_dropdown'),
+		choices = local_camera_ids
+	)
+	WEBCAM_MODE_RADIO = gradio.Radio(
+		label = translator.get('uis.webcam_mode_radio'),
+		choices = uis_choices.webcam_modes,
+		value = uis_choices.webcam_modes[0]
+	)
+	WEBCAM_RESOLUTION_DROPDOWN = gradio.Dropdown(
+		label = translator.get('uis.webcam_resolution_dropdown'),
+		choices = uis_choices.webcam_resolutions,
+		value = uis_choices.webcam_resolutions[0]
+	)
+	WEBCAM_FPS_SLIDER = gradio.Slider(
+		label = translator.get('uis.webcam_fps_slider'),
+		value = 30,
+		step = 1,
+		minimum = 1,
+		maximum = 30
+	)
+	register_ui_component('webcam_device_id_dropdown', WEBCAM_DEVICE_ID_DROPDOWN)
+	register_ui_component('webcam_mode_radio', WEBCAM_MODE_RADIO)
+	register_ui_component('webcam_resolution_dropdown', WEBCAM_RESOLUTION_DROPDOWN)
+	register_ui_component('webcam_fps_slider', WEBCAM_FPS_SLIDER)

uis/components/workflow.py

@@ -0,0 +1,27 @@
+from typing import Optional
+
+import gradio
+
+import facefusion.choices
+from facefusion import state_manager, translator
+from facefusion.types import WorkflowStrategy
+
+WORKFLOW_STRATEGY_DROPDOWN : Optional[gradio.Dropdown] = None
+
+
+def render() -> None:
+	global WORKFLOW_STRATEGY_DROPDOWN
+
+	WORKFLOW_STRATEGY_DROPDOWN = gradio.Dropdown(
+		label = translator.get('uis.workflow_strategy_dropdown'),
+		choices = facefusion.choices.workflow_strategies,
+		value = state_manager.get_item('workflow_strategy')
+	)
+
+
+def listen() -> None:
+	WORKFLOW_STRATEGY_DROPDOWN.change(update_workflow_strategy, inputs = WORKFLOW_STRATEGY_DROPDOWN)
+
+
+def update_workflow_strategy(workflow_strategy : WorkflowStrategy) -> None:
+	state_manager.set_item('workflow_strategy', workflow_strategy)