]> git.madduck.net Git - etc/neomutt.git/blobdiff - .config/neomutt/buildmimetree.py

madduck's git repository

Every one of the projects in this repository is available at the canonical URL git://git.madduck.net/madduck/pub/<projectpath> — see each project's metadata for the exact URL.

All patches and comments are welcome. Please squash your changes to logical commits before using git-format-patch and git-send-email to patches@git.madduck.net. If you'd read over the Git project's submission guidelines and adhered to them, I'd be especially grateful.

SSH access, as well as push access can be individually arranged.

If you use my repositories frequently, consider adding the following snippet to ~/.gitconfig and using the third clone URL listed for each project:

[url "git://git.madduck.net/madduck/"]
  insteadOf = madduck:

fixup! Support both mp/related inline tree structures
[etc/neomutt.git] / .config / neomutt / buildmimetree.py
index 0dd18828c36f1140b1a5086e1fe6eb53cac11cfe..491696f5412c4cd11374b29c4acbedc4d6eaab10 100755 (executable)
@@ -76,6 +76,12 @@ def parse_cli_args(*args, **kwargs):
     else:
         parser.set_defaults(css_file=None)
 
     else:
         parser.set_defaults(css_file=None)
 
+    parser.add_argument(
+        "--related-to-html-only",
+        action="store_true",
+        help="Make related content be sibling to HTML parts only"
+    )
+
     parser.add_argument(
         "--only-build",
         action="store_true",
     parser.add_argument(
         "--only-build",
         action="store_true",
@@ -101,8 +107,10 @@ def parse_cli_args(*args, **kwargs):
 
     massage_p.add_argument(
         "--write-commands-to",
 
     massage_p.add_argument(
         "--write-commands-to",
+        "-o",
         metavar="PATH",
         dest="cmdpath",
         metavar="PATH",
         dest="cmdpath",
+        required=True,
         help="Temporary file path to write commands to",
     )
 
         help="Temporary file path to write commands to",
     )
 
@@ -250,6 +258,9 @@ class Multipart(
     def __str__(self):
         return f"<multipart/{self.subtype}> children={len(self.children)}"
 
     def __str__(self):
         return f"<multipart/{self.subtype}> children={len(self.children)}"
 
+    def __hash__(self):
+        return hash(str(self.subtype) + "".join(str(self.children)))
+
 
 def filewriter_fn(path, content, mode="w", **kwargs):
     with open(path, mode, **kwargs) as out_f:
 
 def filewriter_fn(path, content, mode="w", **kwargs):
     with open(path, mode, **kwargs) as out_f:
@@ -261,6 +272,9 @@ def collect_inline_images(
 ):
     relparts = []
     for path, info in images.items():
 ):
     relparts = []
     for path, info in images.items():
+        if path.startswith("cid:"):
+            continue
+
         data = request.urlopen(path)
 
         mimetype = data.headers["Content-Type"]
         data = request.urlopen(path)
 
         mimetype = data.headers["Content-Type"]
@@ -286,6 +300,7 @@ def convert_markdown_to_html(
     origtext,
     draftpath,
     *,
     origtext,
     draftpath,
     *,
+    related_to_html_only=False,
     cssfile=None,
     filewriter_fn=filewriter_fn,
     tempdir=None,
     cssfile=None,
     filewriter_fn=filewriter_fn,
     tempdir=None,
@@ -314,73 +329,98 @@ def convert_markdown_to_html(
     )
     htmlpart = Part("text", "html", htmlpath, "HTML version")
 
     )
     htmlpart = Part("text", "html", htmlpath, "HTML version")
 
-    altpart = Multipart(
-        "alternative", [textpart, htmlpart], "Group of alternative content"
-    )
-
     imgparts = collect_inline_images(
         images, tempdir=tempdir, filewriter_fn=filewriter_fn
     )
     imgparts = collect_inline_images(
         images, tempdir=tempdir, filewriter_fn=filewriter_fn
     )
-    if imgparts:
+
+    if related_to_html_only:
+        # If there are inline image part, they will be contained within a
+        # multipart/related part along with the HTML part only
+        if imgparts:
+            # replace htmlpart with a multipart/related container of the HTML
+            # parts and the images
+            htmlpart = Multipart(
+                "relative", [htmlpart] + imgparts, "Group of related content"
+            )
+
         return Multipart(
         return Multipart(
-            "relative", [altpart] + imgparts, "Group of related content"
+            "alternative", [textpart, htmlpart], "Group of alternative content"
         )
         )
+
     else:
     else:
-        return altpart
+        # If there are inline image part, they will be siblings to the
+        # multipart/alternative tree within a multipart/related part
+        altpart = Multipart(
+            "alternative", [textpart, htmlpart], "Group of alternative content"
+        )
+        if imgparts:
+            return Multipart(
+                "relative", [altpart] + imgparts, "Group of related content"
+            )
+        else:
+            return altpart
 
 
 class MIMETreeDFWalker:
     def __init__(self, *, visitor_fn=None, debug=False):
 
 
 class MIMETreeDFWalker:
     def __init__(self, *, visitor_fn=None, debug=False):
-        self._visitor_fn = visitor_fn
+        self._visitor_fn = visitor_fn or self._echovisit
         self._debug = debug
 
         self._debug = debug
 
+    def _echovisit(self, node, ancestry, debugprint):
+        debugprint(f"node={node} ancestry={ancestry}")
+
     def walk(self, root, *, visitor_fn=None):
         """
         Recursive function to implement a depth-dirst walk of the MIME-tree
         rooted at `root`.
         """
     def walk(self, root, *, visitor_fn=None):
         """
         Recursive function to implement a depth-dirst walk of the MIME-tree
         rooted at `root`.
         """
-
         if isinstance(root, list):
         if isinstance(root, list):
-            root = Multipart("mixed", children=root)
+            if len(root) > 1:
+                root = Multipart("mixed", children=root)
+            else:
+                root = root[0]
 
         self._walk(
             root,
 
         self._walk(
             root,
-            stack=[],
+            ancestry=[],
             visitor_fn=visitor_fn or self._visitor_fn,
         )
 
             visitor_fn=visitor_fn or self._visitor_fn,
         )
 
-    def _walk(self, node, *, stack, visitor_fn):
+    def _walk(self, node, *, ancestry, visitor_fn):
         # Let's start by enumerating the parts at the current level. At the
         # Let's start by enumerating the parts at the current level. At the
-        # root level, stack will be the empty list, and we expect a multipart/*
-        # container at this level. Later, e.g. within a mutlipart/alternative
-        # container, the subtree will just be the alternative parts, while the
-        # top of the stack will be the multipart/alternative container, which
-        # we will process after the following loop.
-
-        lead = f"{'| '*len(stack)}|-"
+        # root level, ancestry will be the empty list, and we expect a
+        # multipart/* container at this level. Later, e.g. within a
+        # mutlipart/alternative container, the subtree will just be the
+        # alternative parts, while the top of the ancestry will be the
+        # multipart/alternative container, which we will process after the
+        # following loop.
+
+        lead = f"{'│ '*len(ancestry)}"
         if isinstance(node, Multipart):
             self.debugprint(
         if isinstance(node, Multipart):
             self.debugprint(
-                f"{lead}{node} parents={[s.subtype for s in stack]}"
+                f"{lead}├{node} ancestry={[s.subtype for s in ancestry]}"
             )
 
             )
 
-            # Depth-first, so push the current container onto the stack,
-            # then descend …
-            stack.append(node)
-            self.debugprint("| " * (len(stack) + 1))
+            # Depth-first, so push the current container onto the ancestry
+            # stack, then descend …
+            ancestry.append(node)
+            self.debugprint(lead + "│ " * 2)
             for child in node.children:
                 self._walk(
                     child,
             for child in node.children:
                 self._walk(
                     child,
-                    stack=stack,
+                    ancestry=ancestry,
                     visitor_fn=visitor_fn,
                 )
                     visitor_fn=visitor_fn,
                 )
-            self.debugprint("| " * len(stack))
-            assert stack.pop() == node
+            assert ancestry.pop() == node
 
         else:
 
         else:
-            self.debugprint(f"{lead}{node}")
+            self.debugprint(f"{lead}├{node}")
+
+        if False and ancestry:
+            self.debugprint(lead[:-1] + " │")
 
         if visitor_fn:
 
         if visitor_fn:
-            visitor_fn(node, stack, debugprint=self.debugprint)
+            visitor_fn(node, ancestry, debugprint=self.debugprint)
 
     def debugprint(self, s, **kwargs):
         if self._debug:
 
     def debugprint(self, s, **kwargs):
         if self._debug:
@@ -465,6 +505,7 @@ def do_massage(
     extensions=None,
     cssfile=None,
     converter=convert_markdown_to_html,
     extensions=None,
     cssfile=None,
     converter=convert_markdown_to_html,
+    related_to_html_only=True,
     only_build=False,
     tempdir=None,
     debug_commands=False,
     only_build=False,
     tempdir=None,
     debug_commands=False,
@@ -493,13 +534,16 @@ def do_massage(
         draft_f.read(),
         draftpath,
         cssfile=cssfile,
         draft_f.read(),
         draftpath,
         cssfile=cssfile,
+        related_to_html_only=related_to_html_only,
         tempdir=tempdir,
         extensions=extensions,
     )
 
     mimetree = MIMETreeDFWalker(debug=debug_walk)
 
         tempdir=tempdir,
         extensions=extensions,
     )
 
     mimetree = MIMETreeDFWalker(debug=debug_walk)
 
-    def visitor_fn(item, stack, *, debugprint=None):
+    state = dict(pos=1, tags={}, parts=1)
+
+    def visitor_fn(item, ancestry, *, debugprint=None):
         """
         Visitor function called for every node (part) of the MIME tree,
         depth-first, and responsible for telling NeoMutt how to assemble
         """
         Visitor function called for every node (part) of the MIME tree,
         depth-first, and responsible for telling NeoMutt how to assemble
@@ -516,13 +560,27 @@ def do_massage(
                 # The original source already exists in the NeoMutt tree, but
                 # the underlying file may have been modified, so we need to
                 # update the encoding, but that's it:
                 # The original source already exists in the NeoMutt tree, but
                 # the underlying file may have been modified, so we need to
                 # update the encoding, but that's it:
+                cmds.push("<first-entry>")
                 cmds.push("<update-encoding>")
                 cmds.push("<update-encoding>")
+
+                # We really just need to be able to assume that at this point,
+                # NeoMutt is at position 1, and that we've processed only this
+                # part so far. Nevermind about actual attachments, we can
+                # safely ignore those as they stay at the end.
+                assert state["pos"] == 1
+                assert state["parts"] == 1
             else:
                 # … whereas all other parts need to be added, and they're all
                 # considered to be temporary and inline:
                 cmds.push(f"<attach-file>{item.path}<enter>")
                 cmds.push("<toggle-unlink><toggle-disposition>")
 
             else:
                 # … whereas all other parts need to be added, and they're all
                 # considered to be temporary and inline:
                 cmds.push(f"<attach-file>{item.path}<enter>")
                 cmds.push("<toggle-unlink><toggle-disposition>")
 
+                # This added a part at the end of the list of parts, and that's
+                # just how many parts we've seen so far, so it's position in
+                # the NeoMutt compose list is the count of parts
+                state["parts"] += 1
+                state["pos"] = state["parts"]
+
             # If the item (including the original) comes with additional
             # information, then we might just as well update the NeoMutt
             # tree now:
             # If the item (including the original) comes with additional
             # information, then we might just as well update the NeoMutt
             # tree now:
@@ -531,29 +589,47 @@ def do_massage(
 
         elif isinstance(item, Multipart):
             # This node has children, but we already visited them (see
 
         elif isinstance(item, Multipart):
             # This node has children, but we already visited them (see
-            # above), and so they have been tagged in NeoMutt's compose
-            # window. Now it's just a matter of telling NeoMutt to do the
-            # appropriate grouping:
+            # above). The tags dictionary of State should contain a list of
+            # their positions in the NeoMutt compose window, so iterate those
+            # and tag the parts there:
+            for tag in state["tags"][item]:
+                cmds.push(f"<jump>{tag}<enter><tag-entry>")
+
             if item.subtype == "alternative":
                 cmds.push("<group-alternatives>")
             elif item.subtype in ("relative", "related"):
                 cmds.push("<group-related>")
             elif item.subtype == "multilingual":
                 cmds.push("<group-multilingual>")
             if item.subtype == "alternative":
                 cmds.push("<group-alternatives>")
             elif item.subtype in ("relative", "related"):
                 cmds.push("<group-related>")
             elif item.subtype == "multilingual":
                 cmds.push("<group-multilingual>")
+            else:
+                raise NotImplementedError(
+                    f"Handling of multipart/{item.subtype} is not implemented"
+                )
+
+            state["pos"] -= len(state["tags"][item]) - 1
+            state["parts"] += 1
+            del state["tags"][item]
 
         else:
             # We should never get here
 
         else:
             # We should never get here
-            assert not "is valid part"
+            raise RuntimeError(f"Type {type(item)} is unexpected: {item}")
 
         # If the item has a description, we might just as well add it
         if item.desc:
             cmds.push(f"<edit-description>{KILL_LINE}{item.desc}<enter>")
 
 
         # If the item has a description, we might just as well add it
         if item.desc:
             cmds.push(f"<edit-description>{KILL_LINE}{item.desc}<enter>")
 
-        # Finally, if we're at non-root level, tag the new container,
-        # as it might itself be part of a container, to be processed
-        # one level up:
-        if stack:
-            cmds.push("<tag-entry>")
+        if ancestry:
+            # If there's an ancestry, record the current (assumed) position in
+            # the NeoMutt compose window as needed-to-tag by our direct parent
+            # (i.e. the last item of the ancestry)
+            state["tags"].setdefault(ancestry[-1], []).append(state["pos"])
+
+            lead = "│ " * (len(ancestry) + 1) + "* "
+            debugprint(
+                f"{lead}ancestry={[a.subtype for a in ancestry]}\n"
+                f"{lead}children_positions={state['tags'][ancestry[-1]]}\n"
+                f"{lead}pos={state['pos']}, parts={state['parts']}"
+            )
 
     # -----------------
     # End of visitor_fn
 
     # -----------------
     # End of visitor_fn
@@ -597,6 +673,7 @@ if __name__ == "__main__":
                 cmd_f,
                 extensions=args.extensions,
                 cssfile=args.css_file,
                 cmd_f,
                 extensions=args.extensions,
                 cssfile=args.css_file,
+                related_to_html_only=args.related_to_html_only,
                 only_build=args.only_build,
                 tempdir=args.tempdir,
                 debug_commands=args.debug_commands,
                 only_build=args.only_build,
                 tempdir=args.tempdir,
                 debug_commands=args.debug_commands,
@@ -666,7 +743,7 @@ try:
             assert lines[5] in lines_out[7]
 
         @pytest.fixture
             assert lines[5] in lines_out[7]
 
         @pytest.fixture
-        def basic_mime_tree(self):
+        def mime_tree_related_to_alternative(self):
             return Multipart(
                 "relative",
                 children=[
             return Multipart(
                 "relative",
                 children=[
@@ -691,15 +768,49 @@ try:
                 desc="Related",
             )
 
                 desc="Related",
             )
 
-        def test_MIMETreeDFWalker_depth_first_walk(self, basic_mime_tree):
+        @pytest.fixture
+        def mime_tree_related_to_html(self):
+            return Multipart(
+                "alternative",
+                children=[
+                    Part(
+                        "text",
+                        "plain",
+                        "part.txt",
+                        desc="Plain",
+                        orig=True,
+                    ),
+                    Multipart(
+                        "relative",
+                        children=[
+                            Part("text", "html", "part.html", desc="HTML"),
+                            Part(
+                                "text",
+                                "png",
+                                "logo.png",
+                                cid="logo.png",
+                                desc="Logo",
+                            ),
+                        ],
+                        desc="Related",
+                    ),
+                ],
+                desc="Alternative",
+            )
+
+        def test_MIMETreeDFWalker_depth_first_walk(
+            self, mime_tree_related_to_alternative
+        ):
             mimetree = MIMETreeDFWalker()
 
             items = []
 
             mimetree = MIMETreeDFWalker()
 
             items = []
 
-            def visitor_fn(item, stack, debugprint):
-                items.append((item, len(stack)))
+            def visitor_fn(item, ancestry, debugprint):
+                items.append((item, len(ancestry)))
 
 
-            mimetree.walk(basic_mime_tree, visitor_fn=visitor_fn)
+            mimetree.walk(
+                mime_tree_related_to_alternative, visitor_fn=visitor_fn
+            )
             assert len(items) == 5
             assert items[0][0].subtype == "plain"
             assert items[0][1] == 2
             assert len(items) == 5
             assert items[0][0].subtype == "plain"
             assert items[0][1] == 2
@@ -712,26 +823,29 @@ try:
             assert items[4][0].subtype == "relative"
             assert items[4][1] == 0
 
             assert items[4][0].subtype == "relative"
             assert items[4][1] == 0
 
-        def test_MIMETreeDFWalker_list_to_mixed(self, basic_mime_tree):
+        def test_MIMETreeDFWalker_list_to_mixed(self, const1):
             mimetree = MIMETreeDFWalker()
             items = []
 
             mimetree = MIMETreeDFWalker()
             items = []
 
-            def visitor_fn(item, stack, debugprint):
+            def visitor_fn(item, ancestry, debugprint):
                 items.append(item)
 
                 items.append(item)
 
-            mimetree.walk([basic_mime_tree], visitor_fn=visitor_fn)
+            p = Part("text", "plain", const1)
+            mimetree.walk([p], visitor_fn=visitor_fn)
+            assert items[-1].subtype == "plain"
+            mimetree.walk([p, p], visitor_fn=visitor_fn)
             assert items[-1].subtype == "mixed"
 
         def test_MIMETreeDFWalker_visitor_in_constructor(
             assert items[-1].subtype == "mixed"
 
         def test_MIMETreeDFWalker_visitor_in_constructor(
-            self, basic_mime_tree
+            self, mime_tree_related_to_alternative
         ):
             items = []
 
         ):
             items = []
 
-            def visitor_fn(item, stack, debugprint):
+            def visitor_fn(item, ancestry, debugprint):
                 items.append(item)
 
             mimetree = MIMETreeDFWalker(visitor_fn=visitor_fn)
                 items.append(item)
 
             mimetree = MIMETreeDFWalker(visitor_fn=visitor_fn)
-            mimetree.walk(basic_mime_tree)
+            mimetree.walk(mime_tree_related_to_alternative)
             assert len(items) == 5
 
         @pytest.fixture
             assert len(items) == 5
 
         @pytest.fixture
@@ -739,7 +853,14 @@ try:
             return StringIO(text or const1)
 
         def test_do_massage_basic(self, const1, string_io, capsys):
             return StringIO(text or const1)
 
         def test_do_massage_basic(self, const1, string_io, capsys):
-            def converter(drafttext, draftpath, cssfile, extensions, tempdir):
+            def converter(
+                drafttext,
+                draftpath,
+                cssfile,
+                related_to_html_only,
+                extensions,
+                tempdir,
+            ):
                 return Part("text", "plain", draftpath, orig=True)
 
             do_massage(
                 return Part("text", "plain", draftpath, orig=True)
 
             do_massage(
@@ -757,14 +878,22 @@ try:
             assert "unset my_edit_headers" == lines.pop(0)
             assert "send-message" in lines.pop(0)
             assert "update-encoding" in lines.pop(0)
             assert "unset my_edit_headers" == lines.pop(0)
             assert "send-message" in lines.pop(0)
             assert "update-encoding" in lines.pop(0)
+            assert "first-entry" in lines.pop(0)
             assert "source 'rm -f " in lines.pop(0)
             assert "unset my_mdwn_postprocess_cmd_file" == lines.pop(0)
 
         def test_do_massage_fulltree(
             assert "source 'rm -f " in lines.pop(0)
             assert "unset my_mdwn_postprocess_cmd_file" == lines.pop(0)
 
         def test_do_massage_fulltree(
-            self, string_io, const1, basic_mime_tree, capsys
+            self, string_io, const1, mime_tree_related_to_alternative, capsys
         ):
         ):
-            def converter(drafttext, draftpath, cssfile, extensions, tempdir):
-                return basic_mime_tree
+            def converter(
+                drafttext,
+                draftpath,
+                cssfile,
+                related_to_html_only,
+                extensions,
+                tempdir,
+            ):
+                return mime_tree_related_to_alternative
 
             do_massage(
                 draft_f=string_io,
 
             do_massage(
                 draft_f=string_io,
@@ -774,26 +903,27 @@ try:
             )
 
             captured = capsys.readouterr()
             )
 
             captured = capsys.readouterr()
-            lines = captured.out.splitlines()[4:]
-            assert "send-message" in lines.pop(0)
-            assert "Related" in lines.pop(0)
-            assert "group-related" in lines.pop(0)
-            assert "tag-entry" in lines.pop(0)
-            assert "Logo" in lines.pop(0)
-            assert "content-id" in lines.pop(0)
-            assert "toggle-unlink" in lines.pop(0)
-            assert "logo.png" in lines.pop(0)
-            assert "tag-entry" in lines.pop(0)
-            assert "Alternative" in lines.pop(0)
-            assert "group-alternatives" in lines.pop(0)
-            assert "tag-entry" in lines.pop(0)
-            assert "HTML" in lines.pop(0)
-            assert "toggle-unlink" in lines.pop(0)
-            assert "part.html" in lines.pop(0)
-            assert "tag-entry" in lines.pop(0)
-            assert "Plain" in lines.pop(0)
-            assert "update-encoding" in lines.pop(0)
-            assert len(lines) == 2
+            lines = captured.out.splitlines()[4:-2]
+            assert "first-entry" in lines.pop()
+            assert "update-encoding" in lines.pop()
+            assert "Plain" in lines.pop()
+            assert "part.html" in lines.pop()
+            assert "toggle-unlink" in lines.pop()
+            assert "HTML" in lines.pop()
+            assert "jump>1" in lines.pop()
+            assert "jump>2" in lines.pop()
+            assert "group-alternatives" in lines.pop()
+            assert "Alternative" in lines.pop()
+            assert "logo.png" in lines.pop()
+            assert "toggle-unlink" in lines.pop()
+            assert "content-id" in lines.pop()
+            assert "Logo" in lines.pop()
+            assert "jump>1" in lines.pop()
+            assert "jump>4" in lines.pop()
+            assert "group-related" in lines.pop()
+            assert "Related" in lines.pop()
+            assert "send-message" in lines.pop()
+            assert len(lines) == 0
 
         @pytest.fixture
         def fake_filewriter(self):
 
         @pytest.fixture
         def fake_filewriter(self):
@@ -813,9 +943,7 @@ try:
         def markdown_non_converter(self, const1, const2):
             return lambda s, text: f"{const1}{text}{const2}"
 
         def markdown_non_converter(self, const1, const2):
             return lambda s, text: f"{const1}{text}{const2}"
 
-        def test_converter_tree_basic(
-            self, const1, const2, fake_filewriter, markdown_non_converter
-        ):
+        def test_converter_tree_basic(self, const1, const2, fake_filewriter):
             path = pathlib.Path(const2)
             tree = convert_markdown_to_html(
                 const1, path, filewriter_fn=fake_filewriter
             path = pathlib.Path(const2)
             tree = convert_markdown_to_html(
                 const1, path, filewriter_fn=fake_filewriter
@@ -934,15 +1062,53 @@ try:
             text = f"![inline base64 image]({test_png})"
             path = pathlib.Path(const1)
             tree = convert_markdown_to_html(
             text = f"![inline base64 image]({test_png})"
             path = pathlib.Path(const1)
             tree = convert_markdown_to_html(
-                text, path, filewriter_fn=fake_filewriter
+                text,
+                path,
+                filewriter_fn=fake_filewriter,
+                related_to_html_only=False,
             )
             )
-
             assert tree.subtype == "relative"
             assert tree.subtype == "relative"
+            assert tree.children[0].subtype == "alternative"
             assert tree.children[1].subtype == "png"
             written = fake_filewriter.pop()
             assert tree.children[1].path == written[0]
             assert written[1] == request.urlopen(test_png).read()
 
             assert tree.children[1].subtype == "png"
             written = fake_filewriter.pop()
             assert tree.children[1].path == written[0]
             assert written[1] == request.urlopen(test_png).read()
 
+        def test_converter_tree_inline_image_base64_related_to_html(
+            self, test_png, const1, fake_filewriter
+        ):
+            text = f"![inline base64 image]({test_png})"
+            path = pathlib.Path(const1)
+            tree = convert_markdown_to_html(
+                text,
+                path,
+                filewriter_fn=fake_filewriter,
+                related_to_html_only=True,
+            )
+            assert tree.subtype == "alternative"
+            assert tree.children[1].subtype == "relative"
+            assert tree.children[1].children[1].subtype == "png"
+            written = fake_filewriter.pop()
+            assert tree.children[1].children[1].path == written[0]
+            assert written[1] == request.urlopen(test_png).read()
+
+        def test_converter_tree_inline_image_cid(
+            self, const1, fake_filewriter
+        ):
+            text = f"![inline base64 image](cid:{const1})"
+            path = pathlib.Path(const1)
+            tree = convert_markdown_to_html(
+                text,
+                path,
+                filewriter_fn=fake_filewriter,
+                related_to_html_only=False,
+            )
+            assert len(tree.children) == 2
+            assert tree.children[0].cid != const1
+            assert tree.children[0].type != "image"
+            assert tree.children[1].cid != const1
+            assert tree.children[1].type != "image"
+
         def test_inline_image_collection(
             self, test_png, const1, const2, fake_filewriter
         ):
         def test_inline_image_collection(
             self, test_png, const1, const2, fake_filewriter
         ):
@@ -975,6 +1141,48 @@ try:
                 out = apply_styling(html, _PYGMENTS_CSS)
                 assert f'{_CODEHILITE_CLASS}" style="' in out
 
                 out = apply_styling(html, _PYGMENTS_CSS)
                 assert f'{_CODEHILITE_CLASS}" style="' in out
 
+        def test_mime_tree_relative_within_alternative(
+            self, string_io, const1, capsys, mime_tree_related_to_html
+        ):
+            def converter(
+                drafttext,
+                draftpath,
+                cssfile,
+                related_to_html_only,
+                extensions,
+                tempdir,
+            ):
+                return mime_tree_related_to_html
+
+            do_massage(
+                draft_f=string_io,
+                draftpath=const1,
+                cmd_f=sys.stdout,
+                converter=converter,
+            )
+
+            captured = capsys.readouterr()
+            lines = captured.out.splitlines()[4:-2]
+            assert "first-entry" in lines.pop()
+            assert "update-encoding" in lines.pop()
+            assert "Plain" in lines.pop()
+            assert "part.html" in lines.pop()
+            assert "toggle-unlink" in lines.pop()
+            assert "HTML" in lines.pop()
+            assert "logo.png" in lines.pop()
+            assert "toggle-unlink" in lines.pop()
+            assert "content-id" in lines.pop()
+            assert "Logo" in lines.pop()
+            assert "jump>2" in lines.pop()
+            assert "jump>3" in lines.pop()
+            assert "group-related" in lines.pop()
+            assert "Related" in lines.pop()
+            assert "jump>1" in lines.pop()
+            assert "jump>2" in lines.pop()
+            assert "group-alternative" in lines.pop()
+            assert "Alternative" in lines.pop()
+            assert "send-message" in lines.pop()
+            assert len(lines) == 0
 
 except ImportError:
     pass
 
 except ImportError:
     pass