# coding=utf-8

import hashlib

import hmac

import requests

import time

from operator import itemgetter

from .helpers import date_to_milliseconds, interval_to_milliseconds, increment_month

from .exceptions import BinanceAPIException, BinanceRequestException, BinanceWithdrawException

class Client(object):

API_URL = 'https://api.binance.{}/api'

WITHDRAW_API_URL = 'https://api.binance.{}/wapi'

MARGIN_API_URL = 'https://api.binance.{}/sapi'

WEBSITE_URL = 'https://www.binance.{}'

FUTURES_URL = 'https://fapi.binance.{}/fapi'

PUBLIC_API_VERSION = 'v1'

PRIVATE_API_VERSION = 'v3'

WITHDRAW_API_VERSION = 'v3'

MARGIN_API_VERSION = 'v1'

FUTURES_API_VERSION = 'v1'

SYMBOL_TYPE_SPOT = 'SPOT'

ORDER_STATUS_NEW = 'NEW'

ORDER_STATUS_PARTIALLY_FILLED = 'PARTIALLY_FILLED'

ORDER_STATUS_FILLED = 'FILLED'

ORDER_STATUS_CANCELED = 'CANCELED'

ORDER_STATUS_PENDING_CANCEL = 'PENDING_CANCEL'

ORDER_STATUS_REJECTED = 'REJECTED'

ORDER_STATUS_EXPIRED = 'EXPIRED'

KLINE_INTERVAL_1MINUTE = '1m'

KLINE_INTERVAL_3MINUTE = '3m'

KLINE_INTERVAL_5MINUTE = '5m'

KLINE_INTERVAL_15MINUTE = '15m'

KLINE_INTERVAL_30MINUTE = '30m'

KLINE_INTERVAL_1HOUR = '1h'

KLINE_INTERVAL_2HOUR = '2h'

KLINE_INTERVAL_4HOUR = '4h'

KLINE_INTERVAL_6HOUR = '6h'

KLINE_INTERVAL_8HOUR = '8h'

KLINE_INTERVAL_12HOUR = '12h'

KLINE_INTERVAL_1DAY = '1d'

KLINE_INTERVAL_3DAY = '3d'

KLINE_INTERVAL_1WEEK = '1w'

KLINE_INTERVAL_1MONTH = '1M'

SIDE_BUY = 'BUY'

SIDE_SELL = 'SELL'

ORDER_TYPE_LIMIT = 'LIMIT'

ORDER_TYPE_MARKET = 'MARKET'

ORDER_TYPE_STOP_LOSS = 'STOP_LOSS'

ORDER_TYPE_STOP_LOSS_LIMIT = 'STOP_LOSS_LIMIT'

ORDER_TYPE_TAKE_PROFIT = 'TAKE_PROFIT'

ORDER_TYPE_TAKE_PROFIT_LIMIT = 'TAKE_PROFIT_LIMIT'

ORDER_TYPE_LIMIT_MAKER = 'LIMIT_MAKER'

TIME_IN_FORCE_GTC = 'GTC' # Good till cancelled

TIME_IN_FORCE_IOC = 'IOC' # Immediate or cancel

TIME_IN_FORCE_FOK = 'FOK' # Fill or kill

ORDER_RESP_TYPE_ACK = 'ACK'

ORDER_RESP_TYPE_RESULT = 'RESULT'

ORDER_RESP_TYPE_FULL = 'FULL'

# For accessing the data returned by Client.aggregate_trades().

AGG_ID = 'a'

AGG_PRICE = 'p'

AGG_QUANTITY = 'q'

AGG_FIRST_TRADE_ID = 'f'

AGG_LAST_TRADE_ID = 'l'

AGG_TIME = 'T'

AGG_BUYER_MAKES = 'm'

AGG_BEST_MATCH = 'M'

def __init__(self, api_key=None, api_secret=None, requests_params=None, tld='com'):

