sysstra 0.1.2__tar.gz → 0.1.2.0__tar.gz

{sysstra-0.1.2 → sysstra-0.1.2.0}/PKG-INFO

@@ -1,16 +1,21 @@
 Metadata-Version: 2.1
 Name: sysstra
-Version: 0.1.2
+Version: 0.1.2.0
 Summary: Official Python Library for Sysstra Algo Trading
 Home-page: https://github.com/sysstra/sysstra
 Author: Anurag Singh Kushwah
-Author-email: anurag786kushwah@gmail.com
+Author-email: anurag@techrefic.com
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.6
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: requests
+Requires-Dist: numpy
+Requires-Dist: pandas_ta
+Requires-Dist: redis
+Requires-Dist: pandas
 
 ## Hi there 👋
 

{sysstra-0.1.2 → sysstra-0.1.2.0}/setup.py

@@ -1,25 +1,27 @@
 from setuptools import setup, find_packages
 
 setup(
-    name="sysstra",  # Your package name (must be unique on PyPI)
-    version="0.1.2",  # Initial release version
+    name="sysstra",
+    version="0.1.2.0",
     description="Official Python Library for Sysstra Algo Trading",
     long_description=open("README.md").read(),
     long_description_content_type="text/markdown",
     author="Anurag Singh Kushwah",
-    author_email="anurag786kushwah@gmail.com",
-    url="https://github.com/sysstra/sysstra",  # Link to source code
-    packages=find_packages(),  # Automatically find sub-packages
+    author_email="anurag@techrefic.com",
+    url="https://github.com/sysstra/sysstra",
+    packages=find_packages(),
+    include_package_data=True,
     install_requires=[  # Dependencies
         "requests",
         "numpy",
         "pandas_ta",
         "redis",
+        "pandas"
     ],
     classifiers=[  # Additional metadata (check PyPI classifiers)
         "Programming Language :: Python :: 3",
         "License :: OSI Approved :: MIT License",
         "Operating System :: OS Independent",
     ],
-    python_requires=">=3.6",  # Minimum Python version
+    python_requires=">=3.9",
 )

sysstra-0.1.2.0/sysstra/__init__.py

@@ -0,0 +1,23 @@
+api_key: str | None = None
+# data_url: str | None = None
+orders_url: str | None = None
+
+data_url = "https://api.data.sysstra.com/"
+
+
+def set_api_key(key):
+    """ Function to set api key """
+    global api_key
+    api_key = key
+
+
+def set_data_url(url):
+    """ Function to set data url """
+    global data_url
+    data_url = url
+
+
+def set_orders_url(url):
+    """ Function to set Orders URL """
+    global orders_url
+    orders_url = url

{sysstra-0.1.2/src → sysstra-0.1.2.0/sysstra}/custom_indicators.py

