1454 lines
42 KiB
JSON
1454 lines
42 KiB
JSON
{
|
|
"chunks": [
|
|
{
|
|
"chunk_id": "artifacts\\execution\\live.yaml::factual_summary",
|
|
"content": "[./live.py] Factual summary: Provides the runtime framework for executing a market making strategy in either paper or live trading modes. Responsible for initializing exchanges, loading symbol universes, configuring execution components, processing real-time market data, and coordinating the continuous operation of the trading system.",
|
|
"chunk_type": "factual_summary",
|
|
"artifact_file": "artifacts\\execution\\live.yaml",
|
|
"source_file": "./live.py",
|
|
"tags": {
|
|
"domain": [
|
|
"market_data",
|
|
"strategy_execution",
|
|
"order_execution",
|
|
"exchange_integration"
|
|
],
|
|
"trading_function": [
|
|
"data_ingest",
|
|
"entry_logic",
|
|
"exit_logic"
|
|
],
|
|
"strategy_layer": [
|
|
"execution"
|
|
],
|
|
"system_layer": [
|
|
"worker"
|
|
],
|
|
"intent": [
|
|
"orchestration",
|
|
"isolation",
|
|
"safety"
|
|
],
|
|
"data_type": [
|
|
"signals",
|
|
"orders",
|
|
"exchanges"
|
|
],
|
|
"risk": [
|
|
"latency",
|
|
"data_corruption",
|
|
"capital_loss"
|
|
],
|
|
"maturity": [
|
|
"production"
|
|
]
|
|
}
|
|
},
|
|
{
|
|
"chunk_id": "artifacts\\execution\\live.yaml::interpretive_summary",
|
|
"content": "[./live.py] Interpretive summary: Acts as the top-level execution driver for the trading system, wiring together strategy logic, execution components, and exchange data feeds into a single long-running process. Designed to support both simulated and live trading environments while enabling observability and operational control during runtime.",
|
|
"chunk_type": "interpretive_summary",
|
|
"artifact_file": "artifacts\\execution\\live.yaml",
|
|
"source_file": "./live.py",
|
|
"tags": {
|
|
"domain": [
|
|
"market_data",
|
|
"strategy_execution",
|
|
"order_execution",
|
|
"exchange_integration"
|
|
],
|
|
"trading_function": [
|
|
"data_ingest",
|
|
"entry_logic",
|
|
"exit_logic"
|
|
],
|
|
"strategy_layer": [
|
|
"execution"
|
|
],
|
|
"system_layer": [
|
|
"worker"
|
|
],
|
|
"intent": [
|
|
"orchestration",
|
|
"isolation",
|
|
"safety"
|
|
],
|
|
"data_type": [
|
|
"signals",
|
|
"orders",
|
|
"exchanges"
|
|
],
|
|
"risk": [
|
|
"latency",
|
|
"data_corruption",
|
|
"capital_loss"
|
|
],
|
|
"maturity": [
|
|
"production"
|
|
]
|
|
}
|
|
},
|
|
{
|
|
"chunk_id": "artifacts\\execution\\live.yaml::method::main() -> None",
|
|
"content": "[./live.py] Method main() -> None: Asynchronous entry point that orchestrates system initialization, strategy and trader setup, exchange connectivity, optional logging and metrics configuration, and continuous processing of incoming market data events.",
|
|
"chunk_type": "method",
|
|
"artifact_file": "artifacts\\execution\\live.yaml",
|
|
"source_file": "./live.py",
|
|
"tags": {
|
|
"domain": [
|
|
"market_data",
|
|
"strategy_execution",
|
|
"order_execution",
|
|
"exchange_integration"
|
|
],
|
|
"trading_function": [
|
|
"data_ingest",
|
|
"entry_logic",
|
|
"exit_logic"
|
|
],
|
|
"strategy_layer": [
|
|
"execution"
|
|
],
|
|
"system_layer": [
|
|
"worker"
|
|
],
|
|
"intent": [
|
|
"orchestration",
|
|
"isolation",
|
|
"safety"
|
|
],
|
|
"data_type": [
|
|
"signals",
|
|
"orders",
|
|
"exchanges"
|
|
],
|
|
"risk": [
|
|
"latency",
|
|
"data_corruption",
|
|
"capital_loss"
|
|
],
|
|
"maturity": [
|
|
"production"
|
|
]
|
|
}
|
|
},
|
|
{
|
|
"chunk_id": "artifacts\\execution\\live.yaml::invariants",
|
|
"content": "[./live.py] Invariants: - Trading mode must be explicitly selected before execution begins. - Exchanges must be initialized prior to processing market data. - Strategy and trader instances must be fully constructed before entering the main processing loop. - Market data processing must run continuously until the process terminates. - Logging and metrics configuration must not interfere with execution.",
|
|
"chunk_type": "invariants",
|
|
"artifact_file": "artifacts\\execution\\live.yaml",
|
|
"source_file": "./live.py",
|
|
"tags": {
|
|
"domain": [
|
|
"market_data",
|
|
"strategy_execution",
|
|
"order_execution",
|
|
"exchange_integration"
|
|
],
|
|
"trading_function": [
|
|
"data_ingest",
|
|
"entry_logic",
|
|
"exit_logic"
|
|
],
|
|
"strategy_layer": [
|
|
"execution"
|
|
],
|
|
"system_layer": [
|
|
"worker"
|
|
],
|
|
"intent": [
|
|
"orchestration",
|
|
"isolation",
|
|
"safety"
|
|
],
|
|
"data_type": [
|
|
"signals",
|
|
"orders",
|
|
"exchanges"
|
|
],
|
|
"risk": [
|
|
"latency",
|
|
"data_corruption",
|
|
"capital_loss"
|
|
],
|
|
"maturity": [
|
|
"production"
|
|
]
|
|
}
|
|
},
|
|
{
|
|
"chunk_id": "artifacts\\execution\\trader.yaml::factual_summary",
|
|
"content": "[./trader.py] Factual summary: Implements the execution component responsible for placing and managing long and short trades, including associated hedge operations, across supported exchanges. Maintains order book state, open positions, fees, and profit and loss tracking while supporting both live trading and backtesting modes.",
|
|
"chunk_type": "factual_summary",
|
|
"artifact_file": "artifacts\\execution\\trader.yaml",
|
|
"source_file": "./trader.py",
|
|
"tags": {
|
|
"domain": [
|
|
"order_execution",
|
|
"exchange_integration",
|
|
"pnl_accounting"
|
|
],
|
|
"trading_function": [
|
|
"entry_logic",
|
|
"exit_logic"
|
|
],
|
|
"strategy_layer": [
|
|
"execution"
|
|
],
|
|
"system_layer": [
|
|
"service"
|
|
],
|
|
"intent": [
|
|
"abstraction",
|
|
"safety",
|
|
"isolation"
|
|
],
|
|
"data_type": [
|
|
"orders",
|
|
"positions",
|
|
"pnl",
|
|
"exchanges"
|
|
],
|
|
"risk": [
|
|
"capital_loss",
|
|
"latency",
|
|
"data_corruption"
|
|
],
|
|
"maturity": [
|
|
"production"
|
|
]
|
|
}
|
|
},
|
|
{
|
|
"chunk_id": "artifacts\\execution\\trader.yaml::interpretive_summary",
|
|
"content": "[./trader.py] Interpretive summary: Acts as the execution boundary between strategy decision logic and exchange interaction, encapsulating trade placement, position tracking, and operational mode handling. Designed to centralize execution-side concerns such as fee application, position state, and environment-aware behavior for live and simulated trading.",
|
|
"chunk_type": "interpretive_summary",
|
|
"artifact_file": "artifacts\\execution\\trader.yaml",
|
|
"source_file": "./trader.py",
|
|
"tags": {
|
|
"domain": [
|
|
"order_execution",
|
|
"exchange_integration",
|
|
"pnl_accounting"
|
|
],
|
|
"trading_function": [
|
|
"entry_logic",
|
|
"exit_logic"
|
|
],
|
|
"strategy_layer": [
|
|
"execution"
|
|
],
|
|
"system_layer": [
|
|
"service"
|
|
],
|
|
"intent": [
|
|
"abstraction",
|
|
"safety",
|
|
"isolation"
|
|
],
|
|
"data_type": [
|
|
"orders",
|
|
"positions",
|
|
"pnl",
|
|
"exchanges"
|
|
],
|
|
"risk": [
|
|
"capital_loss",
|
|
"latency",
|
|
"data_corruption"
|
|
],
|
|
"maturity": [
|
|
"production"
|
|
]
|
|
}
|
|
},
|
|
{
|
|
"chunk_id": "artifacts\\execution\\trader.yaml::method::_getBracket(exch: str, sym: str) -> List[]",
|
|
"content": "[./trader.py] Method _getBracket(exch: str, sym: str) -> List[]: Retrieves the current bid and ask information for a given symbol on a specified exchange using maintained order book state.",
|
|
"chunk_type": "method",
|
|
"artifact_file": "artifacts\\execution\\trader.yaml",
|
|
"source_file": "./trader.py",
|
|
"tags": {
|
|
"domain": [
|
|
"order_execution",
|
|
"exchange_integration",
|
|
"pnl_accounting"
|
|
],
|
|
"trading_function": [
|
|
"entry_logic",
|
|
"exit_logic"
|
|
],
|
|
"strategy_layer": [
|
|
"execution"
|
|
],
|
|
"system_layer": [
|
|
"service"
|
|
],
|
|
"intent": [
|
|
"abstraction",
|
|
"safety",
|
|
"isolation"
|
|
],
|
|
"data_type": [
|
|
"orders",
|
|
"positions",
|
|
"pnl",
|
|
"exchanges"
|
|
],
|
|
"risk": [
|
|
"capital_loss",
|
|
"latency",
|
|
"data_corruption"
|
|
],
|
|
"maturity": [
|
|
"production"
|
|
]
|
|
}
|
|
},
|
|
{
|
|
"chunk_id": "artifacts\\execution\\trader.yaml::method::startBidding(exch: str, sym: str, ts: float, entryPrice: float or None) -> None",
|
|
"content": "[./trader.py] Method startBidding(exch: str, sym: str, ts: float, entryPrice: float or None) -> None: Used in the Strat class to update the entry price of a symbol on a particular exchange. Logic for updating the entry price is contained there.",
|
|
"chunk_type": "method",
|
|
"artifact_file": "artifacts\\execution\\trader.yaml",
|
|
"source_file": "./trader.py",
|
|
"tags": {
|
|
"domain": [
|
|
"order_execution",
|
|
"exchange_integration",
|
|
"pnl_accounting"
|
|
],
|
|
"trading_function": [
|
|
"entry_logic",
|
|
"exit_logic"
|
|
],
|
|
"strategy_layer": [
|
|
"execution"
|
|
],
|
|
"system_layer": [
|
|
"service"
|
|
],
|
|
"intent": [
|
|
"abstraction",
|
|
"safety",
|
|
"isolation"
|
|
],
|
|
"data_type": [
|
|
"orders",
|
|
"positions",
|
|
"pnl",
|
|
"exchanges"
|
|
],
|
|
"risk": [
|
|
"capital_loss",
|
|
"latency",
|
|
"data_corruption"
|
|
],
|
|
"maturity": [
|
|
"production"
|
|
]
|
|
}
|
|
},
|
|
{
|
|
"chunk_id": "artifacts\\execution\\trader.yaml::method::stopBidding(exch: str, sym: str, ts: float) -> None",
|
|
"content": "[./trader.py] Method stopBidding(exch: str, sym: str, ts: float) -> None: Halts the bidding by removing the order from the limitBuy dictionary.",
|
|
"chunk_type": "method",
|
|
"artifact_file": "artifacts\\execution\\trader.yaml",
|
|
"source_file": "./trader.py",
|
|
"tags": {
|
|
"domain": [
|
|
"order_execution",
|
|
"exchange_integration",
|
|
"pnl_accounting"
|
|
],
|
|
"trading_function": [
|
|
"entry_logic",
|
|
"exit_logic"
|
|
],
|
|
"strategy_layer": [
|
|
"execution"
|
|
],
|
|
"system_layer": [
|
|
"service"
|
|
],
|
|
"intent": [
|
|
"abstraction",
|
|
"safety",
|
|
"isolation"
|
|
],
|
|
"data_type": [
|
|
"orders",
|
|
"positions",
|
|
"pnl",
|
|
"exchanges"
|
|
],
|
|
"risk": [
|
|
"capital_loss",
|
|
"latency",
|
|
"data_corruption"
|
|
],
|
|
"maturity": [
|
|
"production"
|
|
]
|
|
}
|
|
},
|
|
{
|
|
"chunk_id": "artifacts\\execution\\trader.yaml::method::updateBracket(exch: str, sym: str, bidQuote: float, askQuote: float) -> None",
|
|
"content": "[./trader.py] Method updateBracket(exch: str, sym: str, bidQuote: float, askQuote: float) -> None: Updates the bracketed strings in our brackets dictionary.",
|
|
"chunk_type": "method",
|
|
"artifact_file": "artifacts\\execution\\trader.yaml",
|
|
"source_file": "./trader.py",
|
|
"tags": {
|
|
"domain": [
|
|
"order_execution",
|
|
"exchange_integration",
|
|
"pnl_accounting"
|
|
],
|
|
"trading_function": [
|
|
"entry_logic",
|
|
"exit_logic"
|
|
],
|
|
"strategy_layer": [
|
|
"execution"
|
|
],
|
|
"system_layer": [
|
|
"service"
|
|
],
|
|
"intent": [
|
|
"abstraction",
|
|
"safety",
|
|
"isolation"
|
|
],
|
|
"data_type": [
|
|
"orders",
|
|
"positions",
|
|
"pnl",
|
|
"exchanges"
|
|
],
|
|
"risk": [
|
|
"capital_loss",
|
|
"latency",
|
|
"data_corruption"
|
|
],
|
|
"maturity": [
|
|
"production"
|
|
]
|
|
}
|
|
},
|
|
{
|
|
"chunk_id": "artifacts\\execution\\trader.yaml::method::startOffering(exch: str, sym: str, ts: float, entryPrice: float or None) -> None",
|
|
"content": "[./trader.py] Method startOffering(exch: str, sym: str, ts: float, entryPrice: float or None) -> None: Executes the trades when we are going short.",
|
|
"chunk_type": "method",
|
|
"artifact_file": "artifacts\\execution\\trader.yaml",
|
|
"source_file": "./trader.py",
|
|
"tags": {
|
|
"domain": [
|
|
"order_execution",
|
|
"exchange_integration",
|
|
"pnl_accounting"
|
|
],
|
|
"trading_function": [
|
|
"entry_logic",
|
|
"exit_logic"
|
|
],
|
|
"strategy_layer": [
|
|
"execution"
|
|
],
|
|
"system_layer": [
|
|
"service"
|
|
],
|
|
"intent": [
|
|
"abstraction",
|
|
"safety",
|
|
"isolation"
|
|
],
|
|
"data_type": [
|
|
"orders",
|
|
"positions",
|
|
"pnl",
|
|
"exchanges"
|
|
],
|
|
"risk": [
|
|
"capital_loss",
|
|
"latency",
|
|
"data_corruption"
|
|
],
|
|
"maturity": [
|
|
"production"
|
|
]
|
|
}
|
|
},
|
|
{
|
|
"chunk_id": "artifacts\\execution\\trader.yaml::method::stopOffering(exch: str, sym: str, ts: float) -> None",
|
|
"content": "[./trader.py] Method stopOffering(exch: str, sym: str, ts: float) -> None: Stops the short position.",
|
|
"chunk_type": "method",
|
|
"artifact_file": "artifacts\\execution\\trader.yaml",
|
|
"source_file": "./trader.py",
|
|
"tags": {
|
|
"domain": [
|
|
"order_execution",
|
|
"exchange_integration",
|
|
"pnl_accounting"
|
|
],
|
|
"trading_function": [
|
|
"entry_logic",
|
|
"exit_logic"
|
|
],
|
|
"strategy_layer": [
|
|
"execution"
|
|
],
|
|
"system_layer": [
|
|
"service"
|
|
],
|
|
"intent": [
|
|
"abstraction",
|
|
"safety",
|
|
"isolation"
|
|
],
|
|
"data_type": [
|
|
"orders",
|
|
"positions",
|
|
"pnl",
|
|
"exchanges"
|
|
],
|
|
"risk": [
|
|
"capital_loss",
|
|
"latency",
|
|
"data_corruption"
|
|
],
|
|
"maturity": [
|
|
"production"
|
|
]
|
|
}
|
|
},
|
|
{
|
|
"chunk_id": "artifacts\\execution\\trader.yaml::method::logIntradayPnl(val: float) -> None",
|
|
"content": "[./trader.py] Method logIntradayPnl(val: float) -> None: Updates the value of our account to our pnl database",
|
|
"chunk_type": "method",
|
|
"artifact_file": "artifacts\\execution\\trader.yaml",
|
|
"source_file": "./trader.py",
|
|
"tags": {
|
|
"domain": [
|
|
"order_execution",
|
|
"exchange_integration",
|
|
"pnl_accounting"
|
|
],
|
|
"trading_function": [
|
|
"entry_logic",
|
|
"exit_logic"
|
|
],
|
|
"strategy_layer": [
|
|
"execution"
|
|
],
|
|
"system_layer": [
|
|
"service"
|
|
],
|
|
"intent": [
|
|
"abstraction",
|
|
"safety",
|
|
"isolation"
|
|
],
|
|
"data_type": [
|
|
"orders",
|
|
"positions",
|
|
"pnl",
|
|
"exchanges"
|
|
],
|
|
"risk": [
|
|
"capital_loss",
|
|
"latency",
|
|
"data_corruption"
|
|
],
|
|
"maturity": [
|
|
"production"
|
|
]
|
|
}
|
|
},
|
|
{
|
|
"chunk_id": "artifacts\\execution\\trader.yaml::method::fpnl() -> None",
|
|
"content": "[./trader.py] Method fpnl() -> None: Returns a list of floating profit and loss summaries",
|
|
"chunk_type": "method",
|
|
"artifact_file": "artifacts\\execution\\trader.yaml",
|
|
"source_file": "./trader.py",
|
|
"tags": {
|
|
"domain": [
|
|
"order_execution",
|
|
"exchange_integration",
|
|
"pnl_accounting"
|
|
],
|
|
"trading_function": [
|
|
"entry_logic",
|
|
"exit_logic"
|
|
],
|
|
"strategy_layer": [
|
|
"execution"
|
|
],
|
|
"system_layer": [
|
|
"service"
|
|
],
|
|
"intent": [
|
|
"abstraction",
|
|
"safety",
|
|
"isolation"
|
|
],
|
|
"data_type": [
|
|
"orders",
|
|
"positions",
|
|
"pnl",
|
|
"exchanges"
|
|
],
|
|
"risk": [
|
|
"capital_loss",
|
|
"latency",
|
|
"data_corruption"
|
|
],
|
|
"maturity": [
|
|
"production"
|
|
]
|
|
}
|
|
},
|
|
{
|
|
"chunk_id": "artifacts\\execution\\trader.yaml::method::posCounts() -> dict",
|
|
"content": "[./trader.py] Method posCounts() -> dict: Returns a python dictionary of the total positions we have on each exchange.",
|
|
"chunk_type": "method",
|
|
"artifact_file": "artifacts\\execution\\trader.yaml",
|
|
"source_file": "./trader.py",
|
|
"tags": {
|
|
"domain": [
|
|
"order_execution",
|
|
"exchange_integration",
|
|
"pnl_accounting"
|
|
],
|
|
"trading_function": [
|
|
"entry_logic",
|
|
"exit_logic"
|
|
],
|
|
"strategy_layer": [
|
|
"execution"
|
|
],
|
|
"system_layer": [
|
|
"service"
|
|
],
|
|
"intent": [
|
|
"abstraction",
|
|
"safety",
|
|
"isolation"
|
|
],
|
|
"data_type": [
|
|
"orders",
|
|
"positions",
|
|
"pnl",
|
|
"exchanges"
|
|
],
|
|
"risk": [
|
|
"capital_loss",
|
|
"latency",
|
|
"data_corruption"
|
|
],
|
|
"maturity": [
|
|
"production"
|
|
]
|
|
}
|
|
},
|
|
{
|
|
"chunk_id": "artifacts\\execution\\trader.yaml::method::logFee(fee: float) -> None",
|
|
"content": "[./trader.py] Method logFee(fee: float) -> None: Updates our fees in our database",
|
|
"chunk_type": "method",
|
|
"artifact_file": "artifacts\\execution\\trader.yaml",
|
|
"source_file": "./trader.py",
|
|
"tags": {
|
|
"domain": [
|
|
"order_execution",
|
|
"exchange_integration",
|
|
"pnl_accounting"
|
|
],
|
|
"trading_function": [
|
|
"entry_logic",
|
|
"exit_logic"
|
|
],
|
|
"strategy_layer": [
|
|
"execution"
|
|
],
|
|
"system_layer": [
|
|
"service"
|
|
],
|
|
"intent": [
|
|
"abstraction",
|
|
"safety",
|
|
"isolation"
|
|
],
|
|
"data_type": [
|
|
"orders",
|
|
"positions",
|
|
"pnl",
|
|
"exchanges"
|
|
],
|
|
"risk": [
|
|
"capital_loss",
|
|
"latency",
|
|
"data_corruption"
|
|
],
|
|
"maturity": [
|
|
"production"
|
|
]
|
|
}
|
|
},
|
|
{
|
|
"chunk_id": "artifacts\\execution\\trader.yaml::method::posValueAtExchOld(exch: str, sym: str) -> int",
|
|
"content": "[./trader.py] Method posValueAtExchOld(exch: str, sym: str) -> int: Calculates the values of the long and short positions.",
|
|
"chunk_type": "method",
|
|
"artifact_file": "artifacts\\execution\\trader.yaml",
|
|
"source_file": "./trader.py",
|
|
"tags": {
|
|
"domain": [
|
|
"order_execution",
|
|
"exchange_integration",
|
|
"pnl_accounting"
|
|
],
|
|
"trading_function": [
|
|
"entry_logic",
|
|
"exit_logic"
|
|
],
|
|
"strategy_layer": [
|
|
"execution"
|
|
],
|
|
"system_layer": [
|
|
"service"
|
|
],
|
|
"intent": [
|
|
"abstraction",
|
|
"safety",
|
|
"isolation"
|
|
],
|
|
"data_type": [
|
|
"orders",
|
|
"positions",
|
|
"pnl",
|
|
"exchanges"
|
|
],
|
|
"risk": [
|
|
"capital_loss",
|
|
"latency",
|
|
"data_corruption"
|
|
],
|
|
"maturity": [
|
|
"production"
|
|
]
|
|
}
|
|
},
|
|
{
|
|
"chunk_id": "artifacts\\execution\\trader.yaml::method::fpnlnotional() -> int",
|
|
"content": "[./trader.py] Method fpnlnotional() -> int: This method calculates the profit/loss (P&L) based on the notional value of long and short positions for each unique symbol across different exchanges. It computes the average price of long positions, sums the notional values of both long and short positions, and then uses these to compute the P&L.",
|
|
"chunk_type": "method",
|
|
"artifact_file": "artifacts\\execution\\trader.yaml",
|
|
"source_file": "./trader.py",
|
|
"tags": {
|
|
"domain": [
|
|
"order_execution",
|
|
"exchange_integration",
|
|
"pnl_accounting"
|
|
],
|
|
"trading_function": [
|
|
"entry_logic",
|
|
"exit_logic"
|
|
],
|
|
"strategy_layer": [
|
|
"execution"
|
|
],
|
|
"system_layer": [
|
|
"service"
|
|
],
|
|
"intent": [
|
|
"abstraction",
|
|
"safety",
|
|
"isolation"
|
|
],
|
|
"data_type": [
|
|
"orders",
|
|
"positions",
|
|
"pnl",
|
|
"exchanges"
|
|
],
|
|
"risk": [
|
|
"capital_loss",
|
|
"latency",
|
|
"data_corruption"
|
|
],
|
|
"maturity": [
|
|
"production"
|
|
]
|
|
}
|
|
},
|
|
{
|
|
"chunk_id": "artifacts\\execution\\trader.yaml::method::fillLong(exch: str, sym: str, price: float, quan: float, ts: int, tag: str, feeType: str) -> None",
|
|
"content": "[./trader.py] Method fillLong(exch: str, sym: str, price: float, quan: float, ts: int, tag: str, feeType: str) -> None: The fillLong method handles the process of filling a buy order for a specified asset on an exchange. It updates the trader's position with the new quantity and calculates the average price if necessary. If there was a short position, it also calculates the profit/loss from buying back some or all of the shorted amount. Additionally, it logs the trade, applies fees, and ensures data integrity by asserting non-negative values.",
|
|
"chunk_type": "method",
|
|
"artifact_file": "artifacts\\execution\\trader.yaml",
|
|
"source_file": "./trader.py",
|
|
"tags": {
|
|
"domain": [
|
|
"order_execution",
|
|
"exchange_integration",
|
|
"pnl_accounting"
|
|
],
|
|
"trading_function": [
|
|
"entry_logic",
|
|
"exit_logic"
|
|
],
|
|
"strategy_layer": [
|
|
"execution"
|
|
],
|
|
"system_layer": [
|
|
"service"
|
|
],
|
|
"intent": [
|
|
"abstraction",
|
|
"safety",
|
|
"isolation"
|
|
],
|
|
"data_type": [
|
|
"orders",
|
|
"positions",
|
|
"pnl",
|
|
"exchanges"
|
|
],
|
|
"risk": [
|
|
"capital_loss",
|
|
"latency",
|
|
"data_corruption"
|
|
],
|
|
"maturity": [
|
|
"production"
|
|
]
|
|
}
|
|
},
|
|
{
|
|
"chunk_id": "artifacts\\execution\\trader.yaml::method::fillShort(exch: str, sym: str, price: float, quan: float, ts: int, tag: str, feeType: str) -> None",
|
|
"content": "[./trader.py] Method fillShort(exch: str, sym: str, price: float, quan: float, ts: int, tag: str, feeType: str) -> None: The fillShort method handles the process of filling a sell order for a specified asset on an exchange. It updates the trader's position with the new quantity and calculates the average price if necessary. If there was a long position, it also calculates the profit/loss from selling some or all of the held amount. Additionally, it logs the trade, applies fees, and ensures data integrity by asserting non-negative values.",
|
|
"chunk_type": "method",
|
|
"artifact_file": "artifacts\\execution\\trader.yaml",
|
|
"source_file": "./trader.py",
|
|
"tags": {
|
|
"domain": [
|
|
"order_execution",
|
|
"exchange_integration",
|
|
"pnl_accounting"
|
|
],
|
|
"trading_function": [
|
|
"entry_logic",
|
|
"exit_logic"
|
|
],
|
|
"strategy_layer": [
|
|
"execution"
|
|
],
|
|
"system_layer": [
|
|
"service"
|
|
],
|
|
"intent": [
|
|
"abstraction",
|
|
"safety",
|
|
"isolation"
|
|
],
|
|
"data_type": [
|
|
"orders",
|
|
"positions",
|
|
"pnl",
|
|
"exchanges"
|
|
],
|
|
"risk": [
|
|
"capital_loss",
|
|
"latency",
|
|
"data_corruption"
|
|
],
|
|
"maturity": [
|
|
"production"
|
|
]
|
|
}
|
|
},
|
|
{
|
|
"chunk_id": "artifacts\\execution\\trader.yaml::method::hedgeLong(exch: str, sym: str, price: float, quan: float, ts: int, force: bool) -> Exchange",
|
|
"content": "[./trader.py] Method hedgeLong(exch: str, sym: str, price: float, quan: float, ts: int, force: bool) -> Exchange: The hedgeLong method finds an appropriate exchange to hedge a long position by executing a corresponding sell order. It iterates over possible exchanges, calculates adjusted bid prices based on offsets, and selects the highest bid price for execution. If no suitable exchange is found without forcing, it forces hedging. The method ensures that the hedge does not exceed maximum allowed positions and logs relevant information throughout the process.",
|
|
"chunk_type": "method",
|
|
"artifact_file": "artifacts\\execution\\trader.yaml",
|
|
"source_file": "./trader.py",
|
|
"tags": {
|
|
"domain": [
|
|
"order_execution",
|
|
"exchange_integration",
|
|
"pnl_accounting"
|
|
],
|
|
"trading_function": [
|
|
"entry_logic",
|
|
"exit_logic"
|
|
],
|
|
"strategy_layer": [
|
|
"execution"
|
|
],
|
|
"system_layer": [
|
|
"service"
|
|
],
|
|
"intent": [
|
|
"abstraction",
|
|
"safety",
|
|
"isolation"
|
|
],
|
|
"data_type": [
|
|
"orders",
|
|
"positions",
|
|
"pnl",
|
|
"exchanges"
|
|
],
|
|
"risk": [
|
|
"capital_loss",
|
|
"latency",
|
|
"data_corruption"
|
|
],
|
|
"maturity": [
|
|
"production"
|
|
]
|
|
}
|
|
},
|
|
{
|
|
"chunk_id": "artifacts\\execution\\trader.yaml::method::hedgeShort(exch: str, sym: str, price: float, quan: float, ts: int, force: bool) -> Exchange",
|
|
"content": "[./trader.py] Method hedgeShort(exch: str, sym: str, price: float, quan: float, ts: int, force: bool) -> Exchange: The hedgeShort method finds an appropriate exchange to hedge a short position by executing a corresponding buy order. It iterates over possible exchanges, calculates adjusted ask prices based on offsets, and selects the lowest ask price for execution. If no suitable exchange is found without forcing, it forces hedging. The method ensures that the hedge does not exceed maximum allowed positions and logs relevant information throughout the process.",
|
|
"chunk_type": "method",
|
|
"artifact_file": "artifacts\\execution\\trader.yaml",
|
|
"source_file": "./trader.py",
|
|
"tags": {
|
|
"domain": [
|
|
"order_execution",
|
|
"exchange_integration",
|
|
"pnl_accounting"
|
|
],
|
|
"trading_function": [
|
|
"entry_logic",
|
|
"exit_logic"
|
|
],
|
|
"strategy_layer": [
|
|
"execution"
|
|
],
|
|
"system_layer": [
|
|
"service"
|
|
],
|
|
"intent": [
|
|
"abstraction",
|
|
"safety",
|
|
"isolation"
|
|
],
|
|
"data_type": [
|
|
"orders",
|
|
"positions",
|
|
"pnl",
|
|
"exchanges"
|
|
],
|
|
"risk": [
|
|
"capital_loss",
|
|
"latency",
|
|
"data_corruption"
|
|
],
|
|
"maturity": [
|
|
"production"
|
|
]
|
|
}
|
|
},
|
|
{
|
|
"chunk_id": "artifacts\\execution\\trader.yaml::method::processTrade(exch: str, sym: str, price: float, tradeDir: list) -> None",
|
|
"content": "[./trader.py] Method processTrade(exch: str, sym: str, price: float, tradeDir: list) -> None: The first half of the processTrade method handles the scenario where a market sell order results in hitting a limit buy order. It processes the fill, hedges the position, and logs various portfolio and holdings-related details. The second half of the processTrade method handles the scenario where a market buy order results in hitting a limit sell order. It processes the fill, hedges the position, and logs various portfolio and holdings-related details.",
|
|
"chunk_type": "method",
|
|
"artifact_file": "artifacts\\execution\\trader.yaml",
|
|
"source_file": "./trader.py",
|
|
"tags": {
|
|
"domain": [
|
|
"order_execution",
|
|
"exchange_integration",
|
|
"pnl_accounting"
|
|
],
|
|
"trading_function": [
|
|
"entry_logic",
|
|
"exit_logic"
|
|
],
|
|
"strategy_layer": [
|
|
"execution"
|
|
],
|
|
"system_layer": [
|
|
"service"
|
|
],
|
|
"intent": [
|
|
"abstraction",
|
|
"safety",
|
|
"isolation"
|
|
],
|
|
"data_type": [
|
|
"orders",
|
|
"positions",
|
|
"pnl",
|
|
"exchanges"
|
|
],
|
|
"risk": [
|
|
"capital_loss",
|
|
"latency",
|
|
"data_corruption"
|
|
],
|
|
"maturity": [
|
|
"production"
|
|
]
|
|
}
|
|
},
|
|
{
|
|
"chunk_id": "artifacts\\execution\\trader.yaml::invariants",
|
|
"content": "[./trader.py] Invariants: - Trades must only be executed when trading is explicitly enabled. - Exchange-specific state must be initialized before order execution. - Position and profit tracking must remain consistent with executed trades. - Execution behavior must respect live versus backtest operating modes.",
|
|
"chunk_type": "invariants",
|
|
"artifact_file": "artifacts\\execution\\trader.yaml",
|
|
"source_file": "./trader.py",
|
|
"tags": {
|
|
"domain": [
|
|
"order_execution",
|
|
"exchange_integration",
|
|
"pnl_accounting"
|
|
],
|
|
"trading_function": [
|
|
"entry_logic",
|
|
"exit_logic"
|
|
],
|
|
"strategy_layer": [
|
|
"execution"
|
|
],
|
|
"system_layer": [
|
|
"service"
|
|
],
|
|
"intent": [
|
|
"abstraction",
|
|
"safety",
|
|
"isolation"
|
|
],
|
|
"data_type": [
|
|
"orders",
|
|
"positions",
|
|
"pnl",
|
|
"exchanges"
|
|
],
|
|
"risk": [
|
|
"capital_loss",
|
|
"latency",
|
|
"data_corruption"
|
|
],
|
|
"maturity": [
|
|
"production"
|
|
]
|
|
}
|
|
},
|
|
{
|
|
"chunk_id": "artifacts\\strategies\\strat.yaml::factual_summary",
|
|
"content": "[./strat.py] Factual summary: Implements a market making strategy module responsible for maintaining top-of-book state, calculating bid and ask prices using threshold-based logic, validating tradable assets, and coordinating trade logging. Manages exchange instances, symbol discovery across exchanges, and runtime strategy state used for order placement and monitoring.",
|
|
"chunk_type": "factual_summary",
|
|
"artifact_file": "artifacts\\strategies\\strat.yaml",
|
|
"source_file": "./strat.py",
|
|
"tags": {
|
|
"domain": [
|
|
"market_data",
|
|
"strategy_execution",
|
|
"order_execution",
|
|
"exchange_integration"
|
|
],
|
|
"trading_function": [
|
|
"position_sizing",
|
|
"entry_logic",
|
|
"exit_logic"
|
|
],
|
|
"strategy_layer": [
|
|
"execution",
|
|
"decision"
|
|
],
|
|
"system_layer": [
|
|
"engine"
|
|
],
|
|
"intent": [
|
|
"orchestration",
|
|
"validation",
|
|
"safety"
|
|
],
|
|
"data_type": [
|
|
"signals",
|
|
"orders",
|
|
"positions",
|
|
"exchanges"
|
|
],
|
|
"risk": [
|
|
"capital_loss",
|
|
"latency",
|
|
"data_corruption"
|
|
],
|
|
"maturity": [
|
|
"production"
|
|
]
|
|
}
|
|
},
|
|
{
|
|
"chunk_id": "artifacts\\strategies\\strat.yaml::interpretive_summary",
|
|
"content": "[./strat.py] Interpretive summary: Serves as the central coordination unit for the market making strategy, maintaining shared runtime state across exchanges and assets while enforcing eligibility rules and operational constraints. Designed to balance responsiveness with safety through internal validation, rate limiting counters, and symbol qualification logic.",
|
|
"chunk_type": "interpretive_summary",
|
|
"artifact_file": "artifacts\\strategies\\strat.yaml",
|
|
"source_file": "./strat.py",
|
|
"tags": {
|
|
"domain": [
|
|
"market_data",
|
|
"strategy_execution",
|
|
"order_execution",
|
|
"exchange_integration"
|
|
],
|
|
"trading_function": [
|
|
"position_sizing",
|
|
"entry_logic",
|
|
"exit_logic"
|
|
],
|
|
"strategy_layer": [
|
|
"execution",
|
|
"decision"
|
|
],
|
|
"system_layer": [
|
|
"engine"
|
|
],
|
|
"intent": [
|
|
"orchestration",
|
|
"validation",
|
|
"safety"
|
|
],
|
|
"data_type": [
|
|
"signals",
|
|
"orders",
|
|
"positions",
|
|
"exchanges"
|
|
],
|
|
"risk": [
|
|
"capital_loss",
|
|
"latency",
|
|
"data_corruption"
|
|
],
|
|
"maturity": [
|
|
"production"
|
|
]
|
|
}
|
|
},
|
|
{
|
|
"chunk_id": "artifacts\\strategies\\strat.yaml::method::registerExchange(exch: str, exchInst: Exchange) -> None",
|
|
"content": "[./strat.py] Method registerExchange(exch: str, exchInst: Exchange) -> None: Registers an exchange instance under a named key for use by the strategy during execution.",
|
|
"chunk_type": "method",
|
|
"artifact_file": "artifacts\\strategies\\strat.yaml",
|
|
"source_file": "./strat.py",
|
|
"tags": {
|
|
"domain": [
|
|
"market_data",
|
|
"strategy_execution",
|
|
"order_execution",
|
|
"exchange_integration"
|
|
],
|
|
"trading_function": [
|
|
"position_sizing",
|
|
"entry_logic",
|
|
"exit_logic"
|
|
],
|
|
"strategy_layer": [
|
|
"execution",
|
|
"decision"
|
|
],
|
|
"system_layer": [
|
|
"engine"
|
|
],
|
|
"intent": [
|
|
"orchestration",
|
|
"validation",
|
|
"safety"
|
|
],
|
|
"data_type": [
|
|
"signals",
|
|
"orders",
|
|
"positions",
|
|
"exchanges"
|
|
],
|
|
"risk": [
|
|
"capital_loss",
|
|
"latency",
|
|
"data_corruption"
|
|
],
|
|
"maturity": [
|
|
"production"
|
|
]
|
|
}
|
|
},
|
|
{
|
|
"chunk_id": "artifacts\\strategies\\strat.yaml::method::setMinQty(exch: str, qtyMap: dict) -> None",
|
|
"content": "[./strat.py] Method setMinQty(exch: str, qtyMap: dict) -> None: Updates minimum and maximum trade quantity constraints for a given exchange using a provided quantity mapping.",
|
|
"chunk_type": "method",
|
|
"artifact_file": "artifacts\\strategies\\strat.yaml",
|
|
"source_file": "./strat.py",
|
|
"tags": {
|
|
"domain": [
|
|
"market_data",
|
|
"strategy_execution",
|
|
"order_execution",
|
|
"exchange_integration"
|
|
],
|
|
"trading_function": [
|
|
"position_sizing",
|
|
"entry_logic",
|
|
"exit_logic"
|
|
],
|
|
"strategy_layer": [
|
|
"execution",
|
|
"decision"
|
|
],
|
|
"system_layer": [
|
|
"engine"
|
|
],
|
|
"intent": [
|
|
"orchestration",
|
|
"validation",
|
|
"safety"
|
|
],
|
|
"data_type": [
|
|
"signals",
|
|
"orders",
|
|
"positions",
|
|
"exchanges"
|
|
],
|
|
"risk": [
|
|
"capital_loss",
|
|
"latency",
|
|
"data_corruption"
|
|
],
|
|
"maturity": [
|
|
"production"
|
|
]
|
|
}
|
|
},
|
|
{
|
|
"chunk_id": "artifacts\\strategies\\strat.yaml::method::printFloating(ts: float) -> None",
|
|
"content": "[./strat.py] Method printFloating(ts: float) -> None: Emits a formatted runtime summary of strategy activity for logging and monitoring purposes.",
|
|
"chunk_type": "method",
|
|
"artifact_file": "artifacts\\strategies\\strat.yaml",
|
|
"source_file": "./strat.py",
|
|
"tags": {
|
|
"domain": [
|
|
"market_data",
|
|
"strategy_execution",
|
|
"order_execution",
|
|
"exchange_integration"
|
|
],
|
|
"trading_function": [
|
|
"position_sizing",
|
|
"entry_logic",
|
|
"exit_logic"
|
|
],
|
|
"strategy_layer": [
|
|
"execution",
|
|
"decision"
|
|
],
|
|
"system_layer": [
|
|
"engine"
|
|
],
|
|
"intent": [
|
|
"orchestration",
|
|
"validation",
|
|
"safety"
|
|
],
|
|
"data_type": [
|
|
"signals",
|
|
"orders",
|
|
"positions",
|
|
"exchanges"
|
|
],
|
|
"risk": [
|
|
"capital_loss",
|
|
"latency",
|
|
"data_corruption"
|
|
],
|
|
"maturity": [
|
|
"production"
|
|
]
|
|
}
|
|
},
|
|
{
|
|
"chunk_id": "artifacts\\strategies\\strat.yaml::method::bestEdgeBid(exch: str, sym: str) -> List[bool, float, bool, str, float]",
|
|
"content": "[./strat.py] Method bestEdgeBid(exch: str, sym: str) -> List[bool, float, bool, str, float]: This method is designed to determine whether and where a bid should be placed based on several factors related to market conditions and strategy rules. Its primary goal of is to calculate the optimal bid price for a given symbol on a specific exchange, taking into account market positions, hedging strategies, trading limits, price precision, and fee structures. Returns a collection of decision outputs including bid eligibility status, relative pricing divergence, long-position participation, selected hedge exchange, and the computed bid price.",
|
|
"chunk_type": "method",
|
|
"artifact_file": "artifacts\\strategies\\strat.yaml",
|
|
"source_file": "./strat.py",
|
|
"tags": {
|
|
"domain": [
|
|
"market_data",
|
|
"strategy_execution",
|
|
"order_execution",
|
|
"exchange_integration"
|
|
],
|
|
"trading_function": [
|
|
"position_sizing",
|
|
"entry_logic",
|
|
"exit_logic"
|
|
],
|
|
"strategy_layer": [
|
|
"execution",
|
|
"decision"
|
|
],
|
|
"system_layer": [
|
|
"engine"
|
|
],
|
|
"intent": [
|
|
"orchestration",
|
|
"validation",
|
|
"safety"
|
|
],
|
|
"data_type": [
|
|
"signals",
|
|
"orders",
|
|
"positions",
|
|
"exchanges"
|
|
],
|
|
"risk": [
|
|
"capital_loss",
|
|
"latency",
|
|
"data_corruption"
|
|
],
|
|
"maturity": [
|
|
"production"
|
|
]
|
|
}
|
|
},
|
|
{
|
|
"chunk_id": "artifacts\\strategies\\strat.yaml::method::bestEdgeOffer(exch: str, sym: str) -> list",
|
|
"content": "[./strat.py] Method bestEdgeOffer(exch: str, sym: str) -> list: The primary goal of bestEdgeOffer is to calculate the optimal offer (ask) price for a given symbol on a specific exchange, considering market positions, hedging strategies, trading limits, price precision, fee structures. Returns almost identical items as bestEdgeBid, but on the other side of the order book",
|
|
"chunk_type": "method",
|
|
"artifact_file": "artifacts\\strategies\\strat.yaml",
|
|
"source_file": "./strat.py",
|
|
"tags": {
|
|
"domain": [
|
|
"market_data",
|
|
"strategy_execution",
|
|
"order_execution",
|
|
"exchange_integration"
|
|
],
|
|
"trading_function": [
|
|
"position_sizing",
|
|
"entry_logic",
|
|
"exit_logic"
|
|
],
|
|
"strategy_layer": [
|
|
"execution",
|
|
"decision"
|
|
],
|
|
"system_layer": [
|
|
"engine"
|
|
],
|
|
"intent": [
|
|
"orchestration",
|
|
"validation",
|
|
"safety"
|
|
],
|
|
"data_type": [
|
|
"signals",
|
|
"orders",
|
|
"positions",
|
|
"exchanges"
|
|
],
|
|
"risk": [
|
|
"capital_loss",
|
|
"latency",
|
|
"data_corruption"
|
|
],
|
|
"maturity": [
|
|
"production"
|
|
]
|
|
}
|
|
},
|
|
{
|
|
"chunk_id": "artifacts\\strategies\\strat.yaml::method::updateTob(exch: str, sym: str, tob: dict, ts: float, force: bool) -> None",
|
|
"content": "[./strat.py] Method updateTob(exch: str, sym: str, tob: dict, ts: float, force: bool) -> None: The primary goal of the updateTob function is to update the top of the order book for quick access to perform market making operations (bidding and selling) using the highest bid and lowest ask prices.",
|
|
"chunk_type": "method",
|
|
"artifact_file": "artifacts\\strategies\\strat.yaml",
|
|
"source_file": "./strat.py",
|
|
"tags": {
|
|
"domain": [
|
|
"market_data",
|
|
"strategy_execution",
|
|
"order_execution",
|
|
"exchange_integration"
|
|
],
|
|
"trading_function": [
|
|
"position_sizing",
|
|
"entry_logic",
|
|
"exit_logic"
|
|
],
|
|
"strategy_layer": [
|
|
"execution",
|
|
"decision"
|
|
],
|
|
"system_layer": [
|
|
"engine"
|
|
],
|
|
"intent": [
|
|
"orchestration",
|
|
"validation",
|
|
"safety"
|
|
],
|
|
"data_type": [
|
|
"signals",
|
|
"orders",
|
|
"positions",
|
|
"exchanges"
|
|
],
|
|
"risk": [
|
|
"capital_loss",
|
|
"latency",
|
|
"data_corruption"
|
|
],
|
|
"maturity": [
|
|
"production"
|
|
]
|
|
}
|
|
},
|
|
{
|
|
"chunk_id": "artifacts\\strategies\\strat.yaml::invariants",
|
|
"content": "[./strat.py] Invariants: - Only assets validated by runtime eligibility checks may be traded. - Exchange instances must be registered before strategy execution. - Top-of-book data must exist before bid or ask calculations occur. - Rate limiting counters must accurately reflect order activity.",
|
|
"chunk_type": "invariants",
|
|
"artifact_file": "artifacts\\strategies\\strat.yaml",
|
|
"source_file": "./strat.py",
|
|
"tags": {
|
|
"domain": [
|
|
"market_data",
|
|
"strategy_execution",
|
|
"order_execution",
|
|
"exchange_integration"
|
|
],
|
|
"trading_function": [
|
|
"position_sizing",
|
|
"entry_logic",
|
|
"exit_logic"
|
|
],
|
|
"strategy_layer": [
|
|
"execution",
|
|
"decision"
|
|
],
|
|
"system_layer": [
|
|
"engine"
|
|
],
|
|
"intent": [
|
|
"orchestration",
|
|
"validation",
|
|
"safety"
|
|
],
|
|
"data_type": [
|
|
"signals",
|
|
"orders",
|
|
"positions",
|
|
"exchanges"
|
|
],
|
|
"risk": [
|
|
"capital_loss",
|
|
"latency",
|
|
"data_corruption"
|
|
],
|
|
"maturity": [
|
|
"production"
|
|
]
|
|
}
|
|
}
|
|
]
|
|
} |