DVR-Scan-Headless 1.8__py3-none-any.whl

dvr_scan/LICENSE

@@ -0,0 +1,47 @@
+-----------------------------------------------------------------------
+  DVR-Scan License (BSD 2-Clause)
+  < https://github.com/Breakthrough/DVR-Scan >
+-----------------------------------------------------------------------
+
+Copyright (C) 2016, Brandon Castellano.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+    1. Redistributions of source code must retain the above copyright
+       notice, this list of conditions and the following disclaimer.
+
+    2. Redistributions in binary form must reproduce the above
+       copyright notice, this list of conditions and the following
+       disclaimer in the documentation and/or other materials
+       provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+-----------------------------------------------------------------------
+  Ancillary Software Licenses
+-----------------------------------------------------------------------
+
+DVR-Scan uses the following third-party software components:
+
+> NumPy [Copyright (C) 2005-2022, Numpy Developers]
+> OpenCV [Copyright (C) 2022, OpenCV Team]
+> FFmpeg [Copyright (C) 2001, Fabrice Bellard]
+> CUDA [Copyright (C) 2020, Nvidia Corporation]
+
+Some binary distributions may redistribute these components. See the
+included LICENSE-THIRDPARTY file for details. By downloading, copying,
+or using this software, you agree to the terms of this license and all
+third-party software licenses.

dvr_scan/__init__.py

@@ -0,0 +1,55 @@
+#
+#      DVR-Scan: Video Motion Event Detection & Extraction Tool
+#   --------------------------------------------------------------
+#       [  Site: https://www.dvr-scan.com/                 ]
+#       [  Repo: https://github.com/Breakthrough/DVR-Scan  ]
+#
+# Copyright (C) 2016 Brandon Castellano <http://www.bcastell.com>.
+# DVR-Scan is licensed under the BSD 2-Clause License; see the included
+# LICENSE file, or visit one of the above pages for details.
+#
+"""``dvr_scan`` Module
+
+This is the main DVR-Scan module containing all application logic,
+motion detection implementation, and command line processing. The
+main modules under `dvr_scan` are organized as follows:
+
+  ``cli``: command-line interface
+
+  ``scanner``: scans a video for motion and extracts events
+
+  ``detector``: motion detection algorithms
+
+  ``overlays``: overlays which can be drawn when outputting events
+
+There are also a few helper modules:
+
+  ``video_joiner``: concatenates multiple input videos
+
+  ``opencv_loader``: helper for resolving dynamic libraries used by OpenCV
+
+  ``platform``: library/platform specific helpers
+"""
+
+import pkgutil
+import sys
+
+# Used for module/distribution identification.
+__version__ = "1.8"
+
+# Handle loading OpenCV. This **MUST** be first before any other DVR-Scan or third-party
+# packages are imported which might attempt to import the `cv2` module.
+import dvr_scan.opencv_loader as _  # noqa: F401
+from dvr_scan.platform import init_logger
+
+# Initialize logger.
+init_logger(show_stdout=True)
+
+
+def get_license_info() -> str:
+    """Get license/copyright information for the package or standalone executable."""
+    license_text = pkgutil.get_data(__name__, "LICENSE").decode()
+    # Include additional third-party license text if they were bundled into this release.
+    if getattr(sys, "frozen", False) and hasattr(sys, "_MEIPASS"):
+        license_text += pkgutil.get_data(__name__, "LICENSE-THIRDPARTY").decode()
+    return license_text

dvr_scan/__main__.py

