PyEmailerAJM 1.9.3.2__tar.gz → 1.9.4__tar.gz

{pyemailerajm-1.9.3.2 → pyemailerajm-1.9.4}/PKG-INFO

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

pyemailerajm-1.9.4/PyEmailerAJM/_version.py

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

{pyemailerajm-1.9.3.2 → pyemailerajm-1.9.4}/PyEmailerAJM/backend/the_sandman.py

@@ -1,9 +1,12 @@
 from datetime import datetime
-from logging import getLogger
+from logging import getLogger, Logger
 from time import sleep
 from typing import Union, Optional
 
+from tqdm import tqdm
 
+
+# TODO: extract into separate project and make it a dependency
 class TheSandman:
     """
         A utility class to facilitate and log time delays with custom sleep durations.
@@ -25,14 +28,19 @@ class TheSandman:
     DEFAULT_SLEEP_TIME_SECONDS = 600
     DEFAULT_SNOOZE_EXPIRATION_LIMIT_HOURS = 24
     SECONDS_IN_HOUR = 3600
+    DEFAULT_USE_VISUAL_SLEEP = True
 
     def __init__(self, sleep_time_seconds=None, **kwargs):
+        self.sleep_time_start = None
+        self.use_visual_sleep = kwargs.get('use_visual_sleep', self.__class__.DEFAULT_USE_VISUAL_SLEEP)
+
         self.snooze_expiration_limit_hours = kwargs.get('snooze_expiration_limit_hours',
                                                         self.__class__.DEFAULT_SNOOZE_EXPIRATION_LIMIT_HOURS)
         self.sleep_time: int = sleep_time_seconds or self.__class__.DEFAULT_SLEEP_TIME_SECONDS
         self._is_time_remaining = False
         self._sleep_time_string = None
-        self.logger: getLogger = kwargs.get('logger', getLogger(__name__))
+
+        self.logger: Logger = kwargs.get('logger', getLogger(__name__))
         self.sleep_time_string = self.sleep_time
         self.logger.info(f'TheSandman initialized - sleep time set as {self.sleep_time_string}')
 
@@ -51,6 +59,42 @@ class TheSandman:
         else:
             self._sleep_time_string = f'sleeping for {value} {more} second(s)'
 
+        str_parts = [self._sleep_time_string, f'(started at {self.sleep_time_start})']
+        self._sleep_time_string = ' '.join(str_parts)
+
+    def _setup_sleep_in_rounds(self, **kwargs):
+        self.sleep_time_start = datetime.now().strftime('%m/%d/%Y %H:%M')
+        if self.use_visual_sleep:
+            kwargs['print_msg'] = False
+        self._is_time_remaining = False
+        return kwargs
+
+    def _sleep_round(self, curr_sleep_round: int, total_rounds: int, print_msg: bool, **kwargs):
+        if curr_sleep_round == total_rounds - 1:
+            self._is_time_remaining = True
+        sleep_time_seconds = (self.sleep_time // total_rounds)
+        self.sleep(sleep_time_seconds, print_msg=print_msg, **kwargs)
+
+    def sleep_in_rounds(self, rounds=2, **kwargs):
+        kwargs = self._setup_sleep_in_rounds(**kwargs)
+
+        for sleep_round in range(rounds):
+            self._sleep_round(sleep_round, rounds, **kwargs)
+
+    def visual_sleep(self, sleep_time_seconds: int) -> None:
+        try:
+            for _ in tqdm(range(sleep_time_seconds),
+                          desc=f"{self.sleep_time_string}",
+                          unit="second"):
+                sleep(1)
+        except Exception as e:
+            if e.__class__.__name__ != 'KeyboardInterrupt':
+                self.logger.error(f"visual_sleep failed: {e}, turning off visual sleep and trying again...")
+                self.use_visual_sleep = False
+                self.sleep(sleep_time_seconds)
+            else:
+                raise
+
     def sleep(self, sleep_time_seconds: int, **kwargs):
         """
         :param sleep_time_seconds: The number of seconds the function should pause execution.
@@ -61,23 +105,10 @@ class TheSandman:
 
         self.sleep_time_string = self.sleep_time if not self._is_time_remaining else sleep_time_seconds
         self.logger.info(self.sleep_time_string, **kwargs)
