docling-project__docling-2983

The user is reporting a crash in `AsciiDocBackend._parse_picture()` when the image alt text contains commas.
The problematic code is likely in `docling/backend/asciidoc_backend.py`.
The error is `ValueError: not enough values to unpack (expected 2, got 1)`, which occurs when splitting by comma and expecting `key=value` pairs.

Let's start by pinpointing the code and creating a reproduction script.

{
  "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 defined in `docling/backend/asciidoc_backend.py` at line 404.
I'll read the implementation of `_parse_picture` and the corresponding tests.

{
  "end_line": 450,
  "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\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": 380,
  "end_line": 443,
  "total_lines": 443,
  "is_truncated": false
}

The code for `_parse_picture` is:

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

            return picture_info

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

(Actually, `mtch = re.match(r"^image::(.+)\\[(.*)\\]$", line)` in my `read_file` output, which is slightly different from what I typed).

The bug is here:
```python
                for attr in attributes[1:]:
                    key, value = attr.split("=")
                    picture_info[key.strip()] = value.strip()
```
If `attributes[0]` is "A screenshot showing a dialog box", and there are other commas in the alt text, like "A screenshot showing a dialog box, containing text fields, buttons, and validation errors", 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 through `attributes[1:]`:
1. `attr` = " containing text fields" -> `attr.split("=")` returns `[' containing text fields']`. Unpacking `key, value = [' containing text fields']` fails with `ValueError: not enough values to unpack (expected 2, got 1)`.

This confirms the bug.

Now let's create a 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\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()\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 script confirms the bug.
Now I need to fix it.

The goal is to correctly parse the attributes in `image::path[alt, key1=val1, key2=val2]`.
The alt text is the first element, but it can contain commas.
Wait, if the alt text can contain commas, how do we know when the alt text ends and the `key=value` pairs begin?

In AsciiDoc, the `image::` macro syntax is:
`image::filename[alt text, attribute1=value1, attribute2=value2]`

Usually, the alt text is the first comma-separated value. But if the alt text itself contains commas, it's tricky.
Wait, if the alt text is quoted? The current code doesn't handle quotes.

If the alt text can have commas, maybe the attributes that are `key=value` should be identified by the presence of `=`.

Let's see:
`attributes = mtch.group(2).split(",")`
If we have `[Alt text with commas, width=200, height=150]`
`attributes` is `['Alt text with commas', ' width=200', ' height=150']`.
Wait, in my reproduction:
`[A screenshot showing a dialog box, containing text fields, buttons, and validation errors, width=604, height=422]`
`attributes` is `['A screenshot showing a dialog box', ' containing text fields', ' buttons', ' and validation errors', ' width=604', ' height=422']`.

If the intention is that everything before the first `key=value` pair is part of the alt text, that's one way.
But the alt text is specifically the first element.

If we look at how AsciiDoc usually handles this, if the alt text contains commas, it should probably be quoted or escaped. But the issue says "commas in alt text (common in auto-generated exports from tools like Word/Doc2Help)".

If we assume that any attribute that doesn't contain `=` should be treated as part of the alt text unless it's the first one? No, that's not quite right.

Commonly, the first comma-separated item is the alt text. If subsequent items don't have `=`, they might be intended as part of the alt text, OR they are just malformed attributes.

Actually, a better way to parse this is to find all `key=value` pairs from the end, or better, just filter out the ones that are actually `key=value` and lump everything else into the alt text?

Wait, if I have `[Alt text, width=200, height=150]`, then `alt` = "Alt text".
If I have `[Alt text with, comma, width=200, height=150]`, then `alt` = "Alt text with, comma".

So, the logic should be:
1. Split by comma.
2. The first element is always the start of the alt text.
3. For subsequent elements:
   - If it contains `=`, it's a `key=value` pair.
   - If it doesn't contain `=`, it's part of the alt text.

Let's trace this:
Input: `[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 `=`) -> append to `alt`. `alt` = "A screenshot showing a dialog box, containing text fields"
3. `attr` = " buttons" (no `=`) -> append to `alt`. `alt` = "A screenshot showing a dialog box, containing text fields, buttons"
4. `attr` = " and validation errors" (no `=`) -> append to `alt`. `alt` = "A screenshot showing a dialog box, containing text fields, buttons, and validation errors"
5. `attr` = " width=604" (has `=`) -> `key` = "width", `value` = "604".
6. `attr` = " height=422" (has `=`) -> `key` = "height", `value` = "422".

This seems correct and robust for the reported case.

Wait, what if the alt text is empty? `image::path.png[, width=200]`
`attributes` = `['', ' width=200']`
1. `alt` = ""
2. `attr` = " width=200" (has `=`) -> `key` = "width", `value` = "200".
Result: `alt` = "", `width` = "200". Correct.

What if there are no attributes? `image::path.png[Alt text]`
`attributes` = `['Alt text']`
1. `alt` = "Alt text"
Result: `alt` = "Alt text". Correct.

What if it is just `image::path.png[]`?
`attributes` = `['']`
1. `alt` = ""
Result: `alt` = "". Correct.

What if it's `image::path.png` (no brackets)?
`mtch` will be None because `re.match(r"^image::(.+)\\[(.*)\\]$", line)` requires brackets.
Wait, the regex is `r"^image::(.+)\\[(.*)\\]$"` (escaped in Python string as `\\[` and `\\]`).
If `line` = `image::path.png`, `mtch` is None.
Then it returns `{"type": "picture", "uri": line}`.
Wait, if `line` is `image::path.png`, then `uri` becomes `image::path.png`. That seems wrong, it should probably be `path.png`.

Let's check `_parse_picture` again.
```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()
            # ...
            return picture_info

        return {"type": "picture", "uri": line}
```
If `line` is `image::path.png`, it returns `{"type": "picture", "uri": "image::path.png"}`.
Is this intended? The current code does exactly that. The issue is about the brackets part. I should stick to fixing the reported bug.

The fix:
Modify the loop in `_parse_picture` to handle attributes without `=`.

```python
            if attributes:
                alt_text_parts = [attributes[0].strip()]
                for attr in attributes[1:]:
                    if "=" in attr:
                        key, value = attr.split("=", 1)
                        picture_info[key.strip()] = value.strip()
                    else:
                        alt_text_parts.append(attr.strip())
                
                picture_info["alt"] = ", ".join(filter(None, alt_text_parts))
```
Wait, if `attributes[0]` is empty, `filter(None, alt_text_parts)` will remove it.
If `attributes` = `['', ' width=200']`, then `alt_text_parts` = `['']`. `", ".join(filter(None, alt_text_parts))` is `""`. Correct.
If `attributes` = `['Alt', ' text', ' width=200']`, then `alt_text_parts` = `['Alt', ' text']`. `", ".join(filter(None, alt_text_parts))` is `"Alt, text"`. Correct.

Wait, if `attributes[0]` is not empty, we want to keep it. If it is empty, we don't want to lead with a comma.

Let's refine the `alt` text reconstruction.
If `attributes[0]` is present, it's the first part. Any subsequent part that doesn't have `=` is also part of the alt text.

```python
            if attributes:
                alt_text_parts = []
                # The first element is always (potentially) part of the alt text
                alt_text_parts.append(attributes[0].strip())
                
                for attr in attributes[1:]:
                    if "=" in attr:
                        key, value = attr.split("=", 1)
                        picture_info[key.strip()] = value.strip()
                    else:
                        alt_text_parts.append(attr.strip())
                
                # Join alt text parts with comma, but handle empty first element
                # Actually, the original code did: picture_info["alt"] = attributes[0].strip() if attributes[0] else ""
                # If we have [Alt text, with comma, width=200]
                # attributes = ['Alt text', ' with comma', ' width=200']
                # alt_text_parts = ['Alt text', 'with comma']
                # joined = "Alt text, with comma"
                
                # If we have [, width=200]
                # attributes = ['', ' width=200']
                # alt_text_parts = ['']
                # joined = "" (if we use filter(None, ...))
                
                # Let's see...
                alt_text = ", ".join(p for p in alt_text_parts if p)
                picture_info["alt"] = alt_text
```

Wait, if `attributes` is `['']`, then `alt_text_parts` = `['']`. `alt_text` = `""`. Correct.

One detail: `attr.split("=", 1)` is safer than `attr.split("=")` in case the value contains an equals sign (though unlikely for these attributes).

Let's check the original code's behavior for `attributes[0]` being empty:
```python
                picture_info["alt"] = attributes[0].strip() if attributes[0] else ""
```
If `attributes = ['']`, `attributes[0]` is `''`, so `picture_info["alt"] = ""`.
If `attributes = [' ', 'width=200']`, `attributes[0]` is `' '`, so `attributes[0].strip()` is `''`. Wait, `' '` is truthy in Python. So `attributes[0].strip()` would be `''`.
Actually, `if attributes[0]:` where `attributes[0]` is `' '` will be True. Then `attributes[0].strip()` will be `''`.

Let's check if I should use `if attributes[0].strip():` instead.

Original:
```python
                picture_info["alt"] = attributes[0].strip() if attributes[0] else ""
```
If `attributes[0]` is `" "`, then `attributes[0].strip()` is `""`.

If I use:
```python
                alt_text_parts = []
                alt_text_parts.append(attributes[0].strip())
                # ...
                picture_info["alt"] = ", ".join(p for p in alt_text_parts if p)
```
If `attributes[0]` is `" "`, `alt_text_parts` is `[""]`. `alt_text` is `""`.

This seems consistent.

Let's double check the `_parse_picture` function in `docling/backend/asciidoc_backend.py` again.

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

            return picture_info

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

I will replace the `if attributes:` block.

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

Wait, I should make sure I don't break anything.
What if `attributes` is `['width=200']` (i.e., alt text is missing)?
AsciiDoc syntax says the first one is alt text. If the user writes `image::path[width=200]`, then `attributes[0]` is `width=200`.
In the original code:
`picture_info["alt"]` = `"width=200"`.
Then the loop `for attr in attributes[1:]` is empty.
So `alt` becomes `"width=200"`. This is probably how it should be if no comma is present.

In my proposed code:
`alt_text_parts` = `["width=200"]`.
`alt_text` = `"width=200"`.
Seems consistent.

What if `image::path[, width=200]`?
Original:
`attributes` = `['', ' width=200']`
`picture_info["alt"]` = `""`
Loop: `attr` = `" width=200"`, `key` = `"width"`, `value` = `"200"`.
Result: `alt` = `""`, `width` = `"200"`.

My proposed code:
`alt_text_parts` = `['']`
Loop: `attr` = `" width=200"`, `key` = `"width"`, `value` = `"200"`.
`alt_text` = `""` (because `""` is falsy).
Result: `alt` = `""`, `width` = `"200"`.

Seems consistent.

What if `image::path[Alt, width=200, height=100]`?
Original:
`attributes` = `['Alt', ' width=200', ' height=100']`
`alt` = `"Alt"`
Loop: `width=200`, `height=100`.
Result: `alt` = `"Alt"`, `width` = `"200"`, `height` = `"100"`.

My proposed code:
`alt_text_parts` = `['Alt']`
Loop: `width=200`, `height=100`.
`alt_text` = `"Alt"`.
Result: `alt` = `"Alt"`, `width` = `"200"`, `height` = `"100"`.

Seems consistent.

What if `image::path[Alt with, comma, width=200]`?
Original:
`attributes` = `['Alt with', ' comma', ' width=200']`
`alt` = `"Alt width"`
Loop:
- `attr` = `" comma"` -> `split("=")` -> `ValueError`

My proposed code:
`alt_text_parts` = `['Alt with']`
Loop:
- `attr` = `" comma"` -> no `=` -> `alt_text_parts.append("comma")`
- `attr` = `" width=200"` -> has `=` -> `width` = `"200"`
`alt_text` = `"Alt with, comma"`.
Result: `alt` = `"Alt with, comma"`, `width` = `"200"`.

This is exactly what was requested.

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_parts = []\n                alt_text_parts.append(attributes[0].strip())\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_parts.append(attr.strip())\n                picture_info[\"alt\"] = \", \".join(p for p in alt_text_parts if p)\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,15 @@\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_parts = []\n+                alt_text_parts.append(attributes[0].strip())\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_parts.append(attr.strip())\n+                picture_info[\"alt\"] = \", \".join(p for p in alt_text_parts if p)\n \n             return picture_info\n \n",
  "is_truncated": false
}

Now let's verify the fix with the reproduction script and the existing tests in `tests/test_backend_asciidoc.py`.

{
  "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}\")\n    # Verify alt text if possible. The DocumentConverter result doesn't easily show the internal picture_info.\n    # But let's check the status.\nexcept Exception as e:\n    print(f\"Exception: {e}\")\nfinally:\n    tmp_path.unlink()\nPY\n"
}

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

The reproduction script now passes. Now let's run the existing tests for `AsciiDocBackend`.

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

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

Existing tests passed. I should also check if there are any other parallel paths.
The search for `_parse_picture` only found one implementation in `docling/backend/asciidoc_backend.py`.

Wait, let me double check if there are any other backends that might have similar logic.
`grep -rn "image::" docling/backend`

{
  "command": "grep -rn \"image::\" docling/backend"
}

{
  "status": "ok",
  "stdout": "docling/backend/asciidoc_backend.py:401:        return re.match(r\"^image::\", line)\ndocling/backend/asciidoc_backend.py:407:        Syntax: image::path/to/image.png[Alt Text, width=200, height=150, align=center]\ndocling/backend/asciidoc_backend.py:409:        mtch = re.match(r\"^image::(.+)\\[(.*)\\]$\", line)\n",
  "stderr": "",
  "exit_code": 0
}

Only `asciidoc_backend.py` uses `image::`.

I should verify the behavior for edge cases:
1. No alt text, just attributes: `image::path[, width=200]`
2. No attributes, just alt text: `image::path[Alt text]`
3. No alt text and no attributes: `image::path[]`
4. Only attributes, first one is not an attribute: `image::path[Alt text]` (Wait, that's just alt text)
5. Alt text containing commas and no attributes: `image::path[Alt text with, commas]`
6. Attributes that might contain equals sign in value (though not expected in ADOC)

Let's create a comprehensive test script.

{
  "command": "python3 - <<'PY'\nimport re\n\ndef _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            alt_text_parts = []\n            alt_text_parts.append(attributes[0].strip())\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_parts.append(attr.strip())\n            picture_info[\"alt\"] = \", \".join(p for p in alt_text_parts if p)\n\n        return picture_info\n\n    return {\"type\": \"picture\", \"uri\": line}\n\ntest_cases = [\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    (\"image::path/to/image.png[Alt Text, width=200, height=150, align=center]\", \n     {\"type\": \"picture\", \"uri\": \"path/to/image.png\", \"alt\": \"Alt Text\", \"width\": \"200\", \"height\": \"150\", \"align\": \"center\"}),\n    (\"image::path/to/image.png[Alt text with, commas]\", \n     {\"type\": \"picture\", \"uri\": \"path/to/image.png\", \"alt\": \"Alt text with, commas\"}),\n    (\"image::path/to/image.png[, width=200]\", \n     {\"type\": \"picture\", \"uri\": \"path/to/image.png\", \"alt\": \"\", \"width\": \"200\"}),\n    (\"image::path/to/image.png[Alt text]\", \n     {\"type\": \"picture\", \"uri\": \"path/to/image.png\", \"alt\": \"Alt text\"}),\n    (\"image::path/to/image.png[]\", \n     {\"type\": \"picture\", \"uri\": \"path/to/image.png\", \"alt\": \"\"}),\n    (\"image::path/to/image.png\", \n     {\"type\": \"picture\", \"uri\": \"image::path/to/image.png\"}),\n]\n\nfor line, expected in test_cases:\n    res = _parse_picture(line)\n    assert res == expected, f\"Failed for {line}. Expected {expected}, got {res}\"\nprint(\"All test cases passed!\")\nPY\n"
}

{
  "status": "error",
  "error_type": "CommandError",
  "error_message": "Traceback (most recent call last):\n  File \"<stdin>\", line 49, in <module>\nAssertionError: Failed for image::images/screenshot.png[A screenshot showing a dialog box, containing text fields, buttons, and validation errors, width=604, height=422]. Expected {'type': 'picture', 'uri': 'images/screenshot.png', 'alt': 'A screenshot showing a dialog box, containing text fields, buttons, and validation errors', 'width': '604', 'height': '422'}, got {'type': 'picture', 'uri': 'image::images/screenshot.png[A screenshot showing a dialog box, containing text fields, buttons, and validation errors, width=604, height=422]'}\n",
  "details": {
    "stdout": "",
    "stderr": "Traceback (most recent call last):\n  File \"<stdin>\", line 49, in <module>\nAssertionError: Failed for image::images/screenshot.png[A screenshot showing a dialog box, containing text fields, buttons, and validation errors, width=604, height=422]. Expected {'type': 'picture', 'uri': 'images/screenshot.png', 'alt': 'A screenshot showing a dialog box, containing text fields, buttons, and validation errors', 'width': '604', 'height': '422'}, got {'type': 'picture', 'uri': 'image::images/screenshot.png[A screenshot showing a dialog box, containing text fields, buttons, and validation errors, width=604, height=422]'}\n",
    "exit_code": 1
  }
}

Ah, I see what happened. In my embedded python script, the regex was:
`mtch = re.match(r"^image::(.+)\\[(.*)\\]$", line)`
Wait, in a raw string `r"..."`, `\\` means a literal backslash.
So `\\[` means a literal backslash followed by a literal `[`.
But the input line is `image::images/screenshot.png[...]`. It has a `[` not `\[`.

In the actual file `docling/backend/asciidoc_backend.py`, the code is:
```python
        mtch = re.match(r"^image::(.+)\\[(.*)\\]$", line)
```
Wait, I'm reading the code from `read_file` output:
`mtch = re.match(r"^image::(.+)\\[(.*)\\]$", line)`
Let me check if it's `\\[` or `\[`.
The `read_file` output shows `\\[`. In a raw string, that is a literal backslash and a literal bracket.

Wait, `read_file` output again:
`mtch = re.match(r"^image::(.+)\\[(.*)\\]$", line)`

If the code truly is `\\[`, then it only matches if the line has `\[`.
But AsciiDoc macros use `[`.
Let me re-read `read_file` output very carefully.

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

Wait! If the raw string is `r"^image::(.+)\\[(.*)\\]$"`, then `\\[` is a literal `\` followed by `[`.
But the syntax example says `image::path/to/image.png[Alt Text...]`.
Is the original code actually `r"^image::(.+)\[(.*)\]$"`?

Let me check the `read_file` output again.
Actually, the `read_file` output might be showing the escaped version of the string.
No, `read_file` returns the content of the file.

Let's look at the `read_file` output again:
`mtch = re.match(r"^image::(.+)\\[(.*)\\]$", line)`
If I see `\\[` in the `read_file` output, it means the file contains `\\[`.
But `[` is a special character in regex. To match a literal `[`, you use `\[`.
In a raw string `r"\["`, the backslash is kept, so regex sees `\[`.
If the file contains `r"\\["`, then regex sees `\\ [`, which matches a literal backslash followed by `[`.

Let me check the file content using `cat`.

{
  "command": "sed -n '409p' docling/backend/asciidoc_backend.py"
}

{
  "status": "ok",
  "stdout": "        mtch = re.match(r\"^image::(.+)\\[(.*)\\]$\", line)\n",
  "stderr": "",
  "exit_code": 0
}