Provide a more correct definition of stem

Author: AWhetter

doc/source/format.rst

@@ -340,7 +340,7 @@ Compatibility with VFX Software
 This format maximises compatibility with software commonly used in
 the VFX industry.
 Any sequence string that is not directly compatible with a DCC
-can be converted to a compatible sequence string using :ref:`format conversion <convert>`.
+can be converted to a compatible sequence string using :doc:`format conversion <convert>`.
 
 The "**File Compatible**" column notes whether pathseq can represent
 a file sequence output by the DCC.
@@ -572,15 +572,15 @@ a stem may or may not be present in the name of a loose path sequence.
 
    For ranges that start or end the name of the sequence,
    there is ambiguity in how to interpret the stem and suffixes.
-   Unlike :attr:`pathlib.PurePath.stem`, this will never contain a suffix
+   Like :attr:`pathlib.PurePath.stem`, this will contain a suffix
    if the paths have multiple suffixes:
 
    .. code-block:: pycon
 
       >>> LoosePathSequence('file.tar.gz.1-5#').stem
-      'file'
+      'file.tar'
       >>> LoosePathSequence('1-5#file.tar.gz').stem
-      'file'
+      'file.tar'
 
 
 .. _format-loose-prerange:

doc/source/quickstart.rst

@@ -217,4 +217,4 @@ Like :class:`pathlib.Path`, the name of a path sequence can be split into its pa
 .. seealso::
 
     :doc:`/format`
-    :doc:`/user/convert`
+    :doc:`/convert`

src/pathseq/_ast/_formatter.py

@@ -67,6 +67,16 @@ class Formatter:
             'image.$F.exr'
     """
 
+    def __init__(self) -> None:
+        self.include_all_suffixes = False
+        """Whether to include all suffixes in the formatted sequence.
+
+        This is set by :meth:`~.Formatter.format` to indicate whether the
+        suffixes have been cleanly separated from the stem or not.
+        If this is ``False``, then the ``stem`` and ``suffixes`` will overlap
+        and both include all but the last suffix.
+        """
+
     def stem(self, stem: str) -> str:
         return stem
 
@@ -89,7 +99,7 @@ def post_range(self, post_range: str) -> str:
         return post_range
 
     def suffixes(self, suffixes: tuple[str, ...]) -> str:
-        return "".join(suffixes)
+        return "".join(suffixes if self.include_all_suffixes else suffixes[-1:])
 
     def format(self, seq: ParsedSequence | ParsedLooseSequence) -> str:
         """Format the given path sequence into a string.
