import time
-from datetime import datetime
+from datetime import datetime, timedelta
from decimal import Decimal as D, ROUND_DOWN
# Put your poloniex api key in market.py
from json import JSONDecodeError
URL = "https://cryptoportfolio.io/wp-content/uploads/portfolio/json/cryptoportfolio.json"
liquidities = {}
data = None
+ last_date = None
@classmethod
- def repartition(cls, liquidity="medium"):
- cls.parse_cryptoportfolio()
+ def wait_for_recent(cls, delta=4):
+ cls.repartition(refetch=True)
+ while cls.last_date is None or datetime.now() - cls.last_date > timedelta(delta):
+ time.sleep(30)
+ cls.repartition(refetch=True)
+
+ @classmethod
+ def repartition(cls, liquidity="medium", refetch=False):
+ cls.parse_cryptoportfolio(refetch=refetch)
liquidities = cls.liquidities[liquidity]
- cls.last_date = sorted(liquidities.keys())[-1]
return liquidities[cls.last_date]
@classmethod
cls.data = None
@classmethod
- def parse_cryptoportfolio(cls):
- if cls.data is None:
+ def parse_cryptoportfolio(cls, refetch=False):
+ if refetch or cls.data is None:
cls.get_cryptoportfolio()
def filter_weights(weight_hash):
weights_hash = portfolio_hash["weights"]
weights = {}
for i in range(len(weights_hash["_row"])):
- weights[weights_hash["_row"][i]] = dict(filter(
+ date = datetime.strptime(weights_hash["_row"][i], "%Y-%m-%d")
+ weights[date] = dict(filter(
filter_weights,
map(clean_weights(i), weights_hash.items())))
return weights
"medium": medium_liquidity,
"high": high_liquidity,
}
+ cls.last_date = max(max(medium_liquidity.keys()), max(high_liquidity.keys()))
class Computation:
computations = {
return Amount(self.currency, abs(self.value))
def __add__(self, other):
+ if other == 0:
+ return self
if other.currency != self.currency and other.value * self.value != 0:
raise Exception("Summing amounts must be done with same currencies")
return Amount(self.currency, self.value + other.value)
raise Exception("Summing amounts must be done with same currencies")
return Amount(self.currency, self.value - other.value)
+ def __rsub__(self, other):
+ if other == 0:
+ return -self
+ else:
+ return -self.__sub__(other)
+
def __mul__(self, value):
if not isinstance(value, (int, float, D)):
raise TypeError("Amount may only be multiplied by numbers")
ticker = ticker["original"]
rate = Computation.compute_value(ticker, self.order_action(inverted), compute_value=compute_value)
+ #TODO: store when the order is considered filled
+ # FIXME: Dust amount should be removed from there if they werent
+ # honored in other sales
delta_in_base = abs(self.value_from - self.value_to)
# 9 BTC's worth of move (10 - 1 or 1 - 10 depending on case)
print(self)
for order in self.orders:
print("\t", order, sep="")
+ for mouvement in order.mouvements:
+ print("\t\t", mouvement, sep="")
class Order:
def __init__(self, action, amount, rate, base_currency, trade_type, market,
# rate * total = total_in_base
self.total_in_base = Amount(base_currency, hash_.get("total", 0))
+ def __repr__(self):
+ if self.fee_rate > 0:
+ fee_rate = " fee: {}%".format(self.fee_rate * 100)
+ else:
+ fee_rate = ""
+ if self.date is None:
+ date = "No date"
+ else:
+ date = self.date
+ return "Mouvement({} ; {} {} ({}){})".format(
+ date, self.action, self.total, self.total_in_base,
+ fee_rate)
+
if __name__ == '__main__': # pragma: no cover
from market import market
h.print_orders(market)