from __future__ import print_function
import gate_api
from gate_api.rest import ApiException

configuration = gate_api.Configuration()
configuration.key = 'YOUR_API_KEY'
configuration.secret = 'YOUR_API_SECRET'

# create an instance of the API class
api_instance = gate_api.FuturesApi(gate_api.ApiClient(configuration))
order_id = '12345' # str | ID returned on order successfully being created

try:
    # Cancel a single order
    api_response = api_instance.cancel_futures_order(order_id)
    print(api_response)
except ApiException as e:
    print("Exception when calling FuturesApi->cancel_futures_order: %s\n" % e)

from __future__ import print_function
import gate_api
from gate_api.rest import ApiException

configuration = gate_api.Configuration()
configuration.key = 'YOUR_API_KEY'
configuration.secret = 'YOUR_API_SECRET'

# create an instance of the API class
api_instance = gate_api.FuturesApi(gate_api.ApiClient(configuration))
contract = 'BTC_USD' # str | Futures contract
side = 'ask' # str | All bids or asks. Both included in not specified (optional)

try:
    # Cancel all `open` orders matched
    api_response = api_instance.cancel_futures_orders(contract, side=side)
    print(api_response)
except ApiException as e:
    print("Exception when calling FuturesApi->cancel_futures_orders: %s\n" % e)

from __future__ import print_function
import gate_api
from gate_api.rest import ApiException

configuration = gate_api.Configuration()
configuration.key = 'YOUR_API_KEY'
configuration.secret = 'YOUR_API_SECRET'

# create an instance of the API class
api_instance = gate_api.FuturesApi(gate_api.ApiClient(configuration))
order_id = 'order_id_example' # str | ID returned on order successfully being created

try:
    # Cancel a single order
    api_response = api_instance.cancel_price_triggered_order(order_id)
    print(api_response)
except ApiException as e:
    print("Exception when calling FuturesApi->cancel_price_triggered_order: %s\n" % e)

from __future__ import print_function
import gate_api
from gate_api.rest import ApiException

configuration = gate_api.Configuration()
configuration.key = 'YOUR_API_KEY'
configuration.secret = 'YOUR_API_SECRET'

# create an instance of the API class
api_instance = gate_api.FuturesApi(gate_api.ApiClient(configuration))
contract = 'BTC_USD' # str | Futures contract

try:
    # Cancel all open orders
    api_response = api_instance.cancel_price_triggered_order_list(contract)
    print(api_response)
except ApiException as e:
    print("Exception when calling FuturesApi->cancel_price_triggered_order_list: %s\n" % e)

from __future__ import print_function
import gate_api
from gate_api.rest import ApiException

configuration = gate_api.Configuration()
configuration.key = 'YOUR_API_KEY'
configuration.secret = 'YOUR_API_SECRET'

# create an instance of the API class
api_instance = gate_api.FuturesApi(gate_api.ApiClient(configuration))
futures_order = gate_api.FuturesOrder() # FuturesOrder | 

try:
    # Create a futures order
    api_response = api_instance.create_futures_order(futures_order)
    print(api_response)
except ApiException as e:
    print("Exception when calling FuturesApi->create_futures_order: %s\n" % e)

from __future__ import print_function
import gate_api
from gate_api.rest import ApiException

configuration = gate_api.Configuration()
configuration.key = 'YOUR_API_KEY'
configuration.secret = 'YOUR_API_SECRET'

# create an instance of the API class
api_instance = gate_api.FuturesApi(gate_api.ApiClient(configuration))
futures_price_triggered_order = gate_api.FuturesPriceTriggeredOrder() # FuturesPriceTriggeredOrder | 

try:
    # Create a price-triggered order
    api_response = api_instance.create_price_triggered_order(futures_price_triggered_order)
    print(api_response)
except ApiException as e:
    print("Exception when calling FuturesApi->create_price_triggered_order: %s\n" % e)

from __future__ import print_function
import gate_api
from gate_api.rest import ApiException

# create an instance of the API class
api_instance = gate_api.FuturesApi()
contract = 'BTC_USD' # str | Futures contract

try:
    # Get a single contract
    api_response = api_instance.get_futures_contract(contract)
    print(api_response)
except ApiException as e:
    print("Exception when calling FuturesApi->get_futures_contract: %s\n" % e)

from __future__ import print_function
import gate_api
from gate_api.rest import ApiException

