docling-project__docling-2983

The user is reporting a crash in `AsciiDocBackend._parse_picture()` when the image alt text contains commas.
The error is `ValueError: not enough values to unpack (expected 2, got 1)`.
This is likely because the code splits the attributes in the `image::` macro by comma, but alt text can also contain commas.

Let's start by locating `AsciiDocBackend` and `_parse_picture`.

{
  "command": "grep -rn --include=\"*.py\" \"_parse_picture\" ."
}

{
  "status": "ok",
  "stdout": "./docling/backend/asciidoc_backend.py:204:                item = self._parse_picture(line)\n./docling/backend/asciidoc_backend.py:404:    def _parse_picture(line):\n./tests/test_backend_asciidoc.py:25:def test_parse_picture():\n./tests/test_backend_asciidoc.py:29:    res = AsciiDocBackend._parse_picture(line)\n./tests/test_backend_asciidoc.py:36:    res = AsciiDocBackend._parse_picture(line)\n",
  "stderr": "",
  "exit_code": 0
}

Okay, the method is in `docling/backend/asciidoc_backend.py`.
Let's read the implementation of `_parse_picture` in `docling/backend/asciidoc_backend.py`.

{
  "end_line": 430,
  "filepath": "docling/backend/asciidoc_backend.py",
  "start_line": 380
}

{
  "status": "ok",
  "filepath": "docling/backend/asciidoc_backend.py",
  "content": "                row_span = 1\n                col_span = 1\n\n                cell = TableCell(\n                    text=text,\n                    row_span=row_span,\n                    col_span=col_span,\n                    start_row_offset_idx=row_idx,\n                    end_row_offset_idx=row_idx + row_span,\n                    start_col_offset_idx=col_idx,\n                    end_col_offset_idx=col_idx + col_span,\n                    column_header=row_idx == 0,\n                    row_header=False,\n                )\n                data.table_cells.append(cell)\n\n        return data\n\n    #   =========   Pictures\n    @staticmethod\n    def _is_picture(line):\n        return re.match(r\"^image::\", line)\n\n    @staticmethod\n    def _parse_picture(line):\n        \"\"\"\n        Parse an image macro, extracting its path and attributes.\n        Syntax: image::path/to/image.png[Alt Text, width=200, height=150, align=center]\n        \"\"\"\n        mtch = re.match(r\"^image::(.+)\\[(.*)\\]$\", line)\n        if mtch:\n            picture_path = mtch.group(1).strip()\n            attributes = mtch.group(2).split(\",\")\n            picture_info = {\"type\": \"picture\", \"uri\": picture_path}\n\n            # Extract optional attributes (alt text, width, height, alignment)\n            if attributes:\n                picture_info[\"alt\"] = attributes[0].strip() if attributes[0] else \"\"\n                for attr in attributes[1:]:\n                    key, value = attr.split(\"=\")\n                    picture_info[key.strip()] = value.strip()\n\n            return picture_info\n\n        return {\"type\": \"picture\", \"uri\": line}\n\n    #   =========   Captions\n    @staticmethod\n    def _is_caption(line):\n        return re.match(r\"^\\.(.+)\", line)\n",
  "start_line": 380,
  "end_line": 430,
  "total_lines": 443,
  "is_truncated": false
}

The bug is indeed here:
```python
            # Extract optional attributes (alt text, width, height, alignment)
            if attributes:
                picture_info["alt"] = attributes[0].strip() if attributes[0] else ""
                for attr in attributes[1:]:
                    key, value = attr.split("=")
                    picture_info[key.strip()] = value.strip()
```
If `attributes[1:]` contains elements that don't have `=`, `attr.split("=")` will return a list with only one element, and `key, value = attr.split("=")` will raise `ValueError: not enough values to unpack (expected 2, got 1)`.

If alt text contains commas, e.g., `[A screenshot showing a dialog box, containing text fields, buttons, and validation errors, width=604, height=422]`, then:
`attributes` will be `['A screenshot showing a dialog box', ' containing text fields', ' buttons', ' and validation errors', ' width=604', ' height=422']`.
`attributes[0]` is `'A screenshot showing a dialog box'`.
Then it iterates over `attributes[1:]`:
- `' containing text fields'`: no `=`, crashes.

The fix should be to only treat `attr` as a key-value pair if it contains `=`, otherwise it should be part of the alt text. But wait, in AsciiDoc, the first attribute is the alt text, and subsequent ones are key-value pairs. If the alt text itself contains commas, it's a problem because the simple `.split(",")` is too naive.

Wait, looking at AsciiDoc documentation or how it's typically handled: usually, the alt text is the first argument, and it's everything until the first comma that starts a `key=value` pair? Not necessarily.

Actually, according to AsciiDoc syntax, attributes are comma-separated. If the alt text contains commas, it might be intended to be quoted or handled differently. However, the issue report says "common in auto-generated exports from tools like Word/Doc2Help".

If the alt text can contain commas, then maybe we should only consider it a key-value pair if it actually contains an `=`, and anything else should be appended to the alt text?

Let's see:
`attributes = mtch.group(2).split(",")`
`picture_info["alt"] = attributes[0].strip() if attributes[0] else ""`
`for attr in attributes[1:]:`
`    if "=" in attr:`
`        key, value = attr.split("=", 1)`
`        picture_info[key.strip()] = value.strip()`
`    else:`
`        # It's part of the alt text`
`        picture_info["alt"] += ", " + attr.strip()`

Wait, if the alt text contains commas, and then there are key-value pairs, then all pieces between the first comma and the first `key=value` pair are part of the alt text.

Example: `[Alt text with, commas, width=604, height=422]`
`attributes` = `['Alt text with', ' commas', ' width=604', ' height=422']`
- `alt` = `Alt text with`
- `attr` = ` commas` (no `=`) -> `alt` = `Alt text with, commas`
- `attr` = ` width=604` (has `=`) -> `width` = `604`
- `attr` = ` height=422` (has `=`) -> `height` = `422`

This seems to handle the reported case.

Let's double check the reproduction case.
`image::images/screenshot.png[A screenshot showing a dialog box, containing text fields, buttons, and validation errors, width=604, height=422]`
`attributes` = `['A screenshot showing a dialog box', ' containing text fields', ' buttons', ' and validation errors', ' width=604', ' height=422']`
1. `alt` = `"A screenshot showing a dialog box"`
2. `attr` = `" containing text fields"` -> no `=`, `alt` = `"A screenshot showing a dialog box, containing text fields"`
3. `attr` = `" buttons"` -> no `=`, `alt` = `"A screenshot showing a dialog box, containing text fields, buttons"`
4. `attr` = `" and validation errors"` -> no `=`, `alt` = `"A screenshot showing a dialog box, containing text fields, buttons, and validation errors"`
5. `attr` = `" width=604"` -> has `=`, `width` = `"604"`
6. `attr` = `" height=422"` -> has `=`, `height` = `"422"`

Result: `alt` = `"A screenshot showing a dialog box, containing text fields, buttons, and validation errors"`, `width` = `"604"`, `height` = `"422"`.
This looks correct and matches what would be expected.

One thing: `alt` initial value. If `attributes` is empty, `picture_info` doesn't get `alt`. But the code does:
```python
            if attributes:
                picture_info["alt"] = attributes[0].strip() if attributes[0] else ""
```
If `attributes` is `['']`, then `alt` = `""`. If `attributes` is `['something']`, `alt` = `"something"`.

Wait, what if the alt text is empty and the first attribute is `width=604`?
`image::path.png[, width=604]`
`attributes` = `['', ' width=604']`
1. `alt` = `""`
2. `attr` = `" width=604"` -> `width` = `"604"`
Result: `alt` = `""`, `width` = `"604"`. Correct.

What if `image::path.png[width=604]`?
`attributes` = `['width=604']`
1. `alt` = `"width=604"`
Wait, this is tricky. If there's only one attribute and it contains `=`, should it be the alt text or a key-value pair?
In AsciiDoc, the first argument to the image macro is ALWAYS the alt text. If it contains an `=`, it is still the alt text unless it's specified otherwise? No, usually if you omit the alt text, you leave it empty.
Actually, AsciiDoc documentation says:
`image::image-file.png[alt-text, width=100, height=100]`
If you want no alt text:
`image::image-file.png[, width=100, height=100]`

So if the first item in the list contains `=`, it's still the alt text.
Wait, let's check. If the first element is `width=604`, is that the alt text or is that the width?
If the user writes `image::path.png[width=604]`, then `alt` should be `"width=604"`? That doesn't seem right.
But if they write `image::path.png[alt text, width=604]`, then `alt` is `"alt text"`.

Actually, if the first attribute contains `=`, maybe it's NOT alt text if it's a known attribute? But the current implementation treats `attributes[0]` as alt text regardless.

Current implementation:
```python
            if attributes:
                picture_info["alt"] = attributes[0].strip() if attributes[0] else ""
                for attr in attributes[1:]:
                    key, value = attr.split("=")
                    picture_info[key.strip()] = value.strip()
```
In this current implementation, `image::path.png[width=604]` would set `alt` = `"width=604"`. It doesn't check if `attributes[0]` has an `=`.

If I use my proposed fix:
```python
            if attributes:
                alt_text = attributes[0].strip() if attributes[0] else ""
                picture_info["alt"] = alt_text
                for attr in attributes[1:]:
                    if "=" in attr:
                        key, value = attr.split("=", 1)
                        picture_info[key.strip()] = value.strip()
                    else:
                        alt_text += ", " + attr.strip()
                        picture_info["alt"] = alt_text
```
Wait, if `alt_text` is updated, I should keep updating `picture_info["alt"]`.

Wait, the issue is specifically when `attributes[1:]` contains elements without `=`.

Let's try to reproduce it first.

{
  "command": "python3 - <<'PY'\nfrom docling.document_converter import DocumentConverter\nfrom docling.datamodel.base_models import InputFormat\nfrom pathlib import Path\nimport tempfile\n\n# Minimal .adoc file with commas in alt text\ncontent = \"\"\"= Test Document\n\nimage::images/screenshot.png[A screenshot showing a dialog box, containing text fields, buttons, and validation errors, width=604, height=422]\n  \"\"\"\n\nwith tempfile.NamedTemporaryFile(suffix=\".adoc\", mode=\"w\", delete=False) as f:\n    f.write(content)\n    tmp_path = Path(f.name)\n\nconverter = DocumentConverter(allowed_formats=[InputFormat.ASCIIDOC])\nresult = list(converter.convert_all(source=[tmp_path], raises_on_error=False))\nprint(f\"Status: {result[0].status}\")\nprint(f\"Errors: {result[0].errors}\")\nPY\n"
}

{
  "status": "ok",
  "stdout": "Status: failure\nErrors: [ErrorItem(component_type=<DoclingComponentType.PIPELINE: 'pipeline'>, module_name='SimplePipeline', error_message='not enough values to unpack (expected 2, got 1)')]\n",
  "stderr": "",
  "exit_code": 0
}

Reproduction successful. Now let's implement the fix.

I will modify `_parse_picture` in `docling/backend/asciidoc_backend.py`.

```python
    @staticmethod
    def _parse_picture(line):
        """
        Parse an image macro, extracting its path and attributes.
        Syntax: image::path/to/image.png[Alt Text, width=200, height=150, align=center]
        """
        mtch = re.match(r"^image::(.+)\[(.*)\]$", line)
        if mtch:
            picture_path = mtch.group(1).strip()
            attributes = mtch.group(2).split(",")
            picture_info = {"type": "picture", "uri": picture_path}

            # Extract optional attributes (alt text, width, height, alignment)
            if attributes:
                alt_text = attributes[0].strip() if attributes[0] else ""
                picture_info["alt"] = alt_text
                for attr in attributes[1:]:
                    if "=" in attr:
                        key, value = attr.split("=", 1)
                        picture_info[key.strip()] = value.strip()
                    else:
                        alt_text += ", " + attr.strip()
                        picture_info["alt"] = alt_text

            return picture_info

        return {"type": "picture", "uri": line}
```

Wait, if `attributes[0]` is empty and subsequent attributes don't have `=`, they should still be part of `alt`.
Example: `image::path.png[, some alt text, width=100]`
`attributes` = `['', ' some alt text', ' width=100']`
1. `alt_text` = `""`
2. `attr` = `" some alt text"` -> no `=`, `alt_text` = `", some alt text"`, `picture_info["alt"]` = `", some alt text"`.
Wait, if the first one was empty, should it start with a comma? Probably not.

If `alt_text` is empty, we should probably avoid the leading comma.

```python
                alt_text = attributes[0].strip() if attributes[0] else ""
                picture_info["alt"] = alt_text
                for attr in attributes[1:]:
                    if "=" in attr:
                        key, value = attr.split("=", 1)
                        picture_info[key.strip()] = value.strip()
                    else:
                        if alt_text:
                            alt_text += ", " + attr.strip()
                        else:
                            alt_text = attr.strip()
                        picture_info["alt"] = alt_text
```

Wait, if `attributes[0]` is `""`, then `alt_text` is `""`. Then if `attributes[1]` is `" some alt text"`, `alt_text` becomes `"some alt text"`. Then if `attributes[2]` is `" more alt"`, `alt_text` becomes `"some alt text, more alt"`. This looks correct.