@@ -103,6 +113,14 @@ def format(self, seq: ParsedSequence | ParsedLooseSequence) -> str:
         Returns:
             The formatter path sequence.
         """
+        from ._loose_type import RangesInName
+        from ._type import ParsedSequence
+
+        self.include_all_suffixes = bool(
+            isinstance(seq, ParsedSequence)
+            or (isinstance(seq, RangesInName) and seq.ranges.ranges)
+        )
+
         return "".join(
             getattr(self, field.name)(getattr(seq, field.name))
             for field in dataclasses.fields(seq)

src/pathseq/_loose_pure_path_sequence.py

@@ -78,13 +78,18 @@ def stem(self) -> str:
             >>> LoosePurePathSequence('/path/to/images.exr.1-3####').stem
             'images'
 
-        Unlike :attr:`pathlib.PurePath.stem`, this will never contain a suffix
-        if the paths have multiple suffixes:
+        If the ranges do not start or end the path then,
+        unlike :attr:`pathlib.PurePath.stem`, this will never contain a suffix
+        if the range is in the path and the paths have multiple suffixes:
 
         .. code-block:: pycon
 
-            >>> LoosePurePathSequence('/path/to/images.tar.gz.1-3####').stem
+            >>> LoosePurePathSequence('/path/to/images.1-3####.tar.gz').stem
             'images'
+            >>> LoosePurePathSequence('/path/to/1-3####_images.tar.gz').stem
+            'images.tar'
+            >>> LoosePurePathSequence('/path/to/images.tar.gz.1-3####').stem
+            'images.tar'
 
         If the paths have no stem, then the empty string is returned:
 

src/pathseq/_parse_loose_path_sequence.py

@@ -125,13 +125,15 @@ def _tokenise(seq: str) -> list[Token]:
                     suffix_dot = 0
                     if raw_token.startswith("."):
                         suffix_dot = 1
+                    post_i = raw_token.rindex(".", suffix_dot)
                     suffix_i = raw_token.index(".", suffix_dot)
                 except ValueError:
+                    post_i = len(raw_token)
                     suffix_i = len(raw_token)
 
                 token = Token(
                     TokenType.STEM,
-                    raw_token[:suffix_i],
+                    raw_token[:post_i],
                     column,
                 )
                 tokens.append(token)
@@ -161,14 +163,7 @@ def _tokenise(seq: str) -> list[Token]:
             )
             tokens.append(token)
         elif i == len(raw_tokens) - 1:
-            if raw_token.startswith(".") and not raw_token.endswith("."):
-                token = Token(
-                    TokenType.SUFFIXES,
-                    raw_token,
-                    column,
-                )
-                tokens.append(token)
-            elif starts_with_range:
+            if starts_with_range:
                 if any(raw_token.startswith(sep) for sep in _POST_RANGE_SEPARATORS):
                     token = Token(
                         TokenType.POST_RANGE,
@@ -180,19 +175,23 @@ def _tokenise(seq: str) -> list[Token]:
                     column += 1
 
                 if raw_token.endswith("."):
+                    post_i = 0
                     suffix_i = len(raw_token)
                 elif raw_token.startswith("."):
+                    post_i = 0
                     suffix_i = 0
                 else:
                     try:
+                        post_i = raw_token.rindex(".")
                         suffix_i = raw_token.index(".")
                     except ValueError:
+                        post_i = len(raw_token)
                         suffix_i = len(raw_token)
 
-                if raw_token[:suffix_i]:
+                if raw_token[:post_i]:
                     token = Token(
                         TokenType.STEM,
-                        raw_token[:suffix_i],
+                        raw_token[:post_i],
                         column,
                     )
                     tokens.append(token)
@@ -204,10 +203,8 @@ def _tokenise(seq: str) -> list[Token]:
                         column + suffix_i,
                     )
                     tokens.append(token)
-            else:
-                if raw_token.endswith("."):
-                    suffix_i = len(raw_token)
-                elif raw_token.startswith("."):
+            elif not ends_with_range:
+                if raw_token.startswith("."):
                     suffix_i = 0
                 else:
                     try:
@@ -230,6 +227,55 @@ def _tokenise(seq: str) -> list[Token]:
                         column + suffix_i,
                     )
                     tokens.append(token)
+            else:
+                if any(raw_token.startswith(sep) for sep in _PRE_RANGE_SEPARATORS):
+                    token = Token(
+                        TokenType.PRE_RANGE,
+                        raw_token[0],
+                        column,
+                    )
+                    tokens.append(token)
+                    raw_token = raw_token[1:]
+                    column += 1
+
+                prerange = None
+                if any(raw_token.endswith(sep) for sep in _PRE_RANGE_SEPARATORS):
+                    prerange = Token(
+                        TokenType.PRE_RANGE,
+                        raw_token[-1],
+                        column + len(raw_token) - 1,
+                    )
+                    raw_token = raw_token[:-1]
+
+                if raw_token.startswith("."):
+                    stem_i = len(raw_token)
+                    suffix_i = 0
+                else:
+                    try:
+                        stem_i = raw_token.rindex(".")
+                        suffix_i = raw_token.index(".")
+                    except ValueError:
+                        stem_i = 0
+                        suffix_i = len(raw_token)
+
+                token = Token(
+                    TokenType.STEM,
+                    raw_token[:stem_i],
+                    column,
+                )
+                tokens.append(token)
+
+                if raw_token[suffix_i:]:
+                    token = Token(
+                        TokenType.SUFFIXES,
+                        raw_token[suffix_i:],
+                        column + suffix_i,
+                    )
+                    tokens.append(token)
+
+                if prerange:
+                    tokens.append(prerange)
+                    column += 1
 
         column += len(raw_token)
 

tests/test_loose_parsing.py

@@ -108,7 +108,7 @@ class TestPathSequence:
                         (),
                     ),
                     "",
-                    "file",
+                    "file.tar",
                     (".tar", ".gz"),
                 ),
                 id="#file.tar.gz",
@@ -369,8 +369,8 @@ def test_in_without_stem(self, seq, expected):
                         ),
                         (),
                     ),
-                    ".",
-                    (),
+                    "",
+                    (".",),
                 ),
                 id="file.#.",
             ),
@@ -445,10 +445,10 @@ def test_in_without_stem(self, seq, expected):
                         ),
                         (),
                     ),
-                    ".exr.",
-                    (),
+                    "",
+                    (".exr", "."),
                 ),
-                id="file.#.exr",
+                id="file.#.exr.",
             ),
         ],
     )