PyEmailerAJM 1.6__py3-none-any.whl

PyEmailerAJM/__init__.py

@@ -0,0 +1,8 @@
+from PyEmailerAJM.errs import EmailerNotSetupError, DisplayManualQuit
+from PyEmailerAJM.helpers import deprecated, BasicEmailFolderChoices
+from PyEmailerAJM.msg import Msg, FailedMsg
+from PyEmailerAJM.py_emailer_ajm import PyEmailer, EmailerInitializer
+
+__all__ = ['EmailerNotSetupError', 'DisplayManualQuit', 'deprecated',
+           'BasicEmailFolderChoices', 'Msg', 'FailedMsg',
+           'PyEmailer', 'EmailerInitializer']

PyEmailerAJM/_version.py

@@ -0,0 +1 @@
+__version__ = '1.6'

PyEmailerAJM/errs.py

@@ -0,0 +1,6 @@
+class EmailerNotSetupError(Exception):
+    ...
+
+
+class DisplayManualQuit(Exception):
+    ...

PyEmailerAJM/helpers.py

@@ -0,0 +1,40 @@
+import warnings
+import functools
+from enum import IntEnum
+
+
+class BasicEmailFolderChoices(IntEnum):
+    INBOX = 6
+    SENT_ITEMS = 5
+    DRAFTS = 16
+    DELETED_ITEMS = 3
+    OUTBOX = 4
+    
+    def __str__(self):
+        """Return the enum name as a string."""
+        return self.name
+
+    def __repr__(self):
+        return f"<{self.__class__.__name__}.{self.name} ({self.value})>"
+
+
+def deprecated(reason: str = ""):
+    """
+    Decorator that marks a function or method as deprecated.
+
+    :param reason: Optional message to explain what to use instead
+                   or when the feature will be removed.
+    """
+
+    def decorator(func):
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            message = f"Function '{func.__name__}' is deprecated."
+            if reason:
+                message += f" {reason}"
+            warnings.warn(message, category=DeprecationWarning, stacklevel=2)
+            return func(*args, **kwargs)
+
+        return wrapper
+
+    return decorator

PyEmailerAJM/msg.py

@@ -0,0 +1,230 @@
+from abc import abstractmethod
+from os.path import isfile, isabs, abspath, join
+from tempfile import gettempdir
+
+import win32com.client as win32
+import datetime
+import extract_msg
+from bs4 import BeautifulSoup
+from logging import Logger, getLogger, warning
+
+
+class _BasicMsgProperties:
+    def __init__(self, email_item: win32.CDispatch):
+        self.email_item = email_item
+
+    @classmethod
+    @abstractmethod
+    def _validate_and_add_attachments(cls, email_item: win32.CDispatch, attachment_list: list = None):
+        ...
+
+    @property
+    def sender(self):
+        if hasattr(self.email_item, 'SenderEmailType') and self.email_item.SenderEmailType == 'EX':
+            return self.email_item.Sender.GetExchangeUser().PrimarySmtpAddress
+        # return self.email_item.Sender if hasattr(self.email_item, 'Sender') else self.email_item.sender
+        else:
+            return self.email_item.SenderEmailAddress
+
+    @property
+    def sender_name(self):
+        return self.email_item.Sender if hasattr(self.email_item, 'Sender') else self.email_item.sender
+
+    @property
+    def to(self):
+        return self.email_item.To if hasattr(self.email_item, 'To') else self.email_item.to
+
+    def cc(self):
+        return self.email_item.CC if hasattr(self.email_item, 'CC') else self.email_item.cc
+
+    @property
+    def subject(self):
+        return self.email_item.Subject if hasattr(self.email_item, 'Subject') else self.email_item.subject
+
+    @property
+    def received_time(self):
+        #not_future = self.email_item.ReceivedTime.year < datetime.datetime.now().year
+        return self.email_item.ReceivedTime #if not_future else None
+
+    @property
+    def body(self):
+        return self.email_item.HTMLBody if hasattr(self.email_item, 'HTMLBody') else self.email_item.htmlBody
+
+    @property
+    def attachments(self):
+        return self.email_item.Attachments
+
+    @attachments.setter
+    def attachments(self, value: list):
+        self._validate_and_add_attachments(self.email_item, value)
+
+
+class Msg(_BasicMsgProperties):
+    def __init__(self, email_item: win32.CDispatch or extract_msg.Message, **kwargs):
+        super().__init__(email_item)
+        self._logger: Logger = kwargs.get('logger', getLogger(__name__))
+        self.send_success = False
+
+    def __call__(self, *args, **kwargs):
+        return self.email_item
+
+    @classmethod
+    def SetupMsg(cls, sender, recipient, subject, body, email_item: win32.CDispatch, attachments: list = None, **kwargs):
+        email_item.To = recipient
+        email_item.Sender = sender
+        email_item.Subject = subject
+        email_item.HtmlBody = body
+        email_item.cc = kwargs.get('cc', '')
+        email_item.Bcc = kwargs.get('bcc', '')
+
+        cls._validate_and_add_attachments(email_item, attachments)
+        return cls(email_item, **kwargs)
+
+    @classmethod
+    def _validate_and_add_attachments(cls, email_item: win32.CDispatch, attachment_list: list = None):
+        """ Validate and attach files to the email_item. """
+        if not attachment_list:
+            warning("No attachments detected")
+            return
+
+        if not isinstance(attachment_list, list):
+            raise TypeError("Attachments must be provided as a list")
+
+        def _absolute_file_path(file_path):
+            """Returns absolute path if valid; raises FileNotFoundError otherwise."""
+            if not isabs(file_path):
+                file_path = abspath(file_path)
+            if not isfile(file_path):
+                raise FileNotFoundError(f"File {file_path} could not be attached.")
+            return file_path
+
+        for attachment in attachment_list:
+            email_item.attachments.Add(_absolute_file_path(attachment))
+
+    def SaveAllEmailAttachments(self, save_dir_path):
+        all_attachment_paths = set()
+        for attachment in self.attachments:
+            full_save_path = join(save_dir_path, str(attachment))
+            try:
+                attachment.SaveAsFile(full_save_path)
+                all_attachment_paths.add(full_save_path)
+                self._logger.debug(f"{full_save_path} saved from email with subject {self.subject}")
+            except Exception as e:
+                self._logger.error(e, exc_info=True)
+                raise e
+        return all_attachment_paths
+
+    def display(self):
+        # print(f"Displaying the email in {self.email_app_name}, this window might open minimized.")
+        # self._logger.info(f"Displaying the email in {self.email_app_name}, this window might open minimized.")
+        try:
+            self().Display(True)
+        except Exception as e:
+            self._logger.error(e, exc_info=True)
+            raise e
+
+    def send(self):
+        try:
+            # if the send fails, self.to is NULL, so this needs to be saved in a local variable
+            attempted_recipient = self.to
+            self.send_success = False
+            self().Send()
+            # print(f"Mail sent to {self._recipient}")
+            self.send_success = True
+            self._logger.info(f"Mail successfully sent to {attempted_recipient}")
+        except Exception as e:
+            self._logger.error(e, exc_info=True)
+            raise e
+
+    def _ValidateResponseMsg(self):
+        if isinstance(self(), win32.CDispatch):
+            self._logger.debug("passed in msg is CDispatch instance")
+        if hasattr(self(), 'HtmlBody') or hasattr(self(), 'htmlBody'):
+            self._logger.debug("passed in msg has 'HtmlBody' or 'htmlBody' attr")
+
+        if (not isinstance(self(), win32.CDispatch)
+                or not hasattr(self(), ('HtmlBody' or 'htmlBody'))):
+            raise AttributeError("msg attr must have 'HtmlBody' attr AND be a CDispatch instance")
+        return self()
+
+    def _msg_is_recent(self, recent_days_cap=1):
+        if self.received_time is not None:
+            abs_diff = abs(self.received_time - datetime.datetime.now(tz=self.received_time.tzinfo))
+            return abs_diff <= datetime.timedelta(days=recent_days_cap)
+        print(f"msg with subject \'{self.email_item.Subject}\' has no received time. defaulting to false")
+        self._logger.debug(f"msg with subject \'{self.email_item.Subject}\' has no received time. defaulting to false")
+        return False
+
+    def return_as_failed_send(self):
+        return FailedMsg(self())
+
+
+class FailedMsg(Msg):
+    ERR_SKIP_STRING = "err {}: skipping this message"
+    DEFAULT_TEMP_SAVE_PATH = gettempdir()
+
+    def _message_filter_checks(self, **kwargs) -> bool:
+        recent_days_cap = kwargs.get('recent_days_cap', 1)
+        return self._msg_is_recent(recent_days_cap)
+
+    def _fetch_failed_msg_details(self, **kwargs):
+        temp_attachment_save_path = kwargs.get('temp_attachment_save_path',
+                                               self.__class__.DEFAULT_TEMP_SAVE_PATH)
+        try:
+            attachment_msg_path = self.SaveAllEmailAttachments(temp_attachment_save_path)
+            print('saved_attachments')
+        except Exception as e:
+            self._logger.warning(self.__class__.ERR_SKIP_STRING.format(f'({e})'))
+            return e
+        if len(attachment_msg_path) == 1:
+            return next(iter(attachment_msg_path))
+        return attachment_msg_path
+
+    def process_failed_msg(self, post_master_msg, **kwargs):
+        recent_days_cap = kwargs.get('recent_days_cap', 1)
+        try:
+            self.email_item = post_master_msg
+            self._ValidateResponseMsg()
+        except AttributeError as e:
+            self._logger.warning(self.__class__.ERR_SKIP_STRING.format(f'({e})'))
+            return e, None, None
+
+        if self._msg_is_recent(recent_days_cap):
+            attachment_msg = self._fetch_failed_msg_details()
+            if isinstance(attachment_msg, Exception):
+                return attachment_msg, None, None
+            else:
+                if isinstance(attachment_msg, str):
+                    fmd = _FailedMessageDetails.extract_msg_from_attachment(attachment_msg)
+                    return fmd.process_failed_details_msg() #self._process_failed_details_msg(attachment_msg)
+        return None, None, None
+
+
+class _FailedMessageDetails(FailedMsg):
+    @classmethod
+    def extract_msg_from_attachment(cls, parent_msg: str):
+        return cls(extract_msg.Message(parent_msg))
+
+    def _extract_from_failed_details_msg(self, para):
+        email_of_err = para.findNext('p').get_text().strip().split('(')[0].strip()
+        err_reason = para.findNext('p').findNext('p').get_text()
+        send_time = self().date.ctime()
+        failed_subject = self.subject
+
+        err_details = {'email_of_err': email_of_err, 'err_reason': err_reason,
+                       'send_time': send_time, 'failed_subject': failed_subject}
+        # print(f"Email of err: {email_of_err},\nErr reason: {err_reason}\nSend time: {send_time}")
+        return err_details #email_of_err, err_reason, send_time
+
+    def process_failed_details_msg(self, **kwargs):
+        detail_marker_string = kwargs.get('detail_marker_string',
+                                          "Delivery has failed to these recipients or groups:")
+
+        soup = BeautifulSoup(self.body, features="html.parser")
+
+        all_p = soup.find_all(name='p')  # , attrs={'class': 'MsoNormal'})
+
+        for para in all_p:
+            if detail_marker_string in para.get_text():
+                return {** self._extract_from_failed_details_msg(para)}
+        return None, None, None

