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

ladok3/data.nw

@@ -16,7 +16,7 @@ from LADOK (\cref{DataCommand}).
 This is a subcommand for the [[ladok]] command-line interface.
 It can be used like this:
 \begin{minted}{bash}
-ladok data DD1315 > DD1315.csv
+ladok course DD1315 > DD1315.csv
 \end{minted}
 This program will produce CSV-formated data to answer the questions above.
 The data is formated like this:
@@ -26,11 +26,11 @@ The data is formated like this:
 \item component,
 \item student (pseudonym),
 \item grade,
-\item normalized time.
+\item either absolute date or normalized to the course start and finish.
 \end{itemize}
 
 
-\section{The [[data]] subcommand}\label{DataCommand}
+\section{The [[course]] subcommand}\label{DataCommand}
 
 This is a subcommand run as part of the [[ladok3.cli]] module.
 We provide a function [[add_command_options]] that adds the subcommand options 
@@ -47,10 +47,24 @@ import sys
 <<functions>>
 
 def add_command_options(parser):
+  """Add the 'course' subcommand options to the argument parser.
+  
+  Creates a subparser for the course data extraction command with all
+  necessary arguments for filtering and output formatting.
+  
+  Args:
+      parser (ArgumentParser): The parent parser to add the subcommand to.
+  """
   <<add data parser to parser>>
   <<add data command arguments to data parser>>
 
 def command(ladok, args):
+  """Execute the course data extraction command.
+  
+  Args:
+      ladok (LadokSession): The LADOK session for data access.
+      args: Parsed command line arguments containing course and filter options.
+  """
   <<produce data about course specified in args>>
 @
 
@@ -59,7 +73,7 @@ def command(ladok, args):
 We add a subparser.
 We set it up to use the function [[command]].
 <<add data parser to parser>>=
