PyEmailerAJM 1.8.4__tar.gz → 1.9__tar.gz

{pyemailerajm-1.8.4 → pyemailerajm-1.9}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: PyEmailerAJM
-Version: 1.8.4
+Version: 1.9
 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.8.4.tar.gz
+Download-URL: https://github.com/amcsparron2793-Water/PyEmailer/archive/refs/tags/1.9.tar.gz
 Author: Amcsparron
 Author-email: amcsparron@albanyny.gov
 License: MIT License

{pyemailerajm-1.8.4 → pyemailerajm-1.9}/PyEmailerAJM/__init__.py

@@ -17,12 +17,12 @@ def is_instance_of_dynamic(obj: object, base_class_path: str) -> bool:
 from PyEmailerAJM.backend import deprecated
 from PyEmailerAJM.backend.errs import EmailerNotSetupError, DisplayManualQuit
 from PyEmailerAJM.msg import Msg, FailedMsg
-from PyEmailerAJM.searchers import BaseSearcher, SubjectSearcher
+from PyEmailerAJM.searchers import SearcherFactory
 from PyEmailerAJM.py_emailer_ajm import PyEmailer, EmailerInitializer
 from PyEmailerAJM.continuous_monitor.continuous_monitor import ContinuousMonitor
 
 __all__ = ['EmailerNotSetupError', 'DisplayManualQuit', 'deprecated',
            'Msg', 'FailedMsg', 'PyEmailer', 'EmailerInitializer',
-           'BaseSearcher', 'SubjectSearcher', 'ContinuousMonitor',
+           'SearcherFactory', 'ContinuousMonitor',
            'is_instance_of_dynamic']
 

pyemailerajm-1.9/PyEmailerAJM/_version.py

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

{pyemailerajm-1.8.4 → pyemailerajm-1.9}/PyEmailerAJM/backend/__init__.py

@@ -1,5 +1,5 @@
 from PyEmailerAJM.backend.errs import *
-from PyEmailerAJM.backend.enums import BasicEmailFolderChoices, AlertTypes
+from PyEmailerAJM.backend.enums import BasicEmailFolderChoices, AlertTypes, EmailMsgImportanceLevel
 from PyEmailerAJM.backend.the_sandman import TheSandman
 from PyEmailerAJM.backend.logger import PyEmailerLogger
 import warnings
@@ -31,4 +31,4 @@ def deprecated(reason: str = ""):
 __all__ = ['deprecated', 'EmailerNotSetupError', 'InvalidAlertLevel',
            'DisplayManualQuit', 'NoMessagesFetched',
            'UnrecognizedEmailError', 'BasicEmailFolderChoices',
-           'AlertTypes', 'TheSandman', 'PyEmailerLogger']
+           'AlertTypes', 'EmailMsgImportanceLevel','TheSandman', 'PyEmailerLogger']

{pyemailerajm-1.8.4 → pyemailerajm-1.9}/PyEmailerAJM/backend/enums.py

@@ -33,4 +33,13 @@ class BasicEmailFolderChoices(IntEnum):
         return self.name
 
     def __repr__(self):
-        return f"<{self.__class__.__name__}.{self.name} ({self.value})>"
+        return f"<{self.__class__.__name__}.{self.name} ({self.value})>"
+
+
+class EmailMsgImportanceLevel(IntEnum):
+    LOW = 0
+    NORMAL = 1
+    HIGH = 2
+
+    def __str__(self):
+        return self.name

{pyemailerajm-1.8.4 → pyemailerajm-1.9}/PyEmailerAJM/continuous_monitor/backend/continuous_monitor_base.py

@@ -51,6 +51,7 @@ class ContinuousMonitorBase(PyEmailer, EmailState):
     ATTRS_TO_CHECK = []
 
     def __init__(self, display_window: bool, send_emails: bool, **kwargs):
+        # Let EmailerInitializer handle logger factory vs instance normalization
         super().__init__(display_window, send_emails, **kwargs)
 
         self.dev_mode = kwargs.get('dev_mode', False)
@@ -59,6 +60,14 @@ class ContinuousMonitorBase(PyEmailer, EmailState):
         self.log_dev_mode_warnings()
         self.email_handler_init()
 
+    @property
+    def num_snoozed_msgs(self):
+        if (self.snooze_tracker.json_loaded and
+                hasattr(self.snooze_tracker.json_loaded, '__len__')):
+            return len(self.snooze_tracker.json_loaded)
+        else:
+            return 0
+
     @classmethod
     def check_for_class_attrs(cls, class_attrs_to_check):
         for c in class_attrs_to_check:
@@ -68,8 +77,10 @@ class ContinuousMonitorBase(PyEmailer, EmailState):
 
     def initialize_helper_classes(self, **kwargs):
         colorizer = ContinuousColorizer(logger=self.logger)
-        snooze_tracker = SnoozeTracking(Path(kwargs.get('file_name', './snooze_tracker.json')),
-                                        logger=kwargs.get('logger', self.logger))
+        snooze_tracker = SnoozeTracking(
+            Path(kwargs.get('file_name', './snooze_tracker.json')),
+            logger=self.logger,
+        )
         sleep_timer = TheSandman(sleep_time_seconds=kwargs.get('sleep_time_seconds', None), logger=self.logger)
         return colorizer, snooze_tracker, sleep_timer
 
@@ -81,19 +92,25 @@ class ContinuousMonitorBase(PyEmailer, EmailState):
                 f" it will mock send emails but not actually send them to {self.__class__.ADMIN_EMAIL}"
             )
 
+    # Issue with PyEmailer 1.8.5 causes the base version to disable email handler
+    #  (issue with check for setup_email_handler attr) - below is a functional work around
     def email_handler_init(self):
-        if self.dev_mode:
-            self.logger.warning("email handler disabled for dev mode")
-        elif (not type(self).__name__ == "ContinuousMonitorAlertSend"
-              and not is_instance_of_dynamic(self, "__main__.ContinuousMonitorAlertSend")):
-            self.logger.warning(
-                f"email handler not initialized because this is not a ContinuousMonitorAlertSend subclass"
-            )
-        else:
-            self._elog.setup_email_handler(email_msg=self.email,
-                                           logger_admins=self.__class__.ADMIN_EMAIL_LOGGER)
-            self.email = self.initialize_new_email()
-            self.logger.info("email handler initialized, initialized a new email object for use by monitor")
+        try:
+            if self.dev_mode:
+                self.logger.warning("email handler disabled for dev mode")
+            elif (not type(self).__name__ == "ContinuousMonitorAlertSend"
+                  and not is_instance_of_dynamic(self, "__main__.ContinuousMonitorAlertSend")):
+                self.logger.warning(
+                    f"email handler not initialized because this is not a ContinuousMonitorAlertSend subclass"
+                )
+            else:
+                self.logger_class.setup_email_handler(email_msg=self.email,
+                                                      logger_admins=self.__class__.ADMIN_EMAIL_LOGGER)
+                self.email = self.initialize_new_email()
+                self.logger.info("email handler initialized, initialized a new email object for use by monitor")
+        except AttributeError as e:
+            self.logger.error(f"email handler not initialized because {e}")
+            pass
 
     def _print_and_postprocess(self, alert_level):
         """

{pyemailerajm-1.8.4 → pyemailerajm-1.9}/PyEmailerAJM/continuous_monitor/continuous_monitor.py

@@ -9,6 +9,8 @@ from PyEmailerAJM.msg import MsgFactory
 class ContinuousMonitor(ContinuousMonitorBase):
     TITLE_STRING = " Watching for emails with alerts in {} folder ".center(100, '*')
     MSG_FACTORY_CLASS: MsgFactory = MsgFactory
+    ALERT_CHECK_STR = "Checking for emails with an alert..."
+    NO_ALERTS_STR = "No emails with an alert detected in {read_folder} ({num_snoozed} snoozed)."
 
     def GetMessages(self, folder_index=None):
         """
