#!/usr/bin/env python # # Copyright (c) 2011-2025, Ryan Galloway (ryan@rsgalloway.com) # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions are met: # # - Redistributions of source code must retain the above copyright notice, # this list of conditions and the following disclaimer. # # - Redistributions in binary form must reproduce the above copyright notice, # this list of conditions and the following disclaimer in the documentation # and/or other materials provided with the distribution. # # - Neither the name of the software nor the names of its contributors # may be used to endorse or promote products derived from this software # without specific prior written permission. # # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" # AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE # IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE # ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE # LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR # CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF # SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS # INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN # CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) # ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE # POSSIBILITY OF SUCH DAMAGE. # __doc__ = """ Contains tests for the pyseq package. """ import os import re import random import unittest import subprocess import sys import time sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) from pyseq import Item, Sequence, diff, uncompress, get_sequences from pyseq import SequenceError from pyseq import seq as pyseq pyseq.default_format = "%h%r%t" class ItemTestCase(unittest.TestCase): """tests the Item class""" def setUp(self): """set up the test""" self.test_path = os.path.abspath( os.path.join( os.sep, "mnt", "S", "Some", "Path", "to", "a", "file", "with", "numbers", "file.0010.exr", ) ) def test_initializing_with_a_string(self): """testing if initializing an Item with a string showing the path of a file is working properly """ i = Item(self.test_path) self.assertTrue(isinstance(i, Item)) def test_path_attribute_is_working_properly(self): """testing if the path attribute is working properly""" i = Item(self.test_path) self.assertEqual(self.test_path, i.path) def test_path_attribute_is_read_only(self): """testing if the path attribute is read only""" i = Item(self.test_path) with self.assertRaises(AttributeError) as cm: setattr(i, "path", "some value") self.assertEqual(str(cm.exception), "can't set attribute") def test_name_attribute_is_working_properly(self): """testing if the name attribute is working properly""" i = Item(self.test_path) self.assertEqual(i.name, "file.0010.exr") def test_name_attribute_is_read_only(self): """testing if the name attribute is read only""" i = Item(self.test_path) with self.assertRaises(AttributeError) as cm: setattr(i, "name", "some value") self.assertEqual(str(cm.exception), "can't set attribute") def test_dirname_attribute_is_working_properly(self): """testing if the dirname attribute is working properly""" i = Item(self.test_path) self.assertEqual(i.dirname, os.path.dirname(self.test_path)) def test_dirname_attribute_is_read_only(self): """testing if the dirname attribute is read only""" i = Item(self.test_path) with self.assertRaises(AttributeError) as cm: setattr(i, "dirname", "some value") self.assertEqual(str(cm.exception), "can't set attribute") def test_digits_attribute_is_working_properly(self): """testing if the digits attribute is working properly""" i = Item(self.test_path) self.assertEqual(i.digits, ["0010"]) def test_digits_attribute_is_read_only(self): """testing if the digits attribute is read only""" i = Item(self.test_path) with self.assertRaises(AttributeError) as cm: setattr(i, "digits", "some value") self.assertEqual(str(cm.exception), "can't set attribute") def test_parts_attribute_is_working_properly(self): """testing if the parts attribute is working properly""" i = Item(self.test_path) self.assertEqual(i.parts, ["file.", ".exr"]) def test_parts_attribute_is_read_only(self): """testing if the parts attribute is read only""" i = Item(self.test_path) with self.assertRaises(AttributeError) as cm: setattr(i, "parts", "some value") self.assertEqual(str(cm.exception), "can't set attribute") def test_is_sibling_method_is_working_properly(self): """testing if the is_sibling() is working properly""" item1 = Item("/mnt/S/Some/Path/to/a/file/with/numbers/file.0010.exr") item2 = Item("/mnt/S/Some/Path/to/a/file/with/numbers/file.0101.exr") self.assertTrue(item1.is_sibling(item2)) self.assertTrue(item2.is_sibling(item1)) class SequenceTestCase(unittest.TestCase): """tests the pyseq""" def setUp(self): """set the test up""" self.files = ["file.0001.jpg", "file.0002.jpg", "file.0003.jpg"] def test_from_list(self): """testing if Sequence instance can be initialized with a list of file names """ seq = Sequence(self.files) self.assertEqual(str(seq), "file.1-3.jpg") def test_appending_a_new_file(self): """testing if it is possible to append a new item to the list by giving the file name """ seq = Sequence(self.files) test_file = "file.0006.jpg" seq.append(test_file) self.assertTrue(seq.contains("file.0005.jpg")) self.assertTrue(seq.contains(test_file)) self.assertFalse(seq.contains("file.0015.jpg")) def test___setitem__(self): s = Sequence(["file.01.ext", "file.05.ext"]) s[1] = "file.02.ext" self.assertEqual(len(s), 2) self.assertEqual(s[0], Item("file.01.ext")) self.assertEqual(s[1], Item("file.02.ext")) self.assertRaises(SequenceError, s.__setitem__, 0, "item.1.ext") def test___add__(self): s = Sequence(["file.01.ext"]) ns = s + Item("file.02.ext") self.assertEqual(len(ns), 2) self.assertEqual(ns[0], s[0]) self.assertEqual(ns[1], Item("file.02.ext")) self.assertEqual(len(s), 1) ns = s + "file.02.ext" self.assertEqual(len(ns), 2) self.assertEqual(ns[0], s[0]) self.assertEqual(ns[1], Item("file.02.ext")) self.assertEqual(len(s), 1) ns = s + ["file.02.ext"] self.assertEqual(len(ns), 2) self.assertEqual(ns[0], s[0]) self.assertEqual(ns[1], Item("file.02.ext")) self.assertEqual(len(s), 1) ns = s + Sequence(["file.02.ext"]) self.assertEqual(len(ns), 2) self.assertEqual(ns[0], s[0]) self.assertEqual(ns[1], Item("file.02.ext")) self.assertEqual(len(s), 1) self.assertRaises(SequenceError, s.__add__, "item.01.ext") self.assertRaises(TypeError, s.__add__, 1) def test___iadd__(self): s = Sequence(["file.01.ext"]) s += Item("file.02.ext") self.assertEqual(len(s), 2) self.assertEqual(s[0], s[0]) self.assertEqual(s[1], Item("file.02.ext")) s = Sequence(["file.01.ext"]) s += "file.02.ext" self.assertEqual(len(s), 2) self.assertEqual(s[0], s[0]) self.assertEqual(s[1], Item("file.02.ext")) s = Sequence(["file.01.ext"]) s += ["file.02.ext"] self.assertEqual(len(s), 2) self.assertEqual(s[0], s[0]) self.assertEqual(s[1], Item("file.02.ext")) s = Sequence(["file.01.ext"]) s += Sequence(["file.02.ext"]) self.assertEqual(len(s), 2) self.assertEqual(s[0], s[0]) self.assertEqual(s[1], Item("file.02.ext")) def test___setslice___(self): s = Sequence(["file.001.ext"]) s[1:2] = "file.002.ext" self.assertEqual(len(s), 2) self.assertEqual(s[0], Item("file.001.ext")) self.assertEqual(s[1], Item("file.002.ext")) s = Sequence(["file.001.ext"]) s[1:2] = Item("file.002.ext") self.assertEqual(len(s), 2) self.assertEqual(s[0], Item("file.001.ext")) self.assertEqual(s[1], Item("file.002.ext")) s = Sequence(["file.001.ext"]) s[1:2] = [Item("file.002.ext")] self.assertEqual(len(s), 2) self.assertEqual(s[0], Item("file.001.ext")) self.assertEqual(s[1], Item("file.002.ext")) s = Sequence(["file.001.ext"]) s[1:2] = Sequence([Item("file.002.ext")]) self.assertEqual(len(s), 2) self.assertEqual(s[0], Item("file.001.ext")) self.assertEqual(s[1], Item("file.002.ext")) self.assertRaises(SequenceError, s.__setslice__, 1, 2, "item.001.ext") def test_insert(self): s = Sequence(["file.001.ext"]) s.insert(0, "file.002.ext") self.assertEqual(len(s), 2) self.assertEqual(s[0], Item("file.002.ext")) self.assertEqual(s[1], Item("file.001.ext")) self.assertRaises(SequenceError, s.insert, 1, "item") def test_extend(self): s = Sequence(["file.001.ext"]) s.extend(["file.002.ext", "file.003.ext"]) self.assertEqual(len(s), 3) self.assertEqual(s[0], Item("file.001.ext")) self.assertEqual(s[1], Item("file.002.ext")) self.assertEqual(s[2], Item("file.003.ext")) self.assertRaises(SequenceError, s.extend, ["item"]) def test_includes_is_working_properly(self): """testing if Sequence.includes() method is working properly""" seq = Sequence(self.files) self.assertTrue(seq.includes("file.0009.jpg")) self.assertFalse(seq.includes("file.0009.pic")) def test_contains_is_working_properly(self): """test if Sequence.contains() method is working properly""" seq = Sequence(self.files) self.assertFalse(seq.contains("file.0009.jpg")) self.assertFalse(seq.contains("file.0009.pic")) def test_format_is_working_properly_1(self): """test if format is working properly""" seq = Sequence(self.files) seq.append("file.0006.jpg") self.assertEqual(seq.format("%h%p%t %r (%R)"), "file.%04d.jpg 1-6 ([1-3, 6])") def test_format_is_working_properly_2(self): """test if format is working properly""" seq = Sequence(self.files) seq.append("file.0006.jpg") self.assertEqual( "file.0001-0006.jpg", seq.format("%h%04s-%04e%t"), ) self.assertEqual( "file. 1- 6.jpg", seq.format("%h%4s-%4e%t"), ) def test_format_is_working_properly_3(self): """test if format is working properly""" seq = Sequence(self.files) seq.append("file.0006.jpg") seq.append("file.0010.jpg") self.assertEqual( seq.format("%h%p%t %r (missing %M)"), "file.%04d.jpg 1-10 (missing [4-5, 7-9])", ) def test_format_directory_attribute(self): dir_name = os.path.dirname(self.files[0]) + os.sep seq = Sequence(self.files) self.assertEqual(seq.format("%D"), dir_name) def test__get_missing(self): """test that _get_missing works""" # Can't initialize Sequence without an item # seq = Sequence([]) # self.assertEqual(seq._get_missing(), []) seq = Sequence(["file.00010.jpg"]) self.assertEqual(seq._get_missing(), []) seq = Sequence(self.files) seq.append("file.0006.jpg") self.assertEqual(seq._get_missing(), [4, 5]) seq = Sequence(["file.%04d.jpg" % i for i in range(20)]) seq.pop(10) seq.pop(10) seq.pop(10) seq.pop(14) seq.pop(14) missing = [10, 11, 12, 17, 18] self.assertEqual(seq._get_missing(), missing) missing = [] seq = Sequence(["file.0001.jpg"]) for i in range(2, 50): if random.randint(0, 1) == 1: seq.append("file.%04d.jpg" % i) else: missing.append(i) # remove ending random frames while missing[-1] > int(re.search(r"file\.(\d{4})\.jpg", seq[-1]).group(1)): missing.pop(-1) self.assertEqual(seq._get_missing(), missing) class PadSizeTestCase(unittest.TestCase): def test_padsize_with_default_padding(self): item = Item("file.001.exr") frame = "001" expected_padsize = 3 result = pyseq.padsize(item, frame) self.assertEqual(result, expected_padsize) def test_padsize_with_custom_padding(self): item = Item("file.001001.exr") frame = "001001" expected_padsize = 6 result = pyseq.padsize(item, frame) self.assertEqual(result, expected_padsize) def test_padsize_with_no_padding(self): item = Item("file.9.jpg") frame = "9" expected_padsize = 0 result = pyseq.padsize(item, frame) self.assertEqual(result, expected_padsize) def test_padsize_with_strict_padding_disabled(self): pyseq.strict_pad = False item = Item("file.9.jpg") frame = "9" expected_padsize = 0 result = pyseq.padsize(item, frame) self.assertEqual(result, expected_padsize) def test_padsize_with_strict_padding_enabled(self): pyseq.strict_pad = True item = Item("file.09.jpg") frame = "09" expected_padsize = 2 result = pyseq.padsize(item, frame) self.assertEqual(result, expected_padsize) class HelperFunctionsTestCase(unittest.TestCase): """tests the helper functions like pyseq.diff() pyseq.uncompress() pyseq.get_sequences() """ def test_diff_is_working_properly_1(self): """testing if diff is working properly""" self.assertEqual( diff("file01_0040.rgb", "file01_0041.rgb"), [{"frames": ("0040", "0041"), "start": 7, "end": 11}], ) def test_diff_is_working_properly_2(self): """testing if diff is working properly""" self.assertEqual( diff("file3.03.rgb", "file4.03.rgb"), [{"frames": ("3", "4"), "start": 4, "end": 5}], ) def test_uncompress_is_working_properly_1(self): """testing if uncompress is working properly""" seq = uncompress("./tests/files/012_vb_110_v001.%04d.png 1-10", fmt="%h%p%t %r") self.assertEqual("012_vb_110_v001.1-10.png", str(seq)) self.assertEqual(10, len(seq)) def test_uncompress_is_working_properly_2(self): """testing if uncompress is working properly""" seq2 = uncompress("./tests/files/a.%03d.tga [1-3, 10, 12-14]", fmt="%h%p%t %R") self.assertEqual("a.1-14.tga", str(seq2)) self.assertEqual(7, len(seq2)) def test_uncompress_is_working_properly_3(self): """testing if uncompress is working properly""" seq3 = uncompress("a.%03d.tga 1-14 ([1-3, 10, 12-14])", fmt="%h%p%t %r (%R)") self.assertEqual("a.1-14.tga", str(seq3)) self.assertEqual(7, len(seq3)) def test_uncompress_is_working_properly_4(self): """testing if uncompress is working properly""" seq4 = uncompress("a.%03d.tga 1-14 ([1-3, 10, 12-14])", fmt="%h%p%t %s-%e (%R)") self.assertEqual("a.1-14.tga", str(seq4)) def test_uncompress_is_working_properly_5(self): """testing if uncompress is working properly""" seq5 = uncompress("a.%03d.tga 1-14 [1-14]", fmt="%h%p%t %r %R") self.assertEqual("a.1-14.tga", str(seq5)) self.assertEqual(14, len(seq5)) def test_uncompress_is_working_properly_6(self): """testing if uncompress is working properly""" seq6 = uncompress("a.%03d.tga 1-14 ([1-14])", fmt="%h%p%t %r (%R)") self.assertEqual("a.1-14.tga", str(seq6)) self.assertEqual(14, len(seq6)) def test_uncompress_is_working_properly_7(self): """testing if uncompress is working properly, the frame 100000 does not fit inside the pad length """ # enable strict pad checking pyseq.strict_pad = True seq7 = uncompress("a.%03d.tga 1-100000 ([1-10, 100000])", fmt="%h%p%t %r (%R)") self.assertEqual("a.1-10.tga", str(seq7)) self.assertEqual(10, len(seq7)) # disable strict pad checking pyseq.strict_pad = False seq7 = uncompress("a.%03d.tga 1-100000 ([1-10, 100000])", fmt="%h%p%t %r (%R)") self.assertEqual("a.1-100000.tga", str(seq7)) self.assertEqual(11, len(seq7)) def test_uncompress_is_working_properly_8(self): """testing if uncompress is working properly""" seq8 = uncompress("a.%03d.tga 1-100 ([10, 20, 40, 50])", fmt="%h%p%t %r (%m)") self.assertEqual("a.1-100.tga", str(seq8)) self.assertEqual(96, len(seq8)) def test_get_sequences_is_working_properly_1(self): """testing if get_sequences is working properly""" seqs = get_sequences("./files/") expected_results = [ "012_vb_110_v001.1-10.png", "012_vb_110_v002.1-10.png", "a.1-14.tga", "alpha.txt", "bnc01_TinkSO_tx_0_ty_0.101-105.tif", "bnc01_TinkSO_tx_0_ty_1.101-105.tif", "bnc01_TinkSO_tx_1_ty_0.101-105.tif", "bnc01_TinkSO_tx_1_ty_1.101-105.tif", "file.1-2.tif", "file.info.03.rgb", "file01.1-4.j2k", "file01_40-43.rgb", "file02_44-47.rgb", "file1-4.03.rgb", "fileA.1-3.jpg", "fileA.1-3.png", "file_02.tif", "z1_001_v1.1-4.png", "z1_002_v1.1-4.png", "z1_002_v2.1-4.png", ] for seq, expected_result in zip(seqs, expected_results): self.assertEqual(expected_result, str(seq)) def test_get_sequences_is_working_properly_2(self): """testing if get_sequences is working properly""" seqs = get_sequences(["fileA.1.rgb", "fileA.2.rgb", "fileB.1.rgb"]) expected_results = ["fileA.1-2.rgb", "fileB.1.rgb"] for seq, expected_result in zip(seqs, expected_results): self.assertEqual(expected_result, str(seq)) def test_get_sequences_is_working_properly_3(self): """testing if get_sequences is working properly""" seqs = get_sequences("./tests/files/bnc*") expected_results = [ "bnc01_TinkSO_tx_0_ty_0.%04d.tif 101-105", "bnc01_TinkSO_tx_0_ty_1.%04d.tif 101-105", "bnc01_TinkSO_tx_1_ty_0.%04d.tif 101-105", "bnc01_TinkSO_tx_1_ty_1.%04d.tif 101-105", ] for seq, expected_result in zip(seqs, expected_results): self.assertEqual(expected_result, seq.format("%h%p%t %r")) class LSSTestCase(unittest.TestCase): """Tests lss command""" def run_command(self, *args): """a simple wrapper for subprocess.Popen""" process = subprocess.Popen( args, stdout=subprocess.PIPE, universal_newlines=True ) stdout, _ = process.communicate() return stdout def setUp(self): """ """ self.maxDiff = None self.here = os.path.dirname(__file__) self.lss = os.path.realpath( os.path.join(os.path.dirname(self.here), "lib", "pyseq", "lss.py") ) def test_lss_is_working_properly_1(self): """testing if the lss command is working properly. Assumes strict pad is disabled.""" test_files = os.path.join(os.path.dirname(os.path.realpath(__file__)), "files") result = self.run_command(self.lss, test_files) self.assertEqual( """ 10 012_vb_110_v001.%04d.png [1-10] 10 012_vb_110_v002.%04d.png [1-10] 7 a.%03d.tga [1-3, 10, 12-14] 1 alpha.txt 5 bnc01_TinkSO_tx_0_ty_0.%04d.tif [101-105] 5 bnc01_TinkSO_tx_0_ty_1.%04d.tif [101-105] 5 bnc01_TinkSO_tx_1_ty_0.%04d.tif [101-105] 5 bnc01_TinkSO_tx_1_ty_1.%04d.tif [101-105] 4 file.%02d.tif [1-2, 98-99] 1 file.info.03.rgb 3 file01.%03d.j2k [1-2, 4] 4 file01_%04d.rgb [40-43] 4 file02_%04d.rgb [44-47] 4 file%d.03.rgb [1-4] 3 fileA.%04d.jpg [1-3] 3 fileA.%04d.png [1-3] 1 file_02.tif 4 z1_001_v1.%d.png [1-4] 4 z1_002_v1.%d.png [1-4] 4 z1_002_v2.%d.png [9-12] """, result, ) class PerformanceTests(unittest.TestCase): """tests the performance of pyseq""" def test_performance_1(self): """tests performance for single 10k frame sequence""" files = ["file.%03d.jpg" % i for i in range(1, 10000)] s = time.time() seq = Sequence(files) e = time.time() total_time = e - s print("time taken to create sequence: %s" % (total_time)) self.assertEqual(str(seq), "file.1-9999.jpg") self.assertEqual(len(seq), 9999) self.assertTrue(total_time < 0.1) class TestIssues(unittest.TestCase): """tests reported issues on github""" def test_issue_60(self): """tests issue 60. with strict padding disabled, padding should be %d""" # disable strict padding pyseq.strict_pad = False items = [ "file.7.jpg", "file.8.jpg", "file.9.jpg", "file.10.jpg", "file.11.jpg", "file.12.jpg", "file.87.jpg", "file.99.jpg", "file.111.jpg", ] seq = pyseq.get_sequences(items)[0] self.assertEqual(len(items), len(seq)) self.assertEqual(seq._get_padding(), "%d") items = [ "file.7.jpg", "file.8.jpg", "file.9.jpg", "file.10.jpg", "file.11.jpg", "file.12.jpg", ] seq = pyseq.get_sequences(items)[0] self.assertEqual(len(items), len(seq)) self.assertEqual(seq._get_padding(), "%d") seq = pyseq.get_sequences( [ "file.1.jpg", "file.100.jpg", "file.101.jpg", ] )[0] self.assertEqual(len(seq), 3) self.assertEqual(seq._get_padding(), "%d") seq = pyseq.get_sequences( [ "file.10.jpg", "file.11.jpg", "file.12.jpg", ] )[0] self.assertEqual(len(seq), 3) self.assertEqual(seq._get_padding(), "%d") seq = pyseq.get_sequences( [ "file.100.jpg", "file.101.jpg", "file.102.jpg", ] )[0] self.assertEqual(len(seq), 3) self.assertEqual(seq._get_padding(), "%d") seq = pyseq.get_sequences( [ "file.9.jpg", "file.99.jpg", "file.999.jpg", "file.9999.jpg", ] )[0] self.assertEqual(len(seq), 4) self.assertEqual(seq._get_padding(), "%d") seq = pyseq.get_sequences( [ "file.007.jpg", "file.010.jpg", "file.101.jpg", ] )[0] self.assertEqual(len(seq), 3) self.assertEqual(seq._get_padding(), "%03d") # revert to strict pyseq.strict_pad = True seq = pyseq.get_sequences( [ "file.007.jpg", "file.010.jpg", "file.101.jpg", ] )[0] self.assertEqual(len(seq), 3) self.assertEqual(seq._get_padding(), "%03d") def test_issue_67(self): """tests issue 67. hangs on many of missing frames.""" def get_range(frames): return range(frames[0], frames[-1] + 1) # test with strict padding disabled pyseq.strict_pad = False # normal test case (missing frame count w/i tolerance) files = [ "image-1.jpg", "image-383.jpg", "image-844.jpg", "image-2500.jpg", "image-4529.jpg", "image-5000.jpg", ] seqs = get_sequences(files) self.assertEqual(len(seqs), 1) self.assertEqual(len(seqs[0]), len(files)) frames = seqs[0].frames() missing = seqs[0]._get_missing() self.assertEqual(len(frames), len(files)) self.assertEqual(len(missing), 5000 - len(files)) # high missing frame count test 1 files = ["image-1.jpg", "image-1000.jpg", "image-50000000.jpg"] seqs = get_sequences(files) self.assertEqual(len(seqs), 1) frames = seqs[0].frames() missing = seqs[0]._get_missing() self.assertEqual(len(frames), len(files)) r = get_range(frames) self.assertEqual(len(r), 50000000) self.assertTrue(len(missing), 2) # <-- diff behavior: len is num. ranges self.assertEqual(missing[0][0], 2) self.assertEqual(missing[0][-1], 999) self.assertEqual(missing[1][0], 1001) self.assertEqual(missing[1][-1], 49999999) self.assertEqual(seqs[0].format(), " 3 image-%d.jpg [1, 1000, 50000000]") self.assertEqual(seqs[0].format("%M"), "[2-999, 1001-49999999, ]") # test with strict padding enabled pyseq.strict_pad = True # high missing frame count test 2 files = ["image-100000000-2048x2048.jpg", "image-500000000-2048x2048.jpg"] seqs = get_sequences(files) self.assertEqual(len(seqs), 1) frames = seqs[0].frames() self.assertEqual(len(frames), 2) r = get_range(frames) self.assertEqual(len(r), 400000001) missing = seqs[0]._get_missing() self.assertTrue(len(missing), 5000000) self.assertEqual(missing[0][0], 100000001) self.assertEqual(missing[0][-1], 499999999) self.assertEqual( seqs[0].format(), " 2 image-%09d-2048x2048.jpg [100000000, 500000000]" ) self.assertEqual(seqs[0].format("%M"), "[100000001-499999999, ]") # high missing frame count test 3 (from the issue) files = [ "file-1364769281-2048x2048.jpg", "file-530573048-2048x2048.jpg", "file-1127718214-2048x2048.jpg", "file-470543560-2048x2048.jpg", "file-155374807-2048x2048.jpg", "file-1182189546-2048x2048.jpg", "file-157742535-2048x2048.jpg", ] seqs = get_sequences(files) self.assertEqual(len(seqs), 2) # files with frame padding=10 self.assertEqual(seqs[0].frames(), [1127718214, 1182189546, 1364769281]) # frame ranges are in the millions frames = seqs[0].frames() r = get_range(frames) self.assertEqual(len(r), 237051068) frames = seqs[1].frames() r = get_range(frames) self.assertEqual(len(r), 375198242) # files with frame padding=9 self.assertEqual(seqs[1].frames(), [155374807, 157742535, 470543560, 530573048]) def test_issue_69(self): """tests issue 69. more strict padding tests.""" # padded frames padded = [ "file.08.jpg", "file.09.jpg", "file.10.jpg", "file.11.jpg", ] # unpadded frames unpadded = [ "file.8.jpg", "file.9.jpg", "file.10.jpg", "file.11.jpg", ] seqformat = "%4l %h%p%t %R" # test with strict padding enabled (default) # with strict pad enabled, the num of digits in each frame must match pyseq.strict_pad = True # test padded frames seqs = get_sequences(padded) self.assertEqual(len(seqs), 1) self.assertEqual(seqs[0].format(seqformat), " 4 file.%02d.jpg [8-11]") # test unpadded frames seqs = get_sequences(unpadded) self.assertEqual(len(seqs), 2) self.assertEqual(seqs[0].format(seqformat), " 2 file.%02d.jpg [10-11]") self.assertEqual(seqs[1].format(seqformat), " 2 file.%d.jpg [8-9]") # test uncompress with strict pad # finds frames 1-9 because num digits changes after 9 s = uncompress("file.1-150.jpg", fmt="%h%r%t") self.assertEqual(len(s), 9) # test with strict padding disabled # with strict pad disabled, the num of digits in each frame can vary pyseq.strict_pad = False # test padded frames seqs = get_sequences(padded) self.assertEqual(len(seqs), 1) self.assertEqual(seqs[0].format(seqformat), " 4 file.%02d.jpg [8-11]") # test unpadded frames seqs = get_sequences(unpadded) self.assertEqual(len(seqs), 1) self.assertEqual(seqs[0].format(seqformat), " 4 file.%d.jpg [8-11]") # test uncompress without strict pad, finds all 150 frames s = uncompress("file.1-150.jpg", fmt="%h%r%t") self.assertEqual(len(s), 150) def test_issue_83(self): """tests issue 83. externalize frame pattern.""" from pyseq import config filenames = [ "file_v001.jpg", "file_v002.jpg", "file_v003.jpg", "file_v004.jpg", ] # test using default frame pattern seqs1 = pyseq.get_sequences( filenames, frame_pattern=config.DEFAULT_FRAME_PATTERN ) self.assertEqual(len(seqs1), 1) # test if a new file in the sequence is included item = Item("file_v005.jpg") self.assertTrue(seqs1[0].includes(item)) # test using custom frame pattern, different from first sequence seqs2 = pyseq.get_sequences(filenames, frame_pattern="_%d") # should have 4 sequences, with one file each self.assertEqual(len(seqs2), len(filenames)) # test that items from sequences 1 and 2 are not siblings seq1item1 = seqs1[0][0] seq2item1 = seqs2[0][0] self.assertFalse(seq1item1.is_sibling(seq2item1)) # test that 2 items in the sequence 1 are still siblings seq1item2 = seqs1[0][1] self.assertTrue(seq1item1.is_sibling(seq1item2)) # test items in sequences 1 and 2 are not siblings self.assertFalse(seq1item1.is_sibling(seq2item1)) # test that the new item is still included in the first sequence, # and excluded from the second sequence self.assertTrue(seqs1[0].includes(item)) self.assertFalse(seqs2[0].includes(item)) def test_issue_86(self): """tests issue 86. uncompress() with whitespace.""" # test sequence with whitespace sequence_path = "path/to/file/image ([1-2, 4]).png" sequence = pyseq.uncompress(sequence_path, fmt="%h%R%t") self.assertEqual(str(sequence), "image (1-4).png") self.assertEqual(len(sequence), 3) self.assertEqual(sequence[0].path, "path/to/file/image (1).png") self.assertEqual(sequence[1].path, "path/to/file/image (2).png") self.assertEqual(sequence[2].path, "path/to/file/image (4).png") # test sequence with multiple spaces sequence_path = "other/path/file with spaces [10-40].png" sequence = pyseq.uncompress(sequence_path, fmt="%h%R%t") self.assertEqual(str(sequence), "file with spaces 10-40.png") self.assertEqual(len(sequence), 31) # test sequence with brackets sequence_path = "My file [v2].[1-2].jpg" sequence = pyseq.uncompress(sequence_path, fmt="%h%R%t") self.assertEqual(str(sequence), "My file [v2].1-2.jpg") self.assertEqual(len(sequence), 2) if __name__ == "__main__": unittest.main()