sample caching

app/cookie.js

@@ -0,0 +1,30 @@
+window.getArenaCookie = function getArenaCookie(cname) {
+    let name = cname + "=";
+    let decodedCookie = decodeURIComponent(window.document.cookie);
+    let ca = decodedCookie.split(';');
+    for (let i = 0; i < ca.length; i++) {
+        let c = ca[i];
+        while (c.charAt(0) == ' ') {
+        c = c.substring(1);
+        }
+        if (c.indexOf(name) == 0) {
+        return c.substring(name.length, c.length);
+        }
+    }
+    return "";
+}
+
+window.setArenaCookie = function setArenaCookie(cname, cvalue, exdays) {
+    const d = new Date();
+    d.setTime(d.getTime() + (exdays * 24 * 60 * 60 * 1000));
+    let expires = "expires=" + d.toUTCString();
+    window.document.cookie = cname + "=" + cvalue + ";" + expires + "; path=/; SameSite=None; Secure";
+}
+
+if (window.getArenaCookie('session').length == 0)
+{
+    const d = new Date();
+    // store cookie for 90 days, about the time the the cached audio should be deleted
+    window.setArenaCookie('session', d.getTime().toString(), 90);
+    console.log('Session cookie created')
+}

app/synth.py

@@ -3,6 +3,7 @@ from .models import *
 from .utils import *
 from .config import *
 from .init import *
+from .sample_caching import *
 
 import gradio as gr
 from pydub import AudioSegment
@@ -203,6 +204,28 @@ def synthandreturn(text, autoplay, request: gr.Request):
 
         return inputs
 
+    def _cache_sample(text, model):
+        # skip caching if not hardcoded sentence
+        if (text not in sents):
+            return False
+
+        already_cached = False
+        # check if already cached
+        for cached_sample in cached_samples:
+            # TODO:replace cached with newer version
+            if (cached_sample.transcript == text and cached_sample.modelName == model):
+                already_cached = True
+                return True
+
+        if (already_cached):
+            return False
+
+        try:
+            cached_samples.append(Sample(results[model], text, model))
+        except:
+            print('Error when trying to cache sample')
+            return False
+
     mdl1k = mdl1
     mdl2k = mdl2
     print(mdl1k, mdl2k)
@@ -222,10 +245,10 @@ def synthandreturn(text, autoplay, request: gr.Request):
     ):
         # run Zero-GPU spaces one at a time
         predict_and_update_result(text, mdl1k, results, request)
-        # _cache_sample(text, mdl1k)
+        _cache_sample(text, mdl1k)
 
         predict_and_update_result(text, mdl2k, results, request)
-        # _cache_sample(text, mdl2k)
+        _cache_sample(text, mdl2k)
     else:
         # use multithreading
         thread1 = threading.Thread(target=predict_and_update_result, args=(text, mdl1k, results, request))
@@ -240,8 +263,8 @@ def synthandreturn(text, autoplay, request: gr.Request):
         thread2.join(120)
 
         # cache the result
-        # for model in [mdl1k, mdl2k]:
-        #     _cache_sample(text, model)
+        for model in [mdl1k, mdl2k]:
+            _cache_sample(text, model)
 
     print(f"Retrieving models {mdl1k} and {mdl2k} from API")
     return (
@@ -358,24 +381,8 @@ def synthandreturn_battle(text, mdl1, mdl2, autoplay):
         gr.update(visible=False), #nxt round btn
     )
 
-# Unlock vote
-
-def unlock_vote(btn_index, aplayed, bplayed):
-    # sample played
-    if btn_index == 0:
-        aplayed = gr.State(value=True)
-    if btn_index == 1:
-        bplayed = gr.State(value=True)
-
-    # both audio samples played
-    if bool(aplayed) and bool(bplayed):
-        print('Both audio samples played, voting unlocked')
-        return [gr.update(interactive=True), gr.update(interactive=True), gr.update(), gr.update()]
-
-    return [gr.update(), gr.update(), aplayed, bplayed]
-
 def randomsent():
-    return random.choice(sents), '🎲'
+    return '⚡', random.choice(sents), '🎲'
 def randomsent_battle():
     return tuple(randomsent()) + tuple(random_m())
 def clear_stuff():

app/ui.py

