pyDiffTools 0.1.23__tar.gz → 0.1.25__tar.gz

{pydifftools-0.1.23/pyDiffTools.egg-info → pydifftools-0.1.25}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyDiffTools
-Version: 0.1.23
+Version: 0.1.25
 Summary: Diff tools
 Author: J M Franck
 License: Copyright (c) 2015, jmfranck

{pydifftools-0.1.23 → pydifftools-0.1.25/pyDiffTools.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyDiffTools
-Version: 0.1.23
+Version: 0.1.25
 Summary: Diff tools
 Author: J M Franck
 License: Copyright (c) 2015, jmfranck

{pydifftools-0.1.23 → pydifftools-0.1.25}/pydifftools/browser_lifecycle.py

@@ -1,13 +1,14 @@
 def browser_window_is_alive(browser):
     # Keep all browser liveness checks in one place so watch commands share
     # the same shutdown behavior when a user closes the browser window.
+    # Do not probe with execute_script here: page navigations can briefly
+    # interrupt script execution even while the window is still open.
     if browser is None:
         return False
     try:
         handles = browser.window_handles
         if not handles:
             return False
-        browser.execute_script("return 1")
         return True
     except Exception:
         return False

{pydifftools-0.1.23 → pydifftools-0.1.25}/pydifftools/command_line.py

@@ -796,8 +796,35 @@ def pmd(arguments):
     p1.wait()
 
 
+def _subcommand_help_hint(prog):
+    return (
+        f"*** Run '{prog} --help <subcommand>' to learn about "
+        "subcommand options. ***"
+    )
+
+
+class PyDiffArgumentParser(argparse.ArgumentParser):
+    """ArgumentParser with a clearer root-level missing-subcommand hint."""
+
+    def __init__(self, *args, is_root_parser=False, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._pydifft_is_root_parser = is_root_parser
+
+    def error(self, message):
+        if self._pydifft_is_root_parser:
+            self.print_usage(sys.stderr)
+            hint = _subcommand_help_hint(self.prog)
+            self.exit(2, f"{self.prog}: error: {message}\n{hint}\n")
+        super().error(message)
+
+
 def build_parser():
-    parser = argparse.ArgumentParser()
+    parser = PyDiffArgumentParser(
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        is_root_parser=True,
+    )
+    parser.epilog = _subcommand_help_hint(parser.prog)
+    parser._pydifft_subparsers = {}
     subparsers = parser.add_subparsers(dest="command")
     subparsers.required = True
     for name, spec in _COMMAND_SPECS.items():
@@ -823,10 +850,18 @@ def build_parser():
                 action.completer = FilesCompleter(
                     allowednames=["*.yaml", "*.yml"]
                 )
+            if (
+                FilesCompleter is not None
+                and name == "cpb"
+                and action.dest == "filename"
+            ):
+                # Provide Markdown-only completions for continuous pandoc build.
+                action.completer = FilesCompleter(allowednames=["*.md"])
             if name == "wgrph" and action.dest == "t":
                 # Offer case-insensitive completions for incomplete task names.
                 action.completer = wgrph_task_completer
         subparser.set_defaults(_handler=spec["handler"])
+        parser._pydifft_subparsers[name] = subparser
     return parser
 
 
@@ -859,6 +894,11 @@ def main(argv=None):
     if not argv:
         parser.print_help()
         return
+    if argv[0] in ("-h", "--help") and len(argv) > 1:
+        subcommand = argv[1]
+        if subcommand in parser._pydifft_subparsers:
+            parser._pydifft_subparsers[subcommand].print_help()
+            return
     namespace = parser.parse_args(argv)
     handler = namespace._handler
     handler_kwargs = dict(vars(namespace))

{pydifftools-0.1.23 → pydifftools-0.1.25}/pydifftools/continuous.py

@@ -312,7 +312,8 @@ position
             );
         });
 
