Possible send_email enhancement

[OldDogNewTricks000]

I just noticed that in 0.9.4 you released a send_email function. I recently wrote my own, I figured I would share here in the case you want to expand on the functionality of your existing wrapper function. It would add the following options:

• BCC
• Email priority
• Follow-up flag
• Ability to add attachments to the email

import json
from typing import Optional, Tuple, Any, List, Union, Dict
import base64
import mimetypes

def get_file_for_attach(abfss_path: str) -> dict:
    """
    Given a file at an abfss_path, open the file and read into a either a base64 encoded string or non-encoded string for attaching to email via MS Graph api.

    Parameters:         abfss_path          = String of abfss filepath for a file

    Returns:            Dictionary 

    Example useage:     get_file_for_attach('abfss://[email protected]/lh_bronze_100.Lakehouse/Files/excel_output.xlsx')
    """
    # infer MIME type
    mime_type, _ = mimetypes.guess_type(abfss_path)
    #print(f"File: {abfss_path.split('/')[-1]} is of type {mime_type}")

    # read binary content, select content
    binary_content = spark.read.format("binaryFile").load(abfss_path).select("content").collect()[0][0]

    # If it's a text file, decode it first before base64 encoding
    if mime_type and mime_type.startswith("text"):
        try:
            text_content = binary_content.decode("utf-8")  # Convert to string
        except UnicodeDecodeError:
            text_content = binary_content.decode("latin-1")  # Fallback to Latin-1
        encoded_content = base64.b64encode(text_content.encode("utf-8")).decode()  # Re-encode properly
    else:
        # Encode binary files directly
        encoded_content = base64.b64encode(binary_content).decode()
    
    return {
        "contentBytes": encoded_content,
        "mime_type": mime_type or "application/octet-stream",  # Default to binary if unknown
        "name": abfss_path.split("/")[-1]  # Extract filename from path
    }

def send_email(
    access_token: str
    ,recipients: Any
    ,subject: str
    ,body: str
    ,sender: str = "[email protected]"
    ,attach_abfss_paths: Optional[Any] = None
    ,cc_recipients: Optional[Any] = None
    ,bcc_recipients: Optional[Any] = None
    ,priority: str = "normal"                   # Options: "normal", "high", "low"
    ,follow_up_flag: Optional[bool] = False
    ) -> str:
    """
    Send an email via MS Graph API with optional CC, BCC, priority, and follow-up flags.

    Parameters:
        access_token        = String value access token (gained from get_ms_api_token)
        sender              = String value of sender, default: [email protected]
        recipients          = String or list of recipients
        subject             = Subject of email
        body                = Body of email (supports escape sequences like \n)
        attach_abfss_paths  = (Optional) String or list of attachment paths
        cc_recipients       = (Optional) String or list of CC recipients
        bcc_recipients      = (Optional) String or list of BCC recipients
        priority            = (Optional) "normal" (default), "high", or "low"
        follow_up_flag      = (Optional) True or False (default)

    Returns:
        str: Message indicating success or failure.

    Example usage:
        msg = send_email(
            access_token = get_ms_api_token('MS graph')
            ,recipients = ['[email protected]','[email protected]']
            ,attach_abfss_paths = [
                "abfss://really_long_path/text_file.txt"
                ,"abfss://really_long_path/excel_file.xlsx"
                ]
            ,subject = 'Email subject'
            ,body = f"This is a test email sent form Microsoft Fabric.\n\n\tLine 2 here"
            ,priority = 'high'
            ,follow_up_flag = True
            )
    """

    def process_recipients(recipient_input: Any) -> List[dict]:
        """Helper function to convert string or list into recipient format."""
        if not recipient_input:
            return []
        if isinstance(recipient_input, str):
            recipient_input = [recipient_input]
        return [{"emailAddress": {"address": email}} for email in recipient_input]

    to_recipients = process_recipients(recipients)
    
    # Process optional CC & BCC
    cc_recipients_list = process_recipients(cc_recipients)
    bcc_recipients_list = process_recipients(bcc_recipients)

    # Process attachments
    lst_attachments = []
    if attach_abfss_paths:
        if isinstance(attach_abfss_paths, str):
            attach_abfss_paths = [attach_abfss_paths]
        for attach_path in attach_abfss_paths:
            attachment_content = get_file_for_attach(attach_path)
            lst_attachments.append(
                {
                    "@odata.type": "#microsoft.graph.fileAttachment",
                    "name": attach_path.split("/")[-1],
                    "contentBytes": attachment_content["contentBytes"],
                }
            )

    # Email payload
    email_payload = {
        "message": {
            "subject": subject,
            "body": {
                "contentType": "Text",
                "content": body,
            },
            "toRecipients": to_recipients,
            "importance": priority.lower(),  # "normal", "high", or "low"
        }
    }

    # Only add CC/BCC if they have values
    if cc_recipients_list:
        email_payload["message"]["ccRecipients"] = cc_recipients_list
    if bcc_recipients_list:
        email_payload["message"]["bccRecipients"] = bcc_recipients_list

    # Add follow-up flag if provided
    if follow_up_flag:
        email_payload["message"]["flag"] = {"flagStatus": "flagged"}

    # Add attachments if available
    if lst_attachments:
        email_payload["message"]["attachments"] = lst_attachments

    # Define Graph API endpoint
    url = f"https://graph.microsoft.com/v1.0/users/{sender}/sendMail"

    # Send the email
    headers = {"Authorization": f"Bearer {access_token}", "Content-Type": "application/json"}
    response = requests.post(url, headers=headers, data=json.dumps(email_payload))

    # Handle response
    if response.status_code == 202:
        return "Email sent successfully."
    else:
        return f"Failed to send email: {response.status_code}, {response.text}"

[m-kovalsky]

Nice. Yeah I kept it relatively simple for now. Not sure how fancy folks want to get with this. It’s good to hear feedback like this.

[OldDogNewTricks000]

We have a use case where we intend to call a Power BI report export via api (thanks to your wrapper function!), apply report level filter, then email the resulting export to external users. That was the main reason I wrote this function, but I added other functionality because I was already in there and this way it would be a good for many use cases.

[m-kovalsky]

Yes, makes total sense. I’ll add this in, thank you!

[m-kovalsky]

Would you try this? The attachments parameter is a string or list of strings of abfss_paths of the attachments (based on items in a lakehouse in Fabric).

import pandas as pd
from uuid import UUID
import sempy_labs._icons as icons
from typing import List
from sempy_labs._helper_functions import (
    _is_valid_uuid,
    _base_api,
    _create_dataframe,
)

def send_mail(
    user: UUID | str,
    subject: str,
    to_recipients: str | List[str],
    content: str,
    content_type: str = "Text",
    cc_recipients: str | List[str] = None,
    bcc_recipients: str | List[str] = None,
    priority: str = "Normal",
    follow_up_flag: bool = False,
    attachments: str | List[str] = None,
):
    """
    Sends an email to the specified recipients.

    This is a wrapper function for the following API: `user: sendMail <https://learn.microsoft.com/graph/api/user-sendmail>`_.

    Service Principal Authentication is required (see `here <https://github.com/microsoft/semantic-link-labs/blob/main/notebooks/Service%20Principal.ipynb>`_ for examples).

    Parameters
    ----------
    user : uuid.UUID | str
        The user ID or user principal name.
    subject : str
        The email subject.
    to_recipients : str | List[str]
        The email address of the recipients.
    content : str
        The email content.
    content_type : str, default="Text"
        The email content type. Options: "Text" or "HTML".
    cc_recipients : str | List[str], default=None
        The email address of the CC recipients.
    bcc_recipients : str | List[str], default=None
        The email address of the BCC recipients.
    priority : str, default="Normal"
        The email priority. Options: "Normal", "High", or "Low".
    follow_up_flag : bool, default=False
        Whether to set a follow-up flag for the email.
    attachments : str | List[str], default=None
        The abfss path or a list of the abfss paths of the attachments to include in the email.
    """

    import base64
    from sempy_labs._helper_functions import _create_spark_session

    if content_type.lower() == "html":
        content_type = "HTML"
    else:
        content_type = "Text"

    priority = priority.capitalize()
    if priority not in ["Normal", "High", "Low"]:
        raise ValueError(
            f"Invalid priority: {priority}. Options are: Normal, High, Low."
        )

    user_id = resolve_user_id(user=user)

    if isinstance(to_recipients, str):
        to_recipients = [to_recipients]

    if isinstance(cc_recipients, str):
        cc_recipients = [cc_recipients]

    to_email_addresses = [
        {"emailAddress": {"address": email}} for email in to_recipients
    ]

    cc_email_addresses = (
        [{"emailAddress": {"address": email}} for email in cc_recipients]
        if cc_recipients
        else None
    )
    bcc_email_addresses = (
        [{"emailAddress": {"address": email}} for email in bcc_recipients]
        if bcc_recipients
        else None
    )

    payload = {
        "message": {
            "subject": subject,
            "body": {
                "contentType": content_type,
                "content": content,
            },
            "toRecipients": to_email_addresses,
            "importance": priority,
        },
    }

    if cc_email_addresses:
        payload["message"]["ccRecipients"] = cc_email_addresses

    if bcc_email_addresses:
        payload["message"]["bccRecipients"] = bcc_email_addresses

    if follow_up_flag:
        payload["message"]["flag"] = {"flagStatus": "flagged"}

    if attachments:
        if isinstance(attachments, str):
            attachments = [attachments]

        for abfss_path in attachments:
            file_name = abfss_path.split("/")[-1]
            if "attachments" not in payload["message"]:
                payload["message"]["attachments"] = []

            spark = _create_spark_session()
            spark_file = (
                spark.read.format("binaryFile")
                .load(abfss_path)
                .select("content")
                .collect()[0][0]
            )
            content_bytes = base64.b64encode(spark_file).decode(
                "utf-8"
            )  # Convert bytearray to base64 string

            payload["message"]["attachments"].append(
                {
                    "@odata.type": "#microsoft.graph.fileAttachment",
                    "name": file_name,
                    "contentBytes": content_bytes,
                }
            )

    _base_api(
        request=f"users/{user_id}/sendMail",
        client="graph",
        status_codes=202,
        payload=payload,
        method="post",
    )

    print(f"{icons.green_dot} The email has been sent to {to_recipients}.")

