ladok3 4.9__py3-none-any.whl → 4.10__py3-none-any.whl

ladok3/cli.nw

@@ -504,7 +504,11 @@ If all fail, the function will return [[None]] for both.
 (This is due to how we handle the [[login]] command.)
 <<functions>>=
 def load_credentials(filename="config.json"):
-  """Load credentials from environment or file named filename"""
+  """
+  Loads credentials from environment or file named filename.
+  Returns the tuple (instituation, credential dictionary) that
+  can be passed to `LadokSession(instiution, credential dictionary)`.
+  """
 
   <<fetch vars from keyring>>
   <<fetch username and password from keyring>>

ladok3/cli.py

@@ -201,7 +201,11 @@ Note: Your password will be visible on screen during this process.
     if new_val:
       vars[key] = new_val
 def load_credentials(filename="config.json"):
-  """Load credentials from environment or file named filename"""
+  """
+  Loads credentials from environment or file named filename.
+  Returns the tuple (instituation, credential dictionary) that
+  can be passed to `LadokSession(instiution, credential dictionary)`.
+  """
 
   try:
     institution = keyring.get_password("ladok3", "institution")

ladok3/data.py

@@ -4,164 +4,202 @@ import ladok3
 import os
 import sys
 
+
 def filter_rounds(all_rounds, desired_rounds):
-  """Returns only the round objects with round code in desired_rounds."""
-  if not desired_rounds:
-    return all_rounds
-  return filter(
-    lambda x: x.round_code in desired_rounds,
-    all_rounds
-  )
+    """Returns only the round objects with round code in desired_rounds."""
+    if not desired_rounds:
+        return all_rounds
+    return filter(lambda x: x.round_code in desired_rounds, all_rounds)
+
+
 def extract_data_for_round(ladok, course_round, args):
-  course_start = course_round.start
-  course_length = course_round.end - course_start
-  component = course_round.components()[0]
-  results = ladok.search_reported_results_JSON(
-    course_round.round_id, component.instance_id)
-
-  students = filter_students(course_round.participants(), args.students)
-
-  for student in students:
-    student_results = filter_student_results(student, results)
-
-    if not should_include(ladok, student, course_round, student_results):
-      continue
-
-    components = filter_components(course_round.components(), args.components)
-
-    for component in components:
-      if len(student_results) < 1:
-        result_data = None
-      else:
-        result_data = filter_component_result(
-          component, student_results[0]["ResultatPaUtbildningar"])
-
-      if not result_data:
-        grade = "-"
-        normalized_date = None
-      else:
-        if "Betygsgradsobjekt" in result_data:
-          grade = result_data["Betygsgradsobjekt"]["Kod"]
-          try:
-            date = datetime.date.fromisoformat(
-              result_data["Examinationsdatum"])
-          except KeyError:
-            normalized_date = None
-            grade = "-"
-          else:
-            normalized_date = (date - course_start) / course_length
-            if args.time_limit and normalized_date > args.time_limit:
-              grade = "-"
-              normalized_date = None
-        else:
-          grade = "-"
-          normalized_date = None
+    course_start = course_round.start
+    course_length = course_round.end - course_start
+    component = course_round.components()[0]
+    results = ladok.search_reported_results_JSON(
+        course_round.round_id, component.instance_id
+    )
+
+    students = filter_students(course_round.participants(), args.students)
+
+    for student in students:
+        student_results = filter_student_results(student, results)
+
+        if not should_include(ladok, student, course_round, student_results):
+            continue
+
+        components = filter_components(course_round.components(), args.components)
+
+        for component in components:
+            if len(student_results) < 1:
+                result_data = None
+            else:
+                result_data = filter_component_result(
+                    component, student_results[0]["ResultatPaUtbildningar"]
+                )
+
+            if not result_data:
+                grade = "-"
+                normalized_date = None
+            else:
+                if "Betygsgradsobjekt" in result_data:
+                    grade = result_data["Betygsgradsobjekt"]["Kod"]
+                    try:
+                        date = datetime.date.fromisoformat(
+                            result_data["Examinationsdatum"]
+                        )
+                    except KeyError:
+                        normalized_date = None
+                        grade = "-"
+                    else:
+                        normalized_date = (date - course_start) / course_length
+                        if args.time_limit and normalized_date > args.time_limit:
+                            grade = "-"
+                            normalized_date = None
+                else:
+                    grade = "-"
+                    normalized_date = None
+
+            yield student, component, grade, normalized_date
+
 
