mindee 3.19.1 → 4.0.0

data/lib/mindee/pdf/pdf_compressor.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'pdf-reader'
+# Shorthand for pdf-reader's PDF namespace, to avoid mixups with the local Origami fork.
 PDFReader = PDF
 
 module Mindee
@@ -8,20 +9,21 @@ module Mindee
     # 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 pdf_data [StringIO] StringIO handle of the file.
       # @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.
+      # @param force_source_text_compression [bool] If true, attempts to re-write detected text.
+      # @param disable_source_text [bool] 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"
+              logger.warn('Re-writing PDF source-text is an EXPERIMENTAL feature.')
             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"
+              logger.warn('Source-file contains text, but disable_source_text flag is ignored. ' \
+                          'Resulting file will not contain any embedded text.')
             end
           else
-            puts "\e[33m[WARNING] Source-text detected in input PDF. Aborting operation.\e[0m"
+            logger.warn('Source-text detected in input PDF. Aborting operation.')
             return pdf_data
           end
         end
@@ -43,18 +45,18 @@ module Mindee
       # @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])
+          retrieved_page = Mindee::PDF::PDFProcessor.get_page(pdf, index)
+          process_pdf_page(retrieved_page, 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 pages [Array<Origami::Page>] Processed pages.
+      # @param disable_source_text [bool] 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

data/lib/mindee/{extraction/pdf_extractor → pdf}/pdf_extractor.rb

@@ -2,18 +2,18 @@
 
 module Mindee
   # Pdf Extraction Module.
-  module Extraction
+  module PDF
     # Pdf Extraction class.
-    module PdfExtractor
+    module PDFExtractor
       # Pdf extraction class.
-      class PdfExtractor
+      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 = Extraction::ImageExtractor.attach_image_as_new_file(local_input.io_stream)
+            pdf_image = Image::ImageExtractor.attach_image_as_new_file(local_input.io_stream)
             io_buffer = StringIO.new
             pdf_image.save(io_buffer)
 
@@ -24,40 +24,43 @@ module Mindee
         # Retrieves the page count for the Pdf object.
         # @return [Integer]
         def page_count
-          Mindee::PDF::PdfProcessor.open_pdf(@source_pdf).pages.size
+          Mindee::PDF::PDFProcessor.open_pdf(@source_pdf).pages.size
         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 [StreamIO] The buffer containing the new Pdf.
         def cut_pages(page_indexes)
-          options = {
-            page_indexes: page_indexes,
-          }
+          options = PageOptions.new(params: {
+                                      page_indexes: page_indexes,
+                                    })
 
-          Mindee::PDF::PdfProcessor.parse(@source_pdf, options)
+          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::Extraction::PdfExtractor::ExtractedPdf>] The buffer containing the new 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.empty? || page_index_list.nil?
-              raise "Empty indexes aren't allowed for extraction #{page_index_list}"
+              raise Errors::MindeePDFError, "Empty indexes aren't allowed for extraction #{page_index_list}"
             end
 
             page_index_list.each do |page_index|
-              raise "Index #{page_index} is out of range." if (page_index > page_count) || page_index.negative?
+              if (page_index > page_count) || page_index.negative?
+                raise Errors::MindeePDFError,
+                      "Index #{page_index} is out of range."
+              end
             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::Extraction::PdfExtractor::ExtractedPdf.new(cut_pages(page_index_list),
-                                                                               field_filename)
+            extracted_pdf = Mindee::PDF::PDFExtractor::ExtractedPDF.new(cut_pages(page_index_list),
+                                                                        field_filename)
             extracted_pdfs << extracted_pdf
           end
           extracted_pdfs
@@ -68,10 +71,10 @@ module Mindee
 
         # Extracts invoices as complete PDFs from the document.
         # @param page_indexes [Array<Array<Integer>, InvoiceSplitterV1PageGroup>]
-        # @param strict [Boolean]
-        # @return [Array<Mindee::Extraction::PdfExtractor::ExtractedPdf>]
+        # @param strict [bool]
+        # @return [Array<Mindee::PDF::PDFExtractor::ExtractedPDF>]
         def extract_invoices(page_indexes, strict: false)
-          raise 'No indexes provided.' if page_indexes.empty?
+          raise Errors::MindeePDFError, 'No indexes provided.' if page_indexes.empty?
           unless page_indexes[0].is_a?(Mindee::Product::InvoiceSplitter::InvoiceSplitterV1PageGroup)
             return extract_sub_documents(page_indexes)
           end