[OldDogNewTricks000]

I'm sorry I have not tested this yet, in reviewing the code I don't see you inspecting the file type. I had this functionality in get_file_for_attach, basically this:

    mime_type, _ = mimetypes.guess_type(abfss_path)
    #print(f"File: {abfss_path.split('/')[-1]} is of type {mime_type}")

    # read binary content, select content
    binary_content = spark.read.format("binaryFile").load(abfss_path).select("content").collect()[0][0]

    # If it's a text file, decode it first before base64 encoding
    if mime_type and mime_type.startswith("text"):
        try:
            text_content = binary_content.decode("utf-8")  # Convert to string
        except UnicodeDecodeError:
            text_content = binary_content.decode("latin-1")  # Fallback to Latin-1
        encoded_content = base64.b64encode(text_content.encode("utf-8")).decode()  # Re-encode properly
    else:
        # Encode binary files directly
        encoded_content = base64.b64encode(binary_content).decode()

When I tested my function originally I had to add this logic because if I sent an excel file, word doc, ppt, vs a text file they required separate handling. Did you test different attachment types?

[OldDogNewTricks000]

I attempted to test this over the weekend, but I ran into an error, resolve_user_id was not found. I'm not sure where it is supposed to exist, but I checked the helper library and it was not there either.

I still think that the email attachment section will need to be modified as I mentioned above; but I will test once you can help me with the resolve_user_id function issue

[m-kovalsky]

resolve_user_id is in the same _users.py file

[OldDogNewTricks000]

I see no _users.py file in src, I do not see resolve_user_id in _helper_funcions.py or _utils.py. I see a few resolve functions in sempy.fabric as well, but no resolve_user_id.

[m-kovalsky]

https://github.com/microsoft/semantic-link-labs/blob/main/src/sempy_labs/graph/_users.py

[OldDogNewTricks000]

Thank you. I didn't look in the graph area...

I updated your import to pull that function in from graph, but encountered the below error:

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[10], line 3
      1 str_test = 'Test email 1 - No attachments, single receiver'
----> 3 send_mail(
      4     user = 'id_value_removed'
      5     ,subject = str_test
      6     ,to_recipients = '[email protected]'
      7     ,content = str_test
      8     ,content_type = 'Text'
      9 )

Cell In[7], line 141, in send_mail(user, subject, to_recipients, content, content_type, cc_recipients, bcc_recipients, priority, follow_up_flag, attachments)
    129         content_bytes = base64.b64encode(spark_file).decode(
    130             "utf-8"
    131         )  # Convert bytearray to base64 string
    133         payload["message"]["attachments"].append(
    134             {
    135                 "@odata.type": "#microsoft.graph.fileAttachment",
   (...)
    138             }
    139         )
--> 141 _base_api(
    142     request=f"users/{user_id}/sendMail",
    143     client="graph",
    144     status_codes=202,
    145     payload=payload,
    146     method="post",
    147 )
    149 print(f"{icons.green_dot} The email has been sent to {to_recipients}.")

File /nfs4/pyenv-10f2c705-33e2-4d53-906a-189e7da8c851/lib/python3.11/site-packages/sempy_labs/_helper_functions.py:1647, in _base_api(request, client, method, payload, status_codes, uses_pagination, lro_return_json, lro_return_status_code)
   1645         raise NotImplementedError
   1646 else:
-> 1647     headers = _get_headers(auth.token_provider.get(), audience=client)
   1648     if client == "graph":
   1649         url = f"https://graph.microsoft.com/v1.0/{request}"

File /nfs4/pyenv-10f2c705-33e2-4d53-906a-189e7da8c851/lib/python3.11/site-packages/sempy_labs/_authentication.py:154, in _get_headers(token_provider, audience)
    144 def _get_headers(
    145     token_provider: str,
    146     audience: Literal[
    147         "pbi", "storage", "azure", "graph", "asazure", "keyvault"
    148     ] = "azure",
    149 ):
    150     """
    151     Generates headers for an API request.
    152     """
--> 154     token = token_provider(audience=audience)
    156     headers = {"Authorization": f"Bearer {token}"}
    158     if audience == "graph":

TypeError: 'NoneType' object is not callable

[OldDogNewTricks000]

@m-kovalsky I know you've been busy w/ Fabcon, sorry I missed your session, and your latest release. Just pinging you on this again. Also, I'm not sure your attachment functionality will work as expected without the code snippet I posted earlier

[m-kovalsky]

Don't worry, haven't forgotten about this :) Actually some other folks have requested it as well so I appreciate your initiative! Would you try this out? Will need to test it out for different file types.

import pandas as pd
from uuid import UUID
import sempy_labs._icons as icons
from typing import List
from sempy_labs._helper_functions import (
    _is_valid_uuid,
    _base_api,
    _create_dataframe,
    _mount,
)
import os
import base64

