def login(self):
username = request.data.get("username", False)
password = request.data.get("password", False)
log.debug(f"username: {username}")
log.debug(f"password: {password}")
if not username or not password:
return {"error": "invalid credentials"}
user = db.session().query(Users).filter(
and_(
Users.name == username,
Users.password == password
)
).one_or_none()
if not user:
return {"error": "invalid credentials"}
else:
token = Tokens()
token.ttl_max = "2021-12-12 12:00:00"
token.token = self.generate_token()
token.user = user
token.timestamp = datetime.now()
token.ttl_increment = 60
try:
db.session().add(token)
db.session().commit()
return {"token": token.token}
except Exception as e:
log.error(f"Could not create token: {e}")
return {"error": "could not create token"}
def validate_token(self, token, username):
record = db.session().query(Tokens).join(Users, Users.name == username).filter(
Tokens.token == token
).one_or_none()
if record is None:
log.debug("Invalid token")
return "invalid"
if record.ttl_max is None:
log.debug("Invalid token, ttl_max is None")
return "expired"
if datetime.now() > record.ttl_max:
log.debug(f"Token expired (was valid until: {record.ttl_max}), removing token.")
self.logout()
return "expired"
try:
record.timestamp = datetime.now()
db.session().commit()
except Exception as e:
log.error(f"Could not update token: {e}")
return "invalid"
log.debug("Token Valid")
return "valid"
def kraken_rest_api_to_psql(interval=1, pair="XXBTZEUR"):
log.info(
f"Retrieving past data for {pair} with interval {interval} from kraken REST Api"
)
url: str = f"https://api.kraken.com/0/public/OHLC?pair={pair}&interval={interval}"
data: dict = dict()
data["interval"] = interval
data["pair"] = pair
result: dict = requests.post(data=data, url=url).json()
num_kraken_records: int = len(result["result"][pair])
log.info(f"Got {num_kraken_records} records")
session: Session = db.session()
c: int = 0
for record in result["result"][pair]:
existing_record = session.query(exists().where(
and_(Ohlc.begintime == record[0],
Ohlc.interval == interval))).scalar()
if not existing_record:
r = Ohlc()
r.interval = interval
r.pair = "XBT/EUR"
r.begintime = record[0]
r.endtime = float(record[0]) + (interval * 60.0)
r.open = record[1]
r.high = record[2]
r.low = record[3]
r.close = record[4]
r.vwap = record[5]
r.count = record[6]
try:
db.session().add(r)
db.session.commit()
except Exception as e:
db.session.rollback()
log.warning(f"Failure inserting record: {e}")
else:
c += 1
log.info(
f"{c} record(s) skipped, {num_kraken_records - c} record(s) added.")
log.info("Done.")
def valid_api_key(api_name: str) -> bool:
try:
api_key = API_KEYS[api_name].__str__()
except KeyError:
log.error(
f"Could not find valid api_key for registering '{api_name}'-api"
)
sys.exit(0)
session = db.session()
active_api = session.query(ActiveAPI).filter(
ActiveAPI.api_name == api_name).one_or_none()
if active_api is None:
log.error(
f"Failure retrieving active API key from database for {api_name}"
)
return False
elif active_api.api_key != api_key:
log.error(
f"No valid API key for '{api_name}' (probably replaced by another websocket thread)"
)
return False
return True
def get_current_ticker_info(account: str = "kraken") -> dict:
"""
The ticker (current price) for a specific exchange.
:return: JSON with ticker information
"""
if account == "kraken":
kraken_api = krakenex.API()
data = {"pair": ["XXBTZEUR"]}
result = kraken_api.query_public("Ticker", data=data)
log.debug(result)
return {"account": account, "XXBTZEUR": result["c"][0]}
if account == "local":
record = (db.session().query(Ohlc).filter(Ohlc.interval == 1).order_by(
Ohlc.endtime.desc()).limit(1).one_or_none())
if record:
return {"account": account, "XXBTZEUR": record.close}
else:
return {"error": "no data available"}
else:
log.error("get_current_ticker_info(): No valid account given.")
return {"error": "No valid account"}
def getExistingOhlcEntry(pair, endtime, interval):
return (db.session().query(Ohlc).filter(
and_(
Ohlc.pair == pair,
Ohlc.endtime == endtime,
Ohlc.interval == interval,
)).order_by(Ohlc.time.desc()).first())
def write_data_chunk(data, flag):
try:
session = db.session()
log.debug('(%s) Adding `%s`' % (flag, data.filename))
session.add(data)
session.commit()
session.close()
except:
log.error('Error adding file `%s`', data.filename)
data.success = False
data.clear_data()
session = db.session()
session.add(data)
session.commit()
session.close()
def ohlc_data(ohlc_interval: int, limit: int = 50):
log.debug(f"Retrieving OHLC data ({ohlc_interval} minutes interval)")
data = [
x.as_canvasjs_datapoints() for x in db.session().query(Ohlc).filter(
Ohlc.interval == ohlc_interval).order_by(
Ohlc.endtime.desc()).limit(limit)
]
print(data)
return data
def logout():
token = request.data.get('token', False)
username = request.data.get("username", False)
record = db.session().query(Tokens).join(Users, Users.name == username).filter(
Tokens.token == token
).one_or_none()
if record is None:
return False
try:
log.debug(f"Removing token '{token}' for user '{username}'")
db.session().delete(record)
db.session().commit()
return True
except Exception as e:
log.error(f"{e}")
return False
def handle_ticker_data(data, **kwargs):
record = Ticker()
record.a_price = data[1]["a"][0]
record.a_whole_lot_volume = data[1]["a"][1]
record.a_lot_volume = data[1]["a"][2]
record.b_price = data[1]["b"][0]
record.b_whole_lot_volume = data[1]["b"][1]
record.b_lot_volume = data[1]["b"][2]
record.c_price = data[1]["c"][0]
record.c_lot_volume = data[1]["c"][1]
record.v_today = data[1]["v"][0]
record.v_24_hours = data[1]["v"][1]
record.p_today = data[1]["p"][0]
record.p_24_hours = data[1]["p"][1]
record.t_today = data[1]["t"][0]
record.t_24_hours = data[1]["t"][1]
record.l_today = data[1]["l"][0]
record.l_24_hours = data[1]["l"][1]
record.o_today = data[1]["o"][0]
record.o_24_hours = data[1]["o"][1]
record.pair = data[3]
record.timestamp = datetime.datetime.now().timestamp()
try:
db.session().add(record)
db.session().commit()
print("⇩", end="")
sys.stdout.flush()
except Exception as e:
db.session.rollback()
log.error(f"Could not insert ticker data: {str(e)}")
def get_latest_ticker(interval=0):
if interval == 0:
record = db.session().query(Ticker).order_by(
Ticker.timestamp.desc()).limit(1).one_or_none()
return record
else:
query = f"SELECT * FROM ticker WHERE to_timestamp(timestamp) > now() - interval '{interval} seconds'"
result = db.engine.execute(query)
data = [x for x in result]
return data
def register_api_handler(self, api_name: str):
try:
api_key = API_KEYS[api_name]
except KeyError:
log.error(
f"Could not find valid api_key for registering '{api_name}'-api"
)
self.websocket.stop()
log.info(f"Registering '{api_name}'-API with key: {api_key} ")
session = db.session()
record = ActiveAPI()
record.api_key = api_key
record.api_name = api_name
session.merge(record)
try:
session.commit()
except Exception as e:
print(e)
os.exit(1)
def trade_handler(data):
session = db.session()
pair = data[3]
for d in data[1]:
record = Trades()
record.pair = pair
record.price = float(d[0])
record.volume = float(d[1])
record.time = float(d[2])
record.side = str(d[3])
record.order_type = str(d[4])
record.misc = str(d[5])
session.add(record)
try:
session.commit()
print("↓", end="")
sys.stdout.flush()
except Exception as e:
print(e)
def delete_from_db(self):
db.session.delete(self)
db.session().commit()
def save_to_db(self):
db.session(self)
db.session.commit()
def save_to_db(self):
db.session().add(self)
db.session().commit()
def handle_ohlc_data(data, **kwargs):
# The Ohlc socket feeds us with updates of the given
# interval. If the windows is new, there is no record
# with an identical endtime, so we should insert.
# If there is a record with identical endtime, we should
# update the record, and we discard the trades of that
# window-interval (1m, 5m, 30m, 60m, ...)
def getExistingOhlcEntry(pair, endtime, interval):
return (db.session().query(Ohlc).filter(
and_(
Ohlc.pair == pair,
Ohlc.endtime == endtime,
Ohlc.interval == interval,
)).order_by(Ohlc.time.desc()).first())
interval = int(subscriptions[kwargs["channelId"]]["meta"]["interval"])
pair = subscriptions[kwargs["channelId"]]["pair"]
record = getExistingOhlcEntry(pair, data[1][1], interval)
try:
if record:
record.time = data[1][0]
record.begintime = float(data[1][1]) - (interval * 60.0)
record.endtime = data[1][1]
record.open = data[1][2]
record.high = data[1][3]
record.low = data[1][4]
record.close = data[1][5]
record.vwap = data[1][6]
record.volume = data[1][7]
record.count = data[1][8]
print("↺", end="")
sys.stdout.flush()
else:
record = Ohlc()
record.pair = data[3]
record.interval = interval
record.pair = pair
record.time = data[1][0]
record.endtime = data[1][1]
record.open = data[1][2]
record.high = data[1][3]
record.low = data[1][4]
record.close = data[1][5]
record.vwap = data[1][6]
record.volume = data[1][7]
record.count = data[1][8]
print("⇩", end="")
sys.stdout.flush()
db.session().add(record)
db.session().commit()
except Exception as e:
db.session.rollback()
print(f"Failure adding/updating ohcl: {e}")