data/lib/mindee/pdf/pdf_processor.rb

@@ -7,34 +7,24 @@ require_relative 'pdf_tools'
 module Mindee
   module PDF
     # PDF document processing
-    module PdfProcessor
+    module PDFProcessor
       Origami::PDF.class_eval { include PDFTools }
-      # Default options for pdf documents processing.
-      DEFAULT_OPTIONS = {
-        page_indexes: [0],
-        operation: :KEEP_ONLY,
-        on_min_pages: 0,
-      }.freeze
-
       # @param io_stream [StreamIO]
-      # @param options [Hash]
+      # @param options [PageOptions, Hash]
       # @return [StringIO]
       def self.parse(io_stream, options)
-        options = DEFAULT_OPTIONS.merge(options)
-
         current_pdf = open_pdf(io_stream)
         pages_count = current_pdf.pages.size
-        return if options[:on_min_pages] > pages_count
+        return current_pdf.to_io_stream if options.on_min_pages.to_i > pages_count
 
         all_pages = (0..pages_count - 1).to_a
 
-        case options[:operation]
-        when :KEEP_ONLY
-          pages_to_remove = indexes_from_keep(options[:page_indexes], all_pages)
-        when :REMOVE
-          pages_to_remove = indexes_from_remove(options[:page_indexes], all_pages)
+        if options.operation == :KEEP_ONLY
+          pages_to_remove = indexes_from_keep(options.page_indexes, all_pages)
+        elsif options.operation == :REMOVE
+          pages_to_remove = indexes_from_remove(options.page_indexes, all_pages)
         else
-          raise "operation must be one of :KEEP_ONLY or :REMOVE, sent '#{behavior}'"
+          raise ArgumentError, "operation must be one of :KEEP_ONLY or :REMOVE, sent '#{options.operation}'"
         end
 
         current_pdf.delete_pages_at(pages_to_remove) if pages_to_remove.to_a != all_pages.to_a
@@ -55,7 +45,7 @@ module Mindee
         all_pages.to_set - pages_to_keep
       end
 
-      # @param page_indexes [Array]
+      # @param page_indexes [Array[Integer]]
       # @param all_pages [Array]
       def self.indexes_from_remove(page_indexes, all_pages)
         pages_to_remove = Set.new
@@ -85,9 +75,9 @@ module Mindee
         stream = StringIO.new
         pdf_doc.save(stream)
 
-        options = {
-          page_indexes: [page_id - 1],
-        }
+        options = PageOptions.new(params: {
+                                    page_indexes: [page_id - 1],
+                                  })
 
         parse(stream, options)
       end

data/lib/mindee/pdf/pdf_tools.rb

@@ -2,14 +2,23 @@
 
 module Mindee
   module PDF
-    # Monkey-patching for Origami
+    # Collection of miscellaneous PDF operations,as well as some monkey-patching for Origami.
     module PDFTools
-      # @return [StringIO]
+      # Converts the current PDF document into a binary-encoded StringIO stream.
+      #
+      # @param [Hash] params Optional settings to override default processing flags.
+      #   - :delinearize [bool] (default: true) Whether to convert a linearized PDF to its full form.
+      #   - :recompile [bool] (default: true) Whether to recompile the PDF after processing.
+      #   - :decrypt [bool] (default: false) Whether to attempt to decrypt the PDF.
+      #   - Other keys such as :intent, :rebuild_xrefs, :noindent, and :obfuscate may be modified automatically.
+      #
+      # @return [StringIO] A binary-encoded stream representing the processed PDF.
       def to_io_stream(params = {})
         options = {
           delinearize: true,
           recompile: true,
           decrypt: false,
+          noindent: nil,
         }
         options.update(params)
 
@@ -21,7 +30,7 @@ module Mindee
         end
         load_all_objects unless @loaded
 
-        intents_as_pdfa1 if options[:intent] =~ %r{pdf[/-]?A1?/i}
+        intents_as_pdfa1 if options[:intent].to_s =~ %r{pdf[/-]?A1?/i}
         delinearize! if options[:delinearize] && linearized?
         compile(options) if options[:recompile]
 
@@ -33,7 +42,7 @@ module Mindee
       # 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.
+      # @return [bool] 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?
@@ -43,8 +52,8 @@ module Mindee
       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.
+      # @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)
         begin
           pdf_data.rewind
