pyDiffTools 0.1.8__py3-none-any.whl

pydifftools/rearrange_tex.py

@@ -0,0 +1,188 @@
+"""Rearrange TeX files according to a plan file."""
+
+from __future__ import annotations
+
+import argparse
+import pathlib
+import re
+import sys
+from typing import List, Sequence
+
+
+S_CMD = re.compile(
+    r"""^s
+         /((?:\\.|[^/])*)   # pattern
+         /((?:\\.|[^/])*)   # replacement
+         /([gi]{0,2})$      # flags
+    """,
+    re.VERBOSE,
+)
+
+
+def unescape_slashes(s: str) -> str:
+    return s.replace(r"\/", "/")
+
+
+def apply_s_cmd(line: str, cmd: str):
+    m = S_CMD.match(cmd)
+    if not m:
+        raise ValueError(f"Bad s/// command: {cmd!r}")
+    pat_raw, rep_raw, flags = m.groups()
+    pat = unescape_slashes(pat_raw)
+    rep = unescape_slashes(rep_raw)
+    reflags = re.IGNORECASE if "i" in flags else 0
+    count = 0 if "g" in flags else 1
+    # Use re.subn so callers can tell whether the substitution matched any text.
+    result, replaced = re.subn(pat, rep, line, count=count, flags=reflags)
+    return result, replaced
+
+
+def parse_plan_line(s: str):
+    s = s.rstrip("\n")
+    if not s.strip():
+        return ("comment", "")
+    stripped = s.lstrip()
+    if stripped.startswith("#"):
+        return ("comment", stripped[1:].strip())
+    line = stripped
+    idx = 0
+    while idx < len(line) and not line[idx].isspace():
+        idx += 1
+    line_token = line[:idx]
+    # Allow plans to specify either a single source line or an inclusive range like "10-20".
+    if "-" in line_token:
+        range_parts = line_token.split("-")
+        if len(range_parts) != 2:
+            raise ValueError(f"Bad line range in plan: {line_token!r}")
+        start = int(range_parts[0])
+        end = int(range_parts[1])
+        if end < start:
+            raise ValueError(f"Line range out of order: {line_token!r}")
+        line_numbers = list(range(start, end + 1))
+    else:
+        line_numbers = [int(line_token)]
+    scratch = False
+    s_cmds = []
+    pos = idx
+    # Walk the remainder of the line manually so spaces inside s/// survive tokenization.
+    while pos < len(line):
+        while pos < len(line) and line[pos].isspace():
+            pos += 1
+        if pos >= len(line):
+            break
+        if line[pos : pos + 7].lower() == "scratch" and (
+            pos + 7 == len(line) or line[pos + 7].isspace()
+        ):
+            scratch = True
+            pos += 7
+            continue
+        if line.startswith("s/", pos):
+            start = pos
+            pos += 2
+            slash_count = 0
+            while pos < len(line):
+                ch = line[pos]
+                if ch == "\\":
+                    pos += 2
+                    continue
+                if ch == "/":
+                    slash_count += 1
+                    pos += 1
+                    if slash_count == 2:
+                        while pos < len(line) and line[pos] in "gi":
+                            pos += 1
+                        cmd = line[start:pos]
+                        if not S_CMD.match(cmd):
+                            raise ValueError(f"Bad token in plan: {cmd!r}")
+                        s_cmds.append(cmd)
+                        break
+                    continue
+                pos += 1
+            else:
+                raise ValueError(f"Unterminated s/// command in plan: {line!r}")
+            continue
+        end = pos
+        while end < len(line) and not line[end].isspace():
+            end += 1
+        bad = line[pos:end]
+        raise ValueError(f"Bad token in plan: {bad!r}")
+    return ("directive", line_numbers, scratch, s_cmds)
+
+
+def run(argv: Sequence[str] | None = None) -> None:
+    parser = argparse.ArgumentParser(
+        prog="pydifftools rearrange", description="Rearrange TeX file lines"
+    )
+    parser.add_argument(
+        "tex_path", type=pathlib.Path, help="TeX file (modified in place)"
+    )
+    parser.add_argument(
+        "plan_path", type=pathlib.Path, help="Rearrangement plan file (.rrng)"
+    )
+    args = parser.parse_args(argv)
+
+    tex_lines = args.tex_path.read_text(encoding="utf-8").splitlines(keepends=False)
+    n = len(tex_lines)
+
+    items = []
+    used: List[int] = []
+    with args.plan_path.open("r", encoding="utf-8") as f:
+        for raw in f:
+            kind, *rest = parse_plan_line(raw)
+            if kind == "comment":
+                items.append(("comment", rest[0]))
+            else:
+                line_numbers, scratch, s_cmds = rest
+                for ln in line_numbers:
+                    if not (1 <= ln <= n):
+                        raise ValueError(f"Line number {ln} out of range 1..{n}")
+                items.append(("directive", line_numbers, scratch, s_cmds))
+                used.extend(line_numbers)
+
+    missing = sorted(set(range(1, n + 1)) - set(used))
+    dupes = sorted([x for x in set(used) if used.count(x) > 1])
+    if missing:
+        sys.exit(f"ERROR: Plan missing lines: {missing}")
+    if dupes:
+        sys.exit(f"ERROR: Plan duplicated lines: {dupes}")
+
+    out_main: List[str] = []
+    out_scratch: List[str] = []
+    for it in items:
+        if it[0] == "comment":
+            out_main.append("% " + it[1])
+            continue
+        _, line_numbers, scratch, s_cmds = it
+        # Track how many replacements each substitution performs across the
+        # referenced lines so we can surface errors when a pattern never
+        # matches.  This mirrors the Perl s/// behavior the tool emulates.
+        replaced_counts = [0] * len(s_cmds)
+        for ln in line_numbers:
+            mod = tex_lines[ln - 1]
+            for idx, cmd in enumerate(s_cmds):
+                mod, replaced = apply_s_cmd(mod, cmd)
+                replaced_counts[idx] += replaced
+            if scratch:
+                out_scratch.append("% " + mod)
+            else:
+                out_main.append(mod)
+        for idx, replaced in enumerate(replaced_counts):
+            if replaced == 0:
+                raise ValueError(
+                    f"Pattern {s_cmds[idx]!r} not found in lines {line_numbers}"
+                )
+
+    if out_scratch:
+        out_main.append("% --- SCRATCH ---")
+        out_main.extend(out_scratch)
+
+    with args.tex_path.open("w", encoding="utf-8") as f:
+        f.write("\n".join(out_main) + "\n")
+
+
+def main() -> None:
+    run()
+
+
+if __name__ == "__main__":
+    main()

