fix: rename

Author: rustyconover

docs/generator-api.md

@@ -85,7 +85,7 @@ def perform_init(self, init_input):
     # Primary worker: populate work queue
     work_items = [chunk.serialize() for chunk in self.create_chunks()]
     self.enqueue_work(work_items)
-    return GlobalInitResult(self.init_identifier)
+    return InitResult(self.init_identifier)
 
 def process(self):
     # All workers: pull from queue until empty

docs/lifecycle.md

@@ -10,7 +10,7 @@ Understanding when lifecycle methods are called is critical for resource managem
 │    ↓                                                            │
 │  output_schema (property accessed)                              │
 │    ↓                                                            │
-│  perform_init(init_batch) → GlobalInitResult                    │
+│  perform_init(init_batch) → InitResult                    │
 │    ↓                                                            │
 │  setup()  ← Acquire resources here (DB connections, files)      │
 │    ↓                                                            │

docs/protocol.md

@@ -14,7 +14,7 @@ Client                                  Worker
   │◀──── OutputSpec (output schema) ──────│
   │                                       │
   │──── GlobalStateInitInput ────────────▶│
-  │◀──── GlobalInitResult ────────────────│ perform_init()
+  │◀──── InitResult ────────────────│ perform_init()
   │                                       │
   │◀──── Output Batch 1 ──────────────────│ process() yields
   │◀──── Output Batch 2 ──────────────────│
@@ -35,7 +35,7 @@ Client                                  Worker
   │◀──── OutputSpec (output schema) ──────│
   │                                       │
   │──── GlobalStateInitInput ────────────▶│
-  │◀──── GlobalInitResult ────────────────│ perform_init()
+  │◀──── InitResult ────────────────│ perform_init()
   │                                       │
   │──── Input Batch 1 ───────────────────▶│
   │◀──── Output Batch 1 (NEED_MORE_INPUT)─│ transform() / process()

tests/test_protocol_classes.py

@@ -1,6 +1,6 @@
 """Unit tests for VGI protocol classes.
 
-Tests cover Invocation, Arguments, GlobalInitResult, and table_function classes.
+Tests cover Invocation, Arguments, InitResult, and table_function classes.
 """
 
 from __future__ import annotations
@@ -13,7 +13,7 @@
     Arg,
     Arguments,
     ArgumentValidationError,
-    GlobalInitResult,
+    InitResult,
     Invocation,
     InvocationType,
 )
@@ -310,20 +310,20 @@ def test_with_global_init_identifier(self) -> None:
             global_init_identifier=None,
         )
 
-        init_result = GlobalInitResult(global_init_identifier=b"init-data")
+        init_result = InitResult(global_init_identifier=b"init-data")
         updated = original.with_global_init_identifier(init_result)
 
         assert updated.function_name == original.function_name
         assert updated.global_init_identifier == init_result
         assert original.global_init_identifier is None  # Original unchanged
 
 
-class TestGlobalInitResult:
-    """Tests for GlobalInitResult serialization."""
+class TestInitResult:
+    """Tests for InitResult serialization."""
 
     def test_basic_round_trip(self) -> None:
-        """GlobalInitResult should serialize and deserialize correctly."""
-        original = GlobalInitResult(global_init_identifier=b"test-init-id")
+        """InitResult should serialize and deserialize correctly."""
+        original = InitResult(global_init_identifier=b"test-init-id")
 
         serialized = original.serialize()
         assert isinstance(serialized, bytes)
@@ -332,20 +332,20 @@ def test_basic_round_trip(self) -> None:
 
         reader = ipc.open_stream(serialized)
         batch = reader.read_next_batch()
-        deserialized = GlobalInitResult.deserialize(batch)
+        deserialized = InitResult.deserialize(batch)
 
         assert deserialized.global_init_identifier == b"test-init-id"
 
     def test_null_identifier(self) -> None:
-        """GlobalInitResult with null identifier should round-trip correctly."""
-        original = GlobalInitResult(global_init_identifier=None)
+        """InitResult with null identifier should round-trip correctly."""
+        original = InitResult(global_init_identifier=None)
 
         serialized = original.serialize()
         from pyarrow import ipc
 
         reader = ipc.open_stream(serialized)
         batch = reader.read_next_batch()
