uw-course 1.0.1__py3-none-any.whl → 2.0.0__py3-none-any.whl

uw_course/ClassSchedule/SearchInfo.py

@@ -1,5 +1,4 @@
 import re
-from ..Utiles.colorMessage import *
 
 
 class Course():
@@ -20,7 +19,7 @@ class Course():
             self.courseIndex = course['ClassIndex']
             self.courseTitle = course['classTitle']
             self.courseSeat = course['availableSeat']
-            if re.search("\d:\d*", self.time):
+            if re.search(r"\d:\d*", self.time):
                 self.startTime = self.time[0:5]
                 self.endTime = self.time[6:11]
                 StartTimeFlag = False
@@ -37,7 +36,7 @@ class Course():
                 self.weekDay = "H" if self.time[11:15] == "Th" else self.time[11:15]
                 self.writeSchedule()
             else:
-                print(WARNING + "Z_Z For course %s in class %s, Time Data Error Z_Z" % (self.courseIndex, self.classNum)+ENDC)
+                print("Z_Z For course %s in class %s, Time Data Error Z_Z" % (self.courseIndex, self.classNum))
 
     def writeSchedule(self):
         self.fileOut.write(

uw_course/ClassSchedule/runner.py

@@ -1,38 +1,49 @@
-from .SearchInfo import Course
-from ..Utiles.randomColor import randomColor, randomGray
-from ..setting import Setting
-from ..Utiles.colorMessage import *
+from uw_course.ClassSchedule.SearchInfo import Course
+from uw_course.Utiles.randomColor import randomColor, randomGray
+from uw_course.setting import Setting
 
 from os import remove
 
 setting = Setting()
 
 
-def SearchCourse(dbClassUW, courseIndex):
+def get_course_detail(dbClassUW, courseIndex):
     CourseDescribe = dbClassUW.CourseDescribe
+    if not courseIndex or " " not in courseIndex:
+        return None
     faculty = courseIndex.split(" ")[0]
     courseNum = courseIndex.split(" ")[1]
     FacultyList = CourseDescribe.find({"faculty": faculty})
     for course in FacultyList:
-        if course["courseIndex"] == courseNum:
-            print("\n" + "$" * 50 + "\n\n")
-            print("Description: ", end="")
-            print(course["courseDescription"])
-            print("\ncourseCredit: ", end="")
-            print(course["courseCredit"])
-            print("\n\n" + "$" * 50)
-            break
+        if course.get("courseIndex") == courseNum:
+            return course
+    return None
+
+
+def SearchCourse(dbClassUW, courseIndex):
+    course = get_course_detail(dbClassUW, courseIndex)
+    if not course:
+        print("@_@ Course %s Not Found @_@" % (courseIndex))
+        return
+    print("\n" + "$" * 50 + "\n\n")
+    print("Description: ", end="")
+    print(course.get("courseDescription"))
+    print("\ncourseCredit: ", end="")
+    print(course.get("courseCredit"))
+    print("\n\n" + "$" * 50)
     print("\n\n")
 
 
-def SearchAvalibleInTerm(dbClassUW, courseIndex, classNum=None):
+def SearchAvalibleInTerm(dbClassUW, courseIndex, classNum=None, quiet=False):
     ClassSchedule = dbClassUW.ClassSchedule
     courseSelect = ClassSchedule.find({"ClassIndex": courseIndex})
     if courseSelect == None:
-        print(FAIL + "@_@ Course %s Not Found in %s @_@" % (courseIndex, dbClassUW.ClassCollectionName) + ENDC)
+        if not quiet:
+            print("@_@ Course %s Not Found in %s @_@" % (courseIndex, dbClassUW.ClassCollectionName))
         return None
     else:
-        print(OKGREEN + "!! Found Course %s in %s !!" % (courseIndex, dbClassUW.ClassCollectionName) + ENDC)
+        if not quiet:
+            print("!! Found Course %s in %s !!" % (courseIndex, dbClassUW.ClassCollectionName))
         if classNum != None:
             return [courseIndex, classNum]
         return [courseIndex]
@@ -41,7 +52,7 @@ def SearchAvalibleInTerm(dbClassUW, courseIndex, classNum=None):
 def makeSchedule(dbClassUW, courseWishList: list, gray: bool=False):
     classSchedule = dbClassUW.ClassSchedule
     if gray:
-        print(OKGREEN + "!! Make Schedule with Gray Color !!" + ENDC)
+        print("!! Make Schedule with Gray Color !!")
     try:
         remove(setting.outDir)
     except:

uw_course/DB/dbClass.py

@@ -23,3 +23,23 @@ class dbClass:
         self.ClassCollectionName = collectionName
         self.ClassDATABASE.selectCollection(self.ClassCollectionName)
         self.ClassSchedule = self.ClassDATABASE.mongo_collection
+
+    def listClassCollections(self):
+        collections = self.ClassDATABASE.listCollections()
+        term_order = {"Winter": 0, "Spring": 1, "Fall": 2}
+
+        def sort_key(name):
+            if not name.startswith("Class"):
+                return (9999, 99, name)
+            tail = name[len("Class") :]
+            year = tail[:4]
+            term = tail[4:]
+            try:
+                year_value = int(year)
+            except ValueError:
+                year_value = 9999
+            term_value = term_order.get(term, 99)
+            return (year_value, term_value, name)
+
+        class_names = [name for name in collections if name.startswith("Class")]
+        return sorted(class_names, key=sort_key, reverse=True)

uw_course/Utiles/manageDBClass.py

@@ -16,5 +16,10 @@ class connectDB:
     def selectCollection(self, collection_name):
         self.mongo_collection = self.mongo_db[collection_name]
 
+    def listCollections(self):
+        if self.mongo_db is None:
+            return []
+        return self.mongo_db.list_collection_names()
+
     def closeDB(self):
         self.client.close()

uw_course/Utiles/randomColor.py

@@ -1,16 +1,28 @@
-from random import randint
+from random import choice
+
+_PALETTE = [
+    "#1F77B4",  # blue
+    "#FF7F0E",  # orange
+    "#2CA02C",  # green
+    "#D62728",  # red
+    "#9467BD",  # purple
+    "#8C564B",  # brown
+    "#E377C2",  # pink
+    "#7F7F7F",  # gray
+    "#BCBD22",  # olive
+    "#17BECF",  # cyan
+    "#4E79A7",  # blue
+    "#F28E2B",  # orange
+    "#59A14F",  # green
+    "#E15759",  # red
+    "#76B7B2",  # teal
+    "#EDC948",  # yellow
+]
 
 
 def randomColor():
-    colorArr = ['1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F']
-    color = ""
-    for i in range(6):
-        color += colorArr[randint(0, 14)]
-    return "#" + color
+    return choice(_PALETTE)
 
 
 def randomGray():
-    colorArr = ['1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F']
-    color = colorArr[randint(2, 12)]
-    color += colorArr[randint(0, 14)] 
-    return "#" + color + color + color
+    return "#9E9E9E"

uw_course/main.py

@@ -1,85 +1,16 @@
-from .DB.dbClass import dbClass
-from .ClassSchedule.runner import SearchCourse, makeSchedule, SearchAvalibleInTerm
-from .Utiles.colorMessage import *
-from .setting import Setting
-
-from os import system
-import argparse
+import os
 import sys
 
-dbClassUW = dbClass()
-setting = Setting()
-courseWishList = []
-
-url = "https://github.com/zangjiucheng/CourseExplorer/blob/Release/schema.txt"
-
-def addCourse(course):
-    if course != None:
-        courseWishList.append(course)
-
+if __package__ in (None, ""):
+    sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
+    __package__ = "uw_course"
 
-def checkDetail(course):
-    SearchCourse(dbClassUW, course)
-    exit(0)
-    
-def parse_arguments():
-    """Parse command-line arguments and validate them."""
-    parser = argparse.ArgumentParser(
-        description="Course Helper: A tool to manage course details and collections.",
-        epilog=f"""Hint: Use --course to specify a course 
-                  or --file to specify a file with courses using schema: {url}
-                  or --export to export the schedule to pdf (.out only).""",
-    )
-    parser.add_argument(
-        "-c", "--course", type=str, help="Specify the course to check details for."
-    )
-    parser.add_argument(
-        "-f", "--file", type=str, help="Specify a file with collection of courses."
-    )
-    parser.add_argument(
-        "-e", "--export", action=str, help="Export the schedule to pdf (.out only)."
-    )
-    parser.add_argument(
-        "-g", "--gray", action="store_true", help="Enable gray color mode for output."
-    )
+from uw_course.ui.app import run_app
 
-    args = parser.parse_args()
-
-    # Ensure at least one argument is provided
-    if len(sys.argv) == 1:
-        parser.print_help()
-        sys.exit(1)
-
-    return args
 
 def main():
-    args = parse_arguments()
-    gray = args.gray 
-    if args.course:
-        checkDetail(args.course)
-    elif args.export:
-        system("pdfschedule " + args.export)
-        print(OKGREEN + "\n\n ---------------- Done!!! ---------------- \n\n" + ENDC)
-    elif args.file:
-        with open(args.file, "r") as f:
-            collection = f.readline().strip().split("#")[0].strip()
-            dbClassUW.switchCollection(collection)
-            next(f)  # Skip the first line
-            for line in f:
-                try:
-                    if line.startswith("#"):
-                        continue
-                    info = line.strip().split(",")
-                    course = info[0].strip()
-                    if len(info) > 1:
-                        addCourse(SearchAvalibleInTerm(dbClassUW, course, int(info[1].strip())))
-                    else:
-                        addCourse(SearchAvalibleInTerm(dbClassUW, course))
-                except Exception as e:
-                    print(FAIL + f"Error: {e}" + ENDC)
-        makeSchedule(dbClassUW, courseWishList=courseWishList, gray=gray)
-        system("pdfschedule " + setting.outDir)
-        print(OKGREEN + "\n\n ---------------- Done!!! ---------------- \n\n" + ENDC)
+    run_app()
+
 
 if __name__ == "__main__":
-    main()
+    main()

uw_course/pdfschedule.py

@@ -0,0 +1,385 @@
+#!/usr/bin/python3
+"""
+Weekly schedule typesetter
+
+Run ``pdfschedule --help`` or visit <https://github.com/jwodder/schedule> for
+more information.
+"""
+
+__version__ = "0.4.1.post1"
+__author__ = "John Thorvald Wodder II; modified by Jiucheng Zang"
+__author_email__ = "pdfschedule@varonathe.org, git.jiucheng@gmail.com"
+__license__ = "MIT"
+__url__ = "https://github.com/jwodder/schedule"
+
+from collections.abc import Mapping
+from datetime import time
+from math import ceil, floor
+from pathlib import Path
+import re
+from textwrap import wrap
+import attr
+from reportlab.lib import pagesizes
+from reportlab.lib.units import inch
+from reportlab.pdfbase import pdfmetrics
+from reportlab.pdfbase.ttfonts import TTFont
+from reportlab.pdfgen.canvas import Canvas
+import yaml
+
+EM = 0.6  ### TODO: Eliminate
+
+WEEKDAYS_EN = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday"]
+FULL_WEEK_EN = ["Sunday"] + WEEKDAYS_EN + ["Saturday"]
+FULL_WEEK_MON_EN = WEEKDAYS_EN + ["Saturday", "Sunday"]
+
+DAY_REGEXES = [
+    ("Sunday", "Sun?"),
+    ("Monday", "M(on?)?"),
+    ("Tuesday", "T(ue?)?"),
+    ("Wednesday", "W(ed?)?"),
+    ("Thursday", "Thu?|H|R"),
+    ("Friday", "F(ri?)?"),
+    ("Saturday", "Sat?"),
+]
+
+GREY = (0.8, 0.8, 0.8)
+
+COLORS = [
+    GREY,
+    (1, 0, 0),  # red
+    (0, 1, 0),  # blue
+    (0, 0, 1),  # green
+    (0, 1, 1),  # cyan
+    (1, 1, 0),  # yellow
+    (0.5, 0, 0.5),  # purple
+    (1, 1, 1),  # white
+    (1, 0.5, 0),  # orange
+    (1, 0, 1),  # magenta
+]
+
+
+class Schedule:
+    def __init__(self, days, day_names=None):
+        self.events = []
+        self.days = list(days)
+        if day_names is None:
+            self._day_names = lambda d: d
+        elif isinstance(day_names, Mapping):
+            self._day_names = day_names.__getitem__
+        elif not callable(day_names):
+            raise TypeError("day_names must be a callable or dict")
+        else:
+            self._day_names = day_names
+
+    def add_event(self, event):
+        self.events.append(event)
+
+    def day_names(self):
+        return map(self._day_names, self.days)
+
+    def all_events(self):
+        return self.events
+
+    def events_on_day(self, day):
+        return [e for e in self.events if day in e.days]
+
+    @property
+    def number_of_days(self):
+        return len(self.days)
+
+    # The font and pagesize of the canvas must already have been set.
+    # x,y: upper-left corner of schedule to render (counting times along the
+    # edge; `render` should not draw anything outside the given box)
+    def render(
+        self,
+        canvas,
+        width,
+        height,
+        x,
+        y,
+        font_size,
+        show_times=True,
+        min_time=None,
+        max_time=None,
+    ):
+        if min_time is None:
+            min_time = max(
+                min(time2hours(ev.start_time) for ev in self.all_events()) - 0.5, 0
+            )
+        if max_time is None:
+            max_time = min(
+                max(time2hours(ev.end_time) for ev in self.all_events()) + 0.5, 24
+            )
+        # List of hours to label and draw a line across
+        hours = range(floor(min_time) + 1, ceil(max_time))
+        line_height = font_size * 1.2
+        # Font size of the day headers at the top of each column:
+        header_size = font_size * 1.2
+        # Height of the boxes in which the day headers will be drawn:
+        day_height = header_size * 1.2
+        # Font size of the time labels at the left of each hour:
+        time_size = font_size / 1.2
+        # Boundaries of where this method is allowed to draw stuff:
+        area = Box(x, y, width, height)
+
+        canvas.setFontSize(time_size)
+        # Gap between the right edge of the time labels and the left edge of
+        # the schedule box.  I don't remember how I came up with this formula.
+        time_gap = 0.2 * canvas.stringWidth(":00")
+        if show_times:
+            time_width = time_gap + max(canvas.stringWidth(f"{i}:00") for i in hours)
+        else:
+            time_width = 0
+
+        sched = Box(
+            x + time_width,
+            y - day_height,
+            width - time_width,
+            height - day_height,
+        )
+        hour_height = sched.height / (max_time - min_time)
+        day_width = sched.width / self.number_of_days
+        line_width = floor(day_width / (font_size * EM))
+
+        # Border around schedule and day headers:
+        canvas.rect(sched.ulx, sched.lry, sched.width, area.height)
+
+        # Day headers text:
+        canvas.setFontSize(header_size)
+        for i, day in enumerate(self.day_names()):
+            canvas.drawCentredString(
+                sched.ulx + day_width * (i + 0.5),
+                area.uly - line_height,
+                day,
+            )
+
+        # Underline beneath day headers:
+        canvas.line(sched.ulx, sched.uly, sched.lrx, sched.uly)
+
+        # Lines across each hour:
+        canvas.setDash([2], 0)
+        for i in hours:
+            y = sched.uly - (i - min_time) * hour_height
+            canvas.line(sched.ulx, y, sched.lrx, y)
+
+        # Lines between each day:
+        canvas.setDash([], 0)
+        for i in range(1, self.number_of_days):
+            x = sched.ulx + i * day_width
+            canvas.line(x, area.uly, x, area.lry)
+
+        if show_times:
+            canvas.setFontSize(time_size)
+            for i in hours:
+                canvas.drawRightString(
+                    sched.ulx - time_gap,
+                    sched.uly - (i - min_time) * hour_height - time_size / 2,
+                    f"{i}:00",
+                )
+
+        # Events:
+        canvas.setFontSize(font_size)
+        for i, day in enumerate(self.days):
+            dx = sched.ulx + day_width * i
+            for ev in self.events_on_day(day):
+                ebox = Box(
+                    dx,
+                    sched.uly - (time2hours(ev.start_time) - min_time) * hour_height,
+                    day_width,
+                    ev.length * hour_height,
+                )
+                # Event box:
+                canvas.setStrokeColorRGB(0, 0, 0)
+                canvas.setFillColorRGB(*ev.color)
+                canvas.rect(*ebox.rect(), stroke=1, fill=1)
+                canvas.setFillColorRGB(0, 0, 0)
+
+                if ev.color[1] <= 0.33333:
+                    # Background color is too dark; print text in white
+                    canvas.setFillColorRGB(1, 1, 1)
+
+                # Event text:
+                ### TODO: Use PLATYPUS or whatever for this part:
+                text = sum((wrap(t, line_width) for t in ev.text), [])
+                tmp_size = None
+                if len(text) * line_height > ebox.height:
+                    tmp_size = ebox.height / len(text) / 1.2
+                    canvas.setFontSize(tmp_size)
+                    line_height = tmp_size * 1.2
+                y = (
+                    ebox.lry
+                    + ebox.height / 2
+                    + len(text) * line_height / 2
+                    + (tmp_size or font_size) / 3
+                )
+                for t in text:
+                    y -= line_height
+                    canvas.drawCentredString(ebox.ulx + day_width / 2, y, t)
+                if tmp_size is not None:
+                    canvas.setFontSize(font_size)
+                    line_height = font_size * 1.2
+
+
+@attr.define
+class Event:
+    start_time: time = attr.field(validator=attr.validators.instance_of(time))
+    end_time: time = attr.field(validator=attr.validators.instance_of(time))
+    text: list[str] = attr.field()
+    color: tuple[float, float, float] = attr.field()
+    days: list[str] = attr.field()  # List of days
+
+    def __attrs_post_init__(self):
+        if self.start_time >= self.end_time:
+            raise ValueError("Event must start before it ends")
+
+    @property
+    def length(self):
+        """The length of the event in hours"""
+        return timediff(self.start_time, self.end_time)
+
+
+@attr.define
+class Box:
+    ulx: float = attr.field()
+    uly: float = attr.field()
+    width: float = attr.field()
+    height: float = attr.field()
+
+    @property
+    def lrx(self):
+        return self.ulx + self.width
+
+    @property
+    def lry(self):
+        return self.uly - self.height
+
+    def rect(self):
+        return (self.ulx, self.lry, self.width, self.height)
+
+
+def parse_time(s):
+    m = re.fullmatch(r"([0-9]{1,2})(?:[:.]?([0-9]{2}))?", s.strip())
+    if m:
+        return time(int(m[1]), int(m[2] or 0))
+    else:
+        raise ValueError(s)
+
+
+def generate_pdf(
+    infile_path,
+    outfile_path=None,
+    color=False,
+    font="Helvetica",
+    font_size=10,
+    portrait=False,
+    scale=None,
+    no_times=False,
+    no_weekends=False,
+    start_monday=False,
+    start_time=None,
+    end_time=None,
+):
+    if font in available_fonts():
+        font_name = font
+    else:
+        font_name = "CustomFont"
+        pdfmetrics.registerFont(TTFont(font_name, font))
+    if portrait:
+        page_width, page_height = pagesizes.portrait(pagesizes.letter)
+    else:
+        page_width, page_height = pagesizes.landscape(pagesizes.letter)
+    colors = COLORS if color else [GREY]
+    if no_weekends:
+        week = WEEKDAYS_EN
+    elif start_monday:
+        week = FULL_WEEK_MON_EN
+    else:
+        week = FULL_WEEK_EN
+    sched = Schedule(week)
+    with open(infile_path, "r", encoding="utf-8") as infile:
+        for ev in read_events(infile, colors=colors):
+            sched.add_event(ev)
+    if outfile_path is None:
+        outfile_path = str(Path(infile_path).with_suffix(".pdf"))
+    with open(outfile_path, "wb") as outfile:
+        c = Canvas(outfile, (page_width, page_height))
+        c.setFont(font_name, font_size)
+        if scale is not None:
+            factor = 1 / scale
+            c.translate(
+                (1 - factor) * page_width / 2,
+                (1 - factor) * page_height / 2,
+            )
+            c.scale(factor, factor)
+        sched.render(
+            c,
+            x=inch,
+            y=page_height - inch,
+            width=page_width - 2 * inch,
+            height=page_height - 2 * inch,
+            font_size=font_size,
+            show_times=not no_times,
+            min_time=time2hours(start_time) if start_time is not None else None,
+            max_time=time2hours(end_time) if end_time is not None else None,
+        )
+        c.showPage()
+        c.save()
+
+
+def read_events(infile, colors):
+    indata = yaml.safe_load(infile)
+    if not isinstance(indata, list):
+        raise ValueError("Input must be a YAML list")
+    for i, entry in enumerate(indata):
+        text = entry.get("name", "").splitlines()
+        try:
+            days = entry["days"]
+            timestr = entry["time"]
+        except KeyError as e:
+            raise ValueError(f"{str(e)!r} field missing from event #{i + 1}")
+        start_str, _, end_str = timestr.partition("-")
+        try:
+            start = parse_time(start_str)
+            end = parse_time(end_str)
+        except ValueError:
+            raise ValueError(f"Invalid time: {timestr!r}")
+        if "color" in entry:
+            m = re.fullmatch(
+                r"\s*#?\s*([a-fA-F0-9]{2})([a-fA-F0-9]{2})([a-fA-F0-9]{2})\s*",
+                entry["color"],
+            )
+            if not m:
+                raise ValueError("Invalid color: " + repr(entry["color"]))
+            color = (
+                int(m.group(1), 16) / 255,
+                int(m.group(2), 16) / 255,
+                int(m.group(3), 16) / 255,
+            )
+        else:
+            color = colors[i % len(colors)]
+        yield Event(
+            start_time=start,
+            end_time=end,
+            text=text,
+            color=color,
+            days=[d for d, rgx in DAY_REGEXES if re.search(rgx, days)],
+        )
+
+
+def time2hours(t):
+    return t.hour + (t.minute + (t.second + t.microsecond / 1000000) / 60) / 60
+
+
+def timediff(t1, t2):
+    # Returns the difference between two `datetime.time` objects as a number of
+    # hours
+    return time2hours(t2) - time2hours(t1)
+
+
+def available_fonts():
+    return Canvas("").getAvailableFonts()
+    # return pdfmetrics.standardFonts
+
+
+if __name__ == "__main__":
+    raise SystemExit("This module is intended to be imported and used as a library.")

uw_course/setting.py

@@ -1,5 +1,10 @@
+from os import makedirs
+from os.path import join
+
+
 class Setting:
     def __init__(self):
-        self.dataName = "./"
+        self.dataName = "./uw-course-files"
         self.configFileName = "schedule.out"
-        self.outDir = self.dataName + "/" + self.configFileName
+        makedirs(self.dataName, exist_ok=True)
+        self.outDir = join(self.dataName, self.configFileName)

uw_course/ui/__init__.py

@@ -0,0 +1 @@
+"""UI package for uw_course."""