PyEmailerAJM/py_emailer_ajm.py

@@ -0,0 +1,518 @@
+#! python3
+"""
+py_emailer_ajm.py
+
+install win32 with pip install pywin32
+"""
+# imports
+from abc import abstractmethod
+from os import environ
+from os.path import isfile, join, isdir
+from tempfile import gettempdir
+from typing import List
+
+# install win32 with pip install pywin32
+import win32com.client as win32
+
+# This is installed as part of pywin32
+# noinspection PyUnresolvedReferences
+from pythoncom import com_error
+from logging import Logger, basicConfig, StreamHandler, FileHandler
+from email_validator import validate_email, EmailNotValidError
+import questionary
+# this is usually thrown when questionary is used in the dev/Non Win32 environment
+# noinspection PyProtectedMember
+from prompt_toolkit.output.win32 import NoConsoleScreenBufferError
+from win32com.client import CDispatch
+
+from PyEmailerAJM import EmailerNotSetupError, DisplayManualQuit
+from PyEmailerAJM import BasicEmailFolderChoices, deprecated
+from PyEmailerAJM import Msg, FailedMsg
+
+
+class EmailerInitializer:
+    DEFAULT_EMAIL_APP_NAME = 'outlook.application'
+    DEFAULT_NAMESPACE_NAME = 'MAPI'
+
+    def __init__(self, display_window: bool,
+                 send_emails: bool, logger: Logger = None,
+                 auto_send: bool = False,
+                 email_app_name: str = DEFAULT_EMAIL_APP_NAME,
+                 namespace_name: str = DEFAULT_NAMESPACE_NAME, **kwargs):
+
+        self._logger = self._initialize_logger(logger, use_default_logger=kwargs.get('use_default_logger', False))
+        # print("Dummy logger in use!")
+
+        self.email_app_name = email_app_name
+        self.namespace_name = namespace_name
+
+        self.email_app, self.namespace, self.email = self.initialize_email_item_app_and_namespace()
+
+        self.display_window = display_window
+        self.auto_send = auto_send
+        self.send_emails = send_emails
+
+    def _initialize_logger(self, logger=None, **kwargs):
+        if logger:
+            self._logger = logger
+            return self._logger
+        else:
+            self._logger = Logger(__name__)
+
+        if self._logger.hasHandlers():
+            return self._logger
+        if not kwargs.get('use_default_logger', True):
+            print("not using default logger")
+            return self._logger
+        return self._initialize_default_logger()
+
+    def _initialize_default_logger(self, **kwargs):
+        def init_handlers():
+            sh = StreamHandler()
+            sh.set_name('StreamHandler')
+            fh = FileHandler(kwargs.get('log_file_path', join('./', 'PyEmailer.log')))
+            fh.set_name('FileHandler')
+            return sh, fh
+
+        def set_handler_levels(**kw):
+            fh_level = kw.get('FileHandler_level', 'DEBUG')
+            sh_level = kw.get('StreamHandler_level', 'INFO')
+            for h in self._logger.handlers:
+                if isinstance(h, FileHandler):
+                    h.setLevel(fh_level)
+                elif isinstance(h, StreamHandler):
+                    h.setLevel(sh_level)
+                else:
+                    h.setLevel(kw.get('handler_default_level', 'DEBUG'))
+
+        stream_handle, file_handle = init_handlers()
+
+        if kwargs.get('log_to_stdout', True):
+            self._logger.addHandler(stream_handle)
+        self._logger.addHandler(file_handle)
+        set_handler_levels(**kwargs)
+
+        basicConfig(level='INFO', handlers=self._logger.handlers)
+        self._logger.info("basic logger initialized.")
+        return self._logger
+
+    def initialize_new_email(self):
+        if hasattr(self, 'email_app') and self.email_app is not None:
+            self.email = Msg(self.email_app.CreateItem(0), logger=self._logger)
+            return self.email
+        raise AttributeError("email_app is not defined. Run 'initialize_email_item_app_and_namespace' first")
+
+    def initialize_email_item_app_and_namespace(self):
+        try:
+            email_app, namespace = self._setup_email_app_and_namespace()
+            email = self.initialize_new_email()
+        except com_error as e:
+            self._logger.error(e, exc_info=True)
+            raise e
+        return email_app, namespace, email
+
+    def _setup_email_app_and_namespace(self):
+        self.email_app = win32.Dispatch(self.email_app_name)
+
+        self._logger.debug(f"{self.email_app_name} app in use.")
+        self.namespace = self.email_app.GetNamespace(self.namespace_name)
+
+        self._logger.debug(f"{self.namespace_name} namespace in use.")
+        return self.email_app, self.namespace
+
+
+class _SubjectSearcher:
+    # Constants for prefixes
+    FW_PREFIXES = ['FW:', 'FWD:']
+    RE_PREFIX = 'RE:'
+
+    @abstractmethod
+    def GetMessages(self):
+        ...
+
+    def find_messages_by_subject(self, search_subject: str, include_fw: bool = True, include_re: bool = True,
+                                 partial_match_ok: bool = False) -> List[CDispatch]:
+        """Returns a list of messages matching the given subject, ignoring prefixes based on flags."""
+
+        # Normalize search subject
+        normalized_subject = self._normalize_subject(search_subject)
+        matched_messages = []
+        print("partial match ok: ", partial_match_ok)
+
+        for message in self.GetMessages():
+            normalized_message_subject = self._normalize_subject(message.subject)
+
+            if (self._is_exact_match(normalized_message_subject, normalized_subject) or
+                    (partial_match_ok and self._is_partial_match(normalized_message_subject,
+                                                                 normalized_subject))):
+                matched_messages.append(message)
+                continue
+
+            if include_fw and self._matches_prefix(normalized_message_subject,
+                                                   self.__class__.FW_PREFIXES,
+                                                   normalized_subject,
+                                                   partial_match_ok):
+                matched_messages.append(message)
+                continue
+
+            if include_re and self._matches_prefix(normalized_message_subject,
+                                                   [self.__class__.RE_PREFIX],
+                                                   normalized_subject,
+                                                   partial_match_ok):
+                matched_messages.append(message)
+
+        return [m() for m in matched_messages]
+
+    @staticmethod
+    def _normalize_subject(subject: str) -> str:
+        """Normalize the given subject by converting to lowercase and stripping whitespace."""
+        return subject.lower().strip()
+
+    def _matches_prefix(self, message_subject: str, prefixes: list, search_subject: str,
+                        partial_match_ok: bool = False) -> bool:
+        """Checks if the message subject matches the search subject after removing a prefix."""
+        for prefix in prefixes:
+            if message_subject.startswith(prefix.lower()):
+                stripped_subject = message_subject.split(prefix.lower(), 1)[1].strip()
+                return (self._is_exact_match(stripped_subject, search_subject) if not partial_match_ok
+                        else self._is_partial_match(stripped_subject, search_subject))
+        return False
+
+    @staticmethod
+    def _is_exact_match(message_subject: str, search_subject: str) -> bool:
+        """Checks if the subject matches exactly."""
+        return message_subject == search_subject
+
+    @staticmethod
+    def _is_partial_match(message_subject: str, search_subject: str) -> bool:
+        return search_subject in message_subject
+
+
+class PyEmailer(EmailerInitializer, _SubjectSearcher):
+    # the email tab_char
+    tab_char = ' '
+    signature_dir_path = join((environ['USERPROFILE']),
+                              'AppData\\Roaming\\Microsoft\\Signatures\\')
+
+    DisplayEmailSendTrackingWarning = "THIS TYPE OF SEND CANNOT BE DETECTED FOR SEND SUCCESS AUTOMATICALLY."
+    FAILED_SEND_LOGGER_STRING = "{num} confirmed failed send(s) found in the last {recent_days_cap} day(s)."
+
+    DEFAULT_TEMP_SAVE_PATH = gettempdir()
+    VALID_EMAIL_FOLDER_CHOICES = [x for x in BasicEmailFolderChoices]
+
+    def __init__(self, display_window: bool, send_emails: bool, logger: Logger = None, email_sig_filename: str = None,
+                 auto_send: bool = False, email_app_name: str = EmailerInitializer.DEFAULT_EMAIL_APP_NAME,
+                 namespace_name: str = EmailerInitializer.DEFAULT_NAMESPACE_NAME, **kwargs):
+
+        super().__init__(display_window, send_emails, logger, auto_send, email_app_name, namespace_name, **kwargs)
+        self._setup_was_run = False
+        self._current_user_email = None
+
+        self.read_folder = None
+
+        self._email_signature = None
+        self._send_success = False
+        self.email_sig_filename = email_sig_filename
+
+    @property
+    def current_user_email(self):
+        if self.email_app_name.lower().startswith('outlook'):
+            self._current_user_email = (
+                self.namespace.Application.Session.CurrentUser.AddressEntry.GetExchangeUser().PrimarySmtpAddress)
+        return self._current_user_email
+
+    @current_user_email.setter
+    def current_user_email(self, value):
+        try:
+            if validate_email(value, check_deliverability=False):
+                self._current_user_email = value
+        except EmailNotValidError as e:
+            self._logger.error(e, exc_info=True)
+            value = None
+        self._current_user_email = value
+
+    @property
+    def email_signature(self):
+        return self._email_signature
+
+    @email_signature.getter
+    def email_signature(self):
+        if self.email_sig_filename:
+            signature_full_path = join(self.signature_dir_path, self.email_sig_filename)
+            if isdir(self.signature_dir_path):
+                pass
+            else:
+                try:
+                    raise NotADirectoryError(f"{self.signature_dir_path} does not exist.")
+                except NotADirectoryError as e:
+                    self._logger.warning(e)
+                    self._email_signature = None
+
+            if isfile(signature_full_path):
+                with open(signature_full_path, 'r', encoding='utf-16') as f:
+                    self._email_signature = f.read().strip()
+            else:
+                try:
+                    raise FileNotFoundError(f"{signature_full_path} does not exist.")
+                except FileNotFoundError as e:
+                    self._logger.warning(e)
+                    self._email_signature = None
+        else:
+            self._email_signature = None
+
+        return self._email_signature
+
+    @property
+    def send_success(self):
+        return self._send_success
+
+    @send_success.setter
+    def send_success(self, value):
+        self._send_success = value
+
+    def _display_tracking_warning_confirm(self):
+        # noinspection PyBroadException
+        try:
+            q = questionary.confirm(f"{self.DisplayEmailSendTrackingWarning}. Do you understand?",
+                                    default=False, auto_enter=False).ask()
+            return q
+        except Exception as e:
+            # TODO: slated for removal
+            # this is here purely as a compatibility thing, to be taken out later.
+            self._logger.warning(e)
+            self._logger.warning("Defaulting to basic y/n prompt.")
+            while True:
+                q = input(f"{self.DisplayEmailSendTrackingWarning}. Do you understand? (y/n): ").lower().strip()
+                if q == 'y':
+                    self._logger.warning(self.DisplayEmailSendTrackingWarning)
+                    return True
+                elif q == 'n':
+                    return False
+                else:
+                    print("Please respond with 'y' or 'n'.")
+
+    def display_tracker_check(self) -> bool:
+        if self.display_window:
+            c = self._display_tracking_warning_confirm()
+            if c:
+                return c
+            else:
+                try:
+                    raise DisplayManualQuit("User cancelled operation due to DisplayTrackingWarning.")
+                except DisplayManualQuit as e:
+                    self._logger.error(e, exc_info=True)
+                    raise e
+
+    def _GetReadFolder(self, email_dir_index: int = BasicEmailFolderChoices.INBOX):
+        # 6 = inbox
+        if email_dir_index in self.__class__.VALID_EMAIL_FOLDER_CHOICES:
+            self.read_folder = self.namespace.GetDefaultFolder(email_dir_index)
+            return self.read_folder
+        else:
+            try:
+                raise ValueError(f"email_dir_index must be one of {self.__class__.VALID_EMAIL_FOLDER_CHOICES}")
+            except ValueError as e:
+                self._logger.error(e, exc_info=True)
+                raise e
+
+    def GetMessages(self, folder_index=None):
+        if isinstance(folder_index, int):
+            self.read_folder = self._GetReadFolder(folder_index)
+        elif not folder_index and self.read_folder:
+            pass
+        elif not folder_index:
+            self.read_folder = self._GetReadFolder()
+        else:
+            try:
+                raise TypeError("folder_index must be an integer or self.read_folder must be defined")
+            except TypeError as e:
+                self._logger.error(e, exc_info=True)
+                raise e
+        return [Msg(m, logger=self._logger) for m in self.read_folder.Items]
+
+    @deprecated("use Msg classes body attribute instead")
+    def GetEmailMessageBody(self, msg):
+        """message = messages.GetLast()"""
+        body_content = msg.body
+        if body_content:
+            return body_content
+        else:
+            try:
+                raise ValueError("This message has no body.")
+            except ValueError as e:
+                self._logger.error(e, exc_info=True)
+                raise e
+
+    @deprecated("use find_messages_by_subject instead")
+    def FindMsgBySubject(self, subject: str, forwarded_message_match: bool = True,
+                         reply_msg_match: bool = True, partial_match_ok: bool = False):
+        return self.find_messages_by_subject(subject, include_fw=forwarded_message_match,
+                                             include_re=reply_msg_match,
+                                             partial_match_ok=partial_match_ok)
+
+    def SaveAllEmailAttachments(self, msg, save_dir_path):
+        attachments = msg.Attachments
+        for attachment in attachments:
+            full_save_path = join(save_dir_path, str(attachment))
+            try:
+                attachment.SaveAsFile(full_save_path)
+                self._logger.debug(f"{full_save_path} saved from email with subject {msg.subject}")
+            except Exception as e:
+                self._logger.error(e, exc_info=True)
+                raise e
+
+    def SetupEmail(self, recipient: str, subject: str, text: str, attachments: list = None, **kwargs):
+        self.email = self.email.SetupMsg(sender=self.current_user_email, email_item=self.email(),
+                                         recipient=recipient, subject=subject, body=text, attachments=attachments,
+                                         logger=self._logger, **kwargs)
+        self._setup_was_run = True
+        return self.email
+
+    def _manual_send_loop(self):
+        try:
+            send = questionary.confirm("Send Mail?:", default=False).ask()
+            if send:
+                self.email.send()
+                return
+            elif not send:
+                self._logger.info(f"Mail not sent to {self.email.to}")
+                print(f"Mail not sent to {self.email.to}")
+                q = questionary.confirm("do you want to quit early?", default=False).ask()
+                if q:
+                    print("ok quitting!")
+                    self._logger.warning("Quitting early due to user input.")
+                    exit(-1)
+                else:
+                    return
+        except com_error as e:
+            self._logger.error(e, exc_info=True)
+        except NoConsoleScreenBufferError as e:
+            # TODO: slated for removal
+            # this is here purely as a compatibility thing, to be taken out later.
+            self._logger.warning(e)
+            self._logger.warning("defaulting to basic input style...")
+            while True:
+                yn = input("Send Mail? (y/n/q): ").lower()
+                if yn == 'y':
+                    self.email.send()
+                    break
+                elif yn == 'n':
+                    self._logger.info(f"Mail not sent to {self.email.to}")
+                    print(f"Mail not sent to {self.email.to}")
+                    break
+                elif yn == 'q':
+                    print("ok quitting!")
+                    self._logger.warning("Quitting early due to user input.")
+                    exit(-1)
+                else:
+                    print("Please choose \'y\', \'n\' or \'q\'")
+
+    def SendOrDisplay(self, print_ready_msg: bool = False):
+        if self._setup_was_run:
+            if print_ready_msg:
+                print(f"Ready to send/display mail to/for {self.email.to}...")
+            self._logger.info(f"Ready to send/display mail to/for {self.email.to}...")
+            if self.send_emails and self.display_window:
+                send_and_display_warning = ("Sending email while also displaying the email "
+                                            "in the app is not possible. Defaulting to Display only")
+                # print(send_and_display_warning)
+                self._logger.warning(send_and_display_warning)
+                self.send_emails = False
+                self.display_window = True
+
+            if self.send_emails:
+                if self.auto_send:
+                    self._logger.info("Sending emails with auto_send...")
+                    self.email.send()
+
+                else:
+                    self._manual_send_loop()
+
+            elif self.display_window:
+                self.email.display()
+            else:
+                both_disabled_warning = ("Both sending and displaying the email are disabled. "
+                                         "No errors were encountered.")
+                self._logger.warning(both_disabled_warning)
+                # print(both_disabled_warning)
+        else:
+            try:
+                raise EmailerNotSetupError("Setup has not been run, sending or displaying an email cannot occur.")
+            except EmailerNotSetupError as e:
+                self._logger.error(e, exc_info=True)
+                raise e
+
+    @staticmethod
+    def _fmsg_is_no_info_or_err(info):
+        return (any(isinstance(x, Exception) for x in info)
+                or all(isinstance(x, type(None)) for x in info))
+
+    def get_failed_sends(self, fail_string_marker: str = 'undeliverable', partial_match_ok: bool = True, **kwargs):
+        failed_sends = []
+        recent_days_cap = kwargs.get('recent_days_cap', 1)
+        self.GetMessages(BasicEmailFolderChoices.INBOX)
+
+        msg_candidates = self.FindMsgBySubject(fail_string_marker, partial_match_ok=partial_match_ok)
+
+        if msg_candidates:
+            msg_candidates = [FailedMsg(m) for m in msg_candidates]
+            self._logger.info(f"{len(msg_candidates)} 'failed send' candidates found.")
+            self._logger.info("mutating msg_candidates (Msg instances) into FailedMsg instances.")
+
+            for m in msg_candidates:
+                failed_info = m.process_failed_msg(m(), recent_days_cap=recent_days_cap)
+
+                if self._fmsg_is_no_info_or_err(failed_info):
+                    continue
+                else:
+                    failed_sends.append({'postmaster_email': m.sender,
+                                         'err_info': failed_info})
+        results_string = self.__class__.FAILED_SEND_LOGGER_STRING.format(num=len(failed_sends),
+                                                                         recent_days_cap=recent_days_cap)
+        if (not self._logger.hasHandlers() or not any([isinstance(x, StreamHandler)
+                                                       for x in self._logger.handlers])):
+            print(results_string)
+        self._logger.info(results_string)
+        return failed_sends
+
+
+def __failed_sends_test(emailer):
+    failed_sends = emailer.get_failed_sends(recent_days_cap=1)
+    fs_results = ([(x.get('err_info').get('send_time'),
+                    x.get('err_info').get('failed_subject'))
+                   for x in failed_sends]
+                  if failed_sends else "no failed sends found")
+    print(fs_results)
+
+
+def __setup_and_send_test(emailer):
+    emailer.SetupEmail(subject="TEST: Your TEST agreement expires in 30 days or less!",
+                       recipient='amcsparron@albanyny.gov',
+                       text="testing to see anything works", bcc='amcsparron@albanyny.gov')
+    emailer.SendOrDisplay()
+
+
+if __name__ == "__main__":
+    module_name = __file__.split('\\')[-1].split('.py')[0]
+
+    em = PyEmailer(display_window=False, send_emails=True, auto_send=False, use_default_logger=True)
+    m = em.find_messages_by_subject('Andrew', partial_match_ok=True, include_re=True, include_fw=True)
+    print([type(x) for x in m])
+    # __setup_and_send_test(em)
+    # __failed_sends_test(em)
+    # x = emailer.find_messages_by_subject("Timecard", partial_match_ok=False, include_re=False)
+    # #print([(m.SenderEmailAddress, m.SenderEmailType, [x.name for x in m.ItemProperties]) for m in x])
+    # property_accessor = x[0].PropertyAccessor
+    # print(x[0].Sender.GetExchangeUser().PrimarySmtpAddress)
+    # print(property_accessor.GetProperty("PR_EMAIL_ADDRESS"))
+
+    # r_dict = {
+    #     "subject": f"TEST: Your TEST "
+    #                f"agreement expires in 30 days or less!",
+    #     "text": "testing to see if the attachment works",
+    #     "recipient": 'test',
+    #     "attachments": []
+    # }
+    # #   is the tab character for emails
+    # emailer.SetupEmail(**r_dict)  # recipient="test", subject="test subject", text="test_body")
+    # emailer.SendOrDisplay()