@@ -70,11 +79,22 @@ module Mindee
         false
       end
 
+      # Creates an image XObject from the provided image.
+      #
+      # Converts the given image to a binary stream using Mindee's image utilities, then creates
+      # an Origami::Graphics::ImageXObject with a JPEG filter.
+      #
+      # @param [Minimagick::Image] image An image object with the necessary data and structure.
+      # @return [Origami::Graphics::ImageXObject] The created image XObject.
       def self.create_xobject(image)
         image_io = Mindee::Image::ImageUtils.image_to_stringio(image)
         Origami::Graphics::ImageXObject.from_image_file(image_io, 'jpg')
       end
 
+      # Sets properties on the provided image XObject based on image metadata.
+      #
+      # @param [Origami::Graphics::ImageXObject] xobject The image XObject to update.
+      # @param [Hash] image A hash containing image metadata (such as width, height, properties, etc.).
       def self.set_xobject_properties(xobject, image)
         xobject.dictionary[:BitsPerComponent] = 8
         xobject.dictionary[:Filter] = determine_filter(image)
@@ -83,6 +103,10 @@ module Mindee
         xobject.dictionary[:ColorSpace] = determine_colorspace(image)
       end
 
+      # Determines the appropriate filter for an image based on its properties.
+      #
+      # @param [Hash] image The image data hash containing properties.
+      # @return [Symbol] One of :FlateDecode, :LZWDecode or :DCTDecode.
       def self.determine_filter(image)
         filter = image.data['properties']['filter']
         case filter
@@ -92,6 +116,10 @@ module Mindee
         end
       end
 
+      # Determines the colorspace for an image based on its metadata.
+      #
+      # @param [Hash] image The image data hash.
+      # @return [Symbol] One of :DeviceCMYK, :DeviceGray or :DeviceRGB.
       def self.determine_colorspace(image)
         colorspace = image.data['colorspace']
         case colorspace
@@ -101,17 +129,35 @@ module Mindee
         end
       end
 
+      # Adds a content stream to the specified PDF page to display an image XObject.
+      #
+      # @param [Origami::Page] page The PDF page to which content will be added.
+      # @param [String] xobject_name The name identifying the XObject.
+      # @param [Integer] width The width for the transformation matrix.
+      # @param [Integer] height The height for the transformation matrix.
       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
 
+      # Sets the dimensions for the specified PDF page.
+      #
+      # @param [Origami::Page] page The PDF page whose dimensions are being set.
+      # @param [Numeric] width The target width of the page.
+      # @param [Numeric] height The target height of the page.
       def self.set_page_dimensions(page, width, height)
         page[:MediaBox] = [0, 0, width, height]
         page[:CropBox] = [0, 0, width, height]
       end
 
