mindee 4.12.0 → 5.0.0.beta1

data/lib/mindee/http.rb

@@ -1,7 +1,3 @@
 # frozen_string_literal: true
 
-require_relative 'http/api_settings_v2'
-require_relative 'http/endpoint'
 require_relative 'http/http_error_handler'
-require_relative 'http/mindee_api_v2'
-require_relative 'http/workflow_endpoint'

data/lib/mindee/image/extracted_image.rb

@@ -18,23 +18,29 @@ module Mindee
       attr_reader :buffer
 
       # Internal name for the file.
-      attr_reader :internal_file_name
+      attr_reader :filename
 
       # Initializes the ExtractedImage with a buffer and an internal file name.
       #
-      # @param input_source [LocalInputSource] Local source for input.
+      # @param input_source [LocalInputSource, BytesInputSource] Local source for input.
       # @param page_id [Integer] ID of the page the element was found on.
       # @param element_id [Integer, nil] ID of the element in a page.
-      def initialize(input_source, page_id, element_id)
+      # @param preserve_input_filename [Boolean] If true, keep the input source filename as-is.
+      def initialize(input_source, page_id, element_id, preserve_input_filename: false)
         @buffer = StringIO.new(input_source.io_stream.read.to_s)
         @buffer.rewind
-        extension = if input_source.pdf?
-                      '.jpg'
+
+        @filename = if preserve_input_filename
+                      input_source.filename.to_s
                     else
-                      File.extname(input_source.filename)
+                      extension = if input_source.pdf?
+                                    '.jpg'
+                                  else
+                                    File.extname(input_source.filename)
+                                  end
+                      base_name = File.basename(input_source.filename, File.extname(input_source.filename))
+                      "#{base_name}_p#{page_id}_#{element_id}#{extension}"
                     end
-        base_name = File.basename(input_source.filename, File.extname(input_source.filename))
-        @internal_file_name = "#{base_name}_p#{page_id}_#{element_id}#{extension}"
         @page_id = page_id
         @element_id = element_id.nil? ? 0 : element_id
       end
@@ -48,7 +54,7 @@ module Mindee
       def write_to_file(output_path, file_format = nil)
         resolved_path = Pathname.new(File.expand_path(output_path))
         if file_format.nil?
-          raise Errors::MindeeImageError, 'Invalid file format.' if resolved_path.extname.delete('.').empty?
+          raise Error::MindeeImageError, 'Invalid file format.' if resolved_path.extname.delete('.').empty?
 
           file_format = resolved_path.extname.delete('.').upcase
         end
@@ -59,8 +65,8 @@ module Mindee
           image.write resolved_path.to_s
           logger.info("File saved successfully to '#{resolved_path}'")
         rescue StandardError
-          raise Errors::MindeeImageError, "Could not save file '#{output_path}'. " \
-                                          'Is the provided file path valid?.'
+          raise Error::MindeeImageError, "Could not save file '#{output_path}'. " \
+                                         'Is the provided file path valid?.'
         end
       end
 
@@ -69,7 +75,14 @@ module Mindee
       # @return [FileInputSource] A BufferInput source.
       def as_source
         @buffer.rewind
-        Mindee::Input::Source::BytesInputSource.new(@buffer.read || '', @internal_file_name)
+        Mindee::Input::Source::BytesInputSource.new(@buffer.read || '', @filename)
+      end
+
+      # Return the file as a Mindee-compatible BufferInput source.
+      #
+      # @return [FileInputSource] A BufferInput source.
+      def as_input_source
+        as_source
       end
     end
   end

data/lib/mindee/image/image_extractor.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+Mindee::Dependency.require_all_deps!
 require 'mini_magick'
 require 'origami'
 require 'stringio'
@@ -47,7 +48,7 @@ module Mindee
       # @param [Array<Geometry::Point, Geometry::Polygon, Geometry::Quadrilateral>] polygons
       # @return [Array<Image::ExtractedImage>] Extracted Images.
       def self.extract_images_from_polygons(input_source, pdf_stream, page_id, polygons)
-        extracted_elements = []
+        extracted_elements = [] # @type var extracted_elements: Array[Image::ExtractedImage]
 
         polygons.each_with_index do |polygon, element_id|
           polygon = ImageUtils.normalize_polygon(polygon)
