Added “lab” style

nigel.stanger / Handbook

Browse code Added “lab” style master
1 parent f1858fd commit 0f1385969d95db134782f101ab4ed31fea340371 Nigel Stanger authored on 22 Jul 2021

Patch

Showing 7 changed files

                Ignore Space
               Show notes
              View
            
          
          8 ■■■■■
          calendar/teachingdates/app.py
             print("{prog}: debug: paper config: {c}".format(
                prog=PROG, c=dates_config.get_paper_config()))
        cal = calendars.TeachingCalendar(dates_config)
        if args.debug:
            print("Calendar: {cal}".format(cal=cal.calendar()))
            print("Lectures: {lec}".format(lec=cal.lecture_dates()))
            print("Calendars: {cal}".format(cal=cal.calendars))
            print("{cls}: {dates}".format(
                cls=dates_config.style.title() + "s",
                dates=cal.class_dates()))
        print(cal.render(args.style, args.format))
 
    except configuration.ConfigurationError as e:
        print("{prog}: error: failed to load configuration from "

            import argparse
import copy
import pathlib
import sys

from jinja2 import TemplateNotFound

import teachingdates.calendars as calendars
import teachingdates.config as configuration
from teachingdates import PROG


def run():
    args = configuration.parse_command_line()
    if args.debug:
        print("{prog}: debug: args: {a}".format(prog=PROG, a=args))

    try:
        dates_config = configuration.Configuration(args)
        if args.debug:
            print("{prog}: debug: period config: {c}".format(
                prog=PROG, c=dates_config.get_period_config()))
            print("{prog}: debug: paper config: {c}".format(
                prog=PROG, c=dates_config.get_paper_config()))
        cal = calendars.TeachingCalendar(dates_config)
        if args.debug:
            print("Calendars: {cal}".format(cal=cal.calendars))
            print("{cls}: {dates}".format(
                cls=dates_config.style.title() + "s",
                dates=cal.class_dates()))
        print(cal.render(args.style, args.format))

    except configuration.ConfigurationError as e:
        print("{prog}: error: failed to load configuration from "
              "{file}".format(prog=PROG, file=e))
    except configuration.PaperKeyError as e:
        print("{prog}: error: paper '{paper}' in {file} is missing "
              "required key '{key}'".format(prog=PROG,
                                             paper=e.parent,
                                             file=e.file,
                                             key=e.key))
    except configuration.PeriodKeyError as e:
        print("{prog}: error: teaching period '{period}' in {file} is "
              "missing required key '{key}'".format(prog=PROG,
                                                     period=e.parent,
                                                     file=e.file,
                                                     key=e.key))
    except configuration.PaperError as e:
        print("{prog}: error: no entry for paper '{paper}' ({period}) in "
              "{file}.".format(prog=PROG,
                                 file=e,
                                 paper=args.paper,
                                 period=args.period))
    except configuration.PeriodError as e:
        print("{prog}: error: no entry for teaching period '{period}' in "
              "{file}".format(prog=PROG, file=e, period=args.period))
    except TemplateNotFound as e:
        print("{prog}: error: no template found for output style '{style}' "
              "and output format '{format}' (expected {file})".format(
                  prog=PROG, style=args.style, format=args.format, file=e))

            import argparse
import copy
import pathlib
import sys

from jinja2 import TemplateNotFound

import teachingdates.calendars as calendars
import teachingdates.config as configuration
from teachingdates import PROG


def run():
    args = configuration.parse_command_line()
    if args.debug:
        print("{prog}: debug: args: {a}".format(prog=PROG, a=args))

    try:
        dates_config = configuration.Configuration(args)
        if args.debug:
            print("{prog}: debug: period config: {c}".format(
                prog=PROG, c=dates_config.get_period_config()))
            print("{prog}: debug: paper config: {c}".format(
                prog=PROG, c=dates_config.get_paper_config()))
        cal = calendars.TeachingCalendar(dates_config)
        if args.debug:
            print("Calendar: {cal}".format(cal=cal.calendar()))
            print("Lectures: {lec}".format(lec=cal.lecture_dates()))
        print(cal.render(args.style, args.format))

    except configuration.ConfigurationError as e:
        print("{prog}: error: failed to load configuration from "
              "{file}".format(prog=PROG, file=e))
    except configuration.PaperKeyError as e:
        print("{prog}: error: paper '{paper}' in {file} is missing "
              "required key '{key}'".format(prog=PROG,
                                             paper=e.parent,
                                             file=e.file,
                                             key=e.key))
    except configuration.PeriodKeyError as e:
        print("{prog}: error: teaching period '{period}' in {file} is "
              "missing required key '{key}'".format(prog=PROG,
                                                     period=e.parent,
                                                     file=e.file,
                                                     key=e.key))
    except configuration.PaperError as e:
        print("{prog}: error: no entry for paper '{paper}' ({period}) in "
              "{file}.".format(prog=PROG,
                                 file=e,
                                 paper=args.paper,
                                 period=args.period))
    except configuration.PeriodError as e:
        print("{prog}: error: no entry for teaching period '{period}' in "
              "{file}".format(prog=PROG, file=e, period=args.period))
    except TemplateNotFound as e:
        print("{prog}: error: no template found for output style '{style}' "
              "and output format '{format}' (expected {file})".format(
                  prog=PROG, style=args.style, format=args.format, file=e))
             print("{prog}: debug: paper config: {c}".format(
                 prog=PROG, c=dates_config.get_paper_config()))
         cal = calendars.TeachingCalendar(dates_config)
         if args.debug:
+            print("Calendar: {cal}".format(cal=cal.calendar()))
+            print("Lectures: {lec}".format(lec=cal.lecture_dates()))
+            print("Calendars: {cal}".format(cal=cal.calendars))
+            print("{cls}: {dates}".format(
+                cls=dates_config.style.title() + "s",
+                dates=cal.class_dates()))
         print(cal.render(args.style, args.format))
     except configuration.ConfigurationError as e:
         print("{prog}: error: failed to load configuration from "

                Ignore Space
               Show notes
              View
            
          
          48 ■■■■■
          calendar/teachingdates/calendars/basecalendar.py
                 self.mondays[-1].isocalendar()[1] # last ISO week
            ]}])
        self.calendars["iso"] = self.generate_calendar("iso")
 
        self.lecture_offsets = []
        self.skipped_lectures = []
        self.class_offsets = []
        self.skipped_classes = []
        if self.config.paper:
            self.update_lectures(self.config.get_paper_config(self.config.paper))
            self.update_classes(
                self.config.get_paper_config(self.config.paper),
                class_type=self.config.style + "s"
            )
 
    def make_week(self, week_type, start, end=None):
        end = start if end is None else end
        return [
                    print("{prog}: warning: ignored unknown week type "
                          "'{type}'.".format(prog=PROG, type=t))
        return weeks
 
    def update_lectures(self, lecture_list):
        for l in lecture_list["lectures"]:
    def update_classes(self, class_list, class_type="lectures"):
        for l in class_list[class_type]:
            for t, v in l.items():
                if t == "offsets":
                    self.lecture_offsets = v
                    self.class_offsets = v
                elif t == "skip":
                    self.skipped_lectures = v
                    self.skipped_classes = v
                else:
                    print("{prog}: warning: ignored unknown lecture key "
                          "'{key}'.".format(prog=PROG, key=t))
                    print("{prog}: warning: ignored unknown {type} key "
                          "'{key}'.".format(
                              prog=PROG,
                              type=class_type[:-1],
                              key=t))
 
    # turn this into a generator?
    def generate_calendar(self, period):
        result = {}
                result[week_num + break_num] = w
        return result
 
    # turn this into a generator?
    def lecture_dates(self):
    def class_dates(self):
        dates = {}
        lecture_num = 1
        class_num = 1
        teaching_weeks = [t for t in self.calendars[self.config.period].values() if isinstance(t, TeachingWeek)]
        for week_index, monday in enumerate(teaching_weeks):
            for offset_index, offset in enumerate(self.lecture_offsets):
                lec = week_index * 2 + offset_index + 1
                if lec in self.skipped_lectures:
            for offset_index, offset in enumerate(self.class_offsets):
                cls = week_index * 2 + offset_index + 1
                if cls in self.skipped_classes:
                    continue
                dates[lecture_num] = monday + datetime.timedelta(offset)
                lecture_num += 1
                dates[class_num] = monday + datetime.timedelta(offset)
                class_num += 1
        return dates
 
    def render_latex(self, weeks):
        env = jinja2.Environment(
            calendars=self.calendars,
            eow_offset=datetime.timedelta(self.config.end_of_week))
 
    def render(self, style, fmt):
        if self.config.style == "lecture":
            weeks = self.lecture_dates()
        if self.config.style in ["lecture", "lab"]:
            weeks = self.class_dates()
        else:
            weeks = self.calendars[self.config.period]
        
        if fmt == "latex":

            import calendar
import datetime

import jinja2
from num2words import num2words

from teachingdates import PROG

from .errors import TemplateStyleError
from .weeks import BreakWeek, IsoWeek, TeachingWeek

suffix_map = {
    "latex": "tex",
    "text": "txt",
    "xml": "xml",
}

filters = {
    "isteaching": lambda w: isinstance(w, TeachingWeek),
    "isbreak": lambda w: isinstance(w, BreakWeek),
    "pad": lambda s, n: str(s).rjust(n),
    "num2words": lambda s: num2words(str(s)).title().replace("-", "")
}


class TeachingCalendar():
    """This class generates teaching-related dates for a specific paper
    offered in a specific teaching period of a specific year. If you
    don't provide teaching period details, it generates dates for the
    current ISO-8601 year.
    """

    def __init__(self, config):
        self.config = config

        cal = calendar.Calendar().yeardatescalendar(config.year, width=12)
        # Extract the Mondays at the start of each week. Because Calendar
        # is designed to produce data suitable for a printed calendar,
        # it includes all weeks that overlap with the calendar year,
        # regardless of whether they're actually part of the ISO year.
        # We therefore also need to filter on the current ISO year.
        self.mondays = [
            week[0] for month in cal[0] for week in month
            if week[0].isocalendar()[0] == config.year
        ]
        # Similarly, each month generated by Calendar includes all days
        # from the first and last weeks of the month, which may be from
        # the preceding or succeeding month, respectively. These show
        # up as duplicates that need to be removed.
        self.mondays = list(dict.fromkeys(self.mondays))

        self.period_weeks = {}
        self.calendars = {}
        for period in self.config.get_config_keys():
            self.period_weeks[period] = self.generate_period_weeks(
                self.config.get_period_config(period)["weeks"])
            self.calendars[period] = self.generate_calendar(period)
        self.period_weeks["iso"] = self.generate_period_weeks(
            [{"iso": [
                self.mondays[0].isocalendar()[1], # first ISO week
                self.mondays[-1].isocalendar()[1] # last ISO week
            ]}])
        self.calendars["iso"] = self.generate_calendar("iso")

        self.class_offsets = []
        self.skipped_classes = []
        if self.config.paper:
            self.update_classes(
                self.config.get_paper_config(self.config.paper),
                class_type=self.config.style + "s"
            )

    def make_week(self, week_type, start, end=None):
        end = start if end is None else end
        return [
            week_type(
                self.mondays[w].year,
                self.mondays[w].month,
                self.mondays[w].day)
            for w in range(start - 1, end)]

    def generate_period_weeks(self, week_list):
        weeks = []
        for w in week_list:
            for t, r in w.items():
                if t == "teach":
                    weeks += self.make_week(TeachingWeek, r[0], r[1])
                elif t == "break":
                    weeks += self.make_week(BreakWeek, r[0], r[1])
                elif t == "iso":
                    weeks += self.make_week(IsoWeek, r[0], r[1])
                else:
                    print("{prog}: warning: ignored unknown week type "
                          "'{type}'.".format(prog=PROG, type=t))
        return weeks

    def update_classes(self, class_list, class_type="lectures"):
        for l in class_list[class_type]:
            for t, v in l.items():
                if t == "offsets":
                    self.class_offsets = v
                elif t == "skip":
                    self.skipped_classes = v
                else:
                    print("{prog}: warning: ignored unknown {type} key "
                          "'{key}'.".format(
                              prog=PROG,
                              type=class_type[:-1],
                              key=t))

    # turn this into a generator?
    def generate_calendar(self, period):
        result = {}
        week_num = 0
        break_num = 0
        for w in self.period_weeks[period]:
            if isinstance(w, (TeachingWeek, IsoWeek)):
                # Increment first so that break weeks have the
                # same week number as the preceding teaching week.
                # This ensures the keys are always chronologically
                # sorted. Reset the break number for each new
                # teaching week.
                week_num += 1
                break_num = 0
                result[week_num] = w
                # if period == "ISO":
                # print("week ", week_num, " ", w)
            elif isinstance(w, BreakWeek):
                # Allow for up to 99 consecutive break weeks,
                # which should be sufficient :). Should probably
                # throw an exception if we exceed that.
                break_num += 0.01
                result[week_num + break_num] = w
        return result

    # turn this into a generator?
    def class_dates(self):
        dates = {}
        class_num = 1
        teaching_weeks = [t for t in self.calendars[self.config.period].values() if isinstance(t, TeachingWeek)]
        for week_index, monday in enumerate(teaching_weeks):
            for offset_index, offset in enumerate(self.class_offsets):
                cls = week_index * 2 + offset_index + 1
                if cls in self.skipped_classes:
                    continue
                dates[class_num] = monday + datetime.timedelta(offset)
                class_num += 1
        return dates

    def render_latex(self, weeks):
        env = jinja2.Environment(
            block_start_string="\\BLOCK{",
            block_end_string="}",
            variable_start_string="\\VAR{",
            variable_end_string="}",
            comment_start_string="\\#{",
            comment_end_string="}",
            line_statement_prefix="%%",
            line_comment_prefix="%#",
            trim_blocks=True,
            autoescape=False,
            loader=jinja2.PackageLoader("teachingdates", "templates"))
        env.filters.update(filters)
        template = env.get_template(
            "{style}.tex.j2".format(style=self.config.style))
        return template.render(
            weeks=weeks,
            paper=self.config.paper,
            period=self.config.period,
            year=self.config.year,
            eow_offset=datetime.timedelta(self.config.end_of_week))

    def render_text(self, weeks):
        env = jinja2.Environment(
            loader=jinja2.PackageLoader("teachingdates", "templates"),
            autoescape=False)
        env.filters.update(filters)
        template = env.get_template(
            "{style}.txt.j2".format(style=self.config.style))
        return template.render(
            weeks=weeks,
            paper=self.config.paper,
            period=self.config.period,
            year=self.config.year,
            eow_offset=datetime.timedelta(self.config.end_of_week))

    def render_xml(self):
        env = jinja2.Environment(
            loader=jinja2.PackageLoader("teachingdates", "templates"),
            autoescape=jinja2.select_autoescape(["xml"]))
        env.filters.update(filters)
        template = env.get_template("paper-calendar-dates.xml.j2")
        return template.render(
            calendars=self.calendars,
            eow_offset=datetime.timedelta(self.config.end_of_week))

    def render(self, style, fmt):
        if self.config.style in ["lecture", "lab"]:
            weeks = self.class_dates()
        else:
            weeks = self.calendars[self.config.period]
        
        if fmt == "latex":
            return(self.render_latex(weeks))
        elif fmt == "text":
            return(self.render_text(weeks))
        elif fmt == "xml":
            return(self.render_xml())
        else:
            return None

            import calendar
import datetime

import jinja2
from num2words import num2words

from teachingdates import PROG

from .errors import TemplateStyleError
from .weeks import BreakWeek, IsoWeek, TeachingWeek

suffix_map = {
    "latex": "tex",
    "text": "txt",
    "xml": "xml",
}

filters = {
    "isteaching": lambda w: isinstance(w, TeachingWeek),
    "isbreak": lambda w: isinstance(w, BreakWeek),
    "pad": lambda s, n: str(s).rjust(n),
    "num2words": lambda s: num2words(str(s)).title().replace("-", "")
}


class TeachingCalendar():
    """This class generates teaching-related dates for a specific paper
    offered in a specific teaching period of a specific year. If you
    don't provide teaching period details, it generates dates for the
    current ISO-8601 year.
    """

    def __init__(self, config):
        self.config = config

        cal = calendar.Calendar().yeardatescalendar(config.year, width=12)
        # Extract the Mondays at the start of each week. Because Calendar
        # is designed to produce data suitable for a printed calendar,
        # it includes all weeks that overlap with the calendar year,
        # regardless of whether they're actually part of the ISO year.
        # We therefore also need to filter on the current ISO year.
        self.mondays = [
            week[0] for month in cal[0] for week in month
            if week[0].isocalendar()[0] == config.year
        ]
        # Similarly, each month generated by Calendar includes all days
        # from the first and last weeks of the month, which may be from
        # the preceding or succeeding month, respectively. These show
        # up as duplicates that need to be removed.
        self.mondays = list(dict.fromkeys(self.mondays))

        self.period_weeks = {}
        self.calendars = {}
        for period in self.config.get_config_keys():
            self.period_weeks[period] = self.generate_period_weeks(
                self.config.get_period_config(period)["weeks"])
            self.calendars[period] = self.generate_calendar(period)
        self.period_weeks["iso"] = self.generate_period_weeks(
            [{"iso": [
                self.mondays[0].isocalendar()[1], # first ISO week
                self.mondays[-1].isocalendar()[1] # last ISO week
            ]}])
        self.calendars["iso"] = self.generate_calendar("iso")

        self.lecture_offsets = []
        self.skipped_lectures = []
        if self.config.paper:
            self.update_lectures(self.config.get_paper_config(self.config.paper))

    def make_week(self, week_type, start, end=None):
        end = start if end is None else end
        return [
            week_type(
                self.mondays[w].year,
                self.mondays[w].month,
                self.mondays[w].day)
            for w in range(start - 1, end)]

    def generate_period_weeks(self, week_list):
        weeks = []
        for w in week_list:
            for t, r in w.items():
                if t == "teach":
                    weeks += self.make_week(TeachingWeek, r[0], r[1])
                elif t == "break":
                    weeks += self.make_week(BreakWeek, r[0], r[1])
                elif t == "iso":
                    weeks += self.make_week(IsoWeek, r[0], r[1])
                else:
                    print("{prog}: warning: ignored unknown week type "
                          "'{type}'.".format(prog=PROG, type=t))
        return weeks

    def update_lectures(self, lecture_list):
        for l in lecture_list["lectures"]:
            for t, v in l.items():
                if t == "offsets":
                    self.lecture_offsets = v
                elif t == "skip":
                    self.skipped_lectures = v
                else:
                    print("{prog}: warning: ignored unknown lecture key "
                          "'{key}'.".format(prog=PROG, key=t))

    # turn this into a generator?
    def generate_calendar(self, period):
        result = {}
        week_num = 0
        break_num = 0
        for w in self.period_weeks[period]:
            if isinstance(w, (TeachingWeek, IsoWeek)):
                # Increment first so that break weeks have the
                # same week number as the preceding teaching week.
                # This ensures the keys are always chronologically
                # sorted. Reset the break number for each new
                # teaching week.
                week_num += 1
                break_num = 0
                result[week_num] = w
                # if period == "ISO":
                # print("week ", week_num, " ", w)
            elif isinstance(w, BreakWeek):
                # Allow for up to 99 consecutive break weeks,
                # which should be sufficient :). Should probably
                # throw an exception if we exceed that.
                break_num += 0.01
                result[week_num + break_num] = w
        return result

    # turn this into a generator?
    def lecture_dates(self):
        dates = {}
        lecture_num = 1
        teaching_weeks = [t for t in self.calendars[self.config.period].values() if isinstance(t, TeachingWeek)]
        for week_index, monday in enumerate(teaching_weeks):
            for offset_index, offset in enumerate(self.lecture_offsets):
                lec = week_index * 2 + offset_index + 1
                if lec in self.skipped_lectures:
                    continue
                dates[lecture_num] = monday + datetime.timedelta(offset)
                lecture_num += 1
        return dates

    def render_latex(self, weeks):
        env = jinja2.Environment(
            block_start_string="\\BLOCK{",
            block_end_string="}",
            variable_start_string="\\VAR{",
            variable_end_string="}",
            comment_start_string="\\#{",
            comment_end_string="}",
            line_statement_prefix="%%",
            line_comment_prefix="%#",
            trim_blocks=True,
            autoescape=False,
            loader=jinja2.PackageLoader("teachingdates", "templates"))
        env.filters.update(filters)
        template = env.get_template(
            "{style}.tex.j2".format(style=self.config.style))
        return template.render(
            weeks=weeks,
            paper=self.config.paper,
            period=self.config.period,
            year=self.config.year,
            eow_offset=datetime.timedelta(self.config.end_of_week))

    def render_text(self, weeks):
        env = jinja2.Environment(
            loader=jinja2.PackageLoader("teachingdates", "templates"),
            autoescape=False)
        env.filters.update(filters)
        template = env.get_template(
            "{style}.txt.j2".format(style=self.config.style))
        return template.render(
            weeks=weeks,
            paper=self.config.paper,
            period=self.config.period,
            year=self.config.year,
            eow_offset=datetime.timedelta(self.config.end_of_week))

    def render_xml(self):
        env = jinja2.Environment(
            loader=jinja2.PackageLoader("teachingdates", "templates"),
            autoescape=jinja2.select_autoescape(["xml"]))
        env.filters.update(filters)
        template = env.get_template("paper-calendar-dates.xml.j2")
        return template.render(
            calendars=self.calendars,
            eow_offset=datetime.timedelta(self.config.end_of_week))

    def render(self, style, fmt):
        if self.config.style == "lecture":
            weeks = self.lecture_dates()
        else:
            weeks = self.calendars[self.config.period]
        
        if fmt == "latex":
            return(self.render_latex(weeks))
        elif fmt == "text":
            return(self.render_text(weeks))
        elif fmt == "xml":
            return(self.render_xml())
        else:
            return None
                 self.mondays[-1].isocalendar()[1] # last ISO week
             ]}])
         self.calendars["iso"] = self.generate_calendar("iso")
