mindee-lite 5.0.0.beta1

data/lib/mindee/v1/http/endpoint.rb

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'net/http'
+require_relative '../../http/http_error_handler'
+require_relative '../../version'
+require_relative '../../http/response_validation'
+
+module Mindee
+  # Mindee internal HTTP module.
+  module V1
+    module HTTP
+      # API key's default environment key name.
+      API_KEY_ENV_NAME = 'MINDEE_API_KEY'
+      # API key's default value.
+      API_KEY_DEFAULT = nil
+
+      # Base URL default environment key name.
+      BASE_URL_ENV_NAME = 'MINDEE_BASE_URL'
+      # Base URL's default value.
+      BASE_URL_DEFAULT = 'https://api.mindee.net/v1'
+
+      # HTTP request timeout default environment key name.
+      REQUEST_TIMEOUT_ENV_NAME = 'MINDEE_REQUEST_TIMEOUT'
+      # HTTP request timeout default value.
+      TIMEOUT_DEFAULT = 120
+
+      # Default value for the user agent.
+      USER_AGENT = "mindee-api-ruby@v#{Mindee::VERSION} ruby-v#{RUBY_VERSION} #{Mindee::PLATFORM}".freeze
+
+      # Generic API endpoint for a product.
+      class Endpoint
+        # @return [String]
+        attr_reader :api_key
+        # @return [Integer]
+        attr_reader :request_timeout
+        # @return [String]
+        attr_reader :url_root
+        # @return [String]
+        attr_reader :base_url
+
+        def initialize(owner, url_name, version, api_key: '')
+          @owner = owner
+          @url_name = url_name
+          @version = version
+          @request_timeout = ENV.fetch(REQUEST_TIMEOUT_ENV_NAME, TIMEOUT_DEFAULT).to_i
+          if api_key.nil? && !ENV.fetch(API_KEY_ENV_NAME, API_KEY_DEFAULT).to_s.empty?
+            logger.debug('API key set from environment')
+          end
+          @api_key = api_key.nil? || api_key.empty? ? ENV.fetch(API_KEY_ENV_NAME, API_KEY_DEFAULT) : api_key
+          @base_url = ENV.fetch(BASE_URL_ENV_NAME, BASE_URL_DEFAULT).chomp('/')
+          @url_root = "#{@base_url}/products/#{@owner}/#{@url_name}/v#{@version}"
+        end
+
+        # Call the prediction API.
+        # @param input_source [Mindee::Input::Source::LocalInputSource, Mindee::Input::Source::URLInputSource]
+        # @param opts [ParseOptions] Parse options.
+        # @return [Array]
+        def predict(input_source, opts)
+          check_api_key
+          response = predict_req_post(
+            input_source,
+            opts
+          )
+          if !response.nil? && response.respond_to?(:body)
+            hashed_response = JSON.parse(response.body, object_class: Hash)
+            return [hashed_response, response.body] if Mindee::HTTP::ResponseValidation.valid_sync_response?(response)
+
+            Mindee::HTTP::ResponseValidation.clean_request!(response)
+          end
+
+          raise Error::MindeeError, 'Could not resolve server response.' if response.nil?
+
+          error = Mindee::HTTP::ErrorHandler.handle_error(@url_name, response)
+          raise error
+        end
+
+        # Call the prediction API.
+        # @param input_source [Mindee::Input::Source::LocalInputSource, Mindee::Input::Source::URLInputSource]
+        # @param opts [ParseOptions, Hash] Parse options.
+        # @return [Array]
+        def predict_async(input_source, opts)
+          check_api_key
+          response = document_queue_req_post(input_source, opts)
+          if !response.nil? && response.respond_to?(:body)
+            hashed_response = JSON.parse(response.body, object_class: Hash)
+            return [hashed_response, response.body] if Mindee::HTTP::ResponseValidation.valid_async_response?(response)
+
+            Mindee::HTTP::ResponseValidation.clean_request!(response)
+          end
+
+          raise Error::MindeeError, 'Could not resolve server response.' if response.nil?
+
+          raise Mindee::HTTP::ErrorHandler.handle_error(@url_name, response)
+        end
+
+        # Calls the parsed async doc.
+        # @param job_id [String]
+        # @return [Array]
+        def parse_async(job_id)
+          check_api_key
+          response = document_queue_req_get(job_id)
+          hashed_response = JSON.parse(response.body, object_class: Hash)
+          return [hashed_response, response.body] if Mindee::HTTP::ResponseValidation.valid_async_response?(response)
+
+          Mindee::HTTP::ResponseValidation.clean_request!(response)
+          error = Mindee::HTTP::ErrorHandler.handle_error(@url_name, response)
+          raise error
+        end
+
+        private
+
+        # @param input_source [Mindee::Input::Source::LocalInputSource, Mindee::Input::Source::URLInputSource]
+        # @param opts [ParseOptions] Parse options.
+        # @return [Net::HTTPResponse, nil]
+        def predict_req_post(input_source, opts)
+          uri = URI("#{@url_root}/predict")
+
+          params = {} # : Hash[String | Symbol, untyped]
+          params[:cropper] = 'true' if opts.cropper
+          params[:full_text_ocr] = 'true' if opts.full_text
+          uri.query = URI.encode_www_form(params)
+
+          headers = {
+            'Authorization' => "Token #{@api_key}",
+            'User-Agent' => USER_AGENT,
+          }
+          req = Net::HTTP::Post.new(uri, headers)
+          form_data = if input_source.is_a?(Mindee::Input::Source::URLInputSource)
+                        [['document', input_source.url]] # : Array[untyped]
+                      else
+                        [['document', *input_source.read_contents(close: opts.close_file)]] # : Array[untyped]
+                      end
+          form_data.push ['include_mvision', 'true'] if opts.all_words
+
+          req.set_form(form_data, 'multipart/form-data')
+          req['Transfer-Encoding'] = 'chunked'
+
+          Net::HTTP.start(uri.hostname, uri.port, use_ssl: true, read_timeout: @request_timeout) do |http|
+            return http.request(req)
+          end
+          raise Mindee::Error::MindeeError, 'Could not resolve server response.'
+        end
+
+        # @param input_source [Mindee::Input::Source::LocalInputSource, Mindee::Input::Source::URLInputSource]
+        # @param opts [ParseOptions] Parse options.
+        # @return [Net::HTTPResponse]
+        def document_queue_req_post(input_source, opts)
+          uri = if opts.workflow_id
+                  URI("#{@base_url}/workflows/#{opts.workflow_id}/predict_async")
+                else
+                  URI("#{@url_root}/predict_async")
+                end
+
+          params = {} # : Hash[String | Symbol, untyped]
+          params[:cropper] = 'true' if opts.cropper
+          params[:full_text_ocr] = 'true' if opts.full_text
+          params[:rag] = 'true' if opts.rag
+          uri.query = URI.encode_www_form(params)
+
+          headers = {
+            'Authorization' => "Token #{@api_key}",
+            'User-Agent' => USER_AGENT,
+          }
+          req = Net::HTTP::Post.new(uri, headers)
+          form_data = if input_source.is_a?(Mindee::Input::Source::URLInputSource)
+                        [['document', input_source.url]] # : Array[untyped]
+                      else
+                        [['document', *input_source.read_contents(close: opts.close_file)]] # : Array[untyped]
+                      end
+          form_data.push ['include_mvision', 'true'] if opts.all_words
+
+          req.set_form(form_data, 'multipart/form-data')
+          req['Transfer-Encoding'] = 'chunked'
+
+          Net::HTTP.start(uri.hostname, uri.port, use_ssl: true, read_timeout: @request_timeout) do |http|
+            return http.request(req)
+          end
+          raise Mindee::Error::MindeeError, 'Could not resolve server response.'
+        end
+
+        # @param job_id [String]
+        # @return [Net::HTTPResponse, nil]
+        def document_queue_req_get(job_id)
+          uri = URI("#{@url_root}/documents/queue/#{job_id}")
+
+          headers = {
+            'Authorization' => "Token #{@api_key}",
+            'User-Agent' => USER_AGENT,
+          }
+
+          req = Net::HTTP::Get.new(uri, headers)
+
+          response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true, read_timeout: @request_timeout) do |http|
+            http.request(req)
+          end
+
+          raise Error::MindeeError, 'Could not resolve server response.' if response.nil?
+
+          if response.code.to_i > 299 && response.code.to_i < 400
+            req = Net::HTTP::Get.new(response['location'], headers)
+            Net::HTTP.start(uri.hostname, uri.port, use_ssl: true, read_timeout: @request_timeout) do |http|
+              response = http.request(req)
+            end
+          end
+          response
+        end
+
+        # Checks API key
+        def check_api_key
+          return unless @api_key.nil? || @api_key.empty?
+
+          raise Error::MindeeAPIError,
+                "Missing API key for product \"'#{@url_name}' v#{@version}\" (belonging to \"#{@owner}\"), " \
+                "check your Client Configuration.\nYou can set this using the " \
+                "'#{HTTP::API_KEY_ENV_NAME}' environment variable."
+        end
+      end
+    end
+  end
+end

