fixed imports and tests

Author: kiranandcode

tests/test_handlers_llm.py

@@ -1,10 +1,7 @@
 from collections.abc import Callable
 from typing import Annotated
 
-import pytest
-
 from effectful.handlers.llm import Template
-from effectful.handlers.llm.synthesis import ProgramSynthesis
 from effectful.handlers.llm.template import IsRecursive
 from effectful.ops.semantics import NotHandled, handler
 from effectful.ops.syntax import ObjectInterpretation, implements
@@ -119,22 +116,6 @@ def test_primes_decode_int():
         assert isinstance(result, int)
 
 
-@pytest.mark.xfail(reason="Synthesis handler not yet implemented")
-def test_count_char_with_program_synthesis():
-    """Test the count_char template with program synthesis."""
-    mock_code = """<code>
-def count_occurrences(s):
-    return s.count('a')
-</code>"""
-    mock_provider = SingleResponseLLMProvider(mock_code)
-
-    with handler(mock_provider), handler(ProgramSynthesis()):
-        count_a = count_char("a")
-        assert callable(count_a)
-        assert count_a("banana") == 3
-        assert count_a("cherry") == 0
-
-
 class FailingThenSucceedingProvider[T](ObjectInterpretation):
     """Mock provider that fails a specified number of times before succeeding."""
 

tests/test_handlers_llm_provider.py

@@ -5,6 +5,7 @@
 """
 
 import functools
+import inspect
 import json
 import os
 from collections.abc import Callable
@@ -25,8 +26,8 @@
     call_assistant,
     completion,
 )
+from effectful.handlers.llm.encoding import Encodable, SynthesizedFunction
 from effectful.handlers.llm.evaluation import UnsafeEvalProvider
-from effectful.handlers.llm.synthesis import ProgramSynthesis, SynthesisError
 from effectful.ops.semantics import fwd, handler
 from effectful.ops.syntax import ObjectInterpretation, implements
 from effectful.ops.types import NotHandled
@@ -241,29 +242,6 @@ def test_with_config_params(self, request):
             assert isinstance(result, str)
 
 
-@pytest.mark.xfail(reason="Program synthesis not implemented")
-class TestProgramSynthesis:
-    """Tests for ProgramSynthesis handler functionality."""
-
-    @pytest.mark.xfail
-    @requires_openai
-    @retry_on_error(error=SynthesisError, n=3)
-    def test_generates_callable(self, request):
-        """Test ProgramSynthesis handler generates executable code."""
-        with (
-            handler(ReplayLiteLLMProvider(request, model="gpt-4o-mini")),
-            handler(ProgramSynthesis()),
-            handler(LimitLLMCallsHandler(max_calls=1)),
-        ):
-            count_func = create_function("a")
-
-            assert callable(count_func)
-            # Test the generated function
-            assert count_func("banana") == 3
-            assert count_func("cherry") == 0
-            assert count_func("aardvark") == 3
-
-
 def smiley_face() -> Image.Image:
     bmp = [
         "00000000",
@@ -473,7 +451,6 @@ def test_synthesize_counter_with_parameter(self, request):
     @requires_openai
     def test_callable_type_signature_in_schema(self, request):
         """Test that the callable type signature is communicated to the LLM."""
-        from effectful.handlers.llm.encoding import Encodable
 
         # Verify that the enc type includes the signature in its docstring
         encodable = Encodable.define(Callable[[int, int], int], {})
@@ -487,8 +464,6 @@ def test_callable_type_signature_in_schema(self, request):
     @requires_openai
     def test_synthesized_function_roundtrip(self, request):
         """Test that a synthesized function can be encoded and decoded."""
-        from effectful.handlers.llm.encoding import Encodable
-        from effectful.handlers.llm.synthesis import SynthesizedFunction
 
         with (
             handler(ReplayLiteLLMProvider(request, model="gpt-4o-mini")),
@@ -513,7 +488,6 @@ def test_synthesized_function_roundtrip(self, request):
     @requires_openai
     def test_synthesize_bool_return_type(self, request):
         """Test that LLM respects bool return type in signature."""
-        import inspect
 
         with (
             handler(ReplayLiteLLMProvider(request, model="gpt-4o-mini")),
@@ -536,7 +510,6 @@ def test_synthesize_bool_return_type(self, request):
     @requires_openai
     def test_synthesize_three_params(self, request):
         """Test that LLM respects the exact number of parameters in signature."""
-        import inspect
 
         with (
             handler(ReplayLiteLLMProvider(request, model="gpt-4o-mini")),