-      yield student, component, grade, normalized_date
 def filter_student_results(student, results):
-  return list(filter(
-    lambda x: x["Student"]["Uid"] == student.ladok_id,
-    results))
+    return list(filter(lambda x: x["Student"]["Uid"] == student.ladok_id, results))
+
+
 def filter_component_result(component, results):
-  for component_result in results:
-    if "Arbetsunderlag" in component_result:
-      result_data = component_result["Arbetsunderlag"]
-    elif "SenastAttesteradeResultat" in component_result:
-      result_data = component_result["SenastAttesteradeResultat"]
-    else:
-      continue
-    if component.instance_id != result_data["UtbildningsinstansUID"]:
-      continue
-    return result_data
-
-  return None
+    for component_result in results:
+        if "Arbetsunderlag" in component_result:
+            result_data = component_result["Arbetsunderlag"]
+        elif "SenastAttesteradeResultat" in component_result:
+            result_data = component_result["SenastAttesteradeResultat"]
+        else:
+            continue
+        if component.instance_id != result_data["UtbildningsinstansUID"]:
+            continue
+        return result_data
+
+    return None
+
+
 def filter_students(all_students, desired_students):
-  """Returns only the students with personnummer in desired_students."""
-  if not desired_students:
-    return all_students
-  return filter(
-    lambda x: x.personnummer in desired_students,
-    all_students
-  )
+    """Returns only the students with personnummer in desired_students."""
+    if not desired_students:
+        return all_students
+    return filter(lambda x: x.personnummer in desired_students, all_students)
+
 
 def filter_components(all_components, desired_components):
-  """Returns only the components with a code in the desired_components."""
-  if not desired_components:
-    return all_components
-  return filter(
-    lambda x: x.code in desired_components,
-    all_components
-  )
+    """Returns only the components with a code in the desired_components."""
+    if not desired_components:
+        return all_components
+    return filter(lambda x: x.code in desired_components, all_components)
+
+
 def should_include(ladok, student, course_round, result):
-  """Returns True if student should be included, False if to be excluded"""
-  if is_reregistered(ladok, student.ladok_id, course_round):
-    return False
+    """Returns True if student should be included, False if to be excluded"""
+    if is_reregistered(ladok, student.ladok_id, course_round):
+        return False
+
+    if has_credit_transfer(result):
+        return False
+
+    return True
 
-  if has_credit_transfer(result):
-    return False
 
-  return True
 def is_reregistered(ladok, student_id, course):
-  """Check if the student is reregistered on the course round course."""
-  registrations = ladok.registrations_on_course_JSON(
-    course.education_id, student_id)
-  registrations.sort(
-    key=lambda x: x["Utbildningsinformation"]["Studieperiod"]["Startdatum"])
-  first_reg = registrations[0]
-  return first_reg["Utbildningsinformation"]["Utbildningstillfalleskod"] != \
-    course.round_code
+    """Check if the student is reregistered on the course round course."""
+    registrations = ladok.registrations_on_course_JSON(course.education_id, student_id)
+    registrations.sort(
+        key=lambda x: x["Utbildningsinformation"]["Studieperiod"]["Startdatum"]
+    )
+    first_reg = registrations[0]
+    return (
+        first_reg["Utbildningsinformation"]["Utbildningstillfalleskod"]
+        != course.round_code
+    )
+
+
 def has_credit_transfer(results):
-  """Returns True if there exists a credit tranfer among the results."""
-  for result in results:
-    for component_result in result["ResultatPaUtbildningar"]:
-      if component_result["HarTillgodoraknande"]:
-        return True
+    """Returns True if there exists a credit tranfer among the results."""
+    for result in results:
+        for component_result in result["ResultatPaUtbildningar"]:
+            if component_result["HarTillgodoraknande"]:
+                return True
+
+    return False
 
