def handle(self, *args, **options):
        c = Client(settings.BINANCE_API_KEY, settings.BINANCE_SECRET)

        assets = c.get_all_tickers()
        for asset in assets:
            Coin.objects.get_or_create(symbol=asset['symbol'])
        ei = c.get_exchange_info()

        # Get coin order filters.
        for coin_filter in ei['symbols']:
            symbol = coin_filter['symbol']

            lot_filter = next((item for item in coin_filter['filters']
                               if item["filterType"] == "LOT_SIZE"), None)

            coin = Coin.objects.get(symbol=symbol)
            coin.max_qty = lot_filter['maxQty']
            coin.min_qty = lot_filter['minQty']
            coin.step_size = lot_filter['stepSize']
            step_split = lot_filter['stepSize'].split(".")

            if step_split[0] == '1':
                coin.step = 0
            else:
                coin.step = len(step_split[1].split("1")[0]) + 1

            coin.save()
Beispiel #2
0
class App:
    def __init__(self, market, coin):
        self.market = market
        self.coin = coin
        self.dataset = []

    def authorize_client(self):
        self.client = Client(user.API_KEY, user.API_SECRET)

    def append_data(self, price):
        data = self.dataset
        data.append(price) if len(data) < 5 else data.pop(0)

    def get_price(self):
        return [
            Decimal(x['price']) for x in self._fetch_api_data()
            if x['symbol'] == self.market
        ]

    def start(self):
        self.authorize_client()
        price = self.get_price()
        self.append_data(price)

    def _fetch_api_data(self):
        self.prices = self.client.get_all_tickers()
        return self.prices
def run_update(event, context):

    # Getting S3 Bucket File Location
    bucket_name = environ.get("BUCKET")
    s3 = boto3.resource("s3")
    bucket = s3.Bucket(bucket_name)

    # API_KEY , API_SECRET
    API_KEY = environ.get("API_KEY")
    API_SECRET = environ.get("API_SECRET")

    # Creating Dummy Data
    binance_client = Client(api_key=API_KEY, api_secret=API_SECRET)
    all_tradable = binance_client.get_all_tickers()
    df = pd.DataFrame(all_tradable)

    file_name = environ.get('COIN_FILE_NAMES')
    df.to_csv("/tmp/" + file_name, index=False, compression="gzip")

    # Upload File to s3
    path_to_file = f"/tmp/{file_name}"
    bucket.upload_file(path_to_file, file_name)

    response = {"statusCode": 200, "body": "Successfully update valid tickers"}

    return response
Beispiel #4
0
class AutoPilot:
    def __init__(self, key, secret):
        self.client = Client(api_key=key, api_secret=secret)

    def get_all_tickers(self) -> list:
        try:
            return self.client.get_all_tickers()
        except Exception as e:
            print(e)
            return None

    def get_symbol_tikcer(self, symbol: str) -> dict:
        try:
            if (symbol):
                return self.client.get_symbol_ticker(symbol=symbol)
            else:
                raise ValueError('designate symbol')
        except Exception as e:
            print(e)
            return None

    def get_symbol_info(self, symbol: str) -> dict:
        try:
            if (symbol):
                return self.client.get_symbol_info(symbol=symbol)
            else:
                raise ValueError('designate symbol')
        except Exception as e:
            print(e)
            return None
Beispiel #5
0
class ScrapeBinance():
    API, API_SECRET = '', ''

    def __init__(self):
        self.link = 'https://www.binance.com/en/trade/RVN_BTC'

        with open('../metadata/binance_keys.txt') as f:
            keys = f.read()
            keys = keys.split(',')
            ScrapeBinance.API, ScrapeBinance.API_SECRET = keys[0], keys[1]
        self.client = Client(ScrapeBinance.API, ScrapeBinance.API_SECRET)
        self.fill_json()

    def fill_json(self):
        ticker_list = [
            symbol['symbol'] for symbol in self.client.get_all_tickers()
        ]
        ticker_list = set(
            [ticker[:-3] for ticker in ticker_list if ticker[-4:] != 'USDT'])
        with open('meta/coin.json', 'r') as f:
            coin_info = json.load(f)
        coin_list = list(coin_info.keys())

        for new in list(ticker_list.difference(set(coin_info))):
            coin_info[new] = ''
        print(coin_info)
        with open('meta/coin.json', 'w') as f:
            json.dump(coin_info, f)