configuration = gate_api.Configuration()
configuration.key = 'YOUR_API_KEY'
configuration.secret = 'YOUR_API_SECRET'

# create an instance of the API class
api_instance = gate_api.FuturesApi(gate_api.ApiClient(configuration))
order_id = '12345' # str | ID returned on order successfully being created

try:
    # Get a single order
    api_response = api_instance.get_futures_order(order_id)
    print(api_response)
except ApiException as e:
    print("Exception when calling FuturesApi->get_futures_order: %s\n" % e)

from __future__ import print_function
import gate_api
from gate_api.rest import ApiException

configuration = gate_api.Configuration()
configuration.key = 'YOUR_API_KEY'
configuration.secret = 'YOUR_API_SECRET'

# create an instance of the API class
api_instance = gate_api.FuturesApi(gate_api.ApiClient(configuration))
contract = 'BTC_USD' # str | Futures contract, return related data only if specified (optional)
order = 12345 # int | Futures order ID, return related data only if specified (optional)
limit = 100 # int | Maximum number of record returned in one list (optional) (default to 100)
last_id = '12345' # str | Specify list staring point using the last record of `id` in previous list-query results (optional)

try:
    # List personal trading history
    api_response = api_instance.get_my_trades(contract=contract, order=order, limit=limit, last_id=last_id)
    print(api_response)
except ApiException as e:
    print("Exception when calling FuturesApi->get_my_trades: %s\n" % e)

from __future__ import print_function
import gate_api
from gate_api.rest import ApiException

configuration = gate_api.Configuration()
configuration.key = 'YOUR_API_KEY'
configuration.secret = 'YOUR_API_SECRET'

# create an instance of the API class
api_instance = gate_api.FuturesApi(gate_api.ApiClient(configuration))
contract = 'BTC_USD' # str | Futures contract

try:
    # Get single position
    api_response = api_instance.get_position(contract)
    print(api_response)
except ApiException as e:
    print("Exception when calling FuturesApi->get_position: %s\n" % e)

from __future__ import print_function
import gate_api
from gate_api.rest import ApiException

configuration = gate_api.Configuration()
configuration.key = 'YOUR_API_KEY'
configuration.secret = 'YOUR_API_SECRET'

# create an instance of the API class
api_instance = gate_api.FuturesApi(gate_api.ApiClient(configuration))
order_id = 'order_id_example' # str | ID returned on order successfully being created

try:
    # Get a single order
    api_response = api_instance.get_price_triggered_order(order_id)
    print(api_response)
except ApiException as e:
    print("Exception when calling FuturesApi->get_price_triggered_order: %s\n" % e)

from __future__ import print_function
import gate_api
from gate_api.rest import ApiException

configuration = gate_api.Configuration()
configuration.key = 'YOUR_API_KEY'
configuration.secret = 'YOUR_API_SECRET'

# create an instance of the API class
api_instance = gate_api.FuturesApi(gate_api.ApiClient(configuration))
limit = 100 # int | Maximum number of record returned in one list (optional) (default to 100)
_from = 1547706332 # int | Start timestamp (optional)
to = 1547706332 # int | End timestamp (optional)
type = 'dnw' # str | Changing Type  - dnw: Deposit & Withdraw - pnl: Profit & Loss by reducing position - fee: Trading fee - refr: Referrer rebate - fund: Funding (optional)

try:
    # Query account book
    api_response = api_instance.list_futures_account_book(limit=limit, _from=_from, to=to, type=type)
    print(api_response)
except ApiException as e:
    print("Exception when calling FuturesApi->list_futures_account_book: %s\n" % e)

from __future__ import print_function
import gate_api
from gate_api.rest import ApiException

configuration = gate_api.Configuration()
configuration.key = 'YOUR_API_KEY'
configuration.secret = 'YOUR_API_SECRET'

# create an instance of the API class
api_instance = gate_api.FuturesApi(gate_api.ApiClient(configuration))

try:
    # Query futures account
    api_response = api_instance.list_futures_accounts()
    print(api_response)
except ApiException as e:
    print("Exception when calling FuturesApi->list_futures_accounts: %s\n" % e)

from __future__ import print_function
import gate_api
from gate_api.rest import ApiException

