invoice_extractor_arca 0.2.0

data/lib/invoice_extractor_arca/scanners/factory.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require_relative "zbar_scanner"
+require_relative "qreader_scanner"
+require_relative "scanner_chain"
+
+module InvoiceExtractorArca
+  module Scanners
+    class Factory
+      MODES = %i[
+        zbar
+        qreader
+        zbar_then_qreader
+        qreader_then_zbar
+        all
+      ].freeze
+
+      def initialize(
+        resolver:,
+        runner:,
+        python_command: :python3
+      )
+        @resolver = resolver
+        @runner = runner
+        @python_command = python_command
+      end
+
+      def build(mode)
+        normalized = normalize_mode!(mode)
+
+        case normalized
+        when :zbar
+          zbar_scanner
+        when :qreader
+          qreader_scanner
+        when :zbar_then_qreader
+          ScannerChain.new(
+            scanners: [
+              zbar_scanner,
+              qreader_scanner
+            ],
+            mode: :first_success
+          )
+        when :qreader_then_zbar
+          ScannerChain.new(
+            scanners: [
+              qreader_scanner,
+              zbar_scanner
+            ],
+            mode: :first_success
+          )
+        when :all
+          ScannerChain.new(
+            scanners: [
+              zbar_scanner,
+              qreader_scanner
+            ],
+            mode: :all
+          )
+        end
+      end
+
+      private
+
+      def normalize_mode!(mode)
+        normalized = mode.to_sym
+        return normalized if MODES.include?(normalized)
+
+        raise ArgumentError, "Invalid qr_scanner: #{mode.inspect}"
+      end
+
+      def zbar_scanner
+        ZbarScanner.new(
+          resolver: @resolver,
+          runner: @runner
+        )
+      end
+
+      def qreader_scanner
+        QreaderScanner.new(
+          resolver: @resolver,
+          runner: @runner,
+          python_command: @python_command
+        )
+      end
+    end
+  end
+end

data/lib/invoice_extractor_arca/scanners/qreader_scan.py

@@ -0,0 +1,102 @@
+#!/usr/bin/env python3
+
+import contextlib
+import json
+import sys
+
+ORIGINAL_STDOUT = sys.stdout
+
+
+def emit(payload):
+    print(json.dumps(payload), file=ORIGINAL_STDOUT)
+
+
+def warning_payload(code, message):
+    return {
+        "values": [],
+        "warnings": [
+            {
+                "code": code,
+                "message": str(message),
+            }
+        ],
+    }
+
+
+def main():
+    if len(sys.argv) != 2:
+        emit(
+            warning_payload(
+                "qreader_invalid_arguments",
+                "Expected exactly one image path argument",
+            )
+        )
+        return
+
+    image_path = sys.argv[1]
+
+    try:
+        # Keep stdout JSON-only for the Ruby bridge.
+        with contextlib.redirect_stdout(sys.stderr):
+            import cv2
+            from qreader import QReader
+    except Exception as exc:
+        emit(warning_payload("qreader_import_failed", exc))
+        return
+
+    try:
+        image_bgr = cv2.imread(image_path)
+
+        if image_bgr is None:
+            emit(
+                warning_payload(
+                    "qreader_image_read_failed",
+                    f"Could not read image: {image_path}",
+                )
+            )
+            return
+
+        image = cv2.cvtColor(image_bgr, cv2.COLOR_BGR2RGB)
+
+        with contextlib.redirect_stdout(sys.stderr):
+            qreader = QReader()
+            decoded_values = qreader.detect_and_decode(image=image)
+
+        decoded_values = decoded_values or []
+
+        values = [
+            value.strip()
+            for value in decoded_values
+            if isinstance(value, str) and value.strip()
+        ]
+
+        none_count = sum(
+            1 for value in decoded_values if value is None
+        )
+
+        warnings = []
+
+        if none_count > 0:
+            noun = "region" if none_count == 1 else "regions"
+            warnings.append(
+                {
+                    "code": "qreader_detected_undecoded",
+                    "message": (
+                        f"QReader detected {none_count} additional "
+                        f"QR-like {noun} that could not be decoded"
+                    ),
+                }
+            )
+
+        emit(
+            {
+                "values": values,
+                "warnings": warnings,
+            }
+        )
+    except Exception as exc:
+        emit(warning_payload("qreader_failed", exc))
+
+
+if __name__ == "__main__":
+    main()