-data_parser = parser.add_parser("data",
+data_parser = parser.add_parser("course",
   help="Returns course results data in CSV form",
   description="""
 Returns the results in CSV form for all first-time registered students.
@@ -76,12 +90,13 @@ This way the user can deal with how to store the data.
 <<produce data about course specified in args>>=
 data_writer = csv.writer(sys.stdout, delimiter=args.delimiter)
 course_rounds = filter_rounds(
-  ladok.search_course_rounds(code=args.course_code),
-  args.rounds)
+                        ladok.search_course_rounds(code=args.course_code),
+                        args.rounds)
 
-data_writer.writerow([
-  "Course", "Round", "Component", "Student", "Grade", "Time"
-])
+if args.header:
+  data_writer.writerow([
+    "Course", "Round", "Component", "Student", "Grade", "Time"
+  ])
 for course_round in course_rounds:
   data = extract_data_for_round(ladok, course_round, args)
 
@@ -91,6 +106,7 @@ for course_round in course_rounds:
         student, grade, time]
     )
 @ We must take a course code and a delimiter as arguments.
+We also want to know if we want a header or not.
 <<add data command arguments to data parser>>=
 data_parser.add_argument("course_code",
   help="The course code of the course for which to export data")
@@ -100,6 +116,9 @@ data_parser.add_argument("-d", "--delimiter",
   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("-H", "--header", action="store_true",
+                         help="Print a header line with the column names.")
 @
 
 We filter the rounds.
@@ -129,24 +148,40 @@ We also need the course round through the [[course_round]] object of type
 [[CourseRound]].
 <<functions>>=
 def extract_data_for_round(ladok, course_round, args):
+  """Extract student result data for a specific course round.
+  
+  Processes a course round to extract student results data in CSV format,
+  filtering by students and components as specified in args.
+  
+  Args:
+      ladok (LadokSession): The LADOK session for data access.
+      course_round: The course round object to extract data from.
+      args: Command line arguments containing filter options.
+  
+  Returns:
+      list: List of result data dictionaries for CSV output.
+  """
   <<compute start and length of the course>>
   <<get the results for the course round>>
 
-  students = filter_students(course_round.participants(), args.students)
+  students = filter_students(course_round.participants(),
+                             args.students)
 
   for student in students:
-    student_results = filter_student_results(student, results)
+    student_results = filter_student_results(student,
+                                             results)
 
     <<determine if student should be included>>
 
-    components = filter_components(course_round.components(), args.components)
+    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"])
+        result_data = filter_component_result(component,
+                                student_results[0]["ResultatPaUtbildningar"])
 
       if not result_data:
         grade = "-"
@@ -154,7 +189,29 @@ def extract_data_for_round(ladok, course_round, args):
       else:
         <<extract grade and normalized date from result data>>
 
-      yield student, component, grade, normalized_date
+      <<yield [[student, component, grade]] and date>>
+@
+
+We want to yield the data in CSV form, so we simply yield a tuple.
+The date is either the normalized date or the date from the result data.
+The student's identifier will be either the LADOK ID or the student name and 
+personnummer, depending on the command line arguments.
+<<yield [[student, component, grade]] and date>>=
+yield student.ladok_id if args.ladok_id \
+                       else student, \
+      component, \
+      grade, \
+      normalized_date if args.normalize_date \
+                      else result_data["Examinationsdatum"] if result_data \
+                                                            else None
+<<add data command arguments to data parser>>=
+data_parser.add_argument("-l", "--ladok-id", action="store_true",
+                         help="Use the LADOK ID for the student, "
+                              "otherwise the student name and personnummer "
+                              "will be used.")
+data_parser.add_argument("-n", "--normalize-date", action="store_true",
+                         help="Normalize the date to the start of the course, "
+                              "otherwise the date is printed as is.")
 @
 
 \subsection{Get round data}
@@ -185,6 +242,15 @@ Then we must search for a student's result in the batch of results we received
 from LADOK.
 <<functions>>=
 def filter_student_results(student, results):
+  """Filter results for a specific student.
+  
+  Args:
+      student: Student object with ladok_id attribute.
+      results (list): List of result dictionaries from LADOK.
+  
+  Returns:
+      list: Filtered list containing only results for the specified student.
+  """
   return list(filter(
     lambda x: x["Student"]["Uid"] == student.ladok_id,
     results))
@@ -193,6 +259,17 @@ def filter_student_results(student, results):
 Similarly, we want to find the result for a particular component.
 <<functions>>=
 def filter_component_result(component, results):
+  """Find the result data for a specific course component.
+  
+  Searches through results to find the entry matching the given component.
+  
+  Args:
+      component: Course component object to search for.
+      results (list): List of result dictionaries to search through.
+  
+  Returns:
+      dict or None: Result data for the component, or None if not found.
+  """
   for component_result in results:
     <<get the component result data>>
     <<check component code in result data>>

ladok3/data.py

@@ -13,6 +13,19 @@ def filter_rounds(all_rounds, desired_rounds):
 
 
 def extract_data_for_round(ladok, course_round, args):
+    """Extract student result data for a specific course round.
+
+    Processes a course round to extract student results data in CSV format,
+    filtering by students and components as specified in args.
+
+    Args:
+        ladok (LadokSession): The LADOK session for data access.
+        course_round: The course round object to extract data from.
+        args: Command line arguments containing filter options.
+
+    Returns:
+        list: List of result data dictionaries for CSV output.
+    """
     course_start = course_round.start
     course_length = course_round.end - course_start
     component = course_round.components()[0]
@@ -60,14 +73,38 @@ def extract_data_for_round(ladok, course_round, args):
                     grade = "-"
                     normalized_date = None
 
-            yield student, component, grade, normalized_date
+            yield student.ladok_id if args.ladok_id else student, component, grade, (
+                normalized_date
+                if args.normalize_date
+                else result_data["Examinationsdatum"] if result_data else None
+            )
 
 
 def filter_student_results(student, results):
+    """Filter results for a specific student.
+
+    Args:
+        student: Student object with ladok_id attribute.
+        results (list): List of result dictionaries from LADOK.
+
+    Returns:
+        list: Filtered list containing only results for the specified student.
+    """
     return list(filter(lambda x: x["Student"]["Uid"] == student.ladok_id, results))
 
 
 def filter_component_result(component, results):
+    """Find the result data for a specific course component.
+
+    Searches through results to find the entry matching the given component.
+
+    Args:
+        component: Course component object to search for.
+        results (list): List of result dictionaries to search through.
+
+    Returns:
+        dict or None: Result data for the component, or None if not found.
+    """
     for component_result in results:
         if "Arbetsunderlag" in component_result:
             result_data = component_result["Arbetsunderlag"]
@@ -131,8 +168,16 @@ def has_credit_transfer(results):
 
 
 def add_command_options(parser):
+    """Add the 'course' subcommand options to the argument parser.
+
+    Creates a subparser for the course data extraction command with all
+    necessary arguments for filtering and output formatting.
+
+    Args:
+        parser (ArgumentParser): The parent parser to add the subcommand to.
+    """
     data_parser = parser.add_parser(
-        "data",
+        "course",
         help="Returns course results data in CSV form",
         description="""
   Returns the results in CSV form for all first-time registered students.
@@ -151,6 +196,13 @@ def add_command_options(parser):
         "default is a tab character to be compatible with POSIX commands, "
         "use `-d,` or `-d ,` to get comma-separated values.",
     )
+
+    data_parser.add_argument(
+        "-H",
+        "--header",
+        action="store_true",
+        help="Print a header line with the column names.",
+    )
     data_parser.add_argument(
         "-r",
         "--rounds",
@@ -158,6 +210,21 @@ def add_command_options(parser):
         help="The round codes for the rounds to include, "
         "otherwise all rounds will be included.",
     )
+    data_parser.add_argument(
+        "-l",
+        "--ladok-id",
+        action="store_true",
+        help="Use the LADOK ID for the student, "
+        "otherwise the student name and personnummer "
+        "will be used.",
+    )
+    data_parser.add_argument(
+        "-n",
+        "--normalize-date",
+        action="store_true",
+        help="Normalize the date to the start of the course, "
+        "otherwise the date is printed as is.",
+    )
     data_parser.add_argument(
         "-t",
         "--time-limit",
@@ -183,12 +250,21 @@ def add_command_options(parser):
 
 
 def command(ladok, args):
+    """Execute the course data extraction command.
+
+    Args:
+        ladok (LadokSession): The LADOK session for data access.
+        args: Parsed command line arguments containing course and filter options.
+    """
     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"])
+    if args.header:
+        data_writer.writerow(
+            ["Course", "Round", "Component", "Student", "Grade", "Time"]
+        )
     for course_round in course_rounds:
         data = extract_data_for_round(ladok, course_round, args)
 

ladok3/ladok.bash

@@ -25,22 +25,40 @@ __python_argcomplete_run_inner() {
 
 _python_argcomplete() {
     local IFS=$'\013'
-    local SUPPRESS_SPACE=0
-    if compopt +o nospace 2> /dev/null; then
-        SUPPRESS_SPACE=1
-    fi
-    COMPREPLY=( $(IFS="$IFS" \
-                  COMP_LINE="$COMP_LINE" \
-                  COMP_POINT="$COMP_POINT" \
-                  COMP_TYPE="$COMP_TYPE" \
-                  _ARGCOMPLETE_COMP_WORDBREAKS="$COMP_WORDBREAKS" \
-                  _ARGCOMPLETE=1 \
-                  _ARGCOMPLETE_SUPPRESS_SPACE=$SUPPRESS_SPACE \
-                  __python_argcomplete_run "$1") )
-    if [[ $? != 0 ]]; then
-        unset COMPREPLY
-    elif [[ $SUPPRESS_SPACE == 1 ]] && [[ "${COMPREPLY-}" =~ [=/:]$ ]]; then
-        compopt -o nospace
+    local script=""
+    if [[ -n "${ZSH_VERSION-}" ]]; then
+        local completions
+        completions=($(IFS="$IFS" \
+            COMP_LINE="$BUFFER" \
+            COMP_POINT="$CURSOR" \
+            _ARGCOMPLETE=1 \
+            _ARGCOMPLETE_SHELL="zsh" \
+            _ARGCOMPLETE_SUPPRESS_SPACE=1 \
+            __python_argcomplete_run ${script:-${words[1]}}))
+        _describe "${words[1]}" completions -o nosort
+    else
+        local SUPPRESS_SPACE=0
+        if compopt +o nospace 2> /dev/null; then
+            SUPPRESS_SPACE=1
+        fi
+        COMPREPLY=($(IFS="$IFS" \
+            COMP_LINE="$COMP_LINE" \
+            COMP_POINT="$COMP_POINT" \
+            COMP_TYPE="$COMP_TYPE" \
+            _ARGCOMPLETE_COMP_WORDBREAKS="$COMP_WORDBREAKS" \
+            _ARGCOMPLETE=1 \
+            _ARGCOMPLETE_SHELL="bash" \
+            _ARGCOMPLETE_SUPPRESS_SPACE=$SUPPRESS_SPACE \
+            __python_argcomplete_run ${script:-$1}))
+        if [[ $? != 0 ]]; then
+            unset COMPREPLY
+        elif [[ $SUPPRESS_SPACE == 1 ]] && [[ "${COMPREPLY-}" =~ [=/:]$ ]]; then
+            compopt -o nospace
+        fi
     fi
 }
-complete -o nospace -o default -o bashdefault -F _python_argcomplete ladok
+if [[ -z "${ZSH_VERSION-}" ]]; then
+    complete -o nospace -o default -o bashdefault -F _python_argcomplete ladok
+else
+    compdef _python_argcomplete ladok
+fi