def handle_event(self, info: EmissionInfo) -> None:
    """Receive info from psygnal callback and convert to adaptor call."""
    signal_name = info.signal.name
    if signal_name == "parent":
        # Parent change events are handled by the parent adaptor.
        return

    try:
        name = self.SETTER_METHOD.format(name=signal_name)
        setter = getattr(self, name)
    except AttributeError as e:
        logger.exception(e)
        return

    arg = info.args[0]
    logger.debug("EVENT: %r -> %s=%r  ", type(self), signal_name, arg)

    try:
        setter(arg)
    except Exception as e:
        logger.exception(e)

def all(self) -> Iterator[_base.Adaptor]:
    """Return an iterator over all adaptors in the registry."""
    yield from self._objects.values()

def create_adaptor(self, model: _M) -> _base.Adaptor[_M, Any]:
    """Create a new adaptor for the given model object."""
    adaptor_cls: type[_base.Adaptor] = self.get_adaptor_class(model)
    self.validate_adaptor_class(model, adaptor_cls)
    adaptor = adaptor_cls(model)

    return adaptor

def get_adaptor(self, obj: _M, create: bool = True) -> _base.Adaptor[_M, Any]:
    """Get the adaptor for the given model object, create if `create` is True."""
    if obj._model_id.hex not in self._objects:
        if not create:
            raise KeyError(
                f"{type(self).__name__!r} has no adaptor for {type(obj)} @ "
                f"{id(obj):x}, and create=False"
            )
        logger.debug(
            "Creating %r Adaptor %-14r id: %s",
            type(self).__module__,
            type(obj).__name__,
            obj._model_id.hex[:8],
        )
        self._objects[obj._model_id.hex] = adaptor = self.create_adaptor(obj)
        self.initialize_adaptor(obj, adaptor)
    return self._objects[obj._model_id.hex]

def get_adaptor_class(self, obj: model.EventedBase) -> type[_base.Adaptor]:
    """Return the adaptor class for the given model object."""
    cls = type(self)
    cls_module = sys.modules[cls.__module__]
    cls_file = cls_module.__file__
    raise NotImplementedError(
        f"{cls.__name__}.get_adaptor_class not implemented in {cls_file}"
    )

def initialize_adaptor(
    self, model: model.EventedBase, adaptor: _base.Adaptor
) -> None:
    """Initialize the adaptor for the given model object."""
    # syncronize all model properties with the adaptor
    sync_adaptor(adaptor, model)
    # connect the model events to the adaptor, to keep the adaptor in sync

    model.events.connect(adaptor.handle_event)

    if isinstance(model, models.Canvas):
        for view in model.views:
            self.get_adaptor(view, create=True)
    if isinstance(model, models.View):
        self.get_adaptor(model.scene, create=True)
    if isinstance(model, models.Node):
        adaptor = cast("_base.NodeAdaptor", adaptor)
        model.child_added.connect(adaptor._snx_add_child)
        model.child_removed.connect(adaptor._snx_remove_child)
        for child in model.children:
            # perhaps optional ... since _implementations of _snx_add_child
            # will also likely need to call get_adaptor
            self.get_adaptor(child, create=True)
            adaptor._snx_add_child(child)

@classmethod
def validate_adaptor_class(
    cls, obj: model.EventedBase, adaptor_cls: type[_base.Adaptor]
) -> None:
    """Validate that the given class is a valid adaptor for the given object."""
    return _validate_adaptor_class(type(obj), adaptor_cls)