Fully implemented --end-of-week/-e switch

nigel.stanger / Handbook

Browse code Fully implemented --end-of-week/-e switch (was --week-offset/-w) master
1 parent 4157be1 commit ac0bb75fcb3c32f94a807588deec703cecabafdc Nigel Stanger authored on 1 Dec 2019

Patch

Showing 5 changed files

Ignore Space Show notes View calendar/teachingdates/calendars/basecalendar.py
import calendar import datetime import jinja2 from teachingdates import PROG from .errors import TemplateStyleError from .weeks import BreakWeek, IsoWeek, TeachingWeek suffix_map = { "latex": "tex", "text": "txt", "xml": "xml", } 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. """ weeks = [] lecture_offsets = [] skipped_lectures = [] mondays = [] period = None paper = None end_of_week = None year = datetime.date.today().year env = jinja2.Environment( loader=jinja2.PackageLoader("teachingdates", "templates"), autoescape=jinja2.select_autoescape(["html", "xml"])) def __init__(self, year, period, paper, end_of_week=None, period_config=None, paper_config=None): self.year = year self.period = period self.paper = paper self.end_of_week = end_of_week self.env.filters.update({ "isteaching": lambda w: isinstance(w, TeachingWeek), "isbreak": lambda w: isinstance(w, BreakWeek), "eow": lambda d: d + datetime.timedelta(days=self.end_of_week), "pad": lambda s, n: str(s).rjust(n) }) # This is likely to end up with one week too many at the end, # but that doesn't matter as there will never be any teaching # during the last week of December! cal = calendar.Calendar().yeardatescalendar(self.year, width=12) self.mondays = [week[0] for month in cal[0] for week in month] self.mondays = list(dict.fromkeys(self.mondays)) if period_config: self.update_weeks(period_config["weeks"]) else: last_week = datetime.date(self.year, 12, 28).isocalendar()[1] self.update_weeks([{"iso": [1, last_week]}]) if paper_config: self.update_lectures(paper_config["lectures"]) @classmethod def from_configuration(cls, config): if config: return cls(config.year, config.period, config.paper, config.end_of_week, config.get_period_config(), config.get_paper_config()) else: return None 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 teaching_date(self, period, week, offset=0): pass def update_weeks(self, week_list): for w in week_list: for t, r in w.items(): if t == "teach": self.weeks += self.make_week(TeachingWeek, r[0], r[1]) elif t == "break": self.weeks += self.make_week(BreakWeek, r[0], r[1]) elif t == "iso": self.weeks += self.make_week(IsoWeek, r[0], r[1]) else: print("{prog}: warning: ignored unknown week type " "'{type}'.".format(prog=PROG, type=t)) def update_lectures(self, lecture_list): for l in lecture_list: 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 calendar(self): period = {} week_num = break_num = 0 for w in self.weeks: 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 period[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 period[week_num + break_num] = w return period # turn this into a generator? def lecture_dates(self): dates = {} lecture_num = 1 teaching_weeks = [t for t in self.weeks 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(self, style, fmt): suffix = suffix_map[fmt] template = self.env.get_template("{style}.{suffix}.j2".format( style=style, suffix=suffix)) if style in ["calendar", "iso"]: data = self.calendar() elif style == "lecture": data = self.lecture_dates() else: pass return template.render(period=self.period, year=self.year, paper=self.paper, data=data) import calendar import datetime import jinja2 from teachingdates import PROG from .errors import TemplateStyleError from .weeks import BreakWeek, IsoWeek, TeachingWeek suffix_map = { "latex": "tex", "text": "txt", "xml": "xml", } 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. """ weeks = [] lecture_offsets = [] skipped_lectures = [] mondays = [] period = None paper = None year = datetime.date.today().year env = jinja2.Environment( loader=jinja2.PackageLoader("teachingdates", "templates"), autoescape=jinja2.select_autoescape(["html", "xml"])) def __init__(self, year, period, paper, period_config=None, paper_config=None): self.year = year self.period = period self.paper = paper self.env.filters.update({ "isteaching": lambda w: isinstance(w, TeachingWeek), "isbreak": lambda w: isinstance(w, BreakWeek), "nextfriday": lambda d: d + datetime.timedelta(days=4), "nextsunday": lambda d: d + datetime.timedelta(days=6), "pad": lambda s, n: str(s).rjust(n) }) # This is likely to end up with one week too many at the end, # but that doesn't matter as there will never be any teaching # during the last week of December! cal = calendar.Calendar().yeardatescalendar(self.year, width=12) self.mondays = [week[0] for month in cal[0] for week in month] self.mondays = list(dict.fromkeys(self.mondays)) if period_config: self.update_weeks(period_config["weeks"]) else: last_week = datetime.date(self.year, 12, 28).isocalendar()[1] self.update_weeks([{"iso": [1, last_week]}]) if paper_config: self.update_lectures(paper_config["lectures"]) @classmethod def from_configuration(cls, config): if config: return cls(config.year, config.period, config.paper, config.get_period_config(), config.get_paper_config()) else: return None 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 teaching_date(self, period, week, offset=0): pass def update_weeks(self, week_list): for w in week_list: for t, r in w.items(): if t == "teach": self.weeks += self.make_week(TeachingWeek, r[0], r[1]) elif t == "break": self.weeks += self.make_week(BreakWeek, r[0], r[1]) elif t == "iso": self.weeks += self.make_week(IsoWeek, r[0], r[1]) else: print("{prog}: warning: ignored unknown week type " "'{type}'.".format(prog=PROG, type=t)) def update_lectures(self, lecture_list): for l in lecture_list: 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 calendar(self): period = {} week_num = break_num = 0 for w in self.weeks: 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 period[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 period[week_num + break_num] = w return period # turn this into a generator? def lecture_dates(self): dates = {} lecture_num = 1 teaching_weeks = [t for t in self.weeks 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(self, style, fmt): suffix = suffix_map[fmt] template = self.env.get_template("{style}.{suffix}.j2".format( style=style, suffix=suffix)) if style in ["calendar", "iso"]: data = self.calendar() elif style == "lecture": data = self.lecture_dates() else: pass return template.render(period=self.period, year=self.year, paper=self.paper, data=data)

