jazzband__tablib-613

The user is reporting a `ValueError: 'value' is not in list` when loading an ODS file that was created from a `Dataset` containing an empty string.

Reproduction code:
```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`.
Based on the workspace layout, formats are likely under `src/tablib/formats`.

Let's start by finding the ODS implementation.

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

{
  "status": "ok",
  "stdout": "src/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
}

Okay, the implementation is in `src/tablib/formats/_ods.py`.
Let's try to reproduce 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 error occurs in `src/tablib/formats/_ods.py` in the `read_cell` method.
The traceback shows:
```python
  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
```

Wait, the ` AttributeError` is coming from `odf/element.py`. It seems `getAttribute('value')` is failing because 'value' is not a valid attribute for that specific cell element.

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

{
  "end_line": 210,
  "filepath": "src/tablib/formats/_ods.py",
  "start_line": 140
}

{
  "status": "ok",
  "filepath": "src/tablib/formats/_ods.py",
  "content": "            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\n                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)",
  "start_line": 140,
  "end_line": 210,
  "total_lines": 249,
  "is_truncated": false
}

Looking at the `read_cell` logic:

```python
140:             value_type = cell.getAttribute('valuetype')
...
154:         if not cell.childNodes:
155:             value = getattr(cell, 'data', None)
156:             if value is None:
157:                 value = cell.getAttribute('value')
158:             if value is None:
159:                 return ''
...
166: 
167:         for subnode in cell.childNodes:
168:             value = cls.read_cell(subnode, value_type)
169:             if value:
170:                 return value
```

Wait, if `cell.childNodes` exists, it iterates through them and calls `cls.read_cell(subnode, value_type)`.
The `read_cell` function is recursive.
The traceback shows:
```
  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')
```

So when `cls.read_cell(subnode, value_type)` is called, it enters the function.
If `subnode` has no child nodes, it tries `cell.getAttribute('value')` on line 158.
But `subnode` might not have a `value` attribute, causing `odfpy` to raise `ValueError`.

Let's look at `read_cell` more closely. I need to see the beginning of `read_cell`.

{
  "end_line": 165,
  "filepath": "src/tablib/formats/_ods.py",
  "start_line": 130
}

{
  "status": "ok",
  "filepath": "src/tablib/formats/_ods.py",
  "content": "\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\n                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'",
  "start_line": 130,
  "end_line": 165,
  "total_lines": 249,
  "is_truncated": false
}

The problem is that `cell.getAttribute('value')` is called on an element that might not have a `value` attribute. In `odfpy`, `getAttribute` raises `ValueError` if the attribute is not in the allowed list for that element.

The reproduction case is an empty string.
When we export an empty string to ODS, how is it stored?
If we can see how it's exported, it might help.

Let's find where the ODS export is implemented.

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

{
  "status": "ok",
  "stdout": "71:    def export_set(cls, dataset):\n92:    def export_book(cls, databook):\n150:                # backwards compatibility for times exported with older tablib versions\n",
  "stderr": "",
  "exit_code": 0
}

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

{
  "end_line": 110,
  "filepath": "src/tablib/formats/_ods.py",
  "start_line": 71
}

{
  "status": "ok",
  "filepath": "src/tablib/formats/_ods.py",
  "content": "    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",
  "start_line": 71,
  "end_line": 110,
  "total_lines": 249,
  "is_truncated": false
}

And `dset_sheet`:

{
  "end_line": 220,
  "filepath": "src/tablib/formats/_ods.py",
  "start_line": 211
}

{
  "status": "ok",
  "filepath": "src/tablib/formats/_ods.py",
  "content": "            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                    )",
  "start_line": 211,
  "end_line": 220,
  "total_lines": 249,
  "is_truncated": false
}

I need more of `dset_sheet`.

{
  "end_line": 249,
  "filepath": "src/tablib/formats/_ods.py",
  "start_line": 221
}

{
  "status": "ok",
  "filepath": "src/tablib/formats/_ods.py",
  "content": "                    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": 221,
  "end_line": 249,
  "total_lines": 249,
  "is_truncated": false
}