Let's refine the code a bit more to be cleaner.

```python
            if attributes:
                # The first attribute is the alt text.
                alt_text = attributes[0].strip() if attributes[0] else ""
                picture_info["alt"] = alt_text
                # Subsequent attributes can be either alt text fragments (if no '=') or key-value pairs.
                for attr in attributes[1:]:
                    if "=" in attr:
                        key, value = attr.split("=", 1)
                        picture_info[key.strip()] = value.strip()
                    else:
                        attr_stripped = attr.strip()
                        if alt_text:
                            alt_text += ", " + attr_stripped
                        else:
                            alt_text = attr_stripped
                        picture_info["alt"] = alt_text
```

Wait, I should check how `split("=", 1)` works. If there are multiple `=`, it only splits on the first one. This is good.

Let's check if I missed anything.
What if the `line` is `image::path.png[]`?
`mtch.group(2)` will be `""`. `attributes` will be `['']`.
`alt_text` = `""`. `picture_info["alt"] = ""`.
`attributes[1:]` will be empty.
Result: `{"type": "picture", "uri": "path.png", "alt": ""}`. Correct.

What if the `line` is `image::path.png` (no brackets)?
`re.match(r"^image::(.+)\[(.*)\]$", line)` will fail because it expects brackets.
It will go to `return {"type": "picture", "uri": line}`. Correct.

One more thing: the original code did `alt_text = attributes[0].strip() if attributes[0] else ""`.
If the user has `image::path.png[ , width=100]`, `attributes` is `[' ', ' width=100']`.
`attributes[0].strip()` is `""`. `alt_text` is `""`.
Then `attr` is `" width=100"`, it has `=`, so `width=100`.
Result: `alt=""`, `width="100"`.

If the user has `image::path.png[alt, width=100]`, `attributes` is `['alt', ' width=100']`.
`alt_text` is `"alt"`. `picture_info["alt"] = "alt"`.
`attr` is `" width=100"`, it has `=`, so `width=100`.
Result: `alt="alt"`, `width="100"`.

If the user has `image::path.png[alt part 1, alt part 2, width=100]`, `attributes` is `['alt part 1', ' alt part 2', ' width=100']`.
`alt_text` is `"alt part 1"`. `picture_info["alt"] = "alt part 1"`.
`attr` is `" alt part 2"`, no `=`, `alt_text` becomes `"alt part 1, alt part 2"`, `picture_info["alt"]` updated.
`attr` is `" width=100"`, has `=`, `width=100`.
Result: `alt="alt part 1, alt part 2"`, `width="100"`.

Looks solid.

Now let's apply the fix.

{
  "filepath": "docling/backend/asciidoc_backend.py",
  "new_string": "            # Extract optional attributes (alt text, width, height, alignment)\n            if attributes:\n                alt_text = attributes[0].strip() if attributes[0] else \"\"\n                picture_info[\"alt\"] = alt_text\n                for attr in attributes[1:]:\n                    if \"=\" in attr:\n                        key, value = attr.split(\"=\", 1)\n                        picture_info[key.strip()] = value.strip()\n                    else:\n                        attr_stripped = attr.strip()\n                        if alt_text:\n                            alt_text += \", \" + attr_stripped\n                        else:\n                            alt_text = attr_stripped\n                        picture_info[\"alt\"] = alt_text\n",
  "old_string": "            # Extract optional attributes (alt text, width, height, alignment)\n            if attributes:\n                picture_info[\"alt\"] = attributes[0].strip() if attributes[0] else \"\"\n                for attr in attributes[1:]:\n                    key, value = attr.split(\"=\")\n                    picture_info[key.strip()] = value.strip()\n"
}

{
  "status": "ok",
  "filepath": "docling/backend/asciidoc_backend.py",
  "occurrences": 1,
  "strategy": "exact",
  "diff": "--- a/docling/backend/asciidoc_backend.py\n+++ b/docling/backend/asciidoc_backend.py\n@@ -414,10 +414,19 @@\n \n             # Extract optional attributes (alt text, width, height, alignment)\n             if attributes:\n-                picture_info[\"alt\"] = attributes[0].strip() if attributes[0] else \"\"\n+                alt_text = attributes[0].strip() if attributes[0] else \"\"\n+                picture_info[\"alt\"] = alt_text\n                 for attr in attributes[1:]:\n-                    key, value = attr.split(\"=\")\n-                    picture_info[key.strip()] = value.strip()\n+                    if \"=\" in attr:\n+                        key, value = attr.split(\"=\", 1)\n+                        picture_info[key.strip()] = value.strip()\n+                    else:\n+                        attr_stripped = attr.strip()\n+                        if alt_text:\n+                            alt_text += \", \" + attr_stripped\n+                        else:\n+                            alt_text = attr_stripped\n+                        picture_info[\"alt\"] = alt_text\n \n             return picture_info\n \n",
  "is_truncated": false
}