@@ -0,0 +1,80 @@
+#
+#      DVR-Scan: Video Motion Event Detection & Extraction Tool
+#   --------------------------------------------------------------
+#       [  Site: https://www.dvr-scan.com/                 ]
+#       [  Repo: https://github.com/Breakthrough/DVR-Scan  ]
+#
+# Copyright (C) 2016 Brandon Castellano <http://www.bcastell.com>.
+# DVR-Scan is licensed under the BSD 2-Clause License; see the included
+# LICENSE file, or visit one of the above pages for details.
+#
+"""``dvr_scan.__main__`` Module
+
+Provides entry point for DVR-Scan's command-line interface (CLI).
+"""
+
+import logging
+import sys
+from subprocess import CalledProcessError
+
+from scenedetect import VideoOpenFailure
+
+from dvr_scan.controller import parse_settings, run_dvr_scan
+from dvr_scan.shared import logging_redirect_tqdm
+
+EXIT_SUCCESS: int = 0
+EXIT_ERROR: int = 1
+
+
+def main():
+    """Main entry-point for DVR-Scan."""
+    settings = parse_settings()
+    if settings is None:
+        sys.exit(EXIT_ERROR)
+    logger = logging.getLogger("dvr_scan")
+    # TODO(1.7): The logging redirect does not respect the original log level, which is now set to
+    # DEBUG mode for rolling log files.
+    # We might have to just roll our own instead of relying on this one.
+    # TODO: Use Python __debug__ mode instead of hard-coding as config option.
+    debug_mode = settings.get("debug")
+    show_traceback = getattr(logging, settings.get("verbosity").upper()) == logging.DEBUG
+    with logging_redirect_tqdm(loggers=[logger]):
+        try:
+            run_dvr_scan(settings)
+        except ValueError as ex:
+            logger.critical("Setting Error: %s", str(ex), exc_info=show_traceback)
+            if debug_mode:
+                raise
+        except VideoOpenFailure as ex:
+            logger.critical("Failed to load input: %s", str(ex), exc_info=show_traceback)
+            if debug_mode:
+                raise
+        except KeyboardInterrupt:
+            logger.info("Stopping (interrupt received)...", exc_info=show_traceback)
+            if debug_mode:
+                raise
+        except CalledProcessError as ex:
+            logger.error(
+                "Failed to run command:\n  %s\nCommand returned %d, output:\n\n%s",
+                " ".join(ex.cmd),
+                ex.returncode,
+                ex.output,
+                exc_info=show_traceback,
+            )
+            if debug_mode:
+                raise
+        except NotImplementedError as ex:
+            logger.critical("Error (Not Implemented): %s", str(ex), exc_info=show_traceback)
+            if debug_mode:
+                raise
+        except Exception as ex:
+            logger.critical("Critical Error: %s", str(ex), exc_info=True)
+            if debug_mode:
+                raise
+        else:
+            sys.exit(EXIT_SUCCESS)
+        sys.exit(EXIT_ERROR)
+
+
+if __name__ == "__main__":
+    main()

dvr_scan/app/__init__.py

@@ -0,0 +1,10 @@
+#
+#      DVR-Scan: Video Motion Event Detection & Extraction Tool
+#   --------------------------------------------------------------
+#       [  Site: https://www.dvr-scan.com/                 ]
+#       [  Repo: https://github.com/Breakthrough/DVR-Scan  ]
+#
+# Copyright (C) 2024 Brandon Castellano <http://www.bcastell.com>.
+# DVR-Scan is licensed under the BSD 2-Clause License; see the included
+# LICENSE file, or visit one of the above pages for details.
+#

dvr_scan/app/__main__.py

