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: