mindee 3.14.0 → 3.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '043953eb35ed9f251d12ca8b984edcf9acbeb491689574450dc3682b83e9db37'
-  data.tar.gz: 5916ad8aeada6713ee5a846d634693fd1ed5e585495238649f9a9c1d2e9fbd00
+  metadata.gz: 9d356c6733d8a7d00973b219dbae06199040ca8d4bece4eb3906c8ec873aebf0
+  data.tar.gz: ab240a95c8538891aa4a3ef48285903daa06cebaf13f9578eff1a9675258d3bb
 SHA512:
-  metadata.gz: 7edd036d9666e1ffe0318b8ec68cdfe5b37b6bdbb90e36ae0c19efa5cc038f109af30d9e6df6838e4237db2f9495a6251f10164db7e0c7dff528720ef4477a2a
-  data.tar.gz: 7dfbb27c5175bda760ba816be62b1447acf4517d6741506cb458bbe4b2b4c77338eff1d799d19f4b0bdca663323523eb479bc468e80f9ed1943226694ef04143
+  metadata.gz: ec71145b9604ba30c77a842a33c89c1ad4ab4c70301c3eed2292bc95803dd112ee99c964289ca88c16ddffcb6a37f63130b30a23326b4359929791d0dcef4214
+  data.tar.gz: 0c20c191f6abe4166075a1745860ba500a488294bcb59e2a28e0b61a3bcee07a25be2adfef113d045727eeaf10f935278271a7d259f78d63e580bf8eda3833f3

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Mindee Ruby API Library Changelog
 
+## v3.15.0 - 2024-10-29
+### Changes
+* :sparkles: add support for image compression
+* :sparkles: add support for PDF compression
+### Fixes
+* :recycle: refactor pdf & image namespaces
+* :memo: fix rubocop directives unexpectedly appearing in Yard documentation
+* :arrow_up: bump version for mini_magick
+
+
 ## v3.14.0 - 2024-10-11
 ### Changes
 * :sparkles: add support for Financial Document v1.10

data/lib/mindee/client.rb

@@ -128,6 +128,7 @@ module Mindee
     end
 
     # rubocop:disable Metrics/ParameterLists
+
     # Enqueue a document for async parsing and automatically try to retrieve it
     #
     # @param input_source [Mindee::Input::Source::LocalInputSource, Mindee::Input::Source::UrlInputSource]

data/lib/mindee/extraction/common/extracted_image.rb

@@ -54,7 +54,6 @@ module Mindee
         image = MiniMagick::Image.read(@buffer)
         image.format file_format.downcase
         image.write resolved_path.to_s
-        logger.info("File saved successfully to '#{resolved_path}'.")
       rescue TypeError
         raise 'Invalid path/filename provided.'
       rescue StandardError

data/lib/mindee/extraction/common/image_extractor.rb

@@ -11,8 +11,8 @@ module Mindee
   # Image Extraction Module.
   module Extraction
     # Image Extraction wrapper class.
-    class ImageExtractor
-      def self.attach_image_as_new_file(input_buffer)
+    module ImageExtractor
+      def self.attach_image_as_new_file(input_buffer, format: 'jpg')
         # Attaches an image as a new page in a PdfDocument object.
         #
         # @param [StringIO] input_buffer Input buffer. Only supports JPEG.
@@ -21,9 +21,9 @@ module Mindee
         magick_image = MiniMagick::Image.read(input_buffer)
         # NOTE: some jpeg images get rendered as three different versions of themselves per output if the format isn't
         # converted.
-        magick_image.format('jpg')
+        magick_image.format(format)
         original_density = magick_image.resolution
-        scale_factor = original_density[0].to_f / 4.166666 # No clue why bit the resolution needs to be reduced for
+        scale_factor = original_density[0].to_f / 4.166666 # No clue why the resolution needs to be reduced for
         # the pdf otherwise the resulting image shrinks.
         magick_image.format('pdf', 0, { density: scale_factor.to_s })
         Origami::PDF.read(StringIO.new(magick_image.to_blob))
