playing with data types and email previewing

juleswg23 · juleswg23 · commit 0474c95f15e6 · 2025-10-10T16:04:04.000-04:00
diff --git a/send-quarto-emails/main.py b/send-quarto-emails/main.py
@@ -1,17 +1,105 @@
-from methods import send_quarto_email_with_gmail
+from methods import send_quarto_email_with_gmail, write_email_message_to_file, _read_quarto_email_json
 import os
 from dotenv import load_dotenv
 
+from great_tables import GT
+import os
+from plotnine import ggplot, aes, geom_point, labs
+import pandas as pd
+import base64
+from io import BytesIO
+
 os.chdir(os.path.dirname(os.path.abspath(__file__)))
 
 load_dotenv()
 
+password = os.environ["POSIT_APP_PASSWORD"]
+username = os.environ["POSIT_ADDRESS"]
+
+# send_quarto_email_with_gmail(
+#     username=username,
+#     password=password,
+#     json_path=".output_metadata.json",
+#     recipients=[username, "jules.walzergoldfeld@gmail.com"]
+# )
+
+
+
+
+# Simple text
+body_text = "<p>Hello, this is a test email with text, a plot, an image, and a table.</p>"
+
+# Simple plot with plotnine
+df = pd.DataFrame({'x': [1, 2, 3], 'y': [3, 2, 1]})
+p = ggplot(df, aes('x', 'y')) + geom_point() + labs(title="A Simple Plot")
+
+buf = BytesIO()
+p.save(buf, format='png')
+buf.seek(0)
+plot_bytes = buf.read()
+
+plot_html = '<img src="cid:plot-image" alt="plotnine plot"/><br>'
+
+# Simple image (embed as base64)
+image_path = "../examples/newspapers.jpg"
+
+
+with open(image_path, "rb") as img_file:
+    image_bytes = img_file.read()
+
+image_html = '<img src="cid:photo-image" alt="placeholder image"/><br>'
+
+image_html
+
+# Simple table with GT
+table_df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
+gt = GT(table_df)
+table_html = gt.as_raw_html()
+
+result_head = """
+<meta charset="utf-8">
+<title>Email Preview</title>
+"""
+
+# Wrap the email body in the HTML structure
+
+# Modified for redmail, but there are certainly other ways to do this without the ugly jinja syntax in python
+email_body = f"""<!doctype html>
+<html>
+  <head>
+{result_head}
+  </head>
+  <body>
+{body_text} {{{{ plot_image }}}}  {{{{ photo_image }}}} {table_html}
+  </body>
+</html>"""
+
+from dotenv import load_dotenv
+load_dotenv()
+
+from redmail import gmail
+
 password = os.environ["GMAIL_APP_PASSWORD"]
-username = os.environ["GMAIL_ADDRESS"]
+username = "jules.walzergoldfeld@gmail.com"
 
