Implement file input restore / input handler / file serialization

Author: schloerke

shiny/bookmark/_serializers.py

@@ -1,11 +1,15 @@
 from __future__ import annotations
 
+import warnings
 from pathlib import Path
 from shutil import copyfile
-from typing import Any, TypeVar
+from typing import TYPE_CHECKING, Any, TypeVar
 
 from typing_extensions import TypeIs
 
+if TYPE_CHECKING:
+    from ..session import Session
+
 
 class Unserializable: ...
 
@@ -28,22 +32,64 @@ async def serializer_default(value: T, state_dir: Path | None) -> T:
     return value
 
 
-# TODO: Barret - Integrate
-def serializer_file_input(value: Any, state_dir: Path | None) -> Any | Unserializable:
+def serializer_file_input(
+    value: list[dict[str, str | int]], state_dir: Path | None
+) -> Any | Unserializable:
     if state_dir is None:
+        warnings.warn(
+            "`shiny.ui.input_file()` is attempting to save bookmark state. "
+            'However the App\'s `bookmark_store=` is not set to `"server"`. '
+            "Either exclude the input value (`session.bookmark.exclude.append(NAME)`) "
+            'or set `bookmark_store="server"`.',
+            UserWarning,
+            stacklevel=1,
+        )
         return Unserializable()
 
-    # TODO: Barret - Double check this logic!
-
-    # `value` is a data frame. When persisting files, we need to copy the file to
+    # `value` is a "data frame" (list of arrays). When persisting files, we need to copy the file to
     # the persistent dir and then strip the original path before saving.
-    datapath = Path(value["datapath"])
-    new_paths = state_dir / datapath.name
-
-    if new_paths.exists():
-        new_paths.unlink()
-    copyfile(datapath, new_paths)
 
-    value["datapath"] = new_paths.name
-
-    return value
+    if not isinstance(value, list):
+        raise ValueError(
+            f"Invalid value type for file input. Expected list, received: {type(value)}"
+        )
+
+    ret_file_infos = value.copy()
+
+    for i, file_info in enumerate(ret_file_infos):
+        if not isinstance(file_info, dict):
+            raise ValueError(
+                f"Invalid file info type for file input ({i}). "
+                f"Expected dict, received: {type(file_info)}"
+            )
+        if "datapath" not in file_info:
+            raise ValueError(f"Missing 'datapath' key in file info ({i}).")
+        if not isinstance(file_info["datapath"], str):
+            raise TypeError(
+                f"Invalid type for 'datapath' in file info ({i}). "
+                f"Expected str, received: {type(file_info['datapath'])}"
+            )
+
+        datapath = Path(file_info["datapath"])
+        new_path = state_dir / datapath.name
+        if new_path.exists():
+            new_path.unlink()
+        copyfile(datapath, new_path)
+
+        # Store back into the file_info dict to update `ret_file_infos`
+        file_info["datapath"] = new_path.name
+
+    return ret_file_infos
+
+
+def can_serialize_input_file(session: Session) -> bool:
+    """
+    Check if the session can serialize file input.
+
+    Args:
+        session (Session): The current session.
+
+    Returns:
+        bool: True if the session can serialize file input, False otherwise.
+    """
+    return session.bookmark.store == "server"

shiny/input_handler.py

@@ -1,9 +1,11 @@
 from __future__ import annotations
 
 from datetime import date, datetime, timezone
+from pathlib import Path
 from typing import TYPE_CHECKING, Any, Callable, Dict
 
 from .bookmark import serializer_unserializable
+from .bookmark._serializers import can_serialize_input_file, serializer_file_input
 
 if TYPE_CHECKING:
     from .session import Session
@@ -173,33 +175,79 @@ def _(value: Any, name: ResolvedId, session: Session) -> Any:
     if value is None:
         return None
 
-    # TODO: Barret: Input handler for file inputs
+    if not can_serialize_input_file(session):
+        raise ValueError(
+            "`shiny.ui.input_file()` is attempting to restore bookmark state. "
+            'However the App\'s `bookmark_store=` is not set to `"server"`. '
+            "Either exclude the input value (`session.bookmark.exclude.append(NAME)`) "
+            'or set `bookmark_store="server"`.'
+        )
 
-    # # The data will be a named list of lists; convert to a data frame.
-    # val <- as.data.frame(lapply(val, unlist), stringsAsFactors = FALSE)
+    value_obj = value
+
+    # Convert from:
+    # `{name: (n1, n2, n3), size: (s1, s2, s3), type: (t1, t2, t3), datapath: (d1, d2, d3)}`
+    # to:
+    # `[{name: n1, size: s1, type: t1, datapath: d1}, ...]`
+    value_list: list[dict[str, str | int | None]] = []
+    for i in range(len(value_obj["name"])):
+        value_list.append(
+            {
+                "name": value_obj["name"][i],
+                "size": value_obj["size"][i],
+                "type": value_obj["type"][i],
+                "datapath": value_obj["datapath"][i],
+            }
+        )
 
-    # # `val$datapath` should be a filename without a path, for security reasons.
-    # if (basename(val$datapath) != val$datapath) {
-    #   stop("Invalid '/' found in file input path.")
-    # }
+    # Validate the input value
+    for value_item in value_list:
+        if value_item["datapath"] is not None:
+            if not isinstance(value_item["datapath"], str):
+                raise ValueError(
+                    "Invalid type for file input path: ", type(value_item["datapath"])
+                )
+            if Path(value_item["datapath"]).name != value_item["datapath"]:
+                raise ValueError("Invalid '/' found in file input path.")
 
-    # # Prepend the persistent dir
-    # oldfile <- file.path(getCurrentRestoreContext()$dir, val$datapath)
+    import shutil
+    import tempfile
 
-    # # Copy the original file to a new temp dir, so that a restored session can't
-    # # modify the original.
-    # newdir <- file.path(tempdir(), createUniqueId(12))
-    # dir.create(newdir)
-    # val$datapath <- file.path(newdir, val$datapath)
-    # file.copy(oldfile, val$datapath)
+    from shiny._utils import rand_hex
 
-    # # Need to mark this input value with the correct serializer. When a file is
-    # # uploaded the usual way (instead of being restored), this occurs in
-    # # session$`@uploadEnd`.
-    # setSerializer(name, serializerFileInput)
+    from .bookmark._restore_state import get_current_restore_context
+    from .session import session_context
 
-    # snapshotPreprocessInput(name, snapshotPreprocessorFileInput)
+    with session_context(session):
+        restore_ctx = get_current_restore_context()
 
-    # val
+    # These should not fail as we know
+    if restore_ctx is None or restore_ctx.dir is None:
+        raise RuntimeError("No restore context found. Cannot restore file input.")
 
-    return value
+    restore_ctx_dir = Path(restore_ctx.dir)
+
+    for f in value_list:
+        assert f["datapath"] is not None and isinstance(f["datapath"], str)
+
+        data_path = f["datapath"]
+
+        # Prepend the persistent dir
+        old_file = restore_ctx_dir / data_path
+
+        # Copy the original file to a new temp dir, so that a restored session can't
+        # modify the original.
+        tempdir_root = tempfile.TemporaryDirectory()
+        session.on_ended(lambda: tempdir_root.cleanup())
+
+        tempdir = Path(tempdir_root.name) / rand_hex(12)
+        tempdir.mkdir(parents=True, exist_ok=True)
+        f["datapath"] = str(tempdir / Path(data_path).name)
+        shutil.copy2(old_file, f["datapath"])
+
+    # Need to mark this input value with the correct serializer. When a file is
+    # uploaded the usual way (instead of being restored), this occurs in
+    # session$`@uploadEnd`.
+    session.input.set_serializer(name, serializer_file_input)
+
+    return value_list

shiny/ui/_input_file.py

@@ -1,15 +1,18 @@
 from __future__ import annotations
 
-__all__ = ("input_file",)
-
+import warnings
 from typing import Literal, Optional
 
 from htmltools import Tag, TagChild, css, div, span, tags
 
 from .._docstring import add_example
+from ..bookmark import restore_input
+from ..bookmark._utils import to_json_str
 from ..module import resolve_id
 from ._utils import shiny_input_label
 
+__all__ = ("input_file",)
+
 
 @add_example()
 def input_file(
@@ -83,6 +86,27 @@ def input_file(
         accept = [accept]
 
     resolved_id = resolve_id(id)
+    restored_value = restore_input(resolved_id, default=None)
+
+    if restored_value is not None:
+        restored_obj = {
+            "name": list[str | None](),
+            "size": list[int | None](),
+            "type": list[str | None](),
+            "datapath": list[str | None](),
+        }
+        try:
+            for file in restored_value:
+                restored_obj["name"].append(file.get("name", None))
+                restored_obj["size"].append(file.get("size", None))
+                restored_obj["type"].append(file.get("type", None))
+                restored_obj["datapath"].append(file.get("datapath", None))
+            restored_value = to_json_str(restored_obj)
+        except:
+            warnings.warn(
+                f"Error while restoring file input value for `{resolved_id}`. Resetting to `None`."
+            )
+
     btn_file = span(
         button_label,
         tags.input(
@@ -95,6 +119,7 @@ def input_file(
             # Don't use "display: none;" style, which causes keyboard accessibility issue; instead use the following workaround: https://css-tricks.com/places-its-tempting-to-use-display-none-but-dont/
             style="position: absolute !important; top: -99999px !important; left: -99999px !important;",
             class_="shiny-input-file",
+            **({"data-restore": restored_value} if restored_value else {}),
         ),
         class_="btn btn-default btn-file",
     )