Beispiel #6
0
def main():
    api_key = config.get(USER_CFG_SECTION, 'api_key')
    api_secret_key = config.get(USER_CFG_SECTION, 'api_secret_key')

    client = Client(api_key, api_secret_key)

    available_tickers = {}
    for ticker in client.get_all_tickers():
        available_tickers[ticker['symbol']] = None

    global g_state
    if not (os.path.isfile(g_state._table_backup_file)):
        initialize_trade_thresholds(client)
        if config.get(USER_CFG_SECTION, 'current_coin') == '':
            logger.info("Purchasing {0} to begin trading".format(
                g_state.current_coin))
            buy_alt(client, g_state.current_coin, BRIDGE)
            logger.info("Ready to start trading")

    while True:
        try:
            time.sleep(5)
            scout(client, available_tickers)
        except Exception as e:
            logger.info('Error while scouting...\n{}\n'.format(e))
Beispiel #7
0
def get_market_data(end_time, delay=1):
    client = Client(api_key, api_secret)
    fullbook = pd.DataFrame()

    ticker_list = [x['symbol'] for x in client.get_all_tickers()]

    while (_dt_dt_.now() < end_time):
        for symbol in ticker_list:
            try:
                depth = pd.DataFrame(client.get_order_book(symbol=symbol))

                book_update = pd.DataFrame({
                    _dt_dt_.now().strftime("%Y%m%d %H:%M:%S.%f"): {
                        'symbol': symbol,
                        'q_bid': float(depth.loc[0, 'bids'][1]),
                        'p_bid': float(depth.loc[0, 'bids'][0]),
                        'q_ask': float(depth.loc[0, 'asks'][1]),
                        'p_ask': float(depth.loc[0, 'asks'][0]),
                        'q_bid_2': float(depth.loc[1, 'bids'][1]),
                        'p_bid_2': float(depth.loc[1, 'bids'][0]),
                        'q_ask_2': float(depth.loc[1, 'asks'][1]),
                        'p_ask_2': float(depth.loc[1, 'asks'][0])
                    }
                })

                fullbook = fullbook.append(book_update.T)
            except:
                pass

        time.sleep(delay)

    save_fullbook_data(
        fullbook, '/home/yizhang/Research/data/%s' %
        (_dt_dt_.now().strftime("%Y/%m/%d/")))
Beispiel #8
0
    def get_balances(self):
        '''Gets the current balance info using python-binance module. Note that shows in total current USDT value'''

        # Initiate the class
        account = Client(api_key=api_key, api_secret=secret_key)

        # GET account information
        account_dictionary = account.get_account()

        total_balance = 0

        pair_info_all = account.get_all_tickers()

        # Remove non-USDT pair info
        pair_info = [x for x in pair_info_all if "USDT" in x["symbol"][-4:]]

        for i in range(len(account_dictionary["balances"])):
            pair_name = account_dictionary['balances'][i]['asset']
            pair_name_usdt = f"{pair_name}USDT"
            if pair_name == "USDT":
                total_balance += float(account_dictionary['balances'][i]['free'])
            for j in range(len(pair_info)):
                if pair_name_usdt == pair_info[j]['symbol']:
                    total_balance += (float(account_dictionary["balances"][i]["free"]) + float(
                        account_dictionary["balances"][i]["locked"])) \
                                     * float(pair_info[j]['price'])
        return total_balance
Beispiel #9
0
def search_for_coin():

    try:
        #initiate client
        client = Client(api_key, api_secret)

        #get balance
        #balance = client.get_asset_balance(asset='BTC')

        # get all symbol prices
        prices = client.get_all_tickers()

        # find coin
        for coin in prices:
            if coin['symbol'] == pairing:
                print('[!] Pairing Found [!]')
                price = coin['price']
                print('[!] Pairing Price: ' + price + 'BTC [!]')
                created_order = buy_order(client, price)
                if created_order is True:
                    return True
                else:
                    print('[!] ERROR! Retrying... [!]')

        return False

    except (KeyboardInterrupt, SystemExit):
        # debug
        raise