-        deserialized = GlobalInitResult.deserialize(batch)
+        deserialized = InitResult.deserialize(batch)
 
         assert deserialized.global_init_identifier is None
 
@@ -357,15 +357,15 @@ def test_has_identifier_true(self) -> None:
                 [pa.field("global_init_identifier", pa.binary(), nullable=True)]
             ),
         )
-        assert GlobalInitResult.has_identifier(batch) is True
+        assert InitResult.has_identifier(batch) is True
 
     def test_has_identifier_false(self) -> None:
         """has_identifier should return False when field doesn't exist."""
         batch = pa.RecordBatch.from_pylist(
             [{"other_field": "value"}],
             schema=make_schema([pa.field("other_field", pa.string())]),
         )
-        assert GlobalInitResult.has_identifier(batch) is False
+        assert InitResult.has_identifier(batch) is False
 
     def test_deserialize_empty_batch_raises(self) -> None:
         """Deserializing empty batch should raise ValueError."""
@@ -377,7 +377,7 @@ def test_deserialize_empty_batch_raises(self) -> None:
         )
 
         with pytest.raises(ValueError, match="empty RecordBatch"):
-            GlobalInitResult.deserialize(empty_batch)
+            InitResult.deserialize(empty_batch)
 
     def test_deserialize_multi_row_batch_raises(self) -> None:
         """Deserializing multi-row batch should raise ValueError."""
@@ -392,11 +392,11 @@ def test_deserialize_multi_row_batch_raises(self) -> None:
         )
 
         with pytest.raises(ValueError, match="single-row"):
-            GlobalInitResult.deserialize(multi_row_batch)
+            InitResult.deserialize(multi_row_batch)
 
     def test_schema(self) -> None:
         """schema() should return correct Arrow schema."""
-        result = GlobalInitResult(global_init_identifier=b"test")
+        result = InitResult(global_init_identifier=b"test")
         schema = result.schema()
 
         assert len(schema) == 1

vgi/client/client.py

@@ -72,7 +72,7 @@
 from vgi.function import (
     Arguments,
     FunctionInitInput,
-    GlobalInitResult,
+    InitResult,
     Invocation,
     InvocationType,
 )
@@ -375,7 +375,7 @@ def _initialize_stream_common(
         function_type: InvocationType,
         bind_result_callback: Callable[[pa.RecordBatch], None] | None,
         projection_ids: list[int] | None,
-    ) -> tuple[_BindResult, GlobalInitResult, Invocation]:
+    ) -> tuple[_BindResult, InitResult, Invocation]:
         """Perform the common initialization handshake with the primary worker.
 
         Executes the VGI protocol initialization sequence:
@@ -385,7 +385,7 @@ def _initialize_stream_common(
         4. Validates protocol version compatibility
         5. Applies CPU/max_workers limits to max_processes
         6. Sends init data (FunctionInitInput or TableFunctionInitInput)
-        7. Reads GlobalInitResult (shared state identifier for parallel workers)
+        7. Reads InitResult (shared state identifier for parallel workers)
         8. Creates an Invocation with global_init_identifier for additional workers
 
         Args:
@@ -406,7 +406,7 @@ def _initialize_stream_common(
         Returns:
             A tuple of (bind_result, global_init_result, request_with_init):
                 - bind_result: Parsed _BindResult with output_schema, max_processes
-                - global_init_result: GlobalInitResult containing shared state ID
+                - global_init_result: InitResult containing shared state ID
                 - request_with_init: Invocation with global_init_identifier set,
                   suitable for initializing additional parallel workers
 
@@ -496,7 +496,7 @@ def _initialize_stream_common(
         except IPCError as e:
             raise ClientError(str(e)) from e
 
-        global_init_result = GlobalInitResult.deserialize(init_result_batch)
+        global_init_result = InitResult.deserialize(init_result_batch)
         log.debug(
             "init_result_received",
             has_identifier=global_init_result.global_init_identifier is not None,
@@ -835,7 +835,7 @@ def _initialize_additional_worker(
                 and stdout_buffered handles. The data_writer field will be set
                 if input_schema is not None.
             request_with_init: Invocation containing the global_init_identifier
-                from the primary worker's GlobalInitResult. This ensures all
+                from the primary worker's InitResult. This ensures all
                 workers share the same initialization state.
             input_schema: Schema for the input data stream. If provided, a
                 RecordBatchStreamWriter is created and assigned to worker.data_writer.

vgi/examples/table.py

@@ -19,7 +19,7 @@
 import pyarrow as pa
 
 from vgi.arguments import Arg
-from vgi.function import GlobalInitResult
+from vgi.function import InitResult
 from vgi.log import Level, Message
 from vgi.metadata import FunctionExample
 from vgi.table_function import (
@@ -473,7 +473,7 @@ def cardinality(self) -> CardinalityInfo:
         """
         return CardinalityInfo(estimate=self.count, max=self.count)
 