Now let's verify the fix with the reproduction script.

{
  "command": "python3 - <<'PY'\nfrom docling.document_converter import DocumentConverter\nfrom docling.datamodel.base_models import InputFormat\nfrom pathlib import Path\nimport tempfile\n\n# Minimal .adoc file with commas in alt text\ncontent = \"\"\"= Test Document\n\nimage::images/screenshot.png[A screenshot showing a dialog box, containing text fields, buttons, and validation errors, width=604, height=422]\n  \"\"\"\n\nwith tempfile.NamedTemporaryFile(suffix=\".adoc\", mode=\"w\", delete=False) as f:\n    f.write(content)\n    tmp_path = Path(f.name)\n\nconverter = DocumentConverter(allowed_formats=[InputFormat.ASCIIDOC])\nresult = list(converter.convert_all(source=[tmp_path], raises_on_error=False))\nprint(f\"Status: {result[0].status}\")\nprint(f\"Errors: {result[0].errors}\")\nPY\n"
}

{
  "status": "ok",
  "stdout": "Status: success\nErrors: []\n",
  "stderr": "",
  "exit_code": 0
}

Great, the reproduction case now passes. Let's test a few more edge cases to be sure.
1. Alt text contains commas, but NO other attributes.
2. Alt text is empty, but some attributes exist.
3. Alt text is empty, no attributes.
4. No brackets at all.
5. Alt text starts with a comma (unlikely but possible).

I'll write a small test script to check the `_parse_picture` method directly.

{
  "command": "python3 - <<'PY'\nfrom docling.backend.asciidoc_backend import AsciiDocBackend\n\ndef test_parse_picture():\n    cases = [\n        # Original bug case\n        (\"image::images/screenshot.png[A screenshot showing a dialog box, containing text fields, buttons, and validation errors, width=604, height=422]\", \n         {\"type\": \"picture\", \"uri\": \"images/screenshot.png\", \"alt\": \"A screenshot showing a dialog box, containing text fields, buttons, and validation errors\", \"width\": \"604\", \"height\": \"422\"}),\n        \n        # Alt text with commas, no other attributes\n        (\"image::img.png[Alt text, with commas]\", \n         {\"type\": \"picture\", \"uri\": \"img.png\", \"alt\": \"Alt text, with commas\"}),\n        \n        # Empty alt text, other attributes\n        (\"image::img.png[, width=100]\", \n         {\"type\": \"picture\", \"uri\": \"img.png\", \"alt\": \"\", \"width\": \"100\"}),\n        \n        # Empty alt text, no other attributes\n        (\"image::img.png[]\", \n         {\"type\": \"picture\", \"uri\": \"img.png\", \"alt\": \"\"}),\n        \n        # No brackets\n        (\"image::img.png\", \n         {\"type\": \"picture\", \"uri\": \"image::img.png\"}), # Based on current implementation: return {\"type\": \"picture\", \"uri\": line}\n\n        # All alt text, some empty fragments\n        (\"image::img.png[ part 1, , part 2 ]\", \n         {\"type\": \"picture\", \"uri\": \"img.png\", \"alt\": \"part 1, , part 2\"}),\n        \n        # Attribute with multiple equals\n        (\"image::img.png[alt, attr=value=extra]\", \n         {\"type\": \"picture\", \"uri\": \"img.png\", \"alt\": \"alt\", \"attr\": \"value=extra\"}),\n    ]\n\n    for line, expected in cases:\n        result = AsciiDocBackend._parse_picture(line)\n        assert result == expected, f\"Failed for {line}. Expected {expected}, got {result}\"\n    print(\"All tests passed!\")\n\ntest_parse_picture()\nPY\n"
}

{
  "status": "ok",
  "stdout": "All tests passed!\n",
  "stderr": "",
  "exit_code": 0
}

