updated for truth with uw-quiz-generator

uw_programmatic/base_machine.py

@@ -15,7 +15,6 @@ from griptape.configs import Defaults
 from griptape.configs.drivers import (
     OpenAiDriversConfig,
 )
-from griptape.configs.logging import TruncateLoggingFilter
 from griptape.drivers import (
     GriptapeCloudVectorStoreDriver,
     LocalStructureRunDriver,
@@ -38,16 +37,12 @@ from griptape.rules import Rule, Ruleset
 from griptape.structures import Agent, Workflow
 from griptape.tasks import CodeExecutionTask, StructureRunTask, ToolTask
 from griptape.tools import RagTool
+from parsers import UWConfigParser
 from statemachine import State, StateMachine
 from statemachine.factory import StateMachineMetaclass
 
-from griptape_statemachine.parsers.uw_config_parser import UWConfigParser
-
 logger = logging.getLogger(__name__)
-logger.setLevel(logging.ERROR)
-logger.addFilter(TruncateLoggingFilter(max_log_length=100))
-logger2 = logging.getLogger(Defaults.logging_config.logger_name).setLevel(logging.ERROR)
-#logging.getLogger("griptape").setLevel(logging.ERROR)
+logging.getLogger("griptape").setLevel(logging.ERROR)
 
 if TYPE_CHECKING:
     from griptape.structures import Structure
@@ -56,6 +51,7 @@ if TYPE_CHECKING:
 
 load_dotenv()
 
+# Sets max tokens and OpenAI as the driver.
 Defaults.drivers_config = OpenAiDriversConfig(
     prompt_driver=OpenAiChatPromptDriver(model="gpt-4o", max_tokens=4096)
 )
@@ -91,8 +87,11 @@ class UWBaseMachine(StateMachine):
         self.page_range: tuple = ()
         self.question_number: int = 0
         self.taxonomy: list = []
+        # To track give up
         self.give_up_count = 0
         self.current_question_count = 0
+        # To keep vector stores on track
+        self.kb_ids = {}
 
         self.state_status: dict[str, bool] = {}
 
@@ -286,42 +285,30 @@ class UWBaseMachine(StateMachine):
             for ruleset_config in ruleset_configs
         ]
 
-    def get_prompt_by_structure(self, structure_id: str) -> str | None:
-        try:
-            state_structure_config = self._current_state_config.get(
-                "structures", {}
-            ).get(structure_id, {})
-            global_structure_config = self.config["structures"][structure_id]
-        except KeyError:
-            return None
-        prompt_id = None
-        if "prompt_id" in global_structure_config:
-            prompt_id = global_structure_config["prompt_id"]
-        elif "prompt_id" in state_structure_config:
-            prompt_id = state_structure_config["prompt_id"]
+    def retrieve_vector_stores(self) -> None:
+        base_url = "https://cloud.griptape.ai/api/"
+        kb_url = f"{base_url}/knowledge-bases"
+        headers = {"Authorization": f"Bearer {os.getenv('GT_CLOUD_API_KEY')}"}
+        response = requests.get(url=kb_url, headers=headers)
+        response.raise_for_status()
+        all_kbs = {}
+        if response.status_code == 200:
+            data = response.json()
+            for kb in data["knowledge_bases"]:
+                name = kb["name"]
+                kb_id = kb["knowledge_base_id"]
+                if "KB_section" in name:
+                    all_kbs[name] = kb_id
         else:
-            return None
-        return self.config["prompts"][prompt_id]["prompt"]
+            raise ValueError(response.status_code)
+        self.kb_ids = all_kbs
 
-    def get_prompt_by_id(self, prompt_id: str) -> str | None:
-        prompt_config = self.config["prompts"]
-        if prompt_id in prompt_config:
-            return prompt_config[prompt_id]["prompt"]
-        return None
-
-    # ALL METHODS RELATING TO THE WORKFLOW AND PIPELINE
-    def end_workflow(self, task: CodeExecutionTask) -> ListArtifact:
-        parent_outputs = task.parent_outputs
-        questions = []
-        for outputs in parent_outputs.values():
-            if outputs.type == "InfoArtifact":
-                continue
-            questions.append(outputs)
-        return ListArtifact(questions)
+    # ALL METHODS RELATING TO THE WORKFLOW AND PIPELINE ARE BELOW THIS LINE
 
