viso-sdk-python 1.1.21__tar.gz → 1.1.22__tar.gz

{viso_sdk_python-1.1.21 → viso_sdk_python-1.1.22}/CHANGELOG.md

@@ -1,6 +1,11 @@
 # Changelog
 
 <!--next-version-placeholder-->
+## v1.1.22
+### Fix
+- fix rolling queue issue and ROI manager issue
+- add test scripts
+
 ## v1.1.21
 ### Fix
 - redownload model issue

{viso_sdk_python-1.1.21 → viso_sdk_python-1.1.22}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: viso-sdk-python
-Version: 1.1.21
+Version: 1.1.22
 Summary: VisoSDK: A Python SDK for use in Viso containers
 Home-page: https://gitlab.com/TopKamera/03_edge/Base/viso-sdk-python-public.git
 Author: support@viso.ai

viso_sdk_python-1.1.22/tests/unit/test_log_id.py

@@ -0,0 +1,184 @@
+"""Unit tests for LogIDGenerator."""
+import re
+import threading
+
+import pytest
+
+from viso_sdk.logging.log_id import ErrorType, EventType, LogIDGenerator
+
+
+NODE_ID = "abcdef1234567890"
+SOURCE_IDX = 2
+
+
+@pytest.fixture
+def gen():
+    return LogIDGenerator(node_id=NODE_ID, source_idx=SOURCE_IDX)
+
+
+# ---------------------------------------------------------------------------
+# Session ID
+# ---------------------------------------------------------------------------
+
+class TestSessionId:
+    def test_format(self, gen):
+        sid = gen.generate_session_id()
+        # SES-<node_id[:8]>-<source_idx>-<8-char uuid>
+        assert re.fullmatch(r"SES-[a-z0-9]{8}-\d+-[a-f0-9\-]{8}", sid), sid
+
+    def test_node_id_truncated_to_8(self, gen):
+        sid = gen.generate_session_id()
+        parts = sid.split("-")
+        assert parts[1] == NODE_ID[:8]
+
+    def test_source_idx_embedded(self, gen):
+        sid = gen.generate_session_id()
+        assert f"-{SOURCE_IDX}-" in sid
+
+    def test_cached_after_first_call(self, gen):
+        sid1 = gen.generate_session_id()
+        sid2 = gen.generate_session_id()
+        assert sid1 == sid2
+
+    def test_get_session_id_none_before_generate(self, gen):
+        assert gen.get_session_id() is None
+
+    def test_get_session_id_after_generate(self, gen):
+        sid = gen.generate_session_id()
+        assert gen.get_session_id() == sid
+
+    def test_force_regenerates(self, gen):
+        sid1 = gen.generate_session_id()
+        sid2 = gen.generate_session_id(force=True)
+        assert sid1 != sid2
+
+    def test_force_updates_cached_value(self, gen):
+        gen.generate_session_id()
+        new_sid = gen.generate_session_id(force=True)
+        assert gen.get_session_id() == new_sid
+
+
+# ---------------------------------------------------------------------------
+# Error ID
+# ---------------------------------------------------------------------------
+
+class TestErrorId:
+    def test_format_default_type(self, gen):
+        eid = gen.generate_error_id()
+        assert re.fullmatch(r"ERR-GEN-[a-z0-9]{8}-\d+-\d+", eid), eid
+
+    def test_format_custom_type(self, gen):
+        eid = gen.generate_error_id(ErrorType.FRAME_CAPTURE)
+        assert eid.startswith("ERR-FRAME-")
+
+    def test_counter_increments(self, gen):
+        ids = [gen.generate_error_id() for _ in range(5)]
+        counters = [int(i.rsplit("-", 1)[-1]) for i in ids]
+        assert counters == list(range(1, 6))
+
+    def test_counter_independent_from_event_counter(self, gen):
+        gen.generate_event_id()
+        gen.generate_event_id()
+        eid = gen.generate_error_id()
+        assert eid.endswith("-1")
+
+    def test_thread_safety(self, gen):
+        results = []
+        lock = threading.Lock()
+
+        def worker():
+            eid = gen.generate_error_id()
+            with lock:
+                results.append(eid)
+
+        threads = [threading.Thread(target=worker) for _ in range(50)]
+        for t in threads:
+            t.start()
+        for t in threads:
+            t.join()
+
+        counters = sorted(int(i.rsplit("-", 1)[-1]) for i in results)
+        assert counters == list(range(1, 51)), "Duplicate or missing counter values"
+
+
+# ---------------------------------------------------------------------------
+# Event ID
+# ---------------------------------------------------------------------------
+
+class TestEventId:
+    def test_format_default_type(self, gen):
+        eid = gen.generate_event_id()
+        assert re.fullmatch(r"EVT-EVT-[a-z0-9]{8}-\d+-\d+", eid), eid
+
+    def test_format_custom_type(self, gen):
+        eid = gen.generate_event_id(EventType.START)
+        assert eid.startswith("EVT-START-")
+
+    def test_counter_increments(self, gen):
+        ids = [gen.generate_event_id() for _ in range(5)]
+        counters = [int(i.rsplit("-", 1)[-1]) for i in ids]
+        assert counters == list(range(1, 6))
+
+    def test_counter_independent_from_error_counter(self, gen):
+        gen.generate_error_id()
+        gen.generate_error_id()
+        evid = gen.generate_event_id()
+        assert evid.endswith("-1")
+
+    def test_thread_safety(self, gen):
+        results = []
+        lock = threading.Lock()
+
+        def worker():
+            evid = gen.generate_event_id()
+            with lock:
+                results.append(evid)
+
+        threads = [threading.Thread(target=worker) for _ in range(50)]
+        for t in threads:
+            t.start()
+        for t in threads:
+            t.join()
+
+        counters = sorted(int(i.rsplit("-", 1)[-1]) for i in results)
+        assert counters == list(range(1, 51)), "Duplicate or missing counter values"
+
+
+# ---------------------------------------------------------------------------
+# Message formatting
+# ---------------------------------------------------------------------------
+
+class TestFormatting:
+    def test_format_log_with_id(self):
+        msg = LogIDGenerator.format_log_with_id("hello", "ERR-GEN-abc-0-1")
+        assert msg == "[ERR-GEN-abc-0-1] hello"
+
+    def test_format_log_with_session_before_generate(self, gen):
+        assert gen.format_log_with_session("hello") == "hello"
+
+    def test_format_log_with_session_after_generate(self, gen):
+        sid = gen.generate_session_id()
+        msg = gen.format_log_with_session("hello")
+        assert msg == f"[{sid}] hello"
+
+    def test_format_log_with_session_updates_after_force(self, gen):
+        gen.generate_session_id()
+        new_sid = gen.generate_session_id(force=True)
+        msg = gen.format_log_with_session("hello")
+        assert msg == f"[{new_sid}] hello"
+
+
+# ---------------------------------------------------------------------------
+# Short node_id (< 8 chars)
+# ---------------------------------------------------------------------------
+
+class TestShortNodeId:
+    def test_short_node_id_does_not_raise(self):
+        gen = LogIDGenerator(node_id="abc", source_idx=0)
+        sid = gen.generate_session_id()
+        assert "abc" in sid
+
+    def test_error_id_with_short_node_id(self):
+        gen = LogIDGenerator(node_id="xyz", source_idx=1)
+        eid = gen.generate_error_id()
+        assert "xyz" in eid

