Merge branch 'main' into allow-run-locally

Author: klieret

README.md

@@ -51,22 +51,19 @@ Read our paper for more details [coming soon!].
 You can run the software directly using Docker. 
 
 1. [Install Docker](https://docs.docker.com/engine/install/), then start Docker locally.
-2. Run `docker pull --platform=linux/arm64 sweagent/swe-agent:latest` (replace `arm64` with `amd64` if you're running on x86)
+2. Run `docker pull sweagent/swe-agent:latest`
 3. Add your API tokens to a file `keys.cfg` as explained [below](#-add-your-api-keystokens)
 
 Then run
 
 ```bash
-# Please remove all comments (lines starting with '#') before running this command!
+# NOTE:
+# This assumes that keys.cfg is in your current directory (else fix the path below)
+# This command is equivalent to the script shown in the quickstart 
 docker run --rm -it -v /var/run/docker.sock:/var/run/docker.sock \
-  # replace /xxxx/keys.cfg with the paths to your keys
-  -v /xxxx/keys.cfg:/app/keys.cfg \
-  # replace with your architecture, either arm64 or amd64
-  --platform=linux/arm64 \
+  -v $(pwd)/keys.cfg:/app/keys.cfg \
   sweagent/swe-agent-run:latest \
   python run.py --image_name=sweagent/swe-agent:latest \
-  # the rest of the command as shown in the quickstart/benchmarking section,
-  # for example to run on a specific github issue
   --model_name gpt4 \
   --data_path https://github.com/pvlib/pvlib-python/issues/1603 \
   --config_file config/default_from_url.yaml  --skip_existing=False
@@ -79,7 +76,7 @@ docker run --rm -it -v /var/run/docker.sock:/var/run/docker.sock \
 > * See the [installation issues section](#-installation-issues) for more help if you run into
 >   trouble.
 
-### 🐍 Setup with conda (development version) 
+### 🐍 Setup with conda (developer version) 
 
 To install the development version:
 

run.py

@@ -5,6 +5,10 @@
 import subprocess
 import traceback
 from typing import Any, Dict, Optional
+import rich.console
+import rich.markdown
+import rich.panel
+import rich.markdown
 import yaml
 
 from dataclasses import dataclass
@@ -165,15 +169,15 @@ def main(args: ScriptArguments):
 def should_open_pr(args: ScriptArguments, info: Dict[str, Any], *, token: str="") -> bool:
     """Does opening a PR make sense?"""
     if not info.get("submission"):
-        logger.info("Not openening PR because submission was made.")
+        logger.info("Not opening PR because submission was made.")
         return False
     if info["exit_status"] != "submitted":
-        logger.info("Not openening PR because exit status was %s and not submitted.", info["exit_status"])
+        logger.info("Not opening PR because exit status was %s and not submitted.", info["exit_status"])
         return False
     try:
         issue = get_gh_issue_data(args.environment.data_path, token=token)
     except InvalidGithubURL:
-        logger.info("Currently only github is supported to open PRs to. Skipping PR creation.")
+        logger.info("Currently only GitHub is supported to open PRs to. Skipping PR creation.")
         return False
     if issue.state != "open":
         logger.info(f"Issue is not open (state={issue.state}. Skipping PR creation.")
@@ -259,6 +263,8 @@ def save_predictions(traj_dir: Path, instance_id: str, info):
     logger.info(f"Saved predictions to {output_file}")
 
 
+
+
 def save_patch(traj_dir: Path, instance_id: str, info) -> Optional[Path]:
     """Create patch files that can be applied with `git am`.
     
@@ -273,7 +279,7 @@ def save_patch(traj_dir: Path, instance_id: str, info) -> Optional[Path]:
         return
     model_patch = info["submission"]
     patch_output_file.write_text(model_patch)
-    logger.info(f"Saved patch to {patch_output_file}")
+    _print_patch_message(patch_output_file)
     return patch_output_file
 
 
@@ -291,6 +297,31 @@ def apply_patch(local_dir: Path, patch_file: Path) -> None:
         return
     logger.info(f"Applied patch {patch_file} to {local_dir}")
 
+    
+def _print_patch_message(patch_output_file: Path):
+    console = rich.console.Console()
+    msg = [
+        "SWE-agent has produced a patch that it believes will solve the issue you submitted!",
+        "Use the code snippet below to inspect or apply it!"
+    ]
+    panel = rich.panel.Panel.fit(
+        "\n".join(msg),
+        title="🎉 Submission successful 🎉",
+    )
+    console.print(panel)
+    content = [
+        "```bash",
+        f"# The patch has been saved to your local filesystem at:",
+        f"PATCH_FILE_PATH='{patch_output_file.resolve()}'",
+        "# Inspect it:",
+        "cat \"${PATCH_FILE_PATH}\"",
+        "# Apply it to a local repository:",
+        f"cd <your local repo root>",
+        "git apply \"${PATCH_FILE_PATH}\"",
+        "```",
+    ]
+    console.print(rich.markdown.Markdown("\n".join(content)))
+
 
 def get_args(args=None) -> ScriptArguments:
     """Parse command line arguments and return a ScriptArguments object.

run_replay.py

@@ -63,7 +63,7 @@ def create_task_instances_tmp_file(data: List[Dict[str, Any]]) -> str:
         with open(tmp_path, "w") as f:
             for d in data:
                 print(json.dumps(d), file=f, end="\n", flush=True)
-        return replay_task_instances_path
+        return tmp_path
 
     is_other = False
     if data_path.endswith(".jsonl"):

tests/test_parsing.py

@@ -0,0 +1,81 @@
+import pytest
+from sweagent.agent.commands import Command
+from sweagent.agent.parsing import (
+    FormatError, ParseFunction, ActionParser, ThoughtActionParser,
+    XMLThoughtActionParser, EditFormat, Identity, JsonParser
+)
+
+
+def test_parse_function_registry():
+    assert isinstance(ParseFunction.get("ActionParser"), ActionParser)
+    assert isinstance(ParseFunction.get("ThoughtActionParser"), ThoughtActionParser)
+    assert isinstance(ParseFunction.get("XMLThoughtActionParser"), XMLThoughtActionParser)
+    assert isinstance(ParseFunction.get("EditFormat"), EditFormat)
+    assert isinstance(ParseFunction.get("Identity"), Identity)
+    assert isinstance(ParseFunction.get("JsonParser"), JsonParser)
+    with pytest.raises(ValueError):
+        ParseFunction.get("InvalidParser")
+
+
+def test_action_parser():
+    parser = ActionParser()
+    command = Command(code='ls', name='ls')
+    thought, action = parser("ls -l", [command])
+    assert thought == "ls -l"
+    assert action == "ls -l"
+    with pytest.raises(FormatError):
+        parser("invalid command", [command])
+
+
+def test_thought_action_parser():
+    parser = ThoughtActionParser()
+    model_response = "Let's look at the files in the current directory.\n```\nls -l\n```"
+    thought, action = parser(model_response, [])
+    assert thought == "Let's look at the files in the current directory.\n"
+    assert action == "ls -l\n"
+    with pytest.raises(FormatError):
+        parser("No code block", [])
+
+
+def test_xml_thought_action_parser():
+    parser = XMLThoughtActionParser()
+    model_response = "Let's look at the files in the current directory.\n<command>\nls -l\n</command>"
+    thought, action = parser(model_response, [])
+    assert thought == "Let's look at the files in the current directory."
+    assert action == "ls -l"
+    with pytest.raises(FormatError):
+        parser("No command tags", [])
+
+
+def test_edit_format_parser():
+    parser = EditFormat()
+    model_response = "Let's replace the contents.\n```\nimport os\nos.listdir()\n```"
+    thought, action = parser(model_response, [])
+    assert thought == "Let's replace the contents.\n"
+    assert action == "import os\nos.listdir()\n"
+    with pytest.raises(FormatError):
+        parser("No code block", [])
+
+
+def test_identity_parser():
+    parser = Identity()
+    model_response = "Return as is"
+    thought, action = parser(model_response, [])
+    assert thought == model_response
+    assert action == model_response
+
+
+def test_json_parser():
+    parser = JsonParser()
+    model_response = '{"thought": "List files", "command": {"name": "ls", "arguments": {"path": "."}}}'
+    thought, action = parser(model_response, [])
+    assert thought == "List files"
+    assert action == "ls ."
+
+    invalid_json = "Not a JSON"
+    with pytest.raises(FormatError):
+        parser(invalid_json, [])
+
+    missing_keys = '{"thought": "Missing command key"}'
+    with pytest.raises(FormatError):
+        parser(missing_keys, [])