rsconnect-python 1.30.0__py3-none-any.whl

rsconnect/quickstart/templates/notebook/notebook.ipynb.tmpl

@@ -0,0 +1,34 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
+   "metadata": {},
+   "source": [
+    "# Hello from $name"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "id": "b2c3d4e5-f6a7-8901-bcde-f23456789012",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print('Hello from $name!')"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "name": "python"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

rsconnect/quickstart/templates/notebook/pyproject.toml.tmpl

@@ -0,0 +1,13 @@
+[project]
+name = "$name"
+version = "0.0.1"
+requires-python = "$requires_python"
+dependencies = [
+    "jupyter",
+]
+
+[tool.rsconnect]
+app_mode = "jupyter-static"
+entrypoint = "notebook.ipynb"
+title = "$name"
+requirements_file = "uv.lock"

rsconnect/quickstart/templates/quarto/README.md.tmpl

@@ -0,0 +1,19 @@
+# $name
+
+A Posit Connect project scaffolded by `rsconnect quickstart`.
+
+## Run locally
+
+```
+uv run quarto preview report.qmd
+```
+
+## Deploy to Posit Connect
+
+```
+rsconnect deploy pyproject .
+```
+
+## Notes
+
+- Quarto must be installed separately: https://quarto.org

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

@@ -0,0 +1,11 @@
+[project]
+name = "$name"
+version = "0.0.1"
+requires-python = "$requires_python"
+dependencies = []
+
+[tool.rsconnect]
+app_mode = "quarto-static"
+entrypoint = "report.qmd"
+title = "$name"
+requirements_file = "uv.lock"

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

@@ -0,0 +1,8 @@
+---
+title: "$name"
+format: html
+---
+
+# Hello from $name
+
+This is a minimal Quarto document.

rsconnect/quickstart/templates/shiny/README.md.tmpl

@@ -0,0 +1,15 @@
+# $name
+
+A Posit Connect project scaffolded by `rsconnect quickstart`.
+
+## Run locally
+
+```
+uv run shiny run app.py
+```
+
+## Deploy to Posit Connect
+
+```
+rsconnect deploy pyproject .
+```

rsconnect/quickstart/templates/shiny/app.py.tmpl

@@ -0,0 +1,3 @@
+from shiny.express import ui
+
+ui.h1("Hello from $name!")

rsconnect/quickstart/templates/shiny/pyproject.toml.tmpl

@@ -0,0 +1,13 @@
+[project]
+name = "$name"
+version = "0.0.1"
+requires-python = "$requires_python"
+dependencies = [
+    "shiny",
+]
+
+[tool.rsconnect]
+app_mode = "python-shiny"
+entrypoint = "app.py"
+title = "$name"
+requirements_file = "uv.lock"

rsconnect/quickstart/templates/streamlit/README.md.tmpl

@@ -0,0 +1,15 @@
+# $name
+
+A Posit Connect project scaffolded by `rsconnect quickstart`.
+
+## Run locally
+
+```
+uv run streamlit run app.py
+```
+
+## Deploy to Posit Connect
+
+```
+rsconnect deploy pyproject .
+```

rsconnect/quickstart/templates/streamlit/app.py.tmpl

@@ -0,0 +1,3 @@
+import streamlit as st
+
+st.write("Hello from $name!")

rsconnect/quickstart/templates/streamlit/pyproject.toml.tmpl

@@ -0,0 +1,13 @@
+[project]
+name = "$name"
+version = "0.0.1"
+requires-python = "$requires_python"
+dependencies = [
+    "streamlit",
+]
+
+[tool.rsconnect]
+app_mode = "python-streamlit"
+entrypoint = "app.py"
+title = "$name"
+requirements_file = "uv.lock"

rsconnect/quickstart/templates/voila/README.md.tmpl

@@ -0,0 +1,15 @@
+# $name
+
+A Posit Connect project scaffolded by `rsconnect quickstart`.
+
+## Run locally
+
+```
+uv run voila notebook.ipynb
+```
+
+## Deploy to Posit Connect
+
+```
+rsconnect deploy pyproject .
+```

rsconnect/quickstart/templates/voila/pyproject.toml.tmpl

@@ -0,0 +1,14 @@
+[project]
+name = "$name"
+version = "0.0.1"
+requires-python = "$requires_python"
+dependencies = [
+    "voila",
+    "jupyter",
+]
+
+[tool.rsconnect]
+app_mode = "jupyter-voila"
+entrypoint = "notebook.ipynb"
+title = "$name"
+requirements_file = "uv.lock"

rsconnect/shiny_express.py

@@ -0,0 +1,136 @@
+# The contents of this file are copied from:
+# https://github.com/posit-dev/py-shiny/blob/feb4cb7f872922717c39753514ae2d7fa32f10a1/shiny/express/_is_express.py
+
+from __future__ import annotations
+
+import ast
+import re
+import sys
+from pathlib import Path
+from typing import Literal, cast
+
+__all__ = ("is_express_app",)
+
+
+def is_express_app(app: str, app_dir: str | None) -> bool:
+    """Detect whether an app file is a Shiny express app
+
+    Parameters
+    ----------
+    app
+        App filename, like "app.py". It may be a relative path or absolute path.
+    app_dir
+        Directory containing the app file. If this is `None`, then `app` must be an
+        absolute path.
+
+    Returns
+    -------
+    :
+        `True` if it is a Shiny express app, `False` otherwise.
+    """
+    if not app.lower().endswith(".py"):
+        return False
+
+    if app_dir is not None:
+        app_path = Path(app_dir) / app
+    else:
+        app_path = Path(app)
+
+    if not app_path.exists():
+        return False
+
+    try:
+        # Read the file, parse it, and look for any imports of shiny.express.
+        with open(app_path, encoding="utf-8") as f:
+            content = f.read()
+
+        # Check for magic comment in the first 1000 characters
+        forced_mode = find_magic_comment_mode(content[:1000])
+        if forced_mode == "express":
+            return True
+        elif forced_mode == "core":
+            return False
+
+        tree = ast.parse(content, app_path)
+        detector = DetectShinyExpressVisitor()
+        detector.visit(tree)
+
+    except Exception:
+        return False
+
+    return detector.found_shiny_express_import
+
+
+class DetectShinyExpressVisitor(ast.NodeVisitor):
+    def __init__(self):
+        super().__init__()
+        self.found_shiny_express_import = False
+
+    def visit_Import(self, node: ast.Import) -> None:
+        if any(alias.name == "shiny.express" for alias in node.names):
+            self.found_shiny_express_import = True
+
+    def visit_ImportFrom(self, node: ast.ImportFrom) -> None:
+        if node.module == "shiny.express":
+            self.found_shiny_express_import = True
+        elif node.module == "shiny" and any(alias.name == "express" for alias in node.names):
+            self.found_shiny_express_import = True
+
+    # Visit top-level nodes.
+    def visit_Module(self, node: ast.Module) -> None:
+        super().generic_visit(node)
+
+    # Don't recurse into any nodes, so the we'll only ever look at top-level nodes.
+    def generic_visit(self, node: ast.AST) -> None:
+        pass
+
+
+def find_magic_comment_mode(content: str) -> Literal["core", "express"] | None:
+    """
+    Look for a magic comment of the form "# shiny_mode: express" or "# shiny_mode:
+    core".
+
+    If a line of the form "# shiny_mode: x" is found, where "x" is not "express" or
+    "core", then a message will be printed to stderr.
+
+    Returns
+    -------
+    :
+        `"express"` if Shiny Express comment is found, `"core"` if Shiny Core comment is
+        found, and `None` if no magic comment is found.
+    """
+    m = re.search(r"^#[ \t]*shiny_mode:[ \t]*(\S*)[ \t]*$", content, re.MULTILINE)
+    if m is not None:
+        shiny_mode = cast(str, m.group(1))
+        if shiny_mode in ("express", "core"):
+            # The "type: ignore" is needed for mypy, which is used on some projects that
+            # use duplicates of this code.
+            return shiny_mode  # type: ignore
+        else:
+            print(f'Invalid shiny_mode: "{shiny_mode}"', file=sys.stderr)
+
+    return None
+
+
+def escape_to_var_name(x: str) -> str:
+    """
+    Given a string, escape it to a valid Python variable name which contains
+    [a-zA-Z0-9_]. All other characters will be escaped to _<hex>_. Also, if the first
+    character is a digit, it will be escaped to _<hex>_, because Python variable names
+    can't begin with a digit.
+    """
+    encoded = ""
+    is_first = True
+
+    for char in x:
+        if is_first and re.match("[0-9]", char):
+            encoded += f"_{ord(char):x}_"
+        elif re.match("[a-zA-Z0-9]", char):
+            encoded += char
+        else:
+            encoded += f"_{ord(char):x}_"
+
+        if is_first:
+            is_first = False
+
+    return encoded

rsconnect/snowflake.py

@@ -0,0 +1,93 @@
+# pyright: reportMissingTypeStubs=false, reportUnusedImport=false
+from __future__ import annotations
+
+import json
+from subprocess import CalledProcessError, CompletedProcess, run
+from typing import Any, Dict, List, Optional
+
+from .exception import RSConnectException
+from .log import logger
+
+
+def snow(*args: str) -> CompletedProcess[str]:
+    ensure_snow_installed()
+    return run(["snow"] + list(args), capture_output=True, text=True, check=True)
+
+
+def ensure_snow_installed() -> None:
+    try:
+        import snowflake.cli  # noqa: F401
+
+        logger.debug("snowflake-cli is installed.")
+
+    except ImportError:
+        logger.warning("snowflake-cli is not installed.")
+        try:
+            run(["snow", "--version"], capture_output=True, check=True)
+        except CalledProcessError:
+            raise RSConnectException("snow is installed but could not be run.")
+        except FileNotFoundError:
+            raise RSConnectException("snow cannot be found.")
+
+
+def list_connections() -> List[Dict[str, Any]]:
+
+    try:
+        res = snow("connection", "list", "--format", "json")
+        connection_list = json.loads(res.stdout)
+        return connection_list
+    except CalledProcessError:
+        raise RSConnectException("Could not list snowflake connections.")
+
+
+def get_parameters(name: Optional[str] = None) -> Dict[str, Any]:
+    """Get Snowflake connection parameters.
+    Args:
+        name: The name of the connection to retrieve. If None, returns the default connection.
+
+    Returns:
+        A dictionary of connection parameters.
+    """
+    try:
+        from snowflake.connector.config_manager import CONFIG_MANAGER
+    except ImportError:
+        raise RSConnectException("snowflake-cli is not installed.")
+    try:
+        connections = CONFIG_MANAGER["connections"]
+        if not isinstance(connections, dict):
+            raise TypeError("connections is not a dictionary")
+
+        if name is None:
+            def_connection_name = CONFIG_MANAGER["default_connection_name"]
+            if not isinstance(def_connection_name, str):
+                raise TypeError("default_connection_name is not a string")
+            params = connections[def_connection_name]
+        else:
+            params = connections[name]
+
+        if not isinstance(params, dict):
+            raise TypeError("connection parameters is not a dictionary")
+
+        return {str(k): v for k, v in params.items()}
+
+    except (KeyError, AttributeError) as e:
+        raise RSConnectException(f"Could not get Snowflake connection: {e}")
+
+
+def generate_jwt(name: Optional[str] = None) -> str:
+
+    _ = get_parameters(name)
+    connection_name = "" if name is None else name
+
+    try:
+        res = snow("connection", "generate-jwt", "--connection", connection_name, "--format", "json")
+        try:
+            output = json.loads(res.stdout)
+        except json.JSONDecodeError:
+            raise RSConnectException(f"Failed to parse JSON from snow-cli: {res.stdout}")
+        jwt = output.get("message")
+        if jwt is None:
+            raise RSConnectException(f"Failed to generate JWT: Missing 'message' field in response: {output}")
+        return jwt
+    except CalledProcessError as e:
+        raise RSConnectException(f"Failed to generate JWT for connection '{name}': {e.stderr}")