astanin__python-tabulate-268

The user is reporting an `AttributeError` when using `SEPARATING_LINE` with a list of `dataclasses`.
The error happens in `tabulate/__init__.py` at line 1451:
`rows = [[getattr(row, f) for f in field_names] for row in rows ]`
`AttributeError: 'str' object has no attribute '<the first attribute of dataclass>'`

This suggests that `tabulate` is iterating over `rows`, and one of the rows is a `SEPARATING_LINE` (which is likely a string), while other rows are dataclass instances. When it encounters a string, it tries to treat it as a dataclass and call `getattr(row, f)` on it, which fails.

Let's start by exploring the code and reproducing the bug.

{
  "command": "grep -rn \"SEPARATING_LINE\" tabulate/__init__.py"
}

{
  "status": "ok",
  "stdout": "51:SEPARATING_LINE = \"\\001\"\n108:        (len(row) >= 1 and row[0] == SEPARATING_LINE)\n109:        or (len(row) >= 2 and row[1] == SEPARATING_LINE)\n1290:            rows.insert(index, SEPARATING_LINE)\n2453:            # the SEPARATING_LINE flag\n",
  "stderr": "",
  "exit_code": 0
}

Okay, `SEPARATING_LINE` is defined as `"\001"`.
Now let's look at the code around line 1451 in `tabulate/__init__.py`.

{
  "end_line": 1470,
  "filepath": "tabulate/__init__.py",
  "start_line": 1430
}

{
  "status": "ok",
  "filepath": "tabulate/__init__.py",
  "content": "                # a dict of headers for a list of dicts\n                headers = [headers.get(k, k) for k in keys]\n                headers = list(map(str, headers))\n            elif headers == \"firstrow\":\n                if len(rows) > 0:\n                    headers = [firstdict.get(k, k) for k in keys]\n                    headers = list(map(str, headers))\n                else:\n                    headers = []\n            elif headers:\n                raise ValueError(\n                    \"headers for a list of dicts is not a dict or a keyword\"\n                )\n            rows = [[row.get(k) for k in keys] for row in rows]\n\n        elif (\n            headers == \"keys\"\n            and hasattr(tabular_data, \"description\")\n            and hasattr(tabular_data, \"fetchone\")\n            and hasattr(tabular_data, \"rowcount\")\n        ):\n            # Python Database API cursor object (PEP 0249)\n            # print tabulate(cursor, headers='keys')\n            headers = [column[0] for column in tabular_data.description]\n\n        elif (\n            dataclasses is not None\n            and len(rows) > 0\n            and dataclasses.is_dataclass(rows[0])\n        ):\n            # Python 3.7+'s dataclass\n            field_names = [field.name for field in dataclasses.fields(rows[0])]\n            if headers == \"keys\":\n                headers = field_names\n            rows = [[getattr(row, f) for f in field_names] for row in rows]\n\n        elif headers == \"keys\" and len(rows) > 0:\n            # keys are column indices\n            headers = list(map(str, range(len(rows[0]))))\n\n    # take headers from the first row if necessary",
  "start_line": 1430,
  "end_line": 1470,
  "total_lines": 2787,
  "is_truncated": false
}

The problematic block is:
```python
        elif (
            dataclasses is not None
            and len(rows) > 0
            and dataclasses.is_dataclass(rows[0])
        ):
            # Python 3.7+'s dataclass
            field_names = [field.name for field in dataclasses.fields(rows[0])\n            if headers == "keys":
                headers = field_names
            rows = [[getattr(row, f) for f in field_names] for row in rows]
```
If `rows` contains a `SEPARATING_LINE` among dataclasses, `dataclasses.is_dataclass(rows[0])` might be True if the first row is a dataclass, but then the list comprehension `[getattr(row, f) for f in field_names] for row in rows` will fail when `row` is `SEPARATING_LINE` (a string).

Wait, if `rows[0]` is `SEPARATING_LINE`, then `dataclasses.is_dataclass(rows[0])` will be False, and it will skip this block. But if `rows[0]` is a dataclass and some subsequent row is `SEPARATING_LINE`, it will crash.

Let's create a reproduction script.

{
  "command": "python3 - <<'PY'\nfrom dataclasses import dataclass\nfrom tabulate import tabulate, SEPARATING_LINE\n\n@dataclass\nclass Person:\n    name: str\n    age: int\n\ndata = [\n    Person(\"Alice\", 30),\n    SEPARATING_LINE,\n    Person(\"Bob\", 25),\n]\n\ntry:\n    print(tabulate(data, headers=\"keys\"))\nexcept Exception as e:\n    import traceback\n    traceback.print_exc()\nPY\n"
}