-        sleep(sleep_time_seconds)
-
-    def sleep_in_rounds(self, rounds=2, **kwargs):
-        """
-        :param rounds: Number of intervals in which the total sleep time is divided. Defaults to 2.
-        :type rounds: int
-        :return: None
-        :rtype: None
-
-        """
-        dev_mode = kwargs.pop('dev_mode', True)
-        print_msg = kwargs.pop('print_msg', True)
-        self._is_time_remaining = False
-        for sr in range(rounds):
-            if sr == rounds - 1:
-                self._is_time_remaining = True
-            self.sleep((self.sleep_time // rounds), print_msg=print_msg, **kwargs)
+        if self.use_visual_sleep:
+            self.visual_sleep(sleep_time_seconds)
+        else:
+            sleep(sleep_time_seconds)
 
     @classmethod
     def is_snooze_expired(cls, snoozed_at: datetime, snooze_expiration_limit_hours: Optional[int] = None):
@@ -89,3 +120,8 @@ class TheSandman:
             #print('msg_snoozed expired! Unsnoozing now!')
             return True
         return False
+
+
+if __name__ == '__main__':
+    ts = TheSandman(sleep_time_seconds=30)
+    ts.sleep_in_rounds(rounds=3)

{pyemailerajm-1.9.3.2 → pyemailerajm-1.9.4}/PyEmailerAJM/continuous_monitor/backend/continuous_monitor_base.py

@@ -1,6 +1,7 @@
 from abc import abstractmethod
+from os import getenv
 from pathlib import Path
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING, Optional, List
 
 from PyEmailerAJM import PyEmailer, is_instance_of_dynamic
 from PyEmailerAJM.backend import TheSandman
@@ -46,9 +47,9 @@ class ContinuousMonitorBase(PyEmailer, EmailState):
             Configures the email handler unless running in development mode. Provides appropriate logging
             based on the current mode.
     """
-    ADMIN_EMAIL_LOGGER = []
-    ADMIN_EMAIL = []
-    ATTRS_TO_CHECK = []
+    ADMIN_EMAIL_LOGGER: List[str] = []
+    ADMIN_EMAIL: List[str] = []
+    ATTRS_TO_CHECK: List[str] = []
 
     def __init__(self, display_window: bool, send_emails: bool, **kwargs):
         # Let EmailerInitializer handle logger factory vs instance normalization
@@ -182,3 +183,17 @@ class ContinuousMonitorBase(PyEmailer, EmailState):
     @abstractmethod
     def _postprocess_alert(self, alert_level: Optional['AlertTypes'] = None, **kwargs):
         ...
+
+    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.
+        :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
+        """
+        kwargs.setdefault('subfolder_name', self.__class__.DEFAULT_SUBFOLDER_NAME)
+        if not email_dir_index:
+            email_dir_index = self.__class__.DEFAULT_READ_FOLDER_NAME
+        return super()._GetReadFolder(email_dir_index, **kwargs)

pyemailerajm-1.9.4/PyEmailerAJM/continuous_monitor/backend/email_state.py

@@ -0,0 +1,153 @@
+from abc import abstractmethod, ABCMeta
+from logging import Logger
+from typing import Optional
+from enum import Enum as _Enum
+from PyEmailerAJM.backend import AlertTypes
+from PyEmailerAJM.backend import NoMessagesFetched
+
+
+class BaseEmailState(metaclass=ABCMeta):
+    """
+    Provides a base class for defining and managing the state of an email system.
+
+    This class is intended to be subclassed to define specific email state behaviors.
+    Subclasses should provide implementations for abstract methods and define the
+    required class-level variables to ensure proper functionality.
+
+    :ivar ALERT_ENUM: Enum to use for alert comparisons. Subclasses must define this.
+    :type ALERT_ENUM: Enum
+    :ivar ALERT_CRITICAL_MEMBERS: Tuple of enum member names that are critical and must exist
+        in the ALERT_ENUM. This must be defined by subclasses.
+    :type ALERT_CRITICAL_MEMBERS: tuple of str
+    """
+    # Enum to use for alert comparisons; can be overridden by subclasses
+    ALERT_ENUM = None
+    ALERT_CRITICAL_MEMBERS = ()
+
+    def __init_subclass__(cls, **kwargs):
+        super().__init_subclass__(**kwargs)
+        enum_cls = cls._validate_alert_enum()
+        cls._check_for_missing(enum_cls)
+
+    @classmethod
+    def _check_for_missing(cls, enum_cls):
+        critical_members: tuple[str, ...] = getattr(cls, 'ALERT_CRITICAL_MEMBERS', ())
+        missing = [m for m in critical_members if not hasattr(enum_cls, m)]
+        if missing:
+            raise AttributeError(
+                f"ALERT_ENUM must define members: {', '.join(critical_members)} Missing: {', '.join(missing)}"
+            )
+
+    @classmethod
+    def _validate_alert_enum(cls):
+        # Validate ALERT_ENUM is an Enum subclass and has required members
+        enum_cls = getattr(cls, 'ALERT_ENUM', None)
+        if enum_cls is None:
+            raise AttributeError("Subclasses of EmailState must define ALERT_ENUM.")
+        if not isinstance(enum_cls, type) or not issubclass(enum_cls, _Enum):
+            raise TypeError("ALERT_ENUM must be an Enum subclass.")
+        return enum_cls
+
+    def __init__(self):
+        self.logger: Optional[Logger] = None
+        self.all_messages = None
+        self._was_refreshed = False
+
+    @abstractmethod
+    def GetMessages(self):
+        """
+        Retrieve messages from the implemented source.
+
+        :return: Messages retrieved from the source
+        :rtype: list
+        """
+        ...
+
+    @abstractmethod
+    def SetupEmail(self):
+        ...
+
+    def _raise_no_messages(self):
+        """
+        Raises a NoMessagesFetched exception, indicating that the `all_messages` attribute has not been populated.
+        This suggests that the method `refresh_messages` should be executed to fetch and populate messages.
+
+        :raises NoMessagesFetched: Exception raised when no messages have been fetched.
+        """
+        raise NoMessagesFetched("all_messages has not been populated, run self.refresh_messages() first.")
+
+    def refresh_messages(self):
+        """
+        Refreshes the messages by retrieving them from the email folder.
+
+        :return: None
+        :rtype: None
+        """
+        self.logger.info("Refreshing messages from email folder...")
+        self.all_messages = self.GetMessages()
+        self._was_refreshed = True
+        self.logger.info("Successfully refreshed messages from email folder.")
+
+    def _has_alert_level(self, alert_level: _Enum) -> Optional[bool]:
+        """
+        Generic method to check if any messages in all_messages match the specified alert level.
+
+        :param alert_level: The enum member to check for.
+        :return: True if at least one message matches, False if none match, None if not refreshed.
+        """
+        if self.all_messages:
+            return any(x.__class__.ALERT_LEVEL == alert_level for x in self.all_messages)
+        if not self._was_refreshed:
+            self._raise_no_messages()
+        return False
+
+
+class EmailState(BaseEmailState, metaclass=ABCMeta):
+    """
+    Represents an abstract base class for managing the state of email alerts and their associated levels.
+
+    The class provides properties to evaluate the presence of specific alert levels (e.g., overdue, critical warnings,
+    warnings) across the managed messages. Subclasses can customize the alert handling by overriding the
+    ALERT_ENUM attribute. This class is intended to be extended for more specific implementations of email
+    state management.
+
+    :ivar ALERT_ENUM: Enum to use for alert comparisons; can be overridden by subclasses.
+    :type ALERT_ENUM: type
+    :ivar ALERT_CRITICAL_MEMBERS: A tuple consisting of alert levels considered critical.
+    :type ALERT_CRITICAL_MEMBERS: tuple[str, ...]
+    """
+
+    # Enum to use for alert comparisons; can be overridden by subclasses
+    ALERT_ENUM: AlertTypes = AlertTypes
+    ALERT_CRITICAL_MEMBERS: tuple[str, ...] = ("WARNING", "CRITICAL_WARNING", "OVERDUE")
+
+    @property
+    def has_overdue(self):
+        """
+        Checks if there are any overdue messages among all messages. A message is considered overdue if its alert level
+        matches the AlertTypes.OVERDUE constant. If no messages have been fetched and the flag _was_refreshed is False,
+        it raises an exception indicating no messages are available.
+
+        :return: True if there are overdue messages, False otherwise.
+        :rtype: bool
+        """
+        return self._has_alert_level(self.__class__.ALERT_ENUM.OVERDUE)
+
+    @property
+    def has_critical_warning(self):
+        """
+        Checks if there are any messages with a critical warning alert level.
+
+        :return: A boolean indicating whether there is at least one message with a critical warning alert level
+        :rtype: bool
+
+        """
+        return self._has_alert_level(self.__class__.ALERT_ENUM.CRITICAL_WARNING)
+
+    @property
+    def has_warning(self):
+        """
+        :return: Indicates whether there are any messages of warning level present.
+        :rtype: bool
+        """
+        return self._has_alert_level(self.__class__.ALERT_ENUM.WARNING)

{pyemailerajm-1.9.3.2 → pyemailerajm-1.9.4}/PyEmailerAJM/continuous_monitor/continuous_monitor.py

@@ -37,9 +37,21 @@ class ContinuousMonitor(ContinuousMonitorBase):
         self.auto_send = False
         self.display_window = False
 
-    @abstractmethod
     def _postprocess_alert(self, alert_level=None, **kwargs):
-        ...
+        """
+        Processes the alert after it has been generated, enabling customization or
+        additional handling based on the alert level and other contextual keyword arguments.
+
+        :param alert_level: The severity level of the alert, intended to define
+            the gravity or importance of the alert being processed.
+        :type alert_level: Optional
+        :param kwargs: Additional keyword arguments that can be provided for
+            further customization or handling during alert processing.
+        :type kwargs: dict
+        :return: The processed alert result.
+        :rtype: None
+        """
+        return
 
     def _process_no_alert(self, **kwargs):
         no_alert_str = kwargs.get('no_alert_string',

{pyemailerajm-1.9.3.2 → pyemailerajm-1.9.4}/PyEmailerAJM/continuous_monitor/continuous_monitor_alert_send.py

@@ -10,6 +10,7 @@ from pythoncom import com_error
 NO_COLORIZER = False
 
 
+# TODO: create a version that does not monitor the inbox and only sends emails when triggered
 class ContinuousMonitorAlertSend(ContinuousMonitor):
     ADMIN_EMAIL_LOGGER = []
     ADMIN_EMAIL = []

{pyemailerajm-1.9.3.2 → pyemailerajm-1.9.4}/PyEmailerAJM/py_emailer_ajm.py

@@ -5,7 +5,7 @@ py_emailer_ajm.py
 install win32 with pip install pywin32
 """
 # imports
-from os import environ
+from os import environ, getenv
 from os.path import isfile, join, isdir
 from tempfile import gettempdir
 from typing import Optional
@@ -151,6 +151,10 @@ class PyEmailer(EmailerInitializer):
     DEFAULT_TEMP_SAVE_PATH = gettempdir()
     VALID_EMAIL_FOLDER_CHOICES = [x for x in BasicEmailFolderChoices]
 
+    # TODO: validate this works
+    DEFAULT_READ_FOLDER_NAME = getenv('READ_EMAIL_FOLDER', None)
+    DEFAULT_SUBFOLDER_NAME = getenv('READ_EMAIL_SUBFOLDER', 'Inbox')
+
     def __init__(self, display_window: bool, send_emails: bool, logger: Logger = None, email_sig_filename: str = None,
                  auto_send: bool = False, email_app_name: str = EmailerInitializer.DEFAULT_EMAIL_APP_NAME,
                  namespace_name: str = EmailerInitializer.DEFAULT_NAMESPACE_NAME, **kwargs):
@@ -172,11 +176,18 @@ class PyEmailer(EmailerInitializer):
                                                        **kwargs)
         self.logger.info(f"searcher {self.searcher.__class__.__name__} initialized.")
 
+    @property
+    def current_session_exchange_user_email(self):
+        """Returns the primary SMTP address of the current user's Exchange account."""
+        session_current_user = self.namespace.Application.Session.CurrentUser
+        exchange_current_user = session_current_user.AddressEntry.GetExchangeUser()
+
+        return exchange_current_user.PrimarySmtpAddress
+
     @property
     def current_user_email(self):
         if self.email_app_name.lower().startswith('outlook'):
-            self._current_user_email = (
-                self.namespace.Application.Session.CurrentUser.AddressEntry.GetExchangeUser().PrimarySmtpAddress)
+            self._current_user_email = self.current_session_exchange_user_email
         return self._current_user_email
 
     @current_user_email.setter
@@ -307,13 +318,16 @@ class PyEmailer(EmailerInitializer):
         :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')
+        subfolder_name = kwargs.get('subfolder_name', self.__class__.DEFAULT_SUBFOLDER_NAME)
+        if not email_dir_index:
+            email_dir_index = self.__class__.DEFAULT_READ_FOLDER_NAME
+
         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. <<<")
+            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. <<<")
+            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:

{pyemailerajm-1.9.3.2 → pyemailerajm-1.9.4}/PyEmailerAJM.egg-info/PKG-INFO

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

{pyemailerajm-1.9.3.2 → pyemailerajm-1.9.4}/PyEmailerAJM.egg-info/requires.txt

@@ -4,3 +4,4 @@ email_validator
 questionary
 EasyLoggerAJM
 ColorizerAJM
+tdqm

{pyemailerajm-1.9.3.2 → pyemailerajm-1.9.4}/setup.py

@@ -20,7 +20,8 @@ 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', 'EasyLoggerAJM', 'ColorizerAJM'],
+    install_requires=['pywin32', 'extract_msg', 'email_validator', 'questionary',
+                      'EasyLoggerAJM', 'ColorizerAJM', 'tdqm'],
     license='MIT License',
     author='Amcsparron',
     author_email='amcsparron@albanyny.gov',

pyemailerajm-1.9.3.2/PyEmailerAJM/_version.py

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

pyemailerajm-1.9.3.2/PyEmailerAJM/continuous_monitor/backend/email_state.py

@@ -1,127 +0,0 @@
-from abc import abstractmethod
-from logging import Logger
-from typing import Optional
-from PyEmailerAJM.backend import AlertTypes
-from PyEmailerAJM.backend import NoMessagesFetched
-
-
-class EmailState:
-    """
-    Represents the state and behavior associated with processing email messages
-    and evaluating their alert levels (Overdue, Critical Warning, Warning).
-
-    Attributes:
-        logger: A logger object used to log messages and events during message processing.
-        all_messages: A collection of all retrieved email messages.
-        _was_refreshed: A boolean indicating whether the messages have been refreshed.
-
-    Methods:
-        __init__:
-            Initializes the EmailState instance with default values.
-
-        GetMessages:
-            An abstract method to be implemented by subclasses for retrieving email messages.
-
-        _raise_no_messages:
-            Raises a NoMessagesFetched exception if email messages have not been populated.
-
-        refresh_messages:
-            Populates the `all_messages` attribute by fetching the latest messages
-            using the `GetMessages` method and updates `_was_refreshed` to True.
-
-    Properties:
-        has_overdue:
-            Indicates if there are any messages with an alert level of Overdue.
-            Raises NoMessagesFetched if messages have not been refreshed.
-
-        has_critical_warning:
-            Indicates if there are any messages with an alert level of Critical Warning.
-            Raises NoMessagesFetched if messages have not been refreshed.
-
-        has_warning:
-            Indicates if there are any messages with an alert level of Warning.
-            Raises NoMessagesFetched if messages have not been refreshed.
-    """
-
-    def __init__(self):
-        self.logger: Optional[Logger] = None
-        self.all_messages = None
-        self._was_refreshed = False
-
-    @abstractmethod
-    def GetMessages(self):
-        """
-        Retrieve messages from the implemented source.
-
-        :return: Messages retrieved from the source
-        :rtype: list
-        """
-        ...
-
-    @abstractmethod
-    def SetupEmail(self):
-        ...
-
-    def _raise_no_messages(self):
-        """
-        Raises a NoMessagesFetched exception, indicating that the `all_messages` attribute has not been populated.
-        This suggests that the method `refresh_messages` should be executed to fetch and populate messages.
-
-        :raises NoMessagesFetched: Exception raised when no messages have been fetched.
-        """
-        raise NoMessagesFetched("all_messages has not been populated, run self.refresh_messages() first.")
-
-    def refresh_messages(self):
-        """
-        Refreshes the messages by retrieving them from the email folder.
-
-        :return: None
-        :rtype: None
-        """
-        self.logger.info("Refreshing messages from email folder...")
-        self.all_messages = self.GetMessages()
-        self._was_refreshed = True
-        self.logger.info("Successfully refreshed messages from email folder.")
-
-    @property
-    def has_overdue(self):
-        """
-        Checks if there are any overdue messages among all messages. A message is considered overdue if its alert level
-        matches the AlertTypes.OVERDUE constant. If no messages have been fetched and the flag _was_refreshed is False,
-        it raises an exception indicating no messages are available.
-
-        :return: True if there are overdue messages, False otherwise.
-        :rtype: bool
-        """
-        if self.all_messages:
-            return any([x for x in self.all_messages
-                        if x.__class__.ALERT_LEVEL == AlertTypes.OVERDUE])
-        if not self._was_refreshed:
-            self._raise_no_messages()
-
-    @property
-    def has_critical_warning(self):
-        """
-        Checks if there are any messages with a critical warning alert level.
-
-        :return: A boolean indicating whether there is at least one message with a critical warning alert level
-        :rtype: bool
-
-        """
-        if self.all_messages:
-            return any([x for x in self.all_messages
-                        if x.__class__.ALERT_LEVEL == AlertTypes.CRITICAL_WARNING])
-        elif not self._was_refreshed:
-            self._raise_no_messages()
-
-    @property
-    def has_warning(self):
-        """
-        :return: Indicates whether there are any messages of warning level present.
-        :rtype: bool
-        """
-        if self.all_messages:
-            return any([x for x in self.all_messages
-                        if x.__class__.ALERT_LEVEL == AlertTypes.WARNING])
-        elif not self._was_refreshed:
-            self._raise_no_messages()