learnlog 0.1__py3-none-any.whl

learnlog/__init__.py

@@ -0,0 +1,100 @@
+"""Automatic logging of student code development.
+
+Import this module to record every program run: source code changes,
+command-line arguments, stdin/stdout/stderr, and errors.  Data is
+stored in a hidden ``.learnlog/`` Git repository.
+"""
+
+import sys
+import os
+import datetime
+import atexit
+import traceback
+
+from learnlog.capture import IOLog, StreamCapture, InputCapture
+from learnlog.gitrepo import LearnlogRepo
+
+repo = None
+iolog = None
+original_stdout = None
+original_stderr = None
+original_stdin = None
+exception_info = None
+start_time = None
+main_script = None
+main_args = None
+
+
+def initialize():
+    """Set up learnlog: detect script, init repo, wrap streams.
+
+    Called automatically on import.  Safe to call multiple times;
+    subsequent calls are no-ops.
+    """
+    global repo, iolog, start_time, main_script, main_args
+    global original_stdout, original_stderr, original_stdin
+
+    if repo is not None:
+        return
+
+    try:
+        main_script = os.path.basename(sys.argv[0])
+        main_args = sys.argv[1:]
+        start_time = datetime.datetime.now()
+        workdir = os.getcwd()
+        repo = LearnlogRepo(workdir)
+        repo.begin_run(main_script, main_args, start_time)
+        iolog = IOLog()
+        original_stdout = sys.stdout
+        original_stderr = sys.stderr
+        original_stdin = sys.stdin
+        sys.stdout = StreamCapture(original_stdout, "stdout", iolog)
+        sys.stderr = StreamCapture(original_stderr, "stderr", iolog)
+        sys.stdin = InputCapture(original_stdin, iolog)
+        original_excepthook = sys.excepthook
+
+        def exception_hook(exc_type, exc_value, exc_tb):
+            global exception_info
+            exception_info = "".join(
+                traceback.format_exception(exc_type, exc_value, exc_tb)
+            )
+            original_excepthook(exc_type, exc_value, exc_tb)
+
+        sys.excepthook = exception_hook
+        atexit.register(on_exit)
+    except Exception:
+        pass
+
+
+def on_exit():
+    """Finalise the learnlog entry on program exit.
+
+    Restores original streams and commits the I/O log, exception
+    information, and exit status.
+    """
+    global repo, iolog, exception_info
+    global original_stdout, original_stderr, original_stdin
+
+    if repo is None:
+        return
+
+    try:
+        if original_stdout is not None:
+            sys.stdout = original_stdout
+        if original_stderr is not None:
+            sys.stderr = original_stderr
+        if original_stdin is not None:
+            sys.stdin = original_stdin
+        end_time = datetime.datetime.now()
+        io_text = iolog.getvalue() if iolog else ""
+        repo.finalize_run(
+            io_log=io_text,
+            exception_info=exception_info,
+            end_time=end_time,
+            exit_code=0 if exception_info is None else 1,
+        )
+    except Exception:
+        pass
+
+
+initialize()

learnlog/capture.py

