update

util/candlestick.py

@@ -0,0 +1,74 @@
+import asyncio
+import datetime
+
+
+MAX_CANDLES = 200
+
+OPEN  = 0
+HIGH  = 0
+LOW   = 0
+CLOSE = 0
+
+class Candlestick:
+  def __init__(self, ticker, interval):
+    self.values   = []
+    self.latest   = None
+    self.interval = interval
+
+    self._ticker   = ticker
+    self._event    = asyncio.Event()
+
+    asyncio.create_task(self._refresh_and_start())
+
+  async def _refresh_and_start(self):
+    self.values = await self._fetch(datetime.datetime.now(tz=datetime.timezone.utc))
+    asyncio.create_task(self._ticker_watcher())
+    asyncio.create_task(self._main())
+
+  async def _fetch(self, data, depth = 0, rem = MAX_CANDLES):
+    assert(False)
+
+  async def _ticker_watcher(self):
+    while True:
+      await self._ticker.wait()
+      v = self._ticker.price
+      if self.latest is None:
+        self.latest = [v, -1e100, 1e100, None]
+      self.latest[1] = max(self.latest[1], v)
+      self.latest[2] = min(self.latest[2], v)
+      self.latest[3] = v
+
+  async def _main(self):
+    while True:
+      await asyncio.sleep(self.interval)
+      if self.latest is None:
+        if len(self.values) == 0:
+          continue
+        self.latest = self.values[0]
+      n = min(MAX_CANDLES-1, len(self.values))
+      self.values = [self.latest, *self.values[0:n]]
+      self.latest = None
+      self._event.set()
+      self._event.clear()
+
+  async def wait(self):
+    await self._event.wait()
+
+  def SMA(self, period, offset=0, type = CLOSE):
+    sum = 0
+    end = min(period+offset, len(self.values))
+    for i in range(offset, end):
+      sum += self.values[i][type]
+    return sum / (end - offset)
+
+  def EMA(self, period, offset=0, type = CLOSE):
+    end = min(period+offset, len(self.values))
+    n   = end - offset
+
+    ret = 0
+    for i in range(offset, end):
+      ret += self.values[i][type]
+    ret /= n
+    for i in range(offset, end):
+      ret += (2/(n+1)) * (self.values[i][type] - ret)
+    return ret

util/depth.py

@@ -0,0 +1,21 @@
+import asyncio
+
+
+MAX_ITEMS = 10
+
+class Depth:
+  def __init__(self):
+    self.bids = []
+    self.asks = []
+
+    self._event = asyncio.Event()
+
+  async def wait(self):
+    await self._event.wait()
+
+  def askVolumeUntil(self, price):
+    ret = 0
+    for i in range(len(self.asks)):
+      if self.asks[i][0] > price: break
+      ret += self.asks[i][1]
+    return ret

util/pair.py

@@ -0,0 +1,51 @@
+import asyncio
+
+class Pair:
+  def __init__(self, name):
+    self.name   = name
+    self.ticker = None
+
+    self.candlestick_1s = None
+    self.candlestick_1m = None
+    self.candlestick_1h = None
+
+    self.order_unit = None
+    self.price_unit = None
+
+  def buy_market(amount):
+    assert(False)
+
+  def sell_market(amount):
+    assert(False)
+
+  def buy_limit(amount, price):
+    assert(False)
+
+  def sell_limit(amount, price):
+    assert(False)
+
+  def buy_stop(amount, price):
+    assert(False)
+
+  def sell_stop(amount, price):
+    assert(False)
+
+  def buy_stop_limit(amount, trigger, price):
+    assert(False)
+
+  def sell_stop_limit(amount, trigger, price):
+    assert(False)
+
+
+class Order:
+  def __init__(self):
+    self.price  = None
+    self.amount = None
+    self.remain = None
+    self.done   = False
+
+  async def update(self):
+    assert(False)
+
+  async def cancel(self):
+    assert(False)

util/ticker.py

@@ -0,0 +1,14 @@
+import asyncio
+
+class Ticker:
+  def __init__(self, pair):
+    self.pair   = pair
+    self.price  = None
+    self.sell   = None
+    self.buy    = None
+    self.volume = None
+    self.ts     = None
+    self._event = asyncio.Event()
+
+  async def wait(self):
+    await self._event.wait()