pyDiffTools 0.1.8__py3-none-any.whl

pydifftools/doc_contents.py

@@ -0,0 +1,147 @@
+from collections import OrderedDict
+from fuzzywuzzy import process
+
+
+class doc_contents_class(object):
+    def __init__(self, format_type="latex"):
+        self.contents = OrderedDict()
+        self.contents["header"] = ""
+        self.types = {}
+        self.types["header"] = "header"
+        self._reordering_started = False
+        self._aliases = {}
+        self._processed_titles = []
+        self.set_format(format_type)
+
+    def set_format(self, format_type):
+        if format_type == "markdown":
+            # markdown levels go deeper, so include subparagraph mapping
+            self.level_numbers = {
+                "section": 1,
+                "subsection": 2,
+                "subsubsection": 3,
+                "paragraph": 4,
+                "subparagraph": 5,
+            }
+        else:
+            # default to latex behavior
+            self.level_numbers = {
+                "section": 1,
+                "subsection": 2,
+                "subsubsection": 3,
+                "paragraph": 4,
+                "subparagraph": 5,
+            }
+        # map indentation back to section type for outline parsing
+        self.inv_prefix = {
+            (level - 1) * "\t": section
+            for section, level in self.level_numbers.items()
+        }
+        self.format_type = format_type
+
+    def start_sec(self, thistype, thistitle):
+        assert thistitle not in self.contents.keys(), (
+            "more than one section with the name:\n" + thistitle
+        )
+        self.contents[thistitle] = ""
+        self.types[thistitle] = thistype
+        print("added", thistitle)
+
+    def __setstate__(self, d):
+        "set the info from a pickle"
+        self.contents = d["contents"]
+        self.types = d["types"]
+        self._aliases = {}  # doesn't exist, but still needed
+        self._reordering_started = False
+        self._processed_titles = []
+        if "format_type" in d:
+            self.set_format(d["format_type"])
+        else:
+            self.set_format("latex")
+        return
+
+    def __getstate__(self):
+        "return info for a pickle"
+        return {
+            "contents": self.contents,
+            "types": self.types,
+            "format_type": self.format_type,
+        }
+
+    def __iadd__(self, value):
+        self.contents[next(reversed(self.contents))] += value
+        return self
+
+    def __str__(self):
+        if len(self._processed_titles) > 0:
+            raise ValueError(
+                "the following section"
+                " titles were not utilized -- this program is"
+                " for reordering, not dropping!:\n"
+                + str(self._processed_titles)
+            )
+        retval = ""
+        for j in self.contents.keys():
+            if self.types[j] != "header":
+                new_name = j
+                if j in self._aliases.keys():
+                    new_name = self._aliases[j]
+                if self.format_type == "markdown":
+                    retval += "#" * self.level_numbers[self.types[j]]
+                    retval += f" {new_name}\n\n"
+                else:
+                    retval += f"\\{self.types[j]}{{{new_name}}}"
+            retval += f"{self.contents[j]}"
+        return retval
+
+    @property
+    def outline(self):
+        retval = []
+        for j in self.contents.keys():
+            if self.types[j] != "header":
+                indent = (self.level_numbers[self.types[j]] - 1) * "\t"
+                thistitle = (indent + "\t").join(j.split("\n"))
+                retval.append(indent + "*\t" + thistitle)
+        self._reordering_started = False
+        return "\n".join(retval)
+
+    def outline_in_order(self, thisline):
+        if not self._reordering_started:
+            self._processed_titles = [
+                j for j in self.contents.keys() if self.types[j] != "header"
+            ]
+            self._reordering_started = True
+        ilevel = 0
+        spacelevel = 0
+        hitmarker = False
+        for j, thischar in enumerate(thisline):
+            if not hitmarker:
+                if thischar == " ":
+                    spacelevel += 1
+                if spacelevel == 4 or thischar == "\t":
+                    ilevel += 1
+                    spacelevel = 0
+                elif thischar == "*":
+                    hitmarker = True
+            else:
+                assert thischar in [" ", "\t"]
+                title = thisline[j + 1 :]
+                break
+        if not hitmarker:
+            raise ValueError("somehow, there wasn't a * marker!")
+        if title not in self.contents.keys():
+            best_match, match_quality = process.extractOne(
+                title, self.contents.keys()
+            )
+            yesorno = input(
+                f"didn't find\n\t{title}\nin keys, maybe you"
+                f" want\n\t{best_match}\nsay y or n"
+            )
+            if yesorno == "y":
+                self._aliases[best_match] = title  # will be replaced later
+                title = best_match
+            else:
+                raise ValueError("problem with replacement")
+        self.contents.move_to_end(title)
+        self._processed_titles.remove(title)
+        self.types[title] = self.inv_prefix[ilevel * "\t"]