@@ -18,7 +20,9 @@ class ContinuousMonitor(ContinuousMonitorBase):
         :rtype: list
         """
         msgs = super().GetMessages(folder_index)
-        sorted_msgs = [self.__class__.MSG_FACTORY_CLASS.get_msg(x, logger=self.logger, snooze_checker=self.snooze_tracker) for x in msgs]
+        sorted_msgs = [
+            self.__class__.MSG_FACTORY_CLASS.get_msg(x, logger=self.logger, snooze_checker=self.snooze_tracker) for x in
+            msgs]
         alert_messages = [x for x in sorted_msgs if x is not None and x.msg_alert]
         return alert_messages
 
@@ -37,7 +41,8 @@ class ContinuousMonitor(ContinuousMonitorBase):
     def _postprocess_alert(self, alert_level=None, **kwargs):
         ...
 
-    def check_for_alerts(self):
+    # TODO: make no_alerts_string property so there is more flexibility with format
+    def check_for_alerts(self, **kwargs):
         """
         Checks for emails in the specified folder and identifies if there are any alerts. Alerts,
         if present, are categorized as overdue, warning, or critical warning, and are processed accordingly.
@@ -47,8 +52,10 @@ class ContinuousMonitor(ContinuousMonitorBase):
         :rtype: None
 
         """
-        self.logger.info("\nChecking for emails with an alert...", print_msg=True)
+        alert_check_string = kwargs.get('alert_check_string', self.__class__.ALERT_CHECK_STR)
+        self.logger.info(alert_check_string, print_msg=True)
         self.refresh_messages()
+
         if self.has_overdue:
             self._print_and_postprocess(AlertTypes.OVERDUE)
 
@@ -59,7 +66,10 @@ class ContinuousMonitor(ContinuousMonitorBase):
             self._print_and_postprocess(AlertTypes.CRITICAL_WARNING)
 
         else:
-            self.logger.info(f"No emails with an alert detected in {self.read_folder}", print_msg=True)
+            no_alert_str = kwargs.get('no_alert_string',
+                                      self.__class__.NO_ALERTS_STR.format(read_folder=self.read_folder,
+                                                                          num_snoozed=self.num_snoozed_msgs))
+            self.logger.info(no_alert_str, print_msg=True)
 
         self.snooze_tracker.snooze_msgs(self.all_messages)
 

{pyemailerajm-1.8.4 → pyemailerajm-1.9}/PyEmailerAJM/continuous_monitor/continuous_monitor_alert_send.py

@@ -1,6 +1,11 @@
 from typing import Optional
 
 from PyEmailerAJM.continuous_monitor import ContinuousMonitor
+from PyEmailerAJM.backend import EmailMsgImportanceLevel
+
+# This is installed as part of pywin32
+# noinspection PyUnresolvedReferences
+from pythoncom import com_error
 
 NO_COLORIZER = False
 
@@ -14,6 +19,8 @@ class ContinuousMonitorAlertSend(ContinuousMonitor):
                         "Thanks,\n"
                         "{email_sender}")
     ATTRS_TO_CHECK = ['ADMIN_EMAIL', 'ADMIN_EMAIL_LOGGER']
+    ALERT_EMAIL_IMPORTANCE = EmailMsgImportanceLevel.HIGH
+    DEFAULT_EMAIL_IMPORTANCE = EmailMsgImportanceLevel.NORMAL
 
     def __init__(self, display_window: bool, send_emails: bool, **kwargs):
 
@@ -25,14 +32,11 @@ class ContinuousMonitorAlertSend(ContinuousMonitor):
             self.logger.warning(f"IS DEV MODE - NOT checking for class attributes "
                                 f"({', '.join(self.__class__.ATTRS_TO_CHECK)}) for ContinuousMonitorAlertSend")
 
-    def __init_subclass__(cls, **kwargs):
-        cls.check_for_class_attrs(cls.ATTRS_TO_CHECK)
-
     def _set_args_for_endless_watch(self):
         self.send_emails = True
         self.auto_send = True
         self.display_window = False
-        self.logger.debug("send_emails, auto_send, and display_window set to True for endless_watch()")
+        self.logger.debug("Configured endless_watch: send_emails=True, auto_send=True, display_window=False")
 
     def SetupEmail(self, recipient: Optional[str] = None, subject: str = DEFAULT_SUBJECT,
                    text: str = None, attachments: list = None, **kwargs):
@@ -102,10 +106,26 @@ class ContinuousMonitorAlertSend(ContinuousMonitor):
                                                                      ).replace('\n', '<br>')
         return formatted_full_body
 
+    def _set_email_importance(self, importance_level=None, **kwargs):
+        default_importance = kwargs.get('default_importance', self.__class__.DEFAULT_EMAIL_IMPORTANCE)
+        try:
+            if importance_level is None:
+                self.email.importance = self.__class__.ALERT_EMAIL_IMPORTANCE
+            else:
+                self.email.importance = importance_level
+        except (com_error, TypeError) as e:
+            self.logger.warning(f"Invalid Importance level ({importance_level}) for email,"
+                                f" setting to {default_importance}")
+            self.email.importance = default_importance
+            return self.email
+        return self.email
+
     def _postprocess_alert(self, alert_level=None, **kwargs):
+        self._set_email_importance(**kwargs)
         self.SendOrDisplay(**kwargs)
 
     def refresh_messages(self):
+        self.email = self.initialize_new_email()
         self.SetupEmail()
         super().refresh_messages()
 

{pyemailerajm-1.8.4 → pyemailerajm-1.9}/PyEmailerAJM/msg/alert_messages.py

@@ -1,4 +1,6 @@
 from datetime import datetime
+from pathlib import Path
+import inspect
 
 import win32com.client as win32
 # pylint: disable=import-error
@@ -7,7 +9,58 @@ from PyEmailerAJM.backend import TheSandman
 from PyEmailerAJM.backend import AlertTypes
 
 
-class _AlertMsgBase(Msg):
+class _AlertCheckMethods:
+    """
+    Provides utility methods for checking specific keywords in various parts of a message,
+    such as the subject, body, or attachment names.
+
+    This class contains several class methods designed to verify whether a candidate string,
+    message subject, body, or attachment names include any predefined alert keywords.
+
+    """
+
+    DEFAULT_ALERT_CHECK_METHOD_NAMES = ['_check_subject_for_keys',
+                                        '_check_body_for_keys',
+                                        '_check_attachment_name_for_keys']
+
+    @classmethod
+    def _validate_alert_check_methods(cls, alert_check_methods: list = None):
+        if not alert_check_methods:
+            alert_check_methods = cls.DEFAULT_ALERT_CHECK_METHOD_NAMES
+        if all([callable(getattr(cls, x)) for x in alert_check_methods]):
+            alert_check_methods = [getattr(cls, x) for x in alert_check_methods]
+        else:
+            raise AttributeError('alert_check_methods must be a list of callable objects '
+                                 'that accept a single Msg argument', name=None)
+        return alert_check_methods
+
+    @classmethod
+    def _check_string_for_keys(cls, candidate_string: str):
+        if any((x for x in getattr(cls, 'ALERT_SUBJECT_KEYWORDS')
+                if x.lower() in candidate_string.lower())):
+            return True
+        return False
+
+    @classmethod
+    def _check_subject_for_keys(cls, msg: Msg):
+        return cls._check_string_for_keys(msg.subject)
+
+    @classmethod
+    def _check_body_for_keys(cls, msg: Msg):
+        return cls._check_string_for_keys(msg.body)
+
+    @classmethod
+    def _check_attachment_name_for_keys(cls, msg: Msg):
+        for a in msg.attachments:
+            try:
+                if cls._check_string_for_keys(Path(a).resolve().stem):
+                    return True
+            except (ValueError, Exception):
+                continue
+        return False
+
+
+class _AlertMsgBase(Msg, _AlertCheckMethods):
     """
     A base class for alert message handling that inherits from ``Msg``.
     This class is designed to evaluate whether a message meets specific
