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

data/lib/kreuzberg/config.rb

@@ -1,10 +1,12 @@
 # frozen_string_literal: true
 
-require 'json'
-
 module Kreuzberg
   module Config
+    # OCR configuration
+    #
     # @example
+    #   ocr = OCR.new(backend: "tesseract", language: "eng")
+    #
     class OCR
       attr_reader :backend, :language, :tesseract_config
 
@@ -37,7 +39,6 @@ module Kreuzberg
       end
     end
 
-    # Tesseract OCR engine configuration
     class Tesseract
       attr_reader :options
 
@@ -71,7 +72,6 @@ module Kreuzberg
     class Chunking
       attr_reader :max_chars, :max_overlap, :preset, :embedding, :enabled
 
-      # rubocop:disable Metrics/CyclomaticComplexity
       def initialize(
         max_chars: nil,
         max_overlap: nil,
@@ -81,17 +81,11 @@ module Kreuzberg
         chunk_overlap: nil,
         enabled: true
       )
-        # rubocop:enable Metrics/CyclomaticComplexity
         resolved_size = chunk_size || max_chars || 1000
         resolved_overlap = chunk_overlap || max_overlap || 200
 
         @max_chars = resolved_size.to_i
         @max_overlap = resolved_overlap.to_i
-
-        # Validate positive values
-        raise ArgumentError, "max_chars must be a positive integer, got #{@max_chars}" if @max_chars.negative?
-        raise ArgumentError, "max_overlap must be a positive integer, got #{@max_overlap}" if @max_overlap.negative?
-
         @preset = preset&.to_s
         @embedding = normalize_embedding(embedding)
         @enabled = boolean_or_nil(enabled)
@@ -126,7 +120,6 @@ module Kreuzberg
       end
     end
 
-    # Embedding model configuration for document chunking
     class Embedding
       attr_reader :model, :normalize, :batch_size, :show_download_progress, :cache_dir
 
@@ -197,86 +190,18 @@ module Kreuzberg
       end
     end
 
-    # Font configuration for PDF rendering
-    #
-    # @example
-    #   font_config = FontConfig.new(enabled: true, custom_font_dirs: ["/usr/share/fonts"])
-    #
-    class FontConfig
-      attr_accessor :enabled, :custom_font_dirs
-
-      def initialize(enabled: true, custom_font_dirs: nil)
-        @enabled = enabled ? true : false
-        @custom_font_dirs = custom_font_dirs
-      end
-
-      def to_h
-        {
-          enabled: @enabled,
-          custom_font_dirs: @custom_font_dirs
-        }.compact
-      end
-    end
-
-    # Hierarchy detection configuration
-    #
-    # @example
-    #   hierarchy = Hierarchy.new(enabled: true, k_clusters: 6, include_bbox: true)
-    #
-    class Hierarchy
-      attr_reader :enabled, :k_clusters, :include_bbox, :ocr_coverage_threshold
-
-      def initialize(
-        enabled: true,
-        k_clusters: 6,
-        include_bbox: true,
-        ocr_coverage_threshold: nil
-      )
-        @enabled = enabled ? true : false
-        @k_clusters = k_clusters&.to_i || 6
-        @include_bbox = include_bbox ? true : false
-        @ocr_coverage_threshold = ocr_coverage_threshold&.to_f
-      end
-
-      def to_h
-        {
-          enabled: @enabled,
-          k_clusters: @k_clusters,
-          include_bbox: @include_bbox,
-          ocr_coverage_threshold: @ocr_coverage_threshold
-        }.compact
-      end
-
-      def self.from_h(hash)
-        return nil if hash.nil?
-        return hash if hash.is_a?(self)
-
-        new(**hash.transform_keys(&:to_sym)) if hash.is_a?(Hash)
-      end
-    end
-
     # PDF-specific options
     #
     # @example
     #   pdf = PDF.new(extract_images: true, passwords: ["secret", "backup"])
     #
