pyDiffTools 0.1.27__tar.gz → 0.1.29__tar.gz

{pydifftools-0.1.27/pyDiffTools.egg-info → pydifftools-0.1.29}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyDiffTools
-Version: 0.1.27
+Version: 0.1.29
 Summary: Diff tools
 Author: J M Franck
 License: Copyright (c) 2015, jmfranck
@@ -41,6 +41,8 @@ Requires-Dist: watchdog
 Requires-Dist: pydot
 Requires-Dist: python-dateutil
 Requires-Dist: jinja2
+Requires-Dist: ipykernel
+Requires-Dist: matplotlib
 Requires-Dist: nbformat
 Requires-Dist: nbconvert
 Requires-Dist: pygments

{pydifftools-0.1.27 → pydifftools-0.1.29/pyDiffTools.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyDiffTools
-Version: 0.1.27
+Version: 0.1.29
 Summary: Diff tools
 Author: J M Franck
 License: Copyright (c) 2015, jmfranck
@@ -41,6 +41,8 @@ Requires-Dist: watchdog
 Requires-Dist: pydot
 Requires-Dist: python-dateutil
 Requires-Dist: jinja2
+Requires-Dist: ipykernel
+Requires-Dist: matplotlib
 Requires-Dist: nbformat
 Requires-Dist: nbconvert
 Requires-Dist: pygments

{pydifftools-0.1.27 → pydifftools-0.1.29}/pyDiffTools.egg-info/SOURCES.txt

@@ -81,6 +81,7 @@ pydifftools/flowchart/dot_to_yaml.py
 pydifftools/flowchart/graph.py
 pydifftools/flowchart/watch_graph.py
 pydifftools/notebook/__init__.py
+pydifftools/notebook/display.py
 pydifftools/notebook/fast_build.py
 pydifftools/notebook/tex_to_qmd.py
 tests/test_browser_lifecycle.py

{pydifftools-0.1.27 → pydifftools-0.1.29}/pyDiffTools.egg-info/requires.txt

@@ -5,6 +5,8 @@ watchdog
 pydot
 python-dateutil
 jinja2
+ipykernel
+matplotlib
 nbformat
 nbconvert
 pygments

{pydifftools-0.1.27 → pydifftools-0.1.29}/pydifftools/command_line.py

@@ -943,11 +943,82 @@ def main(argv=None):
             "argument --no-comments: not allowed with argument "
             "--comments-to-margin"
         )
+    if (
+        namespace.command == "qmdb"
+        and namespace.always_code
+        and namespace.no_code
+    ):
+        parser._pydifft_subparsers["qmdb"].error(
+            "argument --no-code: not allowed with argument --always-code"
+        )
     handler = namespace._handler
     handler_kwargs = dict(vars(namespace))
     handler_kwargs.pop("_handler", None)
     handler_kwargs.pop("command", None)
-    handler(**handler_kwargs)
+    # {{{ explain Chrome and ChromeDriver version mismatches
+    from selenium.common.exceptions import SessionNotCreatedException
+
+    try:
+        handler(**handler_kwargs)
+    except SessionNotCreatedException as exc:
+        details = str(exc)
+        driver_match = re.search(
+            r"ChromeDriver only supports Chrome version (\d+)",
+            details,
+        )
+        browser_match = re.search(
+            r"Current browser version is (\d+)",
+            details,
+        )
+        if driver_match is None or browser_match is None:
+            raise
+
+        driver_major = int(driver_match.group(1))
+        browser_major = int(browser_match.group(1))
+        print(
+            "pydifft: Chrome could not start because ChromeDriver "
+            f"{driver_major} and Chrome {browser_major} do not match.",
+            file=sys.stderr,
+        )
+        if shutil.which("apt-get") is not None:
+            if browser_major < driver_major:
+                binary_match = re.search(
+                    r"binary path ([^;\n]+)",
+                    details,
+                )
+                browser_binary = (
+                    binary_match.group(1) if binary_match is not None else ""
+                )
+                browser_package = (
+                    "chromium"
+                    if "chromium" in browser_binary
+                    else "google-chrome-stable"
+                )
+                packages = browser_package
+            elif driver_major < browser_major:
+                packages = "chromium-driver"
+            else:
+                packages = "google-chrome-stable chromium-driver"
+            print(
+                "Update the older system package:\n"
+                "  sudo apt update\n"
+                f"  sudo apt install --only-upgrade {packages}",
+                file=sys.stderr,
+            )
+        else:
+            print(
+                "Update the older Chrome or ChromeDriver installation so "
+                "their major versions match.",
+                file=sys.stderr,
+            )
+        print(
+            "Then retry. You can verify the versions with:\n"
+            "  google-chrome --version\n"
+            "  chromedriver --version",
+            file=sys.stderr,
+        )
+        raise SystemExit(1) from None
+    # }}}
 
 
 if __name__ == "__main__":