def send_mail(
    user: UUID | str,
    subject: str,
    to_recipients: str | List[str],
    content: str,
    content_type: str = "Text",
    cc_recipients: str | List[str] = None,
    bcc_recipients: str | List[str] = None,
    priority: str = "Normal",
    follow_up_flag: bool = False,
    attachments: str | List[str] = None,
):
    """
    Sends an email to the specified recipients.

    This is a wrapper function for the following API: `user: sendMail <https://learn.microsoft.com/graph/api/user-sendmail>`_.

    Service Principal Authentication is required (see `here <https://github.com/microsoft/semantic-link-labs/blob/main/notebooks/Service%20Principal.ipynb>`_ for examples).

    Parameters
    ----------
    user : uuid.UUID | str
        The user ID or user principal name.
    subject : str
        The email subject.
    to_recipients : str | List[str]
        The email address of the recipients.
    content : str
        The email content.
    content_type : str, default="Text"
        The email content type. Options: "Text" or "HTML".
    cc_recipients : str | List[str], default=None
        The email address of the CC recipients.
    bcc_recipients : str | List[str], default=None
        The email address of the BCC recipients.
    priority : str, default="Normal"
        The email priority. Options: "Normal", "High", or "Low".
    follow_up_flag : bool, default=False
        Whether to set a follow-up flag for the email.
    attachments : str | List[str], default=None
        The abfss path or a list of the abfss paths of the attachments to include in the email.
    """

    content_type = "HTML" if content_type.lower() == "html" else "Text"

    priority = priority.capitalize()
    if priority not in ["Normal", "High", "Low"]:
        raise ValueError(
            f"Invalid priority: {priority}. Options are: Normal, High, Low."
        )

    user_id = resolve_user_id(user=user)

    if isinstance(to_recipients, str):
        to_recipients = [to_recipients]

    if isinstance(cc_recipients, str):
        cc_recipients = [cc_recipients]

    to_email_addresses = [
        {"emailAddress": {"address": email}} for email in to_recipients
    ]

    cc_email_addresses = (
        [{"emailAddress": {"address": email}} for email in cc_recipients]
        if cc_recipients
        else None
    )
    bcc_email_addresses = (
        [{"emailAddress": {"address": email}} for email in bcc_recipients]
        if bcc_recipients
        else None
    )

    payload = {
        "message": {
            "subject": subject,
            "body": {
                "contentType": content_type,
                "content": content,
            },
            "toRecipients": to_email_addresses,
            "importance": priority,
        },
    }

    if cc_email_addresses:
        payload["message"]["ccRecipients"] = cc_email_addresses

    if bcc_email_addresses:
        payload["message"]["bccRecipients"] = bcc_email_addresses

    if follow_up_flag:
        payload["message"]["flag"] = {"flagStatus": "flagged"}

    content_types = {
        ".txt": "text/plain",
        ".pdf": "application/pdf",
        ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
        ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
        ".csv": "text/csv",
        ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
        ".jpg": "image/jpeg",
        ".jpeg": "image/jpeg",
        ".png": "image/png",
        ".gif": "image/gif",
        ".bmp": "image/bmp",
        ".zip": "application/zip",
        ".json": "application/json",
        ".xml": "application/xml",
        ".html": "text/html",
        ".bim": "application/json",
        ".pbix": "application/vnd.ms-powerbi.report",
        ".pbip": "application/vnd.ms-powerbi.report",
        ".pbit": "application/vnd.ms-powerbi.report",
    }

    def file_path_to_content_bytes(file_path):

        workspace_id = file_path.split("abfss://")[1].split("@")[0]
        lakehouse_id = file_path.split(".microsoft.com/")[1].split("/")[0]
        parts = file_path.split(".microsoft.com/")[1].split("/")[1:]
        file = os.path.join(*parts)

        local_path = _mount(lakehouse_id, workspace_id)
        full_path = os.path.join(local_path, file_path)

        with open(full_path, "rb") as file:
            file_bytes = file.read()

            return base64.b64encode(file_bytes).decode("utf-8")

    if isinstance(attachments, str):
        attachments = [attachments]
    if attachments:
        lst_attachments = []
        for attach_path in attachments:
            content_bytes = file_path_to_content_bytes(attach_path)
            file_extension = os.path.splitext(attach_path)[1]
            content_type = content_types.get(file_extension)
            if not content_type:
                raise ValueError(
                    f"{icons.red_dot} Unsupported file type: {file_extension}. Supported types are: {', '.join(content_types.keys())}."
                )
            lst_attachments.append(
                {
                    "@odata.type": "#microsoft.graph.fileAttachment",
                    "name": attach_path.split("/")[-1],
                    "contentType": content_type,
                    "contentBytes": content_bytes,
                }
            )

        # Add to payload
        payload["message"]["attachments"] = lst_attachments

    _base_api(
        request=f"users/{user_id}/sendMail",
        client="graph",
        status_codes=202,
        payload=payload,
        method="post",
    )

    printout = f"{icons.green_dot} The email has been sent to {to_recipients}"
    if cc_recipients:
        printout += f" and CCed to {cc_recipients}"
    if bcc_recipients:
        printout += f" and BCCed to {bcc_recipients}"
    if attachments:
        printout += f" with {len(attachments)} attachment(s)"
    print(f"{printout}.")

[m-kovalsky]

@OldDogNewTricks000 here is the branch with the updated function for testing: https://github.com/m-kovalsky/semantic-link-labs/blob/a0f05f7ce631d152aff808963bd95a660a3b10de/src/sempy_labs/graph/_users.py#L126

[OldDogNewTricks000]

I'm sorry, I may be a little out of my depth here...

I tried this:

str_test = 'Test email 1 - No attachments, single receiver'

send_mail_local(
    user = 'guid_that_I_replace_for_security'
    ,subject = str_test
    ,to_recipients = 'my_email_I_replaced_for_security'
    ,content = str_test
    ,content_type = "Text"
    ,cc_recipients = None
    ,bcc_recipients = None
    ,priority = "Normal"
    ,follow_up_flag = False
    ,attachments = None
)

