ladok3 3.6__tar.gz → 3.8__tar.gz

{ladok3-3.6 → ladok3-3.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ladok3
-Version: 3.6
+Version: 3.8
 Summary: Python wrapper and CLI for the LADOK3 REST API.
 Home-page: https://github.com/dbosk/ladok3
 License: MIT

{ladok3-3.6 → ladok3-3.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "ladok3"
-version = "3.6"
+version = "3.8"
 description = "Python wrapper and CLI for the LADOK3 REST API."
 authors = [
   "Daniel Bosk <dbosk@kth.se>",

{ladok3-3.6 → ladok3-3.8}/src/ladok3/ladok3.nw

@@ -908,6 +908,24 @@ for course in self.ladok.registrations_JSON(self.ladok_id):
 @
 
 
+\section{Is the student suspended?}
+
+We also want to know if a student is suspended or not.
+We can get a list of suspensions for a student.
+However, since suspended students are rare, we haven't found a specimen to 
+study; so we simply don't know what the list contains.
+But we can return it nonetheless.
+We never cache this result since we always want the most up-to-date version.
+<<student attribute methods>>=
+@property
+def suspensions(self):
+  """
+  The list of the students' suspensions.
+  """
+  return self.ladok.get_student_suspensions_JSON(self.ladok_id)["Avstangning"]
+@
+
+
 \chapter{Courses}\label{CourseClasses}
 
 We can use the course-related classes as follows.
@@ -1099,15 +1117,20 @@ print(r"\end{minted}")
 
 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")
+self.__version = data.pop("Versionsnummer", None) 
 
-self.__credits = data.pop("Omfattning")
-self.__unit = data.pop("Enhet")
+self.__credits = data.pop("Omfattning", None)
+self.__unit = data.pop("Enhet", None)
 
 self.__grade_scale = self.ladok.get_grade_scales(
   id=data.pop("BetygsskalaID"))
@@ -1126,6 +1149,10 @@ else:
 The [[CourseComponent]] class will make the attributes available.
 We specify the most interesting ones and let the [[LadokData]] constructor turn 
 the rest into properties as well, so that they are available for the curious.
+
+Turns out that some course components don't have any credits.
+This is probably a consequence of being a component in a course with no 
+credits, \eg one of those faux courses to register exchange studies.
 <<classes>>=
 class CourseComponent(LadokData):
   """Represents a course component of a course registration"""
@@ -1148,8 +1175,8 @@ class CourseComponent(LadokData):
     else:
       self.__description = description
 
-    self.__credits = kwargs.pop("Omfattning")
-    self.__unit = kwargs.pop("Enhet")
+    self.__credits = kwargs.pop("Omfattning", None)
+    self.__unit = kwargs.pop("Enhet", None)
 
     ladok = kwargs.pop("ladok")
     grade_scale_id = kwargs.pop("BetygsskalaID")
@@ -1260,6 +1287,12 @@ def __fetch_participants(self):
 Students register for a course.
 The [[CourseRegistration]] class represents this data from LADOK.
 This is the object that must be used to get results for a student.
+This object keeps more info than the course instance.
+
+We note that some registrations lack the \enquote{Utbildningstillfalleskod} 
+attribute.
+This happens on \enquote{custom courses} like Erasmus exchanges.
+If that's the case, we use the value [[None]] in its place.
 <<classes>>=
 class CourseRegistration(CourseInstance):
   """Represents a student's participation in a course instance"""
@@ -1268,7 +1301,7 @@ class CourseRegistration(CourseInstance):
 
     # ett Ladok-ID för kursomgången
     self.__round_id = kwargs.pop("UtbildningstillfalleUID")
-    self.__round_code = kwargs.pop("Utbildningstillfalleskod")
+    self.__round_code = kwargs.pop("Utbildningstillfalleskod", None)
 
     dates = kwargs.pop("Studieperiod")
     self.__start = datetime.date.fromisoformat(dates["Startdatum"])
@@ -1295,10 +1328,10 @@ class CourseRegistration(CourseInstance):
     return self.__end
 
   def __str__(self):
-    return f"{self.code} {self.round_code} ({self.start}--{self.end})"
+    return f"{self.code} {self.round_code or ''} ({self.start}--{self.end})"
 
   def __repr__(self):
-    return f"{self.code}:{self.round_code}:{self.start}--{self.end}"
+    return f"{self.code}:{self.round_code or ''}:{self.start}--{self.end}"
 
   def results(self, /, **kwargs):
     """Returns the student's results on the course, filtered on keywords"""
@@ -1444,6 +1477,10 @@ class CourseResult(LadokRemoteData):
     """Returns True if the grade has been attested in LADOK"""
     return self.__attested
 
+  def __str__(self):
+    return f"{self.component} {self.grade} " \
+           f"{self.date}{'*' if not self.attested else ''}"
+
   def push(self):
     if self.__uid:
       <<push the existing CourseResult grade data to LADOK>>

{ladok3-3.6 → ladok3-3.8}/src/ladok3/report.nw

@@ -129,8 +129,8 @@ them.
 <<check that we got all positional arguments>>
 try:
   student = ladok.get_student(args.student_id)
-  course = student.courses(code=args.course_code)[0]
-  result = course.results(component=args.component_code)[0]
+  <<look up [[course]] from [[student]]>>
+  <<look up [[result]] from [[course]]>>
   result.set_grade(args.grade, args.date)
   if args.finalize:
     result.finalize()
@@ -139,9 +139,25 @@ except Exception as err:
     print(f"{student}: {err}")
   except ValueError as verr:
     print(f"{verr}: {args.student_id}: {err}")
-@ This means that we need the following command-line arguments.
-The option [[args.finalize]] is already set above, so we don't need to add that 
-one here.
+@ The option [[args.finalize]] is already set above, so we don't need to add 
+that one here.
+
+Both looking up the course and the component can yield index errors.
+We'd like to distinguish these.
+We will catch the exception, the reraise the same exception but with a better 
+error message.
+<<look up [[course]] from [[student]]>>=
+try:
+  course = student.courses(code=args.course_code)[0]
+except IndexError:
+  raise Exception("f{args.course_code}: No such course for {student}")
+<<look up [[result]] from [[course]]>>=
+try:
+  result = course.results(component=args.component_code)[0]
+except IndexError:
+  raise Exception(f"{args.component_code}: "
+                  f"No such component for {args.course_code}")
+@
 
 
 \section{Report many results given in standard input}
@@ -180,23 +196,14 @@ try:
   try:
     course = student.courses(code=course_code)[0]
   except IndexError:
-    raise Exception(f"{course_code}: no such course.")
+    raise Exception(f"{course_code}: No such course for {student}")
 
   try:
     component = course.results(component=component_code)[0]
   except IndexError:
-    raise Exception(f"{course_code} has no component {component_code}.")
+    raise Exception(f"{component_code}: no such component for {course_code}")
 
-  if not component.attested and component.grade != grade:
-    component.set_grade(grade, date)
-    component.finalize()
-    if args.verbose:
-      print(f"{course_code} {student}: reported "
-        f"{component.component} = {component.grade} ({date}).")
-  elif component.grade != grade:
-    print(f"{course_code} {student}: attested {component.component} "
-      f"result {component.grade} ({component.date}) "
-      f"is different from {grade} ({date}).")
+  <<set [[grade]] to [[component]], output if verbose>>
 except Exception as err:
   try:
     print(f"{course_code} {component_code}={grade} ({date}) {student}: {err}",
@@ -207,6 +214,30 @@ except Exception as err:
       file=sys.stderr)
 @
 
+Now, when we set the grade, there are a few cases that should be handled.
+If the grade isn't attested, we try to change it.
+(This might still fail if the grade is finalized but not attested.)
+If we've selected the verbose option, then we print what we have reported.
+
+If the grade was attested, then we check if it's different.
+If it's different, we output this.
+If it's the same, we silently ignore it.
+This is best for bulk reporting, because then we can always try to report for 
+all students.
+<<set [[grade]] to [[component]], output if verbose>>=
+if not component.attested and component.grade != grade:
+  component.set_grade(grade, date)
+  if args.finalize:
+    component.finalize()
+  if args.verbose:
+    print(f"{course_code} {student}: reported "
+      f"{component.component} = {component.grade} ({date}).")
+elif component.grade != grade:
+  print(f"{course_code} {student}: attested {component.component} "
+    f"result {component.grade} ({component.date}) "
+    f"is different from {grade} ({date}).")
+@
+
 
 \section{Determine which function to run}
 

{ladok3-3.6 → ladok3-3.8}/src/ladok3/student.nw

@@ -63,6 +63,17 @@ student_parser.add_argument("-c", "--course",
 )
 @
 
+\subsection{A results flag}
+
+We also want a flag for specifying whether or not to include the results of 
+each course.
+<<add student command arguments to student parser>>=
+student_parser.add_argument("-r", "--results",
+  action="store_true", default=False,
+  help="Set to include results for each course listed."
+)
+@
+
 \section{Print the student data}
 
 Now that we have the student identifier, we can simply use that to fetch the 
@@ -79,7 +90,8 @@ except Exception as err:
 print_student_data(student)
 
 if args.course:
-  print_course_data(student, args.course)
+  print()
+  print_course_data(student, args)
 @
 
 \subsection{Printing personal student data}
@@ -94,16 +106,22 @@ def print_student_data(student):
   print(f"Personnummer: {student.personnummer}")
   print(f"LADOK ID:     {student.ladok_id}")
   print(f"Alive:        {student.alive}")
+  print(f"Suspended:    {student.suspensions}")
 @
 
 \subsection{Printing student's course data}
 
 To print the student's course data, we simply filter the courses on the option 
 that the user supplies.
+We then print all courses and, if the flag is set, we also print the results 
+for each course.
 <<functions>>=
-def print_course_data(student, course):
+def print_course_data(student, args):
   """Prints the courses"""
   print("Courses:")
-  for course in student.courses(code=course):
-    print(f"- {course}")
+  for course in student.courses(code=args.course):
+    print(f"{course}")
+    if args.results:
+      for result in course.results():
+        print(f"  {result}")
 @