@@ -74,7 +127,6 @@ class _AlertMsgBase(Msg):
 
     @classmethod
     def AlertMsgBaseCheckClsAttrs(cls):
-        # FIXME: this should go with each of the alert_msgs??
         if issubclass(cls, _AlertMsgBase):
             cls.check_for_class_attrs(cls.ATTRS_TO_CHECK)
 
@@ -89,6 +141,8 @@ class _AlertMsgBase(Msg):
         snooze_checker_entry = self.snooze_checker.read_entry(self.subject)
 
         if not snooze_checker_entry and self.msg_snoozed_time:
+            # FIXME: is this the cause of the "\snooze_tracking.py", line 102, in write_entry
+            #  TypeError: fromisoformat: argument must be str
             snooze_expired = TheSandman.is_snooze_expired(self.msg_snoozed_time)
         elif not snooze_checker_entry and not self.msg_snoozed_time:
             snooze_expired = True
@@ -177,15 +231,24 @@ class _AlertMsgBase(Msg):
         return super()._msg_is_recent(recent_days_cap=days_limit)
 
     @classmethod
-    def msg_is_alert(cls, msg: Msg):
+    def msg_is_alert(cls, msg: Msg, **kwargs):
         """
-        Checks if the message subject contains any predefined alert keywords.
-
-        :return: True if the subject contains any alert keywords, False otherwise
+        Checks whether a given message qualifies as an alert based on specific
+        validation methods.
+
+        This method iterates over a set of alert validation methods and applies
+        them to the provided message. If any of the methods validate the message
+        as an alert, the method returns True. Otherwise, it returns False.
+
+        :param msg: The message object to determine if it is an alert.
+        :type msg: Msg
+        :param kwargs: Additional parameters passed to alert validation methods.
+        :type kwargs: dict
+        :return: True if the message is an alert, False otherwise.
         :rtype: bool
         """