-        // When the page has loaded, restore hidden comments and scroll position
+        // When the page has loaded,
+        // restore hidden comments and scroll position
         window.addEventListener('load', function() {
             var hiddenCommentIndexes = sessionStorage.getItem(
                 'commentHiddenBubbleIndexes'

{pydifftools-0.1.23 → pydifftools-0.1.25}/pydifftools/flowchart/graph.py

@@ -378,28 +378,26 @@ def _normalize_graph_dates(data):
 def _append_node(
     lines, indent, node_name, data, wrap_width, order_by_date, sort_order
 ):
-    # Add a node line with an optional sort hint so Graphviz keeps date order.
-    if node_name in data["nodes"]:
-        label = _node_label(
-            _node_text_with_due(data["nodes"][node_name]), wrap_width
-        )
-    else:
-        label = ""
+    # Every rendered DOT node corresponds to a real YAML node, so build the
+    # label directly from that node and prepend the task-link marker line.
+    label = _node_label(
+        _node_text_with_due(data["nodes"][node_name]), wrap_width
+    )
+    task_link_line = (
+        f'<font point-size="7">__WGRPH_TASK_LINK__:{node_name}</font>'
+    )
     if label:
-        if order_by_date:
-            lines.append(
-                f"{indent}{node_name} [label={label},"
-                f" sortv={sort_order[node_name]}];"
-            )
-        else:
-            lines.append(f"{indent}{node_name} [label={label}];")
+        label = "<" + task_link_line + '<br align="left"/>' + label[1:]
     else:
-        if order_by_date:
-            lines.append(
-                f"{indent}{node_name} [sortv={sort_order[node_name]}];"
-            )
-        else:
-            lines.append(f"{indent}{node_name};")
+        label = "<" + task_link_line + '<br align="left"/>' + ">"
+
+    if order_by_date:
+        lines.append(
+            f"{indent}{node_name} [label={label},"
+            f" sortv={sort_order[node_name]}];"
+        )
+    else:
+        lines.append(f"{indent}{node_name} [label={label}];")
 
 
 def yaml_to_dot(data, wrap_width=55, order_by_date=False):
@@ -648,10 +646,7 @@ def write_dot_from_yaml(
             if parent in ancestors:
                 continue
             ancestors.add(parent)
-            if (
-                parent in data["nodes"]
-                and "parents" in data["nodes"][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()

{pydifftools-0.1.23 → pydifftools-0.1.25}/pydifftools/flowchart/watch_graph.py

@@ -2,6 +2,9 @@ import subprocess
 import time
 import shutil
 import math
+import threading
+import urllib.parse
+import http.server
 import xml.etree.ElementTree as ET
 from pathlib import Path
 
@@ -24,12 +27,19 @@ from pydifftools.browser_lifecycle import (
 from .graph import write_dot_from_yaml
 
 
-def _reload_svg(driver, svg_file: Path) -> None:
+def _reload_svg(driver, svg_src) -> None:
     """Refresh the embedded SVG while preserving zoom and scroll."""
     zoom = driver.execute_script("return window.visualViewport.scale")
     scroll_x = driver.execute_script("return window.scrollX")
     scroll_y = driver.execute_script("return window.scrollY")
-    svg_uri = svg_file.resolve().as_uri() + f"?t={time.time()}"
+    if isinstance(svg_src, Path):
+        svg_uri = svg_src.resolve().as_uri()
+    else:
+        svg_uri = str(svg_src)
+    if "?" in svg_uri:
+        svg_uri = svg_uri + f"&ts={time.time()}"
+    else:
+        svg_uri = svg_uri + f"?ts={time.time()}"
     driver.execute_async_script(
         "const [src,z,x,y,done]=arguments;const"
         " s=document.getElementById('svg-view');s.onload=function()"
@@ -42,10 +52,10 @@ def _reload_svg(driver, svg_file: Path) -> None:
     )
 
 
-def start_chrome(webdriver, options, html_file):
-    # Launch Chrome and display the local SVG preview HTML file.
+def start_chrome(webdriver, options, preview_url):
+    # Launch Chrome and display the local SVG preview page from the server.
     driver = webdriver.Chrome(options=options)
-    driver.get(html_file.resolve().as_uri())
+    driver.get(preview_url)
     return driver
 
 
@@ -185,6 +195,60 @@ def _svg_shape_bounds(shape, namespace):
     return None
 
 
+def _svg_parse_viewbox(svg_root):
+    viewbox = svg_root.attrib.get("viewBox")
+    if viewbox is None:
+        return None
+    parts = viewbox.replace(",", " ").split()
+    if len(parts) != 4:
+        return None
+    try:
+        return tuple(float(part) for part in parts)
+    except ValueError:
+        return None
+
+
+def _svg_add_canvas_padding(svg_root, padding=8.0):
+    # Graphviz emits a tight canvas; add small fixed padding so post-processed
+    # outlines and anti-aliased strokes are never clipped at edges.
+    viewbox = _svg_parse_viewbox(svg_root)
+    if viewbox is None:
+        return
+
+    view_x, view_y, view_w, view_h = viewbox
+    if view_w <= 0.0 or view_h <= 0.0:
+        return
+
+    new_view_x = view_x - padding
+    new_view_y = view_y - padding
+    new_view_w = view_w + 2.0 * padding
+    new_view_h = view_h + 2.0 * padding
+    svg_root.set(
+        "viewBox",
+        f"{new_view_x:.2f} {new_view_y:.2f} {new_view_w:.2f} {new_view_h:.2f}",
+    )
+
+
+def _watch_html(svg_url, order_by_date):
+    # Keep the SVG as the page's main content so browser zoom behavior matches
+    # the original watcher experience (the graph scales, not just footer text).
+    # The footer link toggles between dependency/date views depending on mode.
+    footer_label = "date-ordered"
+    footer_url = "/?d=1"
+    if order_by_date:
+        footer_label = "dependency-ordered"
+        footer_url = "/"
+    return (
+        "<html><body style='margin:0'>"
+        "<embed id='svg-view' style='display:block;' type='image/svg+xml'"
+        f" src='{svg_url}'/>"
+        "<p style='margin:0.4em 0.8em;font-family:sans-serif;font-size:13px;'>"
+        f"<a href='{footer_url}'>{footer_label}</a>"
+        "</p>"
+        "</body></html>"
+    )
+
+
 def _svg_expanded_outline(
     shape, namespace, expand, stroke_color, stroke_width
 ):
@@ -221,6 +285,32 @@ def _svg_expanded_outline(
     )
 
 
+def _svg_add_task_links(svg_root, namespace):
+    # Replace marker text emitted in DOT labels with clickable links. Graphviz
+    # generates one <text> item per line, so the marker occupies its own row.
+    xlink_ns = "http://www.w3.org/1999/xlink"
+    ET.register_namespace("xlink", xlink_ns)
+    link_marker = "__WGRPH_TASK_LINK__:"
+    for group in svg_root.iter(f"{namespace}g"):
+        if "class" not in group.attrib or group.attrib["class"] != "node":
+            continue
+        for index, child in enumerate(list(group)):
+            if child.tag != f"{namespace}text" or child.text is None:
+                continue
+            if not child.text.startswith(link_marker):
+                continue
+            task_name = child.text[len(link_marker) :]
+            child.text = task_name
+            link = ET.Element(f"{namespace}a")
+            link.set(
+                f"{{{xlink_ns}}}href", f"/?t={urllib.parse.quote(task_name)}"
+            )
+            link.set("target", "_top")
+            link.append(child)
+            group.remove(child)
+            group.insert(index, link)
+
+
 def build_graph(
     yaml_file,
     dot_file,
@@ -249,6 +339,14 @@ def build_graph(
         ["dot", "-Tsvg", str(dot_file), "-o", str(svg_file)],
         check=True,
     )
+    svg_tree = ET.parse(str(svg_file))
+    svg_root = svg_tree.getroot()
+    namespace = ""
+    if svg_root.tag.startswith("{"):
+        namespace = svg_root.tag[: svg_root.tag.find("}") + 1]
+
+    _svg_add_task_links(svg_root, namespace)
+
     if not order_by_date:
         # In dependency view mode, each node explicitly tagged with
         # ``style: endpoint`` defines a project color. A project includes the
@@ -282,12 +380,6 @@ def build_graph(
                     for parent in data["nodes"][ancestor]["parents"]:
                         ancestors_to_visit.append(parent)
 
-        svg_tree = ET.parse(str(svg_file))
-        svg_root = svg_tree.getroot()
-        namespace = ""
-        if svg_root.tag.startswith("{"):
-            namespace = svg_root.tag[: svg_root.tag.find("}") + 1]
-
         title_to_group = {}
         node_title_to_group = {}
         for group in svg_root.iter(f"{namespace}g"):
@@ -449,7 +541,8 @@ def build_graph(
             for insert_index, outline in reversed(inserts):
                 group.insert(insert_index, outline)
 
-        svg_tree.write(str(svg_file), encoding="utf-8", xml_declaration=True)
+    _svg_add_canvas_padding(svg_root, padding=24.0)
+    svg_tree.write(str(svg_file), encoding="utf-8", xml_declaration=True)
     return data
 
 
@@ -459,27 +552,30 @@ class GraphEventHandler(FileSystemEventHandler):
         yaml_file,
         dot_file,
         svg_file,
-        html_file=None,
+        preview_url=None,
+        svg_url=None,
         driver=None,
         options=None,
         webdriver=None,
         wrap_width=55,
         data=None,
-        order_by_date=False,
-        target_task=None,
+        state=None,
         debounce=0.25,
     ):
         self.yaml_file = Path(yaml_file)
         self.dot_file = Path(dot_file)
         self.svg_file = Path(svg_file)
-        self.html_file = None if html_file is None else Path(html_file)
+        self.preview_url = preview_url
+        self.svg_url = svg_url
         self.driver = driver
         self.options = options
         self.webdriver = webdriver
         self.wrap_width = wrap_width
         self.data = data
-        self.order_by_date = order_by_date
-        self.target_task = target_task
+        if state is None:
+            self.state = {"order_by_date": False, "target_task": None}
+        else:
+            self.state = state
         self.debounce = debounce
         self._last_handled = 0.0
         self._last_mtime = None
@@ -499,9 +595,9 @@ class GraphEventHandler(FileSystemEventHandler):
                     self.dot_file,
                     self.svg_file,
                     self.wrap_width,
-                    self.order_by_date,
+                    self.state["order_by_date"],
                     self.data,
-                    self.target_task,
+                    self.state["target_task"],
                 )
             except Exception:
                 # If the graph fails to build (e.g. invalid date), close the
@@ -515,21 +611,135 @@ class GraphEventHandler(FileSystemEventHandler):
                 if (
                     self.webdriver is not None
                     and self.options is not None
-                    and self.html_file is not None
+                    and self.preview_url is not None
                 ):
                     self.driver = start_chrome(
-                        self.webdriver, self.options, self.html_file
+                        self.webdriver, self.options, self.preview_url
                     )
                 else:
-                    # Allow legacy/test usage without a live driver.
-                    _reload_svg(self.driver, self.svg_file)
+                    # Allow test/legacy usage where no browser driver exists.
+                    if self.svg_url is not None:
+                        _reload_svg(self.driver, self.svg_url)
+                    else:
+                        _reload_svg(self.driver, self.svg_file)
                     self._last_mtime = self.yaml_file.stat().st_mtime
                     return
+            if self.svg_url is not None:
+                _reload_svg(self.driver, self.svg_url)
             else:
                 _reload_svg(self.driver, self.svg_file)
             self._last_mtime = self.yaml_file.stat().st_mtime
 
 
+class FlowchartPreviewServer:
+    def __init__(self, event_handler, host="127.0.0.1"):
+        self.event_handler = event_handler
+        self.host = host
+        self.httpd = None
+        self.server_thread = None
+        self.base_url = None
+        self.svg_url = None
+
+    def start(self):
+        event_handler = self.event_handler
+
+        class Handler(http.server.BaseHTTPRequestHandler):
+            def do_GET(self):
+                parsed = urllib.parse.urlparse(self.path)
+                if parsed.path == "/graph.svg":
+                    svg_bytes = event_handler.svg_file.read_bytes()
+                    self.send_response(200)
+                    self.send_header(
+                        "Content-Type", "image/svg+xml; charset=utf-8"
+                    )
+                    self.send_header("Cache-Control", "no-store")
+                    self.end_headers()
+                    self.wfile.write(svg_bytes)
+                    return
+
+                if parsed.path != "/" and parsed.path != "/index.html":
+                    self.send_error(404)
+                    return
+
+                # Parse query args so GET requests control graph mode.
+                params = urllib.parse.parse_qs(
+                    parsed.query, keep_blank_values=True
+                )
+                order_by_date = event_handler.state["order_by_date"]
+                target_task = event_handler.state["target_task"]
+                if "d" in params:
+                    d_value = params["d"][-1]
+                    order_by_date = d_value in (
+                        "1",
+                        "true",
+                        "yes",
+                        "on",
+                        "",
+                    )
+                if "t" in params:
+                    t_value = params["t"][-1].strip()
+                    if t_value:
+                        target_task = t_value
+                        order_by_date = False
+                    else:
+                        target_task = None
+
+                if (
+                    order_by_date != event_handler.state["order_by_date"]
+                    or target_task != event_handler.state["target_task"]
+                ):
+                    event_handler.state["order_by_date"] = order_by_date
+                    event_handler.state["target_task"] = target_task
+                    event_handler.data = build_graph(
+                        event_handler.yaml_file,
+                        event_handler.dot_file,
+                        event_handler.svg_file,
+                        event_handler.wrap_width,
+                        event_handler.state["order_by_date"],
+                        event_handler.data,
+                        event_handler.state["target_task"],
+                    )
+
+                body = _watch_html(
+                    "/graph.svg", event_handler.state["order_by_date"]
+                )
+                body_bytes = body.encode("utf-8")
+                self.send_response(200)
+                self.send_header("Content-Type", "text/html; charset=utf-8")
+                self.send_header("Content-Length", str(len(body_bytes)))
+                self.send_header("Cache-Control", "no-store")
+                self.end_headers()
+                self.wfile.write(body_bytes)
+
+            def log_message(self, format, *args):
+                return
+
+        self.httpd = http.server.ThreadingHTTPServer((self.host, 0), Handler)
+        self.httpd.daemon_threads = True
+        port = self.httpd.server_address[1]
+        self.base_url = f"http://{self.host}:{port}/"
+        self.svg_url = f"http://{self.host}:{port}/graph.svg"
+        # Start serving immediately so the first browser navigation does not
+        # block waiting for the watcher loop to call handle_request.
+        self.server_thread = threading.Thread(
+            target=self.httpd.serve_forever,
+            daemon=True,
+        )
+        self.server_thread.start()
+
+    def serve_pending_request(self):
+        # The server runs in a background thread; this method remains for
+        # compatibility with the watcher loop call site.
+        return
+
+    def stop(self):
+        if self.httpd is not None:
+            self.httpd.shutdown()
+            self.httpd.server_close()
+        if self.server_thread is not None:
+            self.server_thread.join(timeout=1.0)
+
+
 @register_command(
     "Watch a flowchart YAML file, rebuild DOT/SVG output, and open the"
     " preview",
@@ -537,7 +747,7 @@ class GraphEventHandler(FileSystemEventHandler):
         "yaml": "Path to the flowchart YAML file",
         "wrap_width": "Line wrap width used when generating node labels",
         "d": "Render nodes by date without showing connections",
-        "t": ("Task name to focus on (show incomplete ancestor tasks only)"),
+        "t": "Task name to focus on (show incomplete ancestor tasks only)",
     },
 )
 def wgrph(yaml, wrap_width=55, d=False, t=None):
@@ -559,45 +769,76 @@ def wgrph(yaml, wrap_width=55, d=False, t=None):
 
     dot_file = yaml_file.with_suffix(".dot")
     svg_file = yaml_file.with_suffix(".svg")
-    html_file = yaml_file.with_suffix(".html")
-
-    # Use date ordering when requested so boxes appear in calendar order.
-    # Render the initial graph, optionally restricting to incomplete ancestors
-    # of a target task.
-    data = build_graph(yaml_file, dot_file, svg_file, wrap_width, d, None, t)
-    html_file.write_text(
-        "<html><body style='margin:0'><embed id='svg-view'"
-        " type='image/svg+xml'"
-        f" src='{svg_file.name}?t={time.time()}'/></body></html>"
+
+    # The browser now drives filtering/date-mode by GET query parameters
+    # handled by the local preview server. Keep Python state in sync there.
+    initial_state = {"order_by_date": False, "target_task": None}
+
+    # Build the default dependency graph first. Optional -t / -d args are then
+    # applied by requesting server URLs with query parameters.
+    data = build_graph(
+        yaml_file,
+        dot_file,
+        svg_file,
+        wrap_width,
+        initial_state["order_by_date"],
+        None,
+        initial_state["target_task"],
     )
+
     options = Options()
-    driver = start_chrome(webdriver, options, html_file)
     event_handler = GraphEventHandler(
         yaml_file,
         dot_file,
         svg_file,
-        html_file,
-        driver,
+        None,
+        None,
+        None,
         options,
         webdriver,
         wrap_width,
         data,
-        d,
-        t,
+        initial_state,
     )
+    preview_server = FlowchartPreviewServer(event_handler)
+    preview_server.start()
+    event_handler.preview_url = preview_server.base_url
+    event_handler.svg_url = preview_server.svg_url
+
+    driver = start_chrome(webdriver, options, preview_server.base_url)
+    event_handler.driver = driver
+
+    if t is not None and str(t).strip():
+        driver.get(
+            preview_server.base_url
+            + "?t="
+            + urllib.parse.quote(str(t).strip())
+        )
+    elif d:
+        driver.get(preview_server.base_url + "?d=1")
+
     observer = Observer()
     observer.schedule(event_handler, yaml_file.parent, recursive=False)
     observer.start()
+    dead_since = None
     try:
         while True:
-            # Exit the watcher when the browser window is closed so the CLI
-            # process does not stay alive in the background.
-            if not browser_window_is_alive(event_handler.driver):
-                break
-            time.sleep(1)
+            preview_server.serve_pending_request()
+            # Exit the watcher when the browser window is really closed, but
+            # tolerate short Selenium liveness errors during top-level
+            # navigation (for example when opening /?t=... from the links).
+            if browser_window_is_alive(event_handler.driver):
+                dead_since = None
+            else:
+                if dead_since is None:
+                    dead_since = time.time()
+                elif time.time() - dead_since >= 1.0:
+                    break
+            time.sleep(0.1)
     except KeyboardInterrupt:
         pass
     finally:
         observer.stop()
         observer.join()
         close_chrome(event_handler.driver)
+        preview_server.stop()

{pydifftools-0.1.23 → pydifftools-0.1.25}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pyDiffTools"
-version = "0.1.23"
+version = "0.1.25"
 authors = [{ name = "J M Franck" }]
 description = "Diff tools"
 readme = "README.rst"

{pydifftools-0.1.23 → pydifftools-0.1.25}/tests/test_browser_lifecycle.py

@@ -2,17 +2,11 @@ from pydifftools import browser_lifecycle
 
 
 class FakeBrowser:
-    def __init__(self, handles=None, script_error=False, quit_error=False):
+    def __init__(self, handles=None, quit_error=False):
         self.window_handles = handles if handles is not None else ["main"]
-        self.script_error = script_error
         self.quit_error = quit_error
         self.quit_calls = 0
 
-    def execute_script(self, _code):
-        if self.script_error:
-            raise RuntimeError("window closed")
-        return 1
-
     def quit(self):
         self.quit_calls += 1
         if self.quit_error:
@@ -29,11 +23,6 @@ def test_browser_window_is_alive_false_when_handles_missing():
     assert not browser_lifecycle.browser_window_is_alive(browser)
 
 
-def test_browser_window_is_alive_false_when_script_errors():
-    browser = FakeBrowser(script_error=True)
-    assert not browser_lifecycle.browser_window_is_alive(browser)
-
-
 def test_close_browser_window_quits_and_swallows_errors():
     browser = FakeBrowser(quit_error=True)
     browser_lifecycle.close_browser_window(browser)