@@ -37,27 +37,12 @@ module Mindee
       # to extract.
       # @return [Array<Mindee::Extraction::ExtractedImage>] Extracted Images.
       def self.extract_multiple_images_from_source(input_source, page_id, polygons)
-        new_stream = load_doc(input_source, page_id)
+        new_stream = load_input_source_pdf_page_as_image(input_source, page_id)
         new_stream.seek(0)
 
         extract_images_from_polygons(input_source, new_stream, page_id, polygons)
       end
 
-      # Retrieves a PDF document's page.
-      #
-      # @param [Origami::PDF] pdf_doc Origami PDF handle.
-      # @param [Integer] page_id Page ID.
-      def self.get_page(pdf_doc, page_id)
-        stream = StringIO.new
-        pdf_doc.save(stream)
-
-        options = {
-          page_indexes: [page_id - 1],
-        }
-
-        Mindee::PDF::PdfProcessor.parse(stream, options)
-      end
-
       # Extracts images from their positions on a file (as polygons).
       #
       # @param [Mindee::Input::Source::LocalInputSource] input_source Local input source.
@@ -179,10 +164,10 @@ module Mindee
       # @param input_file [LocalInputSource] Local input.
       # @param [Integer] page_id Page ID.
       # @return [MiniMagick::Image] A valid PdfDocument handle.
-      def self.load_doc(input_file, page_id)
+      def self.load_input_source_pdf_page_as_image(input_file, page_id)
         input_file.io_stream.rewind
         if input_file.pdf?
-          get_page(Origami::PDF.read(input_file.io_stream), page_id)
+          Mindee::PDF::PdfProcessor.get_page(Origami::PDF.read(input_file.io_stream), page_id)
         else
           input_file.io_stream
         end

data/lib/mindee/extraction/pdf_extractor/pdf_extractor.rb

@@ -65,6 +65,7 @@ module Mindee
 
         # rubocop:disable Metrics/CyclomaticComplexity
         # rubocop:disable Metrics/PerceivedComplexity
+
         # Extracts invoices as complete PDFs from the document.
         # @param page_indexes [Array<Array<Integer>, InvoiceSplitterV1PageGroup>]
         # @param strict [Boolean]
@@ -99,6 +100,7 @@ module Mindee
           end
           extract_sub_documents(correct_page_indexes)
         end
+
         # rubocop:enable Metrics/CyclomaticComplexity
         # rubocop:enable Metrics/PerceivedComplexity
 

data/lib/mindee/extraction/tax_extractor/tax_extractor.rb

@@ -271,6 +271,7 @@ module Mindee
         end
         candidates
       end
+
       # rubocop:enable Metrics/CyclomaticComplexity
       # rubocop:enable Metrics/PerceivedComplexity
 

data/lib/mindee/geometry/point.rb

@@ -10,9 +10,10 @@ module Mindee
       # @return [Float]
       attr_accessor :y
 
+      # rubocop:disable Naming/MethodParameterName
+
       # @param x [Float]
       # @param y [Float]
-      # rubocop:disable Naming/MethodParameterName
       def initialize(x, y)
         @x = x
         @y = y

data/lib/mindee/image/image_compressor.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Mindee
+  # Image processing module.
+  module Image
+    # Image compressor module to handle image compression.
+    module ImageCompressor
+      # Resize and/or compress an SKBitmap. This assumes the ratio was provided before hands.
+      # @param image [MiniMagick::Image, StringIO] Input image.
+      # @param quality [Integer, nil] Quality of the final file.
+      # @param max_width [Integer, nil] 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.
+      # @return [StringIO]
+      def self.compress_image(image, quality: 85, max_width: nil, max_height: nil)
+        processed_image = ImageUtils.to_image(image)
+        processed_image.format 'jpg'
+        final_width, final_height = ImageUtils.calculate_new_dimensions(
+          processed_image,
+          max_width: max_width,
+          max_height: max_height
+        )
+        ImageUtils.resize_image(processed_image, final_width, final_height) if final_width || final_height
+        ImageUtils.compress_image_quality(processed_image, quality)
+
+        ImageUtils.image_to_stringio(processed_image)
+      end
+    end
+  end
+end

