PyEmailerAJM 1.7__tar.gz → 1.8__tar.gz

{pyemailerajm-1.7 → pyemailerajm-1.8}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: PyEmailerAJM
-Version: 1.7
+Version: 1.8
 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.7.tar.gz
+Download-URL: https://github.com/amcsparron2793-Water/PyEmailer/archive/refs/tags/1.8.tar.gz
 Author: Amcsparron
 Author-email: amcsparron@albanyny.gov
 License: MIT License
@@ -13,6 +13,8 @@ Requires-Dist: pywin32
 Requires-Dist: extract_msg
 Requires-Dist: email_validator
 Requires-Dist: questionary
+Requires-Dist: EasyLoggerAJM
+Requires-Dist: ColorizerAJM
 Dynamic: author
 Dynamic: author-email
 Dynamic: download-url

pyemailerajm-1.8/PyEmailerAJM/__init__.py

@@ -0,0 +1,33 @@
+from pathlib import Path
+from importlib import import_module
+# TODO: add these to other projects? and or EasyLogger?
+__project_root__ = Path(__file__).parent.parent
+__project_name__ = __project_root__.name
+print(f'logs for {__project_name__} found in {__project_root__ / "logs"}')
+
+
+def is_instance_of_dynamic(obj: object, base_class_path: str) -> bool:
+    """
+    Check if an object is an instance of a class or its subclass specified by its module path.
+    """
+    try:
+        module_path, class_name = base_class_path.rsplit('.', 1)
+        module = import_module(module_path)
+        base_class = getattr(module, class_name)
+        return isinstance(obj, base_class)
+    except (ImportError, AttributeError):
+        return False
+
+
+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.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',
+           '__project_root__', '__project_name__', 'is_instance_of_dynamic']
+

pyemailerajm-1.8/PyEmailerAJM/_version.py

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

{pyemailerajm-1.7 → pyemailerajm-1.8}/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
+from logging import Logger, basicConfig, StreamHandler, FileHandler, getLogger
 from email_validator import validate_email, EmailNotValidError
 import questionary
 # this is usually thrown when questionary is used in the dev/Non Win32 environment
@@ -25,7 +25,7 @@ from prompt_toolkit.output.win32 import NoConsoleScreenBufferError
 from PyEmailerAJM import (EmailerNotSetupError, DisplayManualQuit,
                           deprecated,
                           Msg, FailedMsg)
-from PyEmailerAJM.backend import BasicEmailFolderChoices
+from PyEmailerAJM.backend import BasicEmailFolderChoices, PyEmailerLogger
 from PyEmailerAJM.searchers import SubjectSearcher
 
 
@@ -38,8 +38,11 @@ class EmailerInitializer:
                  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))
+        if logger:
+            self.logger = logger
+        else:
+            self._elog = PyEmailerLogger(**kwargs)
+            self.logger = self._elog()
         # print("Dummy logger in use!")
 
         self.email_app_name = email_app_name
@@ -51,54 +54,9 @@ class EmailerInitializer:
         self.auto_send = auto_send
         self.send_emails = send_emails
 
-    # TODO: replace me with EasyLoggerAJM
-    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)
+            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")
 
@@ -107,17 +65,17 @@ class EmailerInitializer:
             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)
+            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.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.")
+        self.logger.debug(f"{self.namespace_name} namespace in use.")
         return self.email_app, self.namespace
 
 
@@ -160,7 +118,7 @@ class PyEmailer(EmailerInitializer, SubjectSearcher):
             if validate_email(value, check_deliverability=False):
                 self._current_user_email = value
         except EmailNotValidError as e:
-            self._logger.error(e, exc_info=True)
+            self.logger.error(e, exc_info=True)
             value = None
         self._current_user_email = value
 
@@ -178,7 +136,7 @@ class PyEmailer(EmailerInitializer, SubjectSearcher):
                 try:
                     raise NotADirectoryError(f"{self.signature_dir_path} does not exist.")
                 except NotADirectoryError as e:
-                    self._logger.warning(e)
+                    self.logger.warning(e)
                     self._email_signature = None
 
             if isfile(signature_full_path):
@@ -188,10 +146,11 @@ class PyEmailer(EmailerInitializer, SubjectSearcher):
                 try:
                     raise FileNotFoundError(f"{signature_full_path} does not exist.")
                 except FileNotFoundError as e:
-                    self._logger.warning(e)
+                    self.logger.warning(e)
                     self._email_signature = None
         else:
             self._email_signature = None
+            self.logger.info("email_sig_filename not specified, no email signature will be attached.")
 
         return self._email_signature
 
@@ -212,12 +171,12 @@ class PyEmailer(EmailerInitializer, SubjectSearcher):
         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.")
+            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)
+                    self.logger.warning(self.DisplayEmailSendTrackingWarning)
                     return True
                 elif q == 'n':
                     return False
@@ -233,10 +192,10 @@ class PyEmailer(EmailerInitializer, SubjectSearcher):
                 try:
                     raise DisplayManualQuit("User cancelled operation due to DisplayTrackingWarning.")
                 except DisplayManualQuit as e:
-                    self._logger.error(e, exc_info=True)
+                    self.logger.error(e, exc_info=True)
                     raise e
 
-    def _GetReadFolder(self, email_dir_index: int = BasicEmailFolderChoices.INBOX):
+    def _get_default_folder_for_email_dir(self, email_dir_index: int = None, **kwargs):
         # 6 = inbox
         if email_dir_index in self.__class__.VALID_EMAIL_FOLDER_CHOICES:
             self.read_folder = self.namespace.GetDefaultFolder(email_dir_index)
@@ -245,9 +204,30 @@ class PyEmailer(EmailerInitializer, SubjectSearcher):
             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)
+                self.logger.error(e, exc_info=True)
                 raise e
 
+    def _GetReadFolder(self, email_dir_index: int = None, **kwargs):
+        """
+        :param email_dir_index: Specifies the email directory index to be accessed. Defaults to None.
+        :type email_dir_index: int, optional
+        :param kwargs: Additional optional arguments that may be passed. Can include `subfolder_name` to specify a subfolder name, defaulting to 'Inbox'.
+        :type kwargs: dict
+        :return: The folder specified either by the email directory index or the default folder along with the subfolder if applicable.
+        :rtype: object
+        """
+        subfolder_name = kwargs.get('subfolder_name', 'Inbox')
+        if not email_dir_index:
+            email_dir_index = BasicEmailFolderChoices.INBOX
+            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. <<<")
+            return self.namespace.Folders[email_dir_index].Folders[subfolder_name]
+
+        else:
+            return self._get_default_folder_for_email_dir(email_dir_index)
+
     def GetMessages(self, folder_index=None):
         if isinstance(folder_index, int):
             self.read_folder = self._GetReadFolder(folder_index)
@@ -259,9 +239,9 @@ class PyEmailer(EmailerInitializer, SubjectSearcher):
             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)
+                self.logger.error(e, exc_info=True)
                 raise e
-        return [Msg(m, logger=self._logger) for m in self.read_folder.Items]
+        return [Msg(m, logger=self.logger) for m in self.read_folder.Items]
 
     @deprecated("use Msg classes body attribute instead")
     def GetEmailMessageBody(self, msg):
@@ -273,7 +253,7 @@ class PyEmailer(EmailerInitializer, SubjectSearcher):
             try:
                 raise ValueError("This message has no body.")
             except ValueError as e:
-                self._logger.error(e, exc_info=True)
+                self.logger.error(e, exc_info=True)
                 raise e
 
     @deprecated("use find_messages_by_subject instead")
@@ -289,15 +269,15 @@ class PyEmailer(EmailerInitializer, SubjectSearcher):
             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}")
+                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)
+                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)
+                                         logger=self.logger, **kwargs)
         self._setup_was_run = True
         return self.email
 
@@ -308,34 +288,34 @@ class PyEmailer(EmailerInitializer, SubjectSearcher):
                 self.email.send()
                 return
             elif not send:
-                self._logger.info(f"Mail not sent to {self.email.to}")
+                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.")
+                    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)
+            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...")
+            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}")
+                    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.")
+                    self.logger.warning("Quitting early due to user input.")
                     exit(-1)
                 else:
                     print("Please choose \'y\', \'n\' or \'q\'")
@@ -344,18 +324,18 @@ class PyEmailer(EmailerInitializer, SubjectSearcher):
         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}...")
+            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.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.logger.info("Sending emails with auto_send...")
                     self.email.send()
 
                 else:
@@ -366,13 +346,13 @@ class PyEmailer(EmailerInitializer, SubjectSearcher):
             else:
                 both_disabled_warning = ("Both sending and displaying the email are disabled. "
                                          "No errors were encountered.")
-                self._logger.warning(both_disabled_warning)
+                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)
+                self.logger.error(e, exc_info=True)
                 raise e
 
     @staticmethod
@@ -389,8 +369,8 @@ class PyEmailer(EmailerInitializer, SubjectSearcher):
 
         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.")
+            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)
@@ -402,10 +382,10 @@ class PyEmailer(EmailerInitializer, SubjectSearcher):
                                          '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])):
+        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)
+        self.logger.info(results_string)
         return failed_sends
 
 
@@ -428,7 +408,7 @@ def __setup_and_send_test(emailer):
 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)
+    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])
     # __setup_and_send_test(em)

{pyemailerajm-1.7 → pyemailerajm-1.8}/PyEmailerAJM.egg-info/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: PyEmailerAJM
-Version: 1.7
+Version: 1.8
 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.7.tar.gz
+Download-URL: https://github.com/amcsparron2793-Water/PyEmailer/archive/refs/tags/1.8.tar.gz
 Author: Amcsparron
 Author-email: amcsparron@albanyny.gov
 License: MIT License
@@ -13,6 +13,8 @@ Requires-Dist: pywin32
 Requires-Dist: extract_msg
 Requires-Dist: email_validator
 Requires-Dist: questionary
+Requires-Dist: EasyLoggerAJM
+Requires-Dist: ColorizerAJM
 Dynamic: author
 Dynamic: author-email
 Dynamic: download-url

{pyemailerajm-1.7 → pyemailerajm-1.8}/PyEmailerAJM.egg-info/SOURCES.txt

@@ -4,11 +4,12 @@ setup.cfg
 setup.py
 PyEmailerAJM/__init__.py
 PyEmailerAJM/_version.py
-PyEmailerAJM/helpers.py
 PyEmailerAJM/py_emailer_ajm.py
 PyEmailerAJM.egg-info/PKG-INFO
 PyEmailerAJM.egg-info/SOURCES.txt
 PyEmailerAJM.egg-info/dependency_links.txt
 PyEmailerAJM.egg-info/requires.txt
 PyEmailerAJM.egg-info/top_level.txt
-tests/test_PyEmailerAJM.py
+tests/test_PyEmailerAJM.py
+tests/test_logger.py
+tests/test_snooze_tracking.py

{pyemailerajm-1.7 → pyemailerajm-1.8}/PyEmailerAJM.egg-info/requires.txt

@@ -2,3 +2,5 @@ pywin32
 extract_msg
 email_validator
 questionary
+EasyLoggerAJM
+ColorizerAJM

{pyemailerajm-1.7 → pyemailerajm-1.8}/setup.py

