PyKubeGrader 0.0.4__py3-none-any.whl

PyKubeGrader-0.0.4.dist-info/LICENSE.txt

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2024, M3-Learning: Multifunctional Materials and Machine Learning
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

PyKubeGrader-0.0.4.dist-info/METADATA

@@ -0,0 +1,69 @@
+Metadata-Version: 2.1
+Name: PyKubeGrader
+Version: 0.0.4
+Summary: Add a short description here!
+Home-page: https://github.com/pyscaffold/pyscaffold/
+Author: jagar2
+Author-email: jca92@drexel.edu
+License: MIT
+Project-URL: Documentation, https://pyscaffold.org/
+Platform: any
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python
+Description-Content-Type: text/x-rst; charset=UTF-8
+License-File: LICENSE.txt
+Requires-Dist: importlib-metadata; python_version < "3.8"
+Provides-Extra: testing
+Requires-Dist: setuptools; extra == "testing"
+Requires-Dist: pytest; extra == "testing"
+Requires-Dist: pytest-cov; extra == "testing"
+
+.. These are examples of badges you might want to add to your README:
+   please update the URLs accordingly
+
+    .. image:: https://api.cirrus-ci.com/github/<USER>/PyKubeGrader.svg?branch=main
+        :alt: Built Status
+        :target: https://cirrus-ci.com/github/<USER>/PyKubeGrader
+    .. image:: https://readthedocs.org/projects/PyKubeGrader/badge/?version=latest
+        :alt: ReadTheDocs
+        :target: https://PyKubeGrader.readthedocs.io/en/stable/
+    .. image:: https://img.shields.io/coveralls/github/<USER>/PyKubeGrader/main.svg
+        :alt: Coveralls
+        :target: https://coveralls.io/r/<USER>/PyKubeGrader
+    .. image:: https://img.shields.io/pypi/v/PyKubeGrader.svg
+        :alt: PyPI-Server
+        :target: https://pypi.org/project/PyKubeGrader/
+    .. image:: https://img.shields.io/conda/vn/conda-forge/PyKubeGrader.svg
+        :alt: Conda-Forge
+        :target: https://anaconda.org/conda-forge/PyKubeGrader
+    .. image:: https://pepy.tech/badge/PyKubeGrader/month
+        :alt: Monthly Downloads
+        :target: https://pepy.tech/project/PyKubeGrader
+    .. image:: https://img.shields.io/twitter/url/http/shields.io.svg?style=social&label=Twitter
+        :alt: Twitter
+        :target: https://twitter.com/PyKubeGrader
+
+.. image:: https://img.shields.io/badge/-PyScaffold-005CA0?logo=pyscaffold
+    :alt: Project generated with PyScaffold
+    :target: https://pyscaffold.org/
+
+|
+
+============
+PyKubeGrader
+============
+
+
+    Add a short description here!
+
+
+A longer description of your project goes here...
+
+
+.. _pyscaffold-notes:
+
+Note
+====
+
+This project has been set up using PyScaffold 4.6. For details and usage
+information on PyScaffold see https://pyscaffold.org/.

PyKubeGrader-0.0.4.dist-info/RECORD

