mindee 1.1.2 → 2.0.0

data/lib/mindee/endpoint.rb

@@ -1,105 +0,0 @@
-# frozen_string_literal: true
-
-require 'net/http'
-require_relative 'version'
-
-module Mindee
-  MINDEE_API_URL = 'https://api.mindee.net/v1'
-  USER_AGENT = "mindee-api-ruby@v#{Mindee::VERSION} ruby-v#{RUBY_VERSION} #{Mindee::PLATFORM}"
-
-  INVOICE_VERSION = '3'
-  INVOICE_URL_NAME = 'invoices'
-
-  RECEIPT_VERSION = '3'
-  RECEIPT_URL_NAME = 'expense_receipts'
-
-  PASSPORT_VERSION = '1'
-  PASSPORT_URL_NAME = 'passport'
-
-  # Generic API endpoint for a product.
-  class Endpoint
-    attr_reader :api_key
-
-    def initialize(owner, url_name, version, key_name: nil, api_key: nil)
-      @owner = owner
-      @url_name = url_name
-      @version = version
-      @key_name = key_name || url_name
-      @api_key = api_key || set_api_key_from_env
-      @url_root = "#{MINDEE_API_URL}/products/#{@owner}/#{@url_name}/v#{@version}"
-    end
-
-    # @param input_doc [Mindee::InputDocument]
-    # @param include_words [Boolean]
-    # @param close_file [Boolean]
-    # @return [Net::HTTPResponse]
-    def predict_request(input_doc, include_words: false, close_file: true)
-      uri = URI("#{@url_root}/predict")
-      headers = {
-        'Authorization' => "Token #{@api_key}",
-        'User-Agent' => USER_AGENT,
-      }
-      req = Net::HTTP::Post.new(uri, headers)
-
-      params = {
-        'document' => input_doc.read_document(close: close_file),
-      }
-      params.push ['include_mvision', 'true'] if include_words
-
-      req.set_form(params, 'multipart/form-data')
-
-      Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
-        http.request(req)
-      end
-    end
-
-    def envvar_key_name
-      key_name = to_envar(@key_name)
-      key_name = "#{to_envar(@owner)}_#{key_name}" if @owner != 'mindee'
-      "MINDEE_#{key_name}_API_KEY"
-    end
-
-    private
-
-    # Create a standard way to get/set environment variable names.
-    def to_envar(name)
-      name.sub('-', '_').upcase
-    end
-
-    # Set the endpoint's API key from an environment variable, if present.
-    # We look first for the specific key, if not set, we'll use the generic key
-    def set_api_key_from_env
-      env_key = ENV.fetch(envvar_key_name, nil)
-      env_key = ENV.fetch('MINDEE_API_KEY', nil) if env_key.nil?
-      @api_key = env_key if env_key
-    end
-  end
-
-  # Invoice API endpoint
-  class InvoiceEndpoint < Endpoint
-    def initialize(api_key)
-      super('mindee', INVOICE_URL_NAME, INVOICE_VERSION, key_name: 'invoice', api_key: api_key)
-    end
-  end
-
-  # Receipt API endpoint
-  class ReceiptEndpoint < Endpoint
-    def initialize(api_key)
-      super('mindee', RECEIPT_URL_NAME, RECEIPT_VERSION, key_name: 'receipt', api_key: api_key)
-    end
-  end
-
-  # Passport API endpoint
-  class PassportEndpoint < Endpoint
-    def initialize(api_key)
-      super('mindee', PASSPORT_URL_NAME, PASSPORT_VERSION, api_key: api_key)
-    end
-  end
-
-  # Custom (constructed) API endpoint
-  class CustomEndpoint < Endpoint
-    def initialize(document_type, account_name, version, api_key)
-      super(account_name, document_type, version, api_key: api_key)
-    end
-  end
-end

data/lib/mindee/fields/orientation.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-module Mindee
-  # Represents page orientation.
-  class Orientation
-    # @return [Integer]
-    attr_reader :page_id
-    # The confidence score, value will be between 0.0 and 1.0
-    # @return [Float]
-    attr_reader :confidence
-    # A prediction among these 3 possible outputs:
-    #   * 0 degrees: the page is already upright
-    #   * 90 degrees: the page must be rotated clockwise to be upright
-    #   * 270 degrees: the page must be rotated counterclockwise to be upright
-    # @return [Integer]
-    attr_reader :degrees
-
-    # @param prediction [Hash]
-    # @param page_id [Integer]
-    def initialize(prediction, page_id)
-      @degrees = prediction['degrees']
-      @confidence = prediction['confidence']
-      @page_id = page_id
-    end
-  end
-end

data/lib/mindee/fields.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'fields/amount'
-require_relative 'fields/base'
-require_relative 'fields/company_registration'
-require_relative 'fields/datefield'
-require_relative 'fields/locale'
-require_relative 'fields/orientation'
-require_relative 'fields/payment_details'
-require_relative 'fields/tax'
-require_relative 'fields/custom_docs'

data/lib/mindee/inputs.rb