pydifftools/searchacro.py

@@ -0,0 +1,80 @@
+import re
+import os
+from pathlib import Path
+
+
+def replace_acros(pathtofile):
+    clean_unused = False
+    if pathtofile.parent.resolve() == Path.cwd():
+        clean_unused = True
+        print(
+            "I'm going to clean out the unused acronyms, since myacronyms.sty lives in the current directory"
+        )
+    else:
+        print(pathtofile.parent, "not equal to", Path.cwd())
+    acro_restr = r"\\newacronym(?:\[[^\[\]]*\])?{(\w+)}{(\w+)}{.*}"
+    acro_re = re.compile(acro_restr)
+    regex_replacements = []
+    with open(pathtofile, "r", encoding="utf-8") as fp:
+        for line in fp:
+            m = acro_re.match(line)
+            if m:
+                inside, toreplace = m.groups()
+                regex_replacements.append(
+                    (r"\b" + toreplace + r"\b", r"\\gls{" + inside + "}")
+                )
+                regex_replacements.append(
+                    (r"\b" + toreplace + r"s\b", r"\\glspl{" + inside + "}")
+                )
+
+    def replace_in_files(regex_replacements, exclude=[pathtofile, "ms.tex"]):
+        """
+        This function will replace all occurences of specified regex patterns with their corresponding replacements in all .tex files in the current directory except for the file specified in 'exclude'.
+        It returns a list of unused regex patterns.
+        """
+        # Get the current working directory
+        directory = os.getcwd()
+
+        unused_patterns = set(regex for regex, _ in regex_replacements)
+
+        # Loop over all files in the directory
+        for filename in os.listdir(directory):
+            # Only operate on .tex files and exclude the specified file
+            if filename.endswith(".tex") and filename not in exclude:
+                filepath = os.path.join(directory, filename)
+                with open(filepath, "r", encoding="utf-8") as file:
+                    filedata = file.read()
+
+                # Perform the replacements
+                for regex, replacement in regex_replacements:
+                    if re.search(regex, filedata):
+                        filedata = re.sub(regex, replacement, filedata)
+                        unused_patterns.discard(regex)
+                    elif re.search(replacement, filedata):
+                        unused_patterns.discard(regex)
+                    elif re.search(
+                        replacement.replace("gls", "Gls"), filedata
+                    ):
+                        unused_patterns.discard(regex)
+                filedata = re.sub(r"(\.\s*\n\s*)\\gls", r"\1\\Gls", filedata)
+                # Write the file out again
+                with open(filepath, "w", encoding="utf-8") as file:
+                    file.write(filedata)
+        return list(unused_patterns)
+
+    unused = replace_in_files(regex_replacements)
+    print("unused acronyms:", unused)
+    if clean_unused:
+        # {{{ get rid of unused
+        with open(pathtofile, "r", encoding="utf-8") as fp:
+            filedata = fp.read()
+        for regex in unused:
+            fullreg = r"\\newacronym{(\w+)}{" + regex + "}{.*}"
+            if re.search(fullreg, filedata):
+                filedata = re.sub(fullreg, "", filedata)
+            else:
+                raise ValueError("couldn't find", fullreg)
+        filedata = re.sub("\n+", "\n", filedata)
+        with open(pathtofile, "w", encoding="utf-8") as file:
+            file.write(filedata)
+        # }}}