-    # @example With font configuration
-    #   font_config = FontConfig.new(enabled: true, custom_font_dirs: ["/usr/share/fonts"])
-    #   pdf = PDF.new(extract_images: true, font_config: font_config)
-    #
-    # @example With hierarchy configuration
-    #   hierarchy = Hierarchy.new(enabled: true, k_clusters: 6)
-    #   pdf = PDF.new(extract_images: true, hierarchy: hierarchy)
-    #
     class PDF
-      attr_reader :extract_images, :passwords, :extract_metadata, :font_config, :hierarchy
+      attr_reader :extract_images, :passwords, :extract_metadata
 
       def initialize(
         extract_images: false,
         passwords: nil,
-        extract_metadata: true,
-        font_config: nil,
-        hierarchy: nil
+        extract_metadata: true
       )
         @extract_images = extract_images ? true : false
         @passwords = if passwords.is_a?(Array)
@@ -285,45 +210,15 @@ module Kreuzberg
                        (passwords ? [passwords.to_s] : nil)
                      end
         @extract_metadata = extract_metadata ? true : false
-        @font_config = normalize_font_config(font_config)
-        @hierarchy = normalize_hierarchy(hierarchy)
       end
 
       def to_h
         {
           extract_images: @extract_images,
           passwords: @passwords,
-          extract_metadata: @extract_metadata,
-          font_config: @font_config&.to_h,
-          hierarchy: @hierarchy&.to_h
+          extract_metadata: @extract_metadata
         }.compact
       end
-
-      def font_config=(value)
-        @font_config = normalize_font_config(value)
-      end
-
-      def hierarchy=(value)
-        @hierarchy = normalize_hierarchy(value)
-      end
-
-      private
-
-      def normalize_font_config(value)
-        return nil if value.nil?
-        return value if value.is_a?(FontConfig)
-        return FontConfig.new(**value.transform_keys(&:to_sym)) if value.is_a?(Hash)
-
-        raise ArgumentError, "Expected #{FontConfig}, Hash, or nil, got #{value.class}"
-      end
-
-      def normalize_hierarchy(value)
-        return nil if value.nil?
-        return value if value.is_a?(Hierarchy)
-        return Hierarchy.new(**value.transform_keys(&:to_sym)) if value.is_a?(Hash)
-
-        raise ArgumentError, "Expected #{Hierarchy}, Hash, or nil, got #{value.class}"
-      end
     end
 
     # Image extraction configuration
@@ -394,8 +289,6 @@ module Kreuzberg
       attr_reader :target_dpi, :auto_rotate, :deskew, :denoise,
                   :contrast_enhance, :binarization_method, :invert_colors
 