@@ -459,7 +459,7 @@ def jurik_moving_average(dataframe, length=20, phase=50, power=2, source='close'
     try:
         df = dataframe.copy()
         # Initialize necessary columns and constants
-        df['src'] = df[source]  # By default, using 'close' as the source
+        df['sysstra'] = df[source]  # By default, using 'close' as the source
         phase_ratio = np.where(phase < -100, 0.5, np.where(phase > 100, 2.5, phase / 100 + 1.5))
 
         beta = 0.45 * (length - 1) / (0.45 * (length - 1) + 2)
@@ -473,8 +473,8 @@ def jurik_moving_average(dataframe, length=20, phase=50, power=2, source='close'
 
         # Calculate JMA
         for i in range(1, len(df)):
-            df.at[i, 'e0'] = (1 - alpha) * df.at[i, 'src'] + alpha * df.at[i - 1, 'e0']
-            df.at[i, 'e1'] = (df.at[i, 'src'] - df.at[i, 'e0']) * (1 - beta) + beta * df.at[i - 1, 'e1']
+            df.at[i, 'e0'] = (1 - alpha) * df.at[i, 'sysstra'] + alpha * df.at[i - 1, 'e0']
+            df.at[i, 'e1'] = (df.at[i, 'sysstra'] - df.at[i, 'e0']) * (1 - beta) + beta * df.at[i - 1, 'e1']
             df.at[i, 'e2'] = (df.at[i, 'e0'] + phase_ratio * df.at[i, 'e1'] - df.at[i - 1, 'jma']) * (1 - alpha) ** 2 + (alpha ** 2) * df.at[i - 1, 'e2']
             df.at[i, 'jma'] = df.at[i, 'e2'] + df.at[i - 1, 'jma']
 

{sysstra-0.1.2/src → sysstra-0.1.2.0/sysstra}/data/historical.py

@@ -1,5 +1,6 @@
+import json
 import requests
-from src.data import api_key, data_url
+from sysstra import api_key, data_url
 
 
 def fetch_eod_candles(exchange, symbol, start_date, end_date):
@@ -9,7 +10,7 @@ def fetch_eod_candles(exchange, symbol, start_date, end_date):
         request_data = {"exchange": exchange, "symbol": symbol, "from_date": start_date, "to_date": end_date}
         request_url = f"{data_url}/fetch-eod-data"
         eod_data = requests.post(url=request_url, headers=headers, json=request_data)
-        return eod_data
+        return eod_data.json()
     except Exception as e:
         print(f"Exception in fetching eod candles : {e}")
         return []
@@ -23,7 +24,7 @@ def fetch_index_candles(exchange, symbol, start_date, end_date, granularity=1):
                         "granularity": granularity}
         request_url = f"{data_url}/fetch-index-data"
         candles_data = requests.post(url=request_url, headers=headers, json=request_data)
-        return candles_data
+        return candles_data.json()
     except Exception as e:
         print(f"Exception in fetching date candles : {e}")
         return []
@@ -38,7 +39,7 @@ def fetch_option_candles(exchange, underlying_symbol, start_date, end_date, opti
                         "expiry": expiry, "granularity": granularity}
         request_url = f"{data_url}/fetch-options-data"
         candles_data = requests.post(url=request_url, headers=headers, json=request_data)
-        return candles_data
+        return candles_data.json()
     except Exception as e:
         print(f"Exception in fetching options candle : {e}")
         return []
@@ -51,35 +52,60 @@ def fetch_option_candles_by_symbol(exchange, symbol, start_date, end_date, granu
         request_data = {"exchange": exchange, "symbol": symbol, "from_date": start_date, "to_date": end_date, "granularity": granularity}
         request_url = f"{data_url}/fetch-options-data-by-symbol"
         candles_data = requests.post(url=request_url, headers=headers, json=request_data)
-        return candles_data
+        return candles_data.json()
 
     except Exception as e:
         print(f"Exception in fetching options candle : {e}")
         return []
 
 
-def fetch_option_candle_by_timestamp(exchange, underlying_symbol, strike_price, option_type, timestamp, expiry="near"):
+def fetch_option_candle_by_timestamp(exchange, underlying_symbol, strike_price, option_type, timestamp, granularity=1, expiry="near"):
     """ Function to Fetch Order Candle based on timestamp """
     try:
         headers = {"x-api-key": api_key, "content-type": "application/json"}
         request_data = {"exchange": exchange, "underlying_symbol": underlying_symbol, "option_type": option_type,
-                        "strike_price": strike_price, "timestamp": timestamp, "expiry": expiry}
+                        "strike_price": strike_price, "timestamp": str(timestamp), "expiry": expiry, "granularity": granularity}
         request_url = f"{data_url}/fetch-option-data-by-timestamp"
         candles_data = requests.post(url=request_url, headers=headers, json=request_data)
-        return candles_data
+        return candles_data.json()
 
     except Exception as e:
         print(f"Exception in fetching order candle : {e}")
         return []
 
 
+def fetch_crypto_candles(exchange, symbol, start_date, end_date, granularity=1):
+    """ Function to fetch candles for the respective date """
+    try:
+        headers = {"x-api-key": api_key, "content-type": "application/json"}
+        request_data = {"exchange": exchange, "symbol": symbol, "from_date": start_date, "to_date": end_date,
+                        "granularity": granularity}
+        request_url = f"{data_url}/fetch-crypto-data"
+        candles_data = requests.post(url=request_url, headers=headers, json=request_data)
+        return candles_data.json()
+    except Exception as e:
+        print(f"Exception in fetching crypto candles : {e}")
+        return []
+
+
+def fetch_forex_candles(exchange, symbol, start_date, end_date, granularity=1):
+    """ Function to fetch candles for the respective date """
+    try:
+        headers = {"x-api-key": api_key, "content-type": "application/json"}
+        request_data = {"exchange": exchange, "symbol": symbol, "from_date": start_date, "to_date": end_date,
+                        "granularity": granularity}
+        request_url = f"{data_url}/fetch-forex-data"
+        candles_data = requests.post(url=request_url, headers=headers, json=request_data)
+        return candles_data.json()
+    except Exception as e:
+        print(f"Exception in fetching forex candles : {e}")
+        return []
+
+
 if __name__ == '__main__':
-    # eod_candles = fetch_eod_candles(exchange="NSE", symbol="NIFTY 50", start_date="01/01/2024", end_date="05/01/2024")
-    # candles = fetch_index_candles(exchange="NSE", symbol="NIFTY 50", start_date="01/01/2024", end_date="05/01/2024")
-    # candles = fetch_option_candles(exchange="NSE", underlying_symbol="SENSEX", start_date="19/12/2024",
-    #                                end_date="19/12/2024", strike_price=80200, option_type="CE", expiry="near")
-    # candles = fetch_option_candles_by_symbol(exchange="NSE", symbol="SENSEX24D2080200CE", start_date="19/12/2024",
-    #                                          end_date="19/12/2024")
+    api_key = "123asdf"
+    data_url = "http://127.0.0.1:5001"
     candle = fetch_option_candle_by_timestamp(exchange="NSE", underlying_symbol="SENSEX",  strike_price=80200, option_type="CE", expiry="near",
                                               timestamp="2024-12-19 14:45:00")
-    print(candle)
+    print(json.loads(candle.content))
+

sysstra-0.1.2.0/sysstra/orders/backtest.py

@@ -0,0 +1,57 @@
+from sysstra.orders.common import fetch_orders_list, add_order_to_redis
+
+
+def save_bt_report(app_db_cursor, report_dict):
+    """Function to Save Backtest Report in Database"""
+    try:
+        app_db_cursor["bt_reports"].insert_one(report_dict)
+        app_db_cursor["bt_request"].update_one({"_id": report_dict["request_id"]}, {"$set": {"status": "done"}})
+    except Exception as e:
+        print(f"Exception in saving BT Report : {e}")
+        pass
+
+
+def place_bt_order(rdb_cursor, order_candle,  position_type, quantity, transaction_type, order_type, orders_list, option_type=None, strike_price=None, exit_type=None, quantity_left=0, params=None, market_type="cash", trade_type=None, trigger_price=None, lot_size=25, user_id=None, strategy_id=None, request_id=None, exchange="NSE", option_params=None):
+    """ Function to place Backtesting Order """
+    try:
+
+        print("************** Placing Backtesting Order **************")
+        order_dict = {"exchange": "NSE", "order_type": order_type, "position_type": position_type, "quantity": quantity,
+                      "transaction_type": transaction_type, "exit_type": exit_type, "quantity_left": quantity_left,
+                      "lot_size": lot_size, "trade_type": trade_type}
+
+        if trigger_price:
+            order_dict["trigger_price"] = trigger_price
+        else:
+            order_dict["trigger_price"] = order_candle["close"]
+
+        order_dict["order_timestamp"] = str(order_candle["timestamp"])
+        order_dict["tradingsymbol"] = order_candle["symbol"]
+        order_dict["date"] = str(order_candle["date"])
+
+        if market_type == "options":
+            order_dict["expiry"] = order_candle["expiry"]
+            order_dict["option_type"] = option_type
+            order_dict["strike_price"] = strike_price
+        else:
+            order_dict["expiry"] = ""
+            order_dict["option_type"] = ""
+            order_dict["strike_price"] = ""
+
+        order_dict["day"] = order_candle["date"].strftime("%A")
+
+        if params:
+            order_dict.update(params)
+
+        if option_params:
+            order_dict.update(option_params)
+
+        print(f"***** bt_order : {order_dict}")
+        orders_list.append(order_dict)
+
+        return orders_list
+
+    except Exception as e:
+        print(f"Exception in placing backtesting order : {e}")
+        pass
+

sysstra-0.1.2.0/sysstra/orders/common.py

@@ -0,0 +1,196 @@
+import json
+import datetime
+from bson import ObjectId
+from sysstra.utils import calculate_brokerage
+
+
+def add_order_to_redis(rdb_cursor, request_id, order_dict, mode):
+    """Function to add order to redis"""
+    try:
+        rdb_cursor.rpush(str(request_id) + "_orders", json.dumps(order_dict, default=str))
+        rdb_cursor.publish(str(request_id) + "_orders", json.dumps(order_dict, default=str))
+        rdb_cursor.publish(str(order_dict["user_id"]) + "_{}".format(mode) + "_orders", json.dumps(order_dict, default=str))
+    except Exception as e:
+        print(f"Exception in adding order in redis : {e}")
+        pass
+
+
+def fetch_orders_list(rdb_cursor, request_id):
+    """ Function to fetch an orders list for request_id """
+    try:
+        orders_list_json = rdb_cursor.lrange(str(request_id)+"_orders", 0, -1)
+        orders_list = [json.loads(i) for i in orders_list_json]
+        return orders_list
+    except Exception as e:
+        print(f"Exception in fetching orders list : {e}")
+        pass
+
+
+def fetch_last_order(rdb_cursor, request_id):
+    """Function to fetch last order from redis database"""
+    try:
+        last_order = json.loads(rdb_cursor.lindex(str(request_id) + "_orders", -1))
+        return last_order
+    except Exception as e:
+        print(f"Exception in fetching last order : {e}")
+        pass
+
+
+def check_open_orders(orders_list):
+    """ Function to open orders available """
+    try:
+        if orders_list:
+            quantity_dict = {}
+            for order in orders_list:
+                trade_symbol = order["tradingsymbol"]
+                quantity_dict[trade_symbol] = {}
+                quantity_dict[trade_symbol]["buy_quantity"] = 0
+                quantity_dict[trade_symbol]["sell_quantity"] = 0
+                quantity_dict[trade_symbol]["quantity"] = 0
+                quantity_dict[trade_symbol]["option_type"] = ""
+                quantity_dict[trade_symbol]["strike_price"] = ""
+                quantity_dict[trade_symbol]["exit_levels"] = []
+                quantity_dict[trade_symbol]["order_timestamp"] = ""
+                quantity_dict[trade_symbol]["quantity_left"] = 0
+                quantity_dict[trade_symbol]["bnf_price"] = 0
+                quantity_dict[trade_symbol]["expiry"] = ""
+                quantity_dict[trade_symbol]["sl_order_id"] = ""
+                quantity_dict[trade_symbol]["option_order_price"] = 0
+                quantity_dict[trade_symbol]["hka_option_order_price"] = 0
+                quantity_dict[trade_symbol]["trailing_sl"] = 0
+
+            for order in orders_list:
+                trade_symbol = order["tradingsymbol"]
+                if order["trade_type"] == "ENTRY":
+                    quantity_dict[trade_symbol]["buy_quantity"] = order["quantity"]
+                    quantity_dict[trade_symbol]["quantity"] = order["quantity"]
+                    quantity_dict[trade_symbol]["option_type"] = order["option_type"]
+                    quantity_dict[trade_symbol]["strike_price"] = order["strike_price"]
+                    quantity_dict[trade_symbol]["trigger_price"] = order["trigger_price"]
+                    quantity_dict[trade_symbol]["order_timestamp"] = datetime.datetime.strptime(str(order["order_timestamp"]), '%Y-%m-%d %H:%M:%S')
+                    quantity_dict[trade_symbol]["quantity_left"] = order["quantity_left"]
+                    quantity_dict[trade_symbol]["bnf_price"] = order["bnf_price"]
+                    quantity_dict[trade_symbol]["hka_option_order_price"] = order["hka_option_order_price"]
+                    quantity_dict[trade_symbol]["option_order_price"] = order["option_order_price"]
+
+                if "expiry" in order:
+                    quantity_dict[trade_symbol]["expiry"] = order["expiry"]
+
+                if "sl_order_id" in order:
+                    quantity_dict[trade_symbol]["sl_order_id"] = order["sl_order_id"]
+
+                if "trailing_sl" in order:
+                    quantity_dict[trade_symbol]["trailing_sl"] = order["trailing_sl"]
+
+                elif order["trade_type"] == "EXIT":
+                    quantity_dict[trade_symbol]["sell_quantity"] += order["quantity"]
+                    quantity_dict[trade_symbol]["quantity_left"] = order["quantity_left"]
+                    quantity_dict[trade_symbol]["exit_levels"].append(order["exit_type"])
+
+            final_out = {}
+            for entries in quantity_dict:
+                # if quantity_dict[entries]["buy_quantity"] - quantity_dict[entries]["sell_quantity"] > 0:
+                if quantity_dict[entries]["quantity_left"] > 0:
+                    final_out[entries] = quantity_dict[entries]
+            return final_out
+
+        else:
+            return {}
+    except Exception as e:
+        print(f"Exception in checking open orders : {e}")
+        return {}
+
+
+def convert_to_trades(orders_list, market_type, order_exit_levels, mode, broker):
+    """Function to convert Orders to Trades """
+    try:
+        trade_dict = {}
+        trades_array = []
+        for order in orders_list:
+            if order["trade_type"] == "ENTRY":
+                trade_dict["date"] = order["date"]
+                trade_dict["stock"] = order["tradingsymbol"]
+                trade_dict["lot_size"] = order["lot_size"]
+                trade_dict["trade_type"] = order["trade_type"]
+                trade_dict["bnf_price"] = order["bnf_price"]
+                trade_dict["bar_color"] = order["bar_color"]
+                trade_dict["entry_time"] = order["order_timestamp"]
+                trade_dict["entry_price"] = order["trigger_price"]
+                trade_dict["quantity"] = order["quantity"]
+                trade_dict["pnl"] = 0
+                trade_dict["points"] = 0
+                trade_dict["exit_time"] = None
+                trade_dict["exit_price"] = None
+                trade_dict["exit_type"] = ""
+                trade_dict["day"] = order["day"]
+                trade_dict["expiry"] = order["expiry"]
+                trade_dict["brokerage"] = 0
+                trade_dict["net_pnl"] = 0
+
+                if mode == "lt" or mode == "vt":
+                    trade_dict["date"] = datetime.datetime.strptime(str(datetime.datetime.today().date()), '%Y-%m-%d')
+                    trade_dict["user_id"] = ObjectId(order["user_id"])
+                    trade_dict["strategy_id"] = ObjectId(order["strategy_id"])
+                    trade_dict["request_id"] = ObjectId(order["request_id"])
+
+            else:
+                if market_type == "cash":
+                    if order["trade_type"] == "SHORT":
+                        points = trade_dict["entry_price"] - order["trigger_price"]
+                        trade_dict["points"] += round(points)
+                        trade_dict["pnl"] += round(order["quantity"] * points)
+                    else:
+                        points = order["trigger_price"] - trade_dict["entry_price"]
+                        trade_dict["points"] += round(points)
+                        trade_dict["pnl"] += round(order["quantity"] * points)
+                    # trade_dict["pnl"] += round(order["quantity"] * trade_dict["points"])
+                else:
+                    points = order["trigger_price"] - trade_dict["entry_price"]
+                    trade_dict["points"] += round(points)
+                    trade_dict["pnl"] += round(order["quantity"] * trade_dict["points"] * trade_dict["lot_size"])
+
+                if trade_dict["exit_type"]:
+                    trade_dict["exit_type"] += "|" + order["exit_type"]
+                else:
+                    trade_dict["exit_type"] = order["exit_type"]
+
+                if order["exit_type"] in order_exit_levels:
+                    trade_dict["exit_time"] = order["order_timestamp"]
+                    trade_dict["exit_price"] = order["trigger_price"]
+
+                    brokerage, net_pnl = calculate_brokerage(buy_price=trade_dict["entry_price"], sell_price=trade_dict["exit_price"],
+                                                             quantity=order["quantity"] * trade_dict["lot_size"], broker=broker)
+                    trade_dict["brokerage"] += brokerage
+                    trade_dict["net_pnl"] += net_pnl
+
+                    trades_array.append(trade_dict)
+
+                    # Emptying Trade Dict for next trade
+                    trade_dict = {}
+                else:
+                    brokerage, net_pnl = calculate_brokerage(buy_price=trade_dict["entry_price"], sell_price=order["trigger_price"],
+                                                             quantity=order["quantity"] * trade_dict["lot_size"], broker=broker)
+                    trade_dict["brokerage"] += brokerage
+                    trade_dict["net_pnl"] += net_pnl
+        return trades_array
+    except Exception as e:
+        print(f"Exception in converting orders to trades : {e}")
+        pass
+
+
+def check_existing_order(strike_price, option_type, position_type, order_type, orders_list, entry_time=None):
+    """Function to check existing order on defined symbol"""
+    try:
+        for order in orders_list:
+            # if order["tradingsymbol"] == symbol and order["position_type"] == position_type and order["exit_type"] == order_type :
+            if not entry_time:
+                if order["strike_price"] == strike_price and order["option_type"] == option_type and order["position_type"] == position_type and order["exit_type"] == order_type:
+                    return True
+            else:
+                if order["strike_price"] == strike_price and order["option_type"] == option_type and order["position_type"] == position_type and order["exit_type"] == order_type and order["order_timestamp"] > entry_time:
+                    return True
+        return False
+    except Exception as e:
+        print("Exception in checking existing order : {}".format(e))
+        pass
+

sysstra-0.1.2.0/sysstra/orders/live.py

@@ -0,0 +1,186 @@
+import requests
+import datetime
+import json
+from sysstra.orders.common import add_order_to_redis, fetch_orders_list
+from sysstra.utils import send_order_alert
+from sysstra import orders_url
+
+
+def place_lt_order(tradingsymbol, quantity, transaction_type, order_type, lot_size=15, exchange="NSE",
+                   credential_id=None, trigger_price=None, order_price=None):
+    """ Function to Place Live Trading Order """
+    try:
+
+        if order_type == "MARKET":
+            order_data_params = {"tradingsymbol": tradingsymbol,
+                                 "exchange": exchange,
+                                 "transaction_type": transaction_type,
+                                 "quantity": quantity * lot_size,
+                                 "order_type": order_type,
+                                 "product": "MIS",
+                                 "validity": "DAY"}
+
+            order_response = place_live_order(credential_id=credential_id, order_details=order_data_params)
+
+            if order_response["status"] == "COMPLETE":
+                # return "success", order_response["broker_response"][0]["broker_response"]
+                return "success", order_response
+            else:
+                return "failed", None
+
+        elif order_type == "SL":
+            order_data_params = {"tradingsymbol": tradingsymbol, "exchange": exchange,
+                                 "transaction_type": transaction_type,
+                                 "quantity": quantity * lot_size, "product": "MIS", "validity": "DAY",
+                                 "order_type": "SL", "trigger_price": trigger_price, "price": order_price}
+            order_response = place_live_order(credential_id=credential_id, order_details=order_data_params)
+
+            if order_response["status"] == "success":
+                # return "success", order_response["data"]["order_id"]
+                # return "success", order_response["order_id"][0]
+                return "success", order_response["order_id"]
+            else:
+                return "failed", None
+
+        elif order_type == "LIMIT":
+            order_data_params = {"tradingsymbol": tradingsymbol, "exchange": exchange,
+                                 "transaction_type": transaction_type, "quantity": quantity * lot_size,
+                                 "product": "MIS", "validity": "TTL", "validity_ttl": 1,
+                                 "order_type": "LIMIT",  "price": order_price}
+
+            order_response = place_live_order(credential_id=credential_id, order_details=order_data_params)
+
+            if order_response["status"] == "success":
+                # return "success", order_response["data"]["order_id"]
+                # return "success", order_response["order_id"][0]
+                return "success", order_response["order_id"]
+            else:
+                return "failed", None
+
+    except Exception as e:
+        print(f"Exception in placing live trade : {e}")
+        return "failed", None
+
+
+def save_lt_order(app_db_cursor, rdb_cursor, tradingsymbol, option_type, strike_price, position_type, quantity, transaction_type, order_type,
+                  orders_list, exit_type=None, quantity_left=0, params=None, market_type="cash", trade_type=None,
+                  expiry=None, trigger_price=None, lot_size=25, user_id=None, strategy_id=None, request_id=None,
+                  exchange="NSE", exchange_timestamp=None, order_id=None, broker_response=None, sl_order_id=None):
+
+    """Function to save order in Database"""
+    try:
+        order_dict = {"exchange": exchange, "user_id": user_id, "strategy_id": strategy_id,
+                      "request_id": request_id, "tradingsymbol": tradingsymbol, "transaction_type": transaction_type,
+                      "quantity": quantity, "position_type": position_type, "order_type": order_type,
+                      "exit_type": exit_type, "quantity_left": quantity_left, "lot_size": lot_size, "trade_type": trade_type,
+                      "trade_action": trade_type,
+                      "exchange_timestamp": exchange_timestamp, "status": "COMPLETE", "trigger_price": trigger_price, "order_id": order_id}
+
+        if sl_order_id:
+            order_dict["sl_order_id"] = sl_order_id
+
+        if market_type == "cash":
+            order_dict["expiry"] = ""
+            order_dict["option_type"] = ""
+            order_dict["strike_price"] = ""
+        else:
+            order_dict["expiry"] = expiry
+            order_dict["option_type"] = option_type
+            order_dict["strike_price"] = strike_price
+
+        order_dict["order_timestamp"] = exchange_timestamp
+        order_dict["date"] = datetime.datetime.strptime(str(datetime.datetime.today().date()), '%Y-%m-%d')
+        order_dict["day"] = order_dict["date"].strftime("%A")
+
+        if params:
+            order_dict.update(params)
+
+        # Creating New Dict for saving data in to db
+        lt_order_dict = {}
+        for key in order_dict.keys():
+            lt_order_dict[key] = order_dict[key]
+
+        lt_order_dict["order_id"] = order_id
+        lt_order_dict["broker_response"] = broker_response
+        lt_order_dict["trade_action"] = lt_order_dict["trade_type"]
+
+        # Saving Order Details to Database
+        app_db_cursor["lt_orders"].insert_one(lt_order_dict)
+
+        order_dict["strategy_id"] = str(order_dict["strategy_id"])
+        order_dict["request_id"] = str(order_dict["request_id"])
+        order_dict["user_id"] = str(order_dict["user_id"])
+        order_dict["order_timestamp"] = str(order_dict["order_timestamp"])
+        order_dict["exchange_timestamp"] = str(order_dict["exchange_timestamp"])
+        order_dict["expiry"] = str(order_dict["expiry"])
+        order_dict["date"] = str(order_dict["date"])
+        order_dict["order_id"] = order_id
+
+        add_order_to_redis(rdb_cursor=rdb_cursor, request_id=str(request_id), order_dict=order_dict, mode="lt")
+        orders_list = fetch_orders_list(rdb_cursor=rdb_cursor, request_id=str(request_id))
+
+        # Creating Alert Dict
+        alert_dict = {"user_id": str(order_dict["user_id"]),
+                      "strategy_id": str(order_dict["strategy_id"]),
+                      "request_id": str(order_dict["request_id"]),
+                      "mode": "lt",
+                      "exit_type": exit_type,
+                      "symbol": tradingsymbol,
+                      "quantity": quantity,
+                      "price": trigger_price,
+                      "quantity_left": quantity_left,
+                      "trade_type": trade_type,
+                      "template_id": 0
+                      }
+
+        # Sending Alert
+        send_order_alert(alert_dict)
+        return "success", orders_list
+
+    except Exception as e:
+        print(f"Exception in Saving Order in DB : {e}")
+        return "failed", orders_list
+
+
+def save_lt_trade(app_db_cursor, trade_dict):
+    """Function to save order in Database"""
+    try:
+        # logger.info(msg="* saving LT trade to DB *****")
+        app_db_cursor["lt_trades"].insert_one(trade_dict)
+    except Exception as e:
+        print(f"Exception in saving LT trade in DB : {e}")
+        pass
+
+
+def place_live_order(credential_id, order_details):
+    """Function to place live trade order via REST API"""
+    try:
+        print("Placing Live Trade Order")
+        request_dict = {"credential_id": str(credential_id),
+                        "order_details": json.dumps(order_details)}
+        print("request_dict : {}".format(request_dict))
+
+        response = requests.post(url=orders_url+"place_order", params=request_dict)
+        print("******** Order Placement Response *********")
+        print(response.json())
+        return response.json()
+    except Exception as e:
+        print("Exception in placing live trade order : {}".format(e))
+        return None
+
+
+def modify_live_order(credential_id, order_details):
+    """Function to Modify Live Order"""
+    try:
+        print("* Modifying Live Order")
+        request_dict = {"credential_id": str(credential_id),
+                        "order_details": json.dumps(order_details)}
+        print("request_dict : {}".format(request_dict))
+
+        response = requests.post(url=orders_url + "modify_order", params=request_dict)
+        print("******** Order Placement Response *********")
+        print(response.json())
+        return response.json()
+    except Exception as e:
+        print("Exception in Modify Live Order : {}".format(e))
+        pass