allow finalized pipelines to override the seed

Author: huettenhain

refinery/lib/argformats.py

@@ -596,25 +596,23 @@ class DelayedArgument(LazyEvaluation):
     _CMD_SPLIT_TOKEN = ':'
 
     def __init__(self, expression: str, reverse: bool = False, seed=None):
+        requires_seed = seed is None
         self.expression = expression
         self.modifiers = []
         self.finalized = False
-        if seed is not None:
-            if reverse:
-                if not expression.startswith(':'):
-                    expression = F':{expression}'
-            else:
-                if not expression.endswith(':'):
-                    expression = F'{expression}:'
         while not self.finalized:
-            name, arguments, newexpr = self._split_modifier(expression, reverse)
+            name, arguments, newexpr = self._split_modifier(
+                expression,
+                reverse,
+                requires_seed,
+            )
             if not name or not self.handler.can_handle(name, *arguments):
                 break
             self.modifiers.append((name, arguments))
             expression = newexpr
             if self.handler.terminates(name):
                 self.finalized = True
-        if seed is not None:
+        if not requires_seed and not self.finalized:
             if expression:
                 rt = 'reverse ' if reverse else ''
                 raise ValueError(F'{rt}expression {self.expression} with seed {seed} was not fully parsed.')
@@ -654,15 +652,24 @@ def _split_expression(self, expression: str, reverse: bool = False) -> tuple[str
                 return (head, tail) if reverse else (tail, head)
         return expression, None
 
-    def _split_modifier(self, expression: str, reverse: bool = False) -> tuple[str | None, tuple[str], str]:
+    def _split_modifier(
+        self,
+        sequence: str,
+        reverse: bool = False,
+        requires_seed: bool = True,
+    ) -> tuple[str | None, tuple[str, ...], str]:
         brackets = 0
         name = None
         argoffset = 0
         arguments = ()
 
-        rest, expression = self._split_expression(expression, reverse)
+        rest, expression = self._split_expression(sequence, reverse)
+
         if expression is None:
-            return name, arguments, rest
+            if requires_seed:
+                return name, arguments, rest
+            expression, rest = rest, ''
+
         name = expression
 
         for k, character in enumerate(expression):

test/lib/test_argformats.py

@@ -52,6 +52,10 @@ def test_skip_first_character_of_cyclic_key(self):
         key = argformats.DelayedArgument('take[1:16]:cycle:KITTY')()
         self.assertEqual(key, B'ITTYKITTYKITTYK')
 
+    def test_with_seed(self):
+        key = argformats.DelayedBinaryArgument('snip[:2]:snip[1:]', seed=B'FOO')()
+        self.assertEqual(key, B'OO')
+
     def test_itob(self):
         data = argformats.DelayedArgument('itob:take[:4]:accu[0x1337]:A')()
         self.assertEqual(data, bytes.fromhex('3713371337133713'))

test/units/meta/test_reduce.py

@@ -8,6 +8,10 @@ def test_concatenation(self):
         pl = L('emit 5 4 3 2 1 0 [| reduce cca[var:t] ]')
         self.assertEqual(pl(), B'012345')
 
+    def test_finalized_pipeline(self):
+        pl = L('emit 5 4 3 2 1 0 [| reduce t:var ]')
+        self.assertEqual(pl(), B'5')
+
     def test_variables_are_retained(self):
         pl = L('emit +Y X X X [| put q index | reduce pf[{q}{}{t}] ]')
         self.assertEqual(pl(), B'3X2X1X+Y')