-      VALID_BINARIZATION_METHODS = %w[otsu sauvola niblack wolf bradley adaptive].freeze
-
       def initialize(
         target_dpi: 300,
         auto_rotate: true,
@@ -413,12 +306,10 @@ module Kreuzberg
         @binarization_method = binarization_method.to_s
         @invert_colors = invert_colors ? true : false
 
-        # Validate binarization method
-        return if VALID_BINARIZATION_METHODS.include?(@binarization_method)
+        valid_methods = %w[otsu sauvola adaptive]
+        return if valid_methods.include?(@binarization_method)
 
-        valid_methods = VALID_BINARIZATION_METHODS.join(', ')
-        raise ArgumentError,
-              "Invalid binarization_method: #{@binarization_method}. Valid methods are: #{valid_methods}"
+        raise ArgumentError, "binarization_method must be one of: #{valid_methods.join(', ')}"
       end
 
       def to_h
@@ -448,16 +339,14 @@ module Kreuzberg
     class TokenReduction
       attr_reader :mode, :preserve_important_words
 
-      VALID_MODES = %w[off light moderate aggressive maximum].freeze
-
       def initialize(mode: 'off', preserve_important_words: true)
         @mode = mode.to_s
         @preserve_important_words = preserve_important_words ? true : false
 
-        # Validate mode against known valid modes
-        return if VALID_MODES.include?(@mode)
+        valid_modes = %w[off light moderate aggressive maximum]
+        return if valid_modes.include?(@mode)
 
-        raise ArgumentError, "Invalid token reduction mode: #{@mode}. Valid modes are: #{VALID_MODES.join(', ')}"
+        raise ArgumentError, "mode must be one of: #{valid_modes.join(', ')}"
       end
 
       def to_h
@@ -468,7 +357,6 @@ module Kreuzberg
       end
     end
 
-    # HTML preprocessing configuration for content extraction
     class HtmlPreprocessing
       attr_reader :enabled, :preset, :remove_navigation, :remove_forms
 
@@ -497,7 +385,6 @@ module Kreuzberg
       end
     end
 
-    # HTML rendering options for document conversion
     class HtmlOptions
       attr_reader :options
 
@@ -525,7 +412,6 @@ module Kreuzberg
       end
     end
 
-    # YAKE keyword extraction parameters
     class KeywordYakeParams
       attr_reader :window_size
 
@@ -538,7 +424,6 @@ module Kreuzberg
       end
     end
 
-    # RAKE keyword extraction parameters
     class KeywordRakeParams
       attr_reader :min_word_length, :max_words_per_phrase
 
@@ -555,7 +440,6 @@ module Kreuzberg
       end
     end
 
-    # Keyword extraction configuration for document analysis
     class Keywords
       attr_reader :algorithm, :max_keywords, :min_score, :ngram_range,
                   :language, :yake_params, :rake_params
@@ -601,36 +485,6 @@ module Kreuzberg
       end
     end
 
-    # Page tracking configuration for multi-page documents
-    #
-    # @example Enable page extraction
-    #   pages = PageConfig.new(extract_pages: true)
-    #
-    # @example Enable page markers in content
-    #   pages = PageConfig.new(insert_page_markers: true, marker_format: "--- PAGE {page_num} ---")
-    #
-    class PageConfig
-      attr_reader :extract_pages, :insert_page_markers, :marker_format
-
-      def initialize(
-        extract_pages: false,
-        insert_page_markers: false,
-        marker_format: "\n\n<!-- PAGE {page_num} -->\n\n"
-      )
-        @extract_pages = extract_pages ? true : false
-        @insert_page_markers = insert_page_markers ? true : false
-        @marker_format = marker_format.to_s
-      end
-
-      def to_h
-        {
-          extract_pages: @extract_pages,
-          insert_page_markers: @insert_page_markers,
-          marker_format: @marker_format
-        }
-      end
-    end
-
     # Post-processor configuration
     #
     # @example Enable all post-processors
@@ -715,7 +569,7 @@ module Kreuzberg
       attr_reader :use_cache, :enable_quality_processing, :force_ocr,
                   :ocr, :chunking, :language_detection, :pdf_options,
                   :image_extraction, :image_preprocessing, :postprocessor,
-                  :token_reduction, :keywords, :html_options, :pages,
+                  :token_reduction, :keywords, :html_options,
                   :max_concurrent_extractions
 
       # Load configuration from a file.
@@ -734,6 +588,7 @@ module Kreuzberg
       #
       def self.from_file(path)
         hash = Kreuzberg._config_from_file_native(path)
+        # Convert string keys to symbols for keyword arguments
         new(**hash.transform_keys(&:to_sym))
       end
 
@@ -754,6 +609,7 @@ module Kreuzberg
         hash = Kreuzberg._config_discover_native
         return nil if hash.nil?
 
+        # Convert string keys to symbols for keyword arguments
         new(**hash.transform_keys(&:to_sym))
       end
 
@@ -771,7 +627,6 @@ module Kreuzberg
         token_reduction: nil,
         keywords: nil,
         html_options: nil,
-        pages: nil,
         max_concurrent_extractions: nil
       )
         @use_cache = use_cache ? true : false
@@ -787,11 +642,10 @@ module Kreuzberg
         @token_reduction = normalize_config(token_reduction, TokenReduction)
         @keywords = normalize_config(keywords, Keywords)
         @html_options = normalize_config(html_options, HtmlOptions)
-        @pages = normalize_config(pages, PageConfig)
         @max_concurrent_extractions = max_concurrent_extractions&.to_i
       end
 