{
  "status": "ok",
  "stdout": "",
  "stderr": "Traceback (most recent call last):\n  File \"<stdin>\", line 16, in <module>\n  File \"/workspace/tabulate/__init__.py\", line 2088, in tabulate\n    list_of_lists, headers, headers_pad = _normalize_tabular_data(\n  File \"/workspace/tabulate/__init__.py\", line 1464, in _normalize_tabular_data\n    rows = [[getattr(row, f) for f in field_names] for row in rows]\n  File \"/workspace/tabulate/__init__.py\", line 1464, in <listcomp>\n    rows = [[getattr(row, f) for f in field_names] for row in rows]\n  File \"/workspace/tabulate/__init__.py\", line 1464, in <listcomp>\n    rows = [[getattr(row, f) for f in field_names] for row in rows]\nAttributeError: 'str' object has no attribute 'name'\n",
  "exit_code": 0
}

The reproduction confirms the bug.
The line `rows = [[getattr(row, f) for f in field_names] for row in rows]` needs to handle `SEPARATING_LINE`.

Looking at how other parts of `_normalize_tabular_data` might handle this, or how `SEPARATING_LINE` is typically treated.
Usually, `SEPARATING_LINE` is meant to be a marker for a separating line in the table.

Let's look at `_normalize_tabular_data` again.

Wait, I see that `SEPARATING_LINE` is checked in line 108 and 109.
Let's read more of `_normalize_tabular_data`.

{
  "end_line": 1470,
  "filepath": "tabulate/__init__.py",
  "start_line": 1400
}

{
  "status": "ok",
  "filepath": "tabulate/__init__.py",
  "content": "            and getattr(tabular_data.dtype, \"names\")\n        ):\n            # numpy record array\n            headers = tabular_data.dtype.names\n        elif (\n            headers == \"keys\"\n            and len(rows) > 0\n            and isinstance(rows[0], tuple)\n            and hasattr(rows[0], \"_fields\")\n        ):\n            # namedtuple\n            headers = list(map(str, rows[0]._fields))\n        elif len(rows) > 0 and hasattr(rows[0], \"keys\") and hasattr(rows[0], \"values\"):\n            # dict-like object\n            uniq_keys = set()  # implements hashed lookup\n            keys = []  # storage for set\n            if headers == \"firstrow\":\n                firstdict = rows[0] if len(rows) > 0 else {}\n                keys.extend(firstdict.keys())\n                uniq_keys.update(keys)\n                rows = rows[1:]\n            for row in rows:\n                for k in row.keys():\n                    # Save unique items in input order\n                    if k not in uniq_keys:\n                        keys.append(k)\n                        uniq_keys.add(k)\n            if headers == \"keys\":\n                headers = keys\n            elif isinstance(headers, dict):\n                # a dict of headers for a list of dicts\n                headers = [headers.get(k, k) for k in keys]\n                headers = list(map(str, headers))\n            elif headers == \"firstrow\":\n                if len(rows) > 0:\n                    headers = [firstdict.get(k, k) for k in keys]\n                    headers = list(map(str, headers))\n                else:\n                    headers = []\n            elif headers:\n                raise ValueError(\n                    \"headers for a list of dicts is not a dict or a keyword\"\n                )\n            rows = [[row.get(k) for k in keys] for row in rows]\n\n        elif (\n            headers == \"keys\"\n            and hasattr(tabular_data, \"description\")\n            and hasattr(tabular_data, \"fetchone\")\n            and hasattr(tabular_data, \"rowcount\")\n        ):\n            # Python Database API cursor object (PEP 0249)\n            # print tabulate(cursor, headers='keys')\n            headers = [column[0] for column in tabular_data.description]\n\n        elif (\n            dataclasses is not None\n            and len(rows) > 0\n            and dataclasses.is_dataclass(rows[0])\n        ):\n            # Python 3.7+'s dataclass\n            field_names = [field.name for field in dataclasses.fields(rows[0])]\n            if headers == \"keys\":\n                headers = field_names\n            rows = [[getattr(row, f) for f in field_names] for row in rows]\n\n        elif headers == \"keys\" and len(rows) > 0:\n            # keys are column indices\n            headers = list(map(str, range(len(rows[0]))))\n\n    # take headers from the first row if necessary",
  "start_line": 1400,
  "end_line": 1470,
  "total_lines": 2787,
  "is_truncated": false
}

I should check how `SEPARATING_LINE` is handled when it's a row.
If `row == SEPARATING_LINE`, we should probably just keep it as `SEPARATING_LINE` instead of trying to extract attributes from it.

Let's look at the dataclass block:
```python
        elif (
            dataclasses is not None
            and len(rows) > 0
            and dataclasses.is_dataclass(rows[0])
        ):
            # Python 3.7+'s dataclass
            field_names = [field.name for field in dataclasses.fields(rows[0])]
            if headers == "keys":
                headers = field_names
            rows = [[getattr(row, f) for f in field_names] for row in rows]
```

The fix should be changing the last line to something like:
`rows = [[getattr(row, f) for f in field_names] if row != SEPARATING_LINE else row for row in rows]`
Actually, since `SEPARATING_LINE` is just a string, we can check for it.

