mindee 4.13.0 → 5.0.0.beta1

data/lib/mindee/input/sources/local_input_source.rb

@@ -4,8 +4,9 @@ require 'stringio'
 require 'marcel'
 require 'fileutils'
 
-require_relative '../../pdf'
-require_relative '../../image'
+require_relative '../../dependency'
+require_relative '../../pdf' if Mindee::Dependency.all_deps_available?
+require_relative '../../image' if Mindee::Dependency.all_deps_available?
 
 module Mindee
   module Input
@@ -53,7 +54,7 @@ module Mindee
             return if ALLOWED_MIME_TYPES.include? @file_mimetype
           end
 
-          raise Errors::MindeeMimeTypeError, @file_mimetype.to_s
+          raise Error::MindeeMimeTypeError, @file_mimetype.to_s
         end
 
         # @deprecated See {#fix_pdf!} or {#self.fix_pdf} instead.
@@ -69,7 +70,7 @@ module Mindee
         # Attempts to fix the PDF data in the file.
         # @param maximum_offset [Integer] Maximum offset to look for the PDF header.
         # @return [void]
-        # @raise [Mindee::Errors::MindeePDFError]
+        # @raise [Mindee::Error::MindeePDFError]
         def fix_pdf!(maximum_offset: 500)
           @io_stream = LocalInputSource.fix_pdf(@io_stream, maximum_offset: maximum_offset)
           @io_stream.rewind
@@ -80,11 +81,11 @@ module Mindee
         # @param stream [StringIO] The stream to fix.
         # @param maximum_offset [Integer] Maximum offset to look for the PDF header.
         # @return [StringIO] The fixed stream.
-        # @raise [Mindee::Errors::MindeePDFError]
+        # @raise [Mindee::Error::MindeePDFError]
         def self.fix_pdf(stream, maximum_offset: 500)
           out_stream = StringIO.new
           stream.gets('%PDF-')
-          raise Errors::MindeePDFError if stream.eof? || stream.pos > maximum_offset
+          raise Error::MindeePDFError if stream.eof? || stream.pos > maximum_offset
 
           stream.pos = stream.pos - 5
           out_stream << stream.read
@@ -142,6 +143,9 @@ module Mindee
         # Defaults to one for images.
         # @return [Integer]
         def page_count
+          unless Mindee::Dependency.all_deps_available?
+            raise NotImplementedError, Mindee::Dependency::MINDEE_DEPENDENCIES_LOAD_ERROR
+          end
           return 1 unless pdf?
 
           @io_stream.seek(0)
@@ -149,14 +153,6 @@ module Mindee
           pdf_processor.pages.size
         end
 
-        # Returns the page count for a document.
-        # Defaults to one for images.
-        # @return [Integer]
-        # @deprecated Use {#page_count} instead.
-        def count_pages
-          page_count
-        end
-
         # Compresses the file, according to the provided info.
         # @param [Integer] quality Quality of the output file.
         # @param [Integer, nil] max_width Maximum width (Ignored for PDFs).
@@ -167,6 +163,10 @@ module Mindee
         # @param [bool] disable_source_text If the PDF has source text, whether to re-apply it to the original or
         #   not. Needs force_source_text to work.
         def compress!(quality: 85, max_width: nil, max_height: nil, force_source_text: false, disable_source_text: true)