{pydifftools-0.1.27 → pydifftools-0.1.29}/pydifftools/continuous.py

@@ -52,72 +52,88 @@ def forward_search_listener(stop_event, search_queue):
     server.close()
 
 
-def _file_contains_text(path, text):
+def _comment_filter_mode(path, packaged_filters=None):
     if not os.path.exists(path):
-        return False
+        return "missing"
+    if packaged_filters is None:
+        package_dir = os.path.dirname(os.path.abspath(__file__))
+        packaged_filters = {
+            "default": os.path.join(package_dir, "comment_tags.lua"),
+            "margin": os.path.join(package_dir, "comment_tags_margin.lua"),
+            "none": os.path.join(package_dir, "comment_tags_no_comments.lua"),
+        }
     with open(path, encoding="utf-8") as fp:
-        return text in fp.read()
-
-
-def _comment_filter_mode(path):
-    if not os.path.exists(path):
-        return None
-    if _file_contains_text(path, MARGIN_COMMENTS_FILTER_MARKER):
-        return "margin"
-    if _file_contains_text(path, NO_COMMENTS_FILTER_MARKER):
-        return "none"
-    return "default"
-
+        filter_text = fp.read()
+    for mode in ["default", "margin", "none"]:
+        with open(packaged_filters[mode], encoding="utf-8") as fp:
+            if filter_text == fp.read():
+                return mode
+    return "custom"
 
-def _set_comment_filter_mode(source_dir, mode):
-    if mode not in {"default", "margin", "none"}:
-        raise ValueError(f"Unknown comment filter mode: {mode}")
-    package_dir = os.path.dirname(os.path.abspath(__file__))
-    active_filter = os.path.join(source_dir, "comment_tags.lua")
-    inactive_filter = os.path.join(source_dir, "comment_tags.lua.inactive")
-    packaged_filters = {
-        "default": os.path.join(package_dir, "comment_tags.lua"),
-        "margin": os.path.join(package_dir, "comment_tags_margin.lua"),
-        "none": os.path.join(package_dir, "comment_tags_no_comments.lua"),
-    }
 