But wait, look at the dict-like object block:
`rows = [[row.get(k) for k in keys] for row in rows]`
Does this also crash if `row` is `SEPARATING_LINE`?
Let's test it.

{
  "command": "python3 - <<'PY'\nfrom tabulate import tabulate, SEPARATING_LINE\n\ndata = [\n    {\"name\": \"Alice\", \"age\": 30},\n    SEPARATING_LINE,\n    {\"name\": \"Bob\", \"age\": 25},\n]\n\ntry:\n    print(tabulate(data, headers=\"keys\"))\nexcept Exception as e:\n    import traceback\n    traceback.print_exc()\nPY\n"
}

{
  "status": "ok",
  "stdout": "",
  "stderr": "Traceback (most recent call last):\n  File \"<stdin>\", line 10, in <module>\n  File \"/workspace/tabulate/__init__.py\", line 2088, in tabulate\n    list_of_lists, headers, headers_pad = _normalize_tabular_data(\n  File \"/workspace/tabulate/__init__.py\", line 1422, in _normalize_tabular_data\n    for k in row.keys():\nAttributeError: 'str' object has no attribute 'keys'\n",
  "exit_code": 0
}

Wow, it also crashes for dicts! The problem description specifically mentioned dataclasses, but it seems to be a general issue when `SEPARATING_LINE` is interspersed with other types.

Wait, if I look at lines 108-109:
```python
108:        (len(row) >= 1 and row[0] == SEPARATING_LINE)\n109:        or (len(row) >= 2 and row[1] == SEPARATING_LINE)\n
```
This suggests that `row` is expected to be a list/tuple when checking for `SEPARATING_LINE` there.

Let's see where `_normalize_tabular_data` is called. It's called in `tabulate()`.

Let's look at the beginning of `_normalize_tabular_data`.

{
  "end_line": 1400,
  "filepath": "tabulate/__init__.py",
  "start_line": 1300
}

{
  "status": "ok",
  "filepath": "tabulate/__init__.py",
  "content": "            + \"len(index)={} len(rows)={}\".format(len(index), len(rows))\n        )\n    sans_rows, separating_lines = _remove_separating_lines(rows)\n    new_rows = []\n    index_iter = iter(index)\n    for row in sans_rows:\n        index_v = next(index_iter)\n        new_rows.append([index_v] + list(row))\n    rows = new_rows\n    _reinsert_separating_lines(rows, separating_lines)\n    return rows\n\n\ndef _bool(val):\n    \"A wrapper around standard bool() which doesn't throw on NumPy arrays\"\n    try:\n        return bool(val)\n    except ValueError:  # val is likely to be a numpy array with many elements\n        return False\n\n\ndef _normalize_tabular_data(tabular_data, headers, showindex=\"default\"):\n    \"\"\"Transform a supported data type to a list of lists, and a list of headers, with headers padding.\n\n    Supported tabular data types:\n\n    * list-of-lists or another iterable of iterables\n\n    * list of named tuples (usually used with headers=\"keys\")\n\n    * list of dicts (usually used with headers=\"keys\")\n\n    * list of OrderedDicts (usually used with headers=\"keys\")\n\n    * list of dataclasses (Python 3.7+ only, usually used with headers=\"keys\")\n\n    * 2D NumPy arrays\n\n    * NumPy record arrays (usually used with headers=\"keys\")\n\n    * dict of iterables (usually used with headers=\"keys\")\n\n    * pandas.DataFrame (usually used with headers=\"keys\")\n\n    The first row can be used as headers if headers=\"firstrow\",\n    column indices can be used as headers if headers=\"keys\".\n\n    If showindex=\"default\", show row indices of the pandas.DataFrame.\n    If showindex=\"always\", show row indices for all types of data.\n    If showindex=\"never\", don't show row indices for all types of data.\n    If showindex is an iterable, show its values as row indices.\n\n    \"\"\"\n\n    try:\n        bool(headers)\n        is_headers2bool_broken = False  # noqa\n    except ValueError:  # numpy.ndarray, pandas.core.index.Index, ...\n        is_headers2bool_broken = True  # noqa\n        headers = list(headers)\n\n    index = None\n    if hasattr(tabular_data, \"keys\") and hasattr(tabular_data, \"values\"):\n        # dict-like and pandas.DataFrame?\n        if hasattr(tabular_data.values, \"__call__\"):\n            # likely a conventional dict\n            keys = tabular_data.keys()\n            rows = list(\n                izip_longest(*tabular_data.values())\n            )  # columns have to be transposed\n        elif hasattr(tabular_data, \"index\"):\n            # values is a property, has .index => it's likely a pandas.DataFrame (pandas 0.11.0)\n            keys = list(tabular_data)\n            if (\n                showindex in [\"default\", \"always\", True]\n                and tabular_data.index.name is not None\n            ):\n                if isinstance(tabular_data.index.name, list):\n                    keys[:0] = tabular_data.index.name\n                else:\n                    keys[:0] = [tabular_data.index.name]\n            vals = tabular_data.values  # values matrix doesn't need to be transposed\n            # for DataFrames add an index per default\n            index = list(tabular_data.index)\n            rows = [list(row) for row in vals]\n        else:\n            raise ValueError(\"tabular data doesn't appear to be a dict or a DataFrame\")\n\n        if headers == \"keys\":\n            headers = list(map(str, keys))  # headers should be strings\n\n    else:  # it's a usual iterable of iterables, or a NumPy array, or an iterable of dataclasses\n        rows = list(tabular_data)\n\n        if headers == \"keys\" and not rows:\n            # an empty table (issue #81)\n            headers = []\n        elif (\n            headers == \"keys\"\n            and hasattr(tabular_data, \"dtype\")\n            and getattr(tabular_data.dtype, \"names\")",
  "start_line": 1300,
  "end_line": 1400,
  "total_lines": 2787,
  "is_truncated": false
}