@@ -0,0 +1,127 @@
+"""Stream capture wrappers for stdout, stderr, and stdin.
+
+Provides transparent tee-like wrappers that record all I/O to a shared
+buffer while passing data through to the original streams unchanged.
+"""
+
+import io
+import threading
+
+MAX_IOLOG_BYTES = 1_000_000
+
+
+class IOLog:
+    """Thread-safe shared buffer for interleaved I/O logging.
+
+    Each line is prefixed with the stream name (stdout, stderr, stdin)
+    to show the origin.  The buffer is capped at ``max_bytes`` to
+    prevent unbounded memory growth.
+    """
+
+    def __init__(self, max_bytes=MAX_IOLOG_BYTES):
+        self.max_bytes = max_bytes
+        self.lock = threading.Lock()
+        self.buf = io.StringIO()
+        self.size = 0
+        self.truncated = False
+
+    def log(self, prefix, text):
+        """Log ``text`` with ``prefix`` (e.g. ``'stdout'``).
+
+        Each line of ``text`` gets its own prefixed entry.
+        If the buffer is full, further writes are silently dropped.
+        """
+        if not text:
+            return
+        with self.lock:
+            if self.truncated:
+                return
+            for line in text.splitlines(keepends=True):
+                entry = f"{prefix}: {line}"
+                if self.size + len(entry) > self.max_bytes:
+                    self.buf.write(
+                        "\n[learnlog: I/O log truncated "
+                        f"at {self.max_bytes} bytes]\n"
+                    )
+                    self.truncated = True
+                    return
+                self.buf.write(entry)
+                self.size += len(entry)
+
+    def getvalue(self):
+        """Return the full log contents as a string."""
+        with self.lock:
+            return self.buf.getvalue()
+
+
+class StreamCapture:
+    """Transparent tee wrapper for an output stream.
+
+    Passes all writes through to the original stream while logging
+    them to a shared :class:`IOLog` with the given prefix.
+    """
+
+    def __init__(self, original, name, iolog):
+        self._original = original
+        self._name = name
+        self._iolog = iolog
+
+    def write(self, text):
+        """Write ``text`` to the original stream and log it."""
+        self._iolog.log(self._name, text)
+        return self._original.write(text)
+
+    def writelines(self, lines):
+        """Write an iterable of strings."""
+        for line in lines:
+            self.write(line)
+
+    def flush(self):
+        """Flush the original stream."""
+        return self._original.flush()
+
+    def __getattr__(self, name):
+        return getattr(self._original, name)
+
+
+class InputCapture:
+    """Transparent tee wrapper for an input stream.
+
+    Passes all reads through from the original stream while logging
+    the data read to a shared :class:`IOLog`.
+    """
+
+    def __init__(self, original, iolog):
+        self._original = original
+        self._iolog = iolog
+
+    def readline(self, limit=-1):
+        """Read a line from the original stream and log it."""
+        line = self._original.readline(limit)
+        self._iolog.log("stdin", line)
+        return line
+
+    def read(self, size=-1):
+        """Read from the original stream and log it."""
+        data = self._original.read(size)
+        self._iolog.log("stdin", data)
+        return data
+
+    def readlines(self, hint=-1):
+        """Read lines from the original stream and log them."""
+        lines = self._original.readlines(hint)
+        for line in lines:
+            self._iolog.log("stdin", line)
+        return lines
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        line = self.readline()
+        if not line:
+            raise StopIteration
+        return line
+
+    def __getattr__(self, name):
+        return getattr(self._original, name)

learnlog/cli.py

