temporarily remove quarto-shiny skeleton, not yet supported

Author: amol-

docs/CHANGELOG.md

@@ -11,7 +11,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - `rsconnect quickstart` command for scaffolding a new Connect-ready project.
   Supported types: `streamlit`, `shiny`, `fastapi`, `api`, `flask`, `notebook`,
-  `voila`, `quarto`, `quarto-shiny`. Creates a uv-managed virtualenv and prints
+  `voila`, `quarto`. Creates a uv-managed virtualenv and prints
   the local-run and deploy commands.
 - `rsconnect deploy pyproject` command for deploying a project described by
   `pyproject.toml` with a `[tool.rsconnect]` table containing `app_mode` and

rsconnect/bundle.py

@@ -57,6 +57,7 @@
 from .exception import RSConnectException
 from .log import VERBOSE, logger
 from .models import AppMode, AppModes, GlobSet
+from .shiny_express import escape_to_var_name, is_express_app
 
 if TYPE_CHECKING:
     from .actions import QuartoInspectResult
@@ -1182,8 +1183,12 @@ def infer_entrypoint_candidates(path: str, mimetype: str) -> list[str]:
 def guess_deploy_dir(path: str | Path, entrypoint: Optional[str]) -> str:
     if path and not exists(path):
         raise RSConnectException(f"Path {path} does not exist.")
+    # The entrypoint is a bare basename meant to be resolved relative to ``path``
+    # (the later logic does ``join(abs_path, basename(entrypoint))``). Accept it
+    # when it exists relative to the CWD or inside ``path``; only reject when neither.
     if entrypoint and not exists(entrypoint):
-        raise RSConnectException(f"Entrypoint {entrypoint} does not exist.")
+        if not (path and isfile(os.path.join(abspath(path), basename(entrypoint)))):
+            raise RSConnectException(f"Entrypoint {entrypoint} does not exist.")
     abs_path = abspath(path)
     abs_entrypoint = abspath(entrypoint) if entrypoint else None
     if not path and not entrypoint:
@@ -1224,6 +1229,26 @@ def guess_deploy_dir(path: str | Path, entrypoint: Optional[str]) -> str:
     return deploy_dir
 
 
+def resolve_shiny_express_entrypoint(entrypoint: str, directory: str) -> str:
+    """Rewrite a Shiny entrypoint to its Shiny Express module form when needed.
+
+    Connect runs Shiny Express apps through the ``shiny.express.app:<var>``
+    module rather than a plain file, so both ``deploy shiny`` and
+    ``deploy pyproject`` must apply this rewrite to deploy a working app.
+
+    Accepts a bare module name (``"app"``) or a filename (``"app.py"``).
+    Returns the ``shiny.express.app:<escaped>`` form when the app file is a
+    Shiny Express app, otherwise returns ``entrypoint`` unchanged.
+
+    :param str entrypoint: the configured entrypoint, with or without ``.py``.
+    :param str directory: directory containing the app file.
+    """
+    app_file = entrypoint if entrypoint.lower().endswith(".py") else entrypoint + ".py"
+    if is_express_app(app_file, directory):
+        return "shiny.express.app:" + escape_to_var_name(app_file)
+    return entrypoint
+
+
 def abs_entrypoint(path: str | Path, entrypoint: str) -> str | None:
     if isfile(entrypoint):
         return abspath(entrypoint)

rsconnect/main.py

@@ -83,6 +83,7 @@
     make_tensorflow_bundle,
     make_voila_bundle,
     read_manifest_app_mode,
+    resolve_shiny_express_entrypoint,
     validate_entry_point,
     validate_extra_files,
     validate_file_is_notebook,
@@ -120,7 +121,6 @@
 )
 from .pyproject import InvalidPyprojectConfigError, TOMLDecodeError, read_tool_rsconnect
 from .environment import PackageInstaller
-from .shiny_express import escape_to_var_name, is_express_app
 from .utils_package import fix_starlette_requirements
 
 T = TypeVar("T")
@@ -1028,7 +1028,7 @@ def info(file: str):
     help=(
         "Create a new Posit Connect project of the given TYPE in ./<name>/. "
         "Supported TYPE values: streamlit, shiny, fastapi, api, flask, "
-        "notebook, voila, quarto, quarto-shiny. Writes a pyproject.toml "
+        "notebook, voila, quarto. Writes a pyproject.toml "
         "with a [tool.rsconnect] section, creates a uv-managed virtualenv, "
         "and prints the local-run and deploy commands."
     ),
@@ -1604,12 +1604,14 @@ def quickstart_hint() -> str:
 
     # Requirements source precedence: ``-r`` flag > ``[tool.rsconnect].requirements_file``
     # > built-in default ``pyproject.toml`` (top-level deps; Connect resolves transitive).