"""Binance API Client constructor

:param api_key: Api Key

:type api_key: str.

:param api_secret: Api Secret

:type api_secret: str.

:param requests_params: optional - Dictionary of requests params to use for all calls

:type requests_params: dict.

"""

self.API_URL = self.API_URL.format(tld)

self.WITHDRAW_API_URL = self.WITHDRAW_API_URL.format(tld)

self.MARGIN_API_URL = self.MARGIN_API_URL.format(tld)

self.WEBSITE_URL = self.WEBSITE_URL.format(tld)

self.FUTURES_URL = self.FUTURES_URL.format(tld)

self.API_KEY = api_key

self.API_SECRET = api_secret

self.session = self._init_session()

self._requests_params = requests_params

self.response = None

# init DNS and SSL cert

self.ping()

def _init_session(self):

session = requests.session()

session.headers.update({'Accept': 'application/json',

'User-Agent': 'binance/python',

'X-MBX-APIKEY': self.API_KEY})

return session

def _create_api_uri(self, path, signed=True, version=PUBLIC_API_VERSION):

v = self.PRIVATE_API_VERSION if signed else version

return self.API_URL + '/' + v + '/' + path

def _create_withdraw_api_uri(self, path):

return self.WITHDRAW_API_URL + '/' + self.WITHDRAW_API_VERSION + '/' + path

def _create_margin_api_uri(self, path):

return self.MARGIN_API_URL + '/' + self.MARGIN_API_VERSION + '/' + path

def _create_website_uri(self, path):

return self.WEBSITE_URL + '/' + path

def _create_futures_api_uri(self, path):

return self.FUTURES_URL + '/' + self.FUTURES_API_VERSION + '/' + path

def _generate_signature(self, data):

ordered_data = self._order_params(data)

query_string = '&'.join(["{}={}".format(d[0], d[1]) for d in ordered_data])

m = hmac.new(self.API_SECRET.encode('utf-8'), query_string.encode('utf-8'), hashlib.sha256)

return m.hexdigest()

def _order_params(self, data):

"""Convert params to list with signature as last element

:param data:

:return:

"""

has_signature = False

params = []

for key, value in data.items():

if key == 'signature':

has_signature = True

else:

params.append((key, value))

# sort parameters by key

params.sort(key=itemgetter(0))

if has_signature:

params.append(('signature', data['signature']))

return params

def _request(self, method, uri, signed, force_params=False, **kwargs):

# set default requests timeout

kwargs['timeout'] = 10

# add our global requests params

if self._requests_params:

kwargs.update(self._requests_params)

data = kwargs.get('data', None)

if data and isinstance(data, dict):

kwargs['data'] = data

# find any requests params passed and apply them

if 'requests_params' in kwargs['data']:

# merge requests params into kwargs

kwargs.update(kwargs['data']['requests_params'])

del(kwargs['data']['requests_params'])

if signed:

# generate signature

kwargs['data']['timestamp'] = int(time.time() * 1000)

kwargs['data']['signature'] = self._generate_signature(kwargs['data'])

# sort get and post params to match signature order

if data:

# sort post params

kwargs['data'] = self._order_params(kwargs['data'])

# Remove any arguments with values of None.

null_args = [i for i, (key, value) in enumerate(kwargs['data']) if value is None]

for i in reversed(null_args):

del kwargs['data'][i]

# if get request assign data array to params value for requests lib

if data and (method == 'get' or force_params):

kwargs['params'] = '&'.join('%s=%s' % (data[0], data[1]) for data in kwargs['data'])

del(kwargs['data'])

self.response = getattr(self.session, method)(uri, **kwargs)

return self._handle_response()

def _request_api(self, method, path, signed=False, version=PUBLIC_API_VERSION, **kwargs):

uri = self._create_api_uri(path, signed, version)

return self._request(method, uri, signed, **kwargs)

def _request_withdraw_api(self, method, path, signed=False, **kwargs):

uri = self._create_withdraw_api_uri(path)

return self._request(method, uri, signed, True, **kwargs)

def _request_margin_api(self, method, path, signed=False, **kwargs):

