vondb 3.0.0__py3-none-any.whl

von/__init__.py

@@ -0,0 +1,3 @@
+__author__ = "Evan Chen"
+__version__ = "1.0.0"
+__date__ = "August 3, 2016"

von/__main__.py

@@ -0,0 +1,15 @@
+import sys
+
+from . import term
+
+
+def main():
+    cmd = term.VonTerminal()
+    if len(sys.argv) == 1:
+        cmd.run()
+    else:
+        cmd.direct(sys.argv[1:])  # to preserve command line quotes etc
+
+
+if __name__ == "__main__":
+    main()

von/api.py

@@ -0,0 +1,67 @@
+# For importing von externally
+import sys
+
+from . import model
+from .puid import inferPUID
+
+sys.modules["model"] = model
+
+index = model.VonIndex().store  # get the underlying dict
+
+source_to_puid_lookup = {inferPUID(source): source for source in index}
+
+
+def has(source: str) -> bool:
+    """Checks whether a given source exists in database"""
+    return source in index
+
+
+def has_solution(source: str) -> bool:
+    """Checks whether a given source exists in database AND has a solution"""
+    if not has(source):
+        return False
+    entry = index[source]
+    return len(entry.full.bodies) > 1
+
+
+def get_index(source: str, brave=False) -> model.PickleMappingEntry | None:
+    """Returns the index entry for a given source, or None"""
+    entry = index.get(source)
+
+    if entry is None:
+        puid = source.upper()
+        for index_source, index_entry in index.items():
+            if puid == inferPUID(index_source):
+                entry = index_entry
+                break
+
+    if entry is not None and entry.secret:
+        assert brave, f"{entry} requires security clearance"
+    return entry
+
+
+def get(source: str, brave=False) -> model.Problem:
+    """Returns the full data for a given source"""
+    entry = get_index(source, brave)
+    assert entry is not None, f"{source} is None"
+    return entry.full
+
+
+def get_statement(source: str, brave=False) -> str:
+    """Returns just the problem statement for a given source"""
+    return get(source, brave).bodies[0]
+
+
+def get_solution(source: str, brave=False) -> str:
+    """Returns just the solution for a given source (asserts existence)"""
+    bodies = get(source, brave).bodies
+    assert len(bodies) > 1, f"{source} has no solution"
+    return bodies[1]
+
+
+def get_puid(source: str) -> str:
+    return inferPUID(source)
+
+
+def get_source(puid: str) -> str | None:
+    return source_to_puid_lookup.get(puid)

von/clipboard.py

@@ -0,0 +1,21 @@
+try:
+    import pyperclip
+except ModuleNotFoundError:
+    PYPERCLIP_AVAILABLE = False
+    pyperclip = None
+else:
+    PYPERCLIP_AVAILABLE = True
+
+
+def get_clipboard() -> str:
+    if PYPERCLIP_AVAILABLE:
+        assert pyperclip is not None
+        return pyperclip.paste().strip()
+    else:
+        return ""
+
+
+def set_clipboard(s: str):
+    if PYPERCLIP_AVAILABLE:
+        assert pyperclip is not None
+        pyperclip.copy(s)

von/controller/__init__.py

@@ -0,0 +1,46 @@
+from . import (  # NOQA
+    add,
+    asy,
+    br,
+    cd,
+    clear,
+    edit,
+    index,
+    link,
+    markup,
+    nuke,
+    paths,
+    po,
+    search,
+    show,
+    solve,
+    status,
+)
+
+
+class VonController:
+    def do_ls(self, argv: list[str]):
+        self.do_cd(["."] + argv)
+
+    do_add = add.main
+    do_asy = asy.main
+    do_br = br.main
+    do_cd = cd.main
+    do_clear = clear.main
+    do_cs = do_cd
+    do_edit = edit.main
+    do_f = show.main  # alias find
+    do_link = link.main
+    do_m = markup.main
+    do_markup = markup.main
+    do_index = index.main
+    do_nuke = nuke.main
+    do_paths = paths.main
+    do_po = po.main
+    do_s = search.main
+    do_search = search.main
+    do_show = show.main
+    do_solve = solve.main
+    do_solve = solve.main
+    do_ss = status.main
+    do_status = status.main

von/controller/add.py

@@ -0,0 +1,224 @@
+import datetime
+import logging
+import os
+import re
+import subprocess
+import tempfile
+import traceback
+from argparse import Namespace
+from typing import Any, Callable
+
+import yaml
+from yaml.scanner import ScannerError
+
+from .. import model, view
+from ..clipboard import get_clipboard
+from ..puid import inferPUID
+from ..rc import EDITOR, NSEPARATOR, SEPARATOR, TAG_HINT_TEXT
+from . import preview
+
+# https://urlregex.com/
+RE_URL = re.compile(
+    r"http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@.&+]|[!*\(\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+"
+)
+
+
+def user_file_input(
+    initial="",
+    extension=".tmp",
+    pre_hook: Callable[[str], None] = None,
+    delete: bool = False,
+):
+    """Opens in $EDITOR a file with content 'initial'
+    and 'extension', and returns edited file.
+    If pre_hook is not None, runs pre_hook(tf.name) before opening EDITOR.
+    If delete is True, delete the file afterwards.
+    """
+
+    with tempfile.NamedTemporaryFile(suffix=extension, delete=False) as tf:
+        tf.write(initial.encode())
+        filename = tf.name
+    if pre_hook is not None:
+        pre_hook(filename)
+    subprocess.run([EDITOR, filename])
+
+    with open(filename, "r") as tf:
+        edited_message = "".join(_ for _ in tf.readlines())
+    if delete:
+        os.unlink(filename)
+    return edited_message
+
+
+def alert_error_tryagain(message=""):
+    """Prints an error message and waits for user to confirm."""
+    logging.error(message)
+    return input("** Press enter to continue: ")
+
+
+PS_INSTRUCT = r"""% Input your problem and solution below.
+% Three dashes on a newline indicate the breaking points.
+% URL detected: {url}
+% TEX root = {preview_path}
+"""
+
+
+def solicit_user_for_content(raw_text: str, url: str, opts: Namespace):
+    del opts
+    initial = (
+        PS_INSTRUCT.format(
+            url=url if url != "<++>" else "None",
+            preview_path=preview.VON_PREVIEW_PATH,
+        )
+        + NSEPARATOR
+        + raw_text
+    )
+
+    def pre_hook(tempfile_name: str):
+        preview.make_preview(tempfile_name)
+
+    while True:
+        # TODO maybe give user instructions
+        raw_ps = user_file_input(
+            initial=initial, extension="von.tex", pre_hook=pre_hook
+        )
+
+        if raw_ps.count(SEPARATOR) >= 1:
+            bodies = [_.strip() for _ in raw_ps.split(SEPARATOR)[1:]]
+            if bodies[0] == "":
+                return None
+            return bodies
+        elif raw_ps.strip() == "":
+            return None
+        else:
+            alert_error_tryagain("Bad format: can't find separator. Try again.")
+            initial = raw_ps
+
+
+DEFAULT_PATH = model.getcwd()
+YAML_DATA_FILE = """# Input your problem metadata here
+
+source: {source}     # e.g. USAMO 2000/6. This must be unique
+desc:   <++>     # e.g. Fiendish inequality
+path:   {path}<++>
+tags:   [{now.year}-{now.month:02d}, <++>]
+url: {url}
+
+{hint}"""
+
+
+def solicit_user_for_yaml(opts: Namespace, url: str) -> None | tuple[str, Any]:
+    if clipboard_text := get_clipboard():
+        if RE_URL.fullmatch(clipboard_text) is not None:
+            url = clipboard_text
+
+    initial = YAML_DATA_FILE.format(
+        path=model.completePath(DEFAULT_PATH),
+        now=datetime.datetime.now(),
+        source="<++>" if opts.source is None else opts.source,
+        hint=TAG_HINT_TEXT,
+        url=url,
+    )
+    while True:
+        raw_yaml = user_file_input(initial=initial, extension="von.yaml", delete=True)
+        try:
+            d = yaml.safe_load(raw_yaml)
+            if d is None:
+                return None
+            assert "path" in d, "Path is mandatory"
+            assert "source" in d, "Source is mandatory"
+            if d["path"][-1] != "/":
+                d["path"] += "/"
+            assert os.path.isdir(d["path"]), d["path"] + " directory non-existent"
+            target = d["path"] + inferPUID(d["source"]) + ".tex"
+            assert not os.path.isfile(target), target + " already taken"
+            assert model.getEntryByKey(d["source"]) is None, (
+                d["source"] + " is already an existing problem source"
+            )
+        except AssertionError:
+            traceback.print_exc()
+            alert_error_tryagain("Assertions failed, please try again.")
+            initial = raw_yaml
+        except ScannerError:
+            traceback.print_exc()
+            alert_error_tryagain("Could not parse YAML, please try again.")
+            initial = raw_yaml
+        else:
+            del d["path"]
+            # darn PyYAML used to do this fine -_-
+            tags = d.pop("tags")
+            output = (
+                yaml.dump(d, default_flow_style=False).strip()
+                + "\n"
+                + "tags: ["
+                + ", ".join(tags)
+                + "]"
+            )
+            return (target, output)
+
+
+def do_add_problem(raw_text: str, url: str, opts: Namespace):
+    """Core procedure. Opens two instances of editors to solicit user input
+    on problem and produce a problem instance."""
+
+    # Get problem and solution
+    bodies = solicit_user_for_content(raw_text, url, opts)
+    if bodies is None:
+        logging.warning("Aborting due to empty input...")
+        return
+
+    yaml_info = solicit_user_for_yaml(opts, url)
+    if yaml_info is None:
+        logging.warning("Aborting due to empty input...")
+        return
+
+    target, out_yaml = yaml_info
+    out_text = NSEPARATOR.join([out_yaml] + bodies)
+    p = model.addProblemByFileContents(target, out_text)
+    assert p is not None
+    model.augmentCache(p.entry)
+    view.printEntry(p.entry)
+
+
+parser = view.Parser(prog="add", description="Adds a problem to VON.")
+parser.add_argument(
+    "source",
+    default=None,
+    nargs="?",
+    help="If specified, sets the source for the new problem.",
+)
+parser.add_argument(
+    "-f",
+    "--file",
+    dest="filename",
+    default=None,
+    help="If specified, uses contents of file as body",
+)
+parser.add_argument(
+    "-u",
+    "--url",
+    default=None,
+    help="Specify a URL on the command line",
+)
+
+
+def main(self: object, argv: list[str]):
+    del self
+    opts = parser.process(argv)
+    opts.verbose = True
+    url = opts.url if opts.url is not None else "<++>"
+    if opts.filename is not None:
+        if not os.path.isfile(opts.filename):
+            logging.error("The file " + opts.filename + " doesn't exist")
+            return
+        with open(opts.filename) as f:
+            initial_text = "".join(f.readlines())
+    else:
+        if clipboard_text := get_clipboard():
+            if RE_URL.fullmatch(clipboard_text) is not None and opts.url is not None:
+                initial_text = "<++>"
+                url = clipboard_text
+            else:
+                initial_text = clipboard_text
+        else:
+            initial_text = "<++>"
+    do_add_problem(initial_text, url, opts)

von/controller/asy.py

@@ -0,0 +1,46 @@
+import logging
+import re
+
+from .. import model, view
+
+parser = view.Parser(
+    prog="asy", description="Prints the diagram from the solution to a problem"
+)
+parser.add_argument("key", help="The key of the problem to open")
+parser.add_argument(
+    "-n",
+    "--number",
+    default=1,
+    type=int,
+    help="Takes the n-th diagram, one-indexed. Defaults to 1.",
+)
+parser.add_argument(
+    "-b",
+    "--body",
+    default=1,
+    type=int,
+    help="Takes the diagram from the b'th body. Defaults to 1.",
+)
+parser.add_argument(
+    "-c",
+    "--comments",
+    action="store_true",
+    help="Decides whether or not commented lines should be displayed",
+)
+
+
+def main(self: object, argv: list[str]):
+    opts = parser.process(argv)
+    entry = model.getEntryByKey(opts.key)
+    if entry is None:
+        logging.error(opts.key + " not found")
+    else:
+        problem = entry.full
+        soln = problem.bodies[opts.body]
+        asys = re.findall(r"\\begin\{asy\}(.+?)\\end\{asy\}", soln, flags=re.DOTALL)
+        assert opts.number >= 1
+        diagram = asys[opts.number - 1]
+
+        if not opts.comments:
+            diagram = re.sub(r"/\*.*?\*/", "", diagram, flags=re.DOTALL)
+        print("\n".join(line.strip() for line in diagram.strip().split("\n")))

von/controller/br.py

@@ -0,0 +1,22 @@
+import logging
+import sys
+import webbrowser
+
+from .. import model, view
+
+parser = view.Parser(prog="br", description="Browse a problem on AoPS")
+parser.add_argument("key", help="The key of the problem to open")
+
+
+def main(self: object, argv: list[str]):
+    opts = parser.process(argv)
+    entry = model.getEntryByKey(opts.key)
+    if entry is None:
+        logging.error(opts.key + " not found")
+    else:
+        url = entry.url
+        if url is None:
+            print("No URL is provided for this problem")
+            sys.exit(1)
+        print(url)
+        webbrowser.open(url)

von/controller/cd.py

@@ -0,0 +1,18 @@
+import os
+
+from .. import model, view
+
+parser = view.Parser(prog="cd", description="Changes the working directory.")
+parser.add_argument("path", help="The path to change to")
+
+
+def main(self: object, argv: list[str]):
+    opts = parser.process(argv)
+    os.chdir(opts.path)
+
+    if not opts.quiet:
+        entries, dirs = model.viewDirectory(model.getCompleteCwd())
+        for d in dirs:
+            view.printDir(d)
+        for e in entries:
+            view.printEntry(e)

von/controller/clear.py

@@ -0,0 +1,7 @@
+from .. import model, view
+
+parser = view.Parser(prog="clear", description="Clears the Cache.")
+
+
+def main(self: object, argv: list[str]):
+    model.clearCache()

von/controller/edit.py

@@ -0,0 +1,45 @@
+import logging
+import subprocess
+
+from .. import model, view
+from ..fzf import fzf_choose
+from ..rc import EDITOR
+from . import preview
+
+parser = view.Parser(prog="edit", description="Opens problem(s) by source name.")
+parser.add_argument(
+    "-a",
+    "--all",
+    action="store_true",
+    dest="all",
+    help="Edit all problems in cache",
+)
+parser.add_argument(
+    "keys",
+    nargs="*",
+    help="The key of the problem to open (either source or cache index).",
+)
+
+
+def main(self: object, argv: list[str]):
+    opts = parser.process(argv)
+    opts.verbose = True
+
+    if opts.all is True:
+        entries = model.readCache()
+    elif len(opts.keys) == 0:
+        entries = [model.getEntryByKey(fzf_choose())]
+    else:
+        entries = [model.getEntryByKey(key) for key in opts.keys]
+    for entry in entries:
+        if entry is None:
+            logging.error("Not found")
+        else:
+            full_path = model.completePath(entry.path)
+            preview.make_preview(full_path)
+            subprocess.call([EDITOR, full_path])  # do editing
+
+            problem = model.makeProblemFromPath(entry.path)
+            new_entry = model.updateEntryByProblem(old_entry=entry, new_problem=problem)
+            # update cache after editing problem
+            view.printEntry(new_entry)

von/controller/index.py

@@ -0,0 +1,9 @@
+from .. import model, view
+
+parser = view.Parser(
+    prog="index", description="Rebuilds the problem index. No arguments."
+)
+
+
+def main(self: object, argv: list[str]):
+    model.rebuildIndex()

von/controller/link.py