Beispiel #10
0
def populate_data(path,
                  base_currency="ETH",
                  interval=Client.KLINE_INTERVAL_1HOUR,
                  start="30 January, 2016",
                  end="1 April, 2019"):
    """Populate a directory for data within a time range and interval for a base asset.

    Args:
        path: The directory in which to store the data.
        base_currency: The base asset we want the data for.
        interval: The candle interval, eg. 1 hour, as a binance enum.
        start: The start date.
        end: The end date.
    """
    symbols = []

    client = Client("", "")
    tickers = client.get_all_tickers()
    for ticker in tickers:
        symbol = ticker['symbol']
        if symbol.endswith(base_currency):
            symbols.append(symbol)

    for symbol in symbols:
        klines = get_historical_klines(symbol, interval, start, end)
        with open("{}/{}_1h.json".format(path, symbol), 'w') as f:
            f.write(json.dumps(klines))
Beispiel #11
0
class Binance():
	def __init__(self):
		self.client = Client("hziRqaoLzBRMlfwULTS66dm527DMVWjF3rQlPJlH5h9kdJwPg4T9MOgeLXYtjhX1", "syLnOpemHBzlyTo2xZEs9vaILt3RNikpdbTHijLFvqaow7HoddxfR3lXgpvRSgVw")
		self.infos = self.client.get_all_tickers()
		
	def get_price(self):
		final_result = []
		for info in self.infos:
		  for symbol in network_symbols:
		    if info["symbol"] == "{}USDT".format(symbol):
		    	final_result.append(info)
		return final_result
	
	def pure_price(self):
	  prices = []
	  for price in self.get_price():
	    price["symbol"] = price["symbol"][:-4]
	    prices.append(price)
	  return prices
	
	def calculate_interest(current_price , last_price):
	  return (current_price - last_price) / last_price * 100
	  
	def get_kline(self, network):
		return binance.client.get_klines(symbol="%sUSDT"%network, interval="1m")
Beispiel #12
0
class BinanceListingObtainer(ListingObtainer):
    _client: Client

    def __init__(self, propertiesFile="binance_properties.json"):
        super().__init__()
        api_key, api_secret = self._getKeysFromFile(propertiesFile)
        self._client = Client(api_key=api_key, api_secret=api_secret)

    def obtain(self) -> pd.DataFrame:
        dictionary = {"Ticker": []}

        tickers = self._client.get_all_tickers()

        for ticker in tickers:
            dictionary["Ticker"].append(ticker["symbol"])

        self.listings = pd.DataFrame(dictionary, columns=["Ticker"])

        return self.listings

    def _getKeysFromFile(self, propertiesFile: str):
        try:
            with open(propertiesFile, mode='r') as file:
                data = json.load(file)
                apiKey = data["API Key"]
                apiKeySecret = data["API Key Secret"]
                return apiKey, apiKeySecret
        except:
            print(
                "You are missing " + propertiesFile + ". Please ask Robert" \
                                                      "(robert.ciborowski"
                                                      "@mail.utoronto.ca) for "
                                                      "help.")
Beispiel #13
0
class BinanceHelper(object):
    def __init__(self, api_key, api_secret, base_currency, coin_currency):
        self.client = Client(api_key, api_secret)
        self.base_currency = base_currency
        self.coin_currency = coin_currency
        self.symbol = coin_currency + base_currency

    def float_precision(self, f, n):
        n = int(math.log10(1 / float(n)))
        f = math.floor(float(f) * 10**n) / 10**n
        f = "{:0.0{}f}".format(float(f), n)
        return str(int(f)) if int(n) == 0 else f

    def get_price(self):
        price = None
        tickers = self.client.get_all_tickers()
        for ticker in tickers:
            if ticker['symbol'] == self.symbol:
                price = float(ticker['price'])
        return price

    def get_tick_and_step_size(self):
        tick_size = None
        step_size = None
        symbol_info = self.client.get_symbol_info(self.symbol)
        for filt in symbol_info['filters']:
            if filt['filterType'] == 'PRICE_FILTER':
                tick_size = float(filt['tickSize'])
            elif filt['filterType'] == 'LOT_SIZE':
                step_size = float(filt['stepSize'])
        return tick_size, step_size

    def get_balance(self, currency):
        return float(self.client.get_asset_balance(asset=currency)['free'])

    def get_buy_info(self):
        tick_size, step_size = self.get_tick_and_step_size()
        price = float(self.float_precision(self.get_price(), tick_size))
        coin_currency_quantity = float(
            self.float_precision(
                self.get_balance(self.base_currency) / price, step_size))
        return price, coin_currency_quantity

    def get_sell_info(self):
        tick_size, step_size = self.get_tick_and_step_size()
        price = float(self.float_precision(self.get_price(), tick_size))
        coin_currency_quantity = float(
            self.float_precision(self.get_balance(self.coin_currency),
                                 step_size))
        return price, coin_currency_quantity

    def buy(self):
        price, quantity = self.get_buy_info()
        self.client.order_market_buy(symbol=self.symbol, quantity=quantity)

    def sell(self):
        price, quantity = self.get_sell_info()
        self.client.order_market_sell(symbol=self.symbol, quantity=quantity)
