invoice_extractor_arca 0.2.0

data/lib/invoice_extractor_arca/text/layout_table_parser.rb

@@ -0,0 +1,218 @@
+# frozen_string_literal: true
+
+require_relative "../error_record"
+
+module InvoiceExtractorArca
+  module Text
+    class LayoutTableParser
+      HEADERS = [
+        [:code, /C[oó]digo/i],
+        [:description, /Producto\s*\/\s*Servicio/i],
+        [:quantity, /Cantidad/i],
+        [:unit_measure, /U\.\s*Medida/i],
+        [:unit_price, /Precio\s+Unit\./i],
+        [:discount_percentage, /%\s*Bonif\.?/i],
+        [:discount_total, /Imp\.\s*Bonif\.?/i],
+        [:subtotal, /Subtotal/i]
+      ].freeze
+
+      NUMERIC_FIELDS = %i[
+        quantity
+        unit_price
+        discount_percentage
+        discount_total
+        subtotal
+      ].freeze
+
+      NUMERIC_PATTERN =
+        /\A-?\d+(?:\.\d{3})*(?:,\d+)?\z/
+
+      def initialize(value_normalizer:)
+        @value_normalizer = value_normalizer
+      end
+
+      def parse(raw)
+        lines = raw.to_s.lines.map(&:chomp)
+        header_index, positions = find_header(lines)
+
+        unless header_index
+          return failure(
+            "enrichment_service_table_not_found",
+            "Service table header was not found"
+          )
+        end
+
+        body = table_body(lines, header_index)
+
+        {
+          rows: build_rows(body, positions),
+          diagnostics: []
+        }
+      end
+
+      private
+
+      def find_header(lines)
+        lines.each_with_index do |line, index|
+          positions = header_positions(line)
+          return [index, positions] if positions
+        end
+
+        [nil, nil]
+      end
+
+      def header_positions(line)
+        positions = {}
+
+        HEADERS.each do |name, pattern|
+          match = line.match(pattern)
+          return nil unless match
+
+          positions[name] = match.begin(0)
+        end
+
+        offsets = positions.values
+        return nil unless offsets == offsets.sort
+        return nil unless offsets.uniq.length == offsets.length
+
+        positions
+      end
+
+      def table_body(lines, header_index)
+        lines[(header_index + 1)..].to_a.take_while do |line|
+          !line.match?(/^\s*Subtotal\s*:\s*\$/i) &&
+            !line.match?(/Importe\s+Otros\s+Tributos\s*:\s*\$/i) &&
+            !line.match?(/Importe\s+Total\s*:\s*\$/i)
+        end
+      end
+
+      def build_rows(lines, positions)
+        rows = []
+        current = nil
+
+        lines.each do |line|
+          cells = slice_line(line, positions)
+
+          if row_start?(cells)
+            rows << finalize_row(current) if current
+            current = cells
+          elsif current && continuation_line?(cells)
+            append_description(current, cells[:description])
+          end
+        end
+
+        rows << finalize_row(current) if current
+        rows
+      end
+
+      def slice_line(line, positions)
+        names = positions.keys
+
+        cells =
+          names.each_with_index.each_with_object({}) do |(name, index), result|
+            from = positions.fetch(name)
+            next_name = names[index + 1]
+            to = next_name ? positions.fetch(next_name) : nil
+
+            result[name] = line[from...to].to_s.rstrip
+          end
+
+        repair_description_overlap(cells)
+      end
+
+      def row_start?(cells)
+        required = %i[
+          quantity
+          unit_price
+          discount_percentage
+          discount_total
+          subtotal
+        ]
+
+        required.all? do |name|
+          numeric?(cells.fetch(name))
+        end
+      end
+
+      def continuation_line?(cells)
+        description_present = !cells[:description].to_s.strip.empty?
+
+        numeric_cells_empty =
+          NUMERIC_FIELDS.all? do |name|
+            cells.fetch(name).to_s.strip.empty?
+          end
+
+        description_present && numeric_cells_empty
+      end
+
+      def append_description(row, continuation)
+        text = continuation.to_s.strip
+        return if text.empty?
+
+        row[:description] =
+          [row[:description].to_s.strip, text]
+            .reject(&:empty?)
+            .join(" ")
+      end
+
+      def finalize_row(cells)
+        cells.each_with_object({}) do |(name, raw), row|
+          cleaned = raw.to_s.strip
+          normalized = normalize_cell(name, cleaned)
+
+          row[name] = {
+            raw: cleaned,
+            normalized: normalized,
+            source: "pdf_text",
+            method: "layout_column",
+            confidence: confidence_for(name, cleaned, normalized)
+          }
+        end
+      end
+
+      def normalize_cell(name, value)
+        return @value_normalizer.decimal(value) if NUMERIC_FIELDS.include?(name)
+
+        value
+      end
+
+      def confidence_for(name, raw, normalized)
+        return "high" unless NUMERIC_FIELDS.include?(name)
+        return "low" if raw.empty? || normalized.nil?
+
+        "high"
+      end
+
+      def numeric?(value)
+        value.to_s.strip.match?(NUMERIC_PATTERN)
+      end
+
+      def failure(code, message)
+        {
+          rows: [],
+          diagnostics: [
+            ErrorRecord.new(
+              code: code,
+              message: message,
+              severity: "warning",
+              component: "enrichment"
+            )
+          ]
+        }
+      end
+
+      def repair_description_overlap(cells)
+        code = cells[:code].to_s.strip
+        description = cells[:description].to_s
+
+        if code.match?(/\A[[:alpha:]]\z/) &&
+            description.match?(/\A[[:lower:]]/)
+          cells[:description] = "#{code}#{description}"
+          cells[:code] = ""
+        end
+
+        cells
+      end
+    end
+  end
+end