uri = self._create_margin_api_uri(path)

return self._request(method, uri, signed, **kwargs)

def _request_website(self, method, path, signed=False, **kwargs):

uri = self._create_website_uri(path)

return self._request(method, uri, signed, **kwargs)

def _request_futures_api(self, method, path, signed=False, **kwargs):

uri = self._create_futures_api_uri(path)

return self._request(method, uri, signed, True, **kwargs)

def _handle_response(self):

"""Internal helper for handling API responses from the Binance server.

Raises the appropriate exceptions when necessary; otherwise, returns the

response.

"""

if not str(self.response.status_code).startswith('2'):

raise BinanceAPIException(self.response)

try:

return self.response.json()

except ValueError:

raise BinanceRequestException('Invalid Response: %s' % self.response.text)

def _get(self, path, signed=False, version=PUBLIC_API_VERSION, **kwargs):

return self._request_api('get', path, signed, version, **kwargs)

def _post(self, path, signed=False, version=PUBLIC_API_VERSION, **kwargs):

return self._request_api('post', path, signed, version, **kwargs)

def _put(self, path, signed=False, version=PUBLIC_API_VERSION, **kwargs):

return self._request_api('put', path, signed, version, **kwargs)

def _delete(self, path, signed=False, version=PUBLIC_API_VERSION, **kwargs):

return self._request_api('delete', path, signed, version, **kwargs)

# Exchange Endpoints

def get_products(self):

"""Return list of products currently listed on Binance

Use get_exchange_info() call instead

:returns: list - List of product dictionaries

:raises: BinanceRequestException, BinanceAPIException

"""

products = self._request_website('get', 'exchange/public/product')

return products

def get_exchange_info(self):

"""Return rate limits and list of symbols

:returns: list - List of product dictionaries

.. code-block:: python

{

"timezone": "UTC",

"serverTime": 1508631584636,

"rateLimits": [

{

"rateLimitType": "REQUESTS",

"interval": "MINUTE",

"limit": 1200

},

{

"rateLimitType": "ORDERS",

"interval": "SECOND",

"limit": 10

},

{

"rateLimitType": "ORDERS",

"interval": "DAY",

"limit": 100000

}

],

"exchangeFilters": [],

"symbols": [

{

"symbol": "ETHBTC",

"status": "TRADING",

"baseAsset": "ETH",

"baseAssetPrecision": 8,

"quoteAsset": "BTC",

"quotePrecision": 8,

"orderTypes": ["LIMIT", "MARKET"],

"icebergAllowed": false,

"filters": [

{

"filterType": "PRICE_FILTER",

"minPrice": "0.00000100",

"maxPrice": "100000.00000000",

"tickSize": "0.00000100"

}, {

"filterType": "LOT_SIZE",

"minQty": "0.00100000",

"maxQty": "100000.00000000",

"stepSize": "0.00100000"

}, {

"filterType": "MIN_NOTIONAL",

"minNotional": "0.00100000"

}

]

}

]

}

:raises: BinanceRequestException, BinanceAPIException

"""

return self._get('exchangeInfo')

def get_symbol_info(self, symbol):

"""Return information about a symbol

:param symbol: required e.g BNBBTC

:type symbol: str

:returns: Dict if found, None if not

.. code-block:: python

{

"symbol": "ETHBTC",

"status": "TRADING",

"baseAsset": "ETH",

"baseAssetPrecision": 8,

"quoteAsset": "BTC",

"quotePrecision": 8,

"orderTypes": ["LIMIT", "MARKET"],

"icebergAllowed": false,

"filters": [

{

"filterType": "PRICE_FILTER",

"minPrice": "0.00000100",

"maxPrice": "100000.00000000",

"tickSize": "0.00000100"

}, {

"filterType": "LOT_SIZE",

"minQty": "0.00100000",

"maxQty": "100000.00000000",

"stepSize": "0.00100000"

}, {

"filterType": "MIN_NOTIONAL",

"minNotional": "0.00100000"

}

]

}

:raises: BinanceRequestException, BinanceAPIException

"""

