mindee 3.19.1 → 4.0.0

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

@@ -0,0 +1,68 @@
+# 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 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

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

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

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

@@ -0,0 +1,54 @@
+# 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 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

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative 'universal_document'
+require_relative 'universal_page'
+
+module Mindee
+  module Product
+    # Universal product module.
+    module Universal
+      # Universal Document V1 prediction inference.
+      class Universal < Mindee::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::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

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative '../../parsing'
+require_relative 'universal_prediction'
+
+module Mindee
+  module Product
+    module Universal
+      # Universal Document V1 prediction
+      class UniversalDocument < Mindee::Product::Universal::UniversalPrediction
+        include Mindee::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::Parsing::Standard::StringField.new(field_contents_str)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mindee/product/{generated/generated_v1_page.rb → universal/universal_page.rb}

@@ -1,40 +1,40 @@
 # frozen_string_literal: true
 
 require_relative '../../parsing'
-require_relative 'generated_v1_prediction'
+require_relative 'universal_prediction'
 
 module Mindee
   module Product
-    module Generated
-      # Generated Document V1 page.
-      class GeneratedV1Page < Mindee::Parsing::Common::Page
+    module Universal
+      # Universal Document V1 page.
+      class UniversalPage < Mindee::Parsing::Common::Page
         # @param prediction [Hash]
         def initialize(prediction)
-          super(prediction)
-          @prediction = GeneratedV1PagePrediction.new(
+          super
+          @prediction = UniversalPagePrediction.new(
             prediction['prediction'],
             prediction['id']
           )
         end
       end
 
-      # Generated Document V1 page prediction.
-      class GeneratedV1PagePrediction < GeneratedV1Prediction
+      # Universal Document V1 page prediction.
+      class UniversalPagePrediction < UniversalPrediction
         include Mindee::Parsing::Standard
-        include Mindee::Parsing::Generated
+        include Mindee::Parsing::Universal
         def initialize(raw_prediction, page_id = nil)
-          super()
+          super(raw_prediction)
           raw_prediction.each do |field_name, field_contents|
             if field_contents.is_a?(Array)
-              @fields[field_name] = GeneratedListField.new(field_contents, page_id)
-            elsif field_contents.is_a?(Hash) && Parsing::Generated.generated_object?(field_contents)
-              @fields[field_name] = GeneratedObjectField.new(field_contents, page_id)
+              @fields[field_name] = Mindee::Parsing::Universal::UniversalListField.new(field_contents, page_id)
+            elsif field_contents.is_a?(Hash) && Parsing::Universal.universal_object?(field_contents)
+              @fields[field_name] = Mindee::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] = StringField.new(field_contents_str, page_id)
+              @fields[field_name] = Mindee::Parsing::Standard::StringField.new(field_contents_str, page_id)
             end
           end
         end

data/lib/mindee/product/{generated/generated_v1_prediction.rb → universal/universal_prediction.rb}

@@ -4,19 +4,19 @@ require_relative '../../parsing'
 
 module Mindee
   module Product
-    module Generated
-      # Generated Document V1 page.
-      class GeneratedV1Prediction < Mindee::Parsing::Common::Prediction
+    module Universal
+      # Universal Document V1 page.
+      class UniversalPrediction < Mindee::Parsing::Common::Prediction
         include Mindee::Parsing::Common
         include Mindee::Parsing::Standard
-        include Mindee::Parsing::Generated
+        include Mindee::Parsing::Universal
         # All value fields in the document
-        # @return [Hash<Symbol, Mindee::Parsing::Generated::GeneratedListField>]
+        # @return [Hash<Symbol, Mindee::Parsing::Universal::UniversalListField>]
         attr_reader :fields
 
-        def initialize
-          super()
-          @fields = {}
+        def initialize(_ = nil)
+          super
+          @fields = {} # : Hash[Symbol | String, untyped]
         end
 
         # String representation.
@@ -24,7 +24,9 @@ module Mindee
           out_str = ''
           pattern = %r{^(\n* *)( {2}):}
           @fields.each do |field_name, field_value|
-            str_value = if field_value.is_a?(GeneratedListField) && field_value.values.length.positive?
+            str_value = if field_value.is_a?(
+              Mindee::Parsing::Universal::UniversalListField
+            ) && field_value.values.length.positive?
                           generate_field_string(field_name, field_value, pattern)
                         else
                           field_value.to_s
@@ -39,21 +41,24 @@ module Mindee
         private
 
         def generate_field_string(field_name, field_value, pattern)
-          return '' if field_value.values.empty? || field_value.values.nil?
+          values = field_value.values
+          return '' if values.nil? || values.empty?
 
           str_value = ''