data/lib/invoice_extractor_arca/text/locale_value_normalizer.rb

@@ -0,0 +1,53 @@
+# lib/invoice_extractor_arca/text/locale_value_normalizer.rb
+# frozen_string_literal: true
+
+require "bigdecimal"
+require "date"
+
+module InvoiceExtractorArca
+  module Text
+    class LocaleValueNormalizer
+      def date(value)
+        Date.strptime(value.to_s.strip, "%d/%m/%Y").iso8601
+      rescue Date::Error
+        nil
+      end
+
+      def digits(value)
+        result = value.to_s.gsub(/\D/, "")
+        result.empty? ? nil : result
+      end
+
+      def code(value, width)
+        result = digits(value)
+        return nil unless result && result.length <= width
+
+        result.rjust(width, "0")
+      end
+
+      def decimal(value)
+        input = value.to_s.strip.delete(" ")
+        return nil unless input
+
+        normalized =
+          if input.include?(",")
+            input.delete(".").sub(",", ".")
+          else
+            input
+          end
+
+        return nil unless normalized.match?(/\A-?\d+(?:\.\d+)?\z/)
+
+        format_decimal(BigDecimal(normalized), 2)
+      end
+
+      def format_decimal(value, scale)
+        string = value.round(scale).to_s("F")
+        whole, fraction = string.split(".", 2)
+        fraction = fraction.to_s.ljust(scale, "0")[0, scale]
+
+        "#{whole}.#{fraction}"
+      end
+    end
+  end
+end

data/lib/invoice_extractor_arca/text/normalizer.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module InvoiceExtractorArca
+  module Text
+    class Normalizer
+      def normalize(text)
+        normalized =
+          text
+            .to_s
+            .encode(
+              "UTF-8",
+              invalid: :replace,
+              undef: :replace,
+              replace: ""
+            )
+            .delete("\u0000")
+            .gsub(/\r\n?/, "\n")
+            .gsub("\f", "\n\n")
+
+        normalized =
+          normalized
+            .lines
+            .map(&:rstrip)
+            .join("\n")
+            .gsub(/\n{3,}/, "\n\n")
+
+        normalized.strip
+      end
+    end
+  end
+end

data/lib/invoice_extractor_arca/validation/reconciler.rb

@@ -0,0 +1,53 @@
+# lib/invoice_extractor_arca/validation/reconciler.rb
+# frozen_string_literal: true
+
+module InvoiceExtractorArca
+  module Validation
+    class Reconciler
+      MAPPINGS = {
+        voucher_type_code: :voucher_type_code,
+        selling_point: :point_of_sale,
+        invoice_number: :voucher_number,
+        emission_date: :issued_on,
+        biller_cuit: :issuer_cuit,
+        recipient_document_type: :recipient_document_type_description,
+        recipient_document_number: :recipient_document_number,
+        total: :amount,
+        authorization_code: :authorization_code
+      }.freeze
+
+      def call(voucher:, enrichment:, parsing_warnings: [])
+        comparisons = MAPPINGS.map do |text_field, voucher_field|
+          text_value = enrichment.dig(text_field, :normalized)
+          qr_value = voucher[voucher_field]
+
+          status =
+            if text_value.nil?
+              "not_extracted"
+            elsif text_value == qr_value
+              "match"
+            else
+              "mismatch"
+            end
+
+          {
+            field: text_field.to_s,
+            status: status,
+            qr_value: qr_value,
+            text_value: text_value,
+            severity: (status == "mismatch") ? "warning" : "info"
+          }
+        end
+
+        warning =
+          parsing_warnings.any? ||
+          comparisons.any? { |comparison| comparison[:status] == "mismatch" }
+
+        {
+          status: warning ? "warning" : "ok",
+          comparisons: comparisons
+        }
+      end
+    end
+  end
+end