Beispiel #14
0
def main(argv):
    period = 10

    ########### API KEYS ###########
    #Binance
    b_api_key = 'newb'
    b_api_secret = 'noob'
    #HitBTC
    h_api_key = 'nub'
    h_api_secret = '...'

    #### Client Declarations ####

    b_client = Client(b_api_key, b_api_secret)
    h_client = H_Client("https://api.hitbtc.com", h_api_key, h_api_secret)

    #############
    #Get Market Depth
    depth = b_client.get_order_book(symbol='BNBBTC')
    #Get Recent Trades
    trades_recent = b_client.get_recent_trades(symbol='BNBBTC')
    #Get Historical Trades
    trades_hist = b_client.get_historical_trades(symbol='BNBBTC')
    #Get Aggregate trades
    trades_agg = b_client.get_aggregate_trades(symbol='BNBBTC')
    #Get Kline/Candlesticks
    candles = b_client.get_klines(symbol='BNBBTC',
                                  interval=KLINE_INTERVAL_30MINUTE)
    #Get 24hr Ticker
    tickers_24 = b_client.get_ticker()
    #Get All Prices: Get last price for all markets
    prices = b_client.get_all_tickers()
    #Get Orderbook Tickers: Get first bid and ask entry in the order book for all markets
    tickers_order = b_client.get_orderbook_tickers()
    ############

    # print(h_client.get_orderbook("ETHBTC"))
    ethbtc_orderbook = h_client.get_orderbook("ETHBTC")

    #Check to see which coins can be traded and withdrawn
    h_cryptolist = []
    h_currencies = h_client.currencies()
    for currency in h_currencies:
        if currency['id'] == 'BTC':
            print(currency)

    minimum_ask = 0
    minimum_bid = 0

    for order, price in ethbtc_orderbook.items():
        print(order, ":", price)
        print(len(price))
        # for i in price.length():
        if order == 'ask':
            pass
            # print("minimum ask price is: ")
        if order == 'bid':
            pass
Beispiel #15
0
 def coin_prices(self, watch_list):
     #Will print to screen, prices of coins on 'watch list'
     #returns all prices
     prices = Client.get_all_tickers(self)
     print("\nSelected (watch list) Ticker Prices: ")
     for price in prices:
         if price['symbol'] in watch_list:
             print(price)
     return prices
Beispiel #16
0
def compute_pnl():

    json_payload = request.get_json()
    binance_api_key = json_payload['API_KEY']
    binance_api_secret = json_payload['API_SECRET']
    order_history = json_payload['order_history']

    binance_client = Client(api_key=binance_api_key,
                            api_secret=binance_api_secret)

    all_tradable = binance_client.get_all_tickers()
    global prices
    prices = {p['symbol']: p['price'] for p in all_tradable}

    # Step 1: Get quantities of the coins
    valid_orders = [o for o in order_history if float(o['executedQty']) > 0]
    coin_obj_dict = {}
    pnl = {}
    for order in valid_orders:
        coin = order['symbol']
        if order['type'] == 'REVERSE':
            order['price'] = get_reverse_trade_price(order, binance_client)
        if coin not in coin_obj_dict:
            coin_obj_dict[coin] = CoinProfitLoss(coin)
        cpl_object = coin_obj_dict[coin]
        if order['side'] == 'BUY':
            cpl_object.buy(float(order['executedQty']), float(order['price']))
        else:
            cpl_object.sell(float(order['executedQty']), float(order['price']))
    category = []
    ureal_pnl = []
    real_pnl = []
    for coin in coin_obj_dict:
        if coin_obj_dict[coin].cost_basis < 10:
            continue
        unrealised_pnl = coin_obj_dict[coin].get_unrealised_pnl(
            float(prices[coin]))
        realised_pnl = coin_obj_dict[coin].get_realised_pnl()
        category.append({"label": coin})
        ureal_pnl.append({"value": str(unrealised_pnl)})
        real_pnl.append({"value": str(realised_pnl)})
    total_pnl = sum(ureal_pnl) + sum(real_pnl)
    total_pnl_arr = [ureal_pnl[i] + real_pnl[i] for i in range(len(ureal_pnl))]
    most_profitable = category[total_pnl_arr.index(max(total_pnl_arr))]
    least_profitable = category[total_pnl_arr.index(min(total_pnl_arr))]
    return jsonify({
        "code": 200,
        "data": {
            "categories": category,
            "ureal_pnl": ureal_pnl,
            "real_pnl": real_pnl,
            "total_pnl": total_pnl,
            "most_profitable": most_profitable,
            "least_profitable": least_profitable
        }
    }), 200
