apply lint fixes to pdl_interpreter.py

Signed-off-by: hirokuni-kitahara <[email protected]>

Author: hirokuni-kitahara

src/pdl/pdl_interpreter.py

@@ -10,6 +10,7 @@
 
 # TODO: temporarily disabling warnings to mute a pydantic warning from liteLLM
 import warnings
+from functools import partial
 from os import getenv
 
 warnings.filterwarnings("ignore", "Valid config keys have changed in V2")
@@ -338,10 +339,16 @@ def identity(result):
     return identity
 
 
-def set_error_to_scope_for_retry(scope: ScopeType, error, block_id: str) -> ScopeType:
+def set_error_to_scope_for_retry(
+    scope: ScopeType, error, block_id: Optional[str] = ""
+) -> ScopeType:
     repeating_same_error = False
-    if scope["pdl_context"] and isinstance(scope["pdl_context"], list):
-        last_error = scope["pdl_context"][-1]["content"]
+    pdl_context: Optional[LazyMessages] = scope.get("pdl_context")
+    if pdl_context is None:
+        return scope
+    if pdl_context and isinstance(pdl_context, list):
+        last_msg = pdl_context[-1]
+        last_error = last_msg["content"]
         if last_error.endswith(error):
             repeating_same_error = True
     if repeating_same_error:
@@ -353,7 +360,7 @@ def set_error_to_scope_for_retry(scope: ScopeType, error, block_id: str) -> Scop
     }
     scope = scope | {
         "pdl_context": lazy_messages_concat(
-            scope["pdl_context"],
+            pdl_context,
             PdlList([err_msg]),
         )
     }
@@ -380,9 +387,15 @@ def process_advanced_block(
     state = state.with_yield_background(
         state.yield_background and context_in_contribute(block)
     )
+
+    # Bind result variables here with empty values
+    result: PdlLazy[Any] = PdlConst(None)
+    background: LazyMessages = PdlList([{}])
+    new_scope: ScopeType = PdlDict({})
+    trace: AdvancedBlockType = EmptyBlock()
+
     max_retry = block.retry if block.retry else 0
     trial_total = max_retry + 1
-    background: LazyMessages = PdlList([])
     for trial_idx in range(trial_total):
         try:
             result, background, new_scope, trace = process_block_body(
@@ -394,32 +407,35 @@ def process_advanced_block(
             )
             trace = trace.model_copy(update={"pdl__result": result})
             if block.parser is not None:
-                parser = block.parser
-                result = lazy_apply(lambda r: parse_result(parser, r), result)
+                # Use partial to create a function with fixed arguments
+                parser_func = partial(parse_result, block.parser)
+                result = lazy_apply(parser_func, result)
                 if init_state.yield_result and ContributeTarget.RESULT:
                     yield_result(result, block.kind)
             if block.spec is not None and not isinstance(block, FunctionBlock):
-                result = lazy_apply(
-                    lambda r: result_with_type_checking(
-                        r, block.spec, "Type errors during spec checking:", loc, trace
-                    ),
-                    result,
+                # Use partial to create a function with fixed arguments
+                checker = partial(
+                    result_with_type_checking,
+                    spec=block.spec,
+                    msg="Type errors during spec checking:",
+                    loc=loc,
+                    trace=trace,
                 )
+                result = lazy_apply(checker, result)
             if block.fallback is not None:
                 result.result()
             break
         except Exception as exc:
+            err_msg = exc.args[0]
             do_retry = (
                 block.retry
                 and trial_idx + 1 < trial_total
-                and "Keyboard Interrupt" not in exc.message
+                and "Keyboard Interrupt" not in err_msg
             )
             if block.fallback is None and not do_retry:
                 raise exc from exc
-            elif do_retry:
-                error = (
-                    f"An error occurred in a PDL block. Error details: {exc.message}"
-                )
+            if do_retry:
+                error = f"An error occurred in a PDL block. Error details: {err_msg}"
                 print(f"\n\033[0;31m[Retry {trial_idx+1}/{max_retry}] {error}\033[0m\n")
                 scope = set_error_to_scope_for_retry(scope, error, block.pdl__id)
                 continue
@@ -437,12 +453,15 @@ def process_advanced_block(
             )
             if block.spec is not None and not isinstance(block, FunctionBlock):
                 loc = append(loc, "fallback")
-                result = lazy_apply(
-                    lambda r: result_with_type_checking(
-                        r, block.spec, "Type errors during spec checking:", loc, trace
-                    ),
-                    result,
+                # Use partial to create a function with fixed arguments
+                checker = partial(
+                    result_with_type_checking,
+                    spec=block.spec,
+                    msg="Type errors during spec checking:",
+                    loc=loc,
+                    trace=trace,
                 )
+                result = lazy_apply(checker, result)
     if block.def_ is not None:
         var = block.def_
         new_scope = new_scope | PdlDict({var: result})