Deploy Chainlit app to Hugging Face Spaces

Dockerfile

@@ -0,0 +1,17 @@
+# Use an official Python runtime as a parent image
+FROM python:3.10-slim
+
+# Set the working directory in the container
+WORKDIR /climate-change-assistant
+
+# Copy the current directory contents into the container
+COPY . /climate-change-assistant
+
+# Install any needed packages specified in requirements.txt
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+# Following instructions within HF docker file setup
+COPY . .
+
+# Run app.py when the container launches
+CMD ["chainlit", "run", "app.py", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,11 +1,35 @@
----
-title: Scenesfromtomorrow
-emoji: 🐢
-colorFrom: blue
-colorTo: yellow
-sdk: docker
-pinned: false
-license: mit
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+This chainlit app will use an [OpenAI Assistant](https://platform.openai.com/docs/assistants/overview) and the amazing [Probable futures](https://probablefutures.org/) API to provide 
+climate change information for a location, and provide some helpful resources for how to prepare.
+
+The chainlit app is based off the cookbook example [here](https://github.com/Chainlit/cookbook/tree/main/openai-assistant).
+
+![screenshot](./images/screenshot.png)
+
+# Setup
+
+You will need a probable future API key, see [here](https://docs.probablefutures.org/api-access/) for more details. You will also need an [OPENAI key](https://platform.openai.com/docs/quickstart?context=python).
+
+Setup a Conda environment ...
+
+1. Install [miniconda](https://docs.conda.io/en/latest/miniconda.html) by selecting the installer that fits your OS version. Once it is installed you may have to restart your terminal (closing your terminal and opening again)
+2. In this directory, open terminal
+3. `conda env create -f environment.yml`
+4. `conda activate climate-env`
+
+Once you have these, then ...
+
+1. Copy `.env.example` to `.env`
+2. Set OpenAI key and Probable Futures API user and secret
+3. Create assisstent with `python3 create_assistant.py`
+4. Copy the assiostant id from output and put into `.env`
+
+If you make changes to the assistant, rerun `create_assistant.py`, which will update the existing assistant.
+
+# To run chainlit app
+
+`chainlit run app.py`
+
+# To view assistant on OpenAI
+
+Go [here](https://platform.openai.com/assistants)
+

app.py

@@ -0,0 +1,346 @@
+import os
+import json
+from typing import Dict
+
+from openai import AsyncOpenAI
+from openai.types.beta.threads.run import Run
+
+from openai.types.beta import Thread
+from openai.types.beta.threads import (
+    ImageFileContentBlock,
+    TextContentBlock,
+    Message,
+)
+
+import chainlit as cl
+from typing import Optional
+from chainlit.context import context
+
+import assistant_tools as at
+import prompts as pr
+import helper_functions as hf 
+import datetime
+import csv
+
+from utils import DictToObject, stream_message, ask_to_continue, process_thread_message
+
+api_key = os.environ.get("OPENAI_API_KEY")
+client = AsyncOpenAI(api_key=api_key)
+assistant_id = os.environ.get("ASSISTANT_ID")
+
+
+@cl.on_chat_start
+async def start_chat():
+    thread = await client.beta.threads.create()
+    cl.user_session.set("thread", thread)
+    await cl.Message(author="Climate Change Assistant", content=pr.welcome_message).send()
+
+
+@cl.on_message
+async def run_conversation(message_from_ui: cl.Message):
+    count = 0
+    thread = cl.user_session.get("thread")  # type: Thread
+    # Add the message to the thread
+
+    init_message = await client.beta.threads.messages.create(
+        thread_id=thread.id, role="user", content=message_from_ui.content
+    )
+
+    # Send empty message to display the loader
+    loader_msg = cl.Message(author="Climate Change Assistant", content="")
+    await loader_msg.send()
+
+    # Create the run
+    run = await client.beta.threads.runs.create_and_poll(
+        thread_id=thread.id, assistant_id=assistant_id
+    )
+
+    message_references = {}  # type: Dict[str, cl.Message]
+
+    # Periodically check for updates
+    #running = True
+    while True:
+        print('starting while True loop')
+        print(run)
+        run = await client.beta.threads.runs.retrieve(
+            thread_id=thread.id, run_id=run.id
+        )
+
+        # Fetch the run steps
+        run_steps = await client.beta.threads.runs.steps.list(
+            thread_id=thread.id, run_id=run.id, order="asc"
+        )
+
+        for step in run_steps.data:
+            # Fetch step details
+            run_step = await client.beta.threads.runs.steps.retrieve(
+                thread_id=thread.id, run_id=run.id, step_id=step.id
+            )
+            step_details = run_step.step_details
+            # Update step content in the Chainlit UI
+            if step_details.type == "message_creation":
+                thread_message = await client.beta.threads.messages.retrieve(
+                    message_id=step_details.message_creation.message_id,
+                    thread_id=thread.id,
+                )
+                await process_thread_message(message_references, thread_message)
+
+            print("line 116 about the call the tools call loop")
+            count += 1
+            print(str(count))
+
+            if step_details.type == "tool_calls":
+                loading_message = "Retrieving information, please stand by."
+                loading_message_to_assistant = cl.Message(author="Climate Change Assistant", content=loading_message)
+                await loading_message_to_assistant.send()  # output_message_to_assistant.send()
+
+                for tool_call in step_details.tool_calls:
+                    print('top of tool call loop line 119')
+
+                    # IF tool call is a disctionary, convert to object
+                    if isinstance(tool_call, dict):
+                        print("here is a tool call at line 120")
+                        print(tool_call)
+                        tool_call = DictToObject(tool_call)
+                        if tool_call.type == "function":
+                            function = DictToObject(tool_call.function)
+                            tool_call.function = function
+                        if tool_call.type == "code_interpreter":
+                            code_interpretor = DictToObject(tool_call.code_interpretor)
+                            tool_call.code_interpretor = code_interpretor
+
+                    print("here are step details at line 130")
+                    print(step_details)
+                    print("here is tool call at line 132")
+                    print(tool_call)
+                    
+                    if (
+                        tool_call.type == "function"
+                        and len(tool_call.function.arguments) > 0
+                                ):
+                        function_name = tool_call.function.name
+                        function_args = json.loads(tool_call.function.arguments)
+
+                        if not tool_call.id in message_references:
+                            message_references[tool_call.id] = cl.Message(
+                                author=function_name,
+                                content=function_args,
+                                language="json",
+                                #parent_id=context.session.root_message.id,
+                            )
+                            #await message_references[tool_call.id].send()
+
+                            function_mappings = {
+                                #"get_pf_data_handbook": at.get_pf_data_handbook,
+                                "get_pf_data_timeline": at.get_pf_data_timeline,
+                            }
+
+                            # Not sure why, but sometimes this is returned rather than name
+                            function_name = function_name.replace("_schema", "")
+
+                            print(f"FUNCTION NAME: {function_name}")
+                            print(function_args)
+
+                            if function_name == "get_pf_data_timeline":
+
+                                # Extract 'address' and 'country' values
+                                address = function_args['address']
+                                country = function_args['country']
+                                units = function_args.get('units', 'C') #returns the specific value for 'units' else C if blank
+
+                                print(f"Address: {address}, Country: {country}, Units: {units}")
+
+                                parsed_output = at.get_pf_data_timeline(address, country, '1.5', units)
+
+                                if parsed_output is not None:
+                                    
+                                    print(f"RUN STATUS: {run.status} from first timeline scene")
+                                    print(run)
+                                    
+                                    
+                                    # creating an initial output of what life is like today in that place
+                                    output = ""
+
+                                    loading_message_to_assistant = cl.Message(author="Climate Change Assistant", content=pr.timeline_message)
+                                    await loading_message_to_assistant.send()
+
+                                    # filtering the results to just show results describing average / baseline temperatures
+                                    summary = hf.story_completion(pr.one_five_degree_prompt, units, parsed_output[parsed_output.name.str.contains("10 hottest") | parsed_output.name.str.contains("Days above 35")])
+
+                                    next_output = await stream_message(summary, cl)
+
+                                    output += next_output
+
+                                    print(next_output) # hf.summarizer(output)
+                                    img_content, image_bytes = hf.get_image_response_SDXL(pr.image_prompt_SDXL + address + ' ' + country) #hf.summarizer(output)
+                                    #with open('feedback_logs/73ee4d67-4857-47ec-b835-5b1cfb570b20.png', 'rb') as file:
+                                    #        img_content = file.read()
+                                    img = cl.Image(content=image_bytes, name="image1", display="inline", size="large") # img_content
+                                    print('\n Generating image, complete')
+                                    image_message_to_assistant = cl.Message(author="Climate Change Assistant", content=' ', elements=[img])
+                                    await image_message_to_assistant.send()
+
+                                    #adding button to allow user to paginate the content
+                                    res = await ask_to_continue()
+
+                                    while res and res.get("value") == "question":
+
+                                        question = await cl.AskUserMessage(content='How can I help?', timeout=600).send()
+    
+                                        # Use this to send the output of completion request into the next OpenAI API call.
+                                        question_response = hf.summary_completion(address, country, output, question['output'])
+
+                                        next_output = await stream_message(question_response, cl)
+
+                                        output += next_output
+
+                                           
+                                        # Call the function again instead of duplicating the code block
+                                        res = await ask_to_continue()
+                                        
+
+                                    warming_scenario = ['2.0', '3.0']
+                                    
+                                    #inpainting_keywords = ''
+
+                                    for i in range(len(warming_scenario)):
+                                        print(f"RUN STATUS: {run.status} from timeline scene # {i}")
+                                        print(run)
+
+                                        # going to force units to be C b/c otherwise it's breaking the logic for how the 2/3 image gets displayed
+                                        parsed_output = at.get_pf_data_timeline(address, country, warming_scenario[i], 'C') #units
+                                        
+                                        # filterine results to talk about change from baseline 
+                                        summary = hf.story_completion(pr.timeline_prompts[i], units, parsed_output[parsed_output.name.str.contains('Change') | parsed_output.name.str.contains('Likelihood')])
+                                        next_output = await stream_message(summary, cl)
+
+                                        output += next_output
+
+                                        data_changes = parsed_output[parsed_output['name'].str.contains('Change') | parsed_output['name'].str.contains('Likelihood')].copy()
+                                        #print(data_changes)
+                                        inpainting_keywords = hf.generate_inpainting_keywords(data_changes) 
+
+                                        img_content, image_bytes = hf.get_image_response_SDXL(prompt=pr.image_prompt_SDXL + address + ' ' + country, image_path = img_content, filtered_keywords=inpainting_keywords) #str(hf.summarizer(output))
+                                        #with open('feedback_logs/73ee4d67-4857-47ec-b835-5b1cfb570b20.png', 'rb') as file:
+                                        #   img_content = file.read()
+                                        img = cl.Image(content=image_bytes, name="image1", display="inline", size="large") #img_content
+                                        print('\n generating image, complete')
+                                        image_message_to_assistant = cl.Message(author="Climate Change Assistant", content=' ', elements=[img])
+                                        await image_message_to_assistant.send() 
+
+                                        #adding button to allow user to paginate the content
+                                        res = await ask_to_continue()
+
+                                        while res and res.get("value") == "question":
+
+                                            question = await cl.AskUserMessage(content='How can I help?', timeout=600).send()
+        
+                                            # Use this to send the output of completion request into the next OpenAI API call.
+                                            question_response = hf.summary_completion(address, country, output, question['output'])
+
+                                            next_output = await stream_message(question_response, cl)
+
+                                            output += next_output
+
+                                            
+                                            # Call the function again instead of duplicating the code block
+                                            res = await ask_to_continue()
+                                            
+                                        #else:
+                                        #    run.status = "completed"
+                                    
+                                    
+                                    final_message_content = hf.summary_completion(address, country, output, "Please give the user a personalized set of recommendations for how to adapt to climate change for their location and the questions they have asked (if any).")
+                                    next_output = await stream_message(final_message_content, cl)
+                                    output += next_output
+                                    
+                                    # Step 1: Ask users if they'd like to offer feedback
+                                    res_want_feedback = await cl.AskActionMessage(content="Would you like to offer feedback?",
+                                                                                actions=[
+                                                                                    cl.Action(name="yes", value="yes", label="✅ Yes"),
+                                                                                    cl.Action(name="no", value="no", label="🚫 No")],
+                                                                                timeout=600).send()
+
+                                    # Only proceed if they want to give feedback
+                                    if res_want_feedback.get("value") == "yes":
+                                        # Step 2: Ask "How was your experience?"
+                                        res_feedback = await cl.AskActionMessage(content="How was your experience?",
+                                                                                actions=[
+                                                                                    cl.Action(name="good", value="good", label="😀 Good. I'm ready to take action"),
+                                                                                    cl.Action(name="IDK", value="IDK", label="😐 Not sure"),
+                                                                                    cl.Action(name="no_good", value="no_good", label="🙁 Not good"),], 
+                                                                                timeout=600).send()
+
+                                        if res_feedback.get("value") == "good":
+                                            thank_you_message = cl.Message(author="Climate Change Assistant", content="Thanks for your feedback!")
+                                            await thank_you_message.send()
+
+                                        # Step 3: If "no good" or "not sure," ask why
+                                        elif res_feedback.get("value") in ["no_good", "IDK"]:
+                                            res_reason = await cl.AskUserMessage(content="Could you please tell us why?").send()
+
+                                            # Step 4: Capture user open-ended comments and write to a CSV file
+                                            filename = f"feedback_logs/feedback_{datetime.datetime.now().strftime('%Y%m%d_%H%M%S')}.csv"
+                                            
+                                            with open(filename, "a", newline='') as csvfile:
+                                                feedback_writer = csv.writer(csvfile, delimiter=',', quotechar='"', quoting=csv.QUOTE_MINIMAL)
+                                                # Write column headers if the file is new/empty
+                                                if csvfile.tell() == 0:
+                                                    feedback_writer.writerow(["Thread ID", "Feedback Value", "Reason Output"])
+                                                # Assuming thread_id is available from earlier in your session
+                                                thread = cl.user_session.get("thread")
+                                                feedback_writer.writerow([thread.id, res_feedback.get('value'), res_reason['output'] if res_reason['output'] is not None else ''])
+                                            
+                                            thank_you_message = cl.Message(author="Climate Change Assistant", content="Thanks for your feedback!")
+                                            await thank_you_message.send()
+                                    
+                                    next_steps = cl.Message(author="Climate Change Assistant", content=pr.next_steps)
+                                    await next_steps.send()
+                                    
+                                    print('here is the bottom of the if feedback block')
+                                    print(run.status)
+                                    #run.status = "completed" 
+                                
+                                print('here is the bottom of the if pf.function is not none block')
+                                print(run.status)
+                                #run.status = "completed"
+
+                                run = await client.beta.threads.runs.submit_tool_outputs_and_poll(
+                                        thread_id=thread.id,
+                                        run_id=run.id,
+                                        tool_outputs=[
+                                            {
+                                                "tool_call_id": tool_call.id,
+                                                "output": str(parsed_output),
+                                            },
+                                            ],
+                                        )
+
+                            print('here is the bottom of the IF tool call is function block')
+                            #run.status = "completed"
+                            print(run.status)
+                            
+
+        #await cl.sleep(1)  # Refresh every second
+
+        if run.status == "completed":
+            print(f"RUN STATUS: {run.status} from the bottom of the code")
+            #running = False
+            #run = await client.beta.threads.runs.cancel(
+            #    thread_id=thread.id,
+            #    run_id=run.id
+            #    )
+            print(run)
+            break
+
+        
+
+
+
+
+        if run.status in ["cancelled", "failed", "completed", "expired"]:
+
+            if run.status == "failed":
+                print('here is the failed run: ', run)
+            break
+            print('completed')

assistant_tools.py

@@ -0,0 +1,81 @@
+import os
+import json
+import pandas as pd
+
+import requests
+from openai import OpenAI
+from datetime import date
+from datetime import datetime
+
+from dotenv import load_dotenv
+import sys
+
+import prompts as pr
+import helper_functions as hf
+
+pf_api_url = "https://graphql.probablefutures.org"
+#pf_token_audience = "https://graphql.probablefutures.com"
+#pf_token_url = "https://probablefutures.us.auth0.com/oauth/token"
+
+load_dotenv()
+#client = OpenAI()
+
+def get_pf_data_timeline(address, country, warming_scenario='1.5', units='C'):
+    variables = {}
+
+    location = f"""
+        country: "{country}"
+        address: "{address}"
+    """
+
+    query = (
+            """
+            mutation {
+                getDatasetStatistics(input: { """
+            + location
+            + """ \
+                    warmingScenario: \"""" + warming_scenario + """\" 
+                }) {
+                datasetStatisticsResponses{
+                    datasetId
+                    name
+                    unit
+                    warmingScenario
+                    midValue
+                    highValue
+                    mapCategory
+                }
+            }
+        }
+    """
+    )
+    #print(query)
+
+    access_token = hf.get_pf_token()
+    url = pf_api_url + "/graphql"
+    headers = {
+    "Content-Type": "application/json",
+    "Authorization": "Bearer " + access_token
+        }
+    response = requests.post(
+        url, json={"query": query, "variables": variables}, headers=headers
+    )
+
+    response = str(response.json()).replace("'", '"')
+    response = response.replace("None", "null")
+
+    parsed_output = hf.json_to_dataframe(response, address=address, country=country)
+
+    if units.lower() in ('f', 'fahrenheit'):
+        parsed_output.loc[parsed_output.unit == '°C', 'midValue'] = (((parsed_output.loc[parsed_output.unit == '°C', 'midValue'].astype('float') * 9) / 5) + 32).round()
+        parsed_output.loc[parsed_output.unit == '°C', 'highValue'] = (((parsed_output.loc[parsed_output.unit == '°C', 'highValue'].astype('float') * 9) / 5) + 32).round()
+        parsed_output.loc[parsed_output.unit == 'mm', 'midValue'] = (parsed_output.loc[parsed_output.unit == 'mm', 'midValue'].astype('float') / 25.4).round(1)
+        parsed_output.loc[parsed_output.unit == 'mm', 'highValue'] = (parsed_output.loc[parsed_output.unit == 'mm', 'highValue'].astype('float') / 25.4).round(1)
+        parsed_output.loc[parsed_output.unit == '°C', 'unit'] = '°F'
+        parsed_output.loc[parsed_output.unit == 'mm', 'unit'] = 'inches'
+
+    print("got output of pf_data_new")
+
+    #summary = summary_completion(str(address) + " " + str(country))
+
+    return parsed_output 

chainlit.md

@@ -0,0 +1,16 @@
+# Welcome to Scenes From Tomorrow
+
+Overcoming climate procrastination by building empathy with your future self.
+
+## How to Use this App
+The goal of this app is to provide you with a localized view of the impact of climate change and actionable steps to prepare. The data is based on climate models which have been [accurate](http://www.climatehubs.usda.gov/hubs/northwest/topic/basics-global-climate-models#:~:text=Despite%20the%20level%20of%20uncertainty,of%20the%20past%20100%20years.) in predicting global temperature changes since 1970's. 
+
+To use the app, enter a location to see the predicted climate and talk with the AI assistant about how to prepare.
+
+## Data Sources & Methdology
+This application is based on data and other content made available by Probable Futures, a Project of SouthCoast Community Foundation and certain of that data may have been provided to Probable Futures by Woodwell Climate Research Center, Inc. or The Coordinated Regional climate Downscaling Experiment (CORDEX). Please click here for more information on the [Probable Futures API](https://docs.probablefutures.org/api/) and [Probable Futures Climate Models](https://probablefutures.org/science/climate-models/)
+
+## Version
+0.1.1
+
+

helper_functions.py

@@ -0,0 +1,217 @@
+import os
+import json
+import pandas as pd
+
+import requests
+from openai import OpenAI
+from datetime import date
+from datetime import datetime
+
+from dotenv import load_dotenv
+import sys
+
+import io
+import base64
+import urllib
+from PIL import Image
+import io
+import cv2
+
+from diffusers import AutoPipelineForText2Image, AutoPipelineForImage2Image # DiffusionPipeline
+import torch
+#import matplotlib.pyplot as plt
+
+import prompts as pr
+
+pf_api_url = "https://graphql.probablefutures.org"
+#pf_token_audience = "https://graphql.probablefutures.com"
+#pf_token_url = "https://probablefutures.us.auth0.com/oauth/token"
+
+load_dotenv()
+client = OpenAI()
+
+model = "gpt-4o" #"gpt-4-0125-preview"  # gpt-4 #gpt-3.5-turbo-16k
+
+
+pipeline_text2image = AutoPipelineForText2Image.from_pretrained("stabilityai/sdxl-turbo", torch_dtype=torch.float16, variant="fp16") # digiplay/Landscape_PhotoReal_v1
+pipeline_image2image = AutoPipelineForImage2Image.from_pretrained("stabilityai/sdxl-turbo", torch_dtype=torch.float16, variant="fp16") # digiplay/Landscape_PhotoReal_v1
+pipeline_text2image.to("cuda")
+pipeline_image2image.to("cuda")
+
+
+def convert_to_iso8601(date_str):
+    try:
+        # Parse the date string to a datetime object
+        date_obj = datetime.strptime(date_str, "%Y-%m-%d")
+        # Format the datetime object to ISO 8601 format with timezone offset
+        iso8601_date = date_obj.strftime("%Y-%m-%dT%H:%M:%S+00:00")
+        return iso8601_date
+    except ValueError:
+        # Return the original string if it's not in the expected date format
+        return date_str
+
+
+def get_pf_token():
+    client_id = os.getenv("CLIENT_ID")
+    client_secret = os.getenv("CLIENT_SECRET")
+    url = 'https://graphql.probablefutures.org/auth/token'
+
+    # Encode the client credentials
+    encoded_credentials = base64.b64encode(f"{client_id}:{client_secret}".encode()).decode()
+
+    headers = {
+        'Authorization': 'Basic ' + encoded_credentials
+        }
+
+    try:
+        response = requests.get(url, headers=headers)
+        response.raise_for_status()  # This will raise an exception for HTTP errors
+        data = response.json()
+        access_token = data['access_token']
+        return access_token
+
+    except requests.exceptions.RequestException as e:
+        print('There was a problem with your request:', e)
+        return None
+
+
+def json_to_dataframe(json_data, address, country):
+    # Extract the relevant part of the JSON data
+    json_data = json.loads(json_data)
+    data = json_data['data']['getDatasetStatistics']['datasetStatisticsResponses']
+    # Convert to a DataFrame
+    df = pd.DataFrame(data)
+    # Normalize the 'info' column if needed
+    #if not df['info'].apply(lambda x: x == {}).all():
+    #    info_df = pd.json_normalize(df['info'])
+    #    df = df.drop(columns=['info']).join(info_df)
+    df['address'] = address
+    df['country'] = country
+    df = df[['address', 'country', 'name', 'midValue', 'highValue', 'unit', 'mapCategory']]
+    #df = df[df['name'].str.contains('Change')]
+    df = df[~((df['midValue'] == '0.0') & (df['highValue'] == '0.0'))]
+    df.reset_index(drop=True, inplace=True)
+    
+    return df
+
+
+def summary_completion(address, country, output, user_question):
+    content = f"Please answer the user question {user_question} for the location of {address} {country}. Use the information that was just provided previously to the user: {output}"
+    print(content)
+    completion = client.chat.completions.create(
+        model=model, #"gpt-4-0125-preview",  # gpt-4 #gpt-3.5-turbo-16k
+        messages=[
+            {"role": "system", "content": pr.user_question_prompt},
+            {"role": "user", "content": content}
+        ],
+        stream=True
+    )
+
+    return completion#.choices[0].message.content
+
+# the 'content' object is a dataframe so it's wrapped in a str(to_json()) call
+def story_completion(story_system_prompt, units, content):
+    completion = client.chat.completions.create(
+        model=model, #"gpt-4-0125-preview",  # gpt-4 #gpt-3.5-turbo-16k
+        messages=[
+            {"role": "system", "content": str(story_system_prompt + ". Be sure to describe the result using the following temperature scale: " + units)},
+            {"role": "user", "content": str(content.to_json())}
+        ],
+        stream=True
+    )
+
+    return completion#.choices[0].message.content
+
+# need GPU to run this part; uncomment lines 31 & 32
+def get_image_response_SDXL(prompt, image_path=None, filtered_keywords=None): #i'm passing a file path to image when using inpainting; FOR NOW
+    print('starting SDXL')  # Check here for prompt language tips: https://stable-diffusion-art.com/sdxl-prompts/
+    
+    if image_path is None:
+        # Generate image from text
+        # using flash attention for memory optimization 
+        # https://huggingface.co/docs/diffusers/en/optimization/memory#memory-efficient-attention
+        #with torch.inference_mode():
+        result_image = pipeline_text2image(
+            prompt=prompt, num_inference_steps=2, guidance_scale=0.0).images[0]  # Assuming default image dimensions or specify if required
+    else:
+        # Load the image from the path
+        #img = Image.open(image_path) 
+
+        #plt.imshow(img)
+        #plt.title("Loaded Image")
+        #plt.show() 
+
+        #if strength == None:
+        #    strength = 0.51
+
+        # adding inpaiting keywords for 2.0 and 3.0 warming scenarios
+        modified_prompt = filtered_keywords if filtered_keywords else prompt
+        print(modified_prompt)
+
+        # Modify existing image based on new prompt
+        # using flash attention https://huggingface.co/docs/diffusers/en/optimization/memory#memory-efficient-attention
+        #with torch.inference_mode():
+        result_image = pipeline_image2image(
+            prompt=modified_prompt, image=image_path, strength=0.55, guidance_scale=0.0, num_inference_steps=2).images[0]  # negative_prompt="deformed faces, distorted faces, mangled hands, extra legs", 
+
+    # Save the image to a byte buffer
+    buffer = io.BytesIO()
+    result_image.save(buffer, format='PNG')
+    image_bytes = buffer.getvalue()
+    return result_image, image_bytes 
+
+
+def summarizer(content, inpainting=None):
+    if inpainting is None:
+        system_prompt = pr.summarizer_prompt
+    else:
+        system_prompt = pr.summarizer_prompt_inpainting
+    completion = client.chat.completions.create(
+        model=model, #"gpt-3.5-turbo-16k",  # gpt-4 #gpt-4-0125-preview
+        messages=[
+            {"role": "system", "content": system_prompt},
+            {"role": "user", "content": content}
+        ],
+        stream=False
+    )
+    
+    print(str(completion.choices[0].message.content))# + " Photorealism, Sharp Image, wide shot")
+    return str(completion.choices[0].message.content)# + " realistic humans " #" long exposure, blurred motion, streaks of light, surreal, dreamy, ghosting effect, highly detailed"
+
+
+def generate_inpainting_keywords(data_changes):
+    # Check if the DataFrame is empty or missing the necessary columns
+    if data_changes.empty or 'midValue' not in data_changes.columns:
+        return ["no significant change"]
+    data_changes['name'] = data_changes['name'].str.replace('“', '', regex=False).str.replace('”', '', regex=False).str.replace('"', '', regex=False)
+    print(data_changes)
+
+    # Example: Select the change with the highest 'midValue' as the most significant
+    # Find the index of the row with the highest 'midValue'
+    idx_max_midValue = data_changes['midValue'].astype('float').abs().idxmax()
+
+    # Retrieve the 'name' from the row with the highest 'midValue'
+    most_significant_change_name = data_changes.loc[idx_max_midValue, 'name']
+    print(most_significant_change_name)
+    
+    #change_name = most_significant_change['name']  # Assuming the name of the change is in the 'name' column
+    #impact = 'increase' if most_significant_change['midValue'] > 0 else 'decrease'
+
+    # Mapping of change types to potential keywords
+    climate_change_qualifiers = {
+    'Change in total annual precipitation': 'heavy rain, flooding, gloomy skies',
+    'Change in wettest 90 days': 'increased rainfall, frequent storms, saturated grounds',
+    'Change in dry hot days': 'intense sunlight, heat haze, dry atmosphere',
+    'Change in frequency of 1-in-100-year storm': 'severe storms, extreme weather events, damaged infrastructure',
+    'Change in precipitation 1-in-100-year storm': 'torrential rain, flash floods, overflowing rivers',
+    'Likelihood of year-plus extreme drought': 'faded colors, heat mirages, stark shadows',
+    'Likelihood of year-plus drought': 'heat haze, dusty air, sun-bleached surfaces',
+    'Change in wildfire danger days': 'smoky haze, distant glow of fires, ash particles in air'
+}
+
+    # Retrieve qualifiers for the most significant change category
+    qualifiers = climate_change_qualifiers.get(most_significant_change_name, ["change not specified"])
+    #qualifiers_string = ", ".join([str(qualifier) for qualifier in qualifiers])
+    
+    print(qualifiers)
+    return qualifiers

prompts.py

@@ -0,0 +1,217 @@
+
+# defining inputs to prompting functions
+welcome_message = '''
+Please enter a location (city and country) to get started. By default I'll use Metric units but if you want Fahrenheit please say that (or 'F').'''
+
+user_question_prompt = '''
+Please answer the user's question on the impact of climate change on their location and lifestyle being as specific and relevant to the information they've provided as possible.
+If you aren't sure to help say, 'I'm not sure how to help with that.'
+'''
+
+storyboard_prompt = """
+    I am making a magazine about the impact of climate change and I want you to create storyboards.
+    I will share a story with you and want you to create an image based on it.
+    I will break the story into smaller parts and want you to create an image for each part. 
+    Go for photorealistic quality like you are showing a picture.
+    Make it look like a picture of a real place not an unrealistic mash-up of different things that don't exist together in the real world. 
+    Do not add text and callout boxes on the image.
+    The next story chunk is below.
+    """
+
+summarizer_prompt = '''
+Take the input paragraph and condense it down into a single sentence like the example below.
+
+STORYTELLING TIPS
+- always include the words cinematic, realistic, and dynamic
+- describe a single image in the output, not a combination of scenes
+- describe what's being shown in the image in vivid and exceptionally detailed terms
+- always include the name of the place and the country
+
+-----
+INPUT EXAMPLE:
+In Jakarta, Indonesia, the future holds a stark increase in climate volatility, with a 15% likelihood of experiencing extreme droughts lasting a year or more,
+and a general likelihood of 36% for year-plus droughts. This drastic shift towards drier conditions is accompanied by a significant rise in wildfire danger days,
+expected to increase by 15 to 29 days. These changes underscore a new era where climate instability becomes the norm, profoundly disrupting
+land use, commerce, and even geopolitical stability. 
+        
+Jakarta's landscapes and ecosystems, like many others, may not be fully prepared to withstand the stress of alternating extreme droughts and unpredictable
+heavy precipitation events. This evolving climate scenario threatens to reduce habitable land areas permanently while placing unprecedented strain on infrastructure
+and urban areas with challenges of managing too little or too much water.
+
+----
+OUTPUT EXAMPLE:
+A cinemtic, realistic, and dynamic image of Jakarta, Indonesia facing impact of climate change: rushing water through flooded streets in a bustling and eclectic southeast Asian metropolis.
+'''
+
+summarizer_prompt_inpainting = '''
+Take the input paragraph and condense it down to a series of keywords to feed to an inpainting image generation model. do NOT mention the city, country, or warming scenario. A couple examples are shown below.
+
+STORYTELLING TIPS
+- describe a single series of image descriptors in the output
+- describe what's being shown in the image in vivid and exceptionally detailed terms
+- describe one feature of what's included in the input prompt in several keyword descriptors.
+- If the input example describes multiple different possible scenarios please only describe one
+- do NOT describe any abstract concepts such as management, planning, resillience, adaptation
+- ONLY describe adjectives for what you are literally seeing in the landscape scene
+- do NOT describe any non-literal adjectives such as innovative, courageous, resourceful
+
+-----
+INPUT EXAMPLE 1:
+In Auckland, New Zealand, known for its beautiful harbors and vibrant city life, the future under a 3.0°C warming scenario presents a mixed bag of climate challenges. 
+The city could see an unpredictable swing in its weather patterns, with some predictions suggesting less total annual rain but heavier rainfalls during the wettest days, and an increase in dry hot days. 
+This could lead to more frequent and severe drought conditions, impacting Auckland's water supplies, increasing wildfire risks, and putting a strain on both urban and rural communities. 
+Adapting to these changes will be crucial for maintaining the quality of life and the natural beauty that Auckland is famous for.
+
+----
+OUTPUT EXAMPLE 1:
+heavy rain, flooding, storms, wet days, storm clouds, extreme weather
+
+-----
+INPUT EXAMPLE 2:
+In Jakarta, Indonesia, the future holds a stark increase in climate volatility, with a 15% likelihood of experiencing extreme droughts lasting a year or more,
+and a general likelihood of 36% for year-plus droughts. This drastic shift towards drier conditions is accompanied by a significant rise in wildfire danger days,
+expected to increase by 15 to 29 days. These changes underscore a new era where climate instability becomes the norm, profoundly disrupting
+land use, commerce, and even geopolitical stability. 
+        
+Jakarta's landscapes and ecosystems, like many others, may not be fully prepared to withstand the stress of alternating extreme droughts and unpredictable
+heavy precipitation events. This evolving climate scenario threatens to reduce habitable land areas permanently while placing unprecedented strain on infrastructure
+and urban areas with challenges of managing too little or too much water.
+
+----
+OUTPUT EXAMPLE 2:
+drought, parched land, hazy air, wildfire smoke, sunset, high detail 
+'''
+
+
+timeline_message = '''We'll take a look at 3 points in time. First we'll look at today, where temperatures will soon reach the 1.5°C warming level. Then, we'll look at the 2.0° scenario, which could arrive in the 2040's, and then the extreme 3.0°C scenario which could arrive by 2075.'''
+
+
+one_five_degree_prompt = """
+Hello, Climate Change Assistant. You help people understand how climate change will affect their life.
+You will use Probable Futures API to get data that describes the impact of climate change on a specific location.
+You are describing a 1.5°C warming scenario which is already here today. The changes you will describe below have already happened. 
+Create no more than 2-3 sentences, at the 9th or 10th grade reading level, based on the Data and Storytelling tips, and Example Story below.
+Please talk about how climate change is going to have a negative impact on daily life as it exists today.
+Don't be too negative, but don't be overly optimistic either. Just be direct and clear.  Don't use technical language.
+
+-----
+DATA FROM EXAMPLE LOCATION: DENVER COLORADO
+name	unit	midValue	highValue	mapCategory
+10 hottest nights	°C	19.0	21.0	heat
+10 hottest days	°C	34.0	36.0	heat
+Days above 35°C (95°F)	days	2.0	8.0	heat
+10 hottest wet-bulb days	°C	18.0	20.0	heat
+        
+-----
+STORYTELLING TIPS
+- give clear and specific details about that location
+- talk about changes that could impact notable activities and characteristics of that location
+- don't end with vague optimistic statements
+- talk about the trade-offs and hard decisions people will have to make to adapt
+- describe scenes in detail as though describing a picture
+- provide additional details when strongly implied by the data, for example a rise in wildfire danger in dry climates or sea level rise in coastal ones
+- Make sure to describe what the area is known for today
+- Create no more than 2-3 sentences, at the 9th or 10th grade reading level 
+- Make sure to mention the 1.5°C warming scenario which has already happened.
+        
+-----
+EXAMPLE OUTPUT       
+In Denver, a city known for its sunny days and beautiful, mild seasons, the impact of climate change is becoming more noticeable with a warming scenario of 1.5°C. 
+The 10 hottest days of the year have reached a temperature of 34.0°C, and number of days above 35°C has risen to a total of 2 to 8 per year, making a hotter and more extreme summer environment than residents are used to.
+This change could make outdoor activities like hiking in the Rocky Mountains much harder during the hotter months, and could even affect the city's lush parks and gardens, making it a bit tougher for people to enjoy the natural beauty Denver is famous for."""
+
+two_degree_prompt = '''
+Hello, Climate Change Assistant. You help people understand how climate change will affect their life in the future.
+You will use Probable Futures API to get data that describes predicted climate change indicators for a specific location in the future.
+Once you have the data, create no more than 2-3 sentences, at the 9th or 10th grade reading level, telling about how climate change is going to impact life in that location based on the Data and Storytelling tips, and Example Story below.
+Please talk about how climate change is going to have a negative impact on daily life as it exists today.
+Don't be too negative, but don't be overly optimistic either. Just be direct and clear.  Don't use technical language.
+Make sure to mention the 2.0°C warming scenario.
+
+----
+DATA FROM EXAMPLE LOCATION: SAINT TROPEZ, FRANCE
+name	unit	midValue	highValue	mapCategory
+Change in total annual precipitation	mm	18	67	water
+Change in wettest 90 days	mm	14	93	water
+Change in dry hot days	days	32	28	water
+Change in frequency of “1-in-100-year” storm	x as frequent	3	None	water
+Change in precipitation “1-in-100-year” storm	mm	44	None	water
+Likelihood of year-plus extreme drought	%	12	None	land
+Likelihood of year-plus drought	%	33	None	land
+Change in wildfire danger days	days	10	15	land
+Change in water balance	z-score	-0.2	0.2	land
+        
+
+---
+STORYTELLING TIPS
+- give clear and specific details about that location
+- talk about changes that could impact notable activities and characteristics of that location
+- don't end with vague optimistic statements
+- talk about the trade-offs and hard decisions people will have to make to adapt
+- describe scenes in detail as though describing a picture
+- provide additional details when strongly implied by the data, for example a rise in wildfire danger in dry climates or sea level rise in coastal ones
+- Make sure to describe what the area is known for today
+- Make sure to mention the 2.0°C warming scenario.
+- Create no more than 2-3 sentences, at the 9th or 10th grade reading level, including data points in the final output 
+
+---
+EXAMPLE OUTPUT
+In a climate getting warmer by +2.0°C, Saint Tropez, an area known for its beautiful beaches and scenic coast, may experience more extreme weather.
+While there's more rain, there are also likely to be more scorching hot days and unexpected, risky events like storms and droughts.
+To handle longer heatwaves and more days when wildfires could start, it's crucial to act fast to adjust to these changes, especially since coastal places like Saint Tropez are at risk of rising sea levels.'''
+
+
+three_degree_prompt = '''
+Hello, Climate Change Assistant. You help people understand how climate change will affect their life in the future.
+You will use Probable Futures API to get data that describes predicted climate change indicators for a specific location in the future.
+Once you have the data, create no more than 2-3 sentences, at the 9th or 10th grade reading level, telling about how climate change is going to impact life in that location based on the Data and Storytelling tips, and Example Story below.
+Please talk about how climate change is going to have a negative impact on daily life as it exists today.
+Don't be too negative, but don't be overly optimistic either. Just be direct and clear.  Don't use technical language.
+Make sure to mention the 3.0°C warming scenario.  
+
+----
+DATA FROM EXAMPLE LOCATION: PATAGONIA, ARGENTINA
+name	unit			midValue	highValue	mapCategory
+Change in total annual precipitation	mm		66	121	water
+Change in wettest 90 days	mm	18	176	water
+Change in dry hot days	days		33	55	water
+Change in frequency of “1-in-100-year” storm	x as frequent		2	None	water
+Change in precipitation “1-in-100-year” storm	mm		67	None	water
+Change in wildfire danger days	days		17	36	land
+Change in water balance	z-score		-0.2	0.1	land
+        
+
+---
+STORYTELLING TIPS
+- give clear and specific details about that location
+- talk about changes that could impact notable activities and characteristics of that location
+- don't end with vague optimistic statements
+- talk about the trade-offs and hard decisions people will have to make to adapt
+- describe scenes in detail as though describing a picture
+- provide additional details when strongly implied by the data, for example a rise in wildfire danger in dry climates or sea level rise in coastal ones
+- Make sure to describe what the area is known for today
+- Make sure to mention the 3.0°C warming scenario.
+- Create no more than 2-3 sentences, at the 9th or 10th grade reading level, including data points in the final output 
+
+---
+EXAMPLE OUTPUT
+Patagonia, Argentina, renowned for its vast landscapes and Andean peaks, could face profound shifts due to climate shift to 3.0°C warming.
+With an expected increase in annual precipitation and more frequent dry hot days, the region could grapple with climatic uncertainty that threatens its ecosystems and unique wildlife.
+These changes could strain water resources, agriculture, and local economies, prompting urgent action to adapt to an uncertain future.'''
+
+timeline_prompts = [two_degree_prompt, three_degree_prompt]
+
+final_message = '''
+The future you just saw is likely but not certain. We can overcome climate procrastination by identifying specific actions to take, and work together with like-minded individuals to make it a habit. Here are some resources to help you get started:
+1. Project Drawdown: Science-based solutions to help the world slow down and reverse climate change: as quickly, safely, and equitably as possible. (https://drawdown.org/)
+2. Probable Futures: Data, tools, and a climate adaptation handbook to help you adapt to the coming disruptions. (https://probablefutures.org/)
+3. All We Can Save Project: Join a community of like-minded individuals to scale your efforts through collective action (https://www.allwecansave.earth/)
+'''
+
+next_steps = '''
+What would you like to do next? You can ask me questions about the scenes you just saw or enter a new location.
+
+Also please give me a few second to process things before I can respond to your question. 🤖
+'''
+
+image_prompt_SDXL = '''landscape, crisp background, masterpiece, ultra high res, best quality, kkw-ph1, color, '''

requirements.txt

@@ -0,0 +1,231 @@
+absl-py==2.1.0
+accelerate==0.27.0
+aiofiles==23.2.1
+aiohttp==3.9.3
+aiosignal==1.3.1
+annotated-types==0.6.0
+anthropic==0.21.3
+anyio==3.7.1
+argon2-cffi==23.1.0
+argon2-cffi-bindings==21.2.0
+arize==7.14.0
+arrow==1.3.0
+asttokens==2.4.1
+async-lru==2.0.4
+async-timeout==4.0.3
+asyncer==0.0.2
+attrs==23.2.0
+Babel==2.14.0
+backoff==2.2.1
+beautifulsoup4==4.12.3
+bidict==0.22.1
+bleach==6.1.0
+boto3==1.34.37
+botocore==1.34.37
+cachetools==5.3.2
+certifi==2024.2.2
+cffi==1.16.0
+chainlit==1.1.101
+charset-normalizer==3.3.2
+chevron==0.14.0
+click==8.1.7
+comm==0.2.1
+contourpy==1.2.0
+cycler==0.12.1
+dataclasses-json==0.5.14
+debugpy==1.8.0
+decorator==5.1.1
+defusedxml==0.7.1
+Deprecated==1.2.14
+diffusers==0.26.2
+distro==1.9.0
+exceptiongroup==1.2.0
+executing==2.0.1
+fastapi==0.110.1
+fastapi-socketio==0.0.10
+fastjsonschema==2.19.1
+filelock==3.13.1
+filetype==1.2.0
+fire==0.5.0
+fonttools==4.48.1
+fqdn==1.5.1
+frozenlist==1.4.1
+fsspec==2024.2.0
+google-auth==2.27.0
+google-auth-oauthlib==1.2.0
+google-cloud==0.34.0
+googleapis-common-protos==1.62.0
+grpcio==1.60.1
+h11==0.14.0
+httpcore==0.17.3
+httpx==0.24.1
+huggingface-hub==0.20.3
+idna==3.6
+importlib-metadata==6.11.0
+ipykernel==6.26.0
+ipython==8.17.2
+ipywidgets==8.1.1
+isoduration==20.11.0
+jedi==0.19.1
+Jinja2==3.1.3
+jmespath==1.0.1
+joblib==1.3.2
+json5==0.9.14
+jsonpointer==2.4
+jsonschema==4.21.1
+jsonschema-specifications==2023.12.1
+jupyter-events==0.9.0
+jupyter-lsp==2.2.2
+jupyter_client==8.6.0
+jupyter_core==5.7.1
+jupyter_server==2.12.5
+jupyter_server_terminals==0.5.2
+jupyterlab==4.0.6
+jupyterlab-widgets==3.0.9
+jupyterlab_pygments==0.3.0
+jupyterlab_server==2.25.2
+kiwisolver==1.4.5
+Lazify==0.4.0
+lightning==2.1.4
+lightning-cloud==0.5.64
+lightning-utilities==0.10.1
+lightning_sdk==0.0.17a0
+literalai==0.0.601
+Markdown==3.5.2
+markdown-it-py==3.0.0
+MarkupSafe==2.1.5
+marshmallow==3.20.2
+matplotlib==3.8.2
+matplotlib-inline==0.1.6
+mdurl==0.1.2
+mistune==3.0.2
+mpmath==1.3.0
+multidict==6.0.5
+mypy-extensions==1.0.0
+nbclient==0.9.0
+nbconvert==7.16.0
+nbformat==5.9.2
+nest-asyncio==1.6.0
+networkx==3.2.1
+notebook_shim==0.2.3
+numpy==1.26.2
+nvidia-cublas-cu12==12.1.3.1
+nvidia-cuda-cupti-cu12==12.1.105
+nvidia-cuda-nvrtc-cu12==12.1.105
+nvidia-cuda-runtime-cu12==12.1.105
+nvidia-cudnn-cu12==8.9.2.26
+nvidia-cufft-cu12==11.0.2.54
+nvidia-curand-cu12==10.3.2.106
+nvidia-cusolver-cu12==11.4.5.107
+nvidia-cusparse-cu12==12.1.0.106
+nvidia-nccl-cu12==2.19.3
+nvidia-nvjitlink-cu12==12.4.127
+nvidia-nvtx-cu12==12.1.105
+oauthlib==3.2.2
+openai==1.23.2
+opencv-python==4.9.0.80
+opentelemetry-api==1.22.0
+opentelemetry-exporter-otlp==1.22.0
+opentelemetry-exporter-otlp-proto-common==1.22.0
+opentelemetry-exporter-otlp-proto-grpc==1.22.0
+opentelemetry-exporter-otlp-proto-http==1.22.0
+opentelemetry-instrumentation==0.43b0
+opentelemetry-proto==1.22.0
+opentelemetry-sdk==1.22.0
+opentelemetry-semantic-conventions==0.43b0
+overrides==7.7.0
+packaging==23.2
+pandas==2.1.4
+pandocfilters==1.5.1
+parso==0.8.3
+pexpect==4.9.0
+pillow==10.2.0
+platformdirs==4.2.0
+prometheus-client==0.19.0
+prompt-toolkit==3.0.43
+protobuf==4.23.4
+psutil==5.9.8
+ptyprocess==0.7.0
+pure-eval==0.2.2
+pyarrow==15.0.2
+pyasn1==0.5.1
+pyasn1-modules==0.3.0
+pycparser==2.21
+pydantic==2.6.1
+pydantic_core==2.16.2
+Pygments==2.17.2
+PyJWT==2.8.0
+pyparsing==3.1.1
+python-dateutil==2.8.2
+python-dotenv==1.0.1
+python-engineio==4.9.0
+python-graphql-client==0.4.3
+python-json-logger==2.0.7
+python-multipart==0.0.9
+python-socketio==5.11.1
+pytorch-lightning==2.1.4
+pytz==2024.1
+PyYAML==6.0.1
+pyzmq==25.1.2
+referencing==0.33.0
+regex==2023.12.25
+requests==2.31.0
+requests-futures==1.0.0
+requests-oauthlib==1.3.1
+rfc3339-validator==0.1.4
+rfc3986-validator==0.1.1
+rich==13.7.0
+rpds-py==0.17.1
+rsa==4.9
+s3transfer==0.10.0
+safetensors==0.4.2
+scikit-learn==1.3.2
+scipy==1.11.4
+Send2Trash==1.8.2
+simple-term-menu==1.6.4
+simple-websocket==1.0.0
+six==1.16.0
+sniffio==1.3.0
+soupsieve==2.5
+stack-data==0.6.3
+starlette==0.37.2
+sympy==1.12
+syncer==2.0.3
+tensorboard==2.15.1
+tensorboard-data-server==0.7.2
+termcolor==2.4.0
+terminado==0.18.0
+threadpoolctl==3.2.0
+tinycss2==1.2.1
+tokenizers==0.15.2
+tomli==2.0.1
+torch==2.2.2
+#torchaudio==2.1.2+cu121
+#torchmetrics==1.2.0
+#torchvision==0.16.2+cu121
+tornado==6.4
+tqdm==4.66.1
+traitlets==5.14.1
+transformers==4.37.2
+triton==2.2.0
+types-python-dateutil==2.8.19.20240106
+typing-inspect==0.9.0
+typing_extensions==4.9.0
+tzdata==2023.4
+uptrace==1.22.0
+uri-template==1.3.0
+urllib3==2.0.7
+uvicorn==0.25.0
+watchfiles==0.20.0
+wcwidth==0.2.13
+webcolors==1.13
+webencodings==0.5.1
+websocket-client==1.7.0
+websockets==12.0
+Werkzeug==3.0.1
+widgetsnbextension==4.0.9
+wrapt==1.16.0
+wsproto==1.2.0
+xformers==0.0.25.post1
+yarl==1.9.4
+zipp==3.17.0

utils.py

@@ -0,0 +1,79 @@
+from openai import AsyncOpenAI
+from openai.types.beta.threads.run import Run
+
+from openai.types.beta import Thread
+from openai.types.beta.threads import (
+    ImageFileContentBlock,
+    TextContentBlock,
+    Message,
+)
+
+import chainlit as cl
+from typing import Optional
+from typing import Dict
+from chainlit.context import context
+
+class DictToObject:
+    def __init__(self, dictionary):
+        for key, value in dictionary.items():
+            setattr(self, key, value)
+
+async def stream_message(question_response, cl, initial_content=""):
+    '''handler to stream a message back to user. native streaming not supported in assistants + chainlit v1'''
+    msg = cl.Message(content=initial_content)
+    await msg.send()
+
+    next_output = ""
+
+    for part in question_response:
+        if token := part.choices[0].delta.content or "":
+            next_output += token
+            await msg.stream_token(token)
+
+    await msg.update()
+    return next_output
+
+async def ask_to_continue():
+    '''a button for the user to click to continue '''
+    return await cl.AskActionMessage(
+        content="Click to continue ",
+        actions=[
+            cl.Action(name="keep_going", value="next", label="➡️ Let's keep going"),
+            cl.Action(name="ask_question", value="question", label="︖ Ask a question")
+        ],
+        timeout=600
+    ).send()
+
+async def process_thread_message(message_references: Dict[str, cl.Message], thread_message):
+    for idx, content_message in enumerate(thread_message.content):
+        id = thread_message.id + str(idx)
+        if isinstance(content_message, TextContentBlock):
+            if id in message_references:
+                msg = message_references[id]
+                msg.content = content_message.text.value
+                await msg.update()
+            else:
+                message_references[id] = cl.Message(
+                    author=thread_message.role, content=content_message.text.value
+                )
+                await message_references[id].send()
+        elif isinstance(content_message, MessageContentImageFile):
+            image_id = content_message.image_file.file_id
+            response = await client.files.with_raw_response.retrieve_content(image_id)
+            elements = [
+                cl.Image(
+                    name=image_id,
+                    content=response.content,
+                    display="inline",
+                    size="large",
+                ),
+            ]
+            if id not in message_references:
+                message_references[id] = cl.Message(
+                    author=thread_message.role,
+                    content="",
+                    elements=elements,
+                )
+                await message_references[id]. send()
+        else:
+            print("unknown message type", type(content_message))