Beispiel #17
0
def main():
    api_key = os.environ['BINANCE_API']
    api_secret = os.environ['BINANCE_SECRET']
    client = Client(api_key, api_secret)
    all_tickers = client.get_all_tickers()
    dst_dir = Path('Binance')
    interval = '5m'
    # fill in all get_all_kline args except for symbol so we can use in multithreading
    thread_func = partial(get_all_klines,
                          client=client,
                          interval=interval,
                          dst_dir=dst_dir)

    total_erw = 0  # count of total estimated request weight
    symbol_batch = [
    ]  # list to be filled with symbols for single multithread run through
    for i, ticker in enumerate(all_tickers):

        symbol = ticker['symbol']
        erw = estimate_request_weight(symbol, interval, dst_dir, client)
        total_erw += 2  # add 2 for estimate_request_weight function calls just to be safe
        if total_erw + erw > 1100:  # api request limit is 12000 per minute
            print(i, symbol_batch)

            start_time = datetime.now()
            with concurrent.futures.ThreadPoolExecutor() as executor:
                futures = list(executor.map(thread_func, symbol_batch))
            for filepath, data_df in futures:
                # save data outside of multithreading. suspected errors trying to save w/in multithreading. also easier to line up in console output.
                data_df.to_csv(filepath)
                print(f'saved to {filepath}')
            end_time = datetime.now()
            duration = start_time - end_time
            if duration < timedelta(
                    minutes=1):  # pause if outpacing api request limit
                sleep_time = timedelta(minutes=1) - duration
                time.sleep(sleep_time.seconds)
            # restart symbol batch and total_erw w/ data from current ticker
            symbol_batch = [symbol]
            total_erw = erw
        elif erw != 0:
            # skip symbols with 0 erw
            # 0 erw means less than days worth of data to download (see estimate_request_weight function)

            # add symbol to symbol_batch, update total_erw counter
            symbol_batch.append(symbol)
            total_erw += erw
        if i % 100 == 0:
            print(i)

    # one last symbol_batch left
    with concurrent.futures.ThreadPoolExecutor() as executor:
        futures = list(executor.map(thread_func, symbol_batch))
    for filepath, data_df in futures:
        data_df.to_csv(filepath)
        print(f'saved to {filepath}')
def get_all_tickers(api_key=binance_api_key, api_secret=binance_api_secret):
    client = Client(api_key=api_key, api_secret=api_secret)

    all_tickers_data = client.get_all_tickers()
    tickers = []

    for ticker_data in all_tickers_data:
        tickers.append(ticker_data['symbol'])

    return np.array(tickers)
Beispiel #19
0
def get_binance_info():
    client = Client(api_key_binance, api_secret_binance)
    prices = client.get_all_tickers()

    for item in prices:
        if "BTCUSDT" in item["symbol"]:
            btc_price = item["price"]

        if "ETHUSDT" in item["symbol"]:
            eth_price = item["price"]

    return float(btc_price), float(eth_price)
Beispiel #20
0
def get_all_tickers_view(request):
    '''Parameters:	
            symbol (str) – Name of symbol pair e.g BNBBTC
        '''
    if request.method == "POST":
        cli = Client()
        data = request.data
        try:
            agg = cli.get_all_tickers(**data)
            return JsonResponse(agg, safe=False)
        except BinanceAPIException as e:
            return JsonResponse({"MessageError": e.message}, safe=False)
