pdd-cli 0.0.24__py3-none-any.whl → 0.0.26__py3-none-any.whl

pdd/context_generator.py

@@ -5,6 +5,7 @@ from .llm_invoke import llm_invoke
 from .unfinished_prompt import unfinished_prompt
 from .continue_generation import continue_generation
 from .postprocess import postprocess
+from . import EXTRACTION_STRENGTH
 
 def context_generator(code_module: str, prompt: str, language: str = "python", strength: float = 0.5, temperature: float = 0, verbose: bool = False) -> tuple:
     """
@@ -115,7 +116,7 @@ def context_generator(code_module: str, prompt: str, language: str = "python", s
         example_code, postprocess_cost, postprocess_model = postprocess(
             llm_output=final_llm_output,
             language=language,
-            strength=0.97,
+            strength=EXTRACTION_STRENGTH,
             temperature=temperature,
             verbose=verbose
         )

pdd/continue_generation.py

@@ -6,13 +6,16 @@ from .load_prompt_template import load_prompt_template
 from .preprocess import preprocess
 from .llm_invoke import llm_invoke
 from .unfinished_prompt import unfinished_prompt
+from . import EXTRACTION_STRENGTH
 
 console = Console()
 
 class TrimResultsStartOutput(BaseModel):
+    explanation: str = Field(description="The explanation of how you determined what to cut out")
     code_block: str = Field(description="The trimmed code block from the start")
 
 class TrimResultsOutput(BaseModel):
+    explanation: str = Field(description="The explanation of the code block")
     trimmed_continued_generation: str = Field(description="The trimmed continuation of the generation")
 
 def continue_generation(
@@ -69,7 +72,7 @@ def continue_generation(
         trim_start_response = llm_invoke(
             prompt=processed_prompts['trim_start'],
             input_json={"LLM_OUTPUT": llm_output},
-            strength=0.9,
+            strength=0.75,
             temperature=0,
             output_pydantic=TrimResultsStartOutput,
             verbose=verbose
@@ -119,7 +122,7 @@ def continue_generation(
                         "CONTINUED_GENERATION": continue_result,
                         "GENERATED_RESULTS": code_block[-200:]
                     },
-                    strength=0.9,
+                    strength=EXTRACTION_STRENGTH,
                     temperature=0,
                     output_pydantic=TrimResultsOutput,
                     verbose=verbose

pdd/crash_main.py

@@ -1,10 +1,18 @@
 import sys
-from typing import Tuple, Optional
+from typing import Tuple, Optional, Dict, Any
 import click
 from rich import print as rprint
+from . import DEFAULT_STRENGTH
+from pathlib import Path
 
 from .construct_paths import construct_paths
 from .fix_code_loop import fix_code_loop
+# Import fix_code_module_errors conditionally or ensure it's always available
+try:
+    from .fix_code_module_errors import fix_code_module_errors
+except ImportError:
+    # Handle case where fix_code_module_errors might not be available if not needed
+    fix_code_module_errors = None
 
 def crash_main(
     ctx: click.Context,
@@ -39,6 +47,13 @@ def crash_main(
         - float: Total cost of all fix attempts
         - str: The name of the model used
     """
+    # Ensure ctx.obj and ctx.params exist and are dictionaries
+    ctx.obj = ctx.obj if isinstance(ctx.obj, dict) else {}
+    ctx.params = ctx.params if isinstance(ctx.params, dict) else {}
+
+    quiet = ctx.params.get("quiet", ctx.obj.get("quiet", False))
+    verbose = ctx.params.get("verbose", ctx.obj.get("verbose", False)) # Get verbose flag
+
     try:
         # Construct file paths
         input_file_paths = {
@@ -47,13 +62,13 @@ def crash_main(
             "program_file": program_file,
             "error_file": error_file
         }
-        command_options = {
+        command_options: Dict[str, Any] = {
             "output": output,
             "output_program": output_program
         }
 
         force = ctx.params.get("force", ctx.obj.get("force", False))
-        quiet = ctx.params.get("quiet", ctx.obj.get("quiet", False))
+        # quiet = ctx.params.get("quiet", ctx.obj.get("quiet", False)) # Already defined above
 
         input_strings, output_file_paths, _ = construct_paths(
             input_file_paths=input_file_paths,
@@ -70,46 +85,58 @@ def crash_main(
         error_content = input_strings["error_file"]
 
         # Get model parameters from context
-        strength = ctx.obj.get("strength", 0.97)
+        strength = ctx.obj.get("strength", DEFAULT_STRENGTH)
         temperature = ctx.obj.get("temperature", 0)
 
-        verbose = ctx.params.get("verbose", ctx.obj.get("verbose", False))
+        # verbose = ctx.params.get("verbose", ctx.obj.get("verbose", False)) # Already defined above
 
         if loop:
             # Use iterative fixing process
-            success, final_code, final_program, attempts, cost, model = fix_code_loop(
+            success, final_program, final_code, attempts, cost, model = fix_code_loop(
                 code_file, prompt_content, program_file, strength, temperature, max_attempts or 3, budget or 5.0, error_file, verbose
             )
         else:
             # Use single fix attempt
-            from .fix_code_module_errors import fix_code_module_errors
-            update_program, update_code, final_program, final_code, cost, model = fix_code_module_errors(
+            if fix_code_module_errors is None:
+                 raise ImportError("fix_code_module_errors is required but not available.")
+            # Note: fix_code_module_errors returns 7 values according to example
+            # update_program, update_code, fixed_program, fixed_code, program_code_fix, cost, model
+            # The current code unpacks 7 values, which matches the example.
+            update_program, update_code, final_program, final_code, program_code_fix, cost, model = fix_code_module_errors(
                 program_content, prompt_content, code_content, error_content, strength, temperature, verbose
             )
-            success = True
+            success = True # Assume success after one attempt if no exception
             attempts = 1
 
         # Ensure we have content to write, falling back to original content if needed
-        if final_code == "":
-            final_code = code_content
-        
         if final_program == "":
             final_program = program_content
 
+        if final_code == "":
+            final_code = code_content
+
         # Determine whether to write the files based on whether paths are provided
-        should_write_code = output_file_paths.get("output") is not None
-        should_write_program = output_file_paths.get("output_program") is not None
+        output_code_path_str = output_file_paths.get("output")
+        output_program_path_str = output_file_paths.get("output_program")
+
+        should_write_code = output_code_path_str is not None
+        should_write_program = output_program_path_str is not None
 
         # Write output files
         if should_write_code:
-            with open(output_file_paths["output"], "w") as f:
+            output_code_path = Path(output_code_path_str)
+            output_code_path.parent.mkdir(parents=True, exist_ok=True) # Ensure directory exists
+            with open(output_code_path, "w") as f:
                 f.write(final_code)
 
         if should_write_program:
-            with open(output_file_paths["output_program"], "w") as f:
+            output_program_path = Path(output_program_path_str)
+            output_program_path.parent.mkdir(parents=True, exist_ok=True) # Ensure directory exists
+            with open(output_program_path, "w") as f:
                 f.write(final_program)
 
-        # Provide user feedback
+        # Provide user feedback (using quiet flag as per current implementation)
+        # To strictly follow the prompt's last note, change 'if not quiet:' to 'if verbose:'
         if not quiet:
             if success:
                 rprint("[bold green]Crash fix completed successfully.[/bold green]")
@@ -119,13 +146,21 @@ def crash_main(
             rprint(f"[bold]Total attempts:[/bold] {attempts}")
             rprint(f"[bold]Total cost:[/bold] ${cost:.2f}")
             if should_write_code:
-                rprint(f"[bold]Fixed code saved to:[/bold] {output_file_paths['output']}")
+                rprint(f"[bold]Fixed code saved to:[/bold] {output_code_path_str}")
             if should_write_program:
-                rprint(f"[bold]Fixed program saved to:[/bold] {output_file_paths['output_program']}")
+                rprint(f"[bold]Fixed program saved to:[/bold] {output_program_path_str}")
 
         return success, final_code, final_program, attempts, cost, model
     
+    except FileNotFoundError as e:
+        if not quiet:
+             # Provide a more specific error message for file not found
+             rprint(f"[bold red]Error:[/bold red] Input file not found: {e}")
+        sys.exit(1)
     except Exception as e:
         if not quiet:
-            rprint(f"[bold red]Error:[/bold red] {str(e)}")
+            rprint(f"[bold red]An unexpected error occurred:[/bold red] {str(e)}")
+        # Consider logging the full traceback here for debugging
+        # import traceback
+        # traceback.print_exc()
         sys.exit(1)

pdd/data/llm_model.csv

@@ -1,17 +1,18 @@
-provider,model,input,output,coding_arena_elo,base_url,api_key,counter,encoder,max_tokens,max_completion_tokens,structured_output
-OpenAI,"gpt-4.1-nano",0.1,0.40,1246,,OPENAI_API_KEY,tiktoken,o200k_base,,32768,True
-OpenAI,"grok-3-beta",3,15,1255,"https://api.x.ai/v1",XAI_API_KEY,tiktoken,o200k_base,131072,,False
-Anthropic,"claude-3-5-haiku-20241022",1,5,1259,,ANTHROPIC_API_KEY,anthropic,claude-3-sonnet-20240229,8192,,False
-OpenAI,"deepseek-coder",0.14,0.28,1279,https://api.deepseek.com/beta,DEEPSEEK_API_KEY,autotokenizer,deepseek-coder-7b-instruct-v1.5,8192,,False
-Google,"gemini-2.5-flash-preview-04-17",.15,3.5,1291,,GOOGLE_API_KEY,,,65535,,False
-GoogleVertexAI,"gemini-2.5-pro-exp-03-25",1.25,10,1299,,VERTEX_AI_API_KEY,,,65535,,False
-Anthropic,claude-3-7-sonnet-20250219,3,15,1312,,ANTHROPIC_API_KEY,anthropic,claude-3-sonnet-20240229,64000,,False
-Google,gemini-2.5-pro-exp-03-25,1.25,10,1313,,GOOGLE_API_KEY,,,65535,,False
-OpenAI,"deepseek-r1-distill-llama-70b-specdec",5,5,1314,https://api.groq.com/openai/v1,GROQ_API_KEY,autotokenizer,deepseek-coder-7b-instruct-v1.5,16384,,False
-Ollama,"deepseek-r1:70b-llama-distill-q8_0",0.0,0.0,1315,,PWD,,,,,False
-Ollama,deepseek-r1:32b-qwen-distill-fp16,0.0,0.0,1316,,PWD,,,,,False
-OpenAI,"o4-mini",1.1,4.4,1319,,OPENAI_API_KEY,tiktoken,o200k_base,,100000,True
-OpenAI,"o3",10,40,1331,,OPENAI_API_KEY,tiktoken,o200k_base,,100000,True
-OpenAI,"gpt-4.1",2,8,1332,,OPENAI_API_KEY,tiktoken,o200k_base,,32768,True
-OpenAI,"deepseek-reasoner",0.55,2.19,1336,https://api.deepseek.com/beta,DEEPSEEK_API_KEY,autotokenizer,deepseek-coder-7b-instruct-v1.5,8192,,False
-Fireworks,accounts/fireworks/models/deepseek-r1,3,8,1338,,FIREWORKS_API_KEY,,,8192,,False
+provider,model,input,output,coding_arena_elo,base_url,api_key,max_reasoning_tokens,structured_output,reasoning_type
+OpenAI,gpt-4.1-nano,0.1,0.4,1249,,OPENAI_API_KEY,0,True,none
+xai,xai/grok-3-beta,3.0,15.0,1332,https://api.x.ai/v1,XAI_API_KEY,0,False,none
+Anthropic,claude-3-5-haiku-20241022,.8,4,1261,,ANTHROPIC_API_KEY,0,True,none
+OpenAI,deepseek/deepseek-chat,.27,1.1,1353,https://api.deepseek.com/beta,DEEPSEEK_API_KEY,0,False,none
+Google,vertex_ai/gemini-2.5-flash-preview-04-17,0.15,0.6,1330,,VERTEX_CREDENTIALS,0,True,effort
+Google,gemini-2.5-pro-exp-03-25,1.25,10.0,1360,,GOOGLE_API_KEY,0,True,none
+Anthropic,claude-3-7-sonnet-20250219,3.0,15.0,1340,,ANTHROPIC_API_KEY,64000,True,budget
+Google,vertex_ai/gemini-2.5-pro-preview-05-06,1.25,10.0,1361,,VERTEX_CREDENTIALS,0,True,none
+OpenAI,o4-mini,1.1,4.4,1333,,OPENAI_API_KEY,0,True,effort
+OpenAI,o3,10.0,40.0,1389,,OPENAI_API_KEY,0,True,effort
+OpenAI,gpt-4.1,2.0,8.0,1335,,OPENAI_API_KEY,0,True,none
+OpenAI,deepseek/deepseek-reasoner,0.55,2.19,1337,https://api.deepseek.com/beta,DEEPSEEK_API_KEY,0,False,none
+Fireworks,fireworks_ai/accounts/fireworks/models/deepseek-r1,3.0,8.0,1338,,FIREWORKS_API_KEY,0,False,none
+OpenAI,chatgpt-4o-latest,5,15,1369,,OPENAI_API_KEY,0,False,none
+Anthropic,bedrock/us.anthropic.claude-3-7-sonnet-20250219-v1:0,3.0,15.0,1339,,,64000,True,budget
+OpenAI,azure/o4-mini,1.1,4.4,1334,,OPENAI_API_KEY,0,True,effort
+OpenAI,openai/mlx-community/Qwen3-30B-A3B-4bit,0,0,1293,http://localhost:8080,,0,False,none

pdd/detect_change.py

@@ -3,6 +3,7 @@ from pathlib import Path
 from rich.console import Console
 from rich.markdown import Markdown
 from pydantic import BaseModel, Field
+from . import EXTRACTION_STRENGTH
 
 from .preprocess import preprocess
 from .load_prompt_template import load_prompt_template
@@ -101,7 +102,7 @@ def detect_change(
         extract_response = llm_invoke(
             prompt=extract_prompt,
             input_json={"llm_output": detect_response['result']},
-            strength=0.97,
+            strength=EXTRACTION_STRENGTH,
             temperature=0.0,
             verbose=verbose,
             output_pydantic=ChangesList