mini-swe-agent 1.8.0__tar.gz → 1.9.0__tar.gz

{mini_swe_agent-1.8.0/src/mini_swe_agent.egg-info → mini_swe_agent-1.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mini-swe-agent
-Version: 1.8.0
+Version: 1.9.0
 Summary: Nano SWE Agent - A simple AI software engineering agent
 Author-email: Kilian Lieret <kilian.lieret@posteo.de>, "Carlos E. Jimenez" <carlosej@princeton.edu>
 License: MIT License
@@ -50,7 +50,7 @@ Requires-Dist: textual
 Requires-Dist: prompt_toolkit
 Provides-Extra: full
 Requires-Dist: mini-swe-agent[dev]; extra == "full"
-Requires-Dist: swe-rex; extra == "full"
+Requires-Dist: swe-rex>=1.4.0; extra == "full"
 Provides-Extra: dev
 Requires-Dist: datasets; extra == "dev"
 Requires-Dist: pytest; extra == "dev"

{mini_swe_agent-1.8.0 → mini_swe_agent-1.9.0}/pyproject.toml

@@ -47,7 +47,7 @@ dependencies = [
 [project.optional-dependencies]
 full = [
     "mini-swe-agent[dev]",
-    "swe-rex",
+    "swe-rex>=1.4.0",
 ]
 
 dev = [

{mini_swe_agent-1.8.0 → mini_swe_agent-1.9.0/src/mini_swe_agent.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mini-swe-agent
-Version: 1.8.0
+Version: 1.9.0
 Summary: Nano SWE Agent - A simple AI software engineering agent
 Author-email: Kilian Lieret <kilian.lieret@posteo.de>, "Carlos E. Jimenez" <carlosej@princeton.edu>
 License: MIT License
@@ -50,7 +50,7 @@ Requires-Dist: textual
 Requires-Dist: prompt_toolkit
 Provides-Extra: full
 Requires-Dist: mini-swe-agent[dev]; extra == "full"
-Requires-Dist: swe-rex; extra == "full"
+Requires-Dist: swe-rex>=1.4.0; extra == "full"
 Provides-Extra: dev
 Requires-Dist: datasets; extra == "dev"
 Requires-Dist: pytest; extra == "dev"

{mini_swe_agent-1.8.0 → mini_swe_agent-1.9.0}/src/mini_swe_agent.egg-info/SOURCES.txt

@@ -49,4 +49,6 @@ src/minisweagent/run/extra/swebench_single.py
 src/minisweagent/run/extra/utils/__init__.py
 src/minisweagent/run/extra/utils/batch_progress.py
 src/minisweagent/run/utils/__init__.py
-src/minisweagent/run/utils/save.py
+src/minisweagent/run/utils/save.py
+src/minisweagent/utils/__init__.py
+src/minisweagent/utils/log.py

{mini_swe_agent-1.8.0 → mini_swe_agent-1.9.0}/src/mini_swe_agent.egg-info/requires.txt

@@ -26,4 +26,4 @@ mkdocs-glightbox
 
 [full]
 mini-swe-agent[dev]
-swe-rex
+swe-rex>=1.4.0

{mini_swe_agent-1.8.0 → mini_swe_agent-1.9.0}/src/minisweagent/__init__.py

@@ -8,7 +8,7 @@ This file provides:
   unless you want the static type checking.
 """
 
-__version__ = "1.8.0"
+__version__ = "1.9.0"
 
 import os
 from pathlib import Path
@@ -45,6 +45,8 @@ class Model(Protocol):
 
     def query(self, messages: list[dict[str, str]], **kwargs) -> dict: ...
 
+    def get_template_vars(self) -> dict[str, Any]: ...
+
 
 class Environment(Protocol):
     """Protocol for execution environments."""
@@ -53,6 +55,8 @@ class Environment(Protocol):
 
     def execute(self, command: str, cwd: str = "") -> dict[str, str]: ...
 
+    def get_template_vars(self) -> dict[str, Any]: ...
+
 
 class Agent(Protocol):
     """Protocol for agents."""

{mini_swe_agent-1.8.0 → mini_swe_agent-1.9.0}/src/minisweagent/agents/default.py

@@ -1,7 +1,5 @@
 """Basic agent class. See https://mini-swe-agent.com/latest/advanced/control_flow/ for visual explanation."""
 
-import os
-import platform
 import re
 import subprocess
 from collections.abc import Callable
@@ -61,19 +59,21 @@ class DefaultAgent:
         self.messages: list[dict] = []
         self.model = model
         self.env = env
+        self.extra_template_vars = {}
 
     def render_template(self, template: str, **kwargs) -> str:
-        cs = asdict(self.config) | asdict(self.env.config) | asdict(self.model.config) | platform.uname()._asdict()
-        return Template(template).render(**kwargs, **cs, **os.environ)
+        template_vars = asdict(self.config) | self.env.get_template_vars() | self.model.get_template_vars()
+        return Template(template).render(**kwargs, **template_vars, **self.extra_template_vars)
 
     def add_message(self, role: str, content: str, **kwargs):
         self.messages.append({"role": role, "content": content, **kwargs})
 
     def run(self, task: str, **kwargs) -> tuple[str, str]:
         """Run step() until agent is finished. Return exit status & message"""
+        self.extra_template_vars |= {"task": task, **kwargs}
         self.messages = []
         self.add_message("system", self.render_template(self.config.system_template))
-        self.add_message("user", self.render_template(self.config.instance_template, task=task, **kwargs))
+        self.add_message("user", self.render_template(self.config.instance_template))
         while True:
             try:
                 self.step()

{mini_swe_agent-1.8.0 → mini_swe_agent-1.9.0}/src/minisweagent/environments/docker.py

@@ -2,9 +2,11 @@ import os
 import shlex
 import subprocess
 import uuid
-from dataclasses import dataclass, field
+from dataclasses import asdict, dataclass, field
 from typing import Any
 
+from minisweagent.utils.log import get_logger
+
 
 @dataclass
 class DockerEnvironmentConfig:
@@ -33,10 +35,14 @@ class DockerEnvironment:
         """This class executes bash commands in a Docker container using direct docker commands.
         See `DockerEnvironmentConfig` for keyword arguments.
         """
+        self.logger = get_logger("minisweagent.environment")
         self.container_id: str | None = None
         self.config = config_class(**kwargs)
         self._start_container()
 
+    def get_template_vars(self) -> dict[str, Any]:
+        return asdict(self.config)
+
     def _start_container(self):
         """Start the Docker container and return the container ID."""
         container_name = f"minisweagent-{uuid.uuid4().hex[:8]}"
@@ -53,7 +59,7 @@ class DockerEnvironment:
             "sleep",
             self.config.container_timeout,
         ]
-        print(f"Starting container with command: {shlex.join(cmd)}")
+        self.logger.debug(f"Starting container with command: {shlex.join(cmd)}")
         result = subprocess.run(
             cmd,
             capture_output=True,
@@ -61,7 +67,7 @@ class DockerEnvironment:
             timeout=120,  # docker pull might take a while
             check=True,
         )
-        print(f"Started container {container_name} with ID {result.stdout.strip()}")
+        self.logger.info(f"Started container {container_name} with ID {result.stdout.strip()}")
         self.container_id = result.stdout.strip()
 
     def execute(self, command: str, cwd: str = "") -> dict[str, Any]:
@@ -91,7 +97,7 @@ class DockerEnvironment:
     def cleanup(self):
         """Stop and remove the Docker container."""
         if getattr(self, "container_id", None) is not None:  # if init fails early, container_id might not be set
-            print(f"Stopping container {self.container_id}")
+            self.logger.info(f"Stopping container {self.container_id}")
             cmd = f"(timeout 60 {self.config.executable} stop {self.container_id} || {self.config.executable} rm -f {self.container_id}) >/dev/null 2>&1 &"
             subprocess.Popen(cmd, shell=True)
 

{mini_swe_agent-1.8.0 → mini_swe_agent-1.9.0}/src/minisweagent/environments/extra/swerex_docker.py

@@ -1,5 +1,5 @@
 import asyncio
-from dataclasses import dataclass, field
+from dataclasses import asdict, dataclass, field
 from typing import Any
 
 from swerex.deployment.docker import DockerDeployment
@@ -29,11 +29,19 @@ class SwerexDockerEnvironment:
         output = asyncio.run(
             self.deployment.runtime.execute(
                 RexCommand(
-                    command=command, shell=True, check=False, cwd=cwd or self.config.cwd, timeout=self.config.timeout
+                    command=command,
+                    shell=True,
+                    check=False,
+                    cwd=cwd or self.config.cwd,
+                    timeout=self.config.timeout,
+                    merge_output_streams=True,
                 )
             )
         )
         return {
-            "output": f"<stdout>\n{output.stdout}</stdout>\n<stderr>\n{output.stderr}</stderr>",
+            "output": output.stdout,
             "returncode": output.exit_code,
         }
+
+    def get_template_vars(self) -> dict[str, Any]:
+        return asdict(self.config)

{mini_swe_agent-1.8.0 → mini_swe_agent-1.9.0}/src/minisweagent/environments/local.py

@@ -1,6 +1,8 @@
 import os
+import platform
 import subprocess
-from dataclasses import dataclass, field
+from dataclasses import asdict, dataclass, field
+from typing import Any
 
 
 @dataclass
@@ -31,3 +33,6 @@ class LocalEnvironment:
             stderr=subprocess.STDOUT,
         )
         return {"output": result.stdout, "returncode": result.returncode}
+
+    def get_template_vars(self) -> dict[str, Any]:
+        return asdict(self.config) | platform.uname()._asdict() | os.environ

{mini_swe_agent-1.8.0 → mini_swe_agent-1.9.0}/src/minisweagent/environments/singularity.py

@@ -5,10 +5,12 @@ import shutil
 import subprocess
 import tempfile
 import uuid
-from dataclasses import dataclass, field
+from dataclasses import asdict, dataclass, field
 from pathlib import Path
 from typing import Any
 
+from minisweagent.utils.log import get_logger
+
 
 @dataclass
 class SingularityEnvironmentConfig:
@@ -27,14 +29,17 @@ class SingularityEnvironmentConfig:
 class SingularityEnvironment:
     def __init__(self, **kwargs):
         """Singularity environment. See `SingularityEnvironmentConfig` for kwargs."""
+        self.logger = get_logger("minisweagent.environment")
         self.config = SingularityEnvironmentConfig(**kwargs)
         self.sandbox_dir = Path(tempfile.gettempdir()) / f"minisweagent-{uuid.uuid4().hex[:8]}"
-
         subprocess.run(
             [self.config.executable, "build", "--sandbox", self.sandbox_dir, self.config.image],
             check=True,
         )
 
+    def get_template_vars(self) -> dict[str, Any]:
+        return asdict(self.config)
+
     def execute(self, command: str, cwd: str = "") -> dict[str, Any]:
         """Execute a command in a Singularity container and return the result as a dict."""
         cmd = [self.config.executable, "exec"]
@@ -66,7 +71,7 @@ class SingularityEnvironment:
 
     def cleanup(self):
         if self.sandbox_dir.exists():
-            print(f"Removing sandbox {self.sandbox_dir}")
+            self.logger.info(f"Removing sandbox {self.sandbox_dir}")
             shutil.rmtree(self.sandbox_dir)
 
     def __del__(self):

{mini_swe_agent-1.8.0 → mini_swe_agent-1.9.0}/src/minisweagent/models/litellm_model.py

@@ -1,7 +1,7 @@
 import json
 import logging
 import os
-from dataclasses import dataclass, field
+from dataclasses import asdict, dataclass, field
 from pathlib import Path
 from typing import Any
 
@@ -68,3 +68,6 @@ class LitellmModel:
         return {
             "content": response.choices[0].message.content or "",  # type: ignore
         }
+
+    def get_template_vars(self) -> dict[str, Any]:
+        return asdict(self.config) | {"n_model_calls": self.n_calls, "model_cost": self.cost}

{mini_swe_agent-1.8.0 → mini_swe_agent-1.9.0}/src/minisweagent/models/test_models.py

@@ -1,6 +1,7 @@
 import logging
 import time
-from dataclasses import dataclass
+from dataclasses import asdict, dataclass
+from typing import Any
 
 from minisweagent.models import GLOBAL_MODEL_STATS
 
@@ -36,3 +37,6 @@ class DeterministicModel:
         self.cost += self.config.cost_per_call
         GLOBAL_MODEL_STATS.add(self.config.cost_per_call)
         return {"content": output}
+
+    def get_template_vars(self) -> dict[str, Any]:
+        return asdict(self.config) | {"n_model_calls": self.n_calls, "model_cost": self.cost}

{mini_swe_agent-1.8.0 → mini_swe_agent-1.9.0}/src/minisweagent/run/extra/swebench.py

@@ -24,6 +24,7 @@ from minisweagent.environments import get_environment
 from minisweagent.models import get_model
 from minisweagent.run.extra.utils.batch_progress import RunBatchProgressManager
 from minisweagent.run.utils.save import save_traj
+from minisweagent.utils.log import add_file_handlers, logger
 
 _HELP_TEXT = """Run mini-SWE-agent on SWEBench instances.
 
@@ -141,7 +142,7 @@ def process_instance(
         )
         exit_status, result = agent.run(task)
     except Exception as e:
-        print(f"Error processing instance {instance_id}: {e}\n{traceback.format_exc()}")
+        logger.error(f"Error processing instance {instance_id}: {e}", exc_info=True)
         exit_status, result = type(e).__name__, str(e)
         extra_info = {"traceback": traceback.format_exc()}
     finally:
@@ -152,6 +153,7 @@ def process_instance(
             result=result,
             extra_info=extra_info,
             instance_id=instance_id,
+            print_fct=logger.info,
         )
         update_preds_file(output_dir / "preds.json", instance_id, model.config.model_name, result)
         progress_manager.on_instance_end(instance_id, exit_status)
@@ -168,12 +170,12 @@ def filter_instances(
     before_filter = len(instances)
     instances = [instance for instance in instances if re.match(filter_spec, instance["instance_id"])]
     if (after_filter := len(instances)) != before_filter:
-        print(f"Instance filter: {before_filter} -> {after_filter} instances")
+        logger.info(f"Instance filter: {before_filter} -> {after_filter} instances")
     if slice_spec:
         values = [int(x) if x else None for x in slice_spec.split(":")]
         instances = instances[slice(*values)]
         if (after_slice := len(instances)) != before_filter:
-            print(f"Instance slice: {before_filter} -> {after_slice} instances")
+            logger.info(f"Instance slice: {before_filter} -> {after_slice} instances")
     return instances
 
 
@@ -193,24 +195,28 @@ def main(
     environment_class: str | None = typer.Option( None, "--environment-class", help="Environment type to use. Recommended are docker or singularity", rich_help_panel="Advanced"),
 ) -> None:
     # fmt: on
+    output_path = Path(output)
+    output_path.mkdir(parents=True, exist_ok=True)
+    logger.info(f"Results will be saved to {output_path}")
+    add_file_handlers(output_path / "minisweagent.log")
+
     dataset_path = DATASET_MAPPING.get(subset, subset)
-    print(f"Loading dataset {dataset_path}, split {split}...")
+    logger.info(f"Loading dataset {dataset_path}, split {split}...")
     instances = list(load_dataset(dataset_path, split=split))
 
     instances = filter_instances(instances, filter_spec=filter_spec, slice_spec=slice_spec, shuffle=shuffle)
-    output_path = Path(output)
     if not redo_existing and (output_path / "preds.json").exists():
         existing_instances = list(json.loads((output_path / "preds.json").read_text()).keys())
-        print(f"Skipping {len(existing_instances)} existing instances")
+        logger.info(f"Skipping {len(existing_instances)} existing instances")
         instances = [instance for instance in instances if instance["instance_id"] not in existing_instances]
+    logger.info(f"Running on {len(instances)} instances...")
 
-    output_path.mkdir(parents=True, exist_ok=True)
-    print(f"Running on {len(instances)} instances...")
-    print(f"Results will be saved to {output_path}")
 
     config = yaml.safe_load(get_config_path(config_spec).read_text())
-    config.setdefault("environment", {}).setdefault("environment_class", environment_class)
-    config.setdefault("model", {}).setdefault("model_name", model)
+    if environment_class is not None:
+        config.setdefault("environment", {})["environment_class"] = environment_class
+    if model is not None:
+        config.setdefault("model", {})["model_name"] = model
 
     progress_manager = RunBatchProgressManager(len(instances), output_path / f"exit_statuses_{time.time()}.yaml")
 
@@ -222,8 +228,7 @@ def main(
                 pass
             except Exception as e:
                 instance_id = futures[future]
-                print(f"Error in future for instance {instance_id}: {e}")
-                traceback.print_exc()
+                logger.error(f"Error in future for instance {instance_id}: {e}", exc_info=True)
                 progress_manager.on_uncaught_exception(instance_id, e)
 
     with Live(progress_manager.render_group, refresh_per_second=4):
@@ -237,7 +242,7 @@ def main(
             try:
                 process_futures(futures)
             except KeyboardInterrupt:
-                print("Cancelling all pending jobs. Press ^C again to exit immediately.")
+                logger.info("Cancelling all pending jobs. Press ^C again to exit immediately.")
                 for future in futures:
                     if not future.running() and not future.done():
                         future.cancel()

{mini_swe_agent-1.8.0 → mini_swe_agent-1.9.0}/src/minisweagent/run/extra/swebench_single.py

@@ -6,6 +6,7 @@ import typer
 import yaml
 from datasets import load_dataset
 
+from minisweagent import global_config_dir
 from minisweagent.agents.interactive import InteractiveAgent
 from minisweagent.config import builtin_config_dir, get_config_path
 from minisweagent.models import get_model
@@ -13,9 +14,13 @@ from minisweagent.run.extra.swebench import (
     DATASET_MAPPING,
     get_sb_environment,
 )
+from minisweagent.run.utils.save import save_traj
+from minisweagent.utils.log import logger
 
 app = typer.Typer(add_completion=False)
 
+DEFAULT_OUTPUT = global_config_dir / "last_swebench_single_run.traj.json"
+
 
 # fmt: off
 @app.command()
@@ -27,11 +32,12 @@ def main(
     config_path: Path = typer.Option( builtin_config_dir / "extra" / "swebench.yaml", "-c", "--config", help="Path to a config file", rich_help_panel="Basic"),
     environment_class: str | None = typer.Option(None, "--environment-class", rich_help_panel="Advanced"),
     exit_immediately: bool = typer.Option( False, "--exit-immediately", help="Exit immediately when the agent wants to finish instead of prompting.", rich_help_panel="Basic"),
+    output: Path = typer.Option(DEFAULT_OUTPUT, "-o", "--output", help="Output trajectory file", rich_help_panel="Basic"),
 ) -> None:
     # fmt: on
     """Run on a single SWE-Bench instance."""
     dataset_path = DATASET_MAPPING.get(subset, subset)
-    print(f"Loading dataset from {dataset_path}, split {split}...")
+    logger.info(f"Loading dataset from {dataset_path}, split {split}...")
     instances = {
         inst["instance_id"]: inst  # type: ignore
         for inst in load_dataset(dataset_path, split=split)
@@ -41,16 +47,22 @@ def main(
     instance: dict = instances[instance_spec]  # type: ignore
 
     config = yaml.safe_load(get_config_path(config_path).read_text())
-    config.setdefault("environment", {}).setdefault("environment_class", environment_class)
+    if environment_class is not None:
+        config.setdefault("environment", {})["environment_class"] = environment_class
     if exit_immediately:
         config.setdefault("agent", {})["confirm_exit"] = False
     env = get_sb_environment(config, instance)
     agent = InteractiveAgent(
         get_model(model_name, config.get("model", {})),
         env,
-        **(config.get("agent", {}) | {"mode": "yolo"}),
+        **({"mode": "yolo"} | config.get("agent", {})),
     )
-    agent.run(instance["problem_statement"])
+
+    exit_status, result = None, None
+    try:
+        exit_status, result = agent.run(instance["problem_statement"])  # type: ignore[arg-type]
+    finally:
+        save_traj(agent, output, exit_status=exit_status, result=result)  # type: ignore[arg-type]
 
 
 if __name__ == "__main__":

{mini_swe_agent-1.8.0 → mini_swe_agent-1.9.0}/src/minisweagent/run/utils/save.py

@@ -1,4 +1,5 @@
 import json
+from collections.abc import Callable
 from pathlib import Path
 
 from minisweagent import Agent, __version__
@@ -12,6 +13,7 @@ def save_traj(
     exit_status: str | None = None,
     result: str | None = None,
     extra_info: dict | None = None,
+    print_fct: Callable = print,
     **kwargs,
 ):
     """Save the trajectory of the agent to a file.
@@ -49,4 +51,4 @@ def save_traj(
     path.parent.mkdir(parents=True, exist_ok=True)
     path.write_text(json.dumps(data, indent=2))
     if print_path:
-        print(f"Saved trajectory to '{path}'")
+        print_fct(f"Saved trajectory to '{path}'")

mini_swe_agent-1.9.0/src/minisweagent/utils/log.py

@@ -0,0 +1,32 @@
+import logging
+from pathlib import Path
+
+MINI_LOGGERS = {}
+_EXTRA_HANDLERS = []
+
+
+def get_logger(name: str) -> logging.Logger:
+    if name in MINI_LOGGERS:
+        return MINI_LOGGERS[name]
+    logger = logging.getLogger(name)
+    logger.setLevel(logging.DEBUG)
+    handler = logging.StreamHandler()
+    formatter = logging.Formatter("%(name)s: %(levelname)s: %(message)s")
+    handler.setFormatter(formatter)
+    logger.addHandler(handler)
+    for handler in _EXTRA_HANDLERS:
+        logger.addHandler(handler)
+    MINI_LOGGERS[name] = logger
+    return logger
+
+
+def add_file_handlers(path: Path):
+    handler = logging.FileHandler(path)
+    formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
+    handler.setFormatter(formatter)
+    _EXTRA_HANDLERS.append(handler)
+    for logger in MINI_LOGGERS.values():
+        logger.addHandler(handler)
+
+
+logger = get_logger("minisweagent")