-  return False
 
 def add_command_options(parser):
-  data_parser = parser.add_parser("data",
-    help="Returns course results data in CSV form",
-    description="""
+    data_parser = parser.add_parser(
+        "data",
+        help="Returns course results data in CSV form",
+        description="""
   Returns the results in CSV form for all first-time registered students.
-  """.strip())
-  data_parser.set_defaults(func=command)
-  data_parser.add_argument("course_code",
-    help="The course code of the course for which to export data")
-
-  data_parser.add_argument("-d", "--delimiter",
-    default="\t",
-    help="The delimiter for the CSV output; "
-      "default is a tab character to be compatible with POSIX commands, "
-      "use `-d,` or `-d ,` to get comma-separated values.")
-  data_parser.add_argument("-r", "--rounds", nargs="+",
-    help="The round codes for the rounds to include, "
-      "otherwise all rounds will be included.")
-  data_parser.add_argument("-t", "--time-limit", type=float,
-    help="The time (normalized) for cutting off results, "
-      "use `-t 1.0` to cut off at course end.")
-  data_parser.add_argument("-s", "--students", nargs="+",
-    help="List of personnummer for students to include, "
-      "otherwise all students will be included.")
-
-  data_parser.add_argument("-c", "--components", nargs="+",
-    help="List of component codes for components to include, "
-      "otherwise all components will be included.")
+  """.strip(),
+    )
+    data_parser.set_defaults(func=command)
+    data_parser.add_argument(
+        "course_code", help="The course code of the course for which to export data"
+    )
+
+    data_parser.add_argument(
+        "-d",
+        "--delimiter",
+        default="\t",
+        help="The delimiter for the CSV output; "
+        "default is a tab character to be compatible with POSIX commands, "
+        "use `-d,` or `-d ,` to get comma-separated values.",
+    )
+    data_parser.add_argument(
+        "-r",
+        "--rounds",
+        nargs="+",
+        help="The round codes for the rounds to include, "
+        "otherwise all rounds will be included.",
+    )
+    data_parser.add_argument(
+        "-t",
+        "--time-limit",
+        type=float,
+        help="The time (normalized) for cutting off results, "
+        "use `-t 1.0` to cut off at course end.",
+    )
+    data_parser.add_argument(
+        "-s",
+        "--students",
+        nargs="+",
+        help="List of personnummer for students to include, "
+        "otherwise all students will be included.",
+    )
+
+    data_parser.add_argument(
+        "-c",
+        "--components",
+        nargs="+",
+        help="List of component codes for components to include, "
+        "otherwise all components will be included.",
+    )
+
 
 def command(ladok, args):
-  data_writer = csv.writer(sys.stdout, delimiter=args.delimiter)
-  course_rounds = filter_rounds(
-    ladok.search_course_rounds(code=args.course_code),
-    args.rounds)
-
-  data_writer.writerow([
-    "Course", "Round", "Component", "Student", "Grade", "Time"
-  ])
-  for course_round in course_rounds:
-    data = extract_data_for_round(ladok, course_round, args)
-
-    for student, component, grade, time in data:
-      data_writer.writerow(
-        [course_round.code, course_round.round_code, component,
-          student, grade, time]
-      )
+    data_writer = csv.writer(sys.stdout, delimiter=args.delimiter)
+    course_rounds = filter_rounds(
+        ladok.search_course_rounds(code=args.course_code), args.rounds
+    )
+
+    data_writer.writerow(["Course", "Round", "Component", "Student", "Grade", "Time"])
+    for course_round in course_rounds:
+        data = extract_data_for_round(ladok, course_round, args)
+
+        for student, component, grade, time in data:
+            data_writer.writerow(
+                [
+                    course_round.code,
+                    course_round.round_code,
+                    component,
+                    student,
+                    grade,
+                    time,
+                ]
+            )