data/lib/invoice_extractor_arca/scanners/qreader_scanner.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "../errors"
+
+module InvoiceExtractorArca
+  module Scanners
+    class QreaderScanner
+      attr_reader :name
+
+      DEFAULT_HELPER_PATH =
+        File.expand_path("qreader_scan.py", __dir__)
+
+      def initialize(
+        resolver:,
+        runner:,
+        python_command: :python3,
+        helper_path: DEFAULT_HELPER_PATH
+      )
+        @resolver = resolver
+        @runner = runner
+        @python_command = python_command
+        @helper_path = helper_path
+        @name = :qreader
+      end
+
+      def scan(image_path)
+        python = @resolver.resolve!(@python_command)
+
+        result =
+          @runner.run(
+            python,
+            @helper_path,
+            image_path
+          )
+
+        parsed = parse_json(result[:stdout])
+
+        warnings = normalize_warnings(parsed["warnings"], image_path)
+
+        unless result[:success]
+          warnings << {
+            code: "qreader_process_failed",
+            message: result[:stderr].to_s.strip,
+            component: "qr",
+            details: {
+              scanner: name,
+              image_file: image_path
+            }
+          }
+        end
+
+        {
+          values: normalize_values(parsed["values"]),
+          warnings: warnings
+        }
+      rescue Errors::MissingDependency => e
+        {
+          values: [],
+          warnings: [
+            {
+              code: "qreader_missing_dependency",
+              message: e.message,
+              component: "qr",
+              details: {
+                scanner: name,
+                image_file: image_path,
+                missing: e.missing
+              }
+            }
+          ]
+        }
+      rescue JSON::ParserError => e
+        {
+          values: [],
+          warnings: [
+            {
+              code: "qreader_invalid_output",
+              message: e.message,
+              component: "qr",
+              details: {
+                scanner: name,
+                image_file: image_path
+              }
+            }
+          ]
+        }
+      end
+
+      private
+
+      def parse_json(stdout)
+        text = stdout.to_s.strip
+
+        JSON.parse(text)
+      rescue JSON::ParserError
+        json_line =
+          text
+            .lines
+            .map(&:strip)
+            .reverse
+            .find { |line| line.start_with?("{") && line.end_with?("}") }
+
+        raise unless json_line
+
+        JSON.parse(json_line)
+      end
+
+      def normalize_values(values)
+        Array(values)
+          .map(&:to_s)
+          .map(&:strip)
+          .reject(&:empty?)
+      end
+
+      def normalize_warnings(warnings, image_path)
+        Array(warnings).map do |warning|
+          {
+            code: warning.fetch("code", "qreader_warning"),
+            message: warning.fetch("message", ""),
+            component: "qr",
+            details: {
+              scanner: name,
+              image_file: image_path
+            }
+          }
+        end
+      end
+    end
+  end
+end

data/lib/invoice_extractor_arca/scanners/scanner_chain.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module InvoiceExtractorArca
+  module Scanners
+    class ScannerChain
+      MODES = %i[
+        first_success
+        all
+      ].freeze
+
+      def initialize(scanners:, mode: :first_success)
+        @scanners = Array(scanners)
+        @mode = normalize_mode!(mode)
+      end
+
+      def scan(image_path)
+        case @mode
+        when :first_success
+          scan_until_values_found(image_path)
+        when :all
+          scan_all(image_path)
+        end
+      end
+
+      private
+
+      def normalize_mode!(mode)
+        normalized = mode.to_sym
+        return normalized if MODES.include?(normalized)
+
+        raise ArgumentError, "Invalid scanner chain mode: #{mode.inspect}"
+      end
+
+      def scan_until_values_found(image_path)
+        all_warnings = []
+
+        @scanners.each do |scanner|
+          result = scanner.scan(image_path)
+          all_warnings.concat(Array(result[:warnings]))
+
+          values = Array(result[:values])
+          unless values.empty?
+            return {
+              values: values,
+              warnings: all_warnings
+            }
+          end
+        end
+
+        {
+          values: [],
+          warnings: all_warnings
+        }
+      end
+
+      def scan_all(image_path)
+        values = []
+        warnings = []
+
+        @scanners.each do |scanner|
+          result = scanner.scan(image_path)
+          values.concat(Array(result[:values]))
+          warnings.concat(Array(result[:warnings]))
+        end
+
+        {
+          values: values.uniq,
+          warnings: warnings
+        }
+      end
+    end
+  end
+end

data/lib/invoice_extractor_arca/scanners/zbar_scanner.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module InvoiceExtractorArca
+  module Scanners
+    class ZbarScanner
+      attr_reader :name
+
+      def initialize(resolver:, runner:)
+        @resolver = resolver
+        @runner = runner
+        @name = :zbar
+      end
+
+      def scan(image_path)
+        zbarimg = @resolver.resolve!(:zbarimg)
+
+        result =
+          @runner.run(
+            zbarimg,
+            "--raw",
+            image_path
+          )
+
+        values =
+          result[:stdout]
+            .to_s
+            .lines
+            .map(&:strip)
+            .reject(&:empty?)
+
+        warnings = []
+
+        unless result[:success]
+          warnings << {
+            code: "zbarimg_failed",
+            message: result[:stderr].to_s.strip,
+            component: "qr",
+            details: {
+              scanner: name,
+              image_file: image_path
+            }
+          }
+        end
+
+        {
+          values: values,
+          warnings: warnings
+        }
+      end
+    end
+  end
+end