mindee-lite 5.0.0.beta1

data/lib/mindee/v1/product/resume/resume_v1_professional_experience.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require_relative '../../parsing'
+
+module Mindee
+  module V1
+    module Product
+      module Resume
+        # The list of the candidate's professional experiences.
+        class ResumeV1ProfessionalExperience < Mindee::V1::Parsing::Standard::FeatureField
+          include Mindee::V1::Parsing::Standard
+
+          # The type of contract for the professional experience.
+          # @return [String]
+          attr_reader :contract_type
+          # The specific department or division within the company.
+          # @return [String]
+          attr_reader :department
+          # The description of the professional experience as written in the document.
+          # @return [String]
+          attr_reader :description
+          # The name of the company or organization.
+          # @return [String]
+          attr_reader :employer
+          # The month when the professional experience ended.
+          # @return [String]
+          attr_reader :end_month
+          # The year when the professional experience ended.
+          # @return [String]
+          attr_reader :end_year
+          # The position or job title held by the candidate.
+          # @return [String]
+          attr_reader :role
+          # The month when the professional experience began.
+          # @return [String]
+          attr_reader :start_month
+          # The year when the professional experience began.
+          # @return [String]
+          attr_reader :start_year
+
+          # @param prediction [Hash]
+          # @param page_id [Integer, nil]
+          def initialize(prediction, page_id)
+            super
+            @contract_type = prediction['contract_type']
+            @department = prediction['department']
+            @description = prediction['description']
+            @employer = prediction['employer']
+            @end_month = prediction['end_month']
+            @end_year = prediction['end_year']
+            @role = prediction['role']
+            @start_month = prediction['start_month']
+            @start_year = prediction['start_year']
+            @page_id = page_id
+          end
+
+          # @return [Hash]
+          def printable_values
+            printable = {} # @type var printable: Hash[Symbol, String]
+            printable[:contract_type] = format_for_display(@contract_type)
+            printable[:department] = format_for_display(@department)
+            printable[:description] = format_for_display(@description)
+            printable[:employer] = format_for_display(@employer)
+            printable[:end_month] = format_for_display(@end_month)
+            printable[:end_year] = format_for_display(@end_year)
+            printable[:role] = format_for_display(@role)
+            printable[:start_month] = format_for_display(@start_month)
+            printable[:start_year] = format_for_display(@start_year)
+            printable
+          end
+
+          # @return [Hash]
+          def table_printable_values
+            printable = {} # @type var printable: Hash[Symbol, String]
+            printable[:contract_type] = format_for_display(@contract_type, 15)
+            printable[:department] = format_for_display(@department, 10)
+            printable[:description] = format_for_display(@description, 36)
+            printable[:employer] = format_for_display(@employer, 25)
+            printable[:end_month] = format_for_display(@end_month, nil)
+            printable[:end_year] = format_for_display(@end_year, nil)
+            printable[:role] = format_for_display(@role, 20)
+            printable[:start_month] = format_for_display(@start_month, nil)
+            printable[:start_year] = format_for_display(@start_year, nil)
+            printable
+          end
+
+          # @return [String]
+          def to_table_line
+            printable = table_printable_values
+            out_str = String.new
+            out_str << format('| %- 16s', printable[:contract_type])
+            out_str << format('| %- 11s', printable[:department])
+            out_str << format('| %- 37s', printable[:description])
+            out_str << format('| %- 26s', printable[:employer])
+            out_str << format('| %- 10s', printable[:end_month])
+            out_str << format('| %- 9s', printable[:end_year])
+            out_str << format('| %- 21s', printable[:role])
+            out_str << format('| %- 12s', printable[:start_month])
+            out_str << format('| %- 11s', printable[:start_year])
+            out_str << '|'
+          end
+
+          # @return [String]
+          def to_s
+            printable = printable_values
+            out_str = String.new
+            out_str << "\n  :Contract Type: #{printable[:contract_type]}"
+            out_str << "\n  :Department: #{printable[:department]}"
+            out_str << "\n  :Description: #{printable[:description]}"
+            out_str << "\n  :Employer: #{printable[:employer]}"
+            out_str << "\n  :End Month: #{printable[:end_month]}"
+            out_str << "\n  :End Year: #{printable[:end_year]}"
+            out_str << "\n  :Role: #{printable[:role]}"
+            out_str << "\n  :Start Month: #{printable[:start_month]}"
+            out_str << "\n  :Start Year: #{printable[:start_year]}"
+            out_str
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mindee/v1/product/resume/resume_v1_professional_experiences.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require_relative 'resume_v1_social_networks_url'
+require_relative 'resume_v1_language'
+require_relative 'resume_v1_education'
+require_relative 'resume_v1_professional_experience'
+require_relative 'resume_v1_certificate'
+
+module Mindee
+  module V1
+    module Product
+      module Resume
+        # The list of the candidate's professional experiences.
+        class ResumeV1ProfessionalExperiences < Array
+          # Entries.
+          # @return [Array<ResumeV1ProfessionalExperience>]
+          attr_reader :entries
+
+          # @param prediction [Array]
+          # @param page_id [Integer, nil]
+          def initialize(prediction, page_id)
+            entries = prediction.map do |entry|
+              Resume::ResumeV1ProfessionalExperience.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 * 17}"
+            out_str << "+#{char * 12}"
+            out_str << "+#{char * 38}"
+            out_str << "+#{char * 27}"
+            out_str << "+#{char * 11}"
+            out_str << "+#{char * 10}"
+            out_str << "+#{char * 22}"
+            out_str << "+#{char * 13}"
+            out_str << "+#{char * 12}"
+            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 << ' | Contract Type  '
+            out_str << ' | Department'
+            out_str << ' | Description                         '
+            out_str << ' | Employer                 '
+            out_str << ' | End Month'
+            out_str << ' | End Year'
+            out_str << ' | Role                '
+            out_str << ' | Start Month'
+            out_str << ' | Start Year'
+            out_str << " |\n#{self.class.line_items_separator('=')}"
+            out_str + lines
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mindee/v1/product/resume/resume_v1_social_networks_url.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require_relative '../../parsing'
+
+module Mindee
+  module V1
+    module Product
+      module Resume
+        # The list of social network profiles of the candidate.
+        class ResumeV1SocialNetworksUrl < Mindee::V1::Parsing::Standard::FeatureField
+          include Mindee::V1::Parsing::Standard
+
+          # The name of the social network.
+          # @return [String]
+          attr_reader :name
+          # The URL of the social network.
+          # @return [String]
+          attr_reader :url
+
+          # @param prediction [Hash]
+          # @param page_id [Integer, nil]
+          def initialize(prediction, page_id)
+            super
+            @name = prediction['name']
+            @url = prediction['url']
+            @page_id = page_id
+          end
+
+          # @return [Hash]
+          def printable_values
+            printable = {} # @type var printable: Hash[Symbol, String]
+            printable[:name] = format_for_display(@name)
+            printable[:url] = format_for_display(@url)
+            printable
+          end
+
+          # @return [Hash]
+          def table_printable_values
+            printable = {} # @type var printable: Hash[Symbol, String]
+            printable[:name] = format_for_display(@name, 20)
+            printable[:url] = format_for_display(@url, 50)
+            printable
+          end
+
+          # @return [String]
+          def to_table_line
+            printable = table_printable_values
+            out_str = String.new
+            out_str << format('| %- 21s', printable[:name])
+            out_str << format('| %- 51s', printable[:url])
+            out_str << '|'
+          end
+
+          # @return [String]
+          def to_s
+            printable = printable_values
+            out_str = String.new
+            out_str << "\n  :Name: #{printable[:name]}"
+            out_str << "\n  :URL: #{printable[:url]}"
+            out_str
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mindee/v1/product/resume/resume_v1_social_networks_urls.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative 'resume_v1_social_networks_url'
+require_relative 'resume_v1_language'
+require_relative 'resume_v1_education'
+require_relative 'resume_v1_professional_experience'
+require_relative 'resume_v1_certificate'
+
+module Mindee
+  module V1
+    module Product
+      module Resume
+        # The list of social network profiles of the candidate.
+        class ResumeV1SocialNetworksUrls < Array
+          # Entries.
+          # @return [Array<ResumeV1SocialNetworksUrl>]
+          attr_reader :entries
+
+          # @param prediction [Array]
+          # @param page_id [Integer, nil]
+          def initialize(prediction, page_id)
+            entries = prediction.map do |entry|
+              Resume::ResumeV1SocialNetworksUrl.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 * 22}"
+            out_str << "+#{char * 52}"
+            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 << ' | Name                '
+            out_str << ' | URL                                               '
+            out_str << " |\n#{self.class.line_items_separator('=')}"
+            out_str + lines
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mindee/v1/product/universal/universal.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative 'universal_document'
+require_relative 'universal_page'
+
+module Mindee
+  module V1
+    module Product
+      # Universal product module.
+      module Universal
+        # Universal Document V1 prediction inference.
+        class Universal < Mindee::V1::Parsing::Common::Inference
+          @endpoint_name = ''
+          @endpoint_version = ''
+          @has_sync = true
+          @has_async = true
+
+          # @param prediction [Hash]
+          def initialize(prediction)
+            super
+            @prediction = UniversalDocument.new(prediction['prediction'])
+            @pages = [] # : Array[Mindee::V1::Parsing::Common::Page]
+            prediction['pages'].each do |page|
+              if page.key?('prediction') && !page['prediction'].nil? && !page['prediction'].empty?
+                @pages.push(UniversalPage.new(page))
+              end
+            end
+          end
+
+          class << self
+            # Name of the endpoint for this product.
+            # @return [String]
+            attr_reader :endpoint_name
+            # 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
+    end
+  end
+end

