File move from Github repo

.gitignore

@@ -0,0 +1,5 @@
+__pycache__
+.vscode
+.envrc
+flagged
+.python-version

app.py

@@ -0,0 +1,114 @@
+import gradio as gr
+import sys
+import json
+from io import StringIO
+from threading import Thread
+from urllib import parse
+
+
+from prompts import run_code_prompt, welcome_prompt
+from tutor import chat, create_llm_chain
+from gradio_callback import q, job_done
+
+
+def user(user_message, history):
+    return "", history + [[user_message, None]]
+
+
+def code(editor, output, history):
+    json_template = {"editor": editor, "output": output}
+    print(json.dumps(json_template))
+    return "", history + [[json.dumps(json_template), None]]
+
+
+def bot(history):
+    user_message = history[-1][0]
+    try:  # Check to see if the user_message contains code
+        json_template = json.loads(user_message)
+        editor = json_template["editor"]
+        output = json_template["output"]
+        history[-1][0] = "Running your code..."
+        yield history
+        user_message = run_code_prompt(editor, output)
+    except:
+        pass
+    history[-1][1] = ""
+    thread = Thread(target=chat, kwargs={"user_message": user_message})
+    thread.start()
+    while True:
+        next_token = q.get(block=True)
+        if next_token is job_done:
+            break
+        history[-1][1] += next_token
+        yield history
+    thread.join()
+
+
+def run_code(code):
+    buffer = StringIO()
+    sys.stdout = buffer
+    try:
+        exec(code)
+        return buffer.getvalue()
+    except Exception as e:
+        print(e)
+        return buffer.getvalue()
+    finally:
+        sys.stdout = sys.__stdout__
+
+
+def load_level(request: gr.Request):
+    try:
+        level = parse.parse_qs(parse.urlparse(request.headers["referer"]).query)[
+            "level"
+        ][0]
+    except:
+        level = "1"
+    with open(f"levels/{level}/metadata.json", "r") as f:
+        data = json.load(f)
+        instructions = open(f"levels/{level}/{data['instructions']}", "r").read()
+        starter_code = open(f"levels/{level}/{data['starter_code']}", "r").read()
+        return [instructions, starter_code]
+
+
+with gr.Blocks() as demo:
+    with gr.Row():
+        instruction_panel = gr.Markdown()
+    with gr.Row():
+        with gr.Column(scale=1):
+            chatbot = gr.Chatbot(label="AI Tutor", value=[[None, welcome_prompt()]])
+            msg = gr.Textbox(show_label=False, placeholder="Type your message here...")
+            msg.submit(
+                user, [msg, chatbot], [msg, chatbot], queue=False, scroll_to_output=True
+            ).then(bot, chatbot, chatbot)
+        with gr.Column(scale=2):
+            editor = gr.Code(
+                value="Loading...",
+                language="python",
+                interactive=True,
+                show_label=True,
+                label="Code Editor",
+                lines=15,
+            )
+            output = gr.Code(
+                value="""Click "Run" to run your code.""",
+                language="python",
+                interactive=False,
+                show_label=True,
+                label="Output",
+            )
+            with gr.Row():
+                run = gr.Button("Run")
+                run.click(
+                    run_code, editor, output, queue=False, scroll_to_output=True
+                ).then(
+                    code, [editor, output, chatbot], [msg, chatbot], queue=False
+                ).then(
+                    bot, chatbot, chatbot
+                )
+    demo.load(load_level, None, [instruction_panel, editor], queue=False).then(
+        create_llm_chain, [instruction_panel, editor]
+    )
+
+demo.queue()
+demo.launch()

gradio_callback.py

@@ -0,0 +1,36 @@
+from langchain.callbacks.base import BaseCallbackHandler
+from langchain.schema import LLMResult
+from typing import Any, Union, Dict, List
+
+from queue import Empty, SimpleQueue
+q = SimpleQueue()
+
+job_done = object()
+
+class StreamingGradioCallbackHandler(BaseCallbackHandler):
+    def __init__(self, q: SimpleQueue):
+        self.q = q
+
+    def on_llm_start(
+        self, serialized: Dict[str, Any], prompts: List[str], **kwargs: Any
+    ) -> None:
+        """Run when LLM starts running. Clean the queue."""
+        while not self.q.empty():
+            try:
+                self.q.get(block=False)
+            except Empty:
+                continue
+
+    def on_llm_new_token(self, token: str, **kwargs: Any) -> None:
+        """Run on new LLM token. Only available when streaming is enabled."""
+        self.q.put(token)
+
+    def on_llm_end(self, response: LLMResult, **kwargs: Any) -> None:
+        """Run when LLM ends running."""
+        self.q.put(job_done)
+
+    def on_llm_error(
+        self, error: Union[Exception, KeyboardInterrupt], **kwargs: Any
+    ) -> None:
+        """Run when LLM errors."""
+        self.q.put(job_done)

levels/1/instructions.md

@@ -0,0 +1,5 @@
+# Level 1: Reverse a String using a For Loop
+
+The objective of this exercise is to create a function that reverses a string. 
+
+The function must use a for loop to iterate through the original string, building a new string which is then returned. You can't use libraries, arrays, or slices.

levels/1/metadata.json

@@ -0,0 +1,6 @@
+  {
+    "title": "A second example",
+    "language": "Python",
+    "instructions": "instructions.md",
+    "starter_code": "starter_code.py"
+  }

levels/1/starter_code.py

@@ -0,0 +1,4 @@
+def reverse_string(string):
+  return string
+
+print(reverse_string("Hello, world!"))

levels/2/instructions.md

@@ -0,0 +1,10 @@
+# Level 2: Predict the Season
+
+Your goal is to write a predict_season function that uses nested if statements to guess the season. You are given two variables, temp (an integer) and is_raining (a boolean).
+
+- If temp is less than 65 and is_raining is True, it's Winter.
+- If temp is more than 65 and is_raining is True, it's Spring.
+- If temp is more than 65 and is_raining is False, it's Summer.
+- If temp is less than 65 and is_raining is False, it's Fall.
+
+Complete the predict_season function to predict the season and print it to the console.

levels/2/metadata.json

@@ -0,0 +1,6 @@
+  {
+    "title": "Predict the Season",
+    "language": "Python",
+    "instructions": "instructions.md",
+    "starter_code": "starter_code.py"
+  }

levels/2/starter_code.py

@@ -0,0 +1,5 @@
+def predict_season(temp, is_raining):
+  # Add your nested if statements here!
+  return "Summer"
+
+print(predict_season(70, False))

levels/3/instructions.md

@@ -0,0 +1,20 @@
+# Level 3: Cakes, Cookies, and Pies in 2D Arrays
+
+The owner of the Project Mercury Pastries Food Truck wants to find the total inventory for each dessert. They have the following values:
+
+  ```
+  25 17 22
+  18 12 15
+  21 19 27
+  30 10 23
+  ```
+  
+  Each row represents a unique food truck in the business. Each column represents the number of cakes, cookies, and pies, respectively.
+  
+  Write a method that totals each column and displays the total for each category:
+  
+  ```
+  Cakes: 94
+  Cookies: 58
+  Pies: 87
+  ```

levels/3/metadata.json

@@ -0,0 +1,6 @@
+  {
+    "title": "Cakes, Cookies, and Pies in 2D Arrays",
+    "language": "Python",
+    "instructions": "instructions.md",
+    "starter_code": "starter_code.py"
+  }

levels/3/starter_code.py

@@ -0,0 +1,2 @@
+inventory = [[25, 17, 22], [18, 12, 15], [21, 19, 27], [30, 10, 23]]
+print(inventory)

prompts.py

@@ -0,0 +1,40 @@
+from langchain import PromptTemplate
+
+
+def system_prompt(instructions, starter_code):
+    template = f"""
+You are a computer science teacher helping a student learn computer science. You are friendly and want your students to succeed.
+
+The student has been asked to complete the following exercise in Python:
+```
+{instructions}
+```
+They have been given the following starter code:
+```
+{starter_code}
+```
+They will ask you for help. You may help them, but you must not give them the answer. You may only give them hints. You must take a socratic approach to helping them.
+
+Do not let the student deviate from the task at hand. If they ask you a question that is not related to the task at hand, you must redirect them to the task at hand.
+
+{{chat_history}}
+Student: {{student_input}}
+Teacher:"""
+    return PromptTemplate(
+        input_variables=["chat_history", "student_input"], template=template
+    )
+
+def run_code_prompt(editor, output):
+    return f"""
+I've written this code:
+```
+{editor}
+```
+And it produces this output:
+```
+{output}
+```
+"""
+
+def welcome_prompt():
+    return "Hi! I'm your AI-powered computer science tutor. Feel free to ask me any questions as you work on this level. I'll also try and provide help when you run your code."

requirements.txt

@@ -0,0 +1,3 @@
+openai==0.27.8
+langchain==0.0.225
+langchainplus-sdk==0.0.20

tutor.py

@@ -0,0 +1,32 @@
+import os
+
+from langchain.memory import ConversationBufferMemory
+from langchain import LLMChain
+from langchain.chat_models import ChatOpenAI
+
+from gradio_callback import StreamingGradioCallbackHandler, q
+from prompts import system_prompt
+
+llm = ChatOpenAI(
+    streaming=True,
+    callbacks=[StreamingGradioCallbackHandler(q)],
+    temperature=0.0,
+    model="gpt-4",
+    openai_api_key=os.getenv("OPENAI_API_KEY"),
+)
+
+memory = ConversationBufferMemory(memory_key="chat_history")
+
+llm_chain = None
+
+def chat(user_message):
+    return llm_chain.predict(student_input=user_message)
+
+def create_llm_chain(instructions, starter_code):
+    global llm_chain
+    llm_chain = LLMChain(
+        llm=llm,
+        prompt=system_prompt(instructions, starter_code),
+        verbose=True,
+        memory=memory,
+    )