weco 0.2.23__py3-none-any.whl → 0.2.24__py3-none-any.whl

weco/api.py

@@ -4,6 +4,7 @@ import requests
 from rich.console import Console
 
 from weco import __pkg_version__, __base_url__
+from .constants import DEFAULT_API_TIMEOUT
 
 
 def handle_api_error(e: requests.exceptions.HTTPError, console: Console) -> None:
@@ -30,7 +31,7 @@ def start_optimization_run(
     additional_instructions: str = None,
     api_keys: Dict[str, Any] = {},
     auth_headers: dict = {},
-    timeout: Union[int, Tuple[int, int]] = 800,
+    timeout: Union[int, Tuple[int, int]] = DEFAULT_API_TIMEOUT,
 ) -> Dict[str, Any]:
     """Start the optimization run."""
     with console.status("[bold green]Starting Optimization..."):
@@ -53,8 +54,14 @@ def start_optimization_run(
                 timeout=timeout,
             )
             response.raise_for_status()
-            return response.json()
-        except requests.exceptions.HTTPError as e:
+            result = response.json()
+            # Handle None values for code and plan fields
+            if result.get("plan") is None:
+                result["plan"] = ""
+            if result.get("code") is None:
+                result["code"] = ""
+            return result
+        except Exception as e:
             handle_api_error(e, console)
             sys.exit(1)
         except Exception as e:
@@ -63,12 +70,13 @@ def start_optimization_run(
 
 
 def evaluate_feedback_then_suggest_next_solution(
+    console: Console,
     run_id: str,
     execution_output: str,
     additional_instructions: str = None,
     api_keys: Dict[str, Any] = {},
     auth_headers: dict = {},
-    timeout: Union[int, Tuple[int, int]] = 800,
+    timeout: Union[int, Tuple[int, int]] = DEFAULT_API_TIMEOUT,
 ) -> Dict[str, Any]:
     """Evaluate the feedback and suggest the next solution."""
     try:
@@ -83,10 +91,17 @@ def evaluate_feedback_then_suggest_next_solution(
             timeout=timeout,
         )
         response.raise_for_status()
-        return response.json()
+        result = response.json()
+        # Handle None values for code and plan fields
+        if result.get("plan") is None:
+            result["plan"] = ""
+        if result.get("code") is None:
+            result["code"] = ""
+
+        return result
     except requests.exceptions.HTTPError as e:
         # Allow caller to handle suggest errors, maybe retry or terminate
-        handle_api_error(e, Console())  # Use default console if none passed
+        handle_api_error(e, console)  # Use default console if none passed
         raise  # Re-raise the exception
     except Exception as e:
         print(f"Error: {e}")  # Use print as console might not be available
@@ -94,7 +109,11 @@ def evaluate_feedback_then_suggest_next_solution(
 
 
 def get_optimization_run_status(
-    run_id: str, include_history: bool = False, auth_headers: dict = {}, timeout: Union[int, Tuple[int, int]] = 800
+    console: Console,
+    run_id: str,
+    include_history: bool = False,
+    auth_headers: dict = {},
+    timeout: Union[int, Tuple[int, int]] = DEFAULT_API_TIMEOUT,
 ) -> Dict[str, Any]:
     """Get the current status of the optimization run."""
     try:
@@ -102,16 +121,30 @@ def get_optimization_run_status(
             f"{__base_url__}/runs/{run_id}", params={"include_history": include_history}, headers=auth_headers, timeout=timeout
         )
         response.raise_for_status()
-        return response.json()
+        result = response.json()
+        # Handle None values for code and plan fields in best_result and nodes
+        if result.get("best_result"):
+            if result["best_result"].get("code") is None:
+                result["best_result"]["code"] = ""
+            if result["best_result"].get("plan") is None:
+                result["best_result"]["plan"] = ""
+        # Handle None values for code and plan fields in nodes array
+        if result.get("nodes"):
+            for i, node in enumerate(result["nodes"]):
+                if node.get("plan") is None:
+                    result["nodes"][i]["plan"] = ""
+                if node.get("code") is None:
+                    result["nodes"][i]["code"] = ""
+        return result
     except requests.exceptions.HTTPError as e:
-        handle_api_error(e, Console())  # Use default console
+        handle_api_error(e, console)  # Use default console
         raise  # Re-raise
     except Exception as e:
         print(f"Error getting run status: {e}")
         raise  # Re-raise
 
 
-def send_heartbeat(run_id: str, auth_headers: dict = {}, timeout: Union[int, Tuple[int, int]] = 10) -> bool:
+def send_heartbeat(run_id: str, auth_headers: dict = {}, timeout: Union[int, Tuple[int, int]] = (10, 10)) -> bool:
     """Send a heartbeat signal to the backend."""
     try:
         response = requests.put(f"{__base_url__}/runs/{run_id}/heartbeat", headers=auth_headers, timeout=timeout)
@@ -119,9 +152,9 @@ def send_heartbeat(run_id: str, auth_headers: dict = {}, timeout: Union[int, Tup
         return True
     except requests.exceptions.HTTPError as e:
         if e.response.status_code == 409:
-            print(f"Heartbeat ignored: Run {run_id} is not running.", file=sys.stderr)
+            print("Polling ignore: Run {run_id} is not running.", file=sys.stderr)
         else:
-            print(f"Heartbeat failed for run {run_id}: HTTP {e.response.status_code}", file=sys.stderr)
+            print(f"Polling failed for run {run_id}: HTTP {e.response.status_code}", file=sys.stderr)
         return False
     except Exception as e:
         print(f"Error sending heartbeat for run {run_id}: {e}", file=sys.stderr)
@@ -134,7 +167,7 @@ def report_termination(
     reason: str,
     details: Optional[str] = None,
     auth_headers: dict = {},
-    timeout: Union[int, Tuple[int, int]] = 30,
+    timeout: Union[int, Tuple[int, int]] = (10, 30),
 ) -> bool:
     """Report the termination reason to the backend."""
     try:
@@ -172,20 +205,21 @@ def _determine_model_and_api_key() -> tuple[str, dict[str, str]]:
         api_key_dict = {"GEMINI_API_KEY": llm_api_keys["GEMINI_API_KEY"]}
     else:
         # This should never happen if determine_default_model works correctly
-        raise ValueError(f"Unknown model returned: {model}")
+        raise ValueError(f"Unknown default model choice: {model}")
 
     return model, api_key_dict
 
 
 def get_optimization_suggestions_from_codebase(
+    console: Console,
     gitingest_summary: str,
     gitingest_tree: str,
     gitingest_content_str: str,
-    console: Console,
     auth_headers: dict = {},
-    timeout: Union[int, Tuple[int, int]] = 800,
+    timeout: Union[int, Tuple[int, int]] = DEFAULT_API_TIMEOUT,
 ) -> Optional[List[Dict[str, Any]]]:
     """Analyze codebase and get optimization suggestions using the model-agnostic backend API."""
+    model, api_key_dict = _determine_model_and_api_key()
     try:
         model, api_key_dict = _determine_model_and_api_key()
         response = requests.post(
@@ -204,7 +238,7 @@ def get_optimization_suggestions_from_codebase(
         result = response.json()
         return [option for option in result.get("options", [])]
 
-    except requests.exceptions.HTTPError as e:
+    except Exception as e:
         handle_api_error(e, console)
         return None
     except Exception as e:
@@ -213,14 +247,15 @@ def get_optimization_suggestions_from_codebase(
 
 
 def generate_evaluation_script_and_metrics(
+    console: Console,
     target_file: str,
     description: str,
     gitingest_content_str: str,
-    console: Console,
     auth_headers: dict = {},
-    timeout: Union[int, Tuple[int, int]] = 800,
+    timeout: Union[int, Tuple[int, int]] = DEFAULT_API_TIMEOUT,
 ) -> Tuple[Optional[str], Optional[str], Optional[str], Optional[str]]:
     """Generate evaluation script and determine metrics using the model-agnostic backend API."""
+    model, api_key_dict = _determine_model_and_api_key()
     try:
         model, api_key_dict = _determine_model_and_api_key()
         response = requests.post(
@@ -247,16 +282,17 @@ def generate_evaluation_script_and_metrics(
 
 
 def analyze_evaluation_environment(
+    console: Console,
     target_file: str,
     description: str,
     gitingest_summary: str,
     gitingest_tree: str,
     gitingest_content_str: str,
-    console: Console,
     auth_headers: dict = {},
-    timeout: Union[int, Tuple[int, int]] = 800,
+    timeout: Union[int, Tuple[int, int]] = DEFAULT_API_TIMEOUT,
 ) -> Optional[Dict[str, Any]]:
     """Analyze existing evaluation scripts and environment using the model-agnostic backend API."""
+    model, api_key_dict = _determine_model_and_api_key()
     try:
         model, api_key_dict = _determine_model_and_api_key()
         response = requests.post(
@@ -276,7 +312,7 @@ def analyze_evaluation_environment(
         response.raise_for_status()
         return response.json()
 
-    except requests.exceptions.HTTPError as e:
+    except Exception as e:
         handle_api_error(e, console)
         return None
     except Exception as e:
@@ -285,14 +321,15 @@ def analyze_evaluation_environment(
 
 
 def analyze_script_execution_requirements(
+    console: Console,
     script_content: str,
     script_path: str,
     target_file: str,
-    console: Console,
     auth_headers: dict = {},
-    timeout: Union[int, Tuple[int, int]] = 800,
+    timeout: Union[int, Tuple[int, int]] = DEFAULT_API_TIMEOUT,
 ) -> Optional[str]:
     """Analyze script to determine proper execution command using the model-agnostic backend API."""
+    model, api_key_dict = _determine_model_and_api_key()
     try:
         model, api_key_dict = _determine_model_and_api_key()
         response = requests.post(
@@ -311,7 +348,7 @@ def analyze_script_execution_requirements(
         result = response.json()
         return result.get("command", f"python {script_path}")
 
-    except requests.exceptions.HTTPError as e:
+    except Exception as e:
         handle_api_error(e, console)
         return f"python {script_path}"
     except Exception as e:

weco/auth.py

@@ -35,7 +35,7 @@ def save_api_key(api_key: str):
         # Set file permissions to read/write for owner only (600)
         os.chmod(CREDENTIALS_FILE, stat.S_IRUSR | stat.S_IWUSR)
     except OSError as e:
-        print(f"Error: Could not write credentials file or set permissions on {CREDENTIALS_FILE}: {e}")
+        print(f"Error: Unable to save credentials file or set permissions on {CREDENTIALS_FILE}: {e}")
 
 
 def load_weco_api_key() -> str | None:
@@ -53,7 +53,7 @@ def load_weco_api_key() -> str | None:
             credentials = json.load(f)
             return credentials.get("api_key")
     except (IOError, json.JSONDecodeError, OSError) as e:
-        print(f"Warning: Could not read or parse credentials file at {CREDENTIALS_FILE}: {e}")
+        print(f"Warning: Unable to read credentials file at {CREDENTIALS_FILE}: {e}")
         return None
 
 
@@ -64,7 +64,7 @@ def clear_api_key():
             os.remove(CREDENTIALS_FILE)
             print("Logged out successfully.")
         except OSError as e:
-            print(f"Error: Could not remove credentials file at {CREDENTIALS_FILE}: {e}")
+            print(f"Error: Unable to remove credentials file at {CREDENTIALS_FILE}: {e}")
     else:
         print("Already logged out.")
 
@@ -129,7 +129,9 @@ def perform_login(console: Console):
                             continue  # Continue polling
                         else:
                             # Unexpected 202 response format
-                            console.print(f"\n[bold red]Error:[/] Received unexpected 202 response: {token_data}")
+                            console.print(
+                                f"\n[bold red]Error:[/] Received unexpected response from authentication server: {token_data}"
+                            )
                             return False
                     # Check for standard OAuth2 errors (often 400 Bad Request)
                     elif token_response.status_code == 400:
@@ -146,7 +148,7 @@ def perform_login(console: Console):
                             console.print("\n[bold red]Error:[/] Authorization denied by user.")
                             return False
                         else:  # invalid_grant, etc.
-                            error_desc = token_data.get("error_description", "Unknown error during polling.")
+                            error_desc = token_data.get("error_description", "Unknown authentication error occurred.")
                             console.print(f"\n[bold red]Error:[/] {error_desc} ({error_code})")
                             return False
 

weco/chatbot.py

@@ -50,7 +50,7 @@ class UserInteractionHelper:
 
                 if attempts >= max_retries:
                     self.console.print(f"[red]Maximum retry attempts ({max_retries}) reached. Exiting.[/]")
-                    raise Exception("Maximum retry attempts exceeded")
+                    raise Exception("Maximum retry attempts exceeded. Please try again.")
 
                 # Show available options without the full prompt
                 if choices:
@@ -66,7 +66,7 @@ class UserInteractionHelper:
                 continue
 
         # This should never be reached due to the exception above, but just in case
-        raise Exception("Unexpected error in choice selection")
+        raise Exception("Unexpected error while selecting a choice")
 
     def get_choice_numeric(self, prompt: str, max_number: int, default: int = None, max_retries: int = 5) -> int:
         """Get numeric choice with validation and error handling."""
@@ -87,7 +87,7 @@ class UserInteractionHelper:
 
                 if attempts >= max_retries:
                     self.console.print(f"[red]Maximum retry attempts ({max_retries}) reached. Exiting.[/]")
-                    raise Exception("Maximum retry attempts exceeded")
+                    raise Exception("Maximum retry attempts exceeded. Please try again.")
 
                 # Show valid range
                 self.console.print(f"Please enter a number between [bold]1[/] and [bold]{max_number}[/]")
@@ -115,7 +115,7 @@ class UserInteractionHelper:
 
                 if attempts >= max_retries:
                     self.console.print(f"[red]Maximum retry attempts ({max_retries}) reached. Exiting.[/]")
-                    raise Exception("Maximum retry attempts exceeded")
+                    raise Exception("Maximum retry attempts exceeded. Please try again.")
 
                 self.console.print("Valid options: [bold]y[/] / [bold]n[/]")
                 if default:
@@ -123,7 +123,7 @@ class UserInteractionHelper:
 
                 continue
 
-        raise Exception("Unexpected error in yes/no selection")
+        raise Exception("Unexpected error while selecting an option")
 
     def display_optimization_options_table(self, options: List[Dict[str, str]]) -> None:
         """Display optimization options in a formatted table."""
@@ -215,7 +215,10 @@ class Chatbot:
 
             with self.console.status("[bold green]Generating optimization suggestions...[/]"):
                 result = get_optimization_suggestions_from_codebase(
-                    self.gitingest_summary, self.gitingest_tree, self.gitingest_content_str, self.console
+                    console=self.console,
+                    gitingest_summary=self.gitingest_summary,
+                    gitingest_tree=self.gitingest_tree,
+                    gitingest_content_str=self.gitingest_content_str,
                 )
 
                 if result and isinstance(result, list):
@@ -224,7 +227,7 @@ class Chatbot:
                     options = None
 
             if not options or not isinstance(options, list):
-                self.console.print("[red]Failed to get valid optimization options.[/]")
+                self.console.print("[red]Unable to retrieve valid optimization options from the backend.[/]")
                 return None
 
             if not options:
@@ -324,17 +327,19 @@ class Chatbot:
             elif action == "g" or action == "r":
                 with self.console.status("[bold green]Generating evaluation script and determining metrics...[/]"):
                     result = generate_evaluation_script_and_metrics(
-                        selected_option["target_file"],
-                        selected_option["description"],
-                        self.gitingest_content_str,
-                        self.console,
+                        console=self.console,
+                        target_file=selected_option["target_file"],
+                        description=selected_option["description"],
+                        gitingest_content_str=self.gitingest_content_str,
                     )
                 if result and result[0]:
                     eval_script_content, metric_name, goal, reasoning = result
                     if reasoning:
                         self.console.print(f"[dim]Reasoning: {reasoning}[/]")
                 else:
-                    self.console.print("[red]Failed to generate an evaluation script.[/]")
+                    self.console.print(
+                        "[red]Unable to generate an evaluation script. Please try providing a custom script path instead.[/]"
+                    )
                     eval_script_content = None
                     metric_name = None
                     goal = None
@@ -371,7 +376,10 @@ class Chatbot:
         # Analyze the script to determine the proper execution command
         with self.console.status("[bold green]Analyzing script execution requirements...[/]"):
             eval_command = analyze_script_execution_requirements(
-                eval_script_content, eval_script_path_str, selected_option["target_file"], self.console
+                console=self.console,
+                script_content=eval_script_content,
+                script_path=eval_script_path_str,
+                target_file=selected_option["target_file"],
             )
 
         return {
@@ -386,16 +394,16 @@ class Chatbot:
         """Get or create evaluation script configuration using intelligent conversation-guided approach."""
         with self.console.status("[bold green]Analyzing evaluation environment...[/]"):
             analysis = analyze_evaluation_environment(
-                selected_option["target_file"],
-                selected_option["description"],
-                self.gitingest_summary,
-                self.gitingest_tree,
-                self.gitingest_content_str,
-                self.console,
+                console=self.console,
+                target_file=selected_option["target_file"],
+                description=selected_option["description"],
+                gitingest_summary=self.gitingest_summary,
+                gitingest_tree=self.gitingest_tree,
+                gitingest_content_str=self.gitingest_content_str,
             )
 
         if not analysis:
-            self.console.print("[yellow]Failed to analyze evaluation environment. Falling back to generation.[/]")
+            self.console.print("[yellow]Unable to analyze evaluation environment. Falling back to script generation.[/]")
             return self.handle_script_generation_workflow(selected_option)
 
         self.evaluation_analysis = analysis
@@ -529,7 +537,10 @@ class Chatbot:
             if not eval_command or eval_command == f"python {script_path}":
                 with self.console.status("[bold green]Analyzing script execution requirements...[/]"):
                     eval_command = analyze_script_execution_requirements(
-                        script_content, script_path, selected_option["target_file"], self.console
+                        console=self.console,
+                        script_content=script_content,
+                        script_path=script_path,
+                        target_file=selected_option["target_file"],
                     )
 
             self.current_step = "confirmation"
@@ -711,7 +722,7 @@ class Chatbot:
         """Setup evaluation environment for the selected optimization."""
         eval_config = self.get_evaluation_configuration(selected_option)
         if not eval_config:
-            self.console.print("[red]Evaluation script setup failed.[/]")
+            self.console.print("[red]Evaluation script setup failed. Please check your script configuration and try again.[/]")
             return None
 
         eval_config = self.confirm_and_finalize_evaluation_config(eval_config)
@@ -791,7 +802,7 @@ def run_onboarding_chatbot(
         chatbot = Chatbot(project_path, console, run_parser, model)
         chatbot.start()
     except Exception as e:
-        console.print(f"[bold red]An unexpected error occurred in the chatbot: {e}[/]")
+        console.print(f"[bold red]An unexpected error occurred: {e}[/]")
         import traceback
 
         traceback.print_exc()

weco/cli.py

@@ -61,6 +61,12 @@ def configure_run_parser(run_parser: argparse.ArgumentParser) -> None:
         type=str,
         help="Description of additional instruction or path to a file containing additional instructions. Defaults to None.",
     )
+    run_parser.add_argument(
+        "--eval-timeout",
+        type=int,
+        default=None,
+        help="Timeout in seconds for each evaluation. No timeout by default. Example: --eval-timeout 3600",
+    )
 
 
 def execute_run_command(args: argparse.Namespace) -> None:
@@ -77,6 +83,7 @@ def execute_run_command(args: argparse.Namespace) -> None:
         log_dir=args.log_dir,
         additional_instructions=args.additional_instructions,
         console=console,
+        eval_timeout=args.eval_timeout,
     )
     exit_code = 0 if success else 1
     sys.exit(exit_code)
@@ -177,7 +184,9 @@ def main() -> None:
 
         project_path = pathlib.Path(filtered_args[0]) if filtered_args else pathlib.Path.cwd()
         if not project_path.is_dir():
-            console.print(f"[bold red]Error:[/] Path '{project_path}' is not a valid directory.")
+            console.print(
+                f"[bold red]Error:[/] The path '{project_path}' is not a valid directory. Please provide a valid directory path."
+            )
             sys.exit(1)
 
         # Pass the run_parser and model to the chatbot

weco/constants.py

@@ -0,0 +1,7 @@
+# weco/constants.py
+"""
+Constants for the Weco CLI package.
+"""
+
+# API timeout configuration (connect_timeout, read_timeout) in seconds
+DEFAULT_API_TIMEOUT = (10, 800)

weco/optimizer.py

@@ -20,7 +20,6 @@ from .api import (
 from .auth import handle_authentication
 from .panels import (
     SummaryPanel,
-    PlanPanel,
     Node,
     MetricTreePanel,
     EvaluationOutputPanel,
@@ -37,6 +36,7 @@ from .utils import (
     smooth_update,
     format_number,
 )
+from .constants import DEFAULT_API_TIMEOUT
 
 
 # --- Heartbeat Sender Class ---
@@ -63,7 +63,7 @@ class HeartbeatSender(threading.Thread):
 
         except Exception as e:
             # Catch any unexpected error in the loop to prevent silent thread death
-            print(f"[ERROR HeartbeatSender] Unhandled exception in run loop for run {self.run_id}: {e}", file=sys.stderr)
+            print(f"[ERROR HeartbeatSender] Unexpected error in heartbeat thread for run {self.run_id}: {e}", file=sys.stderr)
             traceback.print_exc(file=sys.stderr)
             # The loop will break due to the exception, and thread will terminate via finally.
 
@@ -78,6 +78,7 @@ def execute_optimization(
     log_dir: str = ".runs",
     additional_instructions: Optional[str] = None,
     console: Optional[Console] = None,
+    eval_timeout: Optional[int] = None,
 ) -> bool:
     """
     Execute the core optimization logic.
@@ -153,14 +154,13 @@ def execute_optimization(
             "debug_prob": 0.5,
             "max_debug_depth": max(1, math.ceil(0.1 * steps)),
         }
-        timeout = 800
+        api_timeout = DEFAULT_API_TIMEOUT
         processed_additional_instructions = read_additional_instructions(additional_instructions=additional_instructions)
         source_fp = pathlib.Path(source)
         source_code = read_from_path(fp=source_fp, is_json=False)
 
         # --- Panel Initialization ---
         summary_panel = SummaryPanel(maximize=maximize, metric_name=metric, total_steps=steps, model=model, runs_dir=log_dir)
-        plan_panel = PlanPanel()
         solution_panels = SolutionPanels(metric_name=metric, source_fp=source_fp)
         eval_output_panel = EvaluationOutputPanel()
         tree_panel = MetricTreePanel(maximize=maximize)
@@ -181,9 +181,10 @@ def execute_optimization(
             additional_instructions=processed_additional_instructions,
             api_keys=llm_api_keys,
             auth_headers=auth_headers,
-            timeout=timeout,
+            timeout=api_timeout,
         )
         run_id = run_response["run_id"]
+        run_name = run_response["run_name"]
         current_run_id_for_heartbeat = run_id
 
         # --- Start Heartbeat Thread ---
@@ -203,12 +204,14 @@ def execute_optimization(
             write_to_path(fp=source_fp, content=run_response["code"])
 
             # Update the panels with the initial solution
-            summary_panel.set_run_id(run_id=run_id)  # Add run id now that we have it
+            # Add run id and run name now that we have it
+            summary_panel.set_run_id(run_id=run_id)
+            summary_panel.set_run_name(run_name=run_name)
             # Set the step of the progress bar
             summary_panel.set_step(step=0)
             # Update the token counts
             summary_panel.update_token_counts(usage=run_response["usage"])
-            plan_panel.update(plan=run_response["plan"])
+            summary_panel.update_thinking(thinking=run_response["plan"])
             # Build the metric tree
             tree_panel.build_metric_tree(
                 nodes=[
@@ -218,7 +221,7 @@ def execute_optimization(
                         "code": run_response["code"],
                         "step": 0,
                         "metric_value": None,
-                        "is_buggy": False,
+                        "is_buggy": None,
                     }
                 ]
             )
@@ -227,7 +230,7 @@ def execute_optimization(
             # Update the solution panels with the initial solution and get the panel displays
             solution_panels.update(
                 current_node=Node(
-                    id=run_response["solution_id"], parent_id=None, code=run_response["code"], metric=None, is_buggy=False
+                    id=run_response["solution_id"], parent_id=None, code=run_response["code"], metric=None, is_buggy=None
                 ),
                 best_node=None,
             )
@@ -238,7 +241,6 @@ def execute_optimization(
                 layout=layout,
                 sections_to_update=[
                     ("summary", summary_panel.get_display()),
-                    ("plan", plan_panel.get_display()),
                     ("tree", tree_panel.get_display(is_done=False)),
                     ("current_solution", current_solution_panel),
                     ("best_solution", best_solution_panel),
@@ -248,7 +250,7 @@ def execute_optimization(
             )
 
             # Run evaluation on the initial solution
-            term_out = run_evaluation(eval_command=eval_command)
+            term_out = run_evaluation(eval_command=eval_command, timeout=eval_timeout)
             # Update the evaluation output panel
             eval_output_panel.update(output=term_out)
             smooth_update(
@@ -265,7 +267,7 @@ def execute_optimization(
                 if run_id:
                     try:
                         current_status_response = get_optimization_run_status(
-                            run_id=run_id, include_history=False, timeout=30, auth_headers=auth_headers
+                            console=console, run_id=run_id, include_history=False, timeout=(10, 30), auth_headers=auth_headers
                         )
                         current_run_status_val = current_status_response.get("status")
                         if current_run_status_val == "stopping":
@@ -273,30 +275,31 @@ def execute_optimization(
                             user_stop_requested_flag = True
                             break
                     except requests.exceptions.RequestException as e:
-                        console.print(f"\n[bold red]Warning: Could not check run status: {e}. Continuing optimization...[/]")
+                        console.print(f"\n[bold red]Warning: Unable to check run status: {e}. Continuing optimization...[/]")
                     except Exception as e:
                         console.print(f"\n[bold red]Warning: Error checking run status: {e}. Continuing optimization...[/]")
 
                 # Send feedback and get next suggestion
                 eval_and_next_solution_response = evaluate_feedback_then_suggest_next_solution(
+                    console=console,
                     run_id=run_id,
                     execution_output=term_out,
                     additional_instructions=current_additional_instructions,
                     api_keys=llm_api_keys,
                     auth_headers=auth_headers,
-                    timeout=timeout,
+                    timeout=api_timeout,
                 )
                 # Save next solution (.runs/<run-id>/step_<step>.<extension>)
                 write_to_path(fp=runs_dir / f"step_{step}{source_fp.suffix}", content=eval_and_next_solution_response["code"])
                 # Write the next solution to the source file
                 write_to_path(fp=source_fp, content=eval_and_next_solution_response["code"])
                 status_response = get_optimization_run_status(
-                    run_id=run_id, include_history=True, timeout=timeout, auth_headers=auth_headers
+                    console=console, run_id=run_id, include_history=True, timeout=api_timeout, auth_headers=auth_headers
                 )
                 # Update the step of the progress bar, token counts, plan and metric tree
                 summary_panel.set_step(step=step)
                 summary_panel.update_token_counts(usage=eval_and_next_solution_response["usage"])
-                plan_panel.update(plan=eval_and_next_solution_response["plan"])
+                summary_panel.update_thinking(thinking=eval_and_next_solution_response["plan"])
 
                 nodes_list_from_status = status_response.get("nodes")
                 tree_panel.build_metric_tree(nodes=nodes_list_from_status if nodes_list_from_status is not None else [])
@@ -327,7 +330,9 @@ def execute_optimization(
                                 is_buggy=node_data["is_buggy"],
                             )
                 if current_solution_node is None:
-                    raise ValueError("Current solution node not found in nodes list from status response")
+                    raise ValueError(
+                        "Current solution node not found in the optimization status response. This may indicate a synchronization issue with the backend."
+                    )
 
                 # Update the solution panels with the current and best solution
                 solution_panels.update(current_node=current_solution_node, best_node=best_solution_node)
@@ -339,7 +344,6 @@ def execute_optimization(
                     layout=layout,
                     sections_to_update=[
                         ("summary", summary_panel.get_display()),
-                        ("plan", plan_panel.get_display()),
                         ("tree", tree_panel.get_display(is_done=False)),
                         ("current_solution", current_solution_panel),
                         ("best_solution", best_solution_panel),
@@ -347,7 +351,7 @@ def execute_optimization(
                     ],
                     transition_delay=0.08,  # Slightly longer delay for more noticeable transitions
                 )
-                term_out = run_evaluation(eval_command=eval_command)
+                term_out = run_evaluation(eval_command=eval_command, timeout=eval_timeout)
                 eval_output_panel.update(output=term_out)
                 smooth_update(
                     live=live,
@@ -361,17 +365,18 @@ def execute_optimization(
                 current_additional_instructions = read_additional_instructions(additional_instructions=additional_instructions)
                 # Evaluate the final solution thats been generated
                 eval_and_next_solution_response = evaluate_feedback_then_suggest_next_solution(
+                    console=console,
                     run_id=run_id,
                     execution_output=term_out,
                     additional_instructions=current_additional_instructions,
                     api_keys=llm_api_keys,
-                    timeout=timeout,
+                    timeout=api_timeout,
                     auth_headers=auth_headers,
                 )
                 summary_panel.set_step(step=steps)
                 summary_panel.update_token_counts(usage=eval_and_next_solution_response["usage"])
                 status_response = get_optimization_run_status(
-                    run_id=run_id, include_history=True, timeout=timeout, auth_headers=auth_headers
+                    console=console, run_id=run_id, include_history=True, timeout=api_timeout, auth_headers=auth_headers
                 )
                 # No need to update the plan panel since we have finished the optimization
                 # Get the optimization run status for

weco/panels.py

@@ -7,30 +7,40 @@ from rich.syntax import Syntax
 from rich import box
 from typing import Dict, List, Optional, Union, Tuple
 from .utils import format_number
-import pathlib
+from pathlib import Path
 from .__init__ import __dashboard_url__
 
 
 class SummaryPanel:
     """Holds a summary of the optimization run."""
 
-    def __init__(self, maximize: bool, metric_name: str, total_steps: int, model: str, runs_dir: str, run_id: str = None):
+    def __init__(
+        self,
+        maximize: bool,
+        metric_name: str,
+        total_steps: int,
+        model: str,
+        runs_dir: str,
+        run_id: str = None,
+        run_name: str = None,
+    ):
         self.maximize = maximize
         self.metric_name = metric_name
-        self.goal = ("Maximizing" if self.maximize else "Minimizing") + f" {self.metric_name}..."
         self.total_input_tokens = 0
         self.total_output_tokens = 0
         self.total_steps = total_steps
         self.model = model
         self.runs_dir = runs_dir
         self.run_id = run_id if run_id is not None else "N/A"
+        self.run_name = run_name if run_name is not None else "N/A"
         self.dashboard_url = "N/A"
+        self.thinking_content = ""
         self.progress = Progress(
             TextColumn("[progress.description]{task.description}"),
             BarColumn(bar_width=20),
             TextColumn("[progress.percentage]{task.percentage:>3.0f}%"),
             TextColumn("•"),
-            TextColumn("[bold]{task.completed}/{task.total} Steps"),
+            TextColumn("[bold]{task.completed}/{task.total} Steps "),
             expand=False,
         )
         self.task_id = self.progress.add_task("", total=total_steps)
@@ -40,6 +50,10 @@ class SummaryPanel:
         self.run_id = run_id
         self.set_dashboard_url(run_id=run_id)
 
+    def set_run_name(self, run_name: str):
+        """Set the run name."""
+        self.run_name = run_name
+
     def set_dashboard_url(self, run_id: str):
         """Set the dashboard URL."""
         self.dashboard_url = f"{__dashboard_url__}/runs/{run_id}"
@@ -51,69 +65,100 @@ class SummaryPanel:
     def update_token_counts(self, usage: Dict[str, int]):
         """Update token counts from usage data."""
         if not isinstance(usage, dict) or "input_tokens" not in usage or "output_tokens" not in usage:
-            raise ValueError("Invalid token usage response from API.")
+            raise ValueError("Invalid token usage data received.")
         self.total_input_tokens += usage["input_tokens"]
         self.total_output_tokens += usage["output_tokens"]
 
+    def update_thinking(self, thinking: str):
+        """Update the thinking content."""
+        self.thinking_content = thinking
+
+    def clear_thinking(self):
+        """Clear the thinking content."""
+        self.thinking_content = ""
+
     def get_display(self, final_message: Optional[str] = None) -> Panel:
-        """Create a summary panel with the relevant information."""
-        layout = Layout(name="summary")
-        summary_table = Table(show_header=False, box=None, padding=(0, 1))
+        """Return a Rich panel summarising the current run."""
+        # ───────────────────── summary grid ──────────────────────
+        summary_table = Table.grid(expand=True, padding=(0, 1))
+        summary_table.add_column(ratio=1)
+        summary_table.add_column(justify="right")
+        summary_table.add_row("")
 
+        # Dashboard url
+        summary_table.add_row(f" Dashboard: [underline blue]{self.dashboard_url}[/]")
         summary_table.add_row("")
-        # Goal
+
         if final_message is not None:
-            summary_table.add_row(f"[bold cyan]Result:[/] {final_message}")
-        else:
-            summary_table.add_row(f"[bold cyan]Goal:[/] {self.goal}")
-        summary_table.add_row("")
-        # Model used
-        summary_table.add_row(f"[bold cyan]Model:[/] {self.model}")
-        summary_table.add_row("")
-        # Log directory
-        summary_table.add_row(f"[bold cyan]Logs:[/] [blue underline]{self.runs_dir}/{self.run_id}[/]")
-        summary_table.add_row("")
-        # Dashboard link
-        summary_table.add_row(f"[bold cyan]Dashboard:[/] [blue underline]{self.dashboard_url}[/]")
-        summary_table.add_row("")
-        # Token counts
-        summary_table.add_row(
-            f"[bold cyan]Tokens:[/] ↑[yellow]{format_number(self.total_input_tokens)}[/] ↓[yellow]{format_number(self.total_output_tokens)}[/] = [green]{format_number(self.total_input_tokens + self.total_output_tokens)}[/]"
+            # Add the final message
+            summary_table.add_row(f"[bold cyan] Result:[/] {final_message}", "")
+            summary_table.add_row("")
+
+        # Token info
+        token_info = (
+            f"[bold cyan] {self.model}:[/] "
+            f"↑[yellow]{format_number(self.total_input_tokens)}[/] "
+            f"↓[yellow]{format_number(self.total_output_tokens)}[/] = "
+            f"[green]{format_number(self.total_input_tokens + self.total_output_tokens)} Tokens[/]"
         )
+        summary_table.add_row(token_info)
         summary_table.add_row("")
+
         # Progress bar
         summary_table.add_row(self.progress)
+        summary_table.add_row("")
 
-        # Update layout
-        layout.update(summary_table)
-
-        return Panel(layout, title="[bold]📊 Summary", border_style="magenta", expand=True, padding=(0, 1))
-
-
-class PlanPanel:
-    """Displays the optimization plan with truncation for long plans."""
-
-    def __init__(self):
-        self.plan = ""
+        # Logs url
+        logs_url = Path(self.runs_dir) / self.run_id
+        summary_table.add_row(f" Logs: [underline blue]{logs_url}[/]")
+        summary_table.add_row("")
 
-    def update(self, plan: str):
-        """Update the plan text."""
-        self.plan = plan
+        if final_message is not None:
+            # Don't include the thinking section
+            return Panel(
+                summary_table,
+                title=f"[bold]📊 {'Maximizing' if self.maximize else 'Minimizing'} {self.run_name}",
+                border_style="magenta",
+                expand=True,
+                padding=(0, 1),
+            )
 
-    def clear(self):
-        """Clear the plan text."""
-        self.plan = ""
+        # Include the thinking section
+        layout = Layout(name="summary")
+        layout.split_column(
+            Layout(summary_table, name="main_summary", ratio=1),
+            Layout(
+                Panel(
+                    self.thinking_content or "[dim]No thinking content yet...[/]",
+                    title="[bold]📝 Thinking...",
+                    border_style="cyan",
+                    expand=True,
+                    padding=(0, 1),
+                ),
+                name="thinking_section",
+                ratio=1,
+            ),
+        )
 
-    def get_display(self) -> Panel:
-        """Create a panel displaying the plan with truncation if needed."""
-        return Panel(self.plan, title="[bold]📝 Thinking...", border_style="cyan", expand=True, padding=(0, 1))
+        return Panel(
+            layout,
+            title=f"[bold]📊 {'Maximizing' if self.maximize else 'Minimizing'} {self.run_name}",
+            border_style="magenta",
+            expand=True,
+            padding=(0, 1),
+        )
 
 
 class Node:
     """Represents a node in the solution tree."""
 
     def __init__(
-        self, id: str, parent_id: Union[str, None], code: Union[str, None], metric: Union[float, None], is_buggy: bool
+        self,
+        id: str,
+        parent_id: Union[str, None],
+        code: Union[str, None],
+        metric: Union[float, None],
+        is_buggy: Union[bool, None],
     ):
         self.id = id
         self.parent_id = parent_id
@@ -144,12 +189,15 @@ class MetricTree:
         # Add node to node's parent's children
         if node.parent_id is not None:
             if node.parent_id not in self.nodes:
-                raise ValueError("Could not construct tree: parent node not found.")
+                raise ValueError("Cannot construct optimization tree.")
             self.nodes[node.parent_id].children.append(node)
 
-    def get_draft_nodes(self) -> List[Node]:
-        """Get all draft nodes from the tree."""
-        return [node for node in self.nodes.values() if node.parent_id is None]
+    def get_root_node(self) -> Node:
+        """Get the root node from the tree."""
+        nodes = [node for node in self.nodes.values() if node.parent_id is None]
+        if len(nodes) != 1:
+            raise ValueError("Cannot construct optimization tree.")
+        return nodes[0]
 
     def get_best_node(self) -> Optional[Node]:
         """Get the best node from the tree."""
@@ -157,7 +205,8 @@ class MetricTree:
             node
             for node in self.nodes.values()
             if node.evaluated  # evaluated
-            and not node.is_buggy  # not buggy
+            and node.is_buggy
+            is False  # not buggy => is_buggy can exist in 3 states: None (solution has not yet been evaluated for bugs), True (solution has bug), False (solution does not have a bug)
             and node.metric is not None  # has metric
         ]
         if len(measured_nodes) == 0:
@@ -247,8 +296,8 @@ class MetricTreePanel:
                 append_rec(child, subtree)
 
         tree = Tree("", hide_root=True)
-        for n in self.metric_tree.get_draft_nodes():
-            append_rec(n, tree)
+        root_node = self.metric_tree.get_root_node()
+        append_rec(node=root_node, tree=tree)
 
         return tree
 
@@ -286,7 +335,7 @@ class EvaluationOutputPanel:
 class SolutionPanels:
     """Displays the current and best solutions side by side."""
 
-    def __init__(self, metric_name: str, source_fp: pathlib.Path):
+    def __init__(self, metric_name: str, source_fp: Path):
         # Current solution
         self.current_node = None
         # Best solution
@@ -296,7 +345,7 @@ class SolutionPanels:
         # Determine the lexer for the source file
         self.lexer = self._determine_lexer(source_fp)
 
-    def _determine_lexer(self, source_fp: pathlib.Path) -> str:
+    def _determine_lexer(self, source_fp: Path) -> str:
         """Determine the lexer for the source file."""
         return Syntax.from_path(source_fp).lexer
 
@@ -346,10 +395,7 @@ def create_optimization_layout() -> Layout:
     )
 
     # Split the top section into left and right
-    layout["top_section"].split_row(Layout(name="left_panels", ratio=1), Layout(name="tree", ratio=1))
-
-    # Split the left panels into summary and thinking
-    layout["left_panels"].split_column(Layout(name="summary", ratio=2), Layout(name="plan", ratio=1))
+    layout["top_section"].split_row(Layout(name="summary", ratio=1), Layout(name="tree", ratio=1))
 
     # Split the middle section into left and right
     layout["middle_section"].split_row(Layout(name="current_solution", ratio=1), Layout(name="best_solution", ratio=1))

weco/utils.py

@@ -45,7 +45,7 @@ def determine_default_model(llm_api_keys: Dict[str, Any]) -> str:
         return "gemini-2.5-pro"
     else:
         raise ValueError(
-            "No LLM API keys found in environment. Please set one of the following: OPENAI_API_KEY, ANTHROPIC_API_KEY, GEMINI_API_KEY."
+            "No LLM API keys found in environment variables. Please set one of the following: OPENAI_API_KEY, ANTHROPIC_API_KEY, or GEMINI_API_KEY based on your model of choice."
         )
 
 
@@ -84,7 +84,7 @@ def write_to_path(fp: pathlib.Path, content: Union[str, Dict[str, Any]], is_json
         elif isinstance(content, str):
             f.write(content)
         else:
-            raise TypeError("Content must be str or Dict[str, Any]")
+            raise TypeError("Error writing to file. Please verify the file path and try again.")
 
 
 # Visualization helper functions
@@ -124,19 +124,54 @@ def smooth_update(
 
 
 # Other helper functions
-def run_evaluation(eval_command: str) -> str:
+DEFAULT_MAX_LINES = 50
+DEFAULT_MAX_CHARS = 5000
+
+
+def truncate_output(output: str, max_lines: int = DEFAULT_MAX_LINES, max_chars: int = DEFAULT_MAX_CHARS) -> str:
+    """Truncate the output to a reasonable size."""
+    lines = output.splitlines()
+
+    # Determine what truncations are needed based on original output
+    lines_truncated = len(lines) > max_lines
+    chars_truncated = len(output) > max_chars
+
+    # Apply truncations to the original output
+    if lines_truncated:
+        output = "\n".join(lines[-max_lines:])
+
+    if chars_truncated:
+        output = output[-max_chars:]
+
+    # Add prefixes for truncations that were applied
+    prefixes = []
+    if lines_truncated:
+        prefixes.append(f"truncated to last {max_lines} lines")
+    if chars_truncated:
+        prefixes.append(f"truncated to last {max_chars} characters")
+
+    if prefixes:
+        prefix_text = ", ".join(prefixes)
+        output = f"... ({prefix_text})\n{output}"
+
+    return output
+
+
+def run_evaluation(eval_command: str, timeout: int | None = None) -> str:
     """Run the evaluation command on the code and return the output."""
 
     # Run the eval command as is
-    result = subprocess.run(eval_command, shell=True, capture_output=True, text=True, check=False)
-
-    # Combine stdout and stderr for complete output
-    output = result.stderr if result.stderr else ""
-    if result.stdout:
-        if len(output) > 0:
-            output += "\n"
-        output += result.stdout
-    return output
+    try:
+        result = subprocess.run(eval_command, shell=True, capture_output=True, text=True, check=False, timeout=timeout)
+        # Combine stdout and stderr for complete output
+        output = result.stderr if result.stderr else ""
+        if result.stdout:
+            if len(output) > 0:
+                output += "\n"
+            output += result.stdout
+        return truncate_output(output)
+    except subprocess.TimeoutExpired:
+        return f"Evaluation timed out after {'an unspecified duration' if timeout is None else f'{timeout} seconds'}."
 
 
 # Update Check Function

{weco-0.2.23.dist-info → weco-0.2.24.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: weco
-Version: 0.2.23
+Version: 0.2.24
 Summary: Documentation for `weco`, a CLI for using Weco AI's code optimizer.
 Author-email: Weco AI Team <contact@weco.ai>
 License: MIT
@@ -16,6 +16,8 @@ Requires-Dist: requests
 Requires-Dist: rich
 Requires-Dist: packaging
 Requires-Dist: gitingest
+Requires-Dist: fastapi
+Requires-Dist: slowapi
 Provides-Extra: dev
 Requires-Dist: ruff; extra == "dev"
 Requires-Dist: build; extra == "dev"
@@ -158,6 +160,7 @@ For more advanced examples, including [Triton](/examples/triton/README.md), [CUD
 | `-M, --model`                  | Model identifier for the LLM to use (e.g., `o4-mini`, `claude-sonnet-4-0`).                                                                                                        | `o4-mini` when `OPENAI_API_KEY` is set; `claude-sonnet-4-0` when `ANTHROPIC_API_KEY` is set; `gemini-2.5-pro` when `GEMINI_API_KEY` is set. | `-M o4-mini`         |
 | `-i, --additional-instructions`| Natural language description of specific instructions **or** path to a file containing detailed instructions to guide the LLM.                                                                                             | `None`                                                                                                                                                  | `-i instructions.md` or `-i "Optimize the model for faster inference"`|
 | `-l, --log-dir`                | Path to the directory to log intermediate steps and final optimization result.                                                                                                                                             | `.runs/`                                                                                                                                               | `-l ./logs/`        |
+| `--eval-timeout`       | Timeout in seconds for each step in evaluation.                                                                                                                                                                             | No timeout (unlimited)                                                                                                                                                  | `--eval-timeout 3600`             |
 
 ---
 
@@ -248,28 +251,38 @@ Final speedup value = 1.5
 
 Weco will parse this output to extract the numerical value (1.5 in this case) associated with the metric name ('speedup').
 
-## Contributing
+## Supported Models
 
-We welcome your contributions! To get started:
+Weco supports the following LLM models:
 
-1.  **Fork & Clone the Repository:**
-    ```bash
-    git clone https://github.com/WecoAI/weco-cli.git
-    cd weco-cli
-    ```
+### OpenAI Models
+- `o3`
+- `o3-mini`
+- `o4-mini`
+- `o1-pro`
+- `o1`
+- `gpt-4.1`
+- `gpt-4.1-mini`
+- `gpt-4.1-nano`
+- `gpt-4o`
+- `gpt-4o-mini`
 
-2.  **Install Dependencies:**
-    ```bash
-    pip install -e ".[dev]"
-    ```
+### Anthropic Models
+- `claude-opus-4-0`
+- `claude-sonnet-4-0`
+- `claude-3-7-sonnet-latest`
 
-3.  **Create a Feature Branch:**
-    ```bash
-    git checkout -b feature/your-feature-name
-    ```
+### Gemini Models
+- `gemini-2.5-pro`
+- `gemini-2.5-flash`
+- `gemini-2.5-flash-lite`
+
+You can specify any of these models using the `-M` or `--model` flag. Ensure you have the corresponding API key set as an environment variable for the model provider you wish to use.
 
-4.  **Make Changes:** Ensure your code adheres to our style guidelines and includes relevant tests.
+---
+
+## Contributing
 
-5.  **Commit, Push & Open a PR**: Commit your changes, and open a pull request with a clear description of your enhancements.
+We welcome contributions! Please see [contributing.md](contributing.md) for detailed guidelines on how to contribute to this project.
 
 ---

weco-0.2.24.dist-info/RECORD

@@ -0,0 +1,15 @@
+weco/__init__.py,sha256=ClO0uT6GKOA0iSptvP0xbtdycf0VpoPTq37jHtvlhtw,303
+weco/api.py,sha256=sdRgSvbjStGr5Bywkp4Pkuo9jgtGp95tNzsVXrXmH00,13380
+weco/auth.py,sha256=KMSAsN1V5wx7KUsYL1cEOOiG29Pqf4Exb3EPW4mAWC0,10003
+weco/chatbot.py,sha256=MSG3yybZ0fHTpwW3If9TpOWOAE4EqrcUWpe3q16AjZE,37673
+weco/cli.py,sha256=75JdYpUf0qdJW5pjycZoHUKA2n2MYj33qYM9WQwLT2s,8184
+weco/constants.py,sha256=vfQGDf9_kzlN9BzEFvMsd0EeXOsRyzpvSWyxOJgRauE,168
+weco/optimizer.py,sha256=E5Jii0rTdI9pxkstaM7ipjF4viX5XnSy5w71gdps4Ws,23662
+weco/panels.py,sha256=jwAV_uoa0ZI9vjyey-hSY3rx4pfNNkZvPzqt-iz-RXo,16808
+weco/utils.py,sha256=HecbOqD5rBuVhUkLixVrTWBMJ-ZMAhK-889N-lCk3dQ,7335
+weco-0.2.24.dist-info/licenses/LICENSE,sha256=p_GQqJBvuZgkLNboYKyH-5dhpTDlKs2wq2TVM55WrWE,1065
+weco-0.2.24.dist-info/METADATA,sha256=yFq-NPCUsh59B4Pj9IlYjDo53Kzjya5Rk_9-QmheGLM,16069
+weco-0.2.24.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+weco-0.2.24.dist-info/entry_points.txt,sha256=ixJ2uClALbCpBvnIR6BXMNck8SHAab8eVkM9pIUowcs,39
+weco-0.2.24.dist-info/top_level.txt,sha256=F0N7v6e2zBSlsorFv-arAq2yDxQbzX3KVO8GxYhPUeE,5
+weco-0.2.24.dist-info/RECORD,,

weco-0.2.23.dist-info/RECORD

@@ -1,14 +0,0 @@
-weco/__init__.py,sha256=ClO0uT6GKOA0iSptvP0xbtdycf0VpoPTq37jHtvlhtw,303
-weco/api.py,sha256=hqAyMHGQhJr8BZTUo0jznfO0ossGU3ehEZZehPu6Mu8,11838
-weco/auth.py,sha256=6bDQv07sx7uxA9CrN3HqUdCHV6nqXO41PGCicquvB00,9919
-weco/chatbot.py,sha256=H6d5yK9MB3pqpE7XVh_HAi1YAmxKy0v_xdozVSlKPCc,36959
-weco/cli.py,sha256=Jy7kQEsNKdV7Wds9Z0DIWBeLpEVyssIiOBiQ4zCl3Lw,7862
-weco/optimizer.py,sha256=z86-js_rvLMv3J8zCqvtc1xJC0EA0WqrN9_BlmX2RK4,23259
-weco/panels.py,sha256=Cnro4Q65n7GGh0FBXuB_OGSxRVobd4k5lOuBViTQaaM,15591
-weco/utils.py,sha256=5Pbhv_5wbTRv93Ws7aJfIOtcxeeqNrDRT3bV6YFOdgM,6032
-weco-0.2.23.dist-info/licenses/LICENSE,sha256=p_GQqJBvuZgkLNboYKyH-5dhpTDlKs2wq2TVM55WrWE,1065
-weco-0.2.23.dist-info/METADATA,sha256=E_u4w-WaRzBVYrlEzraepi0y7E1Cc1zHOhBu4Cp01TI,15445
-weco-0.2.23.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-weco-0.2.23.dist-info/entry_points.txt,sha256=ixJ2uClALbCpBvnIR6BXMNck8SHAab8eVkM9pIUowcs,39
-weco-0.2.23.dist-info/top_level.txt,sha256=F0N7v6e2zBSlsorFv-arAq2yDxQbzX3KVO8GxYhPUeE,5
-weco-0.2.23.dist-info/RECORD,,