def __init__(self, state: PricebookProcessorState, reader):
self._reader = reader
self.source_currency, self.target_currency = parse_pair(
self._reader.pair)
self._current_index = state.current_index
self._current_time = state.current_time
self._processor = PricebookProcessor(self._reader.pair)
state.inject_to(self._processor)
def __init__(self, target_currency: str, currency_pairs: List[str],
connector: ConnectorBase):
self._target_currency = target_currency
self._currencies = set()
self._currency_pairs = set()
self._connector = connector
for pair in currency_pairs:
self._currency_pairs.add(pair)
self._currencies.update(parse_pair(pair))
def get_bid_asks(self):
result = []
present = self._market.present
for pair in self._market.direct_currency_pairs:
sc, tc = parse_pair(pair)
if tc != self._market.target_currency:
continue
pb = present.get_pricebook(sc, tc)
result.append([sc] + pb.bid_ask)
return result
def _start_server(self, target_currency, supported_currencies,
direct_pairs):
from flask import Flask, render_template
from flask_bootstrap import Bootstrap
server = Flask(__name__)
server.secret_key = b'fesdfsfr234\n\xec]/'
Bootstrap(server)
supported_currencies = sorted(supported_currencies)
supported_currencies.remove(target_currency)
supported_currencies.insert(0, target_currency)
direct_pairs = sorted(direct_pairs)
direct_pairs = [parse_pair(pair) for pair in direct_pairs]
@server.route("/request_transfer", methods=["POST"])
def _request_transfer():
source_currency = request.json.get("source_currency")
source_amount = request.json.get("source_amount")
target_currency = request.json.get("target_currency")
message = self._web_request_transfer(source_amount,
source_currency,
target_currency)
return jsonify({"message": message})
@server.route("/", methods=["GET", "POST"])
def _interface_index():
return render_template("index.html",
supported_currencies=supported_currencies,
direct_pairs=direct_pairs,
username=get_username())
@server.route("/interface_state")
def _interface_state():
state = self.interface_state
if state is None:
return "null"
return jsonify(state)
import logging
log = logging.getLogger('werkzeug')
log.setLevel(logging.ERROR)
Thread(target=lambda: server.run(
debug=True, use_reloader=False, host='0.0.0.0', port=self.web_port
),
daemon=True).start()
def is_available(self):
"""
Determine whether the snasphot is available for all traded pairs.
It can happen that when too far history is requested, some of the pair data won't be available.
"""
try:
for pair in self._market.direct_currency_pairs:
if not self._connector.get_pricebook(
*parse_pair(pair), self._current_time).is_synchronized:
return False
except TradeEntryNotAvailableException:
return False
return True
def update_portfolio(self, portfolio: PortfolioController):
if not self._is_web_started:
self._is_web_started = True
self._start_server(portfolio.target_currency, portfolio.currencies,
portfolio.pairs)
self._last_portfolio = portfolio
present = portfolio.present
state = {}
state["timestamp"] = present.timestamp
state["total_value"] = portfolio.total_value.amount
state["funds"] = funds = {}
for currency in portfolio.currencies:
funds[currency] = {
"amount": 0.0,
"initial_value": 0.0,
"current_value": 0.0
}
for currency, position in portfolio._current_portfolio_state[
"positions"].items():
amount = 0.0
initial_value = 0.0
for bucket in position:
amount += bucket["amount"]
initial_value += bucket["initial_value"]
current_value = present.get_value(Fund(amount, currency)).amount
funds[currency].update({
"amount": amount,
"initial_value": initial_value,
"current_value": current_value
})
state["prices"] = prices = {}
for pair in portfolio.pairs:
orderbook = present.get_pricebook(*parse_pair(pair))
prices[pair] = {
"b": orderbook.buy_levels[0][0],
"s": orderbook.sell_levels[-1][0]
}
self.interface_state = state
def set_run_end(self, end_timestamp):
for reader in self._readers:
pricebook = self.get_pricebook(*parse_pair(reader.pair),
end_timestamp)
self._reader_limits[reader] = pricebook._current_index