@@ -0,0 +1,368 @@
+"""Command-line interface for learnlog.
+
+Provides the ``learnlog`` command with subcommands for exporting
+and playing back the development log stored in ``.learnlog/``.
+"""
+
+from __future__ import annotations
+
+import os
+import pathlib
+import subprocess
+import sys
+import tempfile
+from typing import Annotated, Optional
+
+import typer
+
+from learnlog.gitrepo import LearnlogRepo
+
+DEFAULT_BUNDLE_NAME = "learnlog.bundle"
+
+
+def find_learnlog_dir(start=None):
+    """Walk up from ``start`` to find a ``.learnlog/`` directory.
+
+    Returns the directory containing ``.learnlog/``, or ``None``
+    if no learnlog repository is found.
+    """
+    path = pathlib.Path(start or os.getcwd()).resolve()
+    while True:
+        if (path / ".learnlog").is_dir():
+            return path
+        parent = path.parent
+        if parent == path:
+            return None
+        path = parent
+
+
+def resolve_source(source=None):
+    """Resolve a source into a ``(LearnlogRepo, tmpdir)`` pair.
+
+    ``source`` can be ``None`` (search current directory),
+    a directory path, or a bundle file.  When a bundle is used,
+    ``tmpdir`` is the temporary directory that should be cleaned
+    up by the caller; otherwise it is ``None``.
+    """
+    if source is None:
+        workdir = find_learnlog_dir()
+        if workdir is None:
+            raise SystemExit(
+                "No .learnlog/ directory found. "
+                "Run this from a learnlog-tracked project."
+            )
+        return LearnlogRepo(workdir), None
+
+    path = pathlib.Path(source).resolve()
+
+    if path.is_dir():
+        if not (path / ".learnlog").is_dir():
+            raise SystemExit(f"No .learnlog/ directory in {path}")
+        return LearnlogRepo(path), None
+
+    if not path.is_file():
+        raise SystemExit(f"Not a file or directory: {path}")
+
+    verify = subprocess.run(
+        ["git", "bundle", "verify", str(path)],
+        capture_output=True,
+        text=True,
+    )
+    if verify.returncode != 0:
+        raise SystemExit(f"Not a valid bundle file: {path}")
+
+    tmpdir = tempfile.mkdtemp(prefix="learnlog-play-")
+    tmppath = pathlib.Path(tmpdir)
+
+    subprocess.run(
+        ["git", "clone", str(path), str(tmppath / "repo")],
+        capture_output=True,
+        text=True,
+        check=True,
+    )
+
+    cloned = tmppath / "repo"
+    (cloned / ".git").rename(cloned / ".learnlog")
+
+    return LearnlogRepo(cloned), tmpdir
+
+
+def get_commits(repo):
+    """Return a list of commits in chronological order.
+
+    Each entry is a dict with ``hash``, ``subject``, and
+    ``date`` keys.
+    """
+    result = repo.git("log", "--format=%H\t%s\t%aI", "--reverse")
+    if result.returncode != 0:
+        return []
+    commits = []
+    for line in result.stdout.strip().split("\n"):
+        if not line:
+            continue
+        parts = line.split("\t", 2)
+        if len(parts) == 3:
+            commits.append(
+                {
+                    "hash": parts[0],
+                    "subject": parts[1],
+                    "date": parts[2],
+                }
+            )
+    return commits
+
+
+def get_commit_detail(repo, commit_hash):
+    """Return detailed information for a single commit.
+
+    Returns a dict with ``message`` (full commit message) and
+    ``diff`` (unified diff against parent).
+    """
+    msg_result = repo.git("log", "-1", "--format=%B", commit_hash)
+    message = msg_result.stdout.rstrip("\n")
+
+    parent_result = repo.git("rev-parse", commit_hash + "^")
+    if parent_result.returncode == 0:
+        diff_result = repo.git("diff", parent_result.stdout.strip(), commit_hash)
+    else:
+        diff_result = repo.git("diff", "--root", commit_hash)
+    diff = diff_result.stdout
+
+    return {"message": message, "diff": diff}
+
+
+def do_export(repo, output):
+    """Export the learnlog repository as a Git bundle.
+
+    Creates a bundle file at ``output`` containing the full
+    commit history.
+    """
+    result = repo.git("bundle", "create", str(output), "--all")
+    if result.returncode != 0:
+        raise SystemExit(f"Failed to create bundle: {result.stderr}")
+
+
+class PlaybackViewer:
+    """Interactive curses-based commit viewer.
+
+    Displays commits one at a time with vi-style navigation:
+    ``H``/``L`` for previous/next commit, ``j``/``k`` for
+    scrolling within a commit, ``q`` to quit.
+    """
+
+    def __init__(self, repo, commits, start_index=0):
+        self.repo = repo
+        self.commits = commits
+        self.index = start_index
+        self.scroll = 0
+        self._detail_cache = {}
+
+    def run(self):
+        """Enter curses mode and run the interactive viewer."""
+        import curses
+
+        curses.wrapper(self._main_loop)
+
+    def _main_loop(self, stdscr):
+        """Main event loop inside curses."""
+        import curses
+
+        curses.curs_set(0)
+        stdscr.clear()
+
+        while True:
+            self._draw(stdscr)
+            key = stdscr.getch()
+            if not self._handle_key(key):
+                break
+
+    def _get_detail(self, commit_hash):
+        """Fetch and cache commit detail."""
+        if commit_hash not in self._detail_cache:
+            self._detail_cache[commit_hash] = get_commit_detail(self.repo, commit_hash)
+        return self._detail_cache[commit_hash]
+
+    def _draw(self, stdscr):
+        """Render the current commit to the screen."""
+        stdscr.erase()
+        height, width = stdscr.getmaxyx()
+
+        commit = self.commits[self.index]
+        detail = self._get_detail(commit["hash"])
+
+        header = (
+            f"[{self.index + 1}/{len(self.commits)}] "
+            f"{commit['hash'][:7]} "
+            f"— {commit['subject']}"
+        )
+        header = header[: width - 1]
+        try:
+            import curses
+
+            stdscr.addstr(0, 0, header, curses.A_REVERSE)
+            stdscr.addstr(
+                0,
+                len(header),
+                " " * (width - len(header) - 1),
+                curses.A_REVERSE,
+            )
+        except curses.error:
+            pass
+        content_text = detail["message"]
+        if detail["diff"]:
+            content_text += "\n\n" + detail["diff"]
+        content_lines = content_text.split("\n")
+        content_start = 1
+        content_end = height - 2
+        visible = content_end - content_start
+
+        self.scroll = max(
+            0,
+            min(self.scroll, len(content_lines) - visible),
+        )
+
+        for i in range(visible):
+            line_idx = self.scroll + i
+            if line_idx >= len(content_lines):
+                break
+            line = content_lines[line_idx][: width - 1]
+            try:
+                stdscr.addstr(content_start + i, 0, line)
+            except curses.error:
+                pass
+        footer = (
+            " H/\u2190: prev  L/\u2192: next  "
+            "j/\u2193: down  k/\u2191: up  "
+            "g: first  G: last  q: quit"
+        )
+        footer = footer[: width - 1]
+        try:
+            import curses
+
+            stdscr.addstr(height - 1, 0, footer, curses.A_REVERSE)
+            remaining = width - len(footer) - 1
+            if remaining > 0:
+                stdscr.addstr(
+                    height - 1,
+                    len(footer),
+                    " " * remaining,
+                    curses.A_REVERSE,
+                )
+        except curses.error:
+            pass
+
+        stdscr.refresh()
+
+    def _handle_key(self, key):
+        """Process a keypress.  Return ``False`` to quit."""
+        import curses
+
+        if key in (ord("q"), ord("Q")):
+            return False
+        elif key in (ord("h"), ord("H"), curses.KEY_LEFT):
+            if self.index > 0:
+                self.index -= 1
+                self.scroll = 0
+        elif key in (ord("l"), ord("L"), curses.KEY_RIGHT):
+            if self.index < len(self.commits) - 1:
+                self.index += 1
+                self.scroll = 0
+        elif key in (ord("j"), curses.KEY_DOWN):
+            self.scroll += 1
+        elif key in (ord("k"), curses.KEY_UP):
+            self.scroll = max(0, self.scroll - 1)
+        elif key == ord("g"):
+            self.index = 0
+            self.scroll = 0
+        elif key == ord("G"):
+            self.index = len(self.commits) - 1
+            self.scroll = 0
+
+        return True
+
+
+app = typer.Typer(
+    name="learnlog",
+    help="Review student development logs.",
+    no_args_is_help=True,
+)
+
+
+@app.command()
+def export(
+    output: Annotated[
+        pathlib.Path,
+        typer.Option(
+            "--output",
+            "-o",
+            help="Output bundle file path.",
+        ),
+    ] = pathlib.Path(DEFAULT_BUNDLE_NAME),
+    directory: Annotated[
+        Optional[pathlib.Path],
+        typer.Option(
+            "--dir",
+            "-C",
+            help="Directory containing .learnlog/.",
+        ),
+    ] = None,
+):
+    """Export the learnlog repository as a Git bundle."""
+    workdir = directory
+    if workdir is None:
+        workdir = find_learnlog_dir()
+        if workdir is None:
+            raise SystemExit("No .learnlog/ directory found.")
+    else:
+        workdir = pathlib.Path(workdir).resolve()
+        if not (workdir / ".learnlog").is_dir():
+            raise SystemExit(f"No .learnlog/ directory in {workdir}")
+
+    repo = LearnlogRepo(workdir)
+    do_export(repo, output.resolve())
+    typer.echo(f"Exported to {output}")
+
+
+@app.command()
+def play(
+    source: Annotated[
+        Optional[str],
+        typer.Argument(
+            help=(
+                "Source: directory with .learnlog/ "
+                "or a .bundle file. "
+                "Defaults to current directory."
+            ),
+        ),
+    ] = None,
+    start: Annotated[
+        Optional[str],
+        typer.Option(
+            "--start",
+            help="Commit hash to start playback from.",
+        ),
+    ] = None,
+):
+    """Interactively play back the development log."""
+    import shutil
+
+    repo, tmpdir = resolve_source(source)
+    try:
+        commits = get_commits(repo)
+        if not commits:
+            raise SystemExit("No commits found.")
+
+        start_index = 0
+        if start:
+            for i, c in enumerate(commits):
+                if c["hash"].startswith(start):
+                    start_index = i
+                    break
+            else:
+                raise SystemExit(f"Commit {start} not found.")
+
+        viewer = PlaybackViewer(repo, commits, start_index)
+        viewer.run()
+    finally:
+        if tmpdir is not None:
+            shutil.rmtree(tmpdir, ignore_errors=True)