data/lib/mindee/v1/http/workflow_endpoint.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'net/http'
+require_relative '../../http/http_error_handler'
+
+module Mindee
+  module V1
+    module HTTP
+      # Handles the routing for workflow calls.
+      class WorkflowEndpoint
+        # @return [String]
+        attr_reader :api_key
+        # @return [Integer]
+        attr_reader :request_timeout
+        # @return [String]
+        attr_reader :url
+
+        def initialize(workflow_id, api_key: '')
+          @request_timeout = ENV.fetch(REQUEST_TIMEOUT_ENV_NAME, TIMEOUT_DEFAULT).to_i
+          @api_key = api_key.nil? || api_key.empty? ? ENV.fetch(API_KEY_ENV_NAME, API_KEY_DEFAULT) : api_key
+          base_url = ENV.fetch(BASE_URL_ENV_NAME, BASE_URL_DEFAULT)
+          @url = "#{base_url.chomp('/')}/workflows/#{workflow_id}/executions"
+        end
+
+        # Sends a document to the workflow.
+        # @param input_source [Mindee::Input::Source::LocalInputSource, Mindee::Input::Source::URLInputSource]
+        # @param opts [WorkflowOptions] Options to configure workflow execution behavior.
+        # @return [Array]
+        def execute_workflow(input_source, opts)
+          check_api_key
+          response = workflow_execution_req_post(input_source, opts)
+          if response.nil?
+            raise Mindee::Error::MindeeHTTPError.new(
+              { code: 0, details: 'Server response was nil.', message: 'Unknown error.' }, @url, 0
+            )
+          end
+
+          hashed_response = JSON.parse(response.body, object_class: Hash)
+          return [hashed_response, response.body] if Mindee::HTTP::ResponseValidation.valid_async_response?(response)
+
+          Mindee::HTTP::ResponseValidation.clean_request!(response)
+          error = Mindee::HTTP::ErrorHandler.handle_error(@url_name, response)
+          raise error
+        end
+
+        # @param input_source [Mindee::Input::Source::LocalInputSource, Mindee::Input::Source::URLInputSource]
+        # @param opts [WorkflowOptions] Options to configure workflow execution behavior.
+        # @return [Net::HTTPResponse, nil]
+        def workflow_execution_req_post(input_source, opts)
+          uri = URI(@url)
+          params = {} # : Hash[String | Symbol, untyped]
+          params[:full_text_ocr] = 'true' if opts.full_text
+          params[:rag] = 'true' if opts.rag
+          uri.query = URI.encode_www_form(params) if params.any?
+
+          headers = {
+            'Authorization' => "Token #{@api_key}",
+            'User-Agent' => USER_AGENT,
+          }
+          req = Net::HTTP::Post.new(uri, headers)
+          form_data = [] # : Array[untyped]
+          if input_source.is_a?(Mindee::Input::Source::URLInputSource)
+            form_data.push ['document', input_source.url]
+          else
+            form_data.push ['document', *input_source.read_contents(close: opts.close_file)]
+          end
+          form_data.push ['alias', opts.document_alias] if opts.document_alias
+          form_data.push ['public_url', opts.public_url] if opts.public_url
+          form_data.push ['priority', opts.priority.to_s] if opts.priority
+
+          req.set_form(form_data, 'multipart/form-data')
+          req['Transfer-Encoding'] = 'chunked'
+
+          response = nil
+          Net::HTTP.start(uri.hostname, uri.port, use_ssl: true, read_timeout: @request_timeout) do |http|
+            response = http.request(req)
+          end
+          response
+        end
+
+        # Checks API key
+        def check_api_key
+          return unless @api_key.nil? || @api_key.empty?
+
+          raise Error::MindeeConfigurationError, "Missing API key. Check your Client Configuration.\n" \
+                                                 "You can set this using the '#{HTTP::API_KEY_ENV_NAME}'" \
+                                                 'environment variable.'
+        end
+      end
+    end
+  end
+end

