mindee 3.20.0 → 4.0.0

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

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
 require_relative '../../parsing'
-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'
+require_relative 'resume_v1_social_networks_urls'
+require_relative 'resume_v1_languages'
+require_relative 'resume_v1_educations'
+require_relative 'resume_v1_professional_experiences'
+require_relative 'resume_v1_certificates'
 
 module Mindee
   module Product
@@ -17,7 +17,7 @@ module Mindee
         # @return [Mindee::Parsing::Standard::StringField]
         attr_reader :address
         # The list of certificates obtained by the candidate.
-        # @return [Array<Mindee::Product::Resume::ResumeV1Certificate>]
+        # @return [Mindee::Product::Resume::ResumeV1Certificates]
         attr_reader :certificates
         # The ISO 639 code of the language in which the document is written.
         # @return [Mindee::Parsing::Standard::StringField]
@@ -26,7 +26,7 @@ module Mindee
         # @return [Mindee::Parsing::Standard::ClassificationField]
         attr_reader :document_type
         # The list of the candidate's educational background.
-        # @return [Array<Mindee::Product::Resume::ResumeV1Education>]
+        # @return [Mindee::Product::Resume::ResumeV1Educations]
         attr_reader :education
         # The email address of the candidate.
         # @return [Mindee::Parsing::Standard::StringField]
@@ -41,7 +41,7 @@ module Mindee
         # @return [Mindee::Parsing::Standard::StringField]
         attr_reader :job_applied
         # The list of languages that the candidate is proficient in.
-        # @return [Array<Mindee::Product::Resume::ResumeV1Language>]
+        # @return [Mindee::Product::Resume::ResumeV1Languages]
         attr_reader :languages
         # The ISO 3166 code for the country of citizenship of the candidate.
         # @return [Mindee::Parsing::Standard::StringField]
@@ -53,10 +53,10 @@ module Mindee
         # @return [Mindee::Parsing::Standard::StringField]
         attr_reader :profession
         # The list of the candidate's professional experiences.
-        # @return [Array<Mindee::Product::Resume::ResumeV1ProfessionalExperience>]
+        # @return [Mindee::Product::Resume::ResumeV1ProfessionalExperiences]
         attr_reader :professional_experiences
         # The list of social network profiles of the candidate.
-        # @return [Array<Mindee::Product::Resume::ResumeV1SocialNetworksUrl>]
+        # @return [Mindee::Product::Resume::ResumeV1SocialNetworksUrls]
         attr_reader :social_networks_urls
         # The list of the candidate's interpersonal and communication abilities.
         # @return [Array<Mindee::Parsing::Standard::StringField>]
@@ -68,50 +68,63 @@ module Mindee
         # @param prediction [Hash]
         # @param page_id [Integer, nil]
         def initialize(prediction, page_id)
-          super()
-          @address = StringField.new(prediction['address'], page_id)
-          @certificates = []
-          prediction['certificates'].each do |item|
-            @certificates.push(ResumeV1Certificate.new(item, page_id))
-          end
-          @document_language = StringField.new(prediction['document_language'], page_id)
-          @document_type = ClassificationField.new(prediction['document_type'], page_id)
-          @education = []
-          prediction['education'].each do |item|
-            @education.push(ResumeV1Education.new(item, page_id))
-          end
-          @email_address = StringField.new(prediction['email_address'], page_id)
-          @given_names = []
+          super
+          @address = Parsing::Standard::StringField.new(
+            prediction['address'],
+            page_id
+          )
+          @certificates = Product::Resume::ResumeV1Certificates.new(prediction['certificates'], page_id)
+          @document_language = Parsing::Standard::StringField.new(
+            prediction['document_language'],
+            page_id
+          )
+          @document_type = Parsing::Standard::ClassificationField.new(
+            prediction['document_type'],
+            page_id
+          )
+          @education = Product::Resume::ResumeV1Educations.new(prediction['education'], page_id)
+          @email_address = Parsing::Standard::StringField.new(
+            prediction['email_address'],
+            page_id
+          )
+          @given_names = [] # : Array[Parsing::Standard::StringField]
           prediction['given_names'].each do |item|
-            @given_names.push(StringField.new(item, page_id))
+            @given_names.push(Parsing::Standard::StringField.new(item, page_id))
           end
-          @hard_skills = []
+          @hard_skills = [] # : Array[Parsing::Standard::StringField]
           prediction['hard_skills'].each do |item|
-            @hard_skills.push(StringField.new(item, page_id))
-          end
-          @job_applied = StringField.new(prediction['job_applied'], page_id)
-          @languages = []
-          prediction['languages'].each do |item|
-            @languages.push(ResumeV1Language.new(item, page_id))
-          end
-          @nationality = StringField.new(prediction['nationality'], page_id)
-          @phone_number = StringField.new(prediction['phone_number'], page_id)
-          @profession = StringField.new(prediction['profession'], page_id)
-          @professional_experiences = []
-          prediction['professional_experiences'].each do |item|
-            @professional_experiences.push(ResumeV1ProfessionalExperience.new(item, page_id))
+            @hard_skills.push(Parsing::Standard::StringField.new(item, page_id))
           end
-          @social_networks_urls = []
-          prediction['social_networks_urls'].each do |item|
-            @social_networks_urls.push(ResumeV1SocialNetworksUrl.new(item, page_id))
-          end
-          @soft_skills = []
+          @job_applied = Parsing::Standard::StringField.new(
+            prediction['job_applied'],
+            page_id
+          )
+          @languages = Product::Resume::ResumeV1Languages.new(prediction['languages'], page_id)
+          @nationality = Parsing::Standard::StringField.new(
+            prediction['nationality'],
+            page_id
+          )
+          @phone_number = Parsing::Standard::StringField.new(
+            prediction['phone_number'],
+            page_id
+          )
+          @profession = Parsing::Standard::StringField.new(
+            prediction['profession'],
+            page_id
+          )
+          @professional_experiences = Product::Resume::ResumeV1ProfessionalExperiences.new(
+            prediction['professional_experiences'], page_id
+          )
+          @social_networks_urls = Product::Resume::ResumeV1SocialNetworksUrls.new(
+            prediction['social_networks_urls'], page_id
+          )
+          @soft_skills = [] # : Array[Parsing::Standard::StringField]
           prediction['soft_skills'].each do |item|
-            @soft_skills.push(StringField.new(item, page_id))
+            @soft_skills.push(Parsing::Standard::StringField.new(item, page_id))
           end
-          @surnames = []
+          @surnames = [] # : Array[Parsing::Standard::StringField]
           prediction['surnames'].each do |item|
-            @surnames.push(StringField.new(item, page_id))
+            @surnames.push(Parsing::Standard::StringField.new(item, page_id))
           end
         end
 

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

@@ -33,7 +33,7 @@ module Mindee
         # @param prediction [Hash]
         # @param page_id [Integer, nil]
         def initialize(prediction, page_id)
-          super(prediction, page_id)
+          super
           @degree_domain = prediction['degree_domain']
           @degree_type = prediction['degree_type']
           @end_month = prediction['end_month']

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

@@ -0,0 +1,64 @@
+# 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 educational background.
+      class ResumeV1Educations < Array
+        # Entries.
+        # @return [Array<ResumeV1Education>]
+        attr_reader :entries
+
+        # @param prediction [Array]
+        # @param page_id [Integer, nil]
+        def initialize(prediction, page_id)
+          entries = prediction.map do |entry|
+            Resume::ResumeV1Education.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 * 27}"
+          out_str << "+#{char * 11}"
+          out_str << "+#{char * 10}"
+          out_str << "+#{char * 27}"
+          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 << ' | Domain         '
+          out_str << ' | Degree                   '
+          out_str << ' | End Month'
+          out_str << ' | End Year'
+          out_str << ' | School                   '
+          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_language.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
           @language = prediction['language']
           @level = prediction['level']
           @page_id = page_id

data/lib/mindee/product/resume/resume_v1_languages.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 languages that the candidate is proficient in.
+      class ResumeV1Languages < Array
+        # Entries.
+        # @return [Array<ResumeV1Language>]
+        attr_reader :entries
+
+        # @param prediction [Array]
+        # @param page_id [Integer, nil]
+        def initialize(prediction, page_id)
+          entries = prediction.map do |entry|
+            Resume::ResumeV1Language.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 * 10}"
+          out_str << "+#{char * 22}"
+          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 << ' | Language'
+          out_str << ' | Level               '
+          out_str << (" |\n#{self.class.line_items_separator('=')}")
+          out_str + lines
+        end
+      end
+    end
+  end
+end

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

@@ -10,11 +10,15 @@ module Mindee
       class ResumeV1Page < Mindee::Parsing::Common::Page
         # @param prediction [Hash]
         def initialize(prediction)
-          super(prediction)
-          @prediction = ResumeV1PagePrediction.new(
-            prediction['prediction'],
-            prediction['id']
-          )
+          super
+          @prediction = if prediction['prediction'].empty?
+                          nil
+                        else
+                          ResumeV1PagePrediction.new(
+                            prediction['prediction'],
+                            prediction['id']
+                          )
+                        end
         end
       end
 

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

@@ -39,7 +39,7 @@ module Mindee
         # @param prediction [Hash]
         # @param page_id [Integer, nil]
         def initialize(prediction, page_id)
-          super(prediction, page_id)
+          super
           @contract_type = prediction['contract_type']
           @department = prediction['department']
           @description = prediction['description']

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