Merge branch 'main' into deprecate-well-panel

Author: schloerke

.github/py-shiny/setup/action.yaml

@@ -4,7 +4,7 @@ inputs:
   python-version:
     description: 'Python version to use'
     required: false
-    default: "3.12"
+    default: "3.13"
 runs:
   using: "composite"
   steps:
@@ -39,12 +39,6 @@ runs:
         run: |
           make ci-install-wheel
 
-      - name: Install backports.tarfile
-        if: ${{ startsWith(inputs.python-version, '3.8') }}
-        shell: bash
-        run: |
-          uv pip install backports.tarfile
-
       - name: Pip list
         shell: bash
         run: |

.github/workflows/build-docs.yaml

@@ -15,7 +15,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: ["3.12"]
+        python-version: ["3.13"]
       fail-fast: false
 
     steps:

.github/workflows/pytest.yaml

@@ -17,7 +17,7 @@ jobs:
     strategy:
       matrix:
         # "3.10" must be a string; otherwise it is interpreted as 3.1.
-        python-version: ["3.12", "3.11", "3.10", "3.9"]
+        python-version: ["3.13", "3.12", "3.11", "3.10", "3.9"]
         os: [ubuntu-latest, windows-latest, macOS-latest]
         exclude:
           - python-version: ${{ github.event.pull_request.draft && '3.11' }}
@@ -73,7 +73,7 @@ jobs:
         with:
           fetch-depth: 0
       - name: "Set up Python 3.10"
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@v5
         with:
           python-version: "3.10"
       - name: Install dependencies
@@ -107,7 +107,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: ["3.12", "3.11", "3.10", "3.9"]
+        python-version: ["3.13", "3.12", "3.11", "3.10", "3.9"]
         browser: ["chromium", "firefox", "webkit"]
         exclude:
           - python-version: ${{ github.event.pull_request.draft && '3.11' }}
@@ -117,8 +117,6 @@ jobs:
           - browser: ${{ github.event.pull_request.draft && 'webkit' }}
           # There are many unexplained tests that fail on webkit w/ python 3.8, 3.9
           # Given the more recent versions of python work, we will exclude this combination
-          - browser: "webkit"
-            python-version: "3.8"
           - browser: "webkit"
             python-version: "3.9"
       fail-fast: false
@@ -157,7 +155,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: ["3.12", "3.11", "3.10", "3.9"]
+        python-version: ["3.13", "3.12", "3.11", "3.10", "3.9"]
         browser: ["chromium", "firefox", "webkit"]
         exclude:
           - python-version: ${{ github.event.pull_request.draft && '3.11' }}

CHANGELOG.md

@@ -9,6 +9,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### New features
 