data/lib/mindee/v1/http.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative 'http/workflow_endpoint'
+require_relative 'http/endpoint'

data/lib/mindee/v1/parsing/common/api_request.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Mindee
+  module V1
+    module Parsing
+      module Common
+        # HTTP request response.
+        class ApiRequest
+          # @return [Hash]
+          attr_reader :error
+          # @return [Array<String>]
+          attr_reader :resources
+          # @return [RequestStatus, Symbol]
+          attr_reader :status
+          # @return [Integer]
+          attr_reader :status_code
+          # @return [String]
+          attr_reader :url
+
+          def initialize(server_response)
+            @error = server_response['error']
+            @resources = server_response['resources']
+
+            @status = if server_response['status'] == 'failure'
+                        RequestStatus::FAILURE
+                      elsif server_response['status'] == 'success'
+                        RequestStatus::SUCCESS
+                      else
+                        server_response['status']&.to_sym
+                      end
+            @status_code = server_response['status_code']
+            @url = server_response['url']
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mindee/v1/parsing/common/api_response.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative 'document'
+require_relative '../../../logging'
+
+module Mindee
+  module V1
+    module Parsing
+      module Common
+        # Potential values for queue in asynchronous calls.
+        module JobStatus
+          # Job is waiting.
+          WAITING = :waiting
+          # Job is processing.
+          PROCESSING = :processing
+          # Job is done.
+          COMPLETED = :completed
+          # Job failed.
+          FAILURE = :failed
+        end
+
+        # Potential values for requests.
+        module RequestStatus
+          # Failed.
+          FAILURE = :failure
+          # Success.
+          SUCCESS = :success
+        end
+
+        # Wrapper class for all predictions (synchronous and asynchronous)
+        class ApiResponse
+          # @return [Mindee::V1::Parsing::Common::Document, nil]
+          attr_reader :document
+          # @return [Mindee::V1::Parsing::Common::Job, nil]
+          attr_reader :job
+          # @return [Mindee::V1::Parsing::Common::ApiRequest]
+          attr_reader :api_request
+          # @return [String]
+          attr_reader :raw_http
+
+          # @param product_class [Mindee::Inference]
+          # @param http_response [Hash]
+          # @param raw_http [String]
+          def initialize(product_class, http_response, raw_http)
+            logger.debug('Handling API response')
+            @raw_http = raw_http
+            raise Error::MindeeAPIError, 'Invalid response format.' unless http_response.key?('api_request')
+
+            @api_request = Mindee::V1::Parsing::Common::ApiRequest.new(http_response['api_request'])
+
+            if http_response.key?('document') &&
+               (!http_response.key?('job') ||
+                 http_response['job']['status'] == 'completed') &&
+               @api_request.status == RequestStatus::SUCCESS
+              @document = Mindee::V1::Parsing::Common::Document.new(product_class, http_response['document'])
+            end
+            @job = Mindee::V1::Parsing::Common::Job.new(http_response['job']) if http_response.key?('job')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mindee/v1/parsing/common/document.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require_relative 'inference'
+require_relative 'extras'
+
+module Mindee
+  module V1
+    module Parsing
+      module Common
+        # Stores all response attributes.
+        class Document
+          # @return [Mindee::Inference]
+          attr_reader :inference
+          # @return [String] Filename sent to the API
+          attr_reader :name
+          # @return [String] Mindee ID of the document
+          attr_reader :id
+          # @return [Mindee::V1::Parsing::Common::Extras::Extras] Potential Extras fields sent back along the prediction
+          attr_reader :extras
+          # @return [Mindee::V1::Parsing::Common::OCR::OCR, nil] OCR text results (limited availability)
+          attr_reader :ocr
+          # @return [Integer] Amount of pages of the document
+          attr_reader :n_pages
+
+          # Loads the MVision OCR response.
+          # @param http_response [Hash] Full HTTP contents of the response.
+          # @return [Mindee::V1::Parsing::Common::OCR::OCR]
+          def self.load_ocr(http_response)
+            ocr_prediction = http_response.fetch('ocr', nil)
+            return nil if ocr_prediction.nil? || ocr_prediction.fetch('mvision-v1', nil).nil?
+
+            OCR::OCR.new(ocr_prediction)
+          end
+
+          # Loads extras into the document prediction.
+          # @param http_response [Hash] Full HTTP contents of the response.
+          # @return [Mindee::V1::Parsing::Common::OCR::OCR]
+          def self.extract_extras(http_response)
+            extras_prediction = http_response['inference'].fetch('extras', nil)
+            return nil if extras_prediction.nil? || extras_prediction.fetch('mvision-v1', nil).nil?
+
+            Mindee::V1::Parsing::Common::Extras::Extras.new(extras_prediction)
+          end
+
+          # @param product_class [Mindee::Inference]
+          # @param http_response [Hash]
+          def initialize(product_class, http_response)
+            @id = http_response['id']
+            @name = http_response['name']
+            @inference = product_class.new(http_response['inference'])
+            @ocr = self.class.load_ocr(http_response)
+            @extras = self.class.extract_extras(http_response)
+            inject_full_text_ocr(http_response)
+            @n_pages = http_response['n_pages']
+          end
+
+          # @return [String]
+          def to_s
+            out_str = String.new
+            out_str << "########\nDocument\n########"
+            out_str << "\n:Mindee ID: #{@id}"
+            out_str << "\n:Filename: #{@name}"
+            out_str << "\n\n#{@inference}"
+          end
+
+          private
+
+          def inject_full_text_ocr(raw_prediction)
+            return unless raw_prediction.dig('inference', 'pages', 0, 'extras', 'full_text_ocr')
+
+            full_text_ocr = String.new
+            raw_prediction.dig('inference', 'pages').each do |page|
+              full_text_ocr << page['extras']['full_text_ocr']['content']
+            end
+            artificial_text_obj = { 'content' => full_text_ocr }
+            if @extras.nil? || @extras.empty?
+              @extras = Mindee::V1::Parsing::Common::Extras::Extras.new({ 'full_text_ocr' => artificial_text_obj })
+            else
+              @extras.add_artificial_extra({ 'full_text_ocr' => artificial_text_obj })
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mindee/v1/parsing/common/execution.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Mindee
+  module V1
+    module Parsing
+      module Common
+        # Identifier for the batch to which the execution belongs.
+        class Execution
+          # Identifier for the batch to which the execution belongs.
+          # @return [String]
+          attr_reader :batch_name
+          # The time at which the execution started.
+          # @return [Time, nil]
+          attr_reader :created_at
+          # File representation within a workflow execution.
+          # @return [ExecutionFile]
+          attr_reader :file
+          # Identifier for the execution.
+          # @return [String]
+          attr_reader :id
+          # Deserialized inference object.
+          # @return [Mindee::Inference]
+          attr_reader :inference
+          # Priority of the execution.
+          # @return [ExecutionPriority, Symbol, nil]
+          attr_reader :priority
+          # The time at which the file was tagged as reviewed.
+          # @return [Time, nil]
+          attr_reader :reviewed_at
+          # The time at which the file was uploaded to a workflow.
+          # @return [Time, nil]
+          attr_reader :available_at
+          # Reviewed fields and values.
+          # @return [Mindee::V1::Product::Universal::UniversalDocument]
+          attr_reader :reviewed_prediction
+          # Execution Status.
+          # @return [String]
+          attr_reader :status
+          # Execution type.
+          # @return [String]
+          attr_reader :type
+          # The time at which the file was uploaded to a workflow.
+          # @return [Time, nil]
+          attr_reader :uploaded_at
+          # Identifier for the workflow.
+          # @return [String]
+          attr_reader :workflow_id
+
+          # rubocop:disable Metrics/CyclomaticComplexity
+
+          # @param product_class [Mindee::Inference]
+          # @param http_response [Hash]
+          def initialize(product_class, http_response)
+            @batch_name = http_response['batch_name']
+            @created_at = Time.iso8601(http_response['created_at']) if http_response['created_at']
+            @file = ExecutionFile.new(http_response['file']) if http_response['file']
+            @id = http_response['id']
+            @inference = product_class.new(http_response['inference']) if http_response['inference']
+            @priority = Mindee::V1::Parsing::Common::ExecutionPriority.to_priority(http_response['priority'])
+            @reviewed_at = Time.iso8601(http_response['reviewed_at']) if http_response['reviewed_at']
+            @available_at = Time.iso8601(http_response['available_at']) if http_response['available_at']
+            if http_response['reviewed_prediction']
+              @reviewed_prediction = Mindee::V1::Product::Universal::UniversalDocument.new(
+                http_response['reviewed_prediction']
+              )
+            end
+            @status = http_response['status']
+            @type = http_response['type']
+            @uploaded_at = Time.iso8601(http_response['uploaded_at']) if http_response['uploaded_at']
+            @workflow_id = http_response['workflow_id']
+          end
+
+          # rubocop:enable Metrics/CyclomaticComplexity
+        end
+      end
+    end
+  end
+end

data/lib/mindee/v1/parsing/common/execution_file.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Mindee
+  module V1
+    module Parsing
+      module Common
+        # Representation of a workflow execution's file data.
+        class ExecutionFile
+          # File name.
+          # @return [String]
+          attr_reader :name
+
+          # Optional alias for the file.
+          # @return [String]
+          attr_reader :alias
+
+          # @param http_response [Hash]
+          def initialize(http_response)
+            @name = http_response['name']
+            @alias = http_response['alias']
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mindee/v1/parsing/common/execution_priority.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Mindee
+  module V1
+    module Parsing
+      module Common
+        # Execution policy priority values.
+        module ExecutionPriority
+          # Low priority execution.
+          # @return [Symbol] :low
+          LOW = :low
+          # Medium priority execution.
+          # @return [Symbol] :low
+          MEDIUM = :medium
+          # High priority execution.
+          # @return [Symbol] :low
+          HIGH = :high
+
+          # Sets the priority to one of its possibly values, defaults to nil otherwise.
+          # @param [String, nil] priority_str
+          # @return [Symbol, nil]
+          def self.to_priority(priority_str)
+            return nil if priority_str.nil?
+
+            case priority_str.downcase
+            when 'low'
+              :low
+            when 'high'
+              :high
+            else
+              :medium
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mindee/v1/parsing/common/extras/cropper_extra.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative '../../standard/position_field'
+
+module Mindee
+  module V1
+    module Parsing
+      module Common
+        module Extras
+          # Contains information on the cropping of a prediction.
+          class CropperExtra
+            # Cropper extra initialization.
+            # @return [Array<Mindee::V1::Parsing::Standard::PositionField>]
+            attr_reader :croppings
+
+            def initialize(raw_prediction, page_id = nil)
+              @croppings = [] # : Array[Mindee::V1::Parsing::Standard::PositionField]
+              raw_prediction['cropping']&.each do |crop|
+                @croppings.push(Mindee::V1::Parsing::Standard::PositionField.new(crop, page_id))
+              end
+            end
+
+            # @return [String]
+            def to_s
+              @croppings.join("\n           ")
+            end
+          end
+        end
+      end
+    end
+  end
+end