mindee 4.13.0 → 5.0.0.beta1

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

@@ -1,119 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../../parsing'
-
-module Mindee
-  module Product
-    module Resume
-      # The list of the candidate's professional experiences.
-      class ResumeV1ProfessionalExperience < Mindee::Parsing::Standard::FeatureField
-        include Mindee::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 = {}
-          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 = {}
-          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

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

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

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../../parsing'
-
-module Mindee
-  module Product
-    module Resume
-      # The list of social network profiles of the candidate.
-      class ResumeV1SocialNetworksUrl < Mindee::Parsing::Standard::FeatureField
-        include Mindee::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 = {}
-          printable[:name] = format_for_display(@name)
-          printable[:url] = format_for_display(@url)
-          printable
-        end
-
-        # @return [Hash]
-        def table_printable_values
-          printable = {}
-          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

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

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

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

@@ -1,32 +0,0 @@
-# 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/universal/universal_page.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../../parsing'
-require_relative 'universal_prediction'
-
-module Mindee
-  module Product
-    module Universal
-      # Universal Document V1 page.
-      class UniversalPage < Mindee::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::Parsing::Standard
-        include Mindee::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::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] = Mindee::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

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

@@ -1,122 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../../parsing'
-
-module Mindee
-  module Product
-    module Universal
-      # Universal Document V1 page.
-      class UniversalPrediction < Mindee::Parsing::Common::Prediction
-        include Mindee::Parsing::Common
-        include Mindee::Parsing::Standard
-        include Mindee::Parsing::Universal
-        # All value fields in the document
-        # @return [Hash<Symbol, Mindee::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::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::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::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::Parsing::Universal::UniversalListField]
-          @fields.each do |field_name, field_value|
-            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, UniversalObjectField>]
-        def object_fields
-          object_fields = {} # : Hash[String | Symbol, untyped]
-          @fields.each do |field_name, field_value|
-            if field_value.is_a?(Mindee::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

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

@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../../../parsing'
-
-module Mindee
-  module Product
-    module US
-      module BankCheck
-        # Bank Check API version 1.1 document data.
-        class BankCheckV1Document < Mindee::Parsing::Common::Prediction
-          include Mindee::Parsing::Standard
-          # The check payer's account number.
-          # @return [Mindee::Parsing::Standard::StringField]
-          attr_reader :account_number
-          # The amount of the check.
-          # @return [Mindee::Parsing::Standard::AmountField]
-          attr_reader :amount
-          # The issuer's check number.
-          # @return [Mindee::Parsing::Standard::StringField]
-          attr_reader :check_number
-          # The date the check was issued.
-          # @return [Mindee::Parsing::Standard::DateField]
-          attr_reader :date
-          # List of the check's payees (recipients).
-          # @return [Array<Mindee::Parsing::Standard::StringField>]
-          attr_reader :payees
-          # The check issuer's routing number.
-          # @return [Mindee::Parsing::Standard::StringField]
-          attr_reader :routing_number
-
-          # @param prediction [Hash]
-          # @param page_id [Integer, nil]
-          def initialize(prediction, page_id)
-            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(Parsing::Standard::StringField.new(item, page_id))
-            end
-            @routing_number = Parsing::Standard::StringField.new(
-              prediction['routing_number'],
-              page_id
-            )
-          end
-
-          # @return [String]
-          def to_s
-            payees = @payees.join("\n #{' ' * 8}")
-            out_str = String.new
-            out_str << "\n:Check Issue Date: #{@date}".rstrip
-            out_str << "\n:Amount: #{@amount}".rstrip
-            out_str << "\n:Payees: #{payees}".rstrip
-            out_str << "\n:Routing Number: #{@routing_number}".rstrip
-            out_str << "\n:Account Number: #{@account_number}".rstrip
-            out_str << "\n:Check Number: #{@check_number}".rstrip
-            out_str[1..].to_s
-          end
-        end
-      end
-    end
-  end
-end