ezmsg-baseproc 1.0__tar.gz → 1.0.2__tar.gz

{ezmsg_baseproc-1.0 → ezmsg_baseproc-1.0.2}/.github/workflows/docs.yml

@@ -4,12 +4,12 @@ on:
   push:
     branches:
       - main
-    tags:
-      - 'v*'
   pull_request:
     branches:
       - main
       - dev
+  release:
+    types: [published]
   workflow_dispatch:
 
 permissions:
@@ -53,8 +53,8 @@ jobs:
           path: 'docs/build/html'
 
   deploy:
-    # Only deploy on push to main or release tags
-    if: github.event_name == 'push' && (github.ref == 'refs/heads/main' || startsWith(github.ref, 'refs/tags/v'))
+    # Only deploy when a release is published
+    if: github.event_name == 'release'
     environment:
       name: github-pages
       url: ${{ steps.deployment.outputs.page_url }}

{ezmsg_baseproc-1.0 → ezmsg_baseproc-1.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ezmsg-baseproc
-Version: 1.0
+Version: 1.0.2
 Summary: Base processor classes and protocols for ezmsg signal processing pipelines
 Author-email: Griffin Milsap <griffin.milsap@gmail.com>, Preston Peranich <pperanich@gmail.com>, Chadwick Boulay <chadwick.boulay@gmail.com>, Kyle McGraw <kmcgraw@blackrockneuro.com>
 License-Expression: MIT

{ezmsg_baseproc-1.0 → ezmsg_baseproc-1.0.2}/src/ezmsg/baseproc/__version__.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '1.0'
-__version_tuple__ = version_tuple = (1, 0)
+__version__ = version = '1.0.2'
+__version_tuple__ = version_tuple = (1, 0, 2)
 
 __commit_id__ = commit_id = None

{ezmsg_baseproc-1.0 → ezmsg_baseproc-1.0.2}/src/ezmsg/baseproc/util/profile.py

@@ -31,20 +31,29 @@ def _setup_logger(append: bool = False) -> logging.Logger:
     write_header = True
     if logpath.exists() and logpath.is_file():
         if append:
-            with open(logpath) as f:
-                first_line = f.readline().rstrip()
-            if first_line == HEADER:
+            try:
+                with open(logpath) as f:
+                    first_line = f.readline().rstrip()
+                if first_line == HEADER:
+                    write_header = False
+                else:
+                    # Remove the file if appending, but headers do not match
+                    ezmsg_logger = logging.getLogger("ezmsg")
+                    ezmsg_logger.warning(
+                        "Profiling header mismatch: please make sure to use the same version of "
+                        "ezmsg for all processes."
+                    )
+                    logpath.unlink()
+            except (PermissionError, OSError):
+                # On Windows, file may be locked by another process - just append
                 write_header = False
-            else:
-                # Remove the file if appending, but headers do not match
-                ezmsg_logger = logging.getLogger("ezmsg")
-                ezmsg_logger.warning(
-                    "Profiling header mismatch: please make sure to use the same version of ezmsg for all processes."
-                )
-                logpath.unlink()
         else:
             # Remove the file if not appending
-            logpath.unlink()
+            try:
+                logpath.unlink()
+            except (PermissionError, OSError):
+                # On Windows, file may be locked by another process - continue anyway
+                pass
 
     # Create a logger with the name "ezprofile"
     _logger = logging.getLogger("ezprofile")

ezmsg_baseproc-1.0.2/tests/test_profile.py

@@ -0,0 +1,189 @@
+import logging
+import os
+from datetime import datetime
+from pathlib import Path
+from unittest.mock import patch
+
+import pytest
+
+from ezmsg.baseproc.util.profile import (
+    HEADER,
+    _setup_logger,
+    get_logger_path,
+    profile_method,
+    profile_subpub,
+)
+
+
+def test_logger_creation():
+    """Test that the ezprofile logger is created when importing from ezmsg.baseproc.util.profile."""
+    logger_name = "ezprofile"
+    assert logger_name in logging.Logger.manager.loggerDict
+    logger = logging.getLogger(logger_name)
+    assert logger.level == logging.INFO
+    assert len(logger.handlers) == 1
+    handler = logger.handlers[0]
+    assert isinstance(handler, logging.FileHandler)
+    assert handler.level == logging.DEBUG
+    assert Path(handler.baseFilename) == get_logger_path()
+
+    # Remove and close all handlers
+    logger.removeHandler(handler)
+    handler.close()
+
+
+@pytest.fixture
+def mock_env():
+    """Fixture to mock environment variables."""
+    with patch.dict(os.environ, {"EZMSG_PROFILE": "test_profiler.log", "EZMSG_LOGLEVEL": "DEBUG"}):
+        yield
+
+
+@pytest.fixture
+def mock_logger_path(mock_env):
+    """Fixture to mock the logger path."""
+    logpath = get_logger_path()
+    yield logpath
+
+
+def test_logger_not_append(mock_logger_path):
+    """Test that the logger creates a new file if append==False."""
+    some_text = "Some,Previous,Logger,Text"
+    correct_header = HEADER
+
+    # Create a file with some text
+    test_logpath = mock_logger_path
+    with open(test_logpath, "w") as f:
+        f.truncate(0)
+        f.write(some_text + "\n")
+
+    logger = _setup_logger(append=False)
+    assert mock_logger_path.exists() and mock_logger_path.is_file()
+    assert logger.name == "ezprofile"
+    assert logger.level == logging.DEBUG
+    assert len(logger.handlers) == 1
+    handler = logger.handlers[0]
+    assert isinstance(handler, logging.FileHandler)
+    assert handler.level == logging.DEBUG
+    assert Path(handler.baseFilename) == test_logpath
+
+    with open(mock_logger_path, "r") as f:
+        first_line = f.readline().strip()
+    assert first_line == correct_header
+
+    # Clean up the logger file handler
+    logger.removeHandler(handler)
+    handler.close()
+
+
+def test_logger_append_header_mismatch(mock_logger_path):
+    """Test that the logger deletes the file if the header mismatches when append=True."""
+    incorrect_header = "Incorrect,Header,Format"
+    correct_header = HEADER
+
+    # Create a file with an incorrect header
+    test_logpath = mock_logger_path
+    with open(test_logpath, "w") as f:
+        f.truncate(0)
+        f.write(incorrect_header + "\n")
+
+    logger = _setup_logger(append=True)
+
+    # Assert that the file was deleted and recreated
+    assert test_logpath.exists()
+    with open(test_logpath, "r") as f:
+        first_line = f.readline().strip()
+    assert first_line == correct_header
+
+    # Clean up the logger handlers
+    handlers = logger.handlers
+    for handler in handlers:
+        logger.removeHandler(handler)
+        handler.close()
+
+
+def test_logger_append_header_match(mock_logger_path):
+    """Test that the logger correctly appends to the logfile if append=True and the header is correct."""
+    correct_header = HEADER
+    next_line = "Some,New,Logger,Text"
+
+    # Create a file with the correct header
+    test_logpath = mock_logger_path
+    with open(test_logpath, "w") as f:
+        f.truncate(0)
+        f.write(correct_header + "\n")
+        f.write(next_line + "\n")
+
+    logger = _setup_logger(append=True)
+    logger.debug("Some,Added,Logger,Text")
+
+    # Assert that the file was appended to
+    assert test_logpath.exists()
+    with open(test_logpath, "r") as f:
+        first_line = f.readline().strip()
+        second_line = f.readline().strip()
+        third_line = f.readline().strip()
+    assert first_line == correct_header
+    assert second_line == next_line
+    assert "Some,Added,Logger,Text" in third_line
+
+    # Clean up the logger handlers
+    handlers = logger.handlers
+    for handler in handlers:
+        if isinstance(handler, logging.FileHandler):
+            logger.removeHandler(handler)
+            handler.close()
+
+
+def test_profile_method_decorator():
+    """Test the profile_method decorator."""
+
+    class DummyClass:
+        address = "dummy_address"
+
+        @profile_method(trace_oldest=True)
+        def sample_method(self, x, y):
+            return x + y
+
+    instance = DummyClass()
+
+    with patch("ezmsg.baseproc.util.profile.logger") as mock_logger:
+        result = instance.sample_method(2, 3)
+        assert result == 5
+
+        # Assert the logger was called
+        mock_logger.debug.assert_called()
+
+
+@pytest.mark.asyncio
+async def test_profile_subpub_decorator(mock_logger_path):
+    """Test the profile_subpub decorator."""
+    test_logpath = mock_logger_path
+    _setup_logger()
+
+    class DummyUnit:
+        address = "dummy_address"
+
+        @profile_subpub(trace_oldest=True)
+        async def sample_subpub(self, msg):
+            yield "stream", msg
+
+    unit = DummyUnit()
+
+    async for stream, obj in unit.sample_subpub("message"):
+        # Assert the generator yields correctly
+        assert stream == "stream"
+        assert obj == "message"
+
+    # Assert the logger was called and printed in the correct format
+    with open(test_logpath, "r") as f:
+        f.readline()
+        second_line = f.readline().strip()
+    log_text = second_line.split(",")
+    assert len(log_text) == 6
+    datetime.strptime(log_text[0], "%Y-%m-%dT%H:%M:%S%z")  # Will throw if format is incorrect
+    assert log_text[1].endswith("test_profile.DummyUnit")
+    assert log_text[2] == "dummy_address"
+    assert log_text[3] == "None"
+    float(log_text[4])  # Will throw if not float
+    float(log_text[5])  # Will throw if not float