added default encodable instance for Callable

Author: kiranandcode

effectful/handlers/llm/encoding.py

@@ -1,9 +1,13 @@
+import ast
 import base64
+import inspect
 import io
+import textwrap
 import typing
 from abc import ABC, abstractmethod
-from collections.abc import Callable, Mapping, Sequence
+from collections.abc import Callable, Mapping, MutableMapping, Sequence
 from dataclasses import dataclass
+from types import CodeType
 from typing import Any
 
 import pydantic
@@ -13,6 +17,7 @@
 )
 from PIL import Image
 
+import effectful.handlers.llm.evaluation as evaluation
 from effectful.ops.semantics import _simple_type
 from effectful.ops.syntax import _CustomSingleDispatchCallable
 from effectful.ops.types import Operation, Term
@@ -253,6 +258,60 @@ def deserialize(self, serialized_value: str) -> typing.Any:
         return typing.cast(typing.Any, adapter.validate_json(serialized_value))
 
 
+@dataclass
+class CallableEncodable(Encodable[Callable, str]):
+    base: type[Callable]
+    enc: type[str]
+    ctx: Mapping[str, Any]
+
+    def encode(self, t: Callable) -> typing.Any:
+        # (https://github.com/python/mypy/issues/14928)
+        if not isinstance(t, Callable):  # type: ignore
+            raise TypeError(f"Expected callable, got {type(t)}")
+        try:
+            source = inspect.getsource(t)
+        except (OSError, TypeError):
+            source = None
+
+        if not source:
+            # create source stub using signature and docstring of callable (useful for builtins etc.)
+            pass
+
+        assert source, "Could not retrieve source code or docstring for function"
+
+        return textwrap.dedent(source)
+
+    def decode(self, encoded_value: str) -> Callable:
+        filename = f"<synthesis:{id(self)}>"
+
+        # https://docs.python.org/3/library/functions.html#exec
+        g: MutableMapping[str, Any] = {}
+        g.update(self.ctx or {})
+
+        before_keys = set(g.keys())
+
+        module: ast.AST = evaluation.parse(encoded_value, 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
+
+
 @Encodable.define.register(object)
 def _encodable_object[T, U](
     ty: type[T], ctx: Mapping[str, Any] | None
@@ -355,3 +414,8 @@ def _encodable_list[T, U](
     return typing.cast(
         Encodable[T, U], ListEncodable(ty, encoded_ty, ctx, has_image, element_encoder)
     )
+
+
+@Encodable.define.register(Callable)
+def _encodable_callable(*args, **kwargs):
+    raise NotImplementedError

effectful/handlers/llm/evaluation.py

@@ -0,0 +1,83 @@
+import ast
+import builtins
+import linecache
+import typing
+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) -> CodeType:
+        return builtins.compile(typing.cast(typing.Any, module), filename, "exec")
+
+    @implements(exec)
+    def exec(
+        self,
+        bytecode: CodeType,
+        env: dict[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 Encodable
+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 = Encodable.define(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 = Encodable.define(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 = Encodable.define(Callable, {"factor": 3})
+        source = """def multiply(x):
+    return x * factor"""
+
+        with handler(UnsafeEvalProvider()):
+            decoded = encodable.decode(source)
+        assert callable(decoded)
+        assert decoded(4) == 12
+
+    def test_encode_non_callable_raises(self):
+        from collections.abc import Callable
+
+        encodable = Encodable.define(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 = Encodable.define(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 = Encodable.define(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 = Encodable.define(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 = Encodable.define(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 = Encodable.define(Callable, {})
+        with handler(UnsafeEvalProvider()):
+            encoded = encodable.encode(greet)
+            decoded = encodable.decode(encoded)
+
+        assert callable(decoded)
+        assert decoded("Alice") == "Hello, Alice!"
+        assert decoded.__name__ == "greet"