Improve Setting class DX with shorter names and type inference

- Rename `description` to `desc` and `default_value` to `default`
- Type is now inferred from default value for common Python types
  (bool, int, float, str, bytes)
- Raise TypeError if neither type nor default is provided

Before:
    Setting(
        name="vgi_debug",
        description="Enable debug mode",
        type=pa.bool_(),
        default_value=False,
    )

After:
    Setting("vgi_debug", "Enable debug mode", default=False)

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

Author: rustyconover

tests/catalog/test_serialization.py

@@ -511,70 +511,75 @@ def test_none_invocation_id(self) -> None:
 class TestSettingSerialization:
     """Test Setting serialization round-trip."""
 
-    def test_basic_round_trip(self) -> None:
-        """Test basic serialization and deserialization."""
-        original = Setting(
-            name="vgi_verbose_mode",
-            description="Enable verbose output",
-            type=pa.bool_(),
-            default_value=None,
-        )
+    def test_basic_round_trip_explicit_type(self) -> None:
+        """Test with explicit type and no default (required setting)."""
+        original = Setting("vgi_api_key", "API key for auth", type=pa.string())
         serialized = original.serialize()
         batch = deserialize_record_batch(serialized)
         restored = Setting.deserialize(batch)
 
         assert restored.name == original.name
-        assert restored.description == original.description
-        assert restored.type == pa.bool_()
-        assert restored.default_value is None
-
-    def test_with_default_value(self) -> None:
-        """Test with a default value."""
-        original = Setting(
-            name="vgi_log_level",
-            description="Logging level",
-            type=pa.string(),
-            default_value="info",
-        )
+        assert restored.desc == original.desc
+        assert restored.type == pa.string()
+        assert restored.default is None
+
+    def test_type_inferred_from_string_default(self) -> None:
+        """Test type inference from string default."""
+        original = Setting("vgi_log_level", "Logging level", default="info")
         serialized = original.serialize()
         batch = deserialize_record_batch(serialized)
         restored = Setting.deserialize(batch)
 
         assert restored.name == original.name
-        assert restored.description == original.description
         assert restored.type == pa.string()
-        assert restored.default_value == "info"
-
-    def test_integer_type(self) -> None:
-        """Test with integer type."""
-        original = Setting(
-            name="vgi_max_workers",
-            description="Maximum worker count",
-            type=pa.int64(),
-            default_value=4,
-        )
+        assert restored.default == "info"
+
+    def test_type_inferred_from_int_default(self) -> None:
+        """Test type inference from int default."""
+        original = Setting("vgi_max_workers", "Maximum worker count", default=4)
         serialized = original.serialize()
         batch = deserialize_record_batch(serialized)
         restored = Setting.deserialize(batch)
 
-        assert restored.name == original.name
         assert restored.type == pa.int64()
-        assert restored.default_value == 4
-
-    def test_bool_default_value(self) -> None:
-        """Test with boolean default value."""
-        original = Setting(
-            name="vgi_debug",
-            description="Enable debug mode",
-            type=pa.bool_(),
-            default_value=False,
-        )
+        assert restored.default == 4
+
+    def test_type_inferred_from_bool_default(self) -> None:
+        """Test type inference from bool default."""
+        original = Setting("vgi_debug", "Enable debug mode", default=False)
         serialized = original.serialize()
         batch = deserialize_record_batch(serialized)
         restored = Setting.deserialize(batch)
 
         assert restored.type == pa.bool_()
-        assert restored.default_value is False
+        assert restored.default is False
+
+    def test_type_inferred_from_float_default(self) -> None:
+        """Test type inference from float default."""
+        original = Setting("vgi_timeout", "Timeout in seconds", default=30.5)
+        serialized = original.serialize()
+        batch = deserialize_record_batch(serialized)
+        restored = Setting.deserialize(batch)
+
+        assert restored.type == pa.float64()
+        assert restored.default == 30.5
+
+    def test_explicit_type_overrides_inference(self) -> None:
+        """Test that explicit type is used even when default is provided."""
+        original = Setting("vgi_port", "Port number", type=pa.int32(), default=8080)
+        serialized = original.serialize()
+        batch = deserialize_record_batch(serialized)
+        restored = Setting.deserialize(batch)
+
+        assert restored.type == pa.int32()
+        assert restored.default == 8080
+
+    def test_missing_type_and_default_raises(self) -> None:
+        """Test that missing type and default raises TypeError."""
+        import pytest
+
+        with pytest.raises(TypeError, match="type must be specified"):
+            Setting("vgi_api_key", "API key")
 
 
 class TestFunctionInfoRequiredSettings:

vgi/catalog/catalog_interface.py

@@ -147,31 +147,68 @@ def deserialize(cls, batch: pa.RecordBatch) -> Self:
         )
 
 