@@ -17,7 +17,7 @@ setup(
     url='https://github.com/amcsparron2793-Water/PyEmailer',
     download_url=f'https://github.com/amcsparron2793-Water/PyEmailer/archive/refs/tags/{get_property("__version__", project_name)}.tar.gz',
     keywords=["Outlook", "Email", "Automation"],
-    install_requires=['pywin32', 'extract_msg', 'email_validator', 'questionary'],
+    install_requires=['pywin32', 'extract_msg', 'email_validator', 'questionary','EasyLoggerAJM', 'ColorizerAJM'],
     license='MIT License',
     author='Amcsparron',
     author_email='amcsparron@albanyny.gov',

{pyemailerajm-1.7 → pyemailerajm-1.8}/tests/test_PyEmailerAJM.py

@@ -7,8 +7,10 @@ from PyEmailerAJM import PyEmailer, Msg
 
 class TestPyEmailer(unittest.TestCase):
     TEST_ATTACHMENT_NAMES = ['attachment1', 'attachment2']
+    TEST_ADMIN_EMAIL = ['example@example.com']
 
     def setUp(self):
+        PyEmailer.ADMIN_EMAIL = TestPyEmailer.TEST_ADMIN_EMAIL
         self.emailer = PyEmailer(False, False)
 
     @classmethod

pyemailerajm-1.8/tests/test_logger.py

@@ -0,0 +1,83 @@
+import unittest
+from unittest.mock import patch, MagicMock
+import logging
+
+from PyEmailerAJM.backend.logger import PyEmailerLogger
+
+
+# FIXME: some of these tests are flakey
+class TestPyEmailerLogger(unittest.TestCase):
+    def setUp(self) -> None:
+        self.logger = PyEmailerLogger()
+
+    def test_call(self):
+        self.assertIs(self.logger(), self.logger.logger)
+
+    @patch('PyEmailerAJM.backend.logger.DupeDebugFilter')
+    def test_add_dupe_debug_to_handler(self, mock_dupe_debug_filter):
+        handler = MagicMock()
+
+        # FIX: Ensure handler.level is an integer
+        handler.level = logging.WARNING  # Set a valid logging level
+
+        self.logger._add_dupe_debug_to_handler(handler)
+        mock_dupe_debug_filter.assert_called_once()
+        handler.addFilter.assert_called_once_with(mock_dupe_debug_filter.return_value)
+
+    @unittest.skip("Skipping this test because it's under development")
+    def test_set_logger_class(self):
+        result = self.logger._set_logger_class()
+        self.assertIs(result, self.logger)
+
+    @patch('PyEmailerAJM.backend.logger.Logger')
+    def test_initialize_logger(self, mock_logger):
+        self.logger.initialize_logger(logger=mock_logger)
+        self.assertFalse(mock_logger.propagate)
+
+    @patch('PyEmailerAJM.backend.logger.OutlookEmailHandler')
+    def test_setup_email_handler(self, mock_email_handler):
+        mock_email_handler_instance = mock_email_handler.return_value
+        mock_email_handler_instance.level = logging.ERROR
+
+        with patch.object(self.logger.logger, 'addHandler', autospec=True) as mock_add_handler:
+            self.logger.setup_email_handler(email_msg='Test email', logger_admins=['admin1@gmail.com'])
+
+            self.assertEqual(mock_email_handler_instance.level, logging.ERROR)
+            mock_email_handler.assert_called_once_with(
+                email_msg='Test email',
+                project_name=self.logger.project_name,
+                logger_dir_path=self.logger.log_location,
+                recipient=['admin1@gmail.com']
+            )
+            mock_email_handler_instance.setLevel.assert_called_once_with(logging.ERROR)
+            mock_email_handler_instance.setFormatter.assert_called_once_with(
+                self.logger.formatter)
+            mock_add_handler.assert_called_once_with(mock_email_handler_instance)
+
+    @patch('PyEmailerAJM.backend.logger.FileHandler')
+    def test_add_filter_to_file_handler(self, mock_file_handler):
+        mock_file_handler.level = logging.INFO  # FIX: Set a valid level
+        self.logger._add_filter_to_file_handler(mock_file_handler)
+        mock_file_handler.addFilter.assert_called_once()
+
+    @patch('PyEmailerAJM.backend.logger.StreamHandler')
+    def test_add_filter_to_stream_handler(self, mock_stream_handler):
+        mock_stream_handler.level = logging.DEBUG  # FIX: Set a valid level
+        self.logger._add_filter_to_stream_handler(mock_stream_handler)
+        mock_stream_handler.addFilter.assert_called_once()
+
+    def test_project_name_getter(self):
+        self.assertEqual(self.logger.project_name, self.logger.project_name)
+
+    def test_project_name_setter(self):
+        self.logger.project_name = 'NewProject'
+        self.assertEqual(self.logger.project_name, 'NewProject')
+
+    @patch('PyEmailerAJM.backend.logger.StreamHandlerIgnoreExecInfo')
+    def test_create_stream_handler(self, mock_stream_handler):
+        self.logger.create_stream_handler(log_level_to_stream=logging.WARNING)
+        mock_stream_handler.assert_called_once()
+
+
+if __name__ == '__main__':
+    unittest.main()

pyemailerajm-1.8/tests/test_snooze_tracking.py

@@ -0,0 +1,93 @@
+import logging
+import unittest
+from datetime import datetime, timedelta
+from pathlib import Path
+from unittest.mock import patch, Mock
+
+from PyEmailerAJM.continuous_monitor.backend import SnoozeTracking
+
+
+class TestSnoozeTracking(unittest.TestCase):
+    TEST_JSON_PATH = Path("./test.json")
+
+    def setUp(self):
+        self.file_path = self.__class__.TEST_JSON_PATH
+
+        self.logger = logging.getLogger('test_logger')
+        self.subject = "Test Email Subject"
+        self.snooze_time = datetime.now() + timedelta(days=2)
+        self.email_entries = {
+            self.subject: self.snooze_time.isoformat()
+        }
+
+        self.snooze_tracking = SnoozeTracking(self.file_path, logger=self.logger)
+
+    @classmethod
+    def tearDownClass(cls):
+        cls.TEST_JSON_PATH.unlink()
+
+    @unittest.skip("this test only works if the file "
+                   "is NOT deleted by tearDownClass, "
+                   "then the test is run again")
+    @patch('json.load')
+    @patch('builtins.open')
+    def test_json_loaded(self, mock_open, mock_json_load):
+        mock_json_load.return_value = self.email_entries
+        loaded_json = self.snooze_tracking.json_loaded
+        mock_open.assert_called_once_with(self.file_path, 'r')
+        self.assertEqual(loaded_json, self.email_entries, 'Should load JSON data from file')
+
+    @patch('json.load')
+    @patch('builtins.open')
+    def test_write_entry(self, mock_open, mock_json_load):
+        mock_json_load.return_value = {}
+        new_snooze_time = datetime.now() + timedelta(days=3)
+        self.snooze_tracking.write_entry(self.subject, new_snooze_time)
+        self.assertEqual(self.snooze_tracking.json_loaded[self.subject], new_snooze_time,
+                         'Should write entry to json_loaded')
+
+    def test_convert_datetime(self):
+        non_dt_val = "non_datetime_value"
+        dt_val = datetime.now()
+        self.assertEqual(self.snooze_tracking._convert_datetime(non_dt_val), non_dt_val,
+                         'Non datetime value should remain unchanged')
+        self.assertEqual(self.snooze_tracking._convert_datetime(dt_val), dt_val.isoformat(),
+                         'Datetime value should be iso formatted')
+
+    @patch('json.dump')
+    @patch('builtins.open')
+    def test_save_json(self, mock_open, mock_json_dump):
+        with patch.object(self.logger, 'info') as mock_info:  # Mock the logger.info method
+            self.snooze_tracking._json_loaded = self.email_entries
+            self.snooze_tracking.save_json()
+
+            # Use the mocked `info` method with assert_called.
+            mock_info.assert_called_with(f"json saved to {self.file_path}")
+
+            mock_open.assert_called_once_with(self.file_path, 'w')
+            mock_json_dump.assert_called_once()
+
+    def test_read_entry(self):
+        self.snooze_tracking._json_loaded = self.email_entries
+        output_snooze_time = self.snooze_tracking.read_entry(self.subject)
+        self.assertEqual(output_snooze_time, self.snooze_time, 'Should correctly read snooze time from json_loaded')
+
+    def test_snooze_msgs(self):
+        mock_msg_1 = Mock()
+        mock_msg_1.subject = "msg_1"
+        mock_msg_1.msg_snoozed = False
+        mock_msg_1.msg_snoozed_time = datetime.now() + timedelta(days=3)
+
+        mock_msg_2 = Mock()
+        mock_msg_2.subject = "msg_2"
+        mock_msg_2.msg_snoozed = True
+        mock_msg_2.msg_snoozed_time = datetime.now() + timedelta(days=1)
+
+        msg_list = [mock_msg_1, mock_msg_2]
+        output_msg_list = self.snooze_tracking.snooze_msgs(msg_list)
+        self.assertEqual(output_msg_list, msg_list, 'Should return the same list')
+        self.assertTrue(output_msg_list[0].msg_snoozed, 'Non-snoozed message should be marked as snoozed')
+
+
+if __name__ == "__main__":
+    unittest.main()

pyemailerajm-1.7/PyEmailerAJM/__init__.py

@@ -1,8 +0,0 @@
-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.py_emailer_ajm import PyEmailer, EmailerInitializer
-
-__all__ = ['EmailerNotSetupError', 'DisplayManualQuit', 'deprecated',
-           'Msg', 'FailedMsg', 'PyEmailer', 'EmailerInitializer']

pyemailerajm-1.7/PyEmailerAJM/_version.py

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

pyemailerajm-1.7/PyEmailerAJM/helpers.py

@@ -1,40 +0,0 @@
-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