minimal working

.gitignore

@@ -0,0 +1 @@
+__pycache__

Dockerfile

@@ -0,0 +1,34 @@
+FROM debian:latest AS base
+
+RUN apt-get update \
+    && apt-get install -y curl \
+    && apt-get clean
+
+# Create user
+RUN useradd -m -u 1000 user
+USER user
+ENV HOME=/home/user \
+	PATH=/home/user/.local/bin:/home/user/.pixi/bin:$PATH \
+    PUP=/home/user/pup
+
+WORKDIR $HOME
+
+CMD ["bash"]
+
+
+#### Puppy ####
+FROM base AS puppy
+
+COPY --chown=user pup .
+
+RUN $PUP
+
+RUN pup py3.11
+
+RUN pup fetch appenv duckdb gradio itables
+
+COPY --chown=user *.py .
+
+EXPOSE 7860
+CMD ["appenv/.venv/bin/uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]
+# CMD ["pup", "play"]

README.md

@@ -1,10 +1,8 @@
 ---
-title: Duckdb Fastapi Gradio
-emoji: 👁
+title: Duckdb FastAPI Gradio
+emoji: 🐕
 colorFrom: red
 colorTo: pink
 sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+pinned: true
+---

main.py

@@ -0,0 +1,137 @@
+__doc__ = """
+This FastAPI app uses gradio components with SQL code input
+and HTML table output.  The query is executed using DuckDB.
+The query results are shown in an iframe where the table
+is styled and made interactive using Datatables.net scripts.
+
+"""
+
+import gradio as gr
+import pandas as pd
+from fastapi import FastAPI
+from fastapi.responses import HTMLResponse, RedirectResponse
+from itables import to_html_datatable
+
+from sql import Q
+
+app = FastAPI()
+
+def query_from_request(query, request: gr.Request):
+    """Process query from input block or from initial request.
+
+    https://github.com/gradio-app/gradio/issues/7464#issuecomment-1960161591
+    """
+    if not query:
+        query_params = request.query_params
+        base64query = dict(query_params).get("q")
+    else:
+        base64query = Q(query).base64
+    if base64query in (None, "example"):
+        decoded = Q("""SELECT 42 AS answer, 'LU & E' AS question""")
+        base64query = decoded.base64
+    else:
+        decoded = Q.from_base64(base64query)
+    href = format_href(base64query)
+    result = f"""<iframe src="/q/{base64query}" width="90%" height="90%"></iframe>"""
+    return (decoded, href, result)
+
+def format_href(url: str):
+    href=f"localhost:7860/sql/{url}"
+    return f"""<a href="{href}">{href}</a>"""
+
+@app.get("/q/{base64query}", response_class=HTMLResponse)
+def query_db(base64query: str|None = None):
+    decoded = Q.from_base64(base64query)
+    df = decoded.df()
+    html = to_html_datatable(df)
+    return f"""
+        <h3>{decoded}</h3>
+        <div>{html}</div>
+    """
+
+with gr.Blocks() as gradio_sql_interface:
+    with gr.Row():
+        with gr.Column():
+            header = gr.Markdown("# SQL Editor")
+            sql_code = gr.Code(language="sql", label="SQL Query", interactive=True)
+            copy_button = gr.HTML()
+            button = gr.Button("run")
+        with gr.Column():
+            markdown = gr.Markdown("# RESULTS")
+            results = gr.HTML()
+    button.click(query_from_request, [sql_code], [sql_code, copy_button, results]) 
+    gradio_sql_interface.load(query_from_request, [sql_code], [sql_code, copy_button, results], queue=True)
+
+app = gr.mount_gradio_app(app, gradio_sql_interface, path="/sql")
+
+@app.get("/")
+@app.get("/sql")
+@app.get("/sql/")
+def redirect_to_example():
+    return RedirectResponse("/sql/?q=example")
+
+# no need to mount/unmount dynamically
+# just change path and app blocks?
+# {
+#   "api.routes": [
+#     "...",
+#     "Mount(path='/gradiosql/qq', name='', app=<gradio.routes.App object at 0x71dc7b9d6d10>)"
+#   ]
+# }
+# @app.get("/sql/{query}")
+# def render_query(query: str):
+#     # unmount any previous gradio apps
+#     # for route in app.routes:
+#     #     if "gradio" in route.path:
+#     #         del route
+#     # global app
+#     # routes = [route for route in app.routes if 'gradio' not in route.path]
+#     # app = Starlette(routes=routes)
+#     with gr.Blocks() as gradio_sql_interface:
+#         sql_code = gr.Code(value=query, language="sql", label="SQL Query", interactive=True)
+#         button = gr.Button("run", link=f"/sql/{sql_code.value}")
+#         markdown = gr.Markdown("# RESULTS")
+#         html = gr.HTML(value=f"""<iframe src="/q/{query}" width="90%" height="90%"></iframe>""")
+#         # button.click(None, [], [], js=f"window.open('/sql/{sql_code.value}', '_top')")
+
+#     gradio_path = f"/gradiosql/{sql_code.value}"
+    # gr.mount_gradio_app(app, gradio_sql_interface, path=gradio_path)
+
+    # return RedirectResponse(gradio_path)
+
+#     del app.routes[index]
+# @app.get("/redirect")
+# async def redirect_example():
+#     url = "/q/qqq"
+#     return Response(status_code=302, headers={"Location": url})
+
+
+    
+#     # return """hi<hr><iframe src="/" width="80%" height="80%"></iframe>"""
+
+# @app.get("/qq/{apath}")
+# async def build_sql_interface(apath: str):
+#     with gr.Blocks() as gradio_sql_interface:
+#         sql_code = gr.Code(value=apath, language="sql", label="SQL Query", interactive=True)
+#         html_code = gr.Code(value=html)
+#         html_html = gr.HTML(value=f"""<iframe src="/q/{apath}" width="80%" height="80%"></iframe>""")
+#         grdf = gr.DataFrame(value=df)
+#         # gradio_sql_interface.queue() 
+
+#     gr.mount_gradio_app(app, gradio_sql_interface, path="/gradio/{apath}")
+#     # import time; time.sleep(1)
+#     return RedirectResponse("/gradio/{{apath}}")
+    # async with httpx.AsyncClient() as client:
+    #     try:
+    #         response = await client.get("/gradio")
+    #         response.raise_for_status()
+    #         return response
+    #     except httpx.HTTPError as e:
+    #         return {"errresponse": e}
+    #         pass #raise HTTPException(status_code=exc.status_code, detail=exc.msg)
+    # return {"path":path}
+
+# if __name__ == "__main__":
+#     import uvicorn
+#     uvicorn.run(app, host="0.0.0.0", port=7860)
+# appenv/.venv/bin/uvicorn main:app --host 0.0.0.0 --port 7860

pup

@@ -0,0 +1,238 @@
+#!/usr/bin/bash
+VERSION="pup v0 @ Apr 2 2024"  # for Debian
+
+
+####################
+#### Parameters ####
+####################
+
+LOG=.woof.log
+# PIXI_DEFAULT_TASK="echo" #"$HOME/appenv/.venv/bin/uvicorn main:app --host 0.0.0.0 --port 7860"
+SYMLINK_ON_PATH=$HOME/.local/bin/pup
+USAGE_MAIN="\n
+\e[1m\e[4mUsage\e[0m: (each subcommand shows more help)\n
+\e[0;33mpup\e[0m\n
+\tinitialize and link 🐶 to PATH\n
+\e[0;33mpup py\e[0m\n
+\tinteractively install base python to current folder\n
+\tif you know what you need:\n
+\tpup py3.12 jupyter jupyter-collaboration>=2\n
+\t(additional arguments go into 'pixi add')\n
+\e[0;33mpup fetch\e[0m\n
+\tinteractively install packages with uv into specified virtual env\n
+\tif you know what you need:\n
+\tpup fetch . duckdb\n
+\tpup fetch newviz altair seaborn\n
+\e[0;33mpup install\e[0m\n
+\tsame as pup fetch\n
+\e[0;33mpup home\e[0m\n
+\tshow 🐶's home folder\n
+\e[0;33mpup kernel\e[0m\n
+\tinteractively create Jupyter kernel linked to 🐶's environment\n
+\tif you know what you need:\n
+\tpup kernel . pup3.11-home\n
+\tpup kernel dataenv pup3.11-data\n
+\e[0;33mpup play\e[0m\n
+\truns PIXI_DEFAULT_TASK (default: 'jupyter notebook')\n
+\e[0;33mpup whereami\e[0m\n
+\tin case you got lost: log of 🐶's commands thus far\n
+\e[0;33mpup which\e[0m\n
+\tshow 🐶's current symlink\n
+\n"
+
+
+###################
+#### Functions ####
+###################
+
+log_command() {
+    ts=$(date +'%FT%T')
+    echo "# $ts" >> "$(pup home)/$LOG"
+    echo "$1" >> "$(pup home)/$LOG"
+}
+
+log() {
+    ts=$(date +'%FT%T')
+    for arg in "$@"; do
+        echo "# $ts - $arg" | tee -a "$(pup home)/$LOG"
+    done
+}
+
+
+#######################
+#### CORE COMMANDS ####
+#######################
+
+#### init (no args) ####
+if [ -z "$1" ]; then
+    # init pup and show usage
+    echo -e $USAGE_MAIN
+
+    # link
+    SYMLINK_CURRENT=$(readlink -f "$SYMLINK_ON_PATH")
+    if [ "$SYMLINK_CURRENT" != "$(pwd)/pup" ] && [ -f "./pup" ]; then
+        SYMLINK_PATH_FOLDER=${SYMLINK_ON_PATH%/*}
+        mkdir -p "$SYMLINK_PATH_FOLDER"
+        ln -s -f "$(pwd)"/pup $SYMLINK_ON_PATH
+    fi
+    log_command "$0 $*"
+    log woof!
+    log "🐶 = $(pup which)"
+    # initialize Pixi project in 'pup home'
+    pup pixi init
+    exit 0
+fi
+#### py|python ####
+if [[ "$1" =~ ^py$|^python$ ]]; then
+    USAGE="\n
+    \e[1m\e[4mUsage\e[0m: pup $1{version} [ADDITIONAL PACKAGES]\n
+    For example:\n
+    \tpup py3.12 jupyter jupyter-collaboration>=2\n
+    \e[4mNote\e[0m:\n
+    \tthis command is meant to be used once during the first base layer setup;\n
+    \tbeyond that, use 'pixi add'\n
+    \n"
+    echo -e $USAGE
+    read -ei "" -p $'\e[0;33minstall which python version (blank = latest)? \e[0m' PYVER
+    PACKAGES=${@:2}
+    read -ei "${PACKAGES:-notebook>=7}" -p $'\e[0;33many additional packages? \e[0m' PACKAGES
+    pup pixi init
+    COMMAND="pixi add uv python${PYVER:+=$PYVER} $PACKAGES"
+    log "🐶 asked for: '$COMMAND'"
+    $COMMAND
+    exit 0
+fi
+if [[ "$1" =~ ^py3.*$ ]]; then
+    log_command "$0 $*"
+    pup pixi init
+    COMMAND="pixi add uv python=${1#py} ${@:2}"
+    log "🐶 asked for: '$COMMAND'"
+    $COMMAND
+    log "✨ $(pixi run python -VV)"
+    exit 0
+fi
+#### fetch|install ####
+if [[ "$1" =~ ^fetch$|^install$ ]]; then
+    USAGE="\e[1m\e[4mUsage\e[0m: pup $1 [WHERE] [WHAT] [OPTIONS]"
+    if [ -z "$2" ]; then
+        echo -e $USAGE
+        read -ei "." -p "Fetch packages where? " WHERE
+        read -ei "" -p "What packages? " WHAT
+        read -ei "" -p "Options to pass to 'uv pip install'? " OPTIONS
+        COMMAND="pup fetch $WHERE $WHAT $OPTIONS"
+        log "🐶 asked for: '$COMMAND'"
+        $COMMAND
+        exit 0
+    fi
+    if [ $# -eq 2 ]; then
+        echo "`🐶 fetch` needs more arguments"
+        echo -e $USAGE
+    fi
+    if [ $# -gt 2 ] && [ "$2" = "." ]; then
+        PYTHON=$(pixi run which python)
+    fi
+    if [ $# -gt 2 ] && [ "$2" != "." ]; then
+        pup new $2
+        PYTHON="$(pup home)/$2/.venv/bin/python"
+    fi
+    COMMAND="pixi run uv pip install -p $PYTHON ${@:3}"
+    log "🐶 asked for: '$COMMAND'"
+    $COMMAND
+    exit 0
+fi
+#### kernel ####
+if [ "$1" == "kernel" ]; then
+    USAGE="\e[1m\e[4mUsage\e[0m: pup $1 [WHERE] [KERNEL_NAME]"
+    if [ -z "$2" ]; then
+        echo -e $USAGE
+        read -ei "." -p "Install kernel for which environment? " WHERE
+        PYVER=$(pixi run python -V); PYVER=${PYVER#Python }
+        read -ei "pup$PYVER-$WHERE" -p "Unique kernel name? (allowed characters: [a-zA-Z0-9.-_]) " KERNEL_NAME
+        COMMAND="pup kernel $WHERE $KERNEL_NAME"
+        log "🐶 asked for: '$COMMAND'"
+        $COMMAND
+        exit 0
+    fi
+    if [ $# -eq 2 ]; then
+        echo "`🐶 kernel` needs more arguments"
+        echo -e $USAGE
+    fi
+    if [ $# -gt 2 ] && [ "$2" = "." ]; then
+        PYTHON=$(pixi run which python)
+    fi
+    if [ $# -gt 2 ] && [ "$2" != "." ]; then
+        PYTHON="$(pup home)/$2/.venv/bin/python"
+    fi
+    pup fetch $2 ipykernel
+    COMMAND="$PYTHON -m ipykernel install --user --name $3"
+    log "🐶 asked for: '$COMMAND'"
+    $COMMAND
+    exit 0
+fi
+#### new ####
+if [ "$1" == "new" ]; then
+    log_command "$0 $*"
+    VENV_PATH="$(pup home)/$2/.venv"
+    if [ ! -d "$VENV_PATH" ]; then
+        pixi run uv venv -p "$(pixi run which python)" $VENV_PATH
+        log "pup & uv created new environment in $2"
+    else
+        log "found existing uv virtual environment $2"
+    fi
+    exit 0
+fi
+#### play ####
+if [ "$1" == "play" ]; then
+    pixi run start
+    exit 0
+fi
+#########################
+#### HELPER COMMANDS ####
+#########################
+#### home ####
+if [ "$1" == "home" ]; then
+    if [ -L "$0" ]; then
+        dirname $(readlink -f $SYMLINK_ON_PATH)
+    else
+        realpath $(dirname $0)
+    fi
+    exit 0
+fi
+#### pixi ####
+if [ "$1" == "pixi" ]; then
+    if [ "$2" == "init" ]; then
+        # install and init Pixi project in pup's home dir
+        if ! command -v pixi &> /dev/null; then
+            export SHELL=bash
+            curl -fsSL https://pixi.sh/install.sh | bash
+        fi
+        PUPHOME=$(pup home)
+        if [[ ! -f "$PUPHOME"/pixi.toml ]]; then
+            pixi init "$PUPHOME"
+            # pixi task add start "$PIXI_DEFAULT_TASK"
+        fi
+        exit 0
+    fi
+    if [ "$2" == "rm" ]; then
+        # remove pixi files
+        rm -r "$(pup home)"/.pixi "$(pup home)"/pixi*
+        exit 0
+    fi
+fi
+#### version ####
+if [ "$1" == "version" ]; then
+    echo $VERSION
+    exit 0
+fi
+#### which ####
+if [ "$1" == "which" ]; then
+    echo $(ls "$SYMLINK_ON_PATH") -\> $(readlink -f $SYMLINK_ON_PATH)
+    exit 0
+fi
+#### whereami ####
+if [ "$1" == "whereami" ]; then
+    cat "$(pup home)/$LOG"
+    exit 0
+fi
+#### unknown command ####
+echo -e "\e[0;33m🐶 does not know 'pup $*'\e[0m\nrun 'pup' to list known commands"

sql.py

@@ -0,0 +1,35 @@
+import base64
+import duckdb
+class Q(str):
+    UNSAFE = ["CREATE", "DELETE", "DROP", "INSERT", "UPDATE"]
+    
+    def __init__(self, query: str):
+        self.is_safe = not any([cmd in query.upper() for cmd in self.UNSAFE])
+
+    def run(self, sql_engine=None):    
+        try:
+            if sql_engine is None:
+                return self.run_duckdb()
+            else:
+                return self.run_sql(sql_engine)
+        except Exception as e:
+            pass   
+    
+    def run_duckdb(self):
+        return duckdb.sql(self)
+
+    def df(self, sql_engine=None):
+        result = self.run(sql_engine=sql_engine)
+        if result is None: return
+        result_df = result.df()
+        return result_df
+
+
+    @property
+    def base64(self):
+        return base64.b64encode(self.encode()).decode()
+
+    @classmethod
+    def from_base64(cls, b64):
+        """Initializing from base64-encoded URL paths."""
+        return cls(base64.b64decode(b64).decode())