-      # rubocop:disable Metrics/CyclomaticComplexity
+      # rubocop:disable Metrics/PerceivedComplexity
       def to_h
         {
           use_cache: @use_cache,
@@ -807,130 +661,24 @@ module Kreuzberg
           token_reduction: @token_reduction&.to_h,
           keywords: @keywords&.to_h,
           html_options: @html_options&.to_h,
-          pages: @pages&.to_h,
           max_concurrent_extractions: @max_concurrent_extractions
         }.compact
       end
-      # rubocop:enable Metrics/CyclomaticComplexity
-
-      # Serialize configuration to JSON string
-      #
-      # @return [String] JSON representation of the configuration
-      #
-      # @example
-      #   config = Extraction.new(use_cache: true)
-      #   json = config.to_json
-      #   puts json  # => "{\"use_cache\":true,...}"
-      #
-      def to_json(*_args)
-        json_hash = to_h
-        # Convert to JSON directly - the native function has issues
-        JSON.generate(json_hash)
-      end
-
-      # Get a field from the configuration
-      #
-      # Supports dot notation for nested fields (e.g., "ocr.backend")
-      #
-      # @param field_name [String, Symbol] Field name to retrieve
-      # @return [Object, nil] Parsed field value, or nil if field doesn't exist
-      #
-      # @example Get a top-level field
-      #   config = Extraction.new(use_cache: true)
-      #   config.get_field("use_cache")  # => true
-      #
-      # @example Get a nested field
-      #   config = Extraction.new(ocr: OCR.new(backend: "tesseract"))
-      #   config.get_field("ocr.backend")  # => "tesseract"
-      #
-      def get_field(field_name)
-        json_hash = to_h
-        field_path = field_name.to_s.split('.')
-
-        # Navigate the nested hash using the field path
-        field_path.reduce(json_hash) do |current, key|
-          case current
-          when Hash
-            # Check both symbol and string keys, prefer symbol if exists
-            if current.key?(key.to_sym)
-              current[key.to_sym]
-            elsif current.key?(key.to_s)
-              current[key.to_s]
-            end
-          end
-        end
-      end
-
-      # Merge another configuration into this one
-      #
-      # Returns a new configuration with fields from the other config overriding
-      # fields from this config (shallow merge).
-      #
-      # @param other [Extraction, Hash] Configuration to merge
-      # @return [Extraction] New merged configuration
-      #
-      # @example
-      #   base = Extraction.new(use_cache: true, force_ocr: false)
-      #   override = Extraction.new(force_ocr: true)
-      #   merged = base.merge(override)
-      #   merged.use_cache   # => true
-      #   merged.force_ocr   # => true
-      #
-      def merge(other)
-        other_config = other.is_a?(Extraction) ? other : Extraction.new(**other)
-        # Merge the two config hashes
-        merged_hash = to_h.merge(other_config.to_h)
-        Extraction.new(**merged_hash)
-      end
-
-      # Merge another configuration into this one (mutating)
-      #
-      # Modifies this configuration in-place by merging fields from another config.
-      #
-      # @param other [Extraction, Hash] Configuration to merge
-      # @return [self]
-      #
-      # @example
-      #   base = Extraction.new(use_cache: true, force_ocr: false)
-      #   override = Extraction.new(force_ocr: true)
-      #   base.merge!(override)
-      #   base.use_cache   # => true
-      #   base.force_ocr   # => true
-      #
-      def merge!(other)
-        other_config = other.is_a?(Extraction) ? other : Extraction.new(**other)
-        merged = merge(other_config)
-        update_from_merged(merged)
-        self
-      end
+      # rubocop:enable Metrics/PerceivedComplexity
 
       private
 
       def normalize_config(value, klass)
         return nil if value.nil?
         return value if value.is_a?(klass)
+        # Convert string keys to symbols for keyword arguments
         return klass.new(**value.transform_keys(&:to_sym)) if value.is_a?(Hash)
 
         raise ArgumentError, "Expected #{klass}, Hash, or nil, got #{value.class}"
       end
