Remove duplicated HWE code repository from dataset PR

Repos/HWE/README.md

@@ -1,63 +0,0 @@
-# HWE — Phoenix-bench Code Release
-
-Code that backs the paper *Phoenix-bench: A Hardware Engineering Benchmark for Agentic AI* (NeurIPS 2026). The companion data (per-instance snapshots, full Verilator testbenches, Docker images) lives at the project page; this tree holds source code, scripts, agent run artifacts, and lightweight metadata (~2.2 GB).
-
-All paths and identifiers in this release have been anonymized; absolute paths in scripts and logs point at `/workspace/phoenix-bench/`, which the verifier maps to the snapshot/testbench layout described under "Data NOT included" below.
-
-## Layout
-
-```
-HWE/
-├── agents/             # the 8 agentic frameworks evaluated in §4.2
-│   ├── Agentless/      # workflow-based  (Xia et al. 2024)
-│   ├── Aider/          # interactive     (paul-gauthier 2024)
-│   ├── ExpeRepair/     # retrieval-aug.  (Mu et al. 2025)
-│   ├── KGCompass/      # knowledge-graph (2025)
-│   ├── Lingxi/         # multi-agent     (2025)
-│   ├── mini-swe-agent/ # minimal SWE-agent variant (2025)
-│   ├── OpenHands/      # interactive     (Wang et al. 2024)
-│   └── SWE-agent/      # interactive     (Yang et al. 2024)
-└── benchmark/
-    ├── construction/   # §3.1 funnel: GitHub crawl → issue/PR filtering
-    ├── verifier/       # §3 Phoenix-Ref harness + gold patches
-    └── eval_harness/   # §4 product+open-source agent evaluation scaffolds
-```
-
-## Mapping to the paper
-
-| Paper element | Code path |
-|---|---|
-| §3.1 Data collection / 4-stage funnel | `benchmark/construction/` |
-| §3 Phoenix-Ref harness (511 instances) | `benchmark/verifier/` |
-| §3 Patch complexity / difficulty tiers (Tab 2, App C) | `benchmark/verifier/classify_patch_complexity.py`, `patch_complexity*` |
-| §3 F2P / P2P verification | `benchmark/verifier/count_fail_to_pass.{py,sh}`, `f2p_sweep_one.sh` |
-| §3 Coverage statistics (Tab 2) | `benchmark/verifier/collect_*coverage*.py` |
-| §3 Issue classification (Fig 3) | `benchmark/verifier/classified_issues_full.json`, `classify_missing_issues.py` |
-| §4.1 Four product agents | `benchmark/eval_harness/benchmark_{claude,codex,codex_new,copilot,gemini}/` |
-| §4.2 Eight open-source agents | `agents/` |
-| §4.2 mini-SWE-agent runs | `benchmark/eval_harness/benchmark_mini_agent/` |
-| §4.3 File-level oracle localization | `benchmark/eval_harness/benchmark_localizations/` |
-| §4.3 Testbench-feedback diagnostic | `benchmark/eval_harness/benchmark_eda/` |
-
-## Data NOT included (download separately)
-
-These are required to actually re-run the benchmark; omitted here for size.
-
-| Artifact | Original location | Size |
-|---|---|---|
-| Per-instance snapshots (511 × repo HEAD) | `HDL_verified_new/snapshots/` | 21 GB |
-| Per-instance Verilator testbenches | `HDL_verified_new/testbench_verilator/` | 16 GB |
-| OpenHands eval outputs (per-instance logs) | `openhands_eval/benchmarks/eval_outputs/` | 9.5 GB |
-
-`benchmark/verifier/patches/` (122 MB, gold developer patches) IS included — needed for F2P verification once snapshots are restored.
-
-## Reproducing F2P verification
-
-```bash
-# After downloading snapshots/ and testbench_verilator/ into benchmark/verifier/
-cd benchmark/verifier
-ls testbench_verilator/ > /tmp/instances.txt
-SWEEP_CSV=/tmp/f2p.csv xargs -P 16 -I {} ./f2p_sweep_one.sh {} < /tmp/instances.txt
-```
-
-The included `f2p_full_sweep_2026-05-27.csv` is a snapshot of the 511-instance sweep run on 2026-05-27 (475 PASS / 32 FAIL / 3 ERROR / 1 misclassified).

Repos/HWE/agents/Agentless/.gitignore

@@ -1,187 +0,0 @@
-# Byte-compiled / optimized / DLL files
-__pycache__/
-*.py[cod]
-*$py.class
-
-# C extensions
-*.so
-
-# Distribution / packaging
-.Python
-build/
-develop-eggs/
-dist/
-downloads/
-eggs/
-.eggs/
-lib/
-lib64/
-parts/
-sdist/
-var/
-wheels/
-share/python-wheels/
-*.egg-info/
-.installed.cfg
-*.egg
-MANIFEST
-
-# PyInstaller
-#  Usually these files are written by a python script from a template
-#  before PyInstaller builds the exe, so as to inject date/other infos into it.
-*.manifest
-*.spec
-
-# Installer logs
-pip-log.txt
-pip-delete-this-directory.txt
-
-# Unit test / coverage reports
-htmlcov/
-.tox/
-.nox/
-.coverage
-.coverage.*
-.cache
-nosetests.xml
-coverage.xml
-*.cover
-*.py,cover
-.hypothesis/
-.pytest_cache/
-cover/
-
-# Translations
-*.mo
-*.pot
-
-# Django stuff:
-*.log
-local_settings.py
-db.sqlite3
-db.sqlite3-journal
-
-# Flask stuff:
-instance/
-.webassets-cache
-
-# Scrapy stuff:
-.scrapy
-
-# Sphinx documentation
-docs/_build/
-
-# PyBuilder
-.pybuilder/
-target/
-
-# Jupyter Notebook
-.ipynb_checkpoints
-
-# IPython
-profile_default/
-ipython_config.py
-
-# pyenv
-#   For a library or package, you might want to ignore these files since the code is
-#   intended to run in multiple environments; otherwise, check them in:
-# .python-version
-
-# pipenv
-#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
-#   However, in case of collaboration, if having platform-specific dependencies or dependencies
-#   having no cross-platform support, pipenv may install dependencies that don't work, or not
-#   install all needed dependencies.
-#Pipfile.lock
-
-# poetry
-#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
-#   This is especially recommended for binary packages to ensure reproducibility, and is more
-#   commonly ignored for libraries.
-#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
-#poetry.lock
-
-# pdm
-#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
-#pdm.lock
-#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
-#   in version control.
-#   https://pdm.fming.dev/#use-with-ide
-.pdm.toml
-
-# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
-__pypackages__/
-
-# Celery stuff
-celerybeat-schedule
-celerybeat.pid
-
-# SageMath parsed files
-*.sage.py
-
-# Environments
-.env
-.venv
-env/
-venv/
-ENV/
-env.bak/
-venv.bak/
-
-# Spyder project settings
-.spyderproject
-.spyproject
-
-# Rope project settings
-.ropeproject
-
-# mkdocs documentation
-/site
-
-# mypy
-.mypy_cache/
-.dmypy.json
-dmypy.json
-
-# Pyre type checker
-.pyre/
-
-# pytype static type analyzer
-.pytype/
-
-# Cython debug symbols
-cython_debug/
-
-# PyCharm
-#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
-#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
-#  and can be added to the global gitignore or merged into this file.  For a more nuclear
-#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
-#  nuclear option because steven uses PyCharm.
-.idea/
-
-# some project specific stuff
-
-/get_repo_structure/astropy
-/get_repo_structure/django
-/get_repo_structure/flask
-/get_repo_structure/pylint
-/get_repo_structure/pytest
-/get_repo_structure/requests
-/get_repo_structure/seaborn
-/get_repo_structure/scikit-learn
-/get_repo_structure/sphinx
-/get_repo_structure/matplotlib
-/get_repo_structure/sympy
-/get_repo_structure/xarray
-get_repo_structure/test_repo/
-results/
-logs/
-dev/
-
-# data files
-*.jsonl
-*.json
-
-# Jupyter Notebooks
-*.ipynb

Repos/HWE/agents/Agentless/.pre-commit-config.yaml

@@ -1,21 +0,0 @@
-repos:
--   repo: https://github.com/pycqa/isort
-    rev: 5.12.0
-    hooks:
-    -   id: isort
-        name: isort (python)
-        args: ["--profile", "black"]
--   repo: https://github.com/psf/black
-    rev: 22.6.0
-    hooks:
-    -   id: black
--   repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v4.3.0
-    hooks:
-    -   id: check-yaml
-    -   id: end-of-file-fixer
-    -   id: trailing-whitespace
-exclude: |
-    (?x)^(
-        README.*
-    )$

Repos/HWE/agents/Agentless/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2024 OpenAutoCoder
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

Repos/HWE/agents/Agentless/README.md

@@ -1,102 +0,0 @@
-# 😺 Agentless
-
-<p align="center">
-    <a href="https://arxiv.org/abs/2407.01489"><img src="https://img.shields.io/badge/📃-Arxiv-b31b1b?style=for-the-badge"></a>
-    <a href="https://github.com/OpenAutoCoder/Agentless/blob/master/LICENSE"><img src="https://forthebadge.com/images/badges/license-mit.svg" style="height: 28px"></a>
-</p>
-
-<p align="center">
-    <big><a href="#-news">😽News</a></big> |
-    <big><a href="#-setup">🐈Setup</a></big> |
-    <big><a href="#-comparison">🧶Comparison</a></big> | 
-    <big><a href="#-artifacts">🐈‍⬛Artifacts</a></big> |
-    <big><a href="#-citation">📝Citation</a></big> |
-    <big><a href="#-acknowledgement">😻Acknowledgement</a></big>
-</p>
-
-## 😽 News 
-
-- *Dec 2nd, 2024*: We integrated Agentless with Claude 3.5 Sonnet to achieve 40.7% and 50.8% solve rate on SWE-bench lite and verified 
-- *Oct 28th, 2024*: We just released OpenAutoCoder-Agentless 1.5! 
-- *July 1st, 2024*: We just released OpenAutoCoder-Agentless 1.0! **Agentless** currently is the best open-source approach on SWE-bench lite with 82 fixes (27.3%) and costing on average $0.34 per issue.
-
-## 😺 About 
-
-**Agentless** is an *agentless* approach to automatically solve software development problems. To solve each issue, **Agentless** follows a simple three phase process: localization, repair, and patch validation.
-- 🙀 **Localization**: Agentless employs a hierarchical process to first localize the fault to specific files, then to relevant classes or functions, and finally to fine-grained edit locations
-- 😼 **Repair**: Agentless takes the edit locations and samples multiple candidate patches per bug in a simple diff format
-- 😸 **Patch Validation**: Agentless selects the regression tests to run and generates additional reproduction test to reproduce the original error. Using the test results, Agentless re-ranks all remaining patches to selects one to submit
-
-## 🐈 Setup
-
-First create the environment 
-
-```shell
-git clone https://github.com/OpenAutoCoder/Agentless.git
-cd Agentless
-
-conda create -n agentless python=3.11 
-conda activate agentless
-pip install -r requirements.txt
-export PYTHONPATH=$PYTHONPATH:$(pwd)
-```
-
-<details><summary>⏬ Developer Setup</summary>
-<div>
-
-```shell
-# for contribution, please install the pre-commit hook.
-pre-commit install  # this allows a more standardized code style
-```
-
-</div>
-</details>
-
-Then export your OpenAI API key 
-```shell
-export OPENAI_API_KEY={key_here}
-```
-
-Now you are ready to run **Agentless** on the problems in SWE-bench! 
-
-> [!NOTE]
-> 
-> To reproduce the full SWE-bench lite experiments and follow our exact setup as described in the paper. Please see this [README](https://github.com/OpenAutoCoder/Agentless/blob/main/README_swebench.md)
-
-## 🧶 Comparison
-
-Below shows the comparison graph between **Agentless** and the best open-source agent-based approaches on SWE-bench lite
-
-<p align="center">
-<img src="./resources/comparison_graph.png" style="width:75%; margin-left: auto; margin-right: auto;">
-</p>
-
-## 🐈‍⬛ Artifacts
-
-You can download the complete artifacts of **Agentless** in our [v1.5.0 release](https://github.com/OpenAutoCoder/Agentless/releases/tag/v1.5.0):
-- 🐈‍⬛ agentless_swebench_lite: complete Agentless run on SWE-bench Lite
-- 🐈‍⬛ agentless_swebench_verified: complete Agentless run on SWE-bench Verified
-- 🐈‍⬛ swebench_repo_structure: preprocessed structure information for each SWE-Bench problem
-
-You can also checkout `classification/` folder to obtain our manual classifications of SWE-bench-lite as well as our filtered SWE-bench-lite-*S* problems.
-
-## 📝 Citation
-
-```bibtex
-@article{agentless,
-  author    = {Xia, Chunqiu Steven and Deng, Yinlin and Dunn, Soren and Zhang, Lingming},
-  title     = {Agentless: Demystifying LLM-based Software Engineering Agents},
-  year      = {2024},
-  journal   = {arXiv preprint},
-}
-```
-
-> [!NOTE]
-> 
-> The first two authors contributed equally to this work, with author order determined via [*Nigiri*](https://senseis.xmp.net/?Nigiri)
-
-## 😻 Acknowledgement 
-
-* [SWE-bench](https://www.swebench.com/)
-* [Aider](https://github.com/paul-gauthier/aider)
-* [SWE-bench-docker](https://github.com/aorwall/SWE-bench-docker)

Repos/HWE/agents/Agentless/README_swebench.md

@@ -1,374 +0,0 @@
-# Agentless experiments on SWE-Bench
-
-<p align="center">
-    <big><a href="#-setup">🐈Setup</a></big> |
-    <big><a href="#-localization">🙀Localization</a></big> | 
-    <big><a href="#-repair">😼Repair</a></big> |
-    <big><a href="#-patch-validation-and-selection">😸Patch Validation and Selection</a></big> |
-    <big><a href="#-cost">💰Cost</a></big>
-</p>
-
-In this document, we will go through the steps to generate the patches on SWE-bench. 
-Currently, we support both [SWE-Bench Lite](https://huggingface.co/datasets/princeton-nlp/SWE-bench_Lite) and [SWE-Bench Verified](https://huggingface.co/datasets/princeton-nlp/SWE-bench_Verified)
-
-## 🐈 Setup
-
-First create the environment 
-
-```shell
-git clone https://github.com/OpenAutoCoder/Agentless.git
-cd Agentless
-
-conda create -n agentless python=3.11 
-conda activate agentless
-pip install -r requirements.txt
-export PYTHONPATH=$PYTHONPATH:$(pwd)
-```
-
-Then export your OpenAI API key 
-```shell
-export OPENAI_API_KEY={key_here}
-```
-
-Create the folder to save our results
-```shell
-mkdir results # where we will save our results
-```
-
-> [!TIP]
-> 
-> We currently support SWE-Bench Lite and SWE-Bench Verified benchmarks, you can use `--dataset` to select the benchmark (by default it will be SWE-Bench Lite)
-> 
-> For example `--dataset=princeton-nlp/SWE-bench_Verified`
-
-> [!TIP]
-> 
-> Since for each issue in the benchmark (both SWE-Bench Lite and SWE-Bench Verified) we need to checkout the repository and process the files, you might want to save some time by downloading the preprocessed data here: [swebench_lite_repo_structure.zip](https://github.com/OpenAutoCoder/Agentless/releases/tag/v1.5.0)
->
-> After downloading, please unzip and export the location as such `export PROJECT_FILE_LOC={folder which you saved}`
-
-> [!TIP]
-> 
-> You can use `--target_id` to specific a particular bug you want to target. 
-> 
-> For example `--target_id=django__django-10914`
-
-> [!TIP]
-> 
-> We use multiple threads (controllable via `--num_threads`) to speed up the Agentless process 
-
-## 🙀 Localization 
-
-In localization, the goal is to find the locations in source code where we need to edit to fix the issues. 
-At a high-level, **Agentless** uses a 3-stage localization step to first localize to specific files, then to relevant code elements, and finally to fine-grained edit locations. 
-We will now take you through the step-by-step procedure of Agentless in each of the localization steps.
-
-#### 1. Localize to suspicious files
-
-First, we localize to suspicious files. This is done in a multi-step process where we combine both LLM localized files with retrieval files.
-
-Run the following command to generate the LLM-predicted suspicious files:
-
-```shell
-python agentless/fl/localize.py --file_level \
-                                --output_folder results/swe-bench-lite/file_level \
-                                --num_threads 10 \
-                                --skip_existing 
-```
-
-This will save all the LLM-predicted suspicious file locations in  `results/swe-bench-lite/file_level/loc_outputs.jsonl` with the logs saved in `results/swe-bench-lite/file_level/localization_logs`
-
-We then complement the previous suspicious files with a simple embedding-based retrieval method to identify additional suspicious files.
-
-This is done by first filtering out irrelevant folders by using LLM to produce a list of irrelevant folders that do not need to be retrieved from with the following command:
-
-```shell
-python agentless/fl/localize.py --file_level \
-                                --irrelevant \
-                                --output_folder results/swe-bench-lite/file_level_irrelevant \
-                                --num_threads 10 \
-                                --skip_existing 
-```
-
-This will save the identified irrelevant folders in `results/swe-bench-lite/file_level_irrelevant/loc_outputs.jsonl` with the logs saved in `results/swe-bench-lite/file_level_irrelevant/localization_logs`
-
-We then perform the retrieval (note the embedding is done with OpenAI `text-embedding-3-small` model) by passing in the irrelevant folders and running the following command: 
-
-```shell
-python agentless/fl/retrieve.py --index_type simple \
-                                --filter_type given_files \
-                                --filter_file results/swe-bench-lite/file_level_irrelevant/loc_outputs.jsonl \
-                                --output_folder results/swe-bench-lite/retrievel_embedding \
-                                --persist_dir embedding/swe-bench_simple \
-                                --num_threads 10 
-```
-
-This will save the retrieved files in `results/swe-bench-lite/retrievel_embedding/retrieve_locs.jsonl` with the logs saved in `results/swe-bench-lite/retrievel_embedding/retrieval_logs`
-
-Finally we merge the LLM-predicted suspicious file locations with the embedding-based retrieved files to obtain a final list of relevant files:
-
-```shell
-python agentless/fl/combine.py  --retrieval_loc_file results/swe-bench-lite/retrievel_embedding/retrieve_locs.jsonl \
-                                --model_loc_file results/swe-bench-lite/file_level/loc_outputs.jsonl \
-                                --top_n 3 \
-                                --output_folder results/swe-bench-lite/file_level_combined 
-```
-
-`results/swe-bench-lite/file_level_combined/combined_locs.jsonl` contains the final list of suspicious files identified by Agentless.
-
-#### 2. localize to related elements
-
-Next, we move on to localizing the related elements.
-
-Run the following command to provide the suspicious files from the first stage as input:
-
-```shell
-python agentless/fl/localize.py --related_level \
-                                --output_folder results/swe-bench-lite/related_elements \
-                                --top_n 3 \
-                                --compress_assign \
-                                --compress \
-                                --start_file results/swe-bench-lite/file_level_combined/combined_locs.jsonl \
-                                --num_threads 10 \
-                                --skip_existing 
-```
-
-This will save the related elements in `results/swe-bench-lite/related_elements/loc_outputs.jsonl` with the logs saved in `results/swe-bench-lite/related_elements/localization_logs`
-
-#### 3. localize to edit locations
-
-Finally, using the related elements, we then localize to the edit locations. This is done via sampling to obtain multiple different sets of edit locations:
-
-
-```shell
-python agentless/fl/localize.py --fine_grain_line_level \
-                                --output_folder results/swe-bench-lite/edit_location_samples \
-                                --top_n 3 \
-                                --compress \
-                                --temperature 0.8 \
-                                --num_samples 4 \
-                                --start_file results/swe-bench-lite/related_elements/loc_outputs.jsonl \
-                                --num_threads 10 \
-                                --skip_existing 
-```
-
-This will save the edit locations in `results/swe-bench-lite/edit_location_samples/loc_outputs.jsonl` with the logs saved in `results/swe-bench-lite/edit_location_samples/localization_logs`
-
-<details><summary>⏬ Structure of `loc_outputs.jsonl` <i>:: click to expand ::</i> </summary>
-<div>
-
-- `instance_id`: task ID of the issue
-- `found_files`: list of files localized by the model
-- `additional_artifact_loc_file`: raw output of the model during file-level localization
-- `file_traj`: trajectory of the model during file-level localization (e.g., \# of tokens)
-- `found_related_locs`: dict of relevant code elements localized by the model
-- `additional_artifact_loc_related`: raw output of the model during relevant-code-level localization 
-- `related_loc_traj`: trajectory of the model during relevant-code-level localization
-- `found_edit_locs`: dict of edit locations localized by the model
-- `additional_artifact_loc_edit_location`: raw output of the model during edit-location-level localization 
-- `edit_loc_traj`: trajectory of the model during edit-location-level localization
-
-</div>
-</details>
-
-Run the following command to separate the individual sets of edit locations:
-
-```shell
-python agentless/fl/localize.py --merge \
-                                --output_folder results/swe-bench-lite/edit_location_individual \
-                                --top_n 3 \
-                                --num_samples 4 \
-                                --start_file results/swe-bench-lite/edit_location_samples/loc_outputs.jsonl 
-```
-
-The separate sets of edit locations can be found in `results/swe-bench-lite/edit_location_individual`. The location files will be named `loc_merged_{x}-{x}_outputs.jsonl` where `x` indicates the individual samples. For our experiments on SWE-bench, we will use all 4 sets of edit locations and perform repairs on them individually to generate 4 different repair runs.
-
-## 😼 Repair
-
-Using the 4 sets of edit locations from before, we now perform repair. 
-
-**Agentless** generates multiple patches per issue (controllable via parameters) and then perform majority voting with patch validation to select the final patch for submission 
-
-Run the following command to generate the patches:
-
-```shell
-python agentless/repair/repair.py --loc_file results/swe-bench-lite/edit_location_individual/loc_merged_0-0_outputs.jsonl \
-                                  --output_folder results/swe-bench-lite/repair_sample_1 \
-                                  --loc_interval \
-                                  --top_n=3 \
-                                  --context_window=10 \
-                                  --max_samples 10  \
-                                  --cot \
-                                  --diff_format \
-                                  --gen_and_process \
-                                  --num_threads 2 
-```
-
-<details><summary>Additional Repair Commands</summary>
-<div>
-
-```shell
-for i in {1..3}; do
-    python agentless/repair/repair.py --loc_file results/swe-bench-lite/edit_location_individual/loc_merged_${i}-${i}_outputs.jsonl \
-                                    --output_folder results/swe-bench-lite/repair_sample_$((i+1)) \
-                                    --loc_interval \
-                                    --top_n=3 \
-                                    --context_window=10 \
-                                    --max_samples 10  \
-                                    --cot \
-                                    --diff_format \
-                                    --gen_and_process \
-                                    --num_threads 2 
-done
-
-```
-</div>
-</details>
-
-These commands generate 10 samples each (1 greedy and 9 via temperature sampling) as defined `--max_samples 10`. The `--context_window` indicates the amount of code lines before and after each localized edit location we provide to the model for repair. The patches are saved in `results/swe-bench-lite/repair_sample_{i}/output.jsonl`, which contains the raw output of each sample as well as any trajectory information (e.g., number of tokens). The complete logs are also saved in `results/swe-bench-lite/repair_sample_{i}/repair_logs/` 
-
-The above commands will combine to generate 40 samples in total for each bug. 
-
-## 😸 Patch Validation and Selection 
-
-Since Agentless generates multiple candidate patches per issue, we need a way to select a final patch for submission.
-
-To do this, Agentless leverages both regression tests that exist in the codebase as well as generating new reproduction tests that can verify if the patch can solve the original issue.
-
-#### Regression test selection
-
-We first select a set of regression tests (tests that already exist in the repository and pass on the original codebase) to run.
-
-Run the following command to get a list of passing tests in the original codebase:
-
-```shell
-python agentless/test/run_regression_tests.py --run_id generate_regression_tests \
-                                              --output_file results/swe-bench-lite/passing_tests.jsonl 
-```
-
-This will generate a list of passing tests at `results/swe-bench-lite/passing_tests.jsonl`
-
-> [!NOTE]
-> 
-> We do not use any of provided PASS_TO_PASS field in the SWE-bench benchmark
-> 
-> We select tests from the complete list of tests which can pass in the original repository
-
-Next, we ask the LLM to remove any tests which should not be ran with the following command:
-
-```shell
-python agentless/test/select_regression_tests.py --passing_tests results/swe-bench-lite/passing_tests.jsonl \
-                                                 --output_folder results/swe-bench-lite/select_regression 
-```
-
-This will produce a list of final regression tests in `results/swe-bench-lite/select_regression/output.jsonl` with the logs at `results/swe-bench-lite/select_regression/select_test_logs`
-
-We can run this on all the patches generate, repeated for each repair run (i.e., by changing `folder`):
-
-```shell
-folder=results/swe-bench-lite/repair_sample_1
-for num in {0..9..1}; do
-    run_id_prefix=$(basename $folder); 
-    python agentless/test/run_regression_tests.py --regression_tests results/swe-bench-lite/select_regression/output.jsonl \
-                                                  --predictions_path="${folder}/output_${num}_processed.jsonl" \
-                                                  --run_id="${run_id_prefix}_regression_${num}" --num_workers 10;
-done
-```
-
-This will output the regression test results in the same folder as the repair results. `results/swe-bench-lite/repair_sample_1/output_{i}_regression_test_results.jsonl` contains the regression test results for each patch number (`i`). 
-
-> [!NOTE]
-> 
-> We also perform post-processing to generate the complete git-diff patch for each repair sample.
-> 
-> You can find the individual patch in `results/repair/output_{i}_processed.jsonl` where `i` is the sample number. 
-
-#### Reproduction test generation
-
-In addition to the regression tests, Agentless also generates a reproduction test that attempt to check if the patch can solve the original issue.
-
-Similar to patch generation, Agentless also generates multiple samples of reproduction tests, and then perform selection:
-```shell
-python agentless/test/generate_reproduction_tests.py --max_samples 40 \
-                                                     --output_folder results/swe-bench-lite/reproduction_test_samples \
-                                                     --num_threads 10 
-```
-
-This will generate 40 samples (1 greedy + 39 temperature sampling) per issue. The generated reproduction tests can be found in `results/swe-bench-lite/reproduction_test_samples/output.jsonl`. The corresponding logs can be found in `results/swe-bench-lite/reproduction_test_samples/generating_test_logs/`.
-
-Now we will execute each of these generated tests on the original repository to see if they can reproduce the original issue.
-
-```shell
-for st in {0..36..4}; do   en=$((st + 3));   
-        echo "Processing ${st} to ${en}";   
-        for num in $(seq $st $en); do     
-            echo "Processing ${num}";     
-            python agentless/test/run_reproduction_tests.py --run_id="reproduction_test_generation_filter_sample_${num}" \
-                                                            --test_jsonl="results/swe-bench-lite/reproduction_test_samples/output_${num}_processed_reproduction_test.jsonl" \
-                                                            --num_workers 6 \
-                                                            --testing;
-done & done
-```
-
-> [!WARNING]
-> 
-> In the above command we execute multiple SWE-bench evaluations in parallel, please ensure that your machine is able to handle that
->
-> If not, you may want to reduce the amount of parallelization 
-
-This produces verification results for each tests in the same folder: `results/swe-bench-lite/reproduction_test_samples/`
-
-We then perform majority voting to select one reproduction test per issue:
-
-```shell
-python agentless/test/generate_reproduction_tests.py --max_samples 40 \
-                                                     --output_folder results/swe-bench-lite/reproduction_test_samples \
-                                                     --output_file reproduction_tests.jsonl \
-                                                     --select
-```
-
-This will generate the reproduction test file at: `results/swe-bench-lite/reproduction_test_samples/reproduction_tests.jsonl`
-
-Finally, we evaluate the generated patches on the selected reproduction test. Similar to regression test execution, this is repeated for each repair run (i.e., by changing `folder`):
-
-```shell
-folder=results/swe-bench-lite/repair_sample_1
-for num in {0..9..1}; do
-    run_id_prefix=$(basename $folder); 
-    python agentless/test/run_reproduction_tests.py --test_jsonl results/swe-bench-lite/reproduction_test_samples/reproduction_tests.jsonl \
-                                                    --predictions_path="${folder}/output_${num}_processed.jsonl" \
-                                                    --run_id="${run_id_prefix}_reproduction_${num}" --num_workers 10;
-done
-```
-
- This will output the reproduction test results in the same folder as the repair results. `results/swe-bench-lite/repair_sample_1/output_{i}_reproduction_test_results.jsonl` contains the reproduction test results for each patch number (`i`). 
-
-
-#### Reranking and patch selection 
-
-Finally, using the regression and reproduction test results, Agentless performs reranking to select the final patch for submission.
-
-Run the following command (`--regression` indicates we are using regression tests for selection `--reproduction` indicates we are using the reproduction tests for selection)
-
-```shell
-python agentless/repair/rerank.py --patch_folder results/swe-bench-lite/repair_sample_1/,results/swe-bench-lite/repair_sample_2/,results/swe-bench-lite/repair_sample_3/,results/swe-bench-lite/repair_sample_4/ \
-                                  --num_samples 40 \
-                                  --deduplicate \
-                                  --regression \
-                                  --reproduction
-```
-
-This command will produced the `all_preds.jsonl` that contains the final selected patch for each instance_id which you can then directly use your favorite way of testing SWE-bench for evaluation!
-
-
-## 💰 Cost 
-
-To measure the cost of running Agentless, we have provided helpful utilities. 
-
-For each of the `output.jsonl` files produced for each of the steps (including substeps), run the following command:
-
-```shell
-python dev/util/cost.py --output_file example_step/output.jsonl 
-```
-
-This will output the dollar cost as well as the number of tokens. `--embedding_cost` can be used to compute the cost of the embedding step. 

Repos/HWE/agents/Agentless/agentless/fl/FL.py

@@ -1,775 +0,0 @@
-from abc import ABC, abstractmethod
-
-from agentless.repair.repair import construct_topn_file_context
-from agentless.util.compress_file import get_skeleton
-from agentless.util.postprocess_data import extract_code_blocks, extract_locs_for_files
-from agentless.util.preprocess_data import (
-    correct_file_paths,
-    get_full_file_paths_and_classes_and_functions,
-    get_repo_files,
-    line_wrap_content,
-    show_project_structure,
-)
-
-MAX_CONTEXT_LENGTH = 128000
-
-
-class FL(ABC):
-    def __init__(self, instance_id, structure, problem_statement, **kwargs):
-        self.structure = structure
-        self.instance_id = instance_id
-        self.problem_statement = problem_statement
-
-    @abstractmethod
-    def localize(self, top_n=1, mock=False) -> tuple[list, list, list, any]:
-        pass
-
-
-class LLMFL(FL):
-    obtain_relevant_files_prompt = """
-    Please look through the following GitHub problem description and Repository structure and provide a list of files that one would need to edit to fix the problem in a Verilog/SystemVerilog hardware design repository.
-
-    ### GitHub Problem Description ###
-    {problem_statement}
-
-    ###
-
-    ### Repository Structure ###
-    {structure}
-
-    ###
-
-    Please only provide the full path and return at most 5 files.
-    The returned files should be separated by new lines ordered by most to least important and wrapped with ```
-    For example:
-    rtl/top.sv
-    rtl/core/alu.sv
-    tb/top_tb.sv
-
-    """
-
-    obtain_irrelevant_files_prompt = """
-    Please look through the following GitHub problem description and Repository structure and provide a list of folders that are irrelevant to fixing the problem.
-    Note that irrelevant folders are those that do not need to be modified and are safe to ignore when trying to solve this problem.
-
-    ### GitHub Problem Description ###
-    {problem_statement}
-
-    ###
-
-    ### Repository Structure ###
-    {structure}
-
-    ###
-
-    Please only provide the full path.
-    Remember that any subfolders will be considered as irrelevant if you provide the parent folder.
-    Please ensure that the provided irrelevant folders do not include any important files needed to fix the problem (e.g., RTL, testbenches, constraints, build scripts, or verification collateral).
-    The returned folders should be separated by new lines and wrapped with ```
-    For example:
-    docs/
-    scripts/legacy/
-    third_party/
-
-    """
-
-    file_content_template = """
-    ### File: {file_name} ###
-    {file_content}
-    """
-
-    file_content_in_block_template = """
-    ### File: {file_name} ###
-    ```systemverilog
-    {file_content}
-    """
-
-    obtain_relevant_code_combine_top_n_prompt = """
-    Please review the following GitHub problem description and relevant files, and provide a set of locations that need to be edited to fix the issue in a Verilog/SystemVerilog codebase.
-    Locations may be specified as module names, interface names, package names, task/function names, parameter/localparam names, signal names, or exact line numbers requiring modification.
-
-    GitHub Problem Description
-    {problem_statement}
-
-    {file_contents}
-
-    Please provide the module/interface/package name, task/function name, parameter name, or the exact line numbers that need to be edited.
-    The possible location outputs should be either "module", "interface", "package", "function", "task", "parameter", "signal", or "line".
-
-    Examples:
-    rtl/top.sv
-    line: 42
-    module: top
-    line: 120
-
-    rtl/core/alu.sv
-    module: alu
-    function: compute_flags
-    line: 88
-
-    rtl/common/types_pkg.sv
-    package: types_pkg
-    parameter: XLEN
-    Return just the location(s) wrapped with ```.
-    """
-
-    obtain_relevant_code_combine_top_n_no_line_number_prompt = """
-    Please review the following GitHub problem description and relevant files, and provide a set of locations that need to be edited to fix the issue in a Verilog/SystemVerilog codebase.
-    Locations may be specified as module/interface/package names, task names, function names, parameters, or signals that require modification.
-
-    GitHub Problem Description
-    {problem_statement}
-
-    {file_contents}
-
-    Please provide the module/interface/package, task, function, parameter, or signal names that need to be edited.
-
-    Examples:
-    rtl/top.sv
-    module: top
-    signal: reset_n
-
-    rtl/core/alu.sv
-    module: alu
-    function: compute_flags
-    task: do_execute
-
-    rtl/common/types_pkg.sv
-    package: types_pkg
-    parameter: XLEN
-    Return just the location(s) wrapped with ```.
-    """
-
-    obtain_relevant_functions_and_vars_from_compressed_files_prompt_more = """
-    Please look through the following GitHub Problem Description and the Skeleton of Relevant Files.
-    Identify all locations that need inspection or editing to fix the problem in a Verilog/SystemVerilog repository, including directly related areas as well as any potentially related parameters, signals, modules, interfaces, packages, tasks, functions, and assertions.
-    For each location you provide, give the name of a module, interface, package, task, function, parameter/localparam, signal, or a named assertion/property/sequence.
-
-    GitHub Problem Description
-    {problem_statement}
-
-    Skeleton of Relevant Files
-    {file_contents}
-
-    Please provide the complete set of locations as either a module name, interface name, package name, task name, function name, parameter name, signal name, or assertion/property name.
-    Note that if you include a module/interface/package, you do not need to list its internal blocks unless you want to point to a specific task/function or named generate block.
-
-    Examples:
-    rtl/top.sv
-    module: top
-    signal: reset_n
-    parameter: BOOT_ADDR
-
-    rtl/core/pipe.sv
-    module: pipeline
-    function: compute_next_pc
-    task: flush_pipe
-    signal: stall
-
-    rtl/common/types_pkg.sv
-    package: types_pkg
-    parameter: XLEN
-    Return just the locations wrapped with ```.
-    """
-
-    obtain_relevant_functions_and_vars_from_raw_files_prompt = """
-    Please look through the following GitHub Problem Description and Relevant Files.
-    Identify all locations that need inspection or editing to fix the problem in a Verilog/SystemVerilog repository, including directly related areas as well as any potentially related parameters, signals, modules, interfaces, packages, tasks, functions, and assertions.
-    For each location you provide, give the name of a module, interface, package, task, function, parameter/localparam, signal, or a named assertion/property/sequence.
-
-    GitHub Problem Description
-    {problem_statement}
-
-    Relevant Files
-    {file_contents}
-
-    Please provide the complete set of locations as either a module name, interface name, package name, task name, function name, parameter name, signal name, or assertion/property name.
-    Note that if you include a module/interface/package, you do not need to list its internal blocks unless you want to point to a specific task/function or named generate block.
-
-    Examples:
-    rtl/top.sv
-    module: top
-    signal: reset_n
-    parameter: BOOT_ADDR
-
-    rtl/core/pipe.sv
-    module: pipeline
-    function: compute_next_pc
-    task: flush_pipe
-    signal: stall
-
-    rtl/common/types_pkg.sv
-    package: types_pkg
-    parameter: XLEN
-    Return just the locations wrapped with ```.
-    """
-
-    def __init__(
-        self,
-        instance_id,
-        structure,
-        problem_statement,
-        model_name,
-        backend,
-        logger,
-        **kwargs,
-    ):
-        super().__init__(instance_id, structure, problem_statement)
-        self.max_tokens = 300
-        self.model_name = model_name
-        self.backend = backend
-        self.logger = logger
-
-    def _parse_model_return_lines(self, content: str) -> list[str]:
-        if not content:
-            self.logger.error("Model returned empty response; cannot parse paths.")
-            return []
-        return content.strip().split("\n")
-
-    def localize_irrelevant(self, top_n=1, mock=False):
-        from agentless.util.api_requests import num_tokens_from_messages
-        from agentless.util.model import make_model
-
-        message = self.obtain_irrelevant_files_prompt.format(
-            problem_statement=self.problem_statement,
-            structure=show_project_structure(self.structure).strip(),
-        ).strip()
-        self.logger.info(f"prompting with message:\n{message}")
-        self.logger.info("=" * 80)
-
-        if mock:
-            self.logger.info("Skipping querying model since mock=True")
-            traj = {
-                "prompt": message,
-                "usage": {
-                    "prompt_tokens": num_tokens_from_messages(message, self.model),
-                },
-            }
-            return [], {"raw_output_loc": ""}, traj
-
-        model = make_model(
-            model=self.model_name,
-            backend=self.backend,
-            logger=self.logger,
-            max_tokens=2048,  # self.max_tokens,
-            temperature=0,
-            batch_size=1,
-        )
-        traj = model.codegen(message, num_samples=1)[0]
-        traj["prompt"] = message
-        raw_output = traj["response"]
-
-        files, classes, functions = get_full_file_paths_and_classes_and_functions(
-            self.structure
-        )
-
-        f_files = []
-        filtered_files = []
-
-        model_identified_files_folder = self._parse_model_return_lines(raw_output)
-        # remove any none folder none files
-        model_identified_files_folder = [
-            x
-            for x in model_identified_files_folder
-            if x.endswith("/") or x.endswith(".py")
-        ]
-
-        for file_content in files:
-            file_name = file_content[0]
-            if any([file_name.startswith(x) for x in model_identified_files_folder]):
-                filtered_files.append(file_name)
-            else:
-                f_files.append(file_name)
-
-        self.logger.info(raw_output)
-
-        return (
-            f_files,
-            {
-                "raw_output_files": raw_output,
-                "found_files": f_files,
-                "filtered_files": filtered_files,
-            },
-            traj,
-        )
-
-    def localize(self, top_n=1, mock=False) -> tuple[list, list, list, any]:
-        from agentless.util.api_requests import num_tokens_from_messages
-        from agentless.util.model import make_model
-
-        found_files = []
-
-        message = self.obtain_relevant_files_prompt.format(
-            problem_statement=self.problem_statement,
-            structure=show_project_structure(self.structure).strip(),
-        ).strip()
-        self.logger.info(f"prompting with message:\n{message}")
-        self.logger.info("=" * 80)
-        if mock:
-            self.logger.info("Skipping querying model since mock=True")
-            traj = {
-                "prompt": message,
-                "usage": {
-                    "prompt_tokens": num_tokens_from_messages(message, self.model_name),
-                },
-            }
-            return [], {"raw_output_loc": ""}, traj
-
-        model = make_model(
-            model=self.model_name,
-            backend=self.backend,
-            logger=self.logger,
-            max_tokens=self.max_tokens,
-            temperature=0,
-            batch_size=1,
-        )
-        traj = model.codegen(message, num_samples=1)[0]
-        traj["prompt"] = message
-        raw_output = traj["response"]
-        model_found_files = self._parse_model_return_lines(raw_output)
-
-        files, classes, functions = get_full_file_paths_and_classes_and_functions(
-            self.structure
-        )
-
-        # sort based on order of appearance in model_found_files
-        found_files = correct_file_paths(model_found_files, files)
-
-        self.logger.info(raw_output)
-
-        return (
-            found_files,
-            {"raw_output_files": raw_output},
-            traj,
-        )
-
-    def localize_function_from_compressed_files(
-        self,
-        file_names,
-        mock=False,
-        temperature=0.0,
-        keep_old_order=False,
-        compress_assign: bool = False,
-        total_lines=30,
-        prefix_lines=10,
-        suffix_lines=10,
-    ):
-        from agentless.util.api_requests import num_tokens_from_messages
-        from agentless.util.model import make_model
-
-        file_contents = get_repo_files(self.structure, file_names)
-        compressed_file_contents = {
-            fn: get_skeleton(
-                code,
-                compress_assign=compress_assign,
-                total_lines=total_lines,
-                prefix_lines=prefix_lines,
-                suffix_lines=suffix_lines,
-            )
-            for fn, code in file_contents.items()
-        }
-        contents = [
-            self.file_content_in_block_template.format(file_name=fn, file_content=code)
-            for fn, code in compressed_file_contents.items()
-        ]
-        file_contents = "".join(contents)
-        template = (
-            self.obtain_relevant_functions_and_vars_from_compressed_files_prompt_more
-        )
-        message = template.format(
-            problem_statement=self.problem_statement, file_contents=file_contents
-        )
-        self.logger.info(f"prompting with message:")
-        self.logger.info("\n" + message)
-
-        def message_too_long(message):
-            return (
-                num_tokens_from_messages(message, self.model_name) >= MAX_CONTEXT_LENGTH
-            )
-
-        while message_too_long(message) and len(contents) > 1:
-            self.logger.info(f"reducing to \n{len(contents)} files")
-            contents = contents[:-1]
-            file_contents = "".join(contents)
-            message = template.format(
-                problem_statement=self.problem_statement, file_contents=file_contents
-            )  # Recreate message
-
-        if message_too_long(message):
-            raise ValueError(
-                "The remaining file content is too long to fit within the context length"
-            )
-        self.logger.info(f"prompting with message:\n{message}")
-        self.logger.info("=" * 80)
-
-        if mock:
-            self.logger.info("Skipping querying model since mock=True")
-            traj = {
-                "prompt": message,
-                "usage": {
-                    "prompt_tokens": num_tokens_from_messages(
-                        message,
-                        self.model_name,
-                    ),
-                },
-            }
-            return {}, {"raw_output_loc": ""}, traj
-
-        model = make_model(
-            model=self.model_name,
-            backend=self.backend,
-            logger=self.logger,
-            max_tokens=self.max_tokens,
-            temperature=temperature,
-            batch_size=1,
-        )
-        traj = model.codegen(message, num_samples=1)[0]
-        traj["prompt"] = message
-        raw_output = traj["response"]
-
-        model_found_locs = extract_code_blocks(raw_output)
-        model_found_locs_separated = extract_locs_for_files(
-            model_found_locs, file_names, keep_old_order
-        )
-
-        self.logger.info(f"==== raw output ====")
-        self.logger.info(raw_output)
-        self.logger.info("=" * 80)
-        self.logger.info(f"==== extracted locs ====")
-        for loc in model_found_locs_separated:
-            self.logger.info(loc)
-        self.logger.info("=" * 80)
-
-        return model_found_locs_separated, {"raw_output_loc": raw_output}, traj
-
-    def localize_function_from_raw_text(
-        self,
-        file_names,
-        mock=False,
-        temperature=0.0,
-        keep_old_order=False,
-    ):
-        from agentless.util.api_requests import num_tokens_from_messages
-        from agentless.util.model import make_model
-
-        file_contents = get_repo_files(self.structure, file_names)
-        raw_file_contents = {fn: code for fn, code in file_contents.items()}
-        contents = [
-            self.file_content_template.format(file_name=fn, file_content=code)
-            for fn, code in raw_file_contents.items()
-        ]
-        file_contents = "".join(contents)
-        template = self.obtain_relevant_functions_and_vars_from_raw_files_prompt
-        message = template.format(
-            problem_statement=self.problem_statement, file_contents=file_contents
-        )
-        self.logger.info(f"prompting with message:")
-        self.logger.info("\n" + message)
-
-        def message_too_long(message):
-            return (
-                num_tokens_from_messages(message, self.model_name) >= MAX_CONTEXT_LENGTH
-            )
-
-        while message_too_long(message) and len(contents) > 1:
-            self.logger.info(f"reducing to \n{len(contents)} files")
-            contents = contents[:-1]
-            file_contents = "".join(contents)
-            message = template.format(
-                problem_statement=self.problem_statement, file_contents=file_contents
-            )  # Recreate message
-
-        if message_too_long(message):
-            raise ValueError(
-                "The remaining file content is too long to fit within the context length"
-            )
-        self.logger.info(f"prompting with message:\n{message}")
-        self.logger.info("=" * 80)
-
-        if mock:
-            self.logger.info("Skipping querying model since mock=True")
-            traj = {
-                "prompt": message,
-                "usage": {
-                    "prompt_tokens": num_tokens_from_messages(
-                        message,
-                        self.model_name,
-                    ),
-                },
-            }
-            return {}, {"raw_output_loc": ""}, traj
-
-        model = make_model(
-            model=self.model_name,
-            backend=self.backend,
-            logger=self.logger,
-            max_tokens=self.max_tokens,
-            temperature=temperature,
-            batch_size=1,
-        )
-        traj = model.codegen(message, num_samples=1)[0]
-        traj["prompt"] = message
-        raw_output = traj["response"]
-
-        model_found_locs = extract_code_blocks(raw_output)
-        model_found_locs_separated = extract_locs_for_files(
-            model_found_locs, file_names, keep_old_order
-        )
-
-        self.logger.info(f"==== raw output ====")
-        self.logger.info(raw_output)
-        self.logger.info("=" * 80)
-        self.logger.info(f"==== extracted locs ====")
-        for loc in model_found_locs_separated:
-            self.logger.info(loc)
-        self.logger.info("=" * 80)
-
-        return model_found_locs_separated, {"raw_output_loc": raw_output}, traj
-
-    def localize_line_from_coarse_function_locs(
-        self,
-        file_names,
-        coarse_locs,
-        context_window: int,
-        add_space: bool,
-        sticky_scroll: bool,
-        no_line_number: bool,
-        temperature: float = 0.0,
-        num_samples: int = 1,
-        mock=False,
-        keep_old_order=False,
-    ):
-        from agentless.util.api_requests import num_tokens_from_messages
-        from agentless.util.model import make_model
-
-        file_contents = get_repo_files(self.structure, file_names)
-        topn_content, file_loc_intervals = construct_topn_file_context(
-            coarse_locs,
-            file_names,
-            file_contents,
-            self.structure,
-            context_window=context_window,
-            loc_interval=True,
-            add_space=add_space,
-            sticky_scroll=sticky_scroll,
-            no_line_number=no_line_number,
-        )
-        if no_line_number:
-            template = self.obtain_relevant_code_combine_top_n_no_line_number_prompt
-        else:
-            template = self.obtain_relevant_code_combine_top_n_prompt
-        message = template.format(
-            problem_statement=self.problem_statement, file_contents=topn_content
-        )
-        self.logger.info(f"prompting with message:\n{message}")
-        self.logger.info("=" * 80)
-
-        def message_too_long(message):
-            return (
-                num_tokens_from_messages(message, self.model_name) >= MAX_CONTEXT_LENGTH
-            )
-
-        while message_too_long(message) and len(coarse_locs) > 1:
-            self.logger.info(f"reducing to \n{len(coarse_locs)} files")
-            coarse_locs.popitem()
-            topn_content, file_loc_intervals = construct_topn_file_context(
-                coarse_locs,
-                file_names,
-                file_contents,
-                self.structure,
-                context_window=context_window,
-                loc_interval=True,
-                add_space=add_space,
-                sticky_scroll=sticky_scroll,
-                no_line_number=no_line_number,
-            )
-            message = template.format(
-                problem_statement=self.problem_statement, file_contents=topn_content
-            )
-
-        if message_too_long(message):
-            raise ValueError(
-                "The remaining file content is too long to fit within the context length"
-            )
-
-        if mock:
-            self.logger.info("Skipping querying model since mock=True")
-            traj = {
-                "prompt": message,
-                "usage": {
-                    "prompt_tokens": num_tokens_from_messages(message, self.model_name),
-                },
-            }
-            return [], {"raw_output_loc": ""}, traj
-
-        model = make_model(
-            model=self.model_name,
-            backend=self.backend,
-            logger=self.logger,
-            max_tokens=self.max_tokens,
-            temperature=temperature,
-            batch_size=num_samples,
-        )
-        raw_trajs = model.codegen(
-            message, num_samples=num_samples, prompt_cache=num_samples > 1
-        )
-
-        # Merge trajectories
-        raw_outputs = [raw_traj["response"] for raw_traj in raw_trajs]
-        traj = {
-            "prompt": message,
-            "response": raw_outputs,
-            "usage": {  # merge token usage
-                "completion_tokens": sum(
-                    raw_traj["usage"]["completion_tokens"] for raw_traj in raw_trajs
-                ),
-                "prompt_tokens": sum(
-                    raw_traj["usage"]["prompt_tokens"] for raw_traj in raw_trajs
-                ),
-            },
-        }
-        model_found_locs_separated_in_samples = []
-        for raw_output in raw_outputs:
-            model_found_locs = extract_code_blocks(raw_output)
-            model_found_locs_separated = extract_locs_for_files(
-                model_found_locs, file_names, keep_old_order
-            )
-            model_found_locs_separated_in_samples.append(model_found_locs_separated)
-
-            self.logger.info(f"==== raw output ====")
-            self.logger.info(raw_output)
-            self.logger.info("=" * 80)
-            self.logger.info(f"==== extracted locs ====")
-            for loc in model_found_locs_separated:
-                self.logger.info(loc)
-            self.logger.info("=" * 80)
-        self.logger.info("==== Input coarse_locs")
-        coarse_info = ""
-        for fn, found_locs in coarse_locs.items():
-            coarse_info += f"### {fn}\n"
-            if isinstance(found_locs, str):
-                coarse_info += found_locs + "\n"
-            else:
-                coarse_info += "\n".join(found_locs) + "\n"
-        self.logger.info("\n" + coarse_info)
-        if len(model_found_locs_separated_in_samples) == 1:
-            model_found_locs_separated_in_samples = (
-                model_found_locs_separated_in_samples[0]
-            )
-
-        return (
-            model_found_locs_separated_in_samples,
-            {"raw_output_loc": raw_outputs},
-            traj,
-        )
-
-    def localize_line_from_raw_text(
-        self,
-        file_names,
-        mock=False,
-        temperature=0.0,
-        num_samples=1,
-        keep_old_order=False,
-    ):
-        from agentless.util.api_requests import num_tokens_from_messages
-        from agentless.util.model import make_model
-
-        file_contents = get_repo_files(self.structure, file_names)
-        raw_file_contents = {
-            fn: line_wrap_content(code) for fn, code in file_contents.items()
-        }
-        contents = [
-            self.file_content_template.format(file_name=fn, file_content=code)
-            for fn, code in raw_file_contents.items()
-        ]
-        file_contents = "".join(contents)
-        template = self.obtain_relevant_code_combine_top_n_prompt
-        message = template.format(
-            problem_statement=self.problem_statement, file_contents=file_contents
-        )
-        self.logger.info(f"prompting with message:")
-        self.logger.info("\n" + message)
-
-        def message_too_long(message):
-            return (
-                num_tokens_from_messages(message, self.model_name) >= MAX_CONTEXT_LENGTH
-            )
-
-        while message_too_long(message) and len(contents) > 1:
-            self.logger.info(f"reducing to \n{len(contents)} files")
-            contents = contents[:-1]
-            file_contents = "".join(contents)
-            message = template.format(
-                problem_statement=self.problem_statement, file_contents=file_contents
-            )  # Recreate message
-
-        if message_too_long(message):
-            raise ValueError(
-                "The remaining file content is too long to fit within the context length"
-            )
-        self.logger.info(f"prompting with message:\n{message}")
-        self.logger.info("=" * 80)
-
-        if mock:
-            self.logger.info("Skipping querying model since mock=True")
-            traj = {
-                "prompt": message,
-                "usage": {
-                    "prompt_tokens": num_tokens_from_messages(
-                        message,
-                        self.model_name,
-                    ),
-                },
-            }
-            return {}, {"raw_output_loc": ""}, traj
-
-        model = make_model(
-            model=self.model_name,
-            backend=self.backend,
-            logger=self.logger,
-            max_tokens=self.max_tokens,
-            temperature=temperature,
-            batch_size=num_samples,
-        )
-        raw_trajs = model.codegen(message, num_samples=num_samples)
-
-        # Merge trajectories
-        raw_outputs = [raw_traj["response"] for raw_traj in raw_trajs]
-        traj = {
-            "prompt": message,
-            "response": raw_outputs,
-            "usage": {  # merge token usage
-                "completion_tokens": sum(
-                    raw_traj["usage"]["completion_tokens"] for raw_traj in raw_trajs
-                ),
-                "prompt_tokens": sum(
-                    raw_traj["usage"]["prompt_tokens"] for raw_traj in raw_trajs
-                ),
-            },
-        }
-        model_found_locs_separated_in_samples = []
-        for raw_output in raw_outputs:
-            model_found_locs = extract_code_blocks(raw_output)
-            model_found_locs_separated = extract_locs_for_files(
-                model_found_locs, file_names, keep_old_order
-            )
-            model_found_locs_separated_in_samples.append(model_found_locs_separated)
-
-            self.logger.info(f"==== raw output ====")
-            self.logger.info(raw_output)
-            self.logger.info("=" * 80)
-            self.logger.info(f"==== extracted locs ====")
-            for loc in model_found_locs_separated:
-                self.logger.info(loc)
-            self.logger.info("=" * 80)
-
-        if len(model_found_locs_separated_in_samples) == 1:
-            model_found_locs_separated_in_samples = (
-                model_found_locs_separated_in_samples[0]
-            )
-
-        return (
-            model_found_locs_separated_in_samples,
-            {"raw_output_loc": raw_outputs},
-            traj,
-        )

Repos/HWE/agents/Agentless/agentless/fl/Index.py

@@ -1,333 +0,0 @@
-import copy
-import os
-from abc import ABC
-
-import tiktoken
-from llama_index.core import (
-    Document,
-    MockEmbedding,
-    Settings,
-    StorageContext,
-    VectorStoreIndex,
-    load_index_from_storage,
-)
-from llama_index.core.callbacks import CallbackManager, TokenCountingHandler
-from llama_index.core.retrievers import VectorIndexRetriever
-from llama_index.core.schema import MetadataMode
-from llama_index.embeddings.openai import OpenAIEmbedding
-
-from agentless.util.api_requests import num_tokens_from_messages
-from agentless.util.preprocess_data import (
-    clean_method_left_space,
-    get_full_file_paths_and_classes_and_functions,
-)
-try:
-    from get_repo_structure.get_repo_structure import parse_verilog_file as parse_source_file
-except ImportError:
-    from get_repo_structure.get_repo_structure import parse_python_file as parse_source_file
-
-VERILOG_EXTENSIONS = {".v", ".sv", ".vh", ".svh"}
-
-
-def _is_verilog_path(file_name: str) -> bool:
-    _, ext = os.path.splitext(file_name)
-    return ext.lower() in VERILOG_EXTENSIONS
-
-
-def _parse_global_stmt(file_content: str, file_name: str) -> tuple[str, str]:
-    if _is_verilog_path(file_name):
-        return "", ""
-    try:
-        from agentless.util.index_skeleton import parse_global_stmt_from_code
-    except Exception:
-        return "", ""
-    return parse_global_stmt_from_code(file_content)
-
-
-def construct_file_meta_data(file_name: str, clazzes: list, functions: list) -> dict:
-    meta_data = {
-        "file_name": file_name,
-    }
-    meta_data["File Name"] = file_name
-
-    if clazzes:
-        class_names = ", ".join([c["name"] for c in clazzes])
-        meta_data["Classes"] = class_names
-        if _is_verilog_path(file_name):
-            meta_data["Modules"] = class_names
-    if functions:
-        function_names = ", ".join([f["name"] for f in functions])
-        meta_data["Functions"] = function_names
-        if _is_verilog_path(file_name):
-            meta_data["Tasks/Functions"] = function_names
-
-    return meta_data
-
-
-def check_meta_data(meta_data: dict) -> bool:
-
-    doc = Document(
-        text="",
-        metadata=meta_data,
-        metadata_template="### {key}: {value}",
-        text_template="Metadata:\n{metadata_str}\n-----\nCode:\n{content}",
-    )
-
-    if (
-        num_tokens_from_messages(
-            doc.get_content(metadata_mode=MetadataMode.EMBED),
-            model="text-embedding-3-small",
-        )
-        > Settings.chunk_size // 2
-    ):
-        # half of the chunk size should not be metadata
-        return False
-
-    return True
-
-
-def build_file_documents_simple(
-    clazzes: list, functions: list, file_name: str, file_content: str
-) -> list[Document]:
-    """
-    Really simple file document format, where we put all content of a single file into a single document
-    """
-    documents = []
-
-    meta_data = construct_file_meta_data(file_name, clazzes, functions)
-
-    doc = Document(
-        text=file_content,
-        metadata=meta_data,
-        metadata_template="### {key}: {value}",
-        text_template="Metadata:\n{metadata_str}\n-----\nCode:\n{content}",
-    )
-    doc.excluded_embed_metadata_keys = ["file_name"]  # used for searching only.
-    doc.excluded_llm_metadata_keys = ["file_name"]  # used for searching only.
-    if not check_meta_data(meta_data):
-        # meta_data a bit too long, instead we just exclude meta data
-        doc.excluded_embed_metadata_keys = list(meta_data.keys())
-        doc.excluded_llm_metadata_keys = list(meta_data.keys())
-        documents.append(doc)
-    else:
-        documents.append(doc)
-
-    return documents
-
-
-def build_file_documents_complex(
-    clazzes: list, functions: list, file_name: str, file_content: str
-) -> list[Document]:
-
-    documents = []
-
-    global_stmt, _ = _parse_global_stmt(file_content, file_name)
-    base_meta_data = construct_file_meta_data(file_name, clazzes, functions)
-    is_verilog = _is_verilog_path(file_name)
-
-    for clazz in clazzes:
-        content = "\n".join(clazz["text"])
-        meta_data = copy.deepcopy(base_meta_data)
-        meta_data["Class Name"] = clazz["name"]
-        if is_verilog:
-            meta_data["Module Name"] = clazz["name"]
-        doc = Document(
-            text=content,
-            metadata=meta_data,
-            metadata_template="### {key}: {value}",
-            text_template="Metadata:\n{metadata_str}\n-----\nCode:\n{content}",
-        )
-
-        doc.excluded_embed_metadata_keys = ["file_name"]  # used for searching only.
-        doc.excluded_llm_metadata_keys = ["file_name"]  # used for searching only.
-        if not check_meta_data(meta_data):
-            doc.excluded_embed_metadata_keys = list(meta_data.keys())
-            doc.excluded_llm_metadata_keys = list(meta_data.keys())
-        documents.append(doc)
-
-        for class_method in clazz["methods"]:
-            method_meta_data = copy.deepcopy(base_meta_data)
-            method_meta_data["Class Name"] = clazz["name"]
-            method_meta_data["Method Name"] = class_method["name"]
-            if is_verilog:
-                method_meta_data["Task/Function Name"] = class_method["name"]
-            content = clean_method_left_space("\n".join(class_method["text"]))
-
-            doc = Document(
-                text=content,
-                metadata=method_meta_data,
-                metadata_template="### {key}: {value}",
-                text_template="Metadata:\n{metadata_str}\n-----\nCode:\n{content}",
-            )
-            doc.excluded_embed_metadata_keys = ["file_name"]  # used for searching only.
-            doc.excluded_llm_metadata_keys = ["file_name"]  # used for searching only.
-            if not check_meta_data(method_meta_data):
-                doc.excluded_embed_metadata_keys = list(method_meta_data.keys())
-                doc.excluded_llm_metadata_keys = list(method_meta_data.keys())
-            documents.append(doc)
-
-    for function in functions:
-        content = "\n".join(function["text"])
-        function_meta_data = copy.deepcopy(base_meta_data)
-        function_meta_data["Function Name"] = function["name"]
-        if is_verilog:
-            function_meta_data["Task/Function Name"] = function["name"]
-        doc = Document(
-            text=content,
-            metadata=function_meta_data,
-            metadata_template="### {key}: {value}",
-            text_template="Metadata:\n{metadata_str}\n-----\nCode:\n{content}",
-        )
-
-        doc.excluded_embed_metadata_keys = ["file_name"]  # used for searching only.
-        doc.excluded_llm_metadata_keys = ["file_name"]  # used for searching only.
-        if not check_meta_data(function_meta_data):
-            doc.excluded_embed_metadata_keys = list(function_meta_data.keys())
-            doc.excluded_llm_metadata_keys = list(function_meta_data.keys())
-        documents.append(doc)
-
-    if global_stmt != "":
-        content = global_stmt
-        global_meta_data = copy.deepcopy(base_meta_data)
-
-        doc = Document(
-            text=content,
-            metadata=global_meta_data,
-            metadata_template="### {key}: {value}",
-            text_template="Metadata:\n{metadata_str}\n-----\nCode:\n{content}",
-        )
-        doc.excluded_embed_metadata_keys = ["file_name"]  # used for searching only.
-        doc.excluded_llm_metadata_keys = ["file_name"]  # used for searching only.
-        if not check_meta_data(global_meta_data):
-            doc.excluded_embed_metadata_keys = list(global_meta_data.keys())
-            doc.excluded_llm_metadata_keys = list(global_meta_data.keys())
-        documents.append(doc)
-
-    return documents
-
-
-class EmbeddingIndex(ABC):
-    def __init__(
-        self,
-        instance_id,
-        structure,
-        problem_statement,
-        persist_dir,
-        filter_type,
-        index_type,
-        chunk_size,
-        chunk_overlap,
-        logger,
-        **kwargs,
-    ):
-        self.instance_id = instance_id
-        self.structure = structure
-        self.problem_statement = problem_statement
-        self.persist_dir = persist_dir + "/{instance_id}"
-        self.filter_type = filter_type
-        self.index_type = index_type
-        self.chunk_size = chunk_size
-        self.chunk_overlap = chunk_overlap
-        self.logger = logger
-        self.kwargs = kwargs
-        # set some embedding global settings.
-
-        Settings.chunk_size = chunk_size
-        Settings.chunk_overlap = chunk_overlap
-
-    def filter_files(self, files):
-        if self.filter_type == "given_files":
-            given_files = self.kwargs["given_files"][: self.kwargs["filter_top_n"]]
-            return given_files
-        elif self.filter_type == "none":
-            # all files are included
-            return [file_content[0] for file_content in files]
-        else:
-            raise NotImplementedError
-
-    def retrieve(self, mock=False):
-
-        persist_dir = self.persist_dir.format(instance_id=self.instance_id)
-        token_counter = TokenCountingHandler(
-            tokenizer=tiktoken.encoding_for_model("text-embedding-3-small").encode
-        )
-        if not os.path.exists(persist_dir) or mock:
-            files, _, _ = get_full_file_paths_and_classes_and_functions(self.structure)
-            filtered_files = self.filter_files(files)
-            self.logger.info(f"Total number of considered files: {len(filtered_files)}")
-            print(f"Total number of considered files: {len(filtered_files)}")
-            documents = []
-
-            for file_content in files:
-                content = "\n".join(file_content[1])
-                file_name = file_content[0]
-
-                if file_name not in filtered_files:
-                    continue
-
-                # create documents
-                class_info, function_names, _ = parse_source_file(None, content)
-                if self.index_type == "simple":
-                    docs = build_file_documents_simple(
-                        class_info, function_names, file_name, content
-                    )
-                elif self.index_type == "complex":
-                    docs = build_file_documents_complex(
-                        class_info, function_names, file_name, content
-                    )
-                else:
-                    raise NotImplementedError
-
-                documents.extend(docs)
-
-            self.logger.info(f"Total number of documents: {len(documents)}")
-            print(f"Total number of documents: {len(documents)}")
-
-            if mock:
-                embed_model = MockEmbedding(
-                    embed_dim=1024
-                )  # embedding dimension does not matter for mocking.
-                Settings.callback_manager = CallbackManager([token_counter])
-            else:
-                embed_model = OpenAIEmbedding(model_name="text-embedding-3-small")
-            index = VectorStoreIndex.from_documents(documents, embed_model=embed_model)
-            index.storage_context.persist(persist_dir=persist_dir)
-        else:
-            storage_context = StorageContext.from_defaults(persist_dir=persist_dir)
-            index = load_index_from_storage(storage_context)
-
-        self.logger.info(f"Retrieving with query:\n{self.problem_statement}")
-
-        retriever = VectorIndexRetriever(index=index, similarity_top_k=100)
-        documents = retriever.retrieve(self.problem_statement)
-
-        self.logger.info(
-            f"Embedding Tokens: {token_counter.total_embedding_token_count}"
-        )
-        print(f"Embedding Tokens: {token_counter.total_embedding_token_count}")
-
-        traj = {
-            "usage": {"embedding_tokens": token_counter.total_embedding_token_count}
-        }
-
-        token_counter.reset_counts()
-
-        if mock:
-            self.logger.info("Skipping since mock=True")
-            return [], None, traj
-
-        file_names = []
-        meta_infos = []
-
-        for node in documents:
-            file_name = node.node.metadata["File Name"]
-            if file_name not in file_names:
-                file_names.append(file_name)
-                self.logger.info("================")
-                self.logger.info(file_name)
-
-            self.logger.info(node.node.text)
-
-            meta_infos.append({"code": node.node.text, "metadata": node.node.metadata})
-
-        return file_names, meta_infos, traj

Repos/HWE/agents/Agentless/agentless/fl/combine.py

@@ -1,82 +0,0 @@
-import argparse
-import json
-import os
-from collections import Counter
-
-from tqdm import tqdm
-
-from agentless.util.utils import load_jsonl
-
-
-def combine_file_level(args):
-
-    embed_used_locs = load_jsonl(args.retrieval_loc_file)
-    model_used_locs = load_jsonl(args.model_loc_file)
-
-    with open(f"{args.output_folder}/embed_used_locs.jsonl", "w") as f:
-        for loc in embed_used_locs:
-            f.write(json.dumps(loc) + "\n")
-
-    with open(f"{args.output_folder}/model_used_locs.jsonl", "w") as f:
-        for loc in model_used_locs:
-            f.write(json.dumps(loc) + "\n")
-
-    for pred in tqdm(model_used_locs, colour="MAGENTA"):
-        instance_id = pred["instance_id"]
-
-        model_loc = pred["found_files"]
-        retrieve_loc = [x for x in embed_used_locs if x["instance_id"] == instance_id][
-            0
-        ]["found_files"]
-
-        combined_loc_counter = Counter()
-        combined_locs = []
-
-        for loc in model_loc[: args.top_n]:
-            combined_loc_counter[loc] += 1
-
-        for loc in retrieve_loc[: args.top_n]:
-            combined_loc_counter[loc] += 1
-
-        combined_locs = [loc for loc, _ in combined_loc_counter.most_common()]
-
-        with open(args.output_file, "a") as f:
-            f.write(
-                json.dumps(
-                    {
-                        "instance_id": instance_id,
-                        "found_files": combined_locs,
-                        "additional_artifact_loc_file": {},
-                        "file_traj": {},
-                    }
-                )
-                + "\n"
-            )
-
-
-def main():
-    parser = argparse.ArgumentParser()
-
-    parser.add_argument("--output_folder", type=str, required=True)
-    parser.add_argument("--output_file", type=str, default="combined_locs.jsonl")
-    parser.add_argument("--retrieval_loc_file", type=str, required=True)
-    parser.add_argument("--model_loc_file", type=str, required=True)
-    # supports file level (step-1) combination
-    parser.add_argument("--top_n", type=int, required=True)
-
-    args = parser.parse_args()
-
-    args.output_file = os.path.join(args.output_folder, args.output_file)
-    assert not os.path.exists(args.output_file), "Output file already exists"
-
-    os.makedirs(args.output_folder, exist_ok=True)
-
-    # dump argument
-    with open(os.path.join(args.output_folder, "args.json"), "w") as f:
-        json.dump(vars(args), f, indent=4)
-
-    combine_file_level(args)
-
-
-if __name__ == "__main__":
-    main()

Repos/HWE/agents/Agentless/agentless/fl/localize.py

@@ -1,680 +0,0 @@
-import argparse
-import concurrent.futures
-import json
-import os
-from threading import Lock
-
-from datasets import load_dataset
-from tqdm import tqdm
-
-from agentless.fl.FL import LLMFL
-from agentless.util.preprocess_data import (
-    check_contains_valid_loc,
-    filter_non_source,
-    filter_out_test_files,
-    get_repo_structure,
-)
-from agentless.util.utils import load_existing_instance_ids, load_jsonl, setup_logger
-
-MAX_RETRIES = 5
-HDL_EXTENSIONS = {".v", ".sv", ".vh", ".svh"}
-
-
-def _filter_hdl_files(files):
-    return [
-        file
-        for file in files
-        if os.path.splitext(file)[1].lower() in HDL_EXTENSIONS
-    ]
-
-
-def _filter_loc_dict(locs, allowed_files):
-    if not isinstance(locs, dict):
-        return locs
-    return {file: loc for file, loc in locs.items() if file in allowed_files}
-
-
-def _filter_edit_locs(edit_locs, allowed_files):
-    if isinstance(edit_locs, list):
-        return [
-            _filter_loc_dict(loc, allowed_files) if isinstance(loc, dict) else loc
-            for loc in edit_locs
-        ]
-    if isinstance(edit_locs, dict):
-        return _filter_loc_dict(edit_locs, allowed_files)
-    return edit_locs
-
-
-def load_bench_data(args):
-    if args.dataset_path:
-        if args.dataset_path.endswith(".jsonl"):
-            return load_jsonl(args.dataset_path)
-        if args.dataset_path.endswith(".json"):
-            with open(args.dataset_path, "r") as f:
-                return json.load(f)
-        raise ValueError("Unsupported dataset_path; use .json or .jsonl")
-    return load_dataset(args.dataset, split=args.dataset_split)
-
-
-def localize_irrelevant_instance(
-    bug, args, swe_bench_data, existing_instance_ids, write_lock=None
-):
-    instance_id = bug["instance_id"]
-    log_file = os.path.join(
-        args.output_folder, "localization_logs", f"{instance_id}.log"
-    )
-    if args.target_id is not None:
-        if args.target_id != bug["instance_id"]:
-            return
-
-    logger = setup_logger(log_file)
-    logger.info(f"Processing bug {instance_id}")
-
-    if bug["instance_id"] in existing_instance_ids:
-        logger.info(f"Skipping existing instance_id: {bug['instance_id']}")
-        return
-
-    logger.info(f"================ localize {instance_id} ================")
-
-    bench_data = [x for x in swe_bench_data if x["instance_id"] == instance_id][0]
-    problem_statement = bench_data["problem_statement"]
-    structure = get_repo_structure(
-        instance_id, bug["repo"], bug["base_commit"], "playground"
-    )
-
-    filter_non_source(structure)  # some basic filtering steps
-    filter_out_test_files(structure)
-
-    found_files = []
-    found_related_locs = {}
-    found_edit_locs = {}
-
-    additional_artifact_loc_file = None
-    additional_artifact_loc_related = None
-    additional_artifact_loc_edit_location = None
-    file_traj, related_loc_traj, edit_loc_traj = {}, {}, {}
-
-    # file level localization
-    if args.file_level:
-        fl = LLMFL(
-            instance_id,
-            structure,
-            problem_statement,
-            args.model,
-            args.backend,
-            logger,
-        )
-        found_files, additional_artifact_loc_file, file_traj = fl.localize_irrelevant(
-            mock=args.mock
-        )
-        found_files = _filter_hdl_files(found_files)
-    else:
-        raise NotImplementedError
-
-    if write_lock is not None:
-        write_lock.acquire()
-    allowed_files = set(found_files)
-    found_related_locs = _filter_loc_dict(found_related_locs, allowed_files)
-    found_edit_locs = _filter_edit_locs(found_edit_locs, allowed_files)
-    with open(args.output_file, "a") as f:
-        f.write(
-            json.dumps(
-                {
-                    "instance_id": instance_id,
-                    "found_files": found_files,
-                    "additional_artifact_loc_file": additional_artifact_loc_file,
-                    "file_traj": file_traj,
-                    "found_related_locs": found_related_locs,
-                    "additional_artifact_loc_related": additional_artifact_loc_related,
-                    "related_loc_traj": related_loc_traj,
-                    "found_edit_locs": found_edit_locs,
-                    "additional_artifact_loc_edit_location": additional_artifact_loc_edit_location,
-                    "edit_loc_traj": edit_loc_traj,
-                }
-            )
-            + "\n"
-        )
-    if write_lock is not None:
-        write_lock.release()
-
-
-def localize_instance(
-    bug, args, swe_bench_data, start_file_locs, existing_instance_ids, write_lock=None
-):
-    instance_id = bug["instance_id"]
-    log_file = os.path.join(
-        args.output_folder, "localization_logs", f"{instance_id}.log"
-    )
-    if args.target_id is not None:
-        if args.target_id != bug["instance_id"]:
-            return
-
-    logger = setup_logger(log_file)
-    logger.info(f"Processing bug {instance_id}")
-
-    if instance_id in existing_instance_ids:
-        logger.info(f"Skipping existing instance_id: {bug['instance_id']}")
-        return
-
-    structure = get_repo_structure(
-        instance_id, bug["repo"], bug["base_commit"], "playground"
-    )
-
-    logger.info(f"================ localize {instance_id} ================")
-
-    bench_data = [x for x in swe_bench_data if x["instance_id"] == instance_id][0]
-    problem_statement = bench_data["problem_statement"]
-
-    filter_non_source(structure)  # some basic filtering steps
-    filter_out_test_files(structure)
-
-    found_files = []
-    found_related_locs = {}
-    found_edit_locs = {}
-    additional_artifact_loc_file = None
-    additional_artifact_loc_related = None
-    additional_artifact_loc_edit_location = None
-    file_traj, related_loc_trajs, edit_loc_traj = {}, [], {}
-
-    # file level localization
-    if args.file_level:
-        fl = LLMFL(
-            instance_id,
-            structure,
-            problem_statement,
-            args.model,
-            args.backend,
-            logger,
-        )
-        found_files, additional_artifact_loc_file, file_traj = fl.localize(
-            mock=args.mock
-        )
-        found_files = _filter_hdl_files(found_files)
-    else:
-        # assume start_file is provided
-        for locs in start_file_locs:
-            if locs["instance_id"] == instance_id:
-                found_files = locs["found_files"]
-                if "additional_artifact_loc_file" in locs:
-                    additional_artifact_loc_file = locs["additional_artifact_loc_file"]
-                    file_traj = locs["file_traj"]
-                if "found_related_locs" in locs:
-                    found_related_locs = locs["found_related_locs"]
-                    additional_artifact_loc_related = locs[
-                        "additional_artifact_loc_related"
-                    ]
-                    related_loc_trajs = locs["related_loc_traj"]
-                break
-
-        found_files = _filter_hdl_files(found_files)
-        allowed_files = set(found_files)
-        found_related_locs = _filter_loc_dict(found_related_locs, allowed_files)
-
-        if len(found_files) == 0:
-            return
-
-    # related class, functions, global var localization
-    if args.related_level:
-        if len(found_files) != 0:
-            trying_temp = 0  # related always try with temp 0
-            related_loc_trajs = []
-            for _ in range(MAX_RETRIES):
-                pred_files = found_files[: args.top_n]
-                fl = LLMFL(
-                    instance_id,
-                    structure,
-                    problem_statement,
-                    args.model,
-                    args.backend,
-                    logger,
-                )
-                additional_artifact_loc_related = []
-                found_related_locs = {}
-                related_loc_traj = {}
-                if args.compress and not args.related_level_separate_file:
-                    (
-                        found_related_locs,
-                        additional_artifact_loc_related,
-                        related_loc_traj,
-                    ) = fl.localize_function_from_compressed_files(
-                        pred_files,
-                        mock=args.mock,
-                        temperature=trying_temp,
-                        keep_old_order=args.keep_old_order,
-                        compress_assign=args.compress_assign,
-                        total_lines=args.compress_assign_total_lines,
-                        prefix_lines=args.compress_assign_prefix_lines,
-                        suffix_lines=args.compress_assign_suffix_lines,
-                    )
-                    additional_artifact_loc_related = [additional_artifact_loc_related]
-                    related_loc_trajs.append(related_loc_traj)
-
-                    if check_contains_valid_loc(
-                        found_related_locs, structure=structure
-                    ):
-                        break
-
-                    logger.info(
-                        f"No valid related locations found ... retrying with higher temperature ..."
-                    )
-                    trying_temp = 1.0  # set trying temp to 1 to get valid locs
-
-                elif args.compress and args.related_level_separate_file:
-                    additional_artifact_loc_related = []
-                    found_related_locs = {fn: [] for fn in pred_files}
-                    related_loc_traj = []
-                    for i, pred_file in enumerate(pred_files):
-                        (
-                            found_related_locs_i,
-                            additional_artifact_loc_related_i,
-                            related_loc_traj_i,
-                        ) = fl.localize_function_from_compressed_files(
-                            [pred_file],
-                            mock=args.mock,
-                            temperature=trying_temp,
-                            compress_assign=args.compress_assign,
-                            total_lines=args.compress_assign_total_lines,
-                            prefix_lines=args.compress_assign_prefix_lines,
-                            suffix_lines=args.compress_assign_suffix_lines,
-                        )
-                        found_related_locs[pred_file] = found_related_locs_i[pred_file]
-                        additional_artifact_loc_related.append(
-                            additional_artifact_loc_related_i
-                        )
-                        related_loc_traj.append(related_loc_traj_i)
-                    related_loc_trajs.append(related_loc_traj)
-
-                    if check_contains_valid_loc(
-                        found_related_locs, structure=structure
-                    ):
-                        break
-                    trying_temp = 1.0  # set trying temp to 1 to get valid locs
-                else:
-                    # directly use raw code file instead of skeleton format as ablation
-                    (
-                        found_related_locs,
-                        additional_artifact_loc_related,
-                        related_loc_traj,
-                    ) = fl.localize_function_from_raw_text(
-                        pred_files,
-                        mock=args.mock,
-                        temperature=trying_temp,
-                        keep_old_order=args.keep_old_order,
-                    )
-                    additional_artifact_loc_related = [additional_artifact_loc_related]
-                    related_loc_trajs.append(related_loc_traj)
-
-                    if check_contains_valid_loc(
-                        found_related_locs, structure=structure
-                    ):
-                        break
-
-                    logger.info(
-                        f"No valid related locations found ... retrying with higher temperature ..."
-                    )
-                    trying_temp = 1.0  # set trying temp to 1 to get valid locs
-
-    if args.fine_grain_line_level:
-        if len(found_files) != 0:
-            # Only supports the following args for now
-            trying_temp = args.temperature
-            for _ in range(MAX_RETRIES):
-                pred_files = found_files[: args.top_n]
-                fl = LLMFL(
-                    instance_id,
-                    structure,
-                    problem_statement,
-                    args.model,
-                    args.backend,
-                    logger,
-                )
-                if not args.direct_edit_loc:
-                    coarse_found_locs = found_related_locs
-                    (
-                        found_edit_locs,
-                        additional_artifact_loc_edit_location,
-                        edit_loc_traj,
-                    ) = fl.localize_line_from_coarse_function_locs(
-                        pred_files,
-                        coarse_found_locs,
-                        context_window=args.context_window,
-                        add_space=args.add_space,
-                        no_line_number=args.no_line_number,
-                        sticky_scroll=args.sticky_scroll,
-                        mock=args.mock,
-                        temperature=trying_temp,
-                        num_samples=args.num_samples,
-                        keep_old_order=args.keep_old_order,
-                    )
-                    additional_artifact_loc_edit_location = [
-                        additional_artifact_loc_edit_location
-                    ]
-                    if args.num_samples > 1 and isinstance(found_edit_locs, dict):
-                        logger.info(
-                            "Requested multiple samples but got a single response from "
-                            f"{args.backend}:{args.model}; wrapping for validation."
-                        )
-                        found_edit_locs = [found_edit_locs]
-
-                    sample_valid = False
-                    if args.num_samples > 1:
-                        for found_edit_loc in found_edit_locs:
-                            if check_contains_valid_loc(
-                                found_edit_loc, structure=structure
-                            ):
-                                # at least one set of location contains valid edit locs is okay
-                                sample_valid = True
-                                break
-                    else:
-                        if check_contains_valid_loc(
-                            found_edit_locs, structure=structure
-                        ):
-                            break
-
-                    if sample_valid:
-                        break
-
-                    logger.info(
-                        f"No valid edit locations found ... retrying with higher temperature ..."
-                    )
-                    trying_temp = 1.0  # set trying temp to 1 to get valid locs
-                else:
-                    # directly use the raw source code to get to edit location, used as ablation setting
-                    (
-                        found_edit_locs,
-                        additional_artifact_loc_edit_location,
-                        edit_loc_traj,
-                    ) = fl.localize_line_from_raw_text(
-                        pred_files,
-                        mock=args.mock,
-                        temperature=trying_temp,
-                        num_samples=args.num_samples,
-                        keep_old_order=args.keep_old_order,
-                    )
-                    additional_artifact_loc_edit_location = [
-                        additional_artifact_loc_edit_location
-                    ]
-                    if args.num_samples > 1 and isinstance(found_edit_locs, dict):
-                        logger.info(
-                            "Requested multiple samples but got a single response from "
-                            f"{args.backend}:{args.model}; wrapping for validation."
-                        )
-                        found_edit_locs = [found_edit_locs]
-
-                    if check_contains_valid_loc(
-                        found_related_locs, structure=structure
-                    ):
-                        break
-
-                    sample_valid = False
-                    if args.num_samples > 1:
-                        for found_edit_loc in found_edit_locs:
-                            if check_contains_valid_loc(
-                                found_edit_loc, structure=structure
-                            ):
-                                # at least one set of location contains valid edit locs is okay
-                                sample_valid = True
-                                break
-                    else:
-                        if check_contains_valid_loc(
-                            found_edit_locs, structure=structure
-                        ):
-                            break
-
-                    if sample_valid:
-                        break
-
-                    logger.info(
-                        f"No valid edit locations found ... retrying with higher temperature ..."
-                    )
-                    trying_temp = 1.0  # set trying temp to 1 to get valid locs
-
-    if write_lock is not None:
-        write_lock.acquire()
-    with open(args.output_file, "a") as f:
-        f.write(
-            json.dumps(
-                {
-                    "instance_id": instance_id,
-                    "found_files": found_files,
-                    "additional_artifact_loc_file": additional_artifact_loc_file,
-                    "file_traj": file_traj,
-                    "found_related_locs": found_related_locs,
-                    "additional_artifact_loc_related": additional_artifact_loc_related,
-                    "related_loc_traj": related_loc_trajs,
-                    "found_edit_locs": found_edit_locs,
-                    "additional_artifact_loc_edit_location": additional_artifact_loc_edit_location,
-                    "edit_loc_traj": edit_loc_traj,
-                }
-            )
-            + "\n"
-        )
-    if write_lock is not None:
-        write_lock.release()
-
-
-def localize_irrelevant(args):
-    swe_bench_data = load_bench_data(args)
-    existing_instance_ids = (
-        load_existing_instance_ids(args.output_file) if args.skip_existing else set()
-    )
-    if args.num_threads == 1:
-        for bug in tqdm(swe_bench_data, colour="MAGENTA"):
-            localize_irrelevant_instance(
-                bug, args, swe_bench_data, existing_instance_ids
-            )
-    else:
-        write_lock = Lock()
-        with concurrent.futures.ThreadPoolExecutor(
-            max_workers=args.num_threads
-        ) as executor:
-            futures = [
-                executor.submit(
-                    localize_irrelevant_instance,
-                    bug,
-                    args,
-                    swe_bench_data,
-                    existing_instance_ids,
-                    write_lock,
-                )
-                for bug in swe_bench_data
-            ]
-            for future in tqdm(
-                concurrent.futures.as_completed(futures),
-                total=len(swe_bench_data),
-                colour="MAGENTA",
-            ):
-                future.result()
-
-
-def localize(args):
-    swe_bench_data = load_bench_data(args)
-    start_file_locs = load_jsonl(args.start_file) if args.start_file else None
-    existing_instance_ids = (
-        load_existing_instance_ids(args.output_file) if args.skip_existing else set()
-    )
-
-    if args.num_threads == 1:
-        for bug in tqdm(swe_bench_data, colour="MAGENTA"):
-            localize_instance(
-                bug, args, swe_bench_data, start_file_locs, existing_instance_ids
-            )
-    else:
-        write_lock = Lock()
-        with concurrent.futures.ThreadPoolExecutor(
-            max_workers=args.num_threads
-        ) as executor:
-            futures = [
-                executor.submit(
-                    localize_instance,
-                    bug,
-                    args,
-                    swe_bench_data,
-                    start_file_locs,
-                    existing_instance_ids,
-                    write_lock,
-                )
-                for bug in swe_bench_data
-            ]
-            for future in tqdm(
-                concurrent.futures.as_completed(futures),
-                total=len(swe_bench_data),
-                colour="MAGENTA",
-            ):
-                future.result()
-
-
-def merge(args):
-    """Merge predicted locations."""
-    start_file_locs = load_jsonl(args.start_file)
-
-    def merge_locs(sample_found_locs: list[dict]):
-        merged_found_locs = {}
-        for locs in sample_found_locs:
-            for fn, file_found_locs in locs.items():
-                if isinstance(file_found_locs, str) and file_found_locs.strip():
-                    merged_found_locs.setdefault(fn, [""])[0] += "\n" + file_found_locs
-                elif "\n".join(file_found_locs).strip():
-                    merged_found_locs.setdefault(fn, [""])[0] += "\n" + "\n".join(
-                        file_found_locs
-                    )
-        return merged_found_locs
-
-    # Dump each location sample.
-    for st_id in range(args.num_samples):
-        en_id = st_id
-        merged_locs = []
-        for locs in start_file_locs:
-            merged_found_locs = []
-            if "found_edit_locs" in locs and len(locs["found_edit_locs"]):
-                merged_found_locs = merge_locs(
-                    locs["found_edit_locs"][st_id : st_id + 1]
-                )
-            merged_locs.append({**locs, "found_edit_locs": merged_found_locs})
-        with open(
-            f"{args.output_folder}/loc_merged_{st_id}-{en_id}_outputs.jsonl", "w"
-        ) as f:
-            for data in merged_locs:
-                f.write(json.dumps(data) + "\n")
-
-
-def check_valid_args(args):
-    assert (
-        not os.path.exists(args.output_file) or args.skip_existing
-    ), "Output file already exists and not set to skip existing localizations"
-
-    assert not (
-        args.file_level and args.start_file
-    ), "Cannot use both file_level and start_file"
-
-    assert not (
-        args.file_level and args.fine_grain_line_level and not args.related_level
-    ), "Cannot use both file_level and fine_grain_line_level without related_level"
-
-    assert not (
-        (not args.file_level) and (not args.start_file)
-    ), "Must use either file_level or start_file"
-
-    assert (not "deepseek" in args.model) or (
-        args.backend == "deepseek"
-    ), "Must specify `--backend deepseek` if using a DeepSeek model"
-
-
-def main():
-    parser = argparse.ArgumentParser()
-
-    parser.add_argument("--output_folder", type=str, required=True)
-    parser.add_argument("--output_file", type=str, default="loc_outputs.jsonl")
-    parser.add_argument(
-        "--start_file",
-        type=str,
-        help="""previous output file to start with to reduce
-        the work, should use in combination without --file_level""",
-    )
-    parser.add_argument("--file_level", action="store_true")
-    parser.add_argument("--related_level", action="store_true")
-    parser.add_argument("--fine_grain_line_level", action="store_true")
-    parser.add_argument("--top_n", type=int, default=3)
-    parser.add_argument("--temperature", type=float, default=0.0)
-    parser.add_argument("--num_samples", type=int, default=1)
-    parser.add_argument("--compress", action="store_true")
-    parser.add_argument("--compress_assign", action="store_true")
-    parser.add_argument("--compress_assign_total_lines", type=int, default=30)
-    parser.add_argument("--compress_assign_prefix_lines", type=int, default=10)
-    parser.add_argument("--compress_assign_suffix_lines", type=int, default=10)
-    parser.add_argument("--merge", action="store_true")
-    parser.add_argument("--add_space", action="store_true")
-    parser.add_argument("--no_line_number", action="store_true")
-    parser.add_argument("--sticky_scroll", action="store_true")
-    parser.add_argument("--related_level_separate_file", action="store_true")
-    parser.add_argument("--context_window", type=int, default=10)
-    parser.add_argument("--keep_old_order", action="store_true")
-    parser.add_argument("--irrelevant", action="store_true")
-    parser.add_argument("--direct_edit_loc", action="store_true")
-    parser.add_argument(
-        "--num_threads",
-        type=int,
-        default=1,
-        help="Number of threads to use for creating API requests",
-    )
-    parser.add_argument("--target_id", type=str)
-    parser.add_argument(
-        "--skip_existing",
-        action="store_true",
-        help="Skip localization of instance id's which already contain a localization in the output file.",
-    )
-    parser.add_argument(
-        "--mock", action="store_true", help="Mock run to compute prompt tokens."
-    )
-    parser.add_argument(
-        "--model",
-        type=str,
-        default=os.getenv("AGENTLESS_MODEL", "gpt-5.2"),
-        help="Model name (defaults to $AGENTLESS_MODEL).",
-    )
-    parser.add_argument(
-        "--backend",
-        type=str,
-        default="openai",
-        choices=["openai", "deepseek", "anthropic"],
-    )
-    parser.add_argument(
-        "--dataset",
-        type=str,
-        default="princeton-nlp/SWE-bench_Lite",
-        choices=["princeton-nlp/SWE-bench_Lite", "princeton-nlp/SWE-bench_Verified"],
-        help="Current supported dataset for evaluation",
-    )
-    parser.add_argument(
-        "--dataset_path",
-        type=str,
-        help="Local dataset file (JSON or JSONL) built by build_dataset.py.",
-    )
-    parser.add_argument(
-        "--dataset_split",
-        type=str,
-        default="test",
-        help="Split name when loading an HF dataset.",
-    )
-
-    args = parser.parse_args()
-    args.output_file = os.path.join(args.output_folder, args.output_file)
-    check_valid_args(args)
-
-    os.makedirs(os.path.join(args.output_folder, "localization_logs"), exist_ok=True)
-    os.makedirs(args.output_folder, exist_ok=True)
-
-    # write the arguments
-    with open(f"{args.output_folder}/args.json", "w") as f:
-        json.dump(vars(args), f, indent=4)
-
-    if args.merge:
-        merge(args)
-    elif args.irrelevant:
-        localize_irrelevant(args)
-    else:
-        localize(args)
-
-
-if __name__ == "__main__":
-    main()

Repos/HWE/agents/Agentless/agentless/fl/retrieve.py

@@ -1,204 +0,0 @@
-import argparse
-import concurrent.futures
-import json
-import os
-from threading import Lock
-
-from datasets import load_dataset
-from tqdm import tqdm
-
-from agentless.fl.Index import EmbeddingIndex
-from agentless.util.preprocess_data import (
-    filter_non_source,
-    filter_out_test_files,
-    get_repo_structure,
-)
-from agentless.util.utils import load_json, load_jsonl, setup_logger
-
-
-def load_bench_data(args):
-    if args.dataset_path:
-        if args.dataset_path.endswith(".jsonl"):
-            return load_jsonl(args.dataset_path)
-        if args.dataset_path.endswith(".json"):
-            with open(args.dataset_path, "r") as f:
-                return json.load(f)
-        raise ValueError("Unsupported dataset_path; use .json or .jsonl")
-    return load_dataset(args.dataset, split=args.dataset_split)
-
-
-def retrieve_locs(bug, args, swe_bench_data, found_files, prev_o, write_lock=None):
-
-    found = False
-    for o in prev_o:
-        if o["instance_id"] == bug["instance_id"]:
-            found = True
-            break
-
-    if found:
-        logger.info(f"skipping {bug['instance_id']} since patch already generated")
-        return None
-
-    instance_id = bug["instance_id"]
-
-    if args.target_id is not None:
-        if args.target_id != instance_id:
-            return None
-
-    log_file = os.path.join(args.output_folder, "retrieval_logs", f"{instance_id}.log")
-    logger = setup_logger(log_file)
-    logger.info(f"Processing bug {instance_id}")
-
-    bench_data = [x for x in swe_bench_data if x["instance_id"] == instance_id][0]
-    problem_statement = bench_data["problem_statement"]
-    structure = get_repo_structure(
-        instance_id, bug["repo"], bug["base_commit"], "playground"
-    )
-
-    filter_non_source(structure)
-    filter_out_test_files(structure)
-
-    if args.filter_file:
-        kwargs = {  # build retrieval kwargs
-            "given_files": [x for x in found_files if x["instance_id"] == instance_id][
-                0
-            ]["found_files"],
-            "filter_top_n": args.filter_top_n,
-        }
-    else:
-        kwargs = {}
-
-    # main retrieval
-    retriever = EmbeddingIndex(
-        instance_id,
-        structure,
-        problem_statement,
-        persist_dir=args.persist_dir,
-        filter_type=args.filter_type,
-        index_type=args.index_type,
-        chunk_size=args.chunk_size,
-        chunk_overlap=args.chunk_overlap,
-        logger=logger,
-        **kwargs,
-    )
-
-    file_names, meta_infos, traj = retriever.retrieve(mock=args.mock)
-
-    if write_lock is not None:
-        write_lock.acquire()
-    with open(args.output_file, "a") as f:
-        f.write(
-            json.dumps(
-                {
-                    "instance_id": instance_id,
-                    "found_files": file_names,
-                    "node_info": meta_infos,
-                    "traj": traj,
-                }
-            )
-            + "\n"
-        )
-    if write_lock is not None:
-        write_lock.release()
-
-
-def retrieve(args):
-    if args.filter_file:
-        found_files = load_jsonl(args.filter_file)
-    else:
-        found_files = []
-
-    swe_bench_data = load_bench_data(args)
-    prev_o = load_jsonl(args.output_file) if os.path.exists(args.output_file) else []
-
-    if args.num_threads == 1:
-        for bug in tqdm(swe_bench_data, colour="MAGENTA"):
-            retrieve_locs(
-                bug, args, swe_bench_data, found_files, prev_o, write_lock=None
-            )
-    else:
-        write_lock = Lock()
-        with concurrent.futures.ThreadPoolExecutor(
-            max_workers=args.num_threads
-        ) as executor:
-            futures = [
-                executor.submit(
-                    retrieve_locs,
-                    bug,
-                    args,
-                    swe_bench_data,
-                    found_files,
-                    prev_o,
-                    write_lock,
-                )
-                for bug in swe_bench_data
-            ]
-            for _ in tqdm(
-                concurrent.futures.as_completed(futures),
-                total=len(swe_bench_data),
-                colour="MAGENTA",
-            ):
-                pass
-
-
-def main():
-    parser = argparse.ArgumentParser()
-
-    parser.add_argument("--output_folder", type=str, required=True)
-    parser.add_argument("--output_file", type=str, default="retrieve_locs.jsonl")
-    parser.add_argument(
-        "--index_type", type=str, default="simple", choices=["simple", "complex"]
-    )
-    parser.add_argument(
-        "--filter_type", type=str, default="none", choices=["none", "given_files"]
-    )
-    parser.add_argument("--filter_top_n", type=int, default=None)
-    parser.add_argument("--filter_file", type=str, default="")
-    parser.add_argument("--chunk_size", type=int, default=1024)
-    parser.add_argument("--chunk_overlap", type=int, default=0)
-    parser.add_argument("--persist_dir", type=str)
-    parser.add_argument("--target_id", type=str)
-    parser.add_argument("--mock", action="store_true")
-    parser.add_argument(
-        "--num_threads",
-        type=int,
-        default=1,
-        help="Number of threads to use for creating API requests (WARNING, embedding token counts are only accurate when thread=1)",
-    )
-    parser.add_argument(
-        "--dataset",
-        type=str,
-        default="princeton-nlp/SWE-bench_Lite",
-        choices=["princeton-nlp/SWE-bench_Lite", "princeton-nlp/SWE-bench_Verified"],
-    )
-    parser.add_argument(
-        "--dataset_path",
-        type=str,
-        help="Local dataset file (JSON or JSONL) built by build_dataset.py.",
-    )
-    parser.add_argument(
-        "--dataset_split",
-        type=str,
-        default="test",
-        help="Split name when loading an HF dataset.",
-    )
-
-    args = parser.parse_args()
-
-    args.output_file = os.path.join(args.output_folder, args.output_file)
-    assert (
-        not args.filter_type == "given_files" or args.filter_file != ""
-    ), "Need to provide a filtering file"
-
-    os.makedirs(args.output_folder, exist_ok=True)
-    os.makedirs(os.path.join(args.output_folder, "retrieval_logs"), exist_ok=True)
-
-    # dump argument
-    with open(os.path.join(args.output_folder, "args.json"), "w") as f:
-        json.dump(vars(args), f, indent=4)
-
-    retrieve(args)
-
-
-if __name__ == "__main__":
-    main()

Repos/HWE/agents/Agentless/agentless/repair/repair.py

@@ -1,855 +0,0 @@
-import argparse
-import concurrent.futures
-import json
-import os
-from difflib import unified_diff
-from threading import Lock
-
-from datasets import load_dataset
-from tqdm import tqdm
-
-from agentless.util.api_requests import num_tokens_from_messages
-from agentless.util.model import make_model
-from agentless.util.postprocess_data import (
-    check_code_differ_by_just_empty_lines,
-    check_syntax,
-    extract_python_blocks,
-    fake_git_repo,
-    lint_code,
-    parse_diff_edit_commands,
-    parse_edit_commands,
-    parse_str_replace_edit_commands,
-    split_edit_multifile_commands,
-)
-from agentless.util.preprocess_data import (
-    get_full_file_paths_and_classes_and_functions,
-    get_repo_structure,
-    line_wrap_content,
-    transfer_arb_locs_to_locs,
-)
-from agentless.util.utils import cleanup_logger, load_jsonl, setup_logger
-
-
-def load_bench_data(args):
-    if args.dataset_path:
-        if args.dataset_path.endswith(".jsonl"):
-            return load_jsonl(args.dataset_path)
-        if args.dataset_path.endswith(".json"):
-            with open(args.dataset_path, "r") as f:
-                return json.load(f)
-        raise ValueError("Unsupported dataset_path; use .json or .jsonl")
-    return load_dataset(args.dataset, split=args.dataset_split)
-
-
-repair_relevant_file_instruction = """
-Below are some code segments, each from a relevant file in a Verilog/SystemVerilog hardware design/verification repository. One or more of these files may contain bugs (e.g., RTL logic issues, reset/clocking problems, parameterization mistakes, width mismatches, or testbench/constraint errors).
-"""
-
-repair_prompt_combine_topn = """
-We are currently solving the following issue within our Verilog/SystemVerilog repository. Here is the issue text:
---- BEGIN ISSUE ---
-{problem_statement}
---- END ISSUE ---
-
-{repair_relevant_file_instruction}
---- BEGIN FILE ---
-```systemverilog
-{content}
---- END FILE ---
-
-Please generate edit_file commands to fix the issue (e.g., adjust RTL modules/interfaces/packages, fix always_comb/always_ff logic, correct signal widths/types, parameters/localparams, assigns, generate blocks, or testbench assertions).
-
-The edit_file command takes four arguments:
-
-edit_file(filename: str, start: int, end: int, content: str) -> None:
-Edit a file. It replaces lines start through end (inclusive) with the given text content in the open file.
-Args:
-filename: str: The full file name to edit.
-start: int: The start line number. Must satisfy start >= 1.
-end: int: The end line number. Must satisfy start <= end <= number of lines in the file.
-content: str: The content to replace the lines with.
-
-Please note that THE edit_file FUNCTION REQUIRES PROPER INDENTATION. If you would like to add the line ' $display(x);', you must fully write that out, with all those spaces before the code!
-Wrap the edit_file command in ```python``` blocks, and include the full file path inside the block as the edit_file filename argument (do not put file paths outside the block).
-"""
-
-repair_prompt_combine_topn_cot = """
-We are currently solving the following issue within our Verilog/SystemVerilog repository. Here is the issue text:
---- BEGIN ISSUE ---
-{problem_statement}
---- END ISSUE ---
-
-{repair_relevant_file_instruction}
---- BEGIN FILE ---
-
-{content}
---- END FILE ---
-
-Please first localize the bug based on the issue statement (e.g., identify the faulty module/interface/package, signal, parameter, always block, assignment, or assertion), and then generate edit_file commands to fix the issue.
-
-The edit_file command takes four arguments:
-
-edit_file(filename: str, start: int, end: int, content: str) -> None:
-Edit a file. It replaces lines start through end (inclusive) with the given text content in the open file.
-Args:
-filename: str: The full file name to edit.
-start: int: The start line number. Must satisfy start >= 1.
-end: int: The end line number. Must satisfy start <= end <= number of lines in the file.
-content: str: The content to replace the lines with.
-
-Please note that THE edit_file FUNCTION REQUIRES PROPER INDENTATION. If you would like to add the line ' $display(x);', you must fully write that out, with all those spaces before the code!
-Wrap the edit_file command in ```python``` blocks, and include the full file path inside the block as the edit_file filename argument (do not put file paths outside the block).
-"""
-
-repair_prompt_combine_topn_cot_diff = """
-We are currently solving the following issue within our Verilog/SystemVerilog repository. Here is the issue text:
---- BEGIN ISSUE ---
-{problem_statement}
---- END ISSUE ---
-
-{repair_relevant_file_instruction}
---- BEGIN FILE ---
-
-{content}
---- END FILE ---
-
-Please first localize the bug based on the issue statement (e.g., identify the faulty module/interface/package, signal, parameter, always block, assignment, generate block, or assertion), and then generate SEARCH/REPLACE edits to fix the issue.
-
-Every SEARCH/REPLACE edit must use this format:
-
-The file path
-
-The start of search block: <<<<<<< SEARCH
-
-A contiguous chunk of lines to search for in the existing source code
-
-The dividing line: =======
-
-The lines to replace into the source code
-
-The end of the replace block: >>>>>>> REPLACE
-
-Here is an example:
-
-```python
-### rtl/top.sv
-<<<<<<< SEARCH
-module top(input logic clk, input logic rst_n);
-=======
-module top(input logic clk, input logic rst_n);
-  // Added reset synchronizer
->>>>>>> REPLACE
-```
-Please note that the SEARCH/REPLACE edit REQUIRES PROPER INDENTATION. If you would like to add the line ' $display(x);', you must fully write that out, with all those spaces before the code!
-Wrap EACH SEARCH/REPLACE edit in a ```python block, and include the file path as the first line INSIDE that block.
-"""
-
-repair_prompt_combine_topn_cot_str_replace = """
-We are currently solving the following issue within our Verilog/SystemVerilog repository. Here is the issue text:
---- BEGIN ISSUE ---
-{problem_statement}
---- END ISSUE ---
-
-{repair_relevant_file_instruction}
---- BEGIN FILE ---
-
-{content}
---- END FILE ---
-
-Please first localize the bug based on the issue statement, and then generate editing commands to fix the issue (e.g., update RTL modules/interfaces/packages, fix signal widths/types, reset/clock logic, parameters/localparams, combinational/sequential logic, assertions, or testbench drivers).
-Each edit command must include the full file path in its `path` field, and do not put file paths outside the command.
-"""
-
-def _post_process_multifile_repair(
-    raw_output: str,
-    file_contents: dict[str, str],
-    logger,
-    file_loc_intervals: dict[str, list],
-    diff_format=False,
-    str_replace_format=False,
-) -> tuple[list[str], list[str]]:
-    if not str_replace_format:
-        edit_multifile_commands = extract_python_blocks(raw_output)
-    else:
-        edit_multifile_commands = raw_output
-    edited_files = []
-    new_contents = []
-    try:
-        file_to_commands = split_edit_multifile_commands(
-            edit_multifile_commands,
-            diff_format=diff_format,
-            str_replace_format=str_replace_format,
-        )
-    except Exception as e:
-        logger.error(e)
-        return edited_files, new_contents
-
-    logger.info("=== file_to_commands: ===")
-    logger.info(json.dumps(file_to_commands, indent=2))
-
-    for edited_file_key in file_to_commands:
-        edited_file = ""
-        new_content = ""
-        try:
-            logger.info(f"=== edited_file: {edited_file_key} ===")
-            edit_commands = file_to_commands[edited_file_key]
-            logger.info("=== edit_commands: ===")
-            for c in edit_commands:
-                logger.info(c)
-                logger.info("\n" + "-" * 40)
-            edited_file = eval(edited_file_key)  # convert '"file.py"' to 'file.py'
-            content = file_contents[edited_file]
-            if diff_format:
-                new_content = parse_diff_edit_commands(
-                    edit_commands, content, file_loc_intervals[edited_file]
-                )
-            elif str_replace_format:
-                new_content = parse_str_replace_edit_commands(
-                    edit_commands, content, file_loc_intervals[edited_file]
-                )
-            else:
-                new_content = parse_edit_commands(edit_commands, content)
-        except Exception as e:
-            logger.error(e)
-            edited_file = ""
-            new_content = ""
-
-        if edited_file == "" or new_content == "":
-            continue
-        edited_files.append(edited_file)
-        new_contents.append(new_content)
-        diff = list(
-            unified_diff(
-                content.split("\n"),
-                new_content.split("\n"),
-                fromfile=edited_file,
-                tofile=edited_file,
-                lineterm="",
-            )
-        )
-
-        logger.info(f"extracted patch:")
-        logger.info("\n".join(diff))
-        print("\n".join(diff))
-
-    return edited_files, new_contents
-
-
-def construct_topn_file_context(
-    file_to_locs,
-    pred_files,
-    file_contents,
-    structure,
-    context_window: int,
-    loc_interval: bool = True,
-    fine_grain_loc_only: bool = False,
-    add_space: bool = False,
-    sticky_scroll: bool = False,
-    no_line_number: bool = True,
-):
-    """Concatenate provided locations to form a context.
-
-    loc: {"file_name_1": ["loc_str_1"], ...}
-    """
-    file_loc_intervals = dict()
-    topn_content = ""
-
-    for pred_file, locs in file_to_locs.items():
-        content = file_contents[pred_file]
-        line_locs, context_intervals = transfer_arb_locs_to_locs(
-            locs,
-            structure,
-            pred_file,
-            context_window,
-            loc_interval,
-            fine_grain_loc_only,
-            file_content=file_contents[pred_file] if pred_file in file_contents else "",
-        )
-
-        if len(line_locs) > 0:
-            # Note that if no location is predicted, we exclude this file.
-            file_loc_content = line_wrap_content(
-                content,
-                context_intervals,
-                add_space=add_space,
-                no_line_number=no_line_number,
-                sticky_scroll=sticky_scroll,
-            )
-            topn_content += f"### {pred_file}\n{file_loc_content}\n\n\n"
-            file_loc_intervals[pred_file] = context_intervals
-
-    return topn_content, file_loc_intervals
-
-
-def process_loc(loc, args, swe_bench_data, prev_o, write_lock=None):
-    instance_id = loc["instance_id"]
-
-    if args.target_id is not None:
-        if args.target_id != instance_id:
-            return
-
-    log_file = os.path.join(args.output_folder, "repair_logs", f"{instance_id}.log")
-    logger = setup_logger(log_file)
-    found = False
-    for o in prev_o:
-        if o["instance_id"] == instance_id:
-            found = True
-            break
-
-    if found:
-        logger.info(f"skipping {instance_id} since patch already generated")
-        return None
-
-    logger.info(f"================ repairing {instance_id} ================")
-    if len(loc["found_files"]) == 0:
-        if write_lock is not None:
-            write_lock.acquire()
-        with open(args.output_file, "a") as f:
-            f.write(
-                json.dumps(
-                    {
-                        "instance_id": instance_id,
-                        "raw_output": [""],
-                        "try_count": [0],
-                        "all_generations": [[]],
-                        "traj": [],
-                        "prev_content": [[]],
-                        "file_names": [[]],
-                    }
-                )
-                + "\n"
-            )
-        if write_lock is not None:
-            write_lock.release()
-        return
-
-    pred_files = loc["found_files"][: args.top_n]
-    bench_data = [x for x in swe_bench_data if x["instance_id"] == instance_id][0]
-    problem_statement = bench_data["problem_statement"]
-    structure = get_repo_structure(
-        instance_id, bench_data["repo"], bench_data["base_commit"], "playground"
-    )
-    files, _, _ = get_full_file_paths_and_classes_and_functions(structure)
-    raw_outputs, counts, all_generations, traj, prev_contents, file_names = (
-        [],
-        [],
-        [],
-        [],
-        [],
-        [],
-    )
-
-    raw_output = ""
-    topn_content = ""
-    # Construct file contents
-    file_contents = dict()
-    for i, pred_file in enumerate(pred_files):
-        content = None
-        for file_content in files:
-            if file_content[0] == pred_file:
-                content = "\n".join(file_content[1])
-                file_contents[pred_file] = content
-                break
-
-        assert content is not None, f"{pred_file} file not found"
-    # Construct top-n file context
-    file_to_edit_locs = dict()
-
-    if "found_edit_locs" in loc:
-        file_to_edit_locs = loc["found_edit_locs"]
-
-    topn_content, file_loc_intervals = construct_topn_file_context(
-        file_to_edit_locs,
-        pred_files,
-        file_contents,
-        structure,
-        context_window=args.context_window,
-        loc_interval=args.loc_interval,
-        fine_grain_loc_only=args.fine_grain_loc_only,
-        add_space=args.add_space,
-        no_line_number=args.diff_format or args.str_replace_format,
-        sticky_scroll=args.sticky_scroll,
-    )
-
-    if topn_content.strip() == "":
-        if write_lock is not None:
-            write_lock.acquire()
-        with open(args.output_file, "a") as f:
-            f.write(
-                json.dumps(
-                    {
-                        "instance_id": instance_id,
-                        "raw_output": [""],
-                        "try_count": [0],
-                        "all_generations": [[]],
-                        "traj": [],
-                        "prev_content": [[]],
-                        "file_names": [[]],
-                    }
-                )
-                + "\n"
-            )
-        if write_lock is not None:
-            write_lock.release()
-        return
-
-    prompt_template = (
-        repair_prompt_combine_topn_cot_str_replace
-        if args.cot and args.str_replace_format
-        else repair_prompt_combine_topn_cot_diff
-        if args.cot and args.diff_format
-        else repair_prompt_combine_topn_cot
-        if args.cot
-        else repair_prompt_combine_topn
-    )
-    file_instruction = repair_relevant_file_instruction
-    message = prompt_template.format(
-        repair_relevant_file_instruction=file_instruction,
-        problem_statement=problem_statement,
-        content=topn_content.rstrip(),
-    ).strip()
-    logger.info(f"prompting with message:\n{message}")
-
-    all_generations, counts, traj, prev_contents, file_names = [], [], [], [], []
-    sample_responses = []
-    # get greedy sample
-    model = make_model(
-        model=args.model,
-        logger=logger,
-        backend=args.backend,
-        max_tokens=1024,
-        temperature=0,
-        batch_size=1,
-    )
-    if args.skip_greedy:
-        greedy_traj = {
-            "response": "",
-            "usage": {
-                "completion_tokens": 0,
-                "prompt_tokens": 0,
-            },
-        }
-    else:
-        if args.mock:
-            greedy_traj = {
-                "response": "",
-                "usage": {
-                    "prompt_tokens": num_tokens_from_messages(message, args.model),
-                },
-            }
-        else:
-            if args.str_replace_format:
-                greedy_traj = model.codegen_w_tool(
-                    message, num_samples=1, prompt_cache=args.max_samples > 1
-                )[0]
-            else:
-                greedy_traj = model.codegen(
-                    message, num_samples=1, prompt_cache=args.max_samples > 1
-                )[0]
-
-    sample_responses.append(greedy_traj)
-    # get temperature samples
-    model = make_model(
-        model=args.model,
-        logger=logger,
-        backend=args.backend,
-        max_tokens=1024,
-        temperature=0.8,
-        batch_size=args.max_samples - 1,  # minus the 1 greedy sample
-    )
-
-    if args.mock:
-        first_traj = {
-            "response": "",
-            "usage": {
-                "prompt_tokens": num_tokens_from_messages(message, args.model),
-            },
-        }
-        later_traj = {
-            "response": "",
-            "usage": {"prompt_tokens": 0},
-        }
-        if args.max_samples - 1:
-            sample_trajs = [first_traj] + [later_traj] * (args.max_samples - 2)
-        else:
-            sample_trajs = []
-    else:
-        if args.max_samples - 1:
-            # always use cached prompt if possible for later samples
-            if args.str_replace_format:
-                sample_trajs = model.codegen_w_tool(
-                    message, num_samples=args.max_samples - 1, prompt_cache=True
-                )
-            else:
-                sample_trajs = model.codegen(
-                    message, num_samples=args.max_samples - 1, prompt_cache=True
-                )
-        else:
-            sample_trajs = []
-
-    sample_responses.extend(sample_trajs)
-
-    count = 0
-    while count < args.max_samples:
-        print(f"trying the {count + 1}-th sample ...")
-        ret = sample_responses[count]
-        count += 1
-        traj.append({**ret, "prompt": message})
-
-        if args.mock:
-            continue
-
-        raw_output = ret["response"]
-        logger.info(f"raw output:\n{raw_output}")
-        all_generations.append(raw_output)
-        edited_files, new_contents = _post_process_multifile_repair(
-            raw_output,
-            file_contents,
-            logger,
-            file_loc_intervals,
-            diff_format=args.diff_format,
-            str_replace_format=args.str_replace_format,
-        )
-
-        if len(new_contents) == 0:
-            prev_contents.append("")
-            file_names.append("")
-        else:
-            prev_content = [file_contents[edited_file] for edited_file in edited_files]
-            prev_contents.append(prev_content)
-            file_names.append(edited_files)
-
-        counts.append(count)
-        raw_outputs.append(raw_output)
-
-    if write_lock is not None:
-        write_lock.acquire()
-    with open(args.output_file, "a") as f:
-        f.write(
-            json.dumps(
-                {
-                    "instance_id": instance_id,
-                    "raw_output": raw_outputs,
-                    "all_generations": [all_generations],
-                    "try_count": counts,
-                    "traj": traj,
-                    "prev_content": [prev_contents],
-                    "file_names": [file_names],
-                }
-            )
-            + "\n"
-        )
-    if write_lock is not None:
-        write_lock.release()
-
-
-def repair(args):
-    with open(f"{args.output_folder}/args.json", "w") as f:
-        json.dump(vars(args), f, indent=4)
-
-    swe_bench_data = load_bench_data(args)
-    locs = load_jsonl(args.loc_file)
-    prev_o = load_jsonl(args.output_file) if os.path.exists(args.output_file) else []
-
-    with open(f"{args.output_folder}/used_locs.jsonl", "w") as f:
-        for loc in locs:
-            f.write(json.dumps(loc) + "\n")
-
-    if args.num_threads == 1:
-        for loc in tqdm(locs, total=len(locs), colour="MAGENTA"):
-            process_loc(loc, args, swe_bench_data, prev_o)
-    else:
-        write_lock = Lock()
-        with concurrent.futures.ThreadPoolExecutor(
-            max_workers=args.num_threads
-        ) as executor:
-            futures = {
-                executor.submit(
-                    process_loc, loc, args, swe_bench_data, prev_o, write_lock
-                ): loc
-                for loc in locs
-            }
-            for future in tqdm(
-                concurrent.futures.as_completed(futures),
-                total=len(locs),
-                colour="MAGENTA",
-            ):
-                future.result()
-
-
-def post_process_raw_output(
-    raw_output_text, file_contents, logger, file_loc_intervals, args
-):
-    git_diffs = ""
-    raw_git_diffs = ""
-    edited_files, new_contents, contents = [], [], []
-    try:
-        edited_files, new_contents = _post_process_multifile_repair(
-            raw_output_text,
-            file_contents,
-            logger,
-            file_loc_intervals,
-            diff_format=args.diff_format,
-            str_replace_format=args.str_replace_format,
-        )
-
-        contents = [file_contents[edited_file] for edited_file in edited_files]
-
-        git_diff = fake_git_repo("playground", edited_files, contents, new_contents)
-
-        raw_git_diffs += "\n" + git_diff.replace("\n", "")
-
-        syntax_success = check_syntax(new_contents)
-
-        differ_by_empty_lines = check_code_differ_by_just_empty_lines(
-            new_contents, contents
-        )
-
-        logger.info(f"{differ_by_empty_lines = }")
-        if syntax_success and not differ_by_empty_lines:
-            git_diffs = raw_git_diffs
-        else:
-            git_diffs = ""  # no need to evaluate
-    except Exception as e:
-        print(raw_output_text)
-        print(e)
-
-    return git_diffs, raw_git_diffs, contents, edited_files, new_contents
-
-
-def post_process_repair(args):
-    """
-    apply some diff formatting.
-    """
-    raw_outputs = load_jsonl(args.raw_output_file)
-    locs = load_jsonl(args.loc_file)
-
-    for raw_output in raw_outputs:
-        instance_id = raw_output["instance_id"]
-        log_file = os.path.join(args.output_folder, "repair_logs", f"{instance_id}.log")
-        logger = setup_logger(log_file)
-
-        if raw_output["raw_output"] == "":
-            with open(args.output_file, "a") as f:
-                f.write(
-                    json.dumps(
-                        {
-                            "model_name_or_path": "agentless",
-                            "instance_id": instance_id,
-                            "model_patch": "",
-                        }
-                    )
-                    + "\n"
-                )
-            continue
-
-        if args.select_id == -1:
-            # Use the last generation
-            assert False, "not implemented for now"
-        else:
-            # Use the indexed generation
-            generation_idx = args.select_id
-            try:
-                raw_output_text = raw_output["all_generations"][0][generation_idx]
-                original_file_content = raw_output["prev_content"][0][generation_idx]
-                pred_file = raw_output["file_names"][0][generation_idx]
-
-                pred_files = [loc for loc in locs if loc["instance_id"] == instance_id][
-                    0
-                ]["found_files"][: args.top_n]
-
-                git_diffs = ""
-                raw_git_diffs = ""
-                if isinstance(raw_output["raw_output"], str):
-                    # for backward compatibility
-                    raw_output["raw_output"] = [raw_output["raw_output"]]
-
-                if isinstance(original_file_content, str):
-                    original_file_content = [original_file_content]
-                    pred_file = [pred_file]
-
-                file_contents = {
-                    file_name: o_file_content
-                    for file_name, o_file_content in zip(
-                        pred_file, original_file_content
-                    )
-                }
-
-                file_loc_intervals = dict()
-
-                loc = [loc for loc in locs if loc["instance_id"] == instance_id][0]
-
-                for i, tmp_pred_file in enumerate(pred_files):
-                    if tmp_pred_file not in pred_file:
-                        continue
-                    if (
-                        "found_edit_locs" in loc
-                        and tmp_pred_file in loc["found_edit_locs"]
-                    ):
-                        line_locs, context_intervals = transfer_arb_locs_to_locs(
-                            loc["found_edit_locs"][tmp_pred_file],
-                            None,
-                            loc["found_files"][i],
-                            args.context_window,
-                            args.loc_interval,
-                            args.fine_grain_loc_only,
-                            file_content=file_contents[tmp_pred_file]
-                            if tmp_pred_file in file_contents
-                            else "",
-                        )
-                    else:
-                        line_locs, context_intervals = [], []  # default values.
-
-                    file_loc_intervals[tmp_pred_file] = context_intervals
-            except Exception as e:
-                logger.info(e)
-                print(e)
-                raw_output_text = ""
-
-        if raw_output_text:
-            (
-                git_diffs,
-                raw_git_diffs,
-                content,
-                edited_files,
-                new_contents,
-            ) = post_process_raw_output(
-                raw_output_text, file_contents, logger, file_loc_intervals, args
-            )
-        else:
-            git_diffs = ""
-            raw_git_diffs = ""
-            content = []
-            edited_files = []
-            new_contents = []
-
-        with open(args.output_file, "a") as f:
-            f.write(
-                json.dumps(
-                    {
-                        "model_name_or_path": "agentless",
-                        "instance_id": instance_id,
-                        "model_patch": git_diffs.lstrip(),
-                        "raw_model_patch": raw_git_diffs.lstrip(),
-                        "original_file_content": content,
-                        "edited_files": edited_files,
-                        "new_file_content": new_contents,
-                    }
-                )
-                + "\n"
-            )
-        cleanup_logger(logger)
-
-
-def main():
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--loc_file", type=str, required=True)
-    parser.add_argument("--top_n", type=int, default=1)
-    parser.add_argument("--loc_interval", action="store_true")
-    parser.add_argument("--context_window", type=int, default=10)
-    parser.add_argument("--gen_and_process", action="store_true")
-    parser.add_argument("--max_samples", type=int, default=20, help="Sampling budget.")
-    parser.add_argument(
-        "--select_id",
-        type=int,
-        default=-1,
-        help="Index the selected samples during post-processing.",
-    )
-    parser.add_argument(
-        "--model",
-        type=str,
-        default=os.getenv("AGENTLESS_MODEL", "gpt-5.2"),
-        help="Model name (defaults to $AGENTLESS_MODEL).",
-    )
-    parser.add_argument(
-        "--backend",
-        type=str,
-        default="openai",
-        choices=["openai", "deepseek", "anthropic"],
-    )
-    parser.add_argument("--output_folder", type=str, required=True)
-    parser.add_argument("--post_process", action="store_true")
-    parser.add_argument("--add_space", action="store_true")
-    parser.add_argument("--cot", action="store_true")
-    parser.add_argument("--fine_grain_loc_only", action="store_true")
-    parser.add_argument("--diff_format", action="store_true")
-    parser.add_argument("--str_replace_format", action="store_true")
-    parser.add_argument("--skip_greedy", action="store_true")
-    parser.add_argument("--sticky_scroll", action="store_true")
-    parser.add_argument(
-        "--num_threads",
-        type=int,
-        default=1,
-        help="Number of threads to use for creating API requests",
-    )
-    parser.add_argument("--target_id", type=str)
-    parser.add_argument(
-        "--mock", action="store_true", help="Mock run to compute prompt tokens."
-    )
-    parser.add_argument(
-        "--dataset",
-        type=str,
-        default="princeton-nlp/SWE-bench_Lite",
-        choices=["princeton-nlp/SWE-bench_Lite", "princeton-nlp/SWE-bench_Verified"],
-    )
-    parser.add_argument(
-        "--dataset_path",
-        type=str,
-        help="Local dataset file (JSON or JSONL) built by build_dataset.py.",
-    )
-    parser.add_argument(
-        "--dataset_split",
-        type=str,
-        default="test",
-        help="Split name when loading an HF dataset.",
-    )
-
-    args = parser.parse_args()
-
-    assert (not "deepseek" in args.model) or (
-        args.backend == "deepseek"
-    ), "Must specify `--backend deepseek` if using a DeepSeek model"
-
-    # diff_format and str_replace_format cannot be both True
-    assert not (
-        args.diff_format and args.str_replace_format
-    ), "Cannot use both diff_format and str_replace_format"
-
-    # str_replace_format only supported with anthropic backend
-    assert not (
-        args.str_replace_format and args.backend != "anthropic"
-    ), "str_replace_format only supported with anthropic backend"
-
-    if not os.path.exists(args.output_folder):
-        os.makedirs(args.output_folder)
-    if not os.path.exists(os.path.join(args.output_folder, "repair_logs")):
-        os.makedirs(os.path.join(args.output_folder, "repair_logs"))
-
-    args.output_file = os.path.join(args.output_folder, "output.jsonl")
-
-    if args.post_process:
-        args.raw_output_file = args.output_file
-        if args.select_id == -1:
-            args.output_file = args.raw_output_file.replace(
-                ".jsonl", "_processed.jsonl"
-            )
-        else:
-            args.output_file = args.raw_output_file.replace(
-                ".jsonl", f"_{args.select_id}_processed.jsonl"
-            )
-        post_process_repair(args)
-    elif args.gen_and_process:
-        repair(args)
-        args.raw_output_file = args.output_file
-        for i in range(args.max_samples):
-            args.output_file = args.raw_output_file.replace(
-                ".jsonl", f"_{i}_processed.jsonl"
-            )
-            args.select_id = i
-            post_process_repair(args)
-    else:
-        repair(args)
-
-
-if __name__ == "__main__":
-    main()

Repos/HWE/agents/Agentless/agentless/repair/rerank.py

@@ -1,343 +0,0 @@
-import argparse
-import json
-import os
-from collections import Counter
-from pathlib import Path
-
-from agentless.util.postprocess_data import normalize_patch
-from agentless.util.utils import load_json, load_jsonl
-
-execution_results = dict()
-
-
-def _load_results(args):
-    global execution_results
-
-    roots = [Path(folder) for folder in args.patch_folder.split(",")]
-
-    intervals = [(0, int(args.num_samples / len(roots)) - 1) for _ in range(len(roots))]
-
-    interval = intervals[0]
-    for i in range(interval[0], interval[1] + 1):
-        for _, root in enumerate(roots):
-            patches = load_jsonl(root / f"output_{i}_normalized.jsonl")
-            print(
-                f"Loaded {len(patches)} patches from {root / f'output_{i}_normalized.jsonl'}"
-            )
-            if args.regression:
-                regression_test_results = load_jsonl(
-                    root / f"output_{i}_regression_test_results.jsonl"
-                )
-            if args.reproduction:
-                reproduction_test_results = load_jsonl(
-                    root / f"output_{i}_reproduction_test_results.jsonl"
-                )
-
-            for patch in patches[:]:
-                if args.regression:
-                    regression_test_result = [
-                        x
-                        for x in regression_test_results
-                        if x["instance_id"] == patch["instance_id"]
-                    ][0].get("regression", [0] * 10000)
-                    regression_test_result = len(regression_test_result)
-                else:
-                    regression_test_result = 0
-
-                if args.reproduction:
-                    if (
-                        len(
-                            [
-                                x
-                                for x in reproduction_test_results
-                                if x["instance_id"] == patch["instance_id"]
-                            ]
-                        )
-                        == 1
-                    ):
-                        reproduction_test_result = [
-                            x
-                            for x in reproduction_test_results
-                            if x["instance_id"] == patch["instance_id"]
-                        ][0].get("reproduction", False)
-                    else:
-                        reproduction_test_result = False
-                else:
-                    reproduction_test_result = True
-
-                execution_results.setdefault(patch["instance_id"], []).append(
-                    {
-                        "normalized_patch": patch["normalized_patch"].strip(),
-                        "patch": patch["model_patch"],
-                        "regression_test_result": regression_test_result,
-                        "reproduction_test_result": reproduction_test_result,
-                    }
-                )
-
-
-def get_sample(instance_id, sample_id) -> tuple[str, bool]:
-    """Returns the diff and pass status."""
-    return execution_results[instance_id][sample_id]
-
-
-def get_all_patches(instance_id, num_samples, deduplicate) -> list[str]:
-    """Returns all unique patches."""
-    patches = [execution_results[instance_id][i]["patch"] for i in range(num_samples)]
-    if deduplicate:
-        patch_keys = [
-            execution_results[instance_id][i]["normalized_patch"]
-            for i in range(num_samples)
-        ]
-    else:
-        patch_keys = [
-            execution_results[instance_id][i]["patch"] for i in range(num_samples)
-        ]
-    unique_patches = set()
-    patch_ids = []
-    for i in range(num_samples):
-        patch_key = patch_keys[i].strip()
-        if patch_key and patch_key not in unique_patches:
-            unique_patches.add(patch_key)
-            patch_ids.append(i)
-    return [(id, patches[id]) for id in patch_ids]
-
-
-def get_all_patches_num(instance_id, num_samples, deduplicate) -> list[str]:
-    """Returns all unique patches with number."""
-    # print(f"{len(execution_results)}")
-    patches = [execution_results[instance_id][i]["patch"] for i in range(num_samples)]
-    if deduplicate:
-        patch_keys = [
-            execution_results[instance_id][i]["normalized_patch"]
-            for i in range(num_samples)
-        ]
-    else:
-        patch_keys = [
-            execution_results[instance_id][i]["patch"] for i in range(num_samples)
-        ]
-    unique_patches = {}
-    total_patch_num = {}
-    patch_ids = []
-    for i in range(num_samples):
-        if patch_keys[i] and patch_keys[i] not in unique_patches:
-            unique_patches[patch_keys[i]] = i
-            patch_ids.append(i)
-            total_patch_num[i] = 0
-        if patch_keys[i]:
-            total_patch_num[unique_patches[patch_keys[i]]] += 1
-
-    return [(id, patches[id], total_patch_num[id]) for id in patch_ids]
-
-
-class SetEncoder(json.JSONEncoder):
-    def default(self, obj):
-        if isinstance(obj, set):
-            return list(obj)
-        return json.JSONEncoder.default(self, obj)
-
-
-def modified_length(normalized_patch):
-    changed_length = 0
-
-    for line in normalized_patch.splitlines():
-        if len(line) > 3 and (line.startswith("---") or line.startswith("+++")):
-            continue
-
-        if line.startswith("-"):
-            changed_length += 1
-        if line.startswith("+"):
-            changed_length += 1
-
-    assert changed_length != 0
-
-    return changed_length
-
-
-def majority_voting(args):
-
-    with open(args.output_file, "w") as f:
-
-        for instance_id in execution_results:
-            if len(execution_results[instance_id]) < args.num_samples:
-                print(
-                    f"There were only {len(execution_results[instance_id])} patches for {instance_id} instead of the full {args.num_samples}"
-                )
-
-            patch_keys = [
-                execution_results[instance_id][i]["normalized_patch"]
-                for i in range(len(execution_results[instance_id]))
-            ]
-            regression_tests = [
-                execution_results[instance_id][i]["regression_test_result"]
-                for i in range(len(execution_results[instance_id]))
-            ]
-
-            min_tests = min(regression_tests)
-            regression_tests = [
-                True if x == min_tests else False for x in regression_tests
-            ]
-
-            reproduction_tests = [
-                execution_results[instance_id][i]["reproduction_test_result"]
-                for i in range(len(execution_results[instance_id]))
-            ]
-            raw_patches = [
-                execution_results[instance_id][i]["patch"]
-                for i in range(len(execution_results[instance_id]))
-            ]
-
-            if args.regression and not args.reproduction:
-                patch_ids = [
-                    i
-                    for i in range(len(execution_results[instance_id]))
-                    if patch_keys[i].strip() and regression_tests[i]
-                ]
-            elif args.reproduction:
-                patch_ids = [
-                    i
-                    for i in range(len(execution_results[instance_id]))
-                    if patch_keys[i].strip()
-                    and regression_tests[i]
-                    and reproduction_tests[i]
-                ]
-                if len(patch_ids) == 0:
-                    # reset to just using the all regression passing patches
-                    patch_ids = [
-                        i
-                        for i in range(len(execution_results[instance_id]))
-                        if patch_keys[i].strip() and regression_tests[i]
-                    ]
-            else:
-                patch_ids = [
-                    i
-                    for i in range(len(execution_results[instance_id]))
-                    if patch_keys[i].strip()
-                ]
-
-            if not patch_ids:
-                # just vote on all patches
-                if not all([x.strip() == "" for x in raw_patches]) and not all(
-                    [x.strip() == "" for x in patch_keys]
-                ):
-                    vote = Counter()
-                    first_appear_idx = dict()
-                    valid_indices = []
-                    for i in range(len(execution_results[instance_id])):
-                        sample = get_sample(instance_id, i)
-                        patch_key = sample["normalized_patch"]
-                        if patch_key != "":
-                            valid_indices.append(i)
-                            vote[patch_key] += 1
-                            if patch_key not in first_appear_idx:
-                                first_appear_idx[patch_key] = i
-                    maj_selected_id = max(
-                        valid_indices,
-                        key=lambda i: (
-                            vote[patch_keys[i]],
-                            -first_appear_idx[patch_keys[i]],
-                        ),
-                    )
-                    patch = get_sample(instance_id, maj_selected_id)["patch"]
-                    result = {
-                        "model_name_or_path": "agentless",
-                        "instance_id": instance_id,
-                        "model_patch": patch,
-                    }
-                else:
-                    print(f"No raw patches valid for {instance_id}")
-                    result = {
-                        "model_name_or_path": "agentless",
-                        "instance_id": instance_id,
-                        "model_patch": "",
-                    }
-                f.write(json.dumps(result) + "\n")
-                continue
-
-            vote = Counter()
-            first_appear_idx = dict()
-            changed_length_idx = dict()
-            for i in patch_ids:
-                sample = get_sample(instance_id, i)
-                patch_key, patch = sample["normalized_patch"], sample["patch"]
-                vote[patch_key] += 1
-                if patch_key not in first_appear_idx:
-                    first_appear_idx[patch_key] = i
-                    changed_length_idx[patch_key] = modified_length(patch_key)
-
-            maj_selected_id = max(
-                patch_ids,
-                key=lambda i: (vote[patch_keys[i]], -first_appear_idx[patch_keys[i]]),
-            )
-
-            if args.target is not None and instance_id == args.target:
-                for patch in vote:
-                    print(
-                        "=" * 20,
-                        vote[patch],
-                        "=" * 20,
-                    )
-                    print(patch)
-                    print("=" * 50)
-
-            sample = get_sample(instance_id, maj_selected_id)
-            result = {
-                "model_name_or_path": "agentless",
-                "instance_id": instance_id,
-                "model_patch": sample["patch"],
-            }
-
-            f.write(json.dumps(result) + "\n")
-
-
-def normalize_patches(args):
-    # separate the patch folders
-    output_folders = [Path(folder) for folder in args.patch_folder.split(",")]
-    num_folders = len(output_folders)
-    selected_ids = list(range(int(args.num_samples / num_folders)))
-
-    for output_folder in output_folders:
-        for i in selected_ids:
-            if os.path.exists(output_folder / f"output_{i}_normalized.jsonl"):
-                # skip
-                continue
-            patches = load_jsonl(output_folder / f"output_{i}_processed.jsonl")
-            for d in patches:
-                instance_id = d["instance_id"]
-                patch = d["model_patch"]
-                original_file_content = d["original_file_content"]
-                new_file_content = d["new_file_content"]
-                edited_files = d["edited_files"]
-                normalized_patch = normalize_patch(
-                    instance_id,
-                    patch,
-                    original_file_content,
-                    new_file_content,
-                    edited_files,
-                )
-                d["normalized_patch"] = normalized_patch
-            with open(output_folder / f"output_{i}_normalized.jsonl", "w") as f:
-                for d in patches:
-                    f.write(json.dumps(d) + "\n")
-
-
-def main():
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--patch_folder", type=str)
-    parser.add_argument("--target", type=str, default=None)
-    parser.add_argument("--num_samples", type=int, default=11)
-    parser.add_argument("--deduplicate", action="store_true")
-    parser.add_argument("--regression", action="store_true")
-    parser.add_argument("--reproduction", action="store_true")
-    parser.add_argument("--output_file", type=str, default="all_preds.jsonl")
-    args = parser.parse_args()
-
-    # first normalize
-    normalize_patches(args)
-    # then load results
-    _load_results(args)
-    # then rerank
-    majority_voting(args)
-
-
-if __name__ == "__main__":
-    main()

Repos/HWE/agents/Agentless/agentless/test/generate_reproduction_tests.py

@@ -1,554 +0,0 @@
-import argparse
-import ast
-import concurrent.futures
-import json
-import os
-import re
-from collections import Counter
-from threading import Lock
-
-from datasets import load_dataset
-from tqdm import tqdm
-
-from agentless.util.api_requests import num_tokens_from_messages
-from agentless.util.model import make_model
-from agentless.util.postprocess_data import remove_comments_and_docstrings
-from agentless.util.utils import load_jsonl, setup_logger
-
-generate_tests_prompt_template = """
-We are currently solving the following issue within our repository. Here is the issue text:
---- BEGIN ISSUE ---
-{problem_statement}
---- END ISSUE ---
-
-Please generate a complete test that can be used to reproduce the issue.
-
-The complete test should contain the following:
-1. Necessary imports
-2. Code to reproduce the issue described in the issue text
-3. Print "Issue reproduced" if the outcome indicates that the issue is reproduced
-4. Print "Issue resolved" if the outcome indicates that the issue has been successfully resolved
-5. Print "Other issues" if the outcome indicates there are other issues with the source code
-
-Here is an example:
-
-```python
-from sqlfluff import lint
-
-def test__rules__std_L060_raised() -> None:
-    try:
-        sql = "SELECT   IFNULL(NULL, 100),
-            NVL(NULL,100);"
-        result = lint(sql, rules=["L060"])
-        assert len(result) == 2
-    except:
-        print("Other issues")
-        return
-
-    try:
-        assert result[0]["description"] == "Use 'COALESCE' instead of 'IFNULL'."
-        assert result[1]["description"] == "Use 'COALESCE' instead of 'NVL'."
-        print("Issue resolved")
-    except AssertionError:
-        print("Issue reproduced")
-        return
-
-    return
-
-test__rules__std_L060_raised()
-```
-
-Please ensure the generated test reflects the issue described in the provided issue text.
-The generated test should be able to be used to both reproduce the issue as well as to verify the issue has been fixed.
-Wrap the complete test in ```python...```.
-"""
-
-
-def create_patch_from_code(python_code: str) -> str:
-    patch_header = """diff --git a/reproduce_bug.py b/reproduce_bug.py
-new file mode 100644
-index 0000000..e69de29
-"""
-    patch_body = []
-    patch_body.append("--- /dev/null")
-    patch_body.append("+++ b/reproduce_bug.py")
-
-    code_lines = python_code.split("\n")
-    patch_body.append(f"@@ -0,0 +1,{len(code_lines)} @@")
-
-    for line in code_lines:
-        patch_body.append(f"+{line}")
-
-    return patch_header + "\n".join(patch_body) + "\n"
-
-
-def extract_first_code_block(text):
-    pattern = re.compile(r"```python(.*?)```", re.DOTALL)
-
-    match = pattern.search(text)
-
-    if match:
-        return match.group(1).strip()
-
-    return None
-
-
-def gen_test(instance_id, args, swe_bench_data, prev_o, write_lock=None):
-
-    if args.target_id is not None:
-        if args.target_id != instance_id:
-            return
-
-    log_file = os.path.join(
-        args.output_folder, "generating_test_logs", f"{instance_id}.log"
-    )
-    logger = setup_logger(log_file)
-    found = False
-    for o in prev_o:
-        if o["instance_id"] == instance_id:
-            found = True
-            break
-
-    if found:
-        logger.info(f"skipping {instance_id} since patch already generated")
-        return None
-
-    logger.info(f"================ generating test for {instance_id} ================")
-
-    bench_data = [x for x in swe_bench_data if x["instance_id"] == instance_id][0]
-    problem_statement = bench_data["problem_statement"]
-
-    raw_outputs, counts, all_generations, traj = (
-        [],
-        [],
-        [],
-        [],
-    )
-
-    raw_output = ""
-
-    prompt_template = generate_tests_prompt_template
-    message = prompt_template.format(
-        problem_statement=problem_statement,
-    ).strip()
-
-    logger.info(f"prompting with message:\n{message}")
-
-    all_generations, counts, traj = [], [], []
-    sample_responses = []
-
-    # get greedy sample
-    model = make_model(
-        model=args.model,
-        logger=logger,
-        backend=args.backend,
-        max_tokens=1024,
-        temperature=0,
-        batch_size=1,
-    )
-    if args.skip_greedy:
-        greedy_traj = {
-            "response": "",
-            "usage": {
-                "completion_tokens": 0,
-                "prompt_tokens": 0,
-            },
-        }
-    else:
-        if args.mock:
-            greedy_traj = {
-                "response": "",
-                "usage": {
-                    "prompt_tokens": num_tokens_from_messages(message, args.model),
-                },
-            }
-        else:
-            greedy_traj = model.codegen(
-                message, num_samples=1, prompt_cache=args.max_samples > 1
-            )[0]
-
-    sample_responses.append(greedy_traj)
-    # get temperature samples
-    model = make_model(
-        model=args.model,
-        logger=logger,
-        backend=args.backend,
-        max_tokens=1024,
-        temperature=0.8,
-        batch_size=args.max_samples - 1,  # minus the 1 greedy sample
-    )
-
-    if args.mock:
-        first_traj = {
-            "response": "",
-            "usage": {
-                "prompt_tokens": num_tokens_from_messages(message, args.model),
-            },
-        }
-        later_traj = {
-            "response": "",
-            "usage": {"prompt_tokens": 0},
-        }
-        if args.max_samples - 1:
-            sample_trajs = [first_traj] + [later_traj] * (args.max_samples - 2)
-        else:
-            sample_trajs = []
-    else:
-        if args.max_samples - 1:
-            # always use cached prompt if possible for later samples
-            sample_trajs = model.codegen(
-                message, num_samples=args.max_samples - 1, prompt_cache=True
-            )
-        else:
-            sample_trajs = []
-
-    sample_responses.extend(sample_trajs)
-
-    count = 0
-    while count < args.max_samples:
-        print(f"trying the {count + 1}-th sample ...")
-        ret = sample_responses[count]
-        count += 1
-        traj.append({**ret, "prompt": message})
-
-        if args.mock:
-            continue
-
-        raw_output = ret["response"]
-        logger.info(f"raw output:\n{raw_output}")
-        print((f"raw output:\n{raw_output}"))
-        all_generations.append(raw_output)
-
-        counts.append(count)
-        raw_outputs.append(raw_output)
-
-    if write_lock is not None:
-        write_lock.acquire()
-    with open(args.output_file, "a") as f:
-        f.write(
-            json.dumps(
-                {
-                    "instance_id": instance_id,
-                    "raw_output": raw_outputs,
-                    "all_generations": [all_generations],
-                    "try_count": counts,
-                    "traj": traj,
-                    "prev_content": [
-                        [""]
-                    ],  # To make the tests compatible with the repair setup
-                    "file_names": [["reproduce_bug.py"]],
-                }
-            )
-            + "\n"
-        )
-    if write_lock is not None:
-        write_lock.release()
-
-
-def generate_tests(args):
-    with open(f"{args.output_folder}/args.json", "w") as f:
-        json.dump(vars(args), f, indent=4)
-
-    swe_bench_data = load_dataset(args.dataset, split="test")
-    instances = swe_bench_data["instance_id"]
-    prev_o = load_jsonl(args.output_file) if os.path.exists(args.output_file) else []
-
-    if args.num_threads == 1:
-        for instance_id in tqdm(instances, total=len(instances), colour="MAGENTA"):
-            gen_test(instance_id, args, swe_bench_data, prev_o)
-    else:
-        write_lock = Lock()
-        with concurrent.futures.ThreadPoolExecutor(
-            max_workers=args.num_threads
-        ) as executor:
-            futures = {
-                executor.submit(
-                    gen_test, instance_id, args, swe_bench_data, prev_o, write_lock
-                ): instance_id
-                for instance_id in instances
-            }
-            for future in tqdm(
-                concurrent.futures.as_completed(futures),
-                total=len(instances),
-                colour="MAGENTA",
-            ):
-                future.result()
-
-
-def post_process_tests(args):
-    """
-    apply some diff formatting.
-    """
-    raw_outputs = load_jsonl(args.raw_output_file)
-    generation_idx = args.select_id
-
-    for raw_output in raw_outputs:
-        instance_id = raw_output["instance_id"]
-
-        if (
-            raw_output["raw_output"] == ""
-            or not raw_output["all_generations"][0][generation_idx]
-        ):
-            with open(args.output_file, "a") as f:
-                f.write(
-                    json.dumps(
-                        {
-                            "model_name_or_path": "agentless",
-                            "instance_id": instance_id,
-                            "test_patch": "",
-                        }
-                    )
-                    + "\n"
-                )
-            continue
-
-        if args.select_id == -1:
-            # Use the last generation
-            assert False, "not implemented for now"
-        else:
-            raw_git_diffs = raw_output["all_generations"][0][generation_idx]
-            extracted_code = extract_first_code_block(
-                raw_output["all_generations"][0][generation_idx]
-            )
-            if extracted_code:
-                git_diffs = create_patch_from_code(extracted_code)
-            else:
-                git_diffs = ""
-
-        with open(args.output_file, "a") as f:
-            f.write(
-                json.dumps(
-                    {
-                        "model_name_or_path": "agentless",
-                        "instance_id": instance_id,
-                        "test_patch": git_diffs.lstrip(),
-                        "raw_test_patch": raw_git_diffs,
-                        "original_file_content": "",
-                    }
-                )
-                + "\n"
-            )
-
-
-def normalize_test(test: str):
-    def normalize_code(code):
-        try:
-            node = ast.parse(code)
-            return ast.unparse(node)
-        except:
-            return code
-
-    test = normalize_code(test)
-
-    try:
-        remove_docstring_test = remove_comments_and_docstrings(test)
-        ast.parse(remove_docstring_test)  # check
-    except:
-        remove_docstring_test = test
-
-    try:
-        test_name = remove_docstring_test.splitlines()[-1].split("(")[0]
-        remove_docstring_test = remove_docstring_test.replace(
-            test_name, "test_func"
-        )  # use generic name
-    except:
-        pass
-
-    return remove_docstring_test
-
-
-def normalize_tests(args):
-
-    selected_ids = list(range(int(args.max_samples)))
-
-    for i in selected_ids:
-        if os.path.exists(
-            f"{args.output_folder}/output_{i}_normalized_reproduction_test.jsonl"
-        ):
-            continue
-
-        tests = load_jsonl(
-            f"{args.output_folder}/output_{i}_processed_reproduction_test.jsonl"
-        )
-        for d in tests:
-            test = extract_first_code_block(d["raw_test_patch"])
-            normalized_test = normalize_test(test)
-            d["normalized_test"] = normalized_test
-
-        with open(
-            f"{args.output_folder}/output_{i}_normalized_reproduction_test.jsonl", "w"
-        ) as f:
-            for d in tests:
-                f.write(json.dumps(d) + "\n")
-
-
-def get_sample(execution_results, instance_id, sample_id) -> tuple[str, bool]:
-    """Returns the diff and pass status."""
-    return execution_results[instance_id][sample_id]
-
-
-def test_selection(args):
-    from pathlib import Path
-
-    test_exec_results = {}
-
-    roots = [Path(folder) for folder in args.output_folder.split(",")]
-
-    intervals = [(0, int(args.max_samples / len(roots)) - 1) for _ in range(len(roots))]
-
-    interval = intervals[0]
-    for i in range(interval[0], interval[1] + 1):
-        for index, root in enumerate(roots):
-            test_patches = load_jsonl(
-                f"{root}/output_{i}_normalized_reproduction_test.jsonl"
-            )
-            filtered_results = load_jsonl(
-                f"{root}/output_{i}_processed_reproduction_test_verified.jsonl"
-            )
-            print(
-                f"Loaded {len(test_patches)} patches from {root}/output_{i}_normalized.jsonl"
-            )
-            for test_patch in test_patches[:]:
-                filtered = [
-                    x
-                    for x in filtered_results
-                    if x["instance_id"] == test_patch["instance_id"]
-                ]
-                if len(filtered) != 0:
-                    filtered_status = filtered[0]["verified"]
-                else:
-                    filtered_status = False
-                test_exec_results.setdefault(test_patch["instance_id"], []).append(
-                    {
-                        "normalized_test": test_patch["normalized_test"].strip(),
-                        "test_patch": test_patch["test_patch"],
-                        "filtered_status": filtered_status,
-                    }
-                )
-
-    total_count = 0
-
-    for instance_id in test_exec_results:
-        patch_keys = [
-            test_exec_results[instance_id][i]["normalized_test"]
-            for i in range(len(test_exec_results[instance_id]))
-        ]
-        verified = [
-            test_exec_results[instance_id][i]["filtered_status"]
-            for i in range(len(test_exec_results[instance_id]))
-        ]
-
-        patch_ids = [
-            i
-            for i in range(len(test_exec_results[instance_id]))
-            if patch_keys[i].strip() and verified[i]
-        ]
-
-        if not patch_ids:
-            continue
-
-        vote = Counter()
-        first_appear_idx = dict()
-        unique_patches = set()
-        for i in patch_ids:
-            sample = get_sample(test_exec_results, instance_id, i)
-            patch_key, patch = sample["normalized_test"], sample["test_patch"]
-            vote[patch_key] += 1
-            if patch_key not in first_appear_idx:
-                first_appear_idx[patch_key] = i
-
-            unique_patches.add(patch_key)
-
-        maj_selected_id = max(
-            patch_ids,
-            key=lambda i: (vote[patch_keys[i]], -first_appear_idx[patch_keys[i]]),
-        )
-
-        print([vote[patch_keys[i]] for i in patch_ids])
-
-        sample = get_sample(test_exec_results, instance_id, maj_selected_id)
-
-        result = {
-            "model_name_or_path": "agentless",
-            "instance_id": instance_id,
-            "test_patch": sample["test_patch"],
-        }
-
-        total_count += 1
-
-        with open(f"{args.output_folder}/{args.output_file}", "a") as f:
-            f.write(json.dumps(result) + "\n")
-
-    print(total_count)
-
-
-def main():
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--max_samples", type=int, default=20, help="Sampling budget.")
-    parser.add_argument(
-        "--select_id",
-        type=int,
-        default=-1,
-        help="Index the selected samples during post-processing.",
-    )
-    parser.add_argument(
-        "--model",
-        type=str,
-        default=os.getenv("AGENTLESS_MODEL", "gpt-5.2"),
-        help="Model name (defaults to $AGENTLESS_MODEL).",
-    )
-    parser.add_argument(
-        "--backend",
-        type=str,
-        default="openai",
-        choices=["openai", "deepseek", "anthropic"],
-    )
-    parser.add_argument("--output_folder", type=str, required=True)
-    parser.add_argument("--output_file", type=str)
-    parser.add_argument("--skip_greedy", action="store_true")
-    parser.add_argument(
-        "--num_threads",
-        type=int,
-        default=1,
-        help="Number of threads to use for creating API requests",
-    )
-    parser.add_argument("--target_id", type=str)
-    parser.add_argument(
-        "--mock", action="store_true", help="Mock run to compute prompt tokens."
-    )
-    parser.add_argument("--select", action="store_true")
-    parser.add_argument(
-        "--dataset",
-        type=str,
-        default="princeton-nlp/SWE-bench_Lite",
-        choices=["princeton-nlp/SWE-bench_Lite", "princeton-nlp/SWE-bench_Verified"],
-    )
-
-    args = parser.parse_args()
-
-    assert (not "deepseek" in args.model) or (
-        args.backend == "deepseek"
-    ), "Must specify `--backend deepseek` if using a DeepSeek model"
-
-    if not os.path.exists(args.output_folder):
-        os.makedirs(args.output_folder)
-    if not os.path.exists(os.path.join(args.output_folder, "generating_test_logs")):
-        os.makedirs(os.path.join(args.output_folder, "generating_test_logs"))
-
-    if not args.select:
-        args.output_file = os.path.join(args.output_folder, "output.jsonl")
-        generate_tests(args)
-        args.raw_output_file = args.output_file
-        for i in range(args.max_samples):
-            args.output_file = args.raw_output_file.replace(
-                ".jsonl", f"_{i}_processed_reproduction_test.jsonl"
-            )
-            args.select_id = i
-            post_process_tests(args)
-    else:
-        normalize_tests(args)
-        test_selection(args)
-
-
-if __name__ == "__main__":
-    main()

Repos/HWE/agents/Agentless/agentless/test/run_regression_tests.py

@@ -1,254 +0,0 @@
-import argparse
-import json
-import os
-
-import jsonlines
-from datasets import load_dataset
-from swebench.harness.constants import (
-    FAIL_TO_PASS,
-    KEY_INSTANCE_ID,
-    PASS_TO_PASS,
-    TestStatus,
-)
-from swebench.harness.grading import get_eval_tests_report, get_logs_eval
-
-from agentless.test.run_tests import run_tests
-
-
-def rewrite_report(instance_id, input_folder_path, regression_tests):
-
-    log_path = f"{input_folder_path}/test/{instance_id}/test_output.txt"
-    eval_sm, found = get_logs_eval(log_path)
-
-    eval_ref = {
-        KEY_INSTANCE_ID: instance_id,
-        FAIL_TO_PASS: [],
-        PASS_TO_PASS: regression_tests[instance_id],
-    }
-
-    report = get_eval_tests_report(eval_sm, eval_ref)
-
-    return report["PASS_TO_PASS"]["failure"]
-
-
-def save_passing_tests(output_jsonl_path, input_folder_path, dataset):
-    ds = load_dataset(dataset)
-
-    with jsonlines.open(output_jsonl_path, mode="w") as writer:
-        for entry in ds["test"]:
-            instance_id = entry["instance_id"]
-
-            log_path = f"{input_folder_path}/test/{instance_id}/test_output.txt"
-            try:
-                # obtain the list of tests that were ran
-                eval_sm, found = get_logs_eval(log_path)
-            except FileNotFoundError:
-                print(f"File not found: {log_path}")
-                continue
-
-            successful_test = []
-
-            for test_name, status in eval_sm.items():
-                # check for tests that passed
-                # NOTE: Different from `swebench.harness.grading.test_passed`, we don't collect XFAIL tests
-                # because they are expected to fail
-                if status in [TestStatus.PASSED.value]:
-                    successful_test.append(test_name)
-
-            if successful_test == []:
-                print(f"{instance_id} didn't get any passing tests")
-
-            # Create the dictionary for each entry
-            result_entry = {
-                "instance_id": instance_id,
-                "tests_passing_in_original_repo": successful_test,
-            }
-
-            # Write the entry to the JSONL file
-            writer.write(result_entry)
-
-
-def run_regression_for_each_instance(args, lines, run_id):
-
-    instance_ids = [line["instance_id"] for line in lines]
-    patches = [line["model_patch"] for line in lines]
-
-    instance_to_plausible = run_tests(
-        instance_ids,
-        patches,
-        args.num_workers,
-        run_id,
-        args.regression_tests,
-        args.instance_ids,
-        args.timeout,
-        apply_model_patch=True,
-        dataset_name=args.dataset,
-    )
-    return instance_to_plausible
-
-
-def check_if_all_instances_pass(instance_to_plausible):
-    all_passed = True
-    not_passing_instances = []
-    for key, value in instance_to_plausible.items():
-        if not value:
-            all_passed = False
-            not_passing_instances.append(key)
-
-    if all_passed:
-        print("All the chosen regression tests pass in the base repository")
-    else:
-        print(
-            f"One or more of the regression tests for instances {not_passing_instances} do not pass in the original repository"
-        )
-        print(len(not_passing_instances))
-
-
-def _run_regression(args):
-    if args.predictions_path == "gold":
-        ds = load_dataset(args.dataset)
-        instance_ids = ds["test"]["instance_id"]
-        patches = ds["test"]["patch"]
-
-        instance_to_plausible = run_tests(
-            instance_ids,
-            patches,
-            args.num_workers,
-            args.run_id,
-            args.regression_tests,
-            args.instance_ids,
-            args.timeout,
-            apply_model_patch=True,
-            dataset_name=args.dataset,
-        )
-        check_if_all_instances_pass(instance_to_plausible)
-    elif args.predictions_path:
-        assert args.predictions_path.endswith("_processed.jsonl")
-        with open(args.predictions_path, "r") as file:
-            data_lines = [json.loads(line) for line in file]
-
-        if not args.load:
-            run_regression_for_each_instance(args, data_lines, args.run_id)
-
-        regression_dict = {}
-        instance_test_dict = {}
-
-        with open(args.regression_tests, "r") as file:
-            for line in file:
-                json_obj = json.loads(line.strip())
-                instance_id = json_obj["instance_id"]
-                test = json_obj["tests_passing_in_original_repo"]
-                instance_test_dict[instance_id] = test
-
-        for data in data_lines:
-            instance_id = data["instance_id"]
-            if os.path.isfile(
-                f"logs/run_evaluation/{args.run_id}/test/{instance_id}/report.json"
-            ):
-                regression_dict[instance_id] = rewrite_report(
-                    instance_id,
-                    f"logs/run_evaluation/{args.run_id}",
-                    instance_test_dict,
-                )
-            else:
-                regression_dict[instance_id] = []
-
-        updated_data_lines = []
-        for data in data_lines:
-            instance_id = data["instance_id"]
-            if instance_id in regression_dict:
-                data["regression"] = regression_dict[instance_id]
-            updated_data_lines.append(data)
-
-        with open(
-            args.predictions_path.replace(
-                "processed.jsonl", "regression_test_results.jsonl"
-            ),
-            "w",
-        ) as file:
-            for data in updated_data_lines:
-                file.write(json.dumps(data) + "\n")
-
-    else:
-        # this is for generating a list of passing tests from the original repor
-        # TODO: some instances don't get any passing tests because some test files
-        # are renamed in the test patch and we grabbed the new file names.
-        # We can fix this by checking if a test file exists in the base repo.
-        ds = load_dataset(args.dataset)
-        instance_ids = (
-            ds["test"]["instance_id"]
-            if args.instance_ids is None
-            else args.instance_ids
-        )
-
-        # Feed in a list of blank patches
-        patches = [
-            {"instance_id": instance_id, "patch": "", "normalized_patch": ""}
-            for instance_id in instance_ids
-        ]
-
-        instance_to_plausible = run_tests(
-            instance_ids,
-            patches,
-            args.num_workers,
-            args.run_id,
-            args.regression_tests,
-            args.instance_ids,
-            args.timeout,
-            apply_model_patch=False,
-            dataset_name=args.dataset,
-        )
-
-        if args.regression_tests:
-            # check if the base repo all passes on the selected regression tests (should be true)
-            check_if_all_instances_pass(instance_to_plausible)
-
-        else:
-            # save the list of passing tests
-            save_passing_tests(
-                args.output_file,
-                os.path.join("logs", "run_evaluation", args.run_id),
-                args.dataset,
-            )
-
-
-def main():
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--run_id", type=str, required=True)
-    parser.add_argument(
-        "--predictions_path",
-        type=str,
-        help="Patch file with normalized patches",
-    )
-    parser.add_argument("--output_file", type=str)
-    parser.add_argument("--regression_tests", type=str)
-    parser.add_argument("--num_workers", type=int, default=12)
-    parser.add_argument(
-        "--timeout", type=int, default=1200, help="Timeout for running tests in seconds"
-    )
-    parser.add_argument(
-        "--instance_ids",
-        nargs="+",
-        type=str,
-        help="Instance IDs to run (space separated), if not provided, all instances will be run",
-    )
-    parser.add_argument("--filter", action="store_true")
-    parser.add_argument("--load", action="store_true")
-    parser.add_argument(
-        "--dataset",
-        type=str,
-        default="princeton-nlp/SWE-bench_Lite",
-        choices=["princeton-nlp/SWE-bench_Lite", "princeton-nlp/SWE-bench_Verified"],
-    )
-
-    args = parser.parse_args()
-
-    assert not (
-        args.predictions_path and args.output_file
-    ), "An output file is only required when selecting regression tests"
-
-    _run_regression(args)
-
-
-if __name__ == "__main__":
-    main()

Repos/HWE/agents/Agentless/agentless/test/run_reproduction_tests.py

@@ -1,170 +0,0 @@
-import argparse
-import json
-import os
-
-from datasets import load_dataset
-
-from agentless.test.run_tests import run_reproduction_tests, txt_file_contains_string
-from agentless.util.utils import load_jsonl
-
-execution_results = dict()
-
-
-def run_reproduction_for_each_instance(args, lines, run_id, test_jsonl):
-
-    instance_ids = [line["instance_id"] for line in lines]
-    patches = [line["model_patch"] for line in lines]
-
-    results = run_reproduction_tests(
-        instance_ids,
-        patches,
-        args.num_workers,
-        run_id,
-        args.instance_ids,
-        args.timeout,
-        testing_patches=False,
-        apply_model_patch=True,
-        test_jsonl=test_jsonl,
-        dataset_name=args.dataset,
-    )
-    return results
-
-
-def _run_reproduction_tests(args):
-    if args.testing:
-        # for reproduction test selection
-        # run on original repo to select tests which can reproduce the issue
-        ds = load_dataset(args.dataset)
-        instance_ids = ds["test"]["instance_id"]
-        patches = [
-            {"instance_id": instance_id, "patch": "", "normalized_patch": ""}
-            for instance_id in instance_ids
-        ]
-
-        evaluation_tests = load_jsonl(args.test_jsonl)
-
-        results = run_reproduction_tests(
-            instance_ids,
-            patches,
-            args.num_workers,
-            args.run_id,
-            args.instance_ids,
-            args.timeout,
-            testing_patches=True,
-            apply_model_patch=False,
-            test_jsonl=args.test_jsonl,
-            dataset_name=args.dataset,
-        )
-
-        with open(args.test_jsonl.replace(".jsonl", "_verified.jsonl"), "w") as file:
-            for evaluation_test in evaluation_tests:
-                instance_id = evaluation_test["instance_id"]
-                if instance_id in results and results[instance_id]:
-                    evaluation_test["verified"] = True
-                    file.write(json.dumps(evaluation_test) + "\n")
-
-    elif args.predictions_path == "gold":
-        # check on groundtruth patches
-        # for evaluation purposes
-        ds = load_dataset(args.dataset)
-        instance_ids = ds["test"]["instance_id"]
-        patches = ds["test"]["patch"]
-
-        results = run_reproduction_tests(
-            instance_ids,
-            patches,
-            args.num_workers,
-            args.run_id,
-            args.instance_ids,
-            args.timeout,
-            testing_patches=False,
-            apply_model_patch=True,
-            test_jsonl=args.test_jsonl,
-            dataset_name=args.dataset,
-        )
-
-        with open(
-            "gold_production_test_results.json",
-            "w",
-        ) as file:
-            file.write(json.dumps(results))
-
-    else:
-        # run on the agentless generated patches
-        assert args.predictions_path.endswith("_processed.jsonl")
-        with open(args.predictions_path, "r") as file:
-            data_lines = [json.loads(line) for line in file]
-
-        if args.load:
-            reproduction_dict = {}
-            for data in data_lines:
-                instance_id = data["instance_id"]
-                expected_output = "Issue resolved"
-                path_to_log = f"logs/run_evaluation/{args.run_id}/test/{instance_id}/test_output.txt"
-                if os.path.isfile(path_to_log):
-                    passes_tests = txt_file_contains_string(
-                        path_to_log, expected_output
-                    )
-                    reproduction_dict[instance_id] = passes_tests
-                else:
-                    reproduction_dict[instance_id] = False
-        else:
-            reproduction_dict = run_reproduction_for_each_instance(
-                args, data_lines, args.run_id, args.test_jsonl
-            )
-
-        updated_data_lines = []
-        for data in data_lines:
-            instance_id = data["instance_id"]
-            if instance_id in reproduction_dict:
-                data["reproduction"] = reproduction_dict[instance_id]
-            updated_data_lines.append(data)
-
-        with open(
-            args.predictions_path.replace(
-                "processed.jsonl", "reproduction_test_results.jsonl"
-            ),
-            "w",
-        ) as file:
-            for data in updated_data_lines:
-                file.write(json.dumps(data) + "\n")
-
-
-def main():
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--run_id", type=str, required=True)
-    parser.add_argument(
-        "--testing", action="store_true", help="If true don't apply the model patch"
-    )
-    parser.add_argument(
-        "--predictions_path",
-        type=str,
-        help="Patch file",
-    )
-    parser.add_argument("--num_workers", type=int, default=12)
-    parser.add_argument(
-        "--timeout", type=int, default=600, help="Timeout for running tests in seconds"
-    )
-    parser.add_argument(
-        "--instance_ids",
-        nargs="+",
-        type=str,
-        help="Instance IDs to run (space separated)",
-    )
-    parser.add_argument(
-        "--dataset",
-        type=str,
-        default="princeton-nlp/SWE-bench_Lite",
-        choices=["princeton-nlp/SWE-bench_Lite", "princeton-nlp/SWE-bench_Verified"],
-    )
-    parser.add_argument("--test_jsonl", type=str)
-    parser.add_argument("--load", action="store_true")
-
-    args = parser.parse_args()
-
-    # then load and run production tests on the results
-    _run_reproduction_tests(args)
-
-
-if __name__ == "__main__":
-    main()

Repos/HWE/agents/Agentless/agentless/test/run_tests.py

@@ -1,630 +0,0 @@
-import json
-import os
-import platform
-import re
-import resource
-import traceback
-from concurrent.futures import ThreadPoolExecutor, as_completed
-from typing import Any
-
-import docker
-from swebench.harness.constants import (
-    FAIL_TO_PASS,
-    KEY_INSTANCE_ID,
-    MAP_REPO_VERSION_TO_SPECS,
-    PASS_TO_PASS,
-    USE_X86,
-    SWEbenchInstance,
-)
-from swebench.harness.docker_build import build_env_images
-from swebench.harness.run_evaluation import get_dataset_from_preds, run_instance
-from swebench.harness.test_spec import (
-    TestSpec,
-    make_env_script_list,
-    make_repo_script_list,
-)
-from swebench.harness.utils import get_test_directives
-from tqdm import tqdm
-
-OPEN_FILE_LIMIT = 4096
-
-NOOP_PATCH = """diff --git a/this_is_invisible.py b/this_is_invisible.py
-new file mode 100644
-index 0000000..e69de29
---- /dev/null
-+++ b/this_is_invisible.py
-@@ -0,0 +1 @@
-+# This is a commented out line
-"""
-
-NOOP_PATCH_2 = """diff --git a/this_is_invisible_2.py b/this_is_invisible_2.py
-new file mode 100644
-index 0000000..e69de29
---- /dev/null
-+++ b/this_is_invisible_2.py
-@@ -0,0 +1 @@
-+# This is a commented out line
-"""
-
-
-def remove_ansi_sequences(input_string):
-    ansi_escape_pattern = r"\x1b\[\d+m"
-    clean_string = re.sub(ansi_escape_pattern, "", input_string)
-
-    return clean_string
-
-
-def txt_file_contains_string(path_to_txt, expected_output, other_patterns=[]):
-    """
-    Check if the given text file contains the specified string.
-    :param path_to_txt: Path to the text file.
-    :param expected_output: The string to search for in the text file.
-    :return: True if the string is found in the text file, otherwise False.
-    """
-    try:
-        with open(path_to_txt, "r", encoding="utf-8") as file:
-            content = file.read()
-            filtered_content = remove_ansi_sequences(content)
-            for pattern in other_patterns:
-                if pattern in filtered_content:
-                    return False
-            return expected_output in filtered_content
-
-    except FileNotFoundError:
-        pass
-    except IOError:
-        print(f"An error occurred while reading the file at {path_to_txt}.")
-
-    return False
-
-
-def create_instance_test_dict(jsonl_file_path):
-    instance_test_dict = {}
-
-    with open(jsonl_file_path, "r") as file:
-        for line in file:
-            json_obj = json.loads(line.strip())
-            instance_id = json_obj["instance_id"]
-            test_patch = json_obj["test_patch"]
-            instance_test_dict[instance_id] = test_patch
-
-    return instance_test_dict
-
-
-def extract_resolved_info(directory_path):
-    # Check if the directory exists
-    if not os.path.exists(directory_path) or not os.path.isdir(directory_path):
-        return {}
-
-    result = {}
-    for subdir in os.listdir(directory_path):
-        subdir_path = os.path.join(directory_path, subdir)
-        if os.path.isdir(subdir_path):
-            report_path = os.path.join(subdir_path, "report.json")
-            if os.path.isfile(report_path):
-                try:
-                    with open(report_path, "r", encoding="utf-8") as report_file:
-                        data = json.load(report_file)
-                        resolved_value = data.get(subdir, {}).get("resolved", False)
-                        result[subdir] = resolved_value
-                except (json.JSONDecodeError, KeyError):
-                    result[subdir] = False
-            # else:
-            #     result[subdir] = False
-    return result
-
-
-def make_reproduction_sec(instance: SWEbenchInstance) -> TestSpec:
-    if isinstance(instance, TestSpec):
-        return instance
-    instance_id = instance[KEY_INSTANCE_ID]
-    repo = instance["repo"]
-    version = instance["version"]
-    base_commit = instance["base_commit"]
-    production_test = instance["production_test"]
-
-    def _from_json_or_obj(key: str) -> Any:
-        """If key points to string, load with json"""
-        if isinstance(instance[key], str):
-            return json.loads(instance[key])
-        return instance[key]
-
-    pass_to_pass = _from_json_or_obj(PASS_TO_PASS)
-    fail_to_pass = _from_json_or_obj(FAIL_TO_PASS)
-
-    env_name = "testbed"
-    repo_directory = f"/{env_name}"
-    specs = MAP_REPO_VERSION_TO_SPECS[repo][version]
-
-    repo_script_list = make_repo_script_list(
-        specs, repo, repo_directory, base_commit, env_name
-    )
-    env_script_list = make_env_script_list(instance, specs, env_name)
-    eval_script_list = make_reproduction_script_list(
-        instance, specs, env_name, repo_directory, base_commit, production_test
-    )
-    if platform.machine() in {"aarch64", "arm64"}:
-        # use arm64 unless explicitly specified
-        arch = "arm64" if instance_id not in USE_X86 else "x86_64"
-    else:
-        arch = "x86_64"
-
-    return TestSpec(
-        instance_id=instance_id,
-        repo=repo,
-        env_script_list=env_script_list,
-        repo_script_list=repo_script_list,
-        eval_script_list=eval_script_list,
-        version=version,
-        arch=arch,
-        FAIL_TO_PASS=fail_to_pass,
-        PASS_TO_PASS=pass_to_pass,
-    )
-
-
-def make_reproduction_script_list(
-    instance, specs, env_name, repo_directory, base_commit, reproduce_patch
-):
-    """
-    Applies new production tests and run tests
-    """
-    # Reset test files to the state they should be in before the patch.
-    reset_tests_command = f"git checkout {base_commit}"
-
-    HEREDOC_DELIMITER = "EOF_114329324912"
-    fake_apply_test_patch_command = (
-        f"git apply -v - <<'{HEREDOC_DELIMITER}'\n{NOOP_PATCH_2}\n{HEREDOC_DELIMITER}"
-    )
-
-    apply_reproduce_test_command = f"git apply -v - <<'{HEREDOC_DELIMITER}'\n{reproduce_patch}\n{HEREDOC_DELIMITER}"
-    reproduce_test_command = "python3 reproduce_bug.py"
-
-    eval_commands = [
-        f"source /opt/miniconda3/bin/activate",
-        f"conda activate {env_name}",
-        f"cd {repo_directory}",
-    ]
-    if "eval_commands" in specs:
-        eval_commands += specs["eval_commands"]
-    eval_commands += [
-        f"git config --global --add safe.directory {repo_directory}",  # for nonroot user
-        f"cd {repo_directory}",
-        # This is just informational, so we have a record
-        f"git status",
-        f"git show",
-        f"git diff {base_commit}",
-        "source /opt/miniconda3/bin/activate",
-        f"conda activate {env_name}",
-    ]
-    if "install" in specs:
-        eval_commands.append(specs["install"])
-    eval_commands += [
-        reset_tests_command,
-        fake_apply_test_patch_command,  # If we don't apply some sort of patch the harness won't return the tests which passed
-        apply_reproduce_test_command,
-        reproduce_test_command,
-        # reset_tests_command,
-    ]
-    return eval_commands
-
-
-def make_regression_spec(instance: SWEbenchInstance) -> TestSpec:
-    if isinstance(instance, TestSpec):
-        return instance
-    instance_id = instance[KEY_INSTANCE_ID]
-    repo = instance["repo"]
-    version = instance["version"]
-    base_commit = instance["base_commit"]
-
-    def _from_json_or_obj(key: str) -> Any:
-        """If key points to string, load with json"""
-        if isinstance(instance[key], str):
-            return json.loads(instance[key])
-        return instance[key]
-
-    pass_to_pass = _from_json_or_obj(PASS_TO_PASS)
-    fail_to_pass = _from_json_or_obj(FAIL_TO_PASS)
-
-    env_name = "testbed"
-    repo_directory = f"/{env_name}"
-    specs = MAP_REPO_VERSION_TO_SPECS[repo][version]
-
-    repo_script_list = make_repo_script_list(
-        specs, repo, repo_directory, base_commit, env_name
-    )
-    env_script_list = make_env_script_list(instance, specs, env_name)
-    eval_script_list = make_regression_script_list(
-        instance, specs, env_name, repo_directory, base_commit
-    )
-    if platform.machine() in {"aarch64", "arm64"}:
-        # use arm64 unless explicitly specified
-        arch = "arm64" if instance_id not in USE_X86 else "x86_64"
-    else:
-        arch = "x86_64"
-
-    return TestSpec(
-        instance_id=instance_id,
-        repo=repo,
-        env_script_list=env_script_list,
-        repo_script_list=repo_script_list,
-        eval_script_list=eval_script_list,
-        version=version,
-        arch=arch,
-        FAIL_TO_PASS=fail_to_pass,  # Remove the fail to pass cases
-        PASS_TO_PASS=pass_to_pass,
-    )
-
-
-def make_regression_script_list(instance, specs, env_name, repo_directory, base_commit):
-    """
-    Applies the test patch and runs the tests.
-    """
-    # Reset test files to the state they should be in before the patch.
-    reset_tests_command = f"git checkout {base_commit}"
-
-    HEREDOC_DELIMITER = "EOF_114329324912"
-    fake_apply_test_patch_command = (
-        f"git apply -v - <<'{HEREDOC_DELIMITER}'\n{NOOP_PATCH_2}\n{HEREDOC_DELIMITER}"
-    )
-
-    test_command = " ".join(
-        [
-            MAP_REPO_VERSION_TO_SPECS[instance["repo"]][instance["version"]][
-                "test_cmd"
-            ],
-            *get_test_directives(instance),
-        ]
-    )
-    eval_commands = [
-        "source /opt/miniconda3/bin/activate",
-        f"conda activate {env_name}",
-        f"cd {repo_directory}",
-    ]
-    if "eval_commands" in specs:
-        eval_commands += specs["eval_commands"]
-    eval_commands += [
-        f"git config --global --add safe.directory {repo_directory}",  # for nonroot user
-        f"cd {repo_directory}",
-        # This is just informational, so we have a record
-        "git status",
-        "git show",
-        f"git diff {base_commit}",
-        "source /opt/miniconda3/bin/activate",
-        f"conda activate {env_name}",
-    ]
-    if "install" in specs:
-        eval_commands.append(specs["install"])
-    eval_commands += [
-        reset_tests_command,
-        fake_apply_test_patch_command,  # If we don't apply some sort of patch the harness won't return the tests which passed
-        test_command,
-        reset_tests_command,
-    ]
-    return eval_commands
-
-
-def rearrange_patches(test_specs):
-    """
-    rearrange the patches such that slower instance_ids are evaluated first
-    this way pipelining will be faster.
-    """
-
-    slow_instance_ids = ["sympy__sympy-11870"]
-
-    slow_specs = [
-        test_spec
-        for test_spec in test_specs
-        if test_spec.instance_id in slow_instance_ids
-    ]
-
-    if len(slow_specs) != 0:
-        print(
-            f"rearrange patches such that {[x.instance_id for x in slow_specs]} are evaluated first"
-        )
-        rearranged_test_specs = slow_specs
-        for test_spec in test_specs:
-            if test_spec.instance_id not in slow_instance_ids:
-                rearranged_test_specs.append(test_spec)
-        return rearranged_test_specs
-    else:
-        return test_specs
-
-
-def run_reproduction_tests(
-    instance_ids: list,
-    model_patches: list,
-    max_workers: int,
-    run_id: str,
-    instances_to_run: list,
-    timeout: int,
-    testing_patches: bool,
-    apply_model_patch=True,
-    test_jsonl=None,
-    dataset_name="princeton-nlp/SWE-bench_Lite",
-):
-    assert len(instance_ids) == len(
-        model_patches
-    ), "There must be the same number of instance_ids as model patches"
-    resource.setrlimit(resource.RLIMIT_NOFILE, (OPEN_FILE_LIMIT, OPEN_FILE_LIMIT))
-
-    instance_to_reproduction_code = create_instance_test_dict(test_jsonl)
-
-    print(f"Using run_id: {run_id}")
-
-    split = "test"
-    client = docker.from_env()
-    force_rebuild = False
-
-    predictions = {}
-
-    for idx, one_instance_id in enumerate(instance_ids):
-        if not apply_model_patch:
-            patch_to_apply = NOOP_PATCH
-        else:
-            patch_to_apply = model_patches[idx]
-        if testing_patches:
-            predictions[one_instance_id] = {
-                "model_name_or_path": "test",
-                "model_patch": NOOP_PATCH,
-                "instance_id": one_instance_id,
-            }
-            # instance_to_reproduction_code[one_instance_id] = patch_to_apply
-        else:
-            predictions[one_instance_id] = {
-                "model_name_or_path": "test",  # TODO change.
-                "model_patch": patch_to_apply,
-                "instance_id": one_instance_id,
-            }
-
-    instances = get_dataset_from_preds(
-        dataset_name, split, instance_ids, predictions, run_id
-    )
-
-    if not instances:
-        print("No instances to run.")
-    else:
-        build_env_images(client, instances, force_rebuild, max_workers)
-
-    no_f2p_instances = []
-
-    for instance in instances:
-        revised_instance = instance
-        revised_instance["FAIL_TO_PASS"] = "[]"
-        revised_instance["PASS_TO_PASS"] = "[]"
-
-        if instance["instance_id"] in instance_to_reproduction_code:
-            revised_instance["production_test"] = instance_to_reproduction_code[
-                instance["instance_id"]
-            ]
-            # only run if there is production test
-            no_f2p_instances.append(revised_instance)
-
-    test_specs = list(map(make_reproduction_sec, no_f2p_instances))
-
-    test_specs = rearrange_patches(test_specs)
-
-    instance_image_ids = {x.instance_image_key for x in test_specs}
-    existing_images = {
-        tag
-        for i in client.images.list(all=True)
-        for tag in i.tags
-        if tag in instance_image_ids
-    }
-    print(f"Found {len(existing_images)} existing instance images. Will reuse them.")
-
-    # Load in previously evaluated results
-    resolved_dict = extract_resolved_info(
-        os.path.join("logs", "run_evaluation", run_id, "test")
-    )
-
-    if instances_to_run:
-        ids = instances_to_run
-    else:
-        ids = [
-            test_spec.instance_id
-            for test_spec in test_specs
-            if test_spec.instance_id not in list(resolved_dict.keys())
-        ]
-
-    results = {}
-
-    print(
-        f"Running {len([test_spec for test_spec in test_specs if test_spec.instance_id in ids])} unevaluated instances..."
-    )
-
-    # Set the empty instances as not resolving the issue
-    for index, patch in enumerate(model_patches):
-        if patch == "":
-            resolved_dict[instance_ids[index]] = False
-
-    with tqdm(total=len(ids), smoothing=0, colour="MAGENTA") as pbar:
-        with ThreadPoolExecutor(max_workers=max_workers) as executor:
-            # Create a future for running each instance
-            futures = {
-                executor.submit(
-                    run_instance,
-                    test_spec,
-                    predictions[test_spec.instance_id],
-                    False,  # do not remove them.
-                    force_rebuild,
-                    client,
-                    run_id,
-                    timeout,
-                ): None
-                for test_spec in test_specs
-                if test_spec.instance_id in ids
-            }
-            # Wait for each future to complete
-            for future in as_completed(futures):
-                pbar.update(1)
-                result = future.result()
-                if result:
-                    instance_id = result[0]
-                    resolved = result[1][instance_id]["resolved"]
-                    resolved_dict[instance_id] = resolved
-                    # See if the tests ran successfully
-                    if testing_patches:
-                        expected_output = "Issue reproduced"
-                        other_patterns = ["Issue resolved", "Other issues"]
-                    else:
-                        expected_output = "Issue resolved"
-                        other_patterns = ["Issue reproduced", "Other issues"]
-                    path_to_log = f"logs/run_evaluation/{run_id}/{split}/{instance_id}/test_output.txt"
-                    passes_tests = txt_file_contains_string(
-                        path_to_log, expected_output, other_patterns=other_patterns
-                    )
-                    results[instance_id] = passes_tests
-                try:
-                    # Update progress bar, check if instance ran successfully
-                    future.result()
-                except Exception as e:
-                    traceback.print_exc()
-                    results[instance_id] = False
-                    resolved_dict[instance_id] = False
-                    continue
-
-    print("All instances run.")
-    return results
-
-
-def run_tests(
-    instance_ids: list,
-    model_patches: list,
-    max_workers: int,
-    run_id: str,
-    regression_test_file: str,
-    instances_to_run: list,
-    timeout: int,
-    apply_model_patch=True,
-    dataset_name="princeton-nlp/SWE-bench_Lite",
-):
-    assert len(instance_ids) == len(
-        model_patches
-    ), "There must be the same number of instance_ids as model patches"
-    resource.setrlimit(resource.RLIMIT_NOFILE, (OPEN_FILE_LIMIT, OPEN_FILE_LIMIT))
-
-    print(f"Using run_id: {run_id}")
-
-    split = "test"
-    client = docker.from_env()
-    force_rebuild = False
-
-    predictions = {}
-
-    for idx, one_instance_id in enumerate(instance_ids):
-        if not apply_model_patch:
-            patch_to_apply = NOOP_PATCH
-        else:
-            patch_to_apply = model_patches[idx]
-        predictions[one_instance_id] = {
-            "model_name_or_path": "test",
-            "model_patch": patch_to_apply,
-            "instance_id": one_instance_id,
-        }
-
-    instances = get_dataset_from_preds(
-        dataset_name, split, instance_ids, predictions, run_id
-    )
-
-    print(f"Running {len(instances)} unevaluated instances...")
-    if not instances:
-        print("No instances to run.")
-    else:
-        build_env_images(client, instances, force_rebuild, max_workers)
-
-    instance_test_dict = {}
-
-    if regression_test_file:
-        with open(regression_test_file, "r") as file:
-            for line in file:
-                json_obj = json.loads(line.strip())
-                instance_id = json_obj["instance_id"]
-                test = json_obj["tests_passing_in_original_repo"]
-                instance_test_dict[instance_id] = test
-
-    no_f2p_instances = []
-    for instance in instances:
-        revised_instance = instance
-        revised_instance["FAIL_TO_PASS"] = "[]"
-        # DO NOT USE any of the PASS_TO_PASS in swebench
-        # it is either obtained from all passing tests (after LLM filtering)
-        # or all tests are ran
-        if regression_test_file:
-            revised_instance["PASS_TO_PASS"] = instance_test_dict[
-                instance["instance_id"]
-            ]
-        else:
-            revised_instance["PASS_TO_PASS"] = "[]"
-
-        no_f2p_instances.append(revised_instance)
-
-    test_specs = list(map(make_regression_spec, no_f2p_instances))
-
-    test_specs = rearrange_patches(test_specs)
-
-    instance_image_ids = {x.instance_image_key for x in test_specs}
-    existing_images = {
-        tag
-        for i in client.images.list(all=True)
-        for tag in i.tags
-        if tag in instance_image_ids
-    }
-    print(f"Found {len(existing_images)} existing instance images. Will reuse them.")
-
-    # Load in previously evaluated results
-    resolved_dict = extract_resolved_info(
-        os.path.join("logs", "run_evaluation", run_id, "test")
-    )
-
-    if instances_to_run:
-        ids = instances_to_run
-    else:
-        ids = [
-            test_spec.instance_id
-            for test_spec in test_specs
-            if test_spec.instance_id not in list(resolved_dict.keys())
-        ]
-
-    results = {}
-
-    # Set the empty instances as not resolving the issue
-    for index, patch in enumerate(model_patches):
-        if patch == "":
-            resolved_dict[instance_ids[index]] = False
-
-    with tqdm(total=len(ids), smoothing=0, colour="MAGENTA") as pbar:
-        with ThreadPoolExecutor(max_workers=max_workers) as executor:
-            # Create a future for running each instance
-            futures = {
-                executor.submit(
-                    run_instance,
-                    test_spec,
-                    predictions[test_spec.instance_id],
-                    False,  # do not remove them.
-                    force_rebuild,
-                    client,
-                    run_id,
-                    timeout,
-                ): None
-                for test_spec in test_specs
-                if test_spec.instance_id in ids
-            }
-            # Wait for each future to complete
-            for future in as_completed(futures):
-                pbar.update(1)
-                result = future.result()
-                if result:
-                    instance_id = result[0]
-                    resolved = result[1][instance_id]["resolved"]
-                    resolved_dict[instance_id] = resolved
-                try:
-                    # Update progress bar, check if instance ran successfully
-                    future.result()
-                except Exception as e:
-                    traceback.print_exc()
-                    results[instance_id] = False  # Or handle the error case as needed
-                    resolved_dict[instance_id] = False
-                    continue
-
-    print("All instances run.")
-    return resolved_dict

Repos/HWE/agents/Agentless/agentless/test/select_regression_tests.py

@@ -1,220 +0,0 @@
-import argparse
-import json
-import os
-
-from datasets import load_dataset
-from tqdm import tqdm
-
-from agentless.util.api_requests import num_tokens_from_messages
-from agentless.util.model import make_model
-from agentless.util.utils import load_jsonl, setup_logger
-
-MAX_CONTEXT_LENGTH = 128000
-
-
-select_tests_prompt_template = """
-We are currently solving the following issue within our repository. Here is the issue text:
---- BEGIN ISSUE ---
-{problem_statement}
---- END ISSUE ---
-
-Below are a list of existing tests in the repository.
-```
-{passing_tests}
-```
-
-Please identify the tests that should not be run after applying the patch to fix the issue.
-These tests should be excluded as the original functionality may change due to the patch.
-
-### Example
-```
-test1
-test2
-test5
-```
-Return only the selected tests.
-"""
-
-
-def select_test(instance_id, args, swe_bench_data, prev_o, passing_tests):
-    def _parse_model_return_lines(content: str) -> list[str]:
-        if content:
-            return content.strip().split("\n")
-
-    if args.target_id is not None:
-        if args.target_id != instance_id:
-            return
-
-    log_file = os.path.join(
-        args.output_folder, "select_test_logs", f"{instance_id}.log"
-    )
-    logger = setup_logger(log_file)
-    found = False
-    for o in prev_o:
-        if o["instance_id"] == instance_id:
-            found = True
-            break
-
-    if found:
-        logger.info(f"skipping {instance_id}")
-        return None
-
-    if len(passing_tests) == 0:
-        with open(args.output_file, "a") as f:
-            f.write(
-                json.dumps(
-                    {
-                        "instance_id": instance_id,
-                        "raw_output": "",
-                        "tests_passing_in_original_repo": passing_tests,
-                        "original_regressions": passing_tests,
-                        "traj": {},
-                    }
-                )
-                + "\n"
-            )
-        return
-
-    logger.info(f"================ selecting test for {instance_id} ================")
-
-    bench_data = [x for x in swe_bench_data if x["instance_id"] == instance_id][0]
-    problem_statement = bench_data["problem_statement"]
-
-    raw_output = ""
-
-    prompt_template = select_tests_prompt_template
-    message = prompt_template.format(
-        problem_statement=problem_statement, passing_tests="\n".join(passing_tests)
-    ).strip()
-
-    logger.info(f"prompting with message:\n{message}")
-
-    # get greedy sample
-    model = make_model(
-        model=args.model,
-        logger=logger,
-        backend=args.backend,
-        max_tokens=1024,
-        temperature=0,
-        batch_size=1,
-    )
-
-    def message_too_long(message):
-        return num_tokens_from_messages(message, args.model) >= MAX_CONTEXT_LENGTH
-
-    while message_too_long(message):
-        # half it
-        # TODO: we can prompt the model multiple times to select from different subset of tests
-        passing_tests = passing_tests[: len(passing_tests) // 2]
-        message = prompt_template.format(
-            problem_statement=problem_statement, passing_tests="\n".join(passing_tests)
-        ).strip()
-
-    greedy_traj = model.codegen(message, num_samples=1)[0]
-    greedy_traj["prompt"] = message
-    raw_output = greedy_traj["response"]
-
-    logger.info(raw_output)
-
-    model_identified_tests = _parse_model_return_lines(raw_output)
-    subset_regression_tests = []
-
-    for x in passing_tests:
-        if x not in model_identified_tests:
-            subset_regression_tests.append(x)
-
-    with open(args.output_file, "a") as f:
-        f.write(
-            json.dumps(
-                {
-                    "instance_id": instance_id,
-                    "raw_output": raw_output,
-                    "tests_passing_in_original_repo": subset_regression_tests,
-                    "original_regressions": passing_tests,
-                    "traj": greedy_traj,
-                }
-            )
-            + "\n"
-        )
-
-
-def select_tests(args):
-    with open(f"{args.output_folder}/args.json", "w") as f:
-        json.dump(vars(args), f, indent=4)
-
-    instance_test_dict = {}
-    with open(args.passing_tests, "r") as file:
-        for line in file:
-            json_obj = json.loads(line.strip())
-            instance_id = json_obj["instance_id"]
-            test = json_obj["tests_passing_in_original_repo"]
-            instance_test_dict[instance_id] = test
-
-    swe_bench_data = load_dataset(args.dataset, split="test")
-    instance_ids = (
-        swe_bench_data["instance_id"]
-        if args.instance_ids is None
-        else args.instance_ids
-    )
-    prev_o = load_jsonl(args.output_file) if os.path.exists(args.output_file) else []
-
-    results = []
-
-    for instance_id in tqdm(instance_ids, total=len(instance_ids), colour="MAGENTA"):
-        result = select_test(
-            instance_id, args, swe_bench_data, prev_o, instance_test_dict[instance_id]
-        )
-        if result is not None:
-            results.append(result)
-
-
-def main():
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "--model",
-        type=str,
-        default=os.getenv("AGENTLESS_MODEL", "gpt-5.2"),
-        help="Model name (defaults to $AGENTLESS_MODEL).",
-    )
-    parser.add_argument(
-        "--backend",
-        type=str,
-        default="openai",
-        choices=["openai", "deepseek", "anthropic"],
-    )
-    parser.add_argument("--output_folder", type=str, required=True)
-    parser.add_argument("--target_id", type=str)
-    parser.add_argument(
-        "--mock", action="store_true", help="Mock run to compute prompt tokens."
-    )
-    parser.add_argument(
-        "--dataset",
-        type=str,
-        default="princeton-nlp/SWE-bench_Lite",
-        choices=["princeton-nlp/SWE-bench_Lite", "princeton-nlp/SWE-bench_Verified"],
-    )
-    parser.add_argument(
-        "--instance_ids",
-        nargs="+",
-        type=str,
-        help="Instance IDs to run (space separated), if not provided, all instances will be run",
-    )
-    parser.add_argument("--passing_tests", type=str, required=True)
-
-    args = parser.parse_args()
-
-    assert (not "deepseek" in args.model) or (
-        args.backend == "deepseek"
-    ), "Must specify `--backend deepseek` if using a DeepSeek model"
-
-    if not os.path.exists(args.output_folder):
-        os.makedirs(args.output_folder)
-    if not os.path.exists(os.path.join(args.output_folder, "select_test_logs")):
-        os.makedirs(os.path.join(args.output_folder, "select_test_logs"))
-
-    args.output_file = os.path.join(args.output_folder, "output.jsonl")
-    select_tests(args)
-
-
-if __name__ == "__main__":
-    main()

Repos/HWE/agents/Agentless/agentless/util/api_requests.py

@@ -1,192 +0,0 @@
-import os
-import time
-from typing import Dict, Union
-
-import anthropic
-import openai
-import tiktoken
-
-
-DEFAULT_AGENTLESS_MODEL = os.getenv("AGENTLESS_MODEL", "gpt-5.2")
-
-
-def _resolve_model_name(model: Union[str, None]) -> str:
-    return model or os.getenv("AGENTLESS_MODEL", DEFAULT_AGENTLESS_MODEL)
-
-
-def num_tokens_from_messages(message, model: Union[str, None] = None):
-    """Returns the number of tokens used by a list of messages."""
-    model = _resolve_model_name(model)
-    try:
-        encoding = tiktoken.encoding_for_model(model)
-    except KeyError:
-        encoding = tiktoken.get_encoding("cl100k_base")
-    if isinstance(message, list):
-        # use last message.
-        num_tokens = len(encoding.encode(message[0]["content"]))
-    else:
-        num_tokens = len(encoding.encode(message))
-    return num_tokens
-
-
-def create_chatgpt_config(
-    message: Union[str, list],
-    max_tokens: int,
-    temperature: float = 1,
-    batch_size: int = 1,
-    system_message: str = "You are a helpful assistant.",
-    model: Union[str, None] = None,
-) -> Dict:
-    model = _resolve_model_name(model)
-    if isinstance(message, list):
-        config = {
-            "model": model,
-            "max_tokens": max_tokens,
-            "temperature": temperature,
-            "n": batch_size,
-            "messages": [{"role": "system", "content": system_message}] + message,
-        }
-    else:
-        config = {
-            "model": model,
-            "max_tokens": max_tokens,
-            "temperature": temperature,
-            "n": batch_size,
-            "messages": [
-                {"role": "system", "content": system_message},
-                {"role": "user", "content": message},
-            ],
-        }
-    return config
-
-
-def handler(signum, frame):
-    # swallow signum and frame
-    raise Exception("end of time")
-
-
-def request_chatgpt_engine(config, logger, base_url="https://api.openai.com/v1", max_retries=40, timeout=100):
-    ret = None
-    retries = 0
-    last_exception = None
-    
-    base_url = os.getenv("OPENAI_API_BASE", base_url)
-
-    client = openai.OpenAI(base_url=base_url)
-
-    while ret is None and retries < max_retries:
-        try:
-            # Attempt to get the completion
-            logger.info("Creating API request")
-
-            ret = client.chat.completions.create(**config)
-
-        except openai.OpenAIError as e:
-            last_exception = e
-            if isinstance(e, openai.BadRequestError):
-                logger.info("Request invalid")
-                print(e)
-                logger.info(e)
-                raise Exception("Invalid API Request")
-            elif isinstance(e, openai.RateLimitError):
-                print("Rate limit exceeded. Waiting...")
-                logger.info("Rate limit exceeded. Waiting...")
-                print(e)
-                logger.info(e)
-                time.sleep(5)
-            elif isinstance(e, openai.APIConnectionError):
-                print("API connection error. Waiting...")
-                logger.info("API connection error. Waiting...")
-                print(e)
-                logger.info(e)
-                time.sleep(5)
-            else:
-                print("Unknown error. Waiting...")
-                logger.info("Unknown error. Waiting...")
-                print(e)
-                logger.info(e)
-                time.sleep(1)
-        except Exception as e:
-            last_exception = e
-            logger.exception("Unexpected exception during API request")
-            time.sleep(1)
-
-        retries += 1
-
-    if ret is None:
-        if last_exception is not None:
-            logger.error(
-                "API request failed after %s retries; last error: %s",
-                retries,
-                repr(last_exception),
-            )
-        else:
-            logger.error("API request failed after %s retries with no response.", retries)
-    logger.info(f"API response {ret}")
-    return ret
-
-
-def create_anthropic_config(
-    message: str,
-    max_tokens: int,
-    temperature: float = 1,
-    batch_size: int = 1,
-    system_message: str = "You are a helpful assistant.",
-    model: Union[str, None] = None,
-    tools: list = None,
-) -> Dict:
-    model = _resolve_model_name(model)
-    if isinstance(message, list):
-        config = {
-            "model": model,
-            "temperature": temperature,
-            "max_tokens": max_tokens,
-            "messages": message,
-        }
-    else:
-        config = {
-            "model": model,
-            "temperature": temperature,
-            "max_tokens": max_tokens,
-            "messages": [
-                {"role": "user", "content": [{"type": "text", "text": message}]},
-            ],
-        }
-
-    if tools:
-        config["tools"] = tools
-
-    return config
-
-
-def request_anthropic_engine(
-    config, logger, max_retries=40, timeout=500, prompt_cache=False
-):
-    ret = None
-    retries = 0
-
-    client = anthropic.Anthropic()
-
-    while ret is None and retries < max_retries:
-        try:
-            start_time = time.time()
-            if prompt_cache:
-                # following best practice to cache mainly the reused content at the beginning
-                # this includes any tools, system messages (which is already handled since we try to cache the first message)
-                config["messages"][0]["content"][0]["cache_control"] = {
-                    "type": "ephemeral"
-                }
-                ret = client.beta.prompt_caching.messages.create(**config)
-            else:
-                ret = client.messages.create(**config)
-        except Exception as e:
-            logger.error("Unknown error. Waiting...", exc_info=True)
-            # Check if the timeout has been exceeded
-            if time.time() - start_time >= timeout:
-                logger.warning("Request timed out. Retrying...")
-            else:
-                logger.warning("Retrying after an unknown error...")
-            time.sleep(10 * retries)
-        retries += 1
-
-    return ret

Repos/HWE/agents/Agentless/agentless/util/compress_file.py

@@ -1,220 +0,0 @@
-import re
-
-import libcst as cst
-import libcst.matchers as m
-
-
-class CompressTransformer(cst.CSTTransformer):
-    DESCRIPTION = str = "Replaces function body with ..."
-    replacement_string = '"__FUNC_BODY_REPLACEMENT_STRING__"'
-
-    def __init__(self, keep_constant=True, keep_indent=False):
-        self.keep_constant = keep_constant
-        self.keep_indent = keep_indent
-
-    def leave_Module(
-        self, original_node: cst.Module, updated_node: cst.Module
-    ) -> cst.Module:
-        new_body = [
-            stmt
-            for stmt in updated_node.body
-            if m.matches(stmt, m.ClassDef())
-            or m.matches(stmt, m.FunctionDef())
-            or (
-                self.keep_constant
-                and m.matches(stmt, m.SimpleStatementLine())
-                and m.matches(stmt.body[0], m.Assign())
-            )
-        ]
-        return updated_node.with_changes(body=new_body)
-
-    def leave_ClassDef(
-        self, original_node: cst.ClassDef, updated_node: cst.ClassDef
-    ) -> cst.ClassDef:
-        # Remove docstring in the class body
-        new_body = [
-            stmt
-            for stmt in updated_node.body.body
-            if not (
-                m.matches(stmt, m.SimpleStatementLine())
-                and m.matches(stmt.body[0], m.Expr())
-                and m.matches(stmt.body[0].value, m.SimpleString())
-            )
-        ]
-        return updated_node.with_changes(body=cst.IndentedBlock(body=new_body))
-
-    def leave_FunctionDef(
-        self, original_node: cst.FunctionDef, updated_node: cst.FunctionDef
-    ) -> cst.CSTNode:
-        if not self.keep_indent:
-            # replace with unindented statement
-            new_expr = cst.Expr(value=cst.SimpleString(value=self.replacement_string))
-            new_body = cst.IndentedBlock((new_expr,))
-            return updated_node.with_changes(body=new_body)
-        else:
-            # replace with indented statement
-            # new_expr = [cst.Pass()]
-            new_expr = [
-                cst.Expr(value=cst.SimpleString(value=self.replacement_string)),
-            ]
-            return updated_node.with_changes(
-                body=cst.IndentedBlock(body=[cst.SimpleStatementLine(body=new_expr)])
-            )
-
-
-class GlobalVariableVisitor(cst.CSTVisitor):
-    METADATA_DEPENDENCIES = (cst.metadata.PositionProvider,)
-
-    def __init__(self):
-        self.assigns = []
-
-    def leave_Assign(self, original_node: cst.Module) -> list:
-        stmt = original_node
-        start_pos = self.get_metadata(cst.metadata.PositionProvider, stmt).start
-        end_pos = self.get_metadata(cst.metadata.PositionProvider, stmt).end
-        self.assigns.append([stmt, start_pos, end_pos])
-
-
-code = """
-\"\"\"
-this is a module
-...
-\"\"\"
-const = {1,2,3}
-import os
-
-class fooClass:
-    '''this is a class'''
-
-    def __init__(self, x):
-        '''initialization.'''
-        self.x = x
-
-    def print(self):
-        print(self.x)
-
-large_var = {
-    1: 2,
-    2: 3,
-    3: 4,
-    4: 5,
-    5: 6,
-    6: 7,
-    7: 8,
-    8: 9,
-    9: 10,
-    10: 11,
-    11: 12,
-    12: 13,
-    13: 14,
-    14: 15,
-    15: 16,
-    16: 17,
-    17: 18,
-    18: 19,
-    19: 20,
-    20: 21,
-}
-
-def test():
-    a = fooClass(3)
-    a.print()
-
-"""
-
-
-def remove_lines(raw_code, remove_line_intervals):
-    # TODO: speed up this function
-    # remove_line_intervals.sort()
-
-    # Remove lines
-    new_code = ""
-    for i, line in enumerate(raw_code.splitlines()):
-        # intervals are one-based
-        if not any(start <= i + 1 <= end for start, end in remove_line_intervals):
-            new_code += line + "\n"
-        if any(start == i + 1 for start, _ in remove_line_intervals):
-            new_code += "...\n"
-    return new_code
-
-
-def compress_assign_stmts(raw_code, total_lines=30, prefix_lines=10, suffix_lines=10):
-    try:
-        tree = cst.parse_module(raw_code)
-    except Exception as e:
-        print(e.__class__.__name__, e)
-        return raw_code
-
-    wrapper = cst.metadata.MetadataWrapper(tree)
-    visitor = GlobalVariableVisitor()
-    wrapper.visit(visitor)
-
-    remove_line_intervals = []
-    for stmt in visitor.assigns:
-        if stmt[2].line - stmt[1].line > total_lines:
-            remove_line_intervals.append(
-                (stmt[1].line + prefix_lines, stmt[2].line - suffix_lines)
-            )
-    return remove_lines(raw_code, remove_line_intervals)
-
-
-def get_skeleton(
-    raw_code,
-    keep_constant: bool = True,
-    keep_indent: bool = False,
-    compress_assign: bool = False,
-    total_lines=30,
-    prefix_lines=10,
-    suffix_lines=10,
-):
-    try:
-        tree = cst.parse_module(raw_code)
-    except:
-        return raw_code
-
-    transformer = CompressTransformer(keep_constant=keep_constant, keep_indent=True)
-    modified_tree = tree.visit(transformer)
-    code = modified_tree.code
-
-    if compress_assign:
-        code = compress_assign_stmts(
-            code,
-            total_lines=total_lines,
-            prefix_lines=prefix_lines,
-            suffix_lines=suffix_lines,
-        )
-
-    if keep_indent:
-        code = code.replace(CompressTransformer.replacement_string + "\n", "...\n")
-        code = code.replace(CompressTransformer.replacement_string, "...\n")
-    else:
-        pattern = f"\\n[ \\t]*{CompressTransformer.replacement_string}"
-        replacement = "\n..."
-        code = re.sub(pattern, replacement, code)
-
-    return code
-
-
-def test_compress():
-    skeleton = get_skeleton(code, True)
-    print(skeleton)
-
-
-def test_compress_var():
-    print("LOC: ", len(code.split("\n")))
-    skeleton = get_skeleton(
-        code,
-        True,
-        keep_indent=False,
-        compress_assign=True,
-        total_lines=10,
-        prefix_lines=5,
-        suffix_lines=5,
-    )
-    print(skeleton)
-    print("LOC: ", len(skeleton.split("\n")))
-
-
-if __name__ == "__main__":
-    # test_compress()
-    test_compress_var()

Repos/HWE/agents/Agentless/agentless/util/index_skeleton.py

@@ -1,73 +0,0 @@
-import libcst as cst
-import libcst.matchers as m
-
-
-class GlobalVisitor(cst.CSTVisitor):
-    METADATA_DEPENDENCIES = (cst.metadata.PositionProvider,)
-
-    def __init__(self):
-        # includes both imports and assigns
-        self.global_stmt = []
-        self.global_imports = []
-
-    def leave_Module(self, original_node: cst.Module) -> list:
-        for stmt in original_node.body:
-            if m.matches(stmt, m.SimpleStatementLine()) and (
-                m.matches(stmt.body[0], m.Assign())
-            ):
-                expr = cst.parse_module("").code_for_node(stmt).strip()
-                self.global_stmt.append(expr)
-
-            if m.matches(stmt, m.SimpleStatementLine()) and (
-                m.matches(stmt.body[0], m.Import())
-                or m.matches(stmt.body[0], m.ImportFrom())
-            ):
-                expr = cst.parse_module("").code_for_node(stmt).strip()
-                self.global_imports.append(expr)
-
-
-def parse_global_stmt_from_code(file_content: str) -> tuple[str, str]:
-    """Parse global variables."""
-    try:
-        tree = cst.parse_module(file_content)
-        wrapper = cst.metadata.MetadataWrapper(tree)
-        visitor = GlobalVisitor()
-        wrapper.visit(visitor)
-
-        return "\n".join(visitor.global_stmt), "\n".join(visitor.global_imports)
-    except:
-        return "", ""
-
-
-code = """
-\"\"\"
-this is a module
-...
-\"\"\"
-const = {1,2,3}
-import os
-from ds import get
-from ds import *
-class fooClass:
-    '''this is a class'''
-
-    def __init__(self, x):
-        '''initialization.'''
-        self.x = x
-
-    def print(self):
-        print(self.x)
-
-def test():
-    a = fooClass(3)
-    a.print()
-"""
-
-
-def test_parse():
-    global_stmt = parse_global_stmt_from_code(code)
-    print(global_stmt)
-
-
-if __name__ == "__main__":
-    test_parse()

Repos/HWE/agents/Agentless/agentless/util/model.py

@@ -1,421 +0,0 @@
-import json
-from abc import ABC, abstractmethod
-from typing import List
-
-from agentless.util.api_requests import (
-    create_anthropic_config,
-    create_chatgpt_config,
-    request_anthropic_engine,
-    request_chatgpt_engine,
-)
-
-
-class DecoderBase(ABC):
-    def __init__(
-        self,
-        name: str,
-        logger,
-        batch_size: int = 1,
-        temperature: float = 0.8,
-        max_new_tokens: int = 1024,
-    ) -> None:
-        logger.info("Initializing a decoder model: {} ...".format(name))
-        self.name = name
-        self.logger = logger
-        self.batch_size = batch_size
-        self.temperature = temperature
-        self.max_new_tokens = max_new_tokens
-
-    @abstractmethod
-    def codegen(
-        self, message: str, num_samples: int = 1, prompt_cache: bool = False
-    ) -> List[dict]:
-        pass
-
-    @abstractmethod
-    def is_direct_completion(self) -> bool:
-        pass
-
-    def __repr__(self) -> str:
-        return self.name
-
-    def __str__(self) -> str:
-        return self.name
-
-
-class OpenAIChatDecoder(DecoderBase):
-    def __init__(self, name: str, logger, **kwargs) -> None:
-        super().__init__(name, logger, **kwargs)
-
-    def codegen(
-        self, message: str, num_samples: int = 1, prompt_cache: bool = False
-    ) -> List[dict]:
-        if self.temperature == 0:
-            assert num_samples == 1
-        batch_size = min(self.batch_size, num_samples)
-
-        config = create_chatgpt_config(
-            message=message,
-            max_tokens=self.max_new_tokens,
-            temperature=self.temperature,
-            batch_size=batch_size,
-            model=self.name,
-        )
-        ret = request_chatgpt_engine(config, self.logger)
-        if ret:
-            responses = [choice.message.content for choice in ret.choices]
-            completion_tokens = ret.usage.completion_tokens
-            prompt_tokens = ret.usage.prompt_tokens
-        else:
-            self.logger.error("No API response returned; see prior logs for errors.")
-            responses = [""]
-            completion_tokens = 0
-            prompt_tokens = 0
-
-        # The nice thing is, when we generate multiple samples from the same input (message),
-        # the input tokens are only charged once according to openai API.
-        # Therefore, we assume the request cost is only counted for the first sample.
-        # More specifically, the `prompt_tokens` is for one input message,
-        # and the `completion_tokens` is the sum of all returned completions.
-        # Therefore, for the second and later samples, the cost is zero.
-        trajs = [
-            {
-                "response": responses[0],
-                "usage": {
-                    "completion_tokens": completion_tokens,
-                    "prompt_tokens": prompt_tokens,
-                },
-            }
-        ]
-        for response in responses[1:]:
-            trajs.append(
-                {
-                    "response": response,
-                    "usage": {
-                        "completion_tokens": 0,
-                        "prompt_tokens": 0,
-                    },
-                }
-            )
-        return trajs
-
-    def is_direct_completion(self) -> bool:
-        return False
-
-
-class AnthropicChatDecoder(DecoderBase):
-    def __init__(self, name: str, logger, **kwargs) -> None:
-        super().__init__(name, logger, **kwargs)
-
-    _STR_REPLACE_EDITOR_DESCRIPTION = """Custom editing tool for editing files
-* State is persistent across command calls and discussions with the user
-
-Notes for using the `str_replace` command:
-* The `old_str` parameter should match EXACTLY one or more consecutive lines from the original file. Be mindful of whitespaces!
-* If the `old_str` parameter is not unique in the file, the replacement will not be performed. Make sure to include enough context in `old_str` to make it unique
-* The `new_str` parameter should contain the edited lines that should replace the `old_str`
-"""
-
-    _USER_REPLY_EDIT_MESSAGE = """File is successfully edited"""
-
-    tools = [
-        {
-            "name": "str_replace_editor",
-            "description": _STR_REPLACE_EDITOR_DESCRIPTION,
-            "input_schema": {
-                "type": "object",
-                "properties": {
-                    "path": {
-                        "description": "Full path to file, e.g. `folder/file.py`.",
-                        "type": "string",
-                    },
-                    "old_str": {
-                        "description": "Required parameter containing the string in `path` to replace.",
-                        "type": "string",
-                    },
-                    "new_str": {
-                        "description": "Optional parameter containing the new string (if not given, no string will be added).",
-                        "type": "string",
-                    },
-                },
-                "required": ["path", "old_str"],
-            },
-        }
-    ]
-
-    MAX_CODEGEN_ITERATIONS = 10
-
-    # specialized codegen with tool
-    def codegen_w_tool(
-        self, message: str, num_samples: int = 1, prompt_cache: bool = False
-    ) -> List[dict]:
-        def _build_response_and_extract(response, messages, iter):
-            json_response = response.to_dict()
-
-            contains_tool = False
-            # formulate the messages
-            json_response.pop("id")
-            json_response.pop("model")
-            json_response.pop("stop_reason")
-            json_response.pop("stop_sequence")
-            json_response.pop("type")
-            json_response.pop("usage")
-
-            messages.append(json_response)
-
-            response_content = []
-
-            for json_message in json_response["content"]:
-                if json_message["type"] == "tool_use":
-                    contains_tool = True
-                    # each tool use requires a response
-                    response_content.append(
-                        {
-                            "type": "tool_result",
-                            "tool_use_id": json_message["id"],
-                            "content": self._USER_REPLY_EDIT_MESSAGE,
-                        }
-                    )
-
-            if contains_tool:
-                messages.append(
-                    {
-                        "role": "user",
-                        "content": response_content,
-                    }
-                )
-            else:
-                if iter == 0:
-                    # if the first iteration does not contain the tool, likely the model is doing some CoT for debugging
-                    # append encouraging message
-                    messages.append(
-                        {
-                            "role": "user",
-                            "content": [
-                                {
-                                    "type": "text",
-                                    "text": "Please generate editing commands to fix the issue",
-                                }
-                            ],
-                        }
-                    )
-                    contains_tool = True
-
-            return messages, contains_tool
-
-        if self.temperature == 0:
-            assert num_samples == 1
-
-        trajs = []
-        for _ in range(num_samples):
-            self.logger.info(f" === Generating ====")
-            # initialized the traj
-            traj = {
-                "response": [],
-                "usage": {
-                    "completion_tokens": 0,
-                    "prompt_tokens": 0,
-                    "cache_creation_token": 0,
-                    "cache_read_input_tokens": 0,
-                },
-            }
-
-            # create the initial config and messages
-            messages = [
-                {"role": "user", "content": [{"type": "text", "text": message}]}
-            ]
-
-            for iteration in range(self.MAX_CODEGEN_ITERATIONS):
-                config = create_anthropic_config(
-                    message=messages,
-                    max_tokens=self.max_new_tokens,
-                    temperature=self.temperature,
-                    batch_size=1,
-                    model=self.name,
-                    tools=self.tools,
-                )
-                ret = request_anthropic_engine(
-                    config,
-                    self.logger,
-                    prompt_cache=True,  # prompt cache should be always true as we at least should query twice
-                )
-
-                if ret:
-                    # add the response to the traj
-                    traj["response"].append([reply.to_dict() for reply in ret.content])
-
-                    # pretty dump the response
-                    for reply in ret.content:
-                        self.logger.info(json.dumps(reply.to_dict(), indent=2))
-
-                    # update the usage
-                    traj["usage"]["completion_tokens"] += ret.usage.output_tokens
-                    traj["usage"]["prompt_tokens"] += ret.usage.input_tokens
-                    traj["usage"][
-                        "cache_creation_token"
-                    ] += ret.usage.cache_creation_input_tokens
-                    traj["usage"][
-                        "cache_read_input_tokens"
-                    ] += ret.usage.cache_read_input_tokens
-
-                    messages, contains_tool = _build_response_and_extract(
-                        ret, messages, iteration
-                    )
-
-                    if not contains_tool:
-                        break
-                else:
-                    assert (
-                        False
-                    ), "No response from the engine"  # this should not happen
-
-            if ret:
-                trajs.append(traj)
-            else:
-                trajs.append(
-                    {
-                        "response": "",
-                        "usage": {
-                            "completion_tokens": 0,
-                            "prompt_tokens": 0,
-                        },
-                    }
-                )
-
-        return trajs
-
-    def codegen(
-        self, message: str, num_samples: int = 1, prompt_cache: bool = False
-    ) -> List[dict]:
-        if self.temperature == 0:
-            assert num_samples == 1
-
-        trajs = []
-        for _ in range(num_samples):
-            config = create_anthropic_config(
-                message=message,
-                max_tokens=self.max_new_tokens,
-                temperature=self.temperature,
-                batch_size=1,
-                model=self.name,
-            )
-            ret = request_anthropic_engine(
-                config, self.logger, prompt_cache=prompt_cache
-            )
-
-            if ret:
-                trajs.append(
-                    {
-                        "response": ret.content[0].text,
-                        "usage": {
-                            "completion_tokens": ret.usage.output_tokens,
-                            "prompt_tokens": ret.usage.input_tokens,
-                            "cache_creation_token": 0
-                            if not prompt_cache
-                            else ret.usage.cache_creation_input_tokens,
-                            "cache_read_input_tokens": 0
-                            if not prompt_cache
-                            else ret.usage.cache_read_input_tokens,
-                        },
-                    }
-                )
-            else:
-                trajs.append(
-                    {
-                        "response": "",
-                        "usage": {
-                            "completion_tokens": 0,
-                            "prompt_tokens": 0,
-                        },
-                    }
-                )
-
-        return trajs
-
-    def is_direct_completion(self) -> bool:
-        return False
-
-
-class DeepSeekChatDecoder(DecoderBase):
-    def __init__(self, name: str, logger, **kwargs) -> None:
-        super().__init__(name, logger, **kwargs)
-
-    def codegen(
-        self, message: str, num_samples: int = 1, prompt_cache: bool = False
-    ) -> List[dict]:
-        if self.temperature == 0:
-            assert num_samples == 1
-
-        trajs = []
-        for _ in range(num_samples):
-            config = create_chatgpt_config(
-                message=message,
-                max_tokens=self.max_new_tokens,
-                temperature=self.temperature,
-                batch_size=1,
-                model=self.name,
-            )
-            ret = request_chatgpt_engine(
-                config, self.logger, base_url="https://api.deepseek.com"
-            )
-            if ret:
-                trajs.append(
-                    {
-                        "response": ret.choices[0].message.content,
-                        "usage": {
-                            "completion_tokens": ret.usage.completion_tokens,
-                            "prompt_tokens": ret.usage.prompt_tokens,
-                        },
-                    }
-                )
-            else:
-                trajs.append(
-                    {
-                        "response": "",
-                        "usage": {
-                            "completion_tokens": 0,
-                            "prompt_tokens": 0,
-                        },
-                    }
-                )
-
-        return trajs
-
-    def is_direct_completion(self) -> bool:
-        return False
-
-
-def make_model(
-    model: str,
-    backend: str,
-    logger,
-    batch_size: int = 1,
-    max_tokens: int = 1024,
-    temperature: float = 0.0,
-):
-    if backend == "openai":
-        return OpenAIChatDecoder(
-            name=model,
-            logger=logger,
-            batch_size=batch_size,
-            max_new_tokens=max_tokens,
-            temperature=temperature,
-        )
-    elif backend == "anthropic":
-        return AnthropicChatDecoder(
-            name=model,
-            logger=logger,
-            batch_size=batch_size,
-            max_new_tokens=max_tokens,
-            temperature=temperature,
-        )
-    elif backend == "deepseek":
-        return DeepSeekChatDecoder(
-            name=model,
-            logger=logger,
-            batch_size=batch_size,
-            max_new_tokens=max_tokens,
-            temperature=temperature,
-        )
-    else:
-        raise NotImplementedError

Repos/HWE/agents/Agentless/agentless/util/parse_global_var.py

@@ -1,93 +0,0 @@
-import libcst as cst
-import libcst.matchers as m
-from libcst.display import dump
-
-
-class GlobalVariableVisitor(cst.CSTVisitor):
-    METADATA_DEPENDENCIES = (cst.metadata.PositionProvider,)
-
-    def __init__(self):
-        self.global_assigns = []
-
-    def leave_Module(self, original_node: cst.Module) -> list:
-        assigns = []
-        for stmt in original_node.body:
-            if m.matches(stmt, m.SimpleStatementLine()) and m.matches(
-                stmt.body[0], m.Assign()
-            ):
-                start_pos = self.get_metadata(cst.metadata.PositionProvider, stmt).start
-                end_pos = self.get_metadata(cst.metadata.PositionProvider, stmt).end
-                assigns.append([stmt, start_pos, end_pos])
-        self.global_assigns.extend(assigns)
-
-
-def parse_global_var_from_code(file_content: str) -> dict[str, dict]:
-    """Parse global variables."""
-    try:
-        tree = cst.parse_module(file_content)
-    except:
-        return file_content
-
-    wrapper = cst.metadata.MetadataWrapper(tree)
-    visitor = GlobalVariableVisitor()
-    wrapper.visit(visitor)
-
-    global_assigns = {}
-    for assign_stmt, start_pos, end_pos in visitor.global_assigns:
-        for t in assign_stmt.body:
-            try:
-                targets = [t.targets[0].target.value]
-            except:
-                try:
-                    targets = t.targets[0].target.elements
-                    targets = [x.value.value for x in targets]
-                except:
-                    targets = []
-            for target_var in targets:
-                global_assigns[target_var] = {
-                    "start_line": start_pos.line,
-                    "end_line": end_pos.line,
-                }
-    return global_assigns
-
-
-def test_parse_global_var_from_file():
-    code = """
-\"\"\"
-this is a module
-...
-\"\"\"
-const_var = {1,2,3}
-const_dict = {
-    'day': 'Monday',
-    'month': 'January',
-}
-a, b = 1, 2
-import os
-
-class fooClass:
-    '''this is a class'''
-
-    def __init__(self, x):
-        '''initialization.'''
-        self.x = x
-
-    def print(self):
-        print(self.x)
-
-def test():
-    a = fooClass(3)
-    a.print()
-
-"""
-    res = parse_global_var_from_code(code)
-    assert res == {
-        "const_var": {"start_line": 6, "end_line": 6},
-        "const_dict": {"start_line": 7, "end_line": 10},
-        "a": {"start_line": 11, "end_line": 11},
-        "b": {"start_line": 11, "end_line": 11},
-    }
-
-
-if __name__ == "__main__":
-    test_parse_global_var_from_file()

Repos/HWE/agents/Agentless/agentless/util/postprocess_data.py

@@ -1,1176 +0,0 @@
-import ast
-import os
-import re
-import subprocess
-import uuid
-from collections import OrderedDict
-
-from get_repo_structure.get_patch_info import parse_patch
-
-SOURCE_EXTENSIONS = {".py", ".v", ".sv", ".vh", ".svh"}
-LOC_PREFIXES = (
-    "line:",
-    "function:",
-    "task:",
-    "method:",
-    "class:",
-    "module:",
-    "interface:",
-    "package:",
-    "program:",
-    "checker:",
-    "config:",
-    "primitive:",
-    "udp:",
-    "variable:",
-)
-
-
-def _looks_like_verilog(code: str) -> bool:
-    sample = "\n".join(code.splitlines()[:50]).lower()
-    if "`timescale" in sample or "`include" in sample:
-        return True
-    return re.search(
-        r"\b(module|endmodule|interface|endinterface|package|endpackage|always_ff|always_comb|logic|wire|reg|assign)\b",
-        sample,
-    ) is not None
-
-
-def _is_source_path(line, file_names):
-    if line in file_names:
-        return True
-    _, ext = os.path.splitext(line)
-    return ext.lower() in SOURCE_EXTENSIONS
-
-
-def check_syntax(code):
-    if not isinstance(code, list):
-        code = [code]
-
-    for c in code:
-        if (
-            not c.strip()
-        ):  # Check for cases where the model didn't return a python block
-            return False
-        try:
-            ast.parse(c)
-        except SyntaxError as e:
-            if _looks_like_verilog(c):
-                continue
-            return False
-    return True
-
-
-def remove_empty_lines(code: str) -> str:
-    # Split the code into lines
-    lines = code.splitlines()
-    # Remove empty lines
-    filtered_lines = [line for line in lines if line.strip() != ""]
-    return "\n".join(filtered_lines)
-
-
-def check_code_differ_by_just_empty_lines(codes, prev_codes) -> bool:
-
-    if not isinstance(codes, list):
-        codes = [codes]
-        prev_codes = [prev_codes]
-
-    normalized_code1 = ""
-    normalized_code2 = ""
-
-    for code, prev_code in zip(codes, prev_codes):
-        # Normalize both code snippets
-        normalized_code1 += remove_empty_lines(code)
-        normalized_code2 += remove_empty_lines(prev_code)
-
-    return normalized_code1 == normalized_code2
-
-
-def lint_code(repo_playground, temp_name, code, prev_code="") -> tuple[bool, set, set]:
-
-    # Generate a temperary folder and add uuid to avoid collision
-    repo_playground = os.path.join(repo_playground, str(uuid.uuid4()))
-
-    # assert playground doesn't exist
-    assert not os.path.exists(repo_playground), f"{repo_playground} already exists"
-
-    # create playground
-    os.makedirs(repo_playground)
-
-    with open(f"{repo_playground}/{temp_name}", "w") as f:
-        f.write(prev_code)
-
-    # lint the code
-    # check for fatal errors
-    fatal = "E9,F821,F823,F831,F406,F407,F701,F702,F704,F706"
-    o = subprocess.run(
-        f"flake8 --select={fatal} --isolated {repo_playground}/{temp_name}",
-        shell=True,
-        capture_output=True,
-    )
-    s = o.stdout.decode("utf-8")
-
-    prev_errors = set()
-    if s != "":
-        for error in s.split(f"{repo_playground}/{temp_name}:")[1:]:
-            num_free_error = ":".join(error.split(":")[2:]).strip()
-            prev_errors.add(num_free_error)
-
-    with open(f"{repo_playground}/{temp_name}", "w") as f:
-        f.write(code)
-
-    o = subprocess.run(
-        f"flake8 --select={fatal} --isolated {repo_playground}/{temp_name}",
-        shell=True,
-        capture_output=True,
-    )
-    s = o.stdout.decode("utf-8")
-
-    # remove playground
-    subprocess.run(f"rm -rf {repo_playground}", shell=True)
-
-    errors = set()
-    if s != "":
-        for error in s.split(f"{repo_playground}/{temp_name}:")[1:]:
-            num_free_error = ":".join(error.split(":")[2:]).strip()
-            errors.add(num_free_error)
-
-    if len(errors - prev_errors) > 0:
-        return False, prev_errors, errors
-
-    return True, set(), set()
-
-
-def fake_git_repo(repo_playground, file_pathes, old_contents, new_contents) -> str:
-    """create a fake git repo to obtain git diff format"""
-
-    if not isinstance(file_pathes, list):
-        # for backwards compatibility
-        file_pathes = [file_pathes]
-        old_contents = [old_contents]
-        new_contents = [new_contents]
-
-    # Generate a temperary folder and add uuid to avoid collision
-    repo_playground = os.path.join(repo_playground, str(uuid.uuid4()))
-
-    # assert playground doesn't exist
-    assert not os.path.exists(repo_playground), f"{repo_playground} already exists"
-
-    # create playground
-    os.makedirs(repo_playground)
-
-    # create a fake git repo
-    subprocess.run(f"cd {repo_playground} && git init", shell=True)
-
-    for file_path, old_content, new_content in zip(
-        file_pathes, old_contents, new_contents
-    ):
-        # create a file
-        subprocess.run(
-            f"mkdir -p {repo_playground}/{os.path.dirname(file_path)}", shell=True
-        )
-
-        with open(f"{repo_playground}/{file_path}", "w") as f:
-            f.write(old_content)
-
-        # add file to git
-        # same message is okay
-        subprocess.run(
-            f"cd {repo_playground} && git add {file_path} && git commit -m 'initial commit'",
-            shell=True,
-        )
-
-    for file_path, old_content, new_content in zip(
-        file_pathes, old_contents, new_contents
-    ):
-        # edit file
-        with open(f"{repo_playground}/{file_path}", "w") as f:
-            f.write(new_content)
-
-    # get git diff
-    o = subprocess.run(
-        f"cd {repo_playground} && git diff .", shell=True, capture_output=True
-    )
-
-    s = o.stdout.decode("utf-8")
-
-    # remove playground
-    subprocess.run(f"rm -rf {repo_playground}", shell=True)
-
-    return s
-
-
-def fake_git_apply(repo_playground, file_path, old_content, patch) -> str:
-    """create a fake git repo to obtain new file content"""
-
-    # Generate a temperary folder and add uuid to avoid collision
-    repo_playground = os.path.join(repo_playground, str(uuid.uuid4()))
-
-    # assert playground doesn't exist
-    assert not os.path.exists(repo_playground), f"{repo_playground} already exists"
-
-    # create playground
-    os.makedirs(repo_playground)
-
-    # create a fake git repo
-    subprocess.run(f"cd {repo_playground} && git init", shell=True)
-
-    # create a file
-    subprocess.run(
-        f"mkdir -p {repo_playground}/{os.path.dirname(file_path)}", shell=True
-    )
-
-    with open(f"{repo_playground}/{file_path}", "w") as f:
-        f.write(old_content)
-
-    # add file to git
-    subprocess.run(
-        f"cd {repo_playground} && git add {file_path} && git commit -m 'initial commit'",
-        shell=True,
-    )
-
-    # apply patch file
-    patch_file = f"{str(uuid.uuid4())}.patch"
-    with open(f"{repo_playground}/{patch_file}", "w") as f:
-        f.write(patch)
-    o = subprocess.run(
-        f"cd {repo_playground} && git apply --whitespace=nowarn {patch_file}",
-        shell=True,
-        capture_output=True,
-    )
-    if o.stderr.decode("utf-8"):
-        print("stderr> ", o.stderr.decode("utf-8"))
-        # TODO: This rarely happen but the patch should be valid, needs to look into it
-
-        with open(f"{repo_playground}/{file_path}", "w") as f:
-            f.write(old_content + "\n")
-
-        o = subprocess.run(
-            f"cd {repo_playground} && git apply --whitespace=nowarn {patch_file}",
-            shell=True,
-            capture_output=True,
-        )
-
-        if o.stderr.decode("utf-8"):
-            print("stderr> ", o.stderr.decode("utf-8"))
-            assert False, "shouldn't happen"
-
-    # get git diff
-    o = subprocess.run(
-        f"cd {repo_playground} && cat {file_path}", shell=True, capture_output=True
-    )
-
-    s = o.stdout.decode("utf-8")
-
-    # remove playground
-    subprocess.run(f"rm -rf {repo_playground}", shell=True)
-
-    return s
-
-
-def fake_git_apply_multiple(repo_playground, file_path_contents, patch) -> dict:
-    """create a fake git repo to obtain new file contents (multiple)"""
-
-    # Generate a temperary folder and add uuid to avoid collision
-    repo_playground = os.path.join(repo_playground, str(uuid.uuid4()))
-
-    # assert playground doesn't exist
-    assert not os.path.exists(repo_playground), f"{repo_playground} already exists"
-
-    # create playground
-    os.makedirs(repo_playground)
-
-    # create a fake git repo
-    subprocess.run(f"cd {repo_playground} && git init", shell=True)
-
-    # create files
-    for file_path, old_content in file_path_contents.items():
-        subprocess.run(
-            f"mkdir -p {repo_playground}/{os.path.dirname(file_path)}", shell=True
-        )
-
-        with open(f"{repo_playground}/{file_path}", "w") as f:
-            f.write(old_content)
-
-        # add file to git
-        subprocess.run(
-            f"cd {repo_playground} && git add {file_path} && git commit -m 'initial commit'",
-            shell=True,
-        )
-
-    # apply patch file
-    patch_file = f"{str(uuid.uuid4())}.patch"
-    with open(f"{repo_playground}/{patch_file}", "w") as f:
-        f.write(patch)
-    o = subprocess.run(
-        f"cd {repo_playground} && git apply --whitespace=nowarn {patch_file}",
-        shell=True,
-        capture_output=True,
-    )
-    if o.stderr.decode("utf-8"):
-        print("stderr> ", o.stderr.decode("utf-8"))
-        # TODO: This rarely happen but the patch should be valid, needs to look into it
-        for file_path, old_content in file_path_contents.items():
-            with open(f"{repo_playground}/{file_path}", "w") as f:
-                f.write(old_content + "\n")
-
-        o = subprocess.run(
-            f"cd {repo_playground} && git apply --whitespace=nowarn {patch_file}",
-            shell=True,
-            capture_output=True,
-        )
-
-        if o.stderr.decode("utf-8"):
-            print("stderr> ", o.stderr.decode("utf-8"))
-            assert False, "shouldn't happen"
-
-    new_file_path_contents = {}
-
-    # get git diff
-    for file_path, old_content in file_path_contents.items():
-        o = subprocess.run(
-            f"cd {repo_playground} && cat {file_path}", shell=True, capture_output=True
-        )
-
-        s = o.stdout.decode("utf-8")
-
-        new_file_path_contents[file_path] = s
-
-    # remove playground
-    subprocess.run(f"rm -rf {repo_playground}", shell=True)
-
-    return new_file_path_contents
-
-
-def get_functions(tree):
-    """Get a set of function and method names from the AST tree."""
-    functions = {}
-
-    class FunctionVisitor(ast.NodeVisitor):
-        def __init__(self):
-            self.parents = []
-
-        def visit(self, node):
-            self.parents.append(node)
-            super().visit(node)
-            self.parents.pop()
-
-        def visit_FunctionDef(self, node):
-            if not any(isinstance(parent, ast.ClassDef) for parent in self.parents):
-                functions[node.name] = ast.unparse(node)
-            self.generic_visit(node)
-
-        def visit_AsyncFunctionDef(self, node):
-            if not any(isinstance(parent, ast.ClassDef) for parent in self.parents):
-                functions[node.name] = ast.unparse(node)
-            self.generic_visit(node)
-
-    class ClassVisitor(ast.NodeVisitor):
-        def visit_ClassDef(self, node):
-            class_name = node.name
-            for body_item in node.body:
-                if isinstance(body_item, ast.FunctionDef) or isinstance(
-                    body_item, ast.AsyncFunctionDef
-                ):
-                    functions[f"{class_name}.{body_item.name}"] = ast.unparse(body_item)
-            self.generic_visit(node)
-
-    FunctionVisitor().visit(tree)
-    ClassVisitor().visit(tree)
-    return functions
-
-
-def is_just_new_function(code1, code2):
-    tree1 = ast.parse(code1)
-    tree2 = ast.parse(code2)
-
-    functions1 = get_functions(tree1)
-    functions2 = get_functions(tree2)
-
-    # The new functions in the second code
-    if len(set(list(functions1.keys())) - set(list(functions2.keys()))) > 0:
-        # removes functions
-        return False
-
-    for func in functions1:
-        if functions1[func] != functions2[func]:
-            # modifies existing functions
-            return False
-
-    if len(set(list(functions2.keys())) - set(list(functions1.keys()))) > 0:
-        return True
-
-    # modifying global stuff is okay, because its actually same as functions almost.
-
-    return False
-
-
-import io
-import re
-import tokenize
-
-
-def remove_comments_and_docstrings(source):
-    io_obj = io.StringIO(source)
-    out = ""
-    prev_toktype = tokenize.INDENT
-    last_lineno = -1
-    last_col = 0
-    for tok in tokenize.generate_tokens(io_obj.readline):
-        token_type = tok[0]
-        token_string = tok[1]
-        start_line, start_col = tok[2]
-        end_line, end_col = tok[3]
-        ltext = tok[4]
-        if start_line > last_lineno:
-            last_col = 0
-        if start_col > last_col:
-            out += " " * (start_col - last_col)
-        if token_type == tokenize.COMMENT:
-            pass
-        elif token_type == tokenize.STRING:
-            if prev_toktype != tokenize.INDENT:
-                if prev_toktype != tokenize.NEWLINE:
-                    if start_col > 0:
-                        out += token_string
-        else:
-            out += token_string
-        prev_toktype = token_type
-        last_col = end_col
-        last_lineno = end_line
-    out = "\n".join(l for l in out.splitlines() if l.strip())
-    return out
-
-
-def normalize_patch(
-    instance_id,
-    patch: str,
-    original_file_content: list,
-    new_file_content: list,
-    edited_files: list,
-) -> str:
-    "Remove edits to trailing spaces and comments in the patch."
-    if not patch.strip():
-        return ""
-
-    normalized_diff = ""
-
-    for o_file_content, n_file_content, edited_file in zip(
-        original_file_content, new_file_content, edited_files
-    ):
-        old_content = o_file_content
-        new_content = n_file_content
-
-        # Normalize file contents
-        def normalize_code(code):
-            try:
-                node = ast.parse(code)
-                return ast.unparse(node)
-            except:
-                return code
-
-        old_content = normalize_code(old_content)
-        new_content = normalize_code(new_content)
-
-        try:
-            remove_docstring_old_content = remove_comments_and_docstrings(old_content)
-            ast.parse(remove_docstring_old_content)  # check
-            remove_docstring_new_content = remove_comments_and_docstrings(new_content)
-            ast.parse(remove_docstring_new_content)  # check
-        except:
-            # when does this exception happen?
-            # when the code has some class or function with empty docstring (thats valid python code)
-            # but removing it is not, to be save we just use the original.
-            remove_docstring_old_content = old_content
-            remove_docstring_new_content = new_content
-
-        diff = fake_git_repo(
-            "playground",
-            edited_file,
-            remove_docstring_old_content,
-            remove_docstring_new_content,
-        )
-
-        if is_just_new_function(
-            remove_docstring_old_content, remove_docstring_new_content
-        ):
-            # modify the diff to ignore context.
-            new_diff = []
-            for line in diff.splitlines():
-                if line.startswith("-") or line.startswith("+"):
-                    new_diff.append(line)
-            diff = "\n".join(new_diff)
-
-        normalized_diff += diff
-
-    # Note that the normalized diff may not be applied to the original file.
-    return normalized_diff
-
-
-def extract_python_blocks(text):
-    # Regular expression pattern to match ```python\n{text}\n```
-    pattern = r"```python\n(.*?)\n```"
-
-    # Use re.findall to find all matches
-    matches = re.findall(pattern, text, re.DOTALL)
-
-    return matches
-
-
-def extract_code_blocks(text):
-    pattern = r"```\n(.*?)\n```"
-    matches = re.findall(pattern, text, re.DOTALL)
-    if len(matches) == 0:
-        if "```" in text:
-            # handle the case where the code block is not complete
-            return [text.split("```", 1)[-1].strip()]
-    return matches
-
-
-def extract_locs_for_files(locs, file_names, keep_old_order=False):
-    if keep_old_order:
-        results = {fn: [] for fn in file_names}
-    else:
-        results = {}  # dict is insertion ordered
-    current_file_name = None
-    for loc in locs:
-        for line in loc.splitlines():
-            stripped = line.strip()
-            if not stripped:
-                continue
-            if _is_source_path(stripped, file_names):
-                current_file_name = stripped
-            elif any(stripped.startswith(w) for w in LOC_PREFIXES):
-                if current_file_name in file_names:
-                    if current_file_name not in results:
-                        results[current_file_name] = []
-                    results[current_file_name].append(stripped)
-
-    for file_name in file_names:
-        if file_name not in results:  # guard for new order case
-            results[file_name] = []
-
-    return {fn: ["\n".join(results[fn])] for fn in results.keys()}
-
-
-def extract_starting_number(subcommand):
-    return int(subcommand.split(",")[0].split("start=")[-1])
-
-
-def extract_ending_number(subcommand):
-    return int(subcommand.split(",")[1].split("end=")[-1])
-
-
-def overlap(subcommand1, subcommand2):
-    start1, end1 = extract_starting_number(subcommand1), extract_ending_number(
-        subcommand1
-    )
-    start2, end2 = extract_starting_number(subcommand2), extract_ending_number(
-        subcommand2
-    )
-    return not (end1 < start2 or end2 < start1)
-
-
-def split_edit_multifile_commands(
-    commands, diff_format=False, str_replace_format=False
-) -> dict[str, str]:
-    """Split commands based on edited files."""
-    file_to_commands = OrderedDict()
-    if str_replace_format:
-        for command in commands:
-            file_name = None
-            for json_message in command:
-                if json_message["type"] == "tool_use":
-                    str_replace_command = json_message["input"]
-
-                    if "command" not in str_replace_command:
-                        str_replace_command["command"] = "str_replace"
-
-                    if "path" not in str_replace_command:
-                        continue
-
-                    if "command" not in str_replace_command:
-                        continue
-
-                    if str_replace_command["command"] == "str_replace":
-                        if "old_str" not in str_replace_command:
-                            continue
-
-                        if "new_str" not in str_replace_command:
-                            # add empty string
-                            str_replace_command["new_str"] = ""
-
-                    if str_replace_command["command"] == "insert":
-                        if (
-                            "insert_line" not in str_replace_command
-                            or "new_str" not in str_replace_command
-                        ):
-                            continue
-
-                    file_name = "'" + str_replace_command["path"] + "'"
-                    # deduplicate
-                    if (
-                        file_name not in file_to_commands
-                        or str_replace_command not in file_to_commands[file_name]
-                    ):
-                        file_to_commands.setdefault(file_name, []).append(
-                            str_replace_command
-                        )
-
-    elif diff_format:
-        for command in commands:
-            file_name = None
-            for subcommand in command.split(">>>>>>> REPLACE")[:-1]:
-                subcommand = subcommand.strip()
-                if "<<<<<<< SEARCH" in subcommand:
-                    fn = subcommand.split("<<<<<<< SEARCH")[0].lstrip("#").strip()
-                    if fn:
-                        file_name = "'" + fn + "'"
-
-                if len(subcommand.split("<<<<<<< SEARCH")) != 2:
-                    continue
-                converted_command = (
-                    "<<<<<<< SEARCH"
-                    + subcommand.split("<<<<<<< SEARCH")[1]
-                    + "\n"
-                    + ">>>>>>> REPLACE"
-                )
-                # deduplicate
-                if (
-                    file_name not in file_to_commands
-                    or converted_command not in file_to_commands[file_name]
-                ):
-                    file_to_commands.setdefault(file_name, []).append(converted_command)
-
-    else:
-        for command in commands:
-            for subcommand in command.split("edit_file(")[1:]:
-                file_name, start, end, content = subcommand.split(",", 3)
-                converted_command = "edit_file(" + ",".join([start, end, content])
-                # deduplicate
-                if (
-                    file_name not in file_to_commands
-                    or converted_command not in file_to_commands[file_name]
-                ):
-                    file_to_commands.setdefault(file_name, []).append(converted_command)
-
-    return file_to_commands
-
-
-def parse_str_replace_edit_commands(
-    commands, content, file_loc_intervals: list[tuple[int, int]]
-):
-    """
-    Original implementation: https://github.com/anthropics/anthropic-quickstarts/blob/main/computer-use-demo/computer_use_demo/tools/edit.py
-    """
-    # let's first make sure the intervals are sorted
-    file_loc_intervals.sort()
-    replaced = False
-    # apply the edits from the end of file to the beginning of file
-    # this is to make sure context is correct
-    for interval in file_loc_intervals[::-1]:
-        start, end = interval
-        start = max(start - 1, 0)
-        # intervals are 1-indexed
-
-        context_segment = "\n".join(content.splitlines()[start:end])
-        context_segment = "\n" + context_segment + "\n"
-
-        # since we want to replace the original context, let's first check for all edits.
-        can_apply = []
-        for subcommand in commands:
-
-            if subcommand["command"] == "str_replace":
-                original, replace = subcommand["old_str"], subcommand["new_str"]
-
-                if original in context_segment:
-                    can_apply.append(subcommand)
-
-            elif subcommand["command"] == "insert":
-                insert_line = subcommand["insert_line"]
-                # TODO check this
-                if insert_line > start and insert_line <= end:
-                    can_apply.append(subcommand)
-
-        # apply edits backwards
-        for subcommand in can_apply[::-1]:
-
-            if subcommand["command"] == "str_replace":
-                original, replace = subcommand["old_str"], subcommand["new_str"]
-
-                if (
-                    original in context_segment
-                ):  # This may not be true after some previously applied edits
-                    context_segment = context_segment.replace(original, replace)
-                    replaced = True
-
-            elif subcommand["command"] == "insert":
-                insert_line = subcommand["insert_line"]
-                replace = subcommand["new_str"]
-                # TODO check this
-                if insert_line > start and insert_line <= end:
-
-                    if insert_line != start - 1:
-                        replace = "\n" + replace
-                    if insert_line != end:
-                        replace = replace + "\n"
-                    context_segment = (
-                        "\n".join(
-                            context_segment.splitlines()[: insert_line - start + 1]
-                        )
-                        + replace
-                        + "\n".join(
-                            context_segment.splitlines()[insert_line - start + 1 :]
-                        )
-                    )
-                    context_segment = context_segment + "\n"
-                    replaced = True
-
-        # reassembly
-        content = (
-            "\n".join(content.splitlines()[:start])
-            + context_segment
-            + "\n".join(content.splitlines()[end:])
-        )
-
-    if not replaced:
-        print("not replaced")
-
-    return content
-
-
-def parse_diff_edit_commands(
-    commands, content, file_loc_intervals: list[tuple[int, int]]
-):
-    def parse_for_threedots(original, replace, file_loc_intervals, content):
-        # if dot dot dot in replace, its always safe to remove it
-        if replace.startswith("...\n") and len(replace) > 4:
-            # im parsing this first because its used later on
-            replace = replace[4:]
-
-        # just dot dot dot, then need to do something special
-        if original == "...":
-            if not replace[0].isspace():
-                # this is okay
-                # find a suitable original string to replace
-                for interval in file_loc_intervals:
-                    start, end = interval
-                    start = max(start - 1, 0)
-                    context_segment = "\n".join(content.splitlines()[start:end])
-
-                    for line in context_segment.splitlines():
-                        if len(line) > 0 and not line[0].isspace():
-                            if content.count(line) == 1:
-                                original = line
-                                # keep the line
-                                replace = replace + "\n\n" + line
-                                break
-
-                    if original != "...":
-                        break
-
-                if original == "...":
-                    print("cannot find suitable location")
-
-        # dot dot dot with something else in original, then its safe to replace
-        if original.startswith("...\n") and len(original) > 4:
-            # remove dot dot dot from original
-            original = original[4:]
-
-        return original, replace
-
-    if len(file_loc_intervals) == 0:
-        if original in content:
-            content = content.replace(original, replace)
-            replaced = True
-        else:
-            print("not replaced")
-        return content
-    # let's first make sure the intervals are sorted
-    file_loc_intervals.sort()
-    replaced = False
-    # apply the edits from the end of file to the beginning of file
-    # this is to make sure context is correct
-    for interval in file_loc_intervals[::-1]:
-        start, end = interval
-        start = max(start - 1, 0)
-        context_segment = "\n".join(content.splitlines()[start:end])
-        context_segment = "\n" + context_segment + "\n"
-
-        # since we want to replace the original context, let's first check for all edits.
-        can_apply = []
-        for subcommand in commands:
-            if not subcommand.startswith("<<<<<<< SEARCH") and subcommand.endswith(
-                ">>>>>>> REPLACE"
-            ):
-                continue
-
-            subcommand = "\n".join(subcommand.splitlines()[1:-1])
-            if len(subcommand.split("\n=======\n")) != 2:
-                continue
-
-            original, replace = subcommand.split("\n=======\n")
-
-            original, replace = parse_for_threedots(
-                original, replace, file_loc_intervals, content
-            )
-
-            original = "\n" + original + "\n"
-            replace = "\n" + replace + "\n"
-
-            if original in context_segment:
-                can_apply.append(subcommand)
-
-        # apply edits backwards
-        for subcommand in can_apply[::-1]:
-            original, replace = subcommand.split("\n=======\n")
-
-            original, replace = parse_for_threedots(
-                original, replace, file_loc_intervals, content
-            )
-
-            original = "\n" + original + "\n"
-            replace = "\n" + replace + "\n"
-            if (
-                original in context_segment
-            ):  # This may not be true after some previously applied edits
-                context_segment = context_segment.replace(original, replace)
-                replaced = True
-        # reassembly
-        content = (
-            "\n".join(content.splitlines()[:start])
-            + context_segment
-            + "\n".join(content.splitlines()[end:])
-        )
-
-    if not replaced:
-        print("not replaced")
-
-    return content
-
-
-def parse_edit_commands(commands, content):
-    content_lines = content.splitlines()
-    map_content_lines_to_line_num = [i for i in range(0, len(content_lines) + 1)]
-
-    # Make a list of the subcommands
-    subcommands = []
-
-    for command in commands:
-        for subcommand in command.split("edit_file(")[1:]:
-            subcommands.append(subcommand)
-
-    # Remove duplicates while preserving order
-    seen = set()
-    unique_subcommands = []
-    for subcommand in subcommands:
-        if subcommand not in seen:
-            unique_subcommands.append(subcommand)
-            seen.add(subcommand)
-
-    # Sort the unique subcommands by the starting number in reverse order
-    unique_sorted_subcommands = sorted(
-        unique_subcommands, key=extract_starting_number, reverse=True
-    )
-
-    for subcommand in unique_sorted_subcommands:
-        command_start = int(subcommand.split(",")[0].split("start=")[-1])
-        command_end = int(subcommand.split(",")[1].split("end=")[-1])
-
-        start = map_content_lines_to_line_num.index(command_start)
-        end = map_content_lines_to_line_num.index(command_end)
-
-        try:
-            changed_content = eval(
-                ")".join(",".join(subcommand.split(",")[2:]).split(")")[:-1])
-            )
-            # small thing to ensure right white space indent
-            if (
-                start == end
-                and len(changed_content.splitlines()) == 1
-                and (len(changed_content) - len(changed_content.lstrip())) == 0
-            ):
-                indent_length = len(content_lines[start - 1]) - len(
-                    content_lines[start - 1].lstrip()
-                )
-                changed_content = " " * indent_length + changed_content.lstrip()
-
-        # catch syntax error
-        except:
-            # try to fix, specially for case where there are """ or ''' in the string, that cannot be
-            # easily evaluated.
-            eval_str = ")".join(
-                ",".join(subcommand.split(",")[2:]).split(")")[:-1]
-            ).strip()
-
-            if eval_str.startswith("content="):
-                eval_str = eval_str[8:]
-
-            if eval_str.startswith('"""') or eval_str.startswith("'''"):
-                eval_str = eval_str[3:-3]
-            if eval_str.startswith('"') or eval_str.startswith("'"):
-                eval_str = eval_str[1:-1]
-
-            changed_content = eval_str
-
-        content_lines[start - 1 : end] = changed_content.splitlines()
-
-    content = "\n".join(content_lines)
-
-    return content
-
-
-def test_parse_str_replace():
-
-    content = """A
-B
-C
-D
-E
-F
-""".strip()
-
-    from agentless.util.preprocess_data import line_wrap_content
-
-    shown_content = line_wrap_content(content, context_intervals=[(3, 5)])
-    print(shown_content)
-
-    commands = [
-        {"command": "insert", "path": "test", "insert_line": 1, "new_str": "test_str"}
-    ]
-    new_content = parse_str_replace_edit_commands(
-        commands, content, file_loc_intervals=[(1, 5)]
-    )
-    print(new_content)
-
-
-def test_parse():
-    raw_output = """
-```python
-edit_file(1, 1, "import os")
-```
-"""
-
-    content = """
-import sys
-""".strip()
-
-    commands = extract_python_blocks(raw_output)
-
-    content = parse_edit_commands(commands, content)
-
-    assert content == "import os", content
-
-    raw_output = """
-```python
-edit_file(1, 1, '''import os\nimport sys''')
-```
-"""
-
-    content = """
-import sys
-""".strip()
-
-    commands = extract_python_blocks(raw_output)
-
-    content = parse_edit_commands(commands, content)
-
-    assert content == "import os\nimport sys", content
-
-    raw_output = """
-```python
-edit_file(1, 1, '''import os''')
-edit_file(1, 1, '''import sys''')
-```
-"""
-
-    content = """
-import sys
-""".strip()
-
-    commands = extract_python_blocks(raw_output)
-
-    content = parse_edit_commands(commands, content)
-
-    assert content == "import sys", content
-
-    content = """
-test
-testing
-""".strip()
-    raw_output = """
-```python
-edit_file(1, 1, "testing\ntesting2")
-edit_file(2, 2, "testing3")
-```
-"""
-    content = parse_edit_commands(extract_python_blocks(raw_output), content)
-
-    assert content == "testing\ntesting2\ntesting3", content
-
-    content = """
-test
-testing
-testinging
-""".strip()
-
-    raw_output = """
-```python
-edit_file(1, 2, "testing")
-edit_file(3, 3, "testing3")
-```
-"""
-    content = parse_edit_commands(extract_python_blocks(raw_output), content)
-
-    assert content == "testing\ntesting3", content
-
-    content = """
-test
-testing
-testinging
-test
-testing
-""".strip()
-
-    raw_output = """
-```python
-edit_file(1, 2, "testing")
-edit_file(3, 3, "testing3")
-edit_file(4, 4, "testing\ntesting2")
-edit_file(5, 5, "testing3")
-```
-"""
-
-    edited_content = """
-testing
-testing3
-testing
-testing2
-testing3
-""".strip()
-    content = parse_edit_commands(extract_python_blocks(raw_output), content)
-
-    assert content == edited_content, content
-
-    # Test for if command is present twice in the output (adapted from real output)
-    content = """
-test
-testing
-testinging
-test
-testing
-""".strip()
-
-    raw_output = (
-        """
-"To fix the issue where `viewcode`
-1. Add a condition
-
-```python
-edit_file(4, 4, """
-        """
-test4
-"""
-        """)
-```
-
-2. Ensure that the `doctree_read`
-
-```python
-edit_file(2, 3, """
-        """
-test-2-3
-"""
-        """)
-```
-
-Here is the complete set of commands to address the issue:
-
-```python
-edit_file(4, 4, """
-        """
-test4
-"""
-        """)
-```
-
-```python
-edit_file(2, 3, """
-        """
-test-2-3
-"""
-        """)
-```
-"""
-    )
-    content = parse_edit_commands(extract_python_blocks(raw_output), content)
-
-    revised_content = """
-test
-test-2-3
-test4
-testing
-""".strip()
-
-    assert content == revised_content, content
-
-    raw_output = """
-```
-django/db/migrations/optimizer.py
-function: MigrationOptimizer.optimize_inner
-
-django/db/migrations/operations/fields.py
-function: AlterField.reduce
-```
-"""
-    files = [
-        "django/db/migrations/optimizer.py",
-        "django/db/migrations/operations/fields.py",
-        "django/db/migrations/operations/models.py",
-    ]
-    extracted_locs = extract_locs_for_files([raw_output], files)
-    print(extracted_locs)
-    assert extracted_locs == [
-        ["function: MigrationOptimizer.optimize_inner"],
-        ["function: AlterField.reduce"],
-        [""],
-    ]
-
-    raw_output = """
-```python
-edit_file(start=1, end=1, content="testing not")
-```
-"""
-
-    content = """
-testing
-""".strip()
-
-    edited_content = """
-testing not
-""".strip()
-
-    content = parse_edit_commands(extract_python_blocks(raw_output), content)
-    assert content == edited_content, edited_content
-
-
-if __name__ == "__main__":
-    # test_parse()
-
-    # Example Usage
-    code1 = """
-class MyClass:
-    def existing_method(self):
-        pass
-"""
-
-    code2 = """
-class MyClass:
-    def existing_method(self):
-        pass
-
-    async def new_method(self):
-        pass
-"""
-
-    print(is_just_new_function(code1, code2))  # Output: True

Repos/HWE/agents/Agentless/agentless/util/preprocess_data.py

@@ -1,868 +0,0 @@
-import json
-import os
-
-from get_repo_structure.get_repo_structure import get_project_structure_from_scratch
-
-try:
-    from get_repo_structure.get_repo_structure import parse_verilog_file as parse_source_file
-except ImportError:
-    from get_repo_structure.get_repo_structure import parse_python_file as parse_source_file
-
-SOURCE_EXTENSIONS = {".v", ".sv", ".vh", ".svh", ".py"}
-MODULE_PREFIXES = (
-    "module:",
-    "interface:",
-    "package:",
-    "program:",
-    "class:",
-    "checker:",
-    "config:",
-    "primitive:",
-    "udp:",
-)
-FUNCTION_PREFIXES = ("function:", "task:", "method:")
-
-
-def _get_global_vars(file_content: str) -> dict:
-    try:
-        from agentless.util.parse_global_var import parse_global_var_from_code
-    except Exception:
-        return {}
-    global_vars = parse_global_var_from_code(file_content)
-    return global_vars if isinstance(global_vars, dict) else {}
-
-def line_wrap_content(
-    content: str,
-    context_intervals=None,
-    add_space=False,
-    no_line_number=False,
-    sticky_scroll=False,
-):
-    """add n| to each line, where n increases"""
-
-    def is_scope(line):
-        # TODO: this might not be precise, can improve with syntax parsing
-        stripped = line.strip()
-        return stripped.startswith("def ") or stripped.startswith("class ") or any(
-            stripped.startswith(token)
-            for token in (
-                "module ",
-                "interface ",
-                "package ",
-                "program ",
-                "class ",
-                "function ",
-                "task ",
-            )
-        )
-
-    lines = content.split("\n")
-    new_lines = []
-    if context_intervals is None or context_intervals == []:
-        context_intervals = [(0, len(lines))]
-
-    prev_scopes = []
-    line_format = "{line}"
-    if not no_line_number:
-        line_format = (
-            "{line_number}|{line}" if not add_space else "{line_number}| {line} "
-        )
-    for interval in context_intervals:
-        min_line, max_line = interval
-
-        if min_line != 0:
-            new_lines.append("...")
-
-        scopes = []
-        for i, line in enumerate(lines):
-            if sticky_scroll:
-                # add current line to scope if necessary
-                if is_scope(line):
-                    indent_level = len(line) - len(line.lstrip())
-                    while scopes and scopes[-1]["indent_level"] >= indent_level:
-                        scopes.pop()
-                    scopes.append(
-                        {"line": line, "line_number": i, "indent_level": indent_level}
-                    )
-
-            if min_line != -1 and i < min_line - 1:
-                continue
-            if sticky_scroll and i == min_line - 1:
-                # add scope lines
-                last_scope_line = None
-                for j, scope_line in enumerate(scopes):
-                    # don't repeat previous scopes
-                    if (
-                        len(prev_scopes) > j
-                        and prev_scopes[j]["line_number"] == scope_line["line_number"]
-                    ):
-                        continue
-                    # don't repeat current line
-                    if i == scope_line["line_number"]:
-                        continue
-                    new_lines.append(
-                        line_format.format(
-                            line_number=scope_line["line_number"] + 1,
-                            line=scope_line["line"],
-                        )
-                    )
-                    last_scope_line = scope_line["line_number"]
-                if last_scope_line is not None and last_scope_line < i - 1:
-                    new_lines.append("...")
-
-            new_lines.append(line_format.format(line_number=i + 1, line=line))
-            if max_line != -1 and i >= max_line - 1:
-                break
-        prev_scopes = scopes
-
-    if max_line != len(lines):
-        new_lines.append("...")
-
-    return "\n".join(new_lines)
-
-
-def merge_intervals(intervals):
-    # intervals inclusive
-    if not intervals:
-        return []
-
-    # Sort the intervals based on the starting value of each tuple
-    intervals.sort(key=lambda interval: interval[0])
-
-    merged_intervals = [intervals[0]]
-
-    for current in intervals[1:]:
-        last = merged_intervals[-1]
-
-        # Check if there is overlap
-        if current[0] <= last[1]:
-            # If there is overlap, merge the intervals
-            merged_intervals[-1] = (last[0], max(last[1], current[1]))
-        else:
-            # If there is no overlap, just add the current interval to the result list
-            merged_intervals.append(current)
-
-    return merged_intervals
-
-
-def transfer_arb_locs_to_locs(
-    locs,
-    structure,
-    pred_file,
-    context_window=10,
-    loc_interval=False,
-    fine_grain_only=False,
-    remove_line=False,
-    file_content="",
-    verbose=False,
-) -> tuple[list, list]:
-    if structure is None:
-        class_info, function_names, file_lines = parse_source_file("", file_content)
-        structure = {}
-        structure[pred_file] = {
-            "classes": class_info,
-            "functions": function_names,
-            "text": file_lines,
-        }
-
-    files, classes, functions = get_full_file_paths_and_classes_and_functions(structure)
-
-    line_loc = []
-    if isinstance(locs, str):
-        # if its a single loc
-        locs = [locs]
-    # TODO: parse it in advance
-    global_vars = _get_global_vars(file_content)
-    unrecognized_locs = []
-
-    for model_pred_locs in locs:
-        current_class_name = ""
-        for loc in model_pred_locs.splitlines():
-            # handle cases like "class: MyClass.my_method"
-            module_prefix = next(
-                (prefix for prefix in MODULE_PREFIXES if loc.startswith(prefix)), None
-            )
-            if module_prefix and "." not in loc:
-                loc = loc[len(module_prefix) :].strip()
-                relevant_class = [
-                    clazz
-                    for clazz in classes
-                    if clazz["file"] == pred_file and clazz["name"] == loc
-                ]
-
-                if len(relevant_class) == 0:
-                    unrecognized_locs.append(loc)
-                else:
-                    line_loc.append(
-                        (relevant_class[0]["start_line"], relevant_class[0]["end_line"])
-                    )
-                    current_class_name = loc
-
-            elif loc.startswith(FUNCTION_PREFIXES) or "." in loc:
-                full_loc = loc
-                loc = loc.split(":", 1)[-1].strip()
-
-                if "." in loc:
-                    # assume its a method within a class
-                    method_name = loc.split(".")[1]
-                    class_name = loc.split(".")[0]
-
-                    relevant_class = [
-                        clazz
-                        for clazz in classes
-                        if clazz["file"] == pred_file and clazz["name"] == class_name
-                    ]
-                    if len(relevant_class) == 0:
-                        unrecognized_locs.append(loc)
-                    else:
-                        relevant_method = [
-                            method
-                            for method in relevant_class[0]["methods"]
-                            if method["name"] == method_name
-                        ]
-                        if len(relevant_method) == 0:
-                            unrecognized_locs.append(loc)
-                        else:
-                            line_loc.append(
-                                (
-                                    relevant_method[0]["start_line"],
-                                    relevant_method[0]["end_line"],
-                                )
-                            )
-
-                else:
-                    relevant_function = [
-                        function
-                        for function in functions
-                        if function["file"] == pred_file and function["name"] == loc
-                    ]
-                    if len(relevant_function) == 0:
-                        if current_class_name != "":
-                            # check if its a method
-                            relevant_class = [
-                                clazz
-                                for clazz in classes
-                                if clazz["file"] == pred_file
-                                and clazz["name"] == current_class_name
-                            ]
-                            relevant_method = [
-                                method
-                                for method in relevant_class[0]["methods"]
-                                if method["name"] == loc
-                            ]
-                            if len(relevant_method) == 0:
-                                unrecognized_locs.append(loc)
-                            else:
-                                line_loc.append(
-                                    (
-                                        relevant_method[0]["start_line"],
-                                        relevant_method[0]["end_line"],
-                                    )
-                                )
-                        else:
-                            # look for it in any class
-                            relevant_method = []
-                            for clazz in classes:
-                                if clazz["file"] == pred_file:
-                                    relevant_method.extend(
-                                        [
-                                            method
-                                            for method in clazz["methods"]
-                                            if method["name"] == loc
-                                        ]
-                                    )
-
-                            if len(relevant_method) == 1:
-                                line_loc.append(
-                                    (
-                                        relevant_method[0]["start_line"],
-                                        relevant_method[0]["end_line"],
-                                    )
-                                )
-                    else:
-                        line_loc.append(
-                            (
-                                relevant_function[0]["start_line"],
-                                relevant_function[0]["end_line"],
-                            )
-                        )
-            elif loc.startswith("line: "):
-                if remove_line:
-                    # TODO: can recover the corresponding function instead of throwing it away
-                    continue
-                loc = loc[len("line: ") :].strip().split()[0]
-                try:
-                    # line_loc.append(int(loc))
-                    line_loc.append((int(loc), int(loc)))
-                except:
-                    continue
-            elif loc.startswith("variable:"):
-                vars = loc[len("variable:") :].strip().split()
-                for v in vars:
-                    if v in global_vars:
-                        line_loc.append(
-                            (global_vars[v]["start_line"], global_vars[v]["end_line"])
-                        )
-            else:
-                if loc.strip():
-                    unrecognized_locs.append(loc)
-                # assert False
-
-    # Fine-grained-only loc: Remove intervals that are supersets of another.
-    if fine_grain_only:
-        filtered_line_loc = []
-        for st, en in line_loc:
-            if filtered_line_loc:
-                last_st, last_en = filtered_line_loc[-1]
-                # If the current interval is a more fine-grained loc, remove the superset.
-                if last_st <= st and en <= last_en:
-                    filtered_line_loc.pop()
-            filtered_line_loc.append((st, en))
-        line_loc = filtered_line_loc
-
-    # compute max min
-    # TODO: think of strategies to do bunched up lines
-    # TODO: e.g., we can have multiple code segments (right now, its just one)
-
-    for file_content in files:
-        if file_content[0] == pred_file:
-            content = file_content[1]
-            break
-
-    if len(line_loc) == 0:
-        return [], []
-
-    # max_line = min(max(line_loc) + context_window, len(content))
-    # min_line = max(min(line_loc) - context_window, 0)
-    #
-    # return line_loc, max_line, min_line
-
-    if verbose:
-        print("Unrecognized locs:")
-        for loc in unrecognized_locs:
-            print(loc)
-
-    # compute overlapping locations instead
-    if loc_interval:
-        contextual_line_loc = []
-        for loc in line_loc:
-            # Clip the context window to the beginning and end of the file
-            max_line = max(min(loc[1] + context_window, len(content)), 0)
-            min_line = min(max(loc[0] - context_window, 0), len(content))
-            contextual_line_loc.append((min_line, max_line))
-
-        return line_loc, merge_intervals(contextual_line_loc)
-    else:
-        # defaulting to max min
-        max_line = min(max([loc[1] for loc in line_loc]) + context_window, len(content))
-        min_line = max(min([loc[0] for loc in line_loc]) - context_window, 0)
-
-        return line_loc, [(min_line, max_line)]
-
-
-def check_contains_valid_loc(file_to_locs, structure):
-    """checks if the llm generated locations have at least one location valid"""
-
-    file_contents = get_repo_files(structure, list(file_to_locs.keys()))
-
-    for pred_file, locs in file_to_locs.items():
-        line_locs, _ = transfer_arb_locs_to_locs(
-            locs,
-            structure,
-            pred_file,
-            0,  # these parameters do not matter for checking purposes
-            True,  # these parameters do not matter for checking purposes
-            False,  # these parameters do not matter for checking purposes
-            file_content=file_contents[pred_file] if pred_file in file_contents else "",
-        )
-
-        if len(line_locs) > 0:
-            return True
-
-    return False
-
-
-def compile_gt_locations(gt_location: dict) -> tuple[list, set, set, set]:
-    """mostly serves a way to check what are the gt locations in gt patch"""
-    edits = gt_location["edits"]
-
-    lines, classes, methods, functions = [], set(), set(), set()
-
-    adds = set()
-
-    for edit in edits:
-        for clazz in edit["class_names"]:
-            classes.add(clazz)
-
-        for method in edit["method_names"]:
-            methods.add(method)
-
-        for function in edit["function_names"]:
-            functions.add(function)
-
-        if edit["type"] == "add":
-            adds.add(edit["line"])
-        else:
-            lines.append(edit["line"])
-
-    # handle the added lines
-    add_intervals = [(i, i + 1) for i in adds]
-    add_intervals = merge_intervals(add_intervals)
-    for st, en in add_intervals:
-        lines.append(st)
-    lines = list(set(lines))
-
-    # sort the lines
-    lines = sorted(lines)
-
-    return lines, classes, methods, functions
-
-
-def show_project_structure(structure, spacing=0) -> str:
-    """pprint the project structure"""
-
-    pp_string = ""
-
-    for key, value in structure.items():
-        if "." in key:
-            _, ext = os.path.splitext(key)
-            if ext.lower() not in SOURCE_EXTENSIONS:
-                continue  # skip non-source files
-        if "." in key:
-            pp_string += " " * spacing + str(key) + "\n"
-        else:
-            pp_string += " " * spacing + str(key) + "/" + "\n"
-        if "classes" not in value:
-            pp_string += show_project_structure(value, spacing + 4)
-
-    return pp_string
-
-
-def filter_out_test_files(structure):
-    """filter out test files from the project structure"""
-    for key, value in list(structure.items()):
-        if key.startswith("test"):
-            del structure[key]
-        elif isinstance(value, dict):
-            filter_out_test_files(value)
-
-
-def filter_none_python(structure):
-    for key, value in list(structure.items()):
-        if (
-            not "functions" in value.keys()
-            and not "classes" in value.keys()
-            and not "text" in value.keys()
-        ) or not len(value.keys()) == 3:
-            filter_none_python(value)
-
-            if structure[key] == {}:
-                del structure[key]
-        else:
-            _, ext = os.path.splitext(key)
-            if ext.lower() not in SOURCE_EXTENSIONS:
-                del structure[key]
-
-
-def filter_non_source(structure):
-    filter_none_python(structure)
-
-
-def filter_proposed_files(proposed_files, repo_structure):
-    """
-    Filter proposed files against a given repository structure.
-
-    Arguments:
-    proposed_files -- list of proposed files with instance IDs
-    repo_structure -- list of repository structures with instance IDs
-
-    Returns:
-    A list of dictionaries with instance IDs and valid files matching the repository structure.
-    """
-    instance_to_files = {
-        entry["instance_id"]: entry["files"] for entry in proposed_files
-    }
-    instance_to_structure = {
-        entry["instance_id"]: entry["structure"] for entry in repo_structure
-    }
-    filtered_files = []
-    for instance_id, files in instance_to_files.items():
-        if instance_id in instance_to_structure:
-            repo_files, _, _ = get_full_file_paths_and_classes_and_functions(
-                instance_to_structure[instance_id]
-            )
-            repo_files_set = set(repo_files)
-            valid_files = []
-            for repo_file in repo_files_set:
-                for proposed_file in files:
-                    if proposed_file == repo_file.split("/")[-1]:
-                        valid_files.append(repo_file)
-            if valid_files:
-                filtered_files.append(
-                    {"instance_id": instance_id, "files": valid_files}
-                )
-    return filtered_files
-
-
-def filter_proposed_classes(proposed_classes, repo_structure):
-    """
-    Filter proposed classes against a given repository structure.
-
-    Arguments:
-    proposed_classes -- list of proposed classes with instance IDs
-    repo_structure -- list of repository structures with instance IDs
-
-    Returns:
-    A list of dictionaries with instance IDs and valid classes matching the repository structure.
-    """
-    instance_to_classes = {
-        entry["instance_id"]: entry["classes"] for entry in proposed_classes
-    }
-    instance_to_structure = {
-        entry["instance_id"]: entry["structure"] for entry in repo_structure
-    }
-    filtered_classes = []
-    for instance_id, classes in instance_to_classes.items():
-        if instance_id in instance_to_structure:
-            _, repo_classes, _ = get_full_file_paths_and_classes_and_functions(
-                instance_to_structure[instance_id]
-            )
-            repo_classes_set = {clazz["name"]: clazz["file"] for clazz in repo_classes}
-            valid_classes = []
-            for proposed_class in classes:
-                if proposed_class in repo_classes_set:
-                    valid_classes.append(
-                        {
-                            "name": proposed_class,
-                            "file": repo_classes_set[proposed_class],
-                        }
-                    )
-            if valid_classes:
-                filtered_classes.append(
-                    {"instance_id": instance_id, "classes": valid_classes}
-                )
-    return filtered_classes
-
-
-def filter_proposed_methods(proposed_methods, repo_structure):
-    """
-    Filter proposed methods against a given repository structure.
-
-    Arguments:
-    proposed_methods -- list of proposed methods with instance IDs
-    repo_structure -- list of repository structures with instance IDs
-
-    Returns:
-    A list of dictionaries with instance IDs and valid methods matching the repository structure.
-    """
-    instance_to_methods = {
-        entry["instance_id"]: entry["methods"] for entry in proposed_methods
-    }
-    instance_to_structure = {
-        entry["instance_id"]: entry["structure"] for entry in repo_structure
-    }
-    filtered_methods = []
-    for instance_id, methods in instance_to_methods.items():
-        if instance_id in instance_to_structure:
-            _, repo_classes, _ = get_full_file_paths_and_classes_and_functions(
-                instance_to_structure[instance_id]
-            )
-            valid_methods = []
-            for repo_class in repo_classes:
-                for method in methods:
-                    if method in repo_class["methods"]:
-                        valid_methods.append(
-                            {
-                                "class": repo_class["name"],
-                                "method": method,
-                                "file": repo_class["file"],
-                            }
-                        )
-            if valid_methods:
-                filtered_methods.append(
-                    {"instance_id": instance_id, "methods": valid_methods}
-                )
-    return filtered_methods
-
-
-def filter_proposed_functions(proposed_functions, repo_structure):
-    """
-    Filter proposed functions against a given repository structure.
-
-    Arguments:
-    proposed_functions -- list of proposed functions with instance IDs
-    repo_structure -- list of repository structures with instance IDs
-
-    Returns:
-    A list of dictionaries with instance IDs and valid functions matching the repository structure.
-    """
-    instance_to_functions = {
-        entry["instance_id"]: entry["functions"] for entry in proposed_functions
-    }
-    instance_to_structure = {
-        entry["instance_id"]: entry["structure"] for entry in repo_structure
-    }
-    filtered_functions = []
-    for instance_id, functions in instance_to_functions.items():
-        if instance_id in instance_to_structure:
-            _, _, repo_functions = get_full_file_paths_and_classes_and_functions(
-                instance_to_structure[instance_id]
-            )
-            valid_functions = []
-            for repo_function in repo_functions:
-                for function in functions:
-                    if isinstance(
-                        repo_function["name"], dict
-                    ):  # Why are there cases where this is not a dict?
-                        if function == repo_function["name"].get("name", []):
-                            valid_functions.append(
-                                {"function": function, "file": repo_function["file"]}
-                            )
-            if valid_functions:
-                filtered_functions.append(
-                    {"instance_id": instance_id, "functions": valid_functions}
-                )
-    return filtered_functions
-
-
-def get_full_file_paths_and_classes_and_functions(structure, current_path=""):
-    """
-    Recursively retrieve all file paths, classes, and functions within a directory structure.
-
-    Arguments:
-    structure -- a dictionary representing the directory structure
-    current_path -- the path accumulated so far, used during recursion (default="")
-
-    Returns:
-    A tuple containing:
-    - files: list of full file paths
-    - classes: list of class details with file paths
-    - functions: list of function details with file paths
-    """
-    files = []
-    classes = []
-    functions = []
-    for name, content in structure.items():
-        if isinstance(content, dict):
-            if (
-                not "functions" in content.keys()
-                and not "classes" in content.keys()
-                and not "text" in content.keys()
-            ) or not len(content.keys()) == 3:
-                # or guards against case where functions and classes are somehow part of the structure.
-                next_path = f"{current_path}/{name}" if current_path else name
-                (
-                    sub_files,
-                    sub_classes,
-                    sub_functions,
-                ) = get_full_file_paths_and_classes_and_functions(content, next_path)
-                files.extend(sub_files)
-                classes.extend(sub_classes)
-                functions.extend(sub_functions)
-            else:
-                next_path = f"{current_path}/{name}" if current_path else name
-                files.append((next_path, content["text"]))
-                if "classes" in content:
-                    for clazz in content["classes"]:
-                        classes.append(
-                            {
-                                "file": next_path,
-                                "name": clazz["name"],
-                                "start_line": clazz["start_line"],
-                                "end_line": clazz["end_line"],
-                                "methods": [
-                                    {
-                                        "name": method["name"],
-                                        "start_line": method["start_line"],
-                                        "end_line": method["end_line"],
-                                    }
-                                    for method in clazz.get("methods", [])
-                                ],
-                            }
-                        )
-                if "functions" in content:
-                    for function in content["functions"]:
-                        function["file"] = next_path
-                        functions.append(function)
-        else:
-            next_path = f"{current_path}/{name}" if current_path else name
-            files.append(next_path)
-    return files, classes, functions
-
-
-PROJECT_FILE_LOC = os.environ.get("PROJECT_FILE_LOC", None)
-
-
-def get_repo_structure(instance_id: str, repo_name, base_commit, playground):
-
-    if PROJECT_FILE_LOC is not None:
-        with open(PROJECT_FILE_LOC + "/" + instance_id + ".json") as f:
-            d = json.load(f)
-        repo_structure = d["structure"]
-    else:
-        d = get_project_structure_from_scratch(
-            repo_name, base_commit, instance_id, playground
-        )
-        repo_structure = d["structure"]
-
-    return repo_structure
-
-
-def get_repo_files(structure, filepaths: list[str]):
-    files, classes, functions = get_full_file_paths_and_classes_and_functions(structure)
-    file_contents = dict()
-    for filepath in filepaths:
-        content = None
-
-        for file_content in files:
-            if file_content[0] == filepath:
-                content = "\n".join(file_content[1])
-                file_contents[filepath] = content
-                break
-
-        assert content is not None, "file not found"
-    return file_contents
-
-
-def correct_file_paths(model_found_files, files):
-    found_files = []
-    if model_found_files:
-        for model_file in model_found_files:
-            for file_content in files:
-                file = file_content[0]
-                if model_file == file:
-                    found_files.append(file)
-        return found_files
-    else:
-        return []
-
-
-def clean_method_left_space(method_code: str) -> str:
-    indent_space = len(method_code.splitlines()[0]) - len(
-        method_code.splitlines()[0].lstrip()
-    )
-    # remove indent_space in each line
-    return "\n".join([line[indent_space:] for line in method_code.splitlines()])
-
-
-def test_correct_file_paths():
-    # Test case 1: Exact match
-    model_files1 = ["data.txt", "analysis/report.pdf"]
-    files1 = [("data.txt",), ("notes.txt",), ("report/report.pdf",)]
-    result1 = correct_file_paths(model_files1, files1)
-    assert result1 == ["data.txt"], f"Expected ['data.txt'], but got {result1}"
-
-    # Test case 2: Subdirectories in model files
-    model_files2 = ["subdir/data.txt", "notes/info.txt"]
-    files2 = [
-        ("work/subdir/data.txt",),
-        ("notes/info.txt",),
-        ("extras/notes/info.txt",),
-    ]
-    result2 = correct_file_paths(model_files2, files2)
-    assert result2 == [
-        "work/subdir/data.txt",
-        "notes/info.txt",
-    ], f"Expected ['work/subdir/data.txt', 'notes/info.txt'], but got {result2}"
-
-    # Test case 3: No match
-    model_files3 = ["missing.txt"]
-    files3 = [("data.txt",), ("notes.txt",), ("analysis/report.pdf",)]
-    result3 = correct_file_paths(model_files3, files3)
-    assert result3 == [], f"Expected [], but got {result3}"
-
-    # Test case 4: Multiple potential matches but only first match counts
-    model_files4 = ["report.doc"]
-    files4 = [("work/report.doc",), ("work/rr/report.docg",)]
-    result4 = correct_file_paths(model_files4, files4)
-    assert result4 == [
-        "work/report.doc"
-    ], f"Expected ['work/report.doc'], but got {result4}"
-
-    # Test case 5: Model file is a subset
-    model_files5 = ["data"]
-    files5 = [("project/data_analysis/data.txt",), ("data/config.yaml",)]
-    result5 = correct_file_paths(model_files5, files5)
-    assert result5 == [], f"Expected [], but got {result5}"
-
-    # Test case 6: File without any folders with two matches
-    model_files6 = ["data.txt"]
-    files6 = [("project/data_analysis/data.txt",), ("data/config.yaml",), ("data.txt",)]
-    result6 = correct_file_paths(model_files6, files6)
-    assert result6 == ["data.txt"], f"Expected ['data.txt'], but got {result6}"
-
-    # Test case 7: File without any folders with only a subdirectory match
-    model_files7 = ["data.txt"]
-    files7 = [("project/data_analysis/data.txt",), ("data/config.yaml",)]
-    result7 = correct_file_paths(model_files7, files7)
-    assert result7 == [
-        "project/data_analysis/data.txt"
-    ], f"Expected ['project/data_analysis/data.txt'], but got {result7}"
-
-    print("All test cases passed!")
-
-
-def test_merge():
-    # Example usage:
-    input_tuples = [(1, 3), (2, 4), (5, 7), (6, 8)]
-    merged_tuples = merge_intervals(input_tuples)
-    assert merged_tuples == [(1, 4), (5, 8)]
-
-    input_tuples = [(1, 5), (2, 3)]
-    merged_tuples = merge_intervals(input_tuples)
-    assert merged_tuples == [(1, 5)]
-
-    input_tuples = [(1, 1)]
-    merged_tuples = merge_intervals(input_tuples)
-    assert merged_tuples == [(1, 1)]
-
-    input_tuples = [(1, 1), (2, 3)]
-    merged_tuples = merge_intervals(input_tuples)
-    assert merged_tuples == [(1, 1), (2, 3)]
-
-
-def test_merge():
-    # Example usage:
-    input_tuples = [(1, 3), (2, 4), (5, 7), (6, 8)]
-    merged_tuples = merge_intervals(input_tuples)
-    assert merged_tuples == [(1, 4), (5, 8)]
-
-    input_tuples = [(1, 5), (2, 3)]
-    merged_tuples = merge_intervals(input_tuples)
-    assert merged_tuples == [(1, 5)]
-
-    input_tuples = [(1, 1)]
-    merged_tuples = merge_intervals(input_tuples)
-    assert merged_tuples == [(1, 1)]
-
-    input_tuples = [(1, 1), (2, 3)]
-    merged_tuples = merge_intervals(input_tuples)
-    assert merged_tuples == [(1, 1), (2, 3)]
-
-
-def test_interval_display():
-
-    content = """
-one
-two
-three
-four
-five
-six
-seven
-eight
-""".strip()
-
-    x = line_wrap_content(content, [])
-    print(x)
-
-    print("============")
-
-    x = line_wrap_content(content, [(1, 2), (4, 6), (7, 8)])
-    print(x)
-
-
-if __name__ == "__main__":
-    test_merge()
-    test_correct_file_paths()
-    test_interval_display()

Repos/HWE/agents/Agentless/agentless/util/utils.py

@@ -1,93 +0,0 @@
-import json
-import logging
-import os
-
-
-def load_jsonl(filepath):
-    """
-    Load a JSONL file from the given filepath.
-
-    Arguments:
-    filepath -- the path to the JSONL file to load
-
-    Returns:
-    A list of dictionaries representing the data in each line of the JSONL file.
-    """
-    with open(filepath, "r") as file:
-        return [json.loads(line) for line in file]
-
-
-def write_jsonl(data, filepath):
-    """
-    Write data to a JSONL file at the given filepath.
-
-    Arguments:
-    data -- a list of dictionaries to write to the JSONL file
-    filepath -- the path to the JSONL file to write
-    """
-    with open(filepath, "w") as file:
-        for entry in data:
-            file.write(json.dumps(entry) + "\n")
-
-
-def load_json(filepath):
-    return json.load(open(filepath, "r"))
-
-
-def combine_by_instance_id(data):
-    """
-    Combine data entries by their instance ID.
-
-    Arguments:
-    data -- a list of dictionaries with instance IDs and other information
-
-    Returns:
-    A list of combined dictionaries by instance ID with all associated data.
-    """
-    combined_data = defaultdict(lambda: defaultdict(list))
-    for item in data:
-        instance_id = item.get("instance_id")
-        if not instance_id:
-            continue
-        for key, value in item.items():
-            if key != "instance_id":
-                combined_data[instance_id][key].extend(
-                    value if isinstance(value, list) else [value]
-                )
-    return [
-        {**{"instance_id": iid}, **details} for iid, details in combined_data.items()
-    ]
-
-
-def setup_logger(log_file):
-    logger = logging.getLogger(log_file)
-    logger.setLevel(logging.DEBUG)
-
-    fh = logging.FileHandler(log_file)
-    fh.setLevel(logging.DEBUG)
-
-    formatter = logging.Formatter("%(asctime)s - %(levelname)s - %(message)s")
-    fh.setFormatter(formatter)
-
-    logger.addHandler(fh)
-    return logger
-
-
-def cleanup_logger(logger):
-    handlers = logger.handlers[:]
-    for handler in handlers:
-        logger.removeHandler(handler)
-        handler.close()
-
-
-def load_existing_instance_ids(output_file):
-    instance_ids = set()
-    if os.path.exists(output_file):
-        with open(output_file, "r") as f:
-            for line in f:
-                try:
-                    data = json.loads(line.strip())
-                    instance_ids.add(data["instance_id"])
-                except json.JSONDecodeError:
-                    continue
-    return instance_ids

Repos/HWE/agents/Agentless/agentless_solutions.tar.gz

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:d18df3fd3da6ce0a0867f94f82bc98973b2594db37cb702a30617c0e2f6c4dc1
-size 85267

Repos/HWE/agents/Agentless/batch_run.sh

@@ -1,14 +0,0 @@
-#!/usr/bin/env bash
-
-#export AGENTLESS_MODEL="gpt-5.2"
-#bash run_agentless.sh
-#export AGENTLESS_MODEL="gemini-3-pro"
-#bash run_agentless.sh
-#export AGENTLESS_MODEL="glm-4.6"
-#bash run_agentless.sh
-#export AGENTLESS_MODEL="minimax-m2"
-#bash run_agentless.sh
-export AGENTLESS_MODEL="deepseek-v3.2"
-bash run_agentless.sh
-#export AGENTLESS_MODEL="qwen3-coder-plus"
-#bash run_agentless.sh

Repos/HWE/agents/Agentless/build_dataset.py

@@ -1,108 +0,0 @@
-import argparse
-import json
-import os
-import sys
-
-
-DEFAULT_DATASET_DIR = "/workspace/phoenix-bench/data/snapshots"
-DEFAULT_ISSUES_DIR = "/workspace/phoenix-bench/data/issues"
-
-
-def read_issue_text(issues_dir, instance_id):
-    issue_path = os.path.join(issues_dir, instance_id)
-    if not os.path.isfile(issue_path):
-        return None
-    with open(issue_path, "r", encoding="utf-8") as f:
-        return f.read().strip()
-
-
-def build_dataset(dataset_dir, issues_dir):
-    entries = []
-    missing = []
-
-    for name in sorted(os.listdir(dataset_dir)):
-        repo_path = os.path.join(dataset_dir, name)
-        if not os.path.isdir(repo_path):
-            continue
-
-        problem_statement = read_issue_text(issues_dir, name)
-        if problem_statement is None:
-            missing.append(name)
-            continue
-
-        entries.append(
-            {
-                "instance_id": name,
-                "repo": repo_path,
-                "base_commit": None,
-                "problem_statement": problem_statement,
-            }
-        )
-
-    return entries, missing
-
-
-def write_output(entries, output_path, jsonl=False):
-    if jsonl:
-        with open(output_path, "w", encoding="utf-8") as f:
-            for entry in entries:
-                f.write(json.dumps(entry) + "\n")
-        return
-
-    with open(output_path, "w", encoding="utf-8") as f:
-        json.dump(entries, f, indent=2)
-
-
-def parse_args():
-    parser = argparse.ArgumentParser(
-        description="Build Agentless dataset JSON/JSONL from local repos and issue text."
-    )
-    parser.add_argument(
-        "--dataset-dir",
-        default=DEFAULT_DATASET_DIR,
-        help="Directory containing repo subdirectories.",
-    )
-    parser.add_argument(
-        "--issues-dir",
-        default=DEFAULT_ISSUES_DIR,
-        help="Directory containing issue text files named by instance_id.",
-    )
-    parser.add_argument(
-        "--output",
-        default="/workspace/phoenix-bench/Agentless/agentless_dataset.json",
-        help="Output path (.json or .jsonl). Defaults next to dataset dir.",
-    )
-    parser.add_argument(
-        "--jsonl",
-        action="store_true",
-        help="Write JSONL instead of JSON array.",
-    )
-    return parser.parse_args()
-
-
-def main():
-    args = parse_args()
-
-    dataset_dir = os.path.abspath(args.dataset_dir)
-    issues_dir = os.path.abspath(args.issues_dir)
-    if args.output:
-        output_path = args.output
-    else:
-        suffix = ".jsonl" if args.jsonl else ".json"
-        output_path = os.path.join(
-            os.path.dirname(dataset_dir), os.path.basename(dataset_dir) + suffix
-        )
-
-    entries, missing = build_dataset(dataset_dir, issues_dir)
-    write_output(entries, output_path, jsonl=args.jsonl)
-
-    print(f"Wrote {len(entries)} entries to {output_path}")
-    if missing:
-        print(
-            "Missing issue files for: " + ", ".join(missing),
-            file=sys.stderr,
-        )
-
-
-if __name__ == "__main__":
-    main()

Repos/HWE/agents/Agentless/build_solutions.py

@@ -1,115 +0,0 @@
-#!/usr/bin/env python3
-import argparse
-import json
-from pathlib import Path
-
-
-def _safe_name(name: str) -> str:
-    return name.replace("/", "__")
-
-
-def _resolve_input_path(results_root: Path, model_name: str) -> Path:
-    candidates = []
-    for candidate_dir in [model_name, _safe_name(model_name), ""]:
-        if candidate_dir:
-            candidate = (
-                results_root / candidate_dir / "output_0_processed.jsonl"
-            ).resolve()
-        else:
-            candidate = (results_root / "output_0_processed.jsonl").resolve()
-        candidates.append(candidate)
-        if candidate.exists():
-            return candidate
-
-    joined = "\n".join(str(p) for p in candidates)
-    raise FileNotFoundError(
-        "Could not find output_0_processed.jsonl for model. Checked:\n" + joined
-    )
-
-
-def _load_jsonl(path: Path) -> list[dict]:
-    rows = []
-    with path.open("r", encoding="utf-8") as f:
-        for line in f:
-            line = line.strip()
-            if not line:
-                continue
-            rows.append(json.loads(line))
-    return rows
-
-
-def main() -> None:
-    parser = argparse.ArgumentParser(
-        description=(
-            "Build OpenHands-style solutions jsonl from Agentless repair outputs."
-        )
-    )
-    parser.add_argument("--model_name", required=True, help="Model name to collect.")
-    parser.add_argument(
-        "--results_root",
-        default="/workspace/phoenix-bench/Agentless/results/hwe-bench-lite/repair_sample_verilog",
-        help="Root folder containing <model_name>/output_0_processed.jsonl.",
-    )
-    parser.add_argument(
-        "--dataset_path",
-        default="/workspace/phoenix-bench/Agentless/agentless_dataset.json",
-        help="Agentless dataset json used for repo_name mapping.",
-    )
-    parser.add_argument(
-        "--output_path",
-        default="",
-        help=(
-            "Output jsonl path. Defaults to "
-            "agentless_solutions_<model_name>_<dataset_size>.jsonl in Agentless root."
-        ),
-    )
-    args = parser.parse_args()
-
-    script_dir = Path(__file__).resolve().parent
-    results_root = Path(args.results_root).resolve()
-    dataset_path = Path(args.dataset_path).resolve()
-
-    input_path = _resolve_input_path(results_root, args.model_name)
-
-    with dataset_path.open("r", encoding="utf-8") as f:
-        dataset = json.load(f)
-
-    patches = _load_jsonl(input_path)
-    patch_by_instance = {}
-    for row in patches:
-        instance_id = row.get("instance_id")
-        if not instance_id:
-            continue
-        patch_by_instance[instance_id] = row.get("model_patch", "")
-
-    output_path = (
-        Path(args.output_path).resolve()
-        if args.output_path
-        else (
-            script_dir
-            / f"agentless_solutions_{_safe_name(args.model_name)}_{len(dataset)}.jsonl"
-        ).resolve()
-    )
-    output_path.parent.mkdir(parents=True, exist_ok=True)
-
-    missing = 0
-    with output_path.open("w", encoding="utf-8") as f:
-        for item in dataset:
-            instance_id = item["instance_id"]
-            solution = patch_by_instance.get(instance_id, "")
-            if instance_id not in patch_by_instance:
-                missing += 1
-            out = {
-                "repo_name": item["repo"],
-                "solution": solution,
-            }
-            f.write(json.dumps(out, ensure_ascii=False) + "\n")
-
-    print(f"Input:  {input_path}")
-    print(f"Output: {output_path}")
-    print(f"Rows:   {len(dataset)}")
-    print(f"Missing patches filled with empty solution: {missing}")
-
-
-if __name__ == "__main__":
-    main()

Repos/HWE/agents/Agentless/classification/README.md

@@ -1,40 +0,0 @@
-# SWE-bench Lite-*S* and problem classifications
-
-Here we provide our manual classifications of the problems in SWE-bench lite
-
-> [!NOTE]
->
-> The classification results differ slightly with the paper as we have performed further manual checking and modified the classifications of few problems.
-
-## Quick Setup
-
-First install the neccessary graphing utilizies:
-
-```shell
-cd classification
-pip install -r requirements_graph.txt
-```
-
-## Graphing
-
-Run the following command to produce Figure 5 in the paper:
-
-```shell
-python graph_classification.py
-```
-
-This will produce various graphs: `benchmark_bar_location.pdf`, `benchmark_pie_description.pdf`, and `benchmark_pie_patch.pdf`
-
-For the detailed classifications, we have released our raw classifications for each problem and can be access in `swebench_lite_classifications.csv`
-
-## SWE-bench Lite-*S* problems
-
-To obtain the problems in SWE-bench Lite-*S*, run the following command:
-
-```shell
-python load_filtered_benchmark.py
-```
-
-This produces the `swebench_lite_s_problems.txt` which contains the instance_ids of the subset of problems
-
-Note: we filter out the problems that contain the exact patch in the problem description, misleading solutions, or do not provide enough information in the original issue description.

Repos/HWE/agents/Agentless/classification/graph_classification.py

@@ -1,199 +0,0 @@
-import matplotlib as mpl
-from matplotlib import pyplot as plt
-
-plt.style.use(
-    "https://github.com/dhaitz/matplotlib-stylesheets/raw/master/pacoty.mplstyle"
-)
-plt.rcParams["font.family"] = "monospace"
-plt.rcParams["font.weight"] = "bold"
-plt.rcParams.update({"font.size": 10})
-
-plt.rcParams["axes.facecolor"] = "#FFFFFF"
-plt.rcParams["axes.edgecolor"] = "black"
-
-mpl.rcParams["axes.prop_cycle"] = mpl.cycler(
-    color=[
-        "#9fc5e8",
-        "#b4a7d6",
-        "#b6d7a8",
-        "#ea9999",
-        "#d5a6bd",
-        "#8c564b",
-        "#e377c2",
-        "#7f7f7f",
-        "#bcbd22",
-        "#17becf",
-    ]
-)
-
-from load_filtered_benchmark import load_classification_results
-
-
-def graph_benchmark_classification():
-
-    instance_id_to_type = load_classification_results()
-
-    description_to_count = {}
-    description_patch_to_count = {}
-    location_to_count = {}
-    location_function_to_count = {}
-    location_file_to_count = {}
-    location_line_to_count = {}
-
-    for instance_id, classification in instance_id_to_type.items():
-        description = classification["description_classification"]
-        description_patch = classification["solution_classification"]
-        location_line = classification["line_location"]
-        location_function = classification["function_location"]
-        location_file = classification["file_location"]
-        location = classification["line_location"]
-
-        if description in description_to_count:
-            description_to_count[description] += 1
-        else:
-            description_to_count[description] = 1
-
-        if description_patch in description_patch_to_count:
-            description_patch_to_count[description_patch] += 1
-        else:
-            description_patch_to_count[description_patch] = 1
-
-        if (
-            location_line == "Natural language"
-            or location_function == "Natural language"
-            or location_file == "Natural language"
-        ):
-            location = "Natural language"
-        elif (
-            location_line == "Stacktrace"
-            or location_function == "Stacktrace"
-            or location_file == "Stacktrace"
-        ):
-            location = "Stacktrace"
-        elif (
-            location_line == "Keywords"
-            or location_function == "Keywords"
-            or location_file == "Keywords"
-        ):
-            location = "Keywords"
-        else:
-            location = "None"
-
-        if location in location_to_count:
-            location_to_count[location] += 1
-        else:
-            location_to_count[location] = 1
-
-        if location_line in location_line_to_count:
-            location_line_to_count[location_line] += 1
-        else:
-            location_line_to_count[location_line] = 1
-
-        if location_function in location_function_to_count:
-            location_function_to_count[location_function] += 1
-        else:
-            location_function_to_count[location_function] = 1
-
-        if location_file in location_file_to_count:
-            location_file_to_count[location_file] += 1
-        else:
-            location_file_to_count[location_file] = 1
-
-    fig, ax = plt.subplots(1, 1, figsize=(6, 5))
-
-    wdges, labels, autopct = ax.pie(
-        description_to_count.values(),
-        labels=[x.replace(" ", "\n") for x in description_to_count.keys()],
-        explode=[
-            0.1 if x == "Not enough info" else 0.02 for x in description_to_count.keys()
-        ],
-        autopct="%1.1f%%",
-        shadow={"ox": -0.04, "edgecolor": "none", "shade": 0.5},
-        textprops={"fontsize": 18},
-    )
-    plt.setp(labels, fontsize=12)
-    fig.tight_layout()
-    plt.savefig("benchmark_pie_description.pdf")
-
-    fig, ax = plt.subplots(1, 1, figsize=(6, 5))
-
-    wdges, labels, autopct = ax.pie(
-        description_patch_to_count.values(),
-        labels=[x.replace(" ", "\n") for x in description_patch_to_count.keys()],
-        explode=[
-            0.1 if x == "Exact patch" else 0.02
-            for x in description_patch_to_count.keys()
-        ],
-        autopct="%1.1f%%",
-        shadow={"ox": -0.04, "edgecolor": "none", "shade": 0.5},
-        startangle=90,
-        textprops={"fontsize": 18},
-    )
-    plt.setp(labels, fontsize=12)
-
-    fig.tight_layout()
-    plt.savefig("benchmark_pie_patch.pdf")
-
-    # 4 stack bar plots
-    fig, ax = plt.subplots(1, 1, figsize=(6, 5))
-
-    bottom = [0, 0, 0, 0]
-    counts = {}
-
-    width = 0.5
-
-    for loc in ["None", "Stacktrace", "Natural language", "Keywords"]:
-        if loc == "Stacktrace":
-            counts["Stack trace"] = []
-            if loc in location_line_to_count:
-                counts["Stack trace"].append(location_line_to_count[loc] / 3)
-            else:
-                counts["Stack trace"].append(0)
-
-            counts["Stack trace"].append(location_function_to_count[loc] / 3)
-            counts["Stack trace"].append(location_file_to_count[loc] / 3)
-            counts["Stack trace"].append(location_to_count[loc] / 3)
-        else:
-            counts[loc] = []
-
-            if loc in location_line_to_count:
-                counts[loc].append(location_line_to_count[loc] / 3)
-            else:
-                counts[loc].append(0)
-
-            counts[loc].append(location_function_to_count[loc] / 3)
-            counts[loc].append(location_file_to_count[loc] / 3)
-            counts[loc].append(location_to_count[loc] / 3)
-
-    for label, count in counts.items():
-        ax.bar(
-            ["Line", "Function", "File", "Overall"],
-            count,
-            bottom=bottom,
-            label=label,
-            width=width,
-        )
-        bottom = [sum(x) for x in zip(bottom, count)]
-
-        # write text
-        for i, v in enumerate(count):
-            if v == 0:
-                continue
-            ax.text(
-                i,
-                bottom[i] - v / 1.5,
-                str(round(v, 1)) + "%",
-                color="black",
-                fontweight="bold",
-                ha="center",
-                fontsize=15,
-            )
-
-    ax.set_ylabel("Percentage")
-    ax.legend(fancybox=True, shadow=True, prop={"size": 10}, frameon=True)
-    fig.tight_layout()
-    plt.savefig("benchmark_bar_location.pdf")
-
-
-if __name__ == "__main__":
-    graph_benchmark_classification()

Repos/HWE/agents/Agentless/classification/load_filtered_benchmark.py

@@ -1,71 +0,0 @@
-def load_classification_results():
-    import csv
-
-    instance_id_to_type = {}
-
-    with open("swebench_lite_classifications.csv", "r") as f:
-        reader = csv.reader(f)
-        # skip first row
-        next(reader)
-        for row in reader:
-            instance_id = row[0]
-
-            instance_id_to_type[instance_id] = {
-                "problem_statement": row[1],
-                "gt_patch": row[2],
-                "test_patch": row[3],
-                "description_classification": row[4],
-                "solution_classification": row[5],
-                "line_location": row[6],
-                "function_location": row[7],
-                "file_location": row[8],
-            }
-
-    return instance_id_to_type
-
-
-def load_swebench_s_problems():
-
-    instance_id_to_type = load_classification_results()
-    description_to_instance_id = {}
-    description_patch_to_instance_id = {}
-
-    for instance_id, instance_type in instance_id_to_type.items():
-        if (
-            instance_type["description_classification"]
-            not in description_to_instance_id
-        ):
-            description_to_instance_id[instance_type["description_classification"]] = []
-
-        description_to_instance_id[instance_type["description_classification"]].append(
-            instance_id
-        )
-
-        if (
-            instance_type["solution_classification"]
-            not in description_patch_to_instance_id
-        ):
-            description_patch_to_instance_id[
-                instance_type["solution_classification"]
-            ] = []
-
-        description_patch_to_instance_id[
-            instance_type["solution_classification"]
-        ].append(instance_id)
-
-    filtered_set = set([instance_id for instance_id in instance_id_to_type.keys()])
-
-    filtered_set = (
-        filtered_set
-        - set(description_to_instance_id["Not enough info"])
-        - set(description_patch_to_instance_id["Misleading"])
-        - set(description_patch_to_instance_id["Exact patch"])
-    )
-
-    with open("swebench_lite_s_problems.txt", "w") as f:
-        for instance_id in filtered_set:
-            f.write(instance_id + "\n")
-
-
-if __name__ == "__main__":
-    load_swebench_s_problems()

Repos/HWE/agents/Agentless/classification/requirements_graph.txt

@@ -1,2 +0,0 @@
-matplotlib
-venn

Repos/HWE/agents/Agentless/get_repo_structure/get_patch_info.py

@@ -1,72 +0,0 @@
-import argparse
-import json
-import re
-from collections import defaultdict
-
-
-def parse_patch(patch):
-    """
-    Parse a git patch into a structured format.
-
-    Parameters:
-        patch (str): The git patch as a string.
-
-    Returns:
-        list: A list of dictionaries representing the file changes and hunks.
-    """
-    file_changes = []
-    current_file = None
-    current_hunk = None
-    deleted_lines = 0
-
-    patch_lines = patch.split("\n")
-    for line in patch_lines:
-        if line.startswith("diff --git"):
-            # Reset for new files
-            if current_file:
-                file_changes.append(current_file)
-            current_file = {"file": "", "hunks": []}
-        elif line.startswith("--- a/"):
-            pass
-        elif line.startswith("+++ b/"):
-            if current_file is not None:
-                current_file["file"] = line[6:]
-        elif line.startswith("@@ "):
-            if current_file is not None:
-                match = re.match(r"@@ -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@", line)
-                if match:
-                    current_hunk = {"start_line": int(match.group(2)), "changes": []}
-                    current_file["hunks"].append(current_hunk)
-                    deleted_lines = 0
-                    added_lines = 0
-        elif line.startswith("+") or line.startswith("-"):
-            if current_hunk is not None:
-                change_type = "add" if line.startswith("+") else "delete"
-                if change_type == "delete":
-                    deleted_lines += 1
-                    current_hunk["changes"].append(
-                        {
-                            "type": change_type,
-                            "content": line[1:].strip(),
-                            "line": current_hunk["start_line"] - added_lines,
-                        }
-                    )
-                    current_hunk["start_line"] += 1
-                else:
-                    added_lines += 1
-                    current_hunk["changes"].append(
-                        {
-                            "type": change_type,
-                            "content": line[1:].strip(),
-                            "line": current_hunk["start_line"] - deleted_lines,
-                        }
-                    )
-                    current_hunk["start_line"] += 1
-        else:
-            if current_hunk is not None:
-                current_hunk["start_line"] += 1
-
-    if current_file:
-        file_changes.append(current_file)
-
-    return file_changes

Repos/HWE/agents/Agentless/get_repo_structure/get_repo_structure.py

@@ -1,376 +0,0 @@
-import argparse
-import json
-import os
-import subprocess
-import uuid
-
-import pandas as pd
-from tqdm import tqdm
-from tree_sitter import Language, Parser
-
-repo_to_top_folder = {
-    "django/django": "django",
-    "sphinx-doc/sphinx": "sphinx",
-    "scikit-learn/scikit-learn": "scikit-learn",
-    "sympy/sympy": "sympy",
-    "pytest-dev/pytest": "pytest",
-    "matplotlib/matplotlib": "matplotlib",
-    "astropy/astropy": "astropy",
-    "pydata/xarray": "xarray",
-    "mwaskom/seaborn": "seaborn",
-    "psf/requests": "requests",
-    "pylint-dev/pylint": "pylint",
-    "pallets/flask": "flask",
-}
-
-_PARSER = None
-_MODULE_NODE_TYPES = {
-    "module_declaration",
-    "interface_declaration",
-    "program_declaration",
-    "package_declaration",
-    "class_declaration",
-    "interface_class_declaration",
-    "checker_declaration",
-    "config_declaration",
-    "primitive_declaration",
-    "udp_declaration",
-}
-_FUNC_NODE_TYPES = {
-    "function_declaration",
-    "task_declaration",
-    "function_prototype",
-    "task_prototype",
-    "method_declaration",
-    "method_prototype",
-    "class_constructor_declaration",
-    "class_constructor_prototype",
-}
-_VERILOG_EXTENSIONS = {".v", ".sv", ".vh", ".svh"}
-_ATTRIBUTE_NODE_TYPES = {"attribute_instance"}
-_SIMPLE_IDENTIFIER_NODE_TYPES = {
-    "simple_identifier",
-    "escaped_identifier",
-    "module_identifier",
-    "udp_identifier",
-}
-
-
-def _get_verilog_parser():
-    global _PARSER
-    if _PARSER is None:
-        so_path = os.environ.get("TREE_SITTER_VERILOG_SO")
-        language_name = os.environ.get("TREE_SITTER_VERILOG_LANGUAGE", "verilog")
-        if not so_path:
-            raise RuntimeError(
-                "TREE_SITTER_VERILOG_SO must point to a tree-sitter-verilog .so file"
-            )
-        if not os.path.isfile(so_path):
-            raise RuntimeError(f"tree-sitter .so not found: {so_path}")
-        try:
-            language = Language(so_path, language_name)
-        except TypeError:
-            import ctypes
-
-            symbol = os.environ.get(
-                "TREE_SITTER_VERILOG_SYMBOL", f"tree_sitter_{language_name}"
-            )
-            lib = ctypes.CDLL(so_path)
-            try:
-                func = getattr(lib, symbol)
-            except AttributeError as exc:
-                raise RuntimeError(
-                    f"tree-sitter language symbol '{symbol}' not found in {so_path}"
-                ) from exc
-            func.restype = ctypes.c_void_p
-            language = Language(func())
-        parser = Parser()
-        if hasattr(parser, "set_language"):
-            parser.set_language(language)
-        else:
-            parser.language = language
-        _PARSER = parser
-    return _PARSER
-
-
-def _node_text(node, source_bytes):
-    return source_bytes[node.start_byte : node.end_byte].decode(
-        "utf-8", errors="replace"
-    )
-
-
-def _iter_tree(node):
-    stack = [node]
-    while stack:
-        current = stack.pop()
-        yield current
-        if current.children:
-            stack.extend(reversed(current.children))
-
-
-def _find_child(node, type_set):
-    for child in node.children:
-        if child.type in type_set:
-            return child
-    return None
-
-
-def _find_identifier(node, identifier_types):
-    for child in node.children:
-        if child.type in _ATTRIBUTE_NODE_TYPES:
-            continue
-        if child.type in identifier_types:
-            return child
-    return None
-
-
-def _name_from_direct(node, source_bytes, identifier_types):
-    name_node = _find_identifier(node, identifier_types)
-    if name_node is None:
-        return None
-    return _node_text(name_node, source_bytes).strip()
-
-
-def _name_from_child(node, source_bytes, child_types, identifier_types):
-    child = _find_child(node, child_types)
-    if child is None:
-        return None
-    return _name_from_direct(child, source_bytes, identifier_types)
-
-
-def _node_key(node):
-    return (node.start_byte, node.end_byte, node.type)
-
-
-def _node_name(node, source_bytes):
-    node_type = node.type
-    if node_type == "module_declaration":
-        return _name_from_child(
-            node, source_bytes, {"module_header"}, _SIMPLE_IDENTIFIER_NODE_TYPES
-        ) or _name_from_direct(node, source_bytes, _SIMPLE_IDENTIFIER_NODE_TYPES)
-    if node_type == "udp_declaration":
-        return _name_from_child(
-            node,
-            source_bytes,
-            {"udp_nonansi_declaration", "udp_ansi_declaration"},
-            _SIMPLE_IDENTIFIER_NODE_TYPES,
-        ) or _name_from_direct(node, source_bytes, _SIMPLE_IDENTIFIER_NODE_TYPES)
-    if node_type == "interface_declaration":
-        name = _name_from_direct(node, source_bytes, {"interface_identifier"})
-        if name:
-            return name
-        return _name_from_child(
-            node,
-            source_bytes,
-            {"interface_nonansi_header", "interface_ansi_header"},
-            {"interface_identifier"},
-        )
-    if node_type == "program_declaration":
-        name = _name_from_direct(node, source_bytes, {"program_identifier"})
-        if name:
-            return name
-        return _name_from_child(
-            node,
-            source_bytes,
-            {"program_nonansi_header", "program_ansi_header"},
-            {"program_identifier"},
-        )
-    if node_type == "package_declaration":
-        return _name_from_direct(node, source_bytes, {"package_identifier"})
-    if node_type in {"class_declaration", "interface_class_declaration"}:
-        return _name_from_direct(node, source_bytes, {"class_identifier"})
-    if node_type == "checker_declaration":
-        return _name_from_direct(node, source_bytes, {"checker_identifier"})
-    if node_type == "config_declaration":
-        return _name_from_direct(node, source_bytes, {"config_identifier"})
-    if node_type == "function_declaration":
-        return _name_from_child(
-            node, source_bytes, {"function_body_declaration"}, {"function_identifier"}
-        )
-    if node_type == "task_declaration":
-        return _name_from_child(
-            node, source_bytes, {"task_body_declaration"}, {"task_identifier"}
-        )
-    if node_type == "function_prototype":
-        return _name_from_direct(node, source_bytes, {"function_identifier"})
-    if node_type == "task_prototype":
-        return _name_from_direct(node, source_bytes, {"task_identifier"})
-    if node_type in {"class_constructor_declaration", "class_constructor_prototype"}:
-        return "new"
-    return None
-
-
-def _find_enclosing_container(node, container_by_id):
-    parent = node.parent
-    while parent is not None:
-        node_key = _node_key(parent)
-        if node_key in container_by_id:
-            return container_by_id[node_key]
-        parent = parent.parent
-    return None
-
-
-def checkout_commit(repo_path, commit_id):
-    """Checkout the specified commit in the given local git repository.
-    :param repo_path: Path to the local git repository
-    :param commit_id: Commit ID to checkout
-    :return: None
-    """
-    try:
-        # Change directory to the provided repository path and checkout the specified commit
-        print(f"Checking out commit {commit_id} in repository at {repo_path}...")
-        subprocess.run(["git", "-C", repo_path, "checkout", commit_id], check=True)
-        print("Commit checked out successfully.")
-    except subprocess.CalledProcessError as e:
-        print(f"An error occurred while running git command: {e}")
-    except Exception as e:
-        print(f"An unexpected error occurred: {e}")
-
-
-def clone_repo(repo_name, repo_playground):
-    try:
-
-        print(
-            f"Cloning repository from https://github.com/{repo_name}.git to {repo_playground}/{repo_to_top_folder[repo_name]}..."
-        )
-        subprocess.run(
-            [
-                "git",
-                "clone",
-                f"https://github.com/{repo_name}.git",
-                f"{repo_playground}/{repo_to_top_folder[repo_name]}",
-            ],
-            check=True,
-        )
-        print("Repository cloned successfully.")
-    except subprocess.CalledProcessError as e:
-        print(f"An error occurred while running git command: {e}")
-    except Exception as e:
-        print(f"An unexpected error occurred: {e}")
-
-
-def get_project_structure_from_scratch(
-    repo_name, commit_id, instance_id, repo_playground
-):
-
-    # Generate a temperary folder and add uuid to avoid collision
-    repo_playground = os.path.join(repo_playground, str(uuid.uuid4()))
-
-    # assert playground doesn't exist
-    assert not os.path.exists(repo_playground), f"{repo_playground} already exists"
-
-    # create playground
-    os.makedirs(repo_playground)
-
-    #clone_repo(repo_name, repo_playground)
-    #checkout_commit(f"{repo_playground}/{repo_to_top_folder[repo_name]}", commit_id)
-    #structure = create_structure(f"{repo_playground}/{repo_to_top_folder[repo_name]}")
-    structure = create_structure(f"{repo_name}")
-    # clean up
-    #subprocess.run(
-    #    ["rm", "-rf", f"{repo_playground}/{repo_to_top_folder[repo_name]}"], check=True
-    #)
-    d = {
-        "repo": repo_name,
-        "base_commit": commit_id,
-        "structure": structure,
-        "instance_id": instance_id,
-    }
-    return d
-
-
-def parse_verilog_file(file_path, file_content=None):
-    """Parse a Verilog/SystemVerilog file with tree-sitter."""
-    if file_content is None:
-        try:
-            with open(file_path, "r") as file:
-                file_content = file.read()
-        except Exception as e:  # Catch all types of exceptions
-            print(f"Error in file {file_path}: {e}")
-            return [], [], ""
-
-    parser = _get_verilog_parser()
-    source_bytes = file_content.encode("utf-8", errors="replace")
-    tree = parser.parse(source_bytes)
-
-    class_info = []
-    function_names = []
-    container_by_id = {}
-    lines = file_content.splitlines()
-
-    for node in _iter_tree(tree.root_node):
-        if node.type not in _MODULE_NODE_TYPES:
-            continue
-
-        container_name = _node_name(node, source_bytes)
-        if not container_name:
-            continue
-        start_line = node.start_point[0] + 1
-        end_line = node.end_point[0] + 1
-
-        container_info = {
-            "name": container_name,
-            "start_line": start_line,
-            "end_line": end_line,
-            "text": lines[start_line - 1 : end_line],
-            "methods": [],
-        }
-        class_info.append(container_info)
-        container_by_id[_node_key(node)] = container_info
-
-    for node in _iter_tree(tree.root_node):
-        if node.type not in _FUNC_NODE_TYPES:
-            continue
-        func_name = _node_name(node, source_bytes)
-        if not func_name:
-            continue
-        start_line = node.start_point[0] + 1
-        end_line = node.end_point[0] + 1
-        func_info = {
-            "name": func_name,
-            "start_line": start_line,
-            "end_line": end_line,
-            "text": lines[start_line - 1 : end_line],
-        }
-        container_info = _find_enclosing_container(node, container_by_id)
-        if container_info is None:
-            function_names.append(func_info)
-        else:
-            container_info["methods"].append(func_info)
-
-    return class_info, function_names, lines
-
-
-def parse_python_file(file_path, file_content=None):
-    """Compatibility shim: parses Verilog/SystemVerilog files."""
-    return parse_verilog_file(file_path, file_content)
-
-
-def create_structure(directory_path):
-    """Create the structure of the repository directory by parsing Verilog files."""
-    structure = {}
-
-    for root, _, files in os.walk(directory_path):
-        repo_name = os.path.basename(directory_path)
-        relative_root = os.path.relpath(root, directory_path)
-        if relative_root == ".":
-            relative_root = repo_name
-        curr_struct = structure
-        for part in relative_root.split(os.sep):
-            if part not in curr_struct:
-                curr_struct[part] = {}
-            curr_struct = curr_struct[part]
-        for file_name in files:
-            _, ext = os.path.splitext(file_name)
-            if ext.lower() in _VERILOG_EXTENSIONS:
-                file_path = os.path.join(root, file_name)
-                class_info, function_names, file_lines = parse_verilog_file(file_path)
-                curr_struct[file_name] = {
-                    "classes": class_info,
-                    "functions": function_names,
-                    "text": file_lines,
-                }
-            else:
-                curr_struct[file_name] = {}
-
-    return structure

Repos/HWE/agents/Agentless/requirements.txt

@@ -1,9 +0,0 @@
-anthropic
-openai
-pre-commit
-datasets
-tiktoken
-libcst
-llama-index
-jsonlines
-swebench @ git+https://github.com/princeton-nlp/SWE-bench

Repos/HWE/agents/Agentless/run_agentless.py

@@ -1,359 +0,0 @@
-#!/usr/bin/env python3
-import argparse
-import os
-import selectors
-import subprocess
-import sys
-import time
-
-
-def _safe_model_dir_name(model_name: str) -> str:
-    return model_name.replace("/", "__")
-
-
-def _build_env():
-    env = os.environ.copy()
-    env["OPENAI_API_BASE"] = "https://api.openai.com/v1"
-    env["OPENAI_API_KEY"] = "YOUR_OPENAI_API_KEY"
-    env["TREE_SITTER_VERILOG_SO"] = "/workspace/phoenix-bench/Agentless/my-languages.so"
-    env["PYTHONPATH"] = f'{env.get("PYTHONPATH", "")}:{os.getcwd()}'
-    env["PYTHONUNBUFFERED"] = "1"
-    return env
-
-
-def run_cmd(cmd, env, cwd):
-    subprocess.run(cmd, env=env, cwd=cwd, check=True)
-
-
-def _run_cmd_streaming(cmd, env, cwd, capture_limit=1024 * 1024):
-    proc = subprocess.Popen(
-        cmd,
-        env=env,
-        cwd=cwd,
-        stdout=subprocess.PIPE,
-        stderr=subprocess.PIPE,
-        bufsize=0,
-    )
-    sel = selectors.DefaultSelector()
-    sel.register(proc.stdout, selectors.EVENT_READ)
-    sel.register(proc.stderr, selectors.EVENT_READ)
-    captured = bytearray()
-
-    while True:
-        events = sel.select(timeout=1)
-        if events:
-            for key, _ in events:
-                data = os.read(key.fileobj.fileno(), 4096)
-                if not data:
-                    sel.unregister(key.fileobj)
-                    key.fileobj.close()
-                    continue
-                if key.fileobj is proc.stdout:
-                    sys.stdout.buffer.write(data)
-                    sys.stdout.buffer.flush()
-                else:
-                    sys.stderr.buffer.write(data)
-                    sys.stderr.buffer.flush()
-                if capture_limit:
-                    captured.extend(data)
-                    if len(captured) > capture_limit:
-                        captured = captured[-capture_limit:]
-        if proc.poll() is not None and not sel.get_map():
-            break
-
-    return proc.wait(), bytes(captured)
-
-
-def run_cmd_with_retry_on_read_timeout(cmd, env, cwd, max_retries):
-    for attempt in range(1, max_retries + 1):
-        status, output = _run_cmd_streaming(cmd, env, cwd)
-        if status == 0:
-            return
-        if b"ReadTimeout" in output:
-            if attempt < max_retries:
-                print(
-                    f"Step 3 hit a ReadTimeout (attempt {attempt}/{max_retries}), retrying..."
-                )
-                continue
-        raise SystemExit(status)
-
-
-def run_cmd_with_inactivity_timeout(cmd, env, cwd, timeout_seconds):
-    proc = subprocess.Popen(
-        cmd,
-        env=env,
-        cwd=cwd,
-        stdout=subprocess.PIPE,
-        stderr=subprocess.PIPE,
-        bufsize=0,
-    )
-    sel = selectors.DefaultSelector()
-    sel.register(proc.stdout, selectors.EVENT_READ)
-    sel.register(proc.stderr, selectors.EVENT_READ)
-    last_output = time.monotonic()
-
-    while True:
-        events = sel.select(timeout=1)
-        if events:
-            for key, _ in events:
-                data = os.read(key.fileobj.fileno(), 4096)
-                if not data:
-                    sel.unregister(key.fileobj)
-                    key.fileobj.close()
-                    continue
-                last_output = time.monotonic()
-                if key.fileobj is proc.stdout:
-                    sys.stdout.buffer.write(data)
-                    sys.stdout.buffer.flush()
-                else:
-                    sys.stderr.buffer.write(data)
-                    sys.stderr.buffer.flush()
-        else:
-            if time.monotonic() - last_output > timeout_seconds:
-                proc.terminate()
-                try:
-                    proc.wait(timeout=5)
-                except subprocess.TimeoutExpired:
-                    proc.kill()
-                return 124
-        if proc.poll() is not None and not sel.get_map():
-            break
-
-    return proc.wait()
-
-
-def main():
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "--model",
-        type=str,
-        default=os.getenv("AGENTLESS_MODEL", "gpt-5.2"),
-        help="Model name for Agentless localization/repair steps.",
-    )
-    parser.add_argument(
-        "--backend",
-        type=str,
-        default="openai",
-        choices=["openai", "deepseek", "anthropic"],
-        help="Model backend for Agentless localization/repair steps.",
-    )
-    args = parser.parse_args()
-    model_dir = _safe_model_dir_name(args.model)
-
-    repo_root = "/workspace/phoenix-bench/Agentless"
-    os.chdir(repo_root)
-    env = _build_env()
-
-    dataset_path = "/workspace/phoenix-bench/Agentless/agentless_dataset.json"
-
-    steps = [
-        (
-            "1",
-            [
-                "python",
-                "agentless/fl/localize.py",
-                "--file_level",
-                "--output_folder",
-                "results/hwe-bench-lite/file_level",
-                "--num_threads",
-                "1",
-                "--skip_existing",
-                "--model",
-                args.model,
-                "--backend",
-                args.backend,
-                "--dataset_path",
-                dataset_path,
-            ],
-            False,
-        ),
-        (
-            "2",
-            [
-                "python",
-                "agentless/fl/localize.py",
-                "--file_level",
-                "--irrelevant",
-                "--output_folder",
-                "results/hwe-bench-lite/file_level_irrelevant",
-                "--num_threads",
-                "1",
-                "--skip_existing",
-                "--model",
-                args.model,
-                "--backend",
-                args.backend,
-                "--dataset_path",
-                dataset_path,
-            ],
-            False,
-        ),
-        (
-            "3",
-            [
-                "python",
-                "agentless/fl/retrieve.py",
-                "--index_type",
-                "simple",
-                "--filter_type",
-                "given_files",
-                "--filter_file",
-                "results/hwe-bench-lite/file_level_irrelevant/loc_outputs.jsonl",
-                "--output_folder",
-                "results/hwe-bench-lite/retrievel_embedding",
-                "--persist_dir",
-                "embedding/hwe-bench_simple",
-                "--num_threads",
-                "1",
-                "--dataset_path",
-                dataset_path,
-            ],
-            False,
-        ),
-        (
-            "4",
-            [
-                "python",
-                "agentless/fl/combine.py",
-                "--retrieval_loc_file",
-                "results/hwe-bench-lite/retrievel_embedding/retrieve_locs.jsonl",
-                "--model_loc_file",
-                "results/hwe-bench-lite/file_level/loc_outputs.jsonl",
-                "--top_n",
-                "3",
-                "--output_folder",
-                "results/hwe-bench-lite/file_level_combined",
-            ],
-            False,
-        ),
-        (
-            "5",
-            [
-                "python",
-                "agentless/fl/localize.py",
-                "--related_level",
-                "--output_folder",
-                "results/hwe-bench-lite/related_elements",
-                "--top_n",
-                "3",
-                "--compress_assign",
-                "--compress",
-                "--start_file",
-                "results/hwe-bench-lite/file_level_combined/combined_locs.jsonl",
-                "--num_threads",
-                "1",
-                "--skip_existing",
-                "--model",
-                args.model,
-                "--backend",
-                args.backend,
-                "--dataset_path",
-                dataset_path,
-            ],
-            False,
-        ),
-        (
-            "6",
-            [
-                "python",
-                "agentless/fl/localize.py",
-                "--fine_grain_line_level",
-                "--output_folder",
-                "results/hwe-bench-lite/edit_location_samples",
-                "--top_n",
-                "3",
-                "--compress",
-                "--temperature",
-                "0.8",
-                "--num_samples",
-                "4",
-                "--start_file",
-                "results/hwe-bench-lite/related_elements/loc_outputs.jsonl",
-                "--num_threads",
-                "1",
-                "--skip_existing",
-                "--model",
-                args.model,
-                "--backend",
-                args.backend,
-                "--dataset_path",
-                dataset_path,
-            ],
-            False,
-        ),
-        (
-            "7",
-            [
-                "python",
-                "agentless/fl/localize.py",
-                "--merge",
-                "--output_folder",
-                "results/hwe-bench-lite/edit_location_individual",
-                "--top_n",
-                "3",
-                "--num_samples",
-                "4",
-                "--start_file",
-                "results/hwe-bench-lite/edit_location_samples/loc_outputs.jsonl",
-                "--model",
-                args.model,
-                "--backend",
-                args.backend,
-                "--dataset_path",
-                dataset_path,
-            ],
-            False,
-        ),
-        (
-            "8",
-            [
-                "python",
-                "agentless/repair/repair.py",
-                "--loc_file",
-                "results/hwe-bench-lite/edit_location_individual/loc_merged_0-0_outputs.jsonl",
-                "--output_folder",
-                f"results/hwe-bench-lite/repair_sample_verilog/{model_dir}",
-                "--loc_interval",
-                "--top_n=3",
-                "--context_window=10",
-                "--max_samples",
-                "1",
-                "--cot",
-                "--diff_format",
-                "--gen_and_process",
-                "--num_threads",
-                "2",
-                "--model",
-                args.model,
-                "--backend",
-                args.backend,
-                "--dataset_path",
-                dataset_path,
-            ],
-            True,
-        ),
-    ]
-
-    for label, cmd, use_inactivity_timeout in steps:
-        print(label)
-        if label != "8":
-            continue
-        if label == "3":
-            run_cmd_with_retry_on_read_timeout(cmd, env, repo_root, max_retries=10)
-        elif use_inactivity_timeout:
-            while True:
-                status = run_cmd_with_inactivity_timeout(
-                    cmd, env, repo_root, timeout_seconds=600
-                )
-                if status == 124:
-                    print("Step 8 timed out after 600s of inactivity, retrying...")
-                    continue
-                if status != 0:
-                    raise SystemExit(status)
-                break
-        else:
-            run_cmd(cmd, env, repo_root)
-
-
-if __name__ == "__main__":
-    main()

Repos/HWE/agents/Agentless/run_agentless.sh

@@ -1,112 +0,0 @@
-export OPENAI_API_BASE=https://api.openai.com/v1
-export OPENAI_API_KEY=YOUR_OPENAI_API_KEY
-export TREE_SITTER_VERILOG_SO=/workspace/phoenix-bench/Agentless/my-languages.so
-export PYTHONPATH=$PYTHONPATH:$(pwd)
-AGENTLESS_MODEL="${AGENTLESS_MODEL:-gpt-5.2}"
-AGENTLESS_MODEL_DIR="${AGENTLESS_MODEL//\//__}"
-AGENTLESS_BACKEND="${AGENTLESS_BACKEND:-}"
-
-if [ -z "$AGENTLESS_BACKEND" ]; then
-  if [[ "$AGENTLESS_MODEL" == *deepseek* ]]; then
-    AGENTLESS_BACKEND="deepseek"
-  else
-    AGENTLESS_BACKEND="openai"
-  fi
-fi
-
-echo "1"
-python agentless/fl/localize.py --file_level \
-                                --output_folder results/hwe-bench-lite/file_level \
-                                --num_threads 10 \
-                                --skip_existing \
-                                --model "$AGENTLESS_MODEL" \
-                                --backend "$AGENTLESS_BACKEND" \
-				                --dataset_path /workspace/phoenix-bench/Agentless/agentless_dataset.json
-
-echo "2"
-python agentless/fl/localize.py --file_level \
-                                --irrelevant \
-                                --output_folder results/hwe-bench-lite/file_level_irrelevant \
-                                --num_threads 10 \
-                                --skip_existing \
-                                --model "$AGENTLESS_MODEL" \
-                                --backend "$AGENTLESS_BACKEND" \
-				                --dataset_path /workspace/phoenix-bench/Agentless/agentless_dataset.json
-
-echo "3"
-python agentless/fl/retrieve.py --index_type simple \
-                                --filter_type given_files \
-                                --filter_file results/hwe-bench-lite/file_level_irrelevant/loc_outputs.jsonl \
-                                --output_folder results/hwe-bench-lite/retrievel_embedding \
-                                --persist_dir embedding/hwe-bench_simple \
-                                --num_threads 10 \
-				                --dataset_path /workspace/phoenix-bench/Agentless/agentless_dataset.json
-
-echo "4"
-python agentless/fl/combine.py  --retrieval_loc_file results/hwe-bench-lite/retrievel_embedding/retrieve_locs.jsonl \
-                                --model_loc_file results/hwe-bench-lite/file_level/loc_outputs.jsonl \
-                                --top_n 3 \
-                                --output_folder results/hwe-bench-lite/file_level_combined 
-
-echo "5"
-python agentless/fl/localize.py --related_level \
-                                --output_folder results/hwe-bench-lite/related_elements \
-                                --top_n 3 \
-                                --compress_assign \
-                                --compress \
-                                --start_file results/hwe-bench-lite/file_level_combined/combined_locs.jsonl \
-                                --num_threads 10 \
-                                --skip_existing \
-                                --model "$AGENTLESS_MODEL" \
-                                --backend "$AGENTLESS_BACKEND" \
-				                --dataset_path /workspace/phoenix-bench/Agentless/agentless_dataset.json
-
-echo "6"
-python agentless/fl/localize.py --fine_grain_line_level \
-                                --output_folder results/hwe-bench-lite/edit_location_samples \
-                                --top_n 3 \
-                                --compress \
-                                --temperature 0.8 \
-                                --num_samples 4 \
-                                --start_file results/hwe-bench-lite/related_elements/loc_outputs.jsonl \
-                                --num_threads 10 \
-                                --skip_existing \
-                                --model "$AGENTLESS_MODEL" \
-                                --backend "$AGENTLESS_BACKEND" \
-				                --dataset_path /workspace/phoenix-bench/Agentless/agentless_dataset.json
-
-echo "7"
-python agentless/fl/localize.py --merge \
-                                --output_folder results/hwe-bench-lite/edit_location_individual \
-                                --top_n 3 \
-                                --num_samples 4 \
-                                --start_file results/hwe-bench-lite/edit_location_samples/loc_outputs.jsonl \
-                                --model "$AGENTLESS_MODEL" \
-                                --backend "$AGENTLESS_BACKEND" \
-				                --dataset_path /workspace/phoenix-bench/Agentless/agentless_dataset.json
-
-echo "8"
-while true; do
-  timeout 300s python agentless/repair/repair.py --loc_file results/hwe-bench-lite/edit_location_individual/loc_merged_0-0_outputs.jsonl \
-                                                --output_folder "results/hwe-bench-lite/repair_sample_verilog/${AGENTLESS_MODEL_DIR}" \
-                                                --loc_interval \
-                                                --top_n=3 \
-                                                --context_window=10 \
-                                                --max_samples 1  \
-                                                --cot \
-                                                --diff_format \
-                                                --gen_and_process \
-                                                --num_threads 2 \
-                                                --model "$AGENTLESS_MODEL" \
-                                                --backend "$AGENTLESS_BACKEND" \
-						                                --dataset_path /workspace/phoenix-bench/Agentless/agentless_dataset.json
-  status=$?
-  if [ $status -eq 124 ]; then
-    echo "Step 8 timed out after 300s, retrying..."
-    continue
-  fi
-  if [ $status -ne 0 ]; then
-    exit $status
-  fi
-  break
-done

Repos/HWE/agents/Agentless/tally_token_use.py

@@ -1,352 +0,0 @@
-#!/usr/bin/env python3
-
-from __future__ import annotations
-
-import argparse
-import json
-import sys
-from collections import defaultdict
-from dataclasses import asdict, dataclass
-from pathlib import Path
-from typing import Any, Iterable
-
-
-DEFAULT_BASE_DIR = Path(__file__).resolve().parent / "results"
-
-
-@dataclass
-class TokenUsage:
-    records: int = 0
-    usage_objects: int = 0
-    prompt_tokens: int = 0
-    completion_tokens: int = 0
-    embedding_tokens: int = 0
-    cache_creation_tokens: int = 0
-    cache_read_tokens: int = 0
-
-    @property
-    def total_text_tokens(self) -> int:
-        return self.prompt_tokens + self.completion_tokens
-
-    @property
-    def total_tokens(self) -> int:
-        return (
-            self.prompt_tokens
-            + self.completion_tokens
-            + self.embedding_tokens
-            + self.cache_creation_tokens
-            + self.cache_read_tokens
-        )
-
-    def add_usage(self, usage: dict[str, Any]) -> None:
-        self.usage_objects += 1
-        self.prompt_tokens += first_int(
-            usage, "prompt_tokens", "input_tokens"
-        )
-        self.completion_tokens += first_int(
-            usage, "completion_tokens", "output_tokens"
-        )
-        self.embedding_tokens += first_int(usage, "embedding_tokens")
-        self.cache_creation_tokens += first_int(
-            usage, "cache_creation_token", "cache_creation_input_tokens"
-        )
-        self.cache_read_tokens += first_int(
-            usage, "cache_read_input_tokens", "cache_read_tokens"
-        )
-
-    def add_row(self, row: "TokenUsage") -> None:
-        self.records += row.records
-        self.usage_objects += row.usage_objects
-        self.prompt_tokens += row.prompt_tokens
-        self.completion_tokens += row.completion_tokens
-        self.embedding_tokens += row.embedding_tokens
-        self.cache_creation_tokens += row.cache_creation_tokens
-        self.cache_read_tokens += row.cache_read_tokens
-
-
-@dataclass
-class ModelSummary:
-    runs: int = 0
-    tokens_sent: int = 0
-    tokens_received: int = 0
-    total_tokens: int = 0
-    api_calls: int = 0
-
-    def add_usage(self, usage: TokenUsage) -> None:
-        self.runs += usage.records
-        self.tokens_sent += usage.prompt_tokens
-        self.tokens_received += usage.completion_tokens
-        self.total_tokens += usage.total_text_tokens
-        self.api_calls += usage.usage_objects
-
-
-def parse_args() -> argparse.Namespace:
-    parser = argparse.ArgumentParser(
-        description=(
-            "Summarize token usage per model in Agentless JSONL outputs. By "
-            "default this scans args.json files under the repo's results/ "
-            "directory and tallies their declared output JSONL files."
-        )
-    )
-    parser.add_argument(
-        "--base-dir",
-        type=Path,
-        default=DEFAULT_BASE_DIR,
-        help="A JSONL file or directory containing Agentless result JSONL files.",
-    )
-    parser.add_argument(
-        "--format",
-        choices=("table", "json"),
-        default="table",
-        help="Output format.",
-    )
-    parser.add_argument(
-        "--include-zero-usage",
-        action="store_true",
-        help="Include models whose declared output files do not contain usage objects.",
-    )
-    return parser.parse_args()
-
-
-def first_int(mapping: dict[str, Any], *keys: str) -> int:
-    for key in keys:
-        value = mapping.get(key)
-        if value is None:
-            continue
-        try:
-            return int(value)
-        except (TypeError, ValueError):
-            continue
-    return 0
-
-
-def iter_usage_objects(value: Any) -> Iterable[dict[str, Any]]:
-    if isinstance(value, dict):
-        usage = value.get("usage")
-        if isinstance(usage, dict):
-            yield usage
-        for child in value.values():
-            yield from iter_usage_objects(child)
-    elif isinstance(value, list):
-        for child in value:
-            yield from iter_usage_objects(child)
-
-
-def iter_jsonl_files(path: Path) -> list[Path]:
-    if path.is_file():
-        if path.suffix != ".jsonl":
-            raise ValueError(f"{path} is not a .jsonl file")
-        return [path]
-    if not path.is_dir():
-        raise ValueError(f"{path} is not a file or directory")
-    return sorted(path.glob("**/*.jsonl"))
-
-
-def load_json(path: Path) -> Any:
-    with path.open(encoding="utf-8") as fh:
-        return json.load(fh)
-
-
-def format_model_name(args_data: dict[str, Any], fallback: str) -> str:
-    model = args_data.get("model")
-    backend = args_data.get("backend")
-    if isinstance(model, str) and model:
-        if isinstance(backend, str) and backend and "/" not in model:
-            return f"{backend}/{model}"
-        return model
-    return fallback
-
-
-def resolve_declared_output(args_path: Path, args_data: dict[str, Any]) -> Path | None:
-    raw_output_file = args_data.get("output_file")
-    if not isinstance(raw_output_file, str) or not raw_output_file:
-        return None
-
-    output_name = Path(raw_output_file).name
-    local_output = args_path.parent / output_name
-    if local_output.exists():
-        return local_output
-
-    raw_path = Path(raw_output_file)
-    if raw_path.is_absolute() and raw_path.exists():
-        return raw_path
-
-    repo_relative = Path(__file__).resolve().parent / raw_path
-    if repo_relative.exists():
-        return repo_relative
-
-    return None
-
-
-def infer_args_for_jsonl(path: Path) -> tuple[str, list[str]]:
-    warnings: list[str] = []
-    for parent in [path.parent, *path.parents]:
-        args_path = parent / "args.json"
-        if not args_path.exists():
-            continue
-        try:
-            args_data = load_json(args_path)
-        except (OSError, json.JSONDecodeError) as exc:
-            warnings.append(f"Ignoring unreadable args file {args_path}: {exc}")
-            continue
-        if isinstance(args_data, dict):
-            return format_model_name(args_data, path.parent.name), warnings
-    return path.parent.name, warnings
-
-
-def collect_file_usage(path: Path) -> tuple[TokenUsage, list[str]]:
-    usage = TokenUsage()
-    warnings: list[str] = []
-
-    try:
-        with path.open(encoding="utf-8") as fh:
-            for line_number, line in enumerate(fh, start=1):
-                line = line.strip()
-                if not line:
-                    continue
-                usage.records += 1
-                try:
-                    row = json.loads(line)
-                except json.JSONDecodeError as exc:
-                    warnings.append(f"Skipping malformed JSONL row {path}:{line_number}: {exc}")
-                    continue
-
-                for usage_object in iter_usage_objects(row):
-                    usage.add_usage(usage_object)
-    except OSError as exc:
-        warnings.append(f"Skipping unreadable output file {path}: {exc}")
-
-    return usage, warnings
-
-
-def collect_summary(
-    base_dir: Path, include_zero_usage: bool
-) -> tuple[dict[str, ModelSummary], list[str]]:
-    summary: dict[str, ModelSummary] = defaultdict(ModelSummary)
-    warnings: list[str] = []
-    seen_outputs: set[Path] = set()
-
-    if base_dir.is_file():
-        for path in iter_jsonl_files(base_dir):
-            model_name, model_warnings = infer_args_for_jsonl(path)
-            warnings.extend(model_warnings)
-            file_usage, file_warnings = collect_file_usage(path)
-            warnings.extend(file_warnings)
-            if file_usage.total_text_tokens or include_zero_usage:
-                summary[model_name].add_usage(file_usage)
-        return dict(summary), warnings
-
-    if not base_dir.is_dir():
-        raise ValueError(f"{base_dir} is not a file or directory")
-
-    for args_path in sorted(base_dir.glob("**/args.json")):
-        try:
-            args_data = load_json(args_path)
-        except (OSError, json.JSONDecodeError) as exc:
-            warnings.append(f"Ignoring unreadable args file {args_path}: {exc}")
-            continue
-        if not isinstance(args_data, dict):
-            warnings.append(f"Ignoring malformed args file {args_path}: top-level JSON is not an object")
-            continue
-
-        path = resolve_declared_output(args_path, args_data)
-        if path is None:
-            continue
-        path = path.resolve()
-        if path in seen_outputs:
-            continue
-        seen_outputs.add(path)
-
-        model_name = format_model_name(args_data, args_path.parent.name)
-        file_usage, file_warnings = collect_file_usage(path)
-        warnings.extend(file_warnings)
-        if file_usage.total_text_tokens or include_zero_usage:
-            summary[model_name].add_usage(file_usage)
-
-    return dict(summary), warnings
-
-
-def format_int(value: int) -> str:
-    return str(value)
-
-
-def render_table(summary: dict[str, ModelSummary]) -> str:
-    headers = [
-        "Model",
-        "Runs",
-        "Tokens Sent",
-        "Tokens Received",
-        "Total Tokens",
-        "API Calls",
-    ]
-    table_rows: list[list[str]] = []
-
-    for model_name, stats in sorted(
-        summary.items(),
-        key=lambda item: (-item[1].total_tokens, item[0]),
-    ):
-        table_rows.append(
-            [
-                model_name,
-                format_int(stats.runs),
-                format_int(stats.tokens_sent),
-                format_int(stats.tokens_received),
-                format_int(stats.total_tokens),
-                format_int(stats.api_calls),
-            ]
-        )
-
-    widths = [len(header) for header in headers]
-    for row in table_rows:
-        for index, value in enumerate(row):
-            widths[index] = max(widths[index], len(value))
-
-    def format_row(row: list[str]) -> str:
-        return "  ".join(value.ljust(widths[index]) for index, value in enumerate(row))
-
-    lines = [format_row(headers), format_row(["-" * width for width in widths])]
-    if table_rows:
-        lines.extend(format_row(row) for row in table_rows)
-    else:
-        lines.append("No token usage records found.")
-
-    return "\n".join(lines)
-
-
-def render_json(summary: dict[str, ModelSummary], base_dir: Path) -> str:
-    return json.dumps(
-        {
-            "base_dir": str(base_dir),
-            "models": {
-                model_name: asdict(stats)
-                for model_name, stats in sorted(summary.items())
-            },
-        },
-        indent=2,
-        sort_keys=True,
-    )
-
-
-def main() -> int:
-    args = parse_args()
-    base_dir = args.base_dir.resolve()
-
-    try:
-        summary, warnings = collect_summary(base_dir, args.include_zero_usage)
-    except ValueError as exc:
-        print(f"Error: {exc}", file=sys.stderr)
-        return 2
-
-    if args.format == "json":
-        print(render_json(summary, base_dir))
-    else:
-        print(render_table(summary))
-
-    for warning in warnings:
-        print(f"Warning: {warning}", file=sys.stderr)
-
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

Repos/HWE/agents/Agentless/test_agentless/apfaudio_eurorack-pmod_pr36/.gitattributes

@@ -1 +0,0 @@
-hardware/fab/* linguist-vendored

Repos/HWE/agents/Agentless/test_agentless/apfaudio_eurorack-pmod_pr36/.gitignore

@@ -1,28 +0,0 @@
-# For PCBs designed using KiCad: https://www.kicad.org/
-# Format documentation: https://kicad.org/help/file-formats/
-
-# Temporary files
-*.000
-*.bak
-*.bck
-*.kicad_pcb-bak
-*.kicad_sch-bak
-*-backups
-*.kicad_prl
-*.sch-bak
-*~
-_autosave-*
-*.tmp
-*-save.pro
-*-save.kicad_pcb
-fp-info-cache
-
-# Netlist files (exported from Eeschema)
-*.net
-
-# Autorouter files (exported from Pcbnew)
-*.dsn
-*.ses
-
-# Exported BOM files
-*.xml

Repos/HWE/agents/Agentless/test_agentless/apfaudio_eurorack-pmod_pr36/.gitmodules

@@ -1,6 +0,0 @@
-[submodule "hardware/libs/AudioJacks"]
-	path = hardware/libs/AudioJacks
-	url = https://github.com/clacktronics/AudioJacks
-[submodule "gateware/external/no2misc"]
-	path = gateware/external/no2misc
-	url = https://github.com/no2fpga/no2misc

Repos/HWE/agents/Agentless/test_agentless/apfaudio_eurorack-pmod_pr36/LICENSE

@@ -1,289 +0,0 @@
-CERN Open Hardware Licence Version 2 - Strongly Reciprocal
-
-
-Preamble
-
-CERN has developed this licence to promote collaboration among
-hardware designers and to provide a legal tool which supports the
-freedom to use, study, modify, share and distribute hardware designs
-and products based on those designs. Version 2 of the CERN Open
-Hardware Licence comes in three variants: CERN-OHL-P (permissive); and
-two reciprocal licences: CERN-OHL-W (weakly reciprocal) and this
-licence, CERN-OHL-S (strongly reciprocal).
-
-The CERN-OHL-S is copyright CERN 2020. Anyone is welcome to use it, in
-unmodified form only.
-
-Use of this Licence does not imply any endorsement by CERN of any
-Licensor or their designs nor does it imply any involvement by CERN in
-their development.
-
-
-1 Definitions
-
-  1.1 'Licence' means this CERN-OHL-S.
-
-  1.2 'Compatible Licence' means
-
-       a) any earlier version of the CERN Open Hardware licence, or
-
-       b) any version of the CERN-OHL-S, or
-
-       c) any licence which permits You to treat the Source to which
-          it applies as licensed under CERN-OHL-S provided that on
-          Conveyance of any such Source, or any associated Product You
-          treat the Source in question as being licensed under
-          CERN-OHL-S.
-
-  1.3 'Source' means information such as design materials or digital
-      code which can be applied to Make or test a Product or to
-      prepare a Product for use, Conveyance or sale, regardless of its
-      medium or how it is expressed. It may include Notices.
-
-  1.4 'Covered Source' means Source that is explicitly made available
-      under this Licence.
-
-  1.5 'Product' means any device, component, work or physical object,
-      whether in finished or intermediate form, arising from the use,
-      application or processing of Covered Source.
-
-  1.6 'Make' means to create or configure something, whether by
-      manufacture, assembly, compiling, loading or applying Covered
-      Source or another Product or otherwise.
-
-  1.7 'Available Component' means any part, sub-assembly, library or
-      code which:
-
-       a) is licensed to You as Complete Source under a Compatible
-          Licence; or
-
-       b) is available, at the time a Product or the Source containing
-          it is first Conveyed, to You and any other prospective
-          licensees
-
-            i) as a physical part with sufficient rights and
-               information (including any configuration and
-               programming files and information about its
-               characteristics and interfaces) to enable it either to
-               be Made itself, or to be sourced and used to Make the
-               Product; or
-           ii) as part of the normal distribution of a tool used to
-               design or Make the Product.
-
-  1.8 'Complete Source' means the set of all Source necessary to Make
-      a Product, in the preferred form for making modifications,
-      including necessary installation and interfacing information
-      both for the Product, and for any included Available Components.
-      If the format is proprietary, it must also be made available in
-      a format (if the proprietary tool can create it) which is
-      viewable with a tool available to potential licensees and
-      licensed under a licence approved by the Free Software
-      Foundation or the Open Source Initiative. Complete Source need
-      not include the Source of any Available Component, provided that
-      You include in the Complete Source sufficient information to
-      enable a recipient to Make or source and use the Available
-      Component to Make the Product.
-
-  1.9 'Source Location' means a location where a Licensor has placed
-      Covered Source, and which that Licensor reasonably believes will
-      remain easily accessible for at least three years for anyone to
-      obtain a digital copy.
-
- 1.10 'Notice' means copyright, acknowledgement and trademark notices,
-      Source Location references, modification notices (subsection
-      3.3(b)) and all notices that refer to this Licence and to the
-      disclaimer of warranties that are included in the Covered
-      Source.
-
- 1.11 'Licensee' or 'You' means any person exercising rights under
-      this Licence.
-
- 1.12 'Licensor' means a natural or legal person who creates or
-      modifies Covered Source. A person may be a Licensee and a
-      Licensor at the same time.
-
- 1.13 'Convey' means to communicate to the public or distribute.
-
-
-2 Applicability
-
-  2.1 This Licence governs the use, copying, modification, Conveying
-      of Covered Source and Products, and the Making of Products. By
-      exercising any right granted under this Licence, You irrevocably
-      accept these terms and conditions.
-
-  2.2 This Licence is granted by the Licensor directly to You, and
-      shall apply worldwide and without limitation in time.
-
-  2.3 You shall not attempt to restrict by contract or otherwise the
-      rights granted under this Licence to other Licensees.
-
-  2.4 This Licence is not intended to restrict fair use, fair dealing,
-      or any other similar right.
-
-
-3 Copying, Modifying and Conveying Covered Source
-
-  3.1 You may copy and Convey verbatim copies of Covered Source, in
-      any medium, provided You retain all Notices.
-
-  3.2 You may modify Covered Source, other than Notices, provided that
-      You irrevocably undertake to make that modified Covered Source
-      available from a Source Location should You Convey a Product in
-      circumstances where the recipient does not otherwise receive a
-      copy of the modified Covered Source. In each case subsection 3.3
-      shall apply.
-
-      You may only delete Notices if they are no longer applicable to
-      the corresponding Covered Source as modified by You and You may
-      add additional Notices applicable to Your modifications.
-      Including Covered Source in a larger work is modifying the
-      Covered Source, and the larger work becomes modified Covered
-      Source.
-
-  3.3 You may Convey modified Covered Source (with the effect that You
-      shall also become a Licensor) provided that You:
-
-       a) retain Notices as required in subsection 3.2;
-
-       b) add a Notice to the modified Covered Source stating that You
-          have modified it, with the date and brief description of how
-          You have modified it;
-
-       c) add a Source Location Notice for the modified Covered Source
-          if You Convey in circumstances where the recipient does not
-          otherwise receive a copy of the modified Covered Source; and
-
-       d) license the modified Covered Source under the terms and
-          conditions of this Licence (or, as set out in subsection
-          8.3, a later version, if permitted by the licence of the
-          original Covered Source). Such modified Covered Source must
-          be licensed as a whole, but excluding Available Components
-          contained in it, which remain licensed under their own
-          applicable licences.
-
-
-4 Making and Conveying Products
-
-You may Make Products, and/or Convey them, provided that You either
-provide each recipient with a copy of the Complete Source or ensure
-that each recipient is notified of the Source Location of the Complete
-Source. That Complete Source is Covered Source, and You must
-accordingly satisfy Your obligations set out in subsection 3.3. If
-specified in a Notice, the Product must visibly and securely display
-the Source Location on it or its packaging or documentation in the
-manner specified in that Notice.
-
-
-5 Research and Development
-
-You may Convey Covered Source, modified Covered Source or Products to
-a legal entity carrying out development, testing or quality assurance
-work on Your behalf provided that the work is performed on terms which
-prevent the entity from both using the Source or Products for its own
-internal purposes and Conveying the Source or Products or any
-modifications to them to any person other than You. Any modifications
-made by the entity shall be deemed to be made by You pursuant to
-subsection 3.2.
-
-
-6 DISCLAIMER AND LIABILITY
-
-  6.1 DISCLAIMER OF WARRANTY -- The Covered Source and any Products
-      are provided 'as is' and any express or implied warranties,
-      including, but not limited to, implied warranties of
-      merchantability, of satisfactory quality, non-infringement of
-      third party rights, and fitness for a particular purpose or use
-      are disclaimed in respect of any Source or Product to the
-      maximum extent permitted by law. The Licensor makes no
-      representation that any Source or Product does not or will not
-      infringe any patent, copyright, trade secret or other
-      proprietary right. The entire risk as to the use, quality, and
-      performance of any Source or Product shall be with You and not
-      the Licensor. This disclaimer of warranty is an essential part
-      of this Licence and a condition for the grant of any rights
-      granted under this Licence.
-
-  6.2 EXCLUSION AND LIMITATION OF LIABILITY -- The Licensor shall, to
-      the maximum extent permitted by law, have no liability for
-      direct, indirect, special, incidental, consequential, exemplary,
-      punitive or other damages of any character including, without
-      limitation, procurement of substitute goods or services, loss of
-      use, data or profits, or business interruption, however caused
-      and on any theory of contract, warranty, tort (including
-      negligence), product liability or otherwise, arising in any way
-      in relation to the Covered Source, modified Covered Source
-      and/or the Making or Conveyance of a Product, even if advised of
-      the possibility of such damages, and You shall hold the
-      Licensor(s) free and harmless from any liability, costs,
-      damages, fees and expenses, including claims by third parties,
-      in relation to such use.
-
-
-7 Patents
-
-  7.1 Subject to the terms and conditions of this Licence, each
-      Licensor hereby grants to You a perpetual, worldwide,
-      non-exclusive, no-charge, royalty-free, irrevocable (except as
-      stated in subsections 7.2 and 8.4) patent licence to Make, have
-      Made, use, offer to sell, sell, import, and otherwise transfer
-      the Covered Source and Products, where such licence applies only
-      to those patent claims licensable by such Licensor that are
-      necessarily infringed by exercising rights under the Covered
-      Source as Conveyed by that Licensor.
-
-  7.2 If You institute patent litigation against any entity (including
-      a cross-claim or counterclaim in a lawsuit) alleging that the
-      Covered Source or a Product constitutes direct or contributory
-      patent infringement, or You seek any declaration that a patent
-      licensed to You under this Licence is invalid or unenforceable
-      then any rights granted to You under this Licence shall
-      terminate as of the date such process is initiated.
-
-
-8 General
-
-  8.1 If any provisions of this Licence are or subsequently become
-      invalid or unenforceable for any reason, the remaining
-      provisions shall remain effective.
-
-  8.2 You shall not use any of the name (including acronyms and
-      abbreviations), image, or logo by which the Licensor or CERN is
-      known, except where needed to comply with section 3, or where
-      the use is otherwise allowed by law. Any such permitted use
-      shall be factual and shall not be made so as to suggest any kind
-      of endorsement or implication of involvement by the Licensor or
-      its personnel.
-
-  8.3 CERN may publish updated versions and variants of this Licence
-      which it considers to be in the spirit of this version, but may
-      differ in detail to address new problems or concerns. New
-      versions will be published with a unique version number and a
-      variant identifier specifying the variant. If the Licensor has
-      specified that a given variant applies to the Covered Source
-      without specifying a version, You may treat that Covered Source
-      as being released under any version of the CERN-OHL with that
-      variant. If no variant is specified, the Covered Source shall be
-      treated as being released under CERN-OHL-S. The Licensor may
-      also specify that the Covered Source is subject to a specific
-      version of the CERN-OHL or any later version in which case You
-      may apply this or any later version of CERN-OHL with the same
-      variant identifier published by CERN.
-
-  8.4 This Licence shall terminate with immediate effect if You fail
-      to comply with any of its terms and conditions.
-
-  8.5 However, if You cease all breaches of this Licence, then Your
-      Licence from any Licensor is reinstated unless such Licensor has
-      terminated this Licence by giving You, while You remain in
-      breach, a notice specifying the breach and requiring You to cure
-      it within 30 days, and You have failed to come into compliance
-      in all material respects by the end of the 30 day period. Should
-      You repeat the breach after receipt of a cure notice and
-      subsequent reinstatement, this Licence will terminate
-      immediately and permanently. Section 6 shall continue to apply
-      after any termination.
-
-  8.6 This Licence shall not be enforceable except by a Licensor
-      acting as such, and third party beneficiary rights are
-      specifically excluded.

Repos/HWE/agents/Agentless/test_agentless/apfaudio_eurorack-pmod_pr36/README.md

@@ -1,135 +0,0 @@
-# Eurorack PMOD
-
-**Assembled boards now available!** [get one **here :)**](https://lectronz.com/stores/apfelaudio)
-
-**Eurorack PMOD** makes it easy for you to combine the world of FPGAs and [hardware electronic music synthesis](https://en.wikipedia.org/wiki/Eurorack). It is an expansion board for FPGA development boards that allows them to interface with a Eurorack hardware synthesizer. This board exposes 8 (4 in + 4 out) DC-coupled audio channels, 192KHz / 32bit sampling supported, at a -8V to +8V swing, amongst many more features. R3.1 hardware looks like this:
-
-![assembled eurorack-pmod module R3.0 (panel)](docs/img/panel.jpg)
-![assembled eurorack-pmod module R3.0 (top)](docs/img/pmod_top.jpg)
-
-
-![ci workflow](https://github.com/schnommus/eurorack-pmod/actions/workflows/main.yml/badge.svg)
-
-
-For a high-level overview on R2.2 hardware, **see [my FOSDEM '23 talk](https://youtu.be/Wbd-OfCWvKU)** on this project. Production hardware is named R3+ and has a few improvements (LEDs fully programmable, jack detection, calibration EEPROM).
-
-[Want one?](#manufacturing). More photos can be found [below](#photos). 
-
-### This project is:
-- The design for a Eurorack-compatible PCB and front-panel, including a [PMOD](https://en.wikipedia.org/wiki/Pmod_Interface) connector (compatible with most FPGA dev boards). PCB designed in [KiCAD](https://www.kicad.org/). Design is [certified open hardware](https://certification.oshwa.org/de000135.html).
-- Various [example cores](gateware/cores) (and calibration / driver cores for the audio CODEC) initially targeting an [iCEBreaker FPGA](https://1bitsquared.com/products/icebreaker) (iCE40 part) but many more boards are supported (see below). Examples include calibration, sampling, effects, synthesis sources and so on. The design files can be synthesized to a bitstream using Yosys' [oss-cad-suite](https://github.com/YosysHQ/oss-cad-suite-build).
-- A [VCV Rack plugin](https://github.com/schnommus/verilog-vcvrack) so you can simulate your Verilog designs in a completely virtual modular system, no hardware required.
-
-## Included examples
-This repository contains a bunch of example DSP cores which are continuously being updated:
-- Bitcrusher
-- Filter (high pass / low pass / band pass)
-- Clock divider
-- .wav sampler
-- Pitch shifter
-- Sequential routing switch
-- Echo/delay effect
-- VCA (voltage controlled amplifier)
-- VCO (voltage controlled oscillator)
-
-These examples can all run out of the box on the development boards listed below.
-
-## Choosing an FPGA development board
-An FPGA development board itself is NOT included! Essentially anything iCE40 or ECP5 based that has a PMOD connector will support the open-source tools and the examples in this project. Just make sure you have enough LUTS, >3K is enough to do interesting things.
-
-The following development boards have been tested with `eurorack-pmod` and are supported by the examples in the github repository
-- iCEbreaker (iCE40 based)
-- ECPIX-5 (ECP5 based)
-- Colorlight i5 (ECP5 based)
-- Colorlight i9 (ECP5 based)
-- pico-ice from TinyVision (iCE40 based)
-
-## Hardware details
-
-![labelled eurorack-pmod 3.0](docs/img/labelled.jpg)
-
-- 3HP module compatible with modular synthesizer systems.
-    - Module depth is 47mm with both ribbon cables attached
-    - This fits nicely in e.g. a 4MS POD 48X (pictured below).
-- PMOD connector compatible with most FPGA development boards.
-- 8 (4 in + 4 out) DC-coupled audio channels, 192KHz / 32bit sampling supported.
-- PWM-controlled, user-programmable red/green LEDs on each output channel.
-- Jack insertion detection on input & output jacks.
-- Calibration EEPROM for unique ID and storing calibration data.
-- I/O is about +/- 8V capable, wider is possible with a resistor change.
-
-## PMOD Pinout
-
-The PMOD pinout is on the silkscreen on the back side of the board. Details are below. Note that Pin 1 is the SQUARE pad.
-
-1) SDI (AK4619VN SDIN1)
-2) SCL (I2C SCL for AK4619VN CODEC, EEPROM, LED + JACK IO expanders)
-3) SDO (AK4619VN SDOUT1)
-4) SDA (I2C SDA)
-5) LRCK (CODEC clock line)
-6) PDN (CODEC power down, also connected to LED output enable and JACK reset line -- HIGH means everything is on)
-7) BICK (CODEC clock line)
-8) MCLK (CODEC clock line)
-9) GND
-10) GND
-11) 3V3 IN
-12) 3V3 IN
-
-## Gateware details
-- Examples based on iCE40 and ECP5 based FPGAs supported by open-source tools.
-- User-defined DSP logic is decoupled from rest of system (see [`gateware/cores`](gateware/cores) directory)
-
-## Getting Started
-
-For now, I have tested builds on Linux and Windows (under MSYS2). Both are tested in CI.
-
-0. Install the [OSS FPGA CAD flow](https://github.com/yosyshq/oss-cad-suite-build).
-    - You may be able to get yosys / verilator from other package managers but I recommend using the [releases from YosysHQ](https://github.com/yosyshq/oss-cad-suite-build) so you're using the same binaries that CI is using.
-    - On Linux, once the YosysHQ suite is installed and in PATH, you should be able to just use `make` in the gateware directory.
-    - On Windows, CI is using MSYS2 with MINGW64 shell. Install MSYS2, MINGW64, extract the oss-cad-suite from YosysHQ and add it to PATH. Then you should be able to use `make` in the gateware directory.
-    - Note: The gateware is automatically built and tested in CI, so for either platform it may be helpful to look at [`.github/workflows/main.yml`](.github/workflows/main.yml).
-
-1. Build or obtain `eurorack-pmod` hardware and connect it to your FPGA development board using a ribbon cable or similar. (Double check that the pin mappings are correct, some ribbon cables will swap them on you! Default pinmaps are for the ribbon cables I shipped with hardware, you need to flip the pinmaps for a direct connection PMOD -> FPGA)
-2. Try some of the examples. From the `gateware` directory, type `make` to see valid commands. By default if you do not select a CORE it will compile a bitstream with the 'mirror' core, which just sends inputs to outputs.
-2. Calibrate your hardware using the process described in [`gateware/cal/cal.py`](gateware/cal/cal.py). Use this to create your own `gateware/cal/cal_mem.hex` to compensate for any DC biases in the ADCs/DACs. (this step is only necessary if you need sub-50mV accuracy on your inputs/outputs, which is the case if you are tuning oscillators, not so much if you are creating rhythm pulses.
-
-# Project structure
-The project is split into 2 directories, [`hardware`](hardware) for the PCB/panel and [`gateware`](gateware) for the FPGA source. Some interesting directories:
-- [`gateware/cores`](gateware/cores): example user core implementations (i.e sequential switch, bitcrusher, filter, vco, vca, sampler etc).
-- [`gateware/top.sv`](gateware/top.sv): top-level gateware with defines for selecting features.
-- [`gateware/cal/cal.py`](gateware/cal/cal.py): tool used to calibrate the hardware after assembly, generating calibration memory.
-- [`gateware/drivers`](gateware/drivers): driver for CODEC and I2C devices used on this board.
-- [`hardware/eurorack-pmod-r3`](hardware/eurorack-pmod-r3): KiCAD design files for PCB and front panel.
-- [`hardware/fab`](hardware/fab): gerber files and BOM for manufacturing the hardware.
-
-# Manufacturing
-
-**Assembled boards now available!** [get one **here :)**](https://lectronz.com/stores/apfelaudio)
-
-Update: R3.1 (first production release) is fully functional with 1 rework, see github issues for up-to-date information.
-
-Note: I gave some R3.0 (preproduction) units out at Hackaday Berlin '23. These are tested but NOT calibrated. They had 2 hacks applied. Some inductors are shorted with 0 ohm resistors as the wrong inductor was populated (means the board is a bit noiser than it should be - but still definitely useable). Also the reset line of the jack detect IO expander was routed incorrectly, so I manually shorted 2 pins of that chip. Functionally these boards are the same as R3.1, which fixes these issues.
-
-
-## Known limitations
-- Moved to github issues
-
-# Photos
-
-## Assembled `eurorack-pmod` (front)
-![assembled eurorack-pmod module (front)](docs/img/leds_front.jpg)
-
-## `eurorack-pmod` connected to iCEBreaker
-![assembled eurorack-pmod module (in system)](docs/img/pmod_insystem.jpg)
-
-# License
-
-[![OSHW logo](docs/img/oshw.svg)](https://certification.oshwa.org/de000135.html)
-
-Hardware and gateware are released under the CERN Open-Hardware License V2 `CERN-OHL-S`, mirrored in the LICENSE text in this repository.
-
-If you wish to license parts of this design in a commercial product without a reciprocal open-source license, or you have a ground-breaking idea for a module we could work on together, feel free to contact me directly. See sebholzapfel.com.
-
-*Copyright (C) 2022,2023 Sebastian Holzapfel*
-
-The above LICENSE and copyright notice does NOT apply to imported artifacts in this repository (i.e datasheets, third-party footprints).