@@ -0,0 +1,218 @@
+#
+#      DVR-Scan: Video Motion Event Detection & Extraction Tool
+#   --------------------------------------------------------------
+#       [  Site: https://www.dvr-scan.com/                 ]
+#       [  Repo: https://github.com/Breakthrough/DVR-Scan  ]
+#
+# Copyright (C) 2024 Brandon Castellano <http://www.bcastell.com>.
+# DVR-Scan is licensed under the BSD 2-Clause License; see the included
+# LICENSE file, or visit one of the above pages for details.
+#
+
+import argparse
+import logging
+import sys
+from subprocess import CalledProcessError
+
+from scenedetect import VideoOpenFailure
+
+import dvr_scan
+from dvr_scan import get_license_info
+from dvr_scan.app.application import Application
+from dvr_scan.config import CHOICE_MAP, USER_CONFIG_FILE_PATH, ConfigLoadFailure, ConfigRegistry
+from dvr_scan.shared import (
+    ScanSettings,
+    init_logging,
+    logfile_path,
+    logging_redirect_tqdm,
+    setup_logger,
+)
+from dvr_scan.shared.cli import VERSION_STRING, LicenseAction, VersionAction, string_type_check
+
+logger = logging.getLogger("dvr_scan")
+
+
+EXIT_SUCCESS: int = 0
+EXIT_ERROR: int = 1
+
+LOGFILE_PATH = logfile_path(name_prefix="dvr-scan-app")
+
+
+def get_cli_parser():
+    parser = argparse.ArgumentParser(
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+        argument_default=argparse.SUPPRESS,
+    )
+    if hasattr(parser, "_optionals"):
+        parser._optionals.title = "arguments"
+
+    parser.add_argument(
+        "-c",
+        "--config",
+        metavar="dvr-scan.cfg",
+        type=str,
+        help=(
+            "Config file to load scan settings from. If not set, tries to load one from %s"
+            % USER_CONFIG_FILE_PATH
+        ),
+    )
+
+    parser.add_argument(
+        "-V",
+        "--version",
+        action=VersionAction,
+        version=VERSION_STRING,
+    )
+
+    parser.add_argument(
+        "-v",
+        "--verbosity",
+        metavar="type",
+        type=string_type_check(CHOICE_MAP["verbosity"], False, "type"),
+        help=(
+            "Verbosity type to use for log output. Must be one of: %s."
+            % (", ".join(CHOICE_MAP["verbosity"]),)
+        ),
+    )
+
+    parser.add_argument(
+        "--logfile",
+        metavar="file",
+        type=str,
+        help=(
+            "Appends application output to file. If file does not exist it will be created. "
+            f"Log path: {LOGFILE_PATH.parent}"
+        ),
+    )
+
+    parser.add_argument(
+        "-L",
+        "--license",
+        action=LicenseAction,
+        version=get_license_info(),
+    )
+
+    parser.add_argument(
+        "--debug",
+        action="store_true",
+        help=argparse.SUPPRESS,
+        default=False,
+    )
+
+    parser.add_argument(
+        "input",
+        nargs="*",
+        type=str,
+    )
+
+    return parser
+
+
+# TODO: There's a lot of duplicated code here between the CLI and GUI. See if we can combine some
+# of the handling of config file loading and exceptions to be consistent between the two.
+#
+# It would also be nice if both commands took the same set of arguments. Can probably re-use the
+# existing CLI parser.
+def main():
+    """Parse command line options and load config file settings."""
+    # We defer printing the debug log until we know where to put it.
+    init_log = []
+    failed_to_load_config = True
+    config = ConfigRegistry()
+    config_load_error = None
+    # Create debug log handler and try to load the user config file.
+    try:
+        user_config = ConfigRegistry()
+        user_config.load()
+        config = user_config
+    except ConfigLoadFailure as ex:
+        config_load_error = ex
+    # Parse CLI args, override config if an override was specified on the command line.
+    try:
+        args = get_cli_parser().parse_args()
+        init_logging(args, config)
+        init_log += [(logging.INFO, "DVR-Scan Application %s" % dvr_scan.__version__)]
+        if config_load_error and not hasattr(args, "config"):
+            raise config_load_error
+        if hasattr(args, "config"):
+            config_setting = ConfigRegistry()
+            config_setting.load(args.config)
+            init_logging(args, config_setting)
+            config = config_setting
+        init_log += config.consume_init_log()
+        if config.config_dict:
+            logger.debug("Loaded configuration:\n%s", str(config.config_dict))
+        logger.debug("Program arguments:\n%s", str(args))
+        settings = ScanSettings(args=args, config=config)
+        if settings.get("save-log"):
+            setup_logger(
+                logfile_path=LOGFILE_PATH,
+                max_log_files=settings.get("max-log-files"),
+                name_prefix="dvr-scan-app",
+            )
+        failed_to_load_config = False
+    except ConfigLoadFailure as ex:
+        init_log += ex.init_log
+        if ex.reason is not None:
+            init_log += [(logging.ERROR, "Error: %s" % str(ex.reason).replace("\t", "  "))]
+        failed_to_load_config = True
+        config_load_error = ex
+    finally:
+        for log_level, log_str in init_log:
+            logger.log(log_level, log_str)
+
+    if failed_to_load_config:
+        logger.critical("Failed to load config file.")
+        logger.debug("Error loading config file:", exc_info=config_load_error)
+        # Intentionally suppress the exception in release mode since we've already logged the
+        # failure reason to the user above. We can now exit with an error code.
+        raise SystemExit(1)
+
+    show_traceback = getattr(logging, settings.get("verbosity").upper()) == logging.DEBUG
+    # TODO: Use Python __debug__ mode instead of hard-coding as config option.
+    debug_mode = settings.get("debug")
+    with logging_redirect_tqdm(loggers=[logger]):
+        try:
+            app = Application(
+                settings=settings, initial_videos=args.input if hasattr(args, "input") else []
+            )
+            app.run()
+
+        except ValueError as ex:
+            logger.critical("Setting Error: %s", str(ex), exc_info=show_traceback)
+            if debug_mode:
+                raise
+        except VideoOpenFailure as ex:
+            logger.critical("Failed to load input: %s", str(ex), exc_info=show_traceback)
+            if debug_mode:
+                raise
+        except KeyboardInterrupt:
+            # TODO: This doesn't always work when the GUI is running.
+            logger.info("Stopping (interrupt received)...", exc_info=show_traceback)
+            if debug_mode:
+                raise
+        except CalledProcessError as ex:
+            logger.error(
+                "Failed to run command:\n  %s\nCommand returned %d, output:\n\n%s",
+                " ".join(ex.cmd),
+                ex.returncode,
+                ex.output,
+                exc_info=show_traceback,
+            )
+            if debug_mode:
+                raise
+        except NotImplementedError as ex:
+            logger.critical("Error (Not Implemented): %s", str(ex), exc_info=show_traceback)
+            if debug_mode:
+                raise
+        except Exception as ex:
+            logger.critical("Critical Error: %s", str(ex), exc_info=True)
+            if debug_mode:
+                raise
+        else:
+            sys.exit(EXIT_SUCCESS)
+        sys.exit(EXIT_ERROR)
+
+
+if __name__ == "__main__":
+    main()