In `dset_sheet`:
```python
                elif col is None:
                    cell = table.TableCell(valuetype="void")
                else:
                    cell = table.TableCell(valuetype="string")
                    cell.addElement(text.P(text=str(col), stylename=style))
```
When `col` is an empty string `""`, it goes to the `else` block:
`cell = table.TableCell(valuetype="string")`
`cell.addElement(text.P(text=str(col), stylename=style))`

So it creates a `TableCell` with `valuetype="string"` and adds a child node (a paragraph `text.P` containing the text).

Now let's look at `read_cell` again:
```python
    @classmethod
    def read_cell(cls, cell, value_type=None):
        ...
        if value_type is None:
            value_type = cell.getAttribute('valuetype')
        ...
        if not cell.childNodes:
            ...
            if value is None:
                value = cell.getAttribute('value')
            ...
        
        for subnode in cell.childNodes:
            value = cls.read_cell(subnode, value_type)
            if value:
                return value
```

Wait! If `col` was an empty string, `cell.childNodes` contains a `text.P` element.
The loop iterates over `childNodes`:
`value = cls.read_cell(subnode, value_type)` where `subnode` is the `text.P` element.

Now, inside that recursive call:
1. `value_type` is "string".
2. `subnode` is `text.P`.
3. `subnode.childNodes` is probably empty.
4. It enters `if not cell.childNodes:` (where `cell` is actually this `subnode`).
5. `value = getattr(cell, 'data', None)` -> `text.P` might have `data`.
6. If `value` is `None`, it calls `value = cell.getAttribute('value')`.
7. Since `cell` is a `text.P` element, it doesn't have a `value` attribute, and `odfpy` raises `ValueError`.

Actually, if the text in `text.P` is an empty string, does `getattr(cell, 'data', None)` return `None` or `""`?
If it returns `""`, then `if value is None:` will be false, and it will proceed to:
```python
            if value_type == 'float':
                return float(value)
            if value_type == 'date':
                return convert_date(value)
            return value  # Any other type default to 'string'
```
It would return `""`.

But wait, if `value` is `""`, then in the caller:
```python
        for subnode in cell.childNodes:
            value = cls.read_cell(subnode, value_type)
            if value:
                return value
```
`if value:` is False for `""`.
So it continues the loop. If there are no more subnodes, it finishes the loop and the function returns `None` (implicitly).

Wait, if `read_cell` returns `None`, what happens?
In `import_sheet`:
```python
    def import_sheet(cls, dset, sheet, headers):
        ...
        row_vals = [cls.read_cell(cell) for cell in row.childNodes if is_real_cell(cell)]
```
`row_vals` will contain `None`.

But the traceback says it fails at `cell.getAttribute('value')` in `read_cell`.
This means `getattr(cell, 'data', None)` returned `None` for the `text.P` node.

Let's verify what a `text.P` node has.
If it's a `text.P` node, its text is usually in a child `text.Text` node.

Let's check `odfpy`'s `text.P` and `text.Text`. Actually, I don't have the source of `odfpy` easily available, but I can test with a script.

I'll write a reproduction script that prints the type and attributes of the cell and its children.

{
  "command": "python3 - <<'PY'\nimport tablib\nfrom odf import opendocument, table, text\nfrom io import BytesIO\n\n# Create an ODS with an empty string\nbook = tablib.Databook(sets=[tablib.Dataset((\"\",))])\nods_data = book.export(\"ods\")\nstream = BytesIO(ods_data)\nods_book = opendocument.load(stream)\n\nsheet = ods_book.spreadsheet.childNodes[0]\nrow = sheet.childNodes[0]\ncell = row.childNodes[0]\n\nprint(f\"Cell: {cell}\")\nprint(f\"CellValueType: {cell.getAttribute('valuetype')}\")\nprint(f\"CellChildren: {cell.childNodes}\")\n\nfor child in cell.childNodes:\n    print(f\"Child: {child}\")\n    print(f\"ChildData: {getattr(child, 'data', None)}\")\n    try:\n        print(f\"ChildValueAttr: {child.getAttribute('value')}\")\n    except Exception as e:\n        print(f\"ChildValueAttr Error: {e}\")\n    print(f\"ChildChildren: {child.childNodes}\")\n    for grandchild in child.childNodes:\n        print(f\"Grandchild: {grandchild}\")\n        print(f\"GrandchildData: {getattr(grandchild, 'data', None)}\")\nPY\n"
}

