support loading of stan playground runs (#85)

magland · jsoules · web-flow · commit ef52102ab385 · 2023-05-31T09:49:57.000-04:00
* support loading of stan playground runs * handle s=spa, empty service URL * address js review of #85 * include spaMode in tests config * set test env to jsdom in vite.config.ts * Revert to node.js default environment. Mock import to avoid error. --------- Co-authored-by: Jeff Soules <jsoules@flatironinstitute.org>
diff --git a/src/MCMCMonitorDataManager/updateSequences.ts b/src/MCMCMonitorDataManager/updateSequences.ts
@@ -1,25 +1,42 @@
-import { GetSequencesRequest, isGetSequencesResponse } from "../../service/src/types";
+import { GetSequencesRequest, isGetSequencesResponse, MCMCSequenceUpdate } from "../../service/src/types";
 import postApiRequest from "../networking/postApiRequest";
+import getSpaSequenceUpdates from "../spaInterface/getSpaSequenceUpdates";
+import { isSpaRunId } from "../spaInterface/util";
 import { MCMCMonitorAction, MCMCMonitorData } from "./MCMCMonitorDataTypes";
 
-
 export default async function updateSequences(data: MCMCMonitorData, dispatch: (a: MCMCMonitorAction) => void) {
     const X = data.sequences.filter(s => (s.updateRequested))
     if (X.length > 0) {
-        const req: GetSequencesRequest = {
-            type: 'getSequencesRequest',
-            sequences: X.map(s => ({
-                runId: s.runId, chainId: s.chainId, variableName: s.variableName, position: s.data.length
-            }))
+        const numSpaRuns = X.filter(s => isSpaRunId(s.runId)).length
+        if ((numSpaRuns > 0) && (numSpaRuns < X.length)) {
+            throw Error('Cannot mix SPA and non-SPA runs in a single updateSequences call')
+        }
+        let sequenceUpdates: MCMCSequenceUpdate[] | undefined
+        if (numSpaRuns === X.length) {
+            const runId = X[0].runId
+            // handle the special case of a stan playground run
+            sequenceUpdates = await getSpaSequenceUpdates(runId, X)
+        }
+        else {
+            // handle the usual case
+            const req: GetSequencesRequest = {
+                type: 'getSequencesRequest',
+                sequences: X.map(s => ({
+                    runId: s.runId, chainId: s.chainId, variableName: s.variableName, position: s.data.length
+                }))
+            }
+            const resp = await postApiRequest(req)
+            if (!isGetSequencesResponse(resp)) {
+                console.warn(resp)
+                throw Error('Unexpected getSequences response')
+            }
+            sequenceUpdates = resp.sequences
         }
-        const resp = await postApiRequest(req)
-        if (!isGetSequencesResponse(resp)) {
-            console.warn(resp)
-            throw Error('Unexpected getSequences response')
+        if (sequenceUpdates) {
+            dispatch({
+                type: "updateSequenceData",
+                sequences: sequenceUpdates
+            })
         }
-        dispatch({
-            type: "updateSequenceData",
-            sequences: resp.sequences
-        })
     }
 }
diff --git a/src/MCMCMonitorDataManager/useMCMCMonitor.ts b/src/MCMCMonitorDataManager/useMCMCMonitor.ts
@@ -1,6 +1,9 @@
 import { useCallback, useContext, useMemo } from 'react'
 import { GetChainsForRunRequest, GetRunsRequest, MCMCChain, MCMCRun, isGetChainsForRunResponse, isGetRunsResponse } from '../../service/src/types'
+import { serviceBaseUrl, spaMode } from '../config'
 import postApiRequest from '../networking/postApiRequest'
+import getSpaChainsForRun from '../spaInterface/getSpaChainsForRun'
+import { isSpaRunId } from '../spaInterface/util'
 import { MCMCMonitorContext, detectedWarmupIterationCount } from './MCMCMonitorData'
 import { GeneralOpts } from './MCMCMonitorDataTypes'
 import updateChains from './updateChains'
@@ -32,6 +35,10 @@ export const useMCMCMonitor = () => {
 
     const updateRuns = useCallback(() => {
         ; (async () => {
+            if (spaMode) return // no need to update runs in spa mode (we only have one run)
+            if (!serviceBaseUrl) {
+                throw Error('Unexpected: cannot update runs. ServiceBaseUrl not set')
+            }
             const req: GetRunsRequest = {
                 type: 'getRunsRequest'
             }
@@ -46,16 +53,25 @@ export const useMCMCMonitor = () => {
 
     const updateChainsForRun = useCallback((runId: string) => {
         ; (async () => {
-            const req: GetChainsForRunRequest = {
-                type: 'getChainsForRunRequest',
-                runId
+            let chains: MCMCChain[]
+            if (isSpaRunId(runId)) {
+                // handle the special case where we have a stan playground run
+                chains = await getSpaChainsForRun(runId)
             }
-            const resp = await postApiRequest(req)
-            if (!isGetChainsForRunResponse(resp)) {
-                console.warn(JSON.stringify(resp))
-                throw Error('Unexpected getChainsForRun response')
+            else {
+                // handle the usual case
+                const req: GetChainsForRunRequest = {
+                    type: 'getChainsForRunRequest',
+                    runId
+                }
+                const resp = await postApiRequest(req)
+                if (!isGetChainsForRunResponse(resp)) {
+                    console.warn(JSON.stringify(resp))
+                    throw Error('Unexpected getChainsForRun response')
+                }
+                chains = resp.chains
             }
-            setChainsForRun(runId, resp.chains)
+            setChainsForRun(runId, chains)
         })()
     }, [setChainsForRun])
 
diff --git a/src/config.ts b/src/config.ts
@@ -8,12 +8,16 @@ export const defaultServiceBaseUrl = 'http://localhost:61542'
 
 export const exampleServiceBaseUrl = 'https://lit-bayou-76056.herokuapp.com'
 
+export const spaMode = queryParams.s === 'spa'
+
 export const serviceBaseUrl = queryParams.s ? (
-    queryParams.s
+    spaMode ? '' : queryParams.s // if we are in spa mode, don't use a serviceBaseUrl
 ) : (
     defaultServiceBaseUrl
 )
 
+export const stanPlaygroundUrl = "https://stan-playground.vercel.app/api/playground"
+
 export const useWebrtc = queryParams.webrtc === '1'
 
 export let webrtcConnectionToService: WebrtcConnectionToService | undefined
diff --git a/src/networking/postApiRequest.ts b/src/networking/postApiRequest.ts
@@ -1,7 +1,9 @@
 import { MCMCMonitorRequest, MCMCMonitorResponse, isMCMCMonitorResponse } from "../../service/src/types"
-import { serviceBaseUrl, useWebrtc, webrtcConnectionToService } from "../config"
+import { serviceBaseUrl, spaMode, useWebrtc, webrtcConnectionToService } from "../config"
 
 const postApiRequest = async (request: MCMCMonitorRequest): Promise<MCMCMonitorResponse> => {
+    if (spaMode) throw Error('Unexpected: cannot postApiRequest in spa mode')
+    if (!serviceBaseUrl) throw Error('Unexpected in postApiRequest: serviceBaseUrl not set')
     // Note: we always use http for probe requests and webrtc signaling requests
     if ((useWebrtc) && (request.type !== 'probeRequest') && (request.type !== 'webrtcSignalingRequest')) {
         if (webrtcConnectionToService && webrtcConnectionToService.status === 'connected') {
diff --git a/src/pages/MainWindow.tsx b/src/pages/MainWindow.tsx
@@ -8,6 +8,7 @@ import useRoute from "../util/useRoute";
 import Home from "./Home";
 import Logo from "./Logo";
 import RunPage from "./RunPage";
+import { constructSpaRunId } from "../spaInterface/util";
 
 
 type Props = {
@@ -22,17 +23,19 @@ const MainWindow: FunctionComponent<Props> = (props: Props) => {
 		updateRuns()
 	}, [updateRuns])
 
-	if (connectedToService === undefined) {
-        return <ConnectionInProgress />
-	}
+    if (serviceBaseUrl) {
+        if (connectedToService === undefined) {
+            return <ConnectionInProgress />
+        }
 
-	if (connectedToService === false) {
-		return (
-            <LogoFrame>
-                <FailedConnection serviceProtocolVersion={serviceProtocolVersion} />
-            </LogoFrame>
-		)
-	}
+        if (connectedToService === false) {
+            return (
+                <LogoFrame>
+                    <FailedConnection serviceProtocolVersion={serviceProtocolVersion} />
+                </LogoFrame>
+            )
+        }
+    }
 
     switch (route.page) {
         case "home":
@@ -45,6 +48,8 @@ const MainWindow: FunctionComponent<Props> = (props: Props) => {
         case "run":
             return <RunPage runId={route.runId} dataManager={dataManager} />
             break
+        case "spa":
+            return <RunPage runId={constructSpaRunId(route.projectId, route.fileName)} dataManager={dataManager} />
         default:
             return <span />
     }
diff --git a/src/pages/RunPage.tsx b/src/pages/RunPage.tsx
@@ -1,5 +1,5 @@
 import { FunctionComponent, useEffect, useMemo } from "react";
-import { MCMCChain, MCMCRun } from "../../service/src/types";
+import { MCMCChain } from "../../service/src/types";
 import MCMCDataManager from "../MCMCMonitorDataManager/MCMCMonitorDataManager";
 import { useMCMCMonitor } from "../MCMCMonitorDataManager/useMCMCMonitor";
 import RunControlPanel from "../components/RunControlPanel";
@@ -14,7 +14,7 @@ type Props = {
 }
 
 const RunPage: FunctionComponent<Props> = ({runId, dataManager}) => {
-	const {runs, chains, sequences, updateChainsForRun, setSelectedChainIds, generalOpts, updateKnownData, setSelectedRunId} = useMCMCMonitor()
+	const {chains, sequences, updateChainsForRun, setSelectedChainIds, generalOpts, updateKnownData, setSelectedRunId} = useMCMCMonitor()
 
     useEffect(() => {
         if (dataManager === undefined) return
@@ -53,8 +53,6 @@ const RunPage: FunctionComponent<Props> = ({runId, dataManager}) => {
 		return Math.max(...a)
 	}, [sequences, runId])
 
-	const run: MCMCRun | undefined = useMemo(() => (runs.filter(r => (r.runId === runId))[0]), [runs, runId])
-
 	const chainsForRun = useMemo(() => {
         return (chains.filter(c => (c.runId === runId))
                       .sort((a, b) => a.chainId.localeCompare(b.chainId)))
@@ -78,7 +76,6 @@ const RunPage: FunctionComponent<Props> = ({runId, dataManager}) => {
 
 	const {width, height} = useWindowDimensions()
 
-	if (!run) return <span>Run not found: {runId}</span>
 	return (
 		<div style={{position: 'absolute', width: width - 40, height: height - 40, margin: 20, overflow: 'hidden'}}>
 			<Splitter
diff --git a/src/spaInterface/getSpaChainsForRun.ts b/src/spaInterface/getSpaChainsForRun.ts
@@ -0,0 +1,27 @@
+import { MCMCChain } from "../../service/src/types";
+import { spaOutputsForRunIds, updateSpaOutputForRun } from "./spaOutputsForRunIds";
+
+const getSpaChainsForRun = async (runId: string): Promise<MCMCChain[]> => {
+    await updateSpaOutputForRun(runId)
+    const cachedEntry = spaOutputsForRunIds[runId]
+    if (!cachedEntry) {
+        console.warn('Unable to load data for run', runId)
+        return []
+    }
+    const spaOutput = cachedEntry.spaOutput
+    const ret: MCMCChain[] = []
+    for (const ch of spaOutput.chains) {
+        ret.push({
+            runId,
+            chainId: ch.chainId,
+            variableNames: Object.keys(ch.sequences),
+            rawHeader: ch.rawHeader,
+            rawFooter: ch.rawFooter,
+            lastChangeTimestamp: Date.now(),
+            excludedInitialIterationCount: ch.numWarmupDraws ?? 0,
+        })
+    }
+    return ret
+}
+
+export default getSpaChainsForRun
diff --git a/src/spaInterface/getSpaSequenceUpdates.ts b/src/spaInterface/getSpaSequenceUpdates.ts
@@ -0,0 +1,27 @@
+import { MCMCSequence, MCMCSequenceUpdate } from "../../service/src/types";
+import { spaOutputsForRunIds, updateSpaOutputForRun } from "./spaOutputsForRunIds";
+
+const getSpaSequenceUpdates = async (runId: string, sequences: MCMCSequence[]): Promise<MCMCSequenceUpdate[] | undefined> => {
+    await updateSpaOutputForRun(runId)
+    const cachedEntry = spaOutputsForRunIds[runId]
+    if (!cachedEntry) {
+        console.warn('Unable to load data for run', runId)
+        return []
+    }
+    const spaOutput = cachedEntry.spaOutput
+    
+    const ret: MCMCSequenceUpdate[] = []
+    for (const seq of sequences) {
+        const data = spaOutput.chains.find(c => c.chainId === seq.chainId)?.sequences[seq.variableName] ?? []
+        ret.push({
+            runId,
+            chainId: seq.chainId,
+            variableName: seq.variableName,
+            position: seq.data.length,
+            data: data.slice(seq.data.length)
+        })
+    }
+    return ret
+}
+
+export default getSpaSequenceUpdates
diff --git a/src/spaInterface/postStanPlaygroundRequest.ts b/src/spaInterface/postStanPlaygroundRequest.ts
@@ -0,0 +1,20 @@
+import { stanPlaygroundUrl } from "../config"
+
+const postStanPlaygroundRequest = async (req: any): Promise<any> => {
+    const url = stanPlaygroundUrl
+
+    const rr = {
+        payload: req
+    }
+    const resp = await fetch(url, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(rr),
+    })
+    const responseData = await resp.json()
+    return responseData
+}
+
+export default postStanPlaygroundRequest
diff --git a/src/spaInterface/spaOutputsForRunIds.ts b/src/spaInterface/spaOutputsForRunIds.ts
@@ -0,0 +1,62 @@
+import postStanPlaygroundRequest from "./postStanPlaygroundRequest";
+import { parseSpaRunId } from "./util";
+
+export type SpaOutput = {
+    chains: {
+        chainId: string,
+        rawHeader: string,
+        rawFooter: string,
+        numWarmupDraws?: number,
+        sequences: {
+            [key: string]: number[]
+        }
+    }[]
+}
+
+export const spaOutputsForRunIds: {[key: string]: {
+    sha1: string,
+    spaOutput: SpaOutput
+}} = {}
+
+export const updateSpaOutputForRun = async (runId: string) => {
+    const {projectId, fileName} = parseSpaRunId(runId)
+    
+    // first we need to get the sha1 of the latest file
+    const req = {
+        type: 'getProjectFile',
+        timestamp: Date.now() / 1000,
+        projectId,
+        fileName
+    }
+    const resp = await postStanPlaygroundRequest(req)
+    if (resp.type !== 'getProjectFile') {
+        console.warn(resp)
+        throw Error('Unexpected response from Stan Playground')
+    }
+    const sha1 = resp.projectFile.contentSha1
+
+    const cachedEntry = spaOutputsForRunIds[runId]
+    if ((cachedEntry && cachedEntry.sha1 === sha1)) {
+        // we already have the latest version
+        return
+    }
+
+    const req2 = {
+        type: 'getDataBlob',
+        timestamp: Date.now() / 1000,
+        workspaceId: resp.projectFile.workspaceId,
+        projectId,
+        sha1
+    }
+    const resp2 = await postStanPlaygroundRequest(req2)
+    if (resp2.type !== 'getDataBlob') {
+        console.warn(resp2)
+        throw Error('Unexpected response from Stan Playground')
+    }
+    const x = JSON.parse(resp2.content)
+    const spaOutput = x as SpaOutput
+    spaOutputsForRunIds[runId] = {
+        sha1,
+        spaOutput
+    }
+}
diff --git a/src/spaInterface/util.ts b/src/spaInterface/util.ts
@@ -0,0 +1,19 @@
+export const isSpaRunId = (runId: string): boolean => {
+    return runId.startsWith('spa|')
+}
+
+export const constructSpaRunId = (projectId: string, fileName: string): string => {
+    return `spa|${projectId}|${fileName}`
+}
+
+export const parseSpaRunId = (runId: string): {projectId: string, fileName: string} => {
+    const a = runId.split('|')
+    if (a.length !== 3) throw Error(`Invalid SPA runId: ${runId}`)
+    if (a[0] !== 'spa') throw Error(`Invalid SPA runId: ${runId}`)
+    const projectId = a[1]
+    const fileName = a[2]
+    return {
+        projectId,
+        fileName
+    }
+}
diff --git a/src/util/useRoute.ts b/src/util/useRoute.ts
diff --git a/test/MCMCMonitorDataManager/updateSequences.test.ts b/test/MCMCMonitorDataManager/updateSequences.test.ts
diff --git a/test/networking/postApiRequest.test.ts b/test/networking/postApiRequest.test.ts
diff --git a/vite.config.ts b/vite.config.ts