Okay, I see `_normalize_tabular_data` starts by converting `tabular_data` into `rows` (a list).
If it's not a dict/DataFrame, it does `rows = list(tabular_data)`.

Then it goes through several `if/elif` blocks to handle different types of rows.
The problem is that if `rows` contains `SEPARATING_LINE`, the type-checking logic (like `dataclasses.is_dataclass(rows[0])`) might be fooled if the first row is of the expected type, but later rows are not. Or if the first row IS `SEPARATING_LINE`, it might skip the correct block.

Wait, if `rows[0]` is `SEPARATING_LINE`, then:
1. It's not a numpy record array (likely).
2. It's not a namedtuple (likely).
3. It doesn't have `.keys()` and `.values()` (it's a string).
4. It's not a database cursor.
5. It's not a dataclass.
6. It falls into `elif headers == "keys" and len(rows) > 0:`, which does `headers = list(map(str, range(len(rows[0]))))`. Since `rows[0]` is `"\001"`, `len(rows[0])` is 1, so `headers` becomes `["0"]`. And then it returns to `tabulate()` where it continues processing.

Actually, let's check what happens if the first row is `SEPARATING_LINE` and the rest are dataclasses.

{
  "command": "python3 - <<'PY'\nfrom dataclasses import dataclass\nfrom tabulate import tabulate, SEPARATING_LINE\n\n@dataclass\nclass Person:\n    name: str\n    age: int\n\ndata = [\n    SEPARATING_LINE,\n    Person(\"Alice\", 30),\n    Person(\"Bob\", 25),\n]\n\ntry:\n    print(tabulate(data, headers=\"keys\"))\nexcept Exception as e:\n    import traceback\n    traceback.print_exc()\nPY\n"
}

{
  "status": "ok",
  "stdout": "",
  "stderr": "Traceback (most recent call last):\n  File \"<stdin>\", line 16, in <module>\n  File \"/workspace/tabulate/__init__.py\", line 2088, in tabulate\n    list_of_lists, headers, headers_pad = _normalize_tabular_data(\n  File \"/workspace/tabulate/__init__.py\", line 1484, in _normalize_tabular_data\n    rows = list(map(lambda r: r if _is_separating_line(r) else list(r), rows))\n  File \"/workspace/tabulate/__init__.py\", line 1484, in <lambda>\n    rows = list(map(lambda r: r if _is_separating_line(r) else list(r), rows))\nTypeError: 'Person' object is not iterable\n",
  "exit_code": 0
}

Indeed, if `rows[0]` is `SEPARATING_LINE`, it skips the dataclass-specialized processing and eventually hits a part of the code that expects each row to be iterable (like a list or tuple).

The root cause is that `_normalize_tabular_data` uses the first element of `rows` to determine the type of all rows. This is problematic when `SEPARATING_LINE` is present, especially at the beginning.

To fix this, we should probably ignore `SEPARATING_LINE` rows when determining the type and when performing the transformation.

Let's see how `SEPARATING_LINE` is recognized. There is a function `_is_separating_line` probably?
Wait, I saw lines 108-109:
```python
108:        (len(row) >= 1 and row[0] == SEPARATING_LINE)\n109:        or (len(row) >= 2 and row[1] == SEPARATING_LINE)\n
```
But `row` there is already supposedly a list/tuple. If `row` is exactly `SEPARATING_LINE` (the string), then `len(row)` is 1 and `row[0]` is `SEPARATING_LINE`. So `(len(row) >= 1 and row[0] == SEPARATING_LINE)` will be true for `row = SEPARATING_LINE`.

Wait, `SEPARATING_LINE = "\001"`.
`len("\001")` is 1.
`"\001"[0]` is `"\001"`.
So `SEPARATING_LINE` (as a string) satisfies the condition.

