More fixes:

- Rename is_reconstructible to can_reconstruct
- Correct ownership of _can_reconstruct
- Required DataConverter for internal classes

Author: andystaples

CHANGELOG.md

@@ -46,7 +46,7 @@ ADDED
   `DataConverter` as a second parameter (`from_json(cls, value, converter)`),
   letting it reconstruct nested typed values via `converter.coerce(...)` /
   `converter.deserialize(...)`. The single-argument form remains supported.
-- `DataConverter` now exposes an overridable `is_reconstructable(target_type)`
+- `DataConverter` now exposes an overridable `can_reconstruct(target_type)`
   method that controls which annotated input/return types the SDK reconstructs
   on the inbound path. A custom converter can override it to recognize its own
   types (for example `pydantic.BaseModel` subclasses), so that orchestrator /

durabletask/internal/type_discovery.py

@@ -88,7 +88,7 @@ def _input_annotation(fn: Callable[..., Any], position: int,
 
     if annotation is inspect.Parameter.empty or annotation is Any:
         return None
-    return annotation if _resolve_converter(converter).is_reconstructable(annotation) else None
+    return annotation if _resolve_converter(converter).can_reconstruct(annotation) else None
 
 
 def orchestrator_input_type(fn: Callable[..., Any],
@@ -129,7 +129,7 @@ def activity_output_type(fn: Any, converter: DataConverter | None = None) -> Any
 
     if annotation is inspect.Signature.empty or annotation is Any or annotation is None:
         return None
-    return annotation if _resolve_converter(converter).is_reconstructable(annotation) else None
+    return annotation if _resolve_converter(converter).can_reconstruct(annotation) else None
 
 
 def entity_input_type(fn: Any, operation: str,

durabletask/serialization.py

@@ -101,29 +101,26 @@ def coerce(self, value: Any, target_type: type | None = None) -> Any:
         """
         ...
 
-    def is_reconstructable(self, target_type: Any) -> bool:
+    def can_reconstruct(self, target_type: Any) -> bool:
         """Return True if this converter can rebuild ``target_type`` from a payload.
 
         Inbound type-discovery calls this to decide whether a function's
         annotated *input* type (or an activity's *return* annotation) should be
         passed to :meth:`deserialize` / :meth:`coerce`. When it returns ``False``
         the SDK passes the raw deserialized payload through unchanged -- this
-        gate is what stops the SDK from invoking an arbitrary constructor on a
-        builtin or otherwise unrecognized annotation.
-
-        The default recognizes the types the built-in codec can rebuild --
-        dataclasses and ``from_json()``-capable types, plus ``Optional`` /
-        ``list`` / ``Sequence`` hints wrapping them -- and excludes builtins
-        (``int``, ``str``, ``dict``, ...) and unknown annotations.
-
-        Override this to teach the SDK about a custom converter's own types (for
+        gate is what stops the SDK from invoking reconstruction on a type the
+        converter does not actually handle.
+
+        The base implementation is conservative and returns ``False``: a
+        converter makes no reconstruction claims unless it opts in.
+        :class:`JsonDataConverter` overrides this to recognize the types its
+        codec can rebuild (dataclasses and ``from_json()``-capable types, plus
+        ``Optional`` / ``list`` / ``Sequence`` hints wrapping them). Override
+        this in a custom converter to teach the SDK about its own types (for
         example ``pydantic.BaseModel`` subclasses) so that inputs annotated with
-        them are reconstructed instead of arriving as raw JSON. The default
-        implementation recurses through ``self.is_reconstructable``, so an
-        override is also consulted for the element types of ``Optional`` /
-        ``list`` hints (e.g. ``list[MyModel]``).
+        them are reconstructed instead of arriving as raw JSON.
         """
-        return _is_reconstructable(self, target_type)
+        return False
 
 
 class JsonDataConverter(DataConverter):
@@ -187,6 +184,9 @@ def coerce(self, value: Any, target_type: type | None = None) -> Any:
             self._log_coercion_fallback(target_type, e)
             return value
 
+    def can_reconstruct(self, target_type: Any) -> bool:
+        return _can_reconstruct(self, target_type)
+
     @staticmethod
     def _log_coercion_fallback(target_type: type, error: Exception) -> None:
         logger.debug(
@@ -211,24 +211,25 @@ def _log_coercion_fallback(target_type: type, error: Exception) -> None:
 # ---------------------------------------------------------------------------
 
 
-def _is_reconstructable(converter: DataConverter, target_type: Any) -> bool:
-    """Default :meth:`DataConverter.is_reconstructable` policy.
+def _can_reconstruct(converter: DataConverter, target_type: Any) -> bool:
+    """:class:`JsonDataConverter`'s reconstruction policy.
 
     Recognizes dataclasses and ``from_json()``-capable types, plus ``Optional``
     / ``list`` / ``Sequence`` hints wrapping them; builtins and unknown
-    annotations are excluded. Recurses through ``converter.is_reconstructable``
-    (not itself) so a subclass override participates in the element-type checks
-    of ``Optional`` / ``list`` hints.
+    annotations are excluded. Recurses through ``converter.can_reconstruct``
+    (not itself) so a :class:`JsonDataConverter` subclass that overrides
+    ``can_reconstruct`` still participates in the element-type checks of
+    ``Optional`` / ``list`` hints.
     """
     origin = typing.get_origin(target_type)
     if origin is not None:
         args = typing.get_args(target_type)
         if origin is typing.Union or origin is types.UnionType:
             return any(
-                converter.is_reconstructable(a) for a in args if a is not type(None)
+                converter.can_reconstruct(a) for a in args if a is not type(None)
             )
         if origin in (list, Sequence):
-            return any(converter.is_reconstructable(a) for a in args)
+            return any(converter.can_reconstruct(a) for a in args)
         return False
     if not isinstance(target_type, type):
         return False

durabletask/worker.py

@@ -1420,8 +1420,8 @@ class _RuntimeOrchestrationContext(task.OrchestrationContext):
     def __init__(self,
                  instance_id: str,
                  registry: _Registry,
+                 data_converter: DataConverter,
                  maximum_timer_interval: timedelta | None = DEFAULT_MAXIMUM_TIMER_INTERVAL,
-                 data_converter: DataConverter | None = None,
                  ):
         self._generator = None
         self._is_replaying = True
@@ -1450,7 +1450,7 @@ def __init__(self,
         self._parent_trace_context: pb.TraceContext | None = None
         self._orchestration_trace_context: pb.TraceContext | None = None
         self._maximum_timer_interval = maximum_timer_interval
-        self._data_converter = data_converter if data_converter is not None else JsonDataConverter()
+        self._data_converter = data_converter
 
     def run(self, generator: Generator[task.Task[Any], Any, Any]) -> None:
         self._generator = generator
@@ -2050,13 +2050,13 @@ def __init__(
         self,
         registry: _Registry,
         logger: logging.Logger,
+        data_converter: DataConverter,
         persisted_orch_span_id: str | None = None,
         maximum_timer_interval: timedelta | None = DEFAULT_MAXIMUM_TIMER_INTERVAL,
-        data_converter: DataConverter | None = None,
     ):
         self._registry = registry
         self._logger = logger
-        self._data_converter = data_converter if data_converter is not None else JsonDataConverter()
+        self._data_converter = data_converter
         self._maximum_timer_interval = maximum_timer_interval
         self._is_suspended = False
         self._suspended_events: list[pb.HistoryEvent] = []
@@ -2834,10 +2834,10 @@ def compare_versions(self, source_version: str | None, default_version: str | No
 
 class _ActivityExecutor:
     def __init__(self, registry: _Registry, logger: logging.Logger,
-                 data_converter: DataConverter | None = None):
+                 data_converter: DataConverter):
         self._registry = registry
         self._logger = logger
-        self._data_converter = data_converter if data_converter is not None else JsonDataConverter()
+        self._data_converter = data_converter
 
     def execute(
             self,
@@ -2873,10 +2873,10 @@ def execute(
 
 class _EntityExecutor:
     def __init__(self, registry: _Registry, logger: logging.Logger,
-                 data_converter: DataConverter | None = None):
+                 data_converter: DataConverter):
         self._registry = registry
         self._logger = logger
-        self._data_converter = data_converter if data_converter is not None else JsonDataConverter()
+        self._data_converter = data_converter
         self._entity_method_cache: dict[tuple[type, str], bool] = {}
 
     def execute(

examples/custom_data_converter/README.md

@@ -51,28 +51,29 @@ everything else** to the default `JsonDataConverter`. This "handle my types,
 delegate the rest" shape is the recommended pattern for a real converter — it
 costs nothing for non-pydantic payloads.
 
-## Inbound inputs: `is_reconstructable`
+## Inbound inputs: `can_reconstruct`
 
 There is one extra detail for reconstructing **inbound** orchestrator/activity
 *inputs*. Before the SDK hands an input to your converter, it asks the converter
 whether the function's annotated input type is something it can rebuild, via
-`DataConverter.is_reconstructable(target_type)`. The default implementation
+`DataConverter.can_reconstruct(target_type)`. The default implementation
 recognizes dataclasses and `from_json()`-capable types (and `Optional` / `list`
 wrappers) — it does **not** know about pydantic models, so without an override an
 input annotated `order: Order` would arrive as a plain `dict`.
 
-The converter overrides `is_reconstructable` to also recognize
-`pydantic.BaseModel` subclasses:
+The converter overrides `can_reconstruct` to also recognize
+`pydantic.BaseModel` subclasses, deferring everything else to the same
+`JsonDataConverter` fallback it uses for serialization:
 
 ```python
-def is_reconstructable(self, target_type):
+def can_reconstruct(self, target_type):
     if _is_model_type(target_type):
         return True
-    return super().is_reconstructable(target_type)  # keep the defaults
+    return self._fallback.can_reconstruct(target_type)  # dataclasses, from_json, ...
 ```
 
-Because the base implementation recurses through `self.is_reconstructable`,
-`list[OrderItem]` and `Optional[Order]` are recognized too. Outbound values,
+The base `DataConverter.can_reconstruct` is conservative — it returns `False`,
+so a converter only claims the types it actually rebuilds. Outbound values,
 `return_type=` arguments, and typed client accessors (`state.get_output(Receipt)`)
 don't depend on this hook — they pass the type to the converter directly.
 

examples/custom_data_converter/src/converter.py

@@ -26,7 +26,7 @@
 
 It may also override one hook:
 
-* ``is_reconstructable(t)``  -- tells the SDK's inbound type-discovery that an
+* ``can_reconstruct(t)``  -- tells the SDK's inbound type-discovery that an
   *input* annotated with type ``t`` should be handed to ``deserialize`` /
   ``coerce`` (rather than passed through as raw JSON). The default recognizes
   dataclasses and ``from_json()``-capable types; override it to add your own
@@ -92,15 +92,15 @@ def coerce(self, value: Any, target_type: type | None = None) -> Any:
             return target_type.model_validate(value)  # type: ignore[union-attr]
         return self._fallback.coerce(value, target_type)
 
-    def is_reconstructable(self, target_type: Any) -> bool:
+    def can_reconstruct(self, target_type: Any) -> bool:
         # Teach the SDK's inbound type-discovery that pydantic models are
         # reconstructable, so an orchestrator/activity input annotated with a
         # model type is rebuilt (and validated) by this converter instead of
-        # arriving as a plain ``dict``. Delegating to ``super()`` keeps the
-        # default behavior (dataclasses, ``from_json`` types, ``Optional`` /
-        # ``list`` wrappers, builtins excluded) for everything else; because the
-        # base recurses through ``self.is_reconstructable``, ``list[OrderItem]``
-        # and ``Optional[Order]`` are recognized too.
+        # arriving as a plain ``dict``. For everything else, defer to the same
+        # ``JsonDataConverter`` fallback this converter uses for serialization,
+        # so its reconstruction claims match what it actually handles
+        # (dataclasses, ``from_json`` types, ``Optional`` / ``list`` wrappers;
+        # builtins excluded).
         if _is_model_type(target_type):
             return True
-        return super().is_reconstructable(target_type)
+        return self._fallback.can_reconstruct(target_type)

examples/custom_data_converter/src/workflows.py

@@ -27,7 +27,7 @@
 # ---------------------------------------------------------------------------
 # These are plain ``pydantic.BaseModel`` subclasses -- no special hooks. The
 # custom ``PydanticDataConverter`` both serializes them and (because it
-# overrides ``is_reconstructable``) teaches the SDK to reconstruct them for
+# overrides ``can_reconstruct``) teaches the SDK to reconstruct them for
 # inbound orchestrator/activity inputs.
 
 

tests/durabletask/test_activity_executor.py

@@ -6,6 +6,7 @@
 from typing import Any
 
 from durabletask import task, worker
+from durabletask.serialization import JsonDataConverter
 
 logging.basicConfig(
     format='%(asctime)s.%(msecs)03d %(name)s %(levelname)s: %(message)s',
@@ -53,5 +54,5 @@ def test_activity(ctx: task.ActivityContext, _):
 def _get_activity_executor(fn: task.Activity) -> tuple[worker._ActivityExecutor, str]:
     registry = worker._Registry()
     name = registry.add_activity(fn)
-    executor = worker._ActivityExecutor(registry, TEST_LOGGER)
+    executor = worker._ActivityExecutor(registry, TEST_LOGGER, JsonDataConverter())
     return executor, name

tests/durabletask/test_entity_executor.py

@@ -7,6 +7,7 @@
 
 from durabletask import entities
 from durabletask.internal.entity_state_shim import StateShim
+from durabletask.serialization import JsonDataConverter
 from durabletask.worker import _EntityExecutor, _Registry
 
 
@@ -15,7 +16,7 @@ def _make_executor(*entity_args) -> _EntityExecutor:
     registry = _Registry()
     for entity in entity_args:
         registry.add_entity(entity)
-    return _EntityExecutor(registry, logging.getLogger("test"))
+    return _EntityExecutor(registry, logging.getLogger("test"), JsonDataConverter())
 
 
 def _execute(executor, entity_name, operation, encoded_input=None):