def buyp(self, price, amount):
orderId = None
cancel = False
try:
_, orderId = yield bitfinex.sell(self.data['pairs'], price, amount)
except Exception as err:
failure = Failure(err)
print(failure.getBriefTraceback())
else:
if orderId is not None:
print('SUCCESSFULLY BUYP:', orderId)
try:
order = yield bitfinex.getOrder(self.data['pairs'],
orderId)
except Exception as err:
failure = Failure(err)
print(failure.getBriefTraceback())
cancel = True
else:
if order.status != 'done':
cancel = True
if cancel:
self.state = 'wait'
self.reactor.callWhenRunning(self.cancel, orderId)
else:
self.data['buyp'] = orderId
self.data['buys'] = []
self.state = 'run'
def sell(exchange,coinPair,amount,price):
global state
global stateStr
global traded_count
orderId = None
if True:#balance >= amount:
try:
orderId = yield exchange.sell(coinPair,price,amount)
print(orderId)
stateStr += '| SELL:' + str(orderId)
except Exception as err:
failure = Failure(err)
stateStr += '| SELL ERROR:' + str(failure.getBriefTraceback())
print(failure.getBriefTraceback())
if orderId[1] is not None and orderId[0] == True:
print("SUCCESSFULLY SELL:", orderId[1])
stateStr += '| SUCCESSFULLY SELL:' + str(orderId[1])
traded_count += 1
try:
order = yield exchange.getOrder(coinPair,orderId)
except Exception as err:
failure = Failure(err)
stateStr += '| getOrder ERROR:' + str(failure.getBriefTraceback())
print(failure.getBriefTraceback())
state = "GO"
def test_writeFailure(self, logger):
"""
L{writeFailure} writes a L{Failure} to the log.
"""
if Failure is None:
raise SkipTest("Twisted unavailable")
try:
raise RuntimeError("because")
except:
failure = Failure()
expectedTraceback = failure.getBriefTraceback()
writeFailure(failure, logger)
message = logger.messages[0]
assertContainsFields(
self,
message,
{
"message_type": "eliot:traceback",
"exception": RuntimeError,
"reason": failure.value,
"traceback": expectedTraceback,
},
)
logger.flushTracebacks(RuntimeError)
def test_writeFailure(self, logger):
"""
L{writeFailure} writes a L{Failure} to the log.
"""
if Failure is None:
raise SkipTest("Twisted unavailable")
try:
raise RuntimeError("because")
except:
failure = Failure()
expectedTraceback = failure.getBriefTraceback()
writeFailure(failure, logger)
message = logger.messages[0]
assertContainsFields(
self,
message,
{
"message_type": "eliot:traceback",
"exception": RuntimeError,
"reason": failure.value,
"traceback": expectedTraceback,
},
)
logger.flushTracebacks(RuntimeError)
def log(self, category, eventDict):
"""
Log an event.
@param category: A short string identifying the type of log event.
The receiving log server may use this to collect all messages of the
same category in their own log files.
@type category: C{bytes}
@param eventDict: The event dictionary. As this is serialized to JSON
(see L{serialize}), for complex values, you may want to render them
to a string before adding them to the event dictionary.
@type eventDict: C{dict}
"""
self.augment(eventDict)
data = self.serialize(category, eventDict)
try:
self.socket.send(data)
except:
failure = Failure()
why = "Failed to send udplog message"
data = self.serializeFailure(category, eventDict, len(data),
failure, why)
try:
self.socket.send(data)
except Exception:
import sys
text = why + '\n' + failure.getBriefTraceback()
print >> sys.stderr, text
def log(self, category, eventDict):
"""
Log an event.
@param category: A short string identifying the type of log event.
The receiving log server may use this to collect all messages of the
same category in their own log files.
@type category: C{bytes}
@param eventDict: The event dictionary. As this is serialized to JSON
(see L{serialize}), for complex values, you may want to render them
to a string before adding them to the event dictionary.
@type eventDict: C{dict}
"""
self.augment(eventDict)
data = self.serialize(category, eventDict)
try:
self.socket.send(data)
except:
failure = Failure()
why = "Failed to send udplog message"
data = self.serializeFailure(category, eventDict, len(data),
failure, why)
try:
self.socket.send(data)
except Exception:
import sys
text = why + '\n' + failure.getBriefTraceback()
print >> sys.stderr, text
def receiveDirectMessage(self, senderName, messageText, metadata=None):
cmdline = string.split(messageText, ' ', 1)
if len(cmdline) == 1:
cmd, arg = cmdline[0], ''
else:
cmd, arg = cmdline
try:
getattr(self, "bot_%s" % cmd)(senderName, arg, metadata)
except:
f = Failure()
self.voice.directMessage(senderName, f.getBriefTraceback())
def cancel(self, orderId):
try:
result, data = yield bitfinex.cancel(self.data['pairs'], orderId)
except Exception as err:
failure = Failure(err)
print(failure.getBriefTraceback())
else:
if result:
print('SUCCESSFULLY CANCEL:', orderId)
self.state = 'run'
def buy(exchange, coinPair, amount, price):
global buy
global state
orderId = None
if True: #balance >= price*amount:
try:
orderId = yield exchange.buy(coinPair, price, amount)
print(orderId)
except Exception as err:
failure = Failure(err)
print(failure.getBriefTraceback())
if orderId[1] is not None and orderId[0] == True:
print("SUCCESSFULLY BUY:", orderId[1])
buys += 1
try:
order = yield exchange.getOrder(orderId, coinPair)
except Exception as err:
failure = Failure(err)
print(failure.getBriefTraceback())
def cbRun(self, exchange):
if self.running:
# print('running')
orderBook = [[], []]
try:
orderBook = yield EXCHANGE[exchange].getOrderBook(self.pairs)
except Exception as err:
failure = Failure(err)
print(failure.getBriefTraceback())
self.slots[exchange].setOrderBook(orderBook)
# print(orderBook)
yield self.cbRun(exchange)
def buyp(amount, price="", sellAmount=0):
global state
global buys
global buypId
orderId = None
try:
if price == "":
matchPrice = "1"
else:
matchPrice = "0"
orderId = yield okexFuture.trade(pairs,
price=price,
amount=str(round(amount)),
tradeType="3",
matchPrice=matchPrice)
except Exception as err:
failure = Failure(err)
print(failure.getBriefTraceback())
if orderId:
print("SUCCESSFULLY BUYP:", orderId)
try:
order = yield okexFuture.getOrder(pairs, orderId=orderId)
except Exception as err:
failure = Failure(err)
print(failure.getBriefTraceback())
else:
print(order)
buypId = orderId
if state == 'PPP':
if sellAmount > 0:
state = 'PPPsell'
reactor.callWhenRunning(sellp, amount=sellAmount)
else:
state = 'STOP'
else:
state = 'BUYPCHECK'
def sell(self, price, amount):
orderId = 0
try:
_, orderId = yield bitfinex.sell(self.data['pairs'], price, amount)
except Exception as err:
failure = Failure(err)
print(failure.getBriefTraceback())
else:
if orderId != 0:
print('SUCCESSFULLY SELL:', orderId)
self.data['sells'].append((price, amount))
self.state = 'run'
def buy(amount=1.0, price=""):
global state
global buys
global lastBuyAmount
orderId = None
try:
if price:
matchPrice = "0"
else:
matchPrice = "1"
orderId = yield okexFuture.trade(pairs,
price=price,
amount=str(round(amount)),
tradeType="1",
matchPrice=matchPrice)
print(orderId)
except Exception as err:
failure = Failure(err)
print(failure.getBriefTraceback())
if orderId:
print("SUCCESSFULLY BUY:", orderId)
try:
order = yield okexFuture.getOrder(pairs, orderId=orderId)
except Exception as err:
failure = Failure(err)
print(failure.getBriefTraceback())
else:
print(order)
price = order[0]['price']
buys.append((price, float(amount)))
data = shelve.open(dataFile)
data['buys'] = buys
lastBuyAmount = amount
data.close()
# time.sleep(1)
state = 'GO'
def cbRun(self, *args, **kwargs):
if self.running:
ticker = {}
try:
ticker = yield EXCHANGE[self.key].getTicker(*args, **kwargs)
except Exception as err:
failure = Failure(err)
print(failure.getBriefTraceback())
if ticker == {}:
self.slot.setData()
else:
self.slot.setData({'ticker': ticker})
yield self.cbRun(*args, **kwargs)
def sell(exchange, coinPair, amount, price):
global sell
global state
orderId = None
if True: #balance >= amount:
try:
orderId = yield exchange.sell(coinPair, price, amount)
print(orderId)
except Exception as err:
failure = Failure(err)
print(failure.getBriefTraceback())
if orderId[1] is not None and orderId[0] == True:
print("SUCCESSFULLY SELL:", orderId[1])
sells += 1
try:
order = yield exchange.getOrder(orderId, coinPair)
except Exception as err:
failure = Failure(err)
print(failure.getBriefTraceback())
state = "GO"
def cbRun(self, *args, **kwargs):
if self.running:
klines = []
try:
klines = yield EXCHANGE[self.key].getKLineLastMin(
*args, **kwargs)
except Exception as err:
failure = Failure(err)
print(failure.getBriefTraceback())
if klines == []:
self.slot.setData()
else:
self.slot.setData({'klines': klines})
yield self.cbRun(*args, **kwargs)
def cbRun(self, *args, **kwargs):
if self.running:
orderBook = {}
try:
orderBook = yield EXCHANGE[self.key].getOrderBook(
*args, **kwargs)
except Exception as err:
failure = Failure(err)
print(failure.getBriefTraceback())
if orderBook == {}:
self.slot.setData()
else:
self.slot.setData({'orderBook': orderBook})
yield self.cbRun(*args, **kwargs)
def sellp(amount, price=""):
global state
global sells
global sellpId
orderId = None
try:
if price == "":
matchPrice = "1"
else:
matchPrice = "0"
orderId = yield okexFuture.trade(pairs,
price=price,
amount=str(round(amount)),
tradeType="4",
matchPrice=matchPrice)
print(orderId)
except Exception as err:
failure = Failure(err)
print(failure.getBriefTraceback())
if orderId:
print("SUCCESSFULLY SELLP:", orderId)
try:
order = yield okexFuture.getOrder(pairs, orderId=orderId)
except Exception as err:
failure = Failure(err)
print(failure.getBriefTraceback())
else:
print(order)
sellpId = orderId
if state == 'PPPsell':
state = 'STOP'
else:
state = 'SELLPCHECK'
def cancel(orderId):
global state
result = False
data = -1
try:
result, data = yield okexFuture.cancel(pairs, orderId=orderId)
except Exception as err:
failure = Failure(err)
print(failure.getBriefTraceback())
if result:
print('SUCCESSFULLY CANCEL:', orderId)
print('cancel result:', data)
state = 'GO'
else:
state = 'GO'
def cbRun(self, *args, **kwargs):
if self.running:
data = {}
try:
data = yield EXCHANGE[self.key].getPosition(*args, **kwargs)
except Exception as err:
failure = Failure(err)
print(failure.getBriefTraceback())
if data == {}:
self.slot.setData()
else:
self.slot.setData({'position': data})
self.count += 1
if self.count % self.LIMIT == 0:
time.sleep(1)
self.count = 0
yield self.cbRun(*args, **kwargs)
def errback(self, failure: Failure):
"""
https://docs.scrapy.org/en/latest/topics/request-response.html
https://docs.scrapy.org/en/latest/topics/request-response.html#topics-request-response-ref-errbacks
:param failure:
:return:
"""
request = failure.request
url = request.url
_id = request.meta.get('_id', '')
res = {
'_id': _id,
'url': url,
'error_type': f"{failure.type}",
'msg': failure.getErrorMessage(),
'traceback': failure.getBriefTraceback(),
}
try:
status = failure.value.response.status
res.update({'status': status})
except:
pass
self.logger.error(json.dumps(res, ensure_ascii=False))
def _do_get_connection(account, conductor, ready, retries_left, backoff):
this_ready = defer.Deferred()
factory = ImapClientFactory(account, conductor, this_ready)
factory.connect()
try:
conn = yield this_ready
# yay - report we are good and tell the real callback we have it.
account.reportStatus(brat.EVERYTHING, brat.GOOD)
ready.callback(conn)
except Exception, exc:
fail = Failure()
logger.debug("first chance connection error handling: %s\n%s", fail.getErrorMessage(), fail.getBriefTraceback())
retries_left -= 1
if retries_left <= 0:
ready.errback(fail)
else:
status = failure_to_status(fail)
account.reportStatus(**status)
logger.warning("Failed to connect, will retry after %s secs: %s", backoff, fail.getErrorMessage())
next_backoff = min(backoff * 2, MAX_BACKOFF) # magic number
conductor.reactor.callLater(
backoff, _do_get_connection, account, conductor, ready, retries_left, next_backoff
)
def err(error: Failure):
print("ERROR ENCOUNTERED")
print(error.type)
print(error.value)
print(error.getBriefTraceback())
reactor.stop()