-          str_value += if field_value.values[0].is_a?(Parsing::Generated::GeneratedObjectField)
-                         field_value.values[0].str_level(1).sub(pattern, '\\1* :')
+          first_value = values[0]
+          str_value += if first_value.is_a?(Parsing::Universal::UniversalObjectField)
+                         first_value.str_level(1).sub(pattern, '\\1* :')
                        else
-                         "#{field_value.values[0].to_s.sub(pattern, '\\1* :')}\n"
+                         "#{first_value.to_s.sub(pattern, '\\1* :')}\n"
                        end
-          field_value.values[1..].each do |sub_value|
-            str_value += if sub_value.is_a?(Parsing::Generated::GeneratedObjectField)
+          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
 
@@ -66,7 +71,7 @@ module Mindee
         end
 
         def generate_sub_value_string(field_name, sub_value, pattern)
-          if sub_value.is_a?(GeneratedObjectField)
+          if sub_value.is_a?(Mindee::Parsing::Universal::UniversalObjectField)
             sub_value.str_level(1).gsub(pattern, '\1* :')
           else
             (' ' * (field_name.length + 2)) + "#{sub_value}\n"
@@ -76,29 +81,32 @@ module Mindee
         # Returns a hash of all fields that aren't a collection
         # @return [Hash<String, StringField>]
         def single_fields
-          single_fields = {}
+          single_fields = {} # : Hash[Symbol | String, untyped]
           @fields.each do |field_name, field_value|
-            single_fields[field_name] = field_value if field_value.is_a?(StringField)
+            single_fields[field_name] = field_value if field_value.is_a?(Mindee::Parsing::Standard::StringField)
           end
           single_fields
         end
 
         # Returns a hash of all list-like fields
-        # @return [Hash<String, GeneratedListField>]
+        # @return [Hash<String, UniversalListField>]
         def list_fields
-          list_fields = {}
+          list_fields = {} # : Hash[Symbol | String, Mindee::Parsing::Universal::UniversalListField]
           @fields.each do |field_name, field_value|
-            list_fields[field_name] = field_value if field_value.is_a?(GeneratedListField)
+            list_fields[field_name] = field_value if field_value.is_a?(Mindee::Parsing::Universal::UniversalListField)
           end
           list_fields
         end
 
         # Returns a hash of all object-like fields
-        # @return [Hash<String, GeneratedObjectField>]
+        # @return [Hash<String, UniversalObjectField>]
         def object_fields
-          object_fields = {}
+          object_fields = {} # : Hash[Symbol | String, untyped]
           @fields.each do |field_name, field_value|
-            object_fields[field_name] = field_value if field_value.is_a?(GeneratedObjectField)
+            if field_value.is_a?(Mindee::Parsing::Universal::UniversalObjectField)
+              object_fields[field_name] =
+                field_value
+            end
           end
           object_fields
         end

data/lib/mindee/product/us/bank_check/bank_check_v1.rb

@@ -13,6 +13,8 @@ module Mindee
         class BankCheckV1 < Mindee::Parsing::Common::Inference
           @endpoint_name = 'bank_check'
           @endpoint_version = '1'
+          @has_async = false
+          @has_sync = true
 
           # @param prediction [Hash]
           def initialize(prediction)
@@ -20,9 +22,7 @@ module Mindee
             @prediction = BankCheckV1Document.new(prediction['prediction'], nil)
             @pages = []
             prediction['pages'].each do |page|
-              if page.key?('prediction') && !page['prediction'].nil? && !page['prediction'].empty?
-                @pages.push(BankCheckV1Page.new(page))
-              end
+              @pages.push(BankCheckV1Page.new(page))
             end
           end
 
@@ -33,6 +33,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/us/bank_check/bank_check_v1_document.rb

@@ -31,16 +31,28 @@ module Mindee
           # @param prediction [Hash]
           # @param page_id [Integer, nil]
           def initialize(prediction, page_id)
-            super()
-            @account_number = StringField.new(prediction['account_number'], page_id)
-            @amount = AmountField.new(prediction['amount'], page_id)
-            @check_number = StringField.new(prediction['check_number'], page_id)
-            @date = DateField.new(prediction['date'], page_id)
-            @payees = []
+            super
+            @account_number = Parsing::Standard::StringField.new(
+              prediction['account_number'],
+              page_id
+            )
+            @amount = Parsing::Standard::AmountField.new(
+              prediction['amount'],
+              page_id
+            )
+            @check_number = Parsing::Standard::StringField.new(
+              prediction['check_number'],
+              page_id
+            )
+            @date = Parsing::Standard::DateField.new(prediction['date'], page_id)
+            @payees = [] # : Array[Parsing::Standard::StringField]
             prediction['payees'].each do |item|
