re-add add multi-decoding

FIXME: better error handling during multi-decoding. What if CommandLineRunner prints an exception, but it's not for the first image processed?

This mostly reverts commit 8fdfecb.

Author: dlenski

README.md

@@ -29,7 +29,7 @@ BarCode(raw='This should be QR_CODE', parsed='This should be QR_CODE', format='Q
 The attributes of the decoded `BarCode` object are `raw`, `parsed`, `format`, `type`, and `points`. The list of formats which ZXing can decode is
 [here](https://zxing.github.io/zxing/apidocs/com/google/zxing/BarcodeFormat.html).
 
-The `decode()` method accepts an image path and takes optional parameters `try_harder` (boolean) and `possible_formats` (list of formats to consider).
+The `decode()` method accepts an image path (or list of paths) and takes optional parameters `try_harder` (boolean) and `possible_formats` (list of formats to consider).
 If no barcode is found, it returns `None`, and if it encounters any other recognizable error from the Java ZXing library, it raises `BarCodeReaderException`.
 
 ## Command-line interface

test/test_all.py

@@ -39,9 +39,20 @@ def test_decoding():
             raise AssertionError('Expected {!r} but got {!r}'.format(expected_format, dec.format))
 
 
+@with_setup(setup_reader)
+def test_decoding_multiple():
+    reader = zxing.BarCodeReader()
+    filenames = [os.path.join(test_barcode_dir, filename) for filename, expected_format, expected_raw in test_barcodes]
+    for dec, (filename, expected_format, expected_raw) in zip(reader.decode(filenames), test_barcodes):
+        if dec.raw != expected_raw:
+            raise AssertionError('{}: Expected {!r} but got {!r}'.format(filename, expected_raw, dec.parsed))
+        if dec.format != expected_format:
+            raise AssertionError('{}: Expected {!r} but got {!r}'.format(filename, expected_format, dec.format))
+
+
 def test_parsing():
     dec = zxing.BarCode.parse("""
-file:default.png (format: FAKE_DATA, type: TEXT):
+file:///tmp/default.png (format: FAKE_DATA, type: TEXT):
 Raw result:
 Élan|\tthe barcode is taking off
 Parsed result:
@@ -53,6 +64,7 @@ def test_parsing():
   Point 2: (201.0,198.0)
   Point 3: (205.23952,21.0)
 """.encode())
+    assert dec.uri == 'file:///tmp/default.png'
     assert dec.format == 'FAKE_DATA'
     assert dec.type == 'TEXT'
     assert dec.raw == 'Élan|\tthe barcode is taking off'

zxing/__init__.py

@@ -31,11 +31,17 @@ def __init__(self, classpath=None, java=None):
         else:
             self.classpath = os.path.join(os.path.dirname(__file__), 'java', '*')
 
-    def decode(self, filename, try_harder=False, possible_formats=None):
+    def decode(self, filenames, try_harder=False, possible_formats=None):
         possible_formats = (possible_formats,) if isinstance(possible_formats, str) else possible_formats
 
-        file_uri = pathlib.Path(filename).absolute().as_uri()
-        cmd = [self.java, '-cp', self.classpath, self.cls, file_uri]
+        if isinstance(filenames, str):
+            one_file = True
+            filenames = filenames,
+        else:
+            one_file = False
+        file_uris = [ pathlib.Path(f).absolute().as_uri() for f in filenames ]
+
+        cmd = [self.java, '-cp', self.classpath, self.cls] + file_uris
         if try_harder:
             cmd.append('--try_harder')
         if possible_formats:
@@ -54,15 +60,33 @@ def decode(self, filename, try_harder=False, possible_formats=None):
                               b'Exception in thread "main" java.lang.NoClassDefFoundError:')):
             raise BarCodeReaderException("Java JARs not found in classpath (%s)" % self.classpath, self.classpath)
         elif stdout.startswith(b'''Exception in thread "main" javax.imageio.IIOException: Can't get input stream from URL!'''):
-            raise BarCodeReaderException("Could not find image path: %s" % filename, filename)
+            raise BarCodeReaderException("Could not find image path: %s" % filenames, filenames)
         elif stdout.startswith(b'''Exception in thread "main" java.io.IOException: Could not load '''):
-            raise BarCodeReaderException("Java library could not read image; is it in a supported format?", filename)
+            raise BarCodeReaderException("Java library could not read image; is it in a supported format?", filenames)
         elif stdout.startswith(b'''Exception '''):
             raise BarCodeReaderException("Unknown Java exception: %s" % stdout)
         elif p.returncode:
             raise BarCodeReaderException("Unexpected Java subprocess return code %d" % p.returncode, self.java)
 
-        return BarCode.parse(stdout)
+        if p.returncode:
+            codes = [ None for fn in filenames ]
+        else:
+            file_results = []
+            for line in stdout.splitlines(True):
+                if line.startswith((b'file:///',b'Exception')):
+                    file_results.append(line)
+                else:
+                    file_results[-1] += line
+            codes = [ BarCode.parse(result) for result in file_results ]
+
+        if one_file:
+            return codes[0]
+        else:
+            # zxing (insanely) randomly reorders the output blocks, so we have to put them back in the
+            # expected order, based on their URIs
+            d = {c.uri: c for c in codes}
+            return [d[f] for f in file_uris]
+
 
 class CLROutputBlock(Enum):
     UNKNOWN = 0
@@ -74,17 +98,17 @@ class BarCode(object):
     @classmethod
     def parse(cls, zxing_output):
         block = CLROutputBlock.UNKNOWN
-        format = type = None
+        uri = format = type = None
         raw = parsed = b''
         points = []
 
         for l in zxing_output.splitlines(True):
             if block==CLROutputBlock.UNKNOWN:
                 if l.endswith(b': No barcode found\n'):
                     return None
-                m = re.search(rb"format:\s*([^,]+),\s*type:\s*([^)]+)", l)
+                m = re.match(rb"(\S+) \(format:\s*([^,]+),\s*type:\s*([^)]+)\)", l)
                 if m:
-                    format, type = m.group(1).decode(), m.group(2).decode()
+                    uri, format, type = m.group(1).decode(), m.group(2).decode(), m.group(3).decode()
                 elif l.startswith(b"Raw result:"):
                     block = CLROutputBlock.RAW
             elif block==CLROutputBlock.RAW:
@@ -104,15 +128,16 @@ def parse(cls, zxing_output):
 
         raw = raw[:-1].decode()
         parsed = parsed[:-1].decode()
-        return cls(format, type, raw, parsed, points)
+        return cls(uri, format, type, raw, parsed, points)
 
-    def __init__(self, format, type, raw, parsed, points):
+    def __init__(self, uri, format, type, raw, parsed, points):
         self.raw = raw
         self.parsed = parsed
+        self.uri = uri
         self.format = format
         self.type = type
         self.points = points
 
     def __repr__(self):
-        return '{}(raw={!r}, parsed={!r}, format={!r}, type={!r}, points={!r})'.format(
-            self.__class__.__name__, self.raw, self.parsed, self.format, self.type, self.points)
+        return '{}(raw={!r}, parsed={!r}, uri={!r}, format={!r}, type={!r}, points={!r})'.format(
+            self.__class__.__name__, self.raw, self.parsed, self.uri, self.format, self.type, self.points)