+          unless Mindee::Dependency.all_deps_available?
+            raise NotImplementedError, Mindee::Dependency::MINDEE_DEPENDENCIES_LOAD_ERROR
+          end
+
           buffer = if pdf?
                      Mindee::PDF::PDFCompressor.compress_pdf(
                        @io_stream,
@@ -189,6 +189,10 @@ module Mindee
         # Checks whether the file has source text if it is a pdf. `false` otherwise
         # @return [bool] `true` if the file is a PDF and has source text.
         def source_text?
+          unless Mindee::Dependency.all_deps_available?
+            raise NotImplementedError, Mindee::Dependency::MINDEE_DEPENDENCIES_LOAD_ERROR
+          end
+
           Mindee::PDF::PDFTools.source_text?(@io_stream)
         end
       end

data/lib/mindee/input/sources/path_input_source.rb

@@ -11,7 +11,7 @@ module Mindee
         # @param filepath [String]
         # @param repair_pdf [bool]
         def initialize(filepath, repair_pdf: false)
-          io_stream = File.open(filepath, 'rb')
+          io_stream = File.new(filepath, 'rb')
           super(io_stream, File.basename(filepath), repair_pdf: repair_pdf)
         end
       end

data/lib/mindee/input/sources/url_input_source.rb

@@ -14,7 +14,7 @@ module Mindee
         attr_reader :url
 
         def initialize(url)
-          raise Errors::MindeeInputError, 'URL must be HTTPS' unless url.start_with? 'https://'
+          raise Error::MindeeInputError, 'URL must be HTTPS' unless url.start_with? 'https://'
 
           logger.debug("URL input: #{url}")
 
@@ -75,9 +75,9 @@ module Mindee
 
           response = make_request(uri, request, max_redirects)
           if response.code.to_i > 299
-            raise Errors::MindeeAPIError, "Failed to download file: HTTP status code #{response.code}"
+            raise Error::MindeeAPIError, "Failed to download file: HTTP status code #{response.code}"
           elsif response.code.to_i < 200
-            raise Errors::MindeeAPIError, "Failed to download file: Invalid response code #{response.code}."
+            raise Error::MindeeAPIError, "Failed to download file: Invalid response code #{response.code}."
           end
 
           response.body
@@ -103,7 +103,7 @@ module Mindee
             response = http.request(request)
             if response.is_a?(Net::HTTPRedirection) && max_redirects.positive?
               location = response['location']
-              raise Errors::MindeeInputError, 'No location in redirection header.' if location.nil?
+              raise Error::MindeeInputError, 'No location in redirection header.' if location.nil?
 
               new_uri = URI.parse(location)
               request = Net::HTTP::Get.new(new_uri)

data/lib/mindee/input.rb

@@ -1,6 +1,4 @@
 # frozen_string_literal: true
 
-require_relative 'input/data_schema'
-require_relative 'input/inference_parameters'
 require_relative 'input/polling_options'
 require_relative 'input/sources'

data/lib/mindee/logging/logger.rb

@@ -5,8 +5,16 @@ require 'logger'
 module Mindee
   # Mindee logging module.
   module Logging
-    @logger = Logger.new($stdout)
     log_level = ENV.fetch('MINDEE_LOG_LEVEL', 'WARN')
+    log_output = ENV.fetch('MINDEE_LOG_OUTPUT', 'stderr')
+    @logger = if log_output == 'stderr'
+                Logger.new($stderr)
+              elsif log_output == 'stdout'
+                Logger.new($stdout)
+              else
+                warn "Invalid MINDEE_LOG_OUTPUT='#{log_output}', defaulting to 'stderr'"
+                Logger.new($stderr)
+              end
     @logger.level = Logger.const_get(log_level)
 
     class << self

data/lib/mindee/page_options.rb

@@ -11,7 +11,7 @@ module Mindee
     attr_accessor :page_indexes, :operation, :on_min_pages
 
     def initialize(params: {})
-      params ||= {}
+      params ||= {} # : Hash[Symbol, untyped]
       params = params.transform_keys(&:to_sym)
       @page_indexes = params.fetch(
         :page_indexes,

data/lib/mindee/pdf/extracted_pdf.rb

@@ -3,57 +3,67 @@
 module Mindee
   # PDF Extraction Module.
   module PDF
-    module PDFExtractor
-      # An extracted sub-Pdf.
-      class ExtractedPDF
-        # Byte contents of the pdf
-        # @return [StringIO]
-        attr_reader :pdf_bytes
-
-        # Name of the file.
-        # @return [String]
-        attr_reader :filename
-
-        # @param pdf_bytes [StringIO]
-        # @param filename [String]
-        def initialize(pdf_bytes, filename)
-          @pdf_bytes = pdf_bytes
-          @filename = filename
-        end
+    # An extracted sub-Pdf.
+    class ExtractedPDF
+      # Byte contents of the pdf
+      # @return [StringIO]
+      attr_reader :pdf_bytes
 
-        # Retrieves the page count for a given pdf.
-        # @return [Integer]
-        def page_count
-          current_pdf = Mindee::PDF::PDFProcessor.open_pdf(pdf_bytes)
-          current_pdf.pages.size
-        rescue TypeError, Origami::InvalidPDFError
-          raise Errors::MindeePDFError, 'Could not retrieve page count from Extracted PDF object.'
-        end
+      # Name of the file.
+      # @return [String]
+      attr_reader :filename
+
+      # @param pdf_stream [StringIO, File]
+      # @param filename [String]
+      def initialize(pdf_stream, filename)
+        @filename = filename
 
-        # Writes the contents of the current PDF object to a file.
-        # @param output_path [String] Path to write to.
-        # @param override [bool] Whether to override the destination file.
-        def write_to_file(output_path, override: false)
-          raise Errors::MindeePDFError, 'Provided path is not a file' if File.directory?(output_path)
-          raise Errors::MindeePDFError, 'Invalid save path provided' unless File.exist?(
-            File.expand_path('..', output_path)
-          ) && !override
-
-          if File.extname(output_path).downcase == 'pdf'
-            base_path = File.expand_path('..', output_path)
-            output_path = File.expand_path("#{File.basename(output_path)}.pdf", base_path)
-          end
-
-          File.write(output_path, @pdf_bytes)
+        if pdf_stream.is_a?(File)
+          pdf_stream.rewind
+          @pdf_bytes = StringIO.new(pdf_stream.read)
+        else
+          @pdf_bytes = pdf_stream
         end
+      end
+
+      # Retrieves the page count for a given pdf.
+      # @return [Integer]
+      def page_count
+        current_pdf = Mindee::PDF::PDFProcessor.open_pdf(pdf_bytes)
+        current_pdf.pages.size
+      rescue TypeError, Origami::InvalidPDFError
+        raise Error::MindeePDFError, 'Could not retrieve page count from Extracted PDF object.'
+      end
 
-        # Returns the current PDF object as a usable BytesInputSource.
-        # @return [Mindee::Input::Source::BytesInputSource]
-        def as_input_source
-          raise Errors::MindeePDFError, 'Bytes object is nil.' if @pdf_bytes.nil?
+      # Writes the contents of the current PDF object to a file.
+      # @param output_path [String] Path to write to.
+      # @param override [bool] Whether to override the destination file.
+      def write_to_file(output_path, override: false)
+        raise Error::MindeePDFError, 'Provided path is not a file' if File.directory?(output_path)
+        raise Error::MindeePDFError, 'Invalid save path provided' unless File.exist?(
+          File.expand_path('..', output_path)
+        ) && !override
 
-          Mindee::Input::Source::BytesInputSource.new(@pdf_bytes.read || '', @filename)
+        if File.extname(output_path).downcase == 'pdf'
+          base_path = File.expand_path('..', output_path)
+          output_path = File.expand_path("#{File.basename(output_path)}.pdf", base_path)
         end
+
+        @pdf_bytes.rewind if @pdf_bytes.respond_to?(:rewind)
+        File.binwrite(output_path, @pdf_bytes.read.to_s)
+        @pdf_bytes.rewind if @pdf_bytes.respond_to?(:rewind)
+      end
+
+      # Returns the current PDF object as a usable BytesInputSource.
+      # @return [Mindee::Input::Source::BytesInputSource]
+      def as_input_source
+        raise Error::MindeePDFError, 'Bytes object is nil.' if @pdf_bytes.nil?
+
+        @pdf_bytes.rewind if @pdf_bytes.respond_to?(:rewind)
+        data = @pdf_bytes.read || ''
+        @pdf_bytes.rewind if @pdf_bytes.respond_to?(:rewind)
+
+        Mindee::Input::Source::BytesInputSource.new(data, @filename)
       end
     end
   end

data/lib/mindee/pdf/pdf_compressor.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
+Mindee::Dependency.require_all_deps!
 require 'pdf-reader'
+
 # Shorthand for pdf-reader's PDF namespace, to avoid mixups with the local Origami fork.
 PDFReader = PDF
 

data/lib/mindee/pdf/pdf_extractor.rb

@@ -3,118 +3,119 @@
 module Mindee
   # Pdf Extraction Module.
   module PDF
-    # Pdf Extraction class.
-    module PDFExtractor
-      # Pdf extraction class.
-      class PDFExtractor
-        # @param local_input [Mindee::Input::Source::LocalInputSource]
-        def initialize(local_input)
-          @filename = local_input.filename
-          if local_input.pdf?
-            @source_pdf = local_input.io_stream
-          else
-            pdf_image = Image::ImageExtractor.attach_image_as_new_file(local_input.io_stream)
-            io_buffer = StringIO.new
-            pdf_image.save(io_buffer)
-
-            @source_pdf = io_buffer
-          end
+    # Pdf extraction class.
+    class PDFExtractor
+      # @param local_input [Mindee::Input::Source::LocalInputSource]
+      def initialize(local_input)
+        unless Mindee::Dependency.all_deps_available?
+          raise NotImplementedError, Mindee::Dependency::MINDEE_DEPENDENCIES_LOAD_ERROR
         end
 
-        # Retrieves the page count for the Pdf object.
-        # @return [Integer]
-        def page_count
-          Mindee::PDF::PDFProcessor.open_pdf(@source_pdf).pages.size
+        @filename = local_input.filename
+        if local_input.pdf?
+          @source_pdf = local_input.io_stream
+        else
+          pdf_image = Image::ImageExtractor.attach_image_as_new_file(local_input.io_stream)
+          io_buffer = StringIO.new
+          pdf_image.save(io_buffer)
+
+          @source_pdf = io_buffer
         end
+      end
 
-        # Creates a new Pdf from pages and save it into a buffer.
-        # @param page_indexes [Array<Integer>] List of page number to use for merging in the original Pdf.
-        # @return [StringIO] The buffer containing the new Pdf.
-        def cut_pages(page_indexes)
-          options = PageOptions.new(params: {
-                                      page_indexes: page_indexes,
-                                    })
+      # Retrieves the page count for the Pdf object.
+      # @return [Integer]
+      def page_count
+        Mindee::PDF::PDFProcessor.open_pdf(@source_pdf).pages.size
+      end
 
-          Mindee::PDF::PDFProcessor.parse(@source_pdf, options)
-        end
+      # Creates a new Pdf from pages and save it into a buffer.
+      # @param page_indexes [Array<Integer>] List of page number to use for merging in the original Pdf.
+      # @return [StringIO] The buffer containing the new Pdf.
+      def cut_pages(page_indexes)
+        options = PageOptions.new(params: {
+                                    page_indexes: page_indexes,
+                                  })
 
-        # Extract the sub-documents from the main pdf, based on the given list of page indexes.
-        # @param page_indexes [Array<Array<Integer>>] List of page number to use for merging in the original Pdf.
-        # @return [Array<Mindee::PDF::PDFExtractor::ExtractedPDF>] The buffer containing the new Pdf.
-        def extract_sub_documents(page_indexes)
-          extracted_pdfs = []
-          extension = File.extname(@filename)
-          basename = File.basename(@filename, extension)
-          page_indexes.each do |page_index_list|
-            if page_index_list.nil? || page_index_list.empty?
-              raise Errors::MindeePDFError, "Empty indexes aren't allowed for extraction #{page_index_list}"
-            end
+        Mindee::PDF::PDFProcessor.parse(@source_pdf, options)
+      end
+
+      # Extract the sub-documents from the main pdf, based on the given list of page indexes.
+      # @param page_indexes [Array<Array<Integer>>] List of page number to use for merging in the original Pdf.
+      # @return [Array<Mindee::PDF::ExtractedPDF>] The buffer containing the new Pdf.
+      def extract_sub_documents(page_indexes)
+        extracted_pdfs = [] # @type var extracted_pdfs: Array[Mindee::PDF::ExtractedPDF]
+        extension = File.extname(@filename)
+        basename = File.basename(@filename, extension)
+        page_indexes.each do |page_index_list|
+          if page_index_list.nil? || page_index_list.empty?
+            raise Error::MindeePDFError, "Empty indexes aren't allowed for extraction #{page_index_list}"
+          end
 
-            page_index_list.each do |page_index|
-              if (page_index > page_count) || page_index.negative?
-                raise Errors::MindeePDFError,
-                      "Index #{page_index} is out of range."
-              end
+          page_index_list.each do |page_index|
+            if (page_index > page_count) || page_index.negative?
+              raise Error::MindeePDFError,
+                    "Index #{page_index} is out of range."
             end
-            formatted_max_index = format('%03d', page_index_list[page_index_list.length - 1] + 1).to_s
-            field_filename = "#{basename}_#{format('%03d',
-                                                   page_index_list[0] + 1)}-#{formatted_max_index}#{extension}"
-            extracted_pdf = Mindee::PDF::PDFExtractor::ExtractedPDF.new(cut_pages(page_index_list),
-                                                                        field_filename)
-            extracted_pdfs << extracted_pdf
           end
