markitdown-pro 1.2.2__tar.gz → 1.3.0__tar.gz

{markitdown_pro-1.2.2 → markitdown_pro-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: markitdown-pro
-Version: 1.2.2
+Version: 1.3.0
 Summary: A package that converts almost any file format to Markdown.
 Author: Developer
 Classifier: Programming Language :: Python :: 3

{markitdown_pro-1.2.2 → markitdown_pro-1.3.0}/markitdown_pro/conversion_pipeline.py

@@ -38,7 +38,7 @@ from typing import Optional
 import httpx
 
 from .common.logger import logger
-from .common.utils import detect_extension, ensure_minimum_content
+from .common.utils import clean_markdown, detect_extension, ensure_minimum_content
 from .handlers.audio_handler import AudioHandler
 from .handlers.base_handler import BaseHandler
 from .handlers.email_handler import EmailHandler
@@ -91,9 +91,10 @@ class ConversionPipeline:
 
         # Map extensions to handlers (normalized lowercase with dot)
         self.handlers_mapping: dict[str, BaseHandler] = {
-            # PDFs
+            # region PDFs
             ".pdf": self.pdf_handler,
-            # Audio
+            # endregion
+            # region Audio
             ".mp3": self.audio_handler,
             ".wav": self.audio_handler,
             # ".ogg": self.audio_handler,
@@ -103,36 +104,40 @@ class ConversionPipeline:
             # ".wma": self.audio_handler,
             # ".webm": self.audio_handler,
             # ".opus": self.audio_handler,
-            # Images
+            # endregion
+            # region Images
             ".bmp": self.image_handler,
             ".gif": self.image_handler,
             ".heic": self.image_handler,
             ".jpeg": self.image_handler,
             ".jpg": self.image_handler,
             ".png": self.image_handler,
-            ".prn": self.image_handler,
+            # ".prn": self.image_handler,
             ".svg": self.image_handler,
             ".tiff": self.image_handler,
             ".webp": self.image_handler,
             ".heif": self.image_handler,
-            # Plain/code text
+            # endregion
+            # region Plain/code text
             ".txt": self.text_handler,
             ".md": self.text_handler,
             ".py": self.text_handler,
             ".go": self.text_handler,
-            # Tabular (via MarkItDown)
+            # endregion
+            # region Tabular (via MarkItDown)
             ".csv": self.tabular_handler,
             ".tsv": self.tabular_handler,
-            # Office/Spreadsheet/Slides
+            # endregion
+            # region Office/Spreadsheet/Slides
             ".xls": self.office_handler,
             ".xlsx": self.office_handler,
-            ".doc": self.office_handler,
             ".docx": self.office_handler,
-            ".odt": self.office_handler,
-            ".rtf": self.office_handler,
-            ".ppt": self.office_handler,
+            # ".odt": self.office_handler,
+            # ".rtf": self.office_handler,
+            # ".ppt": self.office_handler,
             ".pptx": self.office_handler,
-            # Markup/serialization
+            # endregion
+            # region Markup/serialization
             ".html": self.markup_handler,
             ".htm": self.markup_handler,
             ".xml": self.markup_handler,
@@ -140,13 +145,15 @@ class ConversionPipeline:
             ".ndjson": self.markup_handler,
             ".yaml": self.markup_handler,
             ".yml": self.markup_handler,
-            # Others
+            # endregion
+            # region Others
             ".epub": self.epub_handler,
             ".eml": self.email_handler,
             ".p7s": self.email_handler,
             ".msg": self.email_handler,
             ".pst": self.pst_handler,
             ".ipynb": self.ipynb_handler,
+            # endregion
         }
 
     # ---------------------------------------------------------------------
@@ -190,6 +197,7 @@ class ConversionPipeline:
             if not md_content or not ensure_minimum_content(md_content):
                 return None
 
+            md_content = clean_markdown(md_content)
             logger.debug(
                 f"convert_document_to_md: {file_path} returned {len(md_content)} characters"
             )

{markitdown_pro-1.2.2 → markitdown_pro-1.3.0}/markitdown_pro/converters/azure_speech_wrapper.py

@@ -5,6 +5,8 @@ from .base import ConverterWrapper
 
 
 class AzureSpeechWrapper(ConverterWrapper):
+    SUPPORTED_EXTENSIONS = AzureSpeechService.SUPPORTED_EXTENSIONS
+
     def __init__(self):
         super().__init__("Azure Speech Service")
         self.converter = AzureSpeechService()

{markitdown_pro-1.2.2 → markitdown_pro-1.3.0}/markitdown_pro/converters/base.py

@@ -4,7 +4,7 @@ from ..common.logger import logger
 
 
 class ConverterWrapper:
-    SUPPORTED_FORMATS = ()
+    SUPPORTED_EXTENSIONS = ()
 
     def __init__(self, name: str):
         self.name = name

{markitdown_pro-1.2.2 → markitdown_pro-1.3.0}/markitdown_pro/converters/gpt_vision_wrapper.py

@@ -44,6 +44,20 @@ class GPTVisionWrapper(ConverterWrapper):
       add that logic in `convert()` (see inline TODO in that method).
     """
 
+    SUPPORTED_EXTENSIONS = frozenset(
+        {
+            ".bmp",
+            ".gif",
+            ".jpeg",
+            ".jpg",
+            ".png",
+            ".tiff",
+            ".webp",
+            ".heic",
+            ".heif",
+        }
+    )
+
     def __init__(
         self,
         model_name: str = "gpt-4.1-mini",
@@ -82,3 +96,6 @@ class GPTVisionWrapper(ConverterWrapper):
             return await self.gpt_vision.process_scanned_pdf_concurrent(file_path)
         # Otherwise, assume it's an image and run single-image OCR/analysis.
         return await self.gpt_vision.process_image(file_path)
+
+    async def aclose(self) -> None:
+        await self.gpt_vision.aclose()

markitdown_pro-1.3.0/markitdown_pro/converters/markitdown_wrapper.py

@@ -0,0 +1,23 @@
+from typing import Optional
+
+from markitdown_pro.handlers.markitdown_handler import MarkItDownHandler
+
+from ..common.logger import logger
+from .base import ConverterWrapper
+
+
+class MarkItDownWrapper(ConverterWrapper):
+    SUPPORTED_EXTENSIONS = MarkItDownHandler.SUPPORTED_EXTENSIONS
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.handler = MarkItDownHandler(*args, **kwargs)
+
+    async def convert(self, file_path: str) -> Optional[str]:
+        file_extension = file_path.split(".")[-1].lower()
+        if file_extension not in self.SUPPORTED_EXTENSIONS:
+            logger.warning(f"MarkItDownWrapper: Unsupported file format: {file_extension}")
+            return None
+
+        md_content = await self.handler.handle(file_path)
+        return md_content

{markitdown_pro-1.2.2 → markitdown_pro-1.3.0}/markitdown_pro/converters/pymupdf_wrapper.py

@@ -1,25 +1,25 @@
-import logging
 from typing import Optional
 
 import fitz  # PyMuPDF
 
 from ..common.logger import logger
-from ..common.utils import clean_markdown, ensure_minimum_content
 from .base import ConverterWrapper
 
 
 class PyMuPDFWrapper(ConverterWrapper):
-    SUPPORTED_FORMATS = ["pdf", "xps", "epub", "mobi", "fb2", "cbz", "svg"]
+    SUPPORTED_EXTENSIONS = frozenset({"pdf", "xps", "epub", "mobi", "fb2", "cbz", "svg"})
 
     def __init__(self):
         super().__init__("PyMuPDF")
 
     async def convert(self, file_path: str) -> Optional[str]:
         file_extension = file_path.split(".")[-1].lower()
-        logging.info(f"Processing PyMuPDF file: {file_path} with extension: {file_extension}")
+        logger.info(
+            f"PyMuPDFWrapper: Processing file: {file_path} with extension: {file_extension}"
+        )
 
-        if file_extension not in self.SUPPORTED_FORMATS:
-            logger.warning(f"Unsupported file format: {file_extension}")
+        if file_extension not in self.SUPPORTED_EXTENSIONS:
+            logger.warning(f"PyMuPDFWrapper: Unsupported file format: {file_extension}")
             return None
 
         try:
@@ -33,10 +33,8 @@ class PyMuPDFWrapper(ConverterWrapper):
                 text_content += "\n\n"
 
             doc.close()
-
-            text_md = clean_markdown(text_content)
-            return text_md if ensure_minimum_content(text_md) else None
+            return text_content
 
         except Exception as e:
-            logger.error(f"Error processing document with PyMuPDF: {e}")
+            logger.error(f"PyMuPDFWrapper: Error processing document with PyMuPDF: {e}")
             return None

{markitdown_pro-1.2.2 → markitdown_pro-1.3.0}/markitdown_pro/converters/tabular_wrapper.py

@@ -1,7 +1,6 @@
 from typing import Optional
 
 from ..common.logger import logger
-from ..common.utils import clean_markdown
 from ..handlers.tabular_handler import TabularHandler
 from .base import ConverterWrapper
 
@@ -27,5 +26,4 @@ class TabularWrapper(ConverterWrapper):
             return None
 
         markdown = await self.tabular_handler.handle(file_path)
-        markdown = clean_markdown(markdown) if markdown else None
         return markdown

{markitdown_pro-1.2.2 → markitdown_pro-1.3.0}/markitdown_pro/converters/unstructured_wrapper.py

@@ -3,7 +3,6 @@ from typing import Optional
 from unstructured.partition.auto import partition
 
 from ..common.logger import logger
-from ..common.utils import clean_markdown, ensure_minimum_content
 from .base import ConverterWrapper
 
 
@@ -58,5 +57,5 @@ class UnstructuredWrapper(ConverterWrapper):
 
         # Directly call partition.  No asyncio.to_thread
         elements = partition(filename=file_path, extract_images_in_pdf=True)
-        combined = clean_markdown("\n\n".join(str(el) for el in elements))
-        return combined if ensure_minimum_content(combined) else None
+        combined = "\n\n".join(str(el) for el in elements)
+        return combined

{markitdown_pro-1.2.2 → markitdown_pro-1.3.0}/markitdown_pro/handlers/audio_handler.py

@@ -3,7 +3,6 @@ from __future__ import annotations
 from typing import Optional
 
 from ..common.logger import logger
-from ..common.utils import ensure_minimum_content
 from ..converters.azure_speech_wrapper import AzureSpeechWrapper
 from ..converters.base import ConverterWrapper
 from ..converters.markitdown_wrapper import MarkItDownWrapper
@@ -27,7 +26,7 @@ class AudioHandler(BaseHandler):
     - This handler runs converters **sequentially** to avoid unnecessary API calls.
     """
 
-    extensions = frozenset(
+    SUPPORTED_EXTENSIONS = frozenset(
         {
             ".mp3",
             ".wav",
@@ -72,10 +71,7 @@ class AudioHandler(BaseHandler):
             logger.info(f"AudioHandler: Trying {name} for '{file_path}'")
             try:
                 md = await converter.convert(file_path)
-                if md and ensure_minimum_content(md):
-                    logger.info(f"AudioHandler: {name} succeeded for '{file_path}'")
-                    return md
-                logger.debug(f"AudioHandler: {name} returned insufficient content")
+                return md
             except Exception as e:
                 logger.error(f"AudioHandler: {name} failed for '{file_path}': {e}")
 

{markitdown_pro-1.2.2 → markitdown_pro-1.3.0}/markitdown_pro/handlers/base_handler.py

@@ -3,7 +3,7 @@ from typing import Optional
 
 
 class BaseHandler:
-    extensions: frozenset = frozenset()
+    SUPPORTED_EXTENSIONS: frozenset = frozenset()
     pipeline: Optional[list] = None
 
     def __init__(self, *args, **kwargs):
@@ -11,7 +11,7 @@ class BaseHandler:
 
     @classmethod
     async def is_valid(cls, file_path: str) -> bool:
-        return Path(file_path).is_file() and Path(file_path).suffix in cls.extensions
+        return Path(file_path).is_file() and Path(file_path).suffix in cls.SUPPORTED_EXTENSIONS
 
     async def handle(self, file_path, *args, **kwargs) -> Optional[str]:
         raise NotImplementedError("You must implement the handle method")

markitdown_pro-1.3.0/markitdown_pro/handlers/email_handler.py

@@ -0,0 +1,301 @@
+import asyncio
+import html
+import io
+import os
+import re
+import tempfile
+import uuid
+from email.header import decode_header, make_header
+from email.message import Message
+from email.parser import BytesParser
+from email.policy import default
+from typing import Any, Callable, Dict, List, Optional
+
+from ..common.logger import logger
+from .base_handler import BaseHandler
+
+_MAX_ATTACHMENT_BYTES = 50 * 1024 * 1024  # 50MB safety cap
+_READ_CHUNK = 1024 * 1024  # 1MB
+_PARSE_TIMEOUT_SEC = 30
+_CONVERT_TIMEOUT_SEC = 60
+
+
+def _safe_decode_header(value: Optional[str]) -> str:
+    try:
+        if not value:
+            return ""
+        return str(make_header(decode_header(value)))
+    except Exception:
+        return value or ""
+
+
+def _coerce_charset(s: bytes, charset: Optional[str]) -> str:
+    for cs in [charset, "utf-8", "latin-1"]:
+        if not cs:
+            continue
+        try:
+            return s.decode(cs, errors="replace")
+        except Exception:
+            continue
+    return s.decode("utf-8", errors="replace")
+
+
+def _basic_html_to_md(html_text: str) -> str:
+    # Minimal, dependency-free HTML → Markdown-ish conversion that preserves readability
+    txt = html_text
+    txt = re.sub(r"(?is)<(script|style).*?>.*?</\1>", "", txt)
+    txt = re.sub(r"(?i)<br\s*/?>", "\n", txt)
+    txt = re.sub(r"(?i)</p\s*>", "\n\n", txt)
+    txt = re.sub(r"(?i)<li\s*>", "- ", txt)
+    txt = re.sub(r"(?i)</h1\s*>", "\n\n", re.sub(r"(?i)<h1\s*>(.*?)</h1\s*>", r"# \1\n\n", txt))
+    txt = re.sub(r"(?i)</h2\s*>", "\n\n", re.sub(r"(?i)<h2\s*>(.*?)</h2\s*>", r"## \1\n\n", txt))
+    txt = re.sub(r"(?i)</h3\s*>", "\n\n", re.sub(r"(?i)<h3\s*>(.*?)</h3\s*>", r"### \1\n\n", txt))
+    txt = re.sub(r"(?i)<a\s+[^>]*href=['\"]([^'\"]+)['\"][^>]*>(.*?)</a>", r"[\2](\1)", txt)
+    txt = re.sub(
+        r"(?i)<img\s+[^>]*alt=['\"]([^'\"]*)['\"][^>]*src=['\"]([^'\"]+)['\"][^>]*>",
+        r"![\1](\2)",
+        txt,
+    )
+    txt = re.sub(r"(?is)<[^>]+>", "", txt)
+    txt = html.unescape(txt)
+    # Normalize whitespace
+    txt = re.sub(r"[ \t]+\n", "\n", txt)
+    txt = re.sub(r"\n{3,}", "\n\n", txt).strip()
+    return txt
+
+
+class EmailHandler(BaseHandler):
+    SUPPORTED_EXTENSIONS = frozenset({".eml", ".p7s", ".msg"})
+
+    async def handle(self, file_path: str, *args, **kwargs) -> Optional[str]:
+        logger.info(f"EmailHandler: Processing email file: {file_path}")
+        attachment_converter: Optional[Callable[[str, str], "asyncio.Future[str]"]] = kwargs.get(
+            "attachment_converter"
+        )
+        try:
+            email_data = await asyncio.wait_for(
+                asyncio.to_thread(self._parse_email, file_path), timeout=_PARSE_TIMEOUT_SEC
+            )
+            if not email_data:
+                return None
+            markdown_content = await self._build_markdown(email_data, attachment_converter)
+            return markdown_content
+        except asyncio.TimeoutError:
+            logger.error(f"EmailHandler: Timeout while processing email file: {file_path}")
+            return None
+        except Exception as e:
+            logger.exception(f"EmailHandler: Error processing email file: {file_path}: {e}")
+            return None
+
+    def _parse_email(self, file_path: str) -> Dict[str, Any]:
+        """
+        Parses the EML/P7S file and extracts relevant information.
+        Returns:
+            {
+                "subject": str,
+                "from": str,
+                "to": str,
+                "cc": str,
+                "bcc": str,
+                "date": str,
+                "body_text": str,   # text/plain best-effort
+                "body_html": str,   # raw HTML if present
+                "attachments": List[Dict[str, str]]  # [{"filename":..., "path":..., "content_type":..., "cid":...}]
+            }
+        """
+        try:
+            with open(file_path, "rb") as f:
+                msg: Message = BytesParser(policy=default).parse(f)
+            subject = _safe_decode_header(msg.get("Subject", "(No Subject)")) or "(No Subject)"
+            from_ = _safe_decode_header(msg.get("From", "(Unknown Sender)")) or "(Unknown Sender)"
+            to_ = _safe_decode_header(msg.get("To", "")) or ""
+            cc_ = _safe_decode_header(msg.get("Cc", "")) or ""
+            bcc_ = _safe_decode_header(msg.get("Bcc", "")) or ""
+            date_ = msg.get("Date", "(Unknown Date)") or "(Unknown Date)"
+            body_text = ""
+            body_html = ""
+            attachments: List[Dict[str, str]] = []
+
+            def _should_skip(part: Message) -> bool:
+                ctype = (part.get_content_type() or "").lower()
+                # Skip S/MIME signatures and pkcs7 blobs as attachments
+                if ctype in ("application/pkcs7-signature", "application/pkcs7-mime"):
+                    return True
+                return False
+
+            if msg.is_multipart():
+                for part in msg.walk():
+                    if part.is_multipart():
+                        continue
+                    if _should_skip(part):
+                        continue
+                    disp = part.get_content_disposition() or ""
+                    ctype = (part.get_content_type() or "").lower()
+                    cid = (part.get("Content-ID") or "").strip().strip("<>")
+                    payload = part.get_payload(decode=True) or b""
+                    if disp == "attachment" or (
+                        disp == "inline" and cid
+                    ):  # treat inline with CID as attachment (e.g., images)
+                        filename = part.get_filename()
+                        filename = (
+                            _safe_decode_header(filename)
+                            if filename
+                            else f"attachment-{uuid.uuid4().hex}"
+                        )
+                        # Write safely with size cap
+                        suffix = os.path.splitext(filename)[1][:10] if filename else ""
+                        with tempfile.NamedTemporaryFile(delete=False, suffix=suffix) as tmp_file:
+                            written = 0
+                            stream = io.BytesIO(payload)
+                            while True:
+                                chunk = stream.read(_READ_CHUNK)
+                                if not chunk:
+                                    break
+                                written += len(chunk)
+                                if written > _MAX_ATTACHMENT_BYTES:
+                                    raise ValueError(
+                                        f"Attachment '{filename}' exceeds {_MAX_ATTACHMENT_BYTES} bytes"
+                                    )
+                                tmp_file.write(chunk)
+                            attachments.append(
+                                {
+                                    "filename": filename,
+                                    "path": tmp_file.name,
+                                    "content_type": ctype,
+                                    "cid": cid,
+                                }
+                            )
+                        continue
+                    if ctype == "text/plain" and not body_text:
+                        body_text = _coerce_charset(payload, part.get_content_charset() or "utf-8")
+                    elif ctype == "text/html" and not body_html:
+                        body_html = _coerce_charset(payload, part.get_content_charset() or "utf-8")
+            else:
+                ctype = (msg.get_content_type() or "").lower()
+                if ctype == "text/plain":
+                    body_text = _coerce_charset(
+                        msg.get_payload(decode=True) or b"", msg.get_content_charset() or "utf-8"
+                    )
+                elif ctype == "text/html":
+                    body_html = _coerce_charset(
+                        msg.get_payload(decode=True) or b"", msg.get_content_charset() or "utf-8"
+                    )
+            return {
+                "subject": subject,
+                "from": from_,
+                "to": to_,
+                "cc": cc_,
+                "bcc": bcc_,
+                "date": date_,
+                "body_text": body_text.strip(),
+                "body_html": body_html.strip(),
+                "attachments": attachments,
+            }
+        except Exception as e:
+            logger.exception(f"EmailHandler: Error parsing email {file_path}: {e}")
+            return {}
+
+    async def _build_markdown(
+        self,
+        email_data: Dict[str, Any],
+        attachment_converter: Optional[Callable[[str, str], "asyncio.Future[str]"]] = None,
+    ) -> str:
+        # Resolve inline CID references in HTML to temp file paths (if any)
+        cid_map = {a["cid"]: a for a in email_data.get("attachments", []) if a.get("cid")}
+        body_md = ""
+        if email_data.get("body_text"):
+            body_md = email_data["body_text"]
+        elif email_data.get("body_html"):
+            html_body = email_data["body_html"]
+            if cid_map:
+                for cid, meta in cid_map.items():
+                    html_body = re.sub(
+                        rf"(?i)src=['\"]cid:{re.escape(cid)}['\"]",
+                        f"src=\"{meta['path']}\"",
+                        html_body,
+                    )
+            body_md = _basic_html_to_md(html_body)
+        header_lines = [
+            f"# Email: {email_data.get('subject', '(No Subject)')}",
+            f"**From:** {email_data.get('from', '')}",
+            f"**To:** {email_data.get('to', '')}",
+        ]
+        if email_data.get("cc"):
+            header_lines.append(f"**Cc:** {email_data['cc']}")
+        if email_data.get("bcc"):
+            header_lines.append(f"**Bcc:** {email_data['bcc']}")
+        header_lines.append(f"**Date:** {email_data.get('date', '')}")
+        markdown_parts: List[str] = ["\n".join(header_lines), ""]
+        if body_md:
+            markdown_parts.append("```")
+            markdown_parts.append(body_md)
+            markdown_parts.append("```")
+        # Convert attachments (non-CID inline images will also appear here)
+        attachments = email_data.get("attachments", [])
+        for att in attachments:
+            filename = att.get("filename", "attachment")
+            path = att.get("path")
+            ctype = att.get("content_type", "")
+            if att.get("cid"):  # Already linked in body if referenced; still list it
+                markdown_parts.append(f"\n## Inline asset: {filename} ({ctype})\n")
+                markdown_parts.append(
+                    f"![{filename}]({path})"
+                    if ctype.startswith("image/")
+                    else f"[{filename}]({path})"
+                )
+                continue
+            markdown_parts.append(f"\n## Attachment: {filename} ({ctype})\n")
+            try:
+                if attachment_converter:
+                    converted = await asyncio.wait_for(
+                        attachment_converter(path, ctype), timeout=_CONVERT_TIMEOUT_SEC
+                    )
+                    markdown_parts.append(converted if converted else f"[Saved attachment]({path})")
+                else:
+                    # Built-in light handling when no converter provided
+                    if ctype.startswith("image/"):
+                        markdown_parts.append(f"![{filename}]({path})")
+                    elif ctype.startswith("text/"):
+                        try:
+                            with open(path, "rb") as f:
+                                content = f.read(_MAX_ATTACHMENT_BYTES + 1)
+                            if len(content) > _MAX_ATTACHMENT_BYTES:
+                                raise ValueError(
+                                    f"Attachment too large to inline (> {_MAX_ATTACHMENT_BYTES} bytes)"
+                                )
+                            text = _coerce_charset(content, "utf-8")
+                            markdown_parts.append("\n```")
+                            markdown_parts.append(text.strip())
+                            markdown_parts.append("```")
+                        except Exception as e:
+                            logger.warning(
+                                f"EmailHandler: Inline text fallback failed for {filename}: {e}"
+                            )
+                            markdown_parts.append(f"[Saved attachment]({path})")
+                    elif ctype == "text/html":
+                        try:
+                            with open(path, "rb") as f:
+                                content = f.read(min(_MAX_ATTACHMENT_BYTES, 5 * 1024 * 1024))
+                            text = _coerce_charset(content, "utf-8")
+                            markdown_parts.append(_basic_html_to_md(text))
+                        except Exception as e:
+                            logger.warning(
+                                f"EmailHandler: HTML to MD fallback failed for {filename}: {e}"
+                            )
+                            markdown_parts.append(f"[Saved attachment]({path})")
+                    else:
+                        markdown_parts.append(f"[Saved attachment]({path})")
+            except asyncio.TimeoutError:
+                logger.error(f"EmailHandler: Timeout converting attachment '{filename}'")
+                markdown_parts.append(f"[Attachment conversion timed out: {filename}]")
+            except Exception as e:
+                logger.error(f"EmailHandler: Error converting attachment '{filename}': {e}")
+                markdown_parts.append(f"[Error converting attachment: {e}]")
+            finally:
+                try:
+                    os.remove(path)
+                except OSError as e:
+                    logger.warning(
+                        f"EmailHandler: Could not remove temporary attachment file '{path}': {e}"
+                    )
+        return "\n".join(markdown_parts)