Merge pull request #83 from pycompression/outputflag

Add flags for output to the CLI

Author: rhpvorderman

CHANGELOG.rst

@@ -10,9 +10,16 @@ Changelog
 version 0.11.0-dev
 ------------------
 In this release the ``python -m isal.igzip`` relatively slow decompression rate
-has been improved. Previously it was 19% slower than ``igzip`` when used with
-the ``-d`` flag for decompressing, now it is just 8% slower.
-
+has been improved in both speed and usability. Previously it was 19% slower
+than ``igzip`` when used with the ``-d`` flag for decompressing, now it is
+just 8% slower. Also some extra flags were added to make it easier to select
+the output file.
+
++ Prompt when an output file is overwritten with the ``python -m isal.igzip``
+  command line utility and provide the ``-f`` or ``--force`` flags to force
+  overwriting.
++ Added ``-o`` and ``--output`` flags to the ``python -m isal.igzip`` command
+  line utility to allow the user to select the destination of the output file.
 + Reverse a bug in the build system which caused some docstring and parameter
   information on ``igzip_lib`` and ``isal_zlib`` to disappear in the
   documentation and the REPL.

src/isal/igzip.py

@@ -432,8 +432,13 @@ def _argument_parser():
         dest="compress",
         const=False,
         help="Decompress the file instead of compressing.")
-    parser.add_argument("-c", "--stdout", action="store_true",
-                        help="write on standard output")
+    output_group = parser.add_mutually_exclusive_group()
+    output_group.add_argument("-c", "--stdout", action="store_true",
+                              help="write on standard output")
+    output_group.add_argument("-o", "--output",
+                              help="Write to this output file")
+    parser.add_argument("-f", "--force", action="store_true",
+                        help="Overwrite output without prompting")
     # -b flag not taken by either gzip or igzip. Hidden attribute. Above 32K
     # diminishing returns hit. _compression.BUFFER_SIZE = 8k. But 32K is about
     # ~6% faster.
@@ -448,31 +453,46 @@ def main():
 
     compresslevel = args.compresslevel or _COMPRESS_LEVEL_TRADEOFF
 
-    # Determine input file
-    if args.compress and args.file is None:
-        in_file = sys.stdin.buffer
-    elif args.compress and args.file is not None:
-        in_file = io.open(args.file, mode="rb")
-    elif not args.compress and args.file is None:
-        in_file = IGzipFile(mode="rb", fileobj=sys.stdin.buffer)
-    elif not args.compress and args.file is not None:
-        base, extension = os.path.splitext(args.file)
-        if extension != ".gz" and not args.stdout:
-            sys.exit(f"filename doesn't end in .gz: {args.file!r}. "
-                     f"Cannot determine output filename.")
-        in_file = open(args.file, "rb")
-
-    # Determine output file
-    if args.compress and (args.file is None or args.stdout):
-        out_file = IGzipFile(mode="wb", compresslevel=compresslevel,
-                             fileobj=sys.stdout.buffer)
-    elif args.compress and args.file is not None:
-        out_file = open(args.file + ".gz", mode="wb",
-                        compresslevel=compresslevel)
-    elif not args.compress and (args.file is None or args.stdout):
-        out_file = sys.stdout.buffer
-    elif not args.compress and args.file is not None:
-        out_file = io.open(base, "wb")
+    if args.output:
+        out_filepath = args.output
+    elif args.stdout:
+        out_filepath = None  # to stdout
+    elif args.file is None:
+        out_filepath = None  # to stout
+    else:
+        if args.compress:
+            out_filepath = args.file + ".gz"
+        else:
+            out_filepath, extension = os.path.splitext(args.file)
+            if extension != ".gz" and not args.stdout:
+                sys.exit(f"filename doesn't end in .gz: {args.file!r}. "
+                         f"Cannot determine output filename.")
+    if out_filepath is not None and not args.force:
+        if os.path.exists(out_filepath):
+            yes_or_no = input(f"{out_filepath} already exists; "
+                              f"do you wish to overwrite (y/n)?")
+            if yes_or_no not in {"y", "Y", "yes"}:
+                sys.exit("not overwritten")
+
+    if args.compress:
+        if args.file is None:
+            in_file = sys.stdin.buffer
+        else:
+            in_file = io.open(args.file, mode="rb")
+        if out_filepath is not None:
+            out_file = open(out_filepath, "wb", compresslevel=compresslevel)
+        else:
+            out_file = IGzipFile(mode="wb", fileobj=sys.stdout.buffer,
+                                 compresslevel=compresslevel)
+    else:
+        if args.file:
+            in_file = open(args.file, mode="rb")
+        else:
+            in_file = IGzipFile(mode="rb", fileobj=sys.stdin.buffer)
+        if out_filepath is not None:
+            out_file = io.open(out_filepath, mode="wb")
+        else:
+            out_file = sys.stdout.buffer
 
     global READ_BUFFER_SIZE
     READ_BUFFER_SIZE = args.buffer_size

