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 issue is that the parser splits the bracket content by commas and expects `key=value` pairs after the first element (the alt text).

Let's locate the problematic code in `docling/backend/asciidoc_backend.py`.

{
  "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 `_parse_picture` is in `docling/backend/asciidoc_backend.py`.
Let's examine the implementation of `_parse_picture`.

{
  "end_line": 450,
  "filepath": "docling/backend/asciidoc_backend.py",
  "start_line": 400
}

{
  "status": "ok",
  "filepath": "docling/backend/asciidoc_backend.py",
  "content": "    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\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": 400,
  "end_line": 443,
  "total_lines": 443,
  "is_truncated": false
}

The bug is exactly where the problem statement said:
```python
                for attr in attributes[1:]:
                    key, value = attr.split("=")
                    picture_info[key.strip()] = value.strip()
```
If `attributes[1:]` contains a string without `=`, `attr.split("=")` will return a list with only one element, and the unpacking `key, value = ...` will raise `ValueError: not enough values to unpack (expected 2, got 1)`.

When the alt text contains commas, `attributes` becomes larger than it should be, and subsequent fragments of the alt text are treated as attributes.

Example: `image::images/screenshot.png[A screenshot showing a dialog box, containing text fields, buttons, and validation errors, width=604, height=422]`
`mtch.group(2)` is `A screenshot showing a dialog box, containing text fields, buttons, and validation errors, width=604, height=422`.
`attributes` will be `["A screenshot showing a dialog box", " containing text fields", " buttons", " and validation errors", " width=604", " height=422"]`.
Then it iterates starting from `attributes[1]`, which is `" containing text fields"`.
`" containing text fields".split("=")` returns `[" containing text fields"]`.
Unpacking `key, value = [" containing text fields"]` fails.

We should only split by comma if the part contains an `=` sign, or better, we should be more careful about how we identify attributes.
Actually, AsciiDoc image macros follow a specific pattern. The first part is the alt text. The remaining parts are optionally attributes in `key=value` format.

If we want to support commas in alt text, we might need to check if the item contains `=`. But wait, if the alt text contains commas, how do we know where the alt text ends and attributes begin?
In AsciiDoc, attributes are comma-separated. The first comma-separated value is always the alt text.
If the alt text itself contains commas, it should ideally be quoted, but the issue says it happens when alt text contains commas (possibly from auto-generated exports).

If we assume that anything that doesn't contain `=` is part of the alt text, we can merge those back.
However, attributes *must* be `key=value`.

Wait, if the alt text is `A screenshot showing a dialog box, containing text fields`, and then we have `width=604`, we can see that `width=604` has an `=` and `containing text fields` does not.

So the logic should be:
1. Split by comma.
2. The first element is always the start of the alt text.
3. Subsequent elements: if they contain `=`, they are attributes. If they don't, they are part of the alt text.

Wait, this is slightly tricky because we don't know if an attribute can contain a comma in its value. But usually, it's `key=value`.

Let's test this theory. If the alt text has commas, and then attributes follow.
`alt, part2, part3, width=100, height=200`
Alt text: `alt, part2, part3`
Attr: `width=100`, `height=200`

What if an attribute value has a comma? `style="color=red,weight=bold"`? AsciiDoc typically doesn't do that in this way or requires quoting.

Let's try a reproduction script 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\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\"Crash: {e}\")\nfinally:\n    tmp_path.unlink()\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
}

Confirmed. The reproduction script fails as expected.

Now I'll implement the fix.
I will change the loop to check for the presence of `=` before attempting to unpack.
If it doesn't have `=`, I'll append it to the alt text.

Wait, if the first element is the alt text, and then we have `part2, part3, key1=val1, key2=val2`, the alt text should be `alt, part2, part3`.

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

Let's check if this handles the cases correctly.
Case 1: `[Alt text, width=100]`
`attributes` = `["Alt text", " width=100"]`
`alt_text` = "Alt text"
Loop `attr` = " width=100": `"=" in attr` is True. `attrs_dict["width"] = "100"`.
`picture_info["alt"] = "Alt text"`, `picture_info["width"] = "100"`. Correct.

Case 2: `[Alt text with, comma, width=100]`
`attributes` = `["Alt text with", " comma", " width=100"]`
`alt_text` = "Alt text with"
Loop 1: `attr` = " comma": `"=" in attr` is False. `alt_text` = "Alt text with, comma".
Loop 2: `attr` = " width=100": `"=" in attr` is True. `attrs_dict["width"] = "100"`.
`picture_info["alt"] = "Alt text with, comma"`, `picture_info["width"] = "100"`. Correct.

Case 3: `[Alt text]`
`attributes` = `["Alt text"]`
`alt_text` = "Alt text"
Loop is empty.
`picture_info["alt"] = "Alt text"`. Correct.

Case 4: `[]`
`attributes` = `[""]`
`alt_text` = ""
Loop is empty.
`picture_info["alt"] = ""`. Correct.

Case 5: `[width=100]` (No alt text explicitly, just attributes)
In AsciiDoc, if there's only one thing and it has `=`, it's an attribute, and alt text is empty.
Current code: `picture_info["alt"] = attributes[0].strip() if attributes[0] else ""` would set `alt` to `width=100`.
Wait, `attributes` is `["width=100"]`.
`alt_text` = "width=100".
Loop is empty.
Result: `alt="width=100"`. This is probably wrong for AsciiDoc, but is it what the CURRENT code does?
Existing code:
```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()
```
If `attributes` is `["width=100"]`, `picture_info["alt"]` becomes "width=100".
So my proposed change maintains this behavior.

Wait, should I fix the "no alt text" case too?
If `attributes[0]` contains `=`, it's likely an attribute, not alt text.
But let's see if that's a common case or if we should stick to the minimal fix for the reported bug. The reported bug is about commas in alt text.

If the user wants `[width=100]`, they might intend alt text to be empty.
But `_parse_picture` handles `image::path[alt, width=100]`.

Let's see if `attributes[0]` should also be checked for `=`.
If `attributes` is `["width=100", "height=200"]`.
`alt_text` becomes "width=100".
Loop `attr` = "height=200": `attrs_dict["height"] = "200"`.
Result: `alt="width=100", height="200"`. This is definitely wrong.

However, the request is to fix the crash when alt text contains commas. Let's first fix the crash and then consider if we should improve the alt text detection.

Actually, the most robust way is to treat all fragments without `=` as part of the alt text. But the alt text is always first.

Wait, if we have `[width=100, Alt text]`, that's probably not valid AsciiDoc or `Alt text` would be treated as part of an attribute.
In AsciiDoc, the first comma-separated value is the alt text. If it's empty, it's `[,]`.

Let's refine the logic:
The first item is *always* treated as the alt text unless it contains `=`, in which case it's an attribute and the alt text is empty.
Wait, no. If the first item contains `=`, it can still be the alt text if the user really wanted that. But in practice, `key=value` is an attribute.

Actually, looking at the current implementation:
```python
                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 clearly assumes the first one is alt text.

If the alt text contains commas, those subsequent fragments will be processed by `attr.split("=")`.
If they don't contain `=`, it crashes.

So the fix is:
```python
            if attributes:
                 alt_text = 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:
                         alt_text += ", " + attr.strip()
                picture_info["alt"] = alt_text
```

Wait, if the alt text is `Alt Text` and we have `width=100`, `alt_text` remains `Alt Text`.
If the alt text is `Alt, Text` and we have `width=100`, `attributes` is `["Alt", " Text", " width=100"]`.
`alt_text` starts as `Alt`.
Loop 1: ` attr` = " Text", `alt_text` becomes `Alt, Text`.
Loop 2: ` attr` = " width=100", `picture_info["width"]` = "100".
`picture_info["alt"]` = `Alt, Text`.
This looks correct and handles the crash.

Let's check if `attr.split("=")` could fail if there are multiple `=` signs.
`width=100=200`
`attr.split("=")` would return `["width", "100", "200"]`.
Unpacking `key, value = ["width", "100", "200"]` would raise `ValueError: too many values to unpack (expected 2)`.
Using `.split("=", 1)` is safer.

Let's review the `read_file` content again.
```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()
```

I will replace this block.

One more thing: what if `attributes` is empty?
`image::path.png[]` -> `mtch.group(2)` is `""`. `"".split(",")` returns `[""]`.
`attributes` is `[""]`.
`attributes[0]` is `""`. `alt_text` = `""`.
Loop is empty.
`picture_info["alt"] = ""`. Correct.

What if `image::path.png` (no brackets)?
`mtch = re.match(r"^image::(.+)\[(.*)\]$", line)`
The brackets are required by the regex.
If no brackets, `mtch` is None.
Then it returns `{"type": "picture", "uri": line}`. Correct.

Wait, look at the regex: `r"^image::(.+)\[(.*)\]$"`
If the line is `image::path/to/image.png[Alt Text, width=200, height=150, align=center]`, then:
`mtch.group(1)` is `path/to/image.png`.
`mtch.group(2)` is `Alt Text, width=200, height=150, align=center`.

If the line is `image::path/to/image.png` (no brackets), `mtch` is None.

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                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                        alt_text += \", \" + attr.strip()\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,14 @@\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                 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+                        alt_text += \", \" + attr.strip()\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 and also some edge cases.
Edge cases to test:
1. Alt text with commas and attributes.
2. Alt text with commas and no attributes.
3. No alt text, only attributes.
4. Empty brackets.
5. No brackets.
6. Attribute with multiple `=` signs.

{
  "command": "python3 - <<'PY'\nfrom docling.document_converter import DocumentConverter\nfrom docling.datamodel.base_models import InputFormat\nfrom pathlib import Path\nimport tempfile\nfrom docling.backend.asciidoc_backend import AsciiDocBackend\n\ndef test_parse_picture_internal():\n    test_cases = [\n        # (line, expected_alt, expected_attrs)\n        (\"image::path.png[Alt Text, width=100]\", \"Alt Text\", {\"width\": \"100\"}),\n        (\"image::path.png[Alt, with comma, width=100]\", \"Alt, with comma\", {\"width\": \"100\"}),\n        (\"image::path.png[Alt with, multiple, commas]\", \"Alt with, multiple, commas\", {}),\n        (\"image::path.png[width=100, height=200]\", \"width=100\", {\"height\": \"200\"}), # Current behavior\n        (\"image::path.png[]\", \"\", {}),\n        (\"image::path.png[ Alt Text ]\", \"Alt Text\", {}),\n        (\"image::path.png[Alt, width=100=200]\", \"Alt\", {\"width\": \"100=200\"}),\n        (\"image::path.png\", None, None), # Should return {\"type\": \"picture\", \"uri\": \"image::path.png\"}\n    ]\n    \n    for line, exp_alt, exp_attrs in test_cases:\n        res = AsciiDocBackend._parse_picture(line)\n        assert res[\"type\"] == \"picture\"\n        if exp_alt is not None:\n            assert res.get(\"alt\") == exp_alt\n            # Check other attributes\n            for k, v in exp_attrs.items():\n                assert res.get(k) == v\n            # Check no extra attributes\n            for k in res:\n                if k not in [\"type\", \"uri\", \"alt\"] and k not in exp_attrs:\n                    print(f\"Unexpected attribute {k} in {res} for line {line}\")\n                    assert False\n        else:\n            # No brackets case\n            assert res[\"uri\"] == line\n            assert \"alt\" not in res\n    print(\"Internal tests passed!\")\n\ntest_parse_picture_internal()\n\n# Integration test from problem statement\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  \"\"\"\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}\")\n    assert result[0].status is not None # Just check it doesn't crash and returns status\nfinally:\n    tmp_path.unlink()\nPY\n"
}

{
  "status": "ok",
  "stdout": "Internal tests passed!\nStatus: success\nErrors: []\n",
  "stderr": "",
  "exit_code": 0
}

The integration test now returns `Status: success` and `Errors: []`.
The internal tests also passed.

One detail: `image::path.png[width=100, height=200]` results in `alt="width=100", height="200"`.
Wait, if the first element has `=`, should it be part of the alt text?
Generally in AsciiDoc, if you want an empty alt text and attributes, you'd use `[,]` or just `[]`.
If you have `[width=100]`, AsciiDoc might treat `width=100` as the alt text.
According to AsciiDoc documentation: "The first argument to the image macro is the image alternative text. Any subsequent arguments are attributes of the image."
So yes, the first argument is always alt text.

Let's double check the `tests/test_backend_asciidoc.py` file to see if there are existing tests that I might have broken or that I should add.

{
  "filepath": "tests/test_backend_asciidoc.py"
}

{
  "status": "ok",
  "filepath": "tests/test_backend_asciidoc.py",
  "content": "import glob\nimport os\nfrom pathlib import Path\n\nfrom docling.backend.asciidoc_backend import (\n    DEFAULT_IMAGE_HEIGHT,\n    DEFAULT_IMAGE_WIDTH,\n    AsciiDocBackend,\n)\nfrom docling.datamodel.base_models import InputFormat\nfrom docling.datamodel.document import InputDocument\n\n\ndef _get_backend(fname):\n    in_doc = InputDocument(\n        path_or_stream=fname,\n        format=InputFormat.ASCIIDOC,\n        backend=AsciiDocBackend,\n    )\n\n    doc_backend = in_doc._backend\n    return doc_backend\n\n\ndef test_parse_picture():\n    line = (\n        \"image::images/example1.png[Example Image, width=200, height=150, align=center]\"\n    )\n    res = AsciiDocBackend._parse_picture(line)\n    assert res\n    assert res.get(\"width\", 0) == \"200\"\n    assert res.get(\"height\", 0) == \"150\"\n    assert res.get(\"uri\", \"\") == \"images/example1.png\"\n\n    line = \"image::renamed-bookmark.png[Renamed bookmark]\"\n    res = AsciiDocBackend._parse_picture(line)\n    assert res\n    assert \"width\" not in res\n    assert \"height\" not in res\n    assert res.get(\"uri\", \"\") == \"renamed-bookmark.png\"\n\n\ndef test_asciidocs_examples():\n    fnames = sorted(glob.glob(\"./tests/data/asciidoc/*.asciidoc\"))\n\n    for fname in fnames:\n        print(f\"reading {fname}\")\n\n        bname = os.path.basename(fname)\n        gname = os.path.join(\"./tests/data/groundtruth/docling_v2/\", bname + \".md\")\n\n        doc_backend = _get_backend(Path(fname))\n        doc = doc_backend.convert()\n\n        pred_itdoc = doc._export_to_indented_text(max_text_len=16)\n        print(\"\\n\\n\", pred_itdoc)\n\n        pred_mddoc = doc.export_to_markdown()\n        print(\"\\n\\n\", pred_mddoc)\n\n        if os.path.exists(gname):\n            with open(gname) as fr:\n                fr.read()\n\n            # assert pred_mddoc == true_mddoc, \"pred_mddoc!=true_mddoc for asciidoc\"\n        else:\n            with open(gname, \"w\") as fw:\n                fw.write(pred_mddoc)\n\n            # print(\"\\n\\n\", doc.export_to_markdown())\n\n    assert True",
  "start_line": 1,
  "end_line": 72,
  "total_lines": 72,
  "is_truncated": false
}

The existing tests in `tests/test_backend_asciidoc.py` are very minimal.
I've verified the fix with my own tests and the reproduction script.

One final check on the `edit_file` result.
```python
            # Extract optional attributes (alt text, width, height, alignment)
            if attributes:
                alt_text = 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:
                        alt_text += ", " + attr.strip()
                picture_info["alt"] = alt_text
