chore: cleanup

Author: Goldziher

crates/kreuzberg-py/src/config/types.rs

@@ -472,6 +472,67 @@ impl ExtractionConfig {
         self.inner.max_archive_depth = value;
     }
 
+    /// Get the security limits for archive extraction.
+    ///
+    /// Returns:
+    ///     Optional dict with keys: max_archive_size, max_compression_ratio,
+    ///     max_files_in_archive, max_nesting_depth, max_entity_length,
+    ///     max_content_size, max_iterations
+    #[getter]
+    fn security_limits(&self, py: Python<'_>) -> PyResult<Option<Py<PyDict>>> {
+        match &self.inner.security_limits {
+            Some(limits) => {
+                let dict = PyDict::new(py);
+                dict.set_item("max_archive_size", limits.max_archive_size)?;
+                dict.set_item("max_compression_ratio", limits.max_compression_ratio)?;
+                dict.set_item("max_files_in_archive", limits.max_files_in_archive)?;
+                dict.set_item("max_nesting_depth", limits.max_nesting_depth)?;
+                dict.set_item("max_entity_length", limits.max_entity_length)?;
+                dict.set_item("max_content_size", limits.max_content_size)?;
+                dict.set_item("max_iterations", limits.max_iterations)?;
+                Ok(Some(dict.unbind()))
+            }
+            None => Ok(None),
+        }
+    }
+
+    /// Set the security limits for archive extraction.
+    ///
+    /// Args:
+    ///     value: Optional dict with security limit keys, or None to use defaults.
+    #[setter]
+    fn set_security_limits(&mut self, value: Option<Bound<'_, PyDict>>) -> PyResult<()> {
+        self.inner.security_limits = match value {
+            Some(dict) => {
+                let mut limits = kreuzberg::extractors::security::SecurityLimits::default();
+                if let Some(v) = dict.get_item("max_archive_size")? {
+                    limits.max_archive_size = v.extract()?;
+                }
+                if let Some(v) = dict.get_item("max_compression_ratio")? {
+                    limits.max_compression_ratio = v.extract()?;
+                }
+                if let Some(v) = dict.get_item("max_files_in_archive")? {
+                    limits.max_files_in_archive = v.extract()?;
+                }
+                if let Some(v) = dict.get_item("max_nesting_depth")? {
+                    limits.max_nesting_depth = v.extract()?;
+                }
+                if let Some(v) = dict.get_item("max_entity_length")? {
+                    limits.max_entity_length = v.extract()?;
+                }
+                if let Some(v) = dict.get_item("max_content_size")? {
+                    limits.max_content_size = v.extract()?;
+                }
+                if let Some(v) = dict.get_item("max_iterations")? {
+                    limits.max_iterations = v.extract()?;
+                }
+                Some(limits)
+            }
+            None => None,
+        };
+        Ok(())
+    }
+
     fn __repr__(&self) -> String {
         format!(
             "ExtractionConfig(use_cache={}, enable_quality_processing={}, ocr={}, force_ocr={}, extraction_timeout_secs={:?}, force_ocr_pages={:?})",

crates/kreuzberg/src/extractors/image.rs

@@ -55,28 +55,37 @@ impl ImageExtractor {
 
         let ocr_result = backend.process_image(content, &ocr_config_with_format).await?;
 
+        // Destructure to avoid partial-move issues when propagating OCR elements.
+        let ocr_content = ocr_result.content;
+        let ocr_metadata = ocr_result.metadata;
+        let ocr_elements = ocr_result.ocr_elements;
+
         // Full OCR with TIFF multi-frame support (requires tiff crate)
         #[cfg(feature = "ocr")]
         {
             let ocr_extraction_result = crate::extraction::image::extract_text_from_image_with_ocr(
                 content,
                 mime_type,
-                ocr_result.content,
+                ocr_content,
                 config.pages.as_ref(),
             )?;
 
             // Build InternalDocument from OCR text
             let mut doc = build_image_internal_document(Some(&ocr_extraction_result.content), None);
-            doc.metadata = ocr_result.metadata;
+            doc.metadata = ocr_metadata;
+            // Propagate OCR elements from the backend result into the InternalDocument
+            // so that derive_extraction_result can populate ExtractionResult::ocr_elements.
+            inject_ocr_elements_from_vec(&mut doc, ocr_elements);
             Ok(doc)
         }
 
         // Simplified OCR path for WASM (no TIFF multi-frame support)
         #[cfg(not(feature = "ocr"))]
         {
             let _ = mime_type;
-            let mut doc = build_image_internal_document(Some(&ocr_result.content), None);
-            doc.metadata = ocr_result.metadata;
+            let mut doc = build_image_internal_document(Some(&ocr_content), None);
+            doc.metadata = ocr_metadata;
+            inject_ocr_elements_from_vec(&mut doc, ocr_elements);
             Ok(doc)
         }
     }
@@ -253,6 +262,37 @@ impl ImageExtractor {
     }
 }
 
+/// Inject OCR elements into an `InternalDocument`.
+///
+/// Converts each `OcrElement` into an `InternalElement` with `ElementKind::OcrText`
+/// so that the derive pipeline can reconstruct them into `ExtractionResult::ocr_elements`.
+fn inject_ocr_elements_from_vec(doc: &mut InternalDocument, ocr_elements: Option<Vec<crate::types::OcrElement>>) {
+    use crate::types::document_structure::ContentLayer;
+    use crate::types::internal::{ElementKind, InternalElement, InternalElementId};
+
+    if let Some(ocr_elements) = ocr_elements {
+        for (i, elem) in ocr_elements.iter().enumerate() {
+            let kind = ElementKind::OcrText { level: elem.level };
+            let id = InternalElementId::generate("ocr_text", &elem.text, Some(elem.page_number as u32), i as u32);
+            doc.elements.push(InternalElement {
+                id,
+                kind,
+                text: elem.text.clone(),
+                depth: 0,
+                page: Some(elem.page_number as u32),
+                bbox: None,
+                layer: ContentLayer::Body,
+                annotations: Vec::new(),
+                attributes: None,
+                anchor: None,
+                ocr_geometry: Some(elem.geometry.clone()),
+                ocr_confidence: Some(elem.confidence.clone()),
+                ocr_rotation: elem.rotation.clone(),
+            });
+        }
+    }
+}
+
 /// Build a simple `InternalDocument` for an image extraction result.
 ///
 /// If OCR text is available, pushes it as a paragraph. Always pushes

tools/e2e-generator/src/java.rs

@@ -2548,33 +2548,31 @@ fn render_render_assertions_java(
 /// Java types implemented as records (use field-name accessors, not getters).
 ///
 /// Records use `fieldName()` style accessors instead of `getFieldName()`.
-const JAVA_RECORD_TYPES: &[&str] = &[
-    "PdfAnnotation",
-    "Table",
-    "BoundingBox",
-    "Keyword",
-    "Uri",
-    "ArchiveEntry",
-    "ProcessingWarning",
-];
+/// NOTE: Only include types that are actual Java records. Types implemented as
+/// regular classes with getX()/isX() methods must NOT be listed here.
+const JAVA_RECORD_TYPES: &[&str] = &[];
 
 /// Special field name mappings for Java (manifest field name -> Java accessor name).
 fn java_field_override(type_name: &str, field_name: &str) -> Option<String> {
     match (type_name, field_name) {
         ("ExtractionResult", "document") => Some("getDocumentStructure".to_string()),
-        ("ExtractionConfig", "enable_quality_processing") => Some("isEnableQualityProcessing".to_string()),
         _ => None,
     }
 }
 
 /// Return the correct Java accessor for a field, respecting records vs classes
 /// and any per-field overrides.
-fn to_java_accessor(type_name: &str, field_name: &str) -> String {
+///
+/// When `json_type` is `"boolean"`, non-record types use the `isFieldName()`
+/// convention instead of `getFieldName()`.
+fn to_java_accessor_with_type(type_name: &str, field_name: &str, json_type: Option<&str>) -> String {
     if let Some(override_name) = java_field_override(type_name, field_name) {
         return override_name;
     }
     if JAVA_RECORD_TYPES.contains(&type_name) {
         parity::to_camel_case(field_name)
+    } else if json_type == Some("boolean") {
+        format!("is{}", parity::to_pascal_case(field_name))
     } else {
         format!("get{}", parity::to_pascal_case(field_name))
     }
@@ -2636,11 +2634,21 @@ pub fn generate_parity(manifest: &ParityManifest, output_root: &Utf8Path) -> Res
         let required_fields: Vec<(&String, String)> = fields
             .iter()
             .filter(|(_, f)| f.required)
-            .map(|(name, _)| (name, to_java_accessor("ExtractionResult", name)))
+            .map(|(name, f)| {
+                (
+                    name,
+                    to_java_accessor_with_type("ExtractionResult", name, Some(&f.json_type)),
+                )
+            })
             .collect();
         let all_fields: Vec<(&String, String)> = fields
-            .keys()
-            .map(|name| (name, to_java_accessor("ExtractionResult", name)))
+            .iter()
+            .map(|(name, f)| {
+                (
+                    name,
+                    to_java_accessor_with_type("ExtractionResult", name, Some(&f.json_type)),
+                )
+            })
             .collect();
 
         writeln!(buffer)?;
@@ -2694,8 +2702,13 @@ pub fn generate_parity(manifest: &ParityManifest, output_root: &Utf8Path) -> Res
     // ExtractionConfig parity
     if let Some(fields) = parity::fields_for_type_and_lang(manifest, "ExtractionConfig", lang) {
         let all_fields: Vec<(&String, String)> = fields
-            .keys()
-            .map(|name| (name, to_java_accessor("ExtractionConfig", name)))
+            .iter()
+            .map(|(name, f)| {
+                (
+                    name,
+                    to_java_accessor_with_type("ExtractionConfig", name, Some(&f.json_type)),
+                )
+            })
             .collect();
 
         writeln!(buffer)?;
@@ -2732,8 +2745,8 @@ pub fn generate_parity(manifest: &ParityManifest, output_root: &Utf8Path) -> Res
         }
 
         let all_fields: Vec<(&String, String)> = fields
-            .keys()
-            .map(|name| (name, to_java_accessor(type_name, name)))
+            .iter()
+            .map(|(name, f)| (name, to_java_accessor_with_type(type_name, name, Some(&f.json_type))))
             .collect();
 
         let method_name = format!("test{}AllGetters", type_name);