natural-pdf 0.1.10__py3-none-any.whl → 0.1.12__py3-none-any.whl

natural_pdf/exporters/original_pdf.py

@@ -0,0 +1,127 @@
+"""
+Module for exporting original PDF pages without modification.
+"""
+
+import logging
+import os
+from pathlib import Path
+from typing import TYPE_CHECKING, List, Set, Union
+
+# Lazy import for optional dependency
+try:
+    import pikepdf
+except ImportError:
+    pikepdf = None
+
+if TYPE_CHECKING:
+    from natural_pdf.core.page import Page
+    from natural_pdf.core.pdf import PDF
+    from natural_pdf.elements.collections import PageCollection
+
+logger = logging.getLogger(__name__)
+
+
+def create_original_pdf(
+    source: Union["Page", "PageCollection", "PDF"], output_path: Union[str, Path]
+):
+    """
+    Creates a new PDF file containing only the original, unmodified pages
+    specified by the source object.
+
+    Requires 'pikepdf'. Install with: pip install "natural-pdf[ocr-export]"
+
+    Args:
+        source: The Page, PageCollection, or PDF object indicating which pages to include.
+        output_path: The path to save the resulting PDF file.
+
+    Raises:
+        ImportError: If 'pikepdf' is not installed.
+        ValueError: If the source object is empty, pages are from different PDFs,
+                    or the source PDF path cannot be determined.
+        RuntimeError: If pikepdf fails to open the source or save the output.
+        pikepdf.PasswordError: If the source PDF is password-protected.
+    """
+    if pikepdf is None:
+        raise ImportError(
+            "Saving original PDF pages requires 'pikepdf'. "
+            'Install with: pip install "natural-pdf[ocr-export]"'
+        )
+
+    output_path_str = str(output_path)
+    pages_to_extract: List["Page"] = []
+
+    # Determine the list of pages and the source PDF path
+    if hasattr(source, "pages") and isinstance(source.pages, list):  # PDF or PageCollection
+        if not source.pages:
+            raise ValueError("Cannot save an empty collection/PDF.")
+        pages_to_extract = source.pages
+    elif hasattr(source, "page") and hasattr(source, "number"):  # Single Page object
+        # Check if it's a natural_pdf.core.page.Page or similar duck-typed object
+        if hasattr(source, "pdf") and source.pdf and hasattr(source.pdf, "path"):
+            pages_to_extract = [source]
+        else:
+            raise ValueError("Input Page object does not have a valid PDF reference with a path.")
+    else:
+        raise TypeError(f"Unsupported source type for create_original_pdf: {type(source)}")
+
+    if not pages_to_extract:
+        raise ValueError("No valid pages found in the source object.")
+
+    # Verify all pages come from the same PDF and get path
+    first_page_pdf_path = None
+    if hasattr(pages_to_extract[0], "pdf") and pages_to_extract[0].pdf:
+        first_page_pdf_path = getattr(pages_to_extract[0].pdf, "path", None)
+
+    if not first_page_pdf_path:
+        raise ValueError(
+            "Cannot save original pages: Source PDF path not found for the first page."
+        )
+
+    page_indices_set: Set[int] = set()
+    for page in pages_to_extract:
+        page_pdf_path = getattr(getattr(page, "pdf", None), "path", None)
+        if not page_pdf_path or page_pdf_path != first_page_pdf_path:
+            raise ValueError(
+                "Cannot save original pages: All pages must belong to the same source PDF document."
+            )
+        page_indices_set.add(page.index)  # 0-based index
+
+    sorted_indices = sorted(list(page_indices_set))
+
+    logger.info(
+        f"Extracting original pages {sorted_indices} from '{first_page_pdf_path}' to '{output_path_str}'"
+    )
+
+    try:
+        with pikepdf.Pdf.open(first_page_pdf_path) as source_pikepdf_doc:
+            target_pikepdf_doc = pikepdf.Pdf.new()
+
+            for page_index in sorted_indices:
+                if 0 <= page_index < len(source_pikepdf_doc.pages):
+                    # This correctly appends the pikepdf.Page object
+                    target_pikepdf_doc.pages.append(source_pikepdf_doc.pages[page_index])
+                else:
+                    logger.warning(
+                        f"Page index {page_index} out of bounds for source PDF '{first_page_pdf_path}'. Skipping."
+                    )
+
+            if not target_pikepdf_doc.pages:
+                raise RuntimeError(f"No valid pages found to save from source PDF.")
+
+            target_pikepdf_doc.save(output_path_str)
+            logger.info(
+                f"Successfully saved original pages PDF ({len(target_pikepdf_doc.pages)} pages) to: {output_path_str}"
+            )
+
+    except pikepdf.PasswordError:
+        logger.error(f"Failed to open password-protected source PDF: {first_page_pdf_path}")
+        raise RuntimeError(
+            f"Source PDF '{first_page_pdf_path}' is password-protected."
+        ) from None  # Raise specific error without chaining the generic Exception
+    except Exception as e:
+        logger.error(
+            f"Failed to save original pages PDF to '{output_path_str}': {e}",
+            exc_info=True,
+        )
+        # Re-raise as RuntimeError for consistent API error handling
+        raise RuntimeError(f"Failed to save original pages PDF: {e}") from e