-
-      def update_from_merged(merged)
-        @use_cache = merged.use_cache
-        @enable_quality_processing = merged.enable_quality_processing
-        @force_ocr = merged.force_ocr
-        @ocr = merged.ocr
-        @chunking = merged.chunking
-        @language_detection = merged.language_detection
-        @pdf_options = merged.pdf_options
-        @image_extraction = merged.image_extraction
-        @image_preprocessing = merged.image_preprocessing
-        @postprocessor = merged.postprocessor
-        @token_reduction = merged.token_reduction
-        @keywords = merged.keywords
-        @html_options = merged.html_options
-        @pages = merged.pages
-        @max_concurrent_extractions = merged.max_concurrent_extractions
-      end
     end
+
+    # Backwards compatibility aliases
+    Ocr = OCR
   end
 end

data/lib/kreuzberg/errors.rb

@@ -1,75 +1,9 @@
 # frozen_string_literal: true
 
-require 'json'
-
 module Kreuzberg
-  ERROR_CODE_SUCCESS = 0
-  ERROR_CODE_GENERIC = 1
-  ERROR_CODE_PANIC = 2
-  ERROR_CODE_INVALID_ARGUMENT = 3
-  ERROR_CODE_IO = 4
-  ERROR_CODE_PARSING = 5
-  ERROR_CODE_OCR = 6
-  ERROR_CODE_MISSING_DEPENDENCY = 7
-
   module Errors
-    class PanicContext
-      attr_reader :file, :line, :function, :message, :timestamp_secs
-
-      def initialize(file:, line:, function:, message:, timestamp_secs:)
-        @file = file
-        @line = line
-        @function = function
-        @message = message
-        @timestamp_secs = timestamp_secs
-      end
-
-      def to_s
-        "#{file}:#{line}:#{function}: #{message}"
-      end
-
-      def to_h
-        {
-          file:,
-          line:,
-          function:,
-          message:,
-          timestamp_secs:
-        }
-      end
-
-      def self.from_json(json_string)
-        return nil if json_string.nil? || json_string.empty?
-
-        data = JSON.parse(json_string, symbolize_names: true)
-        sliced = data.slice(:file, :line, :function, :message, :timestamp_secs)
-        new(**with_defaults(sliced))
-      rescue JSON::ParserError
-        nil
-      end
-
-      def self.with_defaults(sliced)
-        {
-          file: sliced[:file] || '',
-          line: sliced[:line] || 0,
-          function: sliced[:function] || '',
-          message: sliced[:message] || '',
-          timestamp_secs: sliced[:timestamp_secs] || 0
-        }
-      end
-      private_class_method :with_defaults
-    end
-
     # Base error class for all Kreuzberg errors
-    class Error < StandardError
-      attr_reader :panic_context, :error_code
-
-      def initialize(message, panic_context: nil, error_code: nil)
-        super(message)
-        @panic_context = panic_context
-        @error_code = error_code
-      end
-    end
+    class Error < StandardError; end
 
     # Raised when validation fails
     class ValidationError < Error; end
@@ -78,8 +12,8 @@ module Kreuzberg
     class ParsingError < Error
       attr_reader :context
 
-      def initialize(message, context: nil, panic_context: nil, error_code: nil)
-        super(message, panic_context:, error_code:)
+      def initialize(message, context: nil)
+        super(message)
         @context = context
       end
     end
@@ -88,8 +22,8 @@ module Kreuzberg
     class OCRError < Error
       attr_reader :context
 
-      def initialize(message, context: nil, panic_context: nil, error_code: nil)
-        super(message, panic_context:, error_code:)
+      def initialize(message, context: nil)
+        super(message)
         @context = context
       end
     end
@@ -98,8 +32,8 @@ module Kreuzberg
     class MissingDependencyError < Error
       attr_reader :dependency
 
-      def initialize(message, dependency: nil, panic_context: nil, error_code: nil)
-        super(message, panic_context:, error_code:)
+      def initialize(message, dependency: nil)
+        super(message)
         @dependency = dependency
       end
     end