res = self._get('exchangeInfo')

for item in res['symbols']:

if item['symbol'] == symbol.upper():

return item

return None

# General Endpoints

def ping(self):

"""Test connectivity to the Rest API.

https://github.com/binance-exchange/binance-official-api-docs/blob/master/rest-api.md#test-connectivity

:returns: Empty array

.. code-block:: python

{}

:raises: BinanceRequestException, BinanceAPIException

"""

return self._get('ping')

def get_server_time(self):

"""Test connectivity to the Rest API and get the current server time.

https://github.com/binance-exchange/binance-official-api-docs/blob/master/rest-api.md#check-server-time

:returns: Current server time

.. code-block:: python

{

"serverTime": 1499827319559

}

:raises: BinanceRequestException, BinanceAPIException

"""

return self._get('time')

# Market Data Endpoints

def get_all_tickers(self):

"""Latest price for all symbols.

https://www.binance.com/restapipub.html#symbols-price-ticker

:returns: List of market tickers

.. code-block:: python

[

{

"symbol": "LTCBTC",

"price": "4.00000200"

},

{

"symbol": "ETHBTC",

"price": "0.07946600"

}

]

:raises: BinanceRequestException, BinanceAPIException

"""

return self._get('ticker/allPrices')

def get_orderbook_tickers(self):

"""Best price/qty on the order book for all symbols.

https://www.binance.com/restapipub.html#symbols-order-book-ticker

:returns: List of order book market entries

.. code-block:: python

[

{

"symbol": "LTCBTC",

"bidPrice": "4.00000000",

"bidQty": "431.00000000",

"askPrice": "4.00000200",

"askQty": "9.00000000"

},

{

"symbol": "ETHBTC",

"bidPrice": "0.07946700",

"bidQty": "9.00000000",

"askPrice": "100000.00000000",

"askQty": "1000.00000000"

}

]

:raises: BinanceRequestException, BinanceAPIException

"""

return self._get('ticker/allBookTickers')

def get_order_book(self, **params):

"""Get the Order Book for the market

https://github.com/binance-exchange/binance-official-api-docs/blob/master/rest-api.md#order-book

:param symbol: required

:type symbol: str

:param limit: Default 100; max 1000

:type limit: int

:returns: API response

.. code-block:: python

{

"lastUpdateId": 1027024,

"bids": [

[

"4.00000000", # PRICE

"431.00000000", # QTY

[] # Can be ignored

]

],

"asks": [

[

"4.00000200",

"12.00000000",

[]

]

]

}

:raises: BinanceRequestException, BinanceAPIException

"""

return self._get('depth', data=params)

def get_recent_trades(self, **params):

"""Get recent trades (up to last 500).

https://github.com/binance-exchange/binance-official-api-docs/blob/master/rest-api.md#recent-trades-list

:param symbol: required

:type symbol: str

:param limit: Default 500; max 500.

:type limit: int

:returns: API response

.. code-block:: python

[

{

"id": 28457,

"price": "4.00000100",

"qty": "12.00000000",

"time": 1499865549590,

"isBuyerMaker": true,

"isBestMatch": true

}

]

:raises: BinanceRequestException, BinanceAPIException

"""

return self._get('trades', data=params)

def get_historical_trades(self, **params):

"""Get older trades.

https://github.com/binance-exchange/binance-official-api-docs/blob/master/rest-api.md#recent-trades-list

:param symbol: required

:type symbol: str

:param limit: Default 500; max 500.

:type limit: int

:param fromId: TradeId to fetch from. Default gets most recent trades.

:type fromId: str

:returns: API response

.. code-block:: python

[

{

"id": 28457,

"price": "4.00000100",

"qty": "12.00000000",

"time": 1499865549590,

"isBuyerMaker": true,

"isBestMatch": true

}

]

:raises: BinanceRequestException, BinanceAPIException

"""

return self._get('historicalTrades', data=params)

def get_aggregate_trades(self, **params):

"""Get compressed, aggregate trades. Trades that fill at the time,

from the same order, with the same price will have the quantity aggregated.

https://github.com/binance-exchange/binance-official-api-docs/blob/master/rest-api.md#compressedaggregate-trades-list

:param symbol: required

:type symbol: str

:param fromId: ID to get aggregate trades from INCLUSIVE.

:type fromId: str

:param startTime: Timestamp in ms to get aggregate trades from INCLUSIVE.

:type startTime: int

:param endTime: Timestamp in ms to get aggregate trades until INCLUSIVE.

:type endTime: int

:param limit: Default 500; max 500.

:type limit: int

:returns: API response

.. code-block:: python

[

{

"a": 26129, # Aggregate tradeId

"p": "0.01633102", # Price

"q": "4.70443515", # Quantity

"f": 27781, # First tradeId

"l": 27781, # Last tradeId

"T": 1498793709153, # Timestamp

"m": true, # Was the buyer the maker?

"M": true # Was the trade the best price match?

}

]

:raises: BinanceRequestException, BinanceAPIException

"""

return self._get('aggTrades', data=params)

def aggregate_trade_iter(self, symbol, start_str=None, last_id=None):

"""Iterate over aggregate trade data from (start_time or last_id) to

the end of the history so far.

If start_time is specified, start with the first trade after

start_time. Meant to initialise a local cache of trade data.

If last_id is specified, start with the trade after it. This is meant

for updating a pre-existing local trade data cache.

Only allows start_str or last_id—not both. Not guaranteed to work

right if you're running more than one of these simultaneously. You

will probably hit your rate limit.

See dateparser docs for valid start and end string formats http://dateparser.readthedocs.io/en/latest/

If using offset strings for dates add "UTC" to date string e.g. "now UTC", "11 hours ago UTC"

:param symbol: Symbol string e.g. ETHBTC

:type symbol: str

:param start_str: Start date string in UTC format or timestamp in milliseconds. The iterator will

return the first trade occurring later than this time.

:type start_str: str|int

:param last_id: aggregate trade ID of the last known aggregate trade.

Not a regular trade ID. See https://github.com/binance-exchange/binance-official-api-docs/blob/master/rest-api.md#compressedaggregate-trades-list.

:returns: an iterator of JSON objects, one per trade. The format of

each object is identical to Client.aggregate_trades().

:type last_id: int

"""

if start_str is not None and last_id is not None:

raise ValueError(

'start_time and last_id may not be simultaneously specified.')

# If there's no last_id, get one.

if last_id is None:

# Without a last_id, we actually need the first trade. Normally,

# we'd get rid of it. See the next loop.

if start_str is None:

trades = self.get_aggregate_trades(symbol=symbol, fromId=0)

else:

# The difference between startTime and endTime should be less

# or equal than an hour and the result set should contain at

# least one trade.

if type(start_str) == int:

start_ts = start_str

else:

start_ts = date_to_milliseconds(start_str)

# If the resulting set is empty (i.e. no trades in that interval)

# then we just move forward hour by hour until we find at least one

# trade or reach present moment

while True:

end_ts = start_ts + (60 * 60 * 1000)

trades = self.get_aggregate_trades(

symbol=symbol,

startTime=start_ts,

endTime=end_ts)

if len(trades) > 0:

break

# If we reach present moment and find no trades then there is

# nothing to iterate, so we're done

if end_ts > int(time.time() * 1000):

return

start_ts = end_ts

for t in trades:

yield t

last_id = trades[-1][self.AGG_ID]

while True:

# There is no need to wait between queries, to avoid hitting the

# rate limit. We're using blocking IO, and as long as we're the

# only thread running calls like this, Binance will automatically

# add the right delay time on their end, forcing us to wait for

# data. That really simplifies this function's job. Binance is

# fucking awesome.

trades = self.get_aggregate_trades(symbol=symbol, fromId=last_id)

# fromId=n returns a set starting with id n, but we already have