@@ -94,7 +95,8 @@ module Mindee
         ExtractedImage.new(
           Input::Source::BytesInputSource.new(buffer.read.to_s, file_name),
           page_id,
-          element_id
+          element_id,
+          preserve_input_filename: true
         )
       end
 

data/lib/mindee/image/image_utils.rb

@@ -37,7 +37,7 @@ module Mindee
           MiniMagick::Image.read(image)
         else
           img_class = image.class ? image.class.to_s : 'unknown format'
-          raise Errors::MindeeImageError, "Expected an I/O object or a MiniMagick::Image. '#{img_class}' given instead."
+          raise Error::MindeeImageError, "Expected an I/O object or a MiniMagick::Image. '#{img_class}' given instead."
         end
       end
 
@@ -60,7 +60,7 @@ module Mindee
       # @param max_width [Integer] Maximum width. If not specified, the horizontal ratio will remain the same.
       # @param max_height [Integer] Maximum height. If not specified, the vertical ratio will remain the same.
       def self.calculate_new_dimensions(original, max_width: nil, max_height: nil)
-        raise Errors::MindeeImageError, 'Provided image could not be processed for resizing.' if original.nil?
+        raise Error::MindeeImageError, 'Provided image could not be processed for resizing.' if original.nil?
 
         return [original.width, original.height] if max_width.nil? && max_height.nil?
 
@@ -111,7 +111,7 @@ module Mindee
         elsif polygon.is_a?(Mindee::Geometry::Quadrilateral)
           polygon
         else
-          raise Errors::MindeeGeometryError, 'Provided polygon has an invalid type.'
+          raise Error::MindeeGeometryError, 'Provided polygon has an invalid type.'
         end
       end
 

data/lib/mindee/input/base_parameters.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+module Mindee
+  module Input
+    # Base class for parameters accepted by all V2 endpoints.
+    class BaseParameters
+      # @return [String] ID of the model (required).
+      attr_reader :model_id
+
+      # @return [String, nil] Optional alias for the file.
+      attr_reader :file_alias
+
+      # @return [Array<String>, nil] Optional list of Webhooks IDs to propagate the API response to.
+      attr_reader :webhook_ids
+
+      # @return [PollingOptions] Options for polling. Set only if having timeout issues.
+      attr_reader :polling_options
+
+      # @return [Boolean, nil] Whether to close the file after parsing.
+      attr_reader :close_file
+
+      # @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
+      )
+        raise Error::MindeeInputError, 'Model ID is required.' if model_id.empty? || model_id.nil?
+
+        @model_id = model_id
+        @file_alias = file_alias
+        @webhook_ids = webhook_ids || []
+        @polling_options = get_clean_polling_options(polling_options)
+        @close_file = close_file.nil? || close_file
+      end
+
+      # @return [String] Slug for the endpoint.
+      def self.slug
+        if self == BaseParameters
+          raise NotImplementedError, 'Cannot access `slug` directly on the BaseParameters class.'
+        end
+
+        ''
+      end
+
+      # @return [String] Slug for the endpoint.
+      def slug
+        self.class.slug
+      end
+
+      # Load from a hash
+      # @param [Hash] params Parameters to provide as a hash.
+      # @return [BaseParameters]
+      def self.from_hash(params: {})
+        load_from_hash(params: params)
+        new(
+          params[:model_id],
+          file_alias: params[:file_alias],
+          webhook_ids: params[:webhook_ids],
+          polling_options: params[:polling_options],
+          close_file: params[:close_file]
+        )
+      end
+
+      # Loads a prediction from a Hash.
+      # @param [Hash] params Parameters to provide as a hash.
+      # @return [Hash]
+      def self.load_from_hash(params: {})
+        params.transform_keys!(&:to_sym)
+
+        if params.empty? || params[:model_id].nil? || params[:model_id].empty?
+          raise Error::MindeeInputError, 'Model ID is required.'
+        end
+
+        polling_options_input = params.fetch(:page_options, PollingOptions.new)
+        if polling_options_input.is_a?(Hash)
+          polling_options_input = polling_options_input.transform_keys(&:to_sym)
+          PollingOptions.new(
+            initial_delay_sec: polling_options_input.fetch(:initial_delay_sec, 2.0),
+            delay_sec: polling_options_input.fetch(:delay_sec, 1.5),
+            max_retries: polling_options_input.fetch(:max_retries, 80)
+          )
+        end
+        params
+      end
+
+      # Appends base form data to the provided array.
+      # @param [Array] form_data Array of form fields
+      # @return [Array]
+      def append_form_data(form_data)
+        form_data.push(['file_alias', @file_alias]) if @file_alias
+        webhook_ids = @webhook_ids || []
+        form_data.push(['webhook_ids', webhook_ids.join(',')]) unless @webhook_ids.nil? || webhook_ids.empty?
+        form_data
+      end
+
+      # Validates the parameters for async auto-polling
+      def validate_async_params
+        min_delay_sec = 1
+        min_initial_delay_sec = 1
+        min_retries = 2
+
+        if @polling_options.delay_sec < min_delay_sec
+          raise ArgumentError,
+                "Cannot set auto-poll delay to less than #{min_delay_sec} second(s)"
+        end
+        if @polling_options.initial_delay_sec < min_initial_delay_sec
+          raise ArgumentError,
+                "Cannot set initial parsing delay to less than #{min_initial_delay_sec} second(s)"
+        end
+        return unless @polling_options.max_retries < min_retries
+
+        raise ArgumentError,
+              "Cannot set auto-poll retries to less than #{min_retries}"
+      end
+
+      private
+
+      # Cleans a proper polling options object potentially from a hash.
+      # @param [Hash, PollingOptions, nil] polling_options Polling options.
+      # @return [PollingOptions] Valid polling options object.
+      def get_clean_polling_options(polling_options)
+        return PollingOptions.new if polling_options.is_a?(PollingOptions)
+
+        if polling_options.is_a?(Hash)
+          polling_options = polling_options.transform_keys(&:to_sym)
+          output_polling_options = PollingOptions.new(
+            initial_delay_sec: polling_options.fetch(:initial_delay_sec, 2.0),
+            delay_sec: polling_options.fetch(:delay_sec, 1.5),
+            max_retries: polling_options.fetch(:max_retries, 80)
+          )
+        else
+          output_polling_options = if polling_options.is_a?(PollingOptions)
+                                     polling_options || PollingOptions.new
+                                   else
+                                     PollingOptions.new
+                                   end
+        end
+        output_polling_options
+      end
+    end
+  end
+end