@@ -0,0 +1,17 @@
+pykubegrader/__init__.py,sha256=JHme-EVdE2QbS9_Q2qdHiy5bEsyeQDbZ8aP2OfoSyiw,583
+pykubegrader/widgets/info_widget.py,sha256=x73heTqmqJQ9XkaE3eW4eLXTGJlmmTdGEkGtbIcY7uY,3532
+pykubegrader/widgets/mc_widget.py,sha256=eOFuZwEIc8NtgZS-Xnc9e49C1i0qYJvwFPyDVy7jq0c,2025
+pykubegrader/widgets/misc.py,sha256=dKw6SyRYU3DWRgD3xER7wq-C9e1daWPkqr901LpcwiQ,642
+pykubegrader/widgets/multi_select_base.py,sha256=GJQ-xFJTErar94cFwTxsSmLKPPmywJRUQELhAbv-uFs,3102
+pykubegrader/widgets/reading_base.py,sha256=vSoyThl2vFbnbgB_LDc-DDRPWCM2xGbazEptDjNn4uA,5311
+pykubegrader/widgets/reading_widget.py,sha256=e8lXSzGI9dHCxW7fIvwJUU6j8qWQgHnKR06ke2W1k7w,3022
+pykubegrader/widgets/select_base.py,sha256=cyTWKYRbsGYsYJh6ntW2vPub4r15c8IgcsMFSCG3St4,2121
+pykubegrader/widgets/select_many_widget.py,sha256=Rmb9Es42qzSdPfhU6ypcKnw_30PwuARX2UKVwgwbQhg,3772
+pykubegrader/widgets/telemetry.py,sha256=3GhItJ9dw18XcFutfQEk4z-DllCVtKXCKKLesf_jxzQ,3194
+pykubegrader/widgets/types_widget.py,sha256=FOrnR2x1eNM-pcFNIC8JnQdylgSUSUzuACmiIRuFTbQ,2244
+pykubegrader/widgets/validate.py,sha256=guEj0yeu9A_-Ig6S8diOfaNEWxud3k7t4tI-i4Steak,10585
+PyKubeGrader-0.0.4.dist-info/LICENSE.txt,sha256=YTp-Ewc8Kems8PJEE27KnBPFnZSxoWvSg7nnknzPyYw,1546
+PyKubeGrader-0.0.4.dist-info/METADATA,sha256=iMrtcscGbzaKzGx_dDYNVrPG6XFcuNIGpuTTkjz2rrY,2357
+PyKubeGrader-0.0.4.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+PyKubeGrader-0.0.4.dist-info/top_level.txt,sha256=e550Klfze6higFxER1V62fnGOcIgiKRbsrl9CC4UdtQ,13
+PyKubeGrader-0.0.4.dist-info/RECORD,,

PyKubeGrader-0.0.4.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.6.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

PyKubeGrader-0.0.4.dist-info/top_level.txt

@@ -0,0 +1 @@
+pykubegrader

pykubegrader/__init__.py

@@ -0,0 +1,16 @@
+import sys
+
+if sys.version_info[:2] >= (3, 8):
+    # TODO: Import directly (no need for conditional) when `python_requires = >= 3.8`
+    from importlib.metadata import PackageNotFoundError, version  # pragma: no cover
+else:
+    from importlib_metadata import PackageNotFoundError, version  # pragma: no cover
+
+try:
+    # Change here if project is renamed and does not equal the package name
+    dist_name = "PyKubeGrader"
+    __version__ = version(dist_name)
+except PackageNotFoundError:  # pragma: no cover
+    __version__ = "unknown"
+finally:
+    del version, PackageNotFoundError

pykubegrader/widgets/info_widget.py

@@ -0,0 +1,108 @@
+import os
+import re
+import socket
+
+import numpy as np
+import panel as pn
+
+from .telemetry import ensure_responses, update_responses
+
+EMAIL_PATTERN = re.compile(r"[a-z]+\d+@drexel\.edu")
+
+KEYS = [
+    "first_name",
+    "last_name",
+    "drexel_id",
+    "drexel_email",
+    "hostname",
+    "ip_address",
+    "jupyter_user",
+    "seed",
+]
+
+
+class StudentInfoForm:
+    def __init__(self, **kwargs) -> None:
+        self.first_name = kwargs.get("first_name", "")
+        self.last_name = kwargs.get("last_name", "")
+        self.drexel_id = kwargs.get("drexel_id", "")
+        self.drexel_email = kwargs.get("drexel_email", "")
+        self.hostname = kwargs.get("hostname", "")
+        self.ip_address = kwargs.get("ip_address", "")
+        self.jupyter_user = kwargs.get("jupyter_user", "")
+        self.seed = kwargs.get("seed", np.random.randint(0, 100))
+
+        self.first_name_widget = pn.widgets.TextInput(
+            name="First Name", value=self.first_name
+        )
+        self.last_name_widget = pn.widgets.TextInput(
+            name="Last Name", value=self.last_name
+        )
+        self.drexel_id_widget = pn.widgets.TextInput(
+            name="Drexel ID", value=self.drexel_id
+        )
+        self.drexel_email_widget = pn.widgets.TextInput(
+            name="Drexel Email", value=self.drexel_email
+        )
+
+        self.submit_button = pn.widgets.Button(
+            name="Submit", button_type="primary", styles=dict(margin_top="1.5em")
+        )
+        self.submit_button.on_click(self.submit)
+
+        self.message = pn.pane.Str("")  # Placeholder for status message
+
+        self.layout = pn.Column(
+            "# Student Information Form",
+            self.first_name_widget,
+            self.last_name_widget,
+            self.drexel_id_widget,
+            self.drexel_email_widget,
+            self.submit_button,
+            self.message,
+        )
+
+    def submit(self, _) -> None:
+        info = ensure_responses()
+
+        info["first_name"] = self.first_name_widget.value.strip()
+        info["last_name"] = self.last_name_widget.value.strip()
+        info["drexel_id"] = self.drexel_id_widget.value.strip()
+        info["drexel_email"] = self.drexel_email_widget.value.strip()
+
+        info["hostname"] = socket.gethostname()
+        info["jupyter_user"] = os.environ.get("JUPYTERHUB_USER", "Not on JupyterHub")
+
+        if "seed" not in info:
+            info["seed"] = np.random.randint(0, 100)
+
+        try:
+            info["ip_address"] = socket.gethostbyname(info["hostname"])
+        except socket.gaierror:
+            info["ip_address"] = "IP unavailable"
+
+        try:
+            for key in KEYS:
+                if info[key] == "":
+                    raise ValueError(f"Missing form input: {key}")
+
+            if not EMAIL_PATTERN.fullmatch(info["drexel_email"]):
+                raise ValueError(f"Invalid email format: {info['drexel_email']}")
+
+            email_prefix = info["drexel_email"].split("@")[0]
+            if info["drexel_id"] != email_prefix:
+                raise ValueError(
+                    f"Drexel ID {info['drexel_id']} does not match email {info['drexel_email']}"
+                )
+
+            for key in KEYS:
+                update_responses(key, info[key])
+
+            self.message.object = "Student info recorded successfully!"
+            self.message.style = {"color": "green"}
+        except ValueError as e:
+            self.message.object = str(e)
+            self.message.style = {"color": "red"}
+
+    def show(self):
+        return self.layout

pykubegrader/widgets/mc_widget.py

@@ -0,0 +1,72 @@
+from typing import Tuple
+
+import panel as pn
+
+from .misc import list_of_lists
+from .select_base import SelectQuestion
+
+
+def MCQ(
+    descriptions: list[str],
+    options: list[str] | list[list[str]],
+    initial_vals: list[str],
+) -> Tuple[list[pn.pane.HTML], list[pn.widgets.RadioButtonGroup]]:
+    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
+    ]
+
+    radio_buttons = [
+        pn.widgets.RadioButtonGroup(
+            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, radio_buttons
+
+
+class MCQuestion(SelectQuestion):
+    def __init__(
+        self,
+        title="Select the option that matches the definition:",
+        style=MCQ,
+        question_number=2,
+        keys=["MC1", "MC2", "MC3", "MC4"],
+        options=[
+            ["List", "Dictionary", "Tuple", "Set"],
+            ["return", "continue", "pass", "break"],
+            ["*", "^", "**", "//"],
+            [
+                "list.add(element)",
+                "list.append(element)",
+                "list.insert(element)",
+                "list.push(element)",
+            ],
+        ],
+        descriptions=[
+            "Which of the following stores key:value pairs?",
+            "The following condition returns to the next iteration of the loop",
+            "Which operator is used for exponentiation in Python?",
+            "Which method is used to add an element to the end of a list in Python?",
+        ],
+        points=2,
+    ):
+        super().__init__(
+            title=title,
+            style=style,
+            question_number=question_number,
+            keys=keys,
+            options=options,
+            descriptions=descriptions,
+            points=points,
+        )

pykubegrader/widgets/misc.py

@@ -0,0 +1,29 @@
+import random
+from typing import Tuple
+
+import panel as pn
+
+
+def list_of_lists(options: list) -> bool:
+    return all(isinstance(elem, list) for elem in options)
+
+
+def shuffle_options(options, seed: int):
+    random.seed(seed)
+    random.shuffle(options)
+
+    return options
+
+
+def shuffle_questions(
+    desc_widgets: list[pn.pane.HTML],
+    dropdowns: list[pn.widgets.Select] | list[pn.Column],
+    seed: int,
+) -> list[Tuple[pn.pane.HTML, pn.widgets.Select | pn.Column]]:
+    random.seed(seed)
+
+    # Combine widgets into pairs
+    widget_pairs = list(zip(desc_widgets, dropdowns))
+
+    random.shuffle(widget_pairs)
+    return widget_pairs

pykubegrader/widgets/multi_select_base.py

@@ -0,0 +1,99 @@
+from typing import Callable, Tuple
+
+import panel as pn
+
+from .misc import shuffle_questions
+from .telemetry import ensure_responses, update_responses
+
+
+class MultiSelectQuestion:
+    def __init__(
+        self,
+        title: str,
+        style: Callable[
+            [list[str], list[list[str]], list[bool]],
+            Tuple[list[pn.pane.HTML], list[pn.Column]],
+        ],
+        question_number: int,
+        keys: list[str],
+        options: list[list[str]],
+        descriptions: list[str],
+        points: int,
+    ):
+        responses = ensure_responses()
+
+        self.points = points
+        self.question_number = question_number
+        self.style = style
+
+        flat_index = 0
+        self.keys: list[str] = []
+        for i, _ in enumerate(keys):
+            for _ in options[i]:
+                flat_index += 1  # Start at 1
+                self.keys.append(f"q{question_number}_{flat_index}")
+
+        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, False))
+
+        self.initial_vals = [getattr(self, key) for key in self.keys]
+
+        description_widgets, self.widgets = style(
+            descriptions, options, self.initial_vals
+        )
+
+        self.submit_button = pn.widgets.Button(name="Submit")
+        self.submit_button.on_click(self.submit)
+
+        widget_pairs = shuffle_questions(description_widgets, self.widgets, seed)
+
+        # Panel layout
+        question_header = pn.pane.HTML(
+            f"<h2>Question {self.question_number}: {title}</h2>"
+        )
+        question_body = pn.Column(
+            *[
+                pn.Row(desc_widget, checkbox_set)
+                for desc_widget, checkbox_set in widget_pairs
+            ]
+        )
+
+        self.layout = pn.Column(question_header, question_body, self.submit_button)
+
+    def submit(self, _) -> None:
+        responses_flat: list[bool] = []
+        self.responses_nested: list[list[bool]] = []
+
+        for row in self.widgets:
+            next_selections = []
+
+            for widget in row.objects:
+                # Skip HTML widgets
+                if isinstance(widget, pn.pane.HTML):
+                    continue
+
+                if isinstance(widget, pn.widgets.Checkbox):
+                    next_selections.append(widget.value)
+                    responses_flat.append(widget.value)  # For flat list of responses
+
+            # Append all responses for this widget at once, forming a list of lists
+            self.responses_nested.append(next_selections)
+
+        self.record_responses(responses_flat)
+
+    def record_responses(self, responses_flat: list[bool]) -> None:
+        for key, value in zip(self.keys, responses_flat):
+            update_responses(key, value)
+
+        print("Responses recorded successfully")
+
+    def show(self):
+        return self.layout

pykubegrader/widgets/reading_base.py

