Ejemplo n.º 1
0
def FCPrice(access,symbol):
  db = pymysql.connect(
    config.MySqlConfig.host,
    config.MySqlConfig.mysql_user,
    config.MySqlConfig.mysql_passwd,
    config.MySqlConfig.db,
  )
  cursor = db.cursor()
  sql = 'SELECT api,api_secret FROM accesses WHERE name = "'+access+'"'
  cursor.execute(sql)
  res = cursor.fetchone()
  api=res[0]
  secret=res[1]
  #print(res[0],res[1])
  #  t
  cursor.close()
  db.close()
  bot = Binance(
    API_KEY=api,
    API_SECRET=secret
  )
  price=bot.tickerPrice(
    symbol=symbol
  ) 


  return  price['price']
Ejemplo n.º 2
0
 def __init__(self, market, type, stopsize, interval):
     self.binance = Binance(api_key=config.API_DETAILS['API_KEY'],
                            api_secret=config.API_DETAILS['API_SECRET'])
     self.market = market
     self.type = type
     self.stopsize = stopsize
     self.interval = interval
     self.running = False
     self.stoploss = self.initialize_stop()
def test_authentication_from_json_file():
    """
    Test authentication with bad path to `json` format file.

    Expect `FileNotFoundError`.
    """
    # Import third-party modules
    from pytest import raises

    with raises(FileNotFoundError) as invalidPath:
        Binance.from_json_file('noSuchPath/credentials.json')

        err = ("No such file or directory: 'noSuchPath/credentials.json'")
        err in str(invalidPath.value)
Ejemplo n.º 4
0
class TestBinance:
    exchange = Binance()

    @pytest.mark.asyncio
    async def test_connection(self):
        """
            Check if Binance available
        """

        response = await self.exchange.ping()
        assert type(response) == dict

    @pytest.mark.asyncio
    async def test_exchange_info(self):
        """
            Check exchange info
        """

        exchange_info = await self.exchange.get_info()
        assert 'symbols' in exchange_info.keys()

    @pytest.mark.asyncio
    async def test_symbols(self):
        """
            Check symbols
        """

        symbols = await self.exchange.get_symbols()
        assert len(symbols) > 0
Ejemplo n.º 5
0
    def __init__(self, args):
        self._tz = timezone.utc  # utc timezone
        self._ts = datetime.now(self._tz).timestamp()

        if len(args) != 3:
            print("number of args does not match")
            exit()

        with open(args[1], "r") as f:
            jsonData = json.load(f)
            self._config = jsonData
            print('Configuration file {} loaded'.format(args[1]))
            print(json.dumps(self._config, sort_keys=True, indent=4))

        # logging configuration
        logger = getLogger(__name__)
        logger.setLevel(logging.DEBUG)

        # create file handler
        fh = logging.FileHandler('yourfilename.log')
        fh.setLevel(logging.DEBUG)
        fh_formatter = logging.Formatter(
            '%(levelname)s : %(asctime)s : %(message)s')
        fh.setFormatter(fh_formatter)

        # create console handler
        ch = logging.StreamHandler()
        ch.setLevel(logging.INFO)
        ch_formatter = logging.Formatter(
            '%(levelname)s : %(asctime)s : %(message)s')
        ch.setFormatter(ch_formatter)

        # add the handlers to the logger
        logger.addHandler(fh)
        logger.addHandler(ch)
        self._logger = logger

        if "LOG_LEVEL" in self._config:
            if self._config["LOG_LEVEL"] in [
                    "CRITICAL",
                    "ERROR",
                    "WARNING",
                    "INFO",
                    "DEBUG",
            ]:
                self._logger.setLevel(
                    eval("logging." + self._config["LOG_LEVEL"]))

        self._exchange = Binance(symbol=self._config["SYMBOL"],
                                 apiKey=self._config["APIKEY"],
                                 secret=self._config["SECRET"],
                                 logger=self._logger)

        # load your strategy
        module = machinery.SourceFileLoader("Strategy", args[2]).load_module()
        self._Strategy = module.Strategy(self)

        message = "Botter initialized with {}".format(args[1])
        self._logger.info(message)
Ejemplo n.º 6
0
 def on_status(self, status):
     if is_retweet(status._json): return
     msg = status.text
     if 'doge' in msg.lower() and status.author.id == 44196397:
         print(
             f'WOOOOOO ELON HAS TWEETED, LETS BUY!!!! here is the tweet: {msg}'
         )
         Binance().buy()  # the big elon has spoken, BUY DOGE!!!
