Warum verwenden Trading-API-Wrapper häufig Wörterbücher, um benutzerfreundliche Eingaben (.. Buy, CNC) auf interne API-K ⇐ Python

[Anonymous]

Ich verwende den folgenden Code, um eine Bestellung aufzugeben: < /p>

Code: Select all

from Dhan_Tradehull import Tradehull

client_code = "110"
token_id = "eCbXElV9AIPuQ"

# Initialize Tradehull object (tradehull support library)
tsl = Tradehull(client_code, token_id)

# Place an order using the wrapper function, without needing security ID manually
orderid3 = tsl.order_placement(
'MONOT',     # Trading symbol
'BSE',       # Exchange
10,          # Quantity
0,           # Price
0,           # Trigger price
'MARKET',    # Order type
'BUY',       # Transaction type
'CNC'        # Trade type / product
)

Im obigen Code verwende ich die in dhan_tradehull definierte Handelshülle Die Konstruktorin von TradeHull hat ein Dhan -Objekt des Dhanhq in DhanHQ.Py . Order_placement Funktion ist so definiert:

Code: Select all

def order_placement(
self,
tradingsymbol: str,
exchange: str,
quantity: int,
price: int,
trigger_price: int,
order_type: str,
transaction_type: str,
trade_type: str
) -> str:

try:
script_exchange = {
"NSE": self.Dhan.NSE,
"NFO": self.Dhan.NSE_FNO,
"BFO": self.Dhan.BSE_FNO,
"CUR": self.Dhan.CUR,
"BSE": self.Dhan.BSE,
"MCX": self.Dhan.MCX
}

self.order_Type = {
'LIMIT': self.Dhan.LIMIT,
'MARKET': self.Dhan.MARKET,
'STOPLIMIT': self.Dhan.SL,
'STOPMARKET': self.Dhan.SLM
}

product = {
'MIS': self.Dhan.INTRA,
'MARGIN': self.Dhan.MARGIN,
'MTF': self.Dhan.MTF,
'CO': self.Dhan.CO,
'BO': self.Dhan.BO,
'CNC': self.Dhan.CNC
}

Validity = {'DAY': "DAY", 'IOC': 'IOC'}
transactiontype = {'BUY': self.Dhan.BUY, 'SELL': self.Dhan.SELL}
instrument_exchange = {
'NSE': "NSE",
'BSE': "BSE",
'NFO': 'NSE',
'BFO': 'BSE',
'MCX': 'MCX',
'CUR': 'NSE'
}

exchangeSegment = script_exchange[exchange]
product_Type = product[trade_type.upper()]
order_type = self.order_Type[order_type.upper()]
order_side = transactiontype[transaction_type.upper()]
time_in_force = Validity['DAY']

# Get security ID from instrument dataframe
security_id = self.instrument_df[
((self.instrument_df['SEM_TRADING_SYMBOL'] == tradingsymbol) |
(self.instrument_df['SEM_CUSTOM_SYMBOL'] == tradingsymbol)) &
(self.instrument_df['SEM_EXM_EXCH_ID'] == instrument_exchange[exchange])
].iloc[-1]['SEM_SMST_SECURITY_ID']

# Call Dhan's API wrapper
order = self.Dhan.place_order(
security_id=str(security_id),
exchange_segment=exchangeSegment,
transaction_type=order_side,
quantity=quantity,
order_type=order_type,
product_type=product_Type,
price=price,
trigger_price=trigger_price
)

orderid = order["data"]["orderId"]
return str(orderid)

except Exception as e:
self.logger.exception(f'Got exception in place_order: {e}')
traceback.print_exc()
return None

und in Dhanhq.py hat die Dhanhq -Klasses eine Funktion von Place_order , die intern aufgerufen wird.

Code: Select all

def place_order(
self,
security_id,
exchange_segment,
transaction_type,
quantity,
order_type,
product_type,
price,
trigger_price=0,
disclosed_quantity=0,
after_market_order=True,
validity='DAY',
amo_time='OPEN',
bo_profit_value=None,
bo_stop_loss_Value=None,
tag=None
):
try:
url = self.base_url + '/orders'
payload = {
"dhanClientId": self.client_id,
"transactionType": transaction_type.upper(),
"exchangeSegment": exchange_segment.upper(),
"productType": product_type.upper(),
"orderType": order_type.upper(),
"validity": validity.upper(),
"securityId": security_id,
"quantity": int(quantity),
"disclosedQuantity": int(disclosed_quantity),
"price": float(price),
"afterMarketOrder": after_market_order,
"boProfitValue": bo_profit_value,
"boStopLossValue": bo_stop_loss_Value
}

if tag is not None and tag != '':
payload["correlationId"] = tag

if after_market_order:
if amo_time in ['PRE_OPEN', 'OPEN', 'OPEN_30', 'OPEN_60']:
payload['amoTime'] = amo_time
else:
raise Exception("amo_time must be one of ['PRE_OPEN','OPEN','OPEN_30','OPEN_60']")

if trigger_price > 0:
payload["triggerPrice"] = float(trigger_price)
else:
payload["triggerPrice"] = 0.0

payload = json_dumps(payload)
response = self.session.post(url, data=payload, headers=self.header, timeout=self.timeout)
return self._parse_response(response)

except Exception as e:
logging.error('Exception in dhanhq>>place_order: %s', e)
return {
'status': 'failure',
'remarks': str(e),
'data': '',
}

Meine Frage:
Ich möchte zu diesen Wörterbüchern in Order_placement fragen:
product = {
'MIS': self.Dhan.INTRA,
'MARGIN': self.Dhan.MARGIN,
'MTF': self.Dhan.MTF,
'CO': self.Dhan.CO,
'BO': self.Dhan.BO,
'CNC': self.Dhan.CNC
}
< /code>
Ich möchte wissen, warum diese Wörterbücher definiert sind. Soweit ich diese Wörterbücher sehe, konvertieren sie nur Benutzereingaben in einige interne Namen. Verstehe die Gründe für die Definition dieser Wörterbücher. Denn meiner Meinung nach scheinen sie nur für die Konvertierung von Benutzereingaben in interne Darstellungen gedacht zu sein.