ed-api-client 0.1.0__py3-none-any.whl

ed_api_client/client.py

@@ -0,0 +1,272 @@
+import operator
+import requests
+import time
+import json
+
+from ed_api_client import (
+    User,
+    Slide,
+    Lesson,
+    SlideResultSet,
+    SlideResult,
+    Module,
+    Submission,
+    Assignment,
+    AssignmentResult,
+    Question,
+    Answer,
+    Users,
+    QuizResult,
+    WorkspaceLog,
+    ScaffoldSession, Override,
+)
+
+
+class EdClient:
+    """
+    Provides access to the Ed API
+
+    Methods
+    ----------
+
+    get_user () -> User
+        Retrieves details of the authenticated user
+    get_users (courseId:int) -> List<User>
+        Retrieves details of all users involved in the given course
+    get_slides (lessonId:int) -> List<Slide>
+        Retrieves all slides for the given lesson
+    get_module_structure (courseId:int, fetchSlides:bool=False) -> List<Module>
+        Retrieves all modules and lessons for the given course, and optionally all slides within each lesson
+    get_slide_results (lessonId: int) -> SlideResultSet
+        Retrieves records of student interactions with slides within the given lesson
+    get_submission (submissionId: int) -> Submission
+        Retrieves details of a single submission (i.e. a student hitting Mark).
+        Note the returned submission will include details of indiviual test cases that are passed or failed.
+    get_submissions (userId: int, challengeId: int) -> List<Submission>
+        Retrieves details of all submissions made by the given student towards the given challenge.
+        Note the returned submissions will not include details of indiviual test cases that are passed or failed.
+    getResultsForStudent (assignment: Assignment, student: Student) -> AssignmentResult
+        Retrieves the marks and other details for the given student and given assignment
+    """
+
+    def __init__(self, token):
+        self.host = "https://edstem.org/api"
+        self.session = requests.Session()
+        # self.session.headers.update({"x-token": token})
+        self.session.headers.update({"Authorization": f"Bearer {token}"})
+        self.MAX_ATTEMPTS = 3
+        self.DELAY = 60
+
+    def __get_json(self, url, params=None):
+        r = None
+
+        for attempt in range(0, self.MAX_ATTEMPTS):
+            r = self.session.get(url, params=params)
+
+            if r.status_code >= 200 and r.status_code < 300:
+                return r.json()
+
+            if r.status_code == 429:
+                # getting rate limited
+                time.sleep(self.DELAY)
+
+        print(
+            "given up on request to {} after {} attempts, due to {}:{}".format(
+                url, self.MAX_ATTEMPTS, r.status_code, r.content
+            )
+        )
+        r.raise_for_status()
+
+    def get_user(self) -> User:
+        r = self.__get_json("{}/user".format(self.host))
+        u = r.get("user")
+        if u is None:
+            return None
+
+        return User.from_json(u)
+
+    def get_users(self, courseId: int, role: str = None) -> Users:
+        users = Users()
+
+        r = self.__get_json("{}/courses/{}/admin".format(self.host, courseId))
+
+        for u in r.get("users", []):
+            user = User.from_json(u)
+            if role is None or role == user.role:
+                users.add(user)
+
+        return users
+
+    def get_slides(self, lessonId):
+        slides = []
+
+        r = self.__get_json("{}/lessons/{}".format(self.host, lessonId))
+
+        for s in r.get("lesson", {}).get("slides", []):
+            slides.append(Slide.from_json(s))
+
+        return slides
+
+    def get_slide(self, slideId):
+        slides = []
+
+        r = self.__get_json(f"{self.host}/lessons/slides/{slideId}")
+        print(r)
+        return Slide.from_json(r["slide"])
+
+    def get_challenge(self, challengeId):
+        slides = []
+
+        r = self.__get_json(f"{self.host}/challenges/{challengeId}")
+        print(r)
+        # return Slide.from_json(r['slide'])
+
+    def get_module_structure(self, courseId, fetch_slides=False):
+        r = self.__get_json("{}/courses/{}/lessons".format(self.host, courseId))
+
+        modules = []
+        modulesById = {}
+        moduleIndex = 0
+        for m in r.get("modules", []):
+            module = Module(m["id"], m["name"], moduleIndex)
+            modules.append(module)
+            modulesById[module.id] = module
+            moduleIndex += 1
+
+        for l in r.get("lessons", []):
+            if l["is_hidden"]:
+                continue
+
+            moduleId = l.get("module_id")
+
+            if moduleId is None or moduleId not in modulesById:
+                continue
+
+            lesson = Lesson.from_json(l)
+            modulesById[moduleId].add_lesson(lesson)
+
+            if fetch_slides:
+                for slide in self.get_slides(lesson.id):
+                    lesson.add_slide(slide)
+
+        modules.sort(key=operator.attrgetter("index"))
+        return modules
+
+    def get_slide_results(self, lessonId):
+        r = self.__get_json("{}/lessons/{}/results".format(self.host, lessonId))
+
+        results = SlideResultSet()
+
+        for user in r:
+            userId = user["user_id"]
+
+            for slide in user.get("slides", []):
+                slideId = slide["slide_id"]
+                results.add(userId, slideId, SlideResult(slide))
+
+        return results
+
+    def get_submission(self, submissionId):
+        r = self.__get_json(
+            "{}/challenges/submissions/{}".format(self.host, submissionId)
+        )
+        s = r.get("submission")
+
+        if s is None:
+            return None
+
+        return Submission.from_json(s)
+
+    def get_submissions(self, userId, challengeId):
+        submissions = []
+        r = self.__get_json(
+            "{}/users/{}/challenges/{}/submissions".format(
+                self.host, userId, challengeId
+            )
+        )
+
+        for s in r.get("submissions", []):
+            submissions.append(Submission.from_json(s))
+
+        return submissions
+
+    def get_scaffold(self, challengeId: str):
+
+        r = self.__get_json(f"{self.host}/challenges/{challengeId}/scaffold")
+        print(json.dumps(r))
+
+    def get_workspace_log(self, workspaceId: str) -> WorkspaceLog:
+
+        r = self.__get_json(f"{self.host}/workspaces/{workspaceId}/logs")
+        # print(r['challenge_attempts'], r['challenge_results'])
+
+        return WorkspaceLog.from_json(r)
+
+    def getResultsForStudent(
+        self, assignment: Assignment, student: User
+    ) -> AssignmentResult:
+        result = AssignmentResult(student.id)
+
+        for quiz in assignment.quizzes:
+            answers = self.getAnswers(quiz.id, student.id)
+            result.add_quiz_result(QuizResult.build(quiz.id, quiz.questions, answers))
+
+        for challenge in assignment.challenges:
+            submissions = self.get_submissions(student.id, challenge.id)
+
+            submissions.sort(key=lambda x: x.markedAt)
+
+            for submission in submissions:
+                result.add_challenge_submission(submission, student, assignment)
+
+        result.finalize(assignment, self)
+        return result
+
+    def getQuestions(self, slideId):
+
+        questions = []
+        r = self.__get_json(f"{self.host}/lessons/slides/{slideId}/questions")
+
+        for q in r.get("questions", []):
+            questions.append(Question.from_json(q))
+
+        return questions
+
+    def getAnswers(self, slideId, userId):
+
+        answers = []
+        r = self.__get_json(
+            f"{self.host}/lessons/slides/{slideId}/questions/responses?user_id={userId}"
+        )
+
+        for a in r.get("responses", []):
+
+            if a.get("data") is None:
+                continue
+
+            answers.append(Answer.from_json(a))
+
+        return answers
+
+    def get_scaffold_files(self, challengeId):
+
+        r = self.session.post(f"{self.host}/challenges/{challengeId}/connect/scaffold")
+        ticket = r.json().get("ticket")
+
+        session = ScaffoldSession(ticket)
+        session.start()
+
+        return list(session.filesById.values())
+
+    def get_overrides(self, courseId:int, lessonId:int):
+
+        r = self.__get_json(
+            f"{self.host}/courses/{courseId}/overrides",
+            {'lesson_id' : lessonId}
+        )
+
+        overrides = []
+        for o in r.get('overrides',[]):
+            overrides.append(Override.from_json(o))
+
+        return overrides

