jazzband__tablib-613

The user is reporting a `ValueError: 'value' is not in list` when loading an ODS file that was exported with empty strings.
The provided reproduction code is:
```python
import tablib
book = tablib.Databook()
book.load(
    tablib.Databook(sets=[tablib.Dataset(("",))]).export("ods"),
    format="ods",
)
```
I need to find where ODS loading is implemented in `tablib` and identify the cause of the `ValueError`.

First, I'll search for "ods" in the `src/tablib` directory to find the relevant files.

{
  "command": "grep -rn --include=\"*.py\" \"ods\" src/tablib"
}

{
  "status": "ok",
  "stdout": "src/tablib/_vendor/dbfpy/header.py:56:    # instance construction and initialization methods\nsrc/tablib/_vendor/dbfpy/header.py:176:    # internal methods\nsrc/tablib/_vendor/dbfpy/header.py:208:    # interface methods\nsrc/tablib/_vendor/dbfpy/record.py:160:    # protected methods\nsrc/tablib/_vendor/dbfpy/record.py:183:    # utility methods\nsrc/tablib/_vendor/dbfpy/record.py:201:    # interface methods\nsrc/tablib/_vendor/dbfpy/dbf.py:53:20-dec-2005 [yc]    removed fromStream and newDbf methods:\nsrc/tablib/_vendor/dbfpy/dbf.py:61:24-aug-1998 [jjk]   add some encodeValue methods (not tested), other tweaks\nsrc/tablib/_vendor/dbfpy/dbf.py:163:    # protected methods\nsrc/tablib/_vendor/dbfpy/dbf.py:189:    # interface methods\nsrc/tablib/_vendor/dbfpy/dbf.py:233:    # 'magic' methods (representation and sequence interface)\nsrc/tablib/formats/_ods.py:67:    title = 'ods'\nsrc/tablib/formats/_ods.py:68:    extensions = ('ods',)\nsrc/tablib/formats/_ods.py:178:        ods_book = opendocument.load(in_stream)\nsrc/tablib/formats/_ods.py:179:        for sheet in ods_book.spreadsheet.childNodes:\nsrc/tablib/formats/_ods.py:189:        ods_book = opendocument.load(in_stream)\nsrc/tablib/formats/_ods.py:191:        for sheet in ods_book.spreadsheet.childNodes:\nsrc/tablib/formats/__init__.py:16:    \"ods\": {\"package_name\": \"odfpy package\", \"extras_name\": \"ods\"},\nsrc/tablib/formats/__init__.py:76:        # and Dataset.get_<format>/set_<format> methods.\nsrc/tablib/formats/__init__.py:99:            self.register('ods', 'tablib.formats._ods.ODSFormat')\n",
  "stderr": "",
  "exit_code": 0
}

It seems `src/tablib/formats/_ods.py` is the main file for ODS format support.
I'll start by reproducing the bug.

{
  "command": "python3 - <<'PY'\nimport tablib\ntry:\n    book = tablib.Databook()\n    book.load(\n        tablib.Databook(sets=[tablib.Dataset((\"\",))]).export(\"ods\"),\n        format=\"ods\",\n    )\n    print(\"Success\")\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 4, in <module>\n  File \"/tablib/src/tablib/core.py\", line 903, in load\n    fmt.import_book(self, stream, **kwargs)\n  File \"/tablib/src/tablib/formats/_ods.py\", line 195, in import_book\n    cls.import_sheet(dset, sheet, headers)\n  File \"/tablib/src/tablib/formats/_ods.py\", line 121, in import_sheet\n    row_vals = [cls.read_cell(cell) for cell in row.childNodes if is_real_cell(cell)]\n  File \"/tablib/src/tablib/formats/_ods.py\", line 121, in <listcomp>\n    row_vals = [cls.read_cell(cell) for cell in row.childNodes if is_real_cell(cell)]\n  File \"/tablib/src/tablib/formats/_ods.py\", line 168, in read_cell\n    value = cls.read_cell(subnode, value_type)\n  File \"/tablib/src/tablib/formats/_ods.py\", line 158, in read_cell\n    value = cell.getAttribute('value')\n  File \"/usr/local/lib/python3.10/site-packages/odf/element.py\", line 547, in getAttribute\n    i = allowed_args.index(attr)\nValueError: 'value' is not in list\n",
  "exit_code": 0
}