-    def perform_init(self, init_input: pa.RecordBatch) -> GlobalInitResult:
+    def perform_init(self, init_input: pa.RecordBatch) -> InitResult:
         """Populate the work queue with range chunks."""
         # Parse init data and store in init_storage
         self.init_data = TableFunctionInitInput.deserialize(init_input)
@@ -489,7 +489,7 @@ def perform_init(self, init_input: pa.RecordBatch) -> GlobalInitResult:
         if work_items:
             self.enqueue_work(work_items)
 
-        return GlobalInitResult(self.init_identifier)
+        return InitResult(self.init_identifier)
 
     def process(self) -> OutputGenerator:
         """Generate values by pulling chunks from the work queue."""

vgi/function.py

@@ -52,7 +52,7 @@
     "Arguments",
     "Function",
     "InvocationType",
-    "GlobalInitResult",
+    "InitResult",
     "Level",
     "Message",
     "OutputSpec",
@@ -253,11 +253,11 @@ def deserialize(cls, data: bytes) -> Self:
 
 
 @dataclass(frozen=True, slots=True)
-class GlobalInitResult:
+class InitResult:
     """Result from the global initialization phase of a function.
 
     When a function supports parallel execution (max_processes > 1), the first
-    worker runs perform_init() which returns a GlobalInitResult. This result
+    worker runs perform_init() which returns a InitResult. This result
     contains an identifier that is passed to all subsequent parallel workers
     via retrieve_init(), allowing them to share state or coordinate processing.
 
@@ -285,7 +285,7 @@ def has_identifier(cls, data: pa.RecordBatch) -> bool:
         return cls._IDENTIFIER_FIELD_NAME in data.schema.names
 
     def schema(self) -> pa.Schema:
-        """Return Arrow schema used when serializing GlobalInitResult.
+        """Return Arrow schema used when serializing InitResult.
 
         Returns:
             Arrow schema with fields for each serialized attribute.
@@ -298,10 +298,10 @@ def schema(self) -> pa.Schema:
         )
 
     def serialize(self) -> bytes:
-        """Serialize GlobalInitResult to an Arrow RecordBatch.
+        """Serialize InitResult to an Arrow RecordBatch.
 
         Returns:
-            RecordBatch containing serialized GlobalInitResult fields.
+            RecordBatch containing serialized InitResult fields.
 
         """
         batch = pa.RecordBatch.from_pylist(
@@ -315,20 +315,20 @@ def serialize(self) -> bytes:
         return vgi.ipc_utils.serialize_record_batch(batch)
 
     @classmethod
-    def deserialize(cls, data: pa.RecordBatch) -> "GlobalInitResult":
-        """Deserialize GlobalInitResult from an Arrow RecordBatch.
+    def deserialize(cls, data: pa.RecordBatch) -> "InitResult":
+        """Deserialize InitResult from an Arrow RecordBatch.
 
         Args:
-          data: RecordBatch containing serialized GlobalInitResult fields.
+          data: RecordBatch containing serialized InitResult fields.
 
         Returns:
-          Deserialized GlobalInitResult instance.
+          Deserialized InitResult instance.
 
         """
         first_row = vgi.ipc_utils.validate_single_row_batch(
-            data, "GlobalInitResult", required_fields=[cls._IDENTIFIER_FIELD_NAME]
+            data, "InitResult", required_fields=[cls._IDENTIFIER_FIELD_NAME]
         )
-        return GlobalInitResult(
+        return InitResult(
             global_init_identifier=first_row[cls._IDENTIFIER_FIELD_NAME],
         )
 
@@ -383,13 +383,13 @@ class Invocation:
     # The unique identifier for the call, typically this may be a uuid.
     invocation_id: bytes | None
 
-    global_init_identifier: GlobalInitResult | None = None
+    global_init_identifier: InitResult | None = None
     arguments: Arguments = Arguments()
     client_features: frozenset[str] = frozenset()
     attach_id: bytes | None = None
 
     def with_global_init_identifier(
-        self, global_init_identifier: GlobalInitResult
+        self, global_init_identifier: InitResult
     ) -> "Invocation":
         """Return a new Invocation with the given global_init_identifier."""
         return replace(self, global_init_identifier=global_init_identifier)
@@ -423,7 +423,7 @@ def serialize(self) -> bytes:
                     "function_type": self.function_type.value,
                     "invocation_id": self.invocation_id,
                     "correlation_id": self.correlation_id,
-                    GlobalInitResult._IDENTIFIER_FIELD_NAME: (
+                    InitResult._IDENTIFIER_FIELD_NAME: (
                         self.global_init_identifier.global_init_identifier
                         if self.global_init_identifier
                         else None
@@ -441,7 +441,7 @@ def serialize(self) -> bytes:
                     pa.field("invocation_id", pa.binary(), nullable=True),
                     pa.field("correlation_id", pa.string(), nullable=False),
                     pa.field(
-                        GlobalInitResult._IDENTIFIER_FIELD_NAME,
+                        InitResult._IDENTIFIER_FIELD_NAME,
                         pa.binary(),
                         nullable=True,
                     ),
@@ -486,13 +486,13 @@ def deserialize(data: pa.RecordBatch) -> "Invocation":
         # Parse function_type from string value
         function_type = InvocationType(first_row["function_type"])
 
-        # Parse global_init_identifier - only create GlobalInitResult if field exists
+        # Parse global_init_identifier - only create InitResult if field exists
         # and has a non-None value
         global_init_identifier = None
-        if GlobalInitResult._IDENTIFIER_FIELD_NAME in data.schema.names:
-            identifier_value = first_row[GlobalInitResult._IDENTIFIER_FIELD_NAME]
+        if InitResult._IDENTIFIER_FIELD_NAME in data.schema.names:
+            identifier_value = first_row[InitResult._IDENTIFIER_FIELD_NAME]
             if identifier_value is not None:
-                global_init_identifier = GlobalInitResult(identifier_value)
+                global_init_identifier = InitResult(identifier_value)
 
         # Parse client_features - default to empty set for backward compatibility
         client_features: frozenset[str] = frozenset()
@@ -1211,7 +1211,7 @@ def enqueue_work(self, work_items: list[bytes]) -> int:
             ValueError: If init_identifier has not been set.
 
         Example:
-            def perform_init(self, init_input: pa.RecordBatch) -> GlobalInitResult:
+            def perform_init(self, init_input: pa.RecordBatch) -> InitResult:
                 result = super().perform_init(init_input)
                 # Create work items (e.g., ranges to process)
                 work_items = [struct.pack(">QQ", start, end) for start, end in ranges]
@@ -1314,20 +1314,20 @@ def _validate_input_schema(self, batch: pa.RecordBatch) -> None:
                 context=f"input to {type(self).__name__}",
             )
 
-    def perform_init(self, init_input: pa.RecordBatch) -> GlobalInitResult:
+    def perform_init(self, init_input: pa.RecordBatch) -> InitResult:
         """Perform a new init call and store it in the storage."""
         self.init_data = self.InitDataCls.deserialize(init_input)
         assert self.init_data is not None
         self.init_identifier = self.init_storage.create(self.init_data.serialize())
-        return GlobalInitResult(self.init_identifier)
+        return InitResult(self.init_identifier)
 
-    def retrieve_init(self, init_input: GlobalInitResult) -> None:
+    def retrieve_init(self, init_input: InitResult) -> None:
         """Retrieve and store init data from the storage."""
         if init_input.global_init_identifier is None:
             raise ValueError(
                 "global_init_identifier is required but was None. "
-                "This indicates the GlobalInitResult was not properly initialized. "
-                "Ensure perform_init() returns a GlobalInitResult with a valid "
+                "This indicates the InitResult was not properly initialized. "
+                "Ensure perform_init() returns a InitResult with a valid "
                 "identifier."
             )
         self.init_identifier = init_input.global_init_identifier