def time_series_adjusted_download(symbol, update=False):
outputsize = ParamOutputSize.FULL.value
if update:
outputsize = ParamOutputSize.COMPACT.value
datatype = DataType.JSON.value
symbol = symbol.upper()
url = 'https://www.alphavantage.co/query?' \
'function=TIME_SERIES_DAILY_ADJUSTED&' \
'symbol={0}&outputsize={1}&datatype={2}&apikey={3}' \
.format(symbol, outputsize, datatype, GlobalConfigModel.retrieve('ALPHA_VANTAGE_KEY'))
r = requests.get(url)
json_string = r.text
obj = json.loads(json_string)['Time Series (Daily)']
with DB_CONFIG.transaction() as txn:
for key, value in obj.items():
m_open = str_to_float(value['1. open'])
high = str_to_float(value['2. high'])
low = str_to_float(value['3. low'])
close = str_to_float(value['4. close'])
adjusted_close = str_to_float(value['5. adjusted close'])
percent = adjusted_close / close
TimeSeriesDailyAdjustedModel.insert(
symbol=symbol,
date=key,
open=m_open,
high=high,
low=low,
close=close,
adjusted_open=float_to_float(m_open * percent),
adjusted_high=float_to_float(high * percent),
adjusted_low=float_to_float(low * percent),
adjusted_close=adjusted_close,
volume=int(value['6. volume']),
dividend_amount=str_to_float(value['7. dividend amount']),
split_coefficient=str_to_float(value['8. split coefficient'])
).on_conflict_ignore().execute()
txn.commit()
class JobScheduler:
SCHEDULER_NUM = 1
SCHEDULER_TIME_ZONE = GlobalConfigModel.retrieve('SCHEDULER_TIME_ZONE')
def __init__(self):
self.scheduler = BackgroundScheduler(
{'apscheduler.timezone': JobScheduler.SCHEDULER_TIME_ZONE})
self.scheduler_num = JobScheduler.SCHEDULER_NUM
JobScheduler.SCHEDULER_NUM += 1
self.scheduler.start()
self.jobs = {}
def create_job(self,
name,
app_id,
func,
triggers,
metadata,
args=None,
on_error=OnError.RETRY):
if name not in self.jobs:
job = Job(name=name,
app_id=app_id,
func=func,
triggers=triggers,
scheduler_num=self.scheduler_num,
args=args,
on_error=on_error,
scheduler=self.scheduler,
metadata=metadata)
self.jobs[name] = job
job.run()
return True
return False
def remove_job(self, name):
if name in self.jobs:
job = self.jobs[name]
job.remove()
del self.jobs[name]
def get_str_jobs(self):
return [job.get_info() for job in self.jobs.values()]
import bcrypt
from database.config.global_config_model import GlobalConfigModel
MASTER_SESSION_ID = GlobalConfigModel.retrieve('SESSION_ID').encode()
ALLOWED_SESSIONS = set()
def authenticate(func):
def inner(*args, **kwargs):
session_id = args[-1].get('session_id', None)
# Validate session id is present
if session_id is None:
return {'error': 'No session id'}, 401
# Validate session id is correct
if session_id not in ALLOWED_SESSIONS:
if not bcrypt.checkpw(session_id.encode(), MASTER_SESSION_ID):
return {'error': 'Session id incorrect'}, 401
ALLOWED_SESSIONS.add(session_id)
return func(*args, **kwargs)
return inner
class Gateway:
def __init__(self, app_manager, messenger):
self.app_manager = app_manager
self.messenger = messenger
def __init__(self):
super().__init__()
self.reddit = praw.Reddit(client_id=GlobalConfigModel.retrieve('CLIENT_ID'),
client_secret=GlobalConfigModel.retrieve('CLIENT_SECRET'),
user_agent='Test Script2')
from common.enums import Variant
from database.config.global_config_model import GlobalConfigModel
DEFAULT_DURATION = GlobalConfigModel.retrieve('MESSAGE_DEFAULT_DURATION')
DEFAULT_VARIANT = Variant.INFO
class Messenger:
def __init__(self, socketio):
self.socketio = socketio
def toast(self, toast):
config = {'message': toast.message,
'duration': toast.duration,
'variant': toast.variant
}
self.socketio.emit('toast-message', config)
class Toast:
IDENTIFIER = '<TOAST>'
def __init__(self, message, duration=DEFAULT_DURATION, variant=DEFAULT_VARIANT):
self.message = message
self.duration = duration
self.variant = variant
import csv
import os
import requests
from apps.baseapp import App
from common.enums import APP, Variant
from common.messenger import Toast
from constants import EXCHANGES_DIR, STATIC_DIR, ROOT_DIR
from database.config.global_config_model import GlobalConfigModel
USER_AGENT = GlobalConfigModel.retrieve('USER_AGENT')
class ExchangeUpdater(App):
"""
Updates CSV file of exchanges.
"""
APP_ID = APP.EXCHANGE_UPDATER
FILE_NAME = 'ALL.CSV'
URL = 'https://api.nasdaq.com/api/screener/stocks?tableonly=true&limit=25&offset=0&download=true'
HEADERS = {'User-Agent': USER_AGENT,
'Referer': 'https://www.nasdaq.com',
'Origin': 'https://www.nasdaq.com/',
'Host': 'api.nasdaq.com'
}
def __init__(self):
super().__init__()
self.dir_path = os.path.join(ROOT_DIR, STATIC_DIR, EXCHANGES_DIR)
def __init__(self):
super().__init__()
self.config_map = {**LocalConfigModel.retrieve_all(), **GlobalConfigModel.retrieve_all()}
def refresh_config_map(self):
self.config_map = {**LocalConfigModel.retrieve_all(), **GlobalConfigModel.retrieve_all()}
from enum import Enum
from threading import Timer
from twilio.rest import Client
from common.logger import log, LogLevel
from database.config.local_config_model import LocalConfigModel
from database.config.global_config_model import GlobalConfigModel
TWILIO_SID = GlobalConfigModel.retrieve('TWILIO_SID')
TWILIO_TOKEN = GlobalConfigModel.retrieve('TWILIO_TOKEN')
TWILIO_FROM_NUMBER = GlobalConfigModel.retrieve('TWILIO_FROM_NUMBER')
TWILIO_TO_NUMBER = GlobalConfigModel.retrieve('TWILIO_TO_NUMBER')
batch_messages = []
dead_switch = True
class When(Enum):
ONCE = 0
NOW = 1
NEXT = 2
BATCH = 3
def send(msg, requester=None, when=When.NOW):
log_message = ''
if requester:
log_message += '(Requester: {0})'.format(requester)
log_message += ' ' + msg
from flask import Flask, request, send_file
from flask_cors import CORS
from flask_socketio import SocketIO
from apps.app_manager import AppManager
from apps.gateway import Gateway
from common.logger import log
from common.messenger import Messenger
from database.config.global_config_model import GlobalConfigModel
app = Flask(__name__)
app.config['SECRET_KEY'] = GlobalConfigModel.retrieve('FLASK_SECRET_KEY')
socketio = SocketIO(app, cors_allowed_origins='*', cookie=False)
CORS(app)
gateway = Gateway(AppManager(), Messenger(socketio))
log('Flask', 'Deployed')
@app.route('/')
def main():
return 'Luminarias Server'
@app.route('/<string:command>', methods=['POST'])
def raw(command):
data = request.get_json()
return gateway.raw(command, data)
@app.route('/<action>/<string:app_id>/<string:command>', methods=['POST'])
def enact(action, app_id, command):