Python Schedule Routine Tasks Everyday

$ crontab -l
# MIN HOUR DAY MONTH DAYOFWEEK | COMMAND
# --------------------------------------
MAILTO=shirong0419@icloud.com
0 0 1 * * date && /Users/shi-rongliu/shell/LanguageTool.sh

import smtplib
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
from email.mime.image import MIMEImage

GMAIL = "gmail.com"
Message = """Subject: Program Confirmation
To: {recipient}
From: {sender}
Hey, Thanks for your waiting! Your program is done. We are processing it now and will contact you soon
Regards
Shi-rong (Louis) Liu
http://louiscode00.com/
"""

class TextMeWhenItsDone(object):
    """
    A :class:~practice_common_algorithm.tool.TextMeWhenItsDone object is the sending an email module
    The smtplib module defines an SMTP client session object that can be used to send mail to any internet machine with an SMTP or ESMTP listener daemon.
    """
    def __init__(self, email: str):
        if email[email.index("@")+1:] == GMAIL:
            self.server = smtplib.SMTP("smtp.gmail.com", 587)
    def __del__(self):
        self.server.quit()
    def login(self, email, password):
        """docstring for login"""
        self.server.starttls()
        self.server.login(email, password)
    def textme(self, email, password, receiver="YO"):
        """ Simple Mail Transfer Protocal is an application layer protocol in the OSI model.
        :param email:  The address sending this email
        :type  email:  string
        :param password:  The password for the authentication
        :type  password:  string
        :param receiver:  A list of addresses to send this mail to
        :type  receiver:  string
        :return:  Description
        :rtype:  Type
        """
        self.server.sendmail(email, receiver, Message.format(recipient=receiver, sender=email))
    def textmeimage(self, email: str, password: str, receiver="YO"):
        """docstring for TextMeImage"""
        msg = MIMEMultipart('alternative')
        msg['Subject'] = "Sharing Image"
        msg['From'] = email
        msg['To'] = receiver
        text = MIMEText('<img src="cid:image1">', 'html')
        msg.attach(text)
        image1 = MIMEImage(open('xxxx.jpeg', 'rb').read())
        # Define the image's ID as referenced in the HTML body above
        image1.add_header('Content-ID', '<image1>')
        msg.attach(image1)
        self.server.sendmail(email, receiver, msg.as_string())

from textmewhenitsdone import TextMeWhenItsDone
from typing import List, NamedTuple
import sched
import time
import datetime
import random

class ScheduledTime(NamedTuple):
    """description"""
    hour: int
    minute: int
    second: int

class AuthenticationServer(NamedTuple):
    """description"""
    email: str
    password: str
    receiver: str

def prompt(prompt: str) -> str:
    """docsring for prompt"""
    return input(prompt).strip()

def textme(authentication) -> None:
    textmewhenitsdone = TextMeWhenItsDone(authentication.email)
    textmewhenitsdone.login(authentication.email, authentication.password)
    textmewhenitsdone.textme(authentication.email, authentication.password, authentication.receiver)
    print(f"Sending Email at {datetime.datetime.now()}")

def send_email_at_fixed_time_everyday(authentication: AuthenticationServer, scheduled_times: List[ScheduledTime]) -> None:
    """docstring for send_email_at_fixed_time_everyday"""
    """ Schedule to send email at fixed time everyday
    :param authentication:  Required authentication
    :type  authentication:  AuthenticationServer
    :param schedule_times:  scheduled time to run everyday
    :type  schedule_times:  List[ScheduledTime]
    """
    scheduler = sched.scheduler(time.time, time.sleep)
    def create_scheduled_date_times(
            year: int, month: int, day: int,
            scheduled_times: List[ScheduledTime]) -> List[datetime.datetime]:
        """docstring for create_scheduled_date_times"""
        """ Create scheduld date times
        :param year:  year
        :type  year:  int
        :param month:  month
        :type  month:  int
        :param day:  day
        :type  day:  int
        :param schedule_times:  scheduled time everyday
        :type  schedule_times:  Type
        :return: scheduled date time
        :rtype:  List[datetime.datetime]
        """
        scheduled_date_times = []
        for scheduled_time in scheduled_times:
            date_time = datetime.datetime(
                year=year,
                month=month,
                day=day,
                hour=scheduled_time.hour,
                minute=scheduled_time.minute,
                second=scheduled_time.second,
                microsecond=0
            )
            scheduled_date_times.append(date_time)
        return scheduled_date_times
    now_date_time = datetime.datetime.now()
    scheduled_date_times = create_scheduled_date_times(
            year=now_date_time.year,
            month=now_date_time.month,
            day=now_date_time.day,
            scheduled_times=scheduled_times)
    while True:
        for schedule_date_time in scheduled_date_times:
            if schedule_date_time > datetime.datetime.now():
                t = time.mktime(schedule_date_time.timetuple())
                scheduler.enterabs(time=t,
                                   priority=1,
                                   action=textme,
                                   argument=(),
                                   kwargs={"authentication": authentication})
                print(f"Scheduled action at run at {schedule_date_time}")
        scheduler.run()
        print(f"Scheduled action completed.")
        tomorrow_scheduled_date_times = [
                create_date_time_after_n_hour(date_time=schedule_date_time, n=24)
                for schedule_date_time in scheduled_date_times
        ]
        scheduled_date_times = tomorrow_scheduled_date_times

if __name__ == '__main__':
    authentication = AuthenticationServer(email=prompt("Form: "),
                                          password=prompt("Password: ").split()[0],
                                          receiver=prompt("To: ").split()[0])
    now_date_time = datetime.datetime.now()
    planned_date_time = now_date_time + datetime.timedelta(minutes=1)
    schedule_time_1 = ScheduledTime(hour=planned_date_time.hour,
                                    minute=planned_date_time.minute,
                                    second=0)
    schedule_time_2 = ScheduledTime(hour=planned_date_time.hour,
                                    minute=planned_date_time.minute,
                                    second=10)
    schedule_time_3 = ScheduledTime(hour=planned_date_time.hour,
                                    minute=planned_date_time.minute,
                                    second=20)
    scheduled_times = [schedule_time_1, schedule_time_2, schedule_time_3]

    send_email_at_fixed_time_everyday(authentication=authentication, scheduled_times=scheduled_times)