@@ -1,153 +0,0 @@
-# frozen_string_literal: true
-
-require 'stringio'
-require 'origami'
-require 'marcel'
-
-# Monkey-patching for Origami
-module PDFTools
-  def to_io_stream(params = {})
-    options = {
-      delinearize: true,
-      recompile: true,
-      decrypt: false,
-    }
-    options.update(params)
-
-    if frozen? # incompatible flags with frozen doc (signed)
-      options[:recompile] = nil
-      options[:rebuild_xrefs] = nil
-      options[:noindent] = nil
-      options[:obfuscate] = false
-    end
-    load_all_objects unless @loaded
-
-    intents_as_pdfa1 if options[:intent] =~ %r{pdf[/-]?A1?/i}
-    delinearize! if options[:delinearize] && linearized?
-    compile(options) if options[:recompile]
-
-    io_stream = StringIO.new(output(options))
-    io_stream.set_encoding Encoding::BINARY
-    io_stream
-  end
-end
-
-Origami::PDF.class_eval { include PDFTools }
-
-module Mindee
-  ALLOWED_MIME_TYPES = [
-    'application/pdf',
-    'image/heic',
-    'image/png',
-    'image/jpeg',
-    'image/tiff',
-    'image/webp',
-  ].freeze
-
-  MAX_DOC_PAGES = 3
-
-  # Base class for loading documents.
-  class InputDocument
-    # @return [String]
-    attr_reader :filename
-    # @return [String]
-    attr_reader :filepath
-    # @return [String]
-    attr_reader :file_mimetype
-
-    # @param cut_pages [Boolean]
-    # @param max_pages [Integer]
-    def initialize(cut_pages, max_pages)
-      @file_mimetype = Marcel::MimeType.for @io_stream, name: @filename
-
-      unless ALLOWED_MIME_TYPES.include? @file_mimetype
-        raise "File type not allowed, must be one of #{ALLOWED_MIME_TYPES.join(', ')}"
-      end
-
-      merge_pdf_pages(max_pages) if cut_pages && pdf?
-    end
-
-    def pdf?
-      @file_mimetype == 'application/pdf'
-    end
-
-    # @return [Integer]
-    def page_count
-      if pdf?
-        current_pdf = open_pdf
-        return current_pdf.pages.size
-      end
-      1
-    end
-
-    # @param close [Boolean]
-    def read_document(close: true)
-      @io_stream.seek(0)
-      data = @io_stream.read
-      @io_stream.close if close
-      [data].pack('m')
-    end
-
-    private
-
-    # @param max_pages [Integer]
-    def merge_pdf_pages(max_pages)
-      current_pdf = open_pdf
-      return if current_pdf.pages.size <= MAX_DOC_PAGES
-
-      new_pdf = Origami::PDF.new
-
-      to_insert = [current_pdf.pages[0], current_pdf.pages[-2], current_pdf.pages[-1]].take(max_pages)
-      to_insert.each do |page|
-        new_pdf.append_page(page)
-      end
-      @io_stream = new_pdf.to_io_stream
-    end
-
-    # @return [Origami::PDF]
-    def open_pdf
-      pdf_parser = Origami::PDF::LinearParser.new({})
-      @io_stream.seek(0)
-      pdf_parser.parse(@io_stream)
-    end
-  end
-
-  # Load a document from a path.
-  class PathDocument < InputDocument
-    def initialize(filepath, cut_pages, max_pages: MAX_DOC_PAGES)
-      @io_stream = File.open(filepath, 'rb')
-      @filepath = filepath
-      @filename = File.basename(filepath)
-      super(cut_pages, max_pages)
-    end
-  end
-
-  # Load a document from a base64 string.
-  class Base64Document < InputDocument
-    def initialize(base64_string, filename, cut_pages, max_pages: 3)
-      @io_stream = StringIO.new(base64_string.unpack1('m*'))
-      @io_stream.set_encoding Encoding::BINARY
-      @filename = filename
-      super(cut_pages, max_pages)
-    end
-  end
-
-  # Load a document from raw bytes.
-  class BytesDocument < InputDocument
-    def initialize(raw_bytes, filename, cut_pages, max_pages: MAX_DOC_PAGES)
-      @io_stream = StringIO.new(raw_bytes)
-      @io_stream.set_encoding Encoding::BINARY
-      @filename = filename
-      super(cut_pages, max_pages)
-    end
-  end
-
-  # Load a document from a file handle.
-  class FileDocument < InputDocument
-    def initialize(file_handle, filename, cut_pages, max_pages: MAX_DOC_PAGES)
-      @io_stream = file_handle
-      @filename = filename
-      super(cut_pages, max_pages)
-    end
-  end
-end

data/lib/mindee/response.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-module Mindee
-  # Stores all response attributes.
-  class DocumentResponse
-    # @return [String]
-    attr_reader :document_type
-    # @return [Hash]
-    attr_reader :http_response
-    # @return [Mindee::Document]
-    attr_reader :document
-    # @return [Array<Mindee::Document>]
-    attr_reader :pages
-
-    # @param http_response [Hash]
-    def initialize(http_response, document_type, document, pages)
-      @http_response = http_response
-      @document_type = document_type
-      @document = document
-      @pages = pages
-    end
-
-    def to_s
-      inspect
-    end
-  end
-end