-send_quarto_email_with_gmail(
-    username=username,
-    password=password,
-    json_path=".output_metadata.json",
-    recipients=[username, "jules.walzergoldfeld@posit.co"]
+gmail.username = username
+gmail.password = password
+
+
+msg = gmail.get_message(
+    subject="An example email",
+    receivers=[username],
+    body_images={
+      'plot_image': plot_bytes,
+      'photo_image': image_path,
+    },
+    html=email_body,
 )
+
+
+write_email_message_to_file(msg)
+
+# struct = _read_quarto_email_json(".output_metadata.json")
+# struct.write_preview_email("struct_preview.html")
+
+
diff --git a/send-quarto-emails/methods.py b/send-quarto-emails/methods.py
@@ -1,8 +1,10 @@
 ## TODO: work in progress
-
+from __future__ import annotations
 from dataclasses import dataclass
 import base64
 import json
+import re
+
 
 from email.mime.multipart import MIMEMultipart
 from email.mime.text import MIMEText
@@ -15,13 +17,35 @@
 @dataclass
 class IntermediateDataStruct:
     html: str
-    attachments: dict[str, str]
     subject: str
     rsc_email_supress_report_attachment: bool
     rsc_email_supress_scheduled: bool
 
-    text: str = None  # sometimes present in quarto
-    recipients: list[str] = None  # not present in quarto
+    external_attachments: dict[str, str] | None = None
+    inline_attachments: dict[str, str] | None = None
+
+    text: str | None = None  # sometimes present in quarto
+    recipients: list[str] | None = None  # not present in quarto
+
+    def write_preview_email(self, out_file: str = "preview_email.html") -> None:
+        html_with_inline = re.sub(
+            r'src="cid:([^"\s]+)"',
+            _add_base_64_to_inline_attachments(self.inline_attachments),
+            self.html,
+        )
+
+        with open(out_file, "w", encoding="utf-8") as f:
+            f.write(html_with_inline)
+
+        if self.external_attachments:
+            raise ValueError("Preview does not yet support external attachments.")
+
+    def write_email_message(self) -> EmailMessage:
+        pass
+
+    # sends just to some preview recipient?
+    def preview_send_email():
+        pass
 
 
 # You will have to call redmail get_message, and pass that EmailMessage object to this
@@ -30,20 +54,20 @@ class IntermediateDataStruct:
 # Or make the intermediate struct hold that payload (the EmailMessage class)
 def redmail_to_intermediate_struct(msg: EmailMessage) -> IntermediateDataStruct:
     email_body = msg.get_body()
+    raise NotImplementedError
+    # TODO incomplete
     attachments = {}
     # maybe do walk
     for elem in msg.iter_attachments():
         if elem.is_attachment():
             # This can fail if there's no associated filename?
             attachments[elem.get_filename()] = elem.get_content()
 
-
     iStruct = IntermediateDataStruct(html=email_body)
 
     return iStruct
 
 
-
 def yagmail_to_intermediate_struct():
     pass
 
@@ -81,26 +105,28 @@ def _read_quarto_email_json(path: str) -> IntermediateDataStruct:
     iStruct = IntermediateDataStruct(
         html=email_html,
         text=email_text,
-        attachments=email_images,
+        inline_attachments=email_images,
         subject=email_subject,
         rsc_email_supress_report_attachment=supress_report_attachment,
         rsc_email_supress_scheduled=supress_scheduled,
     )
 
     return iStruct
 
+
 # what to return?
 # consider malformed request?
 
+
 def send_quarto_email_with_gmail(
     username: str,
     password: str,
     json_path: str,
     recipients: list[str],
 ):
-    '''
+    """
     End to end sending of quarto meta data
-    '''
+    """
     email_struct: IntermediateDataStruct = _read_quarto_email_json(json_path)
     email_struct.recipients = recipients
     send_struct_email_with_gmail(
@@ -115,9 +141,9 @@ def send_quarto_email_with_gmail(
 def send_struct_email_with_gmail(
     username: str, password: str, email_struct: IntermediateDataStruct
 ):
-    '''
+    """
     Send the email struct content via gmail with smptlib
-    '''
+    """
     # Compose the email
     msg = MIMEMultipart("related")
     msg["Subject"] = email_struct.subject
@@ -132,13 +158,22 @@ def send_struct_email_with_gmail(
     if email_struct.text:
         msg_alt.attach(MIMEText(email_struct.text, "plain"))
 
-    # Attach images
-    for image_name, image_base64 in email_struct.attachments.items():
+    # Attach inline images
+    for image_name, image_base64 in email_struct.inline_attachments.items():
+        img_bytes = base64.b64decode(image_base64)
+        img = MIMEImage(img_bytes, _subtype="png", name=f"{image_name}")
+
+        img.add_header("Content-ID", f"<{image_name}>")
+        img.add_header("Content-Disposition", "inline", filename=f"{image_name}")
+
+        msg.attach(img)
+
+    for image_name, image_base64 in email_struct.external_attachments.items():
         img_bytes = base64.b64decode(image_base64)
         img = MIMEImage(img_bytes, _subtype="png", name=f"{image_name}")
 
-        img.add_header('Content-ID', f'<{image_name}>')
-        img.add_header("Content-Disposition", "inline", filename=f"{image_name}") 
+        img.add_header("Content-ID", f"<{image_name}>")
+        img.add_header("Content-Disposition", "attachment", filename=f"{image_name}")
 
         msg.attach(img)
 
@@ -148,11 +183,81 @@ def send_struct_email_with_gmail(
 
 
 def send_struct_email_with_redmail(email_struct: IntermediateDataStruct):
-    
     pass
 
+
 def send_struct_email_with_yagmail(email_struct: IntermediateDataStruct):
     pass
 
+
 def send_struct_email_with_mailgun(email_struct: IntermediateDataStruct):
-    pass
+    pass
+
+
+def send_struct_email_with_smtp(email_struct: IntermediateDataStruct):
+    pass
+
+
+def write_email_message_to_file(
+    msg: EmailMessage, out_file: str = "preview_email.html"
+):
+    """
+    Writes the HTML content of an email message to a file, inlining any images referenced by Content-ID (cid).
+
+    This function extracts all attachments referenced by Content-ID from the given EmailMessage,
+    replaces any `src="cid:..."` references in the HTML body with base64-encoded image data,
+    and writes the resulting HTML to the specified output file.
+
+    Params:
+        msg (EmailMessage): The email message object containing the HTML body and attachments.
+        out_file (str, optional): The path to the output HTML file. Defaults to "preview_email.html".
+
+    Returns:
+        None
+    """
+    inline_attachments = {}
+
+    for part in msg.walk():
+        content_id = part.get("Content-ID")
+        if content_id:
+            cid = content_id.strip("<>")
+
+            payload = part.get_payload(decode=True)
+            inline_attachments[cid] = payload
+
+    html = msg.get_body(preferencelist=("html")).get_content()
+
+    # Replace each cid reference with base64 data
+    html_inline = re.sub(
+        r'src="cid:([^"]+)"',
+        _add_base_64_to_inline_attachments(inline_attachments),
+        html,
+    )
+
+    # Write to file
+    with open(out_file, "w", encoding="utf-8") as f:
+        f.write(html_inline)
+
+
+# TODO: make sure this is not losing other attributes of the inline attachments
+def _add_base_64_to_inline_attachments(inline_attachments: dict[str, str]):
+    # Replace all src="cid:..." in the HTML
+    def replace_cid(match):
+        cid = match.group(1)
+        img_data = inline_attachments.get(cid)
+        if img_data:
+            # TODO: this is kinda hacky
+            # If it's a string, decode from base64 to bytes first
+            if isinstance(img_data, str):
+                try:
+                    img_bytes = base64.b64decode(img_data)
+                except Exception:
+                    # If not base64, treat as raw bytes
+                    img_bytes = img_data.encode("utf-8")
+            else:
+                img_bytes = img_data
+            b64 = base64.b64encode(img_bytes).decode("utf-8")
+            return f'src="data:image;base64,{b64}"'
+        return match.group(0)
+
+    return replace_cid
