Mutable defaults fixes (#222)

* Mutable defaults validation

Python's mutable default footgun (shared mutable objects across function calls)
was not being caught in Cog runtime, leading to subtle bugs where predictors
with `default=[]` would share the same list instance across predictions.

Implement import-time validation that hard errors on mutable defaults and
suggests proper `default_factory` usage, with comprehensive support for all
collection types in both Python 3.9+ and typing module syntax.

- Detect mutable defaults (`[]`, `{}`, `set()`, custom objects) at import time
- Provide clear, actionable error messages:
- `default=[]` → "Use Input(default_factory=list) instead"
- `default=[1,2,3]` → "Use Input(default_factory=lambda: [1,2,3]) instead"
- Validate mutual exclusion of `default` and `default_factory` parameters

- **Lists**: `list`, `List[T]`, `list[T]` (Python 3.9+)
- **Dicts**: `dict`, `Dict[K,V]`, `dict[K,V]` (Python 3.9+)
- **Sets**: `set`, `Set[T]`, `set[T]` (Python 3.9+)
- **Bare types**: `list`→`List[Any]`, `dict`→`Dict[str,Any]`, `set`→`Set[Any]`

- Use real `dataclass.Field` objects instead of bespoke implementation
- Compatible with Python 3.9+ (`kw_only` parameter handling)
- Full support for `default_factory` execution at runtime

- Go integration tests verify end-to-end runtime behavior
- Python tests validate all collection type combinations
- Smart pytest skipping for intentionally-bad test modules

- `python/coglet/api.py`: Added mutable default validation to `Input()` function
- `python/coglet/adt.py`: Enhanced type system for all collection types, added `PrimitiveType.ANY`
- `python/coglet/schemas.py`: Fixed Secret schema encoding with proper normalization
- `python/coglet/inspector.py`: Enhanced Field object handling in validation/runtime
- `python/cog/coder/`: Added `SetCoder`, enhanced `JsonCoder` for Python 3.13 compatibility

- 10 mutable defaults validation tests (empty/populated collections, custom objects)
- 9 collection type tests (typing vs built-in vs bare syntax)
- Go integration tests for setup failure detection
- Python 3.9, 3.10, 3.11, 3.12, 3.13 compatibility validation

- Fixed `Field` constructor for Python 3.9 (`kw_only` parameter)
- Fixed `issubclass()` and `inspect.getmro()` for generic types in Python 3.13
- Enhanced `pydantic_coder` and `json_coder` for generic type compatibility

Before (silent footgun):
```python
def predict(self, items: List[str] = Input(default=[])) -> str:
    items.append("new")  # Modifies shared list across predictions!
    return str(items)
```

After (clear error + fix):
```python
def predict(self, items: List[str] = Input(default_factory=list)) -> str:
    items.append("new")  # Safe: fresh list each time
    return str(items)
```
Testing

- Python tests: 19/19 collection + validation tests
- Go tests: 3/3 integration tests
- mypy: All type checking passes
- Multi-version: Python 3.9, 3.10, 3.11, 3.12, 3.13 validated

Fixes mutable default footgun while maintaining full backward compatibility
for correctly-written predictors.

* Implement automatic mutable default conversion

Replace error-throwing validation with automatic conversion of mutable defaults
to safe default_factory implementations. This prevents Python's mutable default
footgun while maintaining backward compatibility.

Changes:
- Convert empty collections ([], {}, set()) to built-in constructors (list, dict, set)
- Convert populated collections/objects to lambda factories using copy.deepcopy
- Update all tests to verify auto-conversion instead of error cases
- Add comprehensive E2E test verifying isolation between prediction calls
- Remove pytest skip logic from test files now that conversion works

Author: tempusfrangit

internal/tests/input_defaults_test.go

@@ -0,0 +1,176 @@
+package tests
+
+import (
+	"encoding/json"
+	"io"
+	"net/http"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/replicate/cog-runtime/internal/runner"
+)
+
+func TestInputDefaults(t *testing.T) {
+	t.Parallel()
+	if *legacyCog {
+		t.Skip("Mutable default validation is coglet specific.")
+	}
+
+	t.Run("mutable default auto-converts", func(t *testing.T) {
+		runtimeServer := setupCogRuntime(t, cogRuntimeServerConfig{
+			procedureMode:    false,
+			explicitShutdown: false,
+			uploadURL:        "",
+			module:           "input_bad_mutable_default",
+			predictorClass:   "Predictor",
+		})
+
+		// Wait for setup to complete, expecting it to succeed due to auto-conversion
+		waitForSetupComplete(t, runtimeServer, runner.StatusReady, runner.SetupSucceeded)
+
+		// Verify that the predictor actually works with auto-converted default
+		input := map[string]any{} // Use default
+		req := httpPredictionRequest(t, runtimeServer, runner.PredictionRequest{Input: input})
+
+		resp, err := http.DefaultClient.Do(req)
+		require.NoError(t, err)
+		defer resp.Body.Close()
+		assert.Equal(t, http.StatusOK, resp.StatusCode)
+
+		body, err := io.ReadAll(resp.Body)
+		require.NoError(t, err)
+
+		var prediction testHarnessResponse
+		err = json.Unmarshal(body, &prediction)
+		require.NoError(t, err)
+
+		assert.Equal(t, runner.PredictionSucceeded, prediction.Status)
+		assert.Equal(t, "items: [1, 2, 3]", prediction.Output)
+	})
+
+	t.Run("immutable default succeeds", func(t *testing.T) {
+		t.Parallel()
+
+		runtimeServer := setupCogRuntime(t, cogRuntimeServerConfig{
+			procedureMode:    false,
+			explicitShutdown: false,
+			uploadURL:        "",
+			module:           "input_immutable_default",
+			predictorClass:   "Predictor",
+		})
+
+		// Wait for setup to complete successfully
+		waitForSetupComplete(t, runtimeServer, runner.StatusReady, runner.SetupSucceeded)
+
+		// Verify that the predictor actually works
+		input := map[string]any{} // Use default
+		req := httpPredictionRequest(t, runtimeServer, runner.PredictionRequest{Input: input})
+
+		resp, err := http.DefaultClient.Do(req)
+		require.NoError(t, err)
+		defer resp.Body.Close()
+		assert.Equal(t, http.StatusOK, resp.StatusCode)
+
+		body, err := io.ReadAll(resp.Body)
+		require.NoError(t, err)
+
+		var prediction testHarnessResponse
+		err = json.Unmarshal(body, &prediction)
+		require.NoError(t, err)
+
+		assert.Equal(t, runner.PredictionSucceeded, prediction.Status)
+		assert.Equal(t, "message: hello world", prediction.Output)
+	})
+
+	t.Run("immutable default with overrided value succeeds", func(t *testing.T) {
+		t.Parallel()
+
+		runtimeServer := setupCogRuntime(t, cogRuntimeServerConfig{
+			procedureMode:    false,
+			explicitShutdown: false,
+			uploadURL:        "",
+			module:           "input_immutable_default",
+			predictorClass:   "Predictor",
+		})
+
+		waitForSetupComplete(t, runtimeServer, runner.StatusReady, runner.SetupSucceeded)
+
+		// Test with custom input
+		input := map[string]any{"message": "custom message"}
+		req := httpPredictionRequest(t, runtimeServer, runner.PredictionRequest{Input: input})
+
+		resp, err := http.DefaultClient.Do(req)
+		require.NoError(t, err)
+		defer resp.Body.Close()
+		assert.Equal(t, http.StatusOK, resp.StatusCode)
+
+		body, err := io.ReadAll(resp.Body)
+		require.NoError(t, err)
+
+		var prediction testHarnessResponse
+		err = json.Unmarshal(body, &prediction)
+		require.NoError(t, err)
+
+		assert.Equal(t, runner.PredictionSucceeded, prediction.Status)
+		assert.Equal(t, "message: custom message", prediction.Output)
+	})
+
+	t.Run("mutable default isolation", func(t *testing.T) {
+		t.Parallel()
+
+		runtimeServer := setupCogRuntime(t, cogRuntimeServerConfig{
+			procedureMode:    false,
+			explicitShutdown: false,
+			uploadURL:        "",
+			module:           "input_mutable_isolation",
+			predictorClass:   "Predictor",
+		})
+
+		// Wait for setup to complete successfully
+		waitForSetupComplete(t, runtimeServer, runner.StatusReady, runner.SetupSucceeded)
+
+		// First prediction call - mutates the default list
+		input1 := map[string]any{} // Use default
+		req1 := httpPredictionRequest(t, runtimeServer, runner.PredictionRequest{Input: input1})
+
+		resp1, err := http.DefaultClient.Do(req1)
+		require.NoError(t, err)
+		defer resp1.Body.Close()
+		assert.Equal(t, http.StatusOK, resp1.StatusCode)
+
+		body1, err := io.ReadAll(resp1.Body)
+		require.NoError(t, err)
+
+		var prediction1 testHarnessResponse
+		err = json.Unmarshal(body1, &prediction1)
+		require.NoError(t, err)
+
+		assert.Equal(t, runner.PredictionSucceeded, prediction1.Status)
+		assert.Equal(t, "items: [1, 2, 3, 999]", prediction1.Output)
+
+		// Wait for runner to be ready for next prediction
+		waitForReady(t, runtimeServer)
+
+		// Second prediction call - should get fresh default, not mutated version
+		input2 := map[string]any{} // Use default again
+		req2 := httpPredictionRequest(t, runtimeServer, runner.PredictionRequest{Input: input2})
+
+		resp2, err := http.DefaultClient.Do(req2)
+		require.NoError(t, err)
+		defer resp2.Body.Close()
+
+		body2, err := io.ReadAll(resp2.Body)
+		require.NoError(t, err)
+		assert.Equal(t, http.StatusOK, resp2.StatusCode)
+
+		var prediction2 testHarnessResponse
+		err = json.Unmarshal(body2, &prediction2)
+		require.NoError(t, err)
+
+		assert.Equal(t, runner.PredictionSucceeded, prediction2.Status)
+		// This should be the original default, not the mutated version
+		assert.Equal(t, "items: [1, 2, 3, 999]", prediction2.Output)
+	})
+}

python/cog/coder/json_coder.py

@@ -1,18 +1,24 @@
 import typing
-from typing import Any, Optional, Type
+from typing import Any, Dict, Optional, Type
 
 from coglet import api
 
 
 class JsonCoder(api.Coder):
     @staticmethod
     def factory(cls: Type) -> Optional[api.Coder]:
-        if (typing.get_origin(cls) is dict and typing.get_args(cls)[0] is str) or (
-            issubclass(cls, dict)
-        ):
+        origin = typing.get_origin(cls)
+        if (origin in (dict, Dict)) and typing.get_args(cls)[0] is str:
             return JsonCoder()
-        else:
-            return None
+
+        try:
+            if issubclass(cls, dict):
+                return JsonCoder()
+        except TypeError:
+            # Generic types like Set[Any] can't be used with issubclass in newer Python
+            pass
+
+        return None
 
     def encode(self, x: Any) -> dict[str, Any]:
         return x

python/cog/coder/pydantic_coder.py

@@ -44,10 +44,15 @@ def __get_pydantic_core_schema__(
 class BaseModelCoder(api.Coder):
     @staticmethod
     def factory(cls: Type):
-        if cls is not BaseModel and any(c is BaseModel for c in inspect.getmro(cls)):
-            return BaseModelCoder(cls)
-        else:
-            return None
+        try:
+            if cls is not BaseModel and any(
+                c is BaseModel for c in inspect.getmro(cls)
+            ):
+                return BaseModelCoder(cls)
+        except (AttributeError, TypeError):
+            # Generic types like Set[Any] don't have __mro__ in newer Python versions
+            pass
+        return None
 
     def __init__(self, cls: Type[BaseModel]):
         self.cls = cls

python/cog/coder/set_coder.py

@@ -0,0 +1,20 @@
+import typing
+from typing import Any, Optional, Set, Type
+
+from coglet import api
+
+
+class SetCoder(api.Coder):
+    @staticmethod
+    def factory(cls: Type) -> Optional[api.Coder]:
+        origin = typing.get_origin(cls)
+        if origin in (set, Set):
+            return SetCoder()
+        else:
+            return None
+
+    def encode(self, x: Any) -> dict[str, Any]:
+        return {'items': list(x)}
+
+    def decode(self, x: dict[str, Any]) -> Any:
+        return set(x['items'])

python/coglet/adt.py

@@ -4,9 +4,9 @@
 import typing
 from dataclasses import dataclass
 from enum import Enum, auto
-from typing import Any, Callable, Dict, List, Optional, Union
+from typing import Any, Callable, Dict, List, Optional, Set, Union
 
-from cog.coder import dataclass_coder
+from cog.coder import dataclass_coder, json_coder, set_coder
 from coglet import api
 from coglet.util import type_name
 
@@ -29,6 +29,7 @@ class PrimitiveType(Enum):
     STRING = auto()
     PATH = auto()
     SECRET = auto()
+    ANY = auto()
     CUSTOM = auto()
 
     @staticmethod
@@ -40,6 +41,7 @@ def _python_type() -> dict:
             PrimitiveType.STRING: str,
             PrimitiveType.PATH: api.Path,
             PrimitiveType.SECRET: api.Secret,
+            PrimitiveType.ANY: Any,
             PrimitiveType.CUSTOM: Any,
         }
 
@@ -52,6 +54,7 @@ def _json_type() -> dict:
             PrimitiveType.STRING: 'string',
             PrimitiveType.PATH: 'string',
             PrimitiveType.SECRET: 'string',
+            PrimitiveType.ANY: 'object',
             PrimitiveType.CUSTOM: 'object',
         }
 
