PyKubeGrader 0.0.4__py3-none-any.whl

pykubegrader/widgets/reading_widget.py

@@ -0,0 +1,84 @@
+from .reading_base import ReadingPython
+
+
+class ReadingPythonQuestion(ReadingPython):
+    def __init__(
+        self,
+        title="Reading, Commenting, and Interpreting Python Code",
+        question_number=4,
+        key="READING1",
+        options={
+            # General list of 15 potential comments with only one correct per line
+            "comments_options": [
+                None,
+                "Initializes a list `numbers` with integers and floats",
+                "Initializes the variable `total` with a value of 0",
+                "A `for` loop that iterates through an iterator `numbers`",
+                "`while` loop that continues to iterate until `total` is less than 9",
+                "Adds and assigns the variable `total` with the value of `num` plus 1",
+                "Statement that ends the `for` loop",
+                "Initializes a dictionary `numbers` with integers and floats",
+                "Initializes the class `total` with a value of 0",
+                "A `for` loop that iterates through an iterator `num`",
+                "`while` loop that continues to iterate until `total` is less than or equal to 9",
+                "Adds the variable `total` with the value of `num` plus 1",
+                "Statement that ends the `while` loop",
+                "`while` loop that continues to iterate while `total` is less than 9",
+                "Initializes a list `numbers` with integers and floats",
+            ],
+            "n_rows": 12,  # Number of lines to show
+            "n_required": 8,  # Number of rows required to respond
+            # Lines of code that require commenting
+            "lines_to_comment": [1, 2, 4, 5, 6, 7],
+            # Table headers
+            "table_headers": [
+                "Step",
+                "Line Number",
+                "Variable Changed",
+                "Current Value",
+                "DataType",
+            ],
+            # Variables Changed
+            "variables_changed": ["", "None", "numbers", "num", "total", "if", "else"],
+            "current_values": [
+                "",
+                "None",
+                "[5, 4.0]",
+                "[5.0, 4.0]",
+                "5.0",
+                "6.0",
+                "5",
+                "6",
+                "4.0",
+                "4",
+                "11.0",
+                "11",
+                "12",
+                "12.0",
+                "0",
+                "0.0",
+                "True",
+                "False",
+                "N/A",
+            ],
+            "datatypes": [
+                "",
+                "NoneType",
+                "list",
+                "dictionary",
+                "tuple",
+                "set",
+                "string",
+                "float",
+                "integer",
+                "boolean",
+                "N/A",
+            ],
+        },
+        points=[20, 25],
+    ):
+        super().__init__(
+            title=title,
+            question_number=question_number,
+            options=options,
+        )

pykubegrader/widgets/select_base.py

@@ -0,0 +1,69 @@
+from typing import Callable, Tuple
+
+import panel as pn
+
+from .misc import shuffle_questions
+from .telemetry import ensure_responses, update_responses
+
+
+class SelectQuestion:
+    def __init__(
+        self,
+        title: str,
+        style: Callable[
+            [list[str], list, list[str]],
+            Tuple[list[pn.pane.HTML], list[pn.widgets.Select]],
+        ],
+        question_number: int,
+        keys: list[str],
+        options: list,
+        descriptions: list[str],
+        points: int,
+    ):
+        responses = ensure_responses()
+
+        self.points = points
+        self.question_number = question_number
+        self.keys = keys
+        self.style = style
+
+        try:
+            seed: int = responses["seed"]
+        except ValueError:
+            raise ValueError(
+                "You must submit your student info before starting the exam"
+            )
+
+        # Dynamically assigning attributes based on keys, with default values from responses
+        for key in self.keys:
+            setattr(self, key, responses.get(key, None))
+
+        self.initial_vals: list = [getattr(self, key) for key in self.keys]
+
+        desc_widgets, self.widgets = style(descriptions, options, self.initial_vals)
+
+        self.submit_button = pn.widgets.Button(name="Submit", button_type="primary")
+        self.submit_button.on_click(self.submit)
+
+        widget_pairs = shuffle_questions(desc_widgets, self.widgets, seed)
+
+        self.layout = pn.Column(
+            f"# Question {self.question_number}: {title}",
+            *(pn.Row(desc_widget, dropdown) for desc_widget, dropdown in widget_pairs),
+            self.submit_button,
+        )
+
+    def submit(self, _) -> None:
+        selections = {key: widget.value for key, widget in zip(self.keys, self.widgets)}
+
+        for value in selections.values():
+            if value is None:
+                raise ValueError("Please answer all questions before submitting")
+
+        for key, value in selections.items():
+            update_responses(key, value)
+
+        print("Responses recorded successfully")
+
+    def show(self):
+        return self.layout

pykubegrader/widgets/select_many_widget.py

@@ -0,0 +1,101 @@
+import panel as pn
+
+from .multi_select_base import MultiSelectQuestion
+
+
+def MultiSelect(
+    descriptions: list[str], options: list[list[str]], initial_vals: list[bool]
+):
+    desc_widgets: list[pn.pane.HTML] = []
+    checkboxes: list[pn.Column] = []
+
+    # Create separator line between questions
+    separator = pn.pane.HTML("<hr style='border:1px solid lightgray; width:100%;'>")
+
+    i = 0
+
+    for question, option_set in zip(descriptions, options):
+        desc_width = "500px"
+
+        # Create description widget with separator
+        desc_widget = pn.pane.HTML(
+            f"<hr style='border:1px solid lightgray; width:100%;'>"
+            f"<div style='text-align: left; width: {desc_width};'><b>{question}</b></div>"
+        )
+
+        # Create checkboxes for current question
+        checkbox_set = [
+            pn.widgets.Checkbox(
+                value=initial_vals[i],
+                name=option,
+                disabled=False,
+            )
+            for i, option in enumerate(option_set, start=i)
+        ]
+
+        desc_widgets.append(desc_widget)
+        checkboxes.append(pn.Column(*[separator] + checkbox_set))
+
+        # Increment iterator for next question
+        i += len(option_set)
+
+    return desc_widgets, checkboxes
+
+
+class SelectMany(MultiSelectQuestion):
+    def __init__(
+        self,
+        title="Select all statements which are TRUE",
+        style=MultiSelect,
+        question_number=3,
+        keys=["MS1", "MS2", "MS3", "MS4", "MS5"],
+        options=[
+            ["`if` statements", "`for` loops", "`while` loops", "`end` statements"],
+            ["dictionary", "tuple", "float", "class"],
+            [
+                "A class can inherit attributes and methods from another class.",
+                "The `self` keyword is used to access variables that belong to a class.",
+                "`__init__` runs on instantiation of a class.",
+                "Variables assigned in a class are always globally accessible.",
+            ],
+            [
+                "Keys in dictionaries are mutable.",
+                "It is possible to store a list of dictionaries in Python.",
+                "You can create multiple instances of a class with different values.",
+                "If `list1` is a list and you assign it to `list2` and append a value to `list2`, `list1` will also contain the value that was appended to `list2`.",
+            ],
+            [
+                "In `print(i)`, `i` must be a string.",
+                "`2day` is not a valid variable name.",
+                "`i` is not defined when evaluating the `while` loop.",
+                "`i < 5` is not valid syntax to compare a variable `i` to an integer `5`, if `i` is a float.",
+            ],
+        ],
+        descriptions=[
+            "Which of the following control structures are used in Python? (Select all that apply)",
+            "Which of the following are built-in data structures in Python? (Select all that apply)",
+            "Concerning object-oriented programming in Python, which of the following statements are true? (Select all that apply)",
+            "Select all of the TRUE statements",
+            """
+            Select all the syntax errors in the following code:
+            <pre>
+                <code class="language-python">
+                    2day = 'Tuesday'
+                    while i < 5:
+                        print(i)
+                        i += 1.0
+                </code>
+            </pre>
+            """,
+        ],
+        points=1,
+    ):
+        super().__init__(
+            title=title,
+            style=style,
+            question_number=question_number,
+            keys=keys,
+            options=options,
+            descriptions=descriptions,
+            points=points,
+        )

pykubegrader/widgets/telemetry.py

@@ -0,0 +1,132 @@
+import base64
+import datetime
+import json
+import logging
+import os
+
+import nacl.public
+import requests
+from IPython.core.interactiveshell import ExecutionInfo
+from requests import Response
+from requests.auth import HTTPBasicAuth
+
+logging.basicConfig(filename=".output.log", level=logging.INFO, force=True)
+
+
+def telemetry(info: ExecutionInfo) -> None:
+    cell_content = info.raw_cell
+    log_encrypted(f"code run: {cell_content}")
+
+
+def encrypt_to_b64(message: str) -> str:
+    with open("server_public_key.bin", "rb") as f:
+        server_pub_key_bytes = f.read()
+    server_pub_key = nacl.public.PublicKey(server_pub_key_bytes)
+
+    with open("client_private_key.bin", "rb") as f:
+        client_private_key_bytes = f.read()
+    client_priv_key = nacl.public.PrivateKey(client_private_key_bytes)
+
+    box = nacl.public.Box(client_priv_key, server_pub_key)
+    encrypted = box.encrypt(message.encode())
+    encrypted_b64 = base64.b64encode(encrypted).decode("utf-8")
+
+    return encrypted_b64
+
+
+def log_encrypted(message: str) -> None:
+    encrypted_b64 = encrypt_to_b64(message)
+    logging.info(f"Encrypted Output: {encrypted_b64}")
+
+
+def log_variable(value, info_type) -> None:
+    timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    message = f"{info_type}, {value}, {timestamp}"
+    log_encrypted(message)
+
+
+def ensure_responses() -> dict:
+    with open(".responses.json", "a") as _:
+        pass
+
+    data = {}
+
+    try:
+        with open(".responses.json", "r") as f:
+            data = json.load(f)
+    except json.JSONDecodeError:
+        with open(".responses.json", "w") as f:
+            json.dump(data, f)
+
+    return data
+
+
+def update_responses(key: str, value) -> dict:
+    data = ensure_responses()
+    data[key] = value
+
+    temp_path = ".responses.tmp"
+    orig_path = ".responses.json"
+
+    try:
+        with open(temp_path, "w") as f:
+            json.dump(data, f)
+
+        os.replace(temp_path, orig_path)
+    except (TypeError, json.JSONDecodeError) as e:
+        print(f"Failed to update responses: {e}")
+
+        if os.path.exists(temp_path):
+            os.remove(temp_path)
+
+        raise
+
+    return data
+
+
+def score_question(
+    student_email: str,
+    term: str,
+    assignment: str,
+    question: str,
+    submission: str,
+    base_url: str = "http://localhost:8000",
+) -> Response:
+    url = base_url + "/live-scorer"
+
+    payload = {
+        "student_email": student_email,
+        "term": term,
+        "assignment": assignment,
+        "question": question,
+        "responses": submission,
+    }
+
+    res = requests.post(url, json=payload, auth=HTTPBasicAuth("student", "capture"))
+
+    return res
+
+
+def submit_question_new(
+    student_email: str,
+    term: str,
+    assignment: str,
+    question: str,
+    responses: dict,
+    score: dict,
+    base_url: str = "http://localhost:8000",
+):
+    url = base_url + "/submit-question"
+
+    payload = {
+        "student_email": student_email,
+        "term": term,
+        "assignment": assignment,
+        "question": question,
+        "responses": responses,
+        "score": score,
+    }
+
+    res = requests.post(url, json=payload, auth=HTTPBasicAuth("student", "capture"))
+
+    return res

pykubegrader/widgets/types_widget.py

@@ -0,0 +1,77 @@
+from typing import Tuple
+
+import panel as pn
+
+from .misc import list_of_lists
+from .select_base import SelectQuestion
+
+
+def MultipleChoice(
+    descriptions: list[str],
+    options: list[str] | list[list[str]],
+    initial_vals: list[str],
+) -> Tuple[list[pn.pane.HTML], list[pn.widgets.Select]]:
+    desc_width = "350px"
+
+    desc_widgets = [
+        pn.pane.HTML(
+            f"<div style='text-align: left; width: {desc_width};'><b>{desc}</b></div>"
+        )
+        for desc in descriptions
+    ]
+
+    dropdowns = [
+        pn.widgets.Select(options=option, value=value, width=300)
+        for value, option in zip(
+            initial_vals,
+            options if list_of_lists(options) else [options] * len(initial_vals),
+        )
+    ]
+
+    return desc_widgets, dropdowns
+
+
+class TypesQuestion(SelectQuestion):
+    def __init__(
+        self,
+        title="Select the option that matches the definition:",
+        style=MultipleChoice,
+        question_number=1,
+        keys=["types1", "types2", "types3", "types4", "types5", "types6"],
+        options=[
+            "None",
+            "list",
+            "function",
+            "dictionary",
+            "array",
+            "variable",
+            "integer",
+            "string",
+            "tuple",
+            "iterator",
+            "float",
+            "object",
+            "class",
+            "module",
+            "package",
+            "instance",
+        ],
+        descriptions=[
+            "An ordered, mutable collection of items, defined with [ ]",
+            "A file containing Python definitions and statements",
+            "A collection of elements of the same type, allowing for efficient storage and manipulation of sequences of data",
+            "An immutable and ordered collection of elements in Python, which can contain mixed data types",
+            "A sequence of Unicode characters",
+            "A data type that represents real numbers with a decimal point",
+        ],
+        points=3,
+    ):
+        super().__init__(
+            title=title,
+            style=style,
+            question_number=question_number,
+            keys=keys,
+            options=options,
+            descriptions=descriptions,
+            points=points,
+        )