pdd-cli 0.0.18__py3-none-any.whl → 0.0.20__py3-none-any.whl

pdd/auto_deps_main.py

@@ -94,5 +94,4 @@ def auto_deps_main(
     except Exception as e:
         if not ctx.obj.get('quiet', False):
             rprint(f"[bold red]Error:[/bold red] {str(e)}")
-        sys.exit(1)
-        # Removed the "raise" line so that we only exit, satisfying the test.
+        sys.exit(1)

pdd/cli.py

@@ -46,7 +46,7 @@ console = Console()
 @click.option("--review-examples", is_flag=True,
               help="Review and optionally exclude few-shot examples before command execution.")
 @click.option('--local', is_flag=True, help='Run commands locally instead of in the cloud.')
-@click.version_option(version="0.0.18")
+@click.version_option(version="0.0.20")
 @click.pass_context
 def cli(
     ctx,

pdd/context_generator.py

@@ -116,7 +116,7 @@ def context_generator(code_module: str, prompt: str, language: str = "python", s
             llm_output=final_llm_output,
             language=language,
             strength=0.97,
-            temperature=temperature,
+            temperature=0,
             verbose=verbose
         )
         total_cost += postprocess_cost

pdd/crash_main.py

@@ -51,10 +51,14 @@ def crash_main(
             "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))
+
         input_strings, output_file_paths, _ = construct_paths(
             input_file_paths=input_file_paths,
-            force=ctx.obj.get('force', False),
-            quiet=ctx.obj.get('quiet', False),
+            force=force,
+            quiet=quiet,
             command="crash",
             command_options=command_options
         )
@@ -66,72 +70,62 @@ def crash_main(
         error_content = input_strings["error_file"]
 
         # Get model parameters from context
-        strength = ctx.obj.get('strength', 0.97)
-        temperature = ctx.obj.get('temperature', 0)
+        strength = ctx.obj.get("strength", 0.97)
+        temperature = ctx.obj.get("temperature", 0)
+
+        verbose = ctx.params.get("verbose", ctx.obj.get("verbose", False))
 
         if loop:
             # Use iterative fixing process
             success, final_code, final_program, attempts, cost, model = fix_code_loop(
-                code_file=code_file,
-                prompt=prompt_content,
-                verification_program=program_file,
-                strength=strength,
-                temperature=temperature,
-                max_attempts=max_attempts or 3,
-                budget=budget or 5.0,
-                error_log_file=error_file,
-                verbose=not ctx.obj.get('verbose', False)
+                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(
-                program=program_content,
-                prompt=prompt_content,
-                code=code_content,
-                errors=error_content,
-                strength=strength,
-                temperature=temperature,
-                verbose=not ctx.obj.get('verbose', False)
+                program_content, prompt_content, code_content, error_content, strength, temperature, verbose
             )
             success = True
             attempts = 1
 
-        # Determine if contents were actually updated
-        if final_code != "":
-            update_code = final_code != code_content
-        else:
-            update_code = False
-        if final_program != "":
-            update_program = final_program != program_content
-        else:
-            update_program = False
-            
-        # Save results if contents changed
-        if update_code and output_file_paths.get("output"):
-            with open(output_file_paths["output"], 'w') as f:
+        # 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
+
+        # 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
+
+        # Write output files
+        if should_write_code:
+            with open(output_file_paths["output"], "w") as f:
                 f.write(final_code)
-        if update_program and output_file_paths.get("output_program"):
-            with open(output_file_paths["output_program"], 'w') as f:
+
+        if should_write_program:
+            with open(output_file_paths["output_program"], "w") as f:
                 f.write(final_program)
 
         # Provide user feedback
-        if not ctx.obj.get('quiet', False):
+        if not quiet:
             if success:
                 rprint("[bold green]Crash fix completed successfully.[/bold green]")
             else:
-                rprint("[bold yellow]Crash fix completed with some issues.[/bold yellow]")
+                rprint("[bold yellow]Crash fix completed with issues.[/bold yellow]")
             rprint(f"[bold]Model used:[/bold] {model}")
             rprint(f"[bold]Total attempts:[/bold] {attempts}")
-            rprint(f"[bold]Total cost:[/bold] ${cost:.6f}")
-            if update_code and output:
+            rprint(f"[bold]Total cost:[/bold] ${cost:.2f}")
+            if should_write_code:
                 rprint(f"[bold]Fixed code saved to:[/bold] {output_file_paths['output']}")
-            if update_program and output_program:
+            if should_write_program:
                 rprint(f"[bold]Fixed program saved to:[/bold] {output_file_paths['output_program']}")
 
         return success, final_code, final_program, attempts, cost, model
-
+    
     except Exception as e:
-        if not ctx.obj.get('quiet', False):
+        if not quiet:
             rprint(f"[bold red]Error:[/bold red] {str(e)}")
         sys.exit(1)

pdd/data/llm_model.csv

@@ -1,17 +1,17 @@
 provider,model,input,output,coding_arena_elo,base_url,api_key,counter,encoder,max_tokens,max_completion_tokens,structured_output
-OpenAI,"gpt-4o-mini",0.15,0.60,1246,,OPENAI_API_KEY,tiktoken,o200k_base,16384,,True
+OpenAI,"gpt-4o-mini",0.15,0.60,1246,,OPENAI_API_KEY,tiktoken,o200k_base,,16384,True
 OpenAI,"grok-2-1212",2,10,1255,"https://api.x.ai/v1",XAI_API_KEY,tiktoken,o200k_base,4096,,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.0-flash-thinking-exp-01-21",.1,.4,1291,,GOOGLE_API_KEY,,,8192,,False
 GoogleVertexAI,"gemini-2.0-pro-exp-02-05",1.25,5,1299,,VERTEX_AI_API_KEY,,,8192,,False
-Anthropic,claude-3-7-sonnet-20250219,3,15,1312,,ANTHROPIC_API_KEY,anthropic,claude-3-sonnet-20240229,8192,,False
+Anthropic,claude-3-7-sonnet-20250219,3,15,1312,,ANTHROPIC_API_KEY,anthropic,claude-3-sonnet-20240229,64000,,False
 Google,gemini-exp-1206,1.25,5,1313,,GOOGLE_API_KEY,,,8192,,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,"o3-mini",1.1,4.4,1319,,OPENAI_API_KEY,tiktoken,o200k_base,,100000,True
 OpenAI,"o1-2024-12-17",15,60,1331,,OPENAI_API_KEY,tiktoken,o200k_base,,32768,True
-OpenAI,"gpt-4o-2024-11-20",2.5,10,1332,,OPENAI_API_KEY,tiktoken,o200k_base,16384,,True
+OpenAI,"gpt-4o-2024-11-20",2.5,10,1332,,OPENAI_API_KEY,tiktoken,o200k_base,,16384,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

pdd/fix_error_loop.py

@@ -135,24 +135,32 @@ def fix_error_loop(unit_test_file: str,
 
     # We do up to max_attempts fix attempts or until budget is exceeded
     iteration = 0
+    # Run an initial test to determine starting state
+    try:
+        fails, errors, warnings, pytest_output = run_pytest_on_file(unit_test_file)
+    except Exception as e:
+        rprint(f"[red]Error running initial pytest:[/red] {e}")
+        return False, "", "", fix_attempts, total_cost, model_name
+
     while fix_attempts < max_attempts and total_cost < budget:
         iteration += 1
-        iteration_header = f"=== Attempt iteration {iteration} ==="
-        rprint(f"[bold blue]{iteration_header}[/bold blue]")
-        with open(error_log_file, "a") as elog:
-            elog.write(f"\n{iteration_header}\n")
-
-        # 1) Run the unit tests using pytest's API directly.
-        try:
-            fails, errors, warnings, pytest_output = run_pytest_on_file(unit_test_file)
-        except Exception as e:
-            rprint(f"[red]Error running pytest:[/red] {e}")
-            return False, "", "", fix_attempts, total_cost, model_name
 
         # Append to error log:
         with open(error_log_file, "a") as elog:
+            elog.write(f"<pytest_output iteration={iteration}>\n")
             elog.write(pytest_output + "\n")
-
+            elog.write("</pytest_output>\n")
+            
+        # If tests pass initially, no need to fix anything
+        if fails == 0 and errors == 0 and warnings == 0:
+            rprint("[green]All tests already pass with no warnings! No fixes needed.[/green]")
+            return True, "", "", 0, 0.0, ""
+        
+        iteration_header = f"=== Attempt iteration {iteration} ==="
+        rprint(f"[bold blue]{iteration_header}[/bold blue]")
+        with open(error_log_file, "a") as elog:
+            elog.write(f"\n{iteration_header}\n\n")
+            elog.write(f"<fix_attempt iteration={iteration}>\n")
         # Print to console (escaped):
         rprint(f"[magenta]Pytest output:[/magenta]\n{escape_brackets(pytest_output)}")
         if verbose:
@@ -271,8 +279,10 @@ def fix_error_loop(unit_test_file: str,
                 verify_output = f"Verification program error: {e}"
 
             with open(error_log_file, "a") as elog:
-                elog.write(f"\n[Verification attempt at iteration {iteration}]\n")
-                elog.write(verify_output + "\n")
+                elog.write(f"</fix_attempt>\n\n")
+                elog.write(f"\n[Verification attempt at iteration {iteration}]\n<verification_output iteration={iteration}>\n")
+                elog.write(verify_output )
+                elog.write("</verification_output>\n")
 
             rprint(f"[blue]Verification program output:[/blue]\n{escape_brackets(verify_output)}")
 
@@ -281,40 +291,18 @@ def fix_error_loop(unit_test_file: str,
                 try:
                     shutil.copy(code_backup, code_file)
                     with open(error_log_file, "a") as elog:
-                        elog.write(f"Restored code file from backup: {code_backup}\n")
+                        elog.write(f"Restored code file from backup: {code_backup}, because verification program failed to run.\n")
                 except Exception as e:
                     rprint(f"[red]Error restoring backup code file:[/red] {e}")
                     break
 
-        # Re-run the tests in the same iteration:
+        # Run pytest for the next iteration
         try:
-            fails2, errors2, warnings2, second_run_output = run_pytest_on_file(unit_test_file)
+            fails, errors, warnings, pytest_output = run_pytest_on_file(unit_test_file)
         except Exception as e:
-            rprint(f"[red]Error running second pytest attempt in iteration {iteration}:[/red] {e}")
+            rprint(f"[red]Error running pytest for next iteration:[/red] {e}")
             return False, "", "", fix_attempts, total_cost, model_name
 
-        with open(error_log_file, "a") as elog:
-            elog.write("\n=== Second Pytest Check (same iteration) ===\n")
-            elog.write(second_run_output + "\n")
-
-        rprint(f"[magenta]Second pytest check:[/magenta]\n{escape_brackets(second_run_output)}")
-
-        if fails2 == 0 and errors2 == 0 and warnings2 == 0:
-            rprint("[green]All tests passed on the second run of this iteration! Exiting loop.[/green]")
-            break
-        else:
-            if (errors2 < best_iteration_info["errors"] or
-                (errors2 == best_iteration_info["errors"] and fails2 < best_iteration_info["fails"]) or
-                (errors2 == best_iteration_info["errors"] and fails2 == best_iteration_info["fails"] and warnings2 < best_iteration_info["warnings"])):
-                best_iteration_info = {
-                    "attempt": iteration,
-                    "fails": fails2,
-                    "errors": errors2,
-                    "warnings": warnings2,
-                    "unit_test_backup": unit_test_backup,
-                    "code_backup": code_backup
-                }
-
     # Final test run:
     try:
         final_fails, final_errors, final_warnings, final_output = run_pytest_on_file(unit_test_file)

pdd/fix_errors_from_unit_tests.py

@@ -154,15 +154,21 @@ def fix_errors_from_unit_tests(
         processed_prompt = preprocess(
             prompt,
             recursive=False,
+            double_curly_brackets=True
+        )
+        
+        processed_fix_errors_prompt = preprocess(
+            fix_errors_prompt,
+            recursive=False,
             double_curly_brackets=True,
-            exclude_keys=['unit_test', 'code', 'unit_test_fix']
+            exclude_keys=['unit_test', 'code', 'errors', 'prompt']
         )
 
         if verbose:
             console.print(Panel("[bold green]Running fix_errors_from_unit_tests...[/bold green]"))
 
         response1 = llm_invoke(
-            prompt=fix_errors_prompt,
+            prompt=processed_fix_errors_prompt,
             input_json={
                 "unit_test": unit_test,
                 "code": code,

pdd/fix_main.py

@@ -3,9 +3,17 @@ from typing import Tuple, Optional
 import click
 from rich import print as rprint
 
+import requests
+import asyncio
+import os
+
+from .preprocess import preprocess
+
 from .construct_paths import construct_paths
 from .fix_errors_from_unit_tests import fix_errors_from_unit_tests
 from .fix_error_loop import fix_error_loop
+from .get_jwt_token import get_jwt_token
+from .get_language import get_language
 
 def fix_main(
     ctx: click.Context,
@@ -130,6 +138,105 @@ def fix_main(
                 if output_file_paths.get("output_results"):
                     rprint(f"  Results file: {output_file_paths['output_results']}")
 
+                # Auto-submit example if requested and successful
+                if auto_submit:
+                    try:
+                        # Get JWT token for cloud authentication
+                        jwt_token = asyncio.run(get_jwt_token(
+                            firebase_api_key=os.environ.get("REACT_APP_FIREBASE_API_KEY"),
+                            github_client_id=os.environ.get("GITHUB_CLIENT_ID"),
+                            app_name="PDD Code Generator"
+                        ))
+                        processed_prompt = preprocess(
+                            input_strings["prompt_file"],
+                            recursive=False,
+                            double_curly_brackets=True
+                        )
+                        # Prepare the submission payload
+                        payload = {
+                            "command": "fix",
+                            "input": {
+                                "prompts": [{
+                                    "content": processed_prompt,
+                                    "filename": os.path.basename(prompt_file)
+                                }],
+                                "code": [{
+                                    "content": input_strings["code_file"],
+                                    "filename": os.path.basename(code_file)
+                                }],
+                                "test": [{
+                                    "content": input_strings["unit_test_file"],
+                                    "filename": os.path.basename(unit_test_file)
+                                }]
+                            },
+                            "output": {
+                                "code": [{
+                                    "content": fixed_code,
+                                    "filename": os.path.basename(output_file_paths["output_code"])
+                                }],
+                                "test": [{
+                                    "content": fixed_unit_test,
+                                    "filename": os.path.basename(output_file_paths["output_test"])
+                                }]
+                            },
+                            "metadata": {
+                                "title": f"Auto-submitted fix for {os.path.basename(code_file)}",
+                                "description": "Automatically submitted successful code fix",
+                                "language": get_language(os.path.splitext(code_file)[1]),  # Detect language from file extension
+                                "framework": "",
+                                "tags": ["auto-fix", "example"],
+                                "isPublic": True,
+                                "price": 0.0
+                            }
+                        }
+
+                        # Add verification program if specified
+                        if verification_program:
+                            with open(verification_program, 'r') as f:
+                                verifier_content = f.read()
+                            payload["input"]["example"] = [{
+                                "content": verifier_content,
+                                "filename": os.path.basename(verification_program)
+                            }]
+
+                        # Add error logs if available
+                        if "error_file" in input_strings:
+                            payload["input"]["error"] = [{
+                                "content": input_strings["error_file"],
+                                "filename": os.path.basename(error_file)
+                            }]
+
+                        # Add analysis if available
+                        if output_file_paths.get("output_results"):
+                            with open(output_file_paths["output_results"], 'r') as f:
+                                analysis_content = f.read()
+                            payload["output"]["analysis"] = [{
+                                "content": analysis_content,
+                                "filename": os.path.basename(output_file_paths["output_results"])
+                            }]
+
+                        # Submit the example to Firebase Cloud Function
+                        headers = {
+                            "Authorization": f"Bearer {jwt_token}",
+                            "Content-Type": "application/json"
+                        }
+                        response = requests.post(
+                            'https://us-central1-prompt-driven-development.cloudfunctions.net/submitExample',
+                            json=payload,
+                            headers=headers
+                        )
+                        
+                        if response.status_code == 200:
+                            if not ctx.obj.get('quiet', False):
+                                rprint("[bold green]Successfully submitted example[/bold green]")
+                        else:
+                            if not ctx.obj.get('quiet', False):
+                                rprint(f"[bold red]Failed to submit example: {response.text}[/bold red]")
+
+                    except Exception as e:
+                        if not ctx.obj.get('quiet', False):
+                            rprint(f"[bold red]Error submitting example: {str(e)}[/bold red]")
+
         return success, fixed_unit_test, fixed_code, attempts, total_cost, model_name
 
     except Exception as e:

pdd/insert_includes.py

@@ -60,7 +60,8 @@ def insert_includes(
         processed_prompt = preprocess(
             insert_includes_prompt,
             recursive=False,
-            double_curly_brackets=False
+            double_curly_brackets=True,
+            exclude_keys=["actual_prompt_to_update", "actual_dependencies_to_insert"]
         )
 
         if verbose:

pdd/llm_invoke.py

@@ -226,7 +226,16 @@ def create_llm_instance(selected_model, temperature, handler):
                 llm = ChatOpenAI(model=model_name, temperature=temperature,
                                  openai_api_key=api_key, callbacks=[handler])
     elif provider == 'anthropic':
-        llm = ChatAnthropic(model=model_name, temperature=temperature, callbacks=[handler])
+        # Special case for Claude 3.7 Sonnet with thinking token budget
+        if 'claude-3-7-sonnet' in model_name:
+            llm = ChatAnthropic(
+                model=model_name, 
+                temperature=temperature, 
+                callbacks=[handler],
+                thinking={"type": "enabled", "budget_tokens": 4000}  # 32K thinking token budget
+            )
+        else:
+            llm = ChatAnthropic(model=model_name, temperature=temperature, callbacks=[handler])
     elif provider == 'google':
         llm = ChatGoogleGenerativeAI(model=model_name, temperature=temperature, callbacks=[handler])
     elif provider == 'googlevertexai':