htmlcmp 1.1.0__tar.gz → 1.2.0__tar.gz

{htmlcmp-1.1.0 → htmlcmp-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: htmlcmp
-Version: 1.1.0
+Version: 1.2.0
 Summary: Compare HTML files by rendered output
 Author: Andreas Stefl
 Maintainer-email: Andreas Stefl <stefl.andreas@gmail.com>
@@ -53,3 +53,15 @@ docker run -ti \
 ```bash
 docker build --tag odr_core_test test/docker
 ```
+
+## Run locally
+
+```bash
+PYTHONPATH=$(pwd)/src:$PYTHONPATH python ./src/htmlcmp/compare_output_server.py \
+  /path/to/REFERENCE \
+  /path/to/MONITORED \
+  --compare \
+  --driver firefox \
+  --port 8000 \
+  -vv
+```

{htmlcmp-1.1.0 → htmlcmp-1.2.0}/README.md

@@ -35,3 +35,15 @@ docker run -ti \
 ```bash
 docker build --tag odr_core_test test/docker
 ```
+
+## Run locally
+
+```bash
+PYTHONPATH=$(pwd)/src:$PYTHONPATH python ./src/htmlcmp/compare_output_server.py \
+  /path/to/REFERENCE \
+  /path/to/MONITORED \
+  --compare \
+  --driver firefox \
+  --port 8000 \
+  -vv
+```

{htmlcmp-1.1.0 → htmlcmp-1.2.0}/pyproject.toml

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

{htmlcmp-1.1.0 → htmlcmp-1.2.0}/src/htmlcmp/compare_output_server.py

@@ -3,6 +3,7 @@
 
 import io
 import sys
+import shutil
 import argparse
 import logging
 import threading
@@ -29,9 +30,10 @@ class Config:
     comparator = None
     browser = None
     thread_local = threading.local()
+    log_file: Path = None
 
 
-def result_symbol(result: str):
+def result_symbol(result: str) -> str | None:
     if not isinstance(result, str):
         raise TypeError("Result must be of type str")
 
@@ -41,10 +43,10 @@ def result_symbol(result: str):
         return "✔"
     if result == "different":
         return "❌"
-    return "⛔"
+    return None
 
 
-def result_css(result: str):
+def result_css(result: str) -> str | None:
     if not isinstance(result, str):
         raise TypeError("Result must be of type str")
 
@@ -53,8 +55,8 @@ def result_css(result: str):
     if result == "same":
         return "color:green;"
     if result == "different":
-        return "color:orange;"
-    return "color:red;"
+        return "color:red;"
+    return None
 
 
 class Observer:
@@ -86,7 +88,7 @@ class 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):
+    def start(self) -> None:
         logger.info("Starting watchdog observer")
         self._observer.start()
 
@@ -118,11 +120,11 @@ class Observer:
         init_compare(Config.path_a, Config.path_b)
         logger.info("Initial comparison submitted")
 
-    def stop(self):
+    def stop(self) -> None:
         logger.info("Stopping watchdog observer")
         self._observer.stop()
 
-    def join(self):
+    def join(self) -> None:
         logger.info("Joining watchdog observer")
         self._observer.join()
 
@@ -130,10 +132,11 @@ class Observer:
 class Comparator:
     def __init__(self, max_workers: int):
         def initializer():
-            browser = getattr(Config.thread_local, "browser", None)
-            if browser is None:
-                browser = get_browser(driver=Config.driver)
-                Config.thread_local.browser = browser
+            if Config.driver is not None:
+                browser = getattr(Config.thread_local, "browser", None)
+                if browser is None:
+                    browser = get_browser(driver=Config.driver)
+                    Config.thread_local.browser = browser
 
         logger.info(f"Creating comparator with {max_workers} workers")
 
@@ -143,12 +146,16 @@ class Comparator:
         self._result = {}
         self._future = {}
 