ladok3/ladok3.nw

@@ -46,6 +46,17 @@ It uses the [[requests]] module.
 We can use the class as follows.
 \inputminted{python}{../examples/example_LadokSession.py}
 
+An alternative way would be to use the general authentication procedure that 
+seems to work at most Swedish universities.
+\begin{minted}[linenos]{python}
+import ladok3
+
+ladok = ladok3.LadokSession("KTH Royal Institute of Technology",
+                            vars={"username": os.environ["KTH_LOGIN"],
+                                  "password": os.environ["KTH_PASSWD"]},
+                            test_environment=True) # for experiments
+\end{minted}
+
 This chapter covers how the [[LadokSession]] class work.
 The remaining chapters cover what the [[ladok]] object can be used for.
 \Cref{StudentClasses} covers how we can work with student data.
@@ -1034,27 +1045,126 @@ This is essentially an \enquote{instance of a course syllabus}.
 We know from above that it inherits from [[LadokRemoteData]] and that it must 
 be initialized with the keywords [[ladok]] (for its parent) and 
 [[UtbildningsinstansUID]] (for itself) and optionally some data.
-This leaves the following methods.
 <<CourseInstance methods>>=
 def __init__(self, /, **kwargs):
   self.__instance_id = kwargs.pop("UtbildningsinstansUID")
-  super().__init__(**kwargs)
+  super().__init__(**kwargs) # sets self.ladok
 
-  try:
-    self.__assign_attr(kwargs)
-  except:
-    self.__pull_attributes()
+  <<CourseInstance constructor body>>
+@
+
+We can fetch the data from LADOK as follows.
+Note that we need to use the [[round_id]] from the [[CourseRound]] object.
+This works since we never have a [[CourseInstance]] object on its own, it's 
+always parent of a [[CourseRound]] object.
+(And that makes this kind of ugly from an OOP perspective.)
+<<fetch CourseInstance data from LADOK>>=
+data = self.ladok.course_round_components_JSON(self.round_id)
+@
+
+Then data will be populated with the following values:
+\begin{pycode}
+import json
+import ladok3
+import os
 
+ladok = ladok3.LadokSession(
+          os.environ["LADOK_INST"],
+          vars={"username": os.environ["LADOK_USER"],
+                "password": os.environ["LADOK_PASS"]},
+          test_environment=True)
+
+print(r"\begin{minted}{JSON}")
+data = ladok.course_round_components_JSON(
+                  "cf7045a7-3e1c-11eb-b960-5f936a674375")
+ladok3.clean_data(data)
+print(json.dumps(data, indent=2))
+print(r"\end{minted}")
+\end{pycode}
+
+Now that we have all data in [[data]], we can assign its values to the private 
+attributes.
+We note, however, that some course instances lack both [[Versionsnummer]] and 
+[[Omfattning]].
+It seems like faux courses are created to document when students go on 
+Exchanges.
+These faux courses have a name and code, but no credits or version of syllabus.
+Consequently they don't have any grading scales either.
+
+Our approach will be to try to assign the attributes using [[kwargs]], and if 
+that fails, we will fetch the data (pull from LADOK).
+If that pull fails with missing data, then we will assume that it's one of 
+these faux courses.
+<<CourseInstance constructor body>>=
+try:
+  self.__assign_attr(kwargs)
+except:
+  self.__pull_attributes()
+<<CourseInstance methods>>=
 def __assign_attr(self, data):
   <<assign CourseInstance data to private attributes>>
 
 def __pull_attributes(self):
-  <<fetch CourseInstance data object from LADOK>>
-  self.__assign_attr(data)
+  <<fetch CourseInstance data from LADOK>>
+  try:
+    self.__assign_attr(data)
+  except:
+    self.__assign_faux(data)
 
 def pull(self):
   self.__pull_attributes()
 