data/lib/mindee/image/image_utils.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module Mindee
+  # Image processing module.
+  module Image
+    # Miscellaneous image operations.
+    module ImageUtils
+      # Resizes a provided MiniMagick Image with the given width & height, if present.
+      # @param image [MiniMagick::Image] MiniMagick image handle.
+      # @param width [Integer] Width to comply with.
+      # @param height [Integer] Height to comply with.
+      def self.resize_image(image, width, height)
+        if width && height
+          image.resize "#{width}x#{height}"
+        elsif width
+          image.resize width.to_s
+        elsif height
+          image.resize "x#{height}"
+        end
+      end
+
+      # Compresses the quality of the provided MiniMagick image.
+      # @param image [MiniMagick::Image] MiniMagick image handle.
+      # @param quality [Integer] Quality to apply to the image. This is independent of a JPG's base quality.
+      def self.compress_image_quality(image, quality)
+        image.quality quality.to_s
+      end
+
+      # Mostly here so that IDEs don't get confused on the type (@type annotation fails sometimes.)
+      # @param [MiniMagick::Image, StringIO, File, Tempfile] image The input image
+      # @return [MiniMagick::Image]
+      def self.to_image(image)
+        if image.respond_to?(:read) && image.respond_to?(:rewind)
+          image.rewind
+          MiniMagick::Image.read(image)
+        elsif image.is_a?(MiniMagick::Image)
+          image
+        else
+          raise "Expected an I/O object or a MiniMagick::Image. '#{image.class}' given instead."
+        end
+      end
+
+      # Converts a StringIO containing an image into a MiniMagick image.
+      # @param image [MiniMagick::Image] the input image.
+      # @param format [String] Format parameter, left open for the future, but should be JPEG for current use-cases.
+      # @return [StringIO]
+      def self.image_to_stringio(image, format = 'JPEG')
+        image.format format
+        blob = image.to_blob
+        stringio = StringIO.new(blob)
+        stringio.rewind
+
+        stringio
+      end
+
+      # Computes the new dimensions for a given SKBitmap, and returns a scaled down version of it relative to the
+      # provided bounds.
+      # @param [MiniMagick::Image] original Input MiniMagick image.
+      # @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 'Provided image could not be processed for resizing.' if original.nil?
+
+        return [original.width, original.height] if max_width.nil? && max_height.nil?
+
+        width_ratio = max_width ? max_width.to_f / original.width : Float::INFINITY
+        height_ratio = max_height ? max_height.to_f / original.height : Float::INFINITY
+
+        scale_factor = [width_ratio, height_ratio].min
+
+        new_width = (original.width * scale_factor).to_i
+        new_height = (original.height * scale_factor).to_i
+
+        [new_width, new_height]
+      end
+
+      # Computes the Height & Width from a page's media box. Falls back to the size of the initial image.
+      # @param image [MiniMagick::Image] The initial image that will fit into the page.
+      # @param media_box [Array<Integer>, nil]
+      # @return [Array<Integer>]
+      def self.calculate_dimensions_from_media_box(image, media_box)
+        if !media_box.nil? && media_box.any?
+          [
+            media_box[2]&.to_i || image[:width].to_i,
+            media_box[3]&.to_i || image[:height].to_i,
+          ]
+        else
+          [image[:width].to_i, image[:height].to_i]
+        end
+      end
+
+      # Transforms a PDF into a MagickImage. This is currently used for single-page PDFs.
+      # @param pdf_stream [StringIO] Input stream.
+      # @param image_quality [Integer] Quality to apply to the image.
+      # @return [MiniMagick::Image]
+      def self.pdf_to_magick_image(pdf_stream, image_quality)
+        compressed_image = MiniMagick::Image.read(pdf_stream.read)
+        compressed_image.format('jpg')
+        compressed_image.quality image_quality.to_s
+        compressed_image
+      end
+    end
+  end
+end