@@ -64,6 +67,7 @@ def _adt_type() -> dict:
             str: PrimitiveType.STRING,
             api.Path: PrimitiveType.PATH,
             api.Secret: PrimitiveType.SECRET,
+            Any: PrimitiveType.ANY,
         }
 
     @staticmethod
@@ -86,6 +90,9 @@ def normalize(self, value: Any) -> Any:
         if self is PrimitiveType.CUSTOM:
             # Custom type, leave as is
             return value
+        elif self is PrimitiveType.ANY:
+            # Any type, accept any value as-is
+            return value
         elif self in {self.PATH, self.SECRET}:
             # String-ly types, only upcast
             return value if tpe is pt else pt(value)
@@ -118,6 +125,9 @@ def json_encode(self, value: Any) -> Any:
         elif self in {self.PATH, self.SECRET}:
             # Leave these as is and let the file runner handle special encoding
             return value
+        elif self is self.ANY:
+            # Any type, return as-is
+            return value
         else:
             return value
 
@@ -136,15 +146,35 @@ class FieldType:
 
     @staticmethod
     def from_type(tpe: type):
-        if typing.get_origin(tpe) is list:
+        origin = typing.get_origin(tpe)
+
+        # Handle bare collection types first
+        if tpe is list:
+            # Bare list -> List[Any]
+            tpe = List[Any]
+            origin = typing.get_origin(tpe)
+        elif tpe is dict:
+            # Bare dict -> Dict[str, Any]
+            tpe = Dict[str, Any]
+            origin = typing.get_origin(tpe)
+        elif tpe is set:
+            # Bare set -> Set[Any]
+            tpe = Set[Any]
+            origin = typing.get_origin(tpe)
+
+        if origin in (list, List):
             t_args = typing.get_args(tpe)