-        if any((x for x in getattr(cls, 'ALERT_SUBJECT_KEYWORDS')
-                if x.lower() in msg.subject.lower())):
+        alert_check_methods = [x(msg) for x in cls._validate_alert_check_methods(**kwargs)]
+        if any(alert_check_methods):
             return True
         return False
 

{pyemailerajm-1.8.4 → pyemailerajm-1.9}/PyEmailerAJM/msg/msg.py

@@ -1,4 +1,7 @@
+from typing import Union
+
 from ..backend.errs import UnrecognizedEmailError
+from ..backend.enums import EmailMsgImportanceLevel
 from abc import abstractmethod
 from os.path import isfile, isabs, abspath, join
 from tempfile import gettempdir
@@ -9,7 +12,7 @@ from pywintypes import com_error
 import datetime
 import extract_msg
 from bs4 import BeautifulSoup
-from logging import Logger, getLogger, warning, info
+from logging import Logger, getLogger, info
 
 
 class _BasicMsgProperties:
@@ -46,6 +49,7 @@ class _BasicMsgProperties:
     def to(self):
         return self.email_item.To if hasattr(self.email_item, 'To') else self.email_item.to
 
+    @property
     def cc(self):
         return self.email_item.CC if hasattr(self.email_item, 'CC') else self.email_item.cc
 
@@ -70,6 +74,23 @@ class _BasicMsgProperties:
     def attachments(self, value: list):
         self._validate_and_add_attachments(self.email_item, value)
 
+    @property
+    def importance(self):
+        return self.email_item.Importance
+
+    @importance.setter
+    def importance(self, value: Union[EmailMsgImportanceLevel, str, int]):
+        if value in EmailMsgImportanceLevel or value in [x.name for x in EmailMsgImportanceLevel]:
+            if isinstance(value, str):
+                value = EmailMsgImportanceLevel[value].value
+            elif isinstance(value, EmailMsgImportanceLevel):
+                value = value.value
+            elif isinstance(value, int):
+                pass
+            self.email_item.Importance = value
+        else:
+            raise TypeError(f"Invalid importance level: {value}")
+
 
 class Msg(_BasicMsgProperties):
     def __init__(self, email_item: win32.CDispatch or extract_msg.Message, **kwargs):