@@ -0,0 +1,168 @@
+import copy
+from typing import Optional
+
+import panel as pn
+
+from .misc import shuffle_options
+from .telemetry import ensure_responses, update_responses
+
+
+class ReadingPython:
+    def __init__(
+        self,
+        title: str,
+        question_number: int,
+        options: dict,
+    ) -> None:
+        # Load responses from JSON (or create file if it doesn't exist)
+        responses = ensure_responses()
+
+        self.question_number = question_number
+
+        default = None
+
+        # Dynamically assign attributes based on keys, with default values from responses
+        for num in range(len(options["lines_to_comment"]) + options["n_rows"]):
+            key = f"q{question_number}_{num+1}"
+
+            # Dynamically assign the value from the responses file for persistence
+            if num < len(options["lines_to_comment"]):
+                setattr(self, key, responses.get(key, default))
+            else:
+                setattr(
+                    self,
+                    key,
+                    responses.get(key, [default] * (len(options["table_headers"]) - 1)),
+                )
+
+        # Checks that a seed was assigned to responses
+        try:
+            seed: int = responses["seed"]
+        except ValueError:
+            raise ValueError(
+                "You must submit your student info before starting the exam"
+            )
+
+        #
+        # Question title
+        #
+
+        question_title = pn.pane.HTML(f"<h2>Question {question_number}: {title}</h2>")
+
+        #
+        # Comment dropdowns
+        #
+
+        self.dropdowns_for_comments: dict[str, pn.widgets.Select] = {
+            line: pn.widgets.Select(
+                options=shuffle_options(options["comments_options"], seed),
+                name=f"Line {line}:",
+                value=getattr(self, f"q{question_number}_{i_comments+1}"),
+                width=600,
+            )
+            for i_comments, line in enumerate(options["lines_to_comment"])
+        }
+
+        comment_dropdowns = pn.Column(*self.dropdowns_for_comments.values())
+
+        #
+        # Execution dropdowns
+        #
+
+        # Instructions
+        execution_instructions = pn.pane.HTML(
+            "<h3>For each step, select the appropriate response:</h3>"
+        )
+
+        # Header row
+        header_row = pn.Row(
+            *[
+                pn.pane.HTML(f"<strong>{header}</strong>", width=150)
+                for header in options["table_headers"]
+            ]
+        )
+
+        # Make a deep copy of the lines to comment and add a null value to the beginning
+        # This is to provide the null response to the question
+        line_comment: list[int | str] = copy.deepcopy(options["lines_to_comment"])
+        line_comment.insert(0, "")
+
+        dropdown_options = [
+            line_comment,
+            options["variables_changed"],
+            options["current_values"],
+            options["datatypes"],
+        ]
+
+        # Function to create a row with dropdowns
+        def create_row(step: int) -> pn.Row:
+            widgets_list = [
+                pn.pane.HTML(f"Step {step+1}", width=150)
+                if i == 0
+                else pn.widgets.Select(
+                    options=dropdown_options[i - 1],
+                    value=getattr(
+                        self,
+                        f'q{question_number}_{len(options["lines_to_comment"])+step+1}',
+                    )[i - 1],
+                    width=150,
+                )
+                for i in range(len(options["table_headers"]))
+            ]
+
+            return pn.Row(*widgets_list)
+
+        # Generate rows dynamically based on n_rows
+        self.rows = [create_row(step) for step in range(options["n_rows"])]
+
+        # Combine header and rows
+        execution_steps = pn.Column(header_row, *self.rows)
+
+        # Submit button
+        self.submit_button = pn.widgets.Button(name="Submit")
+        self.submit_button.on_click(self.submit)
+
+        # Combine everything into a single layout
+        self.layout = pn.Column(
+            question_title,
+            comment_dropdowns,
+            execution_instructions,
+            execution_steps,
+            self.submit_button,
+        )
+
+    def submit(self, _) -> None:
+        # Get section 1 responses
+        self.output_comments: list[str] = []
+        for out in self.dropdowns_for_comments.values():
+            self.output_comments.append(out.value if isinstance(out.value, str) else "")
+
+        # Get section 2 responses
+        self.output_execution: list[list[Optional[str | int]]] = []
+
+        for row in self.rows[:]:
+            row_value: list[Optional[str | int]] = []
+
+            for box in row.objects:
+                if isinstance(box, pn.widgets.Select):
+                    row_value.append(box.value)
+
+            if not any(row_value):
+                continue
+
+            self.output_execution.append(row_value)
+
+        # Persist responses to JSON
+        i = 0
+        for comment_val in self.output_comments:
+            i += 1
+            update_responses(f"q{self.question_number}_{i}", comment_val)
+
+        for exec_val in self.output_execution:
+            i += 1
+            update_responses(f"q{self.question_number}_{i}", exec_val)
+
+        print("Responses recorded successfully")
+
+    def show(self):
+        return self.layout