Merge branch 'main' into fix/js_css_include_perms

Author: elnelson575

CHANGELOG.md

@@ -33,6 +33,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Improvements
 
+* Add support for selecting menu items in `Navset` controllers to improve dropdown navigation test coverage. (#2066)
+
 * `input_date()`, `input_date_range()`, `update_date()`, and `update_date_range()` now supports `""` for values, mins, and maxes. In this case, no date will be specified on the client. (#1713) (#1689)
 
 * 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)
@@ -47,6 +49,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 * Fixed false positive warning in `layout_columns()` about number of widths vs elements. (#1704)
 
+* When errors occur in a bookmarking context, they are now reported in the Python console. (#2076)
+
 ### Bug fixes
 
 * Fixed several issues related to including custom js and css fil
@@ -69,6 +73,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 * Fixed `set()` method of `InputSelectize` controller so it clears existing selections before applying new values. (#2024)
 
+* `include_js()` and `include_css()` now work as expected when trying to include multiple files from the same directory. (#2069)
+
 ### Deprecations
 
 * `ui.update_navs()` has been deprecated in favor of `ui.update_navset()`. (#2047)

Makefile

@@ -260,4 +260,4 @@ narwhals-test-integration: FORCE
 	@echo "-------- Running py-shiny format, lint, typing, and unit tests ----------"
 	$(MAKE) check
 	@echo "-------- Running py-shiny playwright tests ----------"
-	$(MAKE) playwright TEST_FILE="tests/playwright/shiny/components/data_frame" PYTEST_BROWSERS="--browser chromium"
+	$(MAKE) playwright TEST_FILE="tests/playwright/shiny/components/data_frame/data_type/" PYTEST_BROWSERS="--browser chromium"

README.md

@@ -16,7 +16,7 @@ To learn more about Shiny see the [Shiny for Python website](https://shiny.posit
 
 - How to [use modules](https://shiny.posit.co/py/docs/workflow-modules.html) to efficiently develop large applications.
 
-- Hosting applications for free on [shinyapps.io](https://shiny.posit.co/py/docs/deploy.html#deploy-to-shinyapps.io-cloud-hosting), [Hugging Face](https://shiny.posit.co/blog/posts/shiny-on-hugging-face/), or [Shinylive](https://shiny.posit.co/py/docs/shinylive.html).
+- Hosting applications for free on [Connect Cloud](https://docs.posit.co/connect-cloud/how-to/python/shiny-python.html), [shinyapps.io](https://shiny.posit.co/py/docs/deploy.html#deploy-to-shinyapps.io-cloud-hosting), [Hugging Face](https://shiny.posit.co/blog/posts/shiny-on-hugging-face/), or [Shinylive](https://shiny.posit.co/py/docs/shinylive.html).
 
 ## Join the conversation
 

pyproject.toml

@@ -60,7 +60,7 @@ test = [
     "playwright>=1.48.0",
     "pytest-xdist",
     "pytest-timeout",
-    "pytest-rerunfailures",
+    "pytest-rerunfailures<16",
     "pytest-cov",
     "coverage",
     "syrupy>=4.7.1",

shiny/bookmark/_bookmark.py

@@ -558,15 +558,10 @@ async def do_bookmark(self) -> None:
                     await self.show_bookmark_url_modal(full_url)
 
         except Exception as e:
-            msg = f"Error bookmarking state: {e}"
-            from ..ui._notification import notification_show
-
-            notification_show(
-                msg,
-                duration=None,
-                type="error",
-                session=self._root_session,
-            )
+            from ..types import NotifyException
+
+            msg = f"Error bookmarking state: {str(e)}"
+            raise NotifyException(msg) from e
 
 
 class BookmarkProxy(Bookmark):

shiny/module.py

@@ -29,9 +29,23 @@ def ui(fn: Callable[P, R]) -> Callable[Concatenate[str, P], R]:
     """
     Decorator for defining a Shiny module UI function.
 
-    This decorator allows you to write the UI portion of a Shiny module.
-    When your decorated `ui` function is called with an `id`,
-    the UI elements defined within will automatically be namespaced using that `id`.
+    A Shiny module is a reusable component that can be embedded within Shiny apps or
+    other Shiny modules. Each module consists of a UI function and a server function.
+    Use this decorator to mark the UI function for a module.
+
+    The UI function can take whatever parameters are required to create the UI; for
+    example, a label or a default value. It can also take no parameters, if none are
+    required.
+
+    Whatever parameters the UI function takes, the `ui` decorator will prepend the
+    signature with a new `id` argument. This argument will be an id string passed by the
+    caller, that uniquely identifies the module instance within the calling scope.
+
+    When the decorated function is called, any Shiny input or output elements created
+    within the function will automatically have their `id` values prefixed with the
+    module instance's `id`. This ensures that the input and output elements are uniquely
+    namespaced and won't conflict with other elements in the same app.
+
     This enables reuse of UI components and consistent input/output handling
     when paired with a :func:`shiny.module.server` function.
 
@@ -44,8 +58,9 @@ def ui(fn: Callable[P, R]) -> Callable[Concatenate[str, P], R]:
     Returns
     -------
     :
-        A function that takes a `str` `id` as its first argument, followed by any additional
-        parameters accepted by `fn`. When called, it returns UI elements with input/output
+        The decorated UI function. The function takes a `str` `id` as its first argument,
+        followed by any additional parameters accepted by `fn`.
+        When called, it returns UI elements with input/output
         IDs automatically namespaced using the provided module `id`.
 
     See Also
@@ -68,6 +83,21 @@ def server(
     """
     Decorator for defining a Shiny module server function.
 
+    A Shiny module is a reusable component that can be embedded within Shiny apps or
+    other Shiny modules. Each module consists of a UI function and a server function.
+    This decorator is used to encapsulate the server logic for a Shiny module.
+
+    Every Shiny module server function must always begin with the same three arguments:
+    `input`, `output`, and `session`, just like a Shiny app's server function.
+
+    After `input`, `output`, and `session`, the server function may include additional
+    parameters to be used in the server logic; for example, reactive data sources or
+    file paths that need to be provided by the caller.
+
+    This decorator modifies the signature of the decorated server function. The `input`,
+    `output`, and `session` parameters are removed, and a new `id` parameter is
+    prepended to the signature.
+
     This decorator is used to encapsulate the server logic for a Shiny module.
     It automatically creates a namespaced child `Session` using the provided module `id`,
     and passes the appropriate `input`, `output`, and `session` objects to your server function.
@@ -84,9 +114,13 @@ def server(
     Returns
     -------
     :
+        The decorated server function.
         A function that takes a module `id` (as a string) as its first argument,
         followed by any arguments expected by `fn`. When called, it will register
         the module's server logic in a namespaced context.
+        The function signature of `fn` will have been
+        modified to remove `input`, `output`, and `session`, and to prepend a new `id`
+        parameter.
 
     See Also
     --------

shiny/playwright/controller/_navs.py

@@ -145,11 +145,35 @@ def click(self, *, timeout: Timeout = None) -> None:
         """
         Clicks the nav panel.
 
+        If the nav panel is inside a dropdown, playwright will first open the dropdown before selecting the nav panel.
+
         Parameters
         ----------
         timeout
             The maximum time to wait for the nav panel to be visible and interactable. Defaults to `None`.
         """
+
+        parent_ul_loc = self.loc.locator("..").locator("..")
+
+        parent_ul_cls = parent_ul_loc.element_handle().get_attribute("class")
+        cls_menu_regex = re.compile(rf"(^|\s+){re.escape('dropdown-menu')}(\s+|$)")
+        cls_show_regex = re.compile(rf"(^|\s+){re.escape('show')}(\s+|$)")
+        cls_dropdown_regex = re.compile(rf"(^|\s+){re.escape('dropdown')}(\s+|$)")
+
+        # If the item is in a dropdown and the dropdown is closed
+        if (
+            parent_ul_cls
+            and cls_menu_regex.search(parent_ul_cls)
+            and not cls_show_regex.search(parent_ul_cls)
+        ):
+            grandparent_li_loc = parent_ul_loc.locator("..")
+            gnd_li_cls = grandparent_li_loc.element_handle().get_attribute("class")
+
+            # Confirm it is a dropdown
+            if gnd_li_cls and cls_dropdown_regex.search(gnd_li_cls):
+                # click the grandparent list item to open it before clicking the target item
+                grandparent_li_loc.click()
+
         self.loc.click(timeout=timeout)
 
     def expect_active(self, value: bool, *, timeout: Timeout = None) -> None:

shiny/reactive/_reactives.py

@@ -597,9 +597,10 @@ async def _run(self) -> None:
                     from ..ui import notification_show
 
                     msg = str(e)
+                    warnings.warn(msg, ReactiveWarning, stacklevel=2)
                     if e.sanitize:
                         msg = SANITIZE_ERROR_MSG
-                    notification_show(msg, type="error", duration=5000)
+                    notification_show(msg, type="error", duration=None)
                     if e.close:
                         await self._session._unhandled_error(e)
             except Exception as e:

shiny/ui/_include_helpers.py

@@ -36,20 +36,20 @@ def include_js(
     method
         One of the following:
 
-        * ``"link"`` is the link to the CSS file via a :func:`~shiny.ui.tags.link` tag. This
+        * ``"link"`` is the link to the JS file via a :func:`~shiny.ui.tags.script` tag. This
           method is generally preferable to ``"inline"`` since it allows the browser to
           cache the file.
-        * ``"link_files"`` is the same as ``"link"``, but also allow for the CSS file to
+        * ``"link_files"`` is the same as ``"link"``, but also allow for the JS file to
           request other files within ``path``'s immediate parent directory (e.g.,
-          ``@import()`` another file). Note that this isn't the default behavior because
+          ``import`` another file). Note that this isn't the default behavior because
           you should **be careful not to include files in the same directory as ``path``
           that contain sensitive information**. A good general rule of thumb to follow
           is to have ``path`` be located in a subdirectory of the app directory. For
           example, if the app's source is located at ``/app/app.py``, then ``path``
-          should be somewhere like ``/app/css/custom.css`` (and all the other relevant
+          should be somewhere like ``/app/js/custom.js`` (and all the other relevant
           accompanying 'safe' files should be located under ``/app/css/``).
-        * ``"inline"`` is the inline the CSS file contents within a
-          :func:`~shiny.ui.tags.style` tag.
+        * ``"inline"`` is the inline the JS file contents within a
+          :func:`~shiny.ui.tags.script` tag.
     **kwargs
         Attributes which are passed on to `~shiny.ui.tags.script`.
 
@@ -234,7 +234,6 @@ def maybe_copy_files(path: Path | str, include_files: bool) -> tuple[str, str]:
     else:
         os.makedirs(tmpdir, exist_ok=True)
         shutil.copy(path, path_dest)
-
     return path_dest, hash
 
 

tests/playwright/shiny/bugs/2061-css-js-inclusion/app.py

@@ -0,0 +1,38 @@
+from pathlib import Path
+
+from shiny import App, Inputs, Outputs, Session, ui
+
+custom_css = ui.include_css(
+    Path(__file__).parent / "css" / "style.css",
+    method="link_files",
+)
+
+custom_js = ui.include_js(
+    Path(__file__).parent / "js" / "customjs.js",
+    method="link_files",
+)
+
+# path where the JS file's parent directory is mounted
+href = custom_js.get_dependencies()[0].source_path_map()["href"]
+
+# Define the UI
+app_ui = ui.page_fluid(
+    custom_css,
+    custom_js,
+    ui.tags.script(src=href + "/customjs2.js"),
+    ui.h1("Simple Shiny App with External CSS"),
+    ui.div(
+        ui.p("This is a simple Shiny app that demonstrates ui.include_css()"),
+        ui.p("The styling comes from an external CSS file!"),
+        class_="content",
+    ),
+)
+
+
+# Define the server
+def server(input: Inputs, output: Outputs, session: Session):
+    pass
+
+
+# Create and run the app
+app = App(app_ui, server)