pydifftools/flowchart/__init__.py

@@ -0,0 +1,15 @@
+"""Flowchart helpers for dot/yaml conversion and watching.
+
+Heavy dependencies (like PyYAML) are imported lazily so unrelated CLI commands
+can start up even when optional packages are absent.
+"""
+
+__all__ = [
+    "IndentDumper",
+    "load_graph_yaml",
+    "write_dot_from_yaml",
+    "dot_to_yaml",
+    "watch_graph",
+]
+
+

pydifftools/flowchart/dot_to_yaml.py

@@ -0,0 +1,114 @@
+import sys
+import re
+import yaml
+import pydot
+
+from .graph import IndentDumper
+
+
+def _label_to_text(label: str) -> str:
+    if label is None:
+        return None
+    stripped = label.strip()
+    if stripped.startswith('<') and stripped.endswith('>'):
+        stripped = stripped[1:-1]
+    stripped = stripped.replace('<br align="left"/>', '\n')
+    stripped = stripped.replace('<br/>', '\n')
+    lines = [l.strip() for l in stripped.splitlines()]
+    out_lines = []
+    current: list[str] = []
+
+    def flush():
+        nonlocal current
+        if current:
+            out_lines.append(' '.join(current))
+            current = []
+
+    for s in lines:
+        if not s:
+            continue
+        if s.startswith('<font'):
+            flush()
+            if out_lines and out_lines[-1] != '':
+                out_lines.append('')
+            out_lines.append(s)
+        elif s.startswith('</font'):
+            flush()
+            out_lines.append(s)
+        elif s.startswith('•'):
+            flush()
+            current = ['* ' + s[1:].lstrip()]
+        elif re.match(r'\d+[.)]\s', s):
+            flush()
+            current = [s]
+        else:
+            if current:
+                current.append(s)
+            else:
+                current = [s]
+    flush()
+    return '\n'.join(out_lines)
+
+
+def dot_to_yaml(dot_path, yaml_path):
+    graphs = pydot.graph_from_dot_file(dot_path)
+    if not graphs:
+        raise ValueError("No graph found in dot file")
+    graph = graphs[0]
+    nodes = {}
+    for node in graph.get_nodes():
+        name = node.get_name().strip('"')
+        if name in ('graph', 'node', 'edge'):
+            continue
+        label = node.get('label')
+        if label is not None:
+            label = label.strip('"')
+            label = _label_to_text(label)
+        nodes[name] = {
+            'text': label,
+            'children': [],
+            'parents': [],
+        }
+    styles = {}
+    for sub in graph.get_subgraphs():
+        sub_name = sub.get_name().strip('"')
+        attrs = {}
+        if sub.get_node_defaults():
+            attrs['node'] = sub.get_node_defaults()
+        styles[sub_name] = {'attrs': attrs}
+        for n in sub.get_nodes():
+            nname = n.get_name().strip('"')
+            if nname == 'node':
+                continue
+            if nname not in nodes:
+                label = n.get('label')
+                if label is not None:
+                    label = label.strip('"')
+                    label = _label_to_text(label)
+                nodes[nname] = {'text': label, 'children': [], 'parents': []}
+            nodes[nname]['style'] = sub_name
+    for edge in graph.get_edges():
+        src = edge.get_source().strip('"')
+        dst = edge.get_destination().strip('"')
+        nodes.setdefault(src, {'text': None, 'children': [], 'parents': []})
+        nodes.setdefault(dst, {'text': None, 'children': [], 'parents': []})
+        nodes[src]['children'].append(dst)
+        nodes[dst]['parents'].append(src)
+    data = {'styles': styles, 'nodes': nodes}
+    with open(yaml_path, 'w') as f:
+        yaml.dump(
+            data,
+            f,
+            Dumper=IndentDumper,
+            default_flow_style=False,
+            sort_keys=True,
+            allow_unicode=True,
+            indent=2,
+        )
+
+
+if __name__ == '__main__':
+    if len(sys.argv) != 3:
+        print('Usage: dot_to_yaml.py <input.dot> <output.yaml>')
+        sys.exit(1)
+    dot_to_yaml(sys.argv[1], sys.argv[2])