Fileseq 2.3.0__tar.gz → 2.3.2__tar.gz

{fileseq-2.3.0/src/Fileseq.egg-info → fileseq-2.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Fileseq
-Version: 2.3.0
+Version: 2.3.2
 Summary: A Python library for parsing frame ranges and file sequences commonly used in VFX and Animation applications.
 Home-page: https://github.com/justinfx/fileseq
 Author: Matt Chambers

{fileseq-2.3.0 → fileseq-2.3.2/src/Fileseq.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Fileseq
-Version: 2.3.0
+Version: 2.3.2
 Summary: A Python library for parsing frame ranges and file sequences commonly used in VFX and Animation applications.
 Home-page: https://github.com/justinfx/fileseq
 Author: Matt Chambers

{fileseq-2.3.0 → fileseq-2.3.2}/src/Fileseq.egg-info/SOURCES.txt

@@ -84,6 +84,7 @@ test/seq/big.1002.ext
 test/seq/big.1003.ext
 test/seq/foo.0001.exr
 test/seq/foo.0001.jpg
+test/seq/foo.0001_1.exr
 test/seq/foo.0002.exr
 test/seq/foo.0002.jpg
 test/seq/foo.0003.exr

fileseq-2.3.2/src/fileseq/__version__.py

@@ -0,0 +1 @@
+__version__ = '2.3.2'

{fileseq-2.3.0 → fileseq-2.3.2}/src/fileseq/filesequence.py

@@ -963,9 +963,11 @@ class BaseFileSequence(typing.Generic[T]):
             path: str
             for path in filter(None, map(utils.asString, paths)):
                 frame = path[head:tail]
-                try:
-                    int(frame)
-                except ValueError:
+                # Use isdigit() instead of int() to reject PEP 515 underscore
+                # digit separators: int("1001_1") succeeds in Python 3.6+ but
+                # "1001_1" is not a valid frame number.
+                _int_part = frame.partition('.')[0]
+                if not _int_part.lstrip('-').isdigit():
                     if not allow_subframes:
                         continue
                     try:
@@ -1505,6 +1507,12 @@ class BaseFileSequence(typing.Generic[T]):
                 if len(subframe) != decimal_places:
                     continue
 
+                # Reject frames with non-digit characters such as PEP 515
+                # underscore separators (e.g. "1001_1") which int() accepts in
+                # Python 3.6+ but are not valid frame numbers.
+                if not frame.lstrip('-').isdigit():
+                    continue
+
                 has_padded_frame = check_padded(frame)
                 has_padded_subframe = check_padded(subframe)
 

{fileseq-2.3.0 → fileseq-2.3.2}/src/fileseq/frameset.py

@@ -177,6 +177,7 @@ class FrameSet(BaseFrameSet):
         frange = str(frange)
         for key in self.PAD_MAP:
             frange = frange.replace(key, '')
+        frange = ''.join(frange.split())  # https://github.com/justinfx/fileseq/issues/137: strip all whitespace
         self._frange = asString(frange)
 
         # because we're acting like a set, we need to support the empty set
@@ -1485,7 +1486,8 @@ class FrameSet(BaseFrameSet):
         # Dispatch to appropriate specialized method based on frame type
         # Handle empty frames by defaulting to float method
         if frames and isinstance(frames[0], decimal.Decimal):
-            yield from FrameSet._framesToFrameRangesDecimal(frames, zfill)  # type: ignore[arg-type]
+            # noinspection PyTypeChecker
+            yield from FrameSet._framesToFrameRangesDecimal(frames, zfill)
         else:
             yield from FrameSet._framesToFrameRangesFloat(frames, zfill)  # type: ignore[arg-type]
 

{fileseq-2.3.0 → fileseq-2.3.2}/test/test_unit.py

@@ -657,6 +657,175 @@ class TestFrameSet(unittest.TestCase):
             actual = list(FrameSet(case.input).batches(case.batch, frames=False))
             self.assertListEqual(expect, actual, msg=str(case))
 
+    def testWhitespaceHandling(self):
+        """
+        Issue #137: Whitespace tolerance in frame range parsing.
+
+        Test that FrameSet correctly handles whitespace in various positions:
+        - Spaces after commas
+        - Spaces around range operators
+        - Leading/trailing spaces
+        - Spaces with modifiers (x, y, :)
+        - Tabs and newlines
+        """
+        @dataclasses.dataclass
+        class Case:
+            input: str
+            expected_frange: str
+            expected_frames: list[int]
+            description: str
+
+        table = [
+            # Basic whitespace after commas
+            Case(
+                input='1, 2, 3',
+                expected_frange='1,2,3',
+                expected_frames=[1, 2, 3],
+                description='spaces after commas'
+            ),
+            Case(
+                input='1 , 2 , 3',
+                expected_frange='1,2,3',
+                expected_frames=[1, 2, 3],
+                description='spaces before and after commas'
+            ),
+
+            # Whitespace around range operators
+            Case(
+                input='1 - 10',
+                expected_frange='1-10',
+                expected_frames=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
+                description='spaces around dash'
+            ),
+            Case(
+                input='1  -  10',
+                expected_frange='1-10',
+                expected_frames=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
+                description='multiple spaces around dash'
+            ),
+
+            # Leading and trailing whitespace
+            Case(
+                input='  1-5  ',
+                expected_frange='1-5',
+                expected_frames=[1, 2, 3, 4, 5],
+                description='leading and trailing spaces'
+            ),
+            Case(
+                input=' 1 ',
+                expected_frange='1',
+                expected_frames=[1],
+                description='spaces around single frame'
+            ),
+
+            # Whitespace with x modifier (step)
+            Case(
+                input='1-10 x 2',
+                expected_frange='1-10x2',
+                expected_frames=[1, 3, 5, 7, 9],
+                description='spaces with x modifier'
+            ),
+            Case(
+                input='1 - 10 x 2',
+                expected_frange='1-10x2',
+                expected_frames=[1, 3, 5, 7, 9],
+                description='spaces in range and x modifier'
+            ),
+
+            # Whitespace with y modifier (fill)
+            Case(
+                input='1-10 y 2',
+                expected_frange='1-10y2',
+                expected_frames=[2, 4, 6, 8, 10],
+                description='spaces with y modifier'
+            ),
+
+            # Whitespace with : modifier (stagger)
+            Case(
+                input='1-6 : 3',
+                expected_frange='1-6:3',
+                expected_frames=[1, 4, 3, 5, 2, 6],
+                description='spaces with : modifier'
+            ),
+
+            # Complex case with multiple comma-separated ranges
+            Case(
+                input='1 , 2 , 3 , 5-10 , 20-30',
+                expected_frange='1,2,3,5-10,20-30',
+                expected_frames=[1, 2, 3, 5, 6, 7, 8, 9, 10, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30],
+                description='complex multi-range with spaces'
+            ),
+            Case(
+                input='  1  ,  5-10  ,  20  ',
+                expected_frange='1,5-10,20',
+                expected_frames=[1, 5, 6, 7, 8, 9, 10, 20],
+                description='multiple spaces in complex range'
+            ),
+
+            # Tabs (should also be removed)
+            Case(
+                input='1\t,\t2\t,\t3',
+                expected_frange='1,2,3',
+                expected_frames=[1, 2, 3],
+                description='tabs instead of spaces'
+            ),
+            Case(
+                input='1\t-\t10',
+                expected_frange='1-10',
+                expected_frames=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
+                description='tabs around dash'
+            ),
+
+            # Newlines (should also be removed)
+            Case(
+                input='1\n-\n10',
+                expected_frange='1-10',
+                expected_frames=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
+                description='newlines in range'
+            ),
+
+            # Mixed whitespace characters
+            Case(
+                input=' \t1\n,\r2 , 3\t ',
+                expected_frange='1,2,3',
+                expected_frames=[1, 2, 3],
+                description='mixed whitespace types'
+            ),
+
+            # Edge case: all whitespace
+            Case(
+                input='   ',
+                expected_frange='',
+                expected_frames=[],
+                description='only whitespace (empty range)'
+            ),
+
+            # Negative frames with whitespace
+            Case(
+                input=' -10 - -5 ',
+                expected_frange='-10--5',
+                expected_frames=[-10, -9, -8, -7, -6, -5],
+                description='negative frames with spaces'
+            ),
+        ]
+
+        for case in table:
+            with self.subTest(case.description):
+                fs = FrameSet(case.input)
+
+                # Check normalized frange string
+                self.assertEqual(fs.frange, case.expected_frange,
+                               f"frange mismatch for {case.description}")
+
+                # Check actual frame values
+                actual_frames = list(fs)
+                self.assertEqual(actual_frames, case.expected_frames,
+                               f"frames mismatch for {case.description}")
+
+                # Check length
+                self.assertEqual(len(fs), len(case.expected_frames),
+                               f"length mismatch for {case.description}")
+
 class TestBase(unittest.TestCase):
     RX_PATHSEP = re.compile(r'[/\\]')
 
@@ -1798,7 +1967,7 @@ class AbstractBaseTests:
 
         def testFindSequencesOnDisk(self):
             seqs = self.FS.findSequencesOnDisk("seq", strictPadding=True)
-            self.assertEquals(len(seqs), 10)
+            self.assertEquals(len(seqs), 11)
 
             known = {
                 "seq/bar1000-1002,1004-1006#.exr",
@@ -1811,6 +1980,10 @@ class AbstractBaseTests:
                 "seq/baz_left.1-3#.exr",
                 "seq/baz_right.1-3#.exr",
                 "seq/big.999-1003#.ext",
+                # foo.0001_1.exr: underscore fixture for issue #158; DISK_RE
+                # parses it as basename="foo.0001_", frame="1", so it appears
+                # as a standalone sequence rather than contaminating foo.1-5#.exr
+                "seq/foo.0001_1@.exr",
             }
             found = set([str(s) for s in seqs])
             self.assertEqualPaths(found, known)
@@ -2042,6 +2215,17 @@ class AbstractBaseTests:
                     self.FS.findSequenceOnDisk(pattern, strictPadding=False)
                 self.assertEqual(str(cm.exception), 'no sequence found on disk matching ' + pattern)
 
+        def testFindSequenceOnDiskUnderscoreFrameIgnored(self):
+            # Issue #158: findSequenceOnDisk should not match filenames whose
+            # "frame" component contains an underscore (e.g. foo.0001_1.exr).
+            # Python's int() accepts underscore digit separators (PEP 515), so
+            # "1001_1" would previously be treated as a valid frame, causing
+            # "multiple sequences found on disk" errors.
+            # seq/foo.0001_1.exr is present on disk alongside seq/foo.{0001-0005}.exr
+            for strict in (False, True):
+                seq = self.FS.findSequenceOnDisk('seq/foo.#.exr', strictPadding=strict)
+                self.assertEqual(str(seq), 'seq/foo.1-5#.exr')
+
         def testFindSequenceOnDiskSubFrames(self):
             tests = [
                 ("seq/foo.#.exr", "seq/foo.1-5#.exr"),

fileseq-2.3.0/src/fileseq/__version__.py

@@ -1 +0,0 @@
-__version__ = '2.3.0'