-            assert len(t_args) == 1, 'List must have one type argument'
-            elem_t = t_args[0]
-            # Fail fast to avoid the cryptic "unsupported Cog type" error later with elem_t
-            nested_t = typing.get_origin(elem_t)
-            assert nested_t is None, (
-                f'List cannot have nested type {type_name(nested_t)}'
-            )
+            if t_args:
+                assert len(t_args) == 1, 'List must have one type argument'
+                elem_t = t_args[0]
+                # Fail fast to avoid the cryptic "unsupported Cog type" error later with elem_t
+                nested_t = typing.get_origin(elem_t)
+                assert nested_t is None, (
+                    f'List cannot have nested type {type_name(nested_t)}'
+                )
+            else:
+                # Bare list type without type arguments, treat as List[Any]
+                elem_t = Any
             repetition = Repetition.REPEATED
         elif _is_union(tpe):
             t_args = typing.get_args(tpe)
@@ -165,6 +195,8 @@ def from_type(tpe: type):
         coder = None
         if cog_t is PrimitiveType.CUSTOM:
             api.Coder.register(dataclass_coder.DataclassCoder)
+            api.Coder.register(json_coder.JsonCoder)
+            api.Coder.register(set_coder.SetCoder)
             coder = api.Coder.lookup(elem_t)
             assert coder is not None, f'unsupported Cog type {type_name(elem_t)}'
 

python/coglet/adt.pyi

@@ -14,6 +14,7 @@ class PrimitiveType(Enum):
     STRING = ...
     PATH = ...
     SECRET = ...
+    ANY = ...
     CUSTOM = ...
     @staticmethod
     def from_type(tpe: type) -> Any: