Marjor refactoring of the backend.

main.py

@@ -32,7 +32,6 @@ HF_DATASET_AUTH_TOKEN = os.environ.get('HF_DATASET_AUTH_TOKEN', "(none)")
 LOCAL_STORAGE_PATH = ""
 
 datetime_now = datetime.isoformat(datetime.utcnow())
-
 FILE_EVENTS_NAME = f"events-{datetime_now}-{uuid4()}.jsonl"
 FILE_SUBMITTED_NAME = f"submitted-{datetime_now}-{uuid4()}.jsonl"
 
@@ -45,7 +44,7 @@ else:
 if IS_LOCALHOST:
     DATABASE_NAME = "data/sessions_meta.db"
     LOCAL_STORAGE_PATH = Path("data/persistent/")
-    pathlib.Path(DATABASE_NAME).unlink(missing_ok=True)
+    # pathlib.Path(DATABASE_NAME).unlink(missing_ok=True)
     print(f"Database {DATABASE_NAME=} exists? {pathlib.Path(DATABASE_NAME).exists()}")
 else:
     DATABASE_NAME = "/tmp/cache/sessions_meta.db"
@@ -96,21 +95,20 @@ if session_state_table not in global_database_tables:
                                # foreign_keys=[("current_qeval", question_evaluation_table, "id")])
 Session_State_cls = session_state_table.dataclass()
 
-
-
 EVAL_STATE_NEW=0
 EVAL_STATE_QUERY=1
 EVAL_STATE_TIMEDOUT=2
 EVAL_STATE_ANSWER=3
 EVAL_STATE_ERROR=4
 
+
 # Constants to name the various HTML ids in the code
 HTML_SUBMIT_CODE_AREA = "submit_code_area"
 HTML_RESULTS_AREA = "prompt_response"
 HTML_CLEAR_FORM = "clear_the_form"
-HTML_SUBMIT_FEEDBACK = "submit_feedback"
 HTML_USER_DATA = "login_user_data"
-
+OAUTH_SECRET_SESSION_NAME = "oauth_secret"
+USER_DATA_SESSION_NAME = "user_data"
 
 def get_openid_configuration():
     config_url = OPENID_PROVIDER_URL + "/.well-known/openid-configuration"
@@ -142,7 +140,8 @@ else:
 
 
 hdrs = (
-        HighlightJS(langs=['python', 'javascript', 'html', 'css']),
+        HighlightJS(langs=['python', 'c', 'c++']),
+        # Meta(name="htmx-config", content='{"defaultSwapStyle":"outerHTML"}')
         )
 
 if IS_LOCALHOST:
@@ -150,9 +149,11 @@ if IS_LOCALHOST:
     print("Localhost detected in SPACE_HOST. App started in debug+live mode!")
     app, rt = fast_app(debug=True, live=True, hdrs=hdrs)
     REFRESH_TIME = 0.1
+    EVAL_TIMEOUT_SECONDS = 2
 else:
     app, rt = fast_app(debug=False, live=False, hdrs=hdrs)
     REFRESH_TIME = 1
+    EVAL_TIMEOUT_SECONDS = 15
 
 ################# STORAGE
 
@@ -205,7 +206,7 @@ def validate_and_get_question_evaluation_objectid(session, qe_id:int):
         return False, None, None
     qe_obj = qa_obj_row[0]
     if qe_id != qe_obj.id:
-        print("validate_and_get_question_evaluation_objectid QE {qe_id} does not belong to {qe_obj.id}")
+        print(f"validate_and_get_question_evaluation_objectid QE {qe_id} does not belong to {qe_obj.id}")
         return False, None, None
     return True, qe_obj, state_rows[0]
 