{
  "status": "ok",
  "stdout": "Cell: \nCellValueType: string\nCellChildren: [<odf.element.Element object at 0x754a49d2b8e0>]\nChild: \nChildData: None\nChildValueAttr Error: 'value' is not in list\nChildChildren: []\n",
  "stderr": "",
  "exit_code": 0
}

Interesting. For an empty string, the `text.P` node has no children and its `data` is `None`.
Wait, if it's an empty string, why does it have a child `text.P` at all?
The `export_set` code does:
```python
                else:
                    cell = table.TableCell(valuetype="string")
                    cell.addElement(text.P(text=str(col), stylename=style))
```
`text.P(text="")` creates a paragraph.

Now look at `read_cell` again:
```python
        for subnode in cell.childNodes:
            value = cls.read_cell(subnode, value_type)
            if value:
                return value
```
If `read_cell(subnode, value_type)` returns `""` or `None`, it's considered falsy, and the loop continues.
If it returns `None`, it's falsy.

Wait, the issue is that `read_cell` is called recursively on the `text.P` node.
If `subnode` is `text.P(text="")`, it has no child nodes.
Then it does:
```python
        if not cell.childNodes:
            value = getattr(cell, 'data', None)
            if value is None:
                value = cell.getAttribute('value') # BOOM!
```
Indeed, the `text.P` node has no children, and `getattr(cell, 'data', None)` is `None`. So it tries `getAttribute('value')`, which fails because `text.P` does not have a `value` attribute.

If the string was NOT empty, say `"hello"`, then:
`cell.addElement(text.P(text="hello", stylename=style))`
The `text.P` node would likely have a child `text.Text` node containing `"hello"`.

Wait, let's test with a non-empty string.

{
  "command": "python3 - <<'PY'\nimport tablib\nfrom odf import opendocument, table, text\nfrom io import BytesIO\n\n# Create an ODS with a non-empty string\nbook = tablib.Databook(sets=[tablib.Dataset((\"hello\",))])\nods_data = book.export(\"ods\")\nstream = BytesIO(ods_data)\nods_book = opendocument.load(stream)\n\nsheet = ods_book.spreadsheet.childNodes[0]\nrow = sheet.childNodes[0]\ncell = row.childNodes[0]\n\nprint(f\"Cell: {cell}\")\nprint(f\"CellValueType: {cell.getAttribute('valuetype')}\")\nprint(f\"CellChildren: {cell.childNodes}\")\n\nfor child in cell.childNodes:\n    print(f\"Child: {child}\")\n    print(f\"ChildData: {getattr(child, 'data', None)}\")\n    print(f\"ChildChildren: {child.childNodes}\")\n    for grandchild in child.childNodes:\n        print(f\"Grandchild: {grandchild}\")\n        print(f\"GrandchildData: {getattr(grandchild, 'data', None)}\")\nPY\n"
}

{
  "status": "ok",
  "stdout": "Cell: hello\nCellValueType: string\nCellChildren: [<odf.element.Element object at 0x7594715cf790>]\nChild: hello\nChildData: None\nChildChildren: [<odf.element.Text object at 0x7594715cf730>]\nGrandchild: hello\nGrandchildData: hello\n",
  "stderr": "",
  "exit_code": 0
}

Okay!
Non-empty string case:
`TableCell` -> `text.P` -> `text.Text` (where `data` is `"hello"`)

Empty string case:
`TableCell` -> `text.P` (no children, `data` is `None`)

So in the empty string case:
1. `read_cell(TableCell)` sees `childNodes` (the `text.P` node).
2. It calls `read_cell(text.P)`.
3. `read_cell(text.P)` sees no `childNodes`.
4. It tries `getattr(text.P, 'data', None)`, which is `None`.
5. It tries `text.P.getAttribute('value')`, which raises `ValueError`.

