import simplejson as json
from decimal import Decimal as D, ROUND_DOWN
from datetime import date, datetime
+import inspect
__all__ = ["BalanceStore", "ReportStore", "TradeStore"]
def default_json_serial(obj):
if isinstance(obj, (datetime, date)):
return obj.isoformat()
- raise TypeError ("Type %s not serializable" % type(obj))
+ return str(obj)
return json.dumps(self.logs, default=default_json_serial)
def set_verbose(self, verbose_print):
self.verbose_print = verbose_print
- def log_stage(self, stage):
+ def log_stage(self, stage, **kwargs):
+ def as_json(element):
+ if callable(element):
+ return inspect.getsource(element).strip()
+ elif hasattr(element, "as_json"):
+ return element.as_json()
+ else:
+ return element
+
+ args = { k: as_json(v) for k, v in kwargs.items() }
+ args_str = ["{}={}".format(k, v) for k, v in args.items()]
self.print_log("-" * (len(stage) + 8))
- self.print_log("[Stage] {}".format(stage))
+ self.print_log("[Stage] {} {}".format(stage, ", ".join(args_str)))
self.add_log({
"type": "stage",
"stage": stage,
+ "args": args,
})
def log_balances(self, tag=None):
compute_value, type):
values = {}
rates = {}
+ if callable(compute_value):
+ compute_value = inspect.getsource(compute_value).strip()
+
for currency, amount in amounts.items():
values[currency] = amount.as_json()["value"]
rates[currency] = amount.rate
})
def log_orders(self, orders, tick=None, only=None, compute_value=None):
+ if callable(compute_value):
+ compute_value = inspect.getsource(compute_value).strip()
self.print_log("[Orders]")
self.market.trades.print_all_with_order(ind="\t")
self.add_log({
def log_order(self, order, tick, finished=False, update=None,
new_order=None, compute_value=None):
+ if callable(compute_value):
+ compute_value = inspect.getsource(compute_value).strip()
if finished:
self.print_log("[Order] Finished {}".format(order))
elif update == "waiting":
amounts[currency] = ptt * amount / sum_ratio
if trade_type == "short":
amounts[currency] = - amounts[currency]
- if currency not in self.all:
- self.all[currency] = portfolio.Balance(currency, {})
+ self.all.setdefault(currency, portfolio.Balance(currency, {}))
self.market.report.log_dispatch(amount, amounts, liquidity, repartition)
return amounts
self.market = market
self.all = []
+ @property
+ def pending(self):
+ return list(filter(lambda t: t.pending, self.all))
+
def compute_trades(self, values_in_base, new_repartition, only=None):
computed_trades = []
base_currency = sum(values_in_base.values()).currency
def prepare_orders(self, only=None, compute_value="default"):
orders = []
- for trade in self.all:
+ for trade in self.pending:
if only is None or trade.action == only:
orders.append(trade.prepare_order(compute_value=compute_value))
self.market.report.log_orders(orders, only, compute_value)
+ def close_trades(self):
+ for trade in self.all:
+ trade.close()
+
def print_all_with_order(self, ind=""):
for trade in self.all:
trade.print_with_order(ind=ind)