+def __assign_faux(self, data):
+  <<assign faux CourseInstance data to private attributes>>
+@
+
+By trial-and-error, it seems like the faux courses has none of the attributes 
+that the real courses have.
+However, we try our best.
+<<assign common CourseInstance data to private attributes>>=
+if "IngaendeMoment" in data:
+  self.__components = [CourseComponent(
+      ladok=self.ladok, course=self,
+      **component) for component in data["IngaendeMoment"]]
+else:
+  self.__components = []
+<<assign CourseInstance data to private attributes>>=
+<<assign common CourseInstance data to private attributes>>
+
+self.__name = data.pop("Benamning")
+self.__code = data.pop("Utbildningskod")
+
+self.__credits = data.pop("Omfattning")
+self.__unit = data.pop("Enhet")
+
+self.__version = data.pop("Versionsnummer")
+
+self.__education_id = data.pop("UtbildningUID")
+
+self.__grade_scale = self.ladok.get_grade_scales(
+  id=data.pop("BetygsskalaID"))
+<<assign faux CourseInstance data to private attributes>>=
+<<assign common CourseInstance data to private attributes>>
+
+self.__name = data.pop("Benamning", None)
+self.__code = data.pop("Utbildningskod", None)
+
+self.__credits = data.pop("Omfattning", None)
+self.__unit = data.pop("Enhet", None)
+
+self.__version = data.pop("Versionsnummer", None)
+
+self.__education_id = data.pop("UtbildningUID", None)
+
+try:
+  self.__grade_scale = self.ladok.get_grade_scales(
+    id=data.pop("BetygsskalaID"))
+except KeyError:
+  self.__grade_scale = None
+@
+
+Finally, we want to have properties to access the private attributes.
+<<CourseInstance methods>>=
 @property
 def instance_id(self):
   return self.__instance_id
@@ -1092,57 +1202,6 @@ def components(self, /, **kwargs):
   return filter_on_keys(self.__components, **kwargs)
 @
 
-Now we must fetch data from LADOK.
-<<fetch CourseInstance data object from LADOK>>=
-data = self.ladok.course_round_components_JSON(self.round_id)
-@ Then data will be populated with the following values:
-\begin{pycode}
-import json
-import ladok3
-import os
-
-ladok = ladok3.LadokSession(
-          os.environ["LADOK_INST"],
-          vars={"username": os.environ["LADOK_USER"],
-                "password": os.environ["LADOK_PASS"]},
-          test_environment=True)
-
-print(r"\begin{minted}{JSON}")
-data = ladok.course_round_components_JSON(
-                  "cf7045a7-3e1c-11eb-b960-5f936a674375")
-ladok3.clean_data(data)
-print(json.dumps(data, indent=2))
-print(r"\end{minted}")
-\end{pycode}
-
-Now that we have the [[data]] object, we can assign its values to the private 
-attributes.
-We note, however, that some course instances lack both [[Versionsnummer]] and 
-[[Omfattning]].
-It seems like faux courses are created to document when students go on 
-Exchanges.
-These faux courses have a name and code, but no credits or version of syllabus.
-<<assign CourseInstance data to private attributes>>=
-self.__education_id = data.pop("UtbildningUID")
-
-self.__code = data.pop("Utbildningskod")
-self.__name = data.pop("Benamning")
-self.__version = data.pop("Versionsnummer", None) 
-
-self.__credits = data.pop("Omfattning", None)
-self.__unit = data.pop("Enhet", None)
-
-self.__grade_scale = self.ladok.get_grade_scales(
-  id=data.pop("BetygsskalaID"))
-
-if "IngaendeMoment" in data:
-  self.__components = [CourseComponent(
-      ladok=self.ladok, course=self,
-      **component) for component in data["IngaendeMoment"]]
-else:
-  self.__components = []
-@
-
 
 \section{Course components}
 

ladok3/report.nw

@@ -133,7 +133,7 @@ Finally, we have the list of graders.
 <<add one result group arguments>>=
 one_parser.add_argument("graders", nargs="*",
   help="Space separated list of who did the grading, "
-       "give each grader as 'First Last <email@instutution.se>'.")
+       "give each grader as 'First Last <email@institution.se>'.")
 @
 
 Now that we have the arguments, we can just execute the following code using