```
Wait, the `attributes` list is created by `mtch.group(2).split(",")`.
If the alt text is `A screenshot showing a dialog box, containing text fields, buttons, and validation errors` and the attributes are `width=604, height=422`.
The split will be `["A screenshot showing a dialog box", " containing text fields", " buttons", " and validation errors", " width=604", " height=422"]`.
The first is `Alt text`.
Then ` containing text fields` -> `alt_text` becomes `A screenshot showing a dialog box, containing text fields`.
Then ` buttons` -> `alt_text` becomes `A screenshot showing a dialog box, containing text fields, buttons`.
And so on.
The resulting `alt` will be `A screenshot showing a dialog box, containing text fields, buttons, and validation errors`.
Exactly correct.

I'll do a final check for any other parallel paths.
The problem statement says `AsciiDocBackend._parse_picture()` crashes. I've fixed it in `AsciiDocBackend._parse_picture()`.
Are there any other methods that do similar parsing?
I'll grep for `.split(",")` in `docling/backend/asciidoc_backend.py` to see if other macros have the same bug.

{
  "command": "grep \"\\.split(\\\",\\\")\" docling/backend/asciidoc_backend.py"
}

{
  "status": "ok",
  "stdout": "            attributes = mtch.group(2).split(\",\")\n",
  "stderr": "",
  "exit_code": 0
}

It only appears in `_parse_picture`.

I'm confident with the fix.

```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 ""
                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, one detail: `alt_text += ", " + attr.strip()`.
If `attributes[0]` is `""`, and `attributes[1]` is `"Text"`, `alt_text` becomes `, Text`.
Let's check:
`alt_text = attributes[0].strip() if attributes[0] else ""`
If `attributes[0]` is `""`, `alt_text` is `""`.
If `attributes[1]` is `"Text"`, `alt_text` becomes `"" + ", " + "Text"` = `", Text"`.
This might be undesirable.

Better logic for merging:
```python
                alt_parts = [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:
                        alt_parts.append(attr.strip())
                picture_info["alt"] = ", ".join(alt_parts).lstrip(", ") # or something similar
```
Actually, if the user wrote `[, Text]`, the first part is `""`, the second is `" Text"`.
If they wrote `[Alt, Text]`, first is `"Alt"`, second is `" Text"`.

