added default encodable instance for Callable

Author: kiranandcode

effectful/handlers/llm/encoding.py

@@ -1,8 +1,14 @@
+import ast
 import base64
+import inspect
 import io
+import textwrap
+import threading
+import time
 import typing
 from abc import ABC, abstractmethod
-from collections.abc import Callable, Mapping
+from collections.abc import Callable, Mapping, MutableMapping
+from types import CodeType
 from typing import Any
 
 import pydantic
@@ -12,7 +18,10 @@
 )
 from PIL import Image
 
-from effectful.ops.syntax import _CustomSingleDispatchCallable
+import effectful.handlers.llm.evaluation as evaluation
+from effectful.ops.syntax import (
+    _CustomSingleDispatchCallable,
+)
 from effectful.ops.types import Operation, Term
 
 
@@ -44,7 +53,7 @@ def decode(cls, vl: U, env: Mapping[str, Any] | None = None) -> T:
 
     @classmethod
     def encoding_instructions(cls) -> str | None:
-        """Optional instructions to be prefixed onto synthesis prompts to tune the encoding of the result."""
+        """Optional instructions to be prefixed onto prompts to tune the encoding of the result."""
         return None
 
     @classmethod
@@ -262,3 +271,53 @@ def serialize(cls, value: typing.Any) -> list[OpenAIMessageContentListBlock]:
                 return super().serialize(value)
 
     return typing.cast(Encodable[T], ListEncodable())
+
+
+@type_to_encodable_type.register(Callable)
+class CallableEncodable(EncodableAs[Callable, str]):
+    t: type[typing.Any] = str
+
+    @classmethod
+    def encode[T](cls, t: T, env: Mapping[str, Any] | None = None) -> typing.Any:
+        if not callable(t):
+            raise TypeError(f"Expected callable, got {type(t)}")
+        try:
+            source = inspect.getsource(t)
+        except (OSError, TypeError):
+            source = None
+
+        if not source:
+            raise RuntimeError(f"Source code of callable {t} not found")
+
+        return textwrap.dedent(source)
+
+    @classmethod
+    def decode(cls, t: str, env: Mapping[str, Any] | None = None) -> Callable:
+        filename = f"<{cls.__name__}.decode:{int(time.time() * 1_000_000)}:{threading.get_ident()}>"
+
+        # https://docs.python.org/3/library/functions.html#exec
+        g: MutableMapping[str, Any] = {}
+        g.update(env or {})
+
+        before_keys = set(g.keys())
+
+        module: ast.AST = evaluation.parse(t, filename)
+        bytecode: CodeType = evaluation.compile(module, filename)
+        evaluation.exec(bytecode, g)
+
+        # Otherwise: find newly-created callables (in insertion order).
+        new_callables = [
+            v for k, v in g.items() if k not in before_keys and callable(v)
+        ]
+        if not new_callables or len(new_callables) > 1:
+            raise ValueError(
+                "decode() required source code to define exactly one callable."
+            )
+
+        return new_callables[0]
+
+    @Operation.define
+    @classmethod
+    def encoding_instructions(cls) -> str | None:
+        """Instructions to be prefixed onto synthesis prompts to tune the encoding of the result."""
+        return None

effectful/handlers/llm/evaluation.py

@@ -0,0 +1,82 @@
+import ast
+import builtins
+import linecache
+from collections.abc import MutableMapping
+from types import CodeType
+from typing import Any
+
+from effectful.ops.syntax import ObjectInterpretation, defop, implements
+
+
+@defop
+def parse(source: str, filename: str) -> ast.AST:
+    """
+    Parse source text into an AST.
+
+    source: The Python source code to parse.
+    filename: The filename recorded in the resulting AST for tracebacks and tooling.
+
+    Returns the parsed AST.
+    """
+    raise TypeError("An eval provider must be installed in order to parse code.")
+
+
+@defop
+def compile(module: ast.AST, filename: str) -> CodeType:
+    """
+    Compile an AST into a Python code object.
+
+    module: The AST to compile (typically produced by parse()).
+    filename: The filename recorded in the resulting code object (CodeType.co_filename), used in tracebacks and by inspect.getsource().
+
+    Returns the compiled code object.
+    """
+    raise TypeError("An eval provider must be installed in order to compile code.")
+
+
+@defop
+def exec(
+    bytecode: CodeType,
+    env: MutableMapping[str, Any],
+) -> None:
+    """
+    Execute a compiled code object.
+
+    bytecode: A code object to execute (typically produced by compile()).
+    env: The namespace mapping used during execution.
+    """
+    raise TypeError("An eval provider must be installed in order to execute code.")
+
+
+class UnsafeEvalProvider(ObjectInterpretation):
+    """UNSAFE provider that handles parse, comple and exec operations
+    by shelling out to python *without* any further checks. Only use for testing."""
+
+    @implements(parse)
+    def parse(self, source: str, filename: str) -> ast.AST:
+        # Cache source under `filename` so inspect.getsource() can retrieve it later.
+        # inspect uses f.__code__.co_filename -> linecache.getlines(filename)
+        linecache.cache[filename] = (
+            len(source),
+            None,
+            source.splitlines(True),
+            filename,
+        )
+
+        return ast.parse(source, filename=filename, mode="exec")
+
+    @implements(compile)
+    def compile(self, module: ast.AST, filename: str, *rags) -> CodeType:
+        return builtins.compile(module, filename, "exec")
+
+    @implements(exec)
+    def exec(
+        self,
+        bytecode: CodeType,
+        env: MutableMapping[str, Any],
+    ) -> None:
+        # Ensure builtins exist in the execution environment.
+        env.setdefault("__builtins__", __builtins__)
+
+        # Execute module-style so top-level defs land in `env`.
+        builtins.exec(bytecode, env, env)

