pdd-cli 0.0.42__py3-none-any.whl → 0.0.90__py3-none-any.whl

pdd/fix_verification_errors.py

@@ -1,4 +1,3 @@
-import re
 from typing import Dict, Any, Optional
 from rich import print as rprint
 from rich.markdown import Markdown
@@ -145,6 +144,7 @@ def fix_verification_errors(
     verification_result_obj = verification_response.get('result')
 
     if isinstance(verification_result_obj, VerificationOutput):
+        # llm_invoke handles all parsing when output_pydantic is specified
         verification_issues_count = verification_result_obj.issues_count
         verification_details = verification_result_obj.details
         if verbose:
@@ -162,66 +162,18 @@ def fix_verification_errors(
                 if verbose:
                     rprint(f"\n[yellow]Found {verification_issues_count} potential issues. Proceeding to fix step.[/yellow]")
             else:
-                rprint(f"[yellow]Warning:[/yellow] <issues_count> is {verification_issues_count}, but <details> field is empty or missing. Treating as no actionable issues found.")
+                rprint(f"[yellow]Warning:[/yellow] issues_count is {verification_issues_count}, but details field is empty or missing. Treating as no actionable issues found.")
                 verification_issues_count = 0
         else:
             if verbose:
                 rprint("\n[green]No issues found during verification based on structured output.[/green]")
-    elif isinstance(verification_result_obj, str):
-        try:
-            issues_match = re.search(r'<issues_count>(\d+)</issues_count>', verification_result_obj)
-            if issues_match:
-                parsed_issues_count = int(issues_match.group(1))
-                details_match = re.search(r'<details>(.*?)</details>', verification_result_obj, re.DOTALL)
-                parsed_verification_details = details_match.group(1).strip() if (details_match and details_match.group(1)) else None
-
-
-                if parsed_issues_count > 0:
-                    if parsed_verification_details: # Check if details exist and are not empty
-                        issues_found = True
-                        verification_issues_count = parsed_issues_count
-                        verification_details = parsed_verification_details
-                        if verbose:
-                            rprint(f"\n[yellow]Found {verification_issues_count} potential issues in string response. Proceeding to fix step.[/yellow]")
-                    else:
-                        rprint(f"[yellow]Warning:[/yellow] <issues_count> is {parsed_issues_count} in string response, but <details> field is empty or missing. Treating as no actionable issues found.")
-                        verification_issues_count = 0
-                        issues_found = False
-                else: # parsed_issues_count == 0
-                    verification_issues_count = 0
-                    issues_found = False
-                    if verbose:
-                         rprint("\n[green]No issues found in string verification based on <issues_count> being 0.[/green]")
-            else: # issues_match is None (tag not found or content not digits)
-                rprint("[bold red]Error:[/bold red] Could not find or parse integer value from <issues_count> tag in string response.")
-                return {
-                    "explanation": None,
-                    "fixed_program": program,
-                    "fixed_code": code,
-                    "total_cost": total_cost,
-                    "model_name": model_name,
-                    "verification_issues_count": 0,
-                }
-        except ValueError: # Should not be hit if regex is \d+, but as a safeguard
-            rprint("[bold red]Error:[/bold red] Invalid non-integer value in <issues_count> tag in string response.")
-            return {
-                "explanation": None,
-                "fixed_program": program,
-                "fixed_code": code,
-                "total_cost": total_cost,
-                "model_name": model_name,
-                "verification_issues_count": 0,
-            }
-    else: # Not VerificationOutput and not a successfully parsed string
-        rprint("[bold red]Error:[/bold red] Verification LLM call did not return the expected structured output (e.g., parsing failed).")
-        rprint(f"  [dim]Expected type:[/dim] {VerificationOutput} or str")
+    else:
+        # llm_invoke should always return VerificationOutput when output_pydantic is specified
+        rprint("[bold red]Error:[/bold red] Verification LLM call did not return the expected structured output.")
+        rprint(f"  [dim]Expected type:[/dim] {VerificationOutput}")
         rprint(f"  [dim]Received type:[/dim] {type(verification_result_obj)}")
         content_str = str(verification_result_obj)
         rprint(f"  [dim]Received content:[/dim] {content_str[:500]}{'...' if len(content_str) > 500 else ''}")
-        raw_text = verification_response.get('result_text')
-        if raw_text:
-            raw_text_str = str(raw_text)
-            rprint(f"  [dim]Raw LLM text (if available from llm_invoke):[/dim] {raw_text_str[:500]}{'...' if len(raw_text_str) > 500 else ''}")
         return {
             "explanation": None,
             "fixed_program": program,
@@ -262,63 +214,23 @@ def fix_verification_errors(
                 rprint(f"  [dim]Cost:[/dim] ${fix_response.get('cost', 0.0):.6f}")
 
             fix_result_obj = fix_response.get('result')
-            parsed_fix_successfully = False
 
             if isinstance(fix_result_obj, FixerOutput):
+                # llm_invoke handles all parsing and unescaping via _unescape_code_newlines
                 fixed_program = fix_result_obj.fixed_program
                 fixed_code = fix_result_obj.fixed_code
                 fix_explanation = fix_result_obj.explanation
-                
-                # Unescape literal \n strings to actual newlines
-                if fixed_program:
-                    fixed_program = fixed_program.replace('\\n', '\n')
-                if fixed_code:
-                    fixed_code = fixed_code.replace('\\n', '\n')
-                
-                parsed_fix_successfully = True
+
                 if verbose:
                     rprint("[green]Successfully parsed structured output for fix.[/green]")
                     rprint(Markdown(f"**Explanation from LLM:**\n{fix_explanation}"))
-            elif isinstance(fix_result_obj, str):
-                program_match = re.search(r'<fixed_program>(.*?)</fixed_program>', fix_result_obj, re.DOTALL)
-                code_match = re.search(r'<fixed_code>(.*?)</fixed_code>', fix_result_obj, re.DOTALL)
-                explanation_match = re.search(r'<explanation>(.*?)</explanation>', fix_result_obj, re.DOTALL)
-
-                if program_match or code_match or explanation_match: # If any tag is found, attempt to parse
-                    fixed_program_candidate = program_match.group(1).strip() if (program_match and program_match.group(1)) else None
-                    fixed_code_candidate = code_match.group(1).strip() if (code_match and code_match.group(1)) else None
-                    fix_explanation_candidate = explanation_match.group(1).strip() if (explanation_match and explanation_match.group(1)) else None
-
-                    # Unescape literal \n strings to actual newlines
-                    if fixed_program_candidate:
-                        fixed_program_candidate = fixed_program_candidate.replace('\\n', '\n')
-                    if fixed_code_candidate:
-                        fixed_code_candidate = fixed_code_candidate.replace('\\n', '\n')
-
-                    fixed_program = fixed_program_candidate if fixed_program_candidate else program
-                    fixed_code = fixed_code_candidate if fixed_code_candidate else code
-                    fix_explanation = fix_explanation_candidate if fix_explanation_candidate else "[Fix explanation not provided by LLM]"
-                    parsed_fix_successfully = True
-
-                    if verbose:
-                        if not program_match or not fixed_program_candidate:
-                            rprint("[yellow]Warning:[/yellow] Could not find or parse <fixed_program> tag in fix result string. Using original program.")
-                        if not code_match or not fixed_code_candidate:
-                            rprint("[yellow]Warning:[/yellow] Could not find or parse <fixed_code> tag in fix result string. Using original code module.")
-                        if not explanation_match or not fix_explanation_candidate:
-                            rprint("[yellow]Warning:[/yellow] Could not find or parse <explanation> tag in fix result string. Using default explanation.")
-                # else: string, but no relevant tags. Will fall to parsed_fix_successfully = False below
-
-            if not parsed_fix_successfully:
-                rprint(f"[bold red]Error:[/bold red] Fix generation LLM call did not return the expected structured output (e.g., parsing failed).")
-                rprint(f"  [dim]Expected type:[/dim] {FixerOutput} or str (with XML tags)")
+            else:
+                # llm_invoke should always return FixerOutput when output_pydantic is specified
+                rprint(f"[bold red]Error:[/bold red] Fix generation LLM call did not return the expected structured output.")
+                rprint(f"  [dim]Expected type:[/dim] {FixerOutput}")
                 rprint(f"  [dim]Received type:[/dim] {type(fix_result_obj)}")
                 content_str = str(fix_result_obj)
                 rprint(f"  [dim]Received content:[/dim] {content_str[:500]}{'...' if len(content_str) > 500 else ''}")
-                raw_text = fix_response.get('result_text')
-                if raw_text:
-                    raw_text_str = str(raw_text)
-                    rprint(f"  [dim]Raw LLM text (if available from llm_invoke):[/dim] {raw_text_str[:500]}{'...' if len(raw_text_str) > 500 else ''}")
                 fix_explanation = "[Error: Failed to parse structured output from LLM for fix explanation]"
                 # fixed_program and fixed_code remain original (already initialized)