From 4988bae2ff948cde3c6f0fadc8ded7e07a9ece02 Mon Sep 17 00:00:00 2001 From: henryruhs Date: Sat, 7 Nov 2026 15:08:49 +0100 Subject: [PATCH] revamp how cli renders --- facefusion/clis/formatter.py | 121 ++++++++++++++++++++++++++ tests/apis/middlewares/__init__.py | 0 tests/apis/middlewares/test_logger.py | 26 ++++++ tests/clis/test_formatter.py | 120 +++++++++++++++++++++++++ 4 files changed, 267 insertions(+) create mode 100644 facefusion/clis/formatter.py create mode 100644 tests/apis/middlewares/__init__.py create mode 100644 tests/apis/middlewares/test_logger.py create mode 100644 tests/clis/test_formatter.py diff --git a/facefusion/clis/formatter.py b/facefusion/clis/formatter.py new file mode 100644 index 00000000..369bb185 --- /dev/null +++ b/facefusion/clis/formatter.py @@ -0,0 +1,121 @@ +from functools import partial +from logging import ERROR, LogRecord, WARNING +from typing import List + +from facefusion import choices, session_context, session_manager, state_manager +from facefusion.common_helper import get_last +from facefusion.types import ColorName, GroupState, LineGroup + + +def create_group_state() -> GroupState: + return\ + { + 'label': '', + 'line_count': 0 + } + + +def format_record(group_state : GroupState, record : LogRecord) -> str: + module_name = record.__dict__.get('module_name') + line_group = record.__dict__.get('line_group') + + if module_name and line_group: + line_label = '' + line_connector = '│' + + if register_line(group_state, line_group): + line_label = line_group.get('label') + line_connector = '┬' + + return create_line(line_label, line_group.get('color'), line_connector, get_last(module_name.split('.')), color_message(record.getMessage(), record.levelno)) + + group_state.update(create_group_state()) + return record.getMessage() + + +def sort_records(records : List[LogRecord]) -> List[LogRecord]: + record_labels = [] + + for record in records: + record_label = resolve_record_label(record) + + if record_label not in record_labels: + record_labels.append(record_label) + + return sorted(records, key = partial(resolve_record_position, record_labels)) + + +def resolve_record_label(record : LogRecord) -> str: + line_group = record.__dict__.get('line_group') + + if line_group: + return line_group.get('label') + + return str(id(record)) + + +def resolve_record_position(record_labels : List[str], record : LogRecord) -> int: + return record_labels.index(resolve_record_label(record)) + + +def register_line(group_state : GroupState, line_group : LineGroup) -> bool: + group_start = not line_group.get('label') == group_state.get('label') or group_state.get('line_count') == choices.stream_group_size + + if group_start: + group_state['line_count'] = 0 + + group_state['label'] = line_group.get('label') + group_state['line_count'] += 1 + return group_start + + +def color_message(message : str, log_level : int) -> str: + if log_level == WARNING: + return colorize(message, 'yellow') + + if log_level == ERROR: + return colorize(message, 'red') + + return message + + +def colorize(message : str, color_name : ColorName) -> str: + return choices.color_palette.get(color_name) + message + choices.color_palette.get('reset') + + +def create_line(line_label : str, line_color : ColorName, line_connector : str, line_type : str, line_text : str) -> str: + return colorize(line_label.ljust(8) + line_connector, line_color) + ' ' + colorize(line_type.ljust(14), 'grey') + ' ' + line_text + + +def get_line_offset() -> int: + return 8 + 2 + 14 + 2 + + +def resolve_line_group() -> LineGroup: + session_id = session_context.get_session_id() + owner_id = session_manager.resolve_owner_id() + local_id = session_context.resolve_local_id() + + if owner_id in session_manager.API_SESSIONS: + return create_line_group('api', list(session_manager.API_SESSIONS).index(owner_id)) + + if session_id == local_id and state_manager.get_item('command') == 'api': + return\ + { + 'label': 'server', + 'color': 'grey' + } + + if session_id in session_manager.CLI_SESSIONS: + return create_line_group('cli', list(session_manager.CLI_SESSIONS).index(session_id)) + + return create_line_group('cli', 0) + + +def create_line_group(group_name : str, group_index : int) -> LineGroup: + return\ + { + 'label': group_name + '.' + str(group_index), + 'color': choices.stream_group_colors[group_index % len(choices.stream_group_colors)] + } + diff --git a/tests/apis/middlewares/__init__.py b/tests/apis/middlewares/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/tests/apis/middlewares/test_logger.py b/tests/apis/middlewares/test_logger.py new file mode 100644 index 00000000..f887a8ae --- /dev/null +++ b/tests/apis/middlewares/test_logger.py @@ -0,0 +1,26 @@ +import logging + +from _pytest.logging import LogCaptureFixture +from starlette.applications import Starlette +from starlette.requests import Request +from starlette.responses import PlainTextResponse +from starlette.routing import Route +from starlette.testclient import TestClient + +from facefusion.apis.middlewares.logger import create_logger + + +def get_root(request : Request) -> PlainTextResponse: + return PlainTextResponse('root', status_code = 201) + + +def test_create_logger(caplog : LogCaptureFixture) -> None: + caplog.set_level(logging.INFO, logger = 'facefusion') + api = Starlette(routes = [ Route('/', get_root, methods = [ 'POST' ]) ]) + api.add_middleware(create_logger) + + with TestClient(api) as test_client: + test_client.post('/') + + assert caplog.messages == [ 'post / 201' ] + assert caplog.records[0].__dict__.get('module_name') == 'facefusion.apis.request' diff --git a/tests/clis/test_formatter.py b/tests/clis/test_formatter.py new file mode 100644 index 00000000..6a0b4920 --- /dev/null +++ b/tests/clis/test_formatter.py @@ -0,0 +1,120 @@ +import logging + +import pytest + +from facefusion import choices, session_context, session_manager, state_manager +from facefusion.clis.formatter import color_message, colorize, create_group_state, create_line, create_line_group, format_record, get_line_offset, register_line, resolve_line_group, sort_records + + +@pytest.fixture(scope = 'module', autouse = True) +def before_all() -> None: + state_manager.init() + + +def test_create_group_state() -> None: + assert create_group_state() ==\ + { + 'label': '', + 'line_count': 0 + } + + +def test_format_record() -> None: + group_state = create_group_state() + core_record = logging.makeLogRecord({ 'name': 'facefusion', 'msg': 'processing step 1 of 1', 'module_name': 'facefusion.core', 'line_group': create_line_group('cli', 0) }) + warn_record = logging.makeLogRecord({ 'name': 'facefusion', 'msg': 'no face detected', 'levelno': logging.WARNING, 'module_name': 'facefusion.face_detector', 'line_group': create_line_group('cli', 0) }) + table_record = logging.makeLogRecord({ 'name': 'facefusion', 'msg': '+---+' }) + + assert format_record(group_state, core_record) == create_line('cli.0', 'cyan', '┬', 'core', 'processing step 1 of 1') + assert format_record(group_state, warn_record) == create_line('', 'cyan', '│', 'face_detector', color_message('no face detected', logging.WARNING)) + assert format_record(group_state, table_record) == '+---+' + assert group_state == create_group_state() + assert format_record(group_state, core_record) == create_line('cli.0', 'cyan', '┬', 'core', 'processing step 1 of 1') + + +def test_sort_records() -> None: + first_record = logging.makeLogRecord({ 'msg': 'first', 'line_group': create_line_group('api', 0) }) + second_record = logging.makeLogRecord({ 'msg': 'second', 'line_group': create_line_group('api', 1) }) + third_record = logging.makeLogRecord({ 'msg': 'third', 'line_group': create_line_group('api', 0) }) + table_record = logging.makeLogRecord({ 'msg': '+---+' }) + + assert sort_records([ first_record, second_record, third_record, table_record ]) == [ first_record, third_record, second_record, table_record ] + + +def test_register_line() -> None: + group_state = create_group_state() + + assert register_line(group_state, create_line_group('api', 0)) is True + assert register_line(group_state, create_line_group('api', 0)) is False + assert register_line(group_state, create_line_group('api', 1)) is True + + for _ in range(18): + register_line(group_state, create_line_group('api', 1)) + + assert register_line(group_state, create_line_group('api', 1)) is False + assert register_line(group_state, create_line_group('api', 1)) is True + + +def test_color_message() -> None: + assert color_message('message', logging.INFO) == 'message' + assert color_message('message', logging.WARNING) == colorize('message', 'yellow') + assert color_message('message', logging.ERROR) == colorize('message', 'red') + + +def test_colorize() -> None: + assert colorize('message', 'cyan') == choices.color_palette.get('cyan') + 'message' + choices.color_palette.get('reset') + + +def test_create_line() -> None: + assert create_line('api.1', 'magenta', '┬', 'core', 'message') == colorize('api.1 ┬', 'magenta') + ' ' + colorize('core ', 'grey') + ' message' + assert create_line('', 'magenta', '│', 'inference_manager', 'message') == colorize(' │', 'magenta') + ' ' + colorize('inference_manager', 'grey') + ' message' + + +def test_get_line_offset() -> None: + assert get_line_offset() == len(''.ljust(8) + '│' + ' ' + ''.ljust(14) + ' ') + + +def test_resolve_line_group() -> None: + local_id = session_context.resolve_local_id() + + assert resolve_line_group() == create_line_group('cli', 0) + + session_manager.set_cli_session(local_id, session_manager.create_cli_session()) + session_manager.fork_session() + + assert resolve_line_group() == create_line_group('cli', 1) + + session_manager.join_session() + session_manager.clear_cli_session(local_id) + session_manager.set_api_session('api-session-1', session_manager.create_api_session()) + session_manager.set_api_session('api-session-2', session_manager.create_api_session()) + session_context.set_session_id('api-session-2') + + assert resolve_line_group() == create_line_group('api', 1) + + session_manager.fork_session() + + assert resolve_line_group() == create_line_group('api', 1) + + session_manager.join_session() + session_context.set_session_id(local_id) + session_manager.clear_api_session('api-session-1') + session_manager.clear_api_session('api-session-2') + state_manager.init_item('command', 'api') + + assert resolve_line_group() ==\ + { + 'label': 'server', + 'color': 'grey' + } + + state_manager.clear_item('command') + + +def test_create_line_group() -> None: + assert create_line_group('api', 0) ==\ + { + 'label': 'api.0', + 'color': 'cyan' + } + assert create_line_group('cli', 6).get('color') == 'magenta'