data/lib/mindee/input/local_response.rb

@@ -27,7 +27,7 @@ module Mindee
                   end
           @file.rewind
         else
-          raise Errors::MindeeInputError, "Incompatible type for input '#{input_file.class}'."
+          raise Error::MindeeInputError, "Incompatible type for input '#{input_file.class}'."
         end
       end
 
@@ -35,10 +35,10 @@ module Mindee
       # @return [Hash]
       def as_hash
         @file.rewind
-        file_str = @file.read
+        file_str = @file.read or raise 'File could not be read'
         JSON.parse(file_str, object_class: Hash)
       rescue JSON::ParserError
-        raise Errors::MindeeInputError, "File is not a valid dict. #{file_str}"
+        raise Error::MindeeInputError, "File is not a valid dict. #{file_str}"
       end
 
       # Processes the secret key
@@ -54,9 +54,10 @@ module Mindee
         algorithm = OpenSSL::Digest.new('sha256')
         begin
           @file.rewind
-          mac = OpenSSL::HMAC.hexdigest(algorithm, self.class.process_secret_key(secret_key), @file.read)
+          mac = OpenSSL::HMAC.hexdigest(algorithm, self.class.process_secret_key(secret_key),
+                                        @file.read || raise('File could not be read'))
         rescue StandardError
-          raise Errors::MindeeInputError, 'Could not get HMAC signature from payload.'
+          raise Error::MindeeInputError, 'Could not get HMAC signature from payload.'
         end
         mac
       end
@@ -69,12 +70,10 @@ module Mindee
       end
 
       # Deserializes a loaded response
-      # @param response_class [Parsing::V2::CommonResponse] class to return.
-      # @return [Parsing::V2::JobResponse, Parsing::V2::InferenceResponse]
+      # @param response_class [Class<V2::Parsing::BaseResponse>] class to return.
+      # @return [V2::Parsing::JobResponse, Mindee::V2::Parsing::BaseResponse]
       def deserialize_response(response_class)
-        response_class.new(as_hash) # : Parsing::V2::JobResponse | Parsing::V2::InferenceResponse
-      rescue StandardError
-        raise Errors::MindeeInputError, 'Invalid response provided.'
+        response_class.new(as_hash) # : Mindee::V2::Parsing::JobResponse | Mindee::V2::Parsing::BaseResponse
       end
     end
   end

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