Beispiel #21
0
class Binance:
    def __init__(self, api_key: str, api_secret: str):
        self.client = Client(api_key, api_secret)

    def get_tick(self, symbol: str) -> Tick:
        return Tick(**self.client.get_ticker(symbol=symbol))

    def get_all_tickers(self):
        tickers = []
        for tick in self.client.get_all_tickers():
            tickers.append(self.get_tick(tick['symbol']))
        return tickers
Beispiel #22
0
class exchange:
    """
    建構式

    Args:
        apiKey (str): API金鑰
        apiSecret (str): API密鑰

    Returns:
        void
    """
    def __init__(self, apiKey: str, apiSecret: str):
        self.client = Client(apiKey, apiSecret)

    """
    取得當前價格

    Args:
        symbol (str): 要取得價格的標的,例BTCUSDT

    Returns:
        float: 當前的價格
    """

    def getSymbolPrice(self, symbol: str) -> float:
        prices = self.client.get_all_tickers()
        num = len(prices)
        price = 0
        for i in range(num):
            if symbol == prices[i]['symbol']:
                price = prices[i]['price']
        return price

    """
    進行交易

    Args:
        symbol (str): 要取得價格的標的,例BTCUSDT
        side (str): 要買進用buy,要賣出用sell
        quantity (float): 要買進的數量

    Returns:
        str: API response
    """

    def doExchange(self, symbol: str, side: str, quantity: float):
        sides = {'buy': Client.SIDE_BUY, 'sell': Client.SIDE_SELL}
        order = self.client.create_test_order(symbol=symbol,
                                              side=sides[side],
                                              type=Client.ORDER_TYPE_MARKET,
                                              quantity=quantity)
        return order
Beispiel #23
0
    def get_binance_balance(self, api_key, api_secret):
        """
        :returns: binace balance

        .. code-block:: python

            {
              'TRX': {
                'price_BTC': 0.000001,
                'value_BTC': 0.00001,
                'free': 10
              },
              'NEO': {
                'price_BTC': 0.000001,
                'value_BTC': 0.00001,
                'free': 10
              },
              'OMG': {
                'price_BTC': 0.000001,
                'value_BTC': 0.00001,
                'free': 10
              },
              'BTC': {
                'free': 0.002
              }
            }

        """

        client = Client(api_key, api_secret)

        # Get account information
        account = client.get_account()

        # Filter zero balances
        my_balance = {}
        for balance in account['balances']:
            if float(balance['free']) > 0:
                my_balance[balance['asset']] = {'free': float(balance['free'])}

        # Get current prices
        prices = client.get_all_tickers()

        # Filter only BTC prices by account assets and calculate total value
        for price in prices:
            symbol = price['symbol']
            if symbol[-3:] == 'BTC' and symbol[:-3] in my_balance.keys():
                my_asset = my_balance[symbol[:-3]]
                my_asset['price_BTC'] = float(price['price'])
                my_asset['value_BTC'] = (float(price['price']) *
                                         my_asset['free'])
        return my_balance
Beispiel #24
0
 def binance(list):
     binance_api = Keys['binance_key']
     binance_secret = Keys['binance_secret']
     client = Client(binance_api, binance_secret)
     prices = client.get_all_tickers()
     for price in prices:
         if price['symbol'] in list:
             y = price['price']
             x = float(y)
             z = 1 / x
     a = btc()
     b = a * z
     return b
Beispiel #25
0
def binance_get_all_tickers(chat_id):
    full_api = getbinanceapi(chat_id)['binance_api']
    api_key = full_api.split(':')[0].strip()
    api_secret = full_api.split(':')[1].strip()
    client = Client(api_key, api_secret)
    binance_timesync(client)
    js_info = []
    try:
        js_info = client.get_all_tickers()
        #print(js_info)
        return js_info
    except Exception as e:
        print(e)
    return js_info
Beispiel #26
0
class Scraper:
    def __init__(self):
        self.api_key = '7tDBYdWpcmbHLSmJJKVd2aCVbzyGwdQ3hDgSfw5MrrXSpjAoufMW5Tkk02W1JiPv'
        self.api_secret = '98BCmuZh6yFLJUYtJ7WtZtCqiMeNTuauxKfzrRQQ82RNnG01HJdxmuXzxZ5SSnyU'
        self.client = Client(self.api_key, self.api_secret)

    def run(self):
        while True:
            try:
                tickers = self.client.get_all_tickers()
                server_time = self.client.get_server_time()['serverTime']

                for t in tickers:
                    if t['symbol'] in ["ETHUSDT", "BTCUSDT"]:

                        models.store_data(int(server_time), float(t['price']),
                                          t['symbol'])
                time.sleep(1)
            except Exception as e:
                print(e)

    def tickers(self):
        return self.client.get_all_tickers()