def main():
    my_instance = CoinCap()
    instance_binance = Binance()
    timestamp = strftime("%Y_%m_%d %H_%M_%S", gmtime())

    filecoincap = open("coincapio_front_" + timestamp + ".txt", "w")

    front_list = my_instance.get_front()
    for front_item in front_list:
        for front_item_detail in front_item:
            filecoincap.write(front_item_detail + ": " +
                              str(front_item.get(front_item_detail)) + "\n")

    filecoincap.close()

    filebinance = open("binance_klines_" + timestamp + ".txt", "w")

    kline = instance_binance.get_klines('BTCUSDT', '1m')

    filebinance.write(str(kline))

    filebinance.close()
Ejemplo n.º 8
0
def binance() -> Binance:
    """
    Instantiate `Binance` class.

    This object will be used throughout the testing of Binance API SDK.

    Currently, the API key and secret are sourced from a `.env` file.
    Since `.env` files are not being uploaded to project repositories, this
    has to change to sourcing the parameters from a vault.
    """
    dotenv = '.env'  # Relative path to `.env` file
    binance = Binance.from_env_file(dotenv)

    return binance
Ejemplo n.º 9
0
    def __init__(self, ticker):
        super().__init__()
        self.setupUi(self)
        self.timer = QTimer(self)
        self.timer.start(3000)
        self.timer.timeout.connect(self.check)

        with open('key.txt', 'r') as f:
            keys = list(csv.reader(f, delimiter="/"))

        self.upbit = Upbit(upbit_access_key=keys[0][1],
                           upbit_secret_key=keys[0][2])
        self.binance = Binance(binance_access_key=keys[1][1],
                               binance_secret_key=keys[1][2])
        self.ticker = ticker
Ejemplo n.º 10
0
    def __init__(self):
        self.bot = Telegram_bot()

        with open('key.txt', 'r') as f:
            keys = list(csv.reader(f, delimiter="/"))
        self.upbit = Upbit(upbit_access_key=keys[0][1],
                           upbit_secret_key=keys[0][2])
        self.binance = Binance(binance_access_key=keys[1][1],
                               binance_secret_key=keys[1][2])

        self.newest_news = {}
        self.url = 'https://api-manager.upbit.com/api/v1/notices?page=1&per_page=20&thread_name=general'
        self.listing_url = 'https://api-manager.upbit.com/api/v1/notices/search?search=%5B%EA%B1%B0%EB%9E%98%5D&page=1&per_page=20&before=&target=non_ios&thread_name=general'
        self.headers = {
            "User-Agent":
            "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:66.0) Gecko/20100101 Firefox/66.0",
            "Accept-Encoding": "*",
            "Connection": "keep-alive"
        }
Ejemplo n.º 11
0
        res[p] = []

    for trade in all_trades:
        for p in columns:
            res[p].append(trade[p])

    return res


if __name__ == '__main__':
    with open('keys.json') as key_file:
        keys = json.load(key_file)
        key_binance = keys['binance2']

    # exchange instance
    binance = Binance(key_binance['key'], key_binance['secret'])

    # get all trading pairs
    all_tickers = binance.api.get_all_tickers()
    all_pairs = map(lambda x: x['symbol'], all_tickers)
    all_pairs = list(filter(lambda x: x[-3:] == 'BTC', all_pairs))

    # calculate all trade profits
    print('calculating ...')
    all_trades = []
    finished = 0
    task_count = len(all_pairs)
    target = 0.1
    for pair in all_pairs:
        # add all trades of this pair
        all_trades.extend(get_profit_details(pair))
Ejemplo n.º 12
0
from binance import Binance
import json

if __name__ == '__main__':
    api_key = 'key'
    secret_key = 'secret'
    binance = Binance(api_key, secret_key)

    # print binance.get_allPrices()
    print binance.get_balance('ETH')
    # print json.dumps(binance.get_withdraw_history(asset='ETH'), indent = 2)
    # print json.dumps(binance.get_deposit_history(), indent = 2)

    # for deposit in binance.get_deposit_history(asset='eth')['depositList']:
    #     print json.dumps(deposit, indent = 2)
    # print json.dumps(binance.get_deposit_history(), indent = 2 )

    # def on_message(ws, message):
    #     print 'dodooo'
    #     print message
    #
    # ws = binance.ws_depth('ethbTC')
    # ws = binance.ws_kline('MCOETH', '1m')
    # ws.on_message = on_message
    # ws.run_forever()

    # binance.ws_kline('ETHBTC', '1m', on_message)
    # binance.ws_aggTrade('ETHBTC', on_message)
    # binance.ws_user_data(on_message)
    # binance.get_server_time()
    # print binance.get_all_orders("LTCBTC")
Ejemplo n.º 13
0
# reload(sys)
# sys.setdefaultencoding("utf-8")

TULING_KEY = '12f1fc86573e49498efe7882746aa66d'

# 初始化微信机器人
#bot = Bot(cache_path=True, console_qr=True)

# 初始化tuling 机器人
# tuling = Tuling(api_key=TULING_KEY)

# 进行测试的好友
#my_friend = ensure_one(bot.search('龙光'))
#print(my_friend)

ba = Binance()
okex = OKEX()
huobi = HuoBi()
zb = ZB()
coincap = CoinMarketCap()
logger = Logger().get_log()


def query_price_by_exchange(_exchange, _symbol):
    if _symbol and _exchange and len(_symbol) > 2 and len(_exchange) > 1:
        if 'HB' == _exchange:
            return huobi.get_coin_price_api(_symbol)
        elif 'BA' == _exchange:
            return ba.get_coin_price_api(_symbol)
        elif 'OK' == _exchange:
            return okex.get_coin_price_api(_symbol)
Ejemplo n.º 14
0
from utils import read_key_secret, draw_table
from yobit import Yobit
from crex import Crex
from binance import Binance

#####################
# DRAW CREX BINANCE #
#####################
bn_key, bn_secret = read_key_secret('binance_token.txt')
bn = Binance(bn_key, bn_secret)
draw_table(bn.get_wallet())

#####################
# DRAW CREX WALLET  #
#####################
cr_key, cr_secret = read_key_secret('crex_token.txt')
cr = Crex(cr_key, cr_secret)
draw_table(cr.get_wallet())

#####################
# DRAW YOBIT WALLET #
#####################
yb_key, yb_secret = read_key_secret('yobit_token.txt')
yb = Yobit(yb_key, yb_secret)
draw_table(yb.get_wallet())
Ejemplo n.º 15
0

