refactor: clean up scalar function docstrings and remove dead code

- Remove mentions of HAVE_MORE_OUTPUT and FINALIZE from public docstrings
- Remove dead code that handled FINALIZE signal (scalar functions don't use it)
- Simplify run() method to use while True loop (exits via generator.close())
- Clean up internal comments

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: rustyconover

duckdb

@@ -0,0 +1 @@
+Subproject commit e797eded1bdf44f6c64a749bc57049f59969c6cd

vgi/client/client.py

@@ -1818,16 +1818,14 @@ def scalar_function(
         """Invoke a scalar function on the worker and stream results.
 
         Scalar functions transform input batches to single-column output with
-        1:1 row mapping. Unlike table_in_out_function, scalar functions have
-        no finalize phase - processing ends when input is exhausted.
+        1:1 row mapping. Processing ends when input is exhausted.
 
         Processing flow:
         1. Reads the first input batch to determine the input schema
         2. Sends Invocation to worker and receives bind result
         3. Spawns additional workers if max_processes > 1
         4. Distributes input batches to workers (round-robin for parallel mode)
-        5. Collects output batches, handling HAVE_MORE_OUTPUT for log messages
-        6. Returns when input is exhausted (no FINALIZE signal)
+        5. Collects and yields output batches
 
         For parallel processing (max_processes > 1), input batches are distributed
         round-robin across workers using dedicated threads. Output order may not
@@ -1915,7 +1913,6 @@ def _scalar_function_parallel(
     ) -> Generator[pa.RecordBatch, None, None]:
         """Process scalar function batches across one or more workers using threads.
 
-        Similar to _table_in_out_function_parallel but without finalization.
         Handles both single-worker and multi-worker cases uniformly.
 
         Processing flow:
@@ -1925,7 +1922,7 @@ def _scalar_function_parallel(
         4. Signals end-of-input to all workers via None sentinel
         5. Collects all output batches from shared output queue
         6. Waits for worker threads to complete
-        7. Closes all workers (no finalize phase)
+        7. Closes all workers
 
         Args:
             input_batch: The first input batch, already consumed from the
@@ -1937,8 +1934,7 @@ def _scalar_function_parallel(
 
         Yields:
             Output RecordBatches from processing, in non-deterministic order for
-            multi-worker mode. When multiple batches are returned for a single
-            input (HAVE_MORE_OUTPUT for logs), they are combined into one batch.
+            multi-worker mode.
 
         Raises:
             ClientError: If a worker thread fails with an exception.
@@ -2020,7 +2016,6 @@ def _scalar_function_parallel(
         self._join_threads(threads)
         log.debug("all_scalar_worker_threads_complete")
 
-        # Close all workers (no finalize for scalar functions)
         # Close data writers to signal EOF to workers
         for worker in all_workers:
             if worker.data_writer is not None:

vgi/scalar_function.py

@@ -278,12 +278,12 @@ def run(self) -> Generator[ProtocolOutput, ProtocolInput | None, None]:
         """Run the scalar function protocol. Do not override.
 
         This generator implements the SETUP -> DATA -> TEARDOWN lifecycle.
-        No FINALIZE phase for scalar functions.
+        The generator is closed by the caller when input is exhausted.
 
         Protocol:
             - Caller primes with next() or send(None)
             - Caller sends ProtocolInput for each batch
-            - When input exhausted, generator closes (no FINALIZE signal needed)
+            - When input exhausted, caller closes the generator
         """
         # Priming yield - caller calls next() or send(None)
         input: ProtocolInput | None = yield ProtocolOutput(
@@ -300,8 +300,8 @@ def run(self) -> Generator[ProtocolOutput, ProtocolInput | None, None]:
         generator.send(None)
 
         try:
-            # DATA phase - no FINALIZE for scalar functions
-            while not input.is_finalize:
+            # DATA phase - process batches until generator is closed
+            while True:
                 result = self._process_with_exception_handling(generator, input.batch)
 
                 # Determine status based on result
@@ -320,11 +320,6 @@ def run(self) -> Generator[ProtocolOutput, ProtocolInput | None, None]:
                     raise ValueError("Expected ProtocolInput, got None")
                 if self._should_terminate(result):
                     return
-
-            # When FINALIZE signal comes, just emit FINISHED (no finalize phase)
-            yield ProtocolOutput(
-                batch=self.empty_output_batch, status=_OutputStatus.FINISHED
-            )
         finally:
             generator.close()
             # Release resources after processing completes