The fix should be to handle the case where `getAttribute('value')` fails or to check if the attribute exists.
However, `odfpy`'s `getAttribute` doesn't tell you if it exists; it just raises `ValueError` if you ask for something that is not allowed.

We can wrap `cell.getAttribute('value')` in a `try-except ValueError` block.

But wait, there's another issue. If `read_cell` returns `""` (empty string), the caller does:
```python
        for subnode in cell.childNodes:
            value = cls.read_cell(subnode, value_type)
            if value:
                return value
```
`if value:` is False for `""`, so it continues. If it's the only child, the function returns `None`.
The original `tablib` logic probably wanted to return `""` if the cell was explicitly set to an empty string.

But if `read_cell` returns `None`, it's treated as "not found" and we continue looking in other children.
Wait, if it returns `None`, and there are no more children, then `read_cell` returns `None`.
Then in `import_sheet`:
```python
    row_vals = [cls.read_cell(cell) for cell in row.childNodes if is_real_cell(cell)]
```
`row_vals` will contain `None`. When this is assigned to a `Dataset`, `None` is usually okay.

But the problem is specifically the `ValueError`.

Let's see where else `getAttribute` is used.
```python
        if value_type is None:
            value_type = cell.getAttribute('valuetype')
        if value_type == 'date':
            date_value = cell.getAttribute('datevalue')
            ...
        if value_type == 'time':
            time_value = cell.getAttribute('timevalue')
            ...
        if value_type == 'boolean':
            bool_value = cell.getAttribute('booleanvalue')
            ...
```
If `cell` is a `text.P` node, `cell.getAttribute('valuetype')` will also raise `ValueError`!

Wait, the first call to `read_cell` is on a `TableCell`. `TableCell` has `valuetype`.
Then it calls `read_cell(subnode, value_type)`.
In the second call, `value_type` is NOT `None` anymore, so it doesn't call `cell.getAttribute('valuetype')`.

But it still calls `cell.getAttribute('value')` if `not cell.childNodes`.

Let's look at the code again.
```python
133:     @classmethod
134:     def read_cell(cls, cell, value_type=None):
...
137:         if value_type is None:
138:             value_type = cell.getAttribute('valuetype')
```
When `cls.read_cell(subnode, value_type)` is called, `value_type` is passed, so line 138 is skipped.

Then:
```python
140:         if value_type == 'date':
...
146:         if value_type == 'time':
...
152:         if value_type == 'boolean':
...
155:         if not cell.childNodes:
156:             value = getattr(cell, 'data', None)
157:             if value is None:
158:                 value = cell.getAttribute('value')
```
If `value_type` is "string", it skips the date/time/boolean blocks and hits `if not cell.childNodes`.
Since `text.P` has no child nodes in the empty string case, it tries `cell.getAttribute('value')` and crashes.

The simplest fix is to wrap `cell.getAttribute('value')` in a `try...except ValueError`.

Wait, if `value_type` is "string" and it's an empty string, it should return `""`.
If we wrap it in `try...except ValueError: value = None`, then:
```python
            if value is None:
                try:
                    value = cell.getAttribute('value')
                except ValueError:
                    value = None
            if value is None:
                return ''
```
This would return `''` for the empty string case.

However, we should also be careful about other `getAttribute` calls.
If we are in the recursive call, `cell` is a subnode (like `text.P` or `text.Text`).
Should we be calling `getAttribute` on those?

Actually, looking at `odfpy` documentation or common usage, `TableCell` has these attributes, but `text.P` or `text.Text` do not.

The loop:
```python
        for subnode in cell.childNodes:
            value = cls.read_cell(subnode, value_type)
            if value:
                return value
```
If `read_cell` returns `""`, it is ignored. This seems like a bug if the cell is intentionally an empty string. But if it's an empty string, we want to return `""`.