data/lib/mindee/image.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative 'image/image_compressor'
+require_relative 'image/image_utils'

data/lib/mindee/input/sources.rb

@@ -4,6 +4,7 @@ require 'stringio'
 require 'marcel'
 
 require_relative '../pdf'
+require_relative '../image'
 
 module Mindee
   module Input
@@ -126,6 +127,41 @@ module Mindee
           pdf_processor = Mindee::PDF::PdfProcessor.open_pdf(@io_stream)
           pdf_processor.pages.size
         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).
+        # @param [Integer, nil] max_height Maximum height (Ignored for PDFs).
+        # @param [Boolean] force_source_text Whether to force the operation on PDFs with source text.
+        #   This will attempt to re-render PDF text over the rasterized original. If disabled, ignored the operation.
+        #   WARNING: this operation is strongly discouraged.
+        # @param [Boolean] 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)
+          buffer = if pdf?
+                     Mindee::PDF::PDFCompressor.compress_pdf(
+                       @io_stream,
+                       quality: quality,
+                       force_source_text_compression: force_source_text,
+                       disable_source_text: disable_source_text
+                     )
+                   else
+                     Mindee::Image::ImageCompressor.compress_image(
+                       @io_stream,
+                       quality: quality,
+                       max_width: max_width,
+                       max_height: max_height
+                     )
+                   end
+          @io_stream = buffer
+          @io_stream.rewind
+        end
+
+        # Checks whether the file has source text if it is a pdf. False otherwise
+        # @return [Boolean] True if the file is a PDF and has source text.
+        def source_text?
+          Mindee::PDF::PDFTools.source_text?(@io_stream)
+        end
       end
 
       # Load a document from a path.

data/lib/mindee/parsing/standard/position_field.rb

@@ -31,6 +31,8 @@ module Mindee
 
         # rubocop:disable Metrics/CyclomaticComplexity
         # rubocop:disable Metrics/PerceivedComplexity
+
+        # String representation.
         # @return [String]
         def to_s
           return "Polygon with #{@polygon.size} points." if @polygon&.size&.positive?
@@ -40,6 +42,7 @@ module Mindee
 
           ''
         end
+
         # rubocop:enable Metrics/CyclomaticComplexity
         # rubocop:enable Metrics/PerceivedComplexity
 