dvr_scan/app/about_window.py

@@ -0,0 +1,137 @@
+#
+#      DVR-Scan: Video Motion Event Detection & Extraction Tool
+#   --------------------------------------------------------------
+#       [  Site: https://www.dvr-scan.com/                 ]
+#       [  Repo: https://github.com/Breakthrough/DVR-Scan  ]
+#
+# Copyright (C) 2024 Brandon Castellano <http://www.bcastell.com>.
+# DVR-Scan is licensed under the BSD 2-Clause License; see the included
+# LICENSE file, or visit one of the above pages for details.
+#
+
+import importlib.resources as resources
+import tkinter as tk
+import tkinter.filedialog
+import tkinter.messagebox
+import tkinter.scrolledtext
+import tkinter.ttk as ttk
+import typing as ty
+import webbrowser
+
+import PIL
+import PIL.Image
+import PIL.ImageTk
+
+import dvr_scan
+from dvr_scan.platform import get_system_version_info
+
+TITLE = "About DVR-Scan"
+COPYRIGHT = (
+    f"DVR-Scan {dvr_scan.__version__}\n\nCopyright © Brandon Castellano.\nAll rights reserved."
+)
+
+
+class AboutWindow:
+    def __init__(self):
+        self._version_info: ty.Optional[str] = None
+        self._about_image: PIL.Image = None
+        self._about_image_tk: PIL.ImageTk.PhotoImage = None
+
+    def show(self, root: tk.Tk):
+        window = tk.Toplevel(master=root)
+        window.withdraw()
+        window.title(TITLE)
+        window.resizable(True, True)
+
+        app_logo = PIL.Image.open(resources.open_binary(dvr_scan, "dvr-scan-logo.png"))
+        self._about_image = app_logo.crop((8, 8, app_logo.width - 132, app_logo.height - 8))
+        self._about_image_tk = PIL.ImageTk.PhotoImage(self._about_image)
+        canvas = tk.Canvas(window, width=self._about_image.width, height=self._about_image.height)
+        canvas.grid()
+        canvas.create_image(0, 0, anchor=tk.NW, image=self._about_image_tk)
+
+        ttk.Separator(window, orient=tk.HORIZONTAL).grid(row=1, sticky="ew", padx=16.0)
+        ttk.Label(
+            window,
+            text=COPYRIGHT,
+        ).grid(row=2, sticky="nw", padx=24.0, pady=24.0)
+
+        # TODO: These should be buttons not labels.
+        website_link = ttk.Label(
+            window, text="www.dvr-scan.com", cursor="hand2", foreground="medium blue"
+        )
+        website_link.grid(row=2, sticky="ne", padx=24.0, pady=24.0)
+        website_link.bind("<Button-1>", lambda _: webbrowser.open_new_tab("www.dvr-scan.com"))
+
+        about_tabs = ttk.Notebook(window)
+        version_tab = ttk.Frame(about_tabs)
+        version_area = tkinter.scrolledtext.ScrolledText(
+            version_tab, wrap=tk.NONE, width=40, height=1
+        )
+        # TODO: See if we can add another button that will copy debug logs.
+        if not self._version_info:
+            self._version_info = get_system_version_info()
+        version_area.insert(tk.INSERT, self._version_info)
+        version_area.grid(sticky="nsew")
+        version_area.config(state="disabled")
+        version_tab.columnconfigure(0, weight=1)
+        version_tab.rowconfigure(0, weight=1)
+        tk.Button(
+            version_tab,
+            text="Copy to Clipboard",
+            command=lambda: root.clipboard_append(self._version_info),
+        ).grid(row=1, column=0)
+
+        license_tab = ttk.Frame(about_tabs)
+        scrollbar = tk.Scrollbar(license_tab, orient=tk.HORIZONTAL)
+        license_area = tkinter.scrolledtext.ScrolledText(
+            license_tab, wrap=tk.NONE, width=40, xscrollcommand=scrollbar.set, height=1
+        )
+        license_area.insert(tk.INSERT, dvr_scan.get_license_info())
+        license_area.grid(sticky="nsew")
+        scrollbar.config(command=license_area.xview)
+        scrollbar.grid(row=1, sticky="swe")
+        license_area.config(state="disabled")
+        license_tab.columnconfigure(0, weight=1)
+        license_tab.rowconfigure(0, weight=1)
+
+        # TODO: Add tab that has some useful links like submitting bug report, etc
+        about_tabs.add(version_tab, text="Version Info")
+        about_tabs.add(license_tab, text="License Info")
+
+        about_tabs.grid(
+            row=0, column=1, rowspan=4, padx=(0.0, 16.0), pady=(16.0, 16.0), sticky="nsew"
+        )
+        window.update()
+        if self._about_image is not None:
+            window.columnconfigure(0, minsize=self._about_image.width)
+            window.rowconfigure(0, minsize=self._about_image.height)
+        else:
+            window.columnconfigure(0, minsize=200)
+            window.rowconfigure(0, minsize=100)
+        # minsize includes padding
+        window.columnconfigure(1, weight=1, minsize=100)
+        window.rowconfigure(3, weight=1)
+
+        window.minsize(width=window.winfo_reqwidth(), height=window.winfo_reqheight())
+        # can we query widget height?
+
+        root.grab_release()
+
+        window.transient(root)
+        window.focus()
+        window.grab_set()
+
+        def dismiss():
+            window.grab_release()
+            window.destroy()
+            root.grab_set()
+            root.focus()
+
+        window.protocol("WM_DELETE_WINDOW", dismiss)
+        window.attributes("-topmost", True)
+        window.bind("<Escape>", lambda _: window.destroy())
+        window.bind("<Destroy>", lambda _: dismiss())
+
+        window.deiconify()
+        window.wait_window()