Merge branch 'main' into integrate-test-generator

* main:
  fix: Make outside users able to read tmp files (#2070)
  docs: update module server and ui to incorporate #705 (#2044)
  fix: errors on bookmark are now surfaced in the Python console (#2076)
  Add Connect Cloud as a hosting option in README (#2074)
  Update changelog
  Update changelog
  fix: include_css and include_js can use files in same dir (#2069)

Author: schloerke

CHANGELOG.md

@@ -51,6 +51,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 numerous issues related to programmatically updating selectize options. (#2053)
@@ -69,6 +71,10 @@ 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)
+
+* `include_js()` and `include_css()` now correctly handle file permissions in multi-user settings. (#2061)
+
 ### Deprecations
 
 * `ui.update_navs()` has been deprecated in favor of `ui.update_navset()`. (#2047)

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
 

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/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`.
 
@@ -217,11 +217,11 @@ def maybe_copy_files(path: Path | str, include_files: bool) -> tuple[str, str]:
 
     # To avoid unnecessary work when the same file is included multiple times,
     # use a directory scoped by a hash of the file.
-    tmpdir = os.path.join(tempfile.gettempdir(), "shiny_include_files", hash)
+    tmpdir = os.path.join(tempfile.gettempdir(), f"shiny_include_{hash}")
     path_dest = os.path.join(tmpdir, os.path.basename(path))
 
     # Since the hash/tmpdir should represent all the files in the path's directory,
-    # we can simply return here
+    # we can check if it exists to determine if we have a cache hit
     if os.path.exists(path_dest):
         return path_dest, hash
 
@@ -234,17 +234,17 @@ 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
 
 
 def get_hash(path: Path | str, include_files: bool) -> str:
     if include_files:
-        key = get_file_key(path)
-    else:
         dir = os.path.dirname(path)
         files = glob.iglob(os.path.join(dir, "**"), recursive=True)
         key = "\n".join([get_file_key(x) for x in files])
+    else:
+        key = get_file_key(path)
+
     return hash_deterministic(key)
 
 

tests/playwright/shiny/bugs/2061-css-js-inclusion/include_files_case/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)

tests/playwright/shiny/bugs/2061-css-js-inclusion/include_files_case/css/style.css

@@ -0,0 +1,17 @@
+body {
+  font-family: Arial, sans-serif;
+}
+
+h1 {
+  color: black;
+  border-bottom: 2px solid #4682b4;
+  padding-bottom: 10px;
+}
+
+.content {
+  margin: 20px;
+  padding: 15px;
+  background-color: white;
+  border-radius: 5px;
+  box-shadow: 0 0 10px rgba(0, 0, 0, 0.1);
+}

tests/playwright/shiny/bugs/2061-css-js-inclusion/include_files_case/js/customjs.js

@@ -0,0 +1,3 @@
+const newParagraph = document.createElement('p');
+newParagraph.textContent = 'Heyo!';
+document.body.appendChild(newParagraph);

tests/playwright/shiny/bugs/2061-css-js-inclusion/include_files_case/js/customjs2.js

@@ -0,0 +1,3 @@
+const special = document.createElement('p');
+special.textContent = 'Also here!';
+document.body.appendChild(special);