if __name__ == "__main__":
    # data management
    lock = threading.Lock()
    orderbooks = {
        "Binance": {},
        "Huobi": {},
        "Upbit": {},
        "last_update": None,
    }

    # create websocket threads
    binance = Binance(
        url="wss://stream.binance.com:9443/ws/steembtc@depth",
        exchange="Binance",
        orderbook=orderbooks,
        lock=lock,
    )

    huobi = Huobi(
        url="wss://api.huobipro.com/ws",
        exchange="Huobi",
        orderbook=orderbooks,
        lock=lock,
    )

    upbit = Upbit(
        url="wss://api.hitbtc.com/api/2/ws",
        exchange="Upbit",
        orderbook=orderbooks,
        lock=lock,
Ejemplo n.º 16
0
class StopTrail():
    def __init__(self, market, type, stopsize, interval):
        self.binance = Binance(api_key=config.API_DETAILS['API_KEY'],
                               api_secret=config.API_DETAILS['API_SECRET'])
        self.market = market
        self.type = type
        self.stopsize = stopsize
        self.interval = interval
        self.running = False
        self.stoploss = self.initialize_stop()

    def initialize_stop(self):
        if self.type == "buy":
            return (self.binance.get_price(self.market) + self.stopsize)
        else:
            return (self.binance.get_price(self.market) - self.stopsize)

    def update_stop(self):
        price = self.binance.get_price(self.market)
        if self.type == "sell":
            if (price - self.stopsize) > self.stoploss:
                self.stoploss = price - self.stopsize
                print("New high observed: Updating stop loss to %.8f" %
                      self.stoploss)
            elif price <= self.stoploss:
                self.running = False
                amount = self.binance.get_balance(self.market.split("/")[0])
                price = self.binance.get_price(self.market)
                self.binance.sell(self.market, amount, price)
                print("Sell triggered | Price: %.8f | Stop loss: %.8f" %
                      (price, self.stoploss))
        elif self.type == "buy":
            if (price + self.stopsize) < self.stoploss:
                self.stoploss = price + self.stopsize
                print("New low observed: Updating stop loss to %.8f" %
                      self.stoploss)
            elif price >= self.stoploss:
                self.running = False
                balance = self.binance.get_balance(self.market.split("/")[1])
                price = self.binance.get_price(self.market)
                amount = balance / price
                self.binance.buy(self.market, amount, price)
                print("Buy triggered | Price: %.8f | Stop loss: %.8f" %
                      (price, self.stoploss))

    def print_status(self):
        last = self.binance.get_price(self.market)
        print("---------------------")
        print("Trail type: %s" % self.type)
        print("Market: %s" % self.market)
        print("Stop loss: %.8f" % self.stoploss)
        print("Last price: %.8f" % last)
        print("Stop size: %.8f" % self.stopsize)
        print("---------------------")

    def run(self):
        self.running = True
        while (self.running):
            self.print_status()
            self.update_stop()
            time.sleep(self.interval)
Ejemplo n.º 17
0
ratio = 0.98
#设置利润
factor = 1.01
count = 0
# 终止程序的退出码
exit_code = 2
# 刷新时间
refreshTime = 1
# 操作等待时间
wait_time = 0.2
#设置查看的深度
depth_size = 5
# 设置btc的账户最小值
min_btc = 0.1

binance_instance = Binance()
huobi_instance = Huobi()

time.sleep(15)
while(trade_time):
	# 查询账户余额是否足够交易
	binance_btc_balance = binance_instance.balance(binance_btc_name)
	huobi_btc_balance = huobi_instance.balance(huobi_btc_name)
	binance_ont_balance = binance_instance.balance(binance_ont_name)
	huobi_ont_balance = huobi_instance.balance(huobi_ont_name)

	if float(binance_btc_balance) < min_btc or float(huobi_btc_balance) < min_btc:
		print("btc low!")
		time.sleep(60)
		continue
# - binance

obs = None
# obs = TickerObserver()

Exchanges = [
    #    BitFinex(ticker_observer=obs, markets=BitFinex.all_markets),
    #    BitMEX(ticker_observer=obs, markets=BitMEX.all_markets),
    # BitMEX(ticker_observer=obs, markets=['btc_usd', 'eth_btc', 'ltc_btc']),
    # BitFinex(ticker_observer=obs, markets=['btc_usd', 'eth_btc', 'btc_eur', 'eth_usd']),

    # GDAX(ticker_observer=obs, markets=['btc_usd', 'btc_eur', 'eth_eur', 'eth_usd', 'eth_btc']),

    #   GDAX(ticker_observer=obs, markets=GDAX.all_markets),
    # GDAX(ticker_observer=obs, markets=['btc_usd']),
    Binance(ticker_observer=obs, markets=Binance.all_markets),

    # Binance(ticker_observer=obs, markets=['eth_btc', 'ltc_btc', ]),

    # Binance(markets=['eth_btc', ])#, 'bnb_btc', 'eos_btc']),
    # BitMEX(markets=['btc_usd'], ticker_observer=obs)#, 'ada_btc', 'bch_btc', 'xrp_btc', 'btc_usd', 'eth_btc', 'ltc_btc']),

    # Binance(markets=['eth_btc', ])
    # GDAX(markets=['ltc_usd', ]),
    # CryptoExchange(url="wss://api.bitfinex.com/ws/", symbol="BTCUSD"),
]


async def closer():
    while True:
        await asyncio.sleep(5)
Ejemplo n.º 19
0
import websockets
import time
import datetime

from binance import Binance
from coinbase import Coinbase
from bittrex import Bittrex

host = 'localhost'
port = 5678

loop = asyncio.get_event_loop()
curr_time = lambda: datetime.datetime.fromtimestamp(int(time.time())).strftime(
    '%m-%d-%Y %H:%M:%S')

BINANCE = Binance(ohlc='1m', depth=5, ping=3, hours=23)
COINBASE = Coinbase()
BITTREX = Bittrex()


async def start(websocket, path):
    print('Opening Server @ {}'.format(curr_time()))
    tasks = [
        loop.create_task(BINANCE.start(loop, websocket)),
        loop.create_task(COINBASE.start(loop, websocket)),
        loop.create_task(BITTREX.start(loop, websocket))
    ]
    await asyncio.wait(tasks)


def connection(loop, host='localhost', port=5678):
Ejemplo n.º 20
0
import requests
import json
import time
import sys

from your_keys import *
from binance import Binance

binance = Binance(BINANCE_KEY, BINANCE_SECRET)


def find_and_do_trades():
    rvn_price = float(binance.get_coin_price('RVNBTC'))

    rvn_24h_data = binance.get_24h_data('RVNBTC')
    rvn_24h_low = float(rvn_24h_data['low'])
    rvn_24h_high = float(rvn_24h_data['high'])

    if rvn_24h_high - rvn_24h_low < 0.00000020:
        return
    elif rvn_24h_high - (rvn_24h_high - rvn_24h_low) / 10 <= rvn_price:
        rvn_bal = binance.get_balance('RVN')
        if not '-q' in sys.argv or '--quiet' in sys.argv:
            print(
                f'Placed SELL Order on RVN @ {rvn_price + 0.00000002}\nRVN Balance: {rvn_bal}'
            )
        binance.post_sell('RVNBTC', rvn_price + 0.00000002, rvn_bal / 10)
    elif rvn_24h_low + (rvn_24h_high - rvn_24h_low) / 10 >= rvn_price:
        btc_bal = binance.get_balance('BTC')
        if not '-q' in sys.argv or '--quiet' in sys.argv:
            print(