def main(): # Get currency pairs sorted by 24-hour volume polo = poloniex.Poloniex(timeout=10, coach=True) sorted_tickers = sorted(polo.returnTicker().items(), key=lambda x: float(x[1]['baseVolume']), reverse=True) currency_pairs = [(k, float(v['baseVolume'])) for k, v in sorted_tickers if 'BTC_' in k or k == 'USDT_BTC'] volume_texts = [] for currency_pair, volume_24h in currency_pairs[0:DISPLAY_NUMS]: print("currency_pair={}".format(currency_pair)) volume_texts.append( get_volumes(currency_pair, volume_24h, MINUTES, TICKS)) body = textwrap.dedent(u""" Date : {date} Ticks : {minutes} mins x {ticks} {volume_texts} """).format( date=datetime.now().strftime('%Y/%m/%d %H:%M'), minutes=MINUTES, ticks=TICKS, volume_texts='\n\n'.join(volume_texts), ).strip() print('----------') print(body) print('----------') email_client = EmailClient() # Send an email to myself email_client.send_test_email(u"Poloniex trade volumes", body)
def send_mail(self, subject, url, params): mail_rece = params.get('buyer_email') mail_type = params.get('email_type') # user_type = 'mws_user_ship' # if mail_type == 'AmzReceipt': # user_type = 'mws_user_receipt' # elif mail_type == 'AmzInvite': # user_type = 'mws_user_invite' # log.info('UserType: %s', user_type) mail_user_info = random.choice( email_config.mail_user_info.get('mws_users')) mail_from = mail_user_info.split(',')[0] mail_user = email_config.mail_user_info.get('aws_user').split(',')[0] mail_pass = email_config.mail_user_info.get('aws_user').split(',')[1] mail_host = email_config.mail_host_info.get('aws_host') with open('Template' + url, 'r') as f: if mail_type == 'AmzShip': m_body = f.read().format( buyer_name=params.get('buyer_name'), carrier_name=params.get('carrier_name'), tracking_number=params.get('tracking_number'), arrival_date=params.get('arrival_date')) else: m_body = f.read().format(buyer_name=params.get('buyer_name')) emc = EmailClient(mail_host) msg = emc.make_msg(mail_from, mail_rece, subject, m_body, 'html') emc.send(mail_user, mail_pass, mail_from, mail_rece, msg)
def test_reset_functionality(self): """ This functions tests that mail contents are reset after calling reset() """ # initialize the email client email_client = EmailClient(self.server, self.server_port, self.mail_id, self.password) # set email contents to test strings and files email_client.set_subject(self.test_subject) email_client.set_body(self.test_body) email_client.set_signature(self.test_signature) email_client.add_attachment(self.test_attachment) # before reset will be true as email will be sent before_reset = email_client.send(self.recipient) # reset the email contents email_client.reset_email() # after reset will be false as email won't be sent as the contents removed after_reset = email_client.send(self.recipient) # compare that both are not equal self.assertNotEqual(before_reset, after_reset)
def lambda_handler(event, context): try: args = parse_args(event) if not args['notification_type']: raise Exception('notification_type parameter is not passed') # Send notification if args['notification_type'] == 'api': # Check required params if not all([ args['influx_host'], args['smtp_user'], args['test'], args['test_type'], args['notification_type'], args['smtp_password'], args['user_list'] ]): raise Exception('Some required parameters not passed') email = ApiEmailNotification(args).email_notification() elif args['notification_type'] == 'ui': if not all([args['test_id'], args['report_id']]): raise Exception( 'test_id and report_id are required for UI reports') email = UIEmailNotification(args).ui_email_notification() else: raise Exception( 'Incorrect value for notification_type: {}. Must be api or ui'. format(args['notification_type'])) EmailClient(args).send_email(email) except Exception as e: from traceback import format_exc print(format_exc()) return {'statusCode': 500, 'body': json.dumps(str(e))} return {'statusCode': 200, 'body': json.dumps('Email has been sent')}
def test_email_client_reset(self): # Email message content # Email subject subject = 'Testing Reset Method' # Email body body = 'Email body has not been reset. Please check its functionality.' # Email signature signature = '\n\nKind regards,\[email protected]' # initialising Email email_client = EmailClient(self.__server, self.__port_number, self.__username, self.__password) email_client.set_subject(subject) email_client.set_body(body) email_client.set_signature(signature) email_client.add_attachment('test.txt') # resetting email content email_client.reset_email() # adding Email body new_body = 'Email body has been reset.' email_client.set_body(new_body) # testing sent = True self.assertEqual(email_client.send(self.__recipient), sent)
def send_notification(): try: email_client = EmailClient() email_client.send_notification(notification_email_address) email_client.close() except: print("Could not send success notification")
def send_alive_notification(tries, failed, exceptions, successes, alive_since, time_alive): try: email_client = EmailClient() email_client.send_alive_notification(notification_email_address, tries, failed, exceptions, successes, alive_since, time_alive) email_client.close() except: print("Could not send alive notification")
def test_email_client_send_misc(self): # Email message content # Email subject subject = '' # sending Email email_client = EmailClient(self.__server, self.__port_number, self.__username, self.__password) email_client.set_subject(subject) # add Email attachment email_client.add_attachment('test.txt') # testing sent = False self.assertEqual(email_client.send(self.__recipient), sent)
def test_invalid_attachment_path_mails(self): """ This functions tests that mail is not sent when attachment path is invalid """ # initialize the email client email_client = EmailClient(self.server, self.server_port, self.mail_id, self.password) # set email contents to test strings and files email_client.set_subject(self.test_subject) email_client.set_body(self.test_body) email_client.set_signature(self.test_signature) email_client.add_attachment('xyz.txt') # verify that the email is sent self.assertFalse(email_client.send(self.recipient))
def test_valid_mails(self): """ This function tests that the mail is not sent when email contents are empty """ # initialize the email client email_client = EmailClient(self.server, self.server_port, self.mail_id, self.password) # set email contents to test strings and files email_client.set_subject(self.test_subject) email_client.set_body(self.test_body) email_client.set_signature(self.test_signature) email_client.add_attachment(self.test_attachment) # verify that the email is sent self.assertTrue(email_client.send(self.recipient))
def test_empty_mails(self): """ This function tests that the mail is sent successfully when all the mail contents are proper """ # initialize the email client email_client = EmailClient(self.server, self.server_port, self.mail_id, self.password) # set email contents to empty string email_client.set_subject('') email_client.set_body('') email_client.set_signature('') email_client.add_attachment('') # verify that the email is not sent self.assertFalse(email_client.send(self.recipient))
def main(): # Get currency pairs sorted by 24-hour volume polo = poloniex.Poloniex(timeout=10, coach=True) sorted_tickers = sorted(polo.returnTicker().items(), key=lambda x: float(x[1]['baseVolume']), reverse=True) currency_pairs = [k for k, v in sorted_tickers if 'BTC_' in k] chart_texts = [] for currency_pair in currency_pairs[0:DISPLAY_NUMS]: print("currency_pair={}".format(currency_pair)) data = get_chart_data(currency_pair, MINUTES_PER_TICK, TICKS) chart_texts.append( textwrap.dedent(u""" {currency_pair} Latest price : {latest_price} ({price_rate} from highest) Latest timestamp : {latest_timestamp} Highest price : {highest_price} Highest timestamp : {highest_timestamp} ({timestamp_diff} before) Price up-downs : {price_up_downs} (past 3 ticks) Price deviations : {deviations_by_sigma} (σ) 1 sigma price : {sigma_percent} Latest volumes : {latest_volumes} (past 3 ticks, {latest_volumes_rate} of total) Volume up-downs : {volume_up_downs} (past 3 ticks) """).strip().format(**data)) body = textwrap.dedent(u""" Date : {date} Ticks : {minutes} mins x {ticks} ({hours} hours) {chart_texts} """).format( date=datetime.now().strftime('%Y/%m/%d %H:%M:%S'), minutes=MINUTES_PER_TICK, ticks=TICKS, hours=TARGET_HOURS, chart_texts='\n\n'.join(chart_texts), ).strip() # print('----------') # print(body) # print('----------') email_client = EmailClient() # Send an email to myself email_client.send_test_email(u"Poloniex high break (and sigma)", body)
def test_empty_subject_mails(self): """ This function tests that mail is not sent when attachment is present but no subject is added """ # initialize the email client email_client = EmailClient(self.server, self.server_port, self.mail_id, self.password) # set subject of email to empty string email_client.set_subject('') # set email contents to test strings and files email_client.set_body(self.test_body) email_client.set_signature(self.test_signature) email_client.add_attachment(self.test_attachment) # verify that the email is sent self.assertFalse(email_client.send(self.recipient))
def test_empty_email(self): # Empty Email message content # Email subject subject = '' # Email body body = '' # Email signature signature = '' # sending Email email_client = EmailClient(self.__server, self.__port_number, self.__username, self.__password) email_client.set_subject(subject) email_client.set_body(body) email_client.set_signature(signature) # testing sent = False self.assertEqual(email_client.send(self.__recipient), sent)
def test_email_client_send(self): # Email message content # Email subject subject = 'Testing' # Email body body = 'Hi,\n\nI am Kevin. How are you?' # Email signature signature = '\n\nKind regards,\n{}'.format(self.__username) # sending Email email_client = EmailClient(self.__server, self.__port_number, self.__username, self.__password) email_client.set_subject(subject) email_client.set_body(body) email_client.set_signature(signature) email_client.add_attachment('test.txt') # testing sent = True self.assertEqual(email_client.send(self.__recipient), sent)
from sel import Selenium from cloudinary_management import Cloudinary # from whatsapp import send_message import os from pathlib import Path parent_username = os.getenv("parent_username") parent_password = os.getenv("parent_password") email_username = os.getenv("email_username") email_password = os.getenv("email_password") to_whatsapp_numbers = os.getenv("to_whatsapp_numbers") to_email = os.getenv("to_email") sel = Selenium() cloud = Cloudinary() mail = EmailClient(username=email_username, password=email_password, recipients=to_email) if __name__ == '__main__': sel.launch_chrome() sel.go_to_decleration_page() sel.login(username=parent_username, password=parent_password) sel.sign_health_decleration() screenshot = sel.save_screenshot() file = Path(__file__).parent / screenshot mail.send_mail_with_file(filename=file) message_url = cloud.upload_files(file=screenshot) # send_message(message=screenshot, message_url=message_url, to_whatsapp_numbers=to_whatsapp_numbers) sel.quit()
def main(): now = datetime.now() # Get markets exchange = ccxt.bittrex() markets = exchange.fetch_tickers() print('Number of markets={}'.format(len(markets))) # Altcoins altcoins = [ dict(v, symbol=k.split('/')[0]) for k, v in markets.items() if '/BTC' in k ] # Sort by baseVolume (Note: baseVolume might be None, so 'or 0') altcoins.sort(key=lambda x: float(x['quoteVolume'] or 0), reverse=True) print('Number of altcoins={}'.format(len(altcoins))) print([x['symbol'] for x in altcoins]) # Get altcoin data from MongoDB collection = MongoClient().bittrex['tickers'] chart_texts = [] for i, symbol in enumerate( [x['symbol'] for x in altcoins[:DISPLAY_NUMBER_OF_ALTCOINS]]): print('==========') print(symbol) tickers = list( collection.find( { 'symbol': symbol, 'timestamp': { '$gte': now - timedelta(minutes=TARGET_MINUTES) } }, { '_id': False }, ).sort('timestamp', ASCENDING)) # pprint(tickers) chart_dict = tickers_to_chart_dict(tickers) chart_text = textwrap.dedent(u""" {i}. {symbol} ----------------- Latest price : {latest_price:.8f} ({price_diff_rate:+.1%} from highest) Highest price : {highest_price:.8f} ({highest_timestamp_diff} before) Price up-downs : {price_up_downs} Price deviations : {price_diff_by_sigma} (σ) 1 sigma price : {sigma_percent:.1%} """).format( i=i + 1, symbol=symbol, latest_price=chart_dict['latest_price'], highest_price=chart_dict['highest_price'], highest_timestamp=chart_dict['highest_timestamp'].strftime( '%m/%d %H:%M'), price_up_downs=', '.join( ['{:+.1%}'.format(v) for v in chart_dict['price_up_downs']]), highest_timestamp_diff=chart_dict['highest_timestamp_diff'], price_diff_rate=(chart_dict['latest_price'] - chart_dict['highest_price']) / chart_dict['highest_price'], price_diff_by_sigma=', '.join([ '{:.2f}'.format(v) for v in chart_dict['price_diff_by_sigma'] ]), sigma_percent=chart_dict['sigma_percent'], ).strip() print('----------') print(chart_text) chart_texts.append(chart_text) body = textwrap.dedent(u""" Date : {date} Ticks : {minutes} mins x {ticks:,.0f} ({hours:,.0f} hours) {chart_texts} """).format( date=now.strftime('%Y/%m/%d %H:%M:%S'), minutes=MINUTES_PER_TICK, ticks=TARGET_MINUTES / MINUTES_PER_TICK, hours=TARGET_MINUTES / 60, chart_texts='\n\n'.join(chart_texts), ).strip() print('==========') print(body) email_client = EmailClient() # Send an email to myself email_client.send_test_email(u'[CC] Bittrex Tickers', body)
def main(): now = datetime.now() # Symbols db_symbols = MongoClient().cctweet['symbols'] symbols = list( db_symbols.find({'time': { '$exists': False }}, {'_id': False}, sort=[('count', DESCENDING)])) for symbol in symbols: # TODO: Need fix? INTERVAL_MINUTES * 1.5 prev = db_symbols.find_one( { 'key': symbol['key'], 'time': { '$gte': now - timedelta(minutes=INTERVAL_MINUTES * 1.5) } }, sort=[('time', DESCENDING)]) if prev is not None: symbol.update({ 'diff': float(symbol['count'] - prev['count']) / float(prev['count']) }) else: symbol.update({'diff': float('inf')}) # Hashtags db_hashtags = MongoClient().cctweet['hashtags'] hashtags = list( db_hashtags.find({'time': { '$exists': False }}, {'_id': False}, sort=[('count', DESCENDING)])) for hashtag in hashtags: # TODO: Need fix? INTERVAL_MINUTES * 1.5 prev = db_hashtags.find_one( { 'key': hashtag['key'], 'time': { '$gte': now - timedelta(minutes=INTERVAL_MINUTES * 1.5) } }, sort=[('time', DESCENDING)]) if prev is not None: hashtag.update({ 'diff': float(hashtag['count'] - prev['count']) / float(prev['count']) }) else: hashtag.update({'diff': float('inf')}) # Update time db_symbols.update({'time': { '$exists': False }}, {'$set': { 'time': now }}, multi=True) db_hashtags.update({'time': { '$exists': False }}, {'$set': { 'time': now }}, multi=True) # Cleanup db_symbols.remove({'time': {'$lt': now - timedelta(hours=24)}}) db_hashtags.remove({'time': {'$lt': now - timedelta(hours=24)}}) body = textwrap.dedent(u""" Date : {date} $ Top Symbols ============= {top_symbols} # Top Hashtags ============== {top_hashtags} """).format( date=now.strftime('%Y/%m/%d %H:%M'), top_symbols='\n'.join([ u'{}: {} ({})'.format(d['key'], d['count'], '{:+.0%}'.format(d['diff'])) for d in symbols[0:SYMBOL_DISPLAY_SIZE] ]), top_hashtags='\n'.join([ u'{}: {} ({})'.format(d['key'], d['count'], '{:+.0%}'.format(d['diff'])) for d in hashtags[0:HASHTAG_DISPLAY_SIZE] ]), ).strip() email_client = EmailClient() email_client.send_test_email(u'CC Tweet Summary', body)
def __init__(self): super(MyListener, self).__init__() self.email_client = EmailClient()
def main(): # Get all markets res = requests.get('https://api.coinmarketcap.com/v1/ticker/') markets = res.json() print('Number of markets={}'.format(len(markets))) # Sort by 24h_volume_usd (Note: some 24h_volume_usd are None, so 'or 0') markets.sort(key=lambda x: float(x['24h_volume_usd'] or 0), reverse=True) # Pop BTC and USDT (Tether) markets = [x for x in markets if x['symbol'] not in ('BTC', 'USDT')] # pprint(markets) # Get Bitcoin market res = requests.get( 'https://api.coinmarketcap.com/v1/ticker/{}/'.format('bitcoin')) bitcoin = res.json()[0] df = pd.DataFrame(markets) df['price_usd'] = df['price_usd'].astype(float) df['price_btc'] = df['price_btc'].astype(float) df['24h_volume_usd'] = df['24h_volume_usd'].astype(float) df['market_cap_usd'] = df['market_cap_usd'].astype(float) df['available_supply'] = df['available_supply'].astype(float) df['total_supply'] = df['total_supply'].astype(float) df['percent_change_1h'] = df['percent_change_1h'].astype(float) df['percent_change_24h'] = df['percent_change_24h'].astype(float) df['percent_change_7d'] = df['percent_change_7d'].astype(float) df['last_updated'] = df['last_updated'].apply( lambda x: datetime.fromtimestamp(float(x))) print(df[0:10]) df_top10 = df[0:10] df_top20 = df[0:20] df_top30 = df[0:30] df_top50 = df[0:50] df_top51_100 = df[50:100] df_top100 = df[0:100] body = textwrap.dedent(u""" Bitcoin ======= (1h) price change : {bitcoin_1h_change:+.1f}% (24h) price change : {bitcoin_24h_change:+.1f}% (7d) price change : {bitcoin_7d_change:+.1f}% Top 10 markets ============== (1h) price up/down : {top10_1h_up} / {top10_1h_down} (1h) price mean : {top10_1h_mean:+.1f}% (24h) price up/down : {top10_24h_up} / {top10_24h_down} (24h) price mean : {top10_24h_mean:+.1f}% (7d) price up/down : {top10_7d_up} / {top10_7d_down} (7d) price mean : {top10_7d_mean:+.1f}% Top 20 markets ============== (1h) price up/down : {top20_1h_up} / {top20_1h_down} (1h) price mean : {top20_1h_mean:+.1f}% (24h) price up/down : {top20_24h_up} / {top20_24h_down} (24h) price mean : {top20_24h_mean:+.1f}% (7d) price up/down : {top20_7d_up} / {top20_7d_down} (7d) price mean : {top20_7d_mean:+.1f}% Top 30 markets ============== (1h) price up/down : {top30_1h_up} / {top30_1h_down} (1h) price mean : {top30_1h_mean:+.1f}% (24h) price up/down : {top30_24h_up} / {top30_24h_down} (24h) price mean : {top30_24h_mean:+.1f}% (7d) price up/down : {top30_7d_up} / {top30_7d_down} (7d) price mean : {top30_7d_mean:+.1f}% Top 50 markets ============== (1h) price up/down : {top50_1h_up} / {top50_1h_down} (1h) price mean : {top50_1h_mean:+.1f}% (24h) price up/down : {top50_24h_up} / {top50_24h_down} (24h) price mean : {top50_24h_mean:+.1f}% (7d) price up/down : {top50_7d_up} / {top50_7d_down} (7d) price mean : {top50_7d_mean:+.1f}% Top 51-100 markets ============== (1h) price up/down : {top51_100_1h_up} / {top51_100_1h_down} (1h) price mean : {top51_100_1h_mean:+.1f}% (24h) price up/down : {top51_100_24h_up} / {top51_100_24h_down} (24h) price mean : {top51_100_24h_mean:+.1f}% (7d) price up/down : {top51_100_7d_up} / {top51_100_7d_down} (7d) price mean : {top51_100_7d_mean:+.1f}% Top 100 markets =============== (1h) price up/down : {top100_1h_up} / {top100_1h_down} (1h) price mean : {top100_1h_mean:+.1f}% (24h) price up/down : {top100_24h_up} / {top100_24h_down} (24h) price mean : {top100_24h_mean:+.1f}% (7d) price up/down : {top100_7d_up} / {top100_7d_down} (7d) price mean : {top100_7d_mean:+.1f}% """).format( bitcoin_1h_change=float(bitcoin['percent_change_1h']), bitcoin_24h_change=float(bitcoin['percent_change_24h']), bitcoin_7d_change=float(bitcoin['percent_change_7d']), top10_1h_up=len(df_top10[df_top10['percent_change_1h'] > 0]), top10_1h_down=len(df_top10[df_top10['percent_change_1h'] <= 0]), top10_1h_mean=df_top10.mean()['percent_change_1h'], top10_24h_up=len(df_top10[df_top10['percent_change_24h'] > 0]), top10_24h_down=len(df_top10[df_top10['percent_change_24h'] <= 0]), top10_24h_mean=df_top10.mean()['percent_change_24h'], top10_7d_up=len(df_top10[df_top10['percent_change_7d'] > 0]), top10_7d_down=len(df_top10[df_top10['percent_change_7d'] <= 0]), top10_7d_mean=df_top10.mean()['percent_change_7d'], top20_1h_up=len(df_top20[df_top20['percent_change_1h'] > 0]), top20_1h_down=len(df_top20[df_top20['percent_change_1h'] <= 0]), top20_1h_mean=df_top20.mean()['percent_change_1h'], top20_24h_up=len(df_top20[df_top20['percent_change_24h'] > 0]), top20_24h_down=len(df_top20[df_top20['percent_change_24h'] <= 0]), top20_24h_mean=df_top20.mean()['percent_change_24h'], top20_7d_up=len(df_top20[df_top20['percent_change_7d'] > 0]), top20_7d_down=len(df_top20[df_top20['percent_change_7d'] <= 0]), top20_7d_mean=df_top20.mean()['percent_change_7d'], top30_1h_up=len(df_top30[df_top30['percent_change_1h'] > 0]), top30_1h_down=len(df_top30[df_top30['percent_change_1h'] <= 0]), top30_1h_mean=df_top30.mean()['percent_change_1h'], top30_24h_up=len(df_top30[df_top30['percent_change_24h'] > 0]), top30_24h_down=len(df_top30[df_top30['percent_change_24h'] <= 0]), top30_24h_mean=df_top30.mean()['percent_change_24h'], top30_7d_up=len(df_top30[df_top30['percent_change_7d'] > 0]), top30_7d_down=len(df_top30[df_top30['percent_change_7d'] <= 0]), top30_7d_mean=df_top30.mean()['percent_change_7d'], top50_1h_up=len(df_top50[df_top50['percent_change_1h'] > 0]), top50_1h_down=len(df_top50[df_top50['percent_change_1h'] <= 0]), top50_1h_mean=df_top50.mean()['percent_change_1h'], top50_24h_up=len(df_top50[df_top50['percent_change_24h'] > 0]), top50_24h_down=len(df_top50[df_top50['percent_change_24h'] <= 0]), top50_24h_mean=df_top50.mean()['percent_change_24h'], top50_7d_up=len(df_top50[df_top50['percent_change_7d'] > 0]), top50_7d_down=len(df_top50[df_top50['percent_change_7d'] <= 0]), top50_7d_mean=df_top50.mean()['percent_change_7d'], top51_100_1h_up=len( df_top51_100[df_top51_100['percent_change_1h'] > 0]), top51_100_1h_down=len( df_top51_100[df_top51_100['percent_change_1h'] <= 0]), top51_100_1h_mean=df_top51_100.mean()['percent_change_1h'], top51_100_24h_up=len( df_top51_100[df_top51_100['percent_change_24h'] > 0]), top51_100_24h_down=len( df_top51_100[df_top51_100['percent_change_24h'] <= 0]), top51_100_24h_mean=df_top51_100.mean()['percent_change_24h'], top51_100_7d_up=len( df_top51_100[df_top51_100['percent_change_7d'] > 0]), top51_100_7d_down=len( df_top51_100[df_top51_100['percent_change_7d'] <= 0]), top51_100_7d_mean=df_top51_100.mean()['percent_change_7d'], top100_1h_up=len(df_top100[df_top100['percent_change_1h'] > 0]), top100_1h_down=len(df_top100[df_top100['percent_change_1h'] <= 0]), top100_1h_mean=df_top100.mean()['percent_change_1h'], top100_24h_up=len(df_top100[df_top100['percent_change_24h'] > 0]), top100_24h_down=len(df_top100[df_top100['percent_change_24h'] <= 0]), top100_24h_mean=df_top100.mean()['percent_change_24h'], top100_7d_up=len(df_top100[df_top100['percent_change_7d'] > 0]), top100_7d_down=len(df_top100[df_top100['percent_change_7d'] <= 0]), top100_7d_mean=df_top100.mean()['percent_change_7d'], ).strip() email_client = EmailClient() # Send an email to myself email_client.send_test_email(u'[CC] Entire Market Mood', body)
def main(): now = datetime.now() # Get all markets res = requests.get('https://api.coinmarketcap.com/v1/ticker/') markets = res.json() print('Number of markets={}'.format(len(markets))) # Pop base currency and USDT (Tether) symbols = ['{}/{}'.format(x['symbol'], BASE_CURRENCY) for x in markets if x['symbol'] not in (BASE_CURRENCY, 'USDT')] print(symbols) # TODO: ZRX symbols.append('ZRX/{}'.format(BASE_CURRENCY)) symbol_texts = [] for symbol in symbols[:DISPLAY_NUMBER_OF_ALTCOINS]: ex_count = 0 max_bid = 0 max_bid_ex_name = '' max_bid_ex_url = '' max_bid_volume = 0 min_ask = float('inf') min_ask_ex_name = '' min_ask_ex_url = '' min_ask_volume = 0 for ex, ex_url in EXCHANGES: try: ex_ticker = ex.fetch_ticker(symbol) # TODO: Also catch urllib.error.HTTPError? except ccxt.errors.RequestTimeout: continue except TypeError: # Looks not to deal in this exchange continue except Exception as e: logger.warning(e) continue ex_count += 1 ex_ask = ex_ticker.get('ask') or 0 ex_bid = ex_ticker.get('bid') or 0 ex_volume = ex_ticker.get('quoteVolume') or 0 # Volume # print('-' * 30) # print('{}'.format(ex.name)) # print('Ask: {:.8f}'.format(ex_ask)) # print('Bid: {:.8f}'.format(ex_bid)) # print('Volume: {:.1f}'.format(ex_volume)) if MIN_VOLUME < ex_volume: # Price to sell if max_bid < ex_bid: max_bid = ex_bid max_bid_ex_name = ex.name max_bid_ex_url = ex_url max_bid_volume = ex_volume # Price to buy if ex_ask < min_ask: min_ask = ex_ask min_ask_ex_name = ex.name min_ask_ex_url = ex_url min_ask_volume = ex_volume profit = max_bid - min_ask profit_rate = (profit / min_ask) if min_ask != 0 else 0 # TODO: else float('inf') ? if profit_rate >= PROFIT_RATE_THRESHOLD: symbol_text = textwrap.dedent(u""" {symbol} ({ex_count}) -------------------- Sell at : {max_bid_ex_name:10} {max_bid_ex_url} Buy at : {min_ask_ex_name:10} {min_ask_ex_url} Bid : {max_bid:.8f} ({max_bid_volume:.1f} {base_currency}/day) Ask : {min_ask:.8f} ({min_ask_volume:.1f} {base_currency}/day) Profit : {profit:.8f} ({profit_rate:+.1%}) """).format( symbol=symbol, base_currency=BASE_CURRENCY.lower(), ex_count=ex_count, max_bid_ex_name=max_bid_ex_name, max_bid_ex_url=max_bid_ex_url.format(*symbol.split('/')), max_bid=max_bid, max_bid_volume=max_bid_volume, min_ask_ex_name=min_ask_ex_name, min_ask_ex_url=min_ask_ex_url.format(*symbol.split('/')), min_ask=min_ask, min_ask_volume=min_ask_volume, profit=profit, profit_rate=profit_rate, ).strip() # print('=' * 40) # print(symbol_text) symbol_texts.append((symbol_text, profit_rate)) # Sort by profit rate symbol_texts = [x[0] for x in sorted(symbol_texts, key=lambda x: x[1], reverse=True)] body = textwrap.dedent(u""" Date : {date} Top {number_of_altcoins} Currencies from {number_of_exchanges} Exchanges Volume Threshold : {min_volume} {base_currency}/day {symbol_text} """).format( date=now.strftime('%Y/%m/%d %H:%M:%S'), number_of_altcoins=DISPLAY_NUMBER_OF_ALTCOINS, number_of_exchanges=len(EXCHANGES), min_volume=MIN_VOLUME, base_currency=BASE_CURRENCY.lower(), symbol_text='\n\n'.join(symbol_texts), ).strip() print(body) email_client = EmailClient() # Send an email to myself email_client.send_test_email(u'[CC] Check Price Difference (by {})'.format(BASE_CURRENCY), body)
from email_client import EmailClient def send_spam(to): text = ("The best washing machines in town!\n\n" "Only now you can buy a new washing machine " "for the cheapest price ever. For more info " "go to www.best-washing-machines.com") frm = "*****@*****.**" subject = "Hi" client = EmailClient('smtp.server.com') client.send(from, to, subject, text)