Beispiel #27
0
    def update(self):
        from binance.client import Client

        _LOGGER.debug('Fetching data from binance.com')
        try:
            client = Client(self._api_key, self._api_secret)
            prices = client.get_all_tickers()
            for i in prices:
                self.data[i['symbol']] = i['price']
            _LOGGER.debug("Rates updated to %s", self.data)
        except:
            _LOGGER.error('Error fetching data from binance.com')
            self.data = {}
            return False
Beispiel #28
0
def main():
    client = Client(config.api_key, config.api_secret)

    # Get account information
    account = client.get_account()

    # Filter zero balances
    my_balance = {}
    for balance in account['balances']:
        if float(balance['free']) > 0:
            my_balance[balance['asset']] = {'free': float(balance['free'])}

    # Get current prices
    prices = client.get_all_tickers()

    # Add wallet data from config file
    '''
        wallet = {
            'symbol_1': amount,
            'symbol_2': amount
        }
    '''
    for k, v in config.wallet.items():
        if k in list(my_balance.keys()):
            my_balance[k]['free'] = my_balance[k]['free'] + v
        else:
            my_balance[k] = {}
            my_balance[k]['free'] = v

    # Filter only BTC prices by account assets and calculate total value
    for price in prices:
        symbol = price['symbol']
        if symbol[-3:] == 'BTC' and symbol[:-3] in list(my_balance.keys()):
            my_asset = my_balance[symbol[:-3]]
            my_asset['price'] = price['price']
            my_asset['value_BTC'] = (float(price['price']) * my_asset['free'])

    # Extract labels and values for chart
    labels = []
    values = []

    for key, value in my_balance.items():
        labels.append(key)
        if key == 'BTC':
            values.append(float(value['free']))
        else:
            values.append(value['value_BTC'])

    plot_pie(values, labels)
Beispiel #29
0
def fillSymbols():
    BUY_SYMBOLS.clear()
    client1 = Client(config.api_key1, config.api_secret1)
    data = client1.get_all_tickers()
    time.sleep(0.1)
    for x in data:
        if x['symbol'][-4:].find("USDT") != -1:
            if x['symbol'][:-4].find("USD") == -1:
                for a in BLACKLIST:
                    allOf = True
                    if x['symbol'].find(a) != -1:
                        allOf = False
                        break
                if allOf:
                    BUY_SYMBOLS.append(x['symbol'])
Beispiel #30
0
def buy():
    global foundCoin

    client = Client(
        'YOUR API KEY HERE',
        'YOUR SECRET KEY HERE')  # Sisesta siia oma API key ja Secret API Key

    balanceDict = client.get_asset_balance(asset='BTC')
    balance = balanceDict.get('free')  # Leiab vabade vahendite summa

    allPrices = client.get_all_tickers()
    coinInfo = next(item for item in allPrices
                    if item["symbol"] == "%sBTC" % (foundCoin))
    foundPrice = coinInfo.get('price')

    print('[' + str(dt.now().time()) + ']' + 'Your BTC balance is:' + ' ' +
          str(balance))
    print('[' + str(dt.now().time()) + ']' + 'price is' + ' ' + foundPrice)

    possibleBuy = float(balance) / float(
        foundPrice
    ) * 0.8  # Kordaja määrab, kui palju olemasolevast rahast kasutatakse tehingus
    possibleBuy = float(round(possibleBuy, 8))

    def order():
        order = client.create_order(symbol='%sBTC' % (foundCoin),
                                    side=Client.SIDE_BUY,
                                    type=Client.ORDER_TYPE_MARKET,
                                    quantity=possibleBuy)
        print('[' + str(dt.now().time()) + ']' + 'Placed order for %f %s' %
              (possibleBuy, foundCoin))

    x = 8
    while True:
        try:
            order()
            break
        except:
            possibleBuy = float(round(possibleBuy, x - 1))
            x = x - 1
            print(
                '[' + str(dt.now().time()) + ']' + 'Trying' + ' ' +
                str(possibleBuy)
            )  # Erinevad coinid lubavad erinevat täpsust, nii et siin proovib
            # järjest ebatäpsemat ümardamist.
    search()