-    active_mode = _comment_filter_mode(active_filter)
-    inactive_mode = _comment_filter_mode(inactive_filter)
-
-    if mode == "default":
-        if active_mode == "default":
-            return
-        if active_mode in {"margin", "none"}:
-            if inactive_mode == "default":
-                temp_filter = active_filter + ".swap_tmp"
-                os.replace(active_filter, temp_filter)
-                os.replace(inactive_filter, active_filter)
-                os.replace(temp_filter, inactive_filter)
-            else:
-                os.replace(active_filter, inactive_filter)
-                shutil.copy2(packaged_filters["default"], active_filter)
-            return
-        if active_mode is None:
-            if inactive_mode == "default":
-                os.replace(inactive_filter, active_filter)
-            else:
-                shutil.copy2(packaged_filters["default"], active_filter)
-            return
-        shutil.copy2(packaged_filters["default"], active_filter)
-        return
+def _confirm_restore_comment_filter(active_mode):
+    if active_mode == "none":
+        message = (
+            "The current lua filter is the one that does not show comments, "
+            "but you ran without the --no-comments flag.\n\n"
+            "Note that you have not locally edited the filter relative to "
+            "the library default.\n\n"
+            "Do you want to keep the current filter, or restore the library "
+            "default that shows comments?"
+        )
+        default_choice = "restore"
+    elif active_mode == "custom":
+        message = (
+            "The current lua filter does not match the pyDiffTools library "
+            "default or the no-comments filter, but you ran without the "
+            "--no-comments flag.\n\n"
+            "Note that this looks like a locally edited filter.\n\n"
+            "Do you want to keep the current filter, or restore the library "
+            "default that shows comments?"
+        )
+        default_choice = "keep"
+    else:
+        raise ValueError(
+            "Comment filter restore prompt is only valid for custom or "
+            f"no-comments filters, not {active_mode!r}"
+        )
+    prompt_script = """
+import sys
+from PySide6.QtWidgets import QApplication, QMessageBox
 
-    if active_mode == mode:
-        return
-    if active_mode == "default":
-        os.replace(active_filter, inactive_filter)
-        shutil.copy2(packaged_filters[mode], active_filter)
-        return
-    if active_mode in {"margin", "none"}:
-        shutil.copy2(packaged_filters[mode], active_filter)
-        return
-    if active_mode is None and inactive_mode != "default":
-        shutil.copy2(packaged_filters["default"], inactive_filter)
-    shutil.copy2(packaged_filters[mode], active_filter)
+app = QApplication(sys.argv[:1])
+box = QMessageBox()
+box.setWindowTitle("pydifft cpb")
+box.setIcon(QMessageBox.Icon.Question)
+box.setText(sys.argv[1])
+keep_button = box.addButton(
+    "Keep current filter", QMessageBox.ButtonRole.RejectRole
+)
+restore_button = box.addButton(
+    "Restore library default", QMessageBox.ButtonRole.AcceptRole
+)
+if sys.argv[2] == "restore":
+    box.setDefaultButton(restore_button)
+else:
+    box.setDefaultButton(keep_button)
+box.exec()
+if box.clickedButton() is restore_button:
+    sys.exit(0)
+sys.exit(1)
+"""
+    result = subprocess.run(
+        [sys.executable, "-c", prompt_script, message, default_choice],
+        capture_output=True,
+        text=True,
+    )
+    if result.returncode == 0:
+        return True
+    if result.returncode == 1:
+        return False
+    stderr = result.stderr.strip()
+    if stderr:
+        raise RuntimeError(f"pydifft cpb filter dialog failed: {stderr}")
+    raise RuntimeError("pydifft cpb filter dialog failed.")
 
 
 def run_pandoc(
@@ -168,10 +184,87 @@ def run_pandoc(
     ):
         # Keep the active comment filter in the markdown directory so pandoc
         # picks it up alongside other user-supplied project filters.
-        _set_comment_filter_mode(source_dir, comment_filter_mode)
+        # {{{ select the active comment_tags.lua filter
+        package_dir = os.path.dirname(os.path.abspath(__file__))
+        active_filter = os.path.join(source_dir, "comment_tags.lua")
+        inactive_filter = os.path.join(
+            source_dir, "comment_tags.lua.inactive"
+        )
+        packaged_filters = {
+            "default": os.path.join(package_dir, "comment_tags.lua"),
+            "margin": os.path.join(package_dir, "comment_tags_margin.lua"),
+            "none": os.path.join(package_dir, "comment_tags_no_comments.lua"),
+        }
+        active_mode = _comment_filter_mode(active_filter, packaged_filters)
+        inactive_mode = _comment_filter_mode(inactive_filter, packaged_filters)
+
+        if comment_filter_mode == "default":
+            if active_mode == "default":
+                effective_filter_mode = "default"
+            elif active_mode == "none":
+                if _confirm_restore_comment_filter("none"):
+                    shutil.copy2(
+                        packaged_filters["default"], active_filter
+                    )
+                    effective_filter_mode = "default"
+                else:
+                    effective_filter_mode = "none"
+            elif active_mode == "custom":
+                if _confirm_restore_comment_filter("custom"):
+                    shutil.copy2(
+                        packaged_filters["default"], active_filter
+                    )
+                    effective_filter_mode = "default"
+                else:
+                    effective_filter_mode = "custom"
+            elif active_mode == "margin":
+                if inactive_mode in {"default", "custom"}:
+                    temp_filter = active_filter + ".swap_tmp"
+                    os.replace(active_filter, temp_filter)
+                    os.replace(inactive_filter, active_filter)
+                    os.replace(temp_filter, inactive_filter)
+                    effective_filter_mode = inactive_mode
+                else:
+                    os.replace(active_filter, inactive_filter)
+                    shutil.copy2(
+                        packaged_filters["default"], active_filter
+                    )
+                    effective_filter_mode = "default"
+            elif active_mode == "missing":
+                if inactive_mode in {"default", "custom"}:
+                    os.replace(inactive_filter, active_filter)
+                    effective_filter_mode = inactive_mode
+                else:
+                    shutil.copy2(
+                        packaged_filters["default"], active_filter
+                    )
+                    effective_filter_mode = "default"
+            else:
+                shutil.copy2(packaged_filters["default"], active_filter)
+                effective_filter_mode = "default"
+        else:
+            effective_filter_mode = comment_filter_mode
+            if active_mode == comment_filter_mode:
+                pass
+            elif active_mode in {"default", "custom"}:
+                os.replace(active_filter, inactive_filter)
+                shutil.copy2(
+                    packaged_filters[comment_filter_mode], active_filter
+                )
+            else:
+                if active_mode == "missing" and inactive_mode not in {
+                    "default",
+                    "custom",
+                }:
+                    shutil.copy2(
+                        packaged_filters["default"], inactive_filter
+                    )
+                shutil.copy2(
+                    packaged_filters[comment_filter_mode], active_filter
+                )
+        # }}}
         # Only copy the comment UI assets when comments should be rendered.
-        if comment_filter_mode != "none":
-            package_dir = os.path.dirname(os.path.abspath(__file__))
+        if effective_filter_mode != "none":
             for asset_name in ["comments.css", "comment_toggle.js"]:
                 target_path = os.path.join(source_dir, asset_name)
                 if not os.path.exists(target_path):
@@ -483,6 +576,4 @@ def cpb(filename, comments_to_margin=False, no_comments=False):
 
 
 if __name__ == "__main__":
-    filename = sys.argv[1]
-    cpb(filename)
-    # Open the HTML file in the default web browser
+    raise SystemExit("Use `pydifft cpb <filename.md>` instead.")

{pydifftools-0.1.27 → pydifftools-0.1.29}/pydifftools/flowchart/graph.py

@@ -321,8 +321,7 @@ def _node_text_with_due(node, depends_on_undated_parent=False):
 
     # Completed tasks should always show their calendar date so the original
     # deadline remains visible even if it was today or overdue when finished.
-    style_name = str(node.get("style", ""))
-    is_completed = "complete" in style_name
+    is_completed = node_is_completed(node)
     # Replace the actual date with high-visibility notices when the deadline
     # is today or overdue.  These are rendered in a bold 12 pt font so they are
     # immediately noticeable in the diagram.  Completed tasks skip these
@@ -367,6 +366,68 @@ def _node_text_with_due(node, depends_on_undated_parent=False):
     return formatted
 
 
+def node_is_completed(node):
+    return "complete" in str(node.get("style", ""))
+
+
+def node_is_endpoint(node):
+    return "endpoint" in str(node.get("style", ""))
+
+
+def trace_ancestors(
+    data,
+    start_name,
+    stop_at=None,
+    include_stopped=False,
+    skip_over=None,
+):
+    ancestors = []
+    nodes = data.get("nodes", {})
+    if start_name not in nodes:
+        return ancestors
+    ancestors_to_visit = list(nodes[start_name].get("parents", []))
+    already_seen = set([start_name])
+    while ancestors_to_visit:
+        ancestor = ancestors_to_visit.pop()
+        if ancestor in already_seen:
+            continue
+        already_seen.add(ancestor)
+        if ancestor not in nodes:
+            continue
+        ancestor_node = nodes[ancestor]
+        if stop_at is not None and stop_at(ancestor, ancestor_node):
+            if include_stopped:
+                ancestors.append(ancestor)
+            continue
+        if skip_over is not None and skip_over(ancestor, ancestor_node):
+            for parent in ancestor_node.get("parents", []):
+                ancestors_to_visit.append(parent)
+            continue
+        ancestors.append(ancestor)
+        for parent in ancestor_node.get("parents", []):
+            ancestors_to_visit.append(parent)
+    return ancestors
+
+
+def endpoint_projects(data):
+    endpoints = set()
+    for name, node_data in data.get("nodes", {}).items():
+        if node_is_endpoint(node_data):
+            endpoints.add(name)
+
+    projects = {}
+    for endpoint in sorted(endpoints):
+        projects[endpoint] = [endpoint]
+        projects[endpoint].extend(
+            trace_ancestors(
+                data,
+                endpoint,
+                stop_at=lambda name, _node: name in endpoints,
+            )
+        )
+    return projects
+
+
 def _node_label(text, wrap_width=55):
     if text is None:
         return ""
@@ -415,6 +476,8 @@ def _append_node(
     if node_has_due:
         for parent in node.get("parents", []):
             parent_node = data["nodes"].get(parent, {})
+            if node_is_completed(parent_node):
+                continue
             parent_due = parent_node.get("due")
             if parent_due is None or not str(parent_due).strip():
                 depends_on_undated_parent = True
@@ -586,6 +649,65 @@ def yaml_to_dot(data, wrap_width=55, order_by_date=False):
     return "\n".join(lines)
 
 
+def _filter_nodes_for_dot(
+    data, node_names, include_completed_endpoint_ancestors=False
+):
+    nodes = data.get("nodes", {})
+    included = []
+    included_set = set()
+
+    def include_node(name):
+        if name not in included_set:
+            included.append(name)
+            included_set.add(name)
+
+    for name in node_names:
+        if name not in nodes:
+            continue
+        if node_is_completed(nodes[name]):
+            continue
+        include_node(name)
+
+    if include_completed_endpoint_ancestors:
+        for name in list(included):
+            completed_endpoint_ancestors = trace_ancestors(
+                data,
+                name,
+                stop_at=lambda _name, node: node_is_endpoint(node),
+                include_stopped=True,
+                skip_over=lambda _name, node: (
+                    node_is_completed(node) and not node_is_endpoint(node)
+                ),
+            )
+            for ancestor in completed_endpoint_ancestors:
+                if ancestor not in nodes:
+                    continue
+                if node_is_completed(nodes[ancestor]) and node_is_endpoint(
+                    nodes[ancestor]
+                ):
+                    include_node(ancestor)
+
+    data_for_dot = {"nodes": {}, "styles": {}}
+    if "styles" in data:
+        data_for_dot["styles"] = data["styles"]
+    for name in included:
+        data_for_dot["nodes"][name] = dict(nodes[name])
+    for name in data_for_dot["nodes"]:
+        if "children" in data_for_dot["nodes"][name]:
+            data_for_dot["nodes"][name]["children"] = [
+                child
+                for child in data_for_dot["nodes"][name]["children"]
+                if child in included_set
+            ]
+        if "parents" in data_for_dot["nodes"][name]:
+            data_for_dot["nodes"][name]["parents"] = [
+                parent
+                for parent in data_for_dot["nodes"][name]["parents"]
+                if parent in included_set
+            ]
+    return data_for_dot
+
+
 def save_graph_yaml(path, data):
     # Ensure stored dates are normalized before writing.
     _normalize_graph_dates(data)
@@ -610,6 +732,7 @@ def write_dot_from_yaml(
     old_data=None,
     validate_due_dates=False,
     filter_task=None,
+    filter_completed=False,
     resolve_due_date_conflict=None,
 ):
     data = load_graph_yaml(str(yaml_path), old_data=old_data)
@@ -755,40 +878,14 @@ def write_dot_from_yaml(
                 )
         # Include the target task alongside its ancestors in the filtered view.
         ancestors = set([filter_task])
-        parents_to_check = list(data["nodes"][filter_task]["parents"])
-        while parents_to_check:
-            parent = parents_to_check.pop()
-            if parent in ancestors:
-                continue
-            ancestors.add(parent)
-            if parent in data["nodes"] and "parents" in data["nodes"][parent]:
-                for grandparent in data["nodes"][parent]["parents"]:
-                    parents_to_check.append(grandparent)
-        incomplete_ancestors = set()
-        for name in ancestors:
-            if name not in data["nodes"]:
-                continue
-            if "complete" in str(data["nodes"][name].get("style", "")):
-                continue
-            incomplete_ancestors.add(name)
-        data_for_dot = {"nodes": {}, "styles": {}}
-        if "styles" in data:
-            data_for_dot["styles"] = data["styles"]
-        for name in incomplete_ancestors:
-            data_for_dot["nodes"][name] = dict(data["nodes"][name])
-        for name in data_for_dot["nodes"]:
-            if "children" in data_for_dot["nodes"][name]:
-                data_for_dot["nodes"][name]["children"] = [
-                    child
-                    for child in data_for_dot["nodes"][name]["children"]
-                    if child in incomplete_ancestors
-                ]
-            if "parents" in data_for_dot["nodes"][name]:
-                data_for_dot["nodes"][name]["parents"] = [
-                    parent
-                    for parent in data_for_dot["nodes"][name]["parents"]
-                    if parent in incomplete_ancestors
-                ]
+        ancestors.update(trace_ancestors(data, filter_task))
+        data_for_dot = _filter_nodes_for_dot(data, ancestors)
+    elif filter_completed:
+        data_for_dot = _filter_nodes_for_dot(
+            data,
+            data.get("nodes", {}).keys(),
+            include_completed_endpoint_ancestors=True,
+        )
     dot_str = yaml_to_dot(
         data_for_dot, wrap_width=wrap_width, order_by_date=order_by_date
     )