Wait, if the loop finishes without returning, `read_cell` returns `None`.
And `import_sheet` does:
```python
    row_vals = [cls.read_cell(cell) for cell in row.childNodes if is_real_cell(cell)]
```
If `read_cell` returns `None`, it's stored as `None`. This matches what the user says: "If the empty string is replaced with None the problem does not occur."

So if we fix the `ValueError` and return `None` (or `''`), will it be correct?
The user says "When saving data containing the empty string to ODS format, the resulting ODS file is not loadable". They would likely expect the empty string to be preserved.

If I change:
```python
        for subnode in cell.childNodes:
            value = cls.read_cell(subnode, value_type)
            if value:
                return value
```
to:
```python
        for subnode in cell.childNodes:
            value = cls.read_cell(subnode, value_type)
            if value is not None:
                return value
```
Then it would return `""` if `read_cell` returns `""`.

Let's test this hypothesis.
If I have a non-empty string `"hello"`, `read_cell(TableCell)` calls `read_cell(text.P)`.
`read_cell(text.P)` calls `read_cell(text.Text)`.
`read_cell(text.Text)` sees no child nodes and returns `getattr(cell, 'data')` which is `"hello"`.
Then `read_cell(text.P)` receives `"hello"`, `if value:` is true, returns `"hello"`.
Then `read_cell(TableCell)` receives `"hello"`, `if value:` is true, returns `"hello"`.
This works for non-empty strings.

For empty strings:
`read_cell(TableCell)` calls `read_cell(text.P)`.
`read_cell(text.P)` sees no child nodes, `getattr(cell, 'data', None)` is `None`, `cell.getAttribute('value')` fails (which we will fix).
If it returns `''`, then `read_cell(TableCell)` sees `value = ''`.
Currently, `if value:` is false, so it continues.
If we change it to `if value is not None:`, it returns `''`.

So we need two changes:
1. Wrap `cell.getAttribute('value')` in `try...except ValueError`.
2. Change `if value:` to `if value is not None:` in the recursion loop.

Let's refine the `try...except` location.
```python
            if value is None:
                try:
                    value = cell.getAttribute('value')
                except ValueError:
                    value = None
```
Is there a better way? Maybe `getattr(cell, 'getAttribute', lambda x: None)('value')`? No, because `getAttribute` exists but raises `ValueError`.

Wait, I should check if other `getAttribute` calls need this too.
On the first call to `read_cell`, `cell` is a `TableCell`, which is guaranteed to have `valuetype` (or at least `odfpy` allows it).
On subsequent calls, `value_type` is passed, so `cell.getAttribute('valuetype')` is not called.
But what about:
```python
        if value_type == 'date':
            date_value = cell.getAttribute('datevalue')
```
If `value_type` is "date", and we are in a recursive call on a `text.P` node, it will call `cell.getAttribute('datevalue')` and potentially fail.
But `text.P` nodes won't be encountered if `value_type` is "date", unless the ODS is malformed. Usually, "date" types a handled differently.

Wait, let's check `export_set` for "date":
```python
                elif isinstance(col, dt.datetime):
                    cell = table.TableCell(
                        valuetype="date",
                        datevalue=col.strftime('%Y-%m-%dT%H:%M:%S'),
                        stylename=dts,
                    )
```
Here, the `TableCell` has `datevalue`. No `text.P` is added.
So for "date", `cell.childNodes` will be empty.
Then `read_cell(TableCell)` hits:
```python
        if value_type == 'date':
            date_value = cell.getAttribute('datevalue')
            if date_value:
                return convert_date(date_value)
```
This works.

What about other types?
"time":
```python
                elif isinstance(col, dt.time):
                    cell = table.TableCell(
                        valuetype="time",
                        timevalue=col.strftime('PT%HH%MM%SS'),
                        stylename=ts,
                    )
                    cell.addElement(text.P(text=col.strftime('%H:%M:%S')))
```
Here it has BOTH `timevalue` attribute AND a child `text.P` node.
`read_cell(TableCell)` will first check `value_type == 'time'`, call `cell.getAttribute('timevalue')`, and return the time. It won't even reach the `childNodes` loop.