+    # This is the overarching workflow. Creates a workflow with get_single_question x amount of times.
     def get_questions_workflow(self) -> Workflow:
         workflow = Workflow(id="create_question_workflow")
-        # How many questions still need to be created
+        # How many questions still need to be created?
         for _ in range(self.question_number - len(self.question_list)):
             task = StructureRunTask(
                 structure_run_driver=LocalStructureRunDriver(
@@ -329,57 +316,23 @@ class UWBaseMachine(StateMachine):
                 ),
                 child_ids=["end_task"],
             )
+            # Create X amount of workflows to run for X amount of questions needed.
             workflow.add_task(task)
         end_task = CodeExecutionTask(id="end_task", on_run=self.end_workflow)
         workflow.add_task(end_task)
         return workflow
 
-    def single_question_last_task(self, task: CodeExecutionTask) -> TextArtifact:
-        parent_outputs = task.parent_outputs
-        wrong_answers = parent_outputs["wrong_answers"].value  # Output is a list
-        wrong_answers = wrong_answers.split("\n")
-        question_and_answer = parent_outputs["get_question"].value  # Output is a json
-        try:
-            question_and_answer = json.loads(question_and_answer)
-        except:
-            question_and_answer = question_and_answer.split("\n")[1:]
-            question_and_answer = "".join(question_and_answer)
-            question_and_answer = json.loads(question_and_answer)
-        inputs = task.input.value.split(",")
-        question = {
-            "Question": question_and_answer["Question"],
-            "Answer": question_and_answer["Answer"],
-            "Wrong Answers": wrong_answers,
-            "Page": inputs[0],
-            "Taxonomy": inputs[1],
-        }
-        return TextArtifact(question)
-
-    def get_question_for_wrong_answers(self, task: CodeExecutionTask) -> TextArtifact:
-        parent_outputs = task.parent_outputs
-        question = parent_outputs["get_question"].value
-        question = json.loads(question)["Question"]
-        return TextArtifact(question)
-
-    def get_separated_answer_for_wrong_answers(
-        self, task: CodeExecutionTask
-    ) -> TextArtifact:
+    # Ends the get_questions_workflow. Compiles all workflow outputs into one output.
+    def end_workflow(self, task: CodeExecutionTask) -> ListArtifact:
         parent_outputs = task.parent_outputs
-        answer = parent_outputs["get_question"].value
-        print(answer)
-        answer = json.loads(answer)["Answer"]
-        return TextArtifact(answer)
-
-    def make_rag_structure(
-        self, vector_store: GriptapeCloudVectorStoreDriver
-    ) -> Structure:
-        if vector_store:
-            tool = self.build_rag_tool(self.build_rag_engine(vector_store))
-            use_rag_task = ToolTask(tool=tool)
-            return Agent(tasks=[use_rag_task])
-        errormsg = "No Vector Store"
-        raise ValueError(errormsg)
+        questions = []
+        for outputs in parent_outputs.values():
+            if outputs.type == "InfoArtifact":
+                continue
+            questions.append(outputs)
+        return ListArtifact(questions)
 
+    # Generates one workflow to create a single question.
     def get_single_question(self) -> Workflow:
         question_generator = Workflow(id="single_question")
         taxonomy = random.choice(self.taxonomy)
@@ -443,42 +396,65 @@ class UWBaseMachine(StateMachine):
         )
         return question_generator
 
