assignmentwriter 0.1.0__py3-none-any.whl

assignmentwriter/__init__.py

@@ -0,0 +1,33 @@
+from importlib.metadata import PackageNotFoundError, version
+
+from .modules import (
+    INKS,
+    FONTS,
+    PAPERS,
+    LAYOUTS,
+    Layout,
+    Assignment,
+    AssignmentResult,
+    AssignmentConfigOptions,
+    available_fonts,
+    available_papers,
+)
+
+try:
+    __version__ = version("assignmentwriter")
+except PackageNotFoundError:
+    __version__ = "unknown"
+
+__all__ = [
+    "INKS",
+    "FONTS",
+    "PAPERS",
+    "LAYOUTS",
+    "Layout",
+    "Assignment",
+    "AssignmentResult",
+    "AssignmentConfigOptions",
+    "available_fonts",
+    "available_papers",
+    "__version__",
+]

assignmentwriter/__main__.py

@@ -0,0 +1,263 @@
+import argparse
+import sys
+
+from . import __version__
+from .modules import (
+    INKS,
+    FONTS,
+    PAPERS,
+    DEFAULT_FILENAME,
+    DEFAULT_PDF_FILENAME,
+    Assignment,
+    AssignmentConfigOptions,
+    resolve_ink,
+    resolve_font,
+    resolve_paper,
+    read_text_file,
+    available_fonts,
+    available_papers,
+)
+
+try:
+    from rich.console import Console
+    from rich.markup import escape
+    from rich.prompt import Prompt
+    from rich.table import Table
+except ImportError:
+    Console = None
+
+
+def _use_rich(as_text: bool) -> bool:
+    return Console is not None and not as_text
+
+
+def _say(paths: list, as_text: bool) -> None:
+    for path in paths:
+        if _use_rich(as_text):
+            Console().print(f"[bold green]Saved:[/bold green] {escape(path)}")
+        else:
+            print(path)
+
+
+def _fail(message: str) -> int:
+    if Console is not None:
+        Console(stderr=True).print(f"[bold red]Error:[/bold red] {escape(message)}")
+    else:
+        print(f"Error: {message}", file=sys.stderr)
+    return 1
+
+
+def _ask(label, default=None, validate=None, choices=None, as_text=False):
+    """Ask a question until the answer is accepted. Raises EOFError if input ends."""
+    while True:
+        if _use_rich(as_text):
+            options = {}
+            if default is not None:
+                options["default"] = default
+            hint = f" ({'/'.join(choices)})" if choices else ""
+            answer = Prompt.ask(f"{label}{hint}", **options)
+        else:
+            hint = f" [{'/'.join(choices)}]" if choices else ""
+            shown = f" ({default})" if default is not None else ""
+            answer = input(f"{label}{hint}{shown}: ")
+
+        answer = answer.strip()
+        if not answer:
+            if default is None:
+                continue
+            answer = default
+        if validate is None:
+            return answer
+        try:
+            return validate(answer)
+        except ValueError as error:
+            _fail(str(error))
+
+
+def _create(text, paper, font, ink, keep_line_breaks, save, as_text, pdf=False) -> int:
+    try:
+        config = AssignmentConfigOptions(
+            Text=text,
+            Paper=paper,
+            Font=font,
+            Ink=ink,
+            KeepLineBreaks=keep_line_breaks,
+        )
+    except ValueError as error:
+        return _fail(str(error))
+
+    result = Assignment(config).create()
+    if not result:
+        return _fail("Could not create the assignment pages")
+
+    if pdf:
+        path = result.save_pdf(save)
+        paths = [path] if path else None
+    else:
+        paths = result.save(save)
+    if not paths:
+        return _fail("Could not save the assignment pages")
+
+    _say(paths, as_text)
+    return 0
+
+
+def _interactive(args) -> int:
+    try:
+        text = _ask("Text to write", as_text=args.as_text)
+        paper = _ask(
+            "Paper", args.paper, resolve_paper, available_papers(), args.as_text
+        )
+        font = _ask("Font", args.font, resolve_font, available_fonts(), args.as_text)
+        ink = _ask("Ink", args.ink, resolve_ink, list(INKS), args.as_text)
+        default_name = DEFAULT_PDF_FILENAME if args.pdf else DEFAULT_FILENAME
+        save = _ask("Save as", args.save or default_name, as_text=args.as_text)
+    except (EOFError, KeyboardInterrupt):
+        print(file=sys.stderr)
+        return 1
+    return _create(
+        text, paper, font, ink, args.keep_line_breaks, save, args.as_text, args.pdf
+    )
+
+
+def _list(argv) -> int:
+    parser = argparse.ArgumentParser(
+        prog="assignmentwriter list",
+        description="Show the papers, fonts and inks that can be used.",
+    )
+    parser.add_argument(
+        "--as-text",
+        action="store_true",
+        help="plain line-by-line output instead of tables",
+    )
+    args = parser.parse_args(argv)
+    fonts = available_fonts()
+    papers = available_papers()
+
+    if _use_rich(args.as_text):
+        console = Console()
+
+        table = Table(title="Papers")
+        table.add_column("Name", style="cyan")
+        for name in papers:
+            table.add_row(name)
+        console.print(table)
+
+        table = Table(title="Fonts")
+        table.add_column("No.", justify="right")
+        table.add_column("Name", style="cyan")
+        for number, name in enumerate(FONTS, start=1):
+            if name in fonts:
+                table.add_row(str(number), name)
+        console.print(table)
+
+        table = Table(title="Inks")
+        table.add_column("Name", style="cyan")
+        table.add_column("RGB")
+        for name, rgb in INKS.items():
+            table.add_row(name, ", ".join(str(value) for value in rgb))
+        console.print(table)
+    else:
+        for name in papers:
+            print(f"paper\t{name}")
+        for name in fonts:
+            print(f"font\t{name}")
+        for name in INKS:
+            print(f"ink\t{name}")
+    return 0
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="assignmentwriter",
+        description=(
+            "Write an assignment on paper in your choice of handwriting and ink. "
+            "Long text continues on more pages."
+        ),
+        epilog=(
+            "Run with no arguments for an interactive prompt, or "
+            "'assignmentwriter list' to see every paper, font and ink."
+        ),
+    )
+    parser.add_argument("text", nargs="?", help="the text to write")
+    parser.add_argument("--file", help="read the text from this UTF-8 text file")
+    parser.add_argument(
+        "--paper",
+        default="a4",
+        help=f"{', '.join(PAPERS)} (default: a4)",
+    )
+    parser.add_argument(
+        "--font", default="caveat", help="font name or number (default: caveat)"
+    )
+    parser.add_argument(
+        "--ink",
+        default="blue",
+        help=f"{', '.join(INKS)} or a hex colour (default: blue)",
+    )
+    parser.add_argument(
+        "--save",
+        help=(
+            f"where to save (default: {DEFAULT_FILENAME}, or {DEFAULT_PDF_FILENAME} "
+            "with --pdf). Long text goes on several pages: name_1.png, name_2.png, ..."
+        ),
+    )
+    parser.add_argument(
+        "--pdf",
+        action="store_true",
+        help="save all the pages together as one PDF instead of images",
+    )
+    parser.add_argument(
+        "--keep-line-breaks",
+        action="store_true",
+        help="start a new line wherever the text has one",
+    )
+    parser.add_argument(
+        "--as-text",
+        action="store_true",
+        help="plain output (just the saved path, no colors)",
+    )
+    parser.add_argument(
+        "--version", action="version", version=f"%(prog)s {__version__}"
+    )
+    return parser
+
+
+def main(argv=None) -> int:
+    argv = sys.argv[1:] if argv is None else list(argv)
+
+    # "list" is a command only when it is the first word, to write the word
+    # "list" on its own put it in a file and use --file
+    if argv and argv[0] == "list":
+        return _list(argv[1:])
+
+    parser = _build_parser()
+    args = parser.parse_args(argv)
+
+    text = args.text
+    if args.file is not None:
+        if text is not None:
+            parser.error("give the text directly or with --file, not both")
+        try:
+            text = read_text_file(args.file)
+        except ValueError as error:
+            return _fail(str(error))
+    elif text is None:
+        if sys.stdin is not None and not sys.stdin.isatty():
+            text = sys.stdin.read()
+        else:
+            return _interactive(args)
+
+    return _create(
+        text,
+        args.paper,
+        args.font,
+        args.ink,
+        args.keep_line_breaks,
+        args.save,
+        args.as_text,
+        args.pdf,
+    )
+
+
+if __name__ == "__main__":
+    sys.exit(main())

