raw-docx 0.7.0__tar.gz → 0.8.0__tar.gz

{raw_docx-0.7.0 → raw_docx-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: raw_docx
-Version: 0.7.0
+Version: 0.8.0
 Summary: A package for processing and analyzing raw document formats
 Home-page: https://github.com/daveih/raw_docx
 Author: Dave Iberson-Hurst
@@ -17,8 +17,8 @@ Classifier: Programming Language :: Python :: 3.11
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: python-docx
-Requires-Dist: simple_error_log
+Requires-Dist: python-docx==1.1.2
+Requires-Dist: simple_error_log==0.6.0
 Dynamic: author
 Dynamic: classifier
 Dynamic: description
@@ -38,4 +38,4 @@ Simple package to build on top of python-docx to assist in the handling of word
 Build as a normal package
 
 - Build with `python3 -m build --sdist --wheel`
-- Upload to pypi.org using `twine upload dist/* `
+- Upload to pypi.org using `twine upload dist/*`

{raw_docx-0.7.0 → raw_docx-0.8.0}/README.md

@@ -7,4 +7,4 @@ Simple package to build on top of python-docx to assist in the handling of word
 Build as a normal package
 
 - Build with `python3 -m build --sdist --wheel`
-- Upload to pypi.org using `twine upload dist/* `
+- Upload to pypi.org using `twine upload dist/*`

{raw_docx-0.7.0 → raw_docx-0.8.0}/setup.py

@@ -19,7 +19,7 @@ setup(
     packages=find_packages(where="src"),
     package_dir={"": "src"},
     package_data={},
-    install_requires=["python-docx", "simple_error_log"],
+    install_requires=["python-docx==1.1.2", "simple_error_log==0.6.0"],
     tests_require=["pytest", "pytest-cov", "pytest-mock", "python-dotenv"],
     classifiers=[
         "Development Status :: 3 - Alpha",

raw_docx-0.8.0/src/raw_docx/__info__.py

@@ -0,0 +1 @@
+__package_version__ = "0.8.0"

{raw_docx-0.7.0 → raw_docx-0.8.0}/src/raw_docx/raw_document.py

@@ -22,7 +22,7 @@ class RawDocument:
         return self.sections[-1]
 
     def section_by_ordinal(self, ordinal: int) -> RawSection:
-        if 1 >= ordinal <= len(self.sections):
+        if 1 <= ordinal <= len(self.sections):
             return self.sections[ordinal - 1]
         else:
             return None

{raw_docx-0.7.0 → raw_docx-0.8.0}/src/raw_docx/raw_docx.py

@@ -144,7 +144,10 @@ class RawDocx:
                 else:
                     h_span = 1
                     v_span = 1
-                first = r_index == cell._tc.top and c_index == cell._tc.left
+                if cell._tc is not None:
+                    first = r_index == cell._tc.top and c_index == cell._tc.left
+                else:
+                    first = r_index == 0 and c_index == 0
                 target_cell = RawTableCell(h_span, v_span, first)
                 target_row.add(target_cell)
                 for block_item in self._iter_block_items(cell):
@@ -207,18 +210,27 @@ class RawDocx:
         list_level = paragraph._p.xpath("./w:pPr/w:numPr/w:ilvl/@w:val")
         return int(str(list_level[0])) if list_level else 0
 
-    def _is_heading(self, text):
-        if re.match(r"^\d\dHeading \d", text):
-            try:
-                level = int(text[0:2])
-                return True, level
-            except Exception:
-                return True, 0
-        if re.match(r"^Heading \d", text):
+    def _is_heading(self, text) -> tuple[bool, int]:
+        """
+        Extract heading level from text containing "Heading <N>" pattern.
+
+        Args:
+            text: Text to analyze for heading pattern
+
+        Returns:
+            tuple[bool, int]: (success, level) where success indicates if heading
+            pattern was found and level is the extracted integer value
+        """
+        if not text:
+            return False, 0
+
+        # Look for "Heading <N>" pattern where <N> is one or more digits
+        match = re.search(r"Heading\s+(\d+)", text, re.IGNORECASE)
+        if match:
             try:
-                level = int(text[8])
+                level = int(match.group(1))
                 return True, level
-            except Exception:
+            except (ValueError, IndexError):
                 return True, 0
         return False, 0
 

{raw_docx-0.7.0 → raw_docx-0.8.0}/src/raw_docx.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: raw_docx
-Version: 0.7.0
+Version: 0.8.0
 Summary: A package for processing and analyzing raw document formats
 Home-page: https://github.com/daveih/raw_docx
 Author: Dave Iberson-Hurst
@@ -17,8 +17,8 @@ Classifier: Programming Language :: Python :: 3.11
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: python-docx
-Requires-Dist: simple_error_log
+Requires-Dist: python-docx==1.1.2
+Requires-Dist: simple_error_log==0.6.0
 Dynamic: author
 Dynamic: classifier
 Dynamic: description
@@ -38,4 +38,4 @@ Simple package to build on top of python-docx to assist in the handling of word
 Build as a normal package
 
 - Build with `python3 -m build --sdist --wheel`
-- Upload to pypi.org using `twine upload dist/* `
+- Upload to pypi.org using `twine upload dist/*`

raw_docx-0.8.0/src/raw_docx.egg-info/requires.txt

@@ -0,0 +1,2 @@
+python-docx==1.1.2
+simple_error_log==0.6.0

{raw_docx-0.7.0 → raw_docx-0.8.0}/tests/test_docx_paragraph.py

@@ -194,3 +194,51 @@ def test_extract_runs_with_mixed_colors():
     result = extract_runs(paragraph, errors)
     assert len(result) == 3
     assert [r.color for r in result] == ["FF0000", "0000FF", "FF0000"]
+
+
+def test_run_style_color_exception_handling():
+    """Test _run_style_color exception handling (lines 80-82)"""
+    errors = Errors()
+    
+    # Create a run that will cause an exception when accessing style properties
+    run = Mock(spec=Run)
+    
+    # Create a style that raises an exception when trying to access font.color.rgb
+    def side_effect_func(*args, **kwargs):
+        raise AttributeError("Font color access error")
+    
+    style_mock = Mock()
+    style_mock.font.color.rgb = Mock(side_effect=side_effect_func)
+    # Make the rgb property falsy in boolean context but raise when called
+    style_mock.font.color.rgb.__bool__ = Mock(side_effect=side_effect_func)
+    run.style = style_mock
+    
+    result = _run_style_color(run, errors)
+    assert result is None
+    # Should have logged the exception
+
+
+def test_get_font_colour_exception_handling():
+    """Test _get_font_colour exception handling"""
+    errors = Errors()
+    
+    # Create an item that will cause an exception when accessing font properties
+    item = Mock()
+    item.font = None  # This will cause AttributeError when trying to access font.color
+    
+    result = _get_font_colour(item, errors)
+    assert result is None
+    # Should have logged the exception
+
+
+def test_get_highlight_color_exception_handling():
+    """Test _get_highlight_color exception handling"""
+    errors = Errors()
+    
+    # Create a run that will cause an exception when accessing highlight color
+    run = Mock(spec=Run)
+    run.font = None  # This will cause AttributeError when trying to access font.highlight_color
+    
+    result = _get_highlight_color(run, errors)
+    assert result is None
+    # Should have logged the exception

{raw_docx-0.7.0 → raw_docx-0.8.0}/tests/test_raw_document.py

@@ -42,6 +42,62 @@ def test_current_section_with_sections(document, sample_section):
     assert current == sample_section
 
 
+def test_section_by_ordinal(document):
+    """Test getting section by ordinal position"""
+    # Add some sections
+    section1 = RawSection("Section 1", "1", 1)
+    document.add(section1)
+    
+    section2 = RawSection("Section 2", "2", 1)
+    document.add(section2)
+    
+    # Test valid ordinals
+    assert document.section_by_ordinal(1) == document.sections[0]  # Initial section
+    assert document.section_by_ordinal(2) == section1
+    assert document.section_by_ordinal(3) == section2
+    
+    # Test invalid ordinals
+    assert document.section_by_ordinal(0) is None  # Below range
+    assert document.section_by_ordinal(4) is None  # Above range
+    assert document.section_by_ordinal(-1) is None  # Negative
+
+
+def test_section_by_number(document):
+    """Test getting section by section number"""
+    # Add sections with specific numbers
+    section1 = RawSection("Section 1", "1", 1)
+    document.add(section1)
+    
+    section2 = RawSection("Section 2", "2", 1)
+    document.add(section2)
+    
+    # Test valid section numbers
+    assert document.section_by_number("1") == section1
+    assert document.section_by_number("2") == section2
+    
+    # Test invalid section number
+    assert document.section_by_number("999") is None
+    assert document.section_by_number("nonexistent") is None
+
+
+def test_section_by_title(document):
+    """Test getting section by section title"""
+    # Add sections with specific titles
+    section1 = RawSection("First Section", "1", 1)
+    document.add(section1)
+    
+    section2 = RawSection("Second Section", "2", 1)
+    document.add(section2)
+    
+    # Test valid section titles
+    assert document.section_by_title("First Section") == section1
+    assert document.section_by_title("Second Section") == section2
+    
+    # Test invalid section title
+    assert document.section_by_title("Nonexistent Section") is None
+    assert document.section_by_title("") is None
+
+
 def test_to_dict(document):
     """Test converting document to dictionary"""
     # Add sections with content

raw_docx-0.8.0/tests/test_raw_docx.py

@@ -0,0 +1,628 @@
+import pytest
+import os
+import tempfile
+import zipfile
+from unittest.mock import Mock, patch, PropertyMock
+from pathlib import Path
+from docx import Document as DocxDocument
+from docx.shared import Inches
+from docx.text.paragraph import Paragraph
+from docx.table import Table, _Cell
+from docx.oxml.text.paragraph import CT_P
+from docx.oxml.table import CT_Tbl, CT_TcPr
+from lxml import etree
+import docx.parts.image
+from src.raw_docx.raw_docx import RawDocx
+from src.raw_docx.raw_document import RawDocument
+
+
+@pytest.fixture
+def raw_docx():
+    return RawDocx("tests/test_files/example_1.docx")
+
+
+@pytest.fixture
+def temp_docx(tmp_path):
+    """Create a test docx file with various content"""
+    doc_path = tmp_path / "test.docx"
+    doc = DocxDocument()
+
+    # Add regular paragraph
+    doc.add_paragraph("Regular paragraph")
+
+    # Add list items using standard list style
+    doc.add_paragraph("First bullet point", style="List Bullet")
+    doc.add_paragraph("Second bullet point", style="List Bullet")
+
+    # Add table with merged cells
+    table = doc.add_table(rows=2, cols=2)
+    table.cell(0, 0).merge(table.cell(0, 1))  # Merge first row
+    table.cell(0, 0).text = "Merged cell"
+    table.cell(1, 0).text = "Cell 1"
+    table.cell(1, 1).text = "Cell 2"
+
+    # Add image if test file exists
+    image_path = os.path.join(os.path.dirname(__file__), "test_files", "test_image.png")
+    if os.path.exists(image_path):
+        doc.add_picture(image_path, width=Inches(1.0))
+
+    # Save the document
+    doc.save(doc_path)
+    return str(doc_path)
+
+
+@pytest.fixture
+def simple_docx(tmp_path):
+    """Create a simple test docx file"""
+    doc_path = tmp_path / "simple_test.docx"
+    doc = DocxDocument()
+    doc.add_paragraph("Simple paragraph")
+    doc.save(doc_path)
+    return str(doc_path)
+
+
+# Integration Tests
+def test_to_dict_with_document(raw_docx):
+    """Test converting RawDocx to dictionary with loaded document"""
+    result = raw_docx.to_dict()
+    assert result["type"] == "raw_docx"
+    assert result["document"] is not None
+    assert result["document"]["type"] == "document"
+    assert isinstance(result["document"]["sections"], list)
+
+
+def test_initialization_and_processing(temp_docx):
+    """Test document initialization and processing"""
+    from raw_docx.raw_document import RawDocument
+    docx = RawDocx(temp_docx)
+    assert os.path.exists(docx.image_path)
+    assert isinstance(docx.target_document, RawDocument)
+    assert len(docx.target_document.sections) > 0
+
+
+def test_table_processing(temp_docx):
+    """Test table processing with merged cells"""
+    docx = RawDocx(temp_docx)
+    tables = docx.target_document.sections[0].tables()
+    assert len(tables) > 0
+
+    # Check merged cells
+    first_table = tables[0]
+    first_row = first_table.rows[0]
+    assert len(first_row.cells) == 2
+    assert first_row.cells[0].h_span == 2  # Horizontally merged
+    assert first_row.cells[0].first is True
+    assert first_row.cells[1].first is False
+
+
+def test_image_processing(temp_docx):
+    """Test image extraction and processing"""
+    docx = RawDocx(temp_docx)
+
+    # Check if image directory was created
+    assert os.path.exists(docx.image_path)
+
+    # Check if image is referenced in document
+    image_path = os.path.join(os.path.dirname(__file__), "test_files", "test_image.png")
+    if os.path.exists(image_path):
+        found_image = False
+        for section in docx.target_document.sections:
+            for item in section.items:
+                if hasattr(item, "filepath") and item.filepath.endswith(
+                    (".png", ".jpg", ".jpeg")
+                ):
+                    found_image = True
+                    break
+        assert found_image, "Image not found in document"
+
+
+def test_error_handling(tmp_path):
+    """Test error handling for invalid files and directories"""
+    # Test with non-existent file
+    with pytest.raises(Exception):
+        RawDocx(str(tmp_path / "nonexistent.docx"))
+
+    # Test with invalid file format
+    invalid_file = tmp_path / "invalid.txt"
+    invalid_file.write_text("Not a docx file")
+    with pytest.raises(Exception):
+        RawDocx(str(invalid_file))
+
+
+# Coverage Tests - Error Handling and Edge Cases
+def test_organise_dir_permission_error(simple_docx):
+    """Test _organise_dir with permission error"""
+    with patch('os.mkdir', side_effect=PermissionError("Permission denied")):
+        with patch.object(RawDocx, '_process'):
+            docx = RawDocx.__new__(RawDocx)
+            docx.errors = Mock()
+            docx.image_path = "/some/path"
+            docx._organise_dir()
+            docx.errors.exception.assert_called_once()
+
+
+def test_process_exception_handling(simple_docx):
+    """Test _process with exception in processing"""
+    with patch.object(RawDocx, '_organise_dir'):
+        with patch.object(RawDocx, '_process_images'):
+            docx = RawDocx.__new__(RawDocx)
+            docx.errors = Mock()
+            docx.target_document = Mock()
+            docx.target_document.current_section.return_value = Mock()
+            
+            with patch.object(docx, '_iter_block_items', side_effect=Exception("Test error")):
+                docx._process()
+                docx.errors.exception.assert_called()
+
+
+# Coverage Tests - _is_heading Method
+def test_is_heading_comprehensive(simple_docx):
+    """Test _is_heading method comprehensively"""
+    docx = RawDocx(simple_docx)
+    
+    # Test valid patterns
+    assert docx._is_heading("Heading 1") == (True, 1)
+    assert docx._is_heading("Heading 2") == (True, 2)
+    assert docx._is_heading("heading 3") == (True, 3)  # Case insensitive
+    assert docx._is_heading("HEADING 10") == (True, 10)
+    assert docx._is_heading("Some text with Heading 5 in it") == (True, 5)
+    assert docx._is_heading("Heading   7") == (True, 7)  # Multiple spaces
+    
+    # Test invalid patterns
+    assert docx._is_heading("Not a heading") == (False, 0)
+    assert docx._is_heading("Header 1") == (False, 0)
+    assert docx._is_heading("Heading") == (False, 0)
+    assert docx._is_heading("Heading abc") == (False, 0)
+    assert docx._is_heading("1 Heading") == (False, 0)
+    
+    # Test edge cases
+    assert docx._is_heading("") == (False, 0)
+    assert docx._is_heading(None) == (False, 0)
+
+
+# Coverage Tests - List Processing
+def test_get_list_level_with_mock(simple_docx):
+    """Test get_list_level with properly mocked paragraph"""
+    docx = RawDocx(simple_docx)
+    
+    # Create mock paragraph with _p attribute
+    mock_paragraph = Mock()
+    mock_p = Mock()
+    mock_p.xpath.return_value = ['2']
+    mock_paragraph._p = mock_p
+    
+    level = docx.get_list_level(mock_paragraph)
+    assert level == 2
+    
+    # Test with no level
+    mock_p.xpath.return_value = []
+    level = docx.get_list_level(mock_paragraph)
+    assert level == 0
+
+
+def test_is_list_comprehensive(simple_docx):
+    """Test _is_list method comprehensively"""
+    docx = RawDocx(simple_docx)
+    
+    # Test with xpath level
+    mock_paragraph = Mock()
+    mock_p = Mock()
+    mock_p.xpath.return_value = ['1']
+    mock_paragraph._p = mock_p
+    mock_paragraph.style = Mock()
+    mock_paragraph.style.name = "Normal"
+    mock_paragraph.text = "Regular text"
+    
+    result = docx._is_list(mock_paragraph)
+    assert result is True
+    
+    # Test with bullet styles
+    mock_p.xpath.return_value = []
+    mock_paragraph.style.name = "CPT_List Bullet"
+    result = docx._is_list(mock_paragraph)
+    assert result is True
+    
+    mock_paragraph.style.name = "List Bullet"
+    result = docx._is_list(mock_paragraph)
+    assert result is True
+    
+    # Test with bullet character
+    mock_paragraph.style.name = "Normal"
+    mock_paragraph.text = "• Bullet point"
+    result = docx._is_list(mock_paragraph)
+    assert result is True
+    
+    # Test false cases
+    mock_paragraph.text = "Regular text"
+    result = docx._is_list(mock_paragraph)
+    assert result is False
+    
+    mock_paragraph.text = ""
+    result = docx._is_list(mock_paragraph)
+    assert result is False
+    
+    mock_paragraph.text = None
+    result = docx._is_list(mock_paragraph)
+    assert result is False
+
+
+# Coverage Tests - Image Processing
+def test_extract_images_with_media(simple_docx):
+    """Test _extract_images when zipfile contains media files"""
+    docx = RawDocx.__new__(RawDocx)
+    docx.full_path = simple_docx
+    docx.image_path = "/tmp/test_images"
+    
+    # Create mock zipfile with media files
+    mock_file = Mock()
+    mock_file.filename = "word/media/image1.png"
+    
+    mock_archive = Mock()
+    mock_archive.filelist = [mock_file]
+    
+    # Mock the context manager for archive.open
+    mock_source = Mock()
+    mock_source.read.return_value = b"fake image data"
+    mock_archive.open.return_value.__enter__ = Mock(return_value=mock_source)
+    mock_archive.open.return_value.__exit__ = Mock(return_value=None)
+    
+    # Mock the file writing
+    mock_target = Mock()
+    mock_target.__enter__ = Mock(return_value=mock_target)
+    mock_target.__exit__ = Mock(return_value=None)
+    mock_target.write = Mock()
+    
+    with patch('zipfile.ZipFile', return_value=mock_archive):
+        with patch('builtins.open', return_value=mock_target):
+            docx._extract_images()
+            # Should have tried to extract the image
+            mock_archive.open.assert_called()
+
+
+# Coverage Tests - Utility Methods
+def test_tree_method(simple_docx):
+    """Test _tree method with nested children"""
+    docx = RawDocx(simple_docx)
+    
+    # Create nested mock structure
+    grandchild = Mock()
+    grandchild.__iter__ = Mock(return_value=iter([]))
+    
+    child = Mock()
+    child.__iter__ = Mock(return_value=iter([grandchild]))
+    
+    root = Mock()
+    root.__iter__ = Mock(return_value=iter([child]))
+    
+    # Should traverse the tree without errors
+    docx._tree(root)
+
+
+def test_to_dict_edge_cases(simple_docx):
+    """Test to_dict method edge cases"""
+    # Test without target_document attribute
+    docx = RawDocx.__new__(RawDocx)
+    result = docx.to_dict()
+    assert result == {"type": "raw_docx", "document": None}
+    
+    # Test with target_document that doesn't have to_dict method
+    docx.target_document = "not a proper document"
+    result = docx.to_dict()
+    assert result == {"type": "raw_docx", "document": None}
+    
+    # Test with proper target_document
+    docx = RawDocx(simple_docx)
+    result = docx.to_dict()
+    assert result["type"] == "raw_docx"
+    assert result["document"] is not None
+    assert isinstance(result["document"], dict)
+
+
+def test_iter_block_items_string_handling(simple_docx):
+    """Test _iter_block_items handles string children gracefully"""
+    docx = RawDocx(simple_docx)
+    
+    # Mock iterchildren to return a string (should be handled gracefully)
+    with patch.object(docx.source_document.element.body, 'iterchildren', return_value=["string_child"]):
+        items = list(docx._iter_block_items(docx.source_document))
+        # Should handle gracefully and continue without error
+
+
+def test_process_table_bottom_exception(simple_docx):
+    """Test _process_table when accessing bottom raises exception"""
+    docx = RawDocx(simple_docx)
+    
+    # Create a mock table structure
+    mock_table = Mock()
+    mock_row = Mock()
+    mock_cell = Mock()
+    mock_tc = Mock()
+    mock_tc.right = 2
+    mock_tc.left = 1
+    mock_tc.top = 1
+    
+    # Make bottom property raise an exception
+    type(mock_tc).bottom = PropertyMock(side_effect=Exception("Bottom error"))
+    mock_cell._tc = mock_tc
+    mock_row.cells = [mock_cell]
+    mock_table.rows = [mock_row]
+    
+    with patch.object(docx, '_iter_block_items', return_value=[]):
+        target_section = docx.target_document.current_section()
+        # Should handle the exception and set bottom = top + 1
+        docx._process_table(mock_table, target_section)
+
+
+def test_logic_error_exception():
+    """Test LogicError exception can be raised"""
+    with pytest.raises(RawDocx.LogicError):
+        raise RawDocx.LogicError("Test error")
+
+
+# Additional Coverage Tests for Missing Lines
+def test_process_with_unknown_block_item(simple_docx):
+    """Test _process with unknown block item type (lines 66-67)"""
+    with patch.object(RawDocx, '_organise_dir'):
+        with patch.object(RawDocx, '_process_images'):
+            docx = RawDocx.__new__(RawDocx)
+            docx.errors = Mock()
+            docx.target_document = Mock()
+            docx.target_document.current_section.return_value = Mock()
+            
+            # Mock _iter_block_items to return unknown type that will trigger warning and ValueError
+            unknown_item = 123  # Not a Paragraph or Table
+            with patch.object(docx, '_iter_block_items', return_value=[unknown_item]):
+                docx._process()
+                # Should catch the exception and log it
+                docx.errors.exception.assert_called()
+
+
+
+
+def test_process_table_with_invalid_child_type(simple_docx):
+    """Test _process_table with invalid child type (lines 153-163)"""
+    docx = RawDocx(simple_docx)
+    
+    mock_table = Mock()
+    mock_row = Mock()
+    mock_cell = Mock()
+    mock_tc = Mock()
+    mock_tc.right = 2
+    mock_tc.left = 1
+    mock_tc.top = 1
+    mock_tc.bottom = 2
+    mock_cell._tc = mock_tc
+    mock_row.cells = [mock_cell]
+    mock_table.rows = [mock_row]
+    
+    # Return invalid child type
+    invalid_child = "invalid_type"
+    
+    with patch.object(docx, '_iter_block_items', return_value=[invalid_child]):
+        target_section = docx.target_document.current_section()
+        with pytest.raises(RawDocx.LogicError, match="something's not right with a child"):
+            docx._process_table(mock_table, target_section)
+
+
+def test_process_paragraph_with_graphic_and_matching_rid(simple_docx):
+    """Test _process_paragraph with graphic containing matching rId (lines 198-201)"""
+    docx = RawDocx(simple_docx)
+    
+    # Create mock paragraph with graphic
+    mock_paragraph = Mock(spec=Paragraph)
+    mock_paragraph.style = Mock()
+    mock_paragraph.style.name = "Normal"
+    mock_paragraph._p = Mock()
+    mock_paragraph._p.xml = "Some xml content with rId1 reference and Graphic"
+    mock_paragraph.extract_runs.return_value = []
+    
+    target_section = Mock()
+    image_rels = {"rId1": "/path/to/image.png"}
+    
+    with patch.object(docx, '_is_heading', return_value=(False, 0)):
+        with patch.object(docx, '_is_list', return_value=False):
+            with patch('src.raw_docx.raw_docx.RawImage') as mock_image_class:
+                mock_image = Mock()
+                mock_image_class.return_value = mock_image
+                
+                docx._process_paragraph(mock_paragraph, target_section, image_rels)
+                # Should have created and added image
+                mock_image_class.assert_called_with("/path/to/image.png", docx.errors)
+                target_section.add.assert_called_with(mock_image)
+
+
+def test_is_heading_with_exception_handling(simple_docx):
+    """Test _is_heading exception handling (line 230-231)"""
+    docx = RawDocx(simple_docx)
+    
+    # Mock re.search to return a match but int() raises ValueError
+    with patch('src.raw_docx.raw_docx.re.search') as mock_search:
+        mock_match = Mock()
+        mock_match.group.side_effect = ValueError("Invalid conversion")
+        mock_search.return_value = mock_match
+        
+        result = docx._is_heading("Heading 1")
+        # Should return (True, 0) when exception occurs during conversion
+        assert result == (True, 0)
+
+
+def test_is_heading_with_index_error(simple_docx):
+    """Test _is_heading with IndexError (line 230-231)"""
+    docx = RawDocx(simple_docx)
+    
+    with patch('src.raw_docx.raw_docx.re.search') as mock_search:
+        mock_match = Mock()
+        mock_match.group.side_effect = IndexError("Index error")
+        mock_search.return_value = mock_match
+        
+        result = docx._is_heading("Heading 1")
+        # Should return (True, 0) when IndexError occurs
+        assert result == (True, 0)
+
+
+def test_process_images_with_image_part(simple_docx):
+    """Test _process_images when document has image parts (line 76)"""
+    raw_docx_instance = RawDocx.__new__(RawDocx)
+    raw_docx_instance.errors = Mock()
+    raw_docx_instance.image_path = "/tmp/test"
+    raw_docx_instance.image_rels = {}
+    
+    # Mock source document with image parts
+    mock_source_doc = Mock()
+    mock_part = Mock()
+    mock_rels = Mock()
+    
+    # Create mock image part
+    import docx.parts.image
+    mock_image_part = Mock(spec=docx.parts.image.ImagePart)
+    mock_image_part.partname = "/word/media/image1.png"
+    
+    mock_rel = Mock()
+    mock_rel._target = mock_image_part
+    mock_rel.rId = "rId1"
+    
+    mock_rels.values.return_value = [mock_rel]
+    mock_part.rels = mock_rels
+    mock_source_doc.part = mock_part
+    raw_docx_instance.source_document = mock_source_doc
+    
+    with patch.object(raw_docx_instance, '_extract_images'):
+        raw_docx_instance._process_images()
+        # Should have added image to image_rels
+        assert "rId1" in raw_docx_instance.image_rels
+        assert raw_docx_instance.image_rels["rId1"].endswith("image1.png")
+
+
+def test_iter_block_items_invalid_parent(simple_docx):
+    """Test _iter_block_items with invalid parent type (line 93)"""
+    docx = RawDocx(simple_docx)
+    
+    # Test with invalid parent type
+    invalid_parent = "not_a_document_or_cell"
+    
+    with pytest.raises(ValueError, match="something's not right with the parent"):
+        list(docx._iter_block_items(invalid_parent))
+
+
+def test_iter_block_items_unknown_child_type(simple_docx):
+    """Test _iter_block_items with unknown child type (line 117)"""
+    from docx.document import Document
+    docx = RawDocx(simple_docx)
+    
+    # Mock document with unknown child type
+    mock_doc = Mock(spec=Document)
+    mock_body = Mock()
+    
+    # Create unknown child type
+    unknown_child = Mock()
+    unknown_child.__class__ = type('UnknownType', (), {})
+    
+    mock_body.iterchildren.return_value = [unknown_child]
+    mock_doc.element = Mock()
+    mock_doc.element.body = mock_body
+    
+    with pytest.raises(ValueError, match="something's not right with a child"):
+        list(docx._iter_block_items(mock_doc))
+
+
+def test_process_table_cell_none(simple_docx):
+    """Test _process_table when cell._tc is None (lines 145-146)"""
+    docx = RawDocx(simple_docx)
+    
+    # Create mock table with cell._tc = None
+    mock_table = Mock()
+    mock_row = Mock()
+    mock_cell = Mock()
+    mock_cell._tc = None  # This triggers lines 145-146
+    # Need to mock the attributes that are accessed when _tc is None
+    mock_cell.top = 0
+    mock_cell.left = 0
+    mock_row.cells = [mock_cell]
+    mock_table.rows = [mock_row]
+    
+    with patch.object(docx, '_iter_block_items', return_value=[]):
+        target_section = docx.target_document.current_section()
+        docx._process_table(mock_table, target_section)
+        # Should handle None _tc and set default spans
+
+
+def test_process_table_nested_table(simple_docx):
+    """Test _process_table with nested table (line 154)"""
+    docx = RawDocx(simple_docx)
+    
+    # Create mock table structure
+    mock_table = Mock()
+    mock_row = Mock()
+    mock_cell = Mock()
+    mock_tc = Mock()
+    mock_tc.right = 2
+    mock_tc.left = 1
+    mock_tc.top = 1
+    mock_tc.bottom = 2
+    mock_cell._tc = mock_tc
+    mock_row.cells = [mock_cell]
+    mock_table.rows = [mock_row]
+    
+    # Create nested table
+    nested_table = Mock(spec=Table)
+    
+    with patch.object(docx, '_iter_block_items', return_value=[nested_table]):
+        target_section = docx.target_document.current_section()
+        with pytest.raises(RawDocx.LogicError, match="Table within table detected"):
+            docx._process_table(mock_table, target_section)
+
+
+def test_process_table_with_etree_element_ct_tcpr(simple_docx):
+    """Test _process_table with CT_TcPr etree element (lines 156-157)"""
+    docx = RawDocx(simple_docx)
+    
+    # Create mock table structure
+    mock_table = Mock()
+    mock_row = Mock()
+    mock_cell = Mock()
+    mock_tc = Mock()
+    mock_tc.right = 2
+    mock_tc.left = 1
+    mock_tc.top = 1
+    mock_tc.bottom = 2
+    mock_cell._tc = mock_tc
+    mock_row.cells = [mock_cell]
+    mock_table.rows = [mock_row]
+    
+    # Create etree element with CT_TcPr tag
+    etree_element = Mock(spec=etree._Element)
+    etree_element.tag = CT_TcPr
+    
+    with patch.object(docx, '_iter_block_items', return_value=[etree_element]):
+        target_section = docx.target_document.current_section()
+        # Should pass through CT_TcPr elements without error
+        docx._process_table(mock_table, target_section)
+
+
+def test_process_table_with_unknown_etree_element(simple_docx):
+    """Test _process_table with unknown etree element (lines 158-159)"""
+    docx = RawDocx(simple_docx)
+    
+    # Create mock table structure
+    mock_table = Mock()
+    mock_row = Mock()
+    mock_cell = Mock()
+    mock_tc = Mock()
+    mock_tc.right = 2
+    mock_tc.left = 1
+    mock_tc.top = 1
+    mock_tc.bottom = 2
+    mock_cell._tc = mock_tc
+    mock_row.cells = [mock_cell]
+    mock_table.rows = [mock_row]
+    
+    # Create etree element with unknown tag
+    etree_element = Mock(spec=etree._Element)
+    etree_element.tag = "unknown_tag"
+    
+    with patch.object(docx, '_iter_block_items', return_value=[etree_element]):
+        target_section = docx.target_document.current_section()
+        with patch.object(docx.errors, 'warning') as mock_warning:
+            docx._process_table(mock_table, target_section)
+            # Should log warning for unknown etree element
+            mock_warning.assert_called()

{raw_docx-0.7.0 → raw_docx-0.8.0}/tests/test_raw_list.py

@@ -42,7 +42,32 @@ def test_to_text():
     ]
     for item in items:
         list.add(item)
-    assert item.to_text() == "  Item 2"
+    # Test the RawList.to_text() method to cover lines 30-33
+    result = list.to_text()
+    expected_lines = [
+        "  Item 1",  # Level 1 item (2 spaces for level 1)
+        "    Item 1.1",  # Level 2 item (4 spaces for level 2)
+        "  Item 2"   # Level 1 item (2 spaces for level 1)
+    ]
+    assert result == "\n".join(expected_lines)
+
+
+def test_to_text_empty_list():
+    """Test to_text method with empty list"""
+    errors = Errors()
+    list = RawList(errors, 0)
+    result = list.to_text()
+    assert result == ""
+
+
+def test_to_text_single_item():
+    """Test to_text method with single item"""
+    errors = Errors()
+    list = RawList(errors, 0)
+    item = RawListItem([RawRun("Single item", "", None, "Normal")], 0)
+    list.add(item)
+    result = list.to_text()
+    assert result == "Single item"
 
 
 def test_add_multiple_items():

{raw_docx-0.7.0 → raw_docx-0.8.0}/tests/test_raw_paragraph.py

@@ -95,3 +95,40 @@ def test_empty_paragraph():
     paragraph = RawParagraph([])
     assert paragraph.text == ""
     assert len(paragraph.runs) == 0
+
+
+def test_add_span():
+    """Test adding span to paragraph text"""
+    run = RawRun("Hello World", "", None, "Normal")
+    paragraph = RawParagraph([run])
+    
+    # Add span to the beginning of "Hello"
+    paragraph.add_span("Hello", "highlight")
+    
+    # The text should now have the span wrapped around "Hello"
+    expected_text = '<span class="highlight">Hello</span> World'
+    assert paragraph.text == expected_text
+
+
+def test_add_span_partial_match():
+    """Test adding span with partial text match"""
+    run = RawRun("Testing paragraph", "", None, "Normal")
+    paragraph = RawParagraph([run])
+    
+    # Add span to "Test" at the beginning
+    paragraph.add_span("Test", "emphasis")
+    
+    expected_text = '<span class="emphasis">Test</span>ing paragraph'
+    assert paragraph.text == expected_text
+
+
+def test_add_span_exact_match():
+    """Test adding span when text matches exactly"""
+    run = RawRun("Test", "", None, "Normal")
+    paragraph = RawParagraph([run])
+    
+    # Add span to entire text
+    paragraph.add_span("Test", "bold")
+    
+    expected_text = '<span class="bold">Test</span>'
+    assert paragraph.text == expected_text

raw_docx-0.7.0/src/raw_docx/__info__.py

@@ -1 +0,0 @@
-__package_version__ = "0.7.0"

raw_docx-0.7.0/src/raw_docx.egg-info/requires.txt

@@ -1,2 +0,0 @@
-python-docx
-simple_error_log

raw_docx-0.7.0/tests/test_raw_docx.py

@@ -1,107 +0,0 @@
-import pytest
-import os
-from docx import Document as DocxDocument
-from docx.shared import Inches
-from src.raw_docx.raw_docx import RawDocx
-from src.raw_docx.raw_document import RawDocument
-
-
-@pytest.fixture
-def raw_docx():
-    return RawDocx("tests/test_files/example_1.docx")
-
-
-@pytest.fixture
-def temp_docx(tmp_path):
-    """Create a test docx file with various content"""
-    doc_path = tmp_path / "test.docx"
-    doc = DocxDocument()
-
-    # Add regular paragraph
-    doc.add_paragraph("Regular paragraph")
-
-    # Add list items using standard list style
-    doc.add_paragraph("First bullet point", style="List Bullet")
-    doc.add_paragraph("Second bullet point", style="List Bullet")
-
-    # Add table with merged cells
-    table = doc.add_table(rows=2, cols=2)
-    table.cell(0, 0).merge(table.cell(0, 1))  # Merge first row
-    table.cell(0, 0).text = "Merged cell"
-    table.cell(1, 0).text = "Cell 1"
-    table.cell(1, 1).text = "Cell 2"
-
-    # Add image if test file exists
-    image_path = os.path.join(os.path.dirname(__file__), "test_files", "test_image.png")
-    if os.path.exists(image_path):
-        doc.add_picture(image_path, width=Inches(1.0))
-
-    # Save the document
-    doc.save(doc_path)
-    return str(doc_path)
-
-
-def test_to_dict_with_document(raw_docx):
-    """Test converting RawDocx to dictionary with loaded document"""
-    result = raw_docx.to_dict()
-    assert result["type"] == "raw_docx"
-    assert result["document"] is not None
-    assert result["document"]["type"] == "document"
-    assert isinstance(result["document"]["sections"], list)
-
-
-def test_initialization_and_processing(temp_docx):
-    """Test document initialization and processing"""
-    docx = RawDocx(temp_docx)
-    assert os.path.exists(docx.image_path)
-    assert isinstance(docx.target_document, RawDocument)
-    assert len(docx.target_document.sections) > 0
-
-
-def test_table_processing(temp_docx):
-    """Test table processing with merged cells"""
-    docx = RawDocx(temp_docx)
-    tables = docx.target_document.sections[0].tables()
-    assert len(tables) > 0
-
-    # Check merged cells
-    first_table = tables[0]
-    first_row = first_table.rows[0]
-    assert len(first_row.cells) == 2
-    assert first_row.cells[0].h_span == 2  # Horizontally merged
-    assert first_row.cells[0].first is True
-    assert first_row.cells[1].first is False
-
-
-def test_image_processing(temp_docx):
-    """Test image extraction and processing"""
-    docx = RawDocx(temp_docx)
-
-    # Check if image directory was created
-    assert os.path.exists(docx.image_path)
-
-    # Check if image is referenced in document
-    image_path = os.path.join(os.path.dirname(__file__), "test_files", "test_image.png")
-    if os.path.exists(image_path):
-        found_image = False
-        for section in docx.target_document.sections:
-            for item in section.items:
-                if hasattr(item, "filepath") and item.filepath.endswith(
-                    (".png", ".jpg", ".jpeg")
-                ):
-                    found_image = True
-                    break
-        assert found_image, "Image not found in document"
-
-
-def test_error_handling(tmp_path):
-    """Test error handling for invalid files and directories"""
-    # Test with non-existent file
-    with pytest.raises(Exception):
-        RawDocx(str(tmp_path / "nonexistent.docx"))
-
-    # Test with invalid file format
-    invalid_file = tmp_path / "invalid.txt"
-    invalid_file.write_text("Not a docx file")
-    with pytest.raises(Exception):
-        RawDocx(str(invalid_file))