The traceback shows the error is happening in `src/tablib/formats/_ods.py` (or rather, it's calling `odf/element.py` which raises `ValueError: 'value' is not in list`).

Wait, let's look at the traceback carefully:
```
  File "/tablib/src/tablib/formats/_ods.py", line 195, in import_book
    cls.import_sheet(dset, sheet, headers)
  File "/tablib/src/tablib/formats/_ods.py", line 121, in import_sheet
    row_vals = [cls.read_cell(cell) for cell in row.childNodes if is_real_cell(cell)]
  File "/tablib/src/tablib/formats/_ods.py", line 121, in <listcomp>
    row_vals = [cls.read_cell(cell) for cell in row.childNodes if is_real_cell(cell)]
  File "/tablib/src/tablib/formats/_ods.py", line 168, in read_cell
    value = cls.read_cell(subnode, value_type)
  File "/tablib/src/tablib/formats/_ods.py", line 158, in read_cell
    value = cell.getAttribute('value')
  File "/usr/local/lib/python3.10/site-packages/odf/element.py", line 547, in getAttribute
    i = allowed_args.index(attr)
ValueError: 'value' is not in list
```

It seems `cell.getAttribute('value')` is called, but the `odf` library's `getAttribute` raises a `ValueError` if the attribute is not allowed for that element.

Let's read `src/tablib/formats/_ods.py`.

{
  "filepath": "src/tablib/formats/_ods.py"
}

{
  "status": "ok",
  "filepath": "src/tablib/formats/_ods.py",
  "content": "\"\"\" Tablib - ODF Support.\n\"\"\"\n\nimport datetime as dt\nimport numbers\nfrom io import BytesIO\n\nfrom odf import number, opendocument, style, table, text\n\nimport tablib\n\nbold = style.Style(name=\"bold\", family=\"paragraph\")\nbold.addElement(style.TextProperties(\n    fontweight=\"bold\",\n    fontweightasian=\"bold\",\n    fontweightcomplex=\"bold\",\n))\n\n\ndef set_date_style(style):\n    style.addElement(number.Year(style=\"long\"))\n    style.addElement(number.Text(text=\"-\"))\n    style.addElement(number.Month(style=\"long\"))\n    style.addElement(number.Text(text=\"-\"))\n    style.addElement(number.Day(style=\"long\"))\n\n\ndef set_time_style(style):\n    style.addElement(number.Hours(style=\"long\"))\n    style.addElement(number.Text(text=\":\"))\n    style.addElement(number.Minutes(style=\"long\"))\n    style.addElement(number.Text(text=\":\"))\n    style.addElement(number.Seconds(style=\"long\", decimalplaces=\"0\"))\n\n\ndate_style = number.DateStyle(name=\"date-style1\")\nset_date_style(date_style)\nds = style.Style(\n    name=\"ds1\",\n    datastylename=\"date-style1\",\n    parentstylename=\"Default\",\n    family=\"table-cell\",\n)\n\ntime_style = number.DateStyle(name=\"time-style1\")\nset_time_style(time_style)\nts = style.Style(\n    name=\"ts1\",\n    datastylename=\"time-style1\",\n    parentstylename=\"Default\",\n    family=\"table-cell\",\n)\n\ndatetime_style = number.DateStyle(name=\"datetime-style1\")\nset_date_style(datetime_style)\ndatetime_style.addElement(number.Text(text=\" \"))\nset_time_style(datetime_style)\ndts = style.Style(\n    name=\"dts1\",\n    datastylename=\"datetime-style1\",\n    parentstylename=\"Default\",\n    family=\"table-cell\",\n)\n\n\nclass ODSFormat:\n    title = 'ods'\n    extensions = ('ods',)\n\n    @classmethod\n    def export_set(cls, dataset):\n        \"\"\"Returns ODF representation of Dataset.\"\"\"\n\n        wb = opendocument.OpenDocumentSpreadsheet()\n        wb.automaticstyles.addElement(bold)\n        wb.styles.addElement(date_style)\n        wb.automaticstyles.addElement(ds)\n        wb.styles.addElement(time_style)\n        wb.automaticstyles.addElement(ts)\n        wb.styles.addElement(datetime_style)\n        wb.automaticstyles.addElement(dts)\n\n        ws = table.Table(name=dataset.title if dataset.title else 'Tablib Dataset')\n        wb.spreadsheet.addElement(ws)\n        cls.dset_sheet(dataset, ws)\n\n        stream = BytesIO()\n        wb.save(stream)\n        return stream.getvalue()\n\n    @classmethod\n    def export_book(cls, databook):\n        \"\"\"Returns ODF representation of DataBook.\"\"\"\n\n        wb = opendocument.OpenDocumentSpreadsheet()\n        wb.automaticstyles.addElement(bold)\n\n        for i, dset in enumerate(databook._datasets):\n            ws = table.Table(name=dset.title if dset.title else f\"Sheet{i}\")\n            wb.spreadsheet.addElement(ws)\n            cls.dset_sheet(dset, ws)\n\n        stream = BytesIO()\n        wb.save(stream)\n        return stream.getvalue()\n\n    @classmethod\n    def import_sheet(cls, dset, sheet, headers=True, skip_lines=0):\n        \"\"\"Populate dataset `dset` with sheet data.\"\"\"\n\n        dset.title = sheet.getAttribute('name')\n\n        def is_real_cell(cell):\n            return cell.hasChildNodes() or not cell.getAttribute('numbercolumnsrepeated')\n\n        for i, row in enumerate(sheet.childNodes):\n            if row.tagName != 'table:table-row':\n                continue\n            if i < skip_lines:\n                continue\n            row_vals = [cls.read_cell(cell) for cell in row.childNodes if is_real_cell(cell)]\n            if not row_vals:\n                continue\n            if i == skip_lines and headers:\n                dset.headers = row_vals\n            else:\n                if i > skip_lines and len(row_vals) < dset.width:\n                    row_vals += [''] * (dset.width - len(row_vals))\n                dset.append(row_vals)\n\n    @classmethod\n    def read_cell(cls, cell, value_type=None):\n        def convert_date(val):\n            if 'T' in val:\n                return dt.datetime.strptime(val, \"%Y-%m-%dT%H:%M:%S\")\n            else:\n                return dt.datetime.strptime(val, \"%Y-%m-%d\").date()\n\n        if value_type is None:\n            value_type = cell.getAttribute('valuetype')\n        if value_type == 'date':\n            date_value = cell.getAttribute('datevalue')\n            if date_value:\n                return convert_date(date_value)\n        if value_type == 'time':\n            time_value = cell.getAttribute('timevalue')\n            try:\n                return dt.datetime.strptime(time_value, \"PT%HH%MM%SS\").time()\n            except ValueError:\n                # backwards compatibility for times exported with older tablib versions",
  "start_line": 1,
  "end_line": 150,
  "total_lines": 249,
  "is_truncated": true
}

I need to read the rest of `src/tablib/formats/_ods.py`.

{
  "filepath": "src/tablib/formats/_ods.py",
  "start_line": 151
}

{
  "status": "ok",
  "filepath": "src/tablib/formats/_ods.py",
  "content": "                return dt.datetime.strptime(time_value, \"%H:%M:%S\").time()\n        if value_type == 'boolean':\n            bool_value = cell.getAttribute('booleanvalue')\n            return bool_value == 'true'\n        if not cell.childNodes:\n            value = getattr(cell, 'data', None)\n            if value is None:\n                value = cell.getAttribute('value')\n            if value is None:\n                return ''\n            if value_type == 'float':\n                return float(value)\n            if value_type == 'date':\n                return convert_date(value)\n            return value  # Any other type default to 'string'\n\n        for subnode in cell.childNodes:\n            value = cls.read_cell(subnode, value_type)\n            if value:\n                return value\n\n    @classmethod\n    def import_set(cls, dset, in_stream, headers=True, skip_lines=0):\n        \"\"\"Populate dataset `dset` from ODS stream.\"\"\"\n\n        dset.wipe()\n\n        ods_book = opendocument.load(in_stream)\n        for sheet in ods_book.spreadsheet.childNodes:\n            if sheet.qname[1] == 'table':\n                cls.import_sheet(dset, sheet, headers, skip_lines)\n\n    @classmethod\n    def import_book(cls, dbook, in_stream, headers=True):\n        \"\"\"Populate databook `dbook` from ODS stream.\"\"\"\n\n        dbook.wipe()\n\n        ods_book = opendocument.load(in_stream)\n\n        for sheet in ods_book.spreadsheet.childNodes:\n            if sheet.qname[1] != 'table':\n                continue\n            dset = tablib.Dataset()\n            cls.import_sheet(dset, sheet, headers)\n            dbook.add_sheet(dset)\n\n    @classmethod\n    def dset_sheet(cls, dataset, ws):\n        \"\"\"Completes given worksheet from given Dataset.\"\"\"\n        _package = dataset._package(dicts=False)\n\n        for i, sep in enumerate(dataset._separators):\n            _offset = i\n            _package.insert((sep[0] + _offset), (sep[1],))\n\n        for row_number, row in enumerate(_package, start=1):\n            is_header = row_number == 1 and dataset.headers\n            style = bold if is_header else None\n            odf_row = table.TableRow(stylename=style)\n            ws.addElement(odf_row)\n            for j, col in enumerate(row):\n                if isinstance(col, numbers.Number):\n                    cell = table.TableCell(valuetype=\"float\", value=col)\n                elif isinstance(col, dt.datetime):\n                    cell = table.TableCell(\n                        valuetype=\"date\",\n                        datevalue=col.strftime('%Y-%m-%dT%H:%M:%S'),\n                        stylename=dts,\n                    )\n                    cell.addElement(text.P(text=col.strftime('%Y-%m-%d %H:%M:%S')))\n                elif isinstance(col, dt.date):\n                    date_value = col.strftime('%Y-%m-%d')\n                    cell = table.TableCell(valuetype=\"date\", datevalue=date_value, stylename=ds)\n                    cell.addElement(text.P(text=date_value))\n                elif isinstance(col, dt.time):\n                    cell = table.TableCell(\n                        valuetype=\"time\",\n                        timevalue=col.strftime('PT%HH%MM%SS'),\n                        stylename=ts,\n                    )\n                    cell.addElement(text.P(text=col.strftime('%H:%M:%S')))\n                elif col is None:\n                    cell = table.TableCell(valuetype=\"void\")\n                else:\n                    cell = table.TableCell(valuetype=\"string\")\n                    cell.addElement(text.P(text=str(col), stylename=style))\n                odf_row.addElement(cell)\n\n    @classmethod\n    def detect(cls, stream):\n        if isinstance(stream, bytes):\n            # load expects a file-like object.\n            stream = BytesIO(stream)\n        try:\n            opendocument.load(stream)\n            return True\n        except Exception:\n            return False",
  "start_line": 151,
  "end_line": 249,
  "total_lines": 249,
  "is_truncated": false
}

The problematic part seems to be here:
```python
158:            if value is None:
159:                value = cell.getAttribute('value')
160:            if value is None:
161:                return ''
```
Wait, the traceback said:
```
  File "/tablib/src/tablib/formats/_ods.py", line 168, in read_cell
    value = cls.read_cell(subnode, value_type)
  File "/tablib/src/tablib/formats/_ods.py", line 158, in read_cell
    value = cell.getAttribute('value')
```
Looking at the code:
Line 168 is:
```python
        for subnode in cell.childNodes:
            value = cls.read_cell(subnode, value_type)
            if value:
                return value
```
This calls `read_cell(subnode, value_type)` recursively.
In the recursive call, `value_type` is now not `None` (it was `cell.getAttribute('valuetype')` in the caller).

Wait, let's re-examine `read_cell`:
```python
    @classmethod
    def read_cell(cls, cell, value_type=None):
        def convert_date(val):
            # ... (omitted)

        if value_type is None:
            value_type = cell.getAttribute('valuetype')
        if value_type == 'date':
            date_value = cell.getAttribute('datevalue')
            if date_value:
                return convert_date(date_value)
        if value_type == 'time':
            time_value = cell.getAttribute('timevalue')
            try:
                return dt.datetime.strptime(time_value, "PT%HH%MM%SS").time()
            except ValueError:
                # ... (omitted)
        if value_type == 'boolean':
            bool_value = cell.getAttribute('booleanvalue')
            return bool_value == 'true'
        if not cell.childNodes:
            value = getattr(cell, 'data', None)
            if value is None:
                value = cell.getAttribute('value')
            if value is None:
                return ''
            # ... (omitted)
        
        for subnode in cell.childNodes:
            value = cls.read_cell(subnode, value_type)
            if value:
                return value
```

If `value_type` is not 'date', 'time', or 'boolean', it goes to:
```python
        if not cell.childNodes:
            # ...
```
If `cell.childNodes` is NOT empty, it goes to:
```python
        for subnode in cell.childNodes:
            value = cls.read_cell(subnode, value_type)
            if value:
                return value
```
In the recursive call, `value_type` is passed.
Now inside `read_cell(subnode, value_type)`:
1. `value_type` is NOT `None`.
2. Suppose `value_type` is 'string' (which is common).
3. It skips 'date', 'time', 'boolean'.
4. It checks `if not subnode.childNodes:`. If `subnode` has no children:
   - `value = getattr(subnode, 'data', None)`
   - If `value` is `None`, it calls `subnode.getAttribute('value')`.

And HERE is where `odf` raises `ValueError: 'value' is not in list`. The `subnode` is likely a `text.P` or similar element which does not have a 'value' attribute.

Wait, if `value_type` is 'string', and the cell has child nodes, it's likely that the text is inside a `text.P` element, and that `text.P` element's text is what we want.

Let's look at `dset_sheet` (the export part) to see how strings are exported:
```python
                else:
                    cell = table.TableCell(valuetype="string")
                    cell.addElement(text.P(text=str(col), stylename=style))
                    odf_row.addElement(cell)
```
So for a string, it creates a `TableCell` with `valuetype="string"`, and adds a `text.P` child with the text.

Now let's trace `read_cell` for this:
1. `read_cell(cell, None)`:
   - `value_type = cell.getAttribute('valuetype')` -> 'string'.
   - `cell.childNodes` is NOT empty (contains `text.P`).
   - Loop children: `read_cell(subnode, 'string')` where `subnode` is `text.P`.
2. `read_cell(subnode, 'string')`:
   - `value_type` is 'string'.
   - `subnode.childNodes` might be empty or not.
   - If `subnode.childNodes` is empty:
     - `value = getattr(subnode, 'data', None)`
     - If `value` is `None`, `subnode.getAttribute('value')` is called.
     - Since `subnode` is `text.P`, `getAttribute('value')` fails.

But wait, if `col` was `""` (empty string):
```python
                    cell = table.TableCell(valuetype="string")
                    cell.addElement(text.P(text=str(col), stylename=style))
```
`text.P(text="")` is created.

Now if we load it:
`subnode` is `text.P(text="")`.
`subnode.childNodes` might be empty.
`getattr(subnode, 'data', None)` might be `None`.
`subnode.getAttribute('value')` is called and fails.

If `col` was `None`:
```python
                elif col is None:
                    cell = table.TableCell(valuetype="void")
```
`read_cell(cell, None)` -> `value_type` is 'void'.
`cell.childNodes` is empty.
`getattr(cell, 'data', None)` -> `None`.
`cell.getAttribute('value')` -> 'void' probably doesn't have 'value' either? Wait, let's check.
Actually, if `col` is `None`, `value_type` is 'void'.
If `value_type` is 'void', the first `if`s are skipped.
`cell.childNodes` is empty.
`getattr(cell, 'data', None)` -> `None`.
`cell.getAttribute('value')` -> this might also fail? But the issue says "If the empty string is replaced with None the problem does not occur."

Wait, if `col` is `None`, `valuetype` is "void".
If `valuetype` is "void", it does not enter the 'date', 'time', 'boolean' blocks.
If `cell.childNodes` is empty:
`value = getattr(cell, 'data', None)`
`value = cell.getAttribute('value')`
Wait, why does `getAttribute('value')` NOT fail for `valuetype="void"`?
Maybe `TableCell` with `valuetype="void"` allows `getAttribute('value')`?
Or maybe `getattr(cell, 'data, None)` returns something?

Actually, `odf` library's `getAttribute` raises `ValueError` if the attribute is not in the list of allowed attributes for that element.
For `table.TableCell`, 'value' might be allowed?
Let's check `odf` docs or just try to see what's happening.

Actually, if `valuetype` is "string", the content is in a child `text.P` element.
If `valuetype` is "float", the content is in the `value` attribute of `TableCell`.

Wait! Let's look at `read_cell` again.
```python
        if not cell.childNodes:
            value = getattr(cell, 'data', None)
            if value is None:
                value = cell.getAttribute('value')
            if value is None:
                return ''
```
This block is only entered if `cell.childNodes` is empty.
If `valuetype="string"`, the cell has a child `text.P`. So this block is skipped.
Instead, it goes to:
```python
        for subnode in cell.childNodes:
            value = cls.read_cell(subnode, value_type)
            if value:
                return value
```
And `read_cell(subnode, 'string')` is called.
Inside `read_cell(subnode, 'string')`, `subnode` is `text.P`.
`subnode.childNodes` might be empty.
Then it calls `subnode.getAttribute('value')`.
`text.P` definitely doesn't have a `value` attribute. That's why it fails.

But if `value` is "Something", then `read_cell(subnode, 'string')` might return "Something" before it hits `getAttribute('value')`?
No, if `subnode.childNodes` is empty, it always goes to:
```python
            value = getattr(subnode, 'data', None)
            if value is None:
                value = subnode.getAttribute('value')
```

Wait, if `subnode` is `text.P`, where is the text stored?
In `odfpy`, `text.P` has a `.text` attribute or its children are `text.Span` etc.
Actually, looking at `tablib`'s `dset_sheet`:
`cell.addElement(text.P(text=str(col), stylename=style))`

If `odfpy`'s `text.P(text="foo")` is created, how do we get "foo" back?
If I remember correctly, `text.P` elements in `odfpy` might store the text in `.text` attribute or in children.
But look at this code in `read_cell`:
```python
        if not cell.childNodes:
            value = getattr(cell, 'data', None)
```
Maybe `text.P` elements have a `.data` attribute?
If `text` is "foo", maybe `getattr(subnode, 'data', None)` returns "foo"?

If `text` is "", then `getattr(subnode, 'data', None)` probably returns `""` or `None`.
If it returns `""`, then `value` is `""`.
Then:
```python
            if value is None:
                value = cell.getAttribute('value')
```
This is skipped because `value` is `""`.
Then:
```python
            if value is None:
                return ''
```
This is skipped.
Then it returns `value` (which is `""`).

BUT, in the caller:
```python
        for subnode in cell.childNodes:
            value = cls.read_cell(subnode, value_type)
            if value:
                return value
```
If `read_cell` returned `""`, then `if value:` is FALSE!
So it continues to the next subnode, or finishes the loop.
If all subnodes return `""` or `None`, the loop finishes and the function returns `None`.

So if the cell contains an empty string, `read_cell(cell, None)` returns `None`.
Wait, that's not what the traceback says.
The traceback says it crashes at `cell.getAttribute('value')` inside `read_cell` when `cell` is a subnode.

Let's re-trace:
1. `read_cell(cell, None)`: `cell` is `TableCell(valuetype="string")`.
2. `cell.childNodes` contains `text.P(text="")`.
3. Call `read_cell(subnode, 'string')` where `subnode` is `text.P(text="")`.
4. In `read_cell(subnode, 'string')`:
   - `subnode.childNodes` is empty.
   - `value = getattr(subnode, 'data', None)`.
   - If `text.P(text="")` has `.data` as `None` or `""`.
   - If it's `None`, then `subnode.getAttribute('value')` is called and it crashes.
   - If it's `""`, then `value` is `""`. Then it doesn't call `getAttribute('value')`. It returns `""`.
5. Back in `read_cell(cell, None)`:
   - `value = ""`
   - `if value:` is False.
   - Loop continues.
   - Loop finishes.
   - Returns `None`.

Wait, if it returns `None`, why does the traceback show it crashing?
Ah, if `text.P(text="")` has `.data` as `None`.
Then `subnode.getAttribute('value')` is called.

Hold on, if `col` is "foo", then `text.P(text="foo")` is created.
Does `text.P(text="foo")` have `.data == "foo"`?
If so, `read_cell(subnode, 'string')` returns "foo".
In the caller: `if value:` is True, so it returns "foo". Correct.

If `col` is "", then `text.P(text="")` is created.
If `.data` is `None` or `""`.
If `.data` is `""`, then `value` is `""`, `if value:` is False, caller continues, eventually returns `None`.
If `.data` is `None`, then `subnode.getAttribute('value')` is called and crashes.

Wait, the traceback says:
```
  File "/tablib/src/tablib/formats/_ods.py", line 168, in read_cell
    value = cls.read_cell(subnode, value_type)
  File "/tablib/src/tablib/formats/_ods.py", line 158, in read_cell
    value = cell.getAttribute('value')
```
Line 158 is `value = cell.getAttribute('value')`.
Line 168 is `value = cls.read_cell(subnode, value_type)`.
This confirms my trace. `read_cell` is called recursively, and it hits `getAttribute('value')` on the subnode.

Now, why did the user say "If the empty string is replaced with None the problem does not occur"?
If `col` is `None`, the cell is:
```python
                elif col is None:
                    cell = table.TableCell(valuetype="void")
```
`cell.childNodes` is empty.
`read_cell(cell, None)`:
- `value_type = cell.getAttribute('valuetype')` -> 'void'.
- `cell.childNodes` is empty.
- `value = getattr(cell, 'data', None)` -> probably `None`.
- `value = cell.getAttribute('value')` -> `table.TableCell` might allow 'value' attribute even if it's void? Or maybe it doesn't crash because it's a `TableCell`?

Wait, the `odf` library's `getAttribute` check is based on the element type.
`table.TableCell` probably has 'value' in its allowed attributes.
`text.P` probably does NOT.

So we should avoid calling `getAttribute('value')` on elements that are not `TableCell`.
Actually, we only want to call `getAttribute('value')` if we know the element supports it.

But there's another bug here: `if value:` will be false for `""`.
If the result of `read_cell(subnode, value_type)` is `""`, it's ignored.

Let's verify this with a test case that has a non-empty string and an empty string.

{
  "command": "python3 - <<'PY'\nimport tablib\ndataset = tablib.Dataset([(\"foo\", \"bar\"), (\"\", \"baz\")])\nods_data = tablib.Dataset(dataset).export(\"ods\")\nbook = tablib.Databook()\nbook.load(ods_data, format=\"ods\")\nprint(f\"Loaded: {book._datasets[0]}\")\nPY\n"
}

{
  "status": "ok",
  "stdout": "Loaded: (('foo', 'bar'), ('', 'baz'))\n-----------------------------\n",
  "stderr": "",
  "exit_code": 0
}

Wait, the reproduction the user gave was:
```python
book = tablib.Databook()
book.load(
    tablib.Databook(sets=[tablib.Dataset(("",))]).export("ods"),
    format="ods",
)
```
My previous run with `("")` failed.
Wait, I just ran `[("foo", "bar"), ("", "baz")]` and it worked?
Let me re-run the exact reproduction.

{
  "command": "python3 - <<'PY'\nimport tablib\nbook = tablib.Databook()\ntry:\n    book.load(\n        tablib.Databook(sets=[tablib.Dataset((\"\",))]).export(\"ods\"),\n        format=\"ods\",\n    )\n    print(\"Success\")\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 4, in <module>\n  File \"/tablib/src/tablib/core.py\", line 903, in load\n    fmt.import_book(self, stream, **kwargs)\n  File \"/tablib/src/tablib/formats/_ods.py\", line 195, in import_book\n    cls.import_sheet(dset, sheet, headers)\n  File \"/tablib/src/tablib/formats/_ods.py\", line 121, in import_sheet\n    row_vals = [cls.read_cell(cell) for cell in row.childNodes if is_real_cell(cell)]\n  File \"/tablib/src/tablib/formats/_ods.py\", line 121, in <listcomp>\n    row_vals = [cls.read_cell(cell) for cell in row.childNodes if is_real_cell(cell)]\n  File \"/tablib/src/tablib/formats/_ods.py\", line 168, in read_cell\n    value = cls.read_cell(subnode, value_type)\n  File \"/tablib/src/tablib/formats/_ods.py\", line 158, in read_cell\n    value = cell.getAttribute('value')\n  File \"/usr/local/lib/python3.10/site-packages/odf/element.py\", line 547, in getAttribute\n    i = allowed_args.index(attr)\nValueError: 'value' is not in list\n",
  "exit_code": 0
}

Okay, it still fails. Now why did `[("foo", "bar"), ("", "baz")]` work?
Wait, I might have misread the output of my previous run.
Actually, I had:
`Loaded: (('foo', 'bar'), ('', 'baz'))`
Let me check if they actually were empty strings or None.

{
  "command": "python3 - <<'PY'\nimport tablib\ndataset = tablib.Dataset([(\"foo\", \"bar\"), (\"\", \"baz\")])\nods_data = tablib.Dataset(dataset).export(\"ods\")\nbook = tablib.Databook()\nbook.load(ods_data, format=\"ods\")\nprint(f\"Loaded: {book._datasets[0]}\")\n# Check types\nfor row in book._datasets[0]:\n    print(row)\nPY\n"
}

{
  "status": "ok",
  "stdout": "Loaded: (('foo', 'bar'), ('', 'baz'))\n-----------------------------\n",
  "stderr": "",
  "exit_code": 0
}

Wait, it's very strange. `("",)` fails but `("foo", "bar"), ("", "baz")` works?

Let's look at `import_sheet`:
```python
        for i, row in enumerate(sheet.childNodes):
            if row.tagName != 'table:table-row':
                continue
            if i < skip_lines:
                continue
            row_vals = [cls.read_cell(cell) for cell in row.childNodes if is_real_cell(cell)]
            if not row_vals:
                continue
```

If `row_vals` is `['']`, then `if not row_vals:` is False, and it proceeds.
If `row_vals` is `[]` (empty list), it skips.

Wait, I see what's happening. `cls.read_cell(cell)` returns `None` if it's an empty string (because `if value:` is False).

Let's test this hypothesis.

{
  "command": "python3 - <<'PY'\nimport tablib\ndataset = tablib.Dataset([(\"\",)])\nods_data = tablib.Dataset(dataset).export(\"ods\")\nbook = tablib.Databook()\ntry:\n    book.load(ods_data, format=\"ods\")\n    print(\"Success\")\nexcept Exception as e:\n    import traceback\n    traceback.print_exc()\nPY\n"
}

{
  "status": "ok",
  "stdout": "Success\n",
  "stderr": "",
  "exit_code": 0
}

Wait! It succeeded now? I am confused.
The user's reproduction code:
```python
book = tablib.Databook()
book.load(
    tablib.Databook(sets=[tablib.Dataset(("",))]).export("ods"),
    format="ods",
)
```
Wait, the user uses `tablib.Databook(sets=[tablib.Dataset(("",))]).export("ods")`.
My last run used `tablib.Dataset(dataset).export("ods")`.
Ah! `Databook.export("ods")` vs `Dataset.export("ods")`.

Let's check `Databook.export`:
```python
    @classmethod
    def export_book(cls, databook):
        """Returns ODF representation of DataBook."""

        wb = opendocument.OpenDocumentSpreadsheet()
        wb.automaticstyles.addElement(bold)

        for i, dset in enumerate(databook._datasets):
            ws = table.Table(name=dset.title if dset.title else f"Sheet{i}")
            wb.spreadsheet.addElement(ws)
            cls.dset_sheet(dset, ws)

        stream = BytesIO()
        wb.save(stream)
        return stream.getvalue()
```
It calls `cls.dset_sheet(dset, ws)`.
And `Dataset.export("ods")` calls `ODSFormat.export_set(dataset)`:
```python
    @classmethod
    def export_set(cls, dataset):
        """Returns ODF representation of Dataset."""

        wb = opendocument.OpenDocumentSpreadsheet()
        # ...
        ws = table.Table(name=dataset.title if dataset.title else 'Tablib Dataset')
        wb.spreadsheet.addElement(ws)
        cls.dset_sheet(dataset, ws)
        # ...
```
They both call `dset_sheet`.

Wait, let me try the EXACT reproduction code again.

{
  "command": "python3 - <<'PY'\nimport tablib\nbook = tablib.Databook()\ntry:\n    book.load(\n        tablib.Databook(sets=[tablib.Dataset((\"\",))]).export(\"ods\"),\n        format=\"ods\",\n    )\n    print(\"Success\")\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 4, in <module>\n  File \"/tablib/src/tablib/core.py\", line 903, in load\n    fmt.import_book(self, stream, **kwargs)\n  File \"/tablib/src/tablib/formats/_ods.py\", line 195, in import_book\n    cls.import_sheet(dset, sheet, headers)\n  File \"/tablib/src/tablib/formats/_ods.py\", line 121, in import_sheet\n    row_vals = [cls.read_cell(cell) for cell in row.childNodes if is_real_cell(cell)]\n  File \"/tablib/src/tablib/formats/_ods.py\", line 121, in <listcomp>\n    row_vals = [cls.read_cell(cell) for cell in row.childNodes if is_real_cell(cell)]\n  File \"/tablib/src/tablib/formats/_ods.py\", line 168, in read_cell\n    value = cls.read_cell(subnode, value_type)\n  File \"/tablib/src/tablib/formats/_ods.py\", line 158, in read_cell\n    value = cell.getAttribute('value')\n  File \"/usr/local/lib/python3.10/site-packages/odf/element.py\", line 547, in getAttribute\n    i = allowed_args.index(attr)\nValueError: 'value' is not in list\n",
  "exit_code": 0
}