unique_toolkit 1.8.1__py3-none-any.whl → 1.23.0__py3-none-any.whl

unique_toolkit/agentic/tools/a2a/postprocessing/test/test_display.py

@@ -1,391 +0,0 @@
-import re
-
-import pytest
-
-from unique_toolkit.agentic.tools.a2a.postprocessing._display import (
-    _build_sub_agent_answer_display,
-    _DetailsResponseDisplayHandler,
-    _remove_sub_agent_answer_from_text,
-)
-from unique_toolkit.agentic.tools.a2a.postprocessing.config import (
-    SubAgentResponseDisplayMode,
-)
-
-
-class TestDetailsResponseDisplayHandler:
-    """Test suite for DetailsResponseDisplayHandler class."""
-
-    @pytest.fixture
-    def open_handler(self) -> _DetailsResponseDisplayHandler:
-        """Create a handler with open mode."""
-        return _DetailsResponseDisplayHandler(mode="open")
-
-    @pytest.fixture
-    def closed_handler(self) -> _DetailsResponseDisplayHandler:
-        """Create a handler with closed mode."""
-        return _DetailsResponseDisplayHandler(mode="closed")
-
-    @pytest.fixture
-    def sample_data(self):
-        """Sample data for testing."""
-        return {
-            "display_name": "Test Assistant",
-            "assistant_id": "test_assistant_123",
-            "answer": "This is a test answer with multiple lines.\nSecond line here.",
-        }
-
-    def test_build_response_display_open_mode(self, open_handler, sample_data):
-        """Test building response display in open mode."""
-        result = open_handler.build_response_display(
-            display_name=sample_data["display_name"],
-            assistant_id=sample_data["assistant_id"],
-            answer=sample_data["answer"],
-        )
-
-        assert "<details open>" in result
-        assert (
-            f'<div style="display: none;">{sample_data["assistant_id"]}</div>' in result
-        )
-        assert f"<summary>{sample_data['display_name']}</summary>" in result
-        assert sample_data["answer"] in result
-        assert "</details>" in result
-
-    def test_build_response_display_closed_mode(self, closed_handler, sample_data):
-        """Test building response display in closed mode."""
-        result = closed_handler.build_response_display(
-            display_name=sample_data["display_name"],
-            assistant_id=sample_data["assistant_id"],
-            answer=sample_data["answer"],
-        )
-
-        assert "<details>" in result
-        assert "<details open>" not in result
-        assert (
-            f'<div style="display: none;">{sample_data["assistant_id"]}</div>' in result
-        )
-        assert f"<summary>{sample_data['display_name']}</summary>" in result
-        assert sample_data["answer"] in result
-        assert "</details>" in result
-
-    def test_build_response_display_with_special_characters(self, open_handler):
-        """Test building response display with special characters in content."""
-        result = open_handler.build_response_display(
-            display_name="Test & Co.",
-            assistant_id="test<>123",
-            answer="Answer with <tags> & symbols",
-        )
-
-        assert "Test & Co." in result
-        assert "test<>123" in result
-        assert "Answer with <tags> & symbols" in result
-
-    def test_remove_response_display_open_mode(self, open_handler, sample_data):
-        """Test removing response display from text in open mode."""
-        # First build the display
-        display_html = open_handler.build_response_display(
-            display_name=sample_data["display_name"],
-            assistant_id=sample_data["assistant_id"],
-            answer=sample_data["answer"],
-        )
-
-        # Create text with the display embedded
-        text_with_display = f"Some text before\n{display_html}\nSome text after"
-
-        # Remove the display
-        result = open_handler.remove_response_display(
-            assistant_id=sample_data["assistant_id"], text=text_with_display
-        )
-
-        assert "Some text before" in result
-        assert "Some text after" in result
-        assert sample_data["display_name"] not in result
-        assert sample_data["answer"] not in result
-
-    def test_remove_response_display_closed_mode(self, closed_handler, sample_data):
-        """Test removing response display from text in closed mode."""
-        # First build the display
-        display_html = closed_handler.build_response_display(
-            display_name=sample_data["display_name"],
-            assistant_id=sample_data["assistant_id"],
-            answer=sample_data["answer"],
-        )
-
-        # Create text with the display embedded
-        text_with_display = f"Some text before\n{display_html}\nSome text after"
-
-        # Remove the display
-        result = closed_handler.remove_response_display(
-            assistant_id=sample_data["assistant_id"], text=text_with_display
-        )
-
-        assert "Some text before" in result
-        assert "Some text after" in result
-        assert sample_data["display_name"] not in result
-        assert sample_data["answer"] not in result
-
-    def test_remove_response_display_multiple_instances(self, open_handler):
-        """Test removing multiple instances of response display."""
-        assistant_id = "test_123"
-
-        display1 = open_handler.build_response_display(
-            display_name="First", assistant_id=assistant_id, answer="First answer"
-        )
-
-        display2 = open_handler.build_response_display(
-            display_name="Second", assistant_id=assistant_id, answer="Second answer"
-        )
-
-        text_with_displays = f"Start\n{display1}\nMiddle\n{display2}\nEnd"
-
-        result = open_handler.remove_response_display(
-            assistant_id=assistant_id, text=text_with_displays
-        )
-
-        assert "Start" in result
-        assert "Middle" in result
-        assert "End" in result
-        assert "First answer" not in result
-        assert "Second answer" not in result
-
-    def test_remove_response_display_no_match(self, open_handler):
-        """Test removing response display when no match exists."""
-        text = "This is some text without any displays"
-        result = open_handler.remove_response_display(
-            assistant_id="nonexistent", text=text
-        )
-        assert result == text
-
-    def test_remove_response_display_with_regex_special_chars(self, open_handler):
-        """Test removing response display with regex special characters in assistant_id."""
-        assistant_id = "test.+*?[]{}()^$|"
-
-        display_html = open_handler.build_response_display(
-            display_name="Test", assistant_id=assistant_id, answer="Test answer"
-        )
-
-        text_with_display = f"Before\n{display_html}\nAfter"
-
-        result = open_handler.remove_response_display(
-            assistant_id=assistant_id, text=text_with_display
-        )
-
-        assert "Before" in result
-        assert "After" in result
-        assert "Test answer" not in result
-
-    def test_get_detect_re_pattern_validity(self, open_handler, closed_handler):
-        """Test that the regex patterns are valid and compilable."""
-        assistant_id = "test_123"
-
-        open_pattern = open_handler._get_detect_re(assistant_id)
-        closed_pattern = closed_handler._get_detect_re(assistant_id)
-
-        # Should not raise exceptions
-        re.compile(open_pattern)
-        re.compile(closed_pattern)
-
-        assert "(?s)" in open_pattern  # multiline flag
-        assert "(?s)" in closed_pattern
-        assert "details open" in open_pattern
-        assert "details>" in closed_pattern
-        assert "details open" not in closed_pattern
-
-
-class TestDisplayFunctions:
-    """Test suite for module-level display functions."""
-
-    @pytest.fixture
-    def sample_data(self):
-        """Sample data for testing."""
-        return {
-            "display_name": "Test Assistant",
-            "assistant_id": "test_assistant_123",
-            "answer": "This is a test answer.",
-        }
-
-    @pytest.mark.parametrize(
-        "display_mode,expected_content,not_expected_content",
-        [
-            (SubAgentResponseDisplayMode.DETAILS_OPEN, "<details open>", None),
-            (SubAgentResponseDisplayMode.DETAILS_CLOSED, "<details>", "<details open>"),
-            (SubAgentResponseDisplayMode.HIDDEN, "", None),
-        ],
-    )
-    def test_build_sub_agent_answer_display(
-        self, sample_data, display_mode, expected_content, not_expected_content
-    ):
-        """Test building sub-agent answer display with different modes."""
-        result = _build_sub_agent_answer_display(
-            display_name=sample_data["display_name"],
-            display_mode=display_mode,
-            answer=sample_data["answer"],
-            assistant_id=sample_data["assistant_id"],
-        )
-
-        if display_mode == SubAgentResponseDisplayMode.HIDDEN:
-            assert result == ""
-        else:
-            assert expected_content in result
-            assert sample_data["display_name"] in result
-            assert sample_data["answer"] in result
-            assert sample_data["assistant_id"] in result
-
-            if not_expected_content:
-                assert not_expected_content not in result
-
-    @pytest.mark.parametrize(
-        "display_mode",
-        [
-            SubAgentResponseDisplayMode.DETAILS_OPEN,
-            SubAgentResponseDisplayMode.DETAILS_CLOSED,
-        ],
-    )
-    def test_remove_sub_agent_answer_from_text_details_modes(
-        self, sample_data, display_mode
-    ):
-        """Test removing sub-agent answer from text with DETAILS_OPEN and DETAILS_CLOSED modes."""
-        # First build the display
-        display_html = _build_sub_agent_answer_display(
-            display_name=sample_data["display_name"],
-            display_mode=display_mode,
-            answer=sample_data["answer"],
-            assistant_id=sample_data["assistant_id"],
-        )
-
-        text_with_display = f"Before\n{display_html}\nAfter"
-
-        result = _remove_sub_agent_answer_from_text(
-            display_mode=display_mode,
-            text=text_with_display,
-            assistant_id=sample_data["assistant_id"],
-        )
-
-        assert "Before" in result
-        assert "After" in result
-        assert sample_data["answer"] not in result
-
-    def test_remove_sub_agent_answer_from_text_hidden_mode(self, sample_data):
-        """Test removing sub-agent answer from text with HIDDEN mode."""
-        text = "Some text here"
-        result = _remove_sub_agent_answer_from_text(
-            display_mode=SubAgentResponseDisplayMode.HIDDEN,
-            text=text,
-            assistant_id=sample_data["assistant_id"],
-        )
-
-        assert result == text
-
-    def test_roundtrip_build_and_remove(self, sample_data):
-        """Test that building and then removing display results in clean text."""
-        original_text = "This is the original text."
-
-        # Build display
-        display_html = _build_sub_agent_answer_display(
-            display_name=sample_data["display_name"],
-            display_mode=SubAgentResponseDisplayMode.DETAILS_OPEN,
-            answer=sample_data["answer"],
-            assistant_id=sample_data["assistant_id"],
-        )
-
-        # Insert into text
-        text_with_display = f"{original_text}\n{display_html}"
-
-        # Remove display
-        result = _remove_sub_agent_answer_from_text(
-            display_mode=SubAgentResponseDisplayMode.DETAILS_OPEN,
-            text=text_with_display,
-            assistant_id=sample_data["assistant_id"],
-        )
-
-        # Should be back to original (with some whitespace differences)
-        assert original_text in result.strip()
-        assert sample_data["answer"] not in result
-
-
-class TestEdgeCases:
-    """Test suite for edge cases and error conditions."""
-
-    def test_empty_strings(self):
-        """Test handling of empty strings."""
-        handler = _DetailsResponseDisplayHandler(mode="open")
-
-        result = handler.build_response_display(
-            display_name="", assistant_id="test", answer=""
-        )
-
-        assert "<details open>" in result
-        assert "<summary></summary>" in result
-
-    def test_multiline_content(self):
-        """Test handling of multiline content."""
-        handler = _DetailsResponseDisplayHandler(mode="open")
-
-        multiline_answer = """Line 1
-        Line 2
-        Line 3 with    spaces
-        
-        Line 5 after blank line"""
-
-        result = handler.build_response_display(
-            display_name="Multi-line Test",
-            assistant_id="test_ml",
-            answer=multiline_answer,
-        )
-
-        assert multiline_answer in result
-
-        # Test removal
-        text_with_display = f"Before\n{result}\nAfter"
-        clean_result = handler.remove_response_display(
-            assistant_id="test_ml", text=text_with_display
-        )
-
-        assert "Before" in clean_result
-        assert "After" in clean_result
-        assert multiline_answer not in clean_result
-
-    def test_html_content_in_answer(self):
-        """Test handling of HTML content within the answer."""
-        handler = _DetailsResponseDisplayHandler(mode="open")
-
-        html_answer = "<p>This is <strong>bold</strong> text with <em>emphasis</em></p>"
-
-        result = handler.build_response_display(
-            display_name="HTML Test", assistant_id="test_html", answer=html_answer
-        )
-
-        assert html_answer in result
-
-        # Test removal
-        text_with_display = f"Before\n{result}\nAfter"
-        clean_result = handler.remove_response_display(
-            assistant_id="test_html", text=text_with_display
-        )
-
-        assert "Before" in clean_result
-        assert "After" in clean_result
-        assert html_answer not in clean_result
-
-    def test_unicode_content(self):
-        """Test handling of Unicode content."""
-        handler = _DetailsResponseDisplayHandler(mode="open")
-
-        unicode_content = "Testing Unicode: 你好 🌟 café naïve résumé"
-
-        result = handler.build_response_display(
-            display_name="Unicode Test",
-            assistant_id="test_unicode",
-            answer=unicode_content,
-        )
-
-        assert unicode_content in result
-
-        # Test removal
-        text_with_display = f"Before\n{result}\nAfter"
-        clean_result = handler.remove_response_display(
-            assistant_id="test_unicode", text=text_with_display
-        )
-
-        assert "Before" in clean_result
-        assert "After" in clean_result
-        assert unicode_content not in clean_result

unique_toolkit/agentic/tools/a2a/postprocessing/test/test_postprocessor_reference_functions.py

@@ -1,256 +0,0 @@
-import pytest
-
-from unique_toolkit.agentic.tools.a2a.postprocessing._utils import (
-    _replace_references_in_text,
-    _replace_references_in_text_non_overlapping,
-)
-
-
-class TestReplaceReferencesInTextNonOverlapping:
-    """Test cases for _replace_references_in_text_non_overlapping function."""
-
-    def test_single_reference_replacement(self):
-        """Test replacing a single reference."""
-        text = "This is a test<sup>1</sup> with one reference."
-        ref_map = {1: 5}
-        result = _replace_references_in_text_non_overlapping(text, ref_map)
-        expected = "This is a test<sup>5</sup> with one reference."
-        assert result == expected
-
-    def test_multiple_reference_replacements(self):
-        """Test replacing multiple references."""
-        text = "First<sup>1</sup> and second<sup>2</sup> and third<sup>3</sup>."
-        ref_map = {1: 10, 2: 20, 3: 30}
-        result = _replace_references_in_text_non_overlapping(text, ref_map)
-        expected = "First<sup>10</sup> and second<sup>20</sup> and third<sup>30</sup>."
-        assert result == expected
-
-    def test_no_references_in_text(self):
-        """Test with text that has no references."""
-        text = "This text has no references at all."
-        ref_map = {1: 5, 2: 10}
-        result = _replace_references_in_text_non_overlapping(text, ref_map)
-        assert result == text
-
-    @pytest.mark.parametrize(
-        "text,ref_map,expected",
-        [
-            (
-                "This text has<sup>1</sup> references but empty map.",
-                {},
-                "This text has<sup>1</sup> references but empty map.",
-            ),
-            ("", {1: 5}, ""),
-        ],
-    )
-    def test_empty_inputs(self, text, ref_map, expected):
-        """Test with empty reference map or empty text."""
-        result = _replace_references_in_text_non_overlapping(text, ref_map)
-        assert result == expected
-
-    def test_reference_not_in_map(self):
-        """Test with references in text that are not in the map."""
-        text = "Reference<sup>1</sup> and<sup>2</sup> and<sup>3</sup>."
-        ref_map = {1: 10}  # Only maps reference 1
-        result = _replace_references_in_text_non_overlapping(text, ref_map)
-        expected = "Reference<sup>10</sup> and<sup>2</sup> and<sup>3</sup>."
-        assert result == expected
-
-    def test_duplicate_references_in_text(self):
-        """Test with duplicate references in text."""
-        text = "First<sup>1</sup> and second<sup>1</sup> occurrence."
-        ref_map = {1: 99}
-        result = _replace_references_in_text_non_overlapping(text, ref_map)
-        expected = "First<sup>99</sup> and second<sup>99</sup> occurrence."
-        assert result == expected
-
-    def test_adjacent_references(self):
-        """Test with adjacent references."""
-        text = "Adjacent<sup>1</sup><sup>2</sup> references."
-        ref_map = {1: 10, 2: 20}
-        result = _replace_references_in_text_non_overlapping(text, ref_map)
-        expected = "Adjacent<sup>10</sup><sup>20</sup> references."
-        assert result == expected
-
-    def test_references_with_multi_digit_numbers(self):
-        """Test with multi-digit reference numbers."""
-        text = "Reference<sup>123</sup> and<sup>456</sup>."
-        ref_map = {123: 789, 456: 101112}
-        result = _replace_references_in_text_non_overlapping(text, ref_map)
-        expected = "Reference<sup>789</sup> and<sup>101112</sup>."
-        assert result == expected
-
-    def test_references_at_text_boundaries(self):
-        """Test with references at the beginning and end of text."""
-        text = "<sup>1</sup>Start and end<sup>2</sup>"
-        ref_map = {1: 100, 2: 200}
-        result = _replace_references_in_text_non_overlapping(text, ref_map)
-        expected = "<sup>100</sup>Start and end<sup>200</sup>"
-        assert result == expected
-
-    def test_malformed_references_ignored(self):
-        """Test that malformed references are ignored."""
-        text = "Good<sup>1</sup> and bad<sup>abc</sup> and<sup></sup>."
-        ref_map = {1: 10}
-        result = _replace_references_in_text_non_overlapping(text, ref_map)
-        expected = "Good<sup>10</sup> and bad<sup>abc</sup> and<sup></sup>."
-        assert result == expected
-
-    @pytest.mark.parametrize(
-        "text,ref_map,expected",
-        [
-            (
-                "Zero reference<sup>0</sup> here.",
-                {0: 100},
-                "Zero reference<sup>100</sup> here.",
-            ),
-            (
-                "Negative<sup>-1</sup> reference.",
-                {-1: 5},
-                "Negative<sup>5</sup> reference.",
-            ),
-        ],
-    )
-    def test_special_reference_numbers(self, text, ref_map, expected):
-        """Test with zero and negative reference numbers."""
-        result = _replace_references_in_text_non_overlapping(text, ref_map)
-        assert result == expected
-
-
-class TestReplaceReferencesInText:
-    """Test cases for _replace_references_in_text function."""
-
-    def test_non_overlapping_simple_case(self):
-        """Test simple non-overlapping case."""
-        text = "Reference<sup>1</sup> and<sup>2</sup>."
-        ref_map = {1: 10, 2: 20}
-        result = _replace_references_in_text(text, ref_map)
-        expected = "Reference<sup>10</sup> and<sup>20</sup>."
-        assert result == expected
-
-    def test_overlapping_references_case1(self):
-        """Test overlapping case where new reference numbers conflict with existing ones."""
-        text = "First<sup>1</sup> and second<sup>2</sup>."
-        ref_map = {1: 2, 2: 1}  # Swap references
-        result = _replace_references_in_text(text, ref_map)
-        expected = "First<sup>2</sup> and second<sup>1</sup>."
-        assert result == expected
-
-    def test_overlapping_references_case2(self):
-        """Test overlapping case with chain of replacements."""
-        text = "Refs<sup>1</sup><sup>2</sup><sup>3</sup>."
-        ref_map = {1: 2, 2: 3, 3: 1}  # Circular replacement
-        result = _replace_references_in_text(text, ref_map)
-        expected = "Refs<sup>2</sup><sup>3</sup><sup>1</sup>."
-        assert result == expected
-
-    def test_overlapping_with_higher_numbers(self):
-        """Test overlapping where replacement numbers are higher than originals."""
-        text = "Test<sup>1</sup> and<sup>2</sup>."
-        ref_map = {1: 3, 2: 1}  # 2 -> 1, but 1 -> 3
-        result = _replace_references_in_text(text, ref_map)
-        expected = "Test<sup>3</sup> and<sup>1</sup>."
-        assert result == expected
-
-    def test_complex_overlapping_scenario(self):
-        """Test complex overlapping scenario with multiple conflicts."""
-        text = "A<sup>1</sup>B<sup>2</sup>C<sup>3</sup>D<sup>4</sup>."
-        ref_map = {1: 4, 2: 1, 3: 2, 4: 3}  # Full rotation
-        result = _replace_references_in_text(text, ref_map)
-        expected = "A<sup>4</sup>B<sup>1</sup>C<sup>2</sup>D<sup>3</sup>."
-        assert result == expected
-
-    @pytest.mark.parametrize(
-        "text,ref_map,expected",
-        [
-            (
-                "Text with<sup>1</sup> references.",
-                {},
-                "Text with<sup>1</sup> references.",
-            ),
-            ("", {1: 2}, ""),
-            (
-                "This text has no references.",
-                {1: 10, 2: 20},
-                "This text has no references.",
-            ),
-        ],
-    )
-    def test_edge_cases(self, text, ref_map, expected):
-        """Test edge cases: empty reference map, empty text, and text with no references."""
-        result = _replace_references_in_text(text, ref_map)
-        assert result == expected
-
-    def test_single_reference_no_overlap(self):
-        """Test single reference with no overlap potential."""
-        text = "Single<sup>5</sup> reference."
-        ref_map = {5: 100}
-        result = _replace_references_in_text(text, ref_map)
-        expected = "Single<sup>100</sup> reference."
-        assert result == expected
-
-    def test_partial_overlap(self):
-        """Test case where only some references have overlapping numbers."""
-        text = "Mix<sup>1</sup><sup>2</sup><sup>10</sup>."
-        ref_map = {1: 2, 2: 20, 10: 100}  # Only 1->2 creates potential overlap
-        result = _replace_references_in_text(text, ref_map)
-        expected = "Mix<sup>2</sup><sup>20</sup><sup>100</sup>."
-        assert result == expected
-
-    def test_self_mapping(self):
-        """Test case where a reference maps to itself."""
-        text = "Self<sup>1</sup> and other<sup>2</sup>."
-        ref_map = {1: 1, 2: 10}  # 1 maps to itself
-        result = _replace_references_in_text(text, ref_map)
-        expected = "Self<sup>1</sup> and other<sup>10</sup>."
-        assert result == expected
-
-    def test_duplicate_references_with_overlap(self):
-        """Test duplicate references in text with overlapping mappings."""
-        text = "Dup<sup>1</sup> and dup<sup>1</sup> and<sup>2</sup>."
-        ref_map = {1: 2, 2: 1}  # Swap
-        result = _replace_references_in_text(text, ref_map)
-        expected = "Dup<sup>2</sup> and dup<sup>2</sup> and<sup>1</sup>."
-        assert result == expected
-
-    def test_large_reference_numbers(self):
-        """Test with large reference numbers."""
-        text = "Large<sup>999</sup> and<sup>1000</sup>."
-        ref_map = {999: 1000, 1000: 999}  # Swap large numbers
-        result = _replace_references_in_text(text, ref_map)
-        expected = "Large<sup>1000</sup> and<sup>999</sup>."
-        assert result == expected
-
-    def test_zero_and_negative_with_overlap(self):
-        """Test zero and negative numbers with potential overlap."""
-        text = "Zero<sup>0</sup> and neg<sup>-1</sup> and pos<sup>1</sup>."
-        ref_map = {0: 1, -1: 0, 1: -1}  # Circular with zero and negative
-        result = _replace_references_in_text(text, ref_map)
-        expected = "Zero<sup>1</sup> and neg<sup>0</sup> and pos<sup>-1</sup>."
-        assert result == expected
-
-    def test_max_ref_calculation_edge_case(self):
-        """Test edge case for max_ref calculation with empty map."""
-        text = "Some<sup>1</sup> text."
-        ref_map = {}
-        result = _replace_references_in_text(text, ref_map)
-        assert result == text
-
-    def test_phase_separation_correctness(self):
-        """Test that the two-phase approach correctly handles complex overlaps."""
-        # This test ensures the intermediate unique references don't interfere
-        text = "Test<sup>1</sup><sup>2</sup><sup>3</sup><sup>4</sup><sup>5</sup>."
-        ref_map = {1: 5, 2: 4, 3: 3, 4: 2, 5: 1}  # Reverse order
-        result = _replace_references_in_text(text, ref_map)
-        expected = "Test<sup>5</sup><sup>4</sup><sup>3</sup><sup>2</sup><sup>1</sup>."
-        assert result == expected
-
-    def test_intermediate_collision_avoidance(self):
-        """Test that intermediate unique references don't collide with existing text."""
-        # Create a scenario where intermediate refs might collide
-        text = "Refs<sup>1</sup><sup>2</sup> and existing<sup>6</sup><sup>7</sup>."
-        ref_map = {1: 2, 2: 1}  # Simple swap
-        result = _replace_references_in_text(text, ref_map)
-        expected = "Refs<sup>2</sup><sup>1</sup> and existing<sup>6</sup><sup>7</sup>."
-        assert result == expected
-        # The existing <sup>6</sup> and <sup>7</sup> should remain unchanged