Help on debugging a custom wayfire implementation

[CliodynamicPragmatics]

I'm trying to create a custom Ignis shell using the wayfire IPC service hosted here in github. I have had moderate success given that the IPC service is also written in python so there's room for convergence. There are some elements I have achieved like an "focused window" indicator and top bar transparency.

The problem here arised when refactoring, I'm trying to make the Workspaces eventbox send a signal for switching workspaces on scroll via the corresponding pywayfire function, but it seems to be blocked and sends no response. Here is the relevant code for illustrating. Some parts here and there were inspired by the Niri and Hyprland services

Wayfire Service

from wayfire import WayfireSocket
from wayfire.extra.ipc_utils import WayfireUtils

from ignis import utils
from ignis.app import IgnisApp
from ignis.base_service import BaseService

from .workspaces import WayfireWorkspaces

class WayfireService(BaseService):
    def __init__(self):
        super().__init__()
        self._workspaces = WayfireWorkspaces(self)
        self.wf_socket = WayfireSocket(allow_manual_search = True)
        self.wf_utils = WayfireUtils(self.wf_socket)

        IgnisApp.get_initialized().connect("shutdown",
                                           lambda *_: sock.client.close())

        self.main_loop()

    @utils.run_in_thread
    def main_loop(self):
        self.init_vars()
        self.wf_socket.watch([
            "view-mapped",
            "view-minimized",
            "view-tiled",
            "wset-workspace-changed",
            "view-focused",
        ])

        while True:
            msg = self.wf_socket.read_next_event()
            if "event" in msg:
                match msg["event"]:
                    case "wset-workspace-changed":
                        self._workspaces.sync(
                            {"active_workspace":
                             self.wf_utils.get_active_workspace_number() - 1}
                        )
                        self._workspaces.emit("active_workspace_changed")


    def init_vars(self):
        self._workspaces.sync(
            {"total_workspaces": len(self.wf_utils._total_workspaces()),
             "active_workspace": self.wf_utils.get_active_workspace()["x"]}
        )

Workspaces

from ignis.gobject import IgnisProperty, IgnisSignal, DataGObject
from typing import Any, List, Optional

class WayfireWorkspaces(DataGObject):
    """
    A workspace.
    """

    def __init__(self, service):
        super().__init__()
        self.__service = service
        self._total_workspaces = None
        self._active_workspace = None

    @IgnisSignal
    def active_workspace_changed(self):
        """
        Emitted when a new workspace has been changed.
        """

    @IgnisProperty
    def active_workspace(self) -> int:
        """
        The index of the active workspace on its monitor.
        """
        return self._active_workspace

    @IgnisProperty
    def total_workspaces(self) -> int:
        """
        The index of the workspace on its monitor.
        """
        return self._total_workspaces

Workspaces widget

# Usual imports here...

wf_service = WayfireService.get_default()

class WorkspaceBtn(widgets.Button):
    def __init__(self, workspace):
        super().__init__(
            css_classes = ["workspace", "unset"],
            # To be implemented later
            # on_click = lambda x: wf_service.set_workspace(workspace),
        )
        if workspace == wf_service._workspaces.active_workspace:
             self.add_css_class("active")

class Workspaces(widgets.EventBox):
    def __init__(self):
        self.total_workspaces = wf_service._workspaces.total_workspaces
        self.active_workspace = wf_service._workspaces.active_workspace
        self.workspaces = tuple(
            WorkspaceBtn(x) for x in range(0, self.total_workspaces)
        )

        wf_service._workspaces.connect(
            "active_workspace_changed",
            lambda x: self.update_active_workspace(self.active_workspace)
        )

        super().__init__(
            css_classes = ["workspaces"],
            on_scroll_up = lambda *_: self.next_workspace(),
            on_scroll_down = lambda x: self.prev_workspace(),
            on_scroll_left = lambda x: self.prev_workspace(),
            on_scroll_right = lambda x: self.next_workspace(),
            child = self.workspaces
        )

    def next_workspace(self):
        wf_service.wf_utils.go_next_workspace()

    def prev_workspace(self):
        wf_service.wf_utils.go_previous_workspace()

    def update_active_workspace(self, workspace):
        for w in self.workspaces:
            w.remove_css_class("active")
            self.active_workspace = wf_service._workspaces.active_workspace
            self.workspaces[self.active_workspace].add_css_class("active")

I suspect the culprit of the blocking may be the while true block in the main loop, which is adapted from the event monitor script on pywayfire, as i can either emit the signal and make the workspace indicator change the active workspace css or change the active workspace via scrolling the eventbox. But not both events at the same time.

Sorry if this is a beginner question, I'm just unsure how to proceed. I'm using the git versions of both pywayfire and Ignis,