data/lib/invoice_extractor_arca/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module InvoiceExtractorArca
+  VERSION = "0.2.0"
+end

data/lib/invoice_extractor_arca/voucher_validator.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+require "bigdecimal"
+require "date"
+require_relative "catalogs"
+require_relative "errors"
+
+module InvoiceExtractorArca
+  class VoucherValidator
+    REQUIRED_FIELDS = %w[
+      ver
+      fecha
+      cuit
+      ptoVta
+      tipoCmp
+      nroCmp
+      importe
+      moneda
+      ctz
+      tipoDocRec
+      nroDocRec
+      tipoCodAut
+      codAut
+    ].freeze
+
+    def validate_and_normalize(original)
+      validate_hash!(original)
+      validate_required_fields!(original)
+
+      issued_on = normalize_date(original["fecha"])
+      issuer_cuit = digits(original["cuit"], expected: 11)
+      point_of_sale = normalize_code(original["ptoVta"], 5)
+      voucher_type_code = normalize_code(original["tipoCmp"], 3)
+      voucher_number = normalize_code(original["nroCmp"], 8)
+      currency_code = original["moneda"].to_s
+      recipient_document_type_code = original["tipoDocRec"].to_s
+      recipient_document_number = digits(original["nroDocRec"], max: 20)
+      authorization_code = digits(original["codAut"], expected: 14)
+
+      voucher_type_description =
+        catalog_value!(
+          Catalogs::VOUCHER_TYPES,
+          voucher_type_code,
+          "tipoCmp"
+        )
+
+      currency_description =
+        catalog_value!(
+          Catalogs::CURRENCIES,
+          currency_code,
+          "moneda"
+        )
+
+      recipient_document_type_description =
+        catalog_value!(
+          Catalogs::DOCUMENT_TYPES,
+          recipient_document_type_code,
+          "tipoDocRec"
+        )
+
+      {
+        version: normalize_version(original["ver"]),
+        issued_on: issued_on,
+        issuer_cuit: issuer_cuit,
+        point_of_sale: point_of_sale,
+        voucher_type_code: voucher_type_code,
+        voucher_type_description: voucher_type_description,
+        voucher_number: voucher_number,
+        invoice_number: "#{point_of_sale}-#{voucher_number}",
+        amount: decimal(original["importe"], scale: 2, integer_digits: 13),
+        currency_code: currency_code,
+        currency_description: currency_description,
+        exchange_rate: decimal(original["ctz"], scale: 6, integer_digits: 13),
+        recipient_document_type_code: recipient_document_type_code,
+        recipient_document_type_description: recipient_document_type_description,
+        recipient_document_number: recipient_document_number,
+        authorization_type: original["tipoCodAut"].to_s,
+        authorization_code: authorization_code
+      }
+    rescue ArgumentError => e
+      raise Errors::InvalidVoucherSchema, e.message
+    end
+
+    private
+
+    def validate_hash!(original)
+      return if original.is_a?(Hash)
+
+      raise ArgumentError, "Voucher payload must be a JSON object"
+    end
+
+    def validate_required_fields!(original)
+      missing = REQUIRED_FIELDS.reject { |field| original.key?(field) }
+      return if missing.empty?
+
+      raise ArgumentError, "Missing fields: #{missing.join(", ")}"
+    end
+
+    def normalize_version(value)
+      string = Integer(value).to_s
+      raise ArgumentError, "Invalid version" unless string.match?(/\A\d\z/)
+
+      Integer(string)
+    end
+
+    def normalize_date(value)
+      Date.iso8601(value.to_s).iso8601
+    rescue Date::Error
+      raise ArgumentError, "Invalid issue date"
+    end
+
+    def normalize_code(value, width)
+      string = Integer(value).to_s
+      raise ArgumentError, "Invalid code length" if string.length > width
+
+      string.rjust(width, "0")
+    end
+
+    def digits(value, expected: nil, max: nil)
+      string = value.to_s.gsub(/\D/, "")
+      raise ArgumentError, "Missing digits" if string.empty?
+
+      if expected && string.length != expected
+        raise ArgumentError, "Invalid digit length"
+      end
+
+      if max && string.length > max
+        raise ArgumentError, "Invalid digit length"
+      end
+
+      string
+    end
+
+    def decimal(value, scale:, integer_digits:)
+      string = value.to_s.tr(",", ".").strip
+
+      unless string.match?(/\A\d+(\.\d+)?\z/)
+        raise ArgumentError, "Invalid decimal value"
+      end
+
+      whole, fraction = string.split(".", 2)
+
+      if whole.length > integer_digits
+        raise ArgumentError, "Invalid decimal integer length"
+      end
+
+      if fraction && fraction.length > scale
+        raise ArgumentError, "Invalid decimal scale"
+      end
+
+      format_decimal(BigDecimal(string), scale)
+    end
+
+    def format_decimal(value, scale)
+      string = value.round(scale).to_s("F")
+      whole, fraction = string.split(".", 2)
+      fraction = fraction.to_s.ljust(scale, "0")[0, scale]
+
+      "#{whole}.#{fraction}"
+    end
+
+    def catalog_value!(catalog, code, field_name)
+      value = catalog[code]
+      return value unless value.nil?
+
+      raise ArgumentError, "Unknown #{field_name}: #{code}"
+    end
+  end
+end

data/lib/invoice_extractor_arca.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require "json"
+
+require_relative "invoice_extractor_arca/version"
+require_relative "invoice_extractor_arca/configuration"
+require_relative "invoice_extractor_arca/result"
+require_relative "invoice_extractor_arca/error"
+require_relative "invoice_extractor_arca/errors"
+require_relative "invoice_extractor_arca/dependencies/resolver"
+require_relative "invoice_extractor_arca/error_record"
+require_relative "invoice_extractor_arca/command_runner"
+require_relative "invoice_extractor_arca/text/locale_value_normalizer"
+require_relative "invoice_extractor_arca/text/layout_table_parser"
+require_relative "invoice_extractor_arca/text/invoice_parser"
+require_relative "invoice_extractor_arca/validation/reconciler"
+require_relative "invoice_extractor_arca/extractor"
+require_relative "invoice_extractor_arca/scanners/zbar_scanner"
+require_relative "invoice_extractor_arca/scanners/qreader_scanner"
+require_relative "invoice_extractor_arca/scanners/scanner_chain"
+require_relative "invoice_extractor_arca/scanners/factory"
+require_relative "invoice_extractor_arca/pdf/renderer"
+require_relative "invoice_extractor_arca/pdf/ocr_text_extractor"
+require_relative "invoice_extractor_arca/qr/payload_parser"
+require_relative "invoice_extractor_arca/qr/result_builder"
+require_relative "invoice_extractor_arca/qr/reader"
+require_relative "invoice_extractor_arca/qr_extractor"
+require_relative "invoice_extractor_arca/catalogs"
+require_relative "invoice_extractor_arca/voucher_validator"
+require_relative "invoice_extractor_arca/text/normalizer"
+require_relative "invoice_extractor_arca/pdf/text_extractor"
+require_relative "invoice_extractor_arca/ocr/rapidocr_text_extractor"
+require_relative "invoice_extractor_arca/cli"
+require_relative "invoice_extractor_arca/final_payload_builder"
+
+module InvoiceExtractorArca
+  IMAGE_EXTENSIONS = %w[
+    .png
+    .jpg
+    .jpeg
+    .webp
+    .bmp
+    .tif
+    .tiff
+  ].freeze
+
+  module_function
+
+  def extract(path, **options)
+    Extractor.new(**extractor_options(options)).extract(path)
+  end
+
+  def extract_pdf(path, **options)
+    validate_pdf_extension!(path)
+    extract(path, **options)
+  end
+
+  def extract_image(path, **options)
+    validate_image_extension!(path)
+    extract(path, **options)
+  end
+
+  def check_dependencies(dependency_paths: {})
+    Dependencies::Resolver.new(
+      custom_paths: dependency_paths
+    ).check_all
+  end
+
+  def check_dependencies!(dependency_paths: {})
+    Dependencies::Resolver.new(
+      custom_paths: dependency_paths
+    ).resolve_all!
+  end
+
+  def extractor_options(options)
+    allowed = %i[
+      strict
+      dependency_paths
+      page_range
+      resolution
+      multiple_qr
+      qr_scanner
+      python_command
+      resolver
+      runner
+      qr_extractor
+      voucher_validator
+      enrichment
+      text_extractor
+      invoice_parser
+      reconciler
+      image_text_extractor
+      pdf_ocr_text_extractor
+      final_payload_builder
+    ]
+
+    options.slice(*allowed)
+  end
+
+  private_class_method :extractor_options
+
+  def validate_pdf_extension!(path)
+    return if File.extname(path).downcase == ".pdf"
+
+    raise Errors::UnsupportedFileType,
+      "Expected a PDF file: #{path}"
+  end
+  private_class_method :validate_pdf_extension!
+
+  def validate_image_extension!(path)
+    return if IMAGE_EXTENSIONS.include?(File.extname(path).downcase)
+
+    raise Errors::UnsupportedFileType,
+      "Expected an image file: #{path}"
+  end
+  private_class_method :validate_image_extension!
+end

data/requirements-ocr.txt

@@ -0,0 +1,2 @@
+rapidocr==3.9.2
+onnxruntime

data/sig/invoice_extractor_arca.rbs

@@ -0,0 +1,4 @@
+module InvoiceExtractorArca
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end