"boolean":
```python
        if value_type == 'boolean':
            bool_value = cell.getAttribute('booleanvalue')
            return bool_value == 'true'
```
Similarly, if it's boolean, it returns early.

So the only case that reaches the `childNodes` loop and then calls `read_cell` recursively is "string" (and potentially others if they didn't return early).

And for "string", we have:
```python
                else:
                    cell = table.TableCell(valuetype="string")
                    cell.addElement(text.P(text=str(col), stylename=style))
```
The `TableCell` has `valuetype="string"` but NO `value` attribute.
`read_cell(TableCell)` sees `value_type="string"`, skips date/time/boolean, sees `childNodes`, calls `read_cell(text.P)`.
`read_cell(text.P)` sees no `childNodes`, tries `getattr(text.P, 'data')` -> None, tries `text.P.getAttribute('value')` -> BOOM.

So, the fix:
1. Wrap `cell.getAttribute('value')` in `try...except ValueError`.
2. Change `if value:` to `if value is not None:`.

Let's double check if `getattr(cell, 'data', None)` already covers the empty string case if we use a different approach.
In my reproduction:
For `text.Text`, `data` was `"hello"`.
For `text.P`, `data` was `None`.
For `text.P` with empty string, `data` was `None`.

Wait, if `text.P` has no children, it's just an empty paragraph.
If it has children, one of them is `text.Text`, and that has the `data`.

So for an empty string, `text.P` has no children.
`read_cell(text.P)`:
- `cell.childNodes` is empty.
- `getattr(cell, 'data', None)` is `None`.
- `cell.getAttribute('value')` -> `ValueError`.

If we fix it to return `''`, then the caller `read_cell(TableCell)` will receive `''`.
And if we change `if value:` to `if value is not None:`, it will return `''`.

Let's see if there are any other places where `if value:` might be a problem.
```python
        for subnode in cell.childNodes:
            value = cls.read_cell(subnode, value_type)
            if value:
                return value
```
If `read_cell` returns `0` (integer), `if value:` will be false.
Is it possible for `read_cell` to return `0`?
If `value_type` is "float":
```python
            if value_type == 'float':
                return float(value)
```
If `value` is `"0"`, then `float("0")` is `0.0`.
`if 0.0:` is false.
So it would skip the `0.0` value! This is definitely a bug.

So changing `if value:` to `if value is not None:` is not just about empty strings, it's also about zeros.

Let me verify this with a test case.

{
  "command": "python3 - <<'PY'\nimport tablib\nfrom io import BytesIO\n\n# Create an ODS with a zero\nbook = tablib.Databook(sets=[tablib.Dataset([[0]])])\nods_data = book.export(\"ods\")\nstream = BytesIO(ods_data)\nloaded_book = tablib.Databook()\nloaded_book.load(stream, format=\"ods\")\n\nprint(f\"Loaded data: {loaded_book._datasets[0].rows}\")\nPY\n"
}

{
  "status": "error",
  "error_type": "CommandError",
  "error_message": "Traceback (most recent call last):\n  File \"<stdin>\", line 11, in <module>\nAttributeError: 'Dataset' object has no attribute 'rows'\n",
  "details": {
    "stdout": "",
    "stderr": "Traceback (most recent call last):\n  File \"<stdin>\", line 11, in <module>\nAttributeError: 'Dataset' object has no attribute 'rows'\n",
    "exit_code": 1
  }
}

My mistake, `Dataset` uses `rows` maybe? No, it's a list-like object. Let's just print it.

{
  "command": "python3 - <<'PY'\nimport tablib\nfrom io import BytesIO\n\n# Create an ODS with a zero\nbook = tablib.Databook(sets=[tablib.Dataset([[0]])])\nods_data = book.export(\"ods\")\nstream = BytesIO(ods_data)\nloaded_book = tablib.Databook()\nloaded_book.load(stream, format=\"ods\")\n\nprint(f\"Loaded data: {loaded_book._datasets[0]}\")\nPY\n"
}

{
  "status": "ok",
  "stdout": "Loaded data: [0]\n---\n",
  "stderr": "",
  "exit_code": 0
}