tests/test_handlers_llm_encoding.py

@@ -6,6 +6,8 @@
 from PIL import Image
 
 from effectful.handlers.llm.encoding import type_to_encodable_type
+from effectful.handlers.llm.evaluation import UnsafeEvalProvider
+from effectful.ops.semantics import handler
 from effectful.ops.types import Operation, Term
 
 
@@ -718,3 +720,125 @@ class Person(pydantic.BaseModel):
     assert decoded_from_model == person
     assert isinstance(decoded_from_model, Person)
     assert isinstance(decoded_from_model.address, Address)
+
+
+class TestCallableEncodable:
+    """Tests for CallableEncodable - encoding/decoding callables as source code."""
+
+    def test_encode_decode_function(self):
+        from collections.abc import Callable
+
+        def add(a: int, b: int) -> int:
+            return a + b
+
+        encodable = type_to_encodable_type(Callable)
+        encoded = encodable.encode(add, {})
+        assert isinstance(encoded, str)
+        assert "def add" in encoded
+        assert "return a + b" in encoded
+
+        with handler(UnsafeEvalProvider()):
+            decoded = encodable.decode(encoded, {})
+        assert callable(decoded)
+        assert decoded(2, 3) == 5
+        assert decoded.__name__ == "add"
+
+    def test_decode_lambda(self):
+        from collections.abc import Callable
+
+        # Lambdas should work if defined in a way that inspect.getsource can find them
+        # Note: lambdas defined inline may not always have retrievable source
+        encodable = type_to_encodable_type(Callable)
+
+        # Test decoding a lambda from source string
+        lambda_source = "f = lambda x: x * 2"
+        with handler(UnsafeEvalProvider()):
+            decoded = encodable.decode(lambda_source, {})
+        assert callable(decoded)
+        assert decoded(5) == 10
+
+    def test_decode_with_env(self):
+        from collections.abc import Callable
+
+        # Test decoding a function that uses env variables
+        encodable = type_to_encodable_type(Callable)
+        source = """def multiply(x):
+    return x * factor"""
+
+        with handler(UnsafeEvalProvider()):
+            decoded = encodable.decode(source, {"factor": 3})
+        assert callable(decoded)
+        assert decoded(4) == 12
+
+    def test_encode_non_callable_raises(self):
+        from collections.abc import Callable
+
+        encodable = type_to_encodable_type(Callable)
+        with pytest.raises(TypeError, match="Expected callable"):
+            encodable.encode("not a callable", {})
+
+    def test_encode_builtin_raises(self):
+        from collections.abc import Callable
+
+        encodable = type_to_encodable_type(Callable)
+        # Built-in functions don't have source code
+        with pytest.raises(RuntimeError, match="Source code of callable .* not found"):
+            with handler(UnsafeEvalProvider()):
+                encodable.encode(len, {})
+
+    def test_decode_no_callable_raises(self):
+        from collections.abc import Callable
+
+        encodable = type_to_encodable_type(Callable)
+        # Source code that defines no callable
+        source = "x = 42"
+        with pytest.raises(ValueError, match="exactly one callable"):
+            with handler(UnsafeEvalProvider()):
+                encodable.decode(source, {})
+
+    def test_decode_multiple_callables_raises(self):
+        from collections.abc import Callable
+
+        encodable = type_to_encodable_type(Callable)
+        # Source code that defines multiple callables
+        source = """def foo():
+    return 1
+
+def bar():
+    return 2"""
+        with pytest.raises(ValueError, match="exactly one callable"):
+            with handler(UnsafeEvalProvider()):
+                encodable.decode(source, {})
+
+    def test_decode_class(self):
+        from collections.abc import Callable
+
+        encodable = type_to_encodable_type(Callable)
+        # Classes are callable, decode should work with class definitions
+        source = """class Greeter:
+    def __init__(self, name):
+        self.name = name
+
+    def greet(self):
+        return f"Hello, {self.name}!\""""
+
+        with handler(UnsafeEvalProvider()):
+            decoded = encodable.decode(source, {})
+        assert callable(decoded)
+        instance = decoded("World")
+        assert instance.greet() == "Hello, World!"
+
+    def test_roundtrip(self):
+        from collections.abc import Callable
+
+        def greet(name: str) -> str:
+            return f"Hello, {name}!"
+
+        encodable = type_to_encodable_type(Callable)
+        with handler(UnsafeEvalProvider()):
+            encoded = encodable.encode(greet, {})
+            decoded = encodable.decode(encoded, {})
+
+        assert callable(decoded)
+        assert decoded("Alice") == "Hello, Alice!"
+        assert decoded.__name__ == "greet"