ed_api_client/quizzes.py

@@ -0,0 +1,282 @@
+from dataclasses import dataclass, field
+from typing import List, Set, Dict
+import datetime
+import dateutil.parser
+import re
+
+
+def getParsonsSolutionFromSource(source):
+    solution = ""
+    for line in re.split("-----\\s*\n", source):
+        line = line.rstrip()
+
+        if len(line) == 0:
+            continue
+
+        if line.endswith("#alt"):
+            continue
+
+        if line.endswith("#distractor"):
+            continue
+
+        solution = solution + line + "\n"
+
+    return solution
+
+
+def getParsonsAnswer(items):
+    answer = ""
+    for item in items:
+        for i in range(0, item.get("indent", 0)):
+            answer = answer + " "
+
+        answer = answer + item.get("text", "") + "\n"
+
+    return answer
+
+
+def doesCodeMatch(codeA: str, codeB: str, strictIndentation: bool = False):
+
+    codeA = re.sub("-----", "", codeA)
+    codeB = re.sub("-----", "", codeB)
+
+    if strictIndentation:
+        return codeA == codeB
+
+    normA = re.sub("\\s+", " ", codeA).strip()
+    normB = re.sub("\\s+", " ", codeB).strip()
+
+    # print("A", normA)
+    # print("B", normB)
+
+    return normA == normB
+
+
+@dataclass
+class Quiz:
+    id: int
+    name: str
+    questions: list
+
+    def getMaxScore(self):
+        score = 0
+        for question in self.questions:
+            score = score + question.points
+
+        return score
+
+    def add_multichoice_solution(self, questionId: int, solution: Set[int]) -> bool:
+
+        for question in self.questions:
+            if question.type != "multichoice":
+                continue
+
+            if question.id != questionId:
+                continue
+
+            question.add_solution(solution)
+            return True
+
+        return False
+
+    def add_parsons_solution(self, questionId: int, solution: str) -> bool:
+
+        for question in self.questions:
+            if question.type != "parsons":
+                continue
+
+            if question.id != questionId:
+                continue
+
+            question.add_solution(solution)
+            return True
+
+        return False
+
+
+@dataclass
+class Question:
+    id: int
+    points: int
+    content: str
+    type: str = field(default=None, init=False)
+
+    def from_json(json: dict):
+        question_type = json.get("data", {}).get("type", "unknown")
+        if question_type == "multiple-choice":
+            return MultichoiceQuestion.from_json(json)
+        if question_type == "parsons":
+            return ParsonsQuestion.from_json(json)
+        if question_type == "short-answer":
+            return ShortAnswerQuestion.from_json(json)
+
+
+@dataclass
+class ShortAnswerQuestion(Question):
+    type = "short-answer"
+
+    def from_json(json: dict):
+        return ShortAnswerQuestion(
+            json["id"], json["auto_points"], json.get("data", {}).get("content")
+        )
+
+
+@dataclass
+class MultichoiceQuestion(Question):
+    type = "multichoice"
+    multiple_selection: bool
+    options: List[str]
+    solutions: List[Set[int]]
+
+    def from_json(json: dict):
+        return MultichoiceQuestion(
+            json["id"],
+            json["auto_points"],
+            json.get("data", {}).get("content"),
+            json.get("data", {}).get("multiple_selection", False),
+            json.get("data", {}).get("answers", []),
+            [json.get("data", {}).get("solution", [])],
+        )
+
+    def add_solution(self, solution: Set[int]):
+        self.solutions.append(solution)
+
+
+@dataclass
+class ParsonsQuestion(Question):
+    type = "parsons"
+    solutions: List[str] = field(default_factory=list)
+
+    def from_json(json: dict):
+        return ParsonsQuestion(
+            json["id"],
+            json["auto_points"],
+            json.get("data", {}).get("content"),
+            [getParsonsSolutionFromSource(json.get("data", {}).get("source"))],
+        )
+
+    def add_solution(self, solution: str):
+        self.solutions.append(solution)
+
+
+@dataclass
+class Answer:
+    question_id: int
+    created_at: datetime.datetime
+    type: str = field(default=None, init=False)
+
+    def from_json(j: dict):
+
+        if type(j["data"]) == list:
+            return MultichoiceAnswer.from_json(j)
+        elif type(j["data"]) == str:
+            return ShortAnswer.from_json(j)
+        else:
+            return ParsonsAnswer.from_json(j)
+
+
+@dataclass
+class MultichoiceAnswer(Answer):
+    type = "multichoice"
+    choices: Set[int]
+
+    def from_json(j: dict):
+        return MultichoiceAnswer(
+            j["question_id"], dateutil.parser.isoparse(j["created_at"]), j["data"]
+        )
+
+
+@dataclass
+class ParsonsAnswer(Answer):
+    type = "parsons"
+    code: str
+
+    def from_json(j: dict):
+
+        return ParsonsAnswer(
+            j["question_id"],
+            dateutil.parser.isoparse(j["created_at"]),
+            getParsonsAnswer(j["data"]["items"]),
+        )
+
+
+@dataclass
+class ShortAnswer(Answer):
+    type = "shortanswer"
+    text: str
+
+    def from_json(j: dict):
+
+        return ShortAnswer(
+            j["question_id"], dateutil.parser.isoparse(j["created_at"]), j["data"]
+        )
+
+
+@dataclass
+class QuizResult:
+    quizId: int
+    score: int = 0
+    answersByQuestionId: Dict[int, Answer] = field(default_factory=dict)
+    pointsByQuestionId: Dict[int, int] = field(default_factory=dict)
+
+    def build(quizId: int, questions: List, answers: List):
+
+        result = QuizResult(quizId)
+
+        for answer in answers:
+            result.answersByQuestionId[answer.question_id] = answer
+
+        for question in questions:
+
+            answer = result.answersByQuestionId.get(question.id)
+            if answer is None:
+                # result.pointsByQuestionId[question.id] = None
+                continue
+
+            if question.type == "multichoice":
+                correct = False
+                for solution in question.solutions:
+
+                    if solution == answer.choices:
+                        correct = True
+                        break
+
+                if correct:
+                    result.score = result.score + question.points
+                    result.pointsByQuestionId[question.id] = question.points
+                else:
+                    result.pointsByQuestionId[question.id] = 0
+
+            if question.type == "parsons":
+                correct = False
+                for solution in question.solutions:
+                    if doesCodeMatch(solution, answer.code, False):
+                        correct = True
+                        break
+
+                if correct:
+                    result.score = result.score + question.points
+                    result.pointsByQuestionId[question.id] = question.points
+                else:
+                    result.pointsByQuestionId[question.id] = 0
+
+        return result
+
+    def print_summary(self, quiz: Quiz):
+
+        print(
+            f"  {self.score}/{quiz.getMaxScore()} points for "
+            + quiz.name
+            + " from the following questions:"
+        )
+
+        for index in range(0, len(quiz.questions)):
+            question = quiz.questions[index]
+            points = self.pointsByQuestionId.get(question.id)
+
+            if points is None:
+                print(f"    Q{index+1}: 0 points (unanswered)")
+            elif points == 0:
+                print(f"    Q{index+1}: 0 points (incorrect)")
+            else:
+                print(f"    Q{index + 1}: {points} points (correct)")