Gtk.ListBox sort and filter function raise error

[lovetox]

Gtk.ListBox.set_filter_func() and Gtk.ListBox.set_sort_func(), expect a Gtk.ListBoxRow in the callback, but usually it will be a object that inherits from ListBoxRow.

This currently raises an error.

Example:

error: Argument of type "(row1: BaseRow, row2: BaseRow) -> int" cannot be assigned to parameter "sort_func" of type "((ListBoxRow, ListBoxRow, *_DataTs@set_sort_func) -> int) | None" in function "set_sort_func"
    Type "(row1: BaseRow, row2: BaseRow) -> int" is not assignable to type "((ListBoxRow, ListBoxRow) -> int) | None"
      Type "(row1: BaseRow, row2: BaseRow) -> int" is not assignable to type "(ListBoxRow, ListBoxRow) -> int"
        Parameter 1: type "ListBoxRow" is incompatible with type "BaseRow"
          "ListBoxRow" is not assignable to "BaseRow"
        Parameter 2: type "ListBoxRow" is incompatible with type "BaseRow"
          "ListBoxRow" is not assignable to "BaseRow"
      "FunctionType" is not assignable to "None" (reportArgumentType)

[bryanforbes]

Could you include the code that's generating this error?

[lovetox]

from gi.repository import Gtk


class MyListBoxRow(Gtk.ListBoxRow):
    pass


def my_filter(row: MyListBoxRow) -> bool:
    return False


listbox = Gtk.ListBox()
listbox.set_filter_func(my_filter)

[bryanforbes]

Technically, the typings are correct for this use case. From the docs:

A GtkListBox only contains GtkListBoxRow children

So the callback will never be called with anything other than Gtk.ListBoxRow. Even if it was able to produce subclasses, the callback signature would still be correct because the "widest" interface that any object has that gets passed to the callback would be Gtk.ListBoxRow. We can probably make Gtk.ListBox and Gtk.ListBoxRow generic (so that insert(), remove(), etc. and the child property can be more specific than Gtk.Widget), but it would be unsafe to allow my_filter to take anything more constrained than Gtk.ListBoxRow right now:

class MyListBoxRow(Gtk.ListBoxRow):
    def is_filtered(self) -> bool:
        return False

def my_filter(row: MyListBoxRow) -> bool:
    return row.is_filtered()  # raises an error at runtime

I imagine the use-case is to make sure that row.props.child is typed correctly, but without constraining insert() (through generics), it's still unsafe:

class MyListBoxRow(Gtk.ListBoxRow):
    def get_child(self) -> MyWidget | None:
        return super().get_child()

def my_filter(row: MyListBoxRow) -> bool:
    if button := row.get_child():
        button.set_icon_name('asdf')

listbox = Gtk.ListBox()
listbox.set_filter_func(my_filter)
listbox.append(Gtk.Label())  # allowed by the type checker, but breaks the filter func

Generics would solve the child use-case:

# Gtk stubs
class ListBox(Widget, Generic[_WidgetT]):
    def append(self, child: _WidgetT) -> None: ...
    def get_selected_row(self) -> ListBoxRow[_WidgetT] | None: ...
    def set_filter_func(
        self,
        filter_func: Callable[[ListBoxRow[_WidgetT], Unpack[_DataTs]], bool] | None = None,
        *user_data: Unpack[_DataTs],
    ) -> None: ...

class ListBoxRow(Widget, Actionable, Generic[_WidgetT]):
    @type_check_only
    class Props(Widget.Props, Generic[_PropsWidgetT]):
        child: _PropsWidgetT | None = ...,
    def get_child(self) -> _PropsWidgetT | None: ...

# App code
def my_filter(row: Gtk.ListBoxRow[Gtk.Button]) -> bool:
    ...

listbox: Gtk.ListBox[Gtk.Button] = Gtk.ListBox()
listbox.set_filter_func(my_filter)
listbox.append(Gtk.Label())  # disallowed by the type checker

[lovetox]

I think you misunderstand how the listbox is used

from gi.repository import Gtk

class MyListBoxRow(Gtk.ListBoxRow):
    def is_filtered(self) -> bool:
        return False

def my_filter(row: MyListBoxRow) -> bool:
    return row.is_filtered()  # raises an error at runtime

listbox = Gtk.ListBox()
listbox.set_filter_func(my_filter)
listbox.append(MyListBoxRow())

This does not raise an error, and thats how you would commonly use this.

Its not much different to a Gtk.Box(), there are many widgets you add to the container and they have all in common that they subclass Gtk.Widget. With the ListBox its a subclass of Gtk.ListBoxRow.

