cornellGrading 2.19.0__tar.gz → 2.20.1__tar.gz

{cornellgrading-2.19.0/cornellGrading.egg-info → cornellgrading-2.20.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cornellGrading
-Version: 2.19.0
+Version: 2.20.1
 Summary: Routines for interacting with Cornell installations of Canvas and Qualtrics
 Home-page: https://github.com/dsavransky/grading
 Author: Dmitry Savransky

{cornellgrading-2.19.0 → cornellgrading-2.20.1}/cornellGrading/__init__.py

@@ -1,4 +1,4 @@
 name = "cornellGrading"
-__version__ = "2.19.0"
+__version__ = "2.20.1"
 from .cornellGrading import cornellGrading
 from .cornellQualtrics import cornellQualtrics

{cornellgrading-2.19.0 → cornellgrading-2.20.1}/cornellGrading/cornellGrading.py

@@ -5,6 +5,7 @@ import keyring
 import time
 from datetime import datetime, timedelta
 import pytz
+import canvasapi
 from canvasapi import Canvas
 from canvasapi.exceptions import InvalidAccessToken
 import tempfile
@@ -16,6 +17,8 @@ import urllib.parse
 import subprocess
 import shutil
 import requests
+import uuid
+from cornellGrading.utils import convalllatex
 
 try:
     from cornellGrading.pandocHTMLParser import pandocHTMLParser
@@ -2019,8 +2022,8 @@ class cornellGrading:
         r = requests.post(full_url, json={"item": item}, headers=headers)
         assert r.status_code == 200
 
-    def getHomework(self, assignmentNum, preamble=""):
-        """Retrieve assignment based on number and optional preamble
+    def genHomeworkName(self, assignmentNum, preamble=""):
+        """Synthesize assignment name based on number and optional preamble
 
         Args:
             assignmentNum (int):
@@ -2045,6 +2048,31 @@ class cornellGrading:
 
         # generate the name and grab the assignment
         hwname = f"{preamble}HW{assignmentNum}"
+
+        return hwname
+
+    def getHomework(self, assignmentNum, preamble=""):
+        """Retrieve assignment based on number and optional preamble
+
+        Args:
+            assignmentNum (int):
+                Assignment names will be of the form "[preamble] HW#"
+                where # is `assignmentNum`. See also `preamble` input.
+
+            preamble (str):
+                If not "", then assignment name will be "[preamble] HW#". Otherwise,
+                name will be "HW#".  Defaults to ""
+
+        Returns:
+            tuple:
+                hwname (str):
+                    Full assignment name
+                hw (canvasapi.assignment.Assignment):
+                    Assignment object
+        """
+
+        # get the name and grab the assignment
+        hwname = self.genHomeworkName(assignmentNum, preamble=preamble)
         hw = self.getAssignment(hwname)
 
         return hwname, hw
@@ -2054,7 +2082,7 @@ class cornellGrading:
         assignmentNum,
         nprobs,
         solfile,
-        item,
+        npoints=3,
         preamble="",
         selfGradeDueDelta=7,
         selfGradeReleasedDelta=3,
@@ -2070,8 +2098,8 @@ class cornellGrading:
                 Number of howmework problems
             solfile (str):
                 Full path to solutions file to upload
-            item (dict):
-                New Quiz item payload dictionary. See `addNewQuizItem`
+            npoints (int):
+                Number of points each question is scored out of. Defaults to 3.
             preamble (str):
                 Preamble for all naming.
                 See :py:meth:`cornellGrading.cornellGrading.getHomework` for details.
@@ -2132,6 +2160,9 @@ class cornellGrading:
             }
         )
 
+        # create item
+        item = self.genNpointNewQuizItem(npoints)
+
         # add new quiz items
         for j in range(nprobs):
             tmp = item.copy()
@@ -2256,3 +2287,235 @@ class cornellGrading:
         self.uploadScores(hw, netids, scores)
 
         return submittedScoreNoAssignment, submittedAssignmentNoScore
+
+    def genNpointNewQuizItem(self, n, item_body=None, title=None,  position=0):
+        """Generate a New Quiz multiple choice, variable point question with answers
+        ranging from 0 to n and each answer worth the equivalent number of points.
+
+        Args:
+            n (int):
+                Number of points possible.  Question will have n+1 options (from 0 to n)
+                with each response worth the equivalent number of points
+            item_body (str, optional):
+                Question text (html formatted).  If None (default) this is set to
+                <p>Enter your score based on the rubric in the syllabus</p>
+            title (str, optional):
+                Question title.  If None (default) this is set to:
+                HW Problem Score
+            position (int):
+                Position of question in quiz.  Defaults to 0
+
+        Returns:
+            dict:
+                New Quiz Multiple choice question definition
+
+        """
+
+        # set default body text and title
+        if item_body is None:
+            item_body = "<p>Enter your score based on the rubric in the syllabus</p>"
+
+        if title is None:
+            title = "HW Problem Score"
+
+        # generate UUIDs
+        uuids = [uuid.uuid4() for _ in range(n + 1)]
+
+        # create choices and values dict list
+        choices = []
+        values = []
+        for j in range(n + 1):
+            choices.append(
+                {"id": f"{uuids[j]}", "position": j + 1, "item_body": f"<p>{j}</p>"}
+            )
+            values.append({"value": f"{uuids[j]}", "points": j})
+
+        q = {
+            "position": position,
+            "points_possible": float(n),
+            "entry_type": "Item",
+            "status": "immutable",
+            "entry": {
+                "title": title,
+                "item_body": item_body,
+                "calculator_type": "none",
+                "interaction_data": {"choices": choices},
+                "properties": {
+                    "shuffle_rules": {"choices": {"to_lock": [], "shuffled": False}},
+                    "vary_points_by_answer": True,
+                },
+                "scoring_data": {
+                    "value": f"{uuids[-1]}",
+                    "values": values,
+                },
+                "answer_feedback": {f"{uuids[0]}": ""},
+                "scoring_algorithm": "VaryPointsByAnswer",
+                "interaction_type_slug": "choice",
+                "feedback": {},
+            },
+        }
+
+        return q
+
+    def genNewQuizMultipleChoice(
+        self, question, options, correct_ind, points=1, position=0
+    ):
+        """Generate a new quiz-style multiple choice question dictionary
+
+        Args:
+            question (str):
+                The raw question text (may include LaTeX)
+            options (list(str) or ~numpy.ndarray(str)):
+                Possible answers. All contents must be strings (may include LaTeX)
+            correct_ind (ind):
+                Index of correct answer in `options` input.
+            points (int):
+                Number of points for correct answer (defaults to 1).
+            position (int):
+                Position of question in quiz.  Defaults to 0
+
+        Returns:
+            dict:
+                Question-defining dictionary
+
+        """
+
+        # generate UUIDs
+        uuids = [uuid.uuid4() for _ in range(len(options))]
+
+        # create choices dict list
+        choices = []
+        for j in range(len(options)):
+            choices.append(
+                {
+                    "id": f"{uuids[j]}",
+                    "position": j + 1,
+                    "item_body": f"<p>{convalllatex(options[j])}</p>",
+                }
+            )
+
+        q = {
+            "position": position,
+            "points_possible": float(points),
+            "properties": {},
+            "entry_type": "Item",
+            "entry_editable": True,
+            "stimulus_quiz_entry_id": "",
+            "status": "mutable",
+            "entry": {
+                "title": question,
+                "item_body": f"<p>{convalllatex(question)}</p>",
+                "calculator_type": "none",
+                "interaction_data": {"choices": choices},
+                "properties": {
+                    "shuffle_rules": {"choices": {"to_lock": [], "shuffled": False}},
+                    "vary_points_by_answer": False,
+                },
+                "scoring_data": {"value": f"{uuids[correct_ind]}"},
+                "answer_feedback": {},
+                "scoring_algorithm": "Equivalence",
+                "interaction_type_slug": "choice",
+                "feedback": {},
+            },
+        }
+
+        return q
+
+    def genQuizMultipleChoice(
+        self, question, options, correct_ind, points=1, position=0
+    ):
+        """ "Generate a classic quiz-style multiple choice question dictionary
+
+        Args:
+            question (str):
+                The raw question text (may include LaTeX)
+            options (list(str) or ~numpy.ndarray(str)):
+                Possible answers. All contents must be strings (may include LaTeX)
+            correct_ind (ind):
+                Index of correct answer in `options` input.
+            points (int):
+                Number of points for correct answer (defaults to 1).
+            position (int):
+                Position of question in quiz.  Defaults to 0
+
+        Returns:
+            dict:
+                Question-defining dictionary
+
+        """
+
+        # create answers dict list
+        answers = []
+        for j in range(len(options)):
+            answers.append(
+                {
+                    "answer_html": f"<p>{convalllatex(options[j])}</p>",
+                    "answer_weight": 100 if j == correct_ind else 0,
+                }
+            )
+
+        q = {
+            "question_name": question,
+            "question_text": f"<p>{convalllatex(question)}</p>",
+            "question_type": "multiple_choice_question",
+            "position": 0,
+            "points_possible": points,
+            "answers": answers,
+        }
+
+        return q
+
+    def genQuizFromPolev(self, allqs, quiz):
+        """Generate quiz items from a PollEv formatted CSV input file
+
+        Args:
+            allqs (pandas.DataFrame):
+                Table of questions and answers, formatted in PolEV CSV upload style
+            quiz (canvasapi.new_quiz.NewQuiz or canvasapi.quiz.Quiz):
+                Quiz object
+
+        Returns:
+            None
+
+        .. note::
+            Poll Everywhere upload format documentation is available here:
+            https://support.polleverywhere.com/hc/en-us/articles/1260801546530-Import-questions
+
+        """
+
+        assert isinstance(
+            quiz, (canvasapi.new_quiz.NewQuiz, canvasapi.quiz.Quiz)
+        ), "quiz input must be a Quiz or New Quiz object."
+
+        # identify response columns:
+        optcols = []
+        for col in allqs.columns:
+            if col.startswith("Option"):
+                optcols.append(col)
+
+        # iterate through rows, creating the questions
+        for j, row in allqs.iterrows():
+            question = row.Title
+            opts = row[optcols].values
+            opts = opts[~pandas.isna(opts)]
+            correct_ind = [
+                j
+                for j, s in enumerate(opts)
+                if isinstance(s, str) and s.startswith("***")
+            ]
+            assert len(correct_ind) == 1
+            correct_ind = correct_ind[0]
+            opts[correct_ind] = opts[correct_ind].strip("***")
+
+            # create and add the question depending on quiz type
+            if isinstance(quiz, canvasapi.new_quiz.NewQuiz):
+                q = self.genNewQuizMultipleChoice(
+                    question, opts.astype(str), correct_ind, position=j + 1
+                )
+
+                self.addNewQuizItem(quiz.id, q)
+            else:
+                q = self.genQuizMultipleChoice(
+                    question, opts.astype(str), correct_ind, position=j + 1
+                )
+                quiz.create_question(question=q)

cornellgrading-2.20.1/cornellGrading/utils.py

@@ -0,0 +1,55 @@
+import urllib.parse
+import re
+
+
+def convalllatex(text):
+    """Convert all instances of LaTeX in a string to Canvas-compatible images
+
+    Args:
+        text (str):
+            Input text
+
+    Returns:
+        str:
+            Output text
+
+    """
+
+    p = re.compile(r"\${1,2}(.*?)\${1,2}")
+
+    return p.sub(convlatex, text)
+
+
+def convlatex(texstr):
+    """Convert input latex string to Canvas's img html
+
+    Args:
+        texstr (str or re.Match):
+            LaTeX-formatted equation string
+
+    Returns:
+        str:
+            Canvas-style image string
+
+    """
+
+    # handle case where input is re.Match
+    if isinstance(texstr, re.Match):
+        texstr = texstr.groups()[0]
+
+    # replace problematic commands int LaTeX
+    texsubdict = {
+        r"\\textrm": "",
+    }
+    for key, val in texsubdict.items():
+        texstr = re.sub(key, val, texstr)
+
+    convstr = urllib.parse.quote(urllib.parse.quote(texstr))
+    qtxt = (
+        f"""<img class="equation_image" title="{texstr}" """
+        f"""src="/equation_images/{convstr}?scale=1" """
+        f"""alt="LaTeX: {texstr}" """
+        f""" data-equation-content="{texstr}" data-ignore-a11y-check="">"""
+    )
+
+    return qtxt

{cornellgrading-2.19.0 → cornellgrading-2.20.1/cornellGrading.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cornellGrading
-Version: 2.19.0
+Version: 2.20.1
 Summary: Routines for interacting with Cornell installations of Canvas and Qualtrics
 Home-page: https://github.com/dsavransky/grading
 Author: Dmitry Savransky

{cornellgrading-2.19.0 → cornellgrading-2.20.1}/cornellGrading.egg-info/SOURCES.txt

@@ -11,6 +11,7 @@ cornellGrading/cornellQualtrics.py
 cornellGrading/dueDatesFromCSV.py
 cornellGrading/pandocHTMLParser.py
 cornellGrading/upload_MC_questions.py
+cornellGrading/utils.py
 cornellGrading.egg-info/PKG-INFO
 cornellGrading.egg-info/SOURCES.txt
 cornellGrading.egg-info/dependency_links.txt