-          extracted_pdfs
+          formatted_max_index = format('%03d', page_index_list[-1] + 1).to_s
+          field_filename = "#{basename}_#{format('%03d',
+                                                 page_index_list[0] + 1)}-#{formatted_max_index}#{extension}"
+          extracted_pdf = Mindee::PDF::ExtractedPDF.new(cut_pages(page_index_list),
+                                                        field_filename)
+          extracted_pdfs << extracted_pdf
         end
+        extracted_pdfs
+      end
 
-        # rubocop:disable Metrics/CyclomaticComplexity
-        # rubocop:disable Metrics/PerceivedComplexity
+      # rubocop:disable Metrics/CyclomaticComplexity
+      # rubocop:disable Metrics/PerceivedComplexity
 
-        # Extracts invoices as complete PDFs from the document.
-        # @param page_indexes [Array<Array<Integer>, InvoiceSplitterV1InvoicePageGroup>]
-        # @param strict [bool]
-        # @return [Array<Mindee::PDF::PDFExtractor::ExtractedPDF>]
-        def extract_invoices(page_indexes, strict: false)
-          raise Errors::MindeePDFError, 'No indexes provided.' if page_indexes.empty?
+      # Extracts invoices as complete PDFs from the document.
+      # @param page_indexes [Array<Array<Integer>, InvoiceSplitterV1InvoicePageGroup>]
+      # @param strict [bool]
+      # @return [Array<Mindee::PDF::ExtractedPDF>]
+      def extract_invoices(page_indexes, strict: false)
+        raise Error::MindeePDFError, 'No indexes provided.' if page_indexes.empty?
 