# that one. So get rid of the first item in the result set.

trades = trades[1:]

if len(trades) == 0:

return

for t in trades:

yield t

last_id = trades[-1][self.AGG_ID]

def get_klines(self, **params):

"""Kline/candlestick bars for a symbol. Klines are uniquely identified by their open time.

https://github.com/binance-exchange/binance-official-api-docs/blob/master/rest-api.md#klinecandlestick-data

:param symbol: required

:type symbol: str

:param interval: -

:type interval: str

:param limit: - Default 500; max 500.

:type limit: int

:param startTime:

:type startTime: int

:param endTime:

:type endTime: int

:returns: API response

.. code-block:: python

[

[

1499040000000, # Open time

"0.01634790", # Open

"0.80000000", # High

"0.01575800", # Low

"0.01577100", # Close

"148976.11427815", # Volume

1499644799999, # Close time

"2434.19055334", # Quote asset volume

308, # Number of trades

"1756.87402397", # Taker buy base asset volume

"28.46694368", # Taker buy quote asset volume

"17928899.62484339" # Can be ignored

]

]

:raises: BinanceRequestException, BinanceAPIException

"""

return self._get('klines', data=params)

def _get_earliest_valid_timestamp(self, symbol, interval):

"""Get earliest valid open timestamp from Binance

:param symbol: Name of symbol pair e.g BNBBTC

:type symbol: str

:param interval: Binance Kline interval

:type interval: str

:return: first valid timestamp

"""

kline = self.get_klines(

symbol=symbol,

interval=interval,

limit=1,

startTime=0,

endTime=None

)

return kline[0][0]

def get_historical_klines(self, symbol, interval, start_str, end_str=None,

limit=500):

"""Get Historical Klines from Binance

See dateparser docs for valid start and end string formats http://dateparser.readthedocs.io/en/latest/

If using offset strings for dates add "UTC" to date string e.g. "now UTC", "11 hours ago UTC"

:param symbol: Name of symbol pair e.g BNBBTC

:type symbol: str

:param interval: Binance Kline interval

:type interval: str

:param start_str: Start date string in UTC format or timestamp in milliseconds

:type start_str: str|int

:param end_str: optional - end date string in UTC format or timestamp in milliseconds (default will fetch everything up to now)

:type end_str: str|int

:param limit: Default 500; max 1000.

:type limit: int

:return: list of OHLCV values

"""

# init our list

output_data = []

# setup the max limit

limit = limit

# convert interval to useful value in seconds

timeframe = interval_to_milliseconds(interval)

# convert our date strings to milliseconds

if type(start_str) == int:

start_ts = start_str

else:

start_ts = date_to_milliseconds(start_str)

# establish first available start timestamp

first_valid_ts = self._get_earliest_valid_timestamp(symbol, interval)

start_ts = max(start_ts, first_valid_ts)

# if an end time was passed convert it

end_ts = None

if end_str:

if type(end_str) == int:

end_ts = end_str

else:

end_ts = date_to_milliseconds(end_str)

idx = 0

while True:

# fetch the klines from start_ts up to max 500 entries or the end_ts if set

temp_data = self.get_klines(

symbol=symbol,

interval=interval,

limit=limit,

startTime=start_ts,

endTime=end_ts

)

# handle the case where exactly the limit amount of data was returned last loop

if not len(temp_data):

break

# append this loops data to our output data

output_data += temp_data

# set our start timestamp using the last value in the array

start_ts = temp_data[-1][0]

idx += 1

# check if we received less than the required limit and exit the loop

if len(temp_data) < limit:

# exit the while loop

break

# increment next call by our timeframe

if interval == self.KLINE_INTERVAL_1MONTH:

start_ts = increment_month(start_ts)

else:

start_ts += timeframe

# sleep after every 3rd call to be kind to the API

if idx % 3 == 0:

time.sleep(1)

return output_data

def get_historical_klines_generator(self, symbol, interval, start_str, end_str=None):