pydifftools/separate_comments.py

@@ -0,0 +1,73 @@
+import re
+from .comment_functions import (
+    generate_alphabetnumber,
+    matchingbrackets,
+    comment_definition,
+)
+
+
+def tex_sepcomments(texfile):
+    if texfile[-4:] == ".tex":
+        base_filename = texfile[:-4]
+        print("yes, a tex file called", base_filename, ".tex")
+    else:
+        raise RuntimeError("not a tex file??")
+    with open(base_filename + ".tex", "r", encoding="utf-8") as fp:
+        content = fp.read()
+    comment_string = "%%NUMBER OF COMMENTS"
+    a = content.find(comment_string)
+    if a > 0:
+        b = content.find("\n", a + len(comment_string))
+        num_matches = int(content[a + len(comment_string) : b])
+        print("found %d comments already!" % num_matches)
+    else:
+        num_matches = 0
+    content = content.replace(
+        r"\begin{document}",
+        "\\include{%s_comments}\n\\begin{document}" % base_filename,
+    )
+    comment_collection = ""
+    names = ["pdfcommentAG", "pdfcommentAB", "pdfcommentJF", "pdfcommentG"]
+    name_list = "(" + "|".join(names) + ")"
+    comment_re = re.compile(r"\\%s([\[\{])" % (name_list))
+    thismatch = comment_re.search(
+        content
+    )  # match doesn't work with newlines, apparently
+    while thismatch:
+        before = content[: thismatch.start()]
+        thisname, bracket_type = thismatch.groups()
+        a, b = matchingbrackets(content, thismatch.start(), bracket_type)
+        if bracket_type == "[":
+            highlight = content[a + 1 : b]
+            a, b = matchingbrackets(content, b, "{")
+            print("found comment:", content[a : b + 1])
+            comment = content[a + 1 : b]
+            endpoint = b
+        else:
+            highlight = ""
+            comment = content[a + 1 : b]
+            endpoint = b
+        after = content[endpoint + 1 :]
+        # replace and search again
+        print("type of num_matches", num_matches, type(num_matches))
+        envstring = thisname + generate_alphabetnumber(num_matches)
+        print("%s--------------------" % envstring)
+        print("highlight:\n", highlight)
+        print("comment:\n", comment)
+        print("--------------------")
+        print("before replace:\n", content[thismatch.start() : endpoint])
+        content = before + r"\%s" % envstring + "{" + highlight + "}" + after
+        print("--------------------")
+        print("after replace:\n", content[thismatch.start() : endpoint])
+        print("--------------------")
+        comment_collection += comment_definition(envstring, thisname, comment)
+        thismatch = comment_re.search(content)
+        num_matches += 1
+    with open(base_filename + ".tex", "w", encoding="utf-8") as fp:
+        comment_string = "%%%%NUMBER OF COMMENTS %d\n" % num_matches
+        content = content.replace(
+            r"\begin{document}", comment_string + "\\begin{document}"
+        )
+        fp.write(content)
+    with open(base_filename + "_comments.tex", "w", encoding="utf-8") as fp:
+        fp.write(comment_collection)

