An identifier is a label, even when it looks like a number. When importing it with pandas read_csv, set the identifier column's dtype before inference, and explicitly define which strings count as missing. String dtype alone does not preserve literal NA, NULL, or an empty field under the default missing-value policy.

For a developer moving customer or order IDs through an agent-generated export, the acceptance test is simple: compare the decoded identifier strings, row count and row order against the source, then repeat the check after export and re-import. A successful command or a plausible-looking table is not that proof.

In Aident's October 1, 2026 synthetic test, this import policy preserved every identifier with both the C and Python parsers:

frame = pd.read_csv(
    io.StringIO(text),
    engine="c",
    dtype={"record_id": "string"},
    keep_default_na=False,
    na_values={"amount": [""]},
)

Here, an empty record_id is deliberately a literal string, while an empty amount is missing. That is an example contract, not a recommendation to permit blank customer IDs. If your business contract forbids blank IDs, preserve the input first and reject blanks explicitly.

What the two fixtures showed

We ran Python 3.13.14 and pandas 2.2.3 through Aident Loadout's Code Interpreter, using tiny in-memory CSVs and no customer data. Each policy ran with both engine="c" and engine="python". Both engines produced the same counts below.

The numeric fixture contained 00123, 123, 9007199254740992, 9007199254740993, and an empty identifier. The token fixture contained NA, NULL, N/A, nan, an empty identifier, 00123, and 00123 with surrounding spaces.

“Exact” requires an actual string equal to the decoded source field, not numeric equivalence or display formatting. Late casting happened to recreate the literal nan token in one row, but lost the other values. One coincidental match does not make the transformation reversible.

The default numeric import collapsed 00123 and 123 to the same 123.0, and the two adjacent large IDs to the same 9007199254740992.0. These are observations from the tested fixture and runtime, not a claim that every CSV is inferred as floating point.

Run the same check through an agent

If you are evaluating an agent's CSV transformation, inspect the Code Interpreter runtime and run the complete harmless fixture below before using real exports. Record the returned pandas version and both engines' results. Aident's test completed all 20 fixture-policy runs, four export/re-import checks and 15 explicit rejection controls with empty error and stderr output.

If Aident is not installed, give your agent the installation instruction Follow https://aident.ai/SETUP.md. Then ask it:

Run the complete synthetic identifier fixture through Code Interpreter. Do not upload production data or change the environment. Return the Python and pandas versions, policy results, round-trip checks and rejected controls. If a dependency is missing or a check fails, stop and report it rather than claiming preservation.

This continues the same acceptance-test job. It is not permission to connect or write to your CRM, and a catalog visit is not proof of registration, integration connection or successful execution.

Why the obvious fixes are incomplete

The read_csv dtype and missing-value contract separates the requested type from the strings interpreted as missing. Its current documentation says to combine string or object dtype with suitable NA settings when values must not be interpreted.

• Casting after import is too late. Once an ID has been converted or rounded, its original leading zeros or digits are no longer in the parsed value. You need the source to reconstruct them.

• Quotes describe CSV syntax, not a pandas type declaration. Quoting every field did not prevent inference in our test.

• String dtype does not disable missing-value recognition. In the token fixture it preserved the two nonmissing identifiers but converted the other five to missing values.

• Disabling default NA tokens changes more than the ID column. Our policy adds back the empty-string missing marker for amount only. Declare other columns' missing markers separately.

Do not blindly use keep_default_na=False across an existing pipeline without reviewing every column. An amount recorded as NA might need to fail validation, become missing, or remain text under a different schema. This example tests identifier fidelity and a small amount policy, not your full data model.

A complete runnable acceptance test

Prerequisites: Python with pandas installed. No filesystem input, networking or database write is required. The Python csv parser supplies the decoded-string reference using the same explicit comma-separated fixture dialect.

The reference reader rejects unexpected or duplicate columns and malformed row widths. The comparison checks exact identifier strings, count and order. It does not enforce business uniqueness: 00123 and 123 are distinct labels here. Add required/nonblank/unique constraints separately.

import csv
import io
import json
import platform

import pandas as pd


def make_csv(ids, quoting=csv.QUOTE_MINIMAL):
    stream = io.StringIO(newline="")
    writer = csv.writer(stream, quoting=quoting, lineterminator="\n")
    writer.writerow(["record_id", "amount"])
    for index, value in enumerate(ids):
        writer.writerow([value, "" if index == 0 else "12.50"])
    return stream.getvalue()


def reference_ids(text):
    reader = csv.DictReader(io.StringIO(text, newline=""))
    if reader.fieldnames != ["record_id", "amount"]:
        raise ValueError("Unexpected or duplicate columns")
    rows = list(reader)
    if any(None in row or any(value is None for value in row.values()) for row in rows):
        raise ValueError("Unexpected row width")
    return [row["record_id"] for row in rows]


def assert_ids(frame, expected):
    actual = frame["record_id"].tolist()
    if len(actual) != len(expected) or any(
        not isinstance(value, str) or value != wanted
        for value, wanted in zip(actual, expected)
    ):
        raise ValueError("Identifier values, count or order changed")


def read_preserving(text, engine):
    return pd.read_csv(
        io.StringIO(text), engine=engine,
        dtype={"record_id": "string"}, keep_default_na=False,
        na_values={"amount": [""]},
    )