-          if page_indexes[0].is_a?(Array) && page_indexes[0].all? { |i| i.is_a?(Integer) }
-            page_indexes_as_array = page_indexes # @type var page_indexes : Array[Array[Integer]]
-            return extract_sub_documents(page_indexes_as_array)
-          end
-          p_ids = page_indexes # @type var page_indexes: Product::InvoiceSplitter::InvoiceSplitterV1InvoicePageGroups
-          return extract_sub_documents(p_ids.map(&:page_indexes)) unless strict
-
-          correct_page_indexes = []
-          current_list = []
-          previous_confidence = nil
-          p_ids.each_with_index do |p_i, i|
-            page_index = p_i # @type var page_index: Product::InvoiceSplitter::InvoiceSplitterV1InvoicePageGroup
-            confidence = page_index.confidence.to_f
-            page_list = page_index.page_indexes
-
-            if confidence >= 0.5 && previous_confidence.nil?
-              current_list = page_list
-            elsif confidence >= 0.5 && i < p_ids.length - 1
-              correct_page_indexes << current_list
-              current_list = page_list
-            elsif confidence < 0.5 && i == p_ids.length - 1
-              current_list.concat page_list
-              correct_page_indexes << current_list
-            else
-              correct_page_indexes << current_list
-              correct_page_indexes << page_list
-            end
-            previous_confidence = confidence
+        if page_indexes[0].is_a?(Array) && page_indexes[0].all?(Integer)
+          page_indexes_as_array = page_indexes # @type var page_indexes : Array[Array[Integer]]
+          return extract_sub_documents(page_indexes_as_array)
+        end
+        p_ids = page_indexes # @type var page_indexes: Product::InvoiceSplitter::InvoiceSplitterV1InvoicePageGroups
+        return extract_sub_documents(p_ids.map(&:page_indexes)) unless strict
+
+        correct_page_indexes = [] # @type var correct_page_indexes: Array[Array[Integer]]
+        current_list = [] # @type var current_list: Array[Integer]
+        previous_confidence = nil
+        p_ids.each_with_index do |p_i, i|
+          page_index = p_i # @type var page_index: Product::InvoiceSplitter::InvoiceSplitterV1InvoicePageGroup
+          confidence = page_index.confidence.to_f
+          page_list = page_index.page_indexes
+
+          if confidence >= 0.5 && previous_confidence.nil?
+            current_list = page_list
+          elsif confidence >= 0.5 && i < p_ids.length - 1
+            correct_page_indexes << current_list
+            current_list = page_list
+          elsif confidence < 0.5 && i == p_ids.length - 1
+            current_list.concat page_list
+            correct_page_indexes << current_list
+          else
+            correct_page_indexes << current_list
+            correct_page_indexes << page_list
           end