+    # Task to separate the Question into a string
+    def get_question_for_wrong_answers(self, task: CodeExecutionTask) -> TextArtifact:
+        parent_outputs = task.parent_outputs
+        question = parent_outputs["get_question"].value
+        question = json.loads(question)["Question"]
+        return TextArtifact(question)
+
+    # Task to separate the Answer into a string
+    def get_separated_answer_for_wrong_answers(
+        self, task: CodeExecutionTask
+    ) -> TextArtifact:
+        parent_outputs = task.parent_outputs
+        answer = parent_outputs["get_question"].value
+        print(answer)
+        answer = json.loads(answer)["Answer"]
+        return TextArtifact(answer)
+
+    # Combines all the outputs into one dictionary that represents the question
+    def single_question_last_task(self, task: CodeExecutionTask) -> TextArtifact:
+        parent_outputs = task.parent_outputs
+        wrong_answers = parent_outputs["wrong_answers"].value  # Output is a list
+        wrong_answers = wrong_answers.split("\n")
+        question_and_answer = parent_outputs["get_question"].value  # Output is a json
+        try:
+            question_and_answer = json.loads(question_and_answer)
+        except:
+            question_and_answer = question_and_answer.split("\n")[1:]
+            question_and_answer = "".join(question_and_answer)
+            question_and_answer = json.loads(question_and_answer)
+        inputs = task.input.value.split(",")
+        question = {
+            "Question": question_and_answer["Question"],
+            "Answer": question_and_answer["Answer"],
+            "Wrong Answers": wrong_answers,
+            "Page": inputs[0],
+            "Taxonomy": inputs[1],
+        }
+        return TextArtifact(question)
+
+    # These are helper methods
+    # Picks the KB from the dictionary
     def get_vector_store_id_from_page(
         self,
     ) -> tuple[str, GriptapeCloudVectorStoreDriver]:
-        base_url = "https://cloud.griptape.ai/api/"
-        kb_url = f"{base_url}/knowledge-bases"
-        headers = {"Authorization": f"Bearer {os.getenv('GT_CLOUD_API_KEY')}"}
-        # TODO: This needs to change when I have my own bucket. Right now, I'm doing the 10 most recently made KBs
-        response = requests.get(url=kb_url, headers=headers)
-        response.raise_for_status()
-        if response.status_code == 200:
-            data = response.json()
-            possible_kbs = {}
-            for kb in data["knowledge_bases"]:
-                name = kb["name"]
-                if "KB_section" not in name:
-                    continue
-                page_nums = name.split("p")[1:]
-                start_page = int(page_nums[0].split("-")[0])
-                end_page = int(page_nums[1])
-                if end_page <= self.page_range[1] and start_page >= self.page_range[0]:
-                    possible_kbs[kb["knowledge_base_id"]] = f"{start_page}-{end_page}"
-            kb_id = random.choice(list(possible_kbs.keys()))
-            page_value = possible_kbs[kb_id]  # TODO: This won't help at all actually
-            return page_value, GriptapeCloudVectorStoreDriver(
-                api_key=os.getenv("GT_CLOUD_API_KEY", ""),
-                knowledge_base_id=kb_id,
-            )
-        else:
-            raise ValueError(response.status_code)
-
-    def get_taxonomy_vs(self) -> GriptapeCloudVectorStoreDriver:
-        return GriptapeCloudVectorStoreDriver(
+        possible_kbs = {}
+        for name, kb_id in self.kb_ids.items():
+            page_nums = name.split("p")[1:]
+            start_page = int(page_nums[0].split("-")[0])
+            end_page = int(page_nums[1])
+            if end_page <= self.page_range[1] and start_page >= self.page_range[0]:
+                possible_kbs[kb_id] = f"{start_page}-{end_page}"
+        kb_id = random.choice(list(possible_kbs.keys()))
+        page_value = possible_kbs[kb_id]
+        return page_value, GriptapeCloudVectorStoreDriver(
             api_key=os.getenv("GT_CLOUD_API_KEY", ""),
-            knowledge_base_id="2c3a6f19-51a8-43c3-8445-c7fbe06bf460",
+            knowledge_base_id=kb_id,
         )
 
+    # Uses this and all below to build the Rag Tool to get information from the KB
     def build_rag_engine(
         self, vector_store_driver: GriptapeCloudVectorStoreDriver
     ) -> RagEngine:
@@ -500,3 +476,13 @@ class UWBaseMachine(StateMachine):
             description="Contains information about the textbook. Use it ONLY for context.",
             rag_engine=engine,
         )