+      # Processes an image into an image XObject for PDF embedding.
+      #
+      # @param [Hash] image_data The raw image data.
+      # @param [Integer] image_quality The quality setting for image compression.
+      # @param [Numeric] width The desired width of the output image.
+      # @param [Numeric] height The desired height of the output image.
+      # @return [Origami::Graphics::ImageXObject] The resulting image XObject.
       def self.process_image_xobject(image_data, image_quality, width, height)
         compressed_data = Image::ImageCompressor.compress_image(
           image_data,

data/lib/mindee/pdf.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative 'pdf/extracted_pdf'
 require_relative 'pdf/pdf_compressor'
+require_relative 'pdf/pdf_extractor'
 require_relative 'pdf/pdf_processor'
 require_relative 'pdf/pdf_tools'

data/lib/mindee/product/.rubocop.yml

@@ -8,3 +8,6 @@ Metrics/CyclomaticComplexity:
   Enabled: false
 Metrics/PerceivedComplexity:
   Enabled: false
+Metrics/MethodLength:
+  Enabled: false
+

data/lib/mindee/product/barcode_reader/barcode_reader_v1.rb

@@ -12,6 +12,8 @@ module Mindee
       class BarcodeReaderV1 < Mindee::Parsing::Common::Inference
         @endpoint_name = 'barcode_reader'
         @endpoint_version = '1'
+        @has_async = false
+        @has_sync = true
 
         # @param prediction [Hash]
         def initialize(prediction)
@@ -19,9 +21,7 @@ module Mindee
           @prediction = BarcodeReaderV1Document.new(prediction['prediction'], nil)
           @pages = []
           prediction['pages'].each do |page|
-            if page.key?('prediction') && !page['prediction'].nil? && !page['prediction'].empty?
-              @pages.push(BarcodeReaderV1Page.new(page))
-            end
+            @pages.push(BarcodeReaderV1Page.new(page))
           end
         end
 
@@ -32,6 +32,12 @@ module Mindee
           # Version for this product.
           # @return [String]
           attr_reader :endpoint_version
+          # Whether this product has access to an asynchronous endpoint.
+          # @return [bool]
+          attr_reader :has_async
+          # Whether this product has access to synchronous endpoint.
+          # @return [bool]
+          attr_reader :has_sync
         end
       end
     end

data/lib/mindee/product/barcode_reader/barcode_reader_v1_document.rb

@@ -18,14 +18,14 @@ module Mindee
         # @param prediction [Hash]
         # @param page_id [Integer, nil]
         def initialize(prediction, page_id)
-          super()
-          @codes_1d = []
+          super
+          @codes_1d = [] # : Array[Parsing::Standard::StringField]
           prediction['codes_1d'].each do |item|
-            @codes_1d.push(StringField.new(item, page_id))
+            @codes_1d.push(Parsing::Standard::StringField.new(item, page_id))
           end
-          @codes_2d = []
+          @codes_2d = [] # : Array[Parsing::Standard::StringField]
           prediction['codes_2d'].each do |item|
-            @codes_2d.push(StringField.new(item, page_id))
+            @codes_2d.push(Parsing::Standard::StringField.new(item, page_id))
           end
         end
 

data/lib/mindee/product/barcode_reader/barcode_reader_v1_page.rb

@@ -10,11 +10,15 @@ module Mindee
       class BarcodeReaderV1Page < Mindee::Parsing::Common::Page
         # @param prediction [Hash]
         def initialize(prediction)
-          super(prediction)
-          @prediction = BarcodeReaderV1PagePrediction.new(
-            prediction['prediction'],
-            prediction['id']
-          )
+          super
+          @prediction = if prediction['prediction'].empty?
+                          nil
+                        else
+                          BarcodeReaderV1PagePrediction.new(
+                            prediction['prediction'],
+                            prediction['id']
+                          )
+                        end
         end
       end
 

data/lib/mindee/product/bill_of_lading/bill_of_lading_v1.rb

@@ -12,6 +12,8 @@ module Mindee
       class BillOfLadingV1 < Mindee::Parsing::Common::Inference
         @endpoint_name = 'bill_of_lading'
         @endpoint_version = '1'
+        @has_async = true
+        @has_sync = false
 
         # @param prediction [Hash]
         def initialize(prediction)
@@ -19,9 +21,7 @@ module Mindee
           @prediction = BillOfLadingV1Document.new(prediction['prediction'], nil)
           @pages = []
           prediction['pages'].each do |page|
-            if page.key?('prediction') && !page['prediction'].nil? && !page['prediction'].empty?
-              @pages.push(BillOfLadingV1Page.new(page))
-            end
+            @pages.push(BillOfLadingV1Page.new(page))
           end
         end
 
@@ -32,6 +32,12 @@ module Mindee
           # Version for this product.
           # @return [String]
           attr_reader :endpoint_version
+          # Whether this product has access to an asynchronous endpoint.
+          # @return [bool]
+          attr_reader :has_async
+          # Whether this product has access to synchronous endpoint.
+          # @return [bool]
+          attr_reader :has_sync
         end
       end
     end

data/lib/mindee/product/bill_of_lading/bill_of_lading_v1_carrier.rb

@@ -21,7 +21,7 @@ module Mindee
         # @param prediction [Hash]
         # @param page_id [Integer, nil]
         def initialize(prediction, page_id)
-          super(prediction, page_id)
+          super
           @name = prediction['name']
           @professional_number = prediction['professional_number']
           @scac = prediction['scac']

data/lib/mindee/product/bill_of_lading/bill_of_lading_v1_carrier_item.rb

@@ -30,7 +30,7 @@ module Mindee
         # @param prediction [Hash]
         # @param page_id [Integer, nil]
         def initialize(prediction, page_id)
-          super(prediction, page_id)
+          super
           @description = prediction['description']
           @gross_weight = prediction['gross_weight']
           @measurement = prediction['measurement']
@@ -44,10 +44,13 @@ module Mindee
         def printable_values
           printable = {}
           printable[:description] = format_for_display(@description)
-          printable[:gross_weight] = @gross_weight.nil? ? '' : Field.float_to_string(@gross_weight)
-          printable[:measurement] = @measurement.nil? ? '' : Field.float_to_string(@measurement)
+          printable[:gross_weight] =
+            @gross_weight.nil? ? '' : Parsing::Standard::BaseField.float_to_string(@gross_weight)
+          printable[:measurement] =
+            @measurement.nil? ? '' : Parsing::Standard::BaseField.float_to_string(@measurement)
           printable[:measurement_unit] = format_for_display(@measurement_unit)
-          printable[:quantity] = @quantity.nil? ? '' : Field.float_to_string(@quantity)
+          printable[:quantity] =
+            @quantity.nil? ? '' : Parsing::Standard::BaseField.float_to_string(@quantity)
           printable[:weight_unit] = format_for_display(@weight_unit)
           printable
         end
@@ -56,10 +59,13 @@ module Mindee
         def table_printable_values
           printable = {}
           printable[:description] = format_for_display(@description, 36)
-          printable[:gross_weight] = @gross_weight.nil? ? '' : Field.float_to_string(@gross_weight)
-          printable[:measurement] = @measurement.nil? ? '' : Field.float_to_string(@measurement)
+          printable[:gross_weight] =
+            @gross_weight.nil? ? '' : Parsing::Standard::BaseField.float_to_string(@gross_weight)
+          printable[:measurement] =
+            @measurement.nil? ? '' : Parsing::Standard::BaseField.float_to_string(@measurement)
           printable[:measurement_unit] = format_for_display(@measurement_unit, nil)
-          printable[:quantity] = @quantity.nil? ? '' : Field.float_to_string(@quantity)
+          printable[:quantity] =
+            @quantity.nil? ? '' : Parsing::Standard::BaseField.float_to_string(@quantity)
           printable[:weight_unit] = format_for_display(@weight_unit, nil)
           printable
         end

data/lib/mindee/product/bill_of_lading/bill_of_lading_v1_carrier_items.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require_relative 'bill_of_lading_v1_shipper'
+require_relative 'bill_of_lading_v1_consignee'
+require_relative 'bill_of_lading_v1_notify_party'
+require_relative 'bill_of_lading_v1_carrier'
+require_relative 'bill_of_lading_v1_carrier_item'
+
+module Mindee
+  module Product
+    module BillOfLading
+      # The goods being shipped.
+      class BillOfLadingV1CarrierItems < Array
+        # Entries.
+        # @return [Array<BillOfLadingV1CarrierItem>]
+        attr_reader :entries
+
+        # @param prediction [Array]
+        # @param page_id [Integer, nil]
+        def initialize(prediction, page_id)
+          entries = prediction.map do |entry|
+            BillOfLading::BillOfLadingV1CarrierItem.new(entry, page_id)
+          end
+          super(entries)
+        end
+
+        # Creates a line of rST table-compliant string separators.
+        # @param char [String] Character to use as a separator.
+        # @return [String]
+        def self.line_items_separator(char)
+          out_str = String.new
+          out_str << "+#{char * 38}"
+          out_str << "+#{char * 14}"
+          out_str << "+#{char * 13}"
+          out_str << "+#{char * 18}"
+          out_str << "+#{char * 10}"
+          out_str << "+#{char * 13}"
+          out_str
+        end
+
+        # @return [String]
+        def to_s
+          return '' if empty?
+
+          lines = map do |entry|
+            "\n  #{entry.to_table_line}\n#{self.class.line_items_separator('-')}"
+          end.join
+          out_str = String.new
+          out_str << ("\n#{self.class.line_items_separator('-')}\n ")
+          out_str << ' | Description                         '
+          out_str << ' | Gross Weight'
+          out_str << ' | Measurement'
+          out_str << ' | Measurement Unit'
+          out_str << ' | Quantity'
+          out_str << ' | Weight Unit'
+          out_str << (" |\n#{self.class.line_items_separator('=')}")
+          out_str + lines
+        end
+      end
+    end
+  end
+end

data/lib/mindee/product/bill_of_lading/bill_of_lading_v1_consignee.rb

@@ -24,7 +24,7 @@ module Mindee
         # @param prediction [Hash]
         # @param page_id [Integer, nil]
         def initialize(prediction, page_id)
-          super(prediction, page_id)
+          super
           @address = prediction['address']
           @email = prediction['email']
           @name = prediction['name']