Its just a convenience function of Gtk that it automatically wraps every widget you pass into a ListBoxRow if its not a ListBoxRow.

EDIT: Is a Generic an option? I have not tried it, but does this not need support from pygobject?

A Gtk.ListBox holds ListBoxRows, nothing else, a typing with Generic[Widget] would be wrong.
I think it should be Generic[ListBoxRowT], its just the append() function that allows also WidgetT zu be passed.

so more like def append(self, widget: ListBoxRowT | WidgetT)

[lovetox]

I tried simply typing it like this and this works fine

ListBoxRowT = TypeVar("WidgetT", bound=ListBoxRow)

    def set_filter_func(
        self,
        filter_func: Callable[[ListBoxRowT, Unpack[_DataTs]], bool] | None = None,
        *user_data: Unpack[_DataTs],
    ) -> None: ...

[bryanforbes]

Its not much different to a Gtk.Box(), there are many widgets you add to the container and they have all in common that they subclass Gtk.Widget. With the ListBox its a subclass of Gtk.ListBoxRow.

Its just a convenience function of Gtk that it automatically wraps every widget you pass into a ListBoxRow if its not a ListBoxRow.

Ah, thanks for that. I have yet to use a ListBox yet. I just put together a small app and it makes sense what's happening now.

I tried simply typing it like this and this works fine

ListBoxRowT = TypeVar("WidgetT", bound=ListBoxRow)

def set_filter_func(
    self,
    filter_func: Callable[[ListBoxRowT, Unpack[_DataTs]], bool] | None = None,
    *user_data: Unpack[_DataTs],
) -> None: ...

The problem is that ListBoxRowT doesn't really do anything for the correctness of the application. The type checker will still allow listbox.append(Gtk.Label(label='foo')) and your filter function would blow up at runtime:

class MyListBoxRow(Gtk.ListBoxRow):
    def __init__(self, label: str) -> None:
        super().__init__()

        self.set_child(Gtk.Label(label=label))

    def is_filtered(self) -> bool:
        return False

def filter_func(row: MyListBoxRow) -> bool:
    print(row)
    return True

list_box = Gtk.ListBox()
list_box.set_filter_func(filter_func)

list_box.append(MyListBoxRow("Row 1"))
list_box.append(MyListBoxRow("Row 2"))
list_box.append(Gtk.ListBoxRow(child=Gtk.Label(label="Row 3")))
list_box.append(Gtk.Label(label="Row 4"))

When this runs, it outputs the following:

<__main__.MyListBoxRow object at 0x10bd73dc0 (__main__+MyListBoxRow at 0x76bb79d80)>
<__main__.MyListBoxRow object at 0x10bd73dc0 (__main__+MyListBoxRow at 0x76bb79f40)>
<Gtk.ListBoxRow object at 0x10bd78d00 (GtkListBoxRow at 0x76bb7a100)>
<Gtk.ListBoxRow object at 0x10bd78d80 (GtkListBoxRow at 0x76bb7a2c0)>

This is similar to the typing of list:

class list(MutableSequence[_T]):
    @overload
    def sort(self: list[SupportsRichComparisonT], *, key: None = None, reverse: bool = False) -> None: ...
    @overload
    def sort(self, *, key: Callable[[_T], SupportsRichComparison], reverse: bool = False) -> None: ...

So if you declare a list[Gtk.ListBoxRow] (which is sort of what Gtk.ListBox is) and then try to sort it with a function that accepts a subclass:

def row_list_key_func(row: MyListBoxRow) -> int:
   ...

row_list: list[Gtk.ListBoxRow] = []

row_list.sort(key=row_list_key_func)  # type checkers will disallow this

It will be disallowed by any good type checker because the list is allowed to contain anything that is a Gtk.ListBoxRow or any subclass, so accepting a sort function that only expects a subclass would be wrong if a plain Gtk.ListBoxRow was in the list.

So just allowing set_filter_func() to accept a callback that expects a subclass of Gtk.ListBox doesn't solve the problem the type system is designed to solve. This should really be done by making Gtk.ListBox generic, but because append() can accept any Gtk.Widget, that makes things a bit harder (Python's type system isn't quite as expressive as TypeScript's). Give me some time to think of a good solution for this.

[lovetox]

You can type it like that as user, if you know you add different subclasses, then you simply have to type all in your callback.

# App code
def my_filter(row: MyListBoxRow | Gtk.ListBoxRow) -> bool:
    ...

I understand this is maybe not a 100% correct solution, but its probably better than Any.

If you want to solve this correctly, we would need to make many Widgets subscriptable in pygobject. Almost any Widget allows that we add other Widgets somewhere as child.

Anyway maybe you find a better solution.