pydifftools/split_conflict.py

@@ -0,0 +1,213 @@
+# again rerun
+import os
+import re
+
+
+def run(arguments):
+    needsspace_re = re.compile(r'(\w[):;"-\.,!}]*) +([^%}~])')
+    allmarkers_re = re.compile(
+        r"(.*?)%(\[ORIG|ORIG\]\[NEW|NEW\])%(.*\n*)"
+    )  # in all these, the newline at the end is just so it doesn't gobble up the newline
+
+    def parse_line(
+        orig_log_text, new_log_text, log_in_orig, log_in_new, text_to_parse
+    ):
+        match = allmarkers_re.match(text_to_parse)
+        if match:
+            textone, typeofmarker, texttwo = match.groups()
+            if typeofmarker == "NEW]":
+                print(
+                    "found a matching line, current status is (",
+                    log_in_orig,
+                    ",",
+                    log_in_new,
+                    ")",
+                )
+                if log_in_new and not log_in_orig:
+                    switchto = (True, True)  # log in orig, log in new
+                    print(
+                        "in text:\n",
+                        text_to_parse,
+                        "\n--> encountered an end marker, switching to",
+                        switchto,
+                    )
+                else:
+                    raise ValueError(
+                        "I encountered an %NEW]% marker, but I was not leaving orig along and logging only in new (False,True), but rather "
+                        + repr(log_in_orig)
+                        + ","
+                        + repr(log_in_new)
+                        + ":\n"
+                        + text_to_parse
+                    )
+            elif typeofmarker == "ORIG][NEW":
+                print(
+                    "found a matching line, current status is (",
+                    log_in_orig,
+                    ",",
+                    log_in_new,
+                    ")",
+                )
+                if log_in_orig and not log_in_new:
+                    switchto = (False, True)  # log in orig, log in new
+                    print(
+                        "in text:\n",
+                        text_to_parse,
+                        "\n--> encountered a middle marker, switching to",
+                        switchto,
+                    )
+                else:
+                    raise ValueError(
+                        "I encountered an %ORIG][NEW% marker, but I was not logging in orig but not in new, but rather "
+                        + repr(log_in_orig)
+                        + ","
+                        + repr(log_in_new),
+                        ":\n",
+                        text_to_parse,
+                    )
+            elif typeofmarker == "[ORIG":
+                print(
+                    "found a matching line, current status is (",
+                    log_in_orig,
+                    ",",
+                    log_in_new,
+                    ")",
+                )
+                if log_in_new and log_in_orig:
+                    switchto = (True, False)  # log in orig, log in new
+                    print(
+                        "in text:\n",
+                        text_to_parse,
+                        "\n--> encountered an %[ORIG% marker, switching to",
+                        switchto,
+                    )
+                else:
+                    raise ValueError(
+                        "I encountered an %[ORIG% marker, but I was not logging in both orig and new, but rather"
+                        + repr(log_in_orig)
+                        + ","
+                        + repr(log_in_new)
+                        + ":\n"
+                        + text_to_parse
+                    )
+        else:
+            textone = text_to_parse
+            texttwo = None
+        # }}} check to see if I have a separator
+        # regardless, dump the first group into the current bin
+        if log_in_orig:
+            orig_log_text += textone
+        if log_in_new:
+            new_log_text += textone
+        if match:
+            log_in_orig, log_in_new = switchto
+            print("yes, I am actually switching the binning")
+            print("so that status is (", log_in_orig, ",", log_in_new, ")")
+        # if there is a second group (if I have a separator), change which bin I'm in, and add to the end of the current line!
+        if texttwo is not None:
+            orig_log_text, new_log_text, log_in_orig, log_in_new = parse_line(
+                orig_log_text, new_log_text, log_in_orig, log_in_new, texttwo
+            )
+        return orig_log_text, new_log_text, log_in_orig, log_in_new
+
+    fp = open(arguments[0], "r")
+    text_list = []
+    print("opened", arguments[0])
+    log_in_orig = True
+    log_in_new = True
+    head_title = None
+    new_title = None
+    # {{{ pull out just the part between the document text
+    orig_textlist = []
+    new_textlist = []
+    j = 0
+    for thisline in fp:
+        if j == 0:
+            if thisline[:12] == "%ONEWORDDIFF":
+                print("found %ONEWORDDIFF marker, title is:")
+                head_title = "HEAD\n"
+                new_title = thisline[14:]
+                print(new_title)
+                this_is_a_onewordfile = True
+            else:
+                this_is_a_onewordfile = False
+            if this_is_a_onewordfile:
+                print("I found this to be a oneword format file")
+            else:
+                print("I did not find this to be a oneword format file")
+        if this_is_a_onewordfile:  # this is only stored if it's a onewordfile
+            # new processing for oneworddiff
+            # {{{ check to see if I have a separator, and set switchto, to show where I switch
+            orig_log_text, new_log_text, log_in_orig, log_in_new = parse_line(
+                "", "", log_in_orig, log_in_new, thisline
+            )
+            if len(orig_log_text) > 0:
+                orig_textlist.append(orig_log_text)
+            if len(new_log_text) > 0:
+                new_textlist.append(new_log_text)
+        else:
+            # standard processing
+            if (
+                thisline[-11:] == "%FIRSTSET%\n"
+            ):  # if the first set, treat like it's not a comment
+                if log_in_orig:
+                    orig_textlist.append(thisline)
+                if log_in_new:
+                    new_textlist.append(thisline)
+            else:
+                if thisline[:7] == "<<<<<<<":
+                    log_in_orig = True
+                    log_in_new = False
+                    if (
+                        head_title is None
+                    ):  # for the first marker, store the title
+                        head_title = thisline[7:]
+                    elif thisline[7:] == head_title:
+                        pass
+                    else:
+                        raise ValueError(
+                            "I don't understand line %d, which seems to give an inconsistent head title.  It gave:\n%s\nvs expected:\n%s"
+                            % (j, thisline[7:], head_title)
+                        )
+                elif thisline[:7] == ">>>>>>>":
+                    log_in_orig = True
+                    log_in_new = True
+                    if (
+                        new_title is None
+                    ):  # for the first marker, store the title
+                        new_title = thisline[7:]
+                    elif thisline[7:] == new_title:
+                        pass
+                    else:
+                        raise ValueError(
+                            "I don't understand line %d, which seems to give an inconsistent new title.  It gave:\n%s\nvs expected:\n%s"
+                            % (j, thisline[7:], new_title)
+                        )
+                elif thisline[:7] == "=======":
+                    log_in_orig = False
+                    log_in_new = True
+                else:
+                    if log_in_orig:
+                        orig_textlist.append(thisline)
+                    if log_in_new:
+                        new_textlist.append(thisline)
+        j += 1
+    if this_is_a_onewordfile:
+        print("I found this to be a oneword format file")
+    else:
+        print("I did not find this to be a oneword format file")
+    fp.close()
+    # {{{ write out the result
+    newfile = re.sub(r"(.*)", r"\1.merge_new", arguments[0])
+    fp = open(newfile, "w")
+    new_textlist = [
+        "#%%%%%BRANCH TITLE (This side is saved): " + new_title
+    ] + new_textlist
+    fp.write("".join(new_textlist))
+    fp.close()
+    newfile = re.sub(r"(.*)", r"\1.merge_head", arguments[0])
+    fp = open(newfile, "w")
+    orig_textlist = ["#%%%%%BRANCH TITLE: " + head_title] + orig_textlist
+    fp.write("".join(orig_textlist))
+    fp.close()
+    # }}}