But I received this error:

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[31], line 3
      1 str_test = 'Test email 1 - No attachments, single receiver'
----> 3 send_mail_local(
      4     user = 'guid_that_I_replace_for_security'
      5     ,subject = str_test
      6     ,to_recipients = 'my_email_I_replaced_for_security'
      7     ,content = str_test
      8     ,content_type = "Text"
      9     ,cc_recipients = None
     10     ,bcc_recipients = None
     11     ,priority = "Normal"
     12     ,follow_up_flag = False
     13     ,attachments = None
     14 )

Cell In[22], line 286, in send_mail_local(user, subject, to_recipients, content, content_type, cc_recipients, bcc_recipients, priority, follow_up_flag, attachments)
    283     # Add to payload
    284     payload["message"]["attachments"] = lst_attachments
--> 286 _base_api(
    287     request=f"users/{user_id}/sendMail",
    288     client="graph",
    289     status_codes=202,
    290     payload=payload,
    291     method="post",
    292 )
    294 printout = f"{icons.green_dot} The email has been sent to {to_recipients}"
    295 if cc_recipients:

File /nfs4/pyenv-c55d91ca-792d-474b-955f-5f9276b47633/lib/python3.11/site-packages/sempy_labs/_helper_functions.py:1869, in _base_api(request, client, method, payload, status_codes, uses_pagination, lro_return_json, lro_return_status_code)
   1867         raise NotImplementedError
   1868 else:
-> 1869     headers = _get_headers(auth.token_provider.get(), audience=client)
   1870     if client == "graph":
   1871         url = f"https://graph.microsoft.com/v1.0/{request}"

File /nfs4/pyenv-c55d91ca-792d-474b-955f-5f9276b47633/lib/python3.11/site-packages/sempy_labs/_authentication.py:154, in _get_headers(token_provider, audience)
    144 def _get_headers(
    145     token_provider: str,
    146     audience: Literal[
    147         "pbi", "storage", "azure", "graph", "asazure", "keyvault"
    148     ] = "azure",
    149 ):
    150     """
    151     Generates headers for an API request.
    152     """
--> 154     token = token_provider(audience=audience)
    156     headers = {"Authorization": f"Bearer {token}"}
    158     if audience == "graph":

TypeError: 'NoneType' object is not callable

I took your code and created the function called 'send_mail_local' so that it would not conflict with the current send_mail function currently in sll. I tried to follow the error into the _get_headers function in _authentication, but I was unable to find the actual 'token_provider' value anywhere in _authentication.py.

Also, I ended up removing the follow_up_flag in my function because it does not set the follow-up flag on the receiver's side of the email. It only creates a follow-up email on the sender's email side.

Lastly, just a thought, but I would see many use cases where I would like the ability to send the email from a different user. So instead of providing a UUID for a user, my version of the function just takes a string to provide that flexibility.

[m-kovalsky]

You have to use the service principal authentication context manager as such:

https://github.com/microsoft/semantic-link-labs/wiki/Code-Examples#send-an-email

[m-kovalsky]

@OldDogNewTricks000 were you able to test this using the service_principal_authentication context manager?

[OldDogNewTricks000]

I would like to help with this, but I keep running into issues. Would you be willing to get on a call so you can show me what I'm doing wrong? I don't come from a development background so I'm sure I'm missing something important.

[m-kovalsky]

Are you able to run the existing send_mail function which is in production?

[m-kovalsky]

@OldDogNewTricks000 i can confirm that this PR now allows for attachments to be sent via this function. It has been tested successfully.

#525

[m-kovalsky]

This is available in 0.11.2.

[OldDogNewTricks000]

Thank you for updating the function. I tested about 12 different email variations and everything seems to work as expected. I'm just curious though, I tried to email myself a .geojson file from Fabric that I was using as a reference layer and it says that it is not supported. Wouldn't that be handled just like a regular .txt or .csv file?

I am not sure if you are aware, but I removed follow_up_flag parameter from my function because it only flags the sending email; not the receiving email. I would suggest if you leave that in you add that clarification in the documentation.

[m-kovalsky]

Ah, I added in many 'content types' but not .geojson (honestly I haven't heard of it before). I can add that in. Hmm, seems like the follow up flag is a bit useless in that case. I'll probably just remove it. Thanks for letting me know.

See the PR here