-    def submit(self, path: Path):
+    def submit(self, path: Path) -> None:
         logger.debug(f"Submitting comparison for path: {path}")
 
         if not isinstance(path, Path):
             raise TypeError("Path must be of type Path")
 
+        if path.suffix.lower() in [".html", ".htm"] and Config.driver is None:
+            logger.debug(f"Skipping submission of HTML file without browser: {path}")
+            return
+
         if path in self._future:
             try:
                 self._future[path].cancel()
@@ -160,7 +167,7 @@ class Comparator:
         self._result[path] = "pending"
         self._future[path] = self._executor.submit(self.compare, path)
 
-    def compare(self, path: Path):
+    def compare(self, path: Path) -> None:
         logger.debug(f"Comparing files for path: {path}")
 
         if not isinstance(path, Path):
@@ -177,7 +184,7 @@ class Comparator:
         self._result[path] = "same" if result else "different"
         self._future.pop(path)
 
-    def result(self, path: Path):
+    def result(self, path: Path) -> str | None:
         logger.debug(f"Getting comparison result for path: {path}")
 
         if not isinstance(path, Path):
@@ -220,9 +227,13 @@ class Comparator:
 
             return functools.reduce(
                 lambda a, b: (
-                    "pending"
-                    if "pending" in (a, b)
-                    else ("different" if "different" in (a, b) else "same")
+                    None
+                    if None in (a, b)
+                    else (
+                        "pending"
+                        if "pending" in (a, b)
+                        else "different" if "different" in (a, b) else "same"
+                    )
                 ),
                 [self.result(path / name) for name in common]
                 + [
@@ -235,20 +246,42 @@ class Comparator:
                 "same",
             )
 
-        logger.warning(f"No comparison result for path: {path}")
-        return "unknown"
+        logger.debug(f"No comparison result for path: {path}")
+        return None
 
 
 app = Flask("compare")
 
 
+@app.route("/script.js")
+def script_js():
+    logger.debug("Serving script.js")
+
+    return """
+function updateRef(path) {
+  fetch(`/update_ref/${path}`)
+    .then(response => {
+      if (response.ok) {
+        alert(`Reference updated for ${path}`);
+        location.reload();
+      } else {
+        alert(`Failed to update reference for ${path}: ${response.statusText}`);
+      }
+    })
+    .catch(error => {
+      alert(`Error updating reference for ${path}: ${error}`);
+    });
+}
+"""
+
+
 @app.route("/")
 def root():
     logger.debug("Generating root directory listing")
 
     current_entry_id = 0
 
-    def next_entry_id():
+    def next_entry_id() -> int:
         nonlocal current_entry_id
         entry_id = current_entry_id
         current_entry_id += 1
@@ -284,7 +317,7 @@ def root():
             result += "<td></td>"
 
         if is_comparable:
-            main = f'<a href="/compare/{path}">{name}</a>'
+            main = f'<a href="/compare/{path}" target="_blank">{name}</a>'
         else:
             main = f"{name}"
         if cmp_result is not None:
@@ -297,6 +330,10 @@ def root():
         result += f'<td class="main" style="{style}">{main}</td>'
         result += f"<td>{message}</td>"
 
+        result += (
+            f"<td><button onclick=\"updateRef('{path}')\">update ref</button></td>"
+        )
+
         result += "</tr>"
 
         return result
@@ -429,16 +466,24 @@ tr {
   padding-left: calc(1.0rem * var(--depth));
 }
 </style>
+<script src="/script.js"></script>
 </head>
 <body>
 """
 
     result += "<p>"
     result += "comparing<br>"
-    result += f"A: {Config.path_a}<br>"
-    result += f"B: {Config.path_b}"
+    result += f"Reference: {Config.path_a}<br>"
+    result += f"Monitored: {Config.path_b}"
     result += "</p>"
 
+    if Config.log_file is not None:
+        result += "<p>"
+        result += (
+            f'<a href="/logfile" target="_blank">View log file: {Config.log_file}</a>'
+        )
+        result += "</p>"
+
     result += "<p>"
     result += '<button onclick="toggleAll(true)">Expand All</button>'
     result += '<button onclick="toggleAll(false)">Collapse All</button>'
@@ -446,7 +491,7 @@ tr {
 
     result += "<table>"
     result += "<thead>"
-    result += "<tr><td></td><td></td><td>Name</td><td>Message</td></tr>"
+    result += "<tr><td></td><td></td><td>Name</td><td>Message</td><td>Actions</td></tr>"
     result += "</thead>"
     result += "<tbody>"
     result += generate_tree(Config.path_a, Config.path_b, "", None, 0)
@@ -471,6 +516,11 @@ function toggleChildren(parentId, show) {
   document.querySelectorAll(`tr[data-parent-id="${parentId}"]`)
     .forEach(child => {
       child.hidden = !show;
+      if (!show) {
+        toggleChildren(child.dataset.entryId, false);
+        const toggle = child.querySelector(".toggle");
+        if (toggle) toggle.textContent = "▶";
+      }
     });
 }
 
@@ -493,6 +543,16 @@ function toggleAll(show) {
     return result
 
 
+@app.route("/logfile")
+def logfile():
+    logger.debug("Serving log file")
+
+    if Config.log_file is None:
+        return "No log file configured", 404
+
+    return send_from_directory(Config.log_file.parent, Config.log_file.name)
+
+
 @app.route("/compare/<path:path>")
 def compare(path: str):
     logger.debug(f"Generating comparison page for path: {path}")
@@ -506,18 +566,20 @@ def compare(path: str):
 <style>
 html,body {{height:100%;margin:0;}}
 </style>
+<script src="/script.js"></script>
 </head>
 <body style="display:flex;flex-flow:row;">
 <div style="display:flex;flex:1;flex-flow:column;margin:5px;">
-  <a href="/file/a/{path}">{Config.path_a / path}</a>
+  <a href="/file/a/{path}" target="_blank">{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>
+  <a href="/image_diff/{path}" target="_blank">diff</a>
+  <button onclick="updateRef('{path}')">▶</button>
   <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}">{Config.path_b / path}</a>
+  <a href="/file/b/{path}" target="_blank">{Config.path_b / path}</a>
   <iframe id="b" src="/file/b/{path}" title="b" frameborder="0" align="right" style="flex:1;"></iframe>
 </div>
 <script>
@@ -542,6 +604,9 @@ def image_diff(path: str):
     if not isinstance(path, str):
         raise TypeError("Path must be a string")
 
+    if Config.driver is None:
+        return "Image diff not available without browser driver", 404
+
     diff, _ = html_render_diff(
         Config.path_a / path,
         Config.path_b / path,
@@ -566,15 +631,46 @@ def file(variant: str, path: str):
     return send_from_directory(variant_root, path)
 
 
-def setup_logging(verbosity: int):
+@app.route("/update_ref/<path:path>")
+def update_ref(path: str):
+    logger.debug(f"Updating reference for path: {path}")
+
+    if not isinstance(path, str):
+        raise TypeError("Path must be a string")
+
+    src = Config.path_b / path
+    dst = Config.path_a / path
+
+    if not src.exists():
+        return f"Source file does not exist: {src}", 404
+
+    if src.is_file():
+        shutil.copy2(src, dst)
+    else:
+        shutil.copytree(src, dst, dirs_exist_ok=True)
+
+    return "Reference updated", 200
+
+
+def verbosity_to_level(verbosity: int) -> int:
     if verbosity >= 3:
-        level = logging.DEBUG
+        return logging.DEBUG
     elif verbosity == 2:
-        level = logging.INFO
+        return logging.INFO
     elif verbosity == 1:
-        level = logging.WARNING
+        return logging.WARNING
     else:
-        level = logging.ERROR
+        return logging.ERROR
+
+
+def setup_logging(
+    verbosity: int, log_file: Path = None, log_file_verbosity: int = None
+) -> None:
+    level = verbosity_to_level(verbosity)
+
+    root_logger = logging.getLogger()
+    root_logger.setLevel(level)
+    root_logger.handlers.clear()
 
     formatter = logging.Formatter(
         fmt="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
@@ -582,21 +678,28 @@ def setup_logging(verbosity: int):
     )
 
     console_handler = logging.StreamHandler(sys.stderr)
+    console_handler.setLevel(level)
     console_handler.setFormatter(formatter)
-
-    root_logger = logging.getLogger()
-    root_logger.setLevel(level)
-    root_logger.handlers.clear()
     root_logger.addHandler(console_handler)
 
+    if log_file is not None:
+        file_level = (
+            verbosity_to_level(log_file_verbosity)
+            if log_file_verbosity is not None
+            else level
+        )
+
+        file_handler = logging.FileHandler(log_file, mode="a", encoding="utf-8")
+        file_handler.setLevel(file_level)
+        file_handler.setFormatter(formatter)
+        root_logger.addHandler(file_handler)
+
 
 def main():
     parser = argparse.ArgumentParser()
-    parser.add_argument("a", type=Path, help="Path to the first directory")
-    parser.add_argument("b", type=Path, help="Path to the second directory")
-    parser.add_argument(
-        "--driver", choices=["chrome", "firefox", "phantomjs"], default="firefox"
-    )
+    parser.add_argument("ref", type=Path, help="Path to the reference directory")
+    parser.add_argument("mon", type=Path, help="Path to the monitored directory")
+    parser.add_argument("--driver", choices=["chrome", "firefox", "phantomjs"])
     parser.add_argument("--max-workers", type=int, default=1)
     parser.add_argument("--compare", action="store_true")
     parser.add_argument("--port", type=int, default=5000)
@@ -607,14 +710,25 @@ def main():
         default=0,
         help="Increase verbosity (-v, -vv, -vvv)",
     )
+    parser.add_argument(
+        "--log-file",
+        type=Path,
+        help="Path to log file",
+    )
+    parser.add_argument(
+        "--log-file-verbosity", type=int, help="Log file verbosity level"
+    )
     args = parser.parse_args()
 
-    setup_logging(args.verbose)
+    setup_logging(args.verbose, args.log_file, args.log_file_verbosity)
 
-    Config.path_a = args.a
-    Config.path_b = args.b
+    Config.path_a = args.ref
+    Config.path_b = args.mon
     Config.driver = args.driver
-    Config.browser = get_browser(driver=args.driver)
+    Config.browser = (
+        get_browser(driver=args.driver) if args.driver is not None else None
+    )
+    Config.log_file = args.log_file
 
     if args.compare:
         Config.comparator = Comparator(max_workers=args.max_workers)

{htmlcmp-1.1.0 → htmlcmp-1.2.0}/src/htmlcmp/tidy_output.py

@@ -10,7 +10,7 @@ from pathlib import Path
 from htmlcmp.common import bcolors
 
 
-def tidy_json(path: Path) -> int:
+def tidy_json(path: Path, verbose: bool = False) -> int:
     if not isinstance(path, Path):
         raise TypeError("path must be a Path object")
     if not path.is_file():
@@ -21,10 +21,11 @@ def tidy_json(path: Path) -> int:
             json.load(f)
         return 0
     except ValueError:
+        print(f"{bcolors.FAIL}Error: {path} is not a valid JSON file{bcolors.ENDC}")
         return 1
 
 
-def tidy_html(path: Path, html_tidy_config: Path = None) -> int:
+def tidy_html(path: Path, html_tidy_config: Path = None, verbose: bool = False) -> int:
     if not isinstance(path, Path):
         raise TypeError("path must be a Path object")
     if not path.is_file():
@@ -41,6 +42,15 @@ def tidy_html(path: Path, html_tidy_config: Path = None) -> int:
     result = subprocess.run(
         cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True
     )
+    if result.stdout:
+        if verbose and result.returncode == 0:
+            print(result.stdout)
+        elif verbose and result.returncode == 1:
+            print(f"{bcolors.WARNING}Warning: {path} has warnings{bcolors.ENDC}")
+            print(f"{bcolors.WARNING}{result.stdout}{bcolors.ENDC}")
+        elif verbose or result.returncode > 1:
+            print(f"{bcolors.FAIL}Error: {path} has errors{bcolors.ENDC}")
+            print(f"{bcolors.FAIL}{result.stdout}{bcolors.ENDC}")
     if result.returncode == 1:
         return 1
     if result.returncode > 1:
@@ -48,16 +58,16 @@ def tidy_html(path: Path, html_tidy_config: Path = None) -> int:
     return 0
 
 
-def tidy_file(path: Path, html_tidy_config: Path = None) -> int:
+def tidy_file(path: Path, html_tidy_config: Path = None, verbose: bool = False) -> int:
     if not isinstance(path, Path):
         raise TypeError("path must be a Path object")
     if not path.is_file():
         raise FileNotFoundError(f"{path} is not a file")
 
     if path.suffix == ".json":
-        return tidy_json(path)
+        return tidy_json(path, verbose=verbose)
     elif path.suffix == ".html":
-        return tidy_html(path, html_tidy_config=html_tidy_config)
+        return tidy_html(path, html_tidy_config=html_tidy_config, verbose=verbose)
 
 
 def tidyable_file(path: Path) -> bool:
@@ -74,7 +84,11 @@ def tidyable_file(path: Path) -> bool:
 
 
 def tidy_dir(
-    path: Path, level: int = 0, prefix: str = "", html_tidy_config: Path = None
+    path: Path,
+    level: int = 0,
+    prefix: str = "",
+    html_tidy_config: Path = None,
+    verbose: bool = False,
 ) -> dict[str, list[Path]]:
     if not isinstance(path, Path):
         raise TypeError("path must be a Path object")
@@ -104,7 +118,7 @@ def tidy_dir(
 
     for filename in [path.name for path in files]:
         filepath = path / filename
-        tidy = tidy_file(filepath, html_tidy_config=html_tidy_config)
+        tidy = tidy_file(filepath, html_tidy_config=html_tidy_config, verbose=verbose)
         if tidy == 0:
             print(f"{prefix_file}{bcolors.OKGREEN}{filename} ✓{bcolors.ENDC}")
         elif tidy == 1:
@@ -121,6 +135,7 @@ def tidy_dir(
             level=level + 1,
             prefix=prefix + "│   ",
             html_tidy_config=html_tidy_config,
+            verbose=verbose,
         )
         result["warning"].extend(subresult["warning"])
         result["error"].extend(subresult["error"])
@@ -134,9 +149,16 @@ def main():
     parser.add_argument(
         "--html-tidy-config", type=Path, help="Path to tidy config file"
     )
+    parser.add_argument(
+        "--verbose",
+        action="store_true",
+        help="Print verbose output (warnings and errors)",
+    )
     args = parser.parse_args()
 
-    result = tidy_dir(args.path, html_tidy_config=args.html_tidy_config)
+    result = tidy_dir(
+        args.path, html_tidy_config=args.html_tidy_config, verbose=args.verbose
+    )
     if result["error"]:
         return 1
 

{htmlcmp-1.1.0 → htmlcmp-1.2.0}/src/htmlcmp.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: htmlcmp
-Version: 1.1.0
+Version: 1.2.0
 Summary: Compare HTML files by rendered output
 Author: Andreas Stefl
 Maintainer-email: Andreas Stefl <stefl.andreas@gmail.com>
@@ -53,3 +53,15 @@ docker run -ti \
 ```bash
 docker build --tag odr_core_test test/docker
 ```
+
+## Run locally
+
+```bash
+PYTHONPATH=$(pwd)/src:$PYTHONPATH python ./src/htmlcmp/compare_output_server.py \
+  /path/to/REFERENCE \
+  /path/to/MONITORED \
+  --compare \
+  --driver firefox \
+  --port 8000 \
+  -vv
+```