However, the type detection logic at the start of `_normalize_tabular_data` needs to be more robust.

Instead of `rows[0]`, we should look for the first row that is NOT a separating line.

Let's check if there is a helper function for this.
Look at lines 108-109 again. Where are they?

{
  "end_line": 120,
  "filepath": "tabulate/__init__.py",
  "start_line": 90
}

{
  "status": "ok",
  "filepath": "tabulate/__init__.py",
  "content": "TableFormat = namedtuple(\n    \"TableFormat\",\n    [\n        \"lineabove\",\n        \"linebelowheader\",\n        \"linebetweenrows\",\n        \"linebelow\",\n        \"headerrow\",\n        \"datarow\",\n        \"padding\",\n        \"with_header_hide\",\n    ],\n)\n\n\ndef _is_separating_line(row):\n    row_type = type(row)\n    is_sl = (row_type == list or row_type == str) and (\n        (len(row) >= 1 and row[0] == SEPARATING_LINE)\n        or (len(row) >= 2 and row[1] == SEPARATING_LINE)\n    )\n    return is_sl\n\n\ndef _pipe_segment_with_colons(align, colwidth):\n    \"\"\"Return a segment of a horizontal line with optional colons which\n    indicate column's alignment (as in `pipe` output format).\"\"\"\n    w = colwidth\n    if align in [\"right\", \"decimal\"]:\n        return (\"-\" * (w - 1)) + \":\"\n    elif align == \"center\":",
  "start_line": 90,
  "end_line": 120,
  "total_lines": 2787,
  "is_truncated": false
}

Yes, `_is_separating_line(row)` exists.

Now let's go back to `_normalize_tabular_data`.
We need to find the first non-separating line to determine the type.

```python
    else:  # it's a usual iterable of iterables, or a NumPy array, or an iterable of dataclasses
        rows = list(tabular_data)
```
And then:
```python
        elif (
            dataclasses is not None
            and len(rows) > 0
            and dataclasses.is_dataclass(rows[0])
        ):
```
If `rows[0]` is a separating line, `dataclasses.is_dataclass(rows[0])` will be false.

We should find the first row that is not a separating line.

```python
    else:  # it's a usual iterable of iterables, or a NumPy array, or an iterable of dataclasses
        rows = list(tabular_data)
        
        # Find first non-separating line for type determination
        first_non_sl = None
        for row in rows:
            if not _is_separating_line(row):
                first_non_sl = row
                break
```

And then use `first_non_sl` instead of `rows[0]`.

But we also need to handle the transformations of the rows correctly.

For the dataclass case:
```python
        elif (
            dataclasses is not None
            and first_non_sl is not None
            and dataclasses.is_dataclass(first_non_sl)
        ):
            # Python 3.7+'s dataclass
            field_names = [field.name for field in dataclasses.fields(first_non_sl)]
            if headers == "keys":
                headers = field_names
            rows = [[getattr(row, f) for f in field_names] if not _is_separating_line(row) else row for row in rows]
```

Wait, let's check the dict-like object case too.

```python
        elif len(rows) > 0 and hasattr(rows[0], "keys") and hasattr(rows[0], "values"):
            # dict-like object
```
This should also use `first_non_sl`.

```python
        elif first_non_sl is not None and hasattr(first_non_sl, "keys") and hasattr(first_non_sl, "values"):
            # dict-like object
```

Then inside that block:
```python
            if headers == "firstrow":
                firstdict = rows[0] if len(rows) > 0 else {}
                # ...
```
Actually, if `headers == "firstrow"`, it expects the first row to be the header. But what if the first row is a separating line? That would be weird, but possible. However, the standard use case for `headers="firstrow"` usually means the first data row is the header.

If the first row is a separating line, and `headers="firstrow"`, should we skip separating lines to find the first row? Probably.

Actually, if `headers="firstrow"`, the user explicitly said the first row of the provided data is the header. If that's a separating line, it's the user's problem, or we should handle it. But usually, `SEPARATING_LINE` is for separating data rows, not for replacing the header row.

Let's look at the dict-like section again.

```python
        elif len(rows) > 0 and hasattr(rows[0], "keys") and hasattr(rows[0], "values"):
            # dict-like object
            uniq_keys = set()  # implements hashed lookup
            keys = []  # storage for set
            if headers == "firstrow":
                firstdict = rows[0] if len(rows) > 0 else {}
                keys.extend(firstdict.keys())
                uniq_keys.update(keys)
                rows = rows[1:]
            for row in rows:
                for k in row.keys():
                    # Save unique items in input order
                    if k not in uniq_keys:
                        keys.append(k)
                        uniq_keys.add(k)
```

If `rows` contains `SEPARATING_LINE`, then `for row in rows: for k in row.keys():` will crash.

So we should skip separating lines in these loops.

```python
            for row in rows:
                if _is_separating_line(row):
                    continue
                for k in row.keys():
                    # ...
```

