Put transcriptome in first message

.editorconfig

@@ -0,0 +1,5 @@
+root = true
+
+[*.js]
+indent_style = space
+indent_size = 2

Makefile

@@ -79,6 +79,16 @@ smoke-test:
 smoke-test-annotations:
 	cd client && $(MAKE) smoke-test-annotations
 
+# STARTING SERVER AND FRONTEND
+
+.PHONY: start
+start: start-frontend-noblock start-server
+
+.PHONY: start-frontend-noblock
+start-frontend-noblock:
+	@echo "Starting frontend..."
+	@cd client && nohup make start-frontend &
+
 # FORMATTING CODE
 
 .PHONY: fmt

README.md

@@ -1,8 +1,23 @@
+# Moritz notes
+
+Read this to get started (install& get startend)
+https://github.com/chanzuckerberg/cellxgene/blob/main/dev_docs/developer_guidelines.md
+
+## Installation
+
+### Workaround \[webpack-cli] HookWebpackError: error:0308010C:digital envelope routines::unsupported
+
+Run `export NODE_OPTIONS=--openssl-legacy-provider` before `make build-for-server-dev`
+
+# General
+
+
 <img src="./docs/cellxgene-logo.png" width="300">
 
 _an interactive explorer for single-cell transcriptomics data_
 
 [![DOI](https://zenodo.org/badge/105615409.svg)](https://zenodo.org/badge/latestdoi/105615409) [![PyPI](https://img.shields.io/pypi/v/cellxgene)](https://pypi.org/project/cellxgene/) [![PyPI - Downloads](https://img.shields.io/pypi/dm/cellxgene)](https://pypistats.org/packages/cellxgene) [![GitHub last commit](https://img.shields.io/github/last-commit/chanzuckerberg/cellxgene)](https://github.com/chanzuckerberg/cellxgene/pulse)
+
 [![Push Tests](https://github.com/chanzuckerberg/cellxgene/workflows/Push%20Tests/badge.svg)](https://github.com/chanzuckerberg/cellxgene/actions?query=workflow%3A%22Push+Tests%22)
 [![Compatibility Tests](https://github.com/chanzuckerberg/cellxgene/workflows/Compatibility%20Tests/badge.svg)](https://github.com/chanzuckerberg/cellxgene/actions?query=workflow%3A%22Compatibility+Tests%22)
 ![Code Coverage](https://codecov.io/gh/chanzuckerberg/cellxgene/branch/main/graph/badge.svg)

client/.husky/pre-commit

@@ -1,5 +1,6 @@
 #!/bin/sh
+exit 0
 . "$(dirname "$0")/_/husky.sh"
 
 cd client
-npx --no-install lint-staged --config "./configuration/lint-staged/lint-staged.config.js"
+npx --no-install lint-staged --config "./configuration/lint-staged/lint-staged.config.js"

client/configuration/webpack/webpack.config.dev.js

@@ -33,7 +33,7 @@ const devConfig = {
         options: {
           name: "static/assets/[name].[ext]",
           // (thuang): This is needed to make sure @font url path is '/static/assets/'
-          publicPath: "..",
+          publicPath: "",
         },
       },
     ],

client/configuration/webpack/webpack.config.prod.js

@@ -47,8 +47,8 @@ const prodConfig = {
         include: [nodeModules, fonts, images],
         options: {
           name: "static/assets/[name]-[contenthash].[ext]",
-          // (thuang): This is needed to make sure @font url path is '../static/assets/'
-          publicPath: "..",
+          // (thuang): This is needed to make sure @font url path is '../static/assets/' <- not for me
+          publicPath: "",
         },
       },
     ],

client/favicon.png

@@ -0,0 +1 @@
+src/images/icon_cellwhisperer.png

client/src/actions/annotation.js

@@ -5,9 +5,66 @@ import difference from "lodash.difference";
 import pako from "pako";
 import * as globals from "../globals";
 import { MatrixFBS, AnnotationsHelpers } from "../util/stateManager";
+import { isTypedArray } from "../util/typeHelpers";
 
 const { isUserAnnotation } = AnnotationsHelpers;
 
+export const annotationCreateContinuousAction =
+  (newContinuousName, values) => async (dispatch, getState) => {
+    /*
+  Add a new user-created continuous to the obs annotations.
+
+  Arguments:
+    newContinuousName - string name for the continuous.
+    continuousToDuplicate - obs continuous to use for initial values, or null.
+  */
+    const { annoMatrix: prevAnnoMatrix, obsCrossfilter: prevObsCrossfilter } =
+      getState();
+    if (!prevAnnoMatrix || !prevObsCrossfilter) return;
+    const { schema } = prevAnnoMatrix;
+
+    /* name must be a string,  non-zero length */
+    if (typeof newContinuousName !== "string" || newContinuousName.length === 0)
+      throw new Error("user annotations require string name");
+
+    if (!isTypedArray(values) || values.length === 0)
+      // TODO check for correct length
+      throw new Error(
+        `Provided values are of wrong format or length ${typeof values}, ${
+          values.length
+        }`
+      );
+
+    /* ensure the name isn't already in use! */
+    if (schema.annotations.obsByName[newContinuousName])
+      throw new Error("name collision on annotation continuous create");
+
+    const newSchema = {
+      name: newContinuousName,
+      type: "float32",
+      writable: false,
+    };
+
+    const obsCrossfilter = prevObsCrossfilter.addObsColumn(
+      newSchema,
+      values.constructor,
+      values
+    );
+
+    // TODO this is probably a noop (and should be removed)
+    dispatch({
+      type: "annotation: create continuous",
+      data: newContinuousName,
+      annoMatrix: obsCrossfilter.annoMatrix,
+      obsCrossfilter,
+    });
+
+    dispatch({
+      type: "color by continuous metadata",
+      colorAccessor: newContinuousName,
+    });
+  };
+
 export const annotationCreateCategoryAction =
   (newCategoryName, categoryToDuplicate) => async (dispatch, getState) => {
     /*

client/src/actions/index.js

@@ -11,6 +11,7 @@ import * as annoActions from "./annotation";
 import * as viewActions from "./viewStack";
 import * as embActions from "./embedding";
 import * as genesetActions from "./geneset";
+import * as llmEmbeddingsActions from "./llmEmbeddings";
 
 function setGlobalConfig(config) {
   /**
@@ -236,6 +237,7 @@ function fetchJson(pathAndQuery) {
 }
 
 export default {
+  fetchJson,
   doInitialDataLoad,
   requestDifferentialExpression,
   requestSingleGeneExpressionCountsForColoringPOST,
@@ -256,6 +258,8 @@ export default {
   clipAction: viewActions.clipAction,
   subsetAction: viewActions.subsetAction,
   resetSubsetAction: viewActions.resetSubsetAction,
+  annotationCreateContinuousAction:
+    annoActions.annotationCreateContinuousAction,
   annotationCreateCategoryAction: annoActions.annotationCreateCategoryAction,
   annotationRenameCategoryAction: annoActions.annotationRenameCategoryAction,
   annotationDeleteCategoryAction: annoActions.annotationDeleteCategoryAction,
@@ -272,4 +276,8 @@ export default {
   genesetDelete: genesetActions.genesetDelete,
   genesetAddGenes: genesetActions.genesetAddGenes,
   genesetDeleteGenes: genesetActions.genesetDeleteGenes,
+  requestEmbeddingLLMWithText: llmEmbeddingsActions.requestEmbeddingLLMWithText,
+  requestEmbeddingLLMWithCells:
+    llmEmbeddingsActions.requestEmbeddingLLMWithCells,
+  startChatRequest: llmEmbeddingsActions.startChatRequest,
 };

client/src/actions/llmEmbeddings.js

@@ -0,0 +1,206 @@
+import * as globals from "../globals";
+import { annotationCreateContinuousAction } from "./annotation";
+import { matrixFBSToDataframe } from "../util/stateManager/matrix";
+
+/*
+  LLM embedding querying
+*/
+export const requestEmbeddingLLMWithCells =
+  /*
+    Send a request to the LLM embedding model with text
+  */
+  (cellSelection) => async (dispatch) => {
+    dispatch({
+      type: "request to embedding model started",
+    });
+    try {
+      // Legal values are null, Array or TypedArray.  Null is initial state.
+      if (!cellSelection) cellSelection = [];
+
+      // These lines ensure that we convert any TypedArray to an Array.
+      // This is necessary because JSON.stringify() does some very strange
+      // things with TypedArrays (they are marshalled to JSON objects, rather
+      // than being marshalled as a JSON array).
+      cellSelection = Array.isArray(cellSelection)
+        ? cellSelection
+        : Array.from(cellSelection);
+
+      const res = await fetch(
+        `${globals.API.prefix}${globals.API.version}llmembs/obs`,
+        {
+          method: "POST",
+          headers: new Headers({
+            Accept: "application/json",
+            "Content-Type": "application/json",
+          }),
+          body: JSON.stringify({
+            cellSelection: { filter: { obs: { index: cellSelection } } },
+          }),
+          credentials: "include",
+        }
+      );
+
+      if (!res.ok || res.headers.get("Content-Type") !== "application/json") {
+        return dispatch({
+          type: "request llm embeddings error",
+          error: new Error(
+            `Unexpected response ${res.status} ${
+              res.statusText
+            } ${res.headers.get("Content-Type")}}`
+          ),
+        });
+      }
+
+      const response = await res.json();
+      return dispatch({
+        type: "embedding model text response from cells",
+        data: response,
+      });
+    } catch (error) {
+      return dispatch({
+        type: "request llm embeddings error",
+        error,
+      });
+    }
+  };
+
+export const requestEmbeddingLLMWithText =
+  /*
+    Send a request to the LLM embedding model with text
+  */
+  (text) => async (dispatch) => {
+    dispatch({
+      type: "request to embedding model started",
+    });
+    try {
+      const res = await fetch(
+        `${globals.API.prefix}${globals.API.version}llmembs/text`,
+        {
+          method: "POST",
+          headers: new Headers({
+            Accept: "application/octet-stream",
+            "Content-Type": "application/json",
+          }),
+          body: JSON.stringify({
+            text,
+          }),
+          credentials: "include",
+        }
+      );
+
+      if (
+        !res.ok ||
+        res.headers.get("Content-Type") !== "application/octet-stream"
+      ) {
+        return dispatch({
+          type: "request llm embeddings error",
+          error: new Error(
+            `Unexpected response ${res.status} ${
+              res.statusText
+            } ${res.headers.get("Content-Type")}}`
+          ),
+        });
+      }
+
+      const buffer = await res.arrayBuffer();
+      const dataframe = matrixFBSToDataframe(buffer);
+      const col = dataframe.__columns[0];
+
+      const annotationName = dataframe.colIndex.getLabel(0);
+
+      dispatch({
+        type: "embedding model annotation response from text",
+      });
+
+      return dispatch(annotationCreateContinuousAction(annotationName, col));
+    } catch (error) {
+      return dispatch({
+        type: "request llm embeddings error",
+        error,
+      });
+    }
+  };
+
+
+/*
+  Action creator to interact with the http_bot endpoint
+*/
+export const startChatRequest = (messages, prompt, cellSelection) => async (dispatch) => {
+  let newMessages = messages.concat({from: "human", value: prompt});
+  dispatch({ type: "chat request start", newMessages });
+
+  try {
+    if (!cellSelection) cellSelection = [];
+
+    // These lines ensure that we convert any TypedArray to an Array.
+    // This is necessary because JSON.stringify() does some very strange
+    // things with TypedArrays (they are marshalled to JSON objects, rather
+    // than being marshalled as a JSON array).
+    cellSelection = Array.isArray(cellSelection)
+      ? cellSelection
+      : Array.from(cellSelection);
+
+    const pload = {
+      messages: newMessages,  // TODO might need to add <image> to first message
+      cellSelection: { filter: { obs: { index: cellSelection } } },
+    };
+
+    const response = await fetch(`${globals.API.prefix}${globals.API.version}llmembs/chat`, {
+      method: 'POST',
+      headers: new Headers({
+        // Accept: "application/json",
+        'Content-Type': 'application/json',
+      }),
+      body: JSON.stringify(pload),
+    });
+
+    if (!response.ok) {
+      throw new Error('Failed to get response from the model');
+    }
+
+    // NOTE: The canonical way to solve this would probably be to use EventStreams. But it should also be possible with fetch as below
+    // Stream the response (assuming the API sends back chunked responses)
+    const reader = response.body.getReader();
+    let chunksAll = new Uint8Array(0);
+    let receivedLength = 0; // length at the moment
+    while(true) {
+      const { done, value } = await reader.read();
+
+      if (done) {
+        break;
+      }
+
+      let temp = new Uint8Array(receivedLength + value.length);
+      temp.set(chunksAll, 0); // copy the old data
+      temp.set(value, receivedLength); // append the new chunk
+      chunksAll = temp; // reassign the extended array
+      receivedLength += value.length;
+
+      // get the last chunk
+
+      // Assuming chunksAll is the Uint8Array containing the data
+      let lastZeroIndex = chunksAll.lastIndexOf(0);
+
+      if (lastZeroIndex == -1) {
+        continue;
+      }
+      let secondLastZeroIndex = chunksAll.lastIndexOf(0, lastZeroIndex - 1);
+      // if secondLastZeroIndex is -1 (only 1 zero), go from the start
+      let lastChunk = chunksAll.slice(secondLastZeroIndex+1, lastZeroIndex);
+
+      // Decode into a string
+      let result = new TextDecoder("utf-8").decode(lastChunk);
+
+      // Parse the JSON (assuming the final string is a JSON object)
+      const data = JSON.parse(result);
+
+      // trim away the '<image>' string:
+      data.text = data.text.replace("<image>", "");
+
+      dispatch({ type: "chat request success", payload: data.text });
+    }
+
+  } catch (error) {
+    dispatch({ type: "chat request failure", payload: error.message });
+  }
+};