fixtures = {
    "numeric_ids": ["00123", "123", "9007199254740992", "9007199254740993", ""],
    "literal_tokens": ["NA", "NULL", "N/A", "nan", "", "00123", " 00123 "],
}
results = []
controls = []
for engine in ["c", "python"]:
    for label, ids in fixtures.items():
        text = make_csv(ids)
        expected = reference_ids(text)
        assert expected == ids
        for policy in ["default", "late_cast", "quoted_default", "dtype_only", "dtype_and_na"]:
            source = make_csv(ids, csv.QUOTE_ALL) if policy == "quoted_default" else text
            if policy == "dtype_and_na":
                frame = read_preserving(source, engine)
            else:
                options = {"dtype": {"record_id": "string"}} if policy == "dtype_only" else {}
                frame = pd.read_csv(io.StringIO(source), engine=engine, **options)
                if policy == "late_cast":
                    frame["record_id"] = frame["record_id"].astype(str)
            values = frame["record_id"].tolist()
            exact = sum(isinstance(value, str) and value == wanted for value, wanted in zip(values, expected))
            try:
                assert_ids(frame, expected)
                accepted = True
            except ValueError:
                accepted = False
            results.append({"engine": engine, "fixture": label, "policy": policy,
                            "exact_ids": exact, "total": len(ids), "accepted": accepted,
                            "values": [value if isinstance(value, str) else repr(value) for value in values]})
            assert accepted == (policy == "dtype_and_na")
        good = read_preserving(text, engine)
        assert_ids(good, expected)
        assert pd.isna(good["amount"].iloc[0])
        assert good["amount"].iloc[1] == 12.5
        exported = good.to_csv(index=False, lineterminator="\n")
        assert reference_ids(exported) == expected
        assert_ids(read_preserving(exported, engine), expected)
        for mutation in ["changed", "missing", "reversed"]:
            bad = good.copy()
            if mutation == "changed":
                bad.loc[0, "record_id"] = "changed-id"
            elif mutation == "missing":
                bad = bad.iloc[:-1]
            else:
                bad = bad.iloc[::-1]
            try:
                assert_ids(bad, expected)
            except ValueError:
                controls.append({"engine": engine, "fixture": label, "mutation": mutation, "rejected": True})
            else:
                raise AssertionError("Negative control incorrectly accepted")

for invalid in ["record_id,record_id\na,b\n", "record_id,amount\na,1,extra\n", "record_id,amount\na\n"]:
    try:
        reference_ids(invalid)
    except ValueError:
        controls.append({"invalid_csv": repr(invalid), "rejected": True})
    else:
        raise AssertionError("Malformed fixture incorrectly accepted")
print(json.dumps({"python": platform.python_version(), "pandas": pd.__version__,
                  "results": results, "round_trips": 4, "negative_controls": controls,
                  "all_passed": True}, indent=2))

Expected result on the tested runtime: all_passed: true, round_trips: 4, 20 result rows and 15 rejected controls. Expected negative-policy outcomes are intentionally asserted. If your installed version behaves differently, investigate rather than weakening the checker until it passes.

The four correct-policy exports preserved the decoded ID strings and passed re-import under the same policy. Changed, missing and reversed identifier rows were rejected, as were three malformed CSV fixtures. The test does not claim that exporting the amount 12.50 preserves its original textual formatting.

Verify the consumer, not just the exporter

A CSV contains fields, not a persistent pandas schema. Your next program can infer types again. Reapply the contract at each reader, and compare at the boundary where matching or delivery actually happens.

Keep these limits explicit:

• We tested pandas 2.2.3, not the version shown by today's online documentation, every release, or the pyarrow engine. A historical pyarrow leading-zero report demonstrates why engine-specific verification matters. That issue is now closed; it is not evidence that today's pyarrow integration remains broken.

• Decoded identifier equality is not byte-identical file preservation. Quoting, line endings and amount formatting can change.

• The fixtures use a known dialect and tiny inputs. They do not validate arbitrary encodings, delimiters, enormous files, later join behavior or hostile input.

• This test deliberately preserves spaces. Stripping or normalizing identifiers is a business decision requiring an explicit contract.

• It does not establish spreadsheet safety. If the next reader is a spreadsheet, apply the separate CSV formula-injection and literal-cell test too.

If you are choosing where to run it, the Code Interpreter versus AI agent sandbox guide explains the execution boundary. A passing parser fixture is useful proof for one transformation, not a security audit or a guarantee about the whole agent workflow.

Inspect the CSV test runtime, run the controls, and keep the resulting versions and contract with the export. Refresh the test when pandas, the parser engine, the source schema or receiving system changes.

Sources and method

• pandas read_csv documentation, retrieved October 1, 2026, identified itself as version 3.0.6. It supports the dtype/NA explanation; observed results use pandas 2.2.3.

• Python csv documentation describes the reference parser and quoting controls.

• pandas issue 57666 is historical engine-specific context, not a current-release defect claim.

• Aident's October 1, 2026 first-party run: Python 3.13.14 / pandas 2.2.3, two synthetic fixtures, two engines, five policies, four correct-policy round trips and 15 explicit negative controls. No production identifiers, CRM import, spreadsheet application, LLM transformation, speed comparison, private-file transfer or external write was tested.