Create app.py

app.py

@@ -0,0 +1,194 @@
+import openai
+import streamlit as st
+import os
+import json
+import time
+from annotated_text import annotated_text
+
+
+with open('demo.json') as f:
+    tmp = json.load(f)
+
+
+dax_input = st.text_area("DAX input")
+
+
+def generate_annotated_array(text, json_data):
+    """
+    Generate an array of strings based on annotations from the JSON data.
+
+    Parameters:
+    - text (str): The input text to be annotated.
+    - json_data (dict): The JSON data containing annotations.
+
+    Returns:
+    - list: An array of strings with separate elements for each annotation.
+    """
+    entities = json_data['documents'][0]['entities']
+    output = []
+    index = 0
+    buffer_text = ""
+
+    while index < len(text):
+        # Find the entity that matches the current position
+        entity = next((e for e in entities if e['offset'] == index), None)
+        
+        if entity:
+            # If there's buffer_text, add it to the output
+            if buffer_text:
+                output.append(buffer_text)
+                buffer_text = ""
+            
+            # Add the annotated entity to the output
+            output.append("[" + entity['text'] + ":" + entity['category'] + "]")
+            index += entity['length']
+        else:
+            # If no entity is found, add the character to buffer_text
+            buffer_text += text[index]
+            index += 1
+
+    # Add any remaining buffer_text to the output
+    if buffer_text:
+        output.append(buffer_text)
+
+    return output
+
+import requests
+
+
+import requests
+import time 
+
+def analyze_healthcare_text(text):
+    # Endpoint, headers and subscription key
+    base_url = "https://ta4h-endpoint.cognitiveservices.azure.com/language/analyze-text/jobs"
+    headers = {
+        "Content-Type": "application/json",
+        "Ocp-Apim-Subscription-Key": "00667ce9381d46a3a279c4799dd698d0"
+    }
+
+    # Data to be sent in the initial POST request
+    data = {
+        "tasks": [{"kind": "Healthcare"}],
+        "analysisInput": {
+            "documents": [
+                {
+                    "id": "documentId",
+                    "text": text,
+                    "language": "en"
+                }
+            ]
+        }
+    }
+
+    # Making the initial POST request
+    response = requests.post(f"{base_url}?api-version=2022-10-01-preview", headers=headers, json=data)
+
+    time.sleep(10)
+    
+    # Get the operation-location from the response header
+    operation_location = response.headers.get('operation-location')
+    
+    # Extract JOB-ID from the operation-location
+    job_id = operation_location.split('/')[-1].split('?')[0]
+    
+    # Make a subsequent GET request to retrieve the results using the JOB-ID
+    result_response = requests.get(f"{base_url}/{job_id}?api-version=2022-10-01-preview", headers=headers)
+    
+    # Return the JSON response from the GET request
+    result = result_response.json()
+    
+    return result
+
+
+
+def convert_to_annotated_text(input_list):
+    """
+    Convert a list with annotated content into a nested list suitable for annotated_text format.
+    
+    Args:
+    - input_list (list): The list with content and annotations in format '[text:annotation]'.
+    
+    Returns:
+    - list: A nested list in the annotated_text format.
+    """
+    annotated_list = []
+    temp_group = []
+
+    for item in input_list:
+        # Check if the item is an annotation
+        if item.startswith('[') and item.endswith(']'):
+            content = item[1:-1].split(':')
+            temp_group.append((content[0], content[1]))
+        else:
+            if temp_group:  # if there are items in the temporary group
+                annotated_list.append(temp_group)
+                temp_group = []
+            annotated_list.append(item)
+
+    # Add any remaining items in the temporary group to the final list
+    if temp_group:
+        annotated_list.append(temp_group)
+
+    return annotated_list
+
+
+if st.button("Analyze"):
+    text = dax_input
+    json_analysis = analyze_healthcare_text(text)
+    json_analysis = json_analysis["tasks"]["items"][0]["results"]
+    # save json analysis as a file
+    
+    
+    new_text = generate_annotated_array(text, json_analysis)
+    new_text = convert_to_annotated_text(new_text)
+    annotated_text(new_text)
+ 
+
+
+
+st.title("Nuance DAX Copilot")
+
+os.environ["OPENAI_API_BASE"] = openai.api_type = "azure"
+os.environ["OPENAI_API_BASE"] = openai.api_base = "https://eastus-openai-sean.openai.azure.com/"
+os.environ["OPENAI_API_VERSION"] = openai.api_version = "2023-03-15-preview"
+
+openai.api_key = os.environ["OPENAI_API_KEY"]
+openai.api_version = os.environ["OPENAI_API_VERSION"]
+openai.api_base = os.environ["OPENAI_API_BASE"]
+os.environ["OPENAI_API_VERSION"] = openai.api_version = "2023-03-15-preview"
+
+
+if "messages" not in st.session_state:
+    st.session_state.messages = [{"role":"system","content":"You are an AI assistant that ansswers questions about patient encounters. You are not a doctor and should not diagnose or treat patients. However, you can suggest common practices and help doctors with their questions that will help them make better decisions. \ Use only the information below: \n Patient Note / Encounter Summary:  \n"}]
+
+
+for message in st.session_state.messages:
+    with st.chat_message(message["role"]):
+        st.markdown(message["content"])
+
+
+
+
+
+
+if prompt := st.chat_input("Nuance DAX Copilot?"):
+    st.session_state.messages.append({"role": "user", "content": prompt + dax_input})
+    with st.chat_message("user"):
+        st.markdown(prompt)
+
+    with st.chat_message("assistant"):
+        message_placeholder = st.empty()
+        full_response = ""
+        for response in openai.ChatCompletion.create(
+            messages=[
+                {"role": m["role"], "content": m["content"]}
+                for m in st.session_state.messages
+            ],
+            stream=True,
+            engine="gpt-4",
+        ):
+            full_response += response.choices[0].delta.get("content", "")
+            message_placeholder.markdown(full_response + "▌")
+        message_placeholder.markdown(full_response)
+    st.session_state.messages.append({"role": "assistant", "content": full_response})