-          extract_sub_documents(correct_page_indexes)
+          previous_confidence = confidence
         end
+        extract_sub_documents(correct_page_indexes)
+      end
 
-        # rubocop:enable Metrics/CyclomaticComplexity
-        # rubocop:enable Metrics/PerceivedComplexity
+      # rubocop:enable Metrics/CyclomaticComplexity
+      # rubocop:enable Metrics/PerceivedComplexity
 
-        private
+      private
 
-        attr_reader :source_pdf, :filename
-      end
+      attr_reader :source_pdf, :filename
     end
   end
 end

data/lib/mindee/pdf/pdf_processor.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'set'
+Mindee::Dependency.require_all_deps!
 require 'origami'
 require_relative 'pdf_tools'
 
@@ -61,6 +61,11 @@ module Mindee
       # @param io_stream [StringIO]
       # @return [Origami::PDF]
       def self.open_pdf(io_stream)
+        unless PDFTools.pdf_header?(io_stream)
+          raise Origami::InvalidPDFError,
+                'Input stream does not contain a PDF header.'
+        end
+
         pdf_parser = Origami::PDF::LinearParser.new({ verbosity: Origami::Parser::VERBOSE_QUIET })
         io_stream.seek(0)
         pdf_parser.parse(io_stream)

data/lib/mindee/pdf/pdf_tools.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+Mindee::Dependency.require_all_deps!
 require 'origami'
 
 module Mindee