data/lib/mindee/pdf/pdf_compressor.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require 'pdf-reader'
+PDFReader = PDF
+
+module Mindee
+  module PDF
+    # Image compressor module to handle PDF compression.
+    module PDFCompressor
+      # Compresses each page of a provided PDF stream. Skips if force_source_text isn't set and source text is detected.
+      # @param quality [Integer] Compression quality (70-100 for most JPG images in the test dataset).
+      # @param force_source_text_compression [Boolean] If true, attempts to re-write detected text.
+      # @param disable_source_text [Boolean] If true, doesn't re-apply source text to the original PDF.
+      def self.compress_pdf(pdf_data, quality: 85, force_source_text_compression: false, disable_source_text: true)
+        if PDFTools.source_text?(pdf_data)
+          if force_source_text_compression
+            if disable_source_text
+              puts "\e[33m[WARNING] Re-writing PDF source-text is an EXPERIMENTAL feature.\e[0m"
+            else
+              puts "\e[33m[WARNING] Source-file contains text, but disable_source_text flag is ignored. " \
+                   "Resulting file will not contain any embedded text.\e[0m"
+            end
+          else
+            puts "\e[33m[WARNING] Source-text detected in input PDF. Aborting operation.\e[0m"
+            return pdf_data
+          end
+        end
+
+        pdf_data.rewind
+        pdf = Origami::PDF.read(pdf_data)
+        pages = process_pdf_pages(pdf, quality)
+
+        output_pdf = create_output_pdf(pages, disable_source_text, pdf_data)
+
+        output_stream = StringIO.new
+        output_pdf.save(output_stream)
+        output_stream
+      end
+
+      # Processes all pages in the PDF.
+      # @param pdf [Origami::PDF] The Origami PDF object to process.
+      # @param quality [Integer] Compression quality.
+      # @return [Array<Origami::Page>] Processed pages.
+      def self.process_pdf_pages(pdf, quality)
+        pdf.pages.map.with_index do |page, index|
+          process_pdf_page(Mindee::PDF::PdfProcessor.get_page(pdf, index), index, quality, page[:MediaBox])
+        end
+      end
+
+      # Creates the output PDF with processed pages.
+      # @param pages [Array] Processed pages.
+      # @param disable_source_text [Boolean] Whether to disable source text.
+      # @param pdf_data [StringIO] Original PDF data.
+      # @return [Origami::PDF] Output PDF object.
+      def self.create_output_pdf(pages, disable_source_text, pdf_data)
+        output_pdf = Origami::PDF.new
+        # NOTE: Page order and XObject handling require adjustment due to origami adding the last page first.
+        pages.rotate!(1) if pages.count >= 2
+
+        inject_text(pdf_data, pages) unless disable_source_text
+
+        pages.each { |page| output_pdf.append_page(page) }
+
+        output_pdf
+      end
+
+      # Extracts text from a source text PDF, and injects it into a newly-created one.
+      # @param pdf_data [StringIO] Stream representation of the PDF.
+      # @param pages [Array<Origami::Page>] Array of pages containing the rasterized version of the initial pages.
+      def self.inject_text(pdf_data, pages)
+        reader = PDFReader::Reader.new(pdf_data)
+
+        reader.pages.each_with_index do |original_page, index|
+          break if index >= pages.length
+
+          receiver = PDFReader::Reader::PageTextReceiver.new
+          original_page.walk(receiver)
+
+          receiver.runs.each do |text_run|
+            x = text_run.origin.x
+            y = text_run.origin.y
+            text = text_run.text
+            font_size = text_run.font_size
+
+            content_stream = Origami::Stream.new
+            content_stream.dictionary[:Filter] = :FlateDecode
+            content_stream.data = "BT\n/F1 #{font_size} Tf\n#{x} #{y} Td\n(#{text}) Tj\nET\n"
+
+            pages[index].Contents.data += content_stream.data
+          end
+        end
+      end
+
+      # Takes in a page stream, rasterizes it into a JPEG image, and applies the result onto a new Origami PDF page.
+      # @param page_stream [StringIO] Stream representation of a single page from the initial PDF.
+      # @param page_index [Integer] Index of the current page. Technically not needed, but left for debugging purposes.
+      # @param image_quality [Integer] Quality to apply to the rasterized page.
+      # @param media_box [Array<Integer>, nil] Extracted media box from the page. Can be nil.
+      # @return [Origami::Page]
+      def self.process_pdf_page(page_stream, page_index, image_quality, media_box)
+        new_page = Origami::Page.new
+        compressed_image = Mindee::Image::ImageUtils.pdf_to_magick_image(page_stream, image_quality)
+        width, height = Mindee::Image::ImageUtils.calculate_dimensions_from_media_box(compressed_image, media_box)
+
+        compressed_xobject = PDF::PDFTools.create_xobject(compressed_image)
+        PDF::PDFTools.set_xobject_properties(compressed_xobject, compressed_image)
+
+        xobject_name = "X#{page_index + 1}"
+        PDF::PDFTools.add_content_to_page(new_page, xobject_name, width, height)
+        new_page.add_xobject(compressed_xobject, xobject_name)
+
+        PDF::PDFTools.set_page_dimensions(new_page, width, height)
+        new_page
+      end
+    end
+  end
+end

data/lib/mindee/pdf/{pdf_processing.rb → pdf_processor.rb}

@@ -18,6 +18,7 @@ module Mindee
 
       # @param io_stream [StreamIO]
       # @param options [Hash]