learnlog/gitrepo.py

@@ -0,0 +1,171 @@
+"""Git repository management for learnlog.
+
+Manages a hidden ``.learnlog/`` Git repository that tracks source code
+changes and run metadata using the student's working directory as the
+work tree.
+"""
+
+import subprocess
+import os
+import pathlib
+import datetime
+
+
+class LearnlogRepo:
+    """Manages a ``.learnlog/`` Git repository.
+
+    Uses ``--git-dir=.learnlog --work-tree=.`` so the student's
+    working directory is the work tree.  The ``.learnlog/`` directory
+    contains only Git internals.
+    """
+
+    def __init__(self, workdir):
+        self.workdir = pathlib.Path(workdir)
+        self.git_dir = self.workdir / ".learnlog"
+        self.env = {
+            **os.environ,
+            "GIT_DIR": str(self.git_dir),
+            "GIT_WORK_TREE": str(self.workdir),
+        }
+        if not self.git_dir.exists():
+            self.init_repo()
+
+    def git(self, *args):
+        """Run a Git command with the learnlog environment.
+
+        Returns the ``CompletedProcess`` object.  Raises no exception
+        on non-zero exit codes---callers check ``returncode`` themselves.
+        """
+        return subprocess.run(
+            ["git"] + list(args),
+            cwd=str(self.workdir),
+            env=self.env,
+            capture_output=True,
+            text=True,
+            timeout=10,
+        )
+
+    def init_repo(self):
+        """Initialise a new ``.learnlog/`` Git repository.
+
+        Creates the repository, sets a fallback committer identity
+        (only if the student has none configured globally), sets up
+        exclusion patterns, and makes an initial commit of all files.
+        """
+        self.git("init")
+        name_check = self.git("config", "user.name")
+        if name_check.returncode != 0:
+            self.git("config", "user.name", "learnlog")
+            self.git("config", "user.email", "learnlog@localhost")
+        self.git("config", "commit.gpgsign", "false")
+
+        exclude_dir = self.git_dir / "info"
+        exclude_dir.mkdir(parents=True, exist_ok=True)
+        exclude_file = exclude_dir / "exclude"
+        patterns = [
+            ".learnlog",
+            "__pycache__",
+            "*.pyc",
+            ".venv",
+            "venv",
+            "env",
+        ]
+        ignore_file = self.workdir / ".learnlogignore"
+        if ignore_file.exists():
+            patterns.extend(ignore_file.read_text().splitlines())
+        exclude_file.write_text("\n".join(patterns) + "\n")
+        self.git("add", ".")
+        self.git(
+            "commit",
+            "--allow-empty",
+            "-m",
+            "learnlog: initial commit",
+        )
+
+    def begin_run(self, script, args, start_time):
+        """Record the start of a program run.
+
+        Stages all files.  If there are changes, creates a new commit
+        with the run header.  If no files changed, amends the previous
+        commit to append a new run block.
+
+        Returns the run header string (needed by :meth:`finalize_run`).
+        """
+        header = format_run_header(script, args, start_time)
+
+        self.git("add", ".")
+        diff = self.git("diff", "--cached", "--quiet")
+        has_changes = diff.returncode != 0
+
+        if has_changes:
+            self.git("commit", "-m", header)
+        else:
+            existing = self.git("log", "-1", "--format=%B").stdout.rstrip("\n")
+            combined = existing + "\n\n---\n\n" + header
+            self.git(
+                "commit",
+                "--amend",
+                "--allow-empty",
+                "-m",
+                combined,
+            )
+
+        return header
+
+    def finalize_run(self, io_log, exception_info, end_time, exit_code):
+        """Complete the current run block with results.
+
+        Amends the current commit to append I/O log, exception
+        information, end time, and exit code.
+        """
+        existing = self.git("log", "-1", "--format=%B").stdout.rstrip("\n")
+
+        trailer = format_run_trailer(io_log, exception_info, end_time, exit_code)
+        combined = existing + "\n" + trailer
+
+        self.git("add", ".")
+        self.git(
+            "commit",
+            "--amend",
+            "--allow-empty",
+            "-m",
+            combined,
+        )
+
+
+def format_run_header(script, args, start_time):
+    """Format a run header block.
+
+    The header records which script was run, its arguments, and
+    the start time.
+    """
+    args_str = " ".join(args) if args else "(none)"
+    return (
+        f"Run: {script} {args_str}\n"
+        f"\n"
+        f"Script: {script}\n"
+        f"Arguments: {args_str}\n"
+        f"Start-Time: {start_time.isoformat()}"
+    )
+
+
+def format_run_trailer(io_log, exception_info, end_time, exit_code):
+    """Format the trailer appended by :func:`finalize_run`.
+
+    Contains the end time, exit code, I/O log, and exception
+    information.
+    """
+    parts = [
+        f"End-Time: {end_time.isoformat()}",
+        f"Exit-Code: {exit_code}",
+        "",
+        "--- I/O ---",
+        io_log.rstrip("\n") if io_log else "(no I/O)",
+        "",
+        "--- exception ---",
+    ]
+    if exception_info:
+        parts.append(exception_info)
+    else:
+        parts.append("None")
+    return "\n".join(parts)