@@ -33,6 +33,7 @@ document.addEventListener('keypress', shortcuts, false);
 
 """
 head_js += shortcut_js
+head_js += open("app/cookie.js").read()
 head_js += '</script>'
 
 with gr.Blocks() as about:

app/ui_vote.py

@@ -3,37 +3,23 @@ from .config import *
 from .synth import *
 from .vote import *
 from .messages import *
+from .sample_caching import *
 
 blur_text_js = 'document.getElementById("arena-text-input").classList.add("blurred-text")'
 unblur_text_js = 'document.getElementById("arena-text-input").classList.remove("blurred-text")'
 
 def disable():
-    return [gr.update(interactive=False), gr.update(interactive=False), gr.update(interactive=False)]
+    return [gr.update(interactive=False), gr.update(interactive=False), gr.update(interactive=False), gr.update(interactive=False)]
 def enable():
-    return [gr.update(interactive=True), gr.update(interactive=True), gr.update(interactive=True)]
+    return [gr.update(interactive=True), gr.update(interactive=True), gr.update(interactive=True), gr.update(interactive=True)]
 def blur_text():
     return gr.update(elem_classes=['blurred-text'])
 def unblur_text():
     return gr.update(elem_classes=[])
 
-def unlock_vote(autoplay, btn_index, aplayed, bplayed):
-    if autoplay == False:
-        return [gr.update(), gr.update(), aplayed, bplayed]
-
-    # sample played
-    if btn_index == 0:
-        aplayed = True
-    if btn_index == 1:
-        bplayed = True
-
-    # both audio samples played
-    if bool(aplayed) and bool(bplayed):
-        # print('Both audio samples played, voting unlocked')
-        return [gr.update(interactive=True), gr.update(interactive=True), True, True]
-
-    return [gr.update(), gr.update(), aplayed, bplayed]
-
 with gr.Blocks() as vote:
+    session_hash = gr.Textbox(visible=False, value='')
+
     # sample played, using Checkbox so that JS can fetch the value
     aplayed = gr.Checkbox(visible=False, value=False)
     bplayed = gr.Checkbox(visible=False, value=False)
@@ -42,6 +28,7 @@ with gr.Blocks() as vote:
     gr.Markdown(INSTR)
     with gr.Group():
         with gr.Row():
+            cachedt = gr.Button('⚡', scale=0, min_width=0, variant='tool', interactive=True)
             text = gr.Textbox(
                 container=False,
                 show_label=False,
@@ -54,7 +41,7 @@ with gr.Blocks() as vote:
             )
             randomt = gr.Button('🎲', scale=0, min_width=0, variant='tool')
         randomt\
-            .click(randomsent, outputs=[text, randomt])\
+            .click(randomsent, outputs=[cachedt, text, randomt])\
             .then(None, js="() => "+ unblur_text_js)
         btn = gr.Button("Synthesize", variant='primary')
     model1 = gr.Textbox(interactive=False, lines=1, max_lines=1, visible=False)
@@ -138,19 +125,26 @@ with gr.Blocks() as vote:
         gr.update(visible=False), #nxt round btn"""
     # , concurrency_count=1, concurrency_id="sync_queue"
     btn\
-        .click(disable, outputs=[btn, abetter, bbetter])\
+        .click(disable, outputs=[btn, abetter, bbetter, cachedt])\
         .then(synthandreturn, inputs=[text, autoplay], outputs=outputs)\
-        .then(enable, outputs=[btn, gr.State(), gr.State()])\
+        .then(enable, outputs=[btn, gr.State(), gr.State(), gr.State()])\
         .then(None, js="() => "+ unblur_text_js)
     # Next Round ; blur text
     nxtroundbtn\
         .click(clear_stuff, outputs=outputs)\
-        .then(randomsent, outputs=[text, randomt])\
-        .then(synthandreturn, inputs=[text, autoplay], outputs=outputs)\
-        .then(enable, outputs=[btn, gr.State(), gr.State()])
+        .then(disable, outputs=[btn, abetter, bbetter, cachedt])\
+        .then(give_cached_sample, inputs=[session_hash], outputs=[*outputs, cachedt])\
+        .then(enable, outputs=[btn, gr.State(), gr.State(), gr.State()])
     # blur text
     nxtroundbtn.click(None, js="() => "+ blur_text_js)
 