{pyemailerajm-1.8.4 → pyemailerajm-1.9}/PyEmailerAJM/py_emailer_ajm.py

@@ -15,7 +15,7 @@ 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, getLogger
+from logging import Logger, StreamHandler
 from email_validator import validate_email, EmailNotValidError
 import questionary
 # this is usually thrown when questionary is used in the dev/Non Win32 environment
@@ -26,7 +26,7 @@ from PyEmailerAJM import (EmailerNotSetupError, DisplayManualQuit,
                           deprecated,
                           Msg, FailedMsg)
 from PyEmailerAJM.backend import BasicEmailFolderChoices, PyEmailerLogger
-from PyEmailerAJM.searchers import SubjectSearcher
+from PyEmailerAJM.searchers import SearcherFactory
 
 
 class EmailerInitializer:
@@ -47,11 +47,7 @@ class EmailerInitializer:
                  auto_send: bool = False,
                  email_app_name: str = DEFAULT_EMAIL_APP_NAME,
                  namespace_name: str = DEFAULT_NAMESPACE_NAME, **kwargs):
-        if logger:
-            self.logger = logger
-        else:
-            self._elog = PyEmailerLogger(**kwargs)
-            self.logger = self._elog()
+        self.logger, self.logger_class = self.initialize_emailer_logger(logger, **kwargs)
         # print("Dummy logger in use!")
 
         self.email_app_name = email_app_name
@@ -63,6 +59,26 @@ class EmailerInitializer:
         self.auto_send = auto_send
         self.send_emails = send_emails
 
+    def initialize_emailer_logger(self, logger: Logger = None, **kwargs):
+        if logger:
+            # If a real logger instance was provided (has .info), use it directly
+            if hasattr(logger, 'info') and hasattr(logger, 'warning'):
+                self.logger = logger
+                self.logger_class = logger.__class__
+            # If a callable/factory was provided, call it to get the logger instance
+            elif callable(logger):
+                self.logger_class = logger
+                self.logger = self.logger_class()
+            else:
+                # Fallback: treat as an instance but avoid calling missing methods here
+                self.logger = logger
+                # Derive a class reference best-effort
+                self.logger_class = getattr(logger, '__class__', type(logger))
+        else:
+            self.logger_class = PyEmailerLogger(**kwargs)
+            self.logger = self.logger_class()
+        return self.logger, self.logger_class
+
     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)
@@ -88,7 +104,7 @@ class EmailerInitializer:
         return self.email_app, self.namespace
 
 
