weco 0.3.4__py3-none-any.whl → 0.3.6__py3-none-any.whl

weco/optimizer.py

@@ -127,14 +127,15 @@ def execute_optimization(
     eval_command: str,
     metric: str,
     goal: str,  # "maximize" or "minimize"
+    model: str,
     steps: int = 100,
-    model: Optional[str] = None,
     log_dir: str = ".runs",
     additional_instructions: Optional[str] = None,
     console: Optional[Console] = None,
     eval_timeout: Optional[int] = None,
     save_logs: bool = False,
     apply_change: bool = False,
+    api_keys: Optional[dict[str, str]] = None,
 ) -> bool:
     """
     Execute the core optimization logic.
@@ -144,17 +145,25 @@ def execute_optimization(
     """
     if console is None:
         console = Console()
-
     # Global variables for this optimization run
     heartbeat_thread = None
     stop_heartbeat_event = threading.Event()
     current_run_id_for_heartbeat = None
     current_auth_headers_for_heartbeat = {}
+    live_ref = None  # Reference to the Live object for the optimization run
+
+    best_solution_code = None
+    original_source_code = None
 
     # --- Signal Handler for this optimization run ---
     def signal_handler(signum, frame):
+        nonlocal live_ref
+
+        if live_ref is not None:
+            live_ref.stop()  # Stop the live update loop so that messages are printed to the console
+
         signal_name = signal.Signals(signum).name
-        console.print(f"\n[bold yellow]Termination signal ({signal_name}) received. Shutting down...[/]")
+        console.print(f"\n[bold yellow]Termination signal ({signal_name}) received. Shutting down...[/]\n")
 
         # Stop heartbeat thread
         stop_heartbeat_event.set()
@@ -170,7 +179,7 @@ def execute_optimization(
                 details=f"Process terminated by signal {signal_name} ({signum}).",
                 auth_headers=current_auth_headers_for_heartbeat,
             )
-            console.print(f"\n[cyan]To resume this run, use:[/] [bold cyan]weco resume {current_run_id_for_heartbeat}[/]")
+            console.print(f"[cyan]To resume this run, use:[/] [bold cyan]weco resume {current_run_id_for_heartbeat}[/]\n")
 
         # Exit gracefully
         sys.exit(0)
