Added --compress option for 'bat pack' command

This compresses all packed Blend files. Other files, as well as already-
compressed Blend files, are left as-is.

tests/test_compressor.py

@@ -0,0 +1,73 @@
+import pathlib
+import tempfile
+import shutil
+
+from blender_asset_tracer import blendfile
+from abstract_test import AbstractBlendFileTest
+
+from blender_asset_tracer import compressor
+
+
+class CompressorTest(AbstractBlendFileTest):
+    def setUp(self):
+        self.temp = tempfile.TemporaryDirectory()
+        tempdir = pathlib.Path(self.temp.name)
+        self.srcdir = tempdir / 'src'
+        self.destdir = tempdir / 'dest'
+
+        self.srcdir.mkdir()
+        self.destdir.mkdir()
+
+    def tearDown(self):
+        self.temp.cleanup()
+
+    def _test(self, filename: str, source_must_remain: bool):
+        """Do a move/copy test.
+
+        The result should be the same, regardless of whether the
+        source file was already compressed or not.
+        """
+        # Make a copy we can move around without moving the actual file in
+        # the source tree.
+        srcfile = self.srcdir / filename
+        destfile = self.destdir / filename
+        srcfile.parent.mkdir(parents=True, exist_ok=True)
+        destfile.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copy2(str(self.blendfiles / filename), str(srcfile))
+
+        if source_must_remain:
+            compressor.copy(srcfile, destfile)
+        else:
+            compressor.move(srcfile, destfile)
+
+        self.assertEqual(source_must_remain, srcfile.exists())
+        self.assertTrue(destfile.exists())
+
+        if destfile.suffix == '.blend':
+            self.bf = blendfile.BlendFile(destfile)
+            self.assertTrue(self.bf.is_compressed)
+            return
+
+        with destfile.open('rb') as infile:
+            magic = infile.read(3)
+        if destfile.suffix == '.jpg':
+            self.assertEqual(b'\xFF\xD8\xFF', magic,
+                             'Expected %s to be a JPEG' % destfile)
+        else:
+            self.assertNotEqual(b'\x1f\x8b', magic[:2],
+                                'Expected %s to be NOT compressed' % destfile)
+
+    def test_move_already_compressed(self):
+        self._test('basic_file_ñønæščii.blend', False)
+
+    def test_move_compress_on_the_fly(self):
+        self._test('basic_file.blend', False)
+
+    def test_copy_already_compressed(self):
+        self._test('basic_file_ñønæščii.blend', True)
+
+    def test_copy_compress_on_the_fly(self):
+        self._test('basic_file.blend', True)
+
+    def test_move_jpeg(self):
+        self._test('textures/Bricks/brick_dotted_04-color.jpg', False)

tests/test_pack.py

@@ -14,6 +14,7 @@ class AbstractPackTest(AbstractBlendFileTest):
     @classmethod
     def setUpClass(cls):
         super().setUpClass()
+        logging.getLogger('blender_asset_tracer.compressor').setLevel(logging.DEBUG)
         logging.getLogger('blender_asset_tracer.pack').setLevel(logging.DEBUG)
         logging.getLogger('blender_asset_tracer.blendfile.open_cached').setLevel(logging.DEBUG)
         logging.getLogger('blender_asset_tracer.blendfile.open_cached').setLevel(logging.DEBUG)
@@ -23,8 +24,6 @@ class AbstractPackTest(AbstractBlendFileTest):
         super().setUp()
         self.tdir = tempfile.TemporaryDirectory(suffix='-packtest')
         self.tpath = pathlib.Path(self.tdir.name)
-        # self.tpath = pathlib.Path('/tmp/tempdir-packtest')
-        # self.tpath.mkdir(parents=True, exist_ok=True)
 
     def tearDown(self):
         self.tdir.cleanup()
@@ -268,6 +267,38 @@ class PackTest(AbstractPackTest):
         info = infopath.open().read().splitlines(keepends=False)
         self.assertEqual(blendname, info[-1].strip())
 
+    def test_compression(self):
+        blendname = 'subdir/doubly_linked_up.blend'
+        imgfile = self.blendfiles / blendname
+
+        packer = pack.Packer(imgfile, self.blendfiles, self.tpath, compress=True)
+        packer.strategise()
+        packer.execute()
+
+        dest = self.tpath / blendname
+        self.assertTrue(dest.exists())
+        self.assertTrue(blendfile.open_cached(dest).is_compressed)
+
+        for bpath in self.tpath.rglob('*.blend'):
+            if bpath == dest:
+                # Only test files that were bundled as dependency; the main
+                # file was tested above already.
+                continue
+            self.assertTrue(blendfile.open_cached(bpath).is_compressed,
+                            'Expected %s to be compressed' % bpath)
+            break
+        else:
+            self.fail('Expected to have Blend files in the BAT pack.')
+
+        for imgpath in self.tpath.rglob('*.jpg'):
+            with imgpath.open('rb') as imgfile:
+                magic = imgfile.read(3)
+            self.assertEqual(b'\xFF\xD8\xFF', magic,
+                             'Expected %s to NOT be compressed' % imgpath)
+            break
+        else:
+            self.fail('Expected to have JPEG files in the BAT pack.')
+
 
 class ProgressTest(AbstractPackTest):
     def test_strategise(self):

tests/test_tracer.py

@@ -253,7 +253,7 @@ class DepsTest(AbstractTracerTest):
 
         reclim = sys.getrecursionlimit()
         try:
-            sys.setrecursionlimit(80)
+            sys.setrecursionlimit(100)
             # This should finish without hitting the recursion limit.
             for _ in trace.deps(infinite_bfile):
                 pass