docling-project__docling-2983

The user is reporting a crash in `AsciiDocBackend._parse_picture()` when the alt text of an image macro contains commas.
The provided reproduction script demonstrates that `image::images/screenshot.png[A screenshot showing a dialog box, containing text fields, buttons, and validation errors, width=604, height=422]` causes a `ValueError: not enough values to unpack (expected 2, got 1)`.

I need to:
1. Locate `AsciiDocBackend._parse_picture()` in `docling/backend/asciidoc_backend.py`.
2. Understand how it parses the bracket content.
3. Fix it so it handles commas in alt text correctly.
4. Verify the fix with the reproduction script.

Let's start by locating the method and reading the file.

{
  "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
}

The method is in `docling/backend/asciidoc_backend.py` at line 404.
Let's read the implementation of `_parse_picture`.

{
  "filepath": "docling/backend/asciidoc_backend.py",
  "start_line": 404
}

{
  "status": "ok",
  "filepath": "docling/backend/asciidoc_backend.py",
  "content": "    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\n    @staticmethod\n    def _parse_caption(line):\n        mtch = re.match(r\"^\\.(.+)\", line)\n        if mtch:\n            text = mtch.group(1)\n            return {\"type\": \"caption\", \"text\": text}\n\n        return {\"type\": \"caption\", \"text\": \"\"}\n\n    #   =========   Plain text\n    @staticmethod\n    def _parse_text(line):\n        return {\"type\": \"text\", \"text\": line.strip()}",
  "start_line": 404,
  "end_line": 443,
  "total_lines": 443,
  "is_truncated": false
}

The bug is here:
```python
            attributes = mtch.group(2).split(",")
            picture_info = {"type": "picture", "uri": picture_path}

            # 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()
```
It splits by comma and then assumes everything after the first element (the alt text) is a `key=value` pair.
If the alt text contains commas, `attributes[1:]` will contain parts of the alt text that do not contain an `=`.

The AsciiDoc image macro syntax is `image::filename[alt text, attribute1=value1, attribute2=value2]`.
The alt text is the first argument. Subsequent arguments are optional attributes in `key=value` format.

If the alt text contains commas, it's a bit tricky. According to AsciiDoc documentation, the attributes are comma-separated. If the alt text needs to contain commas, it should ideally be escaped or the parser needs to be smarter. However, the issue states that auto-generated exports have these commas.

Wait, if the intent is that only `key=value` pairs can follow the alt text, we should only try to split by `=` if the element actually contains `=`. But that's not quite right because if the alt text contains commas, they will be split into separate elements in the `attributes` list.

Example: `[A screenshot, showing a dialog, width=604]`
`attributes` becomes `['A screenshot', ' showing a dialog', ' width=604']`
`attributes[0]` is `'A screenshot'`.
`attributes[1]` is `' showing a dialog'`. `attr.split("=")` will yield `[' showing a dialog']`, and `key, value = attr.split("=")` will fail.

The correct approach should be to separate the attributes from the alt text more carefully.
Actually, in AsciiDoc, the first comma-separated value is the alt text. If it contains commas, it might be a problem for a simple `.split(",")`.

But looking at how it's currently implemented, it treats the first element as alt text and others as attributes.
If we want to support commas in alt text, we need to distinguish between an attribute (contains `=`) and a continuation of the alt text.

Wait, if we have `[A screenshot, showing a dialog, width=604]`, the attributes are:
1. Alt text: "A screenshot, showing a dialog"
2. width: 604

