PyEmailerAJM 1.6.1__tar.gz → 1.8__tar.gz

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

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: PyEmailerAJM
-Version: 1.6.1
+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.6.1.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.6.1 → pyemailerajm-1.8}/PyEmailerAJM/py_emailer_ajm.py

@@ -5,11 +5,9 @@ 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
@@ -17,17 +15,18 @@ 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
 # 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
+from PyEmailerAJM import (EmailerNotSetupError, DisplayManualQuit,
+                          deprecated,
+                          Msg, FailedMsg)
+from PyEmailerAJM.backend import BasicEmailFolderChoices, PyEmailerLogger
+from PyEmailerAJM.searchers import SubjectSearcher
 
 
 class EmailerInitializer:
@@ -39,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
@@ -52,53 +54,9 @@ class EmailerInitializer:
         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)
+            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,88 +65,21 @@ 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
 
 
-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):
+class PyEmailer(EmailerInitializer, SubjectSearcher):
     # the email tab_char
     tab_char = ' '
     signature_dir_path = join((environ['USERPROFILE']),
@@ -227,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
 
@@ -245,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):
@@ -255,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
 
@@ -279,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
@@ -300,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)
@@ -312,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)
@@ -326,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):
@@ -340,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")
@@ -356,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
 
@@ -375,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\'")
@@ -411,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:
@@ -433,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
@@ -456,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)
@@ -469,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
 
 
@@ -495,13 +408,15 @@ 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)
-    m = em.find_messages_by_subject('Andrew', partial_match_ok=True, include_re=True, include_fw=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)
     # __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])
+    x = em.find_messages_by_subject("GIS Request", partial_match_ok=True)
+    # [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])
     # property_accessor = x[0].PropertyAccessor
     # print(x[0].Sender.GetExchangeUser().PrimarySmtpAddress)
     # print(property_accessor.GetProperty("PR_EMAIL_ADDRESS"))

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

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: PyEmailerAJM
-Version: 1.6.1
+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.6.1.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.6.1 → pyemailerajm-1.8}/PyEmailerAJM.egg-info/SOURCES.txt

@@ -4,13 +4,12 @@ setup.cfg
 setup.py
 PyEmailerAJM/__init__.py
 PyEmailerAJM/_version.py
-PyEmailerAJM/errs.py
-PyEmailerAJM/helpers.py
-PyEmailerAJM/msg.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.6.1 → pyemailerajm-1.8}/PyEmailerAJM.egg-info/requires.txt

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

{pyemailerajm-1.6.1 → 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.6.1 → 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.6.1/PyEmailerAJM/__init__.py

@@ -1,8 +0,0 @@
-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-1.6.1/PyEmailerAJM/_version.py

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

pyemailerajm-1.6.1/PyEmailerAJM/errs.py

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

pyemailerajm-1.6.1/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

pyemailerajm-1.6.1/PyEmailerAJM/msg.py

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