pyzm 2.3.4__tar.gz → 2.3.6__tar.gz

{pyzm-2.3.4/pyzm.egg-info → pyzm-2.3.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyzm
-Version: 2.3.4
+Version: 2.3.6
 Summary: ZoneMinder API, Logger and other base utilities for python programmers
 Home-page: https://github.com/pliablepixels/pyzm
 Author: Pliable Pixels

{pyzm-2.3.4 → pyzm-2.3.6}/pyzm/__init__.py

@@ -3,7 +3,7 @@
 v2: Typed configuration, clean APIs, proper result objects.
 """
 
-__version__ = "2.3.4"
+__version__ = "2.3.6"
 VERSION = __version__
 
 from pyzm.client import ZMClient

{pyzm-2.3.4 → pyzm-2.3.6}/pyzm/log.py

@@ -22,7 +22,12 @@ import sys as _sys
 import time
 from typing import Any
 
-__all__ = ["ZMLogAdapter", "setup_zm_logging"]
+__all__ = [
+    "ZMLogAdapter",
+    "setup_zm_logging",
+    "get_logpath",
+    "get_log_file",
+]
 
 # ZM level mapping: DBG=1, INF=0, WAR=-1, ERR=-2, FAT=-3
 _ZM_LEVELS: dict[str, int] = {"DBG": 1, "INF": 0, "WAR": -1, "ERR": -2, "FAT": -3}
@@ -467,11 +472,6 @@ def setup_zm_logging(
         "dump_console": os.environ.get("PYZM_DUMPCONSOLE"),
     }
 
-    # Apply defaults for None values
-    for key, val in defaults.items():
-        if config.get(key) is None and val is not None:
-            config[key] = val
-
     # Round 1 overrides (before DB read)
     for key in override:
         if override[key]:
@@ -648,3 +648,38 @@ def setup_zm_logging(
         pass
 
     return adapter
+
+
+def get_logpath(conf_path: str = "/etc/zm") -> str:
+    """Return the resolved ZM log directory without initializing logging.
+
+    Precedence (matches setup_zm_logging):
+        PYZM_LOGPATH env var
+        > ZM_PATH_LOGS in /etc/zm/zm.conf and conf.d/*.conf
+        > /var/log/zm (default)
+
+    Safe to call from any process; does not touch the DB, open handlers,
+    or register signal handlers.
+    """
+    env = os.environ.get("PYZM_LOGPATH")
+    if env:
+        return env
+    conf_val = _read_zm_conf_full(conf_path).get("logpath")
+    if conf_val:
+        return conf_val
+    return "/var/log/zm"
+
+
+def get_log_file() -> str | None:
+    """Return the file path pyzm is currently writing logs to, or None.
+
+    Returns None when file logging is disabled (``ZM_LOG_LEVEL_FILE``
+    set to off) or when :func:`setup_zm_logging` has not been called.
+    Reflects live state -- honors ``ZM_LOG_DEBUG_FILE`` overrides and
+    any post-SIGHUP rotation, since it reads ``baseFilename`` off the
+    actual ``WatchedFileHandler``.
+    """
+    for h in logging.getLogger("pyzm").handlers:
+        if isinstance(h, logging.handlers.WatchedFileHandler):
+            return h.baseFilename
+    return None

{pyzm-2.3.4 → pyzm-2.3.6}/pyzm/models/config.py

@@ -447,7 +447,7 @@ class StreamConfig(BaseModel):
     save_frames: bool = False
     save_frames_dir: str = "/tmp"
     delete_after_analyze: bool = False
-    convert_snapshot_to_fid: bool = True
+    convert_snapshot_to_fid: bool = False
 
     @classmethod
     def from_dict(cls, d: dict[str, Any]) -> "StreamConfig":

{pyzm-2.3.4 → pyzm-2.3.6/pyzm.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyzm
-Version: 2.3.4
+Version: 2.3.6
 Summary: ZoneMinder API, Logger and other base utilities for python programmers
 Home-page: https://github.com/pliablepixels/pyzm
 Author: Pliable Pixels

{pyzm-2.3.4 → pyzm-2.3.6}/tests/test_config_variants.py

@@ -661,7 +661,7 @@ class TestStreamConfigVariants:
         sc = StreamConfig.from_dict({})
         assert sc.resize is None
         assert sc.frame_set == ["snapshot", "alarm", "1"]
-        assert sc.convert_snapshot_to_fid is True
+        assert sc.convert_snapshot_to_fid is False
         assert sc.save_frames is False
 
     def test_download_bool_string(self):

pyzm-2.3.6/tests/test_face_dlib_lock.py

@@ -0,0 +1,44 @@
+import unittest
+from unittest.mock import MagicMock, patch
+
+import numpy as np
+from pyzm.models.config import ModelConfig, ModelFramework, ModelType
+
+
+class TestFaceDlibLockRelease(unittest.TestCase):
+    """H4: Lock must be released even if face_recognition raises."""
+
+    def test_lock_released_on_exception(self):
+        # Inject mock modules for the lazy imports inside detect().
+        # Use patch.dict so cleanup restores sys.modules and the mocks
+        # don't leak into other tests that genuinely need cv2.
+        mock_cv2 = MagicMock()
+        mock_fr = MagicMock()
+        mock_imutils = MagicMock()
+
+        with patch.dict("sys.modules", {
+            "cv2": mock_cv2,
+            "imutils": mock_imutils,
+            "face_recognition": mock_fr,
+        }):
+            from pyzm.ml.backends.face_dlib import FaceDlibBackend
+
+            config = ModelConfig(
+                type=ModelType.FACE,
+                framework=ModelFramework.FACE_DLIB,
+                known_faces_dir="/tmp/known",
+            )
+            backend = FaceDlibBackend(config)
+            backend._knn = MagicMock()  # pretend loaded
+            backend._auto_lock = True
+            backend.acquire_lock = MagicMock()
+            backend.release_lock = MagicMock()
+
+            mock_fr.face_locations.side_effect = RuntimeError("GPU OOM")
+
+            dummy = np.zeros((100, 100, 3), dtype=np.uint8)
+            with self.assertRaises(RuntimeError):
+                backend.detect(dummy)
+
+            backend.acquire_lock.assert_called_once()
+            backend.release_lock.assert_called_once()

{pyzm-2.3.4 → pyzm-2.3.6}/tests/test_log.py

@@ -14,6 +14,7 @@ from pyzm.log import (
     _read_zm_conf_full, _zm_config_to_handler_level, _ZM_OFF,
     _ZMDBHandler, _ZMFileFormatter, _ZMSyslogFormatter,
     ZMLogAdapter, setup_zm_logging,
+    get_logpath, get_log_file,
 )
 
 
@@ -668,6 +669,73 @@ class TestSetupZmLogging:
         assert adapter._config["log_debug_target"] == "zmc_m1"  # DB value kept (no override)
         adapter.close()
 
+    @patch("pyzm.log._read_zm_db_log_config", return_value={})
+    @patch("pyzm.log._read_zm_conf_full", return_value={
+        "dbuser": "u", "dbpassword": "p", "dbhost": "h",
+        "dbname": "zm", "webuser": "zmuser", "webgroup": "zmgroup",
+        "logpath": "/var/log/zoneminder",
+    })
+    @patch("pyzm.log._signal.signal")
+    def test_conf_logpath_honored(self, mock_sig, mock_conf, mock_db, monkeypatch):
+        """ZM_PATH_LOGS from zm.conf must flow through when no env/override is set.
+
+        Regression test for #45 -- the first defaults loop used to populate
+        config['logpath'] with '/var/log/zm' before the conf was read, causing
+        the conf value to be silently dropped.
+        """
+        monkeypatch.delenv("PYZM_LOGPATH", raising=False)
+        monkeypatch.delenv("PYZM_WEBUSER", raising=False)
+        monkeypatch.delenv("PYZM_WEBGROUP", raising=False)
+        adapter = setup_zm_logging(name="test_conf_logpath", override={
+            "log_level_file": _ZM_OFF,
+            "log_level_db": _ZM_OFF,
+            "log_level_syslog": _ZM_OFF,
+        })
+        assert adapter._config["logpath"] == "/var/log/zoneminder"
+        assert adapter._config["webuser"] == "zmuser"
+        assert adapter._config["webgroup"] == "zmgroup"
+        adapter.close()
+
+    @patch("pyzm.log._read_zm_db_log_config", return_value={})
+    @patch("pyzm.log._read_zm_conf_full", return_value={
+        "dbuser": "u", "dbpassword": "p", "dbhost": "h",
+        "dbname": "zm", "webuser": "zmuser", "webgroup": "zmgroup",
+        "logpath": "/var/log/zoneminder",
+    })
+    @patch("pyzm.log._signal.signal")
+    def test_env_overrides_conf_logpath(self, mock_sig, mock_conf, mock_db, monkeypatch):
+        """PYZM_LOGPATH env var still wins over the conf-file value."""
+        monkeypatch.setenv("PYZM_LOGPATH", "/env/logs")
+        adapter = setup_zm_logging(name="test_env_logpath", override={
+            "log_level_file": _ZM_OFF,
+            "log_level_db": _ZM_OFF,
+            "log_level_syslog": _ZM_OFF,
+        })
+        assert adapter._config["logpath"] == "/env/logs"
+        adapter.close()
+
+    @patch("pyzm.log._read_zm_db_log_config", return_value={})
+    @patch("pyzm.log._read_zm_conf_full", return_value={
+        "dbuser": "u", "dbpassword": "p", "dbhost": "h",
+        "dbname": "zm", "webuser": None, "webgroup": None,
+        "logpath": None,
+    })
+    @patch("pyzm.log._signal.signal")
+    def test_final_defaults_when_no_source(self, mock_sig, mock_conf, mock_db, monkeypatch):
+        """Hard-coded defaults apply only when env, conf, and override are all empty."""
+        monkeypatch.delenv("PYZM_LOGPATH", raising=False)
+        monkeypatch.delenv("PYZM_WEBUSER", raising=False)
+        monkeypatch.delenv("PYZM_WEBGROUP", raising=False)
+        adapter = setup_zm_logging(name="test_default_logpath", override={
+            "log_level_file": _ZM_OFF,
+            "log_level_db": _ZM_OFF,
+            "log_level_syslog": _ZM_OFF,
+        })
+        assert adapter._config["logpath"] == "/var/log/zm"
+        assert adapter._config["webuser"] == "www-data"
+        assert adapter._config["webgroup"] == "www-data"
+        adapter.close()
+
     @patch("pyzm.log._read_zm_db_log_config", return_value={})
     @patch("pyzm.log._read_zm_conf_full", return_value={
         "dbuser": "u", "dbpassword": "p", "dbhost": "h",
@@ -933,3 +1001,122 @@ class TestFileFormatAllLevels:
         for lvl in range(1, 10):
             result = self._format(logging.DEBUG, zm_debug_level=lvl)
             assert f"].DB{lvl} [" in result
+
+
+# ===================================================================
+# TestGetLogpath
+# ===================================================================
+
+class TestGetLogpath:
+    """Tests for the public get_logpath() helper (issue #46)."""
+
+    def test_env_var_wins(self, tmp_path, monkeypatch):
+        """PYZM_LOGPATH beats conf-file value."""
+        (tmp_path / "zm.conf").write_text("ZM_PATH_LOGS=/conf/path\n")
+        monkeypatch.setenv("PYZM_LOGPATH", "/env/path")
+        assert get_logpath(str(tmp_path)) == "/env/path"
+
+    def test_conf_file_wins_over_default(self, tmp_path, monkeypatch):
+        """ZM_PATH_LOGS in zm.conf is used when env is unset."""
+        (tmp_path / "zm.conf").write_text("ZM_PATH_LOGS=/conf/path\n")
+        monkeypatch.delenv("PYZM_LOGPATH", raising=False)
+        assert get_logpath(str(tmp_path)) == "/conf/path"
+
+    def test_default_when_nothing_set(self, tmp_path, monkeypatch):
+        """Falls back to /var/log/zm when env and conf are silent."""
+        (tmp_path / "zm.conf").write_text("")
+        monkeypatch.delenv("PYZM_LOGPATH", raising=False)
+        assert get_logpath(str(tmp_path)) == "/var/log/zm"
+
+    def test_does_not_require_setup(self, tmp_path, monkeypatch):
+        """get_logpath() works standalone -- no setup_zm_logging needed."""
+        (tmp_path / "zm.conf").write_text("ZM_PATH_LOGS=/standalone/path\n")
+        monkeypatch.delenv("PYZM_LOGPATH", raising=False)
+        # Wipe any pyzm logger handlers to prove we don't peek at them
+        logging.getLogger("pyzm").handlers.clear()
+        assert get_logpath(str(tmp_path)) == "/standalone/path"
+
+
+# ===================================================================
+# TestGetLogFile
+# ===================================================================
+
+class TestGetLogFile:
+    """Tests for the public get_log_file() helper (issue #46)."""
+
+    def setup_method(self):
+        # Each test starts from a clean pyzm logger
+        logging.getLogger("pyzm").handlers.clear()
+
+    def teardown_method(self):
+        logging.getLogger("pyzm").handlers.clear()
+
+    def test_returns_none_when_no_handler(self):
+        """Before setup_zm_logging -- no file handler attached -- returns None."""
+        assert get_log_file() is None
+
+    @patch("pyzm.log._read_zm_db_log_config", return_value={})
+    @patch("pyzm.log._read_zm_conf_full", return_value={
+        "dbuser": "u", "dbpassword": "p", "dbhost": "h",
+        "dbname": "zm", "webuser": "www", "webgroup": "www",
+        "logpath": None,  # forces final-default fallback
+    })
+    @patch("pyzm.log._signal.signal")
+    def test_returns_path_after_setup(self, mock_sig, mock_conf, mock_db, tmp_path):
+        """Returns the WatchedFileHandler's open file path after setup."""
+        adapter = setup_zm_logging(name="zmesdetect_m1", override={
+            "logpath": str(tmp_path),
+            "log_level_file": 0,
+            "log_level_db": _ZM_OFF,
+            "log_level_syslog": _ZM_OFF,
+        })
+        try:
+            assert get_log_file() == str(tmp_path / "zmesdetect_m1.log")
+        finally:
+            adapter.close()
+
+    @patch("pyzm.log._read_zm_db_log_config", return_value={})
+    @patch("pyzm.log._read_zm_conf_full", return_value={
+        "dbuser": "u", "dbpassword": "p", "dbhost": "h",
+        "dbname": "zm", "webuser": "www", "webgroup": "www",
+        "logpath": "/tmp",
+    })
+    @patch("pyzm.log._signal.signal")
+    def test_returns_none_when_file_logging_disabled(
+        self, mock_sig, mock_conf, mock_db,
+    ):
+        """File handler isn't attached when log_level_file == _ZM_OFF."""
+        adapter = setup_zm_logging(name="zm_nofile", override={
+            "log_level_file": _ZM_OFF,
+            "log_level_db": _ZM_OFF,
+            "log_level_syslog": _ZM_OFF,
+        })
+        try:
+            assert get_log_file() is None
+        finally:
+            adapter.close()
+
+    @patch("pyzm.log._read_zm_db_log_config", return_value={})
+    @patch("pyzm.log._read_zm_conf_full", return_value={
+        "dbuser": "u", "dbpassword": "p", "dbhost": "h",
+        "dbname": "zm", "webuser": "www", "webgroup": "www",
+        "logpath": "/should/be/ignored",
+    })
+    @patch("pyzm.log._signal.signal")
+    def test_reflects_debug_file_override(
+        self, mock_sig, mock_conf, mock_db, tmp_path,
+    ):
+        """ZM_LOG_DEBUG_FILE override is visible in get_log_file()."""
+        debug_file = tmp_path / "custom-debug.log"
+        adapter = setup_zm_logging(name="zm_dbg", override={
+            "log_debug": 1,
+            "log_level_debug": 5,
+            "log_debug_file": str(debug_file),
+            "log_level_file": 0,
+            "log_level_db": _ZM_OFF,
+            "log_level_syslog": _ZM_OFF,
+        })
+        try:
+            assert get_log_file() == str(debug_file)
+        finally:
+            adapter.close()

{pyzm-2.3.4 → pyzm-2.3.6}/tests/test_models/test_config.py

@@ -604,7 +604,7 @@ class TestStreamConfig:
         assert sc.sleep_between_attempts == 3
         assert sc.save_frames is False
         assert sc.save_frames_dir == "/tmp"
-        assert sc.convert_snapshot_to_fid is True
+        assert sc.convert_snapshot_to_fid is False
 
     def test_all_fields_override(self):
         sc = StreamConfig(

pyzm-2.3.4/tests/test_face_dlib_lock.py

@@ -1,42 +0,0 @@
-import sys
-import unittest
-from unittest.mock import MagicMock
-
-import numpy as np
-from pyzm.models.config import ModelConfig, ModelFramework, ModelType
-
-
-class TestFaceDlibLockRelease(unittest.TestCase):
-    """H4: Lock must be released even if face_recognition raises."""
-
-    def test_lock_released_on_exception(self):
-        # Inject mock modules for the lazy imports inside detect()
-        mock_cv2 = MagicMock()
-        mock_fr = MagicMock()
-        mock_imutils = MagicMock()
-
-        sys.modules.setdefault("cv2", mock_cv2)
-        sys.modules.setdefault("imutils", mock_imutils)
-        sys.modules.setdefault("face_recognition", mock_fr)
-
-        from pyzm.ml.backends.face_dlib import FaceDlibBackend
-
-        config = ModelConfig(
-            type=ModelType.FACE,
-            framework=ModelFramework.FACE_DLIB,
-            known_faces_dir="/tmp/known",
-        )
-        backend = FaceDlibBackend(config)
-        backend._knn = MagicMock()  # pretend loaded
-        backend._auto_lock = True
-        backend.acquire_lock = MagicMock()
-        backend.release_lock = MagicMock()
-
-        mock_fr.face_locations.side_effect = RuntimeError("GPU OOM")
-
-        dummy = np.zeros((100, 100, 3), dtype=np.uint8)
-        with self.assertRaises(RuntimeError):
-            backend.detect(dummy)
-
-        backend.acquire_lock.assert_called_once()
-        backend.release_lock.assert_called_once()