+      # @return [StringIO]
       def self.parse(io_stream, options)
         options = DEFAULT_OPTIONS.merge(options)
 
@@ -74,6 +75,22 @@ module Mindee
         io_stream.seek(0)
         pdf_parser.parse(io_stream)
       end
+
+      # Retrieves a PDF document's page.
+      #
+      # @param [Origami::PDF] pdf_doc Origami PDF handle.
+      # @param [Integer] page_id Page ID.
+      # @return [StringIO]
+      def self.get_page(pdf_doc, page_id)
+        stream = StringIO.new
+        pdf_doc.save(stream)
+
+        options = {
+          page_indexes: [page_id - 1],
+        }
+
+        parse(stream, options)
+      end
     end
   end
 end

data/lib/mindee/pdf/pdf_tools.rb

@@ -29,6 +29,106 @@ module Mindee
         io_stream.set_encoding Encoding::BINARY
         io_stream
       end
+
+      # Checks a PDFs stream content for text operators
+      # See https://opensource.adobe.com/dc-acrobat-sdk-docs/pdfstandards/PDF32000_2008.pdf page 243-251.
+      # @param [StringIO] stream Stream object from a PDFs page.
+      # @return [Boolean] True if a text operator is found in the stream.
+      def self.stream_has_text?(stream)
+        data = stream.data
+        return false if data.nil? || data.empty?
+
+        text_operators = ['Tc', 'Tw', 'Th', 'TL', 'Tf', 'Tk', 'Tr', 'Tm', 'T*', 'Tj', 'TJ', "'", '"']
+        text_operators.any? { |op| data.include?(op) }
+      end
+
+      # Checks whether the file has source_text. Sends false if the file isn't a PDF.
+      # @param [StringIO] pdf_data
+      # @return [Boolean] True if the pdf has source text, false otherwise.
+      def self.source_text?(pdf_data)
+        begin
+          pdf_data.rewind
+          pdf = Origami::PDF.read(pdf_data)
+
+          pdf.each_page do |page|
+            next unless page[:Contents]
+
+            contents = page[:Contents].solve
+            contents = [contents] unless contents.is_a?(Origami::Array)
+
+            contents.each do |stream_ref|
+              stream = stream_ref.solve
+              return true if stream_has_text?(stream)
+            end
+          end
+
+          false
+        end
+
+        false
+      rescue Origami::InvalidPDFError
+        false
+      end
+
+      def self.create_xobject(image)
+        image_io = Mindee::Image::ImageUtils.image_to_stringio(image)
+        Origami::Graphics::ImageXObject.from_image_file(image_io, 'jpg')
+      end
+
+      def self.set_xobject_properties(xobject, image)
+        xobject.dictionary[:BitsPerComponent] = 8
+        xobject.dictionary[:Filter] = determine_filter(image)
+        xobject.dictionary[:Width] = image[:width]
+        xobject.dictionary[:Height] = image[:height]
+        xobject.dictionary[:ColorSpace] = determine_colorspace(image)
+      end
+
+      def self.determine_filter(image)
+        filter = image.data['properties']['filter']
+        case filter
+        when %r{Zip}i then :FlateDecode
+        when %r{LZW}i then :LZWDecode
+        else :DCTDecode
+        end
+      end
+
+      def self.determine_colorspace(image)
+        colorspace = image.data['colorspace']
+        case colorspace
+        when 'CMYK' then :DeviceCMYK
+        when 'Gray', 'PseudoClass Gray' then :DeviceGray
+        else :DeviceRGB
+        end
+      end
+
+      def self.add_content_to_page(page, xobject_name, width, height)
+        content = "q\n#{width} 0 0 #{height} 0 0 cm\n/#{xobject_name} Do\nQ\n"
+        content_stream = Origami::Stream.new(content)
+        page.Contents = content_stream
+      end
+
+      def self.set_page_dimensions(page, width, height)
+        page[:MediaBox] = [0, 0, width, height]
+        page[:CropBox] = [0, 0, width, height]
+      end
+
+      def self.process_image_xobject(image_data, image_quality, width, height)
+        compressed_data = Image::ImageCompressor.compress_image(
+          image_data,
+          quality: image_quality,
+          max_width: width,
+          max_height: height
+        )
+
+        new_image = Origami::Graphics::ImageXObject.new
+        new_image.data = compressed_data
+        new_image.Width = width
+        new_image.Height = height
+        new_image.ColorSpace = :DeviceRGB
+        new_image.BitsPerComponent = 8
+
+        new_image
+      end
     end
   end
 end