So we should iterate through the `attributes` list and if an element doesn't contain `=`, it's part of the alt text (unless it's the first one, which is always alt text).

Wait, that's not entirely correct. What if an attribute value contains a comma? (Less likely for width/height).

Let's re-examine:
`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']`

We want:
`alt`: "A screenshot showing a dialog box, containing text fields, buttons, and validation errors"
`width`: "604"
`height`: "422"

So, as long as an element doesn't have a `=`, it should be appended to the alt text (with a comma joining them). Once we encounter an element that has a `=`, it and all subsequent elements that have a `=` are attributes.

But wait, what if an attribute comes before another alt-text-like string? (probably not allowed).

Actually, the most robust way would be to find the first element that looks like a `key=value` pair, and everything before that is the alt text.

Example: `[Alt text, part 2, width=10, height=20]`
Split by comma: `['Alt text', ' part 2', ' width=10', ' height=20']`
Index 0: 'Alt text' (alt)
Index 1: ' part 2' (no '=', so append to alt)
Index 2: ' width=10' (has '=', so it's an attribute)
Index 3: ' height=20' (has '=', so it's an attribute)

What if there are no attributes?
`[Alt text, part 2]`
Split: `['Alt text', ' part 2']`
All part of alt text.

What if there is an attribute but no alt text?
`[, width=10]`
Split: `['', ' width=10']`
Alt text: ""
width: 10

What if the alt text is empty and there are no attributes?
`[]`
Split: `['']`
Alt text: ""

Revised logic:
1. Split by `,`.
2. Find the first index `i` where `attributes[i]` contains `=`.
3. Elements from `0` to `i-1` are part of the alt text.
4. Elements from `i` onwards are attributes.

Wait, what if an attribute value contains a comma?
`[Alt text, attr=value,with,comma, width=10]`
The current `split(",")` would break this anyway. Given the current implementation, they are using `split(",")`, so I should probably stick to that as the primary delimiter for top-level attributes, but handle the alt text correctly.

Actually, Asciidoc attributes *can* have commas in values if quoted, but the current implementation doesn't handle quotes. Given the bug report, they just want to handle commas in the alt text.

Let's try a reproduction script to confirm the failure and then test the fix.

{
  "content": "from 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\ntry:\n    converter = DocumentConverter(allowed_formats=[InputFormat.ASCIIDOC])\n    result = list(converter.convert_all(source=[tmp_path], raises_on_error=False))\n    print(f\"Status: {result[0].status}\")\n    print(f\"Errors: {result[0].errors}\")\nexcept Exception as e:\n    print(f\"Exception: {e}\")\nfinally:\n    tmp_path.unlink()\n",
  "filepath": "/tmp/repro.py"
}

{
  "status": "error",
  "error_type": "FileWriteError",
  "error_message": "Path traversal detected: '/tmp/repro.py' escapes workspace root."
}

Ah, I cannot write to `/tmp/`. I should use a file within `/workspace` (though the rules say not to leave untracked files, I can delete it afterwards or just run it with `python3 - <<'PY'`).

Let's run the reproduction using `python3 - <<'PY'`.

{
  "command": "python3 - <<'PY'\nfrom docling.document_converter import DocumentConverter\nfrom docling.datamodel.base_models import InputFormat\nfrom pathlib import Path\nimport tempfile\nimport os\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\ntry:\n    converter = DocumentConverter(allowed_formats=[InputFormat.ASCIIDOC])\n    result = list(converter.convert_all(source=[tmp_path], raises_on_error=False))\n    print(f\"Status: {result[0].status}\")\n    print(f\"Errors: {result[0].errors}\")\nfinally:\n    if tmp_path.exists():\n        os.remove(tmp_path)\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
}

The reproduction confirms the issue. Now I will implement the fix in `docling/backend/asciidoc_backend.py`.

The current code:
```python
            attributes = mtch.group(2).split(",")
            picture_info = {"type": "picture", "uri": picture_path}

            # 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()
```

The proposed fix:
```python
            attributes_raw = mtch.group(2).split(",")
            picture_info = {"type": "picture", "uri": picture_path}

            if attributes_raw:
                # The first element is always the alt text.
                # Subsequent elements are either part of the alt text or are attributes (key=value).
                alt_parts = []
                attrs = []
                
                # We need to find where the real attributes start.
                # An element is an attribute if it contains '='.
                # However, all elements before the first attribute are part of the alt text.
                
                first_attr_index = -1
                for i, attr in enumerate(attributes_raw):
                    if "=" in attr:
                        first_attr_index = i
                        break
                
                if first_attr_index == -1:
                    # No attributes found, everything is alt text
                    alt_text = ",".join(attributes_raw).strip()
                    picture_info["alt"] = alt_text
                else:
                    # Elements before first_attr_index are part of alt text
                    # But wait, if first_attr_index is 0, then there is no alt text?
                    # Actually, the first element is ALWAYS intended to be the alt text.
                    # If attributes_raw[0] has an '=', it's still technically in the alt text position
                    # but in AsciiDoc, image::path[attr1=val1] means empty alt text and attr1=val1.
                    # Wait, no. If the first element is 'width=10', is the alt text empty?
                    # Yes, usually.
                    
                    # Let's refine:
                    # 1. The first element is the start of alt text.
                    # 2. Any subsequent element that DOES NOT contain '=' is also part of alt text.
                    # 3. Once we hit an element that DOES contain '=', it and everything after are attributes.
                    # NO, that's not correct either. The attributes can be in any order after the alt text.
                    # But the alt text is always first.
                    
                    # Correct logic for AsciiDoc image macro:
                    # [alt text, attr1=val1, attr2=val2]
                    # If alt text contains commas, it will be split.
                    # Example: [A, B, width=10] -> alt="A, B", width="10"
                    # Example: [width=10, height=20] -> alt="", width="10", height="20"
                    
                    alt_parts = []
                    attrs = []
                    
                    # The first element is special. If it contains '=', then alt is empty and it's an attribute.
                    # Actually, if the first element contains '=', then there's no alt text.
                    if "=" not in attributes_raw[0]:
                        # First element is part of alt text
                        # Now find subsequent elements that don't have '='
                        i = 1
                        while i < len(attributes_raw) and "=" not in attributes_raw[i]:
                            alt_parts.append(attributes_raw[i])
                            i += 1
                        
                        # First element
                        full_alt = attributes_raw[0]
                        if alt_parts:
                            full_alt += "," + ",".join(alt_parts)
                        picture_info["alt"] = full_alt.strip()
                        
                        # Remaining are attributes
                        for j in range(i, len(attributes_raw)):
                            key, value = attributes_raw[j].split("=", 1)
                            picture_info[key.strip()] = value.strip()
                    else:
                        # First element is already an attribute
                        picture_info["alt"] = ""
                        for j in range(len(attributes_raw)):
                            key, value = attributes_raw[j].split("=", 1)
                            picture_info[key.strip()] = value.strip()
```

Wait, let's simplify.
1. Split by comma.
2. Find the first index `i` such that `attributes_raw[i]` contains `=`.
3. If no such `i` exists:
   all elements are part of alt text.
4. If `i == 0`:
   alt text is empty, all elements from `0` are attributes.
5. If `i > 0`:
   elements `0` to `i-1` are alt text, elements `i` to `end` are attributes.

Wait, is it possible to have an attribute that doesn't contain `=`? No, usually they are `key=value`.
Is it possible to have a comma in the attribute value? Yes, but the current system splits by comma, so we probably should continue doing that for simplicity, or we'll need a full parser. The bug report specifically mentions commas in alt text.

Let's test this logic:
Case 1: `[A screenshot, showing a dialog, width=604, height=422]`
`attributes_raw` = `['A screenshot', ' showing a dialog', ' width=604', ' height=422']`
`i` = 2 (`' width=604'`)
`i > 0`:
alt text = `",".join(attributes_raw[0:2])` = `"A screenshot, showing a dialog"`
attributes = `attributes_raw[2:]` = `[' width=604', ' height=422']`
Result: `alt="A screenshot, showing a dialog", width="604", height="422"` (Correct)

Case 2: `[Alt text]`
`attributes_raw` = `['Alt text']`
`i` = -1
all elements are alt text: `alt="Alt text"` (Correct)

Case 3: `[width=604, height=422]`
`attributes_raw` = `['width=604', ' height=422']`
`i` = 0
alt text = `""`
attributes = `['width=604', ' height=422']` (Correct)

Case 4: `[,]`
`attributes_raw` = `['', '']`
`i` = -1
alt text = `","` (or `""` if stripped)
Wait, `",".join(['', ''])` is `","`.
Let's see. If `attributes_raw` is `['', '']`, then alt text should probably be `""`.
Actually, the current code does `attributes[0].strip() if attributes[0] else ""`.

Let's refine the logic:

```python
            attributes_raw = mtch.group(2).split(",")
            picture_info = {"type": "picture", "uri": picture_path}

            if attributes_raw:
                first_attr_index = -1
                for i, attr in enumerate(attributes_raw):
                    if "=" in attr:
                        first_attr_index = i
                        break
                
                if first_attr_index == -1:
                    # No attributes, everything is alt text
                    alt_text = ",".join(attributes_raw).strip()
                    picture_info["alt"] = alt_text
                elif first_attr_index == 0:
                    # No alt text, everything is attributes
                    picture_info["alt"] = ""
                    for attr in attributes_raw:
                        key, value = attr.split("=", 1)
                        picture_info[key.strip()] = value.strip()
                else:
                    # Everything before first_attr_index is alt text
                    alt_text = ",".join(attributes_raw[:first_attr_index]).strip()
                    picture_info["alt"] = alt_text
                    for attr in attributes_raw[first_attr_index:]:
                        key, value = attr.split("=", 1)
                        picture_info[key.strip()] = value.strip()
```

Wait, if the input is `[ , width=604]`, `attributes_raw` is `[' ', ' width=604']`.
`first_attr_index` = 1.
`alt_text` = `",".join([' ']).strip()` = `""`. (Correct)

If the input is `[]`, `attributes_raw` is `['']`.
`first_attr_index` = -1.
`alt_text` = `",".join(['']).strip()` = `""`. (Correct)

One more: `[Alt text, ]`
`attributes_raw` = `['Alt text', ' ']`
`first_attr_index` = -1.
`alt_text` = `",".join(['Alt text', ' ']).strip()` = `"Alt text, "`.
Wait, maybe it should be `"Alt text"`.
But in AsciiDoc, if you have a trailing comma, it might be intentional or a mistake.

Let's check what the original code did:
```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()
```
For `[Alt text, ]`:
`attributes` = `['Alt text', ' ']`
`picture_info["alt"]` = `"Alt text"`
`attr` = `" "`
`" ".split("=")` -> `[' ']`
`key, value = [' ']` -> `ValueError: not enough values to unpack`

So the original code also crashes on trailing commas.

My proposed fix avoids the crash.

Let's consider if there are any other patterns.
What if someone has `[Alt text, width = 604]` (with spaces around `=`)?
`" width = 604".split("=", 1)` -> `[' width ', ' 604']`
`key.strip()` -> `"width"`
`value.strip()` -> `"604"`
(Correct)

What if someone has `[Alt text, width=604=something]`?
`" width=604=something".split("=", 1)` -> `[' width', '604=something']`
`key.strip()` -> `"width"`
`value.strip()` -> `"604=something"`
(Correct)

The implementation looks solid. Now let's apply it.

Wait, I should check if I need to update anything else.
The problem description says:
> This crashes the entire pipeline with RuntimeError: Pipeline SimplePipeline failed, even with raises_on_error=False the document is marked as FAILURE.

This is because `AsciiDocBackend._parse_picture` is called and it raises a `ValueError`, which is then caught by the pipeline and marks it as failure.

Let's double check `docling/backend/asciidoc_backend.py` for any other places where `split(",")` might be used dangerously.

Looking at the file again (start_line 404):
Only `_parse_picture` uses `split(",")` on that `mtch.group(2)`.

Wait, I should also check if `_parse_picture` is used elsewhere or has siblings.
It's a method of `AsciiDocBackend`.

Let's apply the fix.

{
  "filepath": "docling/backend/asciidoc_backend.py",
  "new_string": "            attributes_raw = mtch.group(2).split(\",\")\n            picture_info = {\"type\": \"picture\", \"uri\": picture_path}\n\n            if attributes_raw:\n                first_attr_index = -1\n                for i, attr in enumerate(attributes_raw):\n                    if \"=\" in attr:\n                        first_attr_index = i\n                        break\n\n                if first_attr_index == -1:\n                    alt_text = \",\".join(attributes_raw).strip()\n                    picture_info[\"alt\"] = alt_text\n                elif first_attr_index == 0:\n                    picture_info[\"alt\"] = \"\"\n                    for attr in attributes_raw:\n                        key, value = attr.split(\"=\", 1)\n                        picture_info[key.strip()] = value.strip()\n                else:\n                    alt_text = \",\".join(attributes_raw[:first_attr_index]).strip()\n                    picture_info[\"alt\"] = alt_text\n                    for attr in attributes_raw[first_attr_index:]:\n                        key, value = attr.split(\"=\", 1)\n                        picture_info[key.strip()] = value.strip()",
  "old_string": "            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()"
}

{
  "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@@ -409,15 +409,30 @@\n         mtch = re.match(r\"^image::(.+)\\[(.*)\\]$\", line)\n         if mtch:\n             picture_path = mtch.group(1).strip()\n-            attributes = mtch.group(2).split(\",\")\n+            attributes_raw = 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+            if attributes_raw:\n+                first_attr_index = -1\n+                for i, attr in enumerate(attributes_raw):\n+                    if \"=\" in attr:\n+                        first_attr_index = i\n+                        break\n+\n+                if first_attr_index == -1:\n+                    alt_text = \",\".join(attributes_raw).strip()\n+                    picture_info[\"alt\"] = alt_text\n+                elif first_attr_index == 0:\n+                    picture_info[\"alt\"] = \"\"\n+                    for attr in attributes_raw:\n+                        key, value = attr.split(\"=\", 1)\n+                        picture_info[key.strip()] = value.strip()\n+                else:\n+                    alt_text = \",\".join(attributes_raw[:first_attr_index]).strip()\n+                    picture_info[\"alt\"] = alt_text\n+                    for attr in attributes_raw[first_attr_index:]:\n+                        key, value = attr.split(\"=\", 1)\n+                        picture_info[key.strip()] = value.strip()\n \n             return picture_info\n \n",
  "is_truncated": false
}

Now I will run the reproduction script again to make sure it passes.

{
  "command": "python3 - <<'PY'\nfrom docling.document_converter import DocumentConverter\nfrom docling.datamodel.base_models import InputFormat\nfrom pathlib import Path\nimport tempfile\nimport os\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\ntry:\n    converter = DocumentConverter(allowed_formats=[InputFormat.ASCIIDOC])\n    result = list(converter.convert_all(source=[tmp_path], raises_on_error=False))\n    print(f\"Status: {result[0].status}\")\n    print(f\"Errors: {result[0].errors}\")\nfinally:\n    if tmp_path.exists():\n        os.remove(tmp_path)\nPY\n"
}

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

The reproduction script now passes. Let's also run the existing tests for `AsciiDocBackend` 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.20s\n",
  "stderr": "",
  "exit_code": 0
}

Existing tests passed. I'll double check if there are any other tests that might be relevant.

{
  "command": "grep -rn \"asciidoc\" tests/"
}

{
  "status": "ok",
  "stdout": "tests/test_backend_asciidoc.py:5:from docling.backend.asciidoc_backend import (\ntests/test_backend_asciidoc.py:43:def test_asciidocs_examples():\ntests/test_backend_asciidoc.py:44:    fnames = sorted(glob.glob(\"./tests/data/asciidoc/*.asciidoc\"))\ntests/test_backend_asciidoc.py:65:            # assert pred_mddoc == true_mddoc, \"pred_mddoc!=true_mddoc for asciidoc\"\n",
  "stderr": "",
  "exit_code": 0
}

It seems only `tests/test_backend_asciidoc.py` is relevant.

One more thing: I should check if `AsciiDocBackend` is used in any other way or if there are other similar methods.
I'll grep for `_parse_` in `docling/backend/asciidoc_backend.py`.

{
  "command": "grep -rn \"_parse_\" docling/backend/asciidoc_backend.py"
}

{
  "status": "ok",
  "stdout": "108:                item = self._parse_title(line)\n117:                item = self._parse_section_header(line)\n130:                item = self._parse_list_item(line)\n173:                table_data.append(self._parse_table_line(line))\n204:                item = self._parse_picture(line)\n233:                item = self._parse_caption(line)\n239:                item = self._parse_text(line)\n252:                item = self._parse_text(line)\n294:    def _parse_title(line):\n303:    def _parse_section_header(line):\n322:    def _parse_list_item(line):\n363:    def _parse_table_line(line):\n404:    def _parse_picture(line):\n447:    def _parse_caption(line):\n457:    def _parse_text(line):\n",
  "stderr": "",
  "exit_code": 0
}

It seems `_parse_picture` is the only one that uses this kind of attribute parsing.

Let's verify once more with a case where alt text is missing but attributes are present.

{
  "command": "python3 - <<'PY'\nfrom docling.document_converter import DocumentConverter\nfrom docling.datamodel.base_models import InputFormat\nfrom pathlib import Path\nimport tempfile\nimport os\n\ncontent = \"\"\"= Test Document\n\nimage::images/screenshot.png[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\ntry:\n    converter = DocumentConverter(allowed_formats=[InputFormat.ASCIIDOC])\n    result = list(converter.convert_all(source=[tmp_path], raises_on_error=False))\n    print(f\"Status: {result[0].status}\")\n    # We can't easily check the internal picture_info, but we can check if it succeeded.\nfinally:\n    if tmp_path.exists():\n        os.remove(tmp_path)\nPY\n"
}

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

And one where they are just commas.

{
  "command": "python3 - <<'PY'\nfrom docling.document_converter import DocumentConverter\nfrom docling.datamodel.base_models import InputFormat\nfrom pathlib import Path\nimport tempfile\nimport os\n\ncontent = \"\"\"= Test Document\n\nimage::images/screenshot.png[A, B, C]\n  \"\"\"\n\nwith tempfile.NamedTemporaryFile(suffix=\".adoc\", mode=\"w\", delete=False) as f:\n    f.write(content)\n    tmp_path = Path(f.name)\n\ntry:\n    converter = DocumentConverter(allowed_formats=[InputFormat.ASCIIDOC])\n    result = list(converter.convert_all(source=[tmp_path], raises_on_error=False))\n    print(f\"Status: {result[0].status}\")\nfinally:\n    if tmp_path.exists():\n        os.remove(tmp_path)\nPY\n"
}

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

All cases seem to be handled.

{
  "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..c16495d 100644\n--- a/docling/backend/asciidoc_backend.py\n+++ b/docling/backend/asciidoc_backend.py\n@@ -409,15 +409,30 @@ class AsciiDocBackend(DeclarativeDocumentBackend):\n         mtch = re.match(r\"^image::(.+)\\[(.*)\\]$\", line)\n         if mtch:\n             picture_path = mtch.group(1).strip()\n-            attributes = mtch.group(2).split(\",\")\n+            attributes_raw = 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+            if attributes_raw:\n+                first_attr_index = -1\n+                for i, attr in enumerate(attributes_raw):\n+                    if \"=\" in attr:\n+                        first_attr_index = i\n+                        break\n+\n+                if first_attr_index == -1:\n+                    alt_text = \",\".join(attributes_raw).strip()\n+                    picture_info[\"alt\"] = alt_text\n+                elif first_attr_index == 0:\n+                    picture_info[\"alt\"] = \"\"\n+                    for attr in attributes_raw:\n+                        key, value = attr.split(\"=\", 1)\n+                        picture_info[key.strip()] = value.strip()\n+                else:\n+                    alt_text = \",\".join(attributes_raw[:first_attr_index]).strip()\n+                    picture_info[\"alt\"] = alt_text\n+                    for attr in attributes_raw[first_attr_index:]:\n+                        key, value = attr.split(\"=\", 1)\n+                        picture_info[key.strip()] = value.strip()\n \n             return picture_info\n \n",
  "stderr": "",
  "exit_code": 0
}

The diff is clean and only affects the targeted method. I'm ready to submit.

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

The fix is implemented and verified.

The `AsciiDocBackend._parse_picture` method was crashing when image alt text contained commas because it assumed every comma-separated element after the first was a `key=value` pair. I updated the parser to correctly identify the first element that contains an `=` as the start of the attributes, treating all preceding elements as part of the alt text.