fix watchdog; add logging

bump version to 1.0.16

Author: andiwand

pyproject.toml

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

src/htmlcmp/compare_output_server.py

@@ -1,10 +1,11 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 
+import io
 import sys
 import argparse
+import logging
 import threading
-import io
 from pathlib import Path
 from concurrent.futures import ThreadPoolExecutor
 
@@ -36,19 +37,32 @@ def dispatch(self, event):
                 event_type = event.event_type
                 src_path = Path(event.src_path)
 
-                if event_type in ["opened"]:
+                logging.verbose(f"Watchdog event: {event_type} {src_path}")
+
+                if event_type not in ["moved", "deleted", "created", "modified"]:
                     return
 
                 if src_path.is_file():
+                    logging.debug(
+                        f"Submit watchdog file change: {event_type} {src_path}"
+                    )
                     Config.comparator.submit(src_path.relative_to(self._path))
+
+        logging.info("Create watchdog for paths:")
+        logging.info(f"  A: {Config.path_a}")
+        logging.info(f"  B: {Config.path_b}")
+
         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):
+        logging.info("Starting watchdog observer")
         self._observer.start()
 
         def init_compare(a: Path, b: Path):
+            logging.verbose(f"Initial compare: {a} vs {b}")
+
             if not isinstance(a, Path) or not isinstance(b, Path):
                 raise TypeError("Paths must be of type Path")
             if not a.is_dir() or not b.is_dir():
@@ -63,16 +77,23 @@ def init_compare(a: Path, b: Path):
 
             for name in common:
                 if (a / name).is_file() and comparable_file(a / name):
+                    logging.debug(
+                        f"Submit initial file comparison: {common_path / name}"
+                    )
                     Config.comparator.submit(common_path / name)
                 elif (a / name).is_dir():
                     init_compare(a / name, b / name)
 
+        logging.info("Kick off initial comparison of all files")
         init_compare(Config.path_a, Config.path_b)
+        logging.info("Initial comparison submitted")
 
     def stop(self):
+        logging.info("Stopping watchdog observer")
         self._observer.stop()
 
     def join(self):
+        logging.info("Joining watchdog observer")
         self._observer.join()
 
 
@@ -84,13 +105,17 @@ def initializer():
                 browser = get_browser(driver=Config.driver)
                 Config.thread_local.browser = browser
 
+        logging.info(f"Creating comparator with {max_workers} workers")
+
         self._executor = ThreadPoolExecutor(
             max_workers=max_workers, initializer=initializer
         )
         self._result = {}
         self._future = {}
 
     def submit(self, path: Path):
+        logging.debug(f"Submitting comparison for path: {path}")
+
         if not isinstance(path, Path):
             raise TypeError("Path must be of type Path")
 
@@ -106,6 +131,8 @@ def submit(self, path: Path):
         self._future[path] = self._executor.submit(self.compare, path)
 
     def compare(self, path: Path):
+        logging.debug(f"Comparing files for path: {path}")
+
         if not isinstance(path, Path):
             raise TypeError("Path must be of type Path")
         if path not in self._future:
@@ -121,6 +148,8 @@ def compare(self, path: Path):
         self._future.pop(path)
 
     def result(self, path: Path):
+        logging.debug(f"Getting comparison result for path: {path}")
+
         if not isinstance(path, Path):
             raise TypeError("Path must be of type Path")
 
@@ -129,6 +158,8 @@ def result(self, path: Path):
         return "unknown"
 
     def result_symbol(self, path: Path):
+        logging.debug(f"Getting comparison result symbol for path: {path}")
+
         if not isinstance(path, Path):
             raise TypeError("Path must be of type Path")
 
@@ -142,6 +173,8 @@ def result_symbol(self, path: Path):
         return "⛔"
 
     def result_css(self, path: Path):
+        logging.debug(f"Getting comparison result CSS for path: {path}")
+
         if not isinstance(path, Path):
             raise TypeError("Path must be of type Path")
 
@@ -160,6 +193,8 @@ def result_css(self, path: Path):
 
 @app.route("/")
 def root():
+    logging.debug("Generating root directory listing")
+
     def print_tree(a: Path, b: Path):
         if not isinstance(a, Path) or not isinstance(b, Path):
             raise TypeError("Paths must be of type Path")
@@ -239,6 +274,8 @@ def print_tree(a: Path, b: Path):
 
 @app.route("/compare/<path:path>")
 def compare(path: str):
+    logging.debug(f"Generating comparison page for path: {path}")
+
     if not isinstance(path, str):
         raise TypeError("Path must be a string")
 
@@ -279,6 +316,8 @@ def compare(path: str):
 
 @app.route("/image_diff/<path:path>")
 def image_diff(path: str):
+    logging.debug(f"Generating image diff for path: {path}")
+
     if not isinstance(path, str):
         raise TypeError("Path must be a string")
 
@@ -295,6 +334,8 @@ def image_diff(path: str):
 
 @app.route("/file/<variant>/<path:path>")
 def file(variant: str, path: str):
+    logging.debug(f"Serving file for variant: {variant}, path: {path}")
+
     if not isinstance(variant, str) or not isinstance(path, str):
         raise TypeError("Variant and path must be strings")
     if variant not in ["a", "b"]:
@@ -304,6 +345,30 @@ def file(variant: str, path: str):
     return send_from_directory(variant_root, path)
 
 
+def setup_logging(verbosity: int):
+    if verbosity >= 3:
+        level = logging.VERBOSE
+    elif verbosity == 2:
+        level = logging.DEBUG
+    elif verbosity == 1:
+        level = logging.INFO
+    else:
+        level = logging.WARNING
+
+    logger = logging.getLogger()
+    logger.setLevel(level)
+    logger.handlers.clear()
+
+    formatter = logging.Formatter(
+        fmt="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
+        datefmt="%Y-%m-%d %H:%M:%S",
+    )
+
+    console_handler = logging.StreamHandler(sys.stderr)
+    console_handler.setFormatter(formatter)
+    logger.addHandler(console_handler)
+
+
 def main():
     parser = argparse.ArgumentParser()
     parser.add_argument("a", type=Path, help="Path to the first directory")
@@ -314,8 +379,17 @@ def main():
     parser.add_argument("--max-workers", type=int, default=1)
     parser.add_argument("--compare", action="store_true")
     parser.add_argument("--port", type=int, default=5000)
+    parser.add_argument(
+        "-v",
+        "--verbose",
+        action="count",
+        default=0,
+        help="Increase verbosity (-v, -vv, -vvv)",
+    )
     args = parser.parse_args()
 
+    setup_logging(args.verbose)
+
     Config.path_a = args.a
     Config.path_b = args.b
     Config.driver = args.driver