And the final transformation:
```python
            rows = [[row.get(k) for k in keys] if not _is_separating_line(row) else row for row in rows]
```

Let's see where `_normalize_tabular_data` is defined and how to implement this cleanly.

I'll search for all occurrences of `rows[0]` in `_normalize_tabular_data` to see where it needs to be replaced by `first_non_sl`.

{
  "command": "grep -n \"rows\\[0\\]\" tabulate/__init__.py | grep -C 2 \"def _normalize_tabular_data\" -A 200"
}

{
  "status": "error",
  "error_type": "CommandError",
  "error_message": "",
  "details": {
    "stdout": "",
    "stderr": "",
    "exit_code": 1
  }
}

My grep was too complex. Let's just do a simple grep for `rows[0]` in `tabulate/__init__.py`.

{
  "command": "grep -n \"rows\\[0\\]\" tabulate/__init__.py"
}

{
  "status": "ok",
  "stdout": "1407:            and isinstance(rows[0], tuple)\n1408:            and hasattr(rows[0], \"_fields\")\n1411:            headers = list(map(str, rows[0]._fields))\n1412:        elif len(rows) > 0 and hasattr(rows[0], \"keys\") and hasattr(rows[0], \"values\"):\n1417:                firstdict = rows[0] if len(rows) > 0 else {}\n1458:            and dataclasses.is_dataclass(rows[0])\n1461:            field_names = [field.name for field in dataclasses.fields(rows[0])]\n1468:            headers = list(map(str, range(len(rows[0]))))\n1473:            headers = [index[0]] + list(rows[0])\n1476:            headers = rows[0]\n1504:        headers_pad = max(0, len(rows[0]) - len(headers))\n",
  "stderr": "",
  "exit_code": 0
}

Okay, there are many `rows[0]` usages.

Let's plan the changes in `_normalize_tabular_data`.

1. After `rows = list(tabular_data)`, find `first_non_sl`.
2. Replace `rows[0]` with `first_non_sl` in type checks and property access.
3. Ensure that list comprehensions that transform rows handle `_is_separating_line(row)`.
4. Handle `headers="firstrow"` for dict-like objects carefully.

Wait, if I change `rows[0]` to `first_non_sl`, I must ensure `first_non_sl` is not `None`.

Let's look at the code again.

```python
    else:  # it's a usual iterable of iterables, or a NumPy array, or an iterable of dataclasses
        rows = list(tabular_data)

        if headers == "keys" and not rows:
            # an empty table (issue #81)
            headers = []
```

I can insert the `first_non_sl` logic here.

```python
    else:  # it's a usual iterable of iterables, or a NumPy array, or an iterable of dataclasses
        rows = list(tabular_data)

        first_non_sl = None
        for row in rows:
            if not _is_separating_line(row):
                first_non_sl = row
                break
```

Now let's see the `elif` blocks.

Line 1407:
```python
        elif (
            headers == "keys"
            and len(rows) > 0
            and isinstance(rows[0], tuple)
            and hasattr(rows[0], "_fields")
        ):
```
Should be:
```python
        elif (
            headers == "keys"
            and first_non_sl is not None
            and isinstance(first_non_sl, tuple)
            and hasattr(first_non_sl, "_fields")
        ):
```

And line 1411:
```python
            headers = list(map(str, rows[0]._fields))
```
Should be:
```python
            headers = list(map(str, first_non_sl._fields))
```

And line 1412:
```python
        elif len(rows) > 0 and hasattr(rows[0], "keys") and hasattr(rows[0], "values"):
```
Should be:
```python
        elif first_non_sl is not None and hasattr(first_non_sl, "keys") and hasattr(first_non_sl, "values"):
```

And line 1417:
```python
                firstdict = rows[0] if len(rows) > 0 else {}
```
Wait, if `headers == "firstrow"`, the user wants the FIRST row to be the header. If the first row is a separating line, should we skip it?
If we are in the `first_non_sl` block, it means we found at least one non-separating line.
But if the user wrote:
`[SEPARATING_LINE, {'a': 1}, {'a': 2}]` and `headers="firstrow"`, then `rows[0]` is `SEPARATING_LINE`.
If we use `first_non_sl`, we get `{'a': 1}` as the header. This seems more reasonable.

However, the `firstdict` is used for `keys.extend(firstdict.keys())`.
And then `rows = rows[1:]`.
If `rows[0]` is a separating line, then `rows[1:]` will still contain the first actual data row at index 0.

This is getting complicated. Maybe I should only apply `first_non_sl` for type detection and property access, but keep `rows[0]` where the user's explicit structure matters (like `headers="firstrow"`).

Actually, let's look at the dataclass case again.

