test(controllers): Add missing methods for controllers

CHANGELOG.md

@@ -5,6 +5,12 @@ All notable changes to Shiny for Python will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [Unreleased]
+
+### Improvements
+
+* Playwright's `OutputDataFrame.set_filter()` controller now supports multi-column filters (#2093)
+
 ## [1.5.0] - 2025-09-11
 
 ### New features

shiny/api-examples/output_code/app-core.py

@@ -0,0 +1,29 @@
+from shiny import App, Inputs, Outputs, Session, render, ui
+
+app_ui = ui.page_fluid(
+    ui.input_text_area(
+        "source",
+        "Enter code to display below:",
+        "print('Hello, Shiny!')\nfor i in range(3):\n    print(i)",
+        rows=8,
+    ),
+    ui.card(
+        ui.output_code("code_default"),
+    ),
+    ui.card(
+        ui.output_code("code_no_placeholder", placeholder=False),
+    ),
+)
+
+
+def server(input: Inputs, output: Outputs, session: Session):
+    @render.code
+    def code_default():
+        return input.source()
+
+    @render.code
+    def code_no_placeholder():
+        return input.source()
+
+
+app = App(app_ui, server)

shiny/api-examples/output_code/app-express.py

@@ -0,0 +1,21 @@
+from shiny.express import input, render, ui
+
+ui.input_text_area(
+    "source",
+    "Enter code to display below:",
+    "print('Hello, Shiny!')\nfor i in range(3):\n    print(i)",
+    rows=8,
+)
+
+with ui.card():
+
+    @render.code
+    def code_default():
+        return input.source()
+
+
+with ui.card():
+
+    @render.code(placeholder=False)
+    def code_no_placeholder():
+        return input.source()

shiny/playwright/controller/_file.py

@@ -1,12 +1,34 @@
 from __future__ import annotations
 
 from playwright.sync_api import Page
+from playwright.sync_api import expect as playwright_expect
 
-from ._base import InputActionBase, WidthLocM
+from .._types import PatternOrStr, Timeout
+from ._base import InputActionBase, WidthLocStlyeM
 
 
-# TODO: Use mixin for dowloadlink and download button
-class DownloadLink(InputActionBase):
+class _DownloadMixin(WidthLocStlyeM, InputActionBase):
+    """Mixin for download controls."""
+
+    def __init__(self, page: Page, id: str, *, loc_suffix: str) -> None:
+        super().__init__(
+            page,
+            id=id,
+            loc=f"#{id}.shiny-download-link{loc_suffix}",
+        )
+
+    def expect_label(
+        self,
+        value: PatternOrStr,
+        *,
+        timeout: Timeout = None,
+    ) -> None:
+        """Expect the anchor itself to contain the provided label text."""
+
+        playwright_expect(self.loc).to_have_text(value, timeout=timeout)
+
+
+class DownloadLink(_DownloadMixin):
     """
     Controller for :func:`shiny.ui.download_link`.
     """
@@ -22,17 +44,10 @@ def __init__(self, page: Page, id: str) -> None:
         id
             The ID of the download link.
         """
-        super().__init__(
-            page,
-            id=id,
-            loc=f"#{id}.shiny-download-link:not(.btn)",
-        )
+        super().__init__(page, id=id, loc_suffix=":not(.btn)")
 
 
-class DownloadButton(
-    WidthLocM,
-    InputActionBase,
-):
+class DownloadButton(_DownloadMixin):
     """
     Controller for :func:`shiny.ui.download_button`
     """
@@ -48,8 +63,4 @@ def __init__(self, page: Page, id: str) -> None:
         id
             The ID of the download button.
         """
-        super().__init__(
-            page,
-            id=id,
-            loc=f"#{id}.btn.shiny-download-link",
-        )
+        super().__init__(page, id=id, loc_suffix=".btn")

shiny/playwright/controller/_output.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import platform
-from typing import Literal, Protocol
+from typing import Any, Literal, Protocol, Sequence, Union, cast
 
 from playwright.sync_api import Locator, Page
 from playwright.sync_api import expect as playwright_expect
@@ -1211,10 +1211,8 @@ def click_loc(loc: Locator, *, shift: bool = False):
                         break
                 click_loc(sort_col, shift=shift)
 
-    # TODO-karan-test: Add support for a list of columns ? If so, all other columns should be reset
     def set_filter(
         self,
-        # TODO-barret support array of filters
         filter: ColumnFilter | list[ColumnFilter] | None,
         *,
         timeout: Timeout = None,
@@ -1242,40 +1240,99 @@ def set_filter(
         if filter is None:
             return
 
+        filter_items: Sequence[Union[ColumnFilter, dict[str, Any]]]
         if isinstance(filter, dict):
-            filter = [filter]
-
-        if not isinstance(filter, list):
+            filter_items = [filter]
+        elif isinstance(filter, (list, tuple)):
+            filter_items = cast(Sequence[Union[ColumnFilter, dict[str, Any]]], filter)
+        else:
             raise ValueError(
-                "Invalid filter value. Must be a ColumnFilter, list[ColumnFilter], or None."
+                "Invalid filter value. Must be a ColumnFilter, "
+                "list[ColumnFilter], or None."
             )
 
-        for filterInfo in filter:
+        for filterInfo in filter_items:
             if "col" not in filterInfo:
                 raise ValueError("Column index (`col`) is required for filtering.")
 
             if "value" not in filterInfo:
                 raise ValueError("Filter value (`value`) is required for filtering.")
 
-            filterColumn = self.loc_column_filter.nth(filterInfo["col"])
+            raw_cols = filterInfo["col"]
+            if isinstance(raw_cols, int):
+                column_indices: list[int] = [raw_cols]
+            elif isinstance(raw_cols, (list, tuple)):
+                cols_iter = cast(Sequence[Any], raw_cols)
+                if len(cols_iter) == 0:
+                    raise ValueError(
+                        "Column index list (`col`) must contain at least one " "entry."
+                    )
+                column_indices = []
+                for col_idx in cols_iter:
+                    if not isinstance(col_idx, int):
+                        raise ValueError(
+                            "Column index (`col`) values must be integers "
+                            "when specifying multiple columns."
+                        )
+                    column_indices.append(col_idx)
+            else:
+                raise ValueError(
+                    "Column index (`col`) must be an int or a list/tuple of " "ints."
+                )
+
+            raw_value = filterInfo["value"]
 
-            if isinstance(filterInfo["value"], str):
-                filterColumn.locator("> input").fill(filterInfo["value"])
-            elif isinstance(filterInfo["value"], (tuple, list)):
-                header_inputs = filterColumn.locator("> div > input")
-                if filterInfo["value"][0] is not None:
-                    header_inputs.nth(0).fill(
-                        str(filterInfo["value"][0]),
-                        timeout=timeout,
+            if len(column_indices) > 1:
+                if not isinstance(raw_value, (list, tuple)):
+                    raise ValueError(
+                        "When filtering multiple columns, `value` must be a "
+                        "list or tuple with one entry per column."
                     )
-                if filterInfo["value"][1] is not None:
-                    header_inputs.nth(1).fill(
-                        str(filterInfo["value"][1]),
-                        timeout=timeout,
+                value_sequence = cast(Sequence[Any], raw_value)
+                if len(value_sequence) != len(column_indices):
+                    raise ValueError(
+                        "The number of filter values must match the number of "
+                        "target columns."
                     )
+                value_iter = list(value_sequence)
             else:
+                value_iter = [raw_value]
+
+            for col_idx, value in zip(column_indices, value_iter):
+                filterColumn = self.loc_column_filter.nth(col_idx)
+
+                if value is None:
+                    continue
+
+                if isinstance(value, (str, int, float)):
+                    filterColumn.locator("> input").fill(str(value), timeout=timeout)
+                    continue
+
+                if isinstance(value, (list, tuple)):
+                    range_values = cast(Sequence[Any], value)
+                    if len(range_values) != 2:
+                        raise ValueError(
+                            "Numeric range filters must provide exactly two "
+                            "values (min, max)."
+                        )
+
+                    header_inputs = filterColumn.locator("> div > input")
+                    lower = range_values[0]
+                    upper = range_values[1]
+                    if lower is not None:
+                        header_inputs.nth(0).fill(str(lower), timeout=timeout)
+                    else:
+                        header_inputs.nth(0).fill("", timeout=timeout)
+
+                    if upper is not None:
+                        header_inputs.nth(1).fill(str(upper), timeout=timeout)
+                    else:
+                        header_inputs.nth(1).fill("", timeout=timeout)
+                    continue
+
                 raise ValueError(
-                    "Invalid filter value. Must be a string or a tuple/list of two numbers."
+                    "Invalid filter value. Must be a string/number, a "
+                    "tuple/list of two numbers, or None."
                 )
 
     def set_cell(

shiny/ui/_output.py

@@ -14,7 +14,7 @@
 
 from htmltools import Tag, TagAttrValue, TagFunction, css, div, tags
 
-from .._docstring import add_example, no_example
+from .._docstring import add_example
 from ..module import resolve_id
 from ..types import MISSING, MISSING_TYPE
 from ._plot_output_opts import (
@@ -271,7 +271,7 @@ def output_text(
     return container(id=resolve_id(id), class_="shiny-text-output")
 
 
-@no_example()
+@add_example()
 def output_code(id: str, placeholder: bool = True) -> Tag:
     """
     Create a output container for code (monospaced text).
@@ -304,9 +304,6 @@ def output_code(id: str, placeholder: bool = True) -> Tag:
     * :func:`~shiny.ui.output_text`
     * :func:`~shiny.ui.output_text_verbatim`
 
-    Example
-    -------
-    See :func:`~shiny.ui.output_text`
     """
 
     cls = "shiny-text-output" + (" noplaceholder" if not placeholder else "")