def _send_email(self, to, content):
t = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
e = EmailSender()
e.login(self._smtp_server, 25, self._user, self._passwd)
e.setContent('arXiv Paper Recommendation({})'.format(t), content)
e.sendEmail(self._user, [to], 'Automatic Paper Recommendation')
e.logout()
def __init__(self):
self.sleep_time = 60
self.config_file_path = "config.json"
self.config = ConfigReader(self.config_file_path)
self.checker = MovieChecker(self.config)
self.sender = EmailSender(self.config)
def main():
email_sender = EmailSender()
for name, data in get_employee_content().items():
try:
form = FORMS.get(data.get('level'), NotExistLevelForms)
form(name, email_sender)
except Exception as err:
print('Error: Main fail with {}'.format(err))
email_sender.update_message()
def __init__(self, key, language):
self.key = key
self.languages = {
'en': alphabet_eng,
'ru': alphabet_rus,
'de': alphabet_deu
}
self.language = language
self.sender = EmailSender('config.txt', False)
async def check_email(request):
post_data = await request.post()
log.debug("POST check_email request with post_data -> {post}", extra = {"post": post_data})
try:
email = post_data['email']
MySqlCon.get_instance().check_email(email)
#EmailSender(post_data['email'], Emairandom.randint(2345600000000, 2345700000000))
code = random.randint(1000, 9999)
EmailSender(email, code)
RedisCon.get_instance().setCode(email, code)
except Exception:
log.exception('POST get_info request wasn`t done')
return json_response({'status': '400', 'message': 'Wrong credentials'}, status=400)
return json_response({'status' : 'ok', 'message': 'Receipt was saved'}, status=200)
def send_email(self, _host, _username, _password, _subject, _toaddr, _body, window):
host = _host.get()
username = _username.get()
password = _password.get()
subject = _subject.get()
tolist = _toaddr.get(1.0, END).split("\n")
tolist.append(self.receiver_entry.get())
body = _body.get(1.0, END)
sender = EmailSender(host.split(":")[0], int(host.split(":")[1]))
result = sender.send(username, password, tolist, subject, body)
print(result)
messagebox.showinfo("Info ", result)
window.destroy()
def __init__(self, name):
"""
:param name: The name of the person who is checked for double bookings.
"""
self.name = name
self.booking_scraper = BookingScraper()
self.email_sender = EmailSender()
# List of bookings, each booking represented by a tuple with the format (time_interval, name).
self.bookings = None
# List used to keep track of previous conflicts to avoid sending multiple emails about the same conflict.
self.previous_conflicts = []
def send_notification(self, status, subject, message):
ColorPrint.info("Send message {0}".format(message))
list_of_providers = self.provider.split(",")
if len(list_of_providers) == 0 or not self.notify:
ColorPrint.err("Notification providers list is empty or notification disabled.")
else:
for provider in list_of_providers:
if status is True:
subject += " Successful"
else:
subject += ' Failed'
if provider == "telegram":
ColorPrint.info("Send telegram message")
telegram = TelegramSender(None)
telegram.send_message(self.chat_id, subject + '\n\n' + message)
if provider == "email":
ColorPrint.info("Send email message")
email_sender = EmailSender(None, None, None, None)
email_sender.send_message(self.recipient, subject, message, status)
class Application():
argumentsParser = ArgumentsParser()
emailSender = EmailSender()
network_scanner = NetworkScanner()
arguments = None
def initialize(self):
self.arguments = self.argumentsParser.get_arguments()
self.start_scanning(self.arguments.interval or 5)
def start_scanning(self, interval: int):
output = self.network_scanner.get_network_devices_output()
print(output)
if self.arguments.testing == True or self.arguments.email != None and self.arguments.pw != None:
self.emailSender.send_email(self.arguments.testing, self.arguments.email, self.arguments.pw, output)
if self.arguments.watch:
for x in range(1, interval):
b = f" Next scan in: {interval - x} seconds" + "." * x
print (b, end="\r")
time.sleep(1)
self.start_scanning(interval)
expected_costs = ExpectedCosts(config)
for cluster in all_clusters:
total_expected_cost = sum([
expected_costs.get_expected_cost(order_id)
for order_id in cluster.orders
])
cluster.expected_cost = total_expected_cost
if __name__ == "__main__":
driver_creator = DriverCreator(sys.argv)
with open(CONFIG_FILE, 'r') as config_file_stream:
config = yaml.safe_load(config_file_stream)
email_config = config['email']
email_sender = EmailSender(email_config)
print("Retrieving Amazon tracking numbers from email...")
amazon_tracking_retriever = AmazonTrackingRetriever(config, driver_creator)
try:
groups_dict = amazon_tracking_retriever.get_trackings()
except:
send_error_email(email_sender, "Error retrieving Amazon emails")
raise
if amazon_tracking_retriever.failed_email_ids:
print(
"Found %d Amazon emails without buying group labels and marked them as unread. Continuing..."
% len(amazon_tracking_retriever.failed_email_ids))
print("Retrieving Best Buy tracking numbers from email...")
fail_count += 1
if fail_count > 5:
break
# zip
#TODO: copy to onedrive file or send to file server
result = os.system('zip -r zips/%s.zip content/%s' %
(this_day, this_day))
# Generate list
with open("zips/list-%s.txt" % this_day, 'w+') as f:
for area_articles in spider.articles:
for article in spider.articles[area_articles]:
f.write(article.__str__() + '\n')
# send
sender = EmailSender(file_path='zips/list-%s.txt' % this_day)
sender.send_email()
else:
print("no")
break
else:
print("no_new_article_today")
print(this_day)
last_day = this_day
time.sleep(432)
def GetArticles():
return
from email_sender import EmailSender
if __name__ == "__main__":
EmailSender().clear_all_files()
OPTIONAL --secs-between-orders - How long (in seconds) to wait between one order being filled and placing the next order. Default 60s." --profit-percentage - How much profit to wait for per order. Default 1%% + fees (currently fees are 0.25%% per trade, total 0.5%%) --email-alerts-to - An email address to send alertrs when an order is placed. EXAMPLE %s --amount-to-trade=100 --max-orders=10 --order-qty=10 --price-delta=0.01 [email protected] """ % (APP_NAME, APP_NAME) bitstamp_client = BitStampHttpClient(APP_NAME, MY_BITSTAMP_ID, MY_PUBLIC_BITSTAMP_KEY, logger_level=logging.DEBUG) email_sender = EmailSender() # TODO change this back # Foor now, pretend that balance is 100 bitstamp_client.dummy_api_call("balance") # re-use the loggger in the client, bit of a hack logger = bitstamp_client.logger # User must specify these amount_to_trade = None max_number_of_orders_to_place = None per_order_quantity = None price_delta = None # how different should the current price differ from the avergae before plaving a BUY # Defaulted
def download_book(url: str, email, my_password, kindle_email):
fic = FanficDownloader("fanficfare", url, "build/")
# fic.download_story()
send = EmailSender(email, my_password, 587, kindle_email)
send.send_fic(fic)
from crypto_notification_condition import CryptoNotificationCondition, Threshold
from email_sender import EmailSender
import time
import argparse
import sys
parser = argparse.ArgumentParser(description='Send notifications on crypto prices')
parser.add_argument('gmail_sender_address', type=str, help='Gmail address to send from')
parser.add_argument('email_receiver_address', type=str, help='Email Address to send to')
args = parser.parse_args()
email_sender = EmailSender(args.gmail_sender_address)
conditions = []
conditions.append(CryptoNotificationCondition('bitcoin', Threshold.ABOVE, 70000))
conditions.append(CryptoNotificationCondition('bitcoin', Threshold.BELOW, 10000))
print("Starting...")
while(True):
try:
for condition in conditions:
if condition.should_notify():
email_sender.send_email(condition.get_email_message(), args.email_receiver_address)
print("Sent email: " + condition.name_of_coin)
except:
print("Error occurred")
e1 = sys.exc_info()[0]
e2 = sys.exc_info()[1]
print(e1)
print(e2)
'k5': '35',
'k6': '45',
'ms_1': '200',
'ms_2': '20',
'k7': 'FAIL',
'k8': 'PASS',
'k9': 'PASS'}]]
labels = ['vanilla', 'modified']
t = GetComplexTable(runs, labels, TablePrinter.CONSOLE)
print(t)
email = GetComplexTable(runs, labels, TablePrinter.EMAIL)
runs = [[{'k1': '1'}, {'k1': '1.1'}, {'k1': '1.2'}],
[{'k1': '5'}, {'k1': '5.1'}, {'k1': '5.2'}]]
t = GetComplexTable(runs, labels, TablePrinter.CONSOLE)
print(t)
simple_table = [
['binary', 'b1', 'b2', 'b3'],
['size', 100, 105, 108],
['rodata', 100, 80, 70],
['data', 100, 100, 100],
['debug', 100, 140, 60],
]
t = GetSimpleTable(simple_table)
print(t)
email += GetSimpleTable(simple_table, TablePrinter.HTML)
email_to = [getpass.getuser()]
email = "<pre style='font-size: 13px'>%s</pre>" % email
EmailSender().SendEmail(email_to, 'SimpleTableTest', email, msg_type='html')
def _email_config(self, sender, password, stmp_url, stmp_port):
self._email_sender = EmailSender(sender, password, stmp_url, stmp_port)
}
logger.debug("%s: task created (%s)", task_guid, path)
paths.append(path)
return paths
selected_channels = get_channels(
SELECTED_SERVER, _parse_channel_names(SELECTED_CHANNELS)
)
saver = Saver(selected_channels, SAVE_FOLDER)
saver.ss.timeout_sec = SHOT_AWAITING_TIME
saver.remove = REMOVE
if SENDING_METHOD == "Email":
saver.email = EmailSender(EMAIL_ACCOUNT)
saver.email_subscribers = EmailSender.parse_mails(EMAIL_SUBSCRIBERS)
saver.email.max_attachments_bytes = EMAIL_MAX_SIZE * 1024 * 1024
elif SENDING_METHOD == "FTP":
saver.ftp = FTPClient(
FTP_HOST,
port=FTP_PORT,
user=FTP_USER,
passwd=FTP_PASSWORD,
work_dir=FTP_WORK_DIR,
passive_mode=FTP_PASSIVE_MODE,
)
saver.ftp_add_relative_path = FTP_ADD_RELATIVE_PATH
else:
pass
import yaml
from recipient import Recipient
from sender import Sender
from email_sender import EmailSender
with open('send_email/email.yaml', encoding='utf-8') as f:
email_setup = yaml.safe_load(f)
sender = Sender(email_setup['from'], email_setup['user'], email_setup['pwd'])
def parse_recipient(line):
name, email_address, lang = line.strip('\n').split(';')
return Recipient(name, email_address, lang)
with open('send_email/recipients.csv', encoding='utf-8') as f:
recipients_strings = f.readlines()
recipients = map(parse_recipient, recipients_strings)
for recipient in recipients:
subject = email_setup['subject'][recipient.lang]
body = email_setup['body'][recipient.lang]
email = EmailSender(sender, recipient, subject, body)
email.send()
def email_config(self, email_sender_json):
self._email_sender = EmailSender(email_sender_json['email'],
email_sender_json['password'],
email_sender_json['stmp']['url'],
email_sender_json['stmp']['port'])
# Al senders
# -------------------------------------------------------
ALL_SENDERS = []
# -------------------------------------------------------
# Initializing email sender
# -------------------------------------------------------
if SEND_SCREEN_EMAIL or SEND_EMAIL:
from senders import AdoptedEmailSender
from email_sender import EmailSender
assert EMAIL_ACCOUNT, host.tr(
"Учетная запись e-mail в Trassir не задана")
assert EMAIL_ADDRESSES, host.tr(
"Получатели почтовых уведомлений не заданы")
mail_sender = EmailSender(EMAIL_ACCOUNT)
if SEND_SCREEN_EMAIL:
ALL_SENDERS.append(
AdoptedEmailSender(mail_sender=mail_sender,
email_recipients=EMAIL_ADDRESSES))
else:
from reactions import MailTextSender
reactions.add_executor(MailTextSender(mail_sender,
EMAIL_ADDRESSES))
# -------------------------------------------------------
# Initializing ftp sender
# -------------------------------------------------------
if SEND_FTP:
if current_day in WORK_DAYS:
push_backup(create_backup())
else:
if current_day == total_month_days:
for day in WORK_DAYS:
if day > current_day and not count:
count += 1
push_backup(create_backup())
if __name__ == host.stats().parent().guid:
if SEND_FTP:
ftp = FTPClient(
host=FTP_HOST,
port=FTP_PORT,
user=FTP_LOGIN,
passwd=FTP_PASS,
work_dir=FTP_WD,
callback=ftp_callback,
check_connection=FTP_CHECK_CONNECTION,
passive_mode=FTP_PASSIVE_MODE,
)
if SEND_EMAIL:
EMAIL_SUBSCRIBERS = EmailSender.parse_mails(EMAIL_SUBSCRIBERS)
mail = EmailSender(EMAIL_ACCOUNT)
schedule.every().day.at(SCHEDULE_TIME).do(check_current_day)
schedule.run_continuously()
import host
import helpers
default_script_name = helpers.set_script_name()
logger = helpers.init_logger("Archive_stat", debug=DEBUG)
from script_object import ScriptObject
from date_utils import ts_to_dt
import schedule
from schedule_object import ScheduleObject
from email_sender import EmailSender
MAIL = None
if MAIL_ACCOUNT:
MAIL = EmailSender(MAIL_ACCOUNT)
if MAIL_SUBJECT:
MAIL_SUBJECT = MAIL_SUBJECT.format(server_name=host.settings("").name)
else:
MAIL_SUBJECT = None
scr_obj = ScriptObject()
if WORK_SCHEDULE:
WORK_SCHEDULE = ScheduleObject(WORK_SCHEDULE)
else:
WORK_SCHEDULE = None
channels = []
selected_channels = None
if CHANNELS:
email_server_port = 465 # Port of server For SMTP SSL connection body = "This is an email sent from Python security system." email_system_address = "" # [email protected] email_system_password = "" # password commanders = ["*****@*****.**", "*****@*****.**"] # emails that can do changes to the system commands = ["arm", "disarm", "status", "sens"] # commands supported by the system system_is_armed = False firstrun = True prev_frame=None actual_frame=None image_diff_threshold = 16 emailSender = EmailSender(email_server_address, email_server_port, email_system_address, email_system_password) emailReceiver = EmailReceiver(email_server_address, email_system_address, email_system_password) ##### FUNCTION TO BE USED BY MAIN ##### def arm_system(): global system_is_armed global firstrun firstrun = True system_is_armed = True print(get_time()+" - System armed.") def disarm_system(): global system_is_armed system_is_armed = False print(get_time()+" - System disarmed.")
def __init__(self, people): self.people = people self.company_state = NO_EMAIL self.last_updated = time.time() self.email_sender = EmailSender()
from email_sender import EmailSender
from analysis_engine import get_news_formatted
import robin_stocks as rs
from secrets import robin_password, robin_username
from newscatcher import Newscatcher
if __name__ == '__main__':
es = EmailSender()
rs.login(username=robin_username,
password=robin_password,
expiresIn=86400,
by_sms=True)
tickers = list(rs.build_holdings().keys())
# message = ''
#
# for ticker in tickers:
# for article in get_news_formatted(ticker):
# message += article+'\n'
#
# es.send_email(f'Morning Roundup', message)
rs.logout()
#!/usr/bin/env python
# -*- encode: utf-8 -*-
#Copyright 2015 RAPP
#Licensed under the Apache License, Version 2.0 (the "License");
#you may not use this file except in compliance with the License.
#You may obtain a copy of the License at
#http://www.apache.org/licenses/LICENSE-2.0
#Unless required by applicable law or agreed to in writing, software
#distributed under the License is distributed on an "AS IS" BASIS,
#WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#See the License for the specific language governing permissions and
#limitations under the License.
# Authors: Aris Thallas
# contact: aris.thallas@{iti.gr, gmail.com}
import rospy
from email_sender import EmailSender
from email_receiver import EmailReceiver
if __name__ == "__main__":
rospy.init_node('Email')
emailReceiver = EmailReceiver()
emailSender = EmailSender()
rospy.spin()