@@ -0,0 +1,22 @@
+import logging
+import sys
+
+from .. import model, view
+from ..clipboard import set_clipboard
+
+parser = view.Parser(prog="link", description="Pastes the URL to clipboard")
+parser.add_argument("key", help="The key of the problem to open")
+
+
+def main(self: object, argv: list[str]):
+    opts = parser.process(argv)
+    entry = model.getEntryByKey(opts.key)
+    if entry is None:
+        logging.error(opts.key + " not found")
+    else:
+        url = entry.url
+        if url is None:
+            print("No URL is provided for this problem")
+            sys.exit(1)
+        print(url)
+        set_clipboard(url)

von/controller/markup.py

@@ -0,0 +1,91 @@
+import logging
+
+from .. import model, strparse, view
+from ..fzf import fzf_choose
+
+parser = view.Parser(
+    prog="markup",
+    description="Gives a Markdown version of problem statement for copy-pasting in email etc.",
+)
+parser.add_argument(
+    "keys",
+    nargs="*",
+    help="The key(S) of the problem to open.",
+)
+parser.add_argument(
+    "-p",
+    "--preserve",
+    action="store_true",
+    help="Suppress macro expansion from body.",
+)
+parser_display_modes = parser.add_mutually_exclusive_group()
+
+parser_display_modes.add_argument(
+    "-a",
+    "--aops",
+    action="store_true",
+    help="Returns in AoPS mode.",
+)
+parser_display_modes.add_argument(
+    "-d",
+    "--discord",
+    action="store_true",
+    help="Returns in Discord mode.",
+)
+
+
+def main(self: object, argv: list[str]):
+    opts = parser.process(argv)
+    keys = opts.keys
+    if len(keys) == 0:
+        keys = [fzf_choose()]
+
+    for i, key in enumerate(keys):
+        entry = model.getEntryByKey(key)
+
+        if entry is None:
+            logging.error(opts.key + " not found")
+            return
+        elif entry.secret and not opts.brave:
+            logging.error("Problem can't be shown without --brave option")
+            return
+
+        problem = entry.full
+        statement = problem.bodies[0]
+
+        if opts.aops is True:
+            header = "[b]"
+            if problem.url is not None:
+                header += f"[url={problem.url}]{entry.source}[/url]"
+            else:
+                header += entry.source
+            if problem.author is not None:
+                header += f", proposed by {problem.author}.[/b]"
+            else:
+                header += ".[/b]"
+            view.out(header)
+            view.out(strparse.toAOPS(statement))
+            if i != len(keys) - 1:
+                view.out("\n--------\n")
+        else:
+            header = "## "
+            if problem.url is not None:
+                header += f"[{problem.source}]({problem.url})"
+            else:
+                header += entry.source
+            if problem.author is not None:
+                header += f", proposed by {problem.author}."
+            else:
+                header += "."
+            view.out(header)
+            if opts.discord is True:
+                view.out(r"```latex")
+            else:
+                view.out("")
+            view.out(
+                statement if opts.preserve is True else strparse.demacro(statement)
+            )
+            if opts.discord is True:
+                view.out(r"```")
+            elif i != len(keys) - 1:
+                view.out("\n")

von/controller/nuke.py

@@ -0,0 +1,18 @@
+from pathlib import Path
+
+from .. import model, view
+from ..puid import inferPUID
+from ..rc import VON_BASE_PATH
+
+parser = view.Parser(prog="nuke", description="Fixes all the filenames to match PUID")
+
+
+def main(self: object, argv: list[str]):
+    parser.process(argv)
+    for p in model.getAllProblems():
+        puid = inferPUID(p.source)
+        src = VON_BASE_PATH / Path(p.path)
+        target = VON_BASE_PATH / src.parent / f"{puid}.tex"
+        if not target.exists():
+            src.rename(target)
+    model.rebuildIndex()

von/controller/paths.py

@@ -0,0 +1,10 @@
+from .. import model, view
+
+parser = view.Parser(
+    prog="paths", description="Prints the paths of all files in cache."
+)
+
+
+def main(self: object, argv: list[str]):
+    for entry in model.readCache():
+        print(entry.path)