+def _infer_arrow_type(value: Any) -> pa.DataType:
+    """Infer Arrow type from a Python value.
+
+    Args:
+        value: Python value to infer type from.
+
+    Returns:
+        The inferred Arrow DataType.
+
+    Raises:
+        TypeError: If the type cannot be inferred.
+
+    """
+    if isinstance(value, bool):
+        return pa.bool_()
+    if isinstance(value, int):
+        return pa.int64()
+    if isinstance(value, float):
+        return pa.float64()
+    if isinstance(value, str):
+        return pa.string()
+    if isinstance(value, bytes):
+        return pa.binary()
+    raise TypeError(
+        f"Cannot infer Arrow type from {type(value).__name__}. "
+        f"Please specify type explicitly."
+    )
+
+
 @dataclass(frozen=True)
 class Setting:
     """A setting exposed by a VGI worker.
 
     Settings can be configured via DuckDB's SET command and are passed
     to VGI functions via the settings parameter in the Invocation.
 
-    Example:
-        Setting(
-            name="vgi_verbose_mode",
-            description="Enable verbose output with extra columns",
-            type=pa.bool_(),
-            default_value=False,
-        )
+    The type can be inferred from the default value for common Python types
+    (bool, int, float, str, bytes). If no default is provided, type must
+    be specified explicitly.
+
+    Examples:
+        # Type inferred from default
+        Setting("vgi_debug", "Enable debug mode", default=False)
+        Setting("vgi_workers", "Max workers", default=4)
+        Setting("vgi_log_level", "Log level", default="info")
+
+        # Explicit type (required when no default)
+        Setting("vgi_api_key", "API key", type=pa.string())
+
+        # Explicit type with default
+        Setting("vgi_timeout", "Timeout in ms", type=pa.int32(), default=5000)
 
     """
 
     # Setting name (e.g., "vgi_verbose_mode")
     name: str
     # Human-readable description
-    description: str
-    # Arrow data type for this setting
-    type: pa.DataType
-    # Default value (None if required, otherwise the Python value)
-    default_value: Any = None
+    desc: str
+    # Arrow data type (inferred from default if not provided)
+    type: pa.DataType | None = None
+    # Default value (None means the setting is required)
+    default: Any = None
 
     ARROW_SCHEMA: ClassVar[pa.Schema] = pa.schema(
         [
@@ -182,25 +219,38 @@ class Setting:
         ]  # type: ignore[arg-type]
     )
 
+    def __post_init__(self) -> None:
+        """Infer type from default value if not provided."""
+        if self.type is None:
+            if self.default is None:
+                raise TypeError(
+                    f"Setting '{self.name}': type must be specified when no default "
+                    f"is provided. Use type=pa.string() or similar."
+                )
+            inferred_type = _infer_arrow_type(self.default)
+            object.__setattr__(self, "type", inferred_type)
+
     def serialize(self) -> bytes:
         """Serialize to Arrow IPC bytes."""
+        assert self.type is not None  # Guaranteed by __post_init__
+
         # Serialize type as a single-field schema
         type_schema = pa.schema([pa.field("value", self.type)])
         type_bytes = type_schema.serialize().to_pybytes()
 
         # Serialize default value if present
         default_bytes: bytes | None = None
-        if self.default_value is not None:
+        if self.default is not None:
             default_batch = pa.RecordBatch.from_pydict(
-                {"value": [self.default_value]}, schema=type_schema
+                {"value": [self.default]}, schema=type_schema
             )
             default_bytes = vgi.ipc_utils.serialize_record_batch(default_batch)
 
         batch = pa.RecordBatch.from_pylist(
             [
                 {
                     "name": self.name,
-                    "description": self.description,
+                    "description": self.desc,
                     "type": type_bytes,
                     "default_value": default_bytes,
                 }
@@ -222,16 +272,16 @@ def deserialize(cls, batch: pa.RecordBatch) -> Self:
         data_type = type_schema.field("value").type
 
         # Deserialize default value if present
-        default_value: Any = None
+        default: Any = None
         if row["default_value"] is not None:
             default_batch = vgi.ipc_utils.deserialize_record_batch(row["default_value"])
-            default_value = default_batch.column("value")[0].as_py()
+            default = default_batch.column("value")[0].as_py()
 
         return cls(
             name=row["name"],
-            description=row["description"],
+            desc=row["description"],
             type=data_type,
-            default_value=default_value,
+            default=default,
         )
 
 

vgi/examples/worker.py

@@ -16,8 +16,6 @@
     vgi-example-worker
 """
 
-import pyarrow as pa
-
 from vgi.catalog import Setting
 from vgi.examples.scalar import (
     AddNumericColumnsFunction,
@@ -62,12 +60,7 @@ class ExampleWorker(Worker):
     catalog_name = "example"
 
     settings = [
-        Setting(
-            name="vgi_verbose_mode",
-            description="Enable verbose output with extra columns",
-            type=pa.bool_(),
-            default_value=False,
-        ),
+        Setting("vgi_verbose_mode", "Enable verbose output", default=False),
     ]
 
     functions = [