mindee-lite 5.0.0.beta1

data/lib/mindee/v2/product/extraction/params/extraction_parameters.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require_relative '../../../../input/base_parameters'
+require_relative 'data_schema'
+
+module Mindee
+  module V2
+    module Product
+      module Extraction
+        module Params
+          # Parameters accepted by the extraction v2 endpoint.
+          class ExtractionParameters < Mindee::Input::BaseParameters
+            # @return [Boolean, nil] Enhance extraction accuracy with Retrieval-Augmented Generation.
+            attr_reader :rag
+
+            # @return [Boolean, nil] Extract the full text content from the document as strings,
+            #   and fill the raw_text` attribute.
+            attr_reader :raw_text
+
+            # @return [Boolean, nil] Calculate bounding box polygons for all fields,
+            #   and fill their `locations` attribute.
+            attr_reader :polygon
+
+            # @return [Boolean, nil] Boost the precision and accuracy of all extractions.
+            #   Calculate confidence scores for all fields, and fill their confidence attribute.
+            attr_reader :confidence
+
+            # @return [String, nil] Additional text context used by the model during inference.
+            #   Not recommended, for specific use only.
+            attr_reader :text_context
+
+            # @return [DataSchemaField]
+            attr_reader :data_schema
+
+            # @return [String] Slug for the endpoint.
+            def self.slug
+              'extraction'
+            end
+
+            # rubocop:disable Metrics/ParameterLists
+            # @param [String] model_id ID of the model
+            # @param [Boolean, nil] rag Whether to enable RAG.
+            # @param [Boolean, nil] raw_text Whether to enable rax text.
+            # @param [Boolean, nil] polygon Whether to enable polygons.
+            # @param [Boolean, nil] confidence Whether to enable confidence scores.
+            # @param [String, nil] file_alias File alias, if applicable.
+            # @param [Array<String>, nil] webhook_ids
+            # @param [String, nil] text_context
+            # @param [Hash, nil] polling_options
+            # @param [Boolean, nil] close_file
+            # @param [DataSchemaField, String, Hash nil] data_schema
+            def initialize(
+              model_id,
+              rag: nil,
+              raw_text: nil,
+              polygon: nil,
+              confidence: nil,
+              file_alias: nil,
+              webhook_ids: nil,
+              text_context: nil,
+              polling_options: nil,
+              close_file: true,
+              data_schema: nil
+            )
+              super(
+                model_id,
+                file_alias: file_alias,
+                webhook_ids: webhook_ids,
+                polling_options: polling_options,
+                close_file: close_file
+              )
+
+              @rag = rag
+              @raw_text = raw_text
+              @polygon = polygon
+              @confidence = confidence
+              @text_context = text_context
+              @data_schema = DataSchema.new(data_schema) unless data_schema.nil?
+              # rubocop:enable Metrics/ParameterLists
+            end
+
+            # Appends inference-specific form data to the provided array.
+            # @param [Array] form_data Array of form fields
+            # @return [Array]
+            def append_form_data(form_data)
+              new_form_data = super
+
+              new_form_data.push(['rag', @rag.to_s]) unless @rag.nil?
+              new_form_data.push(['raw_text', @raw_text.to_s]) unless @raw_text.nil?
+              new_form_data.push(['polygon', @polygon.to_s]) unless @polygon.nil?
+              new_form_data.push(['confidence', @confidence.to_s]) unless @confidence.nil?
+              new_form_data.push(['text_context', @text_context]) if @text_context
+              new_form_data.push(['data_schema', @data_schema.to_s]) if @data_schema
+
+              new_form_data
+            end
+
+            # Loads a prediction from a Hash.
+            # @param [Hash] params Parameters to provide as a hash.
+            # @return [ExtractionParameters]
+            def self.from_hash(params: {})
+              rag = params.fetch(:rag, nil)
+              raw_text = params.fetch(:raw_text, nil)
+              polygon = params.fetch(:polygon, nil)
+              confidence = params.fetch(:confidence, nil)
+              base_params = load_from_hash(params: params)
+              new_params = base_params.merge(rag: rag, raw_text: raw_text, polygon: polygon, confidence: confidence)
+              model_id = new_params.fetch(:model_id)
+
+              ExtractionParameters.new(
+                model_id, rag: rag,
+                          raw_text: raw_text,
+                          polygon: polygon,
+                          confidence: confidence,
+                          file_alias: params.fetch(:file_alias, nil),
+                          webhook_ids: params.fetch(:webhook_ids, nil),
+                          close_file: params.fetch(:close_file, true)
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mindee/v2/product/ocr/ocr.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative 'ocr_response'
+require_relative 'params/ocr_parameters'
+
+module Mindee
+  module V2
+    module Product
+      # OCR module.
+      module OCR
+        # OCR product.
+        class OCR < BaseProduct
+          @slug = 'ocr'
+          @params_type = Mindee::V2::Product::OCR::Params::OCRParameters
+          @response_type = Mindee::V2::Product::OCR::OCRResponse
+        end
+      end
+    end
+  end
+end

data/lib/mindee/v2/product/ocr/ocr_inference.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative 'ocr_result'
+
+module Mindee
+  module V2
+    module Product
+      module OCR
+        # The inference result for an OCR utility request.
+        class OCRInference < Mindee::V2::Parsing::BaseInference
+          # @return [OCRResult] Parsed inference payload.
+          attr_reader :result
+
+          # @param server_response [Hash] Hash representation of the JSON returned by the service.
+          def initialize(server_response)
+            super
+
+            @result = OCRResult.new(server_response['result'])
+          end
+
+          # String representation.
+          # @return [String]
+          def to_s
+            [
+              super,
+              @result.to_s,
+              '',
+            ].join("\n")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mindee/v2/product/ocr/ocr_page.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative 'ocr_word'
+
+module Mindee
+  module V2
+    module Product
+      module OCR
+        # OCR result for a single page.
+        class OCRPage
+          # @return [Array<OCRWord>] List of words extracted from the document page.
+          attr_reader :words
+          # @return [String] Full text content extracted from the document page.
+          attr_reader :content
+
+          # @param server_response [Hash] Hash representation of the JSON returned by the service.
+          def initialize(server_response)
+            @words = server_response['words'].map { |word| OCRWord.new(word) }
+            @content = server_response['content']
+          end
+
+          # String representation.
+          # @return [String]
+          def to_s
+            ocr_words = "\n"
+            ocr_words += @words.join("\n\n") if @words&.any?
+            "OCR Words\n======#{ocr_words}\n\n:Content: #{@content}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mindee/v2/product/ocr/ocr_response.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative '../../parsing/base_response'
+require_relative 'params/ocr_parameters'
+require_relative 'ocr_inference'
+
+module Mindee
+  module V2
+    module Product
+      module OCR
+        # HTTP response wrapper that embeds a V2 Inference.
+        class OCRResponse < Mindee::V2::Parsing::BaseResponse
+          # @return [OCRInference] Parsed inference payload.
+          attr_reader :inference
+
+          # @param server_response [Hash] Hash parsed from the API JSON response.
+          def initialize(server_response)
+            super
+
+            @inference = OCRInference.new(server_response['inference'])
+          end
+
+          # String representation.
+          # @return [String]
+          def to_s
+            @inference.to_s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mindee/v2/product/ocr/ocr_result.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative 'ocr_page'
+
+module Mindee
+  module V2
+    module Product
+      module OCR
+        # Result of a ocr utility inference.
+        class OCRResult
+          # @return [Array<OCRPage>] List of OCR results for each page in the document.
+          attr_reader :pages
+
+          # @param server_response [Hash] Hash representation of the JSON returned by the service.
+          def initialize(server_response)
+            @pages = if server_response.key?('pages')
+                       server_response['pages'].map do |pages|
+                         OCRPage.new(pages)
+                       end
+                     end
+          end
+
+          # String representation.
+          # @return [String]
+          def to_s
+            pages_str = @pages.join("\n")
+
+            "Pages\n======\n#{pages_str}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mindee/v2/product/ocr/ocr_word.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Mindee
+  module V2
+    module Product
+      module OCR
+        # OCR result for a single word extracted from the document page.
+        class OCRWord
+          # @return [String] Text content of the word.
+          attr_reader :content
+          # @return [Mindee::Geometry::Polygon] Position information as a list of points in clockwise order.
+          attr_reader :polygon
+
+          # @param server_response [Hash] Hash representation of the JSON returned by the service.
+          def initialize(server_response)
+            @content = server_response['content']
+            @polygon = Mindee::Geometry::Polygon.new(server_response['polygon'])
+          end
+
+          # String representation.
+          # @return [String]
+          def to_s
+            @content
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mindee/v2/product/ocr/params/ocr_parameters.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Mindee
+  module V2
+    module Product
+      module OCR
+        # OCR Parameters.
+        module Params
+          # Parameters accepted by the ocr utility v2 endpoint.
+          class OCRParameters < Mindee::Input::BaseParameters
+            # @return [String] Slug for the endpoint.
+            def self.slug
+              'ocr'
+            end
+
+            # @param [String] model_id ID of the model
+            # @param [String, nil] file_alias File alias, if applicable.
+            # @param [Array<String>, nil] webhook_ids List of webhook IDs to propagate the API response to.
+            # @param [Hash, nil] polling_options Options for polling. Set only if having timeout issues.
+            # @param [Boolean, nil] close_file Whether to close the file after parsing.
+            def initialize(
+              model_id,
+              file_alias: nil,
+              webhook_ids: nil,
+              polling_options: nil,
+              close_file: true
+            )
+              super
+            end
+
+            # Loads the parameters from a Hash.
+            # @param [Hash] params Parameters to provide as a hash.
+            # @return [OCRParameters]
+            def self.from_hash(params: {})
+              OCRParameters.new(
+                params.fetch(:model_id),
+                file_alias: params.fetch(:file_alias, nil),
+                webhook_ids: params.fetch(:webhook_ids, nil),
+                close_file: params.fetch(:close_file, true)
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mindee/v2/product/split/params/split_parameters.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Mindee
+  module V2
+    module Product
+      # Split module.
+      module Split
+        # Split parameters.
+        module Params
+          # Parameters accepted by the split utility v2 endpoint.
+          class SplitParameters < Mindee::Input::BaseParameters
+            # @return [String] Slug for the endpoint.
+            def self.slug
+              'split'
+            end
+
+            # @param [String] model_id ID of the model
+            # @param [String, nil] file_alias File alias, if applicable.
+            # @param [Array<String>, nil] webhook_ids List of webhook IDs to propagate the API response to.
+            # @param [Hash, nil] polling_options Options for polling. Set only if having timeout issues.
+            # @param [Boolean, nil] close_file Whether to close the file after parsing.
+            def initialize(
+              model_id,
+              file_alias: nil,
+              webhook_ids: nil,
+              polling_options: nil,
+              close_file: true
+            )
+              super
+            end
+
+            # Loads the parameters from a Hash.
+            # @param [Hash] params Parameters to provide as a hash.
+            # @return [SplitParameters]
+            def self.from_hash(params: {})
+              SplitParameters.new(
+                params.fetch(:model_id),
+                file_alias: params.fetch(:file_alias, nil),
+                webhook_ids: params.fetch(:webhook_ids, nil),
+                close_file: params.fetch(:close_file, true)
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mindee/v2/product/split/split.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative 'split_response'
+require_relative 'params/split_parameters'
+
+module Mindee
+  module V2
+    module Product
+      module Split
+        # Split product.
+        class Split < BaseProduct
+          @slug = 'split'
+          @params_type = Mindee::V2::Product::Split::Params::SplitParameters
+          @response_type = Mindee::V2::Product::Split::SplitResponse
+        end
+      end
+    end
+  end
+end

data/lib/mindee/v2/product/split/split_inference.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative 'split_result'
+
+module Mindee
+  module V2
+    module Product
+      module Split
+        # Split inference result.
+        class SplitInference < Mindee::V2::Parsing::BaseInference
+          # @return [SplitResult] Result of a split inference.
+          attr_reader :result
+
+          # @param server_response [Hash] Hash representation of the JSON returned by the service.
+          def initialize(server_response)
+            super
+
+            @result = SplitResult.new(server_response['result'])
+          end
+
+          # String representation.
+          # @return [String]
+          def to_s
+            [
+              super,
+              @result.to_s,
+              '',
+            ].join("\n")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mindee/v2/product/split/split_range.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Mindee
+  module V2
+    module Product
+      module Split
+        # Split inference result.
+        class SplitRange
+          # @return [Array<Integer>] 0-based page indexes, where the first integer indicates the start page and the
+          #     second integer indicates the end page.
+          attr_reader :page_range
+          # @return [String] The document type, as identified on given classification values.
+          attr_reader :document_type
+
+          # @param server_response [Hash] Hash representation of the JSON returned by the service.
+          def initialize(server_response)
+            @page_range = server_response['page_range']
+            @document_type = server_response['document_type']
+          end
+
+          # String representation.
+          # @return [String]
+          def to_s
+            "* :Page Range: #{@page_range}\n  :Document Type: #{@document_type}"
+          end
+
+          # Apply the split range inference to a file and return a single extracted PDF.
+          #
+          # @param input_source [Mindee::Input::Source::LocalInputSource] Local file to extract from
+          # @return [PDF::ExtractedPDF]
+          def extract_from_file(input_source)
+            FileOperation::Split.extract_single_split(input_source, @page_range)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mindee/v2/product/split/split_response.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative '../../parsing/base_response'
+require_relative 'params/split_parameters'
+require_relative 'split_inference'
+
+module Mindee
+  module V2
+    module Product
+      module Split
+        # HTTP response wrapper that embeds a V2 Inference.
+        class SplitResponse < Mindee::V2::Parsing::BaseResponse
+          # @return [SplitInference] Parsed inference payload.
+          attr_reader :inference
+
+          # @param server_response [Hash] Hash parsed from the API JSON response.
+          def initialize(server_response)
+            super
+
+            @inference = SplitInference.new(server_response['inference'])
+          end
+
+          # String representation.
+          # @return [String]
+          def to_s
+            @inference.to_s
+          end
+
+          # Extracts the crops from the input source.
+          # @param input_source [Mindee::Input::Source::LocalInputSource] Path to the file or a File object.
+          # @return [FileOperation::SplitFiles]
+          def extract_from_file(input_source)
+            splits = @inference.result.splits.map(&:page_range)
+            FileOperation::Split.extract_splits(input_source, splits)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mindee/v2/product/split/split_result.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative 'split_range'
+
+module Mindee
+  module V2
+    module Product
+      module Split
+        # Result of a split utility inference.
+        class SplitResult
+          # @return [Array<SplitRange>] List of results of splitped document regions.
+          attr_reader :splits
+
+          # @param server_response [Hash] Hash representation of the JSON returned by the service.
+          def initialize(server_response)
+            @splits = if server_response.key?('splits')
+                        server_response['splits'].map do |split|
+                          SplitRange.new(split)
+                        end
+                      end
+          end
+
+          # String representation.
+          # @return [String]
+          def to_s
+            splits_str = @splits.join("\n")
+
+            "Splits\n======\n#{splits_str}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mindee/v2/product.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require_relative 'product/classification/classification'
+require_relative 'product/crop/crop'
+require_relative 'product/extraction/extraction'
+require_relative 'product/ocr/ocr'
+require_relative 'product/split/split'

data/lib/mindee/v2.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require_relative 'v2/client'
+require_relative 'v2/http'
+require_relative 'v2/file_operation' if Mindee::Dependency.all_deps_available?
+require_relative 'v2/parsing'
+require_relative 'v2/product'

data/lib/mindee/version.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+# Mindee
+module Mindee
+  # Current version.
+  VERSION = '5.0.0.beta1'
+
+  # Finds and return the current platform.
+  # @return [Symbol, Hash[String | Symbol, Regexp], Nil?]
+  def self.find_platform
+    host = RbConfig::CONFIG['host_os']
+    platforms = {
+      linux: %r{linux|cygwin},
+      windows: %r{mswin|mingw|bccwin|wince|emx|win32},
+      macos: %r{mac|darwin},
+      bsd: %r{bsd},
+      solaris: %r{solaris|sunos},
+    }
+    platforms.each do |os, regexp|
+      return os unless (regexp =~ host).nil?
+    end
+  end
+
+  # Current platform.
+  PLATFORM = find_platform.freeze
+end