# create an instance of the API class
api_instance = gate_api.FuturesApi()
contract = 'BTC_USD' # str | Futures contract
_from = 1546905600 # float | Start time of candlesticks, formatted in Unix timestamp in seconds. Default to`to - 100 * interval` if not specified (optional)
to = 1546935600 # float | End time of candlesticks, formatted in Unix timestamp in seconds. Default to current time (optional)
limit = 100 # int | Maximum recent data points returned. `limit` is conflicted with `from` and `to`. If either `from` or `to` is specified, request will be rejected. (optional) (default to 100)
interval = '5m' # str | Interval time between data points (optional) (default to '5m')

try:
    # Get futures candlesticks
    api_response = api_instance.list_futures_candlesticks(contract, _from=_from, to=to, limit=limit, interval=interval)
    print(api_response)
except ApiException as e:
    print("Exception when calling FuturesApi->list_futures_candlesticks: %s\n" % e)

from __future__ import print_function
import gate_api
from gate_api.rest import ApiException

# create an instance of the API class
api_instance = gate_api.FuturesApi()

try:
    # List all futures contracts
    api_response = api_instance.list_futures_contracts()
    print(api_response)
except ApiException as e:
    print("Exception when calling FuturesApi->list_futures_contracts: %s\n" % e)

from __future__ import print_function
import gate_api
from gate_api.rest import ApiException

# create an instance of the API class
api_instance = gate_api.FuturesApi()
contract = 'BTC_USD' # str | Futures contract
limit = 100 # int | Maximum number of record returned in one list (optional) (default to 100)

try:
    # Funding rate history
    api_response = api_instance.list_futures_funding_rate_history(contract, limit=limit)
    print(api_response)
except ApiException as e:
    print("Exception when calling FuturesApi->list_futures_funding_rate_history: %s\n" % e)

from __future__ import print_function
import gate_api
from gate_api.rest import ApiException

# create an instance of the API class
api_instance = gate_api.FuturesApi()
limit = 100 # int | Maximum number of record returned in one list (optional) (default to 100)

try:
    # Futures insurance balance history
    api_response = api_instance.list_futures_insurance_ledger(limit=limit)
    print(api_response)
except ApiException as e:
    print("Exception when calling FuturesApi->list_futures_insurance_ledger: %s\n" % e)

from __future__ import print_function
import gate_api
from gate_api.rest import ApiException

# create an instance of the API class
api_instance = gate_api.FuturesApi()
contract = 'BTC_USD' # str | Futures contract
interval = '0' # str | Order depth. 0 means no aggregation is applied. default to 0 (optional) (default to '0')
limit = 10 # int | Maximum number of order depth data in asks or bids (optional) (default to 10)

try:
    # Futures order book
    api_response = api_instance.list_futures_order_book(contract, interval=interval, limit=limit)
    print(api_response)
except ApiException as e:
    print("Exception when calling FuturesApi->list_futures_order_book: %s\n" % e)

from __future__ import print_function
import gate_api
from gate_api.rest import ApiException

configuration = gate_api.Configuration()
configuration.key = 'YOUR_API_KEY'
configuration.secret = 'YOUR_API_SECRET'

# create an instance of the API class
api_instance = gate_api.FuturesApi(gate_api.ApiClient(configuration))
contract = 'BTC_USD' # str | Futures contract
status = 'open' # str | List orders based on status
limit = 100 # int | Maximum number of record returned in one list (optional) (default to 100)
last_id = '12345' # str | Specify list staring point using the last record of `id` in previous list-query results (optional)

try:
    # List futures orders
    api_response = api_instance.list_futures_orders(contract, status, limit=limit, last_id=last_id)
    print(api_response)
except ApiException as e:
    print("Exception when calling FuturesApi->list_futures_orders: %s\n" % e)

from __future__ import print_function
import gate_api
from gate_api.rest import ApiException

# create an instance of the API class
api_instance = gate_api.FuturesApi()
contract = 'BTC_USD' # str | Futures contract, return related data only if specified (optional)

try:
    # List futures tickers
    api_response = api_instance.list_futures_tickers(contract=contract)
    print(api_response)
except ApiException as e:
    print("Exception when calling FuturesApi->list_futures_tickers: %s\n" % e)

from __future__ import print_function
import gate_api
from gate_api.rest import ApiException

# create an instance of the API class
api_instance = gate_api.FuturesApi()
contract = 'BTC_USD' # str | Futures contract
limit = 100 # int | Maximum number of record returned in one list (optional) (default to 100)
last_id = '12345' # str | Specify list staring point using the last record of `id` in previous list-query results (optional)