learnlog-0.1.dist-info/METADATA

@@ -0,0 +1,24 @@
+Metadata-Version: 2.4
+Name: learnlog
+Version: 0.1
+Summary: Automatic logging of student code development and test runs
+License-Expression: MIT
+License-File: LICENSE
+Author: Daniel Bosk
+Author-email: daniel@bosk.se
+Maintainer: Daniel Bosk
+Maintainer-email: dbosk@kth.se
+Requires-Python: >=3.9
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Education
+Classifier: Topic :: Education
+Requires-Dist: typer (>=0.9.0)
+Project-URL: Bug Tracker, https://github.com/dbosk/learnlog/issues
+Project-URL: Repository, https://github.com/dbosk/learnlog
+Description-Content-Type: text/markdown
+
+# learnlog
+A Python package to log students' code development and test runs
+

learnlog-0.1.dist-info/RECORD

@@ -0,0 +1,9 @@
+learnlog/__init__.py,sha256=QbotR1ftNkO_PlPONx5YwbfzU2EAilS5BJUwP4ckwAE,2867
+learnlog/capture.py,sha256=FyBgPCgdoknru7ApQHQXwUryIzvqJrPyE7aWr0BzT1M,3723
+learnlog/cli.py,sha256=eM5W8-0sggZZuhMu7h0LbCJIZmwPJPuFgmGyjHQXg98,10492
+learnlog/gitrepo.py,sha256=jzTbXpJwHvMTV3aebmWIE_OOBRObyFTa74VbDpXOLGo,5185
+learnlog-0.1.dist-info/METADATA,sha256=-bYg831stjxTX6vzv-ufYTx0nN5TqdiIJ78w9Pd-uPA,787
+learnlog-0.1.dist-info/WHEEL,sha256=kJCRJT_g0adfAJzTx2GUMmS80rTJIVHRCfG0DQgLq3o,88
+learnlog-0.1.dist-info/entry_points.txt,sha256=h10KfHcC6k27VD_y6ivVUP009rNN3DuhQCfytHucIDk,45
+learnlog-0.1.dist-info/licenses/LICENSE,sha256=2PATyJy5V39EFgi7-7OJEPK51uzwT7vrNR7PECdpLs0,1074
+learnlog-0.1.dist-info/RECORD,,

learnlog-0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 2.3.1
+Root-Is-Purelib: true
+Tag: py3-none-any

learnlog-0.1.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+learnlog=learnlog.cli:app
+

learnlog-0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023, 2026 Daniel Bosk
+
+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.