+* Added support for python 3.13. (#1711)
+
 * `ui.sidebar()` is now interactively resizable. (#2020)
 
 * `ui.update_*()` functions now accept `ui.TagChild` (i.e., HTML) as input to the `label` and `icon` arguments. (#2020)
@@ -31,6 +33,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 * Fix missing session when trying to display an error duing bookmarking. (#1984)
 
+* Fixed `set()` method of `InputSelectize` controller so it clears existing selections before applying new values. (#2024)
+
 ### Deprecations
 
 * `ui.panel_well()` is deprecated in favor of `ui.card()`. (#2038)

pyproject.toml

@@ -26,6 +26,7 @@ classifiers = [
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
 ]
 dependencies = [
     "typing-extensions>=4.10.0",
@@ -54,8 +55,8 @@ theme = ["libsass>=0.23.0", "brand_yml>=0.1.0"]
 test = [
     "pytest>=6.2.4",
     "pytest-asyncio>=0.17.2",
-    "pytest-playwright>=0.3.0",
-    "playwright>=1.43.0",
+    "pytest-playwright>=0.5.2",
+    "playwright>=1.48.0",
     "pytest-xdist",
     "pytest-timeout",
     "pytest-rerunfailures",
@@ -86,7 +87,6 @@ test = [
     "faicons",
     "ridgeplot",
     "great_tables",
-    "modin[all]",
     "polars",
     "dask[dataframe]",
     "pyarrow",

shiny/_datastructures.py

@@ -15,8 +15,6 @@ class PriorityQueueFIFO(Generic[T]):
     """
 
     def __init__(self) -> None:
-        # Using Tuple instead of tuple because in Python 3.8 and earlier, tuple isn't
-        # generic
         self._pq: PriorityQueue[tuple[int, int, T]] = PriorityQueue()
         self._counter: int = 0
 

shiny/_utils.py

@@ -72,16 +72,14 @@ def sort_keys_length(x: dict[str, T], descending: bool = False) -> dict[str, T]:
 
 
 def guess_mime_type(
-    url: "str | os.PathLike[str]",
+    url: str | os.PathLike[str],
     default: str = "application/octet-stream",
     strict: bool = True,
 ) -> str:
     """
     Guess the MIME type of a file. This is a wrapper for mimetypes.guess_type, but it
     only returns the type (and not encoding), and it allows a default value.
     """
-    # Note that in the parameters above, "os.PathLike[str]" is in quotes to avoid
-    # "TypeError: 'ABCMeta' object is not subscriptable", in Python<=3.8.
     if url:
         # Work around issue #1601, some installations of Windows 10 return text/plain
         # as the mime type for .js files

shiny/playwright/controller/_input_controls.py

@@ -579,7 +579,7 @@ def set(
             The timeout for the action. Defaults to `None`.
         """
         if not isinstance(selected, str):
-            raise TypeError("`selected` must be a string")
+            raise TypeError("`selected=` must be a string")
 
         # Only need to set.
         # The Browser will _unset_ the previously selected radio button
@@ -778,10 +778,10 @@ def set(
         """
         # Having an arr of size 0 is allowed. Will uncheck everything
         if not isinstance(selected, list):
-            raise TypeError("`selected` must be a list or tuple")
+            raise TypeError("`selected=` must be a list or tuple")
         for item in selected:
             if not isinstance(item, str):
-                raise TypeError("`selected` must be a list of strings")
+                raise TypeError("`selected=` must be a list of strings")
 
         # Make sure the selected items exist
         # Similar to `self.expect_choices(choices = selected)`, but with
@@ -1187,25 +1187,139 @@ def set(
         """
         Sets the selected option(s) of the input selectize.
 
+        Selected items are altered as follows:
+        1. Click on the selectize input to open the dropdown.
+        2. Starting from the first selected item, each position in the currently selected list should match `selected`. If the item is not a match, remove it and try again.
+        3. Add any remaining items in `selected` that are not currently selected by clicking on them in the dropdown.
+        4. Press the `"Escape"` key to close the dropdown.
+
         Parameters
         ----------
         selected
-            The value(s) of the selected option(s).
+            The [ordered] value(s) of the selected option(s).
         timeout
             The maximum time to wait for the selection to be set. Defaults to `None`.
         """
-        if isinstance(selected, str):
-            selected = [selected]
-        self._loc_events.click()
-        for value in selected:
-            self._loc_selectize.locator(f"[data-value='{value}']").click(
+
+        def click_item(data_value: str, error_str: str) -> None:
+            """
+            Clicks the item in the dropdown by its `data-value` attribute.
+            """
+            if not isinstance(data_value, str):
+                raise TypeError(error_str)
+
+            # Wait for the item to exist
+            playwright_expect(
+                self._loc_selectize.locator(f"[data-value='{data_value}']")
+            ).to_have_count(1, timeout=timeout)
+            # Click the item
+            self._loc_selectize.locator(f"[data-value='{data_value}']").click(
                 timeout=timeout
             )
-        self._loc_events.press("Escape")
+
+        # Make sure the selectize exists
+        playwright_expect(self._loc_events).to_have_count(1, timeout=timeout)
+
+        if self.loc.get_attribute("multiple") is None:
+            # Single element selectize
+            if isinstance(selected, list):
+                if len(selected) != 1:
+                    raise ValueError(
+                        "Expected a `str` value (or a list of a single `str` value) when setting a single-select input."
+                    )
+                selected = selected[0]
+
+            # Open the dropdown
+            self._loc_events.click(timeout=timeout)
+
+            try:
+                # Click the item (which closes the dropdown)
+                click_item(selected, "`selected=` value must be a `str`")
+            finally:
+                # Be sure to close the dropdown
+                # (While this is not necessary on a sucessful `set()`, it is cleaner
+                # than a catch all except)
+                self._loc_events.press("Escape", timeout=timeout)
+
+        else:
+            # Multiple element selectize
+
+            def delete_item(item_loc: Locator) -> None:
+                """
+                Deletes the item by clicking on it and pressing the Delete key.
+                """
+
+                item_loc.click()
+                self.page.keyboard.press("Delete")
+
+            if isinstance(selected, str):
+                selected = [selected]
+            if not isinstance(selected, list):
+                raise TypeError(
+                    "`selected=` must be a single `str` value or a list of `str` values when setting a multiple-select input"
+                )
+
+            # Open the dropdown
+            self._loc_events.click()
+
+            try:
+                # Sift through the selected items
+                # From left to right, we will remove ordered items that are not in the
+                # ordered `selected`
+                # If any selected items are not in the current selection, we will add
+                # them at the end
+
+                # All state transitions examples have an end goal of
+                # A,B,C,D,E
+                #
+                # Items wrapped in `[]` are the item of interest at position `i`
+                # Ex: `Z`,i=3 in A,B,C,[Z],E
+
+                i = 0
+                while i < self._loc_events.locator("> .item").count():
+                    item_loc = self._loc_events.locator("> .item").nth(i)
+                    item_data_value = item_loc.get_attribute("data-value")
+
+                    # If the item has no data-value, remove it
+                    # Transition: A,B,C,[?],D,E -> A,B,C,[D],E
+                    if item_data_value is None:
+                        delete_item(item_loc)
+                        continue
+
+                    # If there are more items than selected, remove the extras
+                    # Transition: A,B,C,D,E,[Z] -> A,B,C,D,E,[]
+                    if i >= len(selected):
+                        delete_item(item_loc)
+                        continue
+
+                    selected_data_value = selected[i]
+
+                    # If the item is not the next `selected` value, remove it
+                    # Transition: A,B,[Z],C,D,E -> A,B,[C],D,E
+                    if item_data_value != selected_data_value:
+                        delete_item(item_loc)
+                        continue
+
+                    # The item is the next `selected` value
+                    # Increment the index! (No need to remove it and add it back)
+                    # A,B,[C],D,E -> A,B,C,[D],E
+                    i += 1
+
+                # Add the remaining items
+                # A,B,[] -> A,B,C,D,E
+                if i < len(selected):
+                    for data_value in selected[i:]:
+                        click_item(
+                            data_value, f"`selected[{i}]=` value must be a `str`"
+                        )
+
+            finally:
+                # Be sure to close the dropdown
+                self._loc_events.press("Escape", timeout=timeout)
+        return
 
     def expect_choices(
         self,
-        # TODO-future; support patterns?
         choices: ListPatternOrStr,
         *,
         timeout: Timeout = None,

shiny/render/_render.py

@@ -4,9 +4,6 @@
 import os
 import sys
 import typing
-
-# `typing.Dict` sed for python 3.8 compatibility
-# Can use `dict` in python >= 3.9
 from typing import TYPE_CHECKING, Any, Callable, Literal, Optional, Union, cast
 
 from htmltools import Tag, TagAttrValue, TagChild

shiny/render/renderer/_renderer.py

@@ -336,9 +336,6 @@ def _auto_register(self) -> None:
                 self._auto_registered = True
 
 
-# Not inheriting from `WrapAsync[[], IT]` as python 3.8 needs typing extensions that
-# doesn't support `[]` for a ParamSpec definition. :-( Would be minimal/clean if we
-# could do `class AsyncValueFn(WrapAsync[[], IT]):`
 class AsyncValueFn(Generic[IT]):
     """
     App-supplied output value function which returns type `IT`.