natural-pdf 0.2.10__tar.gz → 0.2.11__tar.gz

{natural_pdf-0.2.10/natural_pdf.egg-info → natural_pdf-0.2.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: natural-pdf
-Version: 0.2.10
+Version: 0.2.11
 Summary: A more intuitive interface for working with PDFs
 Author-email: Jonathan Soma <jonathan.soma@gmail.com>
 License-Expression: MIT

{natural_pdf-0.2.10 → natural_pdf-0.2.11}/natural_pdf/analyzers/guides.py

@@ -4246,12 +4246,26 @@ class _ColumnAccessor:
         """Return number of columns (vertical guides - 1)."""
         return max(0, len(self._guides.vertical) - 1)
 
-    def __getitem__(self, index: int) -> "Region":
-        """Get column at the specified index."""
-        # Handle negative indexing
-        if index < 0:
-            index = len(self) + index
-        return self._guides.column(index)
+    def __getitem__(self, index: Union[int, slice]) -> Union["Region", "ElementCollection"]:
+        """Get column at the specified index or slice."""
+        from natural_pdf.elements.element_collection import ElementCollection
+
+        if isinstance(index, slice):
+            # Handle slice notation - return multiple columns
+            columns = []
+            num_cols = len(self)
+
+            # Convert slice to range of indices
+            start, stop, step = index.indices(num_cols)
+            for i in range(start, stop, step):
+                columns.append(self._guides.column(i))
+
+            return ElementCollection(columns)
+        else:
+            # Handle negative indexing
+            if index < 0:
+                index = len(self) + index
+            return self._guides.column(index)
 
 
 class _RowAccessor:
@@ -4264,12 +4278,26 @@ class _RowAccessor:
         """Return number of rows (horizontal guides - 1)."""
         return max(0, len(self._guides.horizontal) - 1)
 
-    def __getitem__(self, index: int) -> "Region":
-        """Get row at the specified index."""
-        # Handle negative indexing
-        if index < 0:
-            index = len(self) + index
-        return self._guides.row(index)
+    def __getitem__(self, index: Union[int, slice]) -> Union["Region", "ElementCollection"]:
+        """Get row at the specified index or slice."""
+        from natural_pdf.elements.element_collection import ElementCollection
+
+        if isinstance(index, slice):
+            # Handle slice notation - return multiple rows
+            rows = []
+            num_rows = len(self)
+
+            # Convert slice to range of indices
+            start, stop, step = index.indices(num_rows)
+            for i in range(start, stop, step):
+                rows.append(self._guides.row(i))
+
+            return ElementCollection(rows)
+        else:
+            # Handle negative indexing
+            if index < 0:
+                index = len(self) + index
+            return self._guides.row(index)
 
 
 class _CellAccessor:
@@ -4278,33 +4306,82 @@ class _CellAccessor:
     def __init__(self, guides: "Guides"):
         self._guides = guides
 
-    def __getitem__(self, key) -> Union["Region", "_CellRowAccessor"]:
+    def __getitem__(self, key) -> Union["Region", "_CellRowAccessor", "ElementCollection"]:
         """
         Get cell(s) at the specified position.
 
         Supports:
-        - guides.cells[row, col] - tuple indexing
-        - guides.cells[row][col] - nested indexing
+        - guides.cells[row, col] - single cell
+        - guides.cells[row][col] - single cell (nested)
+        - guides.cells[row, :] - all cells in a row
+        - guides.cells[:, col] - all cells in a column
+        - guides.cells[:, :] - all cells
+        - guides.cells[row][:] - all cells in a row (nested)
         """
+        from natural_pdf.elements.element_collection import ElementCollection
+
         if isinstance(key, tuple) and len(key) == 2:
-            # Direct tuple access: guides.cells[row, col]
             row, col = key
-            # Handle negative indexing for both row and col
-            if row < 0:
-                row = len(self._guides.rows) + row
-            if col < 0:
-                col = len(self._guides.columns) + col
-            return self._guides.cell(row, col)
+
+            # Handle slices for row and/or column
+            if isinstance(row, slice) or isinstance(col, slice):
+                cells = []
+                num_rows = len(self._guides.rows)
+                num_cols = len(self._guides.columns)
+
+                # Convert slices to ranges
+                if isinstance(row, slice):
+                    row_indices = range(*row.indices(num_rows))
+                else:
+                    # Single row index
+                    if row < 0:
+                        row = num_rows + row
+                    row_indices = [row]
+
+                if isinstance(col, slice):
+                    col_indices = range(*col.indices(num_cols))
+                else:
+                    # Single column index
+                    if col < 0:
+                        col = num_cols + col
+                    col_indices = [col]
+
+                # Collect all cells in the specified ranges
+                for r in row_indices:
+                    for c in col_indices:
+                        cells.append(self._guides.cell(r, c))
+
+                return ElementCollection(cells)
+            else:
+                # Both are integers - single cell access
+                # Handle negative indexing for both row and col
+                if row < 0:
+                    row = len(self._guides.rows) + row
+                if col < 0:
+                    col = len(self._guides.columns) + col
+                return self._guides.cell(row, col)
+        elif isinstance(key, slice):
+            # First level slice: guides.cells[:] - return all rows as accessors
+            # For now, let's return all cells flattened
+            cells = []
+            num_rows = len(self._guides.rows)
+            row_indices = range(*key.indices(num_rows))
+
+            for r in row_indices:
+                for c in range(len(self._guides.columns)):
+                    cells.append(self._guides.cell(r, c))
+
+            return ElementCollection(cells)
         elif isinstance(key, int):
             # First level of nested access: guides.cells[row]
             # Handle negative indexing for row
             if key < 0:
                 key = len(self._guides.rows) + key
-            # Return a row accessor that allows [col] indexing
+            # Return a row accessor that allows [col] or [:] indexing
             return _CellRowAccessor(self._guides, key)
         else:
             raise TypeError(
-                f"Cell indices must be integers or tuple of two integers, got {type(key)}"
+                f"Cell indices must be integers, slices, or tuple of two integers/slices, got {type(key)}"
             )
 
 
@@ -4315,9 +4392,24 @@ class _CellRowAccessor:
         self._guides = guides
         self._row = row
 
-    def __getitem__(self, col: int) -> "Region":
-        """Get cell at [row][col]."""
-        # Handle negative indexing for column
-        if col < 0:
-            col = len(self._guides.columns) + col
-        return self._guides.cell(self._row, col)
+    def __getitem__(self, col: Union[int, slice]) -> Union["Region", "ElementCollection"]:
+        """Get cell at [row][col] or all cells in row with [row][:]."""
+        from natural_pdf.elements.element_collection import ElementCollection
+
+        if isinstance(col, slice):
+            # Handle slice notation - return all cells in this row
+            cells = []
+            num_cols = len(self._guides.columns)
+
+            # Convert slice to range of indices
+            start, stop, step = col.indices(num_cols)
+            for c in range(start, stop, step):
+                cells.append(self._guides.cell(self._row, c))
+
+            return ElementCollection(cells)
+        else:
+            # Handle single column index
+            # Handle negative indexing for column
+            if col < 0:
+                col = len(self._guides.columns) + col
+            return self._guides.cell(self._row, col)

{natural_pdf-0.2.10 → natural_pdf-0.2.11/natural_pdf.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: natural-pdf
-Version: 0.2.10
+Version: 0.2.11
 Summary: A more intuitive interface for working with PDFs
 Author-email: Jonathan Soma <jonathan.soma@gmail.com>
 License-Expression: MIT

{natural_pdf-0.2.10 → natural_pdf-0.2.11}/tests/test_guides.py

@@ -637,5 +637,69 @@ def test_property_accessors_with_negative_indexing():
         _ = guides.cells[0, -4]  # Column index out of bounds
 
 
+def test_property_accessors_with_slicing():
+    """Test property-based accessors with slice notation."""
+    pdf = PDF("pdfs/01-practice.pdf")
+    page = pdf.pages[0]
+
+    # Create guides with 3x3 grid
+    guides = Guides(page)
+    guides.vertical.divide(3)  # Creates 4 vertical guides = 3 columns
+    guides.horizontal.divide(3)  # Creates 4 horizontal guides = 3 rows
+
+    # Test getting all cells in a row
+    row_cells = guides.cells[0][:]
+    assert hasattr(row_cells, "__len__")  # Should be an ElementCollection
+    assert len(row_cells) == 3  # 3 cells in a row
+
+    # Test getting all cells in a row with tuple notation
+    row_cells_tuple = guides.cells[0, :]
+    assert len(row_cells_tuple) == 3
+    # Should contain same cells
+    assert all(c1.x0 == c2.x0 and c1.top == c2.top for c1, c2 in zip(row_cells, row_cells_tuple))
+
+    # Test getting all cells in a column
+    col_cells = guides.cells[:, 0]
+    assert len(col_cells) == 3  # 3 cells in a column
+
+    # Test getting all cells
+    all_cells = guides.cells[:, :]
+    assert len(all_cells) == 9  # 3x3 = 9 cells
+
+    # Test getting all rows
+    all_rows = guides.rows[:]
+    assert len(all_rows) == 3
+
+    # Test getting all columns
+    all_cols = guides.columns[:]
+    assert len(all_cols) == 3
+
+    # Test slice with step
+    every_other_col = guides.columns[::2]
+    assert len(every_other_col) == 2  # columns 0 and 2
+
+    # Test negative indices in slices
+    last_row_cells = guides.cells[-1, :]
+    assert len(last_row_cells) == 3
+
+    # Test partial slices
+    first_two_rows = guides.rows[:2]
+    assert len(first_two_rows) == 2
+
+    last_two_cols = guides.columns[-2:]
+    assert len(last_two_cols) == 2
+
+    # Test that cells are in correct order
+    # First row cells should be ordered left to right
+    first_row = guides.cells[0, :]
+    for i in range(len(first_row) - 1):
+        assert first_row[i].x0 < first_row[i + 1].x0
+
+    # First column cells should be ordered top to bottom
+    first_col = guides.cells[:, 0]
+    for i in range(len(first_col) - 1):
+        assert first_col[i].top < first_col[i + 1].top
+
+
 if __name__ == "__main__":
     pytest.main([__file__])