@@ -183,8 +192,6 @@ def execute_optimization(
     optimization_completed_normally = False
     user_stop_requested_flag = False
 
-    best_solution_code = None
-    original_source_code = None  # Make available to the finally block
     try:
         # --- Login/Authentication Handling (now mandatory) ---
         weco_api_key, auth_headers = handle_authentication(console)
@@ -197,11 +204,6 @@ def execute_optimization(
         # --- Process Parameters ---
         maximize = goal.lower() in ["maximize", "max"]
 
-        # Determine the model to use
-        if model is None:
-            # Default to o4-mini with credit-based billing
-            model = "o4-mini"
-
         code_generator_config = {"model": model}
         evaluator_config = {"model": model, "include_analysis": True}
         search_policy_config = {
@@ -239,6 +241,7 @@ def execute_optimization(
             save_logs=save_logs,
             log_dir=log_dir,
             auth_headers=auth_headers,
+            api_keys=api_keys,
         )
         # Indicate the endpoint failed to return a response and the optimization was unsuccessful
         if run_response is None:
@@ -256,6 +259,7 @@ def execute_optimization(
         # --- Live Update Loop ---
         refresh_rate = 4
         with Live(layout, refresh_per_second=refresh_rate) as live:
+            live_ref = live
             # Define the runs directory (.runs/<run-id>) to store logs and results
             runs_dir = pathlib.Path(log_dir) / run_id
             runs_dir.mkdir(parents=True, exist_ok=True)
@@ -364,7 +368,12 @@ def execute_optimization(
 
                 # Send feedback and get next suggestion
                 eval_and_next_solution_response = evaluate_feedback_then_suggest_next_solution(
-                    console=console, step=step, run_id=run_id, execution_output=term_out, auth_headers=auth_headers
+                    console=console,
+                    step=step,
+                    run_id=run_id,
+                    execution_output=term_out,
+                    auth_headers=auth_headers,
+                    api_keys=api_keys,
                 )
                 # 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"])
@@ -387,6 +396,16 @@ def execute_optimization(
                     status_response=status_response, solution_id=eval_and_next_solution_response["solution_id"]
                 )
 
+                # Set best solution and save optimization results
+                try:
+                    best_solution_code = best_solution_node.code
+                except AttributeError:
+                    # Can happen if the code was buggy
+                    best_solution_code = read_from_path(fp=runs_dir / f"step_0{source_fp.suffix}", is_json=False)
+
+                # Save best solution to .runs/<run-id>/best.<extension>
+                write_to_path(fp=runs_dir / f"best{source_fp.suffix}", content=best_solution_code)
+
                 # Update the solution panels with the current and best solution
                 solution_panels.update(current_node=current_solution_node, best_node=best_solution_node)
                 current_solution_panel, best_solution_panel = solution_panels.get_display(current_step=step)
@@ -428,7 +447,12 @@ def execute_optimization(
             if not user_stop_requested_flag:
                 # Evaluate the final solution thats been generated
                 eval_and_next_solution_response = evaluate_feedback_then_suggest_next_solution(
-                    console=console, step=steps, run_id=run_id, execution_output=term_out, auth_headers=auth_headers
+                    console=console,
+                    step=steps,
+                    run_id=run_id,
+                    execution_output=term_out,
+                    auth_headers=auth_headers,
+                    api_keys=api_keys,
                 )
                 summary_panel.set_step(step=steps)
                 status_response = get_optimization_run_status(
@@ -443,10 +467,13 @@ def execute_optimization(
                 )
                 # No need to set any solution to unevaluated since we have finished the optimization
                 # and all solutions have been evaluated
-                # No neeed to update the current solution panel since we have finished the optimization
+                # No need to update the current solution panel since we have finished the optimization
                 # We only need to update the best solution panel
                 # Figure out if we have a best solution so far
                 best_solution_node = get_best_node_from_status(status_response=status_response)
+                best_solution_code = best_solution_node.code
+                # Save best solution to .runs/<run-id>/best.<extension>
+                write_to_path(fp=runs_dir / f"best{source_fp.suffix}", content=best_solution_code)
                 solution_panels.update(current_node=None, best_node=best_solution_node)
                 _, best_solution_panel = solution_panels.get_display(current_step=steps)
                 # Update the end optimization layout
@@ -459,17 +486,6 @@ def execute_optimization(
                 end_optimization_layout["tree"].update(tree_panel.get_display(is_done=True))
                 end_optimization_layout["best_solution"].update(best_solution_panel)
 
-                # Save optimization results
-                # If the best solution does not exist or is has not been measured at the end of the optimization
-                # save the original solution as the best solution
-                try:
-                    best_solution_code = best_solution_node.code
-                except AttributeError:
-                    best_solution_code = read_from_path(fp=runs_dir / f"step_0{source_fp.suffix}", is_json=False)
-
-                # Save best solution to .runs/<run-id>/best.<extension>
-                write_to_path(fp=runs_dir / f"best{source_fp.suffix}", content=best_solution_code)
-
                 # Mark as completed normally for the finally block
                 optimization_completed_normally = True
                 live.update(end_optimization_layout)
@@ -481,7 +497,7 @@ def execute_optimization(
         except Exception:
             error_message = str(e)
         console.print(Panel(f"[bold red]Error: {error_message}", title="[bold red]Optimization Error", border_style="red"))
-        console.print(f"\n[cyan]To resume this run, use:[/] [bold cyan]weco resume {run_id}[/]")
+        console.print(f"\n[cyan]To resume this run, use:[/] [bold cyan]weco resume {run_id}[/]\n")
         # Ensure optimization_completed_normally is False
         optimization_completed_normally = False
     finally:
@@ -508,20 +524,16 @@ def execute_optimization(
                     else "CLI terminated unexpectedly without a specific exception captured."
                 )
 
-            # raise Exception(best_solution_code, original_source_code)
             if best_solution_code and best_solution_code != original_source_code:
                 # Determine whether to apply: automatically if --apply-change is set, otherwise ask user
-                should_apply = apply_change or summary_panel.ask_user_feedback(
-                    live=live,
-                    layout=end_optimization_layout,
-                    question="Would you like to apply the best solution to the source file?",
-                    default=True,
+                should_apply = apply_change or Confirm.ask(
+                    "Would you like to apply the best solution to the source file?", default=True
                 )
                 if should_apply:
                     write_to_path(fp=source_fp, content=best_solution_code)
-                    console.print("[green]Best solution applied to the source file.[/]\n")
+                    console.print("\n[green]Best solution applied to the source file.[/]\n")
             else:
-                console.print("[green]A better solution was not found. No changes to apply.[/]\n")
+                console.print("\n[green]A better solution was not found. No changes to apply.[/]\n")
 
             report_termination(
                 run_id=run_id,
@@ -534,12 +546,14 @@ def execute_optimization(
         # Handle exit
         if user_stop_requested_flag:
             console.print("[yellow]Run terminated by user request.[/]")
-            console.print(f"\n[cyan]To resume this run, use:[/] [bold cyan]weco resume {run_id}[/]")
+            console.print(f"\n[cyan]To resume this run, use:[/] [bold cyan]weco resume {run_id}[/]\n")
 
     return optimization_completed_normally or user_stop_requested_flag
 
 
-def resume_optimization(run_id: str, console: Optional[Console] = None, apply_change: bool = False) -> bool:
+def resume_optimization(
+    run_id: str, console: Optional[Console] = None, apply_change: bool = False, api_keys: Optional[dict[str, str]] = None
+) -> bool:
     """Resume an interrupted run from the most recent node and continue optimization."""
     if console is None:
         console = Console()
@@ -549,11 +563,19 @@ def resume_optimization(run_id: str, console: Optional[Console] = None, apply_ch
     stop_heartbeat_event = threading.Event()
     current_run_id_for_heartbeat = None
     current_auth_headers_for_heartbeat = {}
+    live_ref = None  # Reference to the Live object for the optimization run
+
+    best_solution_code = None
+    original_source_code = None
 
     # Signal handler for this optimization run
     def signal_handler(signum, frame):
+        nonlocal live_ref
+        if live_ref is not None:
+            live_ref.stop()  # Stop the live update loop so that messages are printed to the console
+
         signal_name = signal.Signals(signum).name
-        console.print(f"\n[bold yellow]Termination signal ({signal_name}) received. Shutting down...[/]")
+        console.print(f"\n[bold yellow]Termination signal ({signal_name}) received. Shutting down...[/]\n")
         stop_heartbeat_event.set()
         if heartbeat_thread and heartbeat_thread.is_alive():
             heartbeat_thread.join(timeout=2)
@@ -565,7 +587,7 @@ def resume_optimization(run_id: str, console: Optional[Console] = None, apply_ch
                 details=f"Process terminated by signal {signal_name} ({signum}).",
                 auth_headers=current_auth_headers_for_heartbeat,
             )
-            console.print(f"\n[cyan]To resume this run, use:[/] [bold cyan]weco resume {current_run_id_for_heartbeat}[/]")
+            console.print(f"\n[cyan]To resume this run, use:[/] [bold cyan]weco resume {current_run_id_for_heartbeat}[/]\n")
         sys.exit(0)
 
     # Set up signal handlers for this run
@@ -575,9 +597,6 @@ def resume_optimization(run_id: str, console: Optional[Console] = None, apply_ch
     optimization_completed_normally = False
     user_stop_requested_flag = False
 
-    best_solution_code = None
-    original_source_code = None
-
     try:
         # --- Login/Authentication Handling (now mandatory) ---
         weco_api_key, auth_headers = handle_authentication(console)
@@ -659,9 +678,8 @@ def resume_optimization(run_id: str, console: Optional[Console] = None, apply_ch
         source_fp.parent.mkdir(parents=True, exist_ok=True)
         # Store the original content to restore after each evaluation
         original_source_code = read_from_path(fp=source_fp, is_json=False) if source_fp.exists() else ""
-
+        # The code to restore is the code from the last step of the previous run
         code_to_restore = resume_resp.get("code") or resume_resp.get("source_code") or ""
-        write_to_path(fp=source_fp, content=code_to_restore)
 
         # Prepare UI panels
         summary_panel = SummaryPanel(
@@ -687,12 +705,25 @@ def resume_optimization(run_id: str, console: Optional[Console] = None, apply_ch
         best_solution_node = get_best_node_from_status(status_response=status)
         current_solution_node = get_node_from_status(status_response=status, solution_id=resume_resp.get("solution_id"))
 
+        # If there's no best solution yet (baseline evaluation didn't complete),
+        # mark the current node as unevaluated so the tree renders correctly
+        if best_solution_node is None:
+            tree_panel.set_unevaluated_node(node_id=resume_resp.get("solution_id"))
+
         # Ensure runs dir exists
         runs_dir = pathlib.Path(log_dir) / resume_resp["run_id"]
         runs_dir.mkdir(parents=True, exist_ok=True)
         # Persist last step's code into logs as step_<current_step>
         write_to_path(fp=runs_dir / f"step_{current_step}{source_fp.suffix}", content=code_to_restore)
 
+        # Initialize best solution code
+        try:
+            best_solution_code = best_solution_node.code
+        except AttributeError:
+            # Edge case: best solution node is not available.
+            # This can happen if the user has cancelled the run before even running the baseline solution
+            pass  # Leave best solution code as None
+
         # Start Heartbeat Thread
         stop_heartbeat_event.clear()
         heartbeat_thread = HeartbeatSender(resume_resp["run_id"], auth_headers, stop_heartbeat_event)
@@ -705,6 +736,7 @@ def resume_optimization(run_id: str, console: Optional[Console] = None, apply_ch
         # --- Live UI ---
         refresh_rate = 4
         with Live(layout, refresh_per_second=refresh_rate) as live:
+            live_ref = live
             # Initial panels
             current_solution_panel, best_solution_panel = solution_panels.get_display(current_step=current_step)
             # Use backend-provided execution output only (no fallback)
@@ -769,6 +801,7 @@ def resume_optimization(run_id: str, console: Optional[Console] = None, apply_ch
                     run_id=resume_resp["run_id"],
                     execution_output=term_out,
                     auth_headers=auth_headers,
+                    api_keys=api_keys,
                 )
 
                 # Save next solution to logs
@@ -788,6 +821,16 @@ def resume_optimization(run_id: str, console: Optional[Console] = None, apply_ch
                     status_response=status_response, solution_id=eval_and_next_solution_response["solution_id"]
                 )
 
+                # Set best solution and save optimization results
+                try:
+                    best_solution_code = best_solution_node.code
+                except AttributeError:
+                    # Can happen if the code was buggy
+                    best_solution_code = read_from_path(fp=runs_dir / f"step_0{source_fp.suffix}", is_json=False)
+
+                # Save best solution to .runs/<run-id>/best.<extension>
+                write_to_path(fp=runs_dir / f"best{source_fp.suffix}", content=best_solution_code)
+
                 solution_panels.update(current_node=current_solution_node, best_node=best_solution_node)
                 current_solution_panel, best_solution_panel = solution_panels.get_display(current_step=step)
                 eval_output_panel.clear()
@@ -830,6 +873,7 @@ def resume_optimization(run_id: str, console: Optional[Console] = None, apply_ch
                     run_id=resume_resp["run_id"],
                     execution_output=term_out,
                     auth_headers=auth_headers,
+                    api_keys=api_keys,
                 )
                 summary_panel.set_step(step=total_steps)
                 status_response = get_optimization_run_status(
@@ -839,6 +883,10 @@ def resume_optimization(run_id: str, console: Optional[Console] = None, apply_ch
                 tree_panel.build_metric_tree(nodes=nodes_final)
                 # Best solution panel and final message
                 best_solution_node = get_best_node_from_status(status_response=status_response)
+                best_solution_code = best_solution_node.code
+                # Save best solution to .runs/<run-id>/best.<extension>
+                write_to_path(fp=runs_dir / f"best{source_fp.suffix}", content=best_solution_code)
+
                 solution_panels.update(current_node=None, best_node=best_solution_node)
                 _, best_solution_panel = solution_panels.get_display(current_step=total_steps)
                 final_message = (
@@ -850,14 +898,6 @@ def resume_optimization(run_id: str, console: Optional[Console] = None, apply_ch
                 end_optimization_layout["tree"].update(tree_panel.get_display(is_done=True))
                 end_optimization_layout["best_solution"].update(best_solution_panel)
 
-                # Save best
-                try:
-                    best_solution_code = best_solution_node.code
-                except AttributeError:
-                    best_solution_code = read_from_path(fp=runs_dir / f"step_0{source_fp.suffix}", is_json=False)
-
-                write_to_path(fp=runs_dir / f"best{source_fp.suffix}", content=best_solution_code)
-
                 optimization_completed_normally = True
                 live.update(end_optimization_layout)
 
@@ -867,7 +907,7 @@ def resume_optimization(run_id: str, console: Optional[Console] = None, apply_ch
         except Exception:
             error_message = str(e)
         console.print(Panel(f"[bold red]Error: {error_message}", title="[bold red]Optimization Error", border_style="red"))
-        console.print(f"\n[cyan]To resume this run, use:[/] [bold cyan]weco resume {run_id}[/]")
+        console.print(f"\n[cyan]To resume this run, use:[/] [bold cyan]weco resume {run_id}[/]\n")
         optimization_completed_normally = False
     finally:
         signal.signal(signal.SIGINT, original_sigint_handler)
@@ -896,17 +936,14 @@ def resume_optimization(run_id: str, console: Optional[Console] = None, apply_ch
                 )
 
             if best_solution_code and best_solution_code != original_source_code:
-                should_apply = apply_change or summary_panel.ask_user_feedback(
-                    live=live,
-                    layout=end_optimization_layout,
-                    question="Would you like to apply the best solution to the source file?",
-                    default=True,
+                should_apply = apply_change or Confirm.ask(
+                    "Would you like to apply the best solution to the source file?", default=True
                 )
                 if should_apply:
                     write_to_path(fp=source_fp, content=best_solution_code)
-                    console.print("[green]Best solution applied to the source file.[/]\n")
+                    console.print("\n[green]Best solution applied to the source file.[/]\n")
             else:
-                console.print("[green]A better solution was not found. No changes to apply.[/]\n")
+                console.print("\n[green]A better solution was not found. No changes to apply.[/]\n")
 
             report_termination(
                 run_id=run_id,
@@ -917,5 +954,5 @@ def resume_optimization(run_id: str, console: Optional[Console] = None, apply_ch
             )
         if user_stop_requested_flag:
             console.print("[yellow]Run terminated by user request.[/]")
-            console.print(f"\n[cyan]To resume this run, use:[/] [bold cyan]weco resume {run_id}[/]")
+            console.print(f"\n[cyan]To resume this run, use:[/] [bold cyan]weco resume {run_id}[/]\n")
     return optimization_completed_normally or user_stop_requested_flag

weco/panels.py

@@ -6,9 +6,7 @@ from rich.panel import Panel
 from rich.syntax import Syntax
 from rich import box
 from rich.console import Console
-from rich.live import Live
 
-from rich.prompt import Confirm
 from typing import Dict, List, Optional, Union, Tuple
 from pathlib import Path
 from .__init__ import __dashboard_url__
@@ -74,25 +72,6 @@ class SummaryPanel:
         """Clear the thinking content."""
         self.thinking_content = ""
 
-    def ask_user_feedback(self, live: Live, layout: Layout, question: str, default: bool = True) -> bool:
-        """
-        Ask a yes/no question while keeping the main layout fixed.
-        Uses Rich's Confirm for a clean user experience.
-        """
-        # Stop live updates temporarily to prevent layout from moving
-        live.stop()
-
-        try:
-            # Use Rich's built-in Confirm
-            result = Confirm.ask(question, default=default)
-        except (KeyboardInterrupt, EOFError):
-            result = default
-        finally:
-            # Resume live updates
-            live.start()
-
-        return result
-
     def get_display(self, final_message: Optional[str] = None) -> Panel:
         """Return a Rich panel summarising the current run."""
         # ───────────────────── summary grid ──────────────────────

weco/utils.py

@@ -9,13 +9,26 @@ from rich.panel import Panel
 import pathlib
 import requests
 from packaging.version import parse as parse_version
-from .constants import TRUNCATION_THRESHOLD, TRUNCATION_KEEP_LENGTH, DEFAULT_MODEL, SUPPORTED_FILE_EXTENSIONS
+from .constants import TRUNCATION_THRESHOLD, TRUNCATION_KEEP_LENGTH, SUPPORTED_FILE_EXTENSIONS, DEFAULT_MODELS
 
 
-# Env/arg helper functions
-def determine_model_for_onboarding() -> str:
-    """Determine which model to use for onboarding chatbot. Defaults to o4-mini."""
-    return DEFAULT_MODEL
+class UnrecognizedAPIKeysError(Exception):
+    """Exception raised when unrecognized API keys are provided."""
+
+    def __init__(self, api_keys: dict[str, str]):
+        self.api_keys = api_keys
+        providers = {provider for provider, _ in DEFAULT_MODELS}
+        super().__init__(
+            f"Unrecognized API key provider in {set(api_keys.keys())}. Supported providers: {', '.join(providers)}"
+        )
+
+
+class DefaultModelNotFoundError(Exception):
+    """Exception raised when no default model is found for the API keys."""
+
+    def __init__(self, api_keys: dict[str, str]):
+        self.api_keys = api_keys
+        super().__init__(f"No default model found for any of the provided API keys: {set(api_keys.keys())}")
 
 
 def read_additional_instructions(additional_instructions: str | None) -> str | None:
@@ -218,3 +231,18 @@ def check_for_cli_updates():
     except Exception:
         # Catch any other unexpected error during the check
         pass
+
+
+def get_default_model(api_keys: dict[str, str] | None = None) -> str:
+    """Determine the default model to use based on the API keys."""
+    providers = {provider for provider, _ in DEFAULT_MODELS}
+    if api_keys and not all(provider in providers for provider in api_keys.keys()):
+        raise UnrecognizedAPIKeysError(api_keys)
+
+    if api_keys:
+        for provider, model in DEFAULT_MODELS:
+            if provider in api_keys:
+                return model
+        # Should never happen, but just in case
+        raise DefaultModelNotFoundError(api_keys)
+    return DEFAULT_MODELS[0][1]

{weco-0.3.4.dist-info → weco-0.3.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: weco
-Version: 0.3.4
+Version: 0.3.6
 Summary: Documentation for `weco`, a CLI for using Weco AI's code optimizer.
 Author-email: Weco AI Team <contact@weco.ai>
 License: 
@@ -224,6 +224,7 @@ Provides-Extra: dev
 Requires-Dist: ruff; extra == "dev"
 Requires-Dist: build; extra == "dev"
 Requires-Dist: setuptools_scm; extra == "dev"
+Requires-Dist: pytest>=7.0.0; extra == "dev"
 Dynamic: license-file
 
 <div align="center">
@@ -323,6 +324,7 @@ For more advanced examples, including [Triton](/examples/triton/README.md), [CUD
 | `--eval-timeout`       | Timeout in seconds for each step in evaluation.                                                                                                                                                                             | No timeout (unlimited)                                                                                                                                                  | `--eval-timeout 3600`             |
 | `--save-logs`          | Save execution output from each optimization step to disk. Creates timestamped directories with raw output files and a JSONL index for tracking execution history.                                                        | `False`                                                                                                                                                 | `--save-logs`       |
 | `--apply-change`       | Automatically apply the best solution to the source file without prompting.                                                                                                                                                | `False`                                                                                                                                                 | `--apply-change`       |
+| `--api-key`            | API keys for LLM providers (BYOK). Format: `provider=key`. Can specify multiple providers.                                                                                                                                  | `None`                                                                                                                                                  | `--api-key openai=sk-xxx` |
 
 ---
 
@@ -377,6 +379,7 @@ Arguments for `weco resume`:
 |----------|-------------|---------|
 | `run-id` | The UUID of the run to resume (shown at the start of each run) | `0002e071-1b67-411f-a514-36947f0c4b31` |
 | `--apply-change` | Automatically apply the best solution to the source file without prompting | `--apply-change` |
+| `--api-key` | (Optional) API keys for LLM providers (BYOK). Format: `provider=key` | `--api-key openai=sk-xxx` |
 
 Notes:
 - Works only for interrupted runs (status: `error`, `terminated`, etc.).

weco-0.3.6.dist-info/RECORD

@@ -0,0 +1,15 @@
+weco/__init__.py,sha256=ClO0uT6GKOA0iSptvP0xbtdycf0VpoPTq37jHtvlhtw,303
+weco/api.py,sha256=xVVRk1pj9jpjTphaInkkAhjqhgFP2-6zHT_V-5Du1Fc,13629
+weco/auth.py,sha256=O31Hoj-Loi8DWJJG2LfeWgUMuNqAUeGDpd2ZGjA9Ah0,9997
+weco/cli.py,sha256=Mtkv3rE1rQLdeoVydn30EUi1ki3Cyu45Q3cONnQH4QY,11210
+weco/constants.py,sha256=Wt1VI76smsU0Gsg-HSB9e3V1ZjjsMYXJJg2G9Rb-nQc,519
+weco/credits.py,sha256=C08x-TRcLg3ccfKqMGNRY7zBn7t3r7LZ119bxgfztaI,7629
+weco/optimizer.py,sha256=2qYweESOAer26gjjhu4dg01XmuhtA2nMrJuijaxizzE,45492
+weco/panels.py,sha256=POHt0MdRKDykwUJYXcry92O41lpB9gxna55wFI9abWU,16272
+weco/utils.py,sha256=v_rvgw-ktRoXrpPA2copngI8QDCB8UXmbiN-wAiYvEE,9450
+weco-0.3.6.dist-info/licenses/LICENSE,sha256=9LUfoGHjLPtak2zps2kL2tm65HAZIICx_FbLaRuS4KU,11337
+weco-0.3.6.dist-info/METADATA,sha256=-BKVxw7j_Qe5ksblcmoVF_NVeDDIcWTg-CsUUaadAgs,29835
+weco-0.3.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+weco-0.3.6.dist-info/entry_points.txt,sha256=ixJ2uClALbCpBvnIR6BXMNck8SHAab8eVkM9pIUowcs,39
+weco-0.3.6.dist-info/top_level.txt,sha256=F0N7v6e2zBSlsorFv-arAq2yDxQbzX3KVO8GxYhPUeE,5
+weco-0.3.6.dist-info/RECORD,,