+
+    def make_rag_structure(
+        self, vector_store: GriptapeCloudVectorStoreDriver
+    ) -> Structure:
+        if vector_store:
+            tool = self.build_rag_tool(self.build_rag_engine(vector_store))
+            use_rag_task = ToolTask(tool=tool)
+            return Agent(tasks=[use_rag_task])
+        errormsg = "No Vector Store"
+        raise ValueError(errormsg)

uw_programmatic/question_pipeline.py

@@ -1,300 +0,0 @@
-from __future__ import annotations
-import ast
-import json
-import os
-import random
-import logging
-
-import requests
-from dotenv import load_dotenv
-from griptape.artifacts import ListArtifact, TextArtifact
-from griptape.configs import Defaults
-from griptape.configs.drivers import OpenAiDriversConfig
-from griptape.drivers import (
-    LocalStructureRunDriver,
-    OpenAiChatPromptDriver,
-    GriptapeCloudVectorStoreDriver,
-)
-from griptape.artifacts import ListArtifact, TextArtifact
-from griptape.rules import Ruleset, Rule
-
-import json
-import requests
-import random
-import os
-from dotenv import load_dotenv
-
-from griptape.engines.rag import RagEngine
-from griptape.engines.rag.modules import (
-    VectorStoreRetrievalRagModule,
-    TextChunksResponseRagModule,
-)
-from griptape.engines.rag.stages import ResponseRagStage, RetrievalRagStage
-from griptape.tools import RagTool
-from griptape.configs.logging import TruncateLoggingFilter
-
-from griptape_statemachine.parsers.uw_csv_parser import CsvParser
-
-load_dotenv()
-
-# openai default config pass in a new openai driver
-Defaults.drivers_config = OpenAiDriversConfig(
-    prompt_driver=OpenAiChatPromptDriver(model="gpt-4o", max_tokens=4096)
-)
-# logger = logging.getLogger(Defaults.logging_config.logger_name)
-# logger.setLevel(logging.ERROR)
-# logger.addFilter(TruncateLoggingFilter(max_log_length=5000))
-
-
-# ALL METHODS RELATING TO THE WORKFLOW AND PIPELINE
-def end_workflow(task: CodeExecutionTask) -> ListArtifact:
-    parent_outputs = task.parent_outputs
-    questions = []
-    for output in parent_outputs.values():
-        output = output.value
-        try:
-            output = ast.literal_eval(output)
-            question = {output["Question"]: output}
-            questions.append(TextArtifact(question))
-        except SyntaxError:
-            pass
-    return ListArtifact(questions)
-
-
-def get_questions_workflow() -> Workflow:
-    workflow = Workflow(id="create_question_workflow")
-    # How many questions still need to be created
-    for _ in range(10):
-        task = StructureRunTask(
-            driver=LocalStructureRunDriver(create_structure=get_single_question),
-            child_ids=["end_task"],
-        )
-        workflow.add_task(task)
-    end_task = CodeExecutionTask(id="end_task", on_run=end_workflow)
-    workflow.add_task(end_task)
-    return workflow
-
-
-def single_question_last_task(task: CodeExecutionTask) -> TextArtifact:
-    parent_outputs = task.parent_outputs
-    print(f"PARENT OUTPUTS ARE: {parent_outputs}")
-    wrong_answers = parent_outputs["wrong_answers"].value  # Output is a list
-    wrong_answers = wrong_answers.split("\n")
-    question_and_answer = parent_outputs["get_question"].value  # Output is a json
-    question_and_answer = json.loads(question_and_answer)
-    inputs = task.input.value.split(",")
-    question = {
-        "Question": question_and_answer["Question"],
-        "Answer": question_and_answer["Answer"],
-        "Wrong Answers": wrong_answers,
-        "Page": int(inputs[0]),
-        "Taxonomy": inputs[1],
-    }
-    return TextArtifact(question)
-
-
-def get_question_for_wrong_answers(task: CodeExecutionTask) -> TextArtifact:
-    parent_outputs = task.parent_outputs
-    question = parent_outputs["get_question"].value
-    print(question)
-    question = json.loads(question)["Question"]
-    return TextArtifact(question)
-
-
-def get_single_question() -> Workflow:
-    question_generator = Workflow()
-    page_number = random.choice(list(range(1, 9)))
-    taxonomy = random.choice(["Knowledge", "Comprehension", "Application"])
-    taxonomyprompt = {
-        "Knowledge": "Generate a quiz question based ONLY on this information: {{parent_outputs['information_task']}}, then write the answer to the question. The interrogative verb for the question should be one of 'define', 'list', 'state', 'identify', or 'label'.",
-        "Comprehension": "Generate a quiz question based ONLY on this information: {{parent_outputs['information_task']}}, then write the answer to the question. The interrogative verb for the question should be one of 'explain', 'predict', 'interpret', 'infer', 'summarize', 'convert', or 'give an example of x'.",
-        "Application": "Generate a quiz question based ONLY on this information: {{parent_outputs['information_task']}}, then write the answer to the question. The structure of the question should be one of 'How could x be used to y?' or 'How would you show/make use of/modify/demonstrate/solve/apply x to conditions y?'",
-    }
-    # Get KBs and select it, assign it to the structure or create the structure right here.
-    # Rules for subject matter expert: return only a json with question and answer as keys.
-    generate_q_task = StructureRunTask(
-        id="get_question",
-        input=taxonomyprompt[taxonomy],
-        driver=LocalStructureRunDriver(
-            create_structure=lambda: get_structure("subject_matter_expert", page_number)
-        ),
-    )
-
-    get_question_code_task = CodeExecutionTask(
-        id="get_only_question",
-        on_run=get_question_for_wrong_answers,
-        parent_ids=["get_question"],
-        child_ids=["wrong_answers"],
-    )
-    # This will use the same KB as the previous task
-    generate_wrong_answers = StructureRunTask(
-        id="wrong_answers",
-        input="""Write and return three incorrect answers for this question: {{parent_outputs['get_only_question']}} with this context: {{parent_outputs['information_task']}}""",
-        structure_run_driver=LocalStructureRunDriver(
-            create_structure=lambda: get_structure("wrong_answers_generator")
-        ),
-        parent_ids=["get_only_question"],
-    )
-    compile_task = CodeExecutionTask(
-        id="compile_task",
-        input=f"{page_number}, {taxonomy})",
-        on_run=single_question_last_task,
-        parent_ids=["wrong_answers", "get_question"],
-    )
-    question_generator.add_tasks(
-        generate_q_task,
-        get_question_code_task,
-        generate_wrong_answers,
-        compile_task,
-    )
-    return question_generator
-
-
-def get_structure(structure_id: str, page_number=0) -> Structure:
-    match structure_id:
-        case "subject_matter_expert":
-            rulesets = Ruleset(
-                name="specific_question_creator",
-                rules=[
-                    Rule(
-                        "Return ONLY a json with 'Question' and 'Answer' as keys. No markdown, no commentary, no code, no backticks."
-                    ),
-                    Rule(
-                        "Query to knowledge base should always be 'find information for quiz question'"
-                    ),
-                    Rule("Use ONLY information from your knowledge base"),
-                    Rule(
-                        "Question should be a question based on the knowledge base. Answer should be from knowledge base."
-                    ),
-                    Rule(
-                        "The answer to the question should be short, but should not omit important information."
-                    ),
-                    Rule("Answer length should be 10 words maximum, 5 words minimum"),
-                ],
-            )
-            structure = Agent(
-                id="subject_matter_expert",
-                prompt_driver=OpenAiChatPromptDriver(model="gpt-4o"),
-                rulesets=[rulesets],
-                tools=[tool],
-            )
-        case "taxonomy_expert":
-            rulesets = Ruleset(
-                name="KB Rules",
-                rules=[
-                    Rule(
-                        "Use only your knowledge base. Do not make up any additional information."
-                    ),
-                    Rule("Maximum 10 words."),
-                    Rule(
-                        "Return information an AI chatbot could use to write a question on a subject."
-                    ),
-                ],
-            )
-            kb_driver = get_taxonomy_vs()
-            tool = build_rag_tool(build_rag_engine(kb_driver))
-            structure = Agent(
-                id="taxonomy_expert",
-                prompt_driver=OpenAiChatPromptDriver(model="gpt-4o"),
-                tools=[tool],
-            )
-        case "wrong_answers_generator":
-            rulesets = Ruleset(
-                name="incorrect_answers_creator",
-                rules=[
-                    Rule(
-                        "Return ONLY a list of 3 incorrect answers. No markdown, no commentary, no backticks."
-                    ),
-                    Rule(
-                        "All incorrect answers should be different, but plausible answers to the question."
-                    ),
-                    Rule(
-                        "Incorrect answers may reference material from the knowledge base, but must not be correct answers to the question"
-                    ),
-                    Rule(
-                        "Length of incorrect answers should be 10 words max, 5 words minimum"
-                    ),
-                ],
-            )
-            kb_driver = get_vector_store_id_from_page(page_number)
-            tool = build_rag_tool(build_rag_engine(kb_driver))
-            structure = Agent(
-                id="wrong_answers_generator",
-                prompt_driver=OpenAiChatPromptDriver(model="gpt-4o"),
-                rulesets=[rulesets],
-                tools=[tool],
-            )
-        case _:
-            structure = Agent(prompt_driver=OpenAiChatPromptDriver(model="gpt-4o"))
-    return structure
-
-
-def get_vector_store_id_from_page(page: int) -> GriptapeCloudVectorStoreDriver | None:
-    base_url = "https://cloud.griptape.ai/api/"
-    kb_url = f"{base_url}/knowledge-bases"
-    headers = {"Authorization": f"Bearer {os.getenv('GT_CLOUD_API_KEY')}"}
-    # TODO: This needs to change when I have my own bucket. Right now, I'm doing the 10 most recently made KBs
-    response = requests.get(url=kb_url, headers=headers)
-    response = requests.get(
-        url=kb_url,
-        headers=headers,
-    )
-    response.raise_for_status()
-    if response.status_code == 200:
-        data = response.json()
-        for kb in data["knowledge_bases"]:
-            name = kb["name"]
-            if "KB_section" not in name:
-                continue
-            page_nums = name.split("pg")[1].split("-")
-            start_page = int(page_nums[0])
-            end_page = int(page_nums[1])
-            if end_page <= 40 and start_page >= 1:
-                possible_kbs[kb["knowledge_base_id"]] = f"{start_page}-{end_page}"
-        kb_id = random.choice(list(possible_kbs.keys()))
-        page_value = possible_kbs[kb_id]
-        return page_value, GriptapeCloudVectorStoreDriver(
-            api_key=os.getenv("GT_CLOUD_API_KEY", ""),
-            knowledge_base_id=kb_id,
-        )
-    else:
-        raise ValueError(response.status_code)
-    return None
-
-
-def get_taxonomy_vs() -> GriptapeCloudVectorStoreDriver:
-    return GriptapeCloudVectorStoreDriver(
-        api_key=os.getenv("GT_CLOUD_API_KEY", ""),
-        knowledge_base_id="2c3a6f19-51a8-43c3-8445-c7fbe06bf460",
-    )
-
-
-def build_rag_engine(vector_store_driver) -> RagEngine:
-    return RagEngine(
-        retrieval_stage=RetrievalRagStage(
-            retrieval_modules=[
-                VectorStoreRetrievalRagModule(
-                    vector_store_driver=vector_store_driver,
-                    query_params={
-                        "count": 100,
-                    },
-                )
-            ],
-        ),
-        response_stage=ResponseRagStage(
-            response_modules=[TextChunksResponseRagModule()]
-        ),
-    )
-
-
-def build_rag_tool(engine) -> RagTool:
-    return RagTool(
-        description="Contains information about the textbook. Use it to answer any related questions.",
-        rag_engine=engine,
-    )
-
-
-if __name__ == "__main__":
-    # workflow = get_questions_workflow()
-    # workflow.run()
-    CsvParser("uw_programmatic").csv_parser()

uw_programmatic/uw_machine.py

@@ -24,8 +24,11 @@ class UWMachine(UWBaseMachine):
         """Starts the machine."""
         # Clear input history.
         # Clear csv file
+        self.retrieve_vector_stores()
         self.send("enter_first_state")
 
+    # The first state: Listens for Gradio and then gives us the parameters to search for.
+    # Reinitializes the Give Up counter.
     def on_event_gather_parameters(self, event_: dict) -> None:
         event_source = event_["type"]
         event_value = event_["value"]
@@ -42,21 +45,23 @@ class UWMachine(UWBaseMachine):
                 err_msg = f"Unexpected Transition Event ID: {event_value}."
                 raise ValueError(err_msg)
 
+    # Checks if there have not been any new questions generated 3 tries in a row
+    # If # of questions is the same as the # of questions required - sends to end.
     def on_enter_evaluate_q_count(self) -> None:
-        # Check if the number of questions has incremented
         if len(self.question_list) <= self.current_question_count:
             self.give_up_count += 1
         else:
             self.current_question_count = len(self.question_list)
             self.give_up_count = 0
         if self.give_up_count >= 3:
-            self.send("finish_state")
+            self.send("finish_state")  # go to output questions
             return
         if len(self.question_list) >= self.question_number:
             self.send("finish_state")  # go to output questions
         else:
             self.send("next_state")  # go to need more questions
 
