mindee 4.13.0 → 5.0.0.rc1

data/lib/mindee/{product/us/us_mail/us_mail_v3_page.rb → v1/product/resume/resume_v1_page.rb}

@@ -1,21 +1,21 @@
 # frozen_string_literal: true
 
-require_relative '../../../parsing'
-require_relative 'us_mail_v3_document'
+require_relative '../../parsing'
+require_relative 'resume_v1_document'
 
 module Mindee
-  module Product
-    module US
-      module UsMail
-        # US Mail API version 3.0 page data.
-        class UsMailV3Page < Mindee::Parsing::Common::Page
+  module V1
+    module Product
+      module Resume
+        # Resume API version 1.2 page data.
+        class ResumeV1Page < Mindee::V1::Parsing::Common::Page
           # @param prediction [Hash]
           def initialize(prediction)
             super
             @prediction = if prediction['prediction'].empty?
                             nil
                           else
-                            UsMailV3PagePrediction.new(
+                            ResumeV1PagePrediction.new(
                               prediction['prediction'],
                               prediction['id']
                             )
@@ -23,8 +23,8 @@ module Mindee
           end
         end
 
-        # US Mail V3 page prediction.
-        class UsMailV3PagePrediction < UsMailV3Document
+        # Resume V1 page prediction.
+        class ResumeV1PagePrediction < ResumeV1Document
           # @return [String]
           def to_s
             out_str = String.new

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/{product/fr/energy_bill/energy_bill_v1_energy_usages.rb → v1/product/resume/resume_v1_professional_experiences.rb}

@@ -1,27 +1,26 @@
 # frozen_string_literal: true
 
-require_relative 'energy_bill_v1_energy_supplier'
-require_relative 'energy_bill_v1_energy_consumer'
-require_relative 'energy_bill_v1_subscription'
-require_relative 'energy_bill_v1_energy_usage'
-require_relative 'energy_bill_v1_taxes_and_contribution'
-require_relative 'energy_bill_v1_meter_detail'
+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 Product
-    module FR
-      module EnergyBill
-        # Details of energy consumption.
-        class EnergyBillV1EnergyUsages < Array
+  module V1
+    module Product
+      module Resume
+        # The list of the candidate's professional experiences.
+        class ResumeV1ProfessionalExperiences < Array
           # Entries.
-          # @return [Array<EnergyBillV1EnergyUsage>]
+          # @return [Array<ResumeV1ProfessionalExperience>]
           attr_reader :entries
 
           # @param prediction [Array]
           # @param page_id [Integer, nil]
           def initialize(prediction, page_id)
             entries = prediction.map do |entry|
-              EnergyBill::EnergyBillV1EnergyUsage.new(entry, page_id)
+              Resume::ResumeV1ProfessionalExperience.new(entry, page_id)
             end
             super(entries)
           end
@@ -31,13 +30,14 @@ module Mindee
           # @return [String]
           def self.line_items_separator(char)
             out_str = String.new
-            out_str << "+#{char * 13}"
-            out_str << "+#{char * 38}"
-            out_str << "+#{char * 12}"
+            out_str << "+#{char * 17}"
             out_str << "+#{char * 12}"
-            out_str << "+#{char * 10}"
+            out_str << "+#{char * 38}"
+            out_str << "+#{char * 27}"
             out_str << "+#{char * 11}"
-            out_str << "+#{char * 17}"
+            out_str << "+#{char * 10}"
+            out_str << "+#{char * 22}"
+            out_str << "+#{char * 13}"
             out_str << "+#{char * 12}"
             out_str
           end
@@ -51,14 +51,15 @@ module Mindee
             end.join
             out_str = String.new
             out_str << "\n#{self.class.line_items_separator('-')}\n "
-            out_str << ' | Consumption'
+            out_str << ' | Contract Type  '
+            out_str << ' | Department'
             out_str << ' | Description                         '
-            out_str << ' | End Date  '
-            out_str << ' | Start Date'
-            out_str << ' | Tax Rate'
-            out_str << ' | Total    '
-            out_str << ' | Unit of Measure'
-            out_str << ' | Unit Price'
+            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

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/{product/fr/bank_statement/bank_statement_v2.rb → v1/product/universal/universal.rb}

@@ -1,28 +1,29 @@
 # frozen_string_literal: true
 
-require_relative '../../../parsing'
-require_relative 'bank_statement_v2_document'
-require_relative 'bank_statement_v2_page'
+require_relative 'universal_document'
+require_relative 'universal_page'
 
 module Mindee
-  module Product
-    module FR
-      # Bank Statement module.
-      module BankStatement
-        # Bank Statement API version 2 inference prediction.
-        class BankStatementV2 < Mindee::Parsing::Common::Inference
-          @endpoint_name = 'bank_statement_fr'
-          @endpoint_version = '2'
+  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
-          @has_sync = false
 
           # @param prediction [Hash]
           def initialize(prediction)
             super
-            @prediction = BankStatementV2Document.new(prediction['prediction'], nil)
-            @pages = []
+            @prediction = UniversalDocument.new(prediction['prediction'])
+            @pages = [] # : Array[Mindee::V1::Parsing::Common::Page]
             prediction['pages'].each do |page|
-              @pages.push(BankStatementV2Page.new(page))
+              if page.key?('prediction') && !page['prediction'].nil? && !page['prediction'].empty?
+                @pages.push(UniversalPage.new(page))
+              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/{product.rb → v1/product.rb}

@@ -1,32 +1,18 @@
 # frozen_string_literal: true
 
 require_relative 'product/barcode_reader/barcode_reader_v1'
-require_relative 'product/bill_of_lading/bill_of_lading_v1'
-require_relative 'product/business_card/business_card_v1'
 require_relative 'product/cropper/cropper_v1'
-require_relative 'product/delivery_note/delivery_note_v1'
-require_relative 'product/driver_license/driver_license_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/carte_grise/carte_grise_v1'
-require_relative 'product/fr/energy_bill/energy_bill_v1'
-require_relative 'product/fr/health_card/health_card_v1'
 require_relative 'product/fr/id_card/id_card_v1'
 require_relative 'product/fr/id_card/id_card_v2'
-require_relative 'product/fr/payslip/payslip_v2'
-require_relative 'product/fr/payslip/payslip_v3'
-require_relative 'product/ind/indian_passport/indian_passport_v1'
 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/nutrition_facts_label/nutrition_facts_label_v1'
 require_relative 'product/passport/passport_v1'
 require_relative 'product/receipt/receipt_v5'
 require_relative 'product/resume/resume_v1'
 require_relative 'product/universal/universal'
-require_relative 'product/us/bank_check/bank_check_v1'
-require_relative 'product/us/healthcare_card/healthcare_card_v1'
-require_relative 'product/us/us_mail/us_mail_v3'

data/lib/mindee/v1.rb

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