natural_pdf/exporters/searchable_pdf.py

@@ -22,7 +22,7 @@ except ImportError:
     pikepdf = None  # type: ignore
 
 try:
-    from ocrmypdf.hocrtransform import HocrTransform
+    from natural_pdf.exporters.hocr import HocrTransform
 except ImportError:
     HocrTransform = None  # type: ignore
 
@@ -310,7 +310,7 @@ def create_searchable_pdf(
     """
     Creates a searchable PDF from a natural_pdf.PDF object using OCR results.
 
-    Relies on ocrmypdf for hOCR transformation. Requires optional dependencies.
+    Relies on pikepdf for saving the PDF.
 
     Args:
         source: The natural_pdf.PDF, PageCollection, or Page object
@@ -318,16 +318,6 @@ def create_searchable_pdf(
         dpi: The resolution (dots per inch) for rendering page images and hOCR.
     """
 
-    # --- Ensure dependencies are loaded (they should be if installed) ---
-    if Image is None or pikepdf is None or HocrTransform is None:
-        # This should ideally not happen if dependencies are in main install,
-        # but serves as a safeguard during development or if install is broken.
-        raise ImportError(
-            "Required dependencies (Pillow, pikepdf, ocrmypdf) are missing. "
-            "Please ensure natural-pdf is installed correctly with all dependencies."
-        )
-    # --- End Safeguard Check ---
-
     # duck type to see if source has .pages, to populate pages =
     if hasattr(source, "pages"):
         pages = source.pages

natural_pdf/ocr/engine_surya.py

@@ -59,7 +59,7 @@ class SuryaOCREngine(OCREngine):
 
         # Store languages instance variable during initialization to use here
         langs = (
-            [[lang] for lang in self._langs]
+            [self._langs]  # Send all languages together in one list per image
             if hasattr(self, "_langs")
             else [[self.DEFAULT_LANGUAGES[0]]]
         )

natural_pdf/search/__init__.py

@@ -3,29 +3,46 @@
 import logging
 from typing import Optional
 
-# --- Service Implementation Import ---
-# Import the concrete implementation
-from .haystack_search_service import HaystackSearchService
-
-# --- Utils Import ---
-from .haystack_utils import (  # Re-export flag and helper
-    HAS_HAYSTACK_EXTRAS,
-    check_haystack_availability,
-)
-
-# --- Option Imports (for convenience) ---
-# Make options easily available via `from natural_pdf.search import ...`
-from .search_options import SearchOptions  # Alias for TextSearchOptions for simplicity?
+# Import constants
+from .search_options import SearchOptions 
 from .search_options import BaseSearchOptions, MultiModalSearchOptions, TextSearchOptions
-
-# --- Protocol Import ---
-# Import the protocol for type hinting
 from .search_service_protocol import Indexable, IndexConfigurationError, SearchServiceProtocol
 
+# Check search extras availability
+LANCEDB_AVAILABLE = False
+SEARCH_DEPENDENCIES_AVAILABLE = False
+
+try:
+    import sentence_transformers
+    import numpy as np
+    # Basic search dependencies are available
+    SEARCH_DEPENDENCIES_AVAILABLE = True
+    
+    # Check if LanceDB is available
+    try:
+        import lancedb
+        import pyarrow
+        LANCEDB_AVAILABLE = True
+        from .lancedb_search_service import LanceDBSearchService, DEFAULT_LANCEDB_PERSIST_PATH, DEFAULT_EMBEDDING_MODEL
+    except ImportError:
+        # LanceDB not available, we'll use NumPy fallback
+        LANCEDB_AVAILABLE = False
+        from .numpy_search_service import NumpySearchService, DEFAULT_EMBEDDING_MODEL
+except ImportError:
+    # Basic dependencies missing
+    SEARCH_DEPENDENCIES_AVAILABLE = False
+    LANCEDB_AVAILABLE = False
+
 logger = logging.getLogger(__name__)
 
+def check_search_availability():
+    """Check if required search dependencies are available."""
+    if not SEARCH_DEPENDENCIES_AVAILABLE:
+        raise ImportError(
+            "Search functionality requires 'sentence-transformers' and NumPy. "
+            "Install with: pip install natural-pdf[search] (or pip install sentence-transformers numpy)"
+        )
 
-# Factory Function
 def get_search_service(
     collection_name: str,
     persist: bool = False,
@@ -34,53 +51,49 @@ def get_search_service(
 ) -> SearchServiceProtocol:
     """
     Factory function to get an instance of the configured search service.
-
-    A service instance is tied to a specific index name (collection/table).
-
-    Currently, only returns HaystackSearchService but is structured for future extension.
+    
+    Automatically selects the best available implementation:
+    - LanceDB if installed (recommended for both in-memory and persistent)
+    - Numpy fallback for in-memory only
 
     Args:
-        collection_name: The logical name for the index this service instance manages
-                         (used as table_name for LanceDB).
+        collection_name: The logical name for the index/table this service instance manages.
         persist: If True, creates a service instance configured for persistent
-                 storage (currently LanceDB). If False (default), uses InMemory.
-        uri: Override the default path/URI for persistent storage.
+                 storage. If False (default), uses InMemory (via temp dir for LanceDB).
+        uri: Override the default path for persistent storage.
         default_embedding_model: Override the default embedding model used by the service.
-        **kwargs: Reserved for future configuration options.
 
     Returns:
-        An instance conforming to the SearchServiceProtocol for the specified collection/table.
+        An instance conforming to the SearchServiceProtocol.
     """
     logger.debug(
-        f"Calling get_search_service factory for index '{collection_name}' (persist={persist}, uri={uri})..."
+        f"Calling get_search_service factory for collection '{collection_name}' (persist={persist}, uri={uri})..."
     )
+    check_search_availability()
 
-    # Collect arguments relevant to HaystackSearchService.__init__
-    service_args = {}
-    service_args["table_name"] = collection_name
-    service_args["persist"] = persist
+    service_args = {
+        "collection_name": collection_name,
+        "persist": persist,
+    }
     if uri is not None:
         service_args["uri"] = uri
-    if default_embedding_model is not None:
-        service_args["embedding_model"] = default_embedding_model
 
-    # Cache logic commented out as before
+    if default_embedding_model is not None:
+        service_args["embedding_model_name"] = default_embedding_model
 
-    try:
-        service_instance = HaystackSearchService(**service_args)
-        logger.info(f"Created new HaystackSearchService instance for index '{collection_name}'.")
-        return service_instance
-    except ImportError as e:
-        # Error message remains valid
-        logger.error(
-            f"Failed to instantiate Search Service due to missing dependencies: {e}", exc_info=True
+    # If persistence is requested, LanceDB is required
+    if persist and not LANCEDB_AVAILABLE:
+        raise RuntimeError(
+            "Persistent vector search requires LanceDB. "
+            "Please install: pip install lancedb"
         )
-        raise ImportError(
-            "Search Service could not be created. Ensure Haystack extras are installed: pip install natural-pdf[haystack]"
-        ) from e
-    except Exception as e:
-        logger.error(f"Failed to instantiate Search Service: {e}", exc_info=True)
-        raise RuntimeError("Could not create Search Service instance.") from e
-
-
-# Default instance commented out as before
+    
+    # Select the appropriate implementation
+    if LANCEDB_AVAILABLE:
+        logger.info(f"Using LanceDB for vector search (collection: {collection_name})")
+        service_instance = LanceDBSearchService(**service_args)
+    else:
+        logger.info(f"Using NumPy fallback for in-memory vector search (collection: {collection_name})")
+        service_instance = NumpySearchService(**service_args)
+        
+    return service_instance

natural_pdf/search/lancedb_search_service.py

@@ -0,0 +1,325 @@
+import logging
+import shutil
+import tempfile
+from pathlib import Path
+from typing import Any, Dict, Iterable, List, Optional
+
+import lancedb
+import pyarrow as pa
+from sentence_transformers import SentenceTransformer
+
+from .search_options import BaseSearchOptions
+from .search_service_protocol import (
+    Indexable,
+    IndexConfigurationError,
+    SearchServiceProtocol,
+)
+
+logger = logging.getLogger(__name__)
+
+DEFAULT_EMBEDDING_MODEL = "sentence-transformers/all-MiniLM-L6-v2"
+DEFAULT_LANCEDB_PERSIST_PATH = "./natural_pdf_lancedb_index"
+
+
+class LanceDBSearchService(SearchServiceProtocol):
+    """LanceDB-based implementation of the search service protocol."""
+
+    collection_name: str
+
+    def __init__(
+        self,
+        collection_name: str,
+        persist: bool = False,
+        uri: Optional[str] = None,
+        embedding_model_name: str = DEFAULT_EMBEDDING_MODEL,
+    ):
+        self.collection_name = collection_name
+        self._persist = persist
+        self._uri = uri
+        self._embedding_model_name = embedding_model_name
+        self._embedding_dims: Optional[int] = None
+        self._db = None
+        self._table = None
+
+        self.embedding_model = SentenceTransformer(self._embedding_model_name)
+        test_embedding = self.embedding_model.encode("test")
+        self._embedding_dims = len(test_embedding)
+
+        if self._persist:
+            self._uri = self._uri if self._uri else DEFAULT_LANCEDB_PERSIST_PATH
+            logger.info(f"Initializing Persistent LanceDB client at path: {self._uri}")
+            Path(self._uri).mkdir(parents=True, exist_ok=True)
+        else:
+            self._temp_dir_obj = tempfile.TemporaryDirectory()
+            self._uri = self._temp_dir_obj.name
+            logger.info(f"Initializing In-Memory LanceDB client using temp path: {self._uri}")
+
+        self._db = lancedb.connect(self._uri)
+        self._open_or_create_table()
+        logger.info(
+            f"LanceDBSearchService initialized. Table '{self.collection_name}' (persist={self._persist} at '{self._uri}'). Model: '{self._embedding_model_name}', Dims: {self._embedding_dims}"
+        )
+
+    def _get_schema(self) -> pa.Schema:
+        if self._embedding_dims is None:
+            raise RuntimeError("Embedding dimensions not determined. Cannot create schema.")
+        
+        return pa.schema([
+            pa.field("id", pa.string(), nullable=False),
+            pa.field("vector", pa.list_(pa.float32(), list_size=self._embedding_dims)),
+            pa.field("text", pa.string()),
+            pa.field("metadata_json", pa.string())
+        ])
+
+    def _open_or_create_table(self):
+        if self._db is None:
+            raise RuntimeError("LanceDB connection not established.")
+            
+        table_names = self._db.table_names()
+        
+        if self.collection_name in table_names:
+            logger.debug(f"Opening existing LanceDB table: {self.collection_name}")
+            self._table = self._db.open_table(self.collection_name)
+        else:
+            logger.debug(f"Creating new LanceDB table: {self.collection_name} with schema.")
+            schema = self._get_schema()
+            self._table = self._db.create_table(self.collection_name, schema=schema, mode="create")
+
+    def __del__(self):
+        if not self._persist and hasattr(self, '_temp_dir_obj') and logger:
+            logger.debug(f"Cleaning up temporary directory for in-memory LanceDB: {self._uri}")
+            self._temp_dir_obj.cleanup()
+
+    def index(
+        self,
+        documents: Iterable[Indexable],
+        embedder_device: Optional[str] = None,
+        force_reindex: bool = False,
+    ) -> None:
+        indexable_list = list(documents)
+        logger.info(
+            f"Index request for table='{self.collection_name}', docs={len(indexable_list)}, model='{self._embedding_model_name}', force={force_reindex}"
+        )
+
+        if self._table is None or self._db is None:
+            raise RuntimeError(f"LanceDB table '{self.collection_name}' not initialized.")
+
+        if not indexable_list:
+            logger.warning("No documents provided for indexing. Skipping.")
+            return
+
+        if force_reindex:
+            logger.warning(
+                f"Force reindex requested for table '{self.collection_name}'. Deleting existing table and recreating."
+            )
+            self._db.drop_table(self.collection_name)
+            self._open_or_create_table()
+            logger.info(f"Table '{self.collection_name}' deleted and recreated.")
+
+        data_to_add = []
+        texts_to_embed: List[str] = []
+        original_items_info: List[Dict[str, Any]] = []
+
+        import json
+
+        for item in indexable_list:
+            doc_id = item.get_id()
+            metadata = item.get_metadata().copy()
+            content_obj = item.get_content()
+            content_text = ""
+
+            if isinstance(content_obj, str):
+                content_text = content_obj
+            elif hasattr(content_obj, "extract_text") and callable(getattr(content_obj, "extract_text")):
+                content_text = content_obj.extract_text()
+                if not isinstance(content_text, str): content_text = str(content_obj)
+            else:
+                content_text = str(content_obj)
+
+            try:
+                content_hash = item.get_content_hash()
+                if content_hash: metadata["content_hash"] = content_hash
+            except (AttributeError, NotImplementedError): pass
+            except Exception as e: logger.warning(f"Error getting content_hash for item ID '{doc_id}': {e}")
+
+            # Ensure doc_id is not None - use a fallback if needed
+            if doc_id is None:
+                # Generate a unique ID based on content hash or position in the list
+                try:
+                    doc_id = f"auto_{item.get_content_hash() if hasattr(item, 'get_content_hash') else hash(content_text)}"
+                except:
+                    doc_id = f"auto_{len(texts_to_embed)}"
+
+            texts_to_embed.append(content_text)
+            original_items_info.append({
+                "id": doc_id,
+                "metadata_json": json.dumps(metadata),
+                "text": content_text
+            })
+
+        if not texts_to_embed:
+            logger.warning("No text content to embed. Skipping.")
+            return
+
+        logger.info(f"Embedding {len(texts_to_embed)} documents using '{self._embedding_model_name}'...")
+        generated_embeddings = self.embedding_model.encode(
+            texts_to_embed, device=embedder_device, show_progress_bar=len(texts_to_embed) > 10
+        )
+
+        for i, item_info in enumerate(original_items_info):
+            data_to_add.append({
+                "id": item_info["id"],
+                "vector": generated_embeddings[i].tolist(),
+                "text": item_info["text"],
+                "metadata_json": item_info["metadata_json"]
+            })
+
+        if not data_to_add:
+            logger.warning("No data prepared for LanceDB. Skipping add.")
+            return
+
+        # Create a PyArrow table with the same schema as the LanceDB table
+        schema = self._get_schema()
+        arrays = [
+            pa.array([item["id"] for item in data_to_add], type=pa.string()),
+            pa.array([item["vector"] for item in data_to_add]),
+            pa.array([item["text"] for item in data_to_add], type=pa.string()),
+            pa.array([item["metadata_json"] for item in data_to_add], type=pa.string()),
+        ]
+        table = pa.Table.from_arrays(arrays, schema=schema)
+
+        logger.info(f"Adding/updating {len(data_to_add)} documents to LanceDB table '{self.collection_name}'.")
+        self._table.merge_insert("id").when_matched_update_all().when_not_matched_insert_all().execute(
+            table,
+        )
+        logger.info(f"Successfully added/updated {len(data_to_add)} documents. Table count: {self._table.count_rows()}")
+
+    def search(
+        self,
+        query: Any,
+        options: BaseSearchOptions,
+    ) -> List[Dict[str, Any]]:
+        if self._table is None:
+            raise RuntimeError(f"LanceDB table '{self.collection_name}' not initialized.")
+
+        logger.info(f"Search request for table='{self.collection_name}', query_type={type(query).__name__}, options={options}")
+        query_text = ""
+        if isinstance(query, (str, Path)): query_text = str(query)
+        elif hasattr(query, "extract_text") and callable(getattr(query, "extract_text")):
+            query_text = query.extract_text()
+            if not query_text or not query_text.strip(): return []
+        else:
+            raise TypeError(f"Unsupported query type: {type(query)}")
+
+        query_vector = self.embedding_model.encode(query_text).tolist()
+
+        lancedb_filter = None
+        if options.filters:
+            if isinstance(options.filters, str):
+                lancedb_filter = options.filters
+            elif isinstance(options.filters, dict):
+                filter_parts = []
+                for k, v in options.filters.items():
+                    if isinstance(v, str):
+                        filter_parts.append(f"{k} = '{v}'")
+                    else:
+                        filter_parts.append(f"{k} = {v}")
+                if filter_parts:
+                    lancedb_filter = " AND ".join(filter_parts)
+                logger.warning(f"Filter conversion from dict is basic: {options.filters} -> {lancedb_filter}. For metadata_json, use SQL path expressions.")
+
+        search_query = self._table.search(query_vector).limit(options.top_k)
+        if lancedb_filter:
+            search_query = search_query.where(lancedb_filter)
+
+        results_df = search_query.to_df()
+        final_results: List[Dict[str, Any]] = []
+        import json
+
+        for _, row in results_df.iterrows():
+            metadata = {}
+            if "metadata_json" in row and row["metadata_json"]:
+                try:
+                    metadata = json.loads(row["metadata_json"])
+                except json.JSONDecodeError:
+                    logger.warning(f"Failed to parse metadata_json for id {row.get('id')}")
+
+            score = 1 - row["_distance"] if "_distance" in row else 0.0
+
+            final_results.append({
+                "id": row.get("id"),
+                "content_snippet": row["text"][:200] if "text" in row and row["text"] else "",
+                "score": score,
+                "page_number": metadata.get("page_number"),
+                "pdf_path": metadata.get("pdf_path"),
+                "metadata": metadata,
+            })
+        logger.info(f"Search returned {len(final_results)} results from LanceDB table '{self.collection_name}'.")
+        return final_results
+
+    def delete_index(self) -> bool:
+        if self._db is None:
+            logger.warning("LanceDB connection not initialized. Cannot delete index.")
+            return False
+        logger.warning(f"Request to delete LanceDB table '{self.collection_name}'.")
+        
+        self._db.drop_table(self.collection_name)
+        self._table = None
+        logger.info(f"LanceDB table '{self.collection_name}' deleted successfully.")
+        return True
+
+    def index_exists(self) -> bool:
+        if self._db is None: 
+            return False
+        exists = self.collection_name in self._db.table_names()
+        if exists:
+            tbl = self._db.open_table(self.collection_name)
+            count = tbl.count_rows()
+            logger.debug(f"LanceDB table '{self.collection_name}' found with {count} documents. Exists: {count > 0}")
+            return count > 0
+        
+        logger.debug(f"LanceDB table '{self.collection_name}' not found in db.table_names().")
+        return False
+
+    def list_documents(self, include_metadata: bool = False, **kwargs) -> List[Dict]:
+        if self._table is None: 
+            raise RuntimeError("Table not initialized")
+        logger.debug(f"Listing documents for LanceDB table '{self.collection_name}' (include_metadata={include_metadata})...")
+
+        select_columns = ["id"]
+        if include_metadata:
+            select_columns.append("metadata_json")
+
+        lancedb_filter = kwargs.get("filters")
+
+        query = self._table.to_lance().scanner(columns=select_columns, filter=lancedb_filter)
+        results_table = query.to_table()
+        results_list = results_table.to_pylist()
+
+        formatted_docs: List[Dict[str, Any]] = []
+        import json
+        for row in results_list:
+            doc_data: Dict[str, Any] = {"id": row.get("id")}
+            if include_metadata and "metadata_json" in row and row["metadata_json"]:
+                try:
+                    metadata = json.loads(row["metadata_json"])
+                    doc_data["meta"] = metadata
+                except json.JSONDecodeError:
+                    doc_data["meta"] = {}
+            formatted_docs.append(doc_data)
+        logger.info(f"Retrieved {len(formatted_docs)} documents from LanceDB table '{self.collection_name}'.")
+        return formatted_docs
+
+    def delete_documents(self, ids: List[str]) -> None:
+        if self._table is None: 
+            raise RuntimeError("Table not initialized")
+        if not ids:
+            logger.debug("No document IDs provided for deletion. Skipping.")
+            return
+
+        id_filter_string = ", ".join([f"'{doc_id}'" for doc_id in ids])
+        delete_condition = f"id IN ({id_filter_string})"
+        logger.warning(f"Request to delete {len(ids)} documents from LanceDB table '{self.collection_name}' with condition: {delete_condition}")
+        
+        self._table.delete(delete_condition)
+        logger.info(f"Successfully requested deletion of {len(ids)} documents. Table count now: {self._table.count_rows()}")