assignmentwriter/layouts.py

@@ -0,0 +1,119 @@
+from typing import NamedTuple
+
+
+class Layout(NamedTuple):
+    max_line_length: int
+    margin_left: int
+    margin_top: int
+    font_size: int
+    line_spacing: float
+    margin_bottom: int
+
+
+COLORED = ("cream", "cyan", "lightblue", "lightgreen", "lime", "orange", "pink")
+
+_A4 = {
+    "adinekirnberg": (76, 20, 20, 40, 10),
+    "alanishand": (54, 20, 20, 35, 13),
+    "architex": (46, 20, 20, 43, 13),
+    "caveat": (43, 20, 20, 40, 10),
+    "greatvibesregular": (62, 20, 20, 30, 10),
+    "hand_note": (56, 20, 20, 40, 12),
+    "homemadeapple": (42, 20, 20, 25, 6),
+    "honeyscript": (56, 20, 20, 45, 13),
+    "jottflf": (43, 20, 20, 35, 12),
+    "note_this": (49, 20, 20, 30, 12),
+    "pleasewritemeasong": (52, 20, 20, 35, 13),
+    "s_hand": (43, 20, 20, 50, 13),
+}
+
+_LINED = {
+    "adinekirnberg": (60, 370, 330, 115, 2),
+    "alanishand": (60, 370, 338, 80, 50),
+    "architex": (63, 370, 348, 80, 22),
+    "caveat": (52, 370, 333, 85, 22),
+    "greatvibesregular": (60, 370, 340, 75, 15.5),
+    "hand_note": (67, 370, 338, 85, 2.3),
+    "homemadeapple": (45, 370, 310, 60, -1),
+    "honeyscript": (83, 370, 338, 80, 9.5),
+    "jottflf": (50, 370, 340, 75, 22.5),
+    "note_this": (42, 370, 338, 85, 4),
+    "pleasewritemeasong": (60, 370, 340, 75, 29.3),
+    "s_hand": (55, 370, 323, 100, 41),
+}
+
+_ROUGH = {
+    "adinekirnberg": (67, 155, 125, 45, 2),
+    "alanishand": (63, 155, 135, 30, 19),
+    "architex": (64, 155, 135, 35, 6),
+    "caveat": (61, 155, 132, 30, 11),
+    "greatvibesregular": (68, 150, 135, 30, 5),
+    "hand_note": (80, 155, 135, 30, 4),
+    "homemadeapple": (74, 155, 138, 15, 13),
+    "honeyscript": (88, 155, 126, 32, 3.3),
+    "jottflf": (60, 155, 138, 25, 13),
+    "note_this": (75, 155, 143, 20, 16),
+    "pleasewritemeasong": (73, 155, 138, 25, 16),
+    "s_hand": (58, 155, 132, 40, 15.8),
+}
+
+_SPIRAL = {
+    "adinekirnberg": (65, 440, 407, 115, -12),
+    "alanishand": (66, 440, 422, 70, 41.5),
+    "architex": (78, 440, 432, 70, 18),
+    "caveat": (64, 440, 417, 75, 17),
+    "greatvibesregular": (71, 440, 417, 75, 1.5),
+    "hand_note": (76, 440, 422, 75, -0.2),
+    "homemadeapple": (47, 440, 410, 60, -16.8),
+    "honeyscript": (98, 440, 422, 70, 5.5),
+    "jottflf": (56, 440, 417, 75, 7.9),
+    "note_this": (53, 440, 422, 75, 1),
+    "pleasewritemeasong": (66, 440, 417, 75, 14.7),
+    "s_hand": (67, 440, 407, 90, 32),
+}
+
+_WRINKLED = {
+    "adinekirnberg": (55, 140, 62, 71, -8),
+    "alanishand": (64, 140, 77, 35, 29.5),
+    "architex": (72, 140, 87, 35, 18),
+    "caveat": (58, 140, 62, 40, 14),
+    "greatvibesregular": (65, 140, 77, 37, 10.5),
+    "hand_note": (73, 140, 77, 40, 4.8),
+    "homemadeapple": (54, 140, 70, 25, 9.2),
+    "honeyscript": (92, 140, 77, 35, 12.5),
+    "jottflf": (48, 140, 77, 38, 11.9),
+    "note_this": (47, 140, 67, 40, 7),
+    "pleasewritemeasong": (58, 140, 77, 38, 15.7),
+    "s_hand": (54, 140, 72, 50, 22),
+}
+
+_COLORED = {
+    "adinekirnberg": (62, 250, 60, 50, 10),
+    "alanishand": (53, 250, 60, 45, 13),
+    "architex": (45, 250, 60, 53, 13),
+    "caveat": (42, 250, 60, 50, 10),
+    "greatvibesregular": (76, 250, 60, 30, 10),
+    "hand_note": (55, 250, 60, 50, 12),
+    "homemadeapple": (36, 250, 60, 35, 6),
+    "honeyscript": (55, 250, 60, 55, 13),
+    "jottflf": (42, 250, 60, 45, 12),
+    "note_this": (43, 250, 60, 40, 12),
+    "pleasewritemeasong": (51, 250, 60, 45, 13),
+    "s_hand": (42, 250, 60, 60, 13),
+}
+
+
+def _layouts(rows: dict, margin_bottom: int) -> dict:
+    return {font: Layout(*row, margin_bottom) for font, row in rows.items()}
+
+
+LAYOUTS = {
+    "a4": _layouts(_A4, 20),
+    "lined": _layouts(_LINED, 130),
+    "rough": _layouts(_ROUGH, 130),
+    "spiral": _layouts(_SPIRAL, 130),
+    "wrinkled": _layouts(_WRINKLED, 50),
+}
+
+for _name in COLORED:
+    LAYOUTS[_name] = _layouts(_COLORED, 50)

assignmentwriter/modules.py

@@ -0,0 +1,447 @@
+import os
+import re
+import logging
+import operator
+import textwrap
+from pathlib import Path
+from dataclasses import dataclass
+from PIL import Image, ImageDraw, ImageFont
+from .layouts import COLORED, LAYOUTS, Layout
+
+logger = logging.getLogger(__name__)
+
+RES_DIR = Path(__file__).resolve().parent / "res"
+PAPERS_DIR = RES_DIR / "papers"
+FONTS_DIR = RES_DIR / "fonts"
+
+DEFAULT_FILENAME = "assignment.png"
+DEFAULT_PDF_FILENAME = "assignment.pdf"
+
+PDF_PAGE_WIDTH_INCHES = 8.27
+
+PAPERS = {
+    "a4": "a4paper.jpg",
+    "lined": "lined.png",
+    "rough": "rough.jpg",
+    "spiral": "spiral.png",
+    "wrinkled": "wrinkled.jpg",
+    **{name: f"{name}.jpg" for name in COLORED},
+}
+
+# In order, coz i used it in other projects.
+
+FONTS = {
+    "adinekirnberg": "AdineKirnberg.ttf",
+    "alanishand": "AlanisHand.ttf",
+    "architex": "Architex.ttf",
+    "caveat": "caveat.ttf",
+    "greatvibesregular": "GreatVibes-Regular.ttf",
+    "hand_note": "Hand_Note.otf",
+    "homemadeapple": "HomemadeApple.ttf",
+    "honeyscript": "HoneyScript.ttf",
+    "jottflf": "JottFLF.ttf",
+    "note_this": "Note_this.ttf",
+    "pleasewritemeasong": "pleasewritemeasong.ttf",
+    "s_hand": "S_Hand.ttf",
+}
+
+FONT_ALIASES = {
+    "greatvibes": "greatvibesregular",
+}
+
+INKS = {
+    "blue": (19, 19, 148),
+    "black": (19, 19, 20),
+    "red": (163, 2, 2),
+    "green": (0, 122, 0),
+    "pencil": (105, 105, 105),
+    "brown": (101, 67, 33),
+    "purple": (75, 0, 130),
+    "orange": (255, 140, 0),
+    "teal": (0, 128, 128),
+    "magenta": (139, 0, 139),
+}
+
+
+def _normalize(value) -> str:
+    """Lower-case a name and drop everything that is not a letter or digit."""
+    return re.sub(r"[^a-z0-9]", "", str(value).lower())
+
+
+def available_papers() -> list:
+    return [name for name, file in PAPERS.items() if (PAPERS_DIR / file).is_file()]
+
+
+def available_fonts() -> list:
+    return [name for name, file in FONTS.items() if (FONTS_DIR / file).is_file()]
+
+
+def resolve_paper(value) -> str:
+    """Return the paper name for `value` (case and spaces are ignored) or raise ValueError."""
+    lookup = {_normalize(name): name for name in PAPERS}
+    name = lookup.get(_normalize(value))
+    if name is None:
+        raise ValueError(f"Unknown Paper {value!r}. Choose one of: {', '.join(PAPERS)}")
+    if name not in available_papers():
+        raise ValueError(f"The image file for Paper {name!r} is missing")
+    return name
+
+
+def resolve_font(value) -> str:
+    """Return the font name for `value` (spaces, dashes and case are ignored) or raise ValueError."""
+    names = list(FONTS)
+    text = str(value).strip()
+    if re.fullmatch(r"\d+", text):
+        number = int(text)
+        if not 1 <= number <= len(names):
+            raise ValueError(
+                f"Unknown Font number {value!r}. Choose a number from 1 to {len(names)}"
+            )
+        name = names[number - 1]
+    else:
+        lookup = {_normalize(item): item for item in names}
+        lookup.update(FONT_ALIASES)
+        name = lookup.get(_normalize(text))
+        if name is None:
+            raise ValueError(
+                f"Unknown Font {value!r}. Choose one of: {', '.join(names)}"
+            )
+    if name not in available_fonts():
+        raise ValueError(f"The font file for Font {name!r} is missing")
+    return name
+
+
+def resolve_ink(value) -> str:
+    """Return an ink name (e.g. "blue") or a hex colour like "1A2B3C".
+
+    Raises ValueError if `value` is neither.
+    """
+    key = str(value).strip().lower()
+    if key in INKS:
+        return key
+    code = key.removeprefix("#")
+    if re.fullmatch(r"[0-9a-f]{6}", code):
+        return code.upper()
+    raise ValueError(
+        f"Unknown Ink {value!r}. Choose one of: {', '.join(INKS)} "
+        "or a 6-digit hex colour such as 131394"
+    )
+
+
+def ink_to_rgb(ink: str) -> tuple:
+    """Turn a resolved ink (see `resolve_ink`) into an (R, G, B) tuple."""
+    if ink in INKS:
+        return INKS[ink]
+    return (int(ink[0:2], 16), int(ink[2:4], 16), int(ink[4:6], 16))
+
+
+def _pick(value, default):
+    """Default picker LOL, L Hypergamy NGL."""
+    return default if value is None else value
+
+
+def _resolve_target(path, default_name: str, default_suffix: str) -> Path:
+    """Turn what the user passed to save() into the file to write."""
+    raw = os.fsdecode(path) if path is not None else default_name
+    target = Path(raw)
+    if target.is_dir() or raw.endswith(("/", os.sep)):
+        return target / default_name
+    if not target.suffix:
+        return target.with_suffix(default_suffix)
+    return target
+
+
+def read_text_file(path) -> str:
+    """Return the text of a UTF-8 text file (a BOM at the start is ignored).
+
+    Raises ValueError, with a message that names the file, if it cannot be read.
+    """
+    if not isinstance(path, (str, os.PathLike)):
+        raise ValueError("File must be the path of a text file, as a string or a Path")
+    try:
+        return Path(path).expanduser().read_text(encoding="utf-8-sig")
+    except (OSError, UnicodeDecodeError) as error:
+        raise ValueError(f"Could not read {os.fspath(path)}: {error}") from error
+
+
+@dataclass
+class AssignmentConfigOptions:
+    """Settings for the handwritten pages.
+
+    Give either Text or File, not both. FontSize to LineSpacing are None by default.
+    """
+
+    Text: str | None = None
+    Paper: str = "a4"
+    Font: str = "caveat"
+    Ink: str = "blue"
+    KeepLineBreaks: bool = False
+    FontSize: int | None = None
+    MaxLineLength: int | None = None
+    MarginLeft: int | None = None
+    MarginTop: int | None = None
+    MarginBottom: int | None = None
+    LineSpacing: float | None = None
+    File: str | os.PathLike | None = None
+
+    def __post_init__(self):
+        if self.File is not None:
+            if self.Text is not None:
+                raise ValueError("Give Text or File, not both")
+            self.Text = read_text_file(self.File)
+
+        if not isinstance(self.Text, str) or not self.Text.strip():
+            raise ValueError("Nothing to write, Text (or File) is missing or empty")
+
+        self.Ink = resolve_ink(self.Ink)
+        self.Font = resolve_font(self.Font)
+        self.Paper = resolve_paper(self.Paper)
+
+        for name in ("FontSize", "MaxLineLength"):
+            value = getattr(self, name)
+            if value is not None and value < 1:
+                raise ValueError(f"{name} must be at least 1")
+
+        for name in ("MarginLeft", "MarginTop", "MarginBottom"):
+            value = getattr(self, name)
+            if value is not None and value < 0:
+                raise ValueError(f"{name} can't be negative")
+
+        # LineSpacing isn't checked here, _prepare() already complains if the lines would end up on top of each other
+
+
+class AssignmentResult:
+    """What `Assignment.create()` returns.
+
+    - `bool(result)` is False if the pages could not be created.
+    - `len(result)` is the number of pages, `result[0]` is the first page. Each page is a Pillow image that is drawn when you ask for it, so a long text does not keep every page in memory.
+    - `result.image` is the first page.
+    - `result.paths` are the files written by the last `save()` or `save_pdf()`, and `str(result)` is those paths, one per line (an empty string until something has been saved).
+    """
+
+    def __init__(self, render=None, page_count=0, config=None):
+        self._render = render
+        self.page_count = page_count
+        self.config = config
+        self.paths = []
+
+    def __bool__(self) -> bool:
+        return self.page_count > 0
+
+    def __len__(self) -> int:
+        return self.page_count
+
+    def __getitem__(self, index):
+        index = operator.index(index)
+        if not -self.page_count <= index < self.page_count:
+            raise IndexError("page index out of range")
+        return self._render(index % self.page_count)
+
+    def __iter__(self):
+        return (self[index] for index in range(self.page_count))
+
+    def __str__(self) -> str:
+        return "\n".join(self.paths)
+
+    def __repr__(self) -> str:
+        if not self:
+            return "<AssignmentResult failed>"
+        pages = "page" if self.page_count == 1 else "pages"
+        saved = f" saved={self.paths!r}" if self.paths else ""
+        return f"<AssignmentResult {self.page_count} {pages}{saved}>"
+
+    @property
+    def image(self):
+        """The first page as a Pillow image, or None if nothing was created."""
+        return self[0] if self else None
+
+    @property
+    def pages(self):
+        """Iterator over every page as a Pillow image."""
+        return iter(self)
+
+    def save(self, path=None, **kwargs):
+        """Save every page and return the list of paths, or None if it failed.
+
+        - `path` can be a file name or a folder; it defaults to `assignment.png` in the current folder.
+        - When the text needs more than one page they are saved as `name_1.png`, `name_2.png` and so on.
+        - Extra keyword arguments go to Pillow's `Image.save`.
+        """
+        if not self:
+            logger.error("Nothing to save: the assignment pages were not created")
+            return None
+
+        target = _resolve_target(path, DEFAULT_FILENAME, ".png")
+        if target.suffix.lower() in (".jpg", ".jpeg"):
+            kwargs.setdefault(
+                "quality", 95
+            )  # Punish the guy for using JPEG when PNG exists. (MAYBE CHANGE IT TO 50 IN FUTURE)
+
+        if self.page_count == 1:
+            targets = [target]
+        else:
+            digits = len(str(self.page_count))
+            targets = [
+                target.with_name(f"{target.stem}_{number:0{digits}d}{target.suffix}")
+                for number in range(1, self.page_count + 1)
+            ]
+
+        saved = []
+        try:
+            target.parent.mkdir(parents=True, exist_ok=True)
+            for page_path, page in zip(targets, self):
+                page.save(page_path, **kwargs)
+                saved.append(os.fspath(page_path))
+        except Exception as error:
+            logger.error("Could not save the assignment pages to %s: %s", target, error)
+            return None
+
+        self.paths = saved
+        return saved
+
+    def save_pdf(self, path=None):
+        """Save all pages as one PDF and return its path, or None if it failed.
+
+        - `path` can be a file name or a folder; it defaults to `assignment.pdf` in the current folder
+        - The pages are scaled to the width of an A4 sheet. All pages are kept in memory while the PDF is written.
+        """
+        if not self:
+            logger.error("Nothing to save: the assignment pages were not created")
+            return None
+
+        target = _resolve_target(path, DEFAULT_PDF_FILENAME, ".pdf")
+        try:
+            target.parent.mkdir(parents=True, exist_ok=True)
+            pages = list(self)
+            pages[0].save(
+                target,
+                format="PDF",
+                save_all=True,
+                append_images=pages[1:],
+                resolution=pages[0].width / PDF_PAGE_WIDTH_INCHES,
+            )
+        except Exception as error:
+            logger.error("Could not save the assignment PDF to %s: %s", target, error)
+            return None
+
+        self.paths = [os.fspath(target)]
+        return self.paths[0]
+
+
+class Assignment:
+    """Writes text on a paper in a handwriting font and ink.
+
+    - Example:
+        config = AssignmentConfigOptions(Text="Hello World", Paper="lined")
+        result = Assignment(config).create()
+        result.save("page.png")
+    """
+
+    def __init__(self, config: AssignmentConfigOptions):
+        if not isinstance(config, AssignmentConfigOptions):
+            raise TypeError("config must be an AssignmentConfigOptions instance")
+        self.config = config
+
+    def get_defaults(self) -> dict:
+        layout = LAYOUTS[self.config.Paper][self.config.Font]
+        return {
+            "Paper": self.config.Paper,
+            "Font": self.config.Font,
+            "FontFile": FONTS[self.config.Font],
+            "FontSize": layout.font_size,
+            "MaxLineLength": layout.max_line_length,
+            "MarginLeft": layout.margin_left,
+            "MarginTop": layout.margin_top,
+            "MarginBottom": layout.margin_bottom,
+            "LineSpacing": layout.line_spacing,
+        }
+
+    def create(self) -> AssignmentResult:
+        """Lay out the text. Returns a falsy AssignmentResult if anything fails."""
+        try:
+            render, page_count = self._prepare()
+        except Exception as error:
+            logger.error("Could not create the assignment pages: %s", error)
+            return AssignmentResult()
+        return AssignmentResult(render, page_count, self.config)
+
+    def _layout(self) -> Layout:
+        """The tuned layout with the config's overrides applied."""
+        config = self.config
+        layout = LAYOUTS[config.Paper][config.Font]
+        return Layout(
+            max_line_length=_pick(config.MaxLineLength, layout.max_line_length),
+            margin_left=_pick(config.MarginLeft, layout.margin_left),
+            margin_top=_pick(config.MarginTop, layout.margin_top),
+            font_size=_pick(config.FontSize, layout.font_size),
+            line_spacing=_pick(config.LineSpacing, layout.line_spacing),
+            margin_bottom=_pick(config.MarginBottom, layout.margin_bottom),
+        )
+
+    def _wrap(self, width: int) -> list:
+        """Break the text into lines of at most `width` characters."""
+        text = self.config.Text
+        if not self.config.KeepLineBreaks:
+            return textwrap.wrap(text, width=width)
+
+        lines = []
+        for line in text.splitlines():
+            lines.extend(textwrap.wrap(line, width=width) or [""])
+        # blank lines at the very end would only add an empty page
+        while lines and not lines[-1]:
+            lines.pop()
+        return lines
+
+    def _prepare(self):
+        """Work out the pages. Returns (render, page_count).
+
+        `render(index)` draws page `index` (counting from 0) and returns it btw.
+        """
+        config = self.config
+        layout = self._layout()
+
+        with Image.open(PAPERS_DIR / PAPERS[config.Paper]) as paper:
+            base = paper.convert("RGB")
+
+        font = ImageFont.truetype(str(FONTS_DIR / FONTS[config.Font]), layout.font_size)
+        color = ink_to_rgb(config.Ink)
+
+        lines = self._wrap(layout.max_line_length)
+        left, top, right, bottom = font.getbbox("Ay")
+        line_height = (bottom - top) + layout.line_spacing
+        if line_height <= 0:
+            raise ValueError("LineSpacing is too small, the lines would overlap")
+        available_height = base.height - layout.margin_top - layout.margin_bottom
+        lines_per_page = int(available_height // line_height)
+        if lines_per_page < 1:
+            logger.warning(
+                "Not even one line fits on the %s page, use a smaller FontSize, "
+                "MarginTop or MarginBottom.",
+                config.Paper,
+            )
+            lines_per_page = 1
+
+        pages = [
+            lines[start : start + lines_per_page]
+            for start in range(0, len(lines), lines_per_page)
+        ]
+
+        if any(
+            layout.margin_left + font.getlength(line) > base.width for line in lines
+        ):
+            logger.warning(
+                "Some lines run past the right edge of the %s page. "
+                "Use a smaller MaxLineLength or FontSize.",
+                config.Paper,
+            )
+
+        def render(index: int) -> Image.Image:
+            page = base.copy()
+            draw = ImageDraw.Draw(page)
+            y = layout.margin_top
+            for line in pages[index]:
+                draw.text((layout.margin_left, y), line, fill=color, font=font)
+                y += line_height
+            return page
+
+        return render, len(pages)

assignmentwriter/res/fonts/NOTICE.md

@@ -0,0 +1,26 @@
+# Font notice
+
+The code in this package is MIT licensed (see `LICENSE`). The fonts in this folder are **not** covered by that license. Each one has its own terms.
+
+The table below is copied from the info stored inside each font file.
+"Not stated" means the font file itself has no license in it. That doesn't mean the font is free to use, only that the file doesn't say.
+
+| File | Font | Copyright line in the file | License in the file |
+| --- | --- | --- | --- |
+| `caveat.ttf` | Caveat | Copyright 2015 Google Inc. (designer: Pablo Impallari) | SIL Open Font License 1.1 |
+| `GreatVibes-Regular.ttf` | Great Vibes | Copyright (c) 2012 TypeSETit, LLC, Reserved Font Name "Great Vibes" | SIL Open Font License 1.1 |
+| `HomemadeApple.ttf` | Homemade Apple | Copyright (c) 2010 by Font Diner, Inc. | Apache License 2.0 |
+| `AdineKirnberg.ttf` | Adine Kirnberg | Copyright (c) Typographer Mediengestaltung, 2000. Adine Kirnberg-Script 1991 by D. Rakowski. All rights reserved. Full character set added by D. Steffmann | Not stated |
+| `AlanisHand.ttf` | Alanis Hand | "2003" | Not stated |
+| `Architex.ttf` | Architext | (c) Grant Marshall, www.marshallarts.co.za | Not stated |
+| `Hand_Note.otf` | Hand Note | Hand Note (c) Azcreative Studio. 2020. All Rights Reserved (designer: Abdul Azis) | Not stated |
+| `HoneyScript.ttf` | Honey Script | Copyright (c) Typographer Mediengestaltung, 2000. All rights reserved. Added to full character set by Dieter Steffmann | Not stated |
+| `JottFLF.ttf` | JottFLF | Jott FLF Casual, 4.1 Copyright Casady & Greene, Inc. 1988-92. All rights reserved | Not stated |
+| `Note_this.ttf` | Note this | Copyright (c) West Wind Fonts, 2001 | Not stated |
+| `pleasewritemeasong.ttf` | Please write me a song | Vanessa Bays - ByTheButterfly.com | Not stated |
+| `S_Hand.ttf` | S Hand | Created with FontForge (no author or license given) | Not stated |
+
+Full text of the licenses named above:
+
+- SIL Open Font License 1.1: https://openfontlicense.org
+- Apache License 2.0: https://www.apache.org/licenses/LICENSE-2.0

assignmentwriter-0.1.0.dist-info/METADATA

@@ -0,0 +1,266 @@
+Metadata-Version: 2.4
+Name: assignmentwriter
+Version: 0.1.0
+Summary: A Python package and CLI that writes your text on paper in a handwriting font and ink of your choice
+Author: TheHritu
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/TheHritu/AssignmentWriter
+Keywords: assignment,handwriting,handwritten,text-to-handwriting,image,pillow
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Multimedia :: Graphics
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: Pillow>=9.0
+Provides-Extra: cli
+Requires-Dist: rich; extra == "cli"
+Dynamic: license-file
+
+# AssignmentWriter
+
+A Python package and command line tool that writes your text on a sheet of paper, in a handwriting font and ink colour of your choice. Pick a paper, a font and an ink, and get back an image of the page(s) (in form of pdf too) - all in a few lines of code.
+
+[![Version](https://img.shields.io/badge/Version-0.1.0-red)](https://pypi.org/project/assignmentwriter/) [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://github.com/TheHritu/AssignmentWriter/blob/main/LICENSE)
+
+## Installation
+
+```
+pip install assignmentwriter -U
+```
+
+## Quick Start
+
+```python
+from assignmentwriter import Assignment, AssignmentConfigOptions
+
+config = AssignmentConfigOptions(Text="Hello World", Paper="lined", Font="caveat", Ink="blue")
+result = Assignment(config).create()
+
+result.save("page.png")  # saves the image
+print(result)            # prints the saved path (if saved)
+```
+
+Or write a whole text file, on as many pages as it needs:
+
+```python
+config = AssignmentConfigOptions(File="essay.txt", Paper="spiral", Ink="teal")
+result = Assignment(config).create()
+
+result.save("essay.png")      # essay_1.png, essay_2.png, ...
+result.save_pdf("essay.pdf")  # or all the pages in one PDF
+```
+
+## Previews
+
+See at https://github.com/TheHritu/AssignmentWriter
+
+## Papers, fonts and inks
+
+| Option | Values |
+|--------|--------|
+| `Paper` | `a4`, `lined`, `rough`, `spiral`, `wrinkled`, `cream`, `cyan`, `lightblue`, `lightgreen`, `lime`, `orange`, `pink` |
+| `Font` | `adinekirnberg`, `alanishand`, `architex`, `caveat`, `greatvibesregular`, `hand_note`, `homemadeapple`, `honeyscript`, `jottflf`, `note_this`, `pleasewritemeasong`, `s_hand` |
+| `Ink` | `blue`, `black`, `red`, `green`, `pencil`, `brown`, `purple`, `orange`, `teal`, `magenta`, or any hex colour such as `"131394"` |
+
+A font can also be chosen by its number, 1 to 12, in the order shown above (`Font=4` is `caveat`).
+Names are not case sensitive and spaces, dashes and underscores are ignored (`"Hand Note"` and `"Light Green"` work).
+
+```python
+from assignmentwriter import available_fonts, available_papers, INKS
+
+print(available_papers())  # ['a4', 'lined', 'rough', 'spiral', 'wrinkled', 'cream', 'cyan', 'lightblue', 'lightgreen', 'lime', 'orange', 'pink']
+print(available_fonts())   # ['adinekirnberg', 'alanishand', 'architex', 'caveat', 'greatvibesregular', 'hand_note', 'homemadeapple', 'honeyscript', 'jottflf', 'note_this', 'pleasewritemeasong', 's_hand']
+print(list(INKS))          # ['blue', 'black', 'red', 'green', 'pencil', 'brown', 'purple', 'orange', 'teal', 'magenta']
+```
+
+> **Note:** `alanishand` draws the digits `2` and `5` very wide, so lines with those numbers can run off the page. Use another font for text with numbers.
+
+## Configuration
+
+`AssignmentConfigOptions` accepts these fields:
+
+| Field | Type | Default | Description |
+|-------|------|---------|-------------|
+| `Text` | `str` | `None` | Text to write (give `Text` or `File`, not both) |
+| `File` | `str` or `Path` | `None` | A UTF-8 text file to write instead of `Text` |
+| `Paper` | `str` | `"a4"` | Paper to write on |
+| `Font` | `str` | `"caveat"` | Handwriting font (name or number) |
+| `Ink` | `str` | `"blue"` | Ink colour (name or hex) |
+| `KeepLineBreaks` | `bool` | `False` | Start a new line wherever your text has one |
+| `FontSize` | `int` | `None` | Override the font size |
+| `MaxLineLength` | `int` | `None` | Override the number of characters per line |
+| `MarginLeft` | `int` | `None` | Override the left margin (pixels) |
+| `MarginTop` | `int` | `None` | Override the top margin (pixels) |
+| `MarginBottom` | `int` | `None` | Override the space kept free at the bottom of each page (pixels) |
+| `LineSpacing` | `float` | `None` | Override the space between lines (pixels) |
+
+The last six are `None` by default, which keeps the layout that is tuned for the chosen paper and font.
+An invalid value raises a `ValueError` as soon as the config is created.
+
+By default your text is written as one paragraph, line breaks are treated as spaces.
+Use `KeepLineBreaks=True` to keep headings, lists and paragraphs on their own lines.
+
+### Text from a file
+
+Pass the path of a UTF-8 text file as `File` instead of `Text`:
+
+```python
+from assignmentwriter import Assignment, AssignmentConfigOptions
+
+config = AssignmentConfigOptions(File="essay.txt", Paper="lined", Ink="black", KeepLineBreaks=True)
+result = Assignment(config).create()
+result.save("essay.png")
+```
+
+A `ValueError` is raised if the file cannot be read, is empty, or if you give both `Text` and `File`.
+
+### Get the tuned layout for a paper and font:
+
+Returns a dictionary with the default layout values.
+
+```python
+from assignmentwriter import Assignment, AssignmentConfigOptions
+
+config = AssignmentConfigOptions(Text="Hi", Paper="lined", Font="caveat")
+print(Assignment(config).get_defaults())
+# {'Paper': 'lined', 'Font': 'caveat', 'FontFile': 'caveat.ttf', 'FontSize': 85,
+#  'MaxLineLength': 52, 'MarginLeft': 370, 'MarginTop': 333, 'MarginBottom': 130, 'LineSpacing': 22}
+```
+
+## Several pages
+
+When your text is too long for one page, it continues on as many pages as it needs, so none of it is lost.
+A line is never split between two pages.
+
+```python
+config = AssignmentConfigOptions(File="essay.txt", Paper="spiral")
+result = Assignment(config).create()
+
+print(len(result))            # the number of pages
+result.save("essay.png")      # essay_1.png, essay_2.png, ...
+result.save_pdf("essay.pdf")  # or all the pages in one PDF
+```
+
+## `AssignmentResult`
+
+`Assignment.create()` returns an `AssignmentResult` object:
+
+```python
+result = Assignment(config).create()
+
+bool(result)                 # False if the pages could not be created
+len(result)                  # the number of pages
+result.image                 # the first page as a Pillow Image
+result[1]                    # the second page, `for page in result` goes through all of them
+result.save()                # assignment.png, or assignment_1.png, assignment_2.png ... for several pages
+result.save("out.png")       # save to a specific path (png, jpg, ...), returns the list of paths
+result.save("pages/")        # save in a folder
+result.save_pdf("out.pdf")   # all the pages in one PDF (as wide as an A4 sheet), returns the path
+str(result)                  # the paths of the last save, one per line ("" before saving)
+```
+
+Each page is drawn when you ask for it, so a very long text does not keep every page in memory at once.
+
+If anything fails, `create()` returns a falsy `AssignmentResult` and logs the error. `save()` and `save_pdf()` return `None` and log the error if a file cannot be written.
+A warning is logged if some lines run past the right edge of the page. Use a smaller `FontSize` / `MaxLineLength`.
+
+---
+
+# CLI
+
+First, install the extra dependency for coloured output (optional, the CLI also works without it):
+
+```
+pip install "assignmentwriter[cli]"
+```
+
+---
+
+## Usage
+
+**No arguments** — launches an interactive prompt:
+
+```
+assignmentwriter
+```
+
+**Quick create** — just pass your text directly (saved as `assignment.png`):
+
+```
+assignmentwriter "Hello World"
+```
+
+**Pick a paper, font and ink:**
+
+```
+assignmentwriter "Hello World" --paper lined --font caveat --ink black
+```
+
+**Save the image to a file:**
+
+```
+assignmentwriter "Hello World" --save output.png
+```
+
+**Write the text of a file** (keep its line breaks):
+
+```
+assignmentwriter --file notes.txt --keep-line-breaks
+```
+
+**Long text** continues on more pages, saved as `essay_1.png`, `essay_2.png`, ... :
+
+```
+assignmentwriter --file essay.txt --paper spiral --save essay.png
+```
+
+**Save all the pages as one PDF:**
+
+```
+assignmentwriter --file essay.txt --paper spiral --pdf
+```
+
+**Plain output** (just the saved paths, no colors — useful for scripting):
+
+```
+assignmentwriter "Hello World" --as-text
+```
+
+---
+
+## List
+
+See every paper, font and ink:
+
+```
+assignmentwriter list
+```
+
+> **Add `--as-text` to get plain line-by-line output instead of a table.**
+
+## On Some OS
+
+On some operating systems, the CLI may not be available as `assignmentwriter` immediately after installation. If you encounter a "command not found" error, try running it with Python:
+
+```
+python -m assignmentwriter "Hello World"
+```
+
+---
+
+## Fonts and papers
+
+The code is MIT licensed, but the fonts and paper images have their own terms.
+
+## Coffee is love, coffee is life.
+
+https://www.buymeacoffee.com/hritu
+
+## Contributing
+
+Contributions are welcome — open an issue or submit a pull request.
+
+## License
+
+MIT © TheHritu

assignmentwriter-0.1.0.dist-info/RECORD

@@ -0,0 +1,35 @@
+assignmentwriter/__init__.py,sha256=xTrjlQfrqlh7HPAw5YimVFX3raCwjqKu4NjBx2O7peQ,586
+assignmentwriter/__main__.py,sha256=h_jahUCpELtz_fdlRyK7WZtHvizbiOwm2e6QndsXHnk,7710
+assignmentwriter/layouts.py,sha256=qvoYBXDGU_mAjXHfulxKErptCScmmEuhMHvDDSjftEk,3803
+assignmentwriter/modules.py,sha256=XJhvioIuWzbQOk-so0Qm0m8bSkNIVFxwP2M8rkoJYxc,15763
+assignmentwriter/res/fonts/AdineKirnberg.ttf,sha256=bS5LP3jKpVPxDIP81uUjZBPiS3Chhxqphv5WsDjuKnQ,56632
+assignmentwriter/res/fonts/AlanisHand.ttf,sha256=0EUwraVplW7THBHDWoO6kHqNNPgUUi0NR53oh35Exws,36304
+assignmentwriter/res/fonts/Architex.ttf,sha256=prjjPOGQ7pyHFZC5gs_zfhN7MDu3Pcq1XvP_cVS6FDo,30568
+assignmentwriter/res/fonts/GreatVibes-Regular.ttf,sha256=9hhm3pIFM5URLJWfh0Wfa-g14yFKAleEJLPPABwrDTA,105980
+assignmentwriter/res/fonts/Hand_Note.otf,sha256=HXAkV9K0EJS-NHOBWEnVvOGPjvWu-1QySvozZbo3dC4,47280
+assignmentwriter/res/fonts/HomemadeApple.ttf,sha256=sxHwQumubbsyeyOsBHaxay6YoEF1RUGndz-6s7MnmQY,110080
+assignmentwriter/res/fonts/HoneyScript.ttf,sha256=5WTawX0yYmarrQ38lc6EFuAusUW9Ir3NGHOTsxFk734,40952
+assignmentwriter/res/fonts/JottFLF.ttf,sha256=6cQrZRryHdLkUgdE8Uf7h2bqvnyVxMgTg2EVDHo79SQ,43364
+assignmentwriter/res/fonts/NOTICE.md,sha256=L5feAzVoJYndbffFdeuVJ5VyfURwfs2J-NtwRje9qkA,2044
+assignmentwriter/res/fonts/Note_this.ttf,sha256=k3XzcrFqcgjE1RjUXtwCD_SU19Dsji4AScevUZgiC0k,52092
+assignmentwriter/res/fonts/S_Hand.ttf,sha256=5g9I-gNSSenUrKdEqQ1QPjAdSls7ctN6ptF7532vymw,22828
+assignmentwriter/res/fonts/caveat.ttf,sha256=VLiF0Do-0lLFsxJ1riNBhYVFer0w3xUNfV5KM5J6WZE,196984
+assignmentwriter/res/fonts/pleasewritemeasong.ttf,sha256=qL6JlJu0zwesCYIEb5q-5HPVYFemr5fUw9TQsE2BW0Y,38356
+assignmentwriter/res/papers/a4paper.jpg,sha256=6h93xOjYCyx_fTwPdpLU7RS21Vv5WrDsq91-auS0dJ0,140601
+assignmentwriter/res/papers/cream.jpg,sha256=EOWFBjmqDYnbbtbS8DQYT48j4AS1HZO4R56QxPnS79Q,77624
+assignmentwriter/res/papers/cyan.jpg,sha256=FKzgtWC8oh2ikW14Guw63LJZf5oHG10ctlPj4OuYPlA,103933
+assignmentwriter/res/papers/lightblue.jpg,sha256=1sVdyEsV6aj6okrIci5L8zlZGxHjU8EvQfhfIlodRi8,77880
+assignmentwriter/res/papers/lightgreen.jpg,sha256=I91qSWXyILIftPgS9eTXEriQu414N7VPw47YaS4KaUE,91836
+assignmentwriter/res/papers/lime.jpg,sha256=CDRlslSiPLZ1yxzVg8L0ye_EcRPfUeRnwwpPIisHOh8,112593
+assignmentwriter/res/papers/lined.png,sha256=RUf5ivb3sw46b9i6M4kKWSUE-RBylb2XYjQmBE0ATgs,2305592
+assignmentwriter/res/papers/orange.jpg,sha256=-TSeh4nH2-EhqcM-NwfZL8g9YpVL-0Rqe9hHfgkSPmM,100508
+assignmentwriter/res/papers/pink.jpg,sha256=9dclq7jkdl-yHbVeRa8H_sQ_eThBx7r_aTBmE0JTT8U,78830
+assignmentwriter/res/papers/rough.jpg,sha256=m2GFLoxXo0ZDgzqFI83aNwtYCUPNwBtuasqZAszUy60,317604
+assignmentwriter/res/papers/spiral.png,sha256=P0Tr21UXCouvWHUtrJdg7hb3KxLcDd_6aJdYRasPdeM,337063
+assignmentwriter/res/papers/wrinkled.jpg,sha256=fcbTFn-qI50vAY9Oe4if_XfEwTXESVDYnFddVTq4L6Q,595520
+assignmentwriter-0.1.0.dist-info/licenses/LICENSE,sha256=nrgi-zHEF-8cxgWJLEJeqXvxXTjoQVhyvHvzY6YX8fs,1064
+assignmentwriter-0.1.0.dist-info/METADATA,sha256=v9y1O0h7GVkbGkHHjeX0nVZ1SpxJqe489FhQehy6zb0,9215
+assignmentwriter-0.1.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+assignmentwriter-0.1.0.dist-info/entry_points.txt,sha256=TnOxv3Toq5M8O7pVbBWBAfZDaJ_sOGPhBUPXHRMa_Fk,68
+assignmentwriter-0.1.0.dist-info/top_level.txt,sha256=co7qlkBoJDS00g7hBmeVthVA_vTzbo3xQitl3gRbd8c,17
+assignmentwriter-0.1.0.dist-info/RECORD,,

assignmentwriter-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

assignmentwriter-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+assignmentwriter = assignmentwriter.__main__:main

assignmentwriter-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 TheHritu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

assignmentwriter-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+assignmentwriter