try:
    # Futures trading history
    api_response = api_instance.list_futures_trades(contract, limit=limit, last_id=last_id)
    print(api_response)
except ApiException as e:
    print("Exception when calling FuturesApi->list_futures_trades: %s\n" % e)

from __future__ import print_function
import gate_api
from gate_api.rest import ApiException

configuration = gate_api.Configuration()
configuration.key = 'YOUR_API_KEY'
configuration.secret = 'YOUR_API_SECRET'

# create an instance of the API class
api_instance = gate_api.FuturesApi(gate_api.ApiClient(configuration))
contract = 'BTC_USD' # str | Futures contract, return related data only if specified (optional)
limit = 100 # int | Maximum number of record returned in one list (optional) (default to 100)

try:
    # List position close history
    api_response = api_instance.list_position_close(contract=contract, limit=limit)
    print(api_response)
except ApiException as e:
    print("Exception when calling FuturesApi->list_position_close: %s\n" % e)

from __future__ import print_function
import gate_api
from gate_api.rest import ApiException

configuration = gate_api.Configuration()
configuration.key = 'YOUR_API_KEY'
configuration.secret = 'YOUR_API_SECRET'

# create an instance of the API class
api_instance = gate_api.FuturesApi(gate_api.ApiClient(configuration))

try:
    # List all positions of a user
    api_response = api_instance.list_positions()
    print(api_response)
except ApiException as e:
    print("Exception when calling FuturesApi->list_positions: %s\n" % e)

from __future__ import print_function
import gate_api
from gate_api.rest import ApiException

configuration = gate_api.Configuration()
configuration.key = 'YOUR_API_KEY'
configuration.secret = 'YOUR_API_SECRET'

# create an instance of the API class
api_instance = gate_api.FuturesApi(gate_api.ApiClient(configuration))
status = 'status_example' # str | List orders based on status
contract = 'BTC_USD' # str | Futures contract, return related data only if specified (optional)
limit = 100 # int | Maximum number of record returned in one list (optional) (default to 100)
offset = 0 # int | List offset, starting from 0 (optional) (default to 0)

try:
    # List all auto orders
    api_response = api_instance.list_price_triggered_orders(status, contract=contract, limit=limit, offset=offset)
    print(api_response)
except ApiException as e:
    print("Exception when calling FuturesApi->list_price_triggered_orders: %s\n" % e)

from __future__ import print_function
import gate_api
from gate_api.rest import ApiException

configuration = gate_api.Configuration()
configuration.key = 'YOUR_API_KEY'
configuration.secret = 'YOUR_API_SECRET'

# create an instance of the API class
api_instance = gate_api.FuturesApi(gate_api.ApiClient(configuration))
contract = 'BTC_USD' # str | Futures contract
leverage = '10' # str | New position leverage

try:
    # Update position leverage
    api_response = api_instance.update_position_leverage(contract, leverage)
    print(api_response)
except ApiException as e:
    print("Exception when calling FuturesApi->update_position_leverage: %s\n" % e)

from __future__ import print_function
import gate_api
from gate_api.rest import ApiException

configuration = gate_api.Configuration()
configuration.key = 'YOUR_API_KEY'
configuration.secret = 'YOUR_API_SECRET'

# create an instance of the API class
api_instance = gate_api.FuturesApi(gate_api.ApiClient(configuration))
contract = 'BTC_USD' # str | Futures contract
change = '0.01' # str | Margin change. Use positive number to increase margin, negative number otherwise.

try:
    # Update position margin
    api_response = api_instance.update_position_margin(contract, change)
    print(api_response)
except ApiException as e:
    print("Exception when calling FuturesApi->update_position_margin: %s\n" % e)

from __future__ import print_function
import gate_api
from gate_api.rest import ApiException

configuration = gate_api.Configuration()
configuration.key = 'YOUR_API_KEY'
configuration.secret = 'YOUR_API_SECRET'

# create an instance of the API class
api_instance = gate_api.FuturesApi(gate_api.ApiClient(configuration))
contract = 'BTC_USD' # str | Futures contract
risk_limit = '10' # str | New position risk limit

try:
    # Update position risk limit
    api_response = api_instance.update_position_risk_limit(contract, risk_limit)
    print(api_response)
except ApiException as e:
    print("Exception when calling FuturesApi->update_position_risk_limit: %s\n" % e)