@@ -53,10 +54,28 @@ module Mindee
         text_operators.any? { |op| data.include?(op) }
       end
 
+      # Checks whether a stream contains a PDF header near the beginning.
+      # @param [StringIO] io_stream Binary-encoded stream.
+      # @param [Integer] maximum_offset Maximum allowed offset to find '%PDF-'.
+      # @return [bool] `true` when the stream appears to be a PDF.
+      def self.pdf_header?(io_stream, maximum_offset: 500)
+        initial_pos = nil
+        initial_pos = io_stream.pos if io_stream.respond_to?(:pos)
+        io_stream.seek(0)
+        io_stream.gets('%PDF-')
+        !(io_stream.eof? || io_stream.pos > maximum_offset)
+      rescue TypeError, IOError, SystemCallError
+        false
+      ensure
+        io_stream.seek(initial_pos) if !initial_pos.nil? && io_stream.respond_to?(:seek)
+      end
+
       # Checks whether the file has source_text. Sends false if the file isn't a PDF.
       # @param [StringIO] pdf_data Abinary-encoded stream representing the PDF file.
       # @return [bool] `true` if the pdf has source text, false otherwise.
       def self.source_text?(pdf_data)
+        return false unless pdf_header?(pdf_data)
+
         begin
           pdf_data.rewind
           pdf = Origami::PDF.read(pdf_data)