pydifftools/unseparate_comments.py

@@ -0,0 +1,69 @@
+import re
+from .comment_functions import matchingbrackets
+
+
+def tex_unsepcomments(texfile):
+    if texfile[-12:] == "_sepcomm.tex":
+        base_filename = texfile[:-12]
+        print("yes, a _sepcomm.tex file called", base_filename, ".tex")
+    elif texfile[-4:] == ".tex":
+        base_filename = texfile[:-4]
+        print("yes, a .tex file called", base_filename, ".tex")
+    else:
+        raise RuntimeError("not a tex file??")
+    with open(base_filename + "_comments.tex", "r", encoding="utf-8") as fp:
+        content = fp.read()
+    # comment_def_re = re.compile(r"\\newcommand\{\%s[A-Z]+")
+    names = ["pdfcommentAG", "pdfcommentAB", "pdfcommentJF", "pdfcommentG"]
+    list_of_names = []
+    list_of_commands = []
+    list_of_content = []
+    for j in range(0, len(names)):
+        comment_def_re = re.compile(
+            r"\\newcommand\{\\(%s[a-z]+)\}\{" % (names[j])
+        )
+        for m in comment_def_re.finditer(content):
+            print("found %d:%d" % (m.start(), m.end()), m.groups()[0])
+            print("text:", content[m.start() : m.end()])
+            a, b = matchingbrackets(content, m.end() - 1, "{")
+            print("found from %d to %d" % (a, b))
+            print("-----content------")
+            print(content[a : b + 1])
+            print("------------------")
+            list_of_names.append(names[j])
+            list_of_commands.append(m.groups()[0])
+            list_of_content.append(content[a + 1 : b])
+    with open(texfile, "r", encoding="utf-8") as fp:
+        content = fp.read()
+    for j in range(0, len(list_of_names)):
+        a = content.find("\\%s" % list_of_commands[j])
+        if a < 0:
+            raise RuntimeError(
+                "couldn't find command \\%s" % list_of_commands[j]
+            )
+        else:
+            starthighlight, b = matchingbrackets(content, a, "{")
+            highlight = content[starthighlight + 1 : b]
+            print(
+                "found command \\%s with highlight {%s} and going to add"
+                " content {%s}"
+                % (list_of_commands[j], highlight, list_of_content[j])
+            )
+            if len(highlight) > 0:
+                content = (
+                    content[:a]
+                    + "\\%s[%s]{%s}"
+                    % (list_of_names[j], highlight, list_of_content[j])
+                    + content[b + 1 :]
+                )
+            else:
+                content = (
+                    content[:a]
+                    + "\\%s{%s}" % (list_of_names[j], list_of_content[j])
+                    + content[b + 1 :]
+                )
+    content = re.sub("\\\\include{%s_comments}\n" % base_filename, "", content)
+    content = re.sub("%%NUMBER OF COMMENTS [0-9]+ *\n", "", content)
+    with open(base_filename + ".tex", "w", encoding="utf-8") as fp:
+        fp.write(content)
+        print("wrote output to", base_filename + ".tex")

pydifftools/update_check.py

@@ -0,0 +1,31 @@
+import importlib.metadata
+import json
+import urllib.request
+import urllib.error
+
+
+# Return the installed version, the latest version, and whether an update exists.
+# Network errors and malformed responses are ignored so this never blocks the CLI
+# when the network is down.
+def check_update(package_name, timeout=1):
+    current_version = None
+    try:
+        current_version = importlib.metadata.version(package_name)
+    except importlib.metadata.PackageNotFoundError:
+        return None, None, False
+
+    url = f"https://pypi.org/pypi/{package_name}/json"
+    try:
+        with urllib.request.urlopen(url, timeout=timeout) as response:
+            data = json.load(response)
+    except (urllib.error.URLError, TimeoutError, OSError, ValueError):
+        return current_version, None, False
+
+    if "info" not in data or "version" not in data["info"]:
+        return current_version, None, False
+
+    return (
+        current_version,
+        data["info"]["version"],
+        current_version != data["info"]["version"],
+    )