-class PyEmailer(EmailerInitializer, SubjectSearcher):
+class PyEmailer(EmailerInitializer):
     """
     The `PyEmailer` class is designed for managing and handling email-related operations.
     It initializes email client settings, manages email folders, handles email messages,
@@ -138,7 +154,9 @@ class PyEmailer(EmailerInitializer, SubjectSearcher):
                  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)
+        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
 
@@ -147,6 +165,11 @@ class PyEmailer(EmailerInitializer, SubjectSearcher):
         self._email_signature = None
         self._send_success = False
         self.email_sig_filename = email_sig_filename
+        self.searcher = SearcherFactory().get_searcher(search_type=kwargs.pop('search_type', 'subject'),
+                                                       get_messages=kwargs.pop('get_messages', self.GetMessages),
+                                                       logger=self.logger,
+                                                       **kwargs)
+        self.logger.info(f"searcher {self.searcher.__class__.__name__} initialized.")
 
     @property
     def current_user_email(self):
@@ -169,6 +192,30 @@ class PyEmailer(EmailerInitializer, SubjectSearcher):
     def email_signature(self):
         return self._email_signature
 
+    def _read_email_sig_file(self, sig_full_path: str):
+        """
+        Reads the content of an email signature file from the specified path. The method
+        attempts to decode the file using multiple encodings to ensure compatibility
+        with common formats, particularly those used by Outlook for .txt signature files.
+
+        :param sig_full_path: Path to the email signature file to be read.
+        :type sig_full_path: str
+        :return: Content of the email signature if successfully read; otherwise, None.
+        :rtype: Optional[str]
+        """
+        # Try common encodings for Outlook signature .txt files
+        try:
+            with open(sig_full_path, 'r', encoding='utf-16') as f:
+                return f.read().strip()
+        except UnicodeError:
+            # Fallback to UTF-8 with BOM or plain UTF-8
+            try:
+                with open(sig_full_path, 'r', encoding='utf-8-sig') as f:
+                    return f.read().strip()
+            except Exception as e:
+                self.logger.warning(e)
+                return None
+
     @email_signature.getter
     def email_signature(self):
         if self.email_sig_filename:
@@ -183,8 +230,7 @@ class PyEmailer(EmailerInitializer, SubjectSearcher):
                     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()
+                self._email_signature = self._read_email_sig_file(signature_full_path)
             else:
                 try:
                     raise FileNotFoundError(f"{signature_full_path} does not exist.")
@@ -226,7 +272,7 @@ class PyEmailer(EmailerInitializer, SubjectSearcher):
                 else:
                     print("Please respond with 'y' or 'n'.")
 
-    def display_tracker_check(self) -> bool:
+    def display_tracker_check(self) -> bool | None:
         if self.display_window:
             c = self._display_tracking_warning_confirm()
             if c:
@@ -237,6 +283,7 @@ class PyEmailer(EmailerInitializer, SubjectSearcher):
                 except DisplayManualQuit as e:
                     self.logger.error(e, exc_info=True)
                     raise e
+        return None
 
     def _get_default_folder_for_email_dir(self, email_dir_index: int = None, **kwargs):
         # 6 = inbox
@@ -265,7 +312,7 @@ class PyEmailer(EmailerInitializer, SubjectSearcher):
             self.logger.debug(f">>> email_dir_index not specified, defaulting to '{email_dir_index}' folder. <<<")
         if not isinstance(email_dir_index, int):
             self.logger.debug(f">>> email_dir_index is not an int, "
-                               f"defaulting to {email_dir_index} folder and {subfolder_name} subfolder. <<<")
+                              f"defaulting to {email_dir_index} folder and {subfolder_name} subfolder. <<<")
             return self.namespace.Folders[email_dir_index].Folders[subfolder_name]
 
         else:
@@ -284,6 +331,7 @@ class PyEmailer(EmailerInitializer, SubjectSearcher):
             except TypeError as e:
                 self.logger.error(e, exc_info=True)
                 raise e
+        # noinspection PyUnresolvedReferences
         return [Msg(m, logger=self.logger) for m in self.read_folder.Items]
 
     @deprecated("use Msg classes body attribute instead")
@@ -299,12 +347,13 @@ class PyEmailer(EmailerInitializer, SubjectSearcher):
                 self.logger.error(e, exc_info=True)
                 raise e
 
+    # FIXME: this should be rewritten to use the searcher factory etc
     @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)
+        return self.searcher.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
@@ -426,37 +475,25 @@ class PyEmailer(EmailerInitializer, SubjectSearcher):
         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])):
+                                                      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=False)
-    m = em.find_messages_by_subject('Andrew', partial_match_ok=True)
-    print([type(x) for x in m])
+    em = PyEmailer(display_window=False, send_emails=True, auto_send=False, use_default_logger=False,
+                   show_warning_logs_in_console=True)
+    m = em.searcher.find_messages_by_attribute('Andrew', partial_match_ok=True, no_fastpath_search=True)
+    print([(m.__class__, m.sender, m.sender_email_type, m.subject)
+           for m in [Msg(y) for y in m]])
     # __setup_and_send_test(em)
     # __failed_sends_test(em)
-    x = em.find_messages_by_subject("GIS Request", partial_match_ok=True)
+    x = em.searcher.find_messages_by_attribute("Exchange St. Site",
+                                               no_fastpath_search=True,
+                                               partial_match_ok=True)
+    print(type(x[0]))
     # [x.name for x in m.ItemProperties]
     print([(m.__class__, m.sender, m.sender_email_type, m.subject)
            for m in [Msg(y) for y in x]])  # for m in x])