Merge branch 'main' into integrate-test-generator

Author: schloerke

CHANGELOG.md

@@ -29,6 +29,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Improvements
 
+* Restricted the allowable types of the `choices` parameter of `input_select()`, `input_selectize()`, `update_select()`, and `update_selectize()` to actual set of allowable types (previously, the type was suggesting HTML-like values were supported). (#2048)
+
 * Improved the styling and readability of markdown tables rendered by `ui.Chat()` and `ui.MarkdownStream()`. (#1973)
 
 * `selectize`, `remove_button`, and `options` parameters of `ui.input_select()` have been deprecated; use `ui.input_selectize()` instead. (Thanks, @ErdaradunGaztea!) (#1947)
@@ -41,6 +43,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Bug fixes
 
+* Fixed numerous issues related to programmatically updating selectize options. (#2053)
+   * `update_selectize(options=...)` no longer gets ignored when `server=False` (the default).
+   * `update_selectize(options=...)` now works as expected in a module.
+
+* Fixed an issue with `update_selectize()` to properly display labels with HTML reserved characters like "&" (#1330)
+
 * Fixed an issue with `ui.Chat()` sometimes wanting to scroll a parent element. (#1996)
 
 * Explicitly call out module usage in UI input bookmark button documentation. (#1983)

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

@@ -3,21 +3,24 @@
 app_ui = ui.page_fillable(
     ui.panel_title("Hello Shiny Chat"),
     ui.chat_ui("chat"),
-    fillable_mobile=True,
-)
-
-# Create a welcome message
-welcome = """
+    ui.chat_ui(
+        "chat",
+        messages=[
+            """
 Hi! This is a simple Shiny `Chat` UI. Enter a message below and I will
 simply repeat it back to you.
 
 To learn more about chatbots and how to build them with Shiny, check out
 [the documentation](https://shiny.posit.co/py/docs/genai-chatbots.html).
 """
+        ],
+    ),
+    fillable_mobile=True,
+)
 
 
 def server(input, output, session):
-    chat = ui.Chat(id="chat", messages=[welcome])
+    chat = ui.Chat(id="chat")
 
     # Define a callback to run when the user submits a message
     @chat.on_user_submit

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

@@ -7,24 +7,22 @@
     fillable_mobile=True,
 )
 
-# Create a welcome message
-welcome = """
+# Create a chat instance
+chat = ui.Chat(id="chat")
+
+# Display it, with a startup message
+chat.ui(
+    messages=[
+        """
 Hi! This is a simple Shiny `Chat` UI. Enter a message below and I will
 simply repeat it back to you.
 
 To learn more about chatbots and how to build them with Shiny, check out
 [the documentation](https://shiny.posit.co/py/docs/genai-chatbots.html).
 """
-
-# Create a chat instance
-chat = ui.Chat(
-    id="chat",
-    messages=[welcome],
+    ],
 )
 
-# Display it
-chat.ui()
-
 
 # Define a callback to run when the user submits a message
 @chat.on_user_submit

shiny/ui/_input_select.py

@@ -21,7 +21,7 @@
 from ._html_deps_external import selectize_deps
 from ._utils import JSEval, extract_js_keys, shiny_input_label
 
-_Choices = Mapping[str, TagChild]
+_Choices = Mapping[str, str]
 _OptGrpChoices = Mapping[str, _Choices]
 
 # Canonical format for representing select options.
@@ -75,8 +75,7 @@ def input_selectize(
     choices
         Either a list of choices or a dictionary mapping choice values to labels. Note
         that if a dictionary is provided, the keys are used as the (input) values and
-        the values are labels displayed to the user. It is not recommended to use
-        anything other than a string for these labels. A dictionary of dictionaries is
+        the values are labels displayed to the user. A dictionary of dictionaries is
         also supported, and in that case, the top-level keys are treated as
         ``<optgroup>`` labels.
     selected
@@ -157,8 +156,7 @@ def input_select(
     choices
         Either a list of choices or a dictionary mapping choice values to labels. Note
         that if a dictionary is provided, the keys are used as the (input) values and
-        the values are labels displayed to the user. It is not recommended to use
-        anything other than a string for these labels. A dictionary of dictionaries is
+        the values are labels displayed to the user. A dictionary of dictionaries is
         also supported, and in that case, the top-level keys are treated as
         ``<optgroup>`` labels.
     selected
@@ -259,12 +257,6 @@ def _input_select_impl(
 
     choices_ = _normalize_choices(choices)
 
-    if _contains_html(choices_):
-        warn_deprecated(
-            "Passing anything other than a string to `choices` parameter of "
-            "`input_select()` and `input_selectize()` is deprecated."
-        )
-
     selected = restore_input(resolved_id, selected)
     if selected is None and not multiple:
         selected = _find_first_option(choices_)

shiny/ui/_input_update.py

@@ -628,8 +628,7 @@ def update_select(
         An input label.
     choices
         Either a list of choices or a dictionary mapping choice values to labels. Note
-        that if a dictionary is provided, the keys are used as the (input) values so
-        that the dictionary values can hold HTML labels. A dictionary of dictionaries is
+        that if a dictionary is provided, the keys are used as the (input) values. A dictionary of dictionaries is
         also supported, and in that case, the top-level keys are treated as
         ``<optgroup>`` labels.
     selected
@@ -697,8 +696,7 @@ def update_selectize(
         An input label.
     choices
         Either a list of choices or a dictionary mapping choice values to labels. Note
-        that if a dictionary is provided, the keys are used as the (input) values so
-        that the dictionary values can hold HTML labels. A dictionary of dictionaries is
+        that if a dictionary is provided, the keys are used as the (input) values. A dictionary of dictionaries is
         also supported, and in that case, the top-level keys are treated as
         ``<optgroup>`` labels.
     selected
@@ -724,37 +722,31 @@ def update_selectize(
 
     session = require_active_session(session)
 
+    if options is not None:
+        cfg = tags.script(
+            json.dumps(options),
+            type="application/json",
+            data_for=resolve_id(id),
+            data_eval=json.dumps(extract_js_keys(options)),
+        )
+        session.send_input_message(id, {"config": cfg.get_html_string()})
+
     if not server:
         return update_select(
             id, label=label, choices=choices, selected=selected, session=session
         )
 
-    if options is not None:
-        cfg = TagList(
-            tags.script(
-                json.dumps(options),
-                type="application/json",
-                data_for=id,
-                data_eval=json.dumps(extract_js_keys(options)),
-            )
-        )
-        session.send_input_message(id, drop_none({"config": cfg.get_html_string()}))
-
     # Transform choices to a list of dicts (this is the form the client wants)
     # [{"label": "Foo", "value": "foo", "optgroup": "foo"}, ...]
     flat_choices: list[FlatSelectChoice] = []
     if choices is not None:
         for k, v in _normalize_choices(choices).items():
             if not isinstance(v, Mapping):
-                flat_choices.append(
-                    FlatSelectChoice(value=k, label=session._process_ui(v)["html"])
-                )
+                flat_choices.append(FlatSelectChoice(value=k, label=v))
             else:  # The optgroup case
                 flat_choices.extend(
                     [
-                        FlatSelectChoice(
-                            optgroup=k, value=k2, label=session._process_ui(v2)["html"]
-                        )
+                        FlatSelectChoice(optgroup=k, value=k2, label=v2)
                         for (k2, v2) in v.items()
                     ]
                 )

tests/playwright/shiny/components/selectize/app.py

@@ -0,0 +1,34 @@
+from shiny import App, Inputs, Outputs, Session, module, reactive, ui
+
+
+@module.ui
+def reprex_selectize_ui(label: str):
+    return ui.input_selectize("x", label, choices=[], multiple=True)
+
+
+@module.server
+def reprex_selectize_server(
+    input: Inputs, output: Outputs, session: Session, server: bool = True
+):
+    @reactive.effect
+    def _():
+        ui.update_selectize(
+            "x",
+            choices=[f"Foo {i}" for i in range(3)],
+            server=server,
+            options={"placeholder": "Search"},
+        )
+
+
+app_ui = ui.page_fluid(
+    reprex_selectize_ui("serverside", "Server"),
+    reprex_selectize_ui("clientside", "Client"),
+)
+
+
+def server(input: Inputs, output: Outputs, session: Session):
+    reprex_selectize_server("serverside", server=True)
+    reprex_selectize_server("clientside", server=False)
+
+
+app = App(app_ui, server, debug=True)

tests/playwright/shiny/components/selectize/test_selectize.py

@@ -0,0 +1,23 @@
+# import pytest
+from playwright.sync_api import Page, expect
+
+from shiny.playwright import controller
+from shiny.run import ShinyAppProc
+
+
+def test_selectize(page: Page, local_app: ShinyAppProc) -> None:
+    page.goto(local_app.url)
+
+    expect(page.get_by_placeholder("Search")).to_have_count(2)
+
+    selectize_menu = controller.InputSelectize(page, "serverside-x")
+    selectize_menu.expect_choices(["Foo 0", "Foo 1", "Foo 2"])
+    selectize_menu.expect_multiple(True)
+    selectize_menu.set(["Foo 0", "Foo 1"])
+    selectize_menu.expect_selected(["Foo 0", "Foo 1"])
+
+    selectize_menu2 = controller.InputSelectize(page, "clientside-x")
+    selectize_menu2.expect_choices(["Foo 0", "Foo 1", "Foo 2"])
+    selectize_menu2.expect_multiple(True)
+    selectize_menu2.set(["Foo 0", "Foo 1"])
+    selectize_menu2.expect_selected(["Foo 0", "Foo 1"])