```python
        elif (
            dataclasses is not None
            and len(rows) > 0
            and dataclasses.is_dataclass(rows[0])
        ):
            # Python 3.7+'s dataclass
            field_names = [field.name for field in dataclasses.fields(rows[0])]
            if headers == "keys":
                headers = field_names
            rows = [[getattr(row, f) for f in field_names] for row in rows]
```

If I change it to:
```python
        elif (
            dataclasses is not None
            and first_non_sl is not None
            and dataclasses.is_dataclass(first_non_sl)
        ):
            # Python 3.7+'s dataclass
            field_names = [field.name for field in dataclasses.fields(first_non_sl)]
            if headers == "keys":
                headers = field_names
            rows = [[getattr(row, f) for f in field_names] if not _is_separating_line(row) else row for row in rows]
```
This fixes the dataclass crash.

Now let's fix the dict-like crash.

```python
        elif len(rows) > 0 and hasattr(rows[0], "keys") and hasattr(rows[0], "values"):
            # dict-like object
            uniq_keys = set()  # implements hashed lookup
            keys = []  # storage for set
            if headers == "firstrow":
                firstdict = rows[0] if len(rows) > 0 else {}
                keys.extend(firstdict.keys())
                uniq_keys.update(keys)
                rows = rows[1:]
            for row in rows:
                for k in row.keys():
                    # Save unique items in input order
                    if k not in uniq_keys:
                        keys.append(k)
                        uniq_keys.add(k)
            if headers == "keys":
                headers = keys
            # ...
            rows = [[row.get(k) for k in keys] for row in rows]
```

If `rows[0]` is `SEPARATING_LINE`, then `hasattr(rows[0], "keys")` is False, so it skips this block.
Then it goes to the next `elif` (the database cursor one, or the dataclass one).
If it's not a dataclass, it goes to:
```python
        elif headers == "keys" and len(rows) > 0:
            # keys are column indices
            headers = list(map(str, range(len(rows[0]))))
```
Since `rows[0]` is `SEPARATING_LINE` (a string), `len(rows[0])` is 1. `headers` becomes `["0"]`.
Then at the end of `_normalize_tabular_data`:
```python
    try:
        rows = list(map(lambda r: r if _is_separating_line(r) else list(r), rows))
    except TypeError:
        # ...
```
Wait, let's read the end of `_normalize_tabular_data`.

{
  "end_line": 1510,
  "filepath": "tabulate/__init__.py",
  "start_line": 1470
}

{
  "status": "ok",
  "filepath": "tabulate/__init__.py",
  "content": "    # take headers from the first row if necessary\n    if headers == \"firstrow\" and len(rows) > 0:\n        if index is not None:\n            headers = [index[0]] + list(rows[0])\n            index = index[1:]\n        else:\n            headers = rows[0]\n        headers = list(map(str, headers))  # headers should be strings\n        rows = rows[1:]\n    elif headers == \"firstrow\":\n        headers = []\n\n    headers = list(map(str, headers))\n    #    rows = list(map(list, rows))\n    rows = list(map(lambda r: r if _is_separating_line(r) else list(r), rows))\n\n    # add or remove an index column\n    showindex_is_a_str = type(showindex) in [str, bytes]\n    if showindex == \"default\" and index is not None:\n        rows = _prepend_row_index(rows, index)\n    elif isinstance(showindex, Sized) and not showindex_is_a_str:\n        rows = _prepend_row_index(rows, list(showindex))\n    elif isinstance(showindex, Iterable) and not showindex_is_a_str:\n        rows = _prepend_row_index(rows, showindex)\n    elif showindex == \"always\" or (_bool(showindex) and not showindex_is_a_str):\n        if index is None:\n            index = list(range(len(rows)))\n        rows = _prepend_row_index(rows, index)\n    elif showindex == \"never\" or (not _bool(showindex) and not showindex_is_a_str):\n        pass\n\n    # pad with empty headers for initial columns if necessary\n    headers_pad = 0\n    if headers and len(rows) > 0:\n        headers_pad = max(0, len(rows[0]) - len(headers))\n        headers = [\"\"] * headers_pad + headers\n\n    return rows, headers, headers_pad\n\n\ndef _wrap_text_to_colwidths(list_of_lists, colwidths, numparses=True):",
  "start_line": 1470,
  "end_line": 1510,
  "total_lines": 2787,
  "is_truncated": false
}

Wait, I see this line:
```python
    rows = list(map(lambda r: r if _is_separating_line(r) else list(r), rows))
```
This is where it crashes if a row is a dataclass and not a separating line, because `list(dataclass_instance)` is not allowed.

Wait, that's why the dataclass block does:
```python
            rows = [[getattr(row, f) for f in field_names] for row in rows]
```
This converts the dataclass instances into lists of values.
But it fails if `row` is `SEPARATING_LINE`.

So, we must ensure that for any type (dataclass, dict, namedtuple, etc.), the transformation of `rows` into a list of lists handles `SEPARATING_LINE`.

Let's go through each case:

1. **Namedtuples**:
```python
        elif (
            headers == "keys"
            and len(rows) > 0
            and isinstance(rows[0], tuple)
            and hasattr(rows[0], "_fields")
        ):
            # namedtuple
            headers = list(map(str, rows[0]._fields))
```
Wait, there is no `rows = [...]` for namedtuples?
Ah, I see. If it's a namedtuple, it just sets the headers. Then at the end, `list(map(lambda r: r if _is_separating_line(r) else list(r), rows))` is called.
Since namedtuples are tuples, `list(namedtuple_instance)` works! So namedtuples already work with `SEPARATING_LINE`.

2. **Dict-like objects**:
```python
        elif len(rows) > 0 and hasattr(rows[0], "keys") and hasattr(rows[0], "values"):
            # ...
            rows = [[row.get(k) for k in keys] for row in rows]
```
This crashes if `row` is `SEPARATING_LINE`.
Should be: `rows = [[row.get(k) for k in keys] if not _is_separating_line(row) else row for row in rows]`

3. **Dataclasses**:
```python
        elif (
            dataclasses is not None
            and len(rows) > 0
            and dataclasses.is_dataclass(rows[0])
        ):
            # ...
            rows = [[getattr(row, f) for f in field_names] for row in rows]
```
This crashes if `row` is `SEPARATING_LINE`.
Should be: `rows = [[getattr(row, f) for f in field_names] if not _is_separating_line(row) else row for row in rows]`

And we need to fix the type detection if `rows[0]` is `SEPARATING_LINE`.

Let's find the first non-separating line.

```python
    else:  # it's a usual iterable of iterables, or a NumPy array, or an iterable of dataclasses
        rows = list(tabular_data)

        first_non_sl = None
        for row in rows:
            if not _is_separating_line(row):
                first_non_sl = row
                break
```

Then:

Line 1407:
```python
        elif (
            headers == "keys"
            and first_non_sl is not None
            and isinstance(first_non_sl, tuple)
            and hasattr(first_non_sl, "_fields")
        ):
```

Line 1411:
```python
            headers = list(map(str, first_non_sl._fields))
```

Line 1412:
```python
        elif first_non_sl is not None and hasattr(first_non_sl, "keys") and hasattr(first_non_sl, "values"):
```

And the dict-like loop:
```python
            for row in rows:
                if _is_separating_line(row):
                    continue
                for k in row.keys():
                    # ...
```

And the dict-like transformation:
```python
            rows = [[row.get(k) for k in keys] if not _is_separating_line(row) else row for row in rows]
```

And the dataclass detection:
```python
        elif (
            dataclasses is not None
            and first_non_sl is not None
            and dataclasses.is_dataclass(first_non_sl)
        ):
```

And the dataclass field_names:
```python
            field_names = [field.name for field in dataclasses.fields(first_non_sl)]
```

And the dataclass transformation:
```python
            rows = [[getattr(row, f) for f in field_names] if not _is_separating_line(row) else row for row in rows]
```

And finally, the fallback:
```python
        elif headers == "keys" and len(rows) > 0:
            # keys are column indices
            headers = list(map(str, range(len(rows[0]))))
```
If `rows[0]` is `SEPARATING_LINE`, `len(rows[0])` is 1. But the actual data might have more columns.
Should be:
```python
        elif headers == "keys" and first_non_sl is not None:
            # keys are column indices
            headers = list(map(str, range(len(first_non_sl))))
```

Wait, I should also consider `len(rows[0])` later on:
Line 1504:
```python
    if headers and len(rows) > 0:
        headers_pad = max(0, len(rows[0]) - len(headers))
        headers = [""] * headers_pad + headers
```
If `rows[0]` is `SEPARATING_LINE`, `len(rows[0])` is 1. This will be wrong.
We should use the length of `first_non_sl` if it exists.

But wait, if all rows are separating lines, then `first_non_sl` is `None`.

Let's check the `headers = rows[0]` usage too.

{
  "command": "grep -n \"rows\\[0\\]\" tabulate/__init__.py"
}

{
  "status": "ok",
  "stdout": "1407:            and isinstance(rows[0], tuple)\n1408:            and hasattr(rows[0], \"_fields\")\n1411:            headers = list(map(str, rows[0]._fields))\n1412:        elif len(rows) > 0 and hasattr(rows[0], \"keys\") and hasattr(rows[0], \"values\"):\n1417:                firstdict = rows[0] if len(rows) > 0 else {}\n1458:            and dataclasses.is_dataclass(rows[0])\n1461:            field_names = [field.name for field in dataclasses.fields(rows[0])]\n1468:            headers = list(map(str, range(len(rows[0]))))\n1473:            headers = [index[0]] + list(rows[0])\n1476:            headers = rows[0]\n1504:        headers_pad = max(0, len(rows[0]) - len(headers))\n",
  "stderr": "",
  "exit_code": 0
}