tests/test_igzip.py

@@ -150,6 +150,90 @@ def test_compress_infile_stdout(capsysbinary, tmp_path):
     assert err == b''
 
 
+def test_decompress_infile_out_file(tmp_path, capsysbinary):
+    test_gz = tmp_path / "test.gz"
+    test_gz.write_bytes(gzip.compress(DATA))
+    out_file = tmp_path / "out"
+    sys.argv = ['', '-d', '-o', str(out_file), str(test_gz)]
+    igzip.main()
+    out, err = capsysbinary.readouterr()
+    assert out_file.read_bytes() == DATA
+    assert err == b''
+    assert out == b''
+
+
+def test_compress_infile_out_file(tmp_path, capsysbinary):
+    test = tmp_path / "test"
+    test.write_bytes(DATA)
+    out_file = tmp_path / "compressed.gz"
+    sys.argv = ['', '-o', str(out_file), str(test)]
+    igzip.main()
+    out, err = capsysbinary.readouterr()
+    assert gzip.decompress(out_file.read_bytes()) == DATA
+    assert err == b''
+    assert out == b''
+
+
+def test_compress_infile_out_file_force(tmp_path, capsysbinary):
+    test = tmp_path / "test"
+    test.write_bytes(DATA)
+    out_file = tmp_path / "compressed.gz"
+    out_file.touch()
+    sys.argv = ['', '-f', '-o', str(out_file), str(test)]
+    igzip.main()
+    out, err = capsysbinary.readouterr()
+    assert gzip.decompress(out_file.read_bytes()) == DATA
+    assert err == b''
+    assert out == b''
+
+
+def test_compress_infile_out_file_prompt(tmp_path, capsysbinary):
+    test = tmp_path / "test"
+    test.write_bytes(DATA)
+    out_file = tmp_path / "compressed.gz"
+    out_file.touch()
+    sys.argv = ['', '-o', str(out_file), str(test)]
+    with pytest.raises(EOFError):
+        # EOFError because prompt cannot be answered non-interactively.
+        igzip.main()
+    out, err = capsysbinary.readouterr()
+    assert b"compressed.gz already exists; do you wish to overwrite (y/n)?" \
+           in out
+
+
+def test_compress_infile_out_file_inmplicit_name_prompt_refuse(
+        tmp_path, capsysbinary):
+    test = tmp_path / "test"
+    test.write_bytes(DATA)
+    out_file = tmp_path / "test.gz"
+    out_file.touch()
+    sys.argv = ['', str(test)]
+    mock_stdin = io.BytesIO(b"n")
+    sys.stdin = io.TextIOWrapper(mock_stdin)
+    with pytest.raises(SystemExit) as error:
+        igzip.main()
+    error.match("not overwritten")
+    out, err = capsysbinary.readouterr()
+    assert b"test.gz already exists; do you wish to overwrite (y/n)?" \
+           in out
+
+
+def test_compress_infile_out_file_inmplicit_name_prompt_accept(
+        tmp_path, capsysbinary):
+    test = tmp_path / "test"
+    test.write_bytes(DATA)
+    out_file = tmp_path / "test.gz"
+    out_file.touch()
+    sys.argv = ['', str(test)]
+    mock_stdin = io.BytesIO(b"y")
+    sys.stdin = io.TextIOWrapper(mock_stdin)
+    igzip.main()
+    out, err = capsysbinary.readouterr()
+    assert gzip.decompress(out_file.read_bytes()) == DATA
+    assert b"already exists; do you wish to overwrite" in out
+    assert err == b""
+
+
 def test_decompress():
     assert igzip.decompress(COMPRESSED_DATA) == DATA