Create app.py

app.py

@@ -0,0 +1,654 @@
+import os
+import gradio as gr
+import openai
+from openai import OpenAI
+from dotenv import load_dotenv
+from pathlib import Path
+from time import sleep
+import audioread
+import queue
+import threading
+from glob import glob
+# import copy
+import json
+# from io import BytesIO
+# from pydantic import BaseModel
+# import pprint
+# import pandas as pd
+from datetime import datetime, timedelta
+# import pytz
+# import math
+# import numpy as np
+import sqlite3
+import struct
+import re
+
+load_dotenv(override=True)
+key = os.getenv('OPENAI_API_KEY')
+users = os.getenv('LOGNAME')
+unames = users.split(',')
+pwds = os.getenv('PASSWORD')
+pwdList = pwds.split(',')
+
+site = os.getenv('SITE')
+if site == 'local':
+    dp = Path('./data')
+    dp.mkdir(exist_ok=True)
+    dataDir = './data/'
+else:
+    dp = Path('/data')
+    dp.mkdir(exist_ok=True)
+    dataDir = '/data/'
+
+
+speak_file = dataDir + "speek.wav"
+
+# client = OpenAI(api_key = key)
+
+#digits = ['zero: ','one: ','two: ','three: ','four: ','five: ','six: ','seven: ','eight: ','nine: ']
+
+abbrevs = {'St. ' : 'Saint ', 'Mr. ': 'mister ', 'Mrs. ':'mussus ', 'Mr. ':'mister ', 'Ms. ':'mizz '}
+
+# def load_db(dropDown):
+#     db_paths = glob(dataDir + '*.db')
+#     db_list = []
+#     for path in db_paths:
+#         db_list.append(os.path.basename)
+#     return gr.Dropdown(choices=db_list, value=db_list[0])
+
+def set_db(value):
+    return value
+
+def remove_times(txt):
+   pattern = '\s\[\d+\]\s'
+   rv = re.sub(pattern, '', txt)
+   return rv
+
+def seek_hms(seek_ms):
+    seek_ms /= 1000;
+    hrs = int(seek_ms / 3600)
+    mins = int((seek_ms - hrs * 3600) / 60)
+    secs = int(seek_ms - hrs * 3600 - mins * 60)
+    return f'{hrs}h{mins}m{secs}s'
+
+def do_search(prompt, db_name):
+    if not os.path.exists(dataDir + db_name):
+        return []
+    embeddings = get_db_embeddings(db_name)
+    (prompt_embed, status) = get_prompt_embedding(prompt)
+    dot_products = []
+    for (name, text, time, yt_id, db_embed) in embeddings:
+        dp = dot_product(prompt_embed, db_embed)
+        dot_products.append((name, text, time, yt_id, dp) )
+    sorted_dots = sorted(dot_products, key=lambda x: x[4])[-10:]
+    sorted_dots.reverse()
+    return sorted_dots
+
+def dot_product(v1, v2):
+    # v1n = np.array(v1)
+    # v2n = np.array(v2)
+    # dotp = float(np.dot(v1n, v2n))
+    dotp = 0.0
+    for i in range(len(v1)):
+        dotp += v1[i]*v2[i]
+    return dotp
+
+def get_db_embeddings(db_name):
+    # times = []
+    # names = []
+    # texts = []
+    # yt_ids = []
+    embeds = []
+    conn = sqlite3.connect(dataDir + db_name)
+    cur = conn.cursor()
+    result = cur.execute('SELECT * from Embeds')
+    unpacker = struct.Struct('<f')
+    for row in result.fetchall():
+        time = row[1] 
+        name = row[2]
+        text = row[3]
+        yt_id = row[4]
+        embed = row[5]
+        x = []
+        row_embed = []
+        for i in range(1536):
+            j = 4*i
+            x=bytes(embed[j:j+4])
+            val = unpacker.unpack(x)[0]
+            row_embed.append(val)
+        embeds.append( (name, text, time, yt_id, row_embed) )
+    conn.close()
+    return (embeds)
+
+
+def get_prompt_embedding(txt):
+    response = Client().embeddings.create(
+        input=txt,
+        model="text-embedding-3-small"
+        )
+    embedding = response.data[0].embedding
+    l = len(embedding)
+    return (embedding, 'ok')
+
+def write_db_file(fpath):
+    try:
+        with open(fpath, 'rb') as fp:
+            data = fp.read()
+            fname = os.path.basename(fpath)
+    except:
+        return 'Unable to load database, could not read selected file'
+    try:
+        with open(dataDir + fname, 'wb') as fp:
+            fp.write(data)
+    except:
+        return 'Unable to load database, could not write data'
+    try:
+        os.remove(fpath)
+    except:
+        return "Database loaded, but error deleting temp file"
+    return 'Database loaded'
+
+
+
+def Client():
+    return OpenAI(api_key = key)
+
+
+def md(txt):
+    # if 'DOCTYPE' in txt:
+    #     return str(txt.replace('GPT','<br>GPT'))
+    # else:
+    return str(txt).replace('```', ' ').replace('  ', '&nbsp;&nbsp;').replace('  ', '&nbsp;&nbsp;').replace('  ', '&nbsp;&nbsp;').replace('\n','<br>')
+    # return txt
+
+
+
+def genUsageStats(do_reset=False):
+    result = []
+    ttotal4o_in = 0
+    ttotal4o_out = 0
+    ttotal4mini_in = 0
+    ttotal4mini_out = 0
+    totalAudio = 0
+    totalSpeech = 0
+    totalImages = 0
+    totalHdImages = 0
+    if do_reset:
+        dudPath = dataDir + '_speech.txt'
+        if os.path.exists(dudPath):
+            os.remove(dudPath)
+    for user in unames:
+        tokens4o_in = 0
+        tokens4o_out = 0
+        tokens4mini_in = 0
+        tokens4mini_out = 0
+        fp = dataDir + user + '_log.txt'
+        if os.path.exists(fp):
+            accessOk = False
+            for i in range(3):
+                try:
+                    with open(fp) as f:
+                        dataList = f.readlines()
+                    if do_reset:
+                        os.remove(fp)
+                    else:
+                        for line in dataList:
+                            (u, t) = line.split(':')
+                            (t, m) = t.split('-')
+                            (tin, tout) = t.split('/')
+                            incount = int(tin)
+                            outcount = int(tout)
+                            if 'mini' in m:
+                                tokens4mini_in += incount
+                                tokens4mini_out += outcount
+                                ttotal4mini_in += incount
+                                ttotal4mini_out += outcount
+                            else:
+                                tokens4o_in += incount
+                                tokens4o_out += outcount
+                                ttotal4o_in += incount
+                                ttotal4o_out += outcount
+                    accessOk = True
+                    break
+                except:
+                    sleep(3)
+            if not accessOk:
+                return f'File access failed reading stats for user: {user}'
+        userAudio = 0
+        fp = dataDir + user + '_audio.txt'
+        if os.path.exists(fp):
+            accessOk = False
+            for i in range(3):
+                try:
+                    with open(fp) as f:
+                        dataList = f.readlines()
+                    if do_reset:
+                        os.remove(fp)
+                    else:
+                        for line in dataList:
+                            (dud, len) = line.split(':')
+                            userAudio += int(len)
+                        totalAudio += int(userAudio)
+                    accessOk = True
+                    break
+                except:
+                    sleep(3)
+            if not accessOk:
+                return f'File access failed reading audio stats for user: {user}'
+        userSpeech = 0
+        fp = dataDir + user + '_speech.txt'
+        if os.path.exists(fp):
+            accessOk = False
+            for i in range(3):
+                try:
+                    with open(fp) as f:
+                        dataList = f.readlines()
+                    if do_reset:
+                        os.remove(fp)
+                    else:
+                        for line in dataList:
+                            (dud, len) = line.split(':')
+                            userSpeech += int(len)
+                        totalSpeech += int(userSpeech)
+                    accessOk = True
+                    break
+                except:
+                    sleep(3)
+            if not accessOk:
+                return f'File access failed reading speech stats for user: {user}'
+        user_images = 0
+        user_hd_images = 0
+        result.append([user, f'{tokens4mini_in}/{tokens4mini_out}', f'{tokens4o_in}/{tokens4o_out}', f'audio:{userAudio}',f'speech:{userSpeech}', f'images:{user_images}/{user_hd_images}'])
+    result.append(['totals', f'{ttotal4mini_in}/{ttotal4mini_out}', f'{ttotal4o_in}/{ttotal4o_out}', f'audio:{totalAudio}',f'speech:{totalSpeech}', f'images:{totalImages}/{totalHdImages}'])
+    return result       
+
+def new_conversation(user):
+    clean_up(user)  # .wav files
+    return [None, [], gr.Markdown(value='', label='Dialog', container=True), '']
+
+def updatePassword(user, pwd):
+    password = pwd.lower().strip()
+    if user == unames[0] and password == pwdList[0]:
+        return [password, "*********", gr.Button(visible=True, value='Upload Database')]
+    else:
+        return [password, "*********", gr.Button(visible=False, value='Upload Database')]
+
+
+def chat(prompt, user_window, pwd_window, past, response, gptModel, clip_text, db_name):
+    user_window = user_window.lower().strip()
+    isBoss = False
+    clip_txt = clip_text
+    if not response:
+        response = ''
+    else:
+        loc = response.find('Following are Clips')
+        if loc > -1:
+            response = response[:loc]
+    plot = gr.LinePlot(visible=False)
+    # plot = gr.Plot(visible=False)
+    if user_window == unames[0] and pwd_window == pwdList[0]:
+        isBoss = True
+        if prompt.startswith('dot'):
+            results = do_search(prompt[4:], selected_db)
+            txt = ''
+            for (name, text, time, yt_id, dp) in results:
+                yt_id = yt_id.replace('"','')
+                seek_HMS = seek_hms(time)
+                seek_colons = seek_HMS.replace('h',' : ').replace('m',' : ').replace('s','')
+                yt_url = f'https://www.youtube.com/watch?v={yt_id}#t={seek_HMS}'
+                txt += md(f'\n\n{name}\nAt seek time: {seek_colons}\nYouTube Link: [URL]({yt_url}\n\n{remove_times(text)}\n================')
+            return [past, txt, None, gptModel,clip_text]
+        if prompt.startswith('embed'):
+            (embed, status) = get_prompt_embedding(prompt)
+            return [past, str(status), None, gptModel,clip_text]
+        if prompt.startswith('allembeds'):
+            get_db_embeddings()
+            return [past, 'ok', None, gptModel,clip_text]
+        if prompt == 'stats':
+            response = genUsageStats()
+            return [past, str(response), None, gptModel,clip_text]
+        if prompt == 'reset':
+            response = genUsageStats(True)
+            return [past, md(response), None, gptModel,clip_text]
+        if prompt.startswith('gpt4'):
+            gptModel = 'gpt-4o-2024-08-06'
+            prompt = prompt[5:]
+        if prompt.startswith("clean"):
+            user = prompt[6:]
+            response = f'cleaned all .wav and .b64 files for {user}'
+            final_clean_up(user, True)
+            return [past, response, None, gptModel,clip_text]
+        if prompt.startswith('files'):
+            (log_cnt, wav_cnt, other_cnt, others, log_list) = list_permanent_files()
+            response = f'{log_cnt} log files\n{wav_cnt} .wav files\n{other_cnt} Other files:\n{others}\nlogs: {str(log_list)}'
+            return [past, response, None, gptModel,clip_text]
+    if user_window in unames and pwd_window == pwdList[unames.index(user_window)]:
+        chatType = 'normal'
+        prompt = prompt.strip()
+        finish_reason = 'ok'
+        rag_txt = ''
+        prompt_bare = prompt
+        first_time = False
+        if len(past) == 0:
+            first_time = True
+            results = do_search(prompt, db_name)
+            clip_txt = '\n=================\n\nFollowing are Clips and YouTube Links based on your initial query:\n=================\n'
+            if len(results) == 0:
+                clip_txt += '\nSorry, the database you selected appears to be missing\n'
+            for (name, text, time, yt_id, dp) in results:
+                yt_id = yt_id.replace('"','')
+                seek_HMS = seek_hms(time)
+                seek_colons = seek_HMS.replace('h',' : ').replace('m',' : ').replace('s','')
+                pure_text = remove_times(text)
+                yt_url = f'https://www.youtube.com/watch?v={yt_id}#t={seek_HMS}'
+                clip_txt += md(f'\n\n{name}\nAt seek time: {seek_colons}\nYouTube Link: [URL]({yt_url}\n\n{pure_text}\n================')
+                rag_txt += pure_text
+            prompt = rag_txt + '.\n  ' + prompt + '\nGive higher priority to the information just provided.'
+        past.append({"role":"user", "content":prompt})
+        completion = Client().chat.completions.create(model=gptModel, messages=past)
+        reporting_model = gptModel
+        reply = completion.choices[0].message.content
+        tokens_in = completion.usage.prompt_tokens
+        tokens_out = completion.usage.completion_tokens
+        tokens = completion.usage.total_tokens
+        response += "\n\n***YOU***: " + prompt_bare + "\n\n***GPT***: " +  reply.replace('```','\n\n```\n\n')
+        if len(clip_txt) > 0:
+            response += md(clip_txt)
+
+        if isBoss:
+            response += md(f"\n\n{reporting_model}: tokens in/out = {tokens_in}/{tokens_out}\n")
+        if finish_reason != 'ok':
+            response += md(f"\n{finish_reason}\n")
+        if tokens > 40000:
+            response += "\n\nTHIS DIALOG IS GETTING TOO LONG. PLEASE RESTART CONVERSATION SOON."
+        past.append({"role":"assistant", "content": reply})
+        accessOk = False
+        for i in range(3):
+            try:
+                dataFile = new_func(user_window)
+                with open(dataFile, 'a') as f:
+                    m = '4o'
+                    if 'mini' in reporting_model:
+                        m = '4omini'
+                    f.write(f'{user_window}:{tokens_in}/{tokens_out}-{m}\n')
+                accessOk = True
+                break
+            except Exception as e:
+                sleep(3)
+        if not accessOk:
+            response += f"\nDATA LOG FAILED, path = {dataFile}"
+        return [past, response , None, gptModel,clip_txt]
+    else:
+        return [[], "User name and/or password are incorrect", prompt, gptModel,clip_txt]
+
+def new_func(user):
+    dataFile = dataDir + user + '_log.txt'
+    return dataFile
+
+def transcribe(user, pwd, fpath):
+    user = user.lower().strip()
+    pwd = pwd.lower().strip()
+    if not (user in unames and pwd in pwdList):
+        return 'Bad credentials'
+    with audioread.audio_open(fpath) as audio:
+        duration = int(audio.duration)
+        if duration > 0:
+            with open(dataDir + user + '_audio.txt','a') as f:
+                f.write(f'audio:{str(duration)}\n')
+    with open(fpath,'rb') as audio_file:
+        transcript = Client().audio.transcriptions.create(
+            model='whisper-1', file = audio_file ,response_format = 'text' )
+    reply = transcript
+    return str(reply)
+
+def pause_message():
+    return "Audio input is paused.  Resume or Stop as desired"
+
+def update_user(user_win):
+    user_win = user_win.lower().strip()
+    user = 'unknown'
+    for s in unames:
+        if user_win == s:
+            user = s
+            break
+    return [user, user]
+
+def speech_worker(chunks=[],q=[]):
+    for chunk in chunks:
+        fpath = q.pop(0)
+        response = Client().audio.speech.create(model="tts-1", voice="fable", input=chunk, speed=0.85, response_format='wav')
+        with open(fpath, 'wb') as fp:
+            fp.write(response.content)
+
+def gen_speech_file_names(user, cnt):
+    rv = []
+    for i in range(0, cnt):
+        rv.append(dataDir + f'{user}_speech{i}.wav')
+    return rv
+
+def final_clean_up(user, do_b64 = False):
+    user = user.strip().lower()
+    if user == 'kill':
+        flist = glob(dataDir + '*')
+    elif user == 'all':
+        flist = glob(dataDir + '*_speech*.wav')
+    else:
+        flist = glob(dataDir + f'{user}_speech*.wav')
+    for fpath in flist:
+        try:
+            os.remove(fpath)
+        except:
+            continue
+
+def list_permanent_files():
+    flist = os.listdir(dataDir)
+    others = []
+    log_cnt = 0
+    wav_cnt = 0
+    other_cnt = 0
+    list_logs = []
+    for fpath in flist:
+        if fpath.endswith('.txt'):
+            log_cnt += 1
+            list_logs.append(fpath)
+        elif fpath.endswith('.wav'):
+            wav_cnt += 1
+        else:
+            others.append(fpath)
+    other_cnt = len(others)
+    if log_cnt > 5:
+        list_logs = []
+    return (str(log_cnt), str(wav_cnt), str(other_cnt), str(others), list_logs)
+
+
+def show_help():
+    txt = '''
+    1.  Gemeral:
+        1.1 Login with user name and password (not case-sensitive)
+        1.2 Type prompts (questions, instructions) into "Prompt or Question" window (OR) you can speak prompts by
+           tapping the audio "Record" button, saying your prompt, then tapping the "Stop" button.
+           Your prompt will appear in the Prompt window, and you can edit it there if needed.
+        1.3 Text in the "Dialog" window can be spoken by tapping the "Speak Dialog" button.
+    2.  Chat:
+        2.1 Enter prompt and tap the "Submit Prompt/Question" button.  The responses appear in the Dialog window.
+        2.2 Enter follow-up questions in the Prompt window either by typing or speaking. Tap the voice
+              entry "Reset Voice Entry" button to enable additional voice entry. Then tap "Submit Prompt/Question".
+        2.3 If topic changes or when done chatting, tap the "Restart Conversation" button.
+    Hints:
+        1. Better chat results are obtained by including detailed descriptions and instructions
+            in the prompt.
+        2. Always tap "Restart Conversation" before changing chat topics.
+        3. Audio input and output functions depend on the hardware capability of your device.
+        4. "Speak Dialog" will voice whatever is currently in the Dialog window.  You can repeat it and you
+             can edit what's to be spoken.  Except:  In a chat conversation, spoken dialog will only include
+             the latest prompt/response ("YOU:/GPT:") sequence.'''
+    return str(txt).replace('```', ' ').replace('  ', '&nbsp;&nbsp;').replace('  ', '&nbsp;&nbsp;').replace('  ', '&nbsp;&nbsp;').replace('\n','<br>')
+
+def upload_db_file(visibility):
+    viz = not visibility
+    return [viz, gr.File(visible=viz, type="filepath", interactive=True, label='Upload Database')]
+
+with gr.Blocks(theme=gr.themes.Soft()) as demo:
+    history = gr.State([])
+    password = gr.State("")
+    user = gr.State("unknown")
+    model = gr.State("gpt-4o-mini")
+    clip_text = gr.State("")
+    file_browser_visibility = gr.State(False)
+    q = gr.State([])
+    qsave = gr.State([])
+    selected_db = gr.State('GoodNews.db')
+
+    def clean_up(user):
+        flist = glob(dataDir + f'{user}_speech*.wav')
+        for fpath in flist:
+            try:
+                os.remove(fpath)
+            except:
+                continue
+
+    def initial_audio_output(txt, user):
+        global digits
+        global abbrevs
+        if not user in unames:
+            return [gr.Audio(sources=None), []]
+        clean_up(user)
+        q = []
+        if len(txt.strip()) < 5:
+            return ['None', q]
+        try:
+            loc = txt.rindex('YOU:')
+            txt = txt[loc:]
+        except:
+            pass
+        for s,x in abbrevs.items():
+            txt = txt.replace(s, x)
+        words_in = txt.replace('**', '').replace('&nbsp;','').split('<br>')
+        words_out = []
+        for s in words_in:
+            s = s.lstrip('- *@#$%^&_=+-')
+            if len(s) > 0:
+                loc = s.find(' ')
+                if loc > 1:
+                    val = s[0:loc]
+                    isnum = val.replace('.','0').isdecimal()
+                    if isnum:
+                        if val.endswith('.'):
+                            val = val[:-1].replace('.',' point ') + '., '
+                        else:
+                            val = val.replace('.', ' point ') + ', '
+                        s = 'num'+ val + s[loc:]
+                words_out.append(s)
+        chunklist = []
+        for chunk in words_out:
+            if chunk.strip() == '':
+                continue
+            isnumbered = chunk.startswith('num')
+            number = ''
+            loc = 0
+            if isnumbered:
+                chunk = chunk[3:]
+                loc = chunk.index(',')
+                number = chunk[0:loc]
+                chunk = chunk[loc:]
+            locs = []
+            for i in range(1,len(chunk)-1):
+                (a, b, c) = chunk[i-1:i+2]
+                if a.isdecimal() and b == '.' and c.isdecimal():
+                    locs.append(i)
+            for i in locs:
+                chunk = chunk[:i] + ' point ' + chunk[i+1:]
+            if len(chunk) > 50:
+                finechunks = chunk.split('.')
+                for fchunk in finechunks:
+                    if isnumbered:
+                        fchunk = number + fchunk
+                        isnumbered = False
+                    if len(fchunk) > 0:
+                        if fchunk != '"':
+                            chunklist.append(fchunk)
+            else:
+                line = number + chunk
+                if line != '"':
+                    chunklist.append(line)
+        total_speech = 0
+        for chunk in chunklist:
+            total_speech += len(chunk)
+        with open(dataDir + user + '_speech.txt','a') as f:
+            f.write(f'speech:{str(total_speech)}\n')
+        chunk = chunklist[0]
+        if chunk.strip() == '':
+            return gr.Audio(sources=None)
+        fname_list = gen_speech_file_names(user, len(chunklist))
+        q = fname_list.copy()
+        qsave = fname_list.copy()
+        fname = q.pop(0)
+        if len(chunklist) > 0:
+            threading.Thread(target=speech_worker, daemon=True, args=(chunklist[1:],fname_list[1:])).start()
+        response = Client().audio.speech.create(model="tts-1", voice="fable", input=chunk, speed=0.85, response_format='wav')
+        with open(fname, 'wb') as fp:
+            fp.write(response.content)
+        return [fname, q]
+
+    def gen_output_audio(q, user):
+        try:
+            fname = q.pop(0)
+        except:
+            final_clean_up(user)
+            return [None, gr.Audio(sources=None)]
+        if not os.path.exists(fname):
+            sleep(3)
+            if not os.path.exists(fname):
+                response = Client().audio.speech.create(model="tts-1", voice="fable",
+                    input='Sorry, text-to-speech is responding too slow right now', speed=0.85, response_format='wav')
+                with open(fname, 'wb') as fp:
+                    fp.write(response.content)
+                q = []
+        return [fname, q]
+
+
+    gr.Markdown('# MTOI Search')
+    gr.Markdown('Enter user name & password.  Tap "Help & Hints" button for more instructions.')
+    with gr.Row():
+        user_window = gr.Textbox(label = "User Name")
+        user_window.blur(fn=update_user, inputs=user_window, outputs=[user, user_window])
+        pwd_window = gr.Textbox(label = "Password")
+        help_button = gr.Button(value='Help & Hints')
+    with gr.Row():
+        audio_widget = gr.Audio(type='filepath', format='wav',waveform_options=gr.WaveformOptions(
+           show_recording_waveform=True), sources=['microphone'], scale = 3, label="Prompt/Question Voice Entry", max_length=120)
+        reset_button = gr.ClearButton(value="Reset Voice Entry", scale=1) #new_func1()
+    with gr.Row():
+        clear_button = gr.Button(value="Restart Conversation")
+        db_chooser = gr.Dropdown(type="value", label='Choose Database', show_label=True,
+                                choices=['GoodNews.db', 'passover.db', 'MTOI5.db'], interactive=True)
+        button_upload_db = gr.Button(value='Upload Database', visible=False)
+        speak_output = gr.Button(value="Speak Dialog", visible=True)
+        submit_button = gr.Button(value="Submit Prompt/Question")
+    prompt_window = gr.Textbox(label = "Prompt or Question")
+    gr.Markdown('### **Dialog:**')
+    #output_window = gr.Text(container=True, label='Dialog')
+    output_window = gr.Markdown(container=True)
+    with gr.Row():
+        db_file = gr.File(visible=False, type="filepath", interactive=True, label='Upload Database')
+    pwd_window.blur(updatePassword, inputs = [user_window, pwd_window], outputs = [password, pwd_window, button_upload_db])
+    submit_button.click(chat,
+             inputs=[prompt_window, user_window, password, history, output_window, model, clip_text, selected_db],
+             outputs=[history, output_window, prompt_window, model, clip_text])
+    clear_button.click(fn=new_conversation, inputs=user_window, outputs=[prompt_window, history, output_window, clip_text])
+    audio_widget.stop_recording(fn=transcribe, inputs=[user_window, password, audio_widget],
+                                outputs=[prompt_window])
+    audio_widget.pause_recording(fn=pause_message, outputs=[prompt_window])
+    reset_button.add(audio_widget)
+    audio_out = gr.Audio(autoplay=True, visible=False)
+    audio_out.stop(fn=gen_output_audio, inputs=[q, user_window], outputs = [audio_out, q])
+    speak_output.click(fn=initial_audio_output, inputs=[output_window, user_window], outputs=[audio_out, q])
+    help_button.click(fn=show_help, outputs=output_window)
+    button_upload_db.click(fn=upload_db_file,inputs = [file_browser_visibility],
+                          outputs = [file_browser_visibility, db_file])
+    db_file.upload(fn=write_db_file, inputs=[db_file], outputs=[output_window])
+    db_chooser.input(fn=set_db,inputs= [db_chooser], outputs= [selected_db])
+    # demo.load(fn=load_db,inputs=[db_chooser],outputs=[db_chooser])
+
+demo.launch(share=True, allowed_paths=[dataDir], ssr_mode=False)
+