-              @payees.push(StringField.new(item, page_id))
+              @payees.push(Parsing::Standard::StringField.new(item, page_id))
             end
-            @routing_number = StringField.new(prediction['routing_number'], page_id)
+            @routing_number = Parsing::Standard::StringField.new(
+              prediction['routing_number'],
+              page_id
+            )
           end
 
           # @return [String]

data/lib/mindee/product/us/bank_check/bank_check_v1_page.rb

@@ -11,11 +11,15 @@ module Mindee
         class BankCheckV1Page < Mindee::Parsing::Common::Page
           # @param prediction [Hash]
           def initialize(prediction)
-            super(prediction)
-            @prediction = BankCheckV1PagePrediction.new(
-              prediction['prediction'],
-              prediction['id']
-            )
+            super
+            @prediction = if prediction['prediction'].empty?
+                            nil
+                          else
+                            BankCheckV1PagePrediction.new(
+                              prediction['prediction'],
+                              prediction['id']
+                            )
+                          end
           end
         end
 
@@ -33,12 +37,15 @@ module Mindee
           # @param prediction [Hash]
           # @param page_id [Integer, nil]
           def initialize(prediction, page_id)
-            @check_position = PositionField.new(prediction['check_position'], page_id)
+            @check_position = Parsing::Standard::PositionField.new(
+              prediction['check_position'],
+              page_id
+            )
             @signatures_positions = []
             prediction['signatures_positions'].each do |item|
-              @signatures_positions.push(PositionField.new(item, page_id))
+              @signatures_positions.push(Parsing::Standard::PositionField.new(item, page_id))
             end
-            super(prediction, page_id)
+            super
           end
 
           # @return [String]

data/lib/mindee/product/us/healthcare_card/healthcare_card_v1.rb

@@ -13,6 +13,8 @@ module Mindee
         class HealthcareCardV1 < Mindee::Parsing::Common::Inference
           @endpoint_name = 'us_healthcare_cards'
           @endpoint_version = '1'
+          @has_async = true
+          @has_sync = false
 
           # @param prediction [Hash]
           def initialize(prediction)
@@ -20,9 +22,7 @@ module Mindee
             @prediction = HealthcareCardV1Document.new(prediction['prediction'], nil)
             @pages = []
             prediction['pages'].each do |page|
-              if page.key?('prediction') && !page['prediction'].nil? && !page['prediction'].empty?
-                @pages.push(HealthcareCardV1Page.new(page))
-              end
+              @pages.push(HealthcareCardV1Page.new(page))
             end
           end
 
@@ -33,6 +33,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/us/healthcare_card/healthcare_card_v1_copay.rb

@@ -19,7 +19,7 @@ module Mindee
           # @param prediction [Hash]
           # @param page_id [Integer, nil]
           def initialize(prediction, page_id)
-            super(prediction, page_id)
+            super
             @service_fees = prediction['service_fees']
             @service_name = prediction['service_name']
             @page_id = page_id
@@ -28,7 +28,8 @@ module Mindee
           # @return [Hash]
           def printable_values
             printable = {}
-            printable[:service_fees] = @service_fees.nil? ? '' : Field.float_to_string(@service_fees)
+            printable[:service_fees] =
+              @service_fees.nil? ? '' : Parsing::Standard::BaseField.float_to_string(@service_fees)
             printable[:service_name] = format_for_display(@service_name)
             printable
           end
@@ -36,7 +37,8 @@ module Mindee
           # @return [Hash]
           def table_printable_values
             printable = {}
-            printable[:service_fees] = @service_fees.nil? ? '' : Field.float_to_string(@service_fees)
+            printable[:service_fees] =
+              @service_fees.nil? ? '' : Parsing::Standard::BaseField.float_to_string(@service_fees)
             printable[:service_name] = format_for_display(@service_name, nil)
             printable
           end

data/lib/mindee/product/us/healthcare_card/healthcare_card_v1_copays.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative 'healthcare_card_v1_copay'
+
+module Mindee
+  module Product
+    module US
+      module HealthcareCard
+        # Is a fixed amount for a covered service.
+        class HealthcareCardV1Copays < Array
+          # Entries.
+          # @return [Array<HealthcareCardV1Copay>]
+          attr_reader :entries
+
+          # @param prediction [Array]
+          # @param page_id [Integer, nil]
+          def initialize(prediction, page_id)
+            entries = prediction.map do |entry|
+              HealthcareCard::HealthcareCardV1Copay.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 * 14}"
+            out_str << "+#{char * 14}"
+            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 << ' | Service Fees'
+            out_str << ' | Service Name'
+            out_str << (" |\n#{self.class.line_items_separator('=')}")
+            out_str + lines
+          end
+        end
+      end
+    end
+  end
+end