"""Get Historical Klines from Binance

See dateparser docs for valid start and end string formats http://dateparser.readthedocs.io/en/latest/

If using offset strings for dates add "UTC" to date string e.g. "now UTC", "11 hours ago UTC"

:param symbol: Name of symbol pair e.g BNBBTC

:type symbol: str

:param interval: Binance Kline interval

:type interval: str

:param start_str: Start date string in UTC format or timestamp in milliseconds

:type start_str: str|int

:param end_str: optional - end date string in UTC format or timestamp in milliseconds (default will fetch everything up to now)

:type end_str: str|int

:return: generator of OHLCV values

"""

# setup the max limit

limit = 500

# convert interval to useful value in seconds

timeframe = interval_to_milliseconds(interval)

# convert our date strings to milliseconds

if type(start_str) == int:

start_ts = start_str

else:

start_ts = date_to_milliseconds(start_str)

# establish first available start timestamp

first_valid_ts = self._get_earliest_valid_timestamp(symbol, interval)

start_ts = max(start_ts, first_valid_ts)

# if an end time was passed convert it

end_ts = None

if end_str:

if type(end_str) == int:

end_ts = end_str

else:

end_ts = date_to_milliseconds(end_str)

idx = 0

while True:

# fetch the klines from start_ts up to max 500 entries or the end_ts if set

output_data = self.get_klines(

symbol=symbol,

interval=interval,

limit=limit,

startTime=start_ts,

endTime=end_ts

)

# handle the case where exactly the limit amount of data was returned last loop

if not len(output_data):

break

# yield data

for o in output_data:

yield o

# set our start timestamp using the last value in the array

start_ts = output_data[-1][0]

idx += 1

# check if we received less than the required limit and exit the loop

if len(output_data) < limit:

# exit the while loop

break

# increment next call by our timeframe

if interval == self.KLINE_INTERVAL_1MONTH:

start_ts = increment_month(start_ts)

else:

start_ts += timeframe

# sleep after every 3rd call to be kind to the API

if idx % 3 == 0:

time.sleep(1)

def get_avg_price(self, **params):

"""Current average price for a symbol.

https://github.com/binance-exchange/binance-official-api-docs/blob/master/rest-api.md#current-average-price

:param symbol:

:type symbol: str

:returns: API response

.. code-block:: python

{

"mins": 5,

"price": "9.35751834"

}

"""

return self._get('avgPrice', data=params, version=self.PRIVATE_API_VERSION)

def get_ticker(self, **params):

"""24 hour price change statistics.

https://github.com/binance-exchange/binance-official-api-docs/blob/master/rest-api.md#24hr-ticker-price-change-statistics

:param symbol:

:type symbol: str

:returns: API response

.. code-block:: python

{

"priceChange": "-94.99999800",

"priceChangePercent": "-95.960",

"weightedAvgPrice": "0.29628482",

"prevClosePrice": "0.10002000",

"lastPrice": "4.00000200",

"bidPrice": "4.00000000",

"askPrice": "4.00000200",

"openPrice": "99.00000000",

"highPrice": "100.00000000",

"lowPrice": "0.10000000",

"volume": "8913.30000000",

"openTime": 1499783499040,

"closeTime": 1499869899040,

"fristId": 28385, # First tradeId

"lastId": 28460, # Last tradeId

"count": 76 # Trade count

}

OR

.. code-block:: python

[

{

"priceChange": "-94.99999800",

"priceChangePercent": "-95.960",

"weightedAvgPrice": "0.29628482",

"prevClosePrice": "0.10002000",

"lastPrice": "4.00000200",

"bidPrice": "4.00000000",

"askPrice": "4.00000200",

"openPrice": "99.00000000",

"highPrice": "100.00000000",

"lowPrice": "0.10000000",

"volume": "8913.30000000",

"openTime": 1499783499040,

"closeTime": 1499869899040,

"fristId": 28385, # First tradeId

"lastId": 28460, # Last tradeId

"count": 76 # Trade count

}

]