htmlcmp 1.0.0__tar.gz → 1.0.1__tar.gz

{htmlcmp-1.0.0 → htmlcmp-1.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: htmlcmp
-Version: 1.0.0
+Version: 1.0.1
 Summary: Compare HTML files by rendered output
 Home-page: https://github.com/opendocument-app/compare-html
 Author: Andreas Stefl

{htmlcmp-1.0.0 → htmlcmp-1.0.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "htmlcmp"
-version = "1.0.0"
+version = "1.0.1"
 description = "Compare HTML files by rendered output"
 classifiers = []
 authors = [

{htmlcmp-1.0.0 → htmlcmp-1.0.1}/setup.py

@@ -7,7 +7,7 @@ long_description = (this_directory / "README.md").read_text()
 
 setup(
     name="htmlcmp",
-    version="1.0.0",
+    version="1.0.1",
     author="Andreas Stefl",
     author_email="stefl.andreas@gmail.com",
     description="Compare HTML files by rendered output",

htmlcmp-1.0.1/src/htmlcmp/common.py

@@ -0,0 +1,10 @@
+class bcolors:
+    HEADER = "\033[95m"
+    OKBLUE = "\033[94m"
+    OKCYAN = "\033[96m"
+    OKGREEN = "\033[92m"
+    WARNING = "\033[93m"
+    FAIL = "\033[91m"
+    ENDC = "\033[0m"
+    BOLD = "\033[1m"
+    UNDERLINE = "\033[4m"

htmlcmp-1.0.1/src/htmlcmp/compare_output.py

@@ -0,0 +1,251 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+import os
+import sys
+import argparse
+import json
+import threading
+import filecmp
+from concurrent.futures import ThreadPoolExecutor
+from html_render_diff import get_browser, html_render_diff
+from common import bcolors
+
+
+class Config:
+    thread_local = threading.local()
+
+
+def parse_json(path):
+    with open(path) as f:
+        return json.load(f)
+
+
+def compare_json(a, b):
+    json_a = json.dumps(parse_json(a), sort_keys=True)
+    json_b = json.dumps(parse_json(b), sort_keys=True)
+    return json_a == json_b
+
+
+def compare_html(a, b, browser=None, diff_output=None):
+    if browser is None:
+        browser = get_browser()
+    diff, (image_a, image_b) = html_render_diff(a, b, browser=browser)
+    result = True if diff.getbbox() is None else False
+    if diff_output is not None and not result:
+        os.makedirs(diff_output, exist_ok=True)
+        image_a.save(os.path.join(diff_output, "a.png"))
+        image_b.save(os.path.join(diff_output, "b.png"))
+        diff.save(os.path.join(diff_output, "diff.png"))
+    return result
+
+
+def compare_files(a, b, **kwargs):
+    if filecmp.cmp(a, b):
+        return True
+    if a.endswith(".json"):
+        return compare_json(a, b)
+    if a.endswith(".html"):
+        return compare_html(a, b, **kwargs)
+
+
+def comparable_file(path):
+    if path.endswith(".json"):
+        return True
+    if path.endswith(".html"):
+        return True
+    return False
+
+
+def submit_compare_dirs(a, b, executor, diff_output=None, **kwargs):
+    results = {
+        "common_dirs": [],
+        "common_files": [],
+        "left_files_missing": [],
+        "right_files_missing": [],
+        "left_dirs_missing": [],
+        "right_dirs_missing": [],
+    }
+
+    left = sorted(os.listdir(a))
+    right = sorted(os.listdir(b))
+
+    left_files = sorted(
+        [
+            name
+            for name in left
+            if os.path.isfile(os.path.join(a, name))
+            and comparable_file(os.path.join(a, name))
+        ]
+    )
+    right_files = sorted(
+        [
+            name
+            for name in right
+            if os.path.isfile(os.path.join(b, name))
+            and comparable_file(os.path.join(b, name))
+        ]
+    )
+    common_files = [name for name in left_files if name in right_files]
+
+    def compare(path_a, path_b, diff_output):
+        browser = getattr(Config.thread_local, "browser", None)
+        return compare_files(path_a, path_b, browser=browser, diff_output=diff_output)
+
+    for name in common_files:
+        future = executor.submit(
+            compare,
+            os.path.join(a, name),
+            os.path.join(b, name),
+            diff_output=(
+                None if diff_output is None else os.path.join(diff_output, name)
+            ),
+        )
+        results["common_files"].append((name, future))
+
+    results["left_files_missing"] = [
+        name for name in right_files if name not in left_files
+    ]
+    results["right_files_missing"] = [
+        name for name in left_files if name not in right_files
+    ]
+
+    left_dirs = sorted([name for name in left if os.path.isdir(os.path.join(a, name))])
+    right_dirs = sorted(
+        [name for name in right if os.path.isdir(os.path.join(b, name))]
+    )
+    common_dirs = [path for path in left_dirs if path in right_dirs]
+
+    for name in common_dirs:
+        sub_results = submit_compare_dirs(
+            os.path.join(a, name),
+            os.path.join(b, name),
+            executor=executor,
+            diff_output=(
+                None if diff_output is None else os.path.join(diff_output, name)
+            ),
+            **kwargs,
+        )
+        results["common_dirs"].append((name, sub_results))
+
+    results["left_dirs_missing"] = [
+        name for name in right_dirs if name not in left_dirs
+    ]
+    results["right_dirs_missing"] = [
+        name for name in left_dirs if name not in right_dirs
+    ]
+
+    return results
+
+
+def print_results(results, a, b, level=0, prefix=""):
+    prefix_file = prefix + "├── "
+    if level == 0:
+        print(f"compare dir {a} with {b}")
+
+    result = {
+        "left_files_missing": [],
+        "right_files_missing": [],
+        "left_dirs_missing": [],
+        "right_dirs_missing": [],
+        "files_different": [],
+    }
+
+    left_files_missing = " ".join(results["left_files_missing"])
+    if left_files_missing:
+        print(
+            f"{prefix_file}{bcolors.FAIL}missing files left: {left_files_missing} ✘{bcolors.ENDC}"
+        )
+        result["left_files_missing"].extend(
+            [os.path.join(a, name) for name in results["left_files_missing"]]
+        )
+    right_files_missing = " ".join(results["right_files_missing"])
+    if right_files_missing:
+        print(
+            f"{prefix_file}{bcolors.FAIL}missing files right: {right_files_missing} ✘{bcolors.ENDC}"
+        )
+        result["right_files_missing"].extend(
+            [os.path.join(a, name) for name in results["right_files_missing"]]
+        )
+
+    for name, future in results["common_files"]:
+        cmp = future.result()
+        if cmp:
+            print(f"{prefix_file}{bcolors.OKGREEN}{name} ✓{bcolors.ENDC}")
+        else:
+            print(f"{prefix_file}{bcolors.FAIL}{name} ✘{bcolors.ENDC}")
+            result["files_different"].append(os.path.join(a, name))
+
+    left_dirs_missing = " ".join(results["left_dirs_missing"])
+    if left_dirs_missing:
+        print(
+            f"{prefix_file}{bcolors.FAIL}missing dirs left: {left_dirs_missing} ✘{bcolors.ENDC}"
+        )
+        result["left_dirs_missing"].extend(
+            [os.path.join(a, name) for name in results["left_dirs_missing"]]
+        )
+    right_dirs_missing = " ".join(results["right_dirs_missing"])
+    if right_dirs_missing:
+        print(
+            f"{prefix_file}{bcolors.FAIL}missing dirs right: {right_dirs_missing} ✘{bcolors.ENDC}"
+        )
+        result["right_dirs_missing"].extend(
+            [os.path.join(a, name) for name in results["right_dirs_missing"]]
+        )
+
+    for name, sub_results in results["common_dirs"]:
+        print(prefix + "├── " + name)
+        sub_result = print_results(
+            sub_results,
+            os.path.join(a, name),
+            os.path.join(b, name),
+            level=level + 1,
+            prefix=prefix + "│   ",
+        )
+        result["left_files_missing"].extend(sub_result["left_files_missing"])
+        result["right_files_missing"].extend(sub_result["right_files_missing"])
+        result["left_dirs_missing"].extend(sub_result["left_dirs_missing"])
+        result["right_dirs_missing"].extend(sub_result["right_dirs_missing"])
+        result["files_different"].extend(sub_result["files_different"])
+
+    return result
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("a")
+    parser.add_argument("b")
+    parser.add_argument(
+        "--driver", choices=["chrome", "firefox", "phantomjs"], default="firefox"
+    )
+    parser.add_argument("--diff-output")
+    parser.add_argument("--max-workers", type=int, default=1)
+    args = parser.parse_args()
+
+    def initializer():
+        browser = getattr(Config.thread_local, "browser", None)
+        if browser is None:
+            browser = get_browser(driver=args.driver)
+            Config.thread_local.browser = browser
+
+    executor = ThreadPoolExecutor(max_workers=args.max_workers, initializer=initializer)
+
+    results = submit_compare_dirs(
+        args.a, args.b, executor=executor, diff_output=args.diff_output
+    )
+
+    result = print_results(results, args.a, args.b)
+    if (
+        result["left_files_missing"]
+        or result["right_files_missing"]
+        or result["left_dirs_missing"]
+        or result["right_dirs_missing"]
+        or result["files_different"]
+    ):
+        return 1
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

htmlcmp-1.0.1/src/htmlcmp/compare_output_server.py

@@ -0,0 +1,310 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+import os
+import sys
+import argparse
+import threading
+import io
+from concurrent.futures import ThreadPoolExecutor
+from html_render_diff import get_browser, html_render_diff
+from compare_output import comparable_file, compare_files
+from flask import Flask, send_from_directory, send_file
+import watchdog.observers
+import watchdog.events
+
+
+class Config:
+    path_a = None
+    path_b = None
+    driver = None
+    observer = None
+    comparator = None
+    browser = None
+    thread_local = threading.local()
+
+
+class Observer:
+    def __init__(self):
+        class Handler(watchdog.events.FileSystemEventHandler):
+            def __init__(self, path):
+                self._path = path
+
+            def dispatch(self, event):
+                if event.event_type in ["opened"]:
+                    return
+
+                if os.path.isfile(event.src_path):
+                    Config.comparator.submit(
+                        os.path.relpath(event.src_path, self._path)
+                    )
+
+        self._observer = watchdog.observers.Observer()
+        self._observer.schedule(Handler(Config.path_a), Config.path_a, recursive=True)
+        self._observer.schedule(Handler(Config.path_b), Config.path_b, recursive=True)
+
+    def start(self):
+        self._observer.start()
+
+        def init_compare(a, b):
+            common_path = os.path.relpath(a, Config.path_a)
+
+            left = sorted(os.listdir(a))
+            right = sorted(os.listdir(b))
+
+            common = [name for name in left if name in right]
+
+            for name in common:
+                if os.path.isfile(os.path.join(a, name)) and comparable_file(
+                    os.path.join(a, name)
+                ):
+                    Config.comparator.submit(os.path.join(common_path, name))
+                elif os.path.isdir(os.path.join(a, name)):
+                    init_compare(os.path.join(a, name), os.path.join(b, name))
+
+        init_compare(Config.path_a, Config.path_b)
+
+    def stop(self):
+        self._observer.stop()
+
+    def join(self):
+        self._observer.join()
+
+
+class Comparator:
+    def __init__(self, max_workers):
+        def initializer():
+            browser = getattr(Config.thread_local, "browser", None)
+            if browser is None:
+                browser = get_browser(driver=Config.driver)
+                Config.thread_local.browser = browser
+
+        self._executor = ThreadPoolExecutor(
+            max_workers=max_workers, initializer=initializer
+        )
+        self._result = {}
+        self._future = {}
+
+    def submit(self, path):
+        if path in self._future:
+            try:
+                self._future[path].cancel()
+                self._future[path].result()
+                self._future.pop(path)
+            except Exception:
+                pass
+
+        self._result[path] = "pending"
+        self._future[path] = self._executor.submit(self.compare, path)
+
+    def compare(self, path):
+        browser = getattr(Config.thread_local, "browser", None)
+        result = compare_files(
+            os.path.join(Config.path_a, path),
+            os.path.join(Config.path_b, path),
+            browser=browser,
+        )
+        self._result[path] = "same" if result else "different"
+        self._future.pop(path)
+
+    def result(self, path):
+        if path in self._result:
+            return self._result[path]
+        return "unknown"
+
+    def result_symbol(self, path):
+        result = self.result(path)
+        if result == "pending":
+            return "🔄"
+        if result == "same":
+            return "✔"
+        if result == "different":
+            return "❌"
+        return "⛔"
+
+    def result_css(self, path):
+        result = self.result(path)
+        if result == "pending":
+            return "color:blue;"
+        if result == "same":
+            return "color:green;"
+        if result == "different":
+            return "color:orange;"
+        return "color:red;"
+
+
+app = Flask("compare")
+
+
+@app.route("/")
+def root():
+    def print_tree(a, b):
+        common_path = os.path.relpath(a, Config.path_a)
+
+        left = sorted(os.listdir(a))
+        right = sorted(os.listdir(b))
+
+        left_files = sorted(
+            [
+                name
+                for name in left
+                if os.path.isfile(os.path.join(a, name))
+                and comparable_file(os.path.join(a, name))
+            ]
+        )
+        right_files = sorted(
+            [
+                name
+                for name in right
+                if os.path.isfile(os.path.join(b, name))
+                and comparable_file(os.path.join(b, name))
+            ]
+        )
+
+        left_dirs = sorted(
+            [name for name in left if os.path.isdir(os.path.join(a, name))]
+        )
+        right_dirs = sorted(
+            [name for name in right if os.path.isdir(os.path.join(b, name))]
+        )
+
+        common_files = [name for name in left_files if name in right_files]
+        common_dirs = [name for name in left_dirs if name in right_dirs]
+
+        result = "<ul>"
+
+        left_files_missing = " ".join(
+            [name for name in right_files if name not in left_files]
+        )
+        right_files_missing = " ".join(
+            [name for name in left_files if name not in right_files]
+        )
+        left_dirs_missing = " ".join(
+            [name for name in right_dirs if name not in left_dirs]
+        )
+        right_dirs_missing = " ".join(
+            [name for name in left_dirs if name not in right_dirs]
+        )
+        if left_files_missing:
+            result += f"<li><b>A files missing: {left_files_missing}</b></li>"
+        if right_files_missing:
+            result += f"<li><b>B files missing: {right_files_missing}</b></li>"
+        if left_dirs_missing:
+            result += f"<li><b>A dirs missing: {left_dirs_missing}</b></li>"
+        if right_dirs_missing:
+            result += f"<li><b>B dirs missing: {right_dirs_missing}</b></li>"
+
+        for name in common_files:
+            if Config.comparator is None:
+                result += f'<li><a href="/compare/{os.path.join(common_path, name)}">{name}</a></li>'
+            else:
+                symbol = Config.comparator.result_symbol(
+                    os.path.join(common_path, name)
+                )
+                css = Config.comparator.result_css(os.path.join(common_path, name))
+                result += f'<li style="{css}"><a style="{css}" href="/compare/{os.path.join(common_path, name)}">{name}</a> {symbol}</li>'
+
+        for name in common_dirs:
+            result += f"<li>{name}"
+            result += print_tree(os.path.join(a, name), os.path.join(b, name))
+            result += "</li>"
+
+        result += "</ul>"
+        return result
+
+    result = ""
+    result += f"<p>compare A {Config.path_a} vs B {Config.path_b}</p>"
+    result += print_tree(Config.path_a, Config.path_b)
+    return result
+
+
+@app.route("/compare/<path:path>")
+def compare(path):
+    return f"""<!DOCTYPE html>
+<html>
+<head>
+<style>
+html,body {{height:100%;margin:0;}}
+</style>
+</head>
+<body style="display:flex;flex-flow:row;">
+<div style="display:flex;flex:1;flex-flow:column;margin:5px;">
+  <a href="/file/a/{path}">{os.path.join(Config.path_a, path)}</a>
+  <iframe id="a" src="/file/a/{path}" title="a" frameborder="0" align="left" style="flex:1;"></iframe>
+</div>
+<div style="display:flex;flex:0 0 50px;flex-flow:column;">
+  <a href="/image_diff/{path}">diff</a>
+  <img src="/image_diff/{path}" width="50" height="0" style="flex:1;">
+</div>
+<div style="display:flex;flex:1;flex-flow:column;margin:5px;">
+  <a href="/file/b/{path}">{os.path.join(Config.path_b, path)}</a>
+  <iframe id="b" src="/file/b/{path}" title="b" frameborder="0" align="right" style="flex:1;"></iframe>
+</div>
+<script>
+var iframe_a = document.getElementById('a');
+var iframe_b = document.getElementById('b');
+iframe_a.contentWindow.addEventListener('scroll', function(event) {{
+  iframe_b.contentWindow.scrollTo(iframe_a.contentWindow.scrollX, iframe_a.contentWindow.scrollY);
+}});
+iframe_b.contentWindow.addEventListener('scroll', function(event) {{
+  iframe_a.contentWindow.scrollTo(iframe_b.contentWindow.scrollX, iframe_b.contentWindow.scrollY);
+}});
+</script>
+</body>
+</html> 
+"""
+
+
+@app.route("/image_diff/<path:path>")
+def image_diff(path):
+    diff, _ = html_render_diff(
+        os.path.join(Config.path_a, path),
+        os.path.join(Config.path_b, path),
+        Config.browser,
+    )
+    tmp = io.BytesIO()
+    diff.save(tmp, "JPEG", quality=70)
+    tmp.seek(0)
+    return send_file(tmp, mimetype="image/jpeg")
+
+
+@app.route("/file/<variant>/<path:path>")
+def file(variant, path):
+    variant_root = Config.path_a if variant == "a" else Config.path_b
+    return send_from_directory(variant_root, path)
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("a")
+    parser.add_argument("b")
+    parser.add_argument(
+        "--driver", choices=["chrome", "firefox", "phantomjs"], default="firefox"
+    )
+    parser.add_argument("--max-workers", type=int, default=1)
+    parser.add_argument("--compare", action="store_true")
+    parser.add_argument("--port", type=int, default=5000)
+    args = parser.parse_args()
+
+    Config.path_a = args.a
+    Config.path_b = args.b
+    Config.driver = args.driver
+    Config.browser = get_browser(driver=args.driver)
+
+    if args.compare:
+        Config.comparator = Comparator(max_workers=args.max_workers)
+
+        Config.observer = Observer()
+        Config.observer.start()
+
+    app.run(host="0.0.0.0", port=args.port)
+
+    if args.compare:
+        Config.observer.stop()
+        Config.observer.join()
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

htmlcmp-1.0.1/src/htmlcmp/html_render_diff.py

@@ -0,0 +1,115 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+import os
+import sys
+import argparse
+import io
+import time
+
+from PIL import Image, ImageChops
+from selenium import webdriver
+from selenium.webdriver.common.by import By
+from selenium.webdriver.support import expected_conditions
+from selenium.webdriver.support.ui import WebDriverWait
+import pathlib
+
+
+def to_url(something):
+    if os.path.isfile(something):
+        return pathlib.Path(os.path.abspath(something)).as_uri()
+    return something
+
+
+def screenshot(browser, url):
+    browser.get(url)
+
+    target_find_by = By.TAG_NAME
+    target = "body"
+    loaded_page_settling_time = 0
+
+    # Selenium doesn't like when we try to screenshot <body> element of documents generated by pdf2htmlEX
+    if "poppler" in url:
+        target_find_by = By.ID
+        target = "page-container"
+        loaded_page_settling_time = 1
+
+    web_driver_wait = WebDriverWait(browser, 5)
+    web_driver_wait.until(
+        expected_conditions.presence_of_element_located((target_find_by, target))
+    )
+    web_driver_wait.until(
+        lambda driver: driver.execute_script("return document.readyState") == "complete"
+    )
+    if loaded_page_settling_time != 0:
+        time.sleep(loaded_page_settling_time)
+
+    target_element = browser.find_element(target_find_by, target)
+
+    png = target_element.screenshot_as_png
+    return Image.open(io.BytesIO(png))
+
+
+def get_browser(driver="firefox", max_width=1000, max_height=10000):
+    if driver == "phantomjs":
+        browser = webdriver.PhantomJS()
+    elif driver == "firefox":
+        options = webdriver.FirefoxOptions()
+        options.add_argument("--headless")
+        browser = webdriver.Firefox(options=options)
+    else:  # chrome or unknown
+        options = webdriver.ChromeOptions()
+        options.add_argument("--headless=new")
+        browser = webdriver.Chrome(options=options)
+    browser.set_window_size(max_width, max_height)
+    return browser
+
+
+def html_render_diff(a, b, browser):
+    image_a = screenshot(browser, to_url(a))
+    image_b = screenshot(browser, to_url(b))
+
+    image_a = image_a.convert("RGB")
+    image_b = image_b.convert("RGB")
+    diff = ImageChops.difference(image_a, image_b)
+    return diff, (image_a, image_b)
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("a")
+    parser.add_argument("b")
+    parser.add_argument(
+        "--driver", choices=["chrome", "firefox", "phantomjs"], default="firefox"
+    )
+    parser.add_argument("--max-width", default=1000)
+    parser.add_argument("--max-height", default=10000)
+    args = parser.parse_args()
+
+    browser = get_browser(args.driver, args.max_width, args.max_height)
+    diff, _ = html_render_diff(args.a, args.b, browser)
+    browser.quit()
+    bounding_box = diff.getbbox()
+
+    if bounding_box:
+        print("images are different")
+        print("first error at %f%%" % (1e2 * bounding_box[1] / diff.height))
+        print(
+            "bounding box %f%%"
+            % (
+                1e2
+                * (
+                    (bounding_box[2] - bounding_box[0])
+                    * (bounding_box[3] - bounding_box[1])
+                )
+                / (diff.width * diff.height)
+            )
+        )
+        return 1
+
+    print("images are the same")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

htmlcmp-1.0.1/src/htmlcmp/tidy_output.py

@@ -0,0 +1,102 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+import os
+import sys
+import argparse
+import json
+import subprocess
+import shlex
+from common import bcolors
+
+
+def tidy_json(path):
+    try:
+        with open(path, "r") as f:
+            json.load(f)
+        return 0
+    except ValueError:
+        return 1
+
+
+def tidy_html(path):
+    config_path = os.path.join(
+        os.path.dirname(os.path.realpath(__file__)), ".html-tidy"
+    )
+    cmd = shlex.split(f'tidy -config "{config_path}" -q "{path}"')
+    result = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
+    if result.returncode == 1:
+        return 1
+    if result.returncode > 1:
+        return 2
+    return 0
+
+
+def tidy_file(path):
+    if path.endswith(".json"):
+        return tidy_json(path)
+    elif path.endswith(".html"):
+        return tidy_html(path)
+
+
+def tidyable_file(path):
+    if path.endswith(".json"):
+        return True
+    if path.endswith(".html"):
+        return True
+    return False
+
+
+def tidy_dir(path, level=0, prefix=""):
+    prefix_file = prefix + "├── "
+    if level == 0:
+        print(f"tidy dir {path}")
+
+    result = {
+        "warning": [],
+        "error": [],
+    }
+
+    items = [os.path.join(path, name) for name in os.listdir(path)]
+    files = sorted(
+        [path for path in items if os.path.isfile(path) and tidyable_file(path)]
+    )
+    dirs = sorted([path for path in items if os.path.isdir(path)])
+
+    for filename in [os.path.basename(path) for path in files]:
+        filepath = os.path.join(path, filename)
+        tidy = tidy_file(filepath)
+        if tidy == 0:
+            print(f"{prefix_file}{bcolors.OKGREEN}{filename} ✓{bcolors.ENDC}")
+        elif tidy == 1:
+            print(f"{prefix_file}{bcolors.WARNING}{filename} ✓{bcolors.ENDC}")
+            result["warning"].append(filepath)
+        elif tidy > 1:
+            print(f"{prefix_file}{bcolors.FAIL}{filename} ✘{bcolors.ENDC}")
+            result["error"].append(filepath)
+
+    for dirname in [os.path.basename(path) for path in dirs]:
+        print(prefix + "├── " + dirname)
+        subresult = tidy_dir(
+            os.path.join(path, dirname), level=level + 1, prefix=prefix + "│   "
+        )
+        result["warning"].extend(subresult["warning"])
+        result["error"].extend(subresult["error"])
+
+    return result
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("a")
+    args = parser.parse_args()
+
+    result = tidy_dir(args.a)
+    if result["error"]:
+        return 1
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

{htmlcmp-1.0.0 → htmlcmp-1.0.1}/src/htmlcmp.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: htmlcmp
-Version: 1.0.0
+Version: 1.0.1
 Summary: Compare HTML files by rendered output
 Home-page: https://github.com/opendocument-app/compare-html
 Author: Andreas Stefl

htmlcmp-1.0.1/src/htmlcmp.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+README.md
+pyproject.toml
+setup.py
+src/htmlcmp/__init__.py
+src/htmlcmp/common.py
+src/htmlcmp/compare_output.py
+src/htmlcmp/compare_output_server.py
+src/htmlcmp/html_render_diff.py
+src/htmlcmp/tidy_output.py
+src/htmlcmp.egg-info/PKG-INFO
+src/htmlcmp.egg-info/SOURCES.txt
+src/htmlcmp.egg-info/dependency_links.txt
+src/htmlcmp.egg-info/entry_points.txt
+src/htmlcmp.egg-info/top_level.txt

htmlcmp-1.0.1/src/htmlcmp.egg-info/top_level.txt

@@ -0,0 +1 @@
+htmlcmp

htmlcmp-1.0.0/src/htmlcmp.egg-info/SOURCES.txt

@@ -1,8 +0,0 @@
-README.md
-pyproject.toml
-setup.py
-src/htmlcmp.egg-info/PKG-INFO
-src/htmlcmp.egg-info/SOURCES.txt
-src/htmlcmp.egg-info/dependency_links.txt
-src/htmlcmp.egg-info/entry_points.txt
-src/htmlcmp.egg-info/top_level.txt

htmlcmp-1.0.0/src/htmlcmp.egg-info/top_level.txt

@@ -1 +0,0 @@
-