If we use `", ".join(alt_parts)`, and they had `[, Text]`, we get `, Text`.
But if they had `[Alt, Text]`, we get `Alt, Text`.

Let's see the original code:
```python
                picture_info["alt"] = attributes[0].strip() if attributes[0] else ""
```
If `attributes` is `["", "Text"]`:
`picture_info["alt"]` = `""`.
Then loop `attr = "Text"`: `key, value = "Text".split("=")` -> CRASH.

If we want to fix the crash and preserve the meaning:
If the user provides `[Alt, Text, width=100]`, they want the alt text to be `Alt, Text`.
The comma between `Alt` and `Text` is a literal comma.
The comma between `Text` and `width=100` is a delimiter.

If the user provides `[, Text, width=100]`, they might have missed the alt text or they want the alt text to start with a comma. But usually, the first item is the alt text.

Let's see how `", ".join()` would behave.
`alt_parts = ["Alt", "Text"]` -> `"Alt, Text"`
`alt_parts = ["", "Text"]` -> `", Text"`

Is `", Text"` correct if the first element is empty?
In AsciiDoc `image::path[Alt, width=100]`, `attributes` is `["Alt", " width=100"]`.
My current fix: `alt_text = "Alt"`. Loop `attr=" width=100"`, `"=" in attr` is True. `picture_info["width"] = "100"`. Result: `alt="Alt"`. Correct.

`image::path[Alt, Text, width=100]`:
`attributes` = `["Alt", " Text", " width=100"]`.
`alt_text` = `"Alt"`.
Loop 1: `attr=" Text"`, `alt_text` = `"Alt, Text"`.
Loop 2: `attr=" width=100"`, `picture_info["width"] = "100"`.
Result: `alt="Alt, Text"`. Correct.

`image::path[, Text, width=100]`:
`attributes` = `["", " Text", " width=100"]`.
`alt_text` = `""`.
Loop 1: `attr=" Text"`, `alt_text` = `", Text"`.
Loop 2: `attr=" width=100"`, `picture_info["width"] = "100"`.
Result: `alt=", Text"`.

This seems acceptable and correct given the AsciiDoc syntax where the first arg is alt text. If the first arg is empty, the alt text starts with a comma if the second arg is also treated as part of alt text.

Wait, there's a small bug in my fix:
```python
                    else:
                        alt_text += ", " + attr.strip()
```
If `alt_text` is `""` (because `attributes[0]` was empty) and `attr.strip()` is `"Text"`, `alt_text` becomes `", Text"`.
If `alt_text` is `"Alt"` and `attr.strip()` is `"Text"`, `alt_text` becomes `"Alt, Text"`.

Actually, this is consistent. If the user provides `[alt, text]`, they probably want `alt, text`. If they provide `[, text]`, they get `, text`.

Wait, if the user provides `[  , text]`, `attributes[0].strip()` is `""`.
If they provide `[text]`, `alt_text` = `"text"`.

One more edge case: what if there are many attributes and NO alt text?
`[width=100, height=200]`
`attributes` = `["width=100", " height=200"]`.
`alt_text` = `"width=100"`.
Loop 1: `attr=" height=200"`, `"=" in attr` is True. `picture_info["height"] = "200"`.
Result: `alt="width=100", height="200"`.
As I noted before, this is what the original code did. If we want to fix this, we'd need to check if `attributes[0]` contains `=`.

But the issue is specifically about crashing when alt text contains commas.

Let's stick with the current fix as it's minimal and solves the reported problem.

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

I have fixed the bug where `AsciiDocBackend._parse_picture` crashed when the image alt text contained commas. I've verified the fix with a reproduction script and additional test cases, confirming that it no longer crashes and correctly parses images with comma-separated alt text and attributes.

The bug was caused by `AsciiDocBackend._parse_picture` splitting the bracketed content of an `image::` macro by commas and assuming all elements after the first were `key=value` pairs. When the alt text contained commas, these fragments were passed to `split("=")`, resulting in a `ValueError` due to missing equals signs.

I updated the logic to check for the presence of an equals sign before attempting to unpack each attribute fragment; fragments without an equals sign are now appended back to the alt text, and `split("=", 1)` is used to safely handle values that might contain equals signs.

Verified the fix using the reproduction scenario and additional edge cases (e.g., multiple commas in alt text, no alt text, and varying attribute counts).