Wait, one case failed in my head but passed in the script:
`("image::img.png", {"type": "picture", "uri": "image::img.png"})`
Is this correct?
Existing code:
```python
    @staticmethod
    def _parse_picture(line):
        ...
        mtch = re.match(r"^image::(.+)\[(.*)\]$", line)
        if mtch:
            ...
            return picture_info

        return {"type": "picture", "uri": line}
```
Yes, if it doesn't match the regex (which requires `[` and `]`), it returns the whole line as the URI. This is the existing behavior.

Another case:
`("image::img.png[ part 1, , part 2 ]", {"type": "picture", "uri": "img.png", "alt": "part 1, , part 2"})`
Let's trace it:
`attributes` = `[' part 1', ' ', ' part 2 ']`
1. `alt_text` = `"part 1"`, `picture_info["alt"] = "part 1"`
2. `attr` = `" "` -> no `=`, `attr_stripped = ""`. `alt_text` exists, so `alt_text` becomes `"part 1, "`. `picture_info["alt"] = "part 1, "`
3. `attr` = `" part 2 "` -> no `=`, `attr_stripped = "part 2"`. `alt_text` exists, so `alt_text` becomes `"part 1, , part 2"`. `picture_info["alt"] = "part 1, , part 2"`
Result: `{"type": "picture", "uri": "img.png", "alt": "part 1, , part 2"}`. Correct.

I'm confident with this fix. Now I'll check the existing tests in `tests/test_backend_asciidoc.py` to make sure I didn't break anything.

{
  "command": "pytest tests/test_backend_asciidoc.py -q --tb=short --no-header"
}

{
  "status": "ok",
  "stdout": "..                                                                       [100%]\n2 passed in 2.23s\n",
  "stderr": "",
  "exit_code": 0
}

The tests passed.

I'll double check for any other parallel paths.
The user mentioned `AsciiDocBackend._parse_picture()`.
Are there any other backends or async variants?
The workspace layout shows `docling/backend/asciidoc_backend.py`. There is no `AsyncAsciiDocBackend`.
Looking at the files, it seems only `asciidoc_backend.py` handles AsciiDoc.

Final check on the diff.

{
  "command": "git status --short && git diff"
}

{
  "status": "ok",
  "stdout": " M docling/backend/asciidoc_backend.py\ndiff --git a/docling/backend/asciidoc_backend.py b/docling/backend/asciidoc_backend.py\nindex c6a0d18..e03119b 100644\n--- a/docling/backend/asciidoc_backend.py\n+++ b/docling/backend/asciidoc_backend.py\n@@ -414,10 +414,19 @@ class AsciiDocBackend(DeclarativeDocumentBackend):\n \n             # Extract optional attributes (alt text, width, height, alignment)\n             if attributes:\n-                picture_info[\"alt\"] = attributes[0].strip() if attributes[0] else \"\"\n+                alt_text = attributes[0].strip() if attributes[0] else \"\"\n+                picture_info[\"alt\"] = alt_text\n                 for attr in attributes[1:]:\n-                    key, value = attr.split(\"=\")\n-                    picture_info[key.strip()] = value.strip()\n+                    if \"=\" in attr:\n+                        key, value = attr.split(\"=\", 1)\n+                        picture_info[key.strip()] = value.strip()\n+                    else:\n+                        attr_stripped = attr.strip()\n+                        if alt_text:\n+                            alt_text += \", \" + attr_stripped\n+                        else:\n+                            alt_text = attr_stripped\n+                        picture_info[\"alt\"] = alt_text\n \n             return picture_info\n \n",
  "stderr": "",
  "exit_code": 0
}

The diff looks clean.

One detail: I used `split("=", 1)`. This is better than `split("=")` because if the value contains an `=`, it won't crash. The original code had `key, value = attr.split("=")`, which would crash if there were more than one `=`. So my fix also improves that.

I'm done.

{
  "status": "ok",
  "patch_size": 1271,
  "files_changed": 1
}

The patch has been submitted. I have verified it with a reproduction script and existing tests.

The bug was caused by a naive `.split(",")` in `AsciiDocBackend._parse_picture()`, which incorrectly split alt text containing commas into multiple fragments, subsequently causing a `ValueError` when attempting to unpack them as key-value pairs. I updated the parsing logic to treat subsequent fragments as part of the alt text if they do not contain an equals sign.

Summary of changes:
- Modified `docling/backend/asciidoc_backend.py` to correctly handle commas in alt text.
- Added a check to only split attributes by `=` if the equals sign is present, otherwise appending the fragment to the alt text.
- Used `split("=", 1)` to safely handle attribute values that may contain equals signs.