viso_sdk_python-1.1.22/tests/unit/test_polygon_roi_manager.py

@@ -0,0 +1,314 @@
+"""Unit tests for PolygonROIManager."""
+from viso_sdk.roi.polygon_roi_manager import PolygonROIManager, RoiData
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+class MockDet:
+    """Detection-like item (no .info attribute)."""
+    def __init__(self, tlwh):
+        self.tlwh = tlwh
+
+
+class MockTrack:
+    """Track-like item (has .info attribute)."""
+    def __init__(self, tlwh, rect=None):
+        self.tlwh = tlwh
+        self.info = {'rect': rect if rect is not None else tlwh}
+
+
+def _make_roi(label, roi_id, include, points):
+    return {
+        RoiData.ROI_LABEL_KEY: label,
+        RoiData.ROI_ID_KEY: roi_id,
+        RoiData.INCLUDE_KEY: include,
+        RoiData.POINTS_KEY: points,
+    }
+
+
+# Unit square ROI: (0.2,0.2)→(0.8,0.8) in normalised coords
+SQUARE = [[0.2, 0.2], [0.8, 0.2], [0.8, 0.8], [0.2, 0.8]]
+# Inner exclusion zone: (0.4,0.4)→(0.6,0.6)
+INNER_EXCL = [[0.4, 0.4], [0.6, 0.4], [0.6, 0.6], [0.4, 0.6]]
+# Second non-overlapping ROI: (0.85,0.85)→(0.99,0.99)
+SQUARE2 = [[0.85, 0.85], [0.99, 0.85], [0.99, 0.99], [0.85, 0.99]]
+
+# Reference anchor = (0.5, 0.5) → ref point = centre of tlwh
+# tlwh = (x, y, w, h); centre = (x + w/2, y + h/2)
+INSIDE  = MockDet((0.45, 0.45, 0.10, 0.10))  # centre (0.50, 0.50) – inside SQUARE
+OUTSIDE = MockDet((0.00, 0.00, 0.10, 0.10))  # centre (0.05, 0.05) – outside SQUARE
+IN_EXCL = MockDet((0.45, 0.45, 0.06, 0.06))  # centre (0.48, 0.48) – in SQUARE, inside INNER_EXCL
+IN_SQ2  = MockDet((0.88, 0.88, 0.06, 0.06))  # centre (0.91, 0.91) – inside SQUARE2
+
+
+# ---------------------------------------------------------------------------
+# No ROI configured
+# ---------------------------------------------------------------------------
+
+class TestNoRoi:
+    def test_none_polygons_returns_input_unchanged(self):
+        """When no ROI is configured, all items pass through as-is."""
+        mgr = PolygonROIManager(polygons=None)
+        items = [INSIDE, OUTSIDE]
+        assert mgr.filter_in_roi(items) is items
+
+    def test_empty_detections_no_roi(self):
+        mgr = PolygonROIManager(polygons=None)
+        assert mgr.filter_in_roi([]) == []
+
+
+# ---------------------------------------------------------------------------
+# All ROIs have empty points (the bug case)
+# ---------------------------------------------------------------------------
+
+class TestAllEmptyPoints:
+    def test_no_roi_name_when_all_points_empty(self):
+        """Detections must NOT receive roi_id/roi_name when no polygon is drawn."""
+        polygons = [
+            _make_roi("roi1", "id1", True, []),
+            _make_roi("roi2", "id2", True, []),
+        ]
+        mgr = PolygonROIManager(polygons=polygons)
+        result = mgr.filter_in_roi([INSIDE, OUTSIDE])
+
+        assert len(result) == 2
+        for item in result:
+            assert not hasattr(item, 'roi_id'), "roi_id must not be set"
+            assert not hasattr(item, 'roi_name'), "roi_name must not be set"
+
+    def test_all_items_pass_through_when_all_points_empty(self):
+        """All items are returned when polygon is empty (pass-through)."""
+        polygons = [_make_roi("roi1", "id1", True, [])]
+        mgr = PolygonROIManager(polygons=polygons)
+        result = mgr.filter_in_roi([INSIDE, OUTSIDE])
+        assert len(result) == 2
+
+
+# ---------------------------------------------------------------------------
+# Single include polygon
+# ---------------------------------------------------------------------------
+
+class TestSingleIncludePolygon:
+    def setup_method(self):
+        self.mgr = PolygonROIManager(
+            polygons=[_make_roi("zone1", "abc123", True, SQUARE)]
+        )
+
+    def test_item_inside_gets_roi_info(self):
+        result = self.mgr.filter_in_roi([INSIDE])
+        assert len(result) == 1
+        assert result[0].roi_id == ["abc123"]
+        assert result[0].roi_name == ["zone1"]
+
+    def test_item_outside_is_filtered_out(self):
+        result = self.mgr.filter_in_roi([OUTSIDE])
+        assert result == []
+
+    def test_mixed_items(self):
+        result = self.mgr.filter_in_roi([INSIDE, OUTSIDE])
+        assert len(result) == 1
+        assert result[0].roi_id == ["abc123"]
+
+    def test_empty_detection_list(self):
+        assert self.mgr.filter_in_roi([]) == []
+
+
+# ---------------------------------------------------------------------------
+# Exclude polygon
+# ---------------------------------------------------------------------------
+
+class TestExcludePolygon:
+    def setup_method(self):
+        self.mgr = PolygonROIManager(polygons=[
+            _make_roi("zone1", "abc123", True,  SQUARE),
+            _make_roi("excl1", "excl",   False, INNER_EXCL),
+        ])
+
+    def test_item_inside_include_outside_exclude_passes(self):
+        """Point inside SQUARE but outside INNER_EXCL → kept."""
+        # centre (0.30, 0.30): inside SQUARE (0.2–0.8), outside INNER_EXCL (0.4–0.6)
+        item = MockDet((0.25, 0.25, 0.10, 0.10))
+        result = self.mgr.filter_in_roi([item])
+        assert len(result) == 1
+        assert result[0].roi_id == ["abc123"]
+
+    def test_item_inside_exclude_is_filtered(self):
+        """Point inside both SQUARE and INNER_EXCL → excluded."""
+        result = self.mgr.filter_in_roi([IN_EXCL])
+        assert result == []
+
+    def test_item_outside_both_is_filtered(self):
+        result = self.mgr.filter_in_roi([OUTSIDE])
+        assert result == []
+
+
+# ---------------------------------------------------------------------------
+# Multiple include polygons
+# ---------------------------------------------------------------------------
+
+class TestMultipleIncludePolygons:
+    def setup_method(self):
+        self.mgr = PolygonROIManager(polygons=[
+            _make_roi("zone1", "id1", True, SQUARE),
+            _make_roi("zone2", "id2", True, SQUARE2),
+        ])
+
+    def test_item_in_first_polygon_only(self):
+        result = self.mgr.filter_in_roi([INSIDE])
+        assert len(result) == 1
+        assert result[0].roi_id == ["id1"]
+        assert result[0].roi_name == ["zone1"]
+
+    def test_item_in_second_polygon_only(self):
+        result = self.mgr.filter_in_roi([IN_SQ2])
+        assert len(result) == 1
+        assert result[0].roi_id == ["id2"]
+        assert result[0].roi_name == ["zone2"]
+
+    def test_item_in_neither_polygon_filtered(self):
+        result = self.mgr.filter_in_roi([OUTSIDE])
+        assert result == []
+
+    def test_item_matched_to_both_polygons(self):
+        """A point inside an overlapping region of two included polygons gets both ids."""
+        # Create two overlapping ROIs so a single point is in both
+        overlap_sq1 = [[0.1, 0.1], [0.6, 0.1], [0.6, 0.6], [0.1, 0.6]]
+        overlap_sq2 = [[0.4, 0.4], [0.9, 0.4], [0.9, 0.9], [0.4, 0.9]]
+        mgr = PolygonROIManager(polygons=[
+            _make_roi("z1", "r1", True, overlap_sq1),
+            _make_roi("z2", "r2", True, overlap_sq2),
+        ])
+        # centre (0.5, 0.5) is in both
+        item = MockDet((0.45, 0.45, 0.10, 0.10))
+        result = mgr.filter_in_roi([item])
+        assert len(result) == 1
+        assert set(result[0].roi_id) == {"r1", "r2"}
+        assert set(result[0].roi_name) == {"z1", "z2"}
+
+
+# ---------------------------------------------------------------------------
+# Empty polygon acting as pass-through alongside real polygon
+# ---------------------------------------------------------------------------
+
+class TestEmptyPolygonWithRealPolygon:
+    def setup_method(self):
+        self.mgr = PolygonROIManager(polygons=[
+            _make_roi("zone1", "id1", True, SQUARE),
+            _make_roi("everywhere", "idE", True, []),
+        ])
+
+    def test_item_inside_real_polygon_gets_roi_info(self):
+        result = self.mgr.filter_in_roi([INSIDE])
+        assert len(result) == 1
+        assert result[0].roi_id == ["id1"]
+
+    def test_item_outside_real_polygon_passes_without_roi_info(self):
+        """Item not in any real polygon falls through to empty_polygon → no roi info."""
+        result = self.mgr.filter_in_roi([OUTSIDE])
+        assert len(result) == 1
+        assert not hasattr(result[0], 'roi_id')
+        assert not hasattr(result[0], 'roi_name')
+
+
+# ---------------------------------------------------------------------------
+# Track items (have .info attribute)
+# ---------------------------------------------------------------------------
+
+class TestTrackItems:
+    def setup_method(self):
+        self.mgr = PolygonROIManager(
+            polygons=[_make_roi("zone1", "abc123", True, SQUARE)]
+        )
+
+    def test_track_inside_gets_roi_info_in_info_dict(self):
+        track = MockTrack(tlwh=(0.45, 0.45, 0.10, 0.10))
+        result = self.mgr.filter_in_roi([track])
+        assert len(result) == 1
+        assert result[0].info['roi_id'] == ["abc123"]
+        assert result[0].info['roi_name'] == ["zone1"]
+
+    def test_track_outside_is_filtered(self):
+        track = MockTrack(tlwh=(0.0, 0.0, 0.1, 0.1))
+        result = self.mgr.filter_in_roi([track])
+        assert result == []
+
+    def test_track_uses_rect_from_info_when_present(self):
+        """Track uses info['rect'] for the bounding box if available."""
+        track = MockTrack(
+            tlwh=(0.0, 0.0, 0.1, 0.1),          # would be outside
+            rect=(0.45, 0.45, 0.10, 0.10),       # centre (0.5, 0.5) – inside
+        )
+        result = self.mgr.filter_in_roi([track])
+        assert len(result) == 1
+
+
+# ---------------------------------------------------------------------------
+# Pixel coordinates (width > 1.0 triggers normalisation)
+# ---------------------------------------------------------------------------
+
+class TestPixelCoordinates:
+    def test_pixel_coords_normalised_correctly(self):
+        """Items with pixel-space tlwh are divided by frame size before ROI check."""
+        frame_sz = [100, 100]
+        # SQUARE covers normalised (0.2,0.2)→(0.8,0.8)
+        mgr = PolygonROIManager(
+            polygons=[_make_roi("zone1", "id1", True, SQUARE)],
+            frame_sz=frame_sz,
+        )
+        # Pixel rect (45, 45, 10, 10) → centre (50, 50) → normalised (0.5, 0.5) = inside
+        item_in  = MockDet((45.0, 45.0, 10.0, 10.0))
+        # Pixel rect (0, 0, 10, 10) → centre (5, 5) → normalised (0.05, 0.05) = outside
+        item_out = MockDet((0.0, 0.0, 10.0, 10.0))
+
+        result = mgr.filter_in_roi([item_in, item_out], frame_sz=frame_sz)
+        assert len(result) == 1
+        assert result[0].roi_id == ["id1"]
+
+
+# ---------------------------------------------------------------------------
+# Custom anchor point
+# ---------------------------------------------------------------------------
+
+class TestCustomAnchorPoint:
+    def setup_method(self):
+        self.mgr = PolygonROIManager(
+            polygons=[_make_roi("zone1", "id1", True, SQUARE)]
+        )
+
+    def test_top_left_anchor(self):
+        """With anchor (0, 0) the top-left corner is used as the reference point."""
+        # tlwh (0.25, 0.25, 0.1, 0.1) → top-left = (0.25, 0.25) → inside SQUARE
+        item = MockDet((0.25, 0.25, 0.10, 0.10))
+        result = self.mgr.filter_in_roi([item], anchor_pt=(0.0, 0.0))
+        assert len(result) == 1
+
+    def test_bottom_right_anchor(self):
+        """With anchor (1, 1) the bottom-right corner drives the check."""
+        # tlwh (0.7, 0.7, 0.15, 0.15) → bottom-right = (0.85, 0.85) → outside SQUARE
+        item = MockDet((0.7, 0.7, 0.15, 0.15))
+        result = self.mgr.filter_in_roi([item], anchor_pt=(1.0, 1.0))
+        assert result == []
+
+    def test_bottom_right_anchor_inside(self):
+        # tlwh (0.1, 0.1, 0.5, 0.5) → bottom-right = (0.6, 0.6) → inside SQUARE
+        item = MockDet((0.1, 0.1, 0.50, 0.50))
+        result = self.mgr.filter_in_roi([item], anchor_pt=(1.0, 1.0))
+        assert len(result) == 1
+
+
+# ---------------------------------------------------------------------------
+# Original item not mutated
+# ---------------------------------------------------------------------------
+
+class TestImmutability:
+    def test_original_item_not_mutated(self):
+        """filter_in_roi must not modify the original item object."""
+        mgr = PolygonROIManager(
+            polygons=[_make_roi("zone1", "id1", True, SQUARE)]
+        )
+        item = MockDet((0.45, 0.45, 0.10, 0.10))
+        mgr.filter_in_roi([item])
+        assert not hasattr(item, 'roi_id')
+        assert not hasattr(item, 'roi_name')