-    # Without an explicit source the inspector would silently ``pip freeze`` the caller's
-    # interpreter — the bug ``deploy pyproject`` exists to avoid. Malformed TOML values
-    # (wrong type, missing file) are surfaced by the inspector / file existence check.
+    # An explicit default keeps the inspector from falling back to a ``pip freeze`` of the
+    # caller's interpreter. Malformed TOML values (wrong type, missing file) are surfaced
+    # by the inspector / file existence check.
     requirements_file = requirements_file or config.get("requirements_file") or "pyproject.toml"
 
     if app_mode in (AppModes.STREAMLIT_APP, AppModes.PYTHON_SHINY, AppModes.PYTHON_FASTAPI, AppModes.PYTHON_API):
+        if app_mode == AppModes.PYTHON_SHINY:
+            entrypoint = resolve_shiny_express_entrypoint(entrypoint, directory)
         environment = Environment.create_python_environment(
             directory,
             requirements_file=requirements_file,
@@ -2275,8 +2277,7 @@ def deploy_app(
         )
 
         if app_mode == AppModes.PYTHON_SHINY:
-            if is_express_app(entrypoint + ".py", directory):
-                entrypoint = "shiny.express.app:" + escape_to_var_name(entrypoint + ".py")
+            entrypoint = resolve_shiny_express_entrypoint(entrypoint, directory)
 
         # Get server version for metadata support check
         server_version = None
@@ -3290,8 +3291,7 @@ def _write_framework_manifest(
 
     if app_mode == AppModes.PYTHON_SHINY:
         with cli_feedback("Inspecting Shiny for Python app"):
-            if is_express_app(entrypoint + ".py", directory):
-                entrypoint = "shiny.express.app:" + escape_to_var_name(entrypoint + ".py")
+            entrypoint = resolve_shiny_express_entrypoint(entrypoint, directory)
 
     with cli_feedback("Creating manifest.json"):
         environment_file_exists = write_api_manifest_json(

rsconnect/quickstart/quickstart.py

@@ -68,7 +68,7 @@ def run_quickstart(
 
     # Pre-flight checks. Each helper raises ``RSConnectException``
     # with an actionable message; nothing on disk is mutated until every
-    # check has passed. Type validation now lives in Click's argument
+    # check has passed. Type validation lives in Click's argument
     # parser (see ``rsconnect/main.py``), so it has already passed before
     # we get here.
     _require_uv_on_path()
@@ -288,15 +288,6 @@ class TemplateSpec:
         source_files=(FileSpec(name="report.qmd", template="quarto/report.qmd.tmpl"),),
         notes=(_QUARTO_INSTALL_NOTE,),
     ),
-    # quarto-shiny shares the README with quarto-static: same local-run
-    # command, same deploy command, same quarto-install note.
-    AppModes.SHINY_QUARTO: TemplateSpec(
-        pyproject_template="quarto/pyproject_shiny.toml.tmpl",
-        readme_template="quarto/README.md.tmpl",
-        local_run_command=("uv", "run", "quarto", "preview", "report.qmd"),
-        source_files=(FileSpec(name="report.qmd", template="quarto/report_shiny.qmd.tmpl"),),
-        notes=(_QUARTO_INSTALL_NOTE,),
-    ),
 }
 
 

rsconnect/quickstart/templates/quarto/pyproject_shiny.toml.tmpl

@@ -35,11 +35,13 @@
     make_tensorflow_bundle,
     make_tensorflow_manifest,
     make_voila_bundle,
+    resolve_shiny_express_entrypoint,
     to_bytes,
     validate_entry_point,
     validate_extra_files,
     validate_node_entry_point,
 )
+from rsconnect.shiny_express import escape_to_var_name
 from rsconnect.environment_node import NodeEnvironment
 from rsconnect.environment import Environment, PackageInstaller
 from rsconnect.exception import RSConnectException
@@ -1300,6 +1302,17 @@ def test_guess_deploy_dir(self):
         self.assertEqual(abspath(bqplot_dir), guess_deploy_dir(bqplot_ipynb, bqplot_ipynb))
         self.assertEqual(abspath(bqplot_dir), guess_deploy_dir(bqplot_dir, bqplot_ipynb))
 
+    def test_guess_deploy_dir_bare_entrypoint_relative_to_path(self):
+        # A bare entrypoint basename that exists inside ``path`` but not in the
+        # CWD must be accepted (deploy pyproject/voila run from outside the
+        # project pass ``notebook.ipynb`` resolved relative to the directory).
+        bare_entrypoint = basename(bqplot_ipynb)
+        assert not os.path.exists(bare_entrypoint)
+        self.assertEqual(abspath(bqplot_dir), guess_deploy_dir(bqplot_dir, bare_entrypoint))
+        # A bare entrypoint that exists in neither location is still rejected.
+        with self.assertRaises(RSConnectException):
+            guess_deploy_dir(bqplot_dir, "does_not_exist.ipynb")
+
 
 @pytest.mark.parametrize(
     (
@@ -3214,3 +3227,21 @@ def test_ts_bundle_contents(self):
     def test_ts_entrypoint_detection(self):
         ep = get_default_node_entrypoint(_NODE_TS_EXPRESS_DIR)
         assert ep == "app.ts"
+
+
+def test_resolve_shiny_express_entrypoint_bare_name(tmp_path):
+    (tmp_path / "app.py").write_text("from shiny.express import ui\n")
+    resolved = resolve_shiny_express_entrypoint("app", str(tmp_path))
+    assert resolved == "shiny.express.app:" + escape_to_var_name("app.py")
+
+
+def test_resolve_shiny_express_entrypoint_normalizes_py_extension(tmp_path):
+    (tmp_path / "app.py").write_text("from shiny.express import ui\n")
+    assert resolve_shiny_express_entrypoint("app.py", str(tmp_path)) == resolve_shiny_express_entrypoint(
+        "app", str(tmp_path)
+    )
+
+
+def test_resolve_shiny_express_entrypoint_non_express_unchanged(tmp_path):
+    (tmp_path / "app.py").write_text("from shiny import App\n")
+    assert resolve_shiny_express_entrypoint("app.py", str(tmp_path)) == "app.py"

rsconnect/quickstart/templates/quarto/report_shiny.qmd.tmpl

@@ -280,16 +280,16 @@ def test_deploy_pyproject_error_message_mentions_quickstart(runner: CliRunner, p
 ]
 
 
-@pytest.mark.parametrize("app_mode,entrypoint,expected_builder_name", DISPATCH_MATRIX)
-def test_deploy_pyproject_dispatches_by_app_mode(
-    runner: CliRunner,
-    project_dir: pathlib.Path,
-    app_mode: str,
-    entrypoint: str,
-    expected_builder_name: str,
-    monkeypatch: pytest.MonkeyPatch,
-):
-    """Each ``[tool.rsconnect].app_mode`` routes to its matching bundle builder."""
+def _spy_make_bundle(monkeypatch: pytest.MonkeyPatch) -> dict[str, typing.Any]:
+    """Short-circuit a deploy at ``make_bundle`` and capture the dispatched call.
+
+    Records the builder name plus the positional/keyword args passed to
+    ``make_bundle`` (the bundle builder is ``args[0]`` to ``make_bundle`` and the
+    entrypoint is ``args[1]`` of the captured ``args``), then raises a sentinel so
+    no network call happens.
+
+    :param monkeypatch: pytest fixture used to stub out the deploy collaborators.
+    """
     captured: dict[str, typing.Any] = {}
 
     class _StopDispatch(Exception):
@@ -319,6 +319,20 @@ def spy_make_bundle(
     monkeypatch.setattr(api_mod.RSConnectExecutor, "validate_server", lambda self: self)
     monkeypatch.setattr(api_mod.RSConnectExecutor, "validate_app_mode", lambda self, app_mode: self)
     monkeypatch.setattr(api_mod.RSConnectExecutor, "make_bundle", spy_make_bundle)
+    return captured
+
+
+@pytest.mark.parametrize("app_mode,entrypoint,expected_builder_name", DISPATCH_MATRIX)
+def test_deploy_pyproject_dispatches_by_app_mode(
+    runner: CliRunner,
+    project_dir: pathlib.Path,
+    app_mode: str,
+    entrypoint: str,
+    expected_builder_name: str,
+    monkeypatch: pytest.MonkeyPatch,
+):
+    """Each ``[tool.rsconnect].app_mode`` routes to its matching bundle builder."""
+    captured = _spy_make_bundle(monkeypatch)
 
     _write_pyproject(
         project_dir,
@@ -347,6 +361,47 @@ def spy_make_bundle(
         pass
 
 
+_EXPRESS_APP = "from shiny.express import ui\n\nui.h1('hi')\n"
+
+
+def test_deploy_pyproject_shiny_express_entrypoint_matches_deploy_shiny(
+    runner: CliRunner, project_dir: pathlib.Path, monkeypatch: pytest.MonkeyPatch
+):
+    """A Shiny Express app deployed via ``deploy pyproject`` gets the same
+    ``shiny.express.app:`` entrypoint as the dedicated ``deploy shiny`` path.
+
+    Without the rewrite Connect cannot find an application object and the app
+    crashes on boot, so both deploy paths must agree on the express form.
+    """
+    (project_dir / "app.py").write_text(_EXPRESS_APP)
+    _write_pyproject(
+        project_dir,
+        """
+        [project]
+        name = "hello_app"
+        version = "0.0.1"
+        dependencies = ["shiny"]
+
+        [tool.rsconnect]
+        app_mode = "python-shiny"
+        entrypoint = "app.py"
+        title = "Express App"
+        """,
+    )
+    server = ["-s", "http://example.invalid", "-k", "fake-key"]
+
+    captured = _spy_make_bundle(monkeypatch)
+    runner.invoke(cli, ["deploy", "shiny", str(project_dir), *server])
+    shiny_entrypoint = captured["args"][1]
+
+    captured = _spy_make_bundle(monkeypatch)
+    runner.invoke(cli, ["deploy", "pyproject", str(project_dir), *server])
+    pyproject_entrypoint = captured["args"][1]
+
+    assert shiny_entrypoint.startswith("shiny.express.app:")
+    assert pyproject_entrypoint == shiny_entrypoint
+
+
 # ---------------------------------------------------------------------------
 # Title / entrypoint override
 # ---------------------------------------------------------------------------

tests/test_bundle.py

@@ -95,15 +95,31 @@ def test_quickstart_requires_type_and_name(runner: CliRunner, in_tmp_cwd: pathli
     assert result.exit_code != 0
 
 
-def test_quickstart_help_lists_quarto_shiny(runner: CliRunner):
-    """``quarto-shiny`` is a first-class TYPE, not a flag on ``quarto``."""
+def test_quickstart_help_lists_quarto(runner: CliRunner):
+    """``quarto`` is a supported TYPE; the broken ``quarto-shiny`` scaffold was removed."""
     result = runner.invoke(cli, ["quickstart", "--help"])
     assert result.exit_code == 0, result.output
-    assert "quarto-shiny" in result.output
+    assert "quarto" in result.output
+    assert "quarto-shiny" not in result.output
     # The legacy ``--shiny`` flag was removed in favor of the explicit type.
     assert "--shiny" not in result.output
 
 
+def test_quickstart_quarto_shiny_not_supported(runner: CliRunner, in_tmp_cwd: pathlib.Path):
+    """``quarto-shiny`` stays a known alias but no longer scaffolds.
+
+    The template produced an invalid doc that Connect rejected, so the
+    scaffold was removed while the alias still routes to the shared
+    "does not yet support" error rather than a hard "unknown type".
+    """
+    result = _invoke_quickstart(runner, "quarto-shiny", "hello_app")
+    assert result.exit_code != 0
+    combined = result.output + (result.stderr if result.stderr_bytes else "")
+    assert "does not yet support" in combined
+    assert "quarto-shiny" in combined
+    assert not (in_tmp_cwd / "hello_app").exists()
+
+
 @pytest.mark.parametrize(
     "args,expected",
     [
@@ -167,7 +183,7 @@ def test_quickstart_unknown_type_lists_supported(runner: CliRunner, in_tmp_cwd:
     result = _invoke_quickstart(runner, "nonesuch", "hello_app")
     assert result.exit_code != 0
     combined = result.output + (result.stderr if result.stderr_bytes else "")
-    for expected in ("streamlit", "shiny", "fastapi", "api", "flask", "notebook", "voila", "quarto", "quarto-shiny"):
+    for expected in ("streamlit", "shiny", "fastapi", "api", "flask", "notebook", "voila", "quarto"):
         assert expected in combined, f"{expected!r} missing from error output: {combined!r}"
     assert not (in_tmp_cwd / "hello_app").exists()
 
@@ -307,7 +323,6 @@ def test_quickstart_does_not_duplicate_deps_in_tool_rsconnect(runner: CliRunner,
     pytest.param(("notebook",), "jupyter-static", id="notebook-default"),
     pytest.param(("voila",), "jupyter-voila", id="voila"),
     pytest.param(("quarto",), "quarto-static", id="quarto-default"),
-    pytest.param(("quarto-shiny",), "quarto-shiny", id="quarto-shiny"),
 ]
 
 
@@ -591,13 +606,6 @@ def test_quickstart_rolls_back_on_keyboard_interrupt(
         ("Note: Quarto must be installed separately: https://quarto.org",),
         id="quarto-default",
     ),
-    pytest.param(
-        "quarto-shiny",
-        (),
-        "uv run quarto preview report.qmd",
-        ("Note: Quarto must be installed separately: https://quarto.org",),
-        id="quarto-shiny",
-    ),
 ]