+        self.lecture_offsets = []
+        self.skipped_lectures = []
+        self.class_offsets = []
+        self.skipped_classes = []
         if self.config.paper:
+            self.update_lectures(self.config.get_paper_config(self.config.paper))
+            self.update_classes(
+                self.config.get_paper_config(self.config.paper),
+                class_type=self.config.style + "s"
+            )
     def make_week(self, week_type, start, end=None):
         end = start if end is None else end
         return [
                     print("{prog}: warning: ignored unknown week type "
                           "'{type}'.".format(prog=PROG, type=t))
         return weeks
+    def update_lectures(self, lecture_list):
+        for l in lecture_list["lectures"]:
+    def update_classes(self, class_list, class_type="lectures"):
+        for l in class_list[class_type]:
             for t, v in l.items():
                 if t == "offsets":
+                    self.lecture_offsets = v
+                    self.class_offsets = v
                 elif t == "skip":
+                    self.skipped_lectures = v
+                    self.skipped_classes = v
                 else:
+                    print("{prog}: warning: ignored unknown lecture key "
+                          "'{key}'.".format(prog=PROG, key=t))
+                    print("{prog}: warning: ignored unknown {type} key "
+                          "'{key}'.".format(
+                              prog=PROG,
+                              type=class_type[:-1],
+                              key=t))
     # turn this into a generator?
     def generate_calendar(self, period):
         result = {}
                 result[week_num + break_num] = w
         return result
     # turn this into a generator?
+    def lecture_dates(self):
+    def class_dates(self):
         dates = {}
+        lecture_num = 1
+        class_num = 1
         teaching_weeks = [t for t in self.calendars[self.config.period].values() if isinstance(t, TeachingWeek)]
         for week_index, monday in enumerate(teaching_weeks):
+            for offset_index, offset in enumerate(self.lecture_offsets):
+                lec = week_index * 2 + offset_index + 1
+                if lec in self.skipped_lectures:
+            for offset_index, offset in enumerate(self.class_offsets):
+                cls = week_index * 2 + offset_index + 1
+                if cls in self.skipped_classes:
                     continue
+                dates[lecture_num] = monday + datetime.timedelta(offset)
+                lecture_num += 1
+                dates[class_num] = monday + datetime.timedelta(offset)
+                class_num += 1
         return dates
     def render_latex(self, weeks):
         env = jinja2.Environment(
             calendars=self.calendars,
             eow_offset=datetime.timedelta(self.config.end_of_week))
     def render(self, style, fmt):
+        if self.config.style == "lecture":
+            weeks = self.lecture_dates()
+        if self.config.style in ["lecture", "lab"]:
+            weeks = self.class_dates()
         else:
             weeks = self.calendars[self.config.period]
         if fmt == "latex":

                Ignore Space
               Show notes
              View
            
          
          10 ■■■■■
          calendar/teachingdates/config/cli.py
+        "c": "calendar",
        "calendar": "calendar",
        "l": "lecture",
        "lecture": "lecture",
        "p": "lab",
        "lab": "lab",
        "i": "iso",
        "iso": "iso",
    }
 
    parser.add_argument(
        "--style",
        "-s",
        default="calendar",
        choices=["calendar", "c", "lecture", "l", "iso", "i"],
        choices=["calendar", "c", "lecture", "l", "lab", "p", "iso", "i"],
        help="output style: 'calendar' for teaching calendars in course "
        "outlines, 'lecture' for individual lecture dates, or 'iso'"
        "for dates across the entire ISO-8601 year [default 'calendar']")
            "outlines, 'lecture'/'lab' for individual lecture/lab dates, "
            "or 'iso' for dates across the entire ISO-8601 year [default "
            "'calendar']")
 
    parser.add_argument("--teaching-period",
                        "-t",
                        default=None,

            import argparse
import datetime

from teachingdates import PROG


def oxford_comma_list(words):
    if isinstance(words, list) or isinstance(words, tuple):
        if len(words) == 0:
            return ""
        elif len(words) == 1:
            return words[0]
        elif len(words) == 2:
            return " and ".join(words)
        else:
            return ", ".join(words[:-1]) + ", and " + words[-1]
    else:
        raise TypeError("expected list, got {t}".format(t=str(type(words))))


def switch_message(switches, context, severity="warning", required=False):
    switch_string = oxford_comma_list(switches)
    return ("{prog}: {severity}: {switches} {verb} {required} for "
            "{context}".format(prog=PROG,
                               severity=severity,
                               switches=switch_string,
                               verb="are" if len(switches) > 1 else "is",
                               required="required" if required else "ignored",
                               context=context))


def parse_command_line():
    """Parse command-line arguments.

    Example command lines:
    generate_dates --style calendar --format latex --year 2020 --period S1 --paper INFO201
    generate_dates --style lecture --format xml --period S2 --paper INFO202
    """
    format_map = {
        "t": "text",
        "text": "text",
        "l": "latex",
        "latex": "latex",
        "x": "xml",
        "xml": "xml",
    }
    style_map = {
        "c": "calendar",
        "calendar": "calendar",
        "l": "lecture",
        "lecture": "lecture",
        "p": "lab",
        "lab": "lab",
        "i": "iso",
        "iso": "iso",
    }

    parser = argparse.ArgumentParser(prog=PROG, description="")

    parser.add_argument(
        "--config",
        "-c",
        default=None,
        dest="config_file",
        help="file name of the configuration file "
        "[default '~/.config/{prog}/config.yml']".format(prog=PROG))

    parser.add_argument("--debug",
                        "-d",
                        action='store_true',
                        help="enable debugging output")

    parser.add_argument(
        "--end-of-week",
        "-e",
        type=int,
        default=None,
        help="offset to end of week from Monday (= 0) [default 4 (= Friday)]")

    parser.add_argument("--format",
                        "-f",
                        default="latex",
                        choices=["text", "t", "latex", "l", "xml", "x"],
                        help="output format [default 'latex']")

    parser.add_argument("--output",
                        "-o",
                        type=argparse.FileType("w", encoding="UTF-8"),
                        help="file name to write the output to; existing "
                        "files of the same name will be overwritten!")

    parser.add_argument(
        "--paper",
        "-p",
        default=None,
        help="paper code (e.g., INFO201) [required for 'lecture' style, "
        "ignored otherwise]")

    parser.add_argument(
        "--style",
        "-s",
        default="calendar",
        choices=["calendar", "c", "lecture", "l", "lab", "p", "iso", "i"],
        help="output style: 'calendar' for teaching calendars in course "
            "outlines, 'lecture'/'lab' for individual lecture/lab dates, "
            "or 'iso' for dates across the entire ISO-8601 year [default "
            "'calendar']")

    parser.add_argument("--teaching-period",
                        "-t",
                        default=None,
                        choices=["SS", "S1", "S2", "FY"],
                        dest="period",
                        help="teaching period [required]")

    parser.add_argument(
        "--year",
        "-y",
        type=int,
        default=datetime.date.today().year,
        help="the year to generate dates for [default {y}]".format(
            y=datetime.date.today().year))

    args = parser.parse_args()
    # normalise format and style
    args.format = format_map[args.format]
    args.style = style_map[args.style]

    if args.style == "calendar":
        # --paper is irrelevant
        if args.paper:
            args.paper = ""
            print("{prog}: warning: --paper/-p is ignored for 'calendar' "
                  "style".format(prog=PROG))
        # --teaching-period is required
        if not args.period:
            parser.exit(
                2, "{prog}: error: --teaching-period/-t is required for "
                "'calendar' style\n".format(prog=PROG))

    elif args.style == "iso":
        # both --paper and --teaching-period are irrelevant
        if args.paper or args.period:
            args.paper = ""
            args.period = "iso"
            print("{prog}: warning: --paper/-p and --teaching-period/-t are "
                  "ignored for 'iso' style".format(prog=PROG))

    elif args.style == "lecture":
        # --end-of-week is irrelevant
        if args.end_of_week is not None:
            args.end_of_week = None
            print("{prog}: warning: --end-of-week/-e is ignored for 'lecture' "
                  "style".format(prog=PROG))
        # both --paper and --teaching-period are required
        if not args.paper:
            parser.exit(
                2,
                message="{prog}: error: -paper/-p and --teaching-period/-t "
                "are required for 'lecture' style\n".format(prog=PROG))

    else:
        pass

    # Can't set default week offset until after error processing above,
    # otherwise it generates a spurious warning in 'lecture' style.
    if args.end_of_week is None:
        args.end_of_week = 4

    return args

            import argparse
import datetime

from teachingdates import PROG


def oxford_comma_list(words):
    if isinstance(words, list) or isinstance(words, tuple):
        if len(words) == 0:
            return ""
        elif len(words) == 1:
            return words[0]
        elif len(words) == 2:
            return " and ".join(words)
        else:
            return ", ".join(words[:-1]) + ", and " + words[-1]
    else:
        raise TypeError("expected list, got {t}".format(t=str(type(words))))


def switch_message(switches, context, severity="warning", required=False):
    switch_string = oxford_comma_list(switches)
    return ("{prog}: {severity}: {switches} {verb} {required} for "
            "{context}".format(prog=PROG,
                               severity=severity,
                               switches=switch_string,
                               verb="are" if len(switches) > 1 else "is",
                               required="required" if required else "ignored",
                               context=context))


def parse_command_line():
    """Parse command-line arguments.

    Example command lines:
    generate_dates --style calendar --format latex --year 2020 --period S1 --paper INFO201
    generate_dates --style lecture --format xml --period S2 --paper INFO202
    """
    format_map = {
        "t": "text",
        "text": "text",
        "l": "latex",
        "latex": "latex",
        "x": "xml",
        "xml": "xml",
    }
    style_map = {
        "c": "calendar",
        "calendar": "calendar",
        "l": "lecture",
        "lecture": "lecture",
        "i": "iso",
        "iso": "iso",
    }

    parser = argparse.ArgumentParser(prog=PROG, description="")

    parser.add_argument(
        "--config",
        "-c",
        default=None,
        dest="config_file",
        help="file name of the configuration file "
        "[default '~/.config/{prog}/config.yml']".format(prog=PROG))

    parser.add_argument("--debug",
                        "-d",
                        action='store_true',
                        help="enable debugging output")

    parser.add_argument(
        "--end-of-week",
        "-e",
        type=int,
        default=None,
        help="offset to end of week from Monday (= 0) [default 4 (= Friday)]")

    parser.add_argument("--format",
                        "-f",
                        default="latex",
                        choices=["text", "t", "latex", "l", "xml", "x"],
                        help="output format [default 'latex']")

    parser.add_argument("--output",
                        "-o",
                        type=argparse.FileType("w", encoding="UTF-8"),
                        help="file name to write the output to; existing "
                        "files of the same name will be overwritten!")

    parser.add_argument(
        "--paper",
        "-p",
        default=None,
        help="paper code (e.g., INFO201) [required for 'lecture' style, "
        "ignored otherwise]")

    parser.add_argument(
        "--style",
        "-s",
        default="calendar",
        choices=["calendar", "c", "lecture", "l", "iso", "i"],
        help="output style: 'calendar' for teaching calendars in course "
        "outlines, 'lecture' for individual lecture dates, or 'iso'"
        "for dates across the entire ISO-8601 year [default 'calendar']")

    parser.add_argument("--teaching-period",
                        "-t",
                        default=None,
                        choices=["SS", "S1", "S2", "FY"],
                        dest="period",
                        help="teaching period [required]")

    parser.add_argument(
        "--year",
        "-y",
        type=int,
        default=datetime.date.today().year,
        help="the year to generate dates for [default {y}]".format(
            y=datetime.date.today().year))

    args = parser.parse_args()
    # normalise format and style
    args.format = format_map[args.format]
    args.style = style_map[args.style]

    if args.style == "calendar":
        # --paper is irrelevant
        if args.paper:
            args.paper = ""
            print("{prog}: warning: --paper/-p is ignored for 'calendar' "
                  "style".format(prog=PROG))
        # --teaching-period is required
        if not args.period:
            parser.exit(
                2, "{prog}: error: --teaching-period/-t is required for "
                "'calendar' style\n".format(prog=PROG))

    elif args.style == "iso":
        # both --paper and --teaching-period are irrelevant
        if args.paper or args.period:
            args.paper = ""
            args.period = "iso"
            print("{prog}: warning: --paper/-p and --teaching-period/-t are "
                  "ignored for 'iso' style".format(prog=PROG))

    elif args.style == "lecture":
        # --end-of-week is irrelevant
        if args.end_of_week is not None:
            args.end_of_week = None
            print("{prog}: warning: --end-of-week/-e is ignored for 'lecture' "
                  "style".format(prog=PROG))
        # both --paper and --teaching-period are required
        if not args.paper:
            parser.exit(
                2,
                message="{prog}: error: -paper/-p and --teaching-period/-t "
                "are required for 'lecture' style\n".format(prog=PROG))

    else:
        pass

    # Can't set default week offset until after error processing above,
    # otherwise it generates a spurious warning in 'lecture' style.
    if args.end_of_week is None:
        args.end_of_week = 4

    return args
         "c": "calendar",
         "calendar": "calendar",
         "l": "lecture",
         "lecture": "lecture",
+        "p": "lab",
+        "lab": "lab",
         "i": "iso",
         "iso": "iso",
     }
     parser.add_argument(
         "--style",
         "-s",
         default="calendar",
+        choices=["calendar", "c", "lecture", "l", "iso", "i"],
+        choices=["calendar", "c", "lecture", "l", "lab", "p", "iso", "i"],
         help="output style: 'calendar' for teaching calendars in course "
+        "outlines, 'lecture' for individual lecture dates, or 'iso'"
+        "for dates across the entire ISO-8601 year [default 'calendar']")
+            "outlines, 'lecture'/'lab' for individual lecture/lab dates, "
+            "or 'iso' for dates across the entire ISO-8601 year [default "
+            "'calendar']")
     parser.add_argument("--teaching-period",
                         "-t",
                         default=None,

Ignore Space Show notes View calendar/teachingdates/config/config.py
import datetime import importlib.resources as pkg_resources from pathlib import Path from shutil import copyfile import yaml from teachingdates import PROG from .errors import (ConfigurationError, PaperError, PaperKeyError, PeriodError, PeriodKeyError) CONFIG_FILENAME = "config.yml" CONFIG_DIR = Path.home().joinpath(".config", PROG) CONFIG_FILE = CONFIG_DIR.joinpath(CONFIG_FILENAME) class Configuration(object): """Validate and structure the configuration for easy access. Includes methods to return the period configuration and the paper configuration, as applicable. (Yes, the period configuration includes the paper configuration, but it may also include other papers, so it's more convenient to return these separately.) The configuration file will normally contain specifications for several teaching periods and papers. We don't need all of this: usually we're only interested in one teaching period and one paper (if relevant). """ def __init__(self, args): self.load_config(file=args.config_file) self.style = args.style self.period = args.period self.paper = args.paper self.end_of_week = args.end_of_week # priority: year on command line (defaults to current year), # year in config self.year = (self.config["year"] if "year" in self.config.keys() else args.year) period_config = paper_config = None if self.style != "iso": if self.period not in self.config.keys(): raise PeriodError(str(self.config_file)) period_config = self.config[self.period] # the "name" and "weeks" keys are required for key in ["name", "weeks"]: if key not in period_config.keys(): raise PeriodKeyError(key, self.period, self.config_file) self.period_name = period_config["name"] # Papers are only relevant in "lecture" and "lab" styles, # which by definition must specify a paper. try: if self.style in ["lecture", "lab"]: key = self.style + "s" if ("papers" in period_config.keys() and self.paper in period_config["papers"].keys()): paper_config = period_config["papers"][self.paper] # we expect at least a "lectures" entry if (not paper_config or key not in paper_config.keys()): raise PaperKeyError( key, self.paper, self.config_file) else: raise PaperError(str(self.config_file)) except AttributeError as e: raise PaperError(str(self.config_file)) def load_config(self, file=None): """Load a configuration file. If no file is specified, try the default configuration in ~/.config. If that doesn't exist, copy the default configuration from teachingdates.config. """ cfg = None if not file: file = CONFIG_FILE if not CONFIG_FILE.exists(): CONFIG_DIR.mkdir(exist_ok=True) configmgr = pkg_resources.path("teachingdates.config", CONFIG_FILENAME) with configmgr as f: copyfile(f, CONFIG_FILE) print("{prog}: created new configuration file at " "'{f}'".format(prog=PROG, f=str(CONFIG_FILE))) try: with open(file) as f: cfg = yaml.safe_load(f.read()) except FileNotFoundError as e: print("{prog}: error: no such file '{file}'".format(prog=PROG, file=file)) if not cfg: raise ConfigurationError(str(file)) self.config_file = file self.config = cfg def get_period_config(self, period=None): """Get the configuration details for a teaching period. No need to specify the year as all configurations are for a single year anyway. """ period = self.period if period is None else period if period in self.config.keys(): return self.config[period] else: return None def get_paper_config(self, paper=None, period=None): """Get the configuration details for a paper. Can optionally specify the teaching period. No need to specify the year as all configurations are for a single year anyway. """ paper = self.paper if paper is None else paper period_config = self.get_period_config(period=period) if (period_config and "papers" in period_config.keys() and paper in period_config["papers"].keys()): return period_config["papers"][paper] else: return None def get_config_keys(self): return self.config.keys() import datetime import importlib.resources as pkg_resources from pathlib import Path from shutil import copyfile import yaml from teachingdates import PROG from .errors import (ConfigurationError, PaperError, PaperKeyError, PeriodError, PeriodKeyError) CONFIG_FILENAME = "config.yml" CONFIG_DIR = Path.home().joinpath(".config", PROG) CONFIG_FILE = CONFIG_DIR.joinpath(CONFIG_FILENAME) class Configuration(object): """Validate and structure the configuration for easy access. Includes methods to return the period configuration and the paper configuration, as applicable. (Yes, the period configuration includes the paper configuration, but it may also include other papers, so it's more convenient to return these separately.) The configuration file will normally contain specifications for several teaching periods and papers. We don't need all of this: usually we're only interested in one teaching period and one paper (if relevant). """ def __init__(self, args): self.load_config(file=args.config_file) self.style = args.style self.period = args.period self.paper = args.paper self.end_of_week = args.end_of_week # priority: year on command line (defaults to current year), # year in config self.year = (self.config["year"] if "year" in self.config.keys() else args.year) period_config = paper_config = None if self.style != "iso": if self.period not in self.config.keys(): raise PeriodError(str(self.config_file)) period_config = self.config[self.period] # the "name" and "weeks" keys are required for key in ["name", "weeks"]: if key not in period_config.keys(): raise PeriodKeyError(key, self.period, self.config_file) self.period_name = period_config["name"] # Papers are only relevant in "lecture" style, which by definition # must specify a paper. try: if self.style == "lecture": if ("papers" in period_config.keys() and self.paper in period_config["papers"].keys()): paper_config = period_config["papers"][self.paper] # we expect at least a "lectures" entry if (not paper_config or "lectures" not in paper_config.keys()): raise PaperKeyError("lectures", self.paper, self.config_file) else: raise PaperError(str(self.config_file)) except AttributeError as e: raise PaperError(str(self.config_file)) def load_config(self, file=None): """Load a configuration file. If no file is specified, try the default configuration in ~/.config. If that doesn't exist, copy the default configuration from teachingdates.config. """ cfg = None if not file: file = CONFIG_FILE if not CONFIG_FILE.exists(): CONFIG_DIR.mkdir(exist_ok=True) configmgr = pkg_resources.path("teachingdates.config", CONFIG_FILENAME) with configmgr as f: copyfile(f, CONFIG_FILE) print("{prog}: created new configuration file at " "'{f}'".format(prog=PROG, f=str(CONFIG_FILE))) try: with open(file) as f: cfg = yaml.safe_load(f.read()) except FileNotFoundError as e: print("{prog}: error: no such file '{file}'".format(prog=PROG, file=file)) if not cfg: raise ConfigurationError(str(file)) self.config_file = file self.config = cfg def get_period_config(self, period=None): """Get the configuration details for a teaching period. No need to specify the year as all configurations are for a single year anyway. """ period = self.period if period is None else period if period in self.config.keys(): return self.config[period] else: return None def get_paper_config(self, paper=None, period=None): """Get the configuration details for a paper. Can optionally specify the teaching period. No need to specify the year as all configurations are for a single year anyway. """ paper = self.paper if paper is None else paper period_config = self.get_period_config(period=period) if (period_config and "papers" in period_config.keys() and paper in period_config["papers"].keys()): return period_config["papers"][paper] else: return None def get_config_keys(self): return self.config.keys()

Ignore Space Show notes View

calendar/teachingdates/config/config.py

import datetime
import importlib.resources as pkg_resources
from pathlib import Path
from shutil import copyfile

import yaml

from teachingdates import PROG

from .errors import (ConfigurationError, PaperError, PaperKeyError,
                     PeriodError, PeriodKeyError)

CONFIG_FILENAME = "config.yml"
CONFIG_DIR = Path.home().joinpath(".config", PROG)
CONFIG_FILE = CONFIG_DIR.joinpath(CONFIG_FILENAME)

class Configuration(object):
    """Validate and structure the configuration for easy access.

Includes methods to return the period configuration and the paper
    configuration, as applicable. (Yes, the period configuration
    includes the paper configuration, but it may also include other
    papers, so it's more convenient to return these separately.)

The configuration file will normally contain specifications for
    several teaching periods and papers. We don't need all of this:
    usually we're only interested in one teaching period and one
    paper (if relevant).
    """

def __init__(self, args):
        self.load_config(file=args.config_file)
        self.style = args.style
        self.period = args.period
        self.paper = args.paper
        self.end_of_week = args.end_of_week
        # priority: year on command line (defaults to current year),
        # year in config
        self.year = (self.config["year"]
                     if "year" in self.config.keys() else args.year)

period_config = paper_config = None
        if self.style != "iso":
            if self.period not in self.config.keys():
                raise PeriodError(str(self.config_file))

period_config = self.config[self.period]
            # the "name" and "weeks" keys are required
            for key in ["name", "weeks"]:
                if key not in period_config.keys():
                    raise PeriodKeyError(key, self.period, self.config_file)
            self.period_name = period_config["name"]

# Papers are only relevant in "lecture" and "lab" styles,
            # which by definition must specify a paper.
            try:
                if self.style in ["lecture", "lab"]:
                    key = self.style + "s"
                    if ("papers" in period_config.keys()
                            and self.paper in period_config["papers"].keys()):
                        paper_config = period_config["papers"][self.paper]
                        # we expect at least a "lectures" entry
                        if (not paper_config
                                or key not in paper_config.keys()):
                            raise PaperKeyError(
                                key, self.paper, self.config_file)
                    else:
                        raise PaperError(str(self.config_file))
            except AttributeError as e:
                raise PaperError(str(self.config_file))

def load_config(self, file=None):
        """Load a configuration file.

If no file is specified, try the default configuration in
        ~/.config. If that doesn't exist, copy the default configuration
        from teachingdates.config.
        """
        cfg = None
        if not file:
            file = CONFIG_FILE
            if not CONFIG_FILE.exists():
                CONFIG_DIR.mkdir(exist_ok=True)
                configmgr = pkg_resources.path("teachingdates.config",
                                               CONFIG_FILENAME)
                with configmgr as f:
                    copyfile(f, CONFIG_FILE)
                    print("{prog}: created new configuration file at "
                          "'{f}'".format(prog=PROG, f=str(CONFIG_FILE)))
        try:
            with open(file) as f:
                cfg = yaml.safe_load(f.read())
        except FileNotFoundError as e:
            print("{prog}: error: no such file '{file}'".format(prog=PROG,
                                                             file=file))
        if not cfg:
            raise ConfigurationError(str(file))
        self.config_file = file
        self.config = cfg

def get_period_config(self, period=None):
        """Get the configuration details for a teaching period.

No need to specify the year as all configurations are for a
        single year anyway.
        """
        period = self.period if period is None else period
        if period in self.config.keys():
            return self.config[period]
        else:
            return None

def get_paper_config(self, paper=None, period=None):
        """Get the configuration details for a paper.

Can optionally specify the teaching period. No need to specify
        the year as all configurations are for a single year anyway.
        """
        paper = self.paper if paper is None else paper
        period_config = self.get_period_config(period=period)
        if (period_config and "papers" in period_config.keys()
                and paper in period_config["papers"].keys()):
            return period_config["papers"][paper]
        else:
            return None

def get_config_keys(self):
        return self.config.keys()

import datetime
import importlib.resources as pkg_resources
from pathlib import Path
from shutil import copyfile

import yaml

from teachingdates import PROG

from .errors import (ConfigurationError, PaperError, PaperKeyError,
                     PeriodError, PeriodKeyError)

CONFIG_FILENAME = "config.yml"
CONFIG_DIR = Path.home().joinpath(".config", PROG)
CONFIG_FILE = CONFIG_DIR.joinpath(CONFIG_FILENAME)

class Configuration(object):
    """Validate and structure the configuration for easy access.

period_config = paper_config = None
        if self.style != "iso":
            if self.period not in self.config.keys():
                raise PeriodError(str(self.config_file))

# Papers are only relevant in "lecture" style, which by definition
            # must specify a paper.
            try:
                if self.style == "lecture":
                    if ("papers" in period_config.keys()
                            and self.paper in period_config["papers"].keys()):
                        paper_config = period_config["papers"][self.paper]
                        # we expect at least a "lectures" entry
                        if (not paper_config
                                or "lectures" not in paper_config.keys()):
                            raise PaperKeyError("lectures", self.paper,
                                                self.config_file)
                    else:
                        raise PaperError(str(self.config_file))
            except AttributeError as e:
                raise PaperError(str(self.config_file))

def load_config(self, file=None):
        """Load a configuration file.

def get_period_config(self, period=None):
        """Get the configuration details for a teaching period.

def get_paper_config(self, paper=None, period=None):
        """Get the configuration details for a paper.

def get_config_keys(self):
        return self.config.keys()

Ignore Space Show notes View calendar/teachingdates/config/config.yml
SS: name: "Summer School" weeks: - teach: [2, 7] S1: name: "First Semester" weeks: - teach: [9, 15] - break: [16, 16] - teach: [17, 22] papers: COMP101: lectures: - offsets: [0, 2] - skip: [17] INFO201: lectures: - offsets: [1, 3] INFO303: lectures: - offsets: [2, 4] - skip: [14] INFO408: lectures: - offsets: [3] labs: - offsets: [3] S2: name: "Second Semester" weeks: - teach: [28, 34] - break: [35, 35] - teach: [36, 41] papers: INFO202: lectures: - offsets: [1, 2] FY: name: "Full Year" weeks: - teach: [9, 15] - break: [16, 16] - teach: [17, 22] - break: [23, 27] - teach: [28, 34] - break: [35, 35] - teach: [36, 41] SS: name: "Summer School" weeks: - teach: [2, 7] S1: name: "First Semester" weeks: - teach: [9, 15] - break: [16, 16] - teach: [17, 22] papers: COMP101: lectures: - offsets: [0, 2] - skip: [17] INFO201: lectures: - offsets: [1, 3] INFO303: lectures: - offsets: [2, 4] - skip: [14] INFO408: lectures: - offsets: [3] S2: name: "Second Semester" weeks: - teach: [28, 34] - break: [35, 35] - teach: [36, 41] papers: INFO202: lectures: - offsets: [1, 2] FY: name: "Full Year" weeks: - teach: [9, 15] - break: [16, 16] - teach: [17, 22] - break: [23, 27] - teach: [28, 34] - break: [35, 35] - teach: [36, 41]

Ignore Space Show notes View

calendar/teachingdates/config/config.yml

Ignore Space Show notes View calendar/teachingdates/templates/lab.tex.j2 0 → 100644
% Lab dates for \VAR{paper} \VAR{period} \VAR{year}. \newcount\lecnum \newcount\weeknum \newcommand{\LabDate}[1]{% \lecnum #1\relax% \advance\lecnum by -1\relax% \ifcase\lecnum% \BLOCK{for lab, date in weeks.items()} \BLOCK{if not loop.first}\or \BLOCK{endif -} \VAR{date.day} \VAR{date.strftime("%B")}% lab \VAR{lab} \BLOCK{endfor} \else ????% \fi% } \newcommand{\LabDateByWeek}[2]{% \weeknum #1\relax% \advance\weeknum by -1\relax% \multiply\weeknum by 2\relax% \advance\weeknum by #2\relax% \LabDate{\the\weeknum}% }

Ignore Space Show notes View

calendar/teachingdates/templates/lab.tex.j2 0 → 100644

Ignore Space Show notes View calendar/teachingdates/templates/lab.txt.j2 0 → 100644
# Lab dates for {{ paper }} {{ period }} {{ year }} {%- for lab, date in weeks.items() %} Lab {{ lab\|pad(2) }}: {{ date.isoformat() }} {%- endfor %}

Show line notes below