pyemailerajm-1.6.dist-info/METADATA

@@ -0,0 +1,21 @@
+Metadata-Version: 2.4
+Name: PyEmailerAJM
+Version: 1.6
+Summary: Allows for automating sending Email with the Outlook Desktop client. Future releases will add more client support
+Home-page: https://github.com/amcsparron2793-Water/PyEmailer
+Download-URL: https://github.com/amcsparron2793-Water/PyEmailer/archive/refs/tags/1.6.tar.gz
+Author: Amcsparron
+Author-email: amcsparron@albanyny.gov
+License: MIT License
+Keywords: Outlook,Email,Automation
+License-File: LICENSE.txt
+Requires-Dist: pywin32
+Dynamic: author
+Dynamic: author-email
+Dynamic: download-url
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: summary

pyemailerajm-1.6.dist-info/RECORD

@@ -0,0 +1,11 @@
+PyEmailerAJM/__init__.py,sha256=bn1ONP8stlYp4ngNMRICP6AheZdZ2F9QiFs0uSmTwHA,436
+PyEmailerAJM/_version.py,sha256=M1eDmUwdJ1O4qzSP864VIsLUTc686xQagwVqbieJkTU,21
+PyEmailerAJM/errs.py,sha256=-_SM8q3cdTacvefJl-__qC6uIEn8uQgo1YdVXq22sjw,99
+PyEmailerAJM/helpers.py,sha256=bvYvU4Dma9JgDiXE31xdeXVP6diYBU1tab1Hesxxnr0,1052
+PyEmailerAJM/msg.py,sha256=jornyustxEvhi8QMupKxHGcV2xzLB3-Ftjc-cqNBvQ8,9666
+PyEmailerAJM/py_emailer_ajm.py,sha256=WEtg2HzEcW2v_MiPyIb7-kHCk1k7ZelNEXx8zBGI2xY,22574
+pyemailerajm-1.6.dist-info/licenses/LICENSE.txt,sha256=7TxqSLofaZz1NmKH8ljjGHxsgR1OyIeGah5ZZrKYVXI,1084
+pyemailerajm-1.6.dist-info/METADATA,sha256=KhMHZ1piuEudIEV-iw7QnFbXR4rpveQOO1Sy0zE_O6M,690
+pyemailerajm-1.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pyemailerajm-1.6.dist-info/top_level.txt,sha256=SCqZjBB-AUu9Qkgcrfc3KhH8VSriJqEGevQVPpIyI4Q,13
+pyemailerajm-1.6.dist-info/RECORD,,

pyemailerajm-1.6.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pyemailerajm-1.6.dist-info/licenses/LICENSE.txt

@@ -0,0 +1,17 @@
+MIT License
+Copyright (c) 2018 Andrew McSparron
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pyemailerajm-1.6.dist-info/top_level.txt

@@ -0,0 +1 @@
+PyEmailerAJM