+    # fetch a comparison pair from cache
+    cachedt\
+        .click(disable, outputs=[btn, abetter, bbetter, cachedt])\
+        .then(give_cached_sample, inputs=[session_hash], outputs=[*outputs, cachedt])\
+        .then(enable, outputs=[btn, gr.State(), gr.State(), gr.State()])
+    # TODO: await download of sample before allowing playback
+
     # Allow interaction with the vote buttons only when both audio samples have finished playing
     aud1\
         .stop(
@@ -174,5 +168,21 @@ with gr.Blocks() as vote:
     aud2.stop(None, inputs=[aplayed], js="(a) => a ? "+ unblur_text_js +" : 0;")
 
     nxt_outputs = [abetter, bbetter, prevmodel1, prevmodel2, nxtroundbtn]
-    abetter.click(a_is_better, outputs=nxt_outputs, inputs=[model1, model2, useridstate])
-    bbetter.click(b_is_better, outputs=nxt_outputs, inputs=[model1, model2, useridstate])
+    abetter\
+        .click(a_is_better, outputs=nxt_outputs, inputs=[model1, model2, useridstate, text])\
+        .then(voted_on_cached, inputs=[model1, model2, text, session_hash], outputs=[])
+    bbetter\
+        .click(b_is_better, outputs=nxt_outputs, inputs=[model1, model2, useridstate, text])\
+        .then(voted_on_cached, inputs=[model1, model2, text, session_hash], outputs=[])
+
+    # get session cookie
+    vote\
+        .load(
+            None,
+            None,
+            session_hash,
+            js="() => { return getArenaCookie('session') }",
+        )
+    # give a cached sample pair to voter; .then() did not work here
+    vote\
+        .load(give_cached_sample, inputs=[session_hash, autoplay], outputs=[*outputs, cachedt])

app/vote.py

@@ -60,56 +60,68 @@ def b_is_better_battle(model1, model2, userid):
 
 # A/B better
 
-def a_is_better(model1, model2, userid, battle=False):
-    print("A is better", model1, model2)
-    if not model1 in AVAILABLE_MODELS.keys() and not model1 in AVAILABLE_MODELS.values():
+def a_is_better(model1, model2, userid, text):
+    return is_better(model1, model2, userid, text, True)
+def b_is_better(model1, model2, userid, text):
+    return is_better(model1, model2, userid, text, False)
+
+def is_better(model1, model2, userid, text, chose_a):
+    if(
+        (
+            not model1 in AVAILABLE_MODELS.keys()
+            and not model1 in AVAILABLE_MODELS.values()
+        )
+        or (
+            not model2 in AVAILABLE_MODELS.keys()
+            and not model2 in AVAILABLE_MODELS.values()
+        )
+    ):
         raise gr.Error('Sorry, please try voting again.')
+
+    # userid is unique for each cast vote pair
     userid = mkuuid(userid)
     if model1 and model2:
         conn = get_db()
         cursor = conn.cursor()
-        cursor.execute('INSERT INTO votelog (username, chosen, rejected) VALUES (?, ?, ?)', (str(userid), model1, model2,))
-        if scheduler:
-            with scheduler.lock:
-                conn.commit()
+        sql_query = 'INSERT INTO votelog (username, chosen, rejected) VALUES (?, ?, ?)'
+        if chose_a:
+            cursor.execute(sql_query, (str(userid), model1, model2))
         else:
+            cursor.execute(sql_query, (str(userid), model2, model1))
+
+        with scheduler.lock:
             conn.commit()
-        cursor.close()
-        upvote_model(model1, str(userid), battle)
-        downvote_model(model2, str(userid), battle)
-    return reload(model1, model2, userid, chose_a=True)
-def b_is_better(model1, model2, userid, battle=False):
-    print("B is better", model1, model2)
-    if not model1 in AVAILABLE_MODELS.keys() and not model1 in AVAILABLE_MODELS.values():
-        raise gr.Error('Sorry, please try voting again.')
-    userid = mkuuid(userid)
-    if model1 and model2:
-        conn = get_db()
-        cursor = conn.cursor()
-        cursor.execute('INSERT INTO votelog (username, chosen, rejected) VALUES (?, ?, ?)', (str(userid), model2, model1,))
-        if scheduler:
-            with scheduler.lock:
-                conn.commit()
+            # also retrieve primary key ID
+            cursor.execute('SELECT last_insert_rowid()')
+            votelogid = cursor.fetchone()[0]
+            cursor.close()
+
+        if chose_a:
+            upvote_model(model1, str(userid))
+            downvote_model(model2, str(userid))
         else:
-            conn.commit()
-        cursor.close()
-        upvote_model(model2, str(userid), battle)
-        downvote_model(model1, str(userid), battle)
-    return reload(model1, model2, userid, chose_b=True)
+            upvote_model(model2, str(userid))
+            downvote_model(model1, str(userid))
+        log_text(text)
+        # log_text(text, votelogid)
 
-# Reload
+    return reload(model1, model2, userid, chose_a=chose_a, chose_b=(not chose_a))
 
+# Reload
 def reload(chosenmodel1=None, chosenmodel2=None, userid=None, chose_a=False, chose_b=False):
+    # chosenmodel1 = make_link_to_space(chosenmodel1)
+    # chosenmodel2 = make_link_to_space(chosenmodel2)
     out = [
         gr.update(interactive=False, visible=False),
         gr.update(interactive=False, visible=False)
     ]
+    style = 'text-align: center; font-size: 1rem; margin-bottom: 0; padding: var(--input-padding)'
     if chose_a == True:
-        out.append(gr.update(value=f'Your vote: {chosenmodel1}', interactive=False, visible=True))
-        out.append(gr.update(value=f'{chosenmodel2}', interactive=False, visible=True))
+        out.append(gr.update(value=f'<p style="{style}">Your vote: {chosenmodel1}</p>', visible=True))
+        out.append(gr.update(value=f'<p style="{style}">{chosenmodel2}</p>', visible=True))
     else:
-        out.append(gr.update(value=f'{chosenmodel1}', interactive=False, visible=True))
-        out.append(gr.update(value=f'Your vote: {chosenmodel2}', interactive=False, visible=True))
+        out.append(gr.update(value=f'<p style="{style}">{chosenmodel1}</p>', visible=True))
+        out.append(gr.update(value=f'<p style="{style}">Your vote: {chosenmodel2}</p>', visible=True))
     out.append(gr.update(visible=True))
     return out