# Fix "'DataFrame' object has no attribute 'append'" in pandas 2

Yes. An agent replaces each DataFrame.append call pandas 2 removed, building frames once instead of row by row, compares the output, and opens a pull request.

[Run this on Rush](https://cloud.getrush.ai/run/fix-dataframe-append-attribute-error/pandas/). Opens the console with this prompt ready to send, in a Project that has your repository.

## What the agent does

The agent begins with the pin, because a project that pins an old pandas should not be seeing a pandas 2 error. In a project like bahadiraraz/GitHub-Stalker, `requirements.txt` says `pandas==1.3.5`. That release has wheels for CPython 3.7 through 3.10 only, so on Python 3.11 the pin cannot be installed without compiling pandas. On Python 3.9 it installs and still does not import: the resolver pairs it with NumPy 2, and `import pandas` raises `ValueError: numpy.dtype size changed, may indicate binary incompatibility`. Either way the person setting the project up ends on a current pandas, where the first frame the program builds fails with `'DataFrame' object has no attribute 'append'`.

Then it reads every call and what surrounds it. `main/main.py` has seven, on lines 73, 88, 103, 122, 142, 214 and 235, all of the form `df = df.append({...}, ignore_index=True)`. One appends a single row. The other six sit inside loops over GitHub API results (followers, following, forks, and stargazers three times), each starting from `pd.DataFrame(columns=[...])` and growing one row per item. The mechanical replacement is `pd.concat([df, pd.DataFrame([row])], ignore_index=True)` on the same line. The agent does not use it in the loops, because it keeps the cost that made pandas remove `append`: every iteration copies the whole frame.

For the six loops it collects the rows in a list and builds the frame once after the loop with `pd.DataFrame(rows, columns=[...])`. That changes one thing a reader would not guess, and the agent measures it. Growing an empty frame row by row leaves the `id` column with dtype `object`; building it from a list of dicts gives `int64`. This matters here because `compare_csv` puts the fresh frame next to one loaded with `pd.read_csv`, where `id` is `int64`, and decides whether anything changed using `equals` and then `pd.concat(...).drop_duplicates(keep=False)`.

So it runs that comparison for the old code on pandas 1.3.5 with NumPy 1.26, and for both replacements on current pandas, against the same sample rows and the same CSV text. The project's own tests cannot do this job: `tests/test_main.py` has six tests and each one calls the live GitHub API with a token read from an `.env` file. The agent stands in a stub for `github_api` that returns objects with `id` and `login`, and says in the pull request that this is what it did.

## Start it with one API call

`POST https://api.phoenix.so/o/{org}/sessions`

```json
{
  "agent": "claude",
  "input": "This project fails with: AttributeError: 'DataFrame' object has no attribute 'append'. Fix it for pandas 2 and later. Read the dependency files; say which pandas is pinned, which Python versions that pin has wheels for, and what a fresh install on a current Python resolves. If the pin installs but does not import, quote the error. List every DataFrame.append and Series.append call with file and line, and for each say whether it runs once or inside a loop and what the frame it appends to started as. Replace a single append with pd.concat. Replace append inside a loop by collecting rows in a list and building the frame once after the loop; do not put pd.concat inside the loop. Keep the column order and the ignore_index behaviour. Then check for differences the rewrite can introduce: print the dtypes of each frame from the old code on the pinned pandas and from the new code on current pandas, including the case where the loop runs zero times, and run any code that compares, merges or writes these frames on both. If the tests need network access or credentials, do not use real credentials: stub the API client with objects that have the attributes the code reads, and say so. Update the pandas requirement to a range you ran. Open a pull request with the dtype table and the comparison output for old and new.",
  "resources": [
    {
      "url": "https://github.com/your-org/your-app"
    }
  ]
}
```

1. **Get an API key.** In the console, open Settings, then API keys, and create a key for your org. Send it in the Authorization header as a Bearer token.
2. **Send the request.** POST the body in request.json to https://api.phoenix.so/o/{org}/sessions, with your repository as the resources URL. The run starts in its own cloud sandbox.
3. **Read what came back.** Follow the run on its live stream or wait for the run.completed webhook, then read the result and its trajectory.

## What comes back

A pull request that rewrites seven call sites in `main/main.py` and the pandas line in `requirements.txt`. The description has a table with one row per function: where the append was, whether it was in a loop, and what replaced it. Under it is the dtype comparison. For the follower frame it reads `id: object` before and `id: int64` after, with the name column `object` on old pandas and `str` on pandas 3, which infers a string dtype by default.

It reports the comparison honestly, including the part that is not about this change. In the sample check `equals` returns false for the old code and for both replacements, on both pandas versions, and the `drop_duplicates` test that follows reports no change in every case. So the function's answer does not move, and the description points out that it was already resting on its second test before this pull request.

A reviewer checks the zero-row case, which the description calls out: a frame built from an empty list has `object` columns, as it did before. They also run the tool once with a real token, since that path is stubbed. The description lists the stubbed methods so that run can be short.

## Run it on every scheduled job that fails with this AttributeError

Code like this often lives in scheduled scripts: a report, an export, a scraper that runs from cron or a workflow. It breaks the first time its environment is rebuilt, and nobody is watching. Add an automation with a `webhook` trigger and the prompt above to the Project that holds the repository. In the job's wrapper, when the command exits non-zero and the log contains `has no attribute 'append'`, `POST` the traceback to the trigger's URL with `Authorization: Bearer` and the trigger's secret. The traceback is placed after the saved prompt, so the agent knows which call ran first.

A job that fails every night would otherwise start a run every night. Send an `Idempotency-Key` header to the trigger's URL made from the repository name and the pandas version in the log, so repeated failures of the same job answer `deduped` and start nothing new.

## Why run it on Rush?

Search results for this error give one line to paste, and that line is `pd.concat` in place of `append`. Pasted into a loop it restores the program and keeps it slow, and it leaves the question nobody asks: is the frame I build now the same frame as before? Answering that takes the old pandas and the new one installed side by side, which on a current laptop means first getting a 2021 pandas to import at all. The run sets up both in its own sandbox and keeps the commands and their output in the session transcript.

The agent also reads past the failing line to where the frame is used. A dtype that moves from `object` to `int64` is harmless in a printout and decisive in an `equals` check, a merge key or a CSV round trip. The pull request shows the consumers it ran, so the reviewer is approving a measured change and not a pattern.

## Frequently asked questions

### What is the direct replacement for DataFrame.append?

`pd.concat([df, other], ignore_index=True)`, where `other` is a DataFrame. To add one dict as a row, wrap it first: `pd.DataFrame([row])`. pandas deprecated `append` in 1.4 and removed it in 2.0, for both `DataFrame` and `Series`.

### Why not call pd.concat inside the loop?

It works, and it copies every existing row on each pass, exactly as `append` did. With a few dozen rows nobody notices. With tens of thousands the loop dominates the run time. Collecting dicts in a list and building the frame once does the copying a single time.

### Can I pin pandas below 2 instead?

Only on interpreters that still have wheels for the release you pin, and you then need to hold NumPy below 2 as well, because old pandas builds do not load against it. The agent treats that as a stopgap. It fixes the calls and sets the requirement to a range it ran.

### Does list.append need changing too?

No. Python lists keep `append`, and so does `HDFStore`. The agent decides by reading what the object is, not by matching the text `.append(`, and the table in the pull request lists only the calls on a DataFrame or Series.

### Will the agent use my API token to test?

Not unless you hand it one. The request names no connections, and the prompt tells the agent to stub the API client instead of using credentials. A secret saved on a Project reaches every session in that Project as an environment variable, so keep a production token out of the Project you run this in.

## More pandas jobs

- [Fix "AttributeError: 'DataFrame' object has no attribute 'applymap'" in pandas 3](https://getrush.ai/run/fix-dataframe-applymap-attribute-error/pandas/)
- [Fix "'DataFrame' object has no attribute 'as_matrix'" after upgrading pandas](https://getrush.ai/run/fix-dataframe-as-matrix-attribute-error/pandas/)
- [Fix "AttributeError: 'DataFrame' object has no attribute 'iteritems'" in pandas 2](https://getrush.ai/run/fix-dataframe-iteritems-attribute-error/pandas/)

## More jobs like this: Fix a bug from an alert

- [Fix "AttributeError: 'DataFrame' object has no attribute 'ix'" in an Old pandas Script](https://getrush.ai/run/fix-dataframe-ix-attribute-error/pandas/)
- [Fix "The repository 'http://deb.debian.org/debian buster Release' does not have a Release file" in a Docker build](https://getrush.ai/run/fix-debian-buster-release-file-missing/docker/)
- [Fix "MovedIn20Warning: The declarative_base() function is now available as sqlalchemy.orm.declarative_base()"](https://getrush.ai/run/fix-declarative-base-movedin20warning/sqlalchemy/)

## Keep reading

- [How a Rush run works on your repository, from request to pull request](https://getrush.ai/cloud/)
- [Compare cloud agents, agent sandboxes and AI code review](https://getrush.ai/compare/)
- [Rush pricing: Free, Pro and Max](https://getrush.ai/pricing/)