@@ -227,26 +228,26 @@ def html_create_feedback_updown_button(qe_id, ans_id, selected=0, disabled=False
     if selected == 1: up_col = colors[1]
     if selected == -1: down_col = colors[1]
     toggle_url = f"/toggle_up_down/{qe_id}/{ans_id}"
-    up = Button("👍", hx_get=f"{toggle_url}/1", hx_swap="outerHTML",
-                target_id=f"{html_target_id}", style=f"background-color:{up_col}")
-    down = Button("👎", hx_get=f"{toggle_url}/-1", disabled=disabled, hx_swap="outerHTML",
-                  hx_preserve=True, hx_trigger="click", hx_push_url="false",
-                  target_id=f"{html_target_id}", style=f"background-color:{down_col}")
+    up = Button("👍", hx_get=f"{toggle_url}/1", disabled=disabled, target_id=html_target_id,
+                hx_swap="outerHTML", style=f"background-color:{up_col}")
+    down = Button("👎", hx_get=f"{toggle_url}/-1", disabled=disabled, target_id=html_target_id,
+                  hx_swap="outerHTML", style=f"background-color:{down_col}")
     button_row = Div(up, down, id=html_target_id)
     return button_row
 
 
-def html_augment_evaluation_text_with_feedback(eval_html, qe_id, ans_id, selected=0):
+def html_augment_evaluation_text_with_feedback(eval_html, qe_obj, ans_id):
     """
     Will plot the + / - buttons for feedback.
 
     :param eval_html:
-    :param qe_id:
+    :param qe_obj:
     :param ans_id:
     :return:
     """
-
-    buttons = html_create_feedback_updown_button(qe_id, ans_id, selected)
+    answer_eval_js = json.loads(qe_obj.answer_eval_text)
+    buttons = html_create_feedback_updown_button(qe_obj.id, ans_id, answer_eval_js[ans_id]["EVAL"],
+                                                 disabled=(qe_obj.submitted == 1))
     final_div = Div(eval_html, buttons, style=" background-color: #f0f0f0;")
     return final_div
 
@@ -262,11 +263,11 @@ def get(session, qe_id:int, ans_id:int, which:int):
     :param which:
     :return:
     """
-    print(qe_id, ans_id, which)
+    # print(qe_id, ans_id, which)
     if which not in {-1, 1}:
         print(f"The {which=} is bad")
         return None
-    print(f"{qe_id=} {ans_id=} {which=}")
+    # print(f"{qe_id=} {ans_id=} {which=}")
 
     is_ok, qe_obj, session_obj = validate_and_get_question_evaluation_objectid(session, qe_id)
     if not is_ok:
@@ -275,7 +276,7 @@ def get(session, qe_id:int, ans_id:int, which:int):
 
     save_to_storage(
         storage.NavigationEvent(event_type="/toggle_up_down", event_session_id=session_obj.session_id,
-                                event_params={"qe_id":qe_id, "ans_id":ans_id, "which":which}),
+                                event_params={"question_evaluation_id":qe_id, "answer_id":ans_id, "which":which}),
     )
 
     answer_eval_js = json.loads(qe_obj.answer_eval_text)
@@ -293,17 +294,18 @@ def get(session, qe_id:int, ans_id:int, which:int):
     return buttons
 
 
-def html_get_textual_feedback_form(qe_obj, thank=False):
-    if thank:
+def html_get_textual_feedback_form(qe_obj,):
+    if qe_obj.submitted == 1:
         ph = "Thank you!"
     else:
         ph = "Write your general feedback here"
     form = Form(Input(name="freeform_feedback", placeholder=ph),
                 Button("Submit", disabled=(qe_obj.submitted == 1)), hx_post=f"/submit_feedback/{qe_obj.id}",
-                target_id=HTML_SUBMIT_FEEDBACK, hx_swap="outerHTML",)
-    div = Div(P("Give us a general feedback for the evaluation (optional)"), form, id=HTML_SUBMIT_FEEDBACK)
+                target_id=HTML_RESULTS_AREA, hx_swap="outerHTML",)
+    div = Div(P("Give us a general feedback for the evaluation (optional)"), form)
     return div
 
+
 @rt("/submit_feedback/{qe_id}")
 def post(session, qe_id:int, freeform_feedback:str):
     is_ok, qe_obj, session_obj = validate_and_get_question_evaluation_objectid(session, qe_id)
@@ -315,7 +317,7 @@ def post(session, qe_id:int, freeform_feedback:str):
     session_id = session.get("session_id", "Not set")
     save_to_storage(
         storage.NavigationEvent(event_type="/submit_feedback", event_session_id=session_id,
-                                event_params={"qe_id":qe_id})
+                                event_params={"question_evaluation_id":qe_id})
     )
 
     answer_eval_js = json.loads(qe_obj.answer_eval_text)
@@ -323,21 +325,22 @@ def post(session, qe_id:int, freeform_feedback:str):
     qe_obj.submitted = True
     qe_obj.answer_eval_text = json.dumps(answer_eval_js)
     question_evaluation_table.upsert(qe_obj)
-
+    user_data = session.get(USER_DATA_SESSION_NAME, {})
     save_to_storage(
         storage.CodeSubmittedEvent(event_session_id=session["session_id"], db_question_evaluation_id=qe_obj.id,
                                    submitted_date=session_obj.submitted_date,
                                    received_date=session_obj.evaluated_date,
                                    code_to_eval=qe_obj.code_text, evaluation_response=qe_obj.answer_eval_text,
-                                   has_feedback=True, feedback_date=datetime.isoformat(datetime.utcnow()))
+                                   has_feedback=True, feedback_date=datetime.isoformat(datetime.utcnow()),
+                                   feedback_userdata=user_data)
     )
 
-    return html_get_textual_feedback_form(qe_obj, thank=True)
+    return tl_html_results_and_feedback_area(session_id) #html_render_answer_from_db(session_id, html_id=HTML_RESULTS_AREA) #html_get_textual_feedback_form(qe_obj, thank=True), html_format_code_review_form(qe_obj, HTML_RESULTS_AREA)
 
 
 #######  EVALUATE CODE
 
-def html_format_code_review_form(qe_obj, html_id=""):
+def html_format_code_review_form(qe_obj):
     """
     Formats the code review, adding fields for feedback if it is required.
 
@@ -357,58 +360,96 @@ def html_format_code_review_form(qe_obj, html_id=""):
         for k, eval_line in enumerate(enhanced_answer):
             if caug_code == eval_line["criteria"]:
                 eval_txt = P(eval_line["explanation"])
-                eval_txt_fb = html_augment_evaluation_text_with_feedback(eval_txt, qe_obj.id, k)
+                eval_txt_fb = html_augment_evaluation_text_with_feedback(eval_txt, qe_obj, k)
                 list_of_citerias.append(eval_txt_fb)
     textual_feedback = html_get_textual_feedback_form(qe_obj)
-    return Div(html_render_code_output(c_code), *list_of_citerias, textual_feedback, id=html_id)
+    return html_render_code_output(c_code), *list_of_citerias, textual_feedback
+
 
-def html_default_results(html_id):
-    return Div(P("This is where criterias will show up once the code is evaluated"), id=html_id)
 
-def html_waiting_for_results(html_id):
-    return Div(P("Working  . . ."), id=html_id,
-    hx_get=f"/render_answer",
-    hx_trigger = f"every {REFRESH_TIME}s",
-    hx_swap = "outerHTML",
-    )
+
+def check_if_query_should_timeout(session_obj):
+    """
+    Checks if the evaluation request is timed out. Will update the database to ERROR
+
+    :param eval_request_status:
+    :return:
+    """
+    submitted_dt = datetime.fromisoformat(session_obj.submitted_date)
+    crt_time = datetime.utcnow()
+    time_difference = crt_time - submitted_dt
+    difference_in_seconds = time_difference.total_seconds()
+    if difference_in_seconds > EVAL_TIMEOUT_SECONDS:
+        session_obj.state = EVAL_STATE_TIMEDOUT
+    session_state_table.upsert(session_obj)
+
+
+def html_default_results():
+    return P("Submit a piece of C code to get a Clean-Code evaluation.")
+
+def html_waiting_for_results():
+    return Div(P("Working  . . ."), hx_get=f"/render_answer",
+    hx_trigger = f"every {REFRESH_TIME}s", hx_swap="outerHTML", target_id=HTML_RESULTS_AREA,)
+
+def html_eval_request_timed_out():
+    return P("Timed out. Retry in few minutes pls!")
+
+
+@rt("/render_answer")
+def get(session):
+    """
+    Endpoint to render the evaluation answer. Pooled by frontend.
+
+    :param session:
+    :return:
+    """
+    if 'session_id' not in session: return "render_answer No session ID"
+    session_id = session["session_id"]
+    answer_area = tl_html_results_and_feedback_area(session_id)
+    return answer_area
+
 
 def get_latest_eval_request_status(session_id):
     state_rows = session_state_table(limit=1, where=f"session_id == '{session_id}'", order_by="id DESC")
     if len(state_rows) <= 0:
         return EVAL_STATE_NEW, None
     state_obj = state_rows[0]
-    if state_obj.state in {EVAL_STATE_NEW, EVAL_STATE_QUERY, EVAL_STATE_ANSWER}:
-        return  state_obj.state, state_obj
+    if state_obj.state in {EVAL_STATE_NEW, EVAL_STATE_QUERY, EVAL_STATE_TIMEDOUT, EVAL_STATE_ANSWER}:
+        return state_obj.state, state_obj
     return EVAL_STATE_ERROR, state_obj
 
 
-def html_error_results(message, html_id):
-    div = Div(P("There was an error:", P(message)), id=html_id)
-    return div
+def html_error_results(message):
+    ans = P("There was an error:", P(message))
+    return ans
 
 
 def html_render_code_output(code):
-    txtarea = Pre(Code(code))
+    txtarea = Pre(Code(code, _class="language-c"))
     return txtarea
 
 
-def html_render_answer_from_db(session_id, html_id):
+def html_render_answer_from_db(session_id):
     eval_request_status, state_obj = get_latest_eval_request_status(session_id)
     # state_rows = session_state_table(limit=1, where=f"session_id == '{session_id}'", order_by="id DESC")
     # print(eval_request_status, state_obj)
     if eval_request_status == EVAL_STATE_NEW:
-        return html_default_results(html_id), #, html_render_inputbox(HTML_RESULTS_AREA, HTML_SUBMIT_CODE_AREA)
+        return html_default_results(),
     if eval_request_status == EVAL_STATE_ANSWER:
         qe_obj_lst = question_evaluation_table(limit=1, where=f"id == {state_obj.current_qeval}")
         if len(qe_obj_lst) < 1:
             print(f"Object id {state_obj.current_qeval} can't be found in question_evaluation_table")
             return (None,)
         qe_obj = qe_obj_lst[0]
-        return (html_format_code_review_form(qe_obj, html_id),
-                html_render_inputbox(target_html_id=HTML_RESULTS_AREA, region_html_id=HTML_SUBMIT_CODE_AREA)) #, html_render_code_output(HTML_SUBMIT_CODE_AREA, state_obj.code)
+        return (html_format_code_review_form(qe_obj),
+                html_render_inputbox(target_html_id=HTML_RESULTS_AREA, region_html_id=HTML_SUBMIT_CODE_AREA))
+    if eval_request_status == EVAL_STATE_TIMEDOUT:
+        return html_eval_request_timed_out(),
     if eval_request_status == EVAL_STATE_QUERY:
-        return html_waiting_for_results(html_id),
-    return html_error_results(state_obj.answer, html_id), #, html_render_code_output(HTML_SUBMIT_CODE_AREA, state_obj.code)
+        check_if_query_should_timeout(state_obj)
+        return html_waiting_for_results(),
+    print(f"Unknown state of the code evalation request {state_obj.state}:")
+    return html_error_results("Some error occured."),
 
 
 # How can I timeout? Well ... TBD.
@@ -468,6 +509,18 @@ def call_gpt_and_store_result(session_obj_id, code_to_check):
         import traceback
         traceback.print_exc()
 
+
+def tl_html_results_and_feedback_area(session_id):
+    """
+    Top level component that will render the code evaluation overlapped with feedback submission form.
+
+    :param session_id:
+    :return:
+    """
+    results_feedback_area = html_render_answer_from_db(session_id)
+    return Div(*results_feedback_area, id=HTML_RESULTS_AREA)
+
+
 ########  CODE INPUT FORM
 
 
@@ -481,6 +534,7 @@ def html_render_inputbox(target_html_id, region_html_id):
     return Div(form, id=region_html_id, hx_swap_oob='true')
 
 
+
 ##########  CLEAR FORM
 
 def html_render_clear_area_button(html_id):
@@ -555,8 +609,8 @@ function checkPopupClosed() {
     else:
         auth_callback_url = f"https://{SPACE_HOST}/auth_callback/"
 
-    secret = secrets.token_urlsafe(32)
-    session["oauth_secret"] = secret
+    secret = datetime.isoformat(datetime.utcnow()) + "-" + secrets.token_urlsafe(32)
+    session[OAUTH_SECRET_SESSION_NAME] = secret
     encoded_scopes = html.escape(OAUTH_SCOPES)
     redirect_link = (f"https://huggingface.co/oauth/authorize?redirect_uri={auth_callback_url}&scope={encoded_scopes}"
                      f"&client_id={OAUTH_CLIENT_ID}&state={secret}&response_type=code&prompt=consent")
@@ -598,6 +652,7 @@ def get(session, code:str=None, state:str=None, error:str=None, error_descriptio
     :param error_description:
     :return:
     """
+    # print(session)
     close_script = Script("""
     localStorage.setItem('login_success', 'true');
     setTimeout(function() {
@@ -613,17 +668,18 @@ def get(session, code:str=None, state:str=None, error:str=None, error_descriptio
                   P("Please close this page"))
         return_answer.append(ans)
         return Div(*return_answer)
-    print(f"OAuth returned a code")
 
     # validating the secret
-    sess_secret = session.get("oauth_secret", None)
+    sess_secret = session.get(OAUTH_SECRET_SESSION_NAME, None)
     if sess_secret is None:
         print("No session secret")
         return_answer.append(P("access denied"))
         return Div(*return_answer)
 
     if sess_secret != state:
-        print(f"Mistmatch session secret and HF secret: {sess_secret=} {state=}")
+        msg = f"Mismatch session secret and HF secret: {sess_secret=} {state=}"
+        print(msg)
+        return_answer.append(P("Mismatch session secret and HF secret"))
         return Div(*return_answer)
 
     # Moving on and get the token
@@ -660,10 +716,9 @@ def get(session, code:str=None, state:str=None, error:str=None, error_descriptio
             user_data = response_userinfo.json()
             # Set the user data in DB
             # TODO Is it mildly safe to store user data in session?
-            session["user_data"] = user_data
-            session["oauth_secret"] = None
-            print(user_data)
-
+            session[USER_DATA_SESSION_NAME] = user_data
+            session[OAUTH_SECRET_SESSION_NAME] = None
+            # print(user_data)
         else:
             print(f"Error while taking the user data: {response_userinfo.text}" )
             return_answer.append(P("Error logging in"))
@@ -675,13 +730,21 @@ def get(session, code:str=None, state:str=None, error:str=None, error_descriptio
 
     # print(session)
     return_answer.append(P("Succes! Close this page."))
-    print(return_answer)
+    save_to_storage(
+        storage.NavigationEvent(event_type="/auth_callback", event_session_id=session["session_id"],
+                                event_params={"user_data":user_data})
+    )
+
     return Div(*return_answer)
 
 
 @rt("/logout")
 def get(session):
-    session["oauth_secret"] = None
+    session[OAUTH_SECRET_SESSION_NAME] = None
+    save_to_storage(
+        storage.NavigationEvent(event_type="/logout", event_session_id=session["session_id"],
+                                event_params={"user_data":session["user_data"]})
+    )
     session["user_data"] = None
     return RedirectResponse(url="/")
 
@@ -690,7 +753,6 @@ def get(session):
 
 @rt("/")
 def get(session):
-    print(session)
     if 'session_id' not in session:
         session['session_id'] = str(uuid.uuid4())
     session_id = session["session_id"]
@@ -700,7 +762,7 @@ def get(session):
     save_to_storage(
         storage.NavigationEvent(event_type="/", event_session_id=session_id)
     )
-    user_data = session.get("user_data", None)
+    user_data = session.get(USER_DATA_SESSION_NAME, None)
     if user_data is not None:
         auth_area = html_render_welcome_user(user_data)
     else:
@@ -715,21 +777,15 @@ def get(session):
     ]
 
     input_area = html_render_inputbox(target_html_id=HTML_RESULTS_AREA, region_html_id=HTML_SUBMIT_CODE_AREA)
-    results_area = html_render_answer_from_db(session_id, HTML_RESULTS_AREA)
+    results_feedback_area = tl_html_results_and_feedback_area(session_id)
     clear_area = render_clear_area(session_id, HTML_CLEAR_FORM)
-    return title, Main(*preamble, input_area, results_area, clear_area)
-
-@rt("/render_answer")
-def get(session):
-    if 'session_id' not in session: return "render_answer No session ID"
-    session_id = session["session_id"]
-    answer_area = html_render_answer_from_db(session_id, HTML_RESULTS_AREA)
-    return answer_area
+    # print(session)
+    return title, Main(*preamble, input_area, results_feedback_area, clear_area)
 
 
 @rt("/submit_to_eval", methods="post")
 def post(session, ccodetoeval:str):
-    print(session)
+    # print(session)
     if 'session_id' not in session:
         return P("submit_to_eval. Bad call. No session ID")
     session_id = session["session_id"]
@@ -738,13 +794,15 @@ def post(session, ccodetoeval:str):
         state=EVAL_STATE_QUERY,
         submitted_date=datetime.isoformat(datetime.utcnow()),
     )
+    save_to_storage(
+        storage.NavigationEvent(event_type="/submit_to_eval", event_session_id=session_id, event_params={"ccodetoeval":ccodetoeval})
+    )
+
     # we insert and we get the new primary key
     session_obj = session_state_table.insert(session_obj)
     # will be executed in another thread with magic @threaded
     call_gpt_and_store_result(session_obj.id, ccodetoeval)
-    return (*html_render_answer_from_db(session_id, HTML_RESULTS_AREA),
-            render_clear_area(session_id, HTML_CLEAR_FORM)
-            )
+    return tl_html_results_and_feedback_area(session_id), render_clear_area(session_id, HTML_CLEAR_FORM)
 
 
 @rt("/clear_area", methods="get")
@@ -763,11 +821,10 @@ def get(session):
         submitted_date=datetime.isoformat(datetime.utcnow()),
     )
     session_state_table.insert(session_obj)
-    # re-issue forms
+    # re-issue the page, basically.
     input_area = html_render_inputbox(target_html_id=HTML_RESULTS_AREA, region_html_id=HTML_SUBMIT_CODE_AREA)
-    results_area = html_render_answer_from_db(session_id, HTML_RESULTS_AREA)
+    results_area = tl_html_results_and_feedback_area(session_id)
     clear_area = render_clear_area(session_id, HTML_CLEAR_FORM)
-    print(results_area)
-    return *results_area, input_area, clear_area
+    return results_area, input_area, clear_area
 
 serve()

storage.py

@@ -23,6 +23,7 @@ class CodeSubmittedEvent():
     evaluation_response:str = ""
     has_feedback:bool = False
     feedback_date:str = ""
+    feedback_userdata:dict=dataclasses.field(default_factory=dict)