+    # Necessary for state machine to not throw errors
     def on_event_evaluate_q_count(self, event_: dict) -> None:
         pass
 
@@ -64,6 +69,8 @@ class UWMachine(UWBaseMachine):
         # Create the entire workflow to create another question.
         self.get_questions_workflow().run()
 
+    # Returns the output of the workflow - a ListArtifact of TextArtifacts of questions.
+    # Question, Answer, Wrong Answers, Taxonomy, Page Number
     def on_event_need_more_q(self, event_: dict) -> None:
         event_source = event_["type"]
         event_value = event_["value"]
@@ -81,7 +88,7 @@ class UWMachine(UWBaseMachine):
                                     for question in values
                                 ]
                                 self.most_recent_questions = (
-                                    questions  # This is a ListArtifact I'm pretty sure
+                                    questions  # This is a ListArtifact
                                 )
                                 self.send("next_state")
                     case _:
@@ -89,13 +96,13 @@ class UWMachine(UWBaseMachine):
             case _:
                 print(f"Unexpected: {event_}")
 
+    # Merges the existing and new questions and sends to similarity auditor to get rid of similar questions.
     def on_enter_assess_generated_q(self) -> None:
-        # TODO: Should it append it to the list already and remove duplicates? or not?
-        # TODO: Merge incoming lists
         merged_list = [*self.question_list, *self.most_recent_questions]
         prompt = f"{merged_list}"
         self.get_structure("similarity_auditor").run(prompt)
 
+    # Sets the returned question list (with similar questions wiped) equal to self.question_list
     def on_event_assess_generated_q(self, event_: dict) -> None:
         event_source = event_["type"]
         event_value = event_["value"]
@@ -114,11 +121,12 @@ class UWMachine(UWBaseMachine):
                                     new_question_list = json.loads(
                                         new_question_list
                                     )  # This must be in that JSON format
-                                except:
+                                except:  # If not in JSON decode format
                                     new_question_list = self.question_list
                                 self.question_list = new_question_list
-                                self.send("next_state")  # move on
+                                self.send("next_state")  # go to Evaluate Q Count
 
+    # Writes and saves a csv in the correct format to outputs/professor_guide.csv
     def on_enter_output_q(self) -> None:
         with Path(Path.cwd().joinpath("outputs/professor_guide.csv")).open(
             "w", newline=""
@@ -126,85 +134,26 @@ class UWMachine(UWBaseMachine):
             writer = csv.writer(file)
             for question in range(len(self.question_list)):
                 new_row = ["MC", "", 1]
-                try:
-                    new_row.append(self.question_list[question]["Question"])
-                    wrong_answers = list(self.question_list[question]["Wrong Answers"])
-                    column = random.randint(1, len(wrong_answers) + 1)
-                    new_row.append(column)
-                    for i in range(1, len(wrong_answers) + 2):
-                        if i == column:
-                            new_row.append(self.question_list[question]["Answer"])
-                        else:
-                            wrong_answer = wrong_answers.pop()
-                            if not wrong_answer:
-                                wrong_answer = ""
-                            new_row.append(wrong_answer)
-                    new_row.append(self.question_list[question]["Page"])
-                    new_row.append(self.question_list[question]["Taxonomy"])
-                    writer.writerow(new_row)
-                except KeyError:
-                    new_row.append(self.question_list["Question"])
-                    wrong_answers = list(self.question_list["Wrong Answers"])
-                    column = random.randint(1, len(wrong_answers) + 1)
-                    new_row.append(column)
-                    for i in range(1, len(wrong_answers) + 2):
-                        if i == column:
-                            new_row.append(self.question_list["Answer"])
-                        else:
-                            new_row.append(wrong_answers.pop())
-                    new_row.append(self.question_list["Page"])
-                    new_row.append(self.question_list["Taxonomy"])
-                    writer.writerow(new_row)
-            if self.give_up_count == 3:
-                writer.writerow(["Failed to generate more questions.",])
-        self.send("next_state")
-
-    def on_event_output_q(self, event_: dict) -> None:
-        pass
-
-    def on_exit_output_q(self) -> None:
-        # Reset the state machine values
-        self.question_list = []
-        self.most_recent_questions = []
-
-    if __name__ == "__main__":
-
-        question_list = [
-            {
-                "Page": "1-2",
-                "Taxonomy": "Knowledge",
-                "Question": "What is Python?",
-                "Answer": "A programming language",
-                "Wrong Answers": ["A snake", "A car brand", "A fruit"],
-            },
-            {
-                "Page": "3-4",
-                "Taxonomy": "Comprehension",
-                "Question": "What does HTML stand for?",
-                "Answer": "HyperText Markup Language",
-                "Wrong Answers": [
-                    "High Text Machine Language",
-                    "Hyperlink Text Mode Language",
-                    "None of the above",
-                ],
-            },
-        ]
-
-        with Path(Path.cwd().joinpath("outputs/professor_guide.csv")).open(
-            "w", newline=""
-        ) as file:
-            writer = csv.writer(file)
-            for question in range(len(question_list)):
-                # TODO: Shuffle answers according to row, keep correct answer in random section. Answer column is a number.
-                new_row = [question_list[question]["Question"]]
-                wrong_answers = list(question_list[question]["Wrong Answers"])
+                new_row.append(self.question_list[question]["Question"])
+                wrong_answers = list(self.question_list[question]["Wrong Answers"])
                 column = random.randint(1, len(wrong_answers) + 1)
                 new_row.append(column)
                 for i in range(1, len(wrong_answers) + 2):
                     if i == column:
-                        new_row.append(question_list[question]["Answer"])
+                        new_row.append(self.question_list[question]["Answer"])
                     else:
                         new_row.append(wrong_answers.pop())
-                new_row.append(question_list[question]["Page"])
-                new_row.append(question_list[question]["Taxonomy"])
+                new_row.append(self.question_list[question]["Page"])
+                new_row.append(self.question_list[question]["Taxonomy"])
                 writer.writerow(new_row)
+            if self.give_up_count == 3:
+                writer.writerow(
+                    [
+                        "Failed to generate more questions.",
+                    ]
+                )
+        self.send("next_state")  # back to gather_parameters
+
+    # Necessary to prevent errors being thrown from state machine
+    def on_event_output_q(self, event_: dict) -> None:
+        pass