data/lib/mindee/pdf.rb

@@ -1,3 +1,5 @@
 # frozen_string_literal: true
 
-require_relative 'pdf/pdf_processing'
+require_relative 'pdf/pdf_compressor'
+require_relative 'pdf/pdf_processor'
+require_relative 'pdf/pdf_tools'

data/lib/mindee/version.rb

@@ -3,7 +3,7 @@
 # Mindee
 module Mindee
   # Current version.
-  VERSION = '3.14.0'
+  VERSION = '3.15.0'
 
   # Finds and return the current platform.
   # @return [String]

data/lib/mindee.rb

@@ -19,6 +19,16 @@ module Mindee
     end
   end
 
+  module Image
+    # Miscellaneous image operations.
+    module ImageUtils
+    end
+
+    # Image compressor module to handle image compression.
+    module ImageCompressor
+    end
+  end
+
   # Custom extraction module
   module Extraction
   end

data/mindee.gemspec

@@ -30,8 +30,9 @@ Gem::Specification.new do |spec|
   spec.required_ruby_version = Gem::Requirement.new('>= 2.6')
 
   spec.add_runtime_dependency 'marcel', '~> 1.0.2'
-  spec.add_runtime_dependency 'mini_magick', '~> 4.13.0'
+  spec.add_runtime_dependency 'mini_magick', '>=4', '< 6'
   spec.add_runtime_dependency 'origamindee', '~> 3.1.0'
+  spec.add_runtime_dependency 'pdf-reader', '~> 2.12.0'
 
   spec.add_development_dependency 'rake', '~> 12.3.3'
   spec.add_development_dependency 'rspec', '~> 3.12.0'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mindee
 version: !ruby/object:Gem::Version
-  version: 3.14.0
+  version: 3.15.0
 platform: ruby
 authors:
 - Mindee, SA
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-10-11 00:00:00.000000000 Z
+date: 2024-10-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: marcel
@@ -28,16 +28,22 @@ dependencies:
   name: mini_magick
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4'
+    - - "<"
       - !ruby/object:Gem::Version
-        version: 4.13.0
+        version: '6'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4'
+    - - "<"
       - !ruby/object:Gem::Version
-        version: 4.13.0
+        version: '6'
 - !ruby/object:Gem::Dependency
   name: origamindee
   requirement: !ruby/object:Gem::Requirement
@@ -52,6 +58,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 3.1.0
+- !ruby/object:Gem::Dependency
+  name: pdf-reader
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.12.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.12.0
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -224,6 +244,9 @@ files:
 - lib/mindee/http/endpoint.rb
 - lib/mindee/http/error.rb
 - lib/mindee/http/response_validation.rb
+- lib/mindee/image.rb
+- lib/mindee/image/image_compressor.rb
+- lib/mindee/image/image_utils.rb
 - lib/mindee/input.rb
 - lib/mindee/input/local_response.rb
 - lib/mindee/input/sources.rb
@@ -262,7 +285,8 @@ files:
 - lib/mindee/parsing/standard/string_field.rb
 - lib/mindee/parsing/standard/tax_field.rb
 - lib/mindee/pdf.rb
-- lib/mindee/pdf/pdf_processing.rb
+- lib/mindee/pdf/pdf_compressor.rb
+- lib/mindee/pdf/pdf_processor.rb
 - lib/mindee/pdf/pdf_tools.rb
 - lib/mindee/product.rb
 - lib/mindee/product/.rubocop.yml