kreuzberg 4.0.0.pre.rc.29 → 4.0.0.rc1

data/vendor/kreuzberg/src/pdf/metadata.rs

@@ -1,99 +1,52 @@
-use super::bindings::bind_pdfium;
 use super::error::{PdfError, Result};
-use crate::types::{PageBoundary, PageInfo, PageStructure, PageUnitType};
 use pdfium_render::prelude::*;
 use serde::{Deserialize, Serialize};
 
-/// PDF-specific metadata.
-///
-/// Contains metadata fields specific to PDF documents that are not in the common
-/// `Metadata` structure. Common fields like title, authors, keywords, and dates
-/// are now at the `Metadata` level.
 #[derive(Debug, Clone, Serialize, Deserialize, Default)]
 pub struct PdfMetadata {
-    /// PDF version (e.g., "1.7", "2.0")
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub pdf_version: Option<String>,
-
-    /// PDF producer (application that created the PDF)
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub producer: Option<String>,
-
-    /// Whether the PDF is encrypted/password-protected
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub is_encrypted: Option<bool>,
-
-    /// First page width in points (1/72 inch)
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub width: Option<i64>,
-
-    /// First page height in points (1/72 inch)
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub height: Option<i64>,
-
-    /// Total number of pages in the PDF document
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub page_count: Option<usize>,
-}
-
-/// Complete PDF extraction metadata including common and PDF-specific fields.
-///
-/// This struct combines common document fields (title, authors, dates) with
-/// PDF-specific metadata and optional page structure information. It is returned
-/// by `extract_metadata_from_document()` when page boundaries are provided.
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct PdfExtractionMetadata {
-    /// Document title
     #[serde(skip_serializing_if = "Option::is_none")]
     pub title: Option<String>,
-
-    /// Document subject or description
     #[serde(skip_serializing_if = "Option::is_none")]
     pub subject: Option<String>,
-
-    /// Document authors (parsed from PDF Author field)
     #[serde(skip_serializing_if = "Option::is_none")]
     pub authors: Option<Vec<String>>,
-
-    /// Document keywords (parsed from PDF Keywords field)
     #[serde(skip_serializing_if = "Option::is_none")]
     pub keywords: Option<Vec<String>>,
-
-    /// Creation timestamp (ISO 8601 format)
     #[serde(skip_serializing_if = "Option::is_none")]
     pub created_at: Option<String>,
-
-    /// Last modification timestamp (ISO 8601 format)
     #[serde(skip_serializing_if = "Option::is_none")]
     pub modified_at: Option<String>,
-
-    /// Application or user that created the document
     #[serde(skip_serializing_if = "Option::is_none")]
     pub created_by: Option<String>,
-
-    /// PDF-specific metadata
-    pub pdf_specific: PdfMetadata,
-
-    /// Page structure with boundaries and optional per-page metadata
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub page_structure: Option<PageStructure>,
+    pub producer: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub page_count: Option<usize>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub pdf_version: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub is_encrypted: Option<bool>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub width: Option<i64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub height: Option<i64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub summary: Option<String>,
 }
 
-/// Extract PDF-specific metadata from raw bytes.
-///
-/// Returns only PDF-specific metadata (version, producer, encryption status, dimensions).
 pub fn extract_metadata(pdf_bytes: &[u8]) -> Result<PdfMetadata> {
     extract_metadata_with_password(pdf_bytes, None)
 }
 
-/// Extract PDF-specific metadata from raw bytes with optional password.
-///
-/// Returns only PDF-specific metadata (version, producer, encryption status, dimensions).
 pub fn extract_metadata_with_password(pdf_bytes: &[u8], password: Option<&str>) -> Result<PdfMetadata> {
-    let pdfium = bind_pdfium(PdfError::MetadataExtractionFailed, "metadata extraction")?;
+    let bindings = Pdfium::bind_to_library(Pdfium::pdfium_platform_library_name_at_path("./"))
+        .or_else(|_| Pdfium::bind_to_system_library())
+        .map_err(|e| PdfError::MetadataExtractionFailed(format!("Failed to initialize Pdfium: {}", e)))?;
+
+    let pdfium = Pdfium::new(bindings);
 
     let document = pdfium.load_pdf_from_byte_slice(pdf_bytes, password).map_err(|e| {
-        let err_msg = super::error::format_pdfium_error(e);
+        let err_msg = e.to_string();
         if (err_msg.contains("password") || err_msg.contains("Password")) && password.is_some() {
             PdfError::InvalidPassword
         } else if err_msg.contains("password") || err_msg.contains("Password") {
@@ -103,7 +56,7 @@ pub fn extract_metadata_with_password(pdf_bytes: &[u8], password: Option<&str>)
         }
     })?;
 
-    extract_pdf_specific_metadata(&document)
+    extract_metadata_from_document(&document)
 }
 
 pub fn extract_metadata_with_passwords(pdf_bytes: &[u8], passwords: &[&str]) -> Result<PdfMetadata> {
@@ -126,215 +79,70 @@ pub fn extract_metadata_with_passwords(pdf_bytes: &[u8], passwords: &[&str]) ->
     extract_metadata(pdf_bytes)
 }
 
-/// Extract complete PDF metadata from a document.
-///
-/// Extracts common fields (title, subject, authors, keywords, dates, creator),
-/// PDF-specific metadata, and optionally builds a PageStructure with boundaries.
-///
-/// # Arguments
-///
-/// * `document` - The PDF document to extract metadata from
-/// * `page_boundaries` - Optional vector of PageBoundary entries for building PageStructure.
-///   If provided, a PageStructure will be built with these boundaries.
-///
-/// # Returns
-///
-/// Returns a `PdfExtractionMetadata` struct containing all extracted metadata,
-/// including page structure if boundaries were provided.
-pub fn extract_metadata_from_document(
-    document: &PdfDocument<'_>,
-    page_boundaries: Option<&[PageBoundary]>,
-) -> Result<PdfExtractionMetadata> {
-    extract_metadata_from_document_impl(document, page_boundaries)
-}
-
-/// Internal implementation of metadata extraction that can be reused by unified extraction.
-pub(crate) fn extract_metadata_from_document_impl(
-    document: &PdfDocument<'_>,
-    page_boundaries: Option<&[PageBoundary]>,
-) -> Result<PdfExtractionMetadata> {
-    let pdf_specific = extract_pdf_specific_metadata(document)?;
-
-    let common = extract_common_metadata_from_document(document)?;
-
-    let page_structure = if let Some(boundaries) = page_boundaries {
-        Some(build_page_structure(document, boundaries)?)
-    } else {
-        None
-    };
-
-    Ok(PdfExtractionMetadata {
-        title: common.title,
-        subject: common.subject,
-        authors: common.authors,
-        keywords: common.keywords,
-        created_at: common.created_at,
-        modified_at: common.modified_at,
-        created_by: common.created_by,
-        pdf_specific,
-        page_structure,
-    })
-}
-
-/// Extract PDF-specific metadata from a document.
-///
-/// Returns only PDF-specific metadata (version, producer, encryption status, dimensions).
-fn extract_pdf_specific_metadata(document: &PdfDocument<'_>) -> Result<PdfMetadata> {
+pub(crate) fn extract_metadata_from_document(document: &PdfDocument<'_>) -> Result<PdfMetadata> {
     let pdf_metadata = document.metadata();
 
     let mut metadata = PdfMetadata {
         pdf_version: format_pdf_version(document.version()),
         ..Default::default()
     };
-
+    metadata.page_count = Some(document.pages().len() as usize);
     metadata.is_encrypted = document
         .permissions()
         .security_handler_revision()
         .ok()
         .map(|revision| revision != PdfSecurityHandlerRevision::Unprotected);
 
-    metadata.producer = pdf_metadata
-        .get(PdfDocumentMetadataTagType::Producer)
+    metadata.title = pdf_metadata
+        .get(PdfDocumentMetadataTagType::Title)
         .map(|tag| tag.value().to_string());
 
-    if !document.pages().is_empty()
-        && let Ok(page_rect) = document.pages().page_size(0)
-    {
-        metadata.width = Some(page_rect.width().value.round() as i64);
-        metadata.height = Some(page_rect.height().value.round() as i64);
-    }
-
-    // Always capture page count
-    metadata.page_count = Some(document.pages().len() as usize);
-
-    Ok(metadata)
-}
+    metadata.subject = pdf_metadata
+        .get(PdfDocumentMetadataTagType::Subject)
+        .map(|tag| tag.value().to_string());
 
-/// Build a PageStructure from a document and page boundaries.
-///
-/// Constructs a complete PageStructure including:
-/// - Total page count
-/// - Unit type (Page)
-/// - Character offset boundaries for each page
-/// - Optional per-page metadata with dimensions
-///
-/// # Validation
-///
-/// - Boundaries must not be empty
-/// - Boundary count must match the document's page count
-fn build_page_structure(document: &PdfDocument<'_>, boundaries: &[PageBoundary]) -> Result<PageStructure> {
-    let total_count = document.pages().len() as usize;
-
-    if boundaries.is_empty() {
-        return Err(PdfError::MetadataExtractionFailed(
-            "No page boundaries provided for PageStructure".to_string(),
-        ));
+    if let Some(author_tag) = pdf_metadata.get(PdfDocumentMetadataTagType::Author) {
+        let authors = parse_authors(author_tag.value());
+        if !authors.is_empty() {
+            metadata.authors = Some(authors);
+        }
     }
 
-    if boundaries.len() != total_count {
-        return Err(PdfError::MetadataExtractionFailed(format!(
-            "Boundary count {} doesn't match page count {}",
-            boundaries.len(),
-            total_count
-        )));
+    if let Some(keywords_tag) = pdf_metadata.get(PdfDocumentMetadataTagType::Keywords) {
+        let keywords = parse_keywords(keywords_tag.value());
+        if !keywords.is_empty() {
+            metadata.keywords = Some(keywords);
+        }
     }
 
-    let mut pages = Vec::new();
-    for (index, boundary) in boundaries.iter().enumerate() {
-        let page_number = boundary.page_number;
-
-        let dimensions = if let Ok(page_rect) = document.pages().page_size(index as i32) {
-            Some((page_rect.width().value as f64, page_rect.height().value as f64))
-        } else {
-            None
-        };
-
-        pages.push(PageInfo {
-            number: page_number,
-            title: None,
-            dimensions,
-            image_count: None,
-            table_count: None,
-            hidden: None,
-        });
+    if let Some(created_tag) = pdf_metadata.get(PdfDocumentMetadataTagType::CreationDate) {
+        metadata.created_at = Some(parse_pdf_date(created_tag.value()));
     }
 
-    Ok(PageStructure {
-        total_count,
-        unit_type: PageUnitType::Page,
-        boundaries: Some(boundaries.to_vec()),
-        pages: if pages.is_empty() { None } else { Some(pages) },
-    })
-}
-
-/// Extract common metadata from a PDF document.
-///
-/// Returns common fields (title, authors, keywords, dates) that are now stored
-/// in the base `Metadata` struct instead of format-specific metadata.
-///
-/// This function uses batch fetching with caching to optimize metadata extraction
-/// by reducing repeated dictionary lookups. All metadata tags are fetched once and
-/// cached in a single pass.
-pub fn extract_common_metadata_from_document(document: &PdfDocument<'_>) -> Result<CommonPdfMetadata> {
-    let pdf_metadata = document.metadata();
-
-    let tag_types = [
-        PdfDocumentMetadataTagType::Title,
-        PdfDocumentMetadataTagType::Subject,
-        PdfDocumentMetadataTagType::Author,
-        PdfDocumentMetadataTagType::Keywords,
-        PdfDocumentMetadataTagType::CreationDate,
-        PdfDocumentMetadataTagType::ModificationDate,
-        PdfDocumentMetadataTagType::Creator,
-    ];
-
-    let mut metadata_cache: [Option<String>; 7] = Default::default();
-    for (index, tag_type) in tag_types.iter().enumerate() {
-        if let Some(tag) = pdf_metadata.get(*tag_type) {
-            metadata_cache[index] = Some(tag.value().to_string());
-        }
+    if let Some(modified_tag) = pdf_metadata.get(PdfDocumentMetadataTagType::ModificationDate) {
+        metadata.modified_at = Some(parse_pdf_date(modified_tag.value()));
     }
 
-    let title = metadata_cache[0].clone();
-
-    let subject = metadata_cache[1].clone();
-
-    let authors = metadata_cache[2]
-        .as_ref()
-        .map(|author_str| parse_authors(author_str))
-        .and_then(|parsed| if !parsed.is_empty() { Some(parsed) } else { None });
-
-    let keywords = metadata_cache[3]
-        .as_ref()
-        .map(|keywords_str| parse_keywords(keywords_str))
-        .and_then(|parsed| if !parsed.is_empty() { Some(parsed) } else { None });
-
-    let created_at = metadata_cache[4].as_ref().map(|date_str| parse_pdf_date(date_str));
+    metadata.created_by = pdf_metadata
+        .get(PdfDocumentMetadataTagType::Creator)
+        .map(|tag| tag.value().to_string());
 
-    let modified_at = metadata_cache[5].as_ref().map(|date_str| parse_pdf_date(date_str));
+    metadata.producer = pdf_metadata
+        .get(PdfDocumentMetadataTagType::Producer)
+        .map(|tag| tag.value().to_string());
 
-    let created_by = metadata_cache[6].clone();
+    if !document.pages().is_empty()
+        && let Ok(page_rect) = document.pages().page_size(0)
+    {
+        metadata.width = Some(page_rect.width().value.round() as i64);
+        metadata.height = Some(page_rect.height().value.round() as i64);
+    }
 
-    Ok(CommonPdfMetadata {
-        title,
-        subject,
-        authors,
-        keywords,
-        created_at,
-        modified_at,
-        created_by,
-    })
-}
+    if metadata.summary.is_none() {
+        metadata.summary = Some(generate_summary(&metadata));
+    }
 
-/// Common metadata fields extracted from a PDF.
-pub struct CommonPdfMetadata {
-    pub title: Option<String>,
-    pub subject: Option<String>,
-    pub authors: Option<Vec<String>>,
-    pub keywords: Option<Vec<String>>,
-    pub created_at: Option<String>,
-    pub modified_at: Option<String>,
-    pub created_by: Option<String>,
+    Ok(metadata)
 }
 
 fn parse_authors(author_str: &str) -> Vec<String> {
@@ -398,6 +206,25 @@ fn parse_pdf_date(date_str: &str) -> String {
     }
 }
 
+fn generate_summary(metadata: &PdfMetadata) -> String {
+    let mut parts = Vec::new();
+
+    if let Some(page_count) = metadata.page_count {
+        let plural = if page_count != 1 { "s" } else { "" };
+        parts.push(format!("PDF document with {} page{}.", page_count, plural));
+    }
+
+    if let Some(ref version) = metadata.pdf_version {
+        parts.push(format!("PDF version {}.", version));
+    }
+
+    if metadata.is_encrypted == Some(true) {
+        parts.push("Document is encrypted.".to_string());
+    }
+
+    parts.join(" ")
+}
+
 fn format_pdf_version(version: PdfDocumentVersion) -> Option<String> {
     match version {
         PdfDocumentVersion::Unset => None,
@@ -485,25 +312,35 @@ mod tests {
     }
 
     #[test]
-    fn test_extract_metadata_invalid_pdf() {
-        let result = extract_metadata(b"not a pdf");
-        assert!(result.is_err());
+    fn test_generate_summary() {
+        let metadata = PdfMetadata {
+            page_count: Some(10),
+            pdf_version: Some("1.7".to_string()),
+            is_encrypted: Some(false),
+            ..Default::default()
+        };
+
+        let summary = generate_summary(&metadata);
+        assert!(summary.contains("10 pages"));
+        assert!(summary.contains("1.7"));
+        assert!(!summary.contains("encrypted"));
     }
 
     #[test]
-    fn test_build_page_structure_empty_boundaries() {
-        let result_msg = "No page boundaries provided for PageStructure".to_string();
-        assert!(!result_msg.is_empty());
+    fn test_generate_summary_single_page() {
+        let metadata = PdfMetadata {
+            page_count: Some(1),
+            ..Default::default()
+        };
+
+        let summary = generate_summary(&metadata);
+        assert!(summary.contains("1 page."));
+        assert!(!summary.contains("pages"));
     }
 
     #[test]
-    fn test_build_page_structure_boundary_mismatch_message() {
-        let boundaries_count = 3;
-        let page_count = 5;
-        let error_msg = format!(
-            "Boundary count {} doesn't match page count {}",
-            boundaries_count, page_count
-        );
-        assert_eq!(error_msg, "Boundary count 3 doesn't match page count 5");
+    fn test_extract_metadata_invalid_pdf() {
+        let result = extract_metadata(b"not a pdf");
+        assert!(result.is_err());
     }
 }

data/vendor/kreuzberg/src/pdf/mod.rs

@@ -26,56 +26,25 @@
 //!
 //! // Extract metadata
 //! let metadata = extract_metadata(&pdf_bytes)?;
-//! println!("PDF version: {:?}", metadata.pdf_version);
+//! println!("Page count: {:?}", metadata.page_count);
 //! # Ok(())
 //! # }
 //! ```
 //!
 //! # Note
 //!
-//! This module requires the `pdf` feature. The `ocr` feature enables additional
+//! This module is always available. The `ocr` feature enables additional
 //! functionality in the PDF extractor for rendering pages to images.
-#[cfg(feature = "pdf")]
-pub(crate) mod bindings;
-#[cfg(all(feature = "pdf", feature = "bundled-pdfium"))]
-pub mod bundled;
-#[cfg(feature = "pdf")]
 pub mod error;
-#[cfg(feature = "pdf")]
-pub mod fonts;
-#[cfg(feature = "pdf")]
-pub mod hierarchy;
-#[cfg(feature = "pdf")]
 pub mod images;
-#[cfg(feature = "pdf")]
 pub mod metadata;
-#[cfg(feature = "pdf")]
 pub mod rendering;
-#[cfg(feature = "pdf")]
 pub mod table;
-#[cfg(feature = "pdf")]
 pub mod text;
 
-#[cfg(feature = "pdf")]
-pub use crate::core::config::HierarchyConfig;
-#[cfg(all(feature = "pdf", feature = "bundled-pdfium"))]
-pub use bundled::extract_bundled_pdfium;
-#[cfg(feature = "pdf")]
 pub use error::PdfError;
-#[cfg(feature = "pdf")]
-pub use fonts::{cached_font_count, get_font_descriptors, initialize_font_cache};
-#[cfg(feature = "pdf")]
-pub use hierarchy::{
-    BoundingBox, CharData, FontSizeCluster, HierarchyLevel, TextBlock, assign_hierarchy_levels,
-    assign_hierarchy_levels_from_clusters, cluster_font_sizes, extract_chars_with_fonts, should_trigger_ocr,
-};
-#[cfg(feature = "pdf")]
 pub use images::{PdfImage, PdfImageExtractor, extract_images_from_pdf};
-#[cfg(feature = "pdf")]
 pub use metadata::extract_metadata;
-#[cfg(feature = "pdf")]
 pub use rendering::{PageRenderOptions, render_page_to_image};
-#[cfg(feature = "pdf")]
 pub use table::extract_words_from_page;
-#[cfg(feature = "pdf")]
 pub use text::extract_text_from_pdf;

data/vendor/kreuzberg/src/pdf/rendering.rs

@@ -1,4 +1,3 @@
-use super::bindings::{PdfiumHandle, bind_pdfium};
 use super::error::{PdfError, Result};
 use image::DynamicImage;
 use pdfium_render::prelude::*;
@@ -27,18 +26,20 @@ impl Default for PageRenderOptions {
     }
 }
 
-pub struct PdfRenderer<'a> {
-    pdfium: PdfiumHandle<'a>,
+pub struct PdfRenderer {
+    pdfium: Pdfium,
 }
 
-impl PdfRenderer<'static> {
+impl PdfRenderer {
     pub fn new() -> Result<Self> {
-        let pdfium = bind_pdfium(PdfError::RenderingFailed, "page rendering")?;
+        let binding = Pdfium::bind_to_library(Pdfium::pdfium_platform_library_name_at_path("./"))
+            .or_else(|_| Pdfium::bind_to_system_library())
+            .map_err(|e| PdfError::RenderingFailed(format!("Failed to initialize Pdfium: {}", e)))?;
+
+        let pdfium = Pdfium::new(binding);
         Ok(Self { pdfium })
     }
-}
 
-impl PdfRenderer<'_> {
     pub fn render_page_to_image(
         &self,
         pdf_bytes: &[u8],
@@ -56,7 +57,7 @@ impl PdfRenderer<'_> {
         password: Option<&str>,
     ) -> Result<DynamicImage> {
         let document = self.pdfium.load_pdf_from_byte_slice(pdf_bytes, password).map_err(|e| {
-            let err_msg = super::error::format_pdfium_error(e);
+            let err_msg = e.to_string();
             if (err_msg.contains("password") || err_msg.contains("Password")) && password.is_some() {
                 PdfError::InvalidPassword
             } else if err_msg.contains("password") || err_msg.contains("Password") {
@@ -68,7 +69,7 @@ impl PdfRenderer<'_> {
 
         let page = document
             .pages()
-            .get(page_index as i32)
+            .get(page_index as u16)
             .map_err(|_| PdfError::PageNotFound(page_index))?;
 
         let width_points = page.width().value;
@@ -114,7 +115,7 @@ impl PdfRenderer<'_> {
         password: Option<&str>,
     ) -> Result<Vec<DynamicImage>> {
         let document = self.pdfium.load_pdf_from_byte_slice(pdf_bytes, password).map_err(|e| {
-            let err_msg = super::error::format_pdfium_error(e);
+            let err_msg = e.to_string();
             if (err_msg.contains("password") || err_msg.contains("Password")) && password.is_some() {
                 PdfError::InvalidPassword
             } else if err_msg.contains("password") || err_msg.contains("Password") {
@@ -237,8 +238,7 @@ mod tests {
 
     #[test]
     fn test_renderer_size() {
-        use std::mem::size_of;
-        let _size = size_of::<PdfRenderer>();
+        assert!(size_of::<PdfRenderer>() > 0);
     }
 
     #[test]