Function thread_render

ui/easydiffusion/task_manager.py:235–318

(device)

def thread_render(device):
    global current_state, current_state_error

    from easydiffusion import model_manager, runtime
    from easydiffusion.backend_manager import backend
    from requests import ConnectionError

    try:
        runtime.init(device)

        weak_thread_data[threading.current_thread()] = {
            "device": runtime.context.device,
            "device_name": runtime.context.device_name,
            "alive": True,
        }

        current_state = ServerStates.LoadingModel

        while True:
            try:
                if backend.ping(timeout=1):
                    break

                time.sleep(1)
            except (TimeoutError, ConnectionError):
                time.sleep(1)

        model_manager.load_default_models(runtime.context)
        current_state = ServerStates.Online
    except Exception as e:
        log.error(traceback.format_exc())
        weak_thread_data[threading.current_thread()] = {"error": e, "alive": False}
        return

    while True:
        session_cache.clean()
        task_cache.clean()
        if not weak_thread_data[threading.current_thread()]["alive"]:
            log.info(f"Shutting down thread for device {runtime.context.device}")
            model_manager.unload_all(runtime.context)
            return
        if isinstance(current_state_error, SystemExit):
            current_state = ServerStates.Unavailable
            return
        task = thread_get_next_task()
        if task is None:
            idle_event.clear()
            idle_event.wait(timeout=1)
            continue
        if task.error is not None:
            log.error(task.error)
            task.response = {"status": "failed", "detail": str(task.error)}
            task.buffer_queue.put(json.dumps(task.response))
            continue
        if current_state_error:
            task.error = current_state_error
            task.response = {"status": "failed", "detail": str(task.error)}
            task.buffer_queue.put(json.dumps(task.response))