Ignore Space Show notes View

calendar/teachingdates/calendars/basecalendar.py

import calendar
import datetime

import jinja2

from teachingdates import PROG

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

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

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.
    """
    weeks = []
    lecture_offsets = []
    skipped_lectures = []
    mondays = []
    period = None
    paper = None
    end_of_week = None
    year = datetime.date.today().year
    env = jinja2.Environment(
        loader=jinja2.PackageLoader("teachingdates", "templates"),
        autoescape=jinja2.select_autoescape(["html", "xml"]))

def __init__(self,
                 year,
                 period,
                 paper,
                 end_of_week=None,
                 period_config=None,
                 paper_config=None):
        self.year = year
        self.period = period
        self.paper = paper
        self.end_of_week = end_of_week

self.env.filters.update({
            "isteaching": lambda w: isinstance(w, TeachingWeek),
            "isbreak": lambda w: isinstance(w, BreakWeek),
            "eow": lambda d: d + datetime.timedelta(days=self.end_of_week),
            "pad": lambda s, n: str(s).rjust(n)
        })

# This is likely to end up with one week too many at the end,
        # but that doesn't matter as there will never be any teaching
        # during the last week of December!
        cal = calendar.Calendar().yeardatescalendar(self.year, width=12)

self.mondays = [week[0] for month in cal[0] for week in month]
        self.mondays = list(dict.fromkeys(self.mondays))
        if period_config:
            self.update_weeks(period_config["weeks"])
        else:
            last_week = datetime.date(self.year, 12, 28).isocalendar()[1]
            self.update_weeks([{"iso": [1, last_week]}])
        if paper_config:
            self.update_lectures(paper_config["lectures"])

@classmethod
    def from_configuration(cls, config):
        if config:
            return cls(config.year, config.period, config.paper,
                       config.end_of_week, config.get_period_config(),
                       config.get_paper_config())
        else:
            return None

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 teaching_date(self, period, week, offset=0):
        pass

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

def update_lectures(self, lecture_list):
        for l in lecture_list:
            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 calendar(self):
        period = {}
        week_num = break_num = 0
        for w in self.weeks:
            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
                period[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
                period[week_num + break_num] = w
        return period

# turn this into a generator?
    def lecture_dates(self):
        dates = {}
        lecture_num = 1
        teaching_weeks = [t for t in self.weeks 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(self, style, fmt):
        suffix = suffix_map[fmt]
        template = self.env.get_template("{style}.{suffix}.j2".format(
            style=style, suffix=suffix))
        if style in ["calendar", "iso"]:
            data = self.calendar()
        elif style == "lecture":
            data = self.lecture_dates()
        else:
            pass
        return template.render(period=self.period,
                               year=self.year,
                               paper=self.paper,
                               data=data)

import calendar
import datetime

import jinja2

from teachingdates import PROG

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

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

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.
    """
    weeks = []
    lecture_offsets = []
    skipped_lectures = []
    mondays = []
    period = None
    paper = None
    year = datetime.date.today().year
    env = jinja2.Environment(
        loader=jinja2.PackageLoader("teachingdates", "templates"),
        autoescape=jinja2.select_autoescape(["html", "xml"]))

def __init__(self,
                 year,
                 period,
                 paper,
                 period_config=None,
                 paper_config=None):
        self.year = year
        self.period = period
        self.paper = paper

self.env.filters.update({
            "isteaching": lambda w: isinstance(w, TeachingWeek),
            "isbreak": lambda w: isinstance(w, BreakWeek),
            "nextfriday": lambda d: d + datetime.timedelta(days=4),
            "nextsunday": lambda d: d + datetime.timedelta(days=6),
            "pad": lambda s, n: str(s).rjust(n)
        })

@classmethod
    def from_configuration(cls, config):
        if config:
            return cls(config.year, config.period, config.paper,
                       config.get_period_config(), config.get_paper_config())
        else:
            return None

def teaching_date(self, period, week, offset=0):
        pass

Ignore Space Show notes View calendar/teachingdates/config/cli.py
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")) 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 = 0 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.style != "lecture" and 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")) 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("--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( "--week-offset", "-w", type=int, default=4, help="offset to end of week from Monday (where Monday = 0) " "[default 4 (= Friday)]" ) 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": # --week-offset is irrelevant if args.week_offset: args.week_offset = "" print("{prog}: warning: --week_offset/-w 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 return args

Ignore Space Show notes View

calendar/teachingdates/config/cli.py

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"))

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 = 0
            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.style != "lecture" and args.end_of_week is None:
        args.end_of_week = 4

return args

import argparse
import datetime

from teachingdates import PROG

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

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

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

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

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

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

elif args.style == "lecture":
        # --week-offset is irrelevant
        if args.week_offset:
            args.week_offset = ""
            print("{prog}: warning: --week_offset/-w 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

return args

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). """ style = None period = None paper = None year = None end_of_week = None config = None config_file = None 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) # 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, period=None, paper=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 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). """ style = None period = None paper = None year = None config = None config_file = None def __init__(self, args): self.load_config(file=args.config_file) self.style = args.style self.period = args.period self.paper = args.paper # 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) # 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, period=None, paper=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

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).
    """
    style = None
    period = None
    paper = None
    year = None
    end_of_week = None
    config = None
    config_file = None

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)

# 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, period=None, paper=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

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.

def __init__(self, args):
        self.load_config(file=args.config_file)
        self.style = args.style
        self.period = args.period
        self.paper = args.paper
        # 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))

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, period=None, paper=None):
        """Get the configuration details for a paper.

Ignore Space Show notes View calendar/teachingdates/templates/calendar.txt.j2
# Teaching calendar for {{ period }} {{ year }} {%- for week, date in data.items() %} {% if date\|isteaching %}Week {{ week\|pad(2) }}:{% elif date\|isbreak %}Break :{% else %}WTF???{% endif %} {{ date.isoformat() }} — {{ (date\|eow).isoformat() }} {%- endfor %} # Teaching calendar for {{ period }} {{ year }} {%- for week, date in data.items() %} {% if date\|isteaching %}Week {{ week\|pad(2) }}:{% elif date\|isbreak %}Break :{% else %}WTF???{% endif %} {{ date.isoformat() }} — {{ (date\|nextfriday).isoformat() }} {%- endfor %}

Ignore Space Show notes View

calendar/teachingdates/templates/calendar.txt.j2

Ignore Space Show notes View calendar/teachingdates/templates/iso.txt.j2
# ISO-8601 calendar weeks for {{ year }} {%- for week, date in data.items() %} Week {{ week\|pad(2) }}: {{ date.isoformat() }} — {{ (date\|eow).isoformat() }} {%- endfor %} # ISO-8601 calendar weeks for {{ year }} {%- for week, date in data.items() %} Week {{ week\|pad(2) }}: {{ date.isoformat() }} — {{ (date\|nextsunday).isoformat() }} {%- endfor %}

Show line notes below