data/lib/mindee/v1/product/universal/universal_document.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative '../../parsing'
+require_relative 'universal_prediction'
+
+module Mindee
+  module V1
+    module Product
+      module Universal
+        # Universal Document V1 prediction
+        class UniversalDocument < Mindee::V1::Product::Universal::UniversalPrediction
+          include Mindee::V1::Parsing::Standard
+
+          # @param raw_prediction [Hash]
+          def initialize(raw_prediction)
+            super
+            raw_prediction.each do |field_name, field_contents|
+              if field_contents.is_a?(Array)
+                @fields[field_name] = Parsing::Universal::UniversalListField.new(field_contents)
+              elsif field_contents.is_a?(Hash) && Parsing::Universal.universal_object?(field_contents)
+                @fields[field_name] = Parsing::Universal::UniversalObjectField.new(field_contents)
+              else
+                field_contents_str = field_contents.dup
+                if field_contents_str.key?('value') && field_contents_str['value'].nil? == false
+                  field_contents_str['value'] = field_contents_str['value'].to_s
+                end
+                @fields[field_name] = Mindee::V1::Parsing::Standard::StringField.new(field_contents_str)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mindee/v1/product/universal/universal_page.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative '../../parsing'
+require_relative 'universal_prediction'
+
+module Mindee
+  module V1
+    module Product
+      module Universal
+        # Universal Document V1 page.
+        class UniversalPage < Mindee::V1::Parsing::Common::Page
+          # @param prediction [Hash]
+          def initialize(prediction)
+            super
+            @prediction = UniversalPagePrediction.new(
+              prediction['prediction'],
+              prediction['id']
+            )
+          end
+        end
+
+        # Universal Document V1 page prediction.
+        class UniversalPagePrediction < UniversalPrediction
+          include Mindee::V1::Parsing::Standard
+          include Mindee::V1::Parsing::Universal
+
+          def initialize(raw_prediction, page_id = nil)
+            super(raw_prediction)
+            raw_prediction.each do |field_name, field_contents|
+              if field_contents.is_a?(Array)
+                @fields[field_name] = Mindee::V1::Parsing::Universal::UniversalListField.new(field_contents, page_id)
+              elsif field_contents.is_a?(Hash) && Parsing::Universal.universal_object?(field_contents)
+                @fields[field_name] = Mindee::V1::Parsing::Universal::UniversalObjectField.new(field_contents, page_id)
+              else
+                field_contents_str = field_contents.dup
+                if field_contents_str.key?('value') && !field_contents_str['value'].nil?
+                  field_contents_str['value'] = field_contents_str['value'].to_s
+                end
+                @fields[field_name] = Mindee::V1::Parsing::Standard::StringField.new(field_contents_str, page_id)
+              end
+            end
+          end
+
+          # @return [String]
+          def to_s
+            out_str = String.new
+            out_str << "\n#{super}"
+            out_str
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mindee/v1/product/universal/universal_prediction.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require_relative '../../parsing'
+
+module Mindee
+  module V1
+    module Product
+      module Universal
+        # Universal Document V1 page.
+        class UniversalPrediction < Mindee::V1::Parsing::Common::Prediction
+          include Mindee::V1::Parsing::Common
+          include Mindee::V1::Parsing::Standard
+          include Mindee::V1::Parsing::Universal
+
+          # All value fields in the document
+          # @return [Hash<Symbol, Mindee::V1::Parsing::Universal::UniversalListField>]
+          attr_reader :fields
+
+          def initialize(_ = nil)
+            super
+            @fields = {} # : Hash[String | Symbol, untyped]
+          end
+
+          # String representation.
+          def to_s
+            out_str = ''
+            pattern = %r{^(\n* *)( {2}):}
+            @fields.each do |field_name, field_value|
+              str_value = if field_value.is_a?(
+                Mindee::V1::Parsing::Universal::UniversalListField
+              ) && field_value.values.length.positive?
+                            generate_field_string(field_name, field_value, pattern)
+                          else
+                            field_value.to_s
+                          end
+              out_str += "\n:#{field_name}:"
+
+              out_str += " #{str_value}".sub(%r{^\s+\n}, "\n") if str_value.length.positive?
+            end
+            out_str.sub("\n", '')
+          end
+
+          private
+
+          def generate_field_string(field_name, field_value, pattern)
+            values = field_value.values
+            return '' if values.nil? || values.empty?
+
+            str_value = ''
+            first_value = values[0]
+            str_value += if first_value.is_a?(Parsing::Universal::UniversalObjectField)
+                           first_value.str_level(1).sub(pattern, '\\1* :')
+                         else
+                           "#{first_value.to_s.sub(pattern, '\\1* :')}\n"
+                         end
+            Array(values[1..]).each do |sub_value|
+              str_value += if sub_value.is_a?(Parsing::Universal::UniversalObjectField)
+                             sub_value.str_level(1).sub(pattern, '\\1* :')
+                           else
+                             "#{' ' * (field_name.length + 2)} #{sub_value}\n"
+                           end
+            end
+
+            str_value.rstrip
+          end
+
+          def generate_list_field_string(field_name, field_value, pattern)
+            str_value = ''
+            field_value.each_value do |sub_value|
+              str_value += generate_sub_value_string(field_name, sub_value, pattern)
+            end
+            str_value.rstrip
+          end
+
+          def generate_sub_value_string(field_name, sub_value, pattern)
+            if sub_value.is_a?(Mindee::V1::Parsing::Universal::UniversalObjectField)
+              sub_value.str_level(1).gsub(pattern, '\1* :')
+            else
+              (' ' * (field_name.length + 2)) + "#{sub_value}\n"
+            end
+          end
+
+          # Returns a hash of all fields that aren't a collection
+          # @return [Hash<String, StringField>]
+          def single_fields
+            single_fields = {} # : Hash[String | Symbol, untyped]
+            @fields.each do |field_name, field_value|
+              single_fields[field_name] = field_value if field_value.is_a?(Mindee::V1::Parsing::Standard::StringField)
+            end
+            single_fields
+          end
+
+          # Returns a hash of all list-like fields
+          # @return [Hash<String, UniversalListField>]
+          def list_fields
+            list_fields = {} # : Hash[String | Symbol, Mindee::V1::Parsing::Universal::UniversalListField]
+            @fields.each do |field_name, field_value|
+              if field_value.is_a?(Mindee::V1::Parsing::Universal::UniversalListField)
+                list_fields[field_name] =
+                  field_value
+              end
+            end
+            list_fields
+          end
+
+          # Returns a hash of all object-like fields
+          # @return [Hash<String, UniversalObjectField>]
+          def object_fields
+            object_fields = {} # : Hash[String | Symbol, untyped]
+            @fields.each do |field_name, field_value|
+              if field_value.is_a?(Mindee::V1::Parsing::Universal::UniversalObjectField)
+                object_fields[field_name] =
+                  field_value
+              end
+            end
+            object_fields
+          end
+
+          # Lists names of all top-level field keys
+          # @return [Array<String>]
+          def list_field_names
+            @fields.keys.map(&:to_s)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mindee/v1/product.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative 'product/barcode_reader/barcode_reader_v1'
+require_relative 'product/cropper/cropper_v1'
+require_relative 'product/financial_document/financial_document_v1'
+require_relative 'product/fr/bank_account_details/bank_account_details_v1'
+require_relative 'product/fr/bank_account_details/bank_account_details_v2'
+require_relative 'product/fr/bank_statement/bank_statement_v2'
+require_relative 'product/fr/id_card/id_card_v1'
+require_relative 'product/fr/id_card/id_card_v2'
+require_relative 'product/international_id/international_id_v2'
+require_relative 'product/invoice/invoice_v4'
+require_relative 'product/invoice_splitter/invoice_splitter_v1'
+require_relative 'product/multi_receipts_detector/multi_receipts_detector_v1'
+require_relative 'product/passport/passport_v1'
+require_relative 'product/receipt/receipt_v5'
+require_relative 'product/resume/resume_v1'
+require_relative 'product/universal/universal'

data/lib/mindee/v1.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require_relative 'v1/client'
+require_relative 'v1/extraction' if Mindee::Dependency.all_deps_available?
+require_relative 'v1/http'
+require_relative 'v1/parsing'
+require_relative 'v1/product'