diff --git a/.github/workflows/pythonpublish.yml b/.github/workflows/pythonpublish.yml
index 5fdb9e42..e9df9e04 100644
--- a/.github/workflows/pythonpublish.yml
+++ b/.github/workflows/pythonpublish.yml
@@ -15,7 +15,7 @@ jobs:
     - name: Set up Python
       uses: actions/setup-python@v1
       with:
-        python-version: '3.8.6'
+        python-version: '3.10.18'
     - name: Install dependencies
       run: |
         python -m pip install --upgrade pip
diff --git a/README.md b/README.md
index d5cc5118..f0339d7c 100644
--- a/README.md
+++ b/README.md
@@ -2,53 +2,115 @@
 
 Python SDK for 5paisa APIs natively written in VB .NET
 
+![PyPI](https://img.shields.io/pypi/v/py5paisa)
+![GitHub Workflow Status (branch)](https://img.shields.io/github/workflow/status/5paisa/py5paisa/Publish%20package/master)
+
 ![5paisa logo](./docs/images/5-paisa-img.jpg)
 
 #### Documentation
 
-Read the docs hosted [here](https://5paisa.github.io/)
+Read the docs hosted [here](https://www.5paisa.com/developerapi/overview)
 
 #### Features
 
 -   Order placement, modification and cancellation
 -   Fetching user info including holdings, positions, margin and order book.
+-   Fetching live market streaming.
+-   Placing, modifying and deleting Bracket Order.
 -   Fetching order status and trade information.
+-   Getting live data streaming using websockets.
 
 ### Installation
 
-`pip install pyp5aisa`
+`pip install py5paisa`
 
 ### Usage
 
 #### Configuring API keys
 
-Get your API keys from https://www.5paisa.com/developerapi/apikeys
+Get your API keys from [here](https://xstream.5paisa.com/dashboard)
 
-Configure these keys in a file named `keys.conf` in the same directory as your python script exists
+Note:- We have deprecated the existing method which involved the use of login credentials.
+       Kindly go through this updated documentation of using Access token for API Access.
 
-A sample `keys.conf` is given below:
+#### Scrip codes reference:
+```py
+Note : Use these Links for getting scrip codes
 
-```conf
-[KEYS]
-APP_NAME=YOUR_APP_NAME_HERE
-APP_SOURCE=YOUR_APP_SOURCE_HERE
-USER_ID=YOUR_USER_ID_HERE
-PASSWORD=YOUR_PASSWORD_HERE
-USER_KEY=YOUR_USER_KEY_HERE
-ENCRYPTION_KEY=YOUR_ENCRYPTION_KEY_HERE
-```
+Scrip Master - Downaload ScripMaster [here](https://openapi.5paisa.com/VendorsAPI/Service1.svc/ScripMaster/segment/All)
+
+[API Documentation](https://xstream.5paisa.com/dev-docs/docFundamentals/scrip-master)
+
+#Fetch Scrip Codes
+
+scrips = client.get_scrips()
 
+#Query Script Data Inputs sequence- exchange, exchangetype, symbol, strike, type, expiry
 
-#### Authentication
+#Strike to be 0 for cash stocks , Actual Strike for Derivatives 
 
+#type to be XX for Cash stocks and Futures, EQ for indices, CE/PE for Options
+
+#Fetch Scrip Data for Cash
+record = client.query_scrips("N","C","ITC","0","XX","")
+#Fetch Scrip Data for Options
+record = client.query_scrips("N","D","NIFTY","22300","CE","2024-04-25")
+#Fetch Scrip Data for Futures
+record = client.query_scrips("N","C","INFY","0","XX","")
+```
+
+#### AUTHENTICATION USING OAUTH
 ```py
 from py5paisa import FivePaisaClient
+cred={
+    "APP_NAME":"YOUR APP_NAME",
+    "APP_SOURCE":"YOUR APP_SOURCE",
+    "USER_ID":"YOUR USER_ID",
+    "PASSWORD":"YOUR PASSWORD",
+    "USER_KEY":"YOUR USERKEY",
+    "ENCRYPTION_KEY":"YOUR ENCRYPTION_KEY"
+    }
+
+#This function will automatically take care of generating and sending access token for all your API's
+
+client = FivePaisaClient(cred=cred)
+
+# OAUTH Approach
+# First get a token by logging in to -> https://dev-openapi.5paisa.com/WebVendorLogin/VLogin/Index?VendorKey=<Your Vendor Key>&ResponseURL=<Redirect URL>
+# VendorKey is UesrKey for individuals user
+# for e.g. you can use ResponseURL as https://www.5paisa.com/technology/developer-apis
+# Pass the token received in the response url after successful login to get an access token (this also sets the token for all the APIs you use)-
+
+# Please note that you need to copy the request token from URL and paste in this code and start the code within 30s.
+
+client.get_oauth_session('Your Response Token')
+
+After successful authentication, you should get a `Logged in!!` message in console
+
+#Function to fetch access token after successful login
+print(client.get_access_token())
+
+#Login with Access Token
+client.set_access_token('accessToken','clientCode')
 
-client = FivePaisaClient(email="random_email@xyz.com", passwd="password", dob="YYYYMMDD")
-client.login()
 ```
 
-After successful authentication, you should get a `Logged in!!` message
+#### Market Feed
+
+```py
+#NOTE : ScripData and ScripCode you can find from new Scripmaster as mentioned above
+
+
+req_list_ = [{"Exch": "N", "ExchType": "C", "ScripData": "ITC_EQ"}]
+              {"Exch": "N", "ExchType": "C", "ScripCode": "2885"}]
+
+print(client.fetch_market_feed_scrip(req_list_))
+
+```
+#### Market Status
+```py
+print(client.get_market_status())
+```
 
 #### Fetching user info
 
@@ -65,55 +127,430 @@ client.positions()
 # Fetches the order book of the client
 client.order_book()
 
+# Fetches Trade book
+client.get_tradebook()
+
 ```
 
-Scrip codes reference:
+#### Position Conversion
+
+```py
+# Convert positions
+# client.position_convertion(<Exchange>,<Exchange Type>,<Scrip Name>,<Buy/Sell>,<Qty>,<From Delivery/Intraday>,<From Delivery/Intraday>)
+client.position_convertion("N","C","BPCL_EQ","B",5,"D","I")
+```
 
-BSE: https://www.bseindia.com/
-NSE: https://nse-scrips.herokuapp.com/
 
 #### Placing an order
 
 ```py
 # Note: This is an indicative order.
 
-from py5paisa.order import Order, OrderType, Exchange, ExchangeType
+from py5paisa.order import Order, OrderType, Exchange
+
+#You can pass scripdata either you can pass scripcode also.
+# please use price = 0 for market Order
+#use IsIntraday= true for intraday orders
 
-test_order = Order(order_type=OrderType.BUY, scrip_code=11111, quantity=10)
+#Using Scrip Data :-
 
-client.place_order(test_order)
+#Using Scrip Code :-
+client.place_order(OrderType='B',Exchange='N',ExchangeType='C', ScripCode = 1660, Qty=1, Price=260)
+#Sample For SL order (for order to be treated as SL order just pass StopLossPrice)
+client.place_order(OrderType='B',Exchange='N',ExchangeType='C', ScripCode = 1660, Qty=1, Price=350, IsIntraday=False, StopLossPrice=345)
+#Derivative Order
+client.place_order(OrderType='B',Exchange='N',ExchangeType='D', ScripCode = 57633, Qty=50, Price=1.5)
+
+Please refer below documentation link for paramaters to be passed in cleint.place_order function
+https://www.5paisa.com/developerapi/order-request-place-order
 
+```
+#### Placing offline orders (After Market Orders)
+
+By default all orders are normal orders, pass `AHPlaced=Y` to place offline orders.
+
+```py
+client.place_order(OrderType='B',Exchange='N',ExchangeType='C', ScripCode = 1660, Qty=1, Price=325, AHPlaced="Y")
 ```
 
 #### Modifying an order
 
 ```py
-client.modify_order(exch_order_id="12345678", traded_qty=10, scrip_code=11111)
+client.modify_order(ExchOrderID="1100000017861430", Qty=2,Price=261)
 ```
 
-#### Canceling an order
+#### Cancelling an order
 
 ```py
-client.cancel_order(exch_order_id="12345678", traded_qty=10, scrip_code=11111)
+client.cancel_order(exch_order_id="1100000017795041")
+```
+```py
+cancel_bulk=[
+            {
+                "ExchOrderID": "<Exchange Order ID 1>"
+            },
+            {
+                "ExchOrderID": "<Exchange Order ID 2>"
+            },
+client.cancel_bulk_order(cancel_bulk)
 ```
 
-#### Fetching Order Status and Trade Information
+#### Order Margin Calculation
+-   This function can help calculate
+-   Margin required for single or multileg order
+-   Margin required considering existing positions( CoverPosition = Y/N)
+
+```py
+Orders2 =[
+
+             {
+                "Exch": "N",
+                "ExchType": "C",
+                "ScripCode": 2885,
+                "ScripData": "",
+                "PlaceModifyCancel": "P",
+                "OrderType": "B",
+                "Price": 0,
+                "Qty": 1,
+                "IsIntraday": False
+            },
+            {
+                "Exch": "B",
+                "ExchType": "C",
+                "ScripCode": 512070,
+                "ScripData": "",
+                "PlaceModifyCancel": "P",
+                "OrderType": "S",
+                "Price": 0,
+                "Qty": 1,
+                "IsIntraday": True
+            }
+        ]
+a=client.multi_order_Margin(CoverPositions='Y',Orders=Orders2)
+
+```
+#### SquareOffAll Orders
 
 ```py
-from py5paisa.order import OrderForStatus, Exchange, ExchangeType, RequestList
+client.squareoff_all()
+```
+#### Bracket Order 
+
+For placing Braket order
+```py
+client.bo_order(OrderType='B',Exchange='N',ExchangeType='C', ScripCode = 1660, Qty=1, LimitPrice=330,TargetPrice=345,StopLossPrice=320,LimitPriceForSL=319,TrailingSL=1.5)
+
+```
+For placing Cover order
+```py
+client.cover_order(OrderType='B',Exchange='N',ExchangeType='C', ScripCode = 1660, Qty=1, LimitPrice=330,StopLossPrice=320,TrailingSL=1.5)
+```
+
+Note:For placing Bracket order in FNO segment pass ExchType='D'
+
+For Modifying Bracket/Cover Order only for Initial order (entry)
+```py
+
+client.modify_bo_order(ExchOrderID="1100000017861430",LimitPrice=330)
+client.modify_cover_order(ExchOrderID="1100000017861430",LimitPrice=330)
+
+#Note : For cover order just pass LimitPriceProfitOrder equal to Zero.
+```
+
+For Modifying LimitPriceProfitOrder 
+```py
+client.modify_bo_order(ExchOrderID="1100000017861430",TargetPrice=330)
+client.modify_cover_order(ExchOrderID="1100000017861430",TargetPrice=330)
+```
+For Modifying TriggerPriceForSL
+```py
+
+client.modify_bo_order(ExchOrderID="1100000017861430",LimitPriceForSL=330)
+client.modify_bo_order(ExchOrderID="1100000017861430",LimitPriceForSL=330)
+
+#Note : You have pass atmarket=true while modifying stoploss price, Pass ExchorderId for the particular leg to modify.
+```
+#### Basket Orders
+
+```py
+# Create a new Basket
+client.create_basket("<New Basket Name>")
 
-test_order_status = OrderForStatus(exchange=Exchange.BSE, exchange_type=ExchangeType.CASH, scrip_code=500875, order_id=0)
+# Rename existing basket
+client.rename_basket("<Modified Basket Name>",<Exisiting Basket ID>)
 
-req_list = RequestList()
-# Add multiple orders to the RequestList to know status of multiple orders at once.
-req_list.add_order(test_order_status)
+# Clone existing basket
+client.clone_basket(<Exisiting Basket ID>)
+
+# Delete bulk baskets
+delete_basket_list=[{"BasketID":"<Exisiting Basket ID>"},{"BasketID":"<Exisiting Basket ID>"}]
+client.delete_basket(delete_basket_list)
+
+
+# Get list of all baskets (Open/Closed)
+client.get_basket()
+
+basket_list= [
+            {
+                "BasketID": "<Exisiting Basket ID>"
+            },
+            {
+                "BasketID": "<Exisiting Basket ID>"
+            }
+        ]
+order_to_basket=Basket_order("N","C",23000,"BUY",1,"1660","I")
+client.add_basket_order(order_to_basket,basket_list)
+
+# Get orders in basket
+client.get_order_in_basket(<Exisiting Basket ID>)
+
+```
+
+#### Fetching Order Status and Trade Information
+
+```py
+from py5paisa.order import  Exchange
+
+req_list= [
+        {
+            "Exch": "N",
+            "ExchType": "C",
+            "ScripCode": 20374,
+            "ExchOrderID": "1000000015310807"
+        }]
 
 # Fetches the trade details
 client.fetch_trade_info(req_list)
 
+req_list_= [
+
+        {
+            "Exch": "N",
+            "RemoteOrderID": "90980441"
+        }]
 # Fetches the order status
-client.fetch_order_status(req_list)
+client.fetch_order_status(req_list_)
+
+# Fetch Trade History
+
+print(client.get_trade_history("PASS EXCHANGE ORDER ID"))
+
+```
+#### Live Market Feed Streaming - Websocket
+#NOTE : Webscoket only works with ScripCode
+```py
+req_list=[
+            { "Exch":"N","ExchType":"C","ScripCode":1660},
+            ]
+
+req_data=client.Request_Feed('mf','s',req_list)
+def on_message(ws, message):
+    print(message)
+
+
+client.connect(req_data)
+
+client.receive_data(on_message)
+```
+Note: Use the following abbreviations :
+
+Market Feed=mf
+
+Market Depth (upto 5)=md
+
+Indices (Spot Feed) =i
+
+Open Interest=oi
+
+Subscribe= s
+
+Unsubscribe=u
+
+#### Live Market Depth Streaming (Depth 20)
+
+```py
+a={
+                "method":"subscribe",
+                "operation":"20depth",
+                "instruments":["NC2885"]
+            }
+print(client.socket_20_depth(a))
+def on_message(ws, message):
+    print(message)
+client.receive_data(on_message)
+
+Note:- Instruments in payload above is a list(array) in format as <exchange><exchange type><scrip code>
+```
+
+#### Level 5 Market Depth 
+```py
+print(client.fetch_market_depth_by_scrip(Exchange="N",ExchangeType="C",ScripCode="1660"))
+print(client.fetch_market_depth_by_scrip(Exchange="N",ExchangeType="C",ScripData="RELIANCE_EQ"))
+```
+
+#### Full Market Snapshot 
+```py
+a=[{"Exchange":"N","ExchangeType":"C","ScripCode":"2885"},
+   {"Exchange":"N","ExchangeType":"C","ScripData":"ITC_EQ"},
+   ]
+print(client.fetch_market_snapshot(a))
+```
+
+
+#### Option Chain
+```py
+client.get_expiry("N","NIFTY")
+# Returns list of all active expiries
+
+# client.get_option_chain("N","NIFTY",<Pass expiry timestamp from get_expiry response>)
+client.get_option_chain("N","NIFTY",1647507600000)
+```
+
+#### Historical Data
+```py
+#historical_data(<Exchange>,<Exchange Type>,<Scrip Code>,<Time Frame>,<From Data>,<To Date>)
+
+df=client.historical_data('N','C',1660,'15m','2021-05-25','2021-06-16')
+print(df)
+
+# Note : TimeFrame Should be from this list ['1m','5m','10m','15m','30m','60m','1d']
+```
+
+
+#### Bulk Order Placement
+
+```py
+
+bulk_order=[{
+        "Exchange":"N", "ExchangeType":"C", "ScripCode":0, "ScripData":"ITC_EQ", "Price": "440", "OrderType": "Buy", "Qty": 1, "DisQty": "0", "StopLossPrice": "0", "IsIntraday": True, "iOrderValidity": "0", "RemoteOrderID":"50000091_220620"
+    },{
+        "Exchange":"N", "ExchangeType":"C", "ScripCode":0, "ScripData":"IDEA_EQ", "Price": "15", "OrderType": "Buy", "Qty": 1, "DisQty": "0", "StopLossPrice": "0", "IsIntraday": True, "iOrderValidity": "0", "RemoteOrderID":"50000091_220620"
+    }
+]
+client.place_order_bulk(OrderList=bulk_order)
+```
+
+#### Strategy Execution
+#### List Of Strategies Available
+ - Short Straddle
+ - Short Strangle
+ - Long Straddle
+ - Long Strangle
+ - Iron Fly(Butterfly)
+ - Iron Condor
+ - Call Calendar Spread
+ - Put Calendar Spread
+ - Call Ladder
+ - Put Ladder
+ - Ladder
+```py
+#Import strategy package
+from py5paisa.strategy import *
+```
+Note: These single-commands are capable of trading multiple legs of pre-defined strategies.
+Like :- Short/Long Straddles and Strangles, Iron Fly and Iron Condor (many more to come)
+Please use these at your own risk.
+```py
+#Create an Object:-
+cred={
+    "APP_NAME":"YOUR APP_NAME",
+    "APP_SOURCE":YOUR APP_SOURCE,
+    "USER_ID":"YOUR USER_ID",
+    "PASSWORD":"YOUR PASSWORD",
+    "USER_KEY":"YOUR USERKEY",
+    "ENCRYPTION_KEY":"YOUR ENCRYPTION_KEY"
+    }
+--Old approach
+strategy=strategies(user="random_email@xyz.com", passw="password", dob="YYYYMMDD",cred=cred)
+--New Approach
+strategy=strategies(cred=cred,request_token="eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1bmlxdWVfbmFtZSI6IjUwMDUyNzcwIiwicm9sZSI6ImdpUUlvYXR5R2NYQUR3eFYwNXVXSGlPVzJRT1dOTGNzIiwibmJmIjoxNjY3ODMwODczLCJleHAiOjE2Njc4MzA5MDMsImlhdCI6MTY2NzgzMDg3M30.iP_FZtFy-nj6QeRd0sEhaKS-jr-wu-pCwtcdYCGPeO4")
+
+```
+Use the following to execute the strategy (note:- they are executed at market price only)
+```py
+#short_straddle(<symbol>,<strike price>,<qty>,<expiry>,<Order Type>)
+strategy.short_straddle("banknifty",'37000','50','20210610','I',tag='<Your strategy Name>')
+
+#Using tag is optional
+```
+```py
+#short_strangle(<symbol>,<List of sell strike price>,<qty>,<expiry>,<Order Type>)
+strategy.short_strangle("banknifty",['35300','37000'],'50','20210610','D')
+```
+```py
+#long_straddle(<symbol>,<strike price>,<qty>,<expiry>,<Order Type>)
+strategy.long_straddle("banknifty",'37000','50','20210610','I',tag='<Your strategy Name>')
+
+#Using tag is optional
+```
+```py
+#long_strangle(<symbol>,<List of sell strike price>,<qty>,<expiry>,<Order Type>)
+strategy.long_strangle("banknifty",['35300','37000'],'50','20210610','D')
+```
+
+```py
+#iron_condor(<symbol>,<List of buy strike prices>,<List of sell strike price>,<qty>,<expiry>,<Order Type>)
+strategy.iron_condor("NIFTY",["15000","15200"],["15100","15150"],"75","20210603","I")
+```
+
+```py
+#iron_fly(<symbol>,<List of buy strike prices>,<Sell strike price>,<qty>,<expiry>,<Order Type>)
+strategy.iron_fly("NIFTY",["15000","15200"],"15100","75","20210610","I",tag='<Your strategy Name>')
+
+#Using tag is optional
+```
+
+```py
+#call_calendar(<symbol>,<List of sell strike price>,<qty>,<list of expiry(first one will be bought and the second sold based on expiry)>,<Order Type>)
+strategy.call_calendar("nifty",'15600','75',['20210603','20210610'],'I')
+```
+
+```py
+#put_calendar(<symbol>,<List of sell strike price>,<qty>,<list of expiry(first one will be bought and the second sold based on expiry)>,<Order Type>)
+strategy.put_calendar("nifty",'15600','75',['20210603','20210610'],'I')
+```
+
+```py
+#call_ladder(<symbol>,<Buy strike prices>,<List of Sell strike price>,<qty>,<expiry>,<Order Type>)
+strategy.call_ladder("NIFTY","15100",["15300","15400"],"75","20210610","I")
+```
+
+```py
+#put_ladder(<symbol>,<Buy strike prices>,<List of Sell strike price>,<qty>,<expiry>,<Order Type>)
+strategy.put_ladder("NIFTY","15000",["14800","14500"],"75","20210610","I",tag='<Your strategy Name>')
+
+#Using tag is optional
+```
+
+```py
+#ladder(<symbol>,<List of Buy strike prices>,<List of Sell strike price>,<qty>,<expiry>,<Order Type>)
+strategy.ladder("sbin",["400","420"],["350","370","450","500"],"1500","20210729","D")
+```
+
+```py
+Squareoff a strategy Using tags
+strategy.squareoff('tag')
+
+# Use the same tag as used while executing the strategies
+```
+
+
+
+#### REPORTS
+
+```py
+TAX Report
+a=client.tax_report("2024-01-01",'2024-06-26')
+print(a)
+
+# to fetch Tax report
+```
+```py
+Ledger Report
+a=client.fetch_ledger("2024-01-01",'2024-06-26')
+print(a)
 
+# to fetch Ledger report
 ```
 
 #### TODO
diff --git a/docs/index.md b/docs/index.md
index 46a6df93..441713fd 100644
--- a/docs/index.md
+++ b/docs/index.md
@@ -8,4 +8,7 @@ Python SDK for 5paisa APIs natively written in VB .NET
 
 -   Order placement, modification and cancellation
 -   Fetching user info including holdings, positions, margin and order book.
--   Fetching order status and trade information.
\ No newline at end of file
+-   Fetching live market streaming.
+-   Placing, modifying and deleting Bracket Order.
+-   Fetching order status and trade information.
+-   Getting live data streaming using websocket.
\ No newline at end of file
diff --git a/docs/usage/bo.md b/docs/usage/bo.md
new file mode 100644
index 00000000..01ca1ad8
--- /dev/null
+++ b/docs/usage/bo.md
@@ -0,0 +1,33 @@
+#### Bracket Order 
+
+
+For placing Braket order
+```py
+test_order=bo_co_order(scrip_code=1660,BuySell='B',Qty=1, LimitPriceInitialOrder=204,TriggerPriceInitialOrder=0,LimitPriceProfitOrder=208.0,TriggerPriceForSL=202,RequestType='P',AtMarket=False)
+
+client.bo_order(test_order)
+```
+Note : For cover order just pass LimitPriceProfitOrder equal to Zero.
+
+For Modifying Bracket Order only for Initial order (entry)
+```py
+test_order=bo_co_order(scrip_code=1660,BuySell='B',Qty=1, LimitPriceInitialOrder=203,TriggerPriceInitialOrder=0,LimitPriceProfitOrder=208.0,TriggerPriceForSL=202,RequestType='M',AtMarket=False,ExchOrderId='12345678')
+
+client.bo_order(test_order)
+
+
+```
+For Modifying LimitPriceProfitOrder 
+```py
+test_order=Order(order_type='S', scrip_code=1660, quantity=1, price=208.50,is_intraday=True,exchange='N',exchange_segment='C',atmarket=False,exch_order_id="12345678" ,order_for=OrderFor.MODIFY)
+
+client.mod_bo_order(test_order)
+```
+For Modifying TriggerPriceForSL
+```py
+test_order=Order(order_type='S', scrip_code=1660, quantity=1, price=0,is_intraday=True,exchange='N',exchange_segment='C',atmarket=True,exch_order_id="123456789" ,stoploss_price=201.50,is_stoploss_order=True,order_for=OrderFor.MODIFY)
+
+client.mod_bo_order(test_order)
+
+#Note : You have pass atmarket=true while modifying stoploss price, Pass ExchorderId for the particular leg to modify.
+```
diff --git a/docs/usage/cancel.md b/docs/usage/cancel.md
index b84e1a4d..2f93f53a 100644
--- a/docs/usage/cancel.md
+++ b/docs/usage/cancel.md
@@ -1,5 +1,5 @@
 ## Canceling an order
 
 ```py
-client.cancel_order(exch_order_id="12345678", traded_qty=10, scrip_code=11111)
+client.cancel_order(order_type='B', scrip_code=1660, quantity=1,exchange='N',exchange_segment='C',exch_order_id='12345678')
 ```
\ No newline at end of file
diff --git a/docs/usage/info.md b/docs/usage/info.md
index b88e5d24..700e12f5 100644
--- a/docs/usage/info.md
+++ b/docs/usage/info.md
@@ -21,18 +21,27 @@ client.order_book()
 #### Order Status and Trade Information
 
 ```py
-from py5paisa.order import OrderForStatus, Exchange, ExchangeType, RequestList
 
-test_order_status = OrderForStatus(exchange=Exchange.BSE, exchange_type=ExchangeType.CASH, scrip_code=500875, order_id=0)
+req_list= [
 
-req_list = RequestList()
-# Add multiple orders to the RequestList to know status of multiple orders at once.
-req_list.add_order(test_order_status)
+        {
+            "Exch": "N",
+            "ExchType": "C",
+            "ScripCode": 20374,
+            "ExchOrderID": "1000000015310807"
+        }]
 
 # Fetches the trade details
 client.fetch_trade_info(req_list)
 
-# Fetches the order status
-client.fetch_order_status(req_list)
+req_list_= [
 
+        {
+            "Exch": "N",
+            "ExchType": "C",
+            "ScripCode": 20374,
+            "RemoteOrderID": "90980441"
+        }]
+# Fetches the order status
+client.fetch_order_status(req_list_)
 ```
\ No newline at end of file
diff --git a/docs/usage/mf.md b/docs/usage/mf.md
new file mode 100644
index 00000000..7998d222
--- /dev/null
+++ b/docs/usage/mf.md
@@ -0,0 +1,10 @@
+#### Market Feed
+
+```py
+# NOTE : Symbol has to be in the same format as specified in the example below.
+
+req_list_=[{"Exch":"N","ExchType":"D","Symbol":"NIFTY 22 APR 2021 CE 15200.00","Expiry":"20210422","StrikePrice":"15200","OptionType":"CE"},
+            {"Exch":"N","ExchType":"D","Symbol":"NIFTY 22 APR 2021 PE 15200.00","Expiry":"20210422","StrikePrice":"15200","OptionType":"PE"}]
+            
+client.fetch_market_feed(req_list_)
+```
diff --git a/docs/usage/modify.md b/docs/usage/modify.md
index 6511205c..77fa67ae 100644
--- a/docs/usage/modify.md
+++ b/docs/usage/modify.md
@@ -1,5 +1,6 @@
 ## Modifying an order
 
 ```py
-client.modify_order(exch_order_id="12345678", traded_qty=10, scrip_code=11111)
+test_order = Order(order_type='B', scrip_code=1660, quantity=1, price=205,is_intraday=False,exchange='N',exchange_segment='C',atmarket=True,exch_order_id="12345678" )
+client.modify_order(test_order)
 ```
diff --git a/docs/usage/place.md b/docs/usage/place.md
index 81e6e81b..6fbe1222 100644
--- a/docs/usage/place.md
+++ b/docs/usage/place.md
@@ -1,28 +1,15 @@
 ## Placing an order
 
 ```py
-# Note: This is an indicative order.
-
-from py5paisa.order import Order, OrderType
-
-test_order = Order(order_type=OrderType.BUY, scrip_code=11111, quantity=10, price=123.0)
+from py5paisa.order import Order, OrderType, Exchange
 
+test_order = Order(order_type='B',exchange='N',exchange_segment='C', scrip_code=1660, quantity=1, price=205,is_intraday=True,atmarket=False)
 client.place_order(test_order)
 
 ```
 
 #### Detailed Usage
 
-#### Placing an intraday order
-
-By default orders are delivery, to place an intraday order, pass `is_intraday=True`
-
-```py
-from py5paisa.order import Order, OrderType
-
-test_order = Order(order_type=OrderType.BUY, scrip_code=11111, quantity=10, is_intraday=True, price=123.0)
-client.place_order(test_order)
-```
 
 #### Placing a stoploss order
 
@@ -32,9 +19,8 @@ By default orders are regular, to place a stoploss order, pass `is_stoploss_orde
 
 ```py
 from py5paisa.order import Order, OrderType
+test_order = Order(order_type='B',exchange='N',exchange_segment='C', scrip_code=1660, quantity=1, price=208,is_intraday=True,atmarket=False, is_stoploss_order=True, stoploss_price=207.5)
 
-test_order = Order(order_type=OrderType.BUY, scrip_code=11111, quantity=10, is_stoploss=True, stoploss_price=123.0)
-client.place_order(test_order)
 ```
 
 #### Placing offline orders
@@ -43,9 +29,8 @@ By default all orders are normal orders, pass `ahplaced=AHPlaced.AFTER_MARKET_CL
 
 ```py
 from py5paisa.order import Order, OrderType, AHPlaced
+test_order = Order(order_type='B',exchange='N',exchange_segment='C', scrip_code=1660, quantity=1, price=205,is_intraday=False,atmarket=False, ahplaced=AHPlaced.AFTER_MARKET_CLOSED)
 
-test_order = Order(order_type=OrderType.BUY, scrip_code=11111, quantity=10, ahplaced=AHPlaced.AFTER_MARKET_CLOSED)
-client.place_order(test_order)
 ```
 
 #### Enums
diff --git a/docs/usage/websocket.md b/docs/usage/websocket.md
new file mode 100644
index 00000000..af5028d0
--- /dev/null
+++ b/docs/usage/websocket.md
@@ -0,0 +1,61 @@
+### Web Socket
+
+####For Subscribe ScripCode
+
+```py
+
+req_list=[
+            { "Exch":"N","ExchType":"C","ScripCode":1660},
+            
+            ]
+
+dict1=client.Request_Feed('mf','s',req_list)
+
+
+```
+
+####For Subscribe Multiple ScripCode
+
+```py
+
+req_list=[
+            { "Exch":"N","ExchType":"C","ScripCode":1660},
+            { "Exch":"N","ExchType":"D","ScripCode":61211}
+            ]
+
+dict1=client.Request_Feed('mf','s',req_list)
+
+```
+
+####For Unsubscibe ScripCode
+
+```py
+
+req_list=[
+            { "Exch":"N","ExchType":"C","ScripCode":1660}
+            ]
+
+dict1=client.Request_Feed('mf','u',req_list)
+
+```
+
+####For Unsubscibe Multiple ScripCode
+
+```py
+
+req_list=[
+            { "Exch":"N","ExchType":"C","ScripCode":1660},
+            { "Exch":"N","ExchType":"D","ScripCode":61211}
+            ]
+
+dict1=client.Request_Feed('mf','u',req_list)
+
+```
+
+####Start Streaming
+
+```py
+client.Streming_data(dict1)
+
+# Note : Pass Dictionary in Parameter Field
+```
\ No newline at end of file
diff --git a/mkdocs.yml b/mkdocs.yml
index 07f95d78..8374ea06 100644
--- a/mkdocs.yml
+++ b/mkdocs.yml
@@ -7,7 +7,11 @@ nav:
         - 'Placing an order': 'usage/place.md'
         - 'Modiying an order': 'usage/modify.md'
         - 'Canceling an order': 'usage/cancel.md'
+        - 'Fetching  Market Feed Information': 'usage/mf.md'
+        - 'Placing a Bracket order': 'usage/bo.md'
         - 'Fetching information': 'usage/info.md'
+        - 'Web Socket Live Streaming' : 'usage/websocket.md'
+        
 theme: 
     name: material
     features:
diff --git a/py5paisa/auth.py b/py5paisa/auth.py
index 89eb954c..ed03fa5d 100644
--- a/py5paisa/auth.py
+++ b/py5paisa/auth.py
@@ -5,15 +5,15 @@
 from Crypto.Cipher import AES
 import base64
 from pbkdf2 import PBKDF2
-from .conf import ENCRYPTION_KEY
+
 
 
 class EncryptionClient:
 
-    def __init__(self):
+    def __init__(self,ENCRYPTION_KEY): 
         self.iv = bytes([83, 71, 26, 58, 54, 35, 22, 11,
                          83, 71, 26, 58, 54, 35, 22, 11])
-        self.enc_key = ENCRYPTION_KEY
+        self.enc_key = ENCRYPTION_KEY 
 
     def _pad_and_convert_to_bytes(self, text):
         return bytes(text+chr(16-len(text) % 16)*(16-len(text) % 16), encoding="utf-8")
@@ -25,5 +25,7 @@ def encrypt(self, text):
         aesiv = key_gen.read(16)
         aeskey = key_gen.read(32)
         cipher = AES.new(aeskey, AES.MODE_CBC, aesiv)
-
+    
         return str(base64.b64encode(cipher.encrypt(padded_text)), encoding="utf-8")
+
+
diff --git a/py5paisa/conf.py b/py5paisa/conf.py
deleted file mode 100644
index 1edb8628..00000000
--- a/py5paisa/conf.py
+++ /dev/null
@@ -1,18 +0,0 @@
-"""
-Get your API keys from https://www.5paisa.com/developerapi/apikeys
-"""
-import configparser
-
-config = configparser.ConfigParser()
-config.read("keys.conf")
-try:
-    section = config["KEYS"]
-except KeyError:
-    raise Exception("Please configure your keys in keys.conf")
-
-APP_SOURCE = config["KEYS"]["APP_SOURCE"]
-APP_NAME = config["KEYS"]["APP_NAME"]
-USER_ID = config["KEYS"]["USER_ID"]
-PASSWORD = config["KEYS"]["PASSWORD"]
-USER_KEY = config["KEYS"]["USER_KEY"]
-ENCRYPTION_KEY = config["KEYS"]["ENCRYPTION_KEY"]
diff --git a/py5paisa/const.py b/py5paisa/const.py
index c65924a6..6933f95d 100644
--- a/py5paisa/const.py
+++ b/py5paisa/const.py
@@ -1,41 +1,32 @@
 """
 Contains reusable payloads across requests
 """
-from .conf import APP_NAME, USER_ID, PASSWORD, USER_KEY
 import datetime
+from enum import Enum
 
 HEADERS = {'Content-Type': 'application/json'}
 
 GENERIC_PAYLOAD = {
     "head": {
-        "appName": APP_NAME,
-        "appVer": "1.0",
-        "key": USER_KEY,
-        "osName": "WEB",
-        "requestCode": "",
-        "userId": USER_ID,
-        "password": PASSWORD
     },
     "body": {
-        "ClientCode": ""
     }
 }
-
 LOGIN_PAYLOAD = {"head": {
-    "appName": APP_NAME,
+    "appName": "",
     "appVer": "1.0",
-    "key": USER_KEY,
+    "key": "",
     "osName": "WEB",
     "requestCode": "5PLoginV2",
-    "userId": USER_ID,
-    "password": PASSWORD
+    "userId": "",
+    "password": ""
 },
     "body":
     {
     "Email_id": "",
     "Password": "",
-    "LocalIP": "",
-    "PublicIP": "",
+    "LocalIP": "192.168.10.10",
+    "PublicIP": "192.168.10.10",
     "HDSerailNumber": "",
     "MACAddress": "",
     "MachineID": "039377",
@@ -45,7 +36,46 @@
     "ConnectionType": "1"
 }
 }
+LOGIN_CHECK_PAYLOAD={
+    "head" : {
+        "requestCode":"5PLoginCheck",
+        "key":"",
+        "appVer":"1.0",
+        "appName":"",
+        "osName":"WEB",
+        "LoginId":""
+        },
+    "body":{
+        "RegistrationID":""
+        }
+    }
+WS_PAYLOAD={"Method":"",
+            "Operation":"",
+            "ClientCode":"",
+            "MarketFeedData":""}
+
+JWT_HEADERS={
+    'Ocp-Apim-Subscription-Key': 'c89fab8d895a426d9e00db380b433027',
+    'Authorization':''
+    }
+
+JWT_PAYLOAD={
+    "ClientCode":"",
+    "JWTToken":""
+    }
+SOCKET_DEPTH_PAYLOAD={
+            "operation":"",
+            "method":"",
+            "instruments":""}
+
+class VTT_TYPE(Enum):
+    P = 'VTT'
+    M = 'MVTT'
+    C = 'CVTT'
+    G = 'GVTT'
+    H = 'HVTT'
 
+SUBSCRIPTION_KEY="c89fab8d895a426d9e00db380b433027"
 TODAY_TIMESTAMP = int(datetime.datetime.today().timestamp())
 NEXT_DAY_TIMESTAMP = int(
     (datetime.datetime.today()+datetime.timedelta(days=1)).timestamp())
diff --git a/py5paisa/csv.py b/py5paisa/csv.py
new file mode 100644
index 00000000..dc85077f
--- /dev/null
+++ b/py5paisa/csv.py
@@ -0,0 +1,448 @@
+
+"""
+csv.py - read/write/investigate CSV files
+"""
+
+import re
+from _csv import Error, __version__, writer, reader, register_dialect, \
+                 unregister_dialect, get_dialect, list_dialects, \
+                 field_size_limit, \
+                 QUOTE_MINIMAL, QUOTE_ALL, QUOTE_NONNUMERIC, QUOTE_NONE, \
+                 __doc__
+from _csv import Dialect as _Dialect
+
+from io import StringIO
+
+__all__ = ["QUOTE_MINIMAL", "QUOTE_ALL", "QUOTE_NONNUMERIC", "QUOTE_NONE",
+           "Error", "Dialect", "__doc__", "excel", "excel_tab",
+           "field_size_limit", "reader", "writer",
+           "register_dialect", "get_dialect", "list_dialects", "Sniffer",
+           "unregister_dialect", "__version__", "DictReader", "DictWriter",
+           "unix_dialect"]
+
+class Dialect:
+    """Describe a CSV dialect.
+
+    This must be subclassed (see csv.excel).  Valid attributes are:
+    delimiter, quotechar, escapechar, doublequote, skipinitialspace,
+    lineterminator, quoting.
+
+    """
+    _name = ""
+    _valid = False
+    # placeholders
+    delimiter = None
+    quotechar = None
+    escapechar = None
+    doublequote = None
+    skipinitialspace = None
+    lineterminator = None
+    quoting = None
+
+    def __init__(self):
+        if self.__class__ != Dialect:
+            self._valid = True
+        self._validate()
+
+    def _validate(self):
+        try:
+            _Dialect(self)
+        except TypeError as e:
+            # We do this for compatibility with py2.3
+            raise Error(str(e))
+
+class excel(Dialect):
+    """Describe the usual properties of Excel-generated CSV files."""
+    delimiter = ','
+    quotechar = '"'
+    doublequote = True
+    skipinitialspace = False
+    lineterminator = '\r\n'
+    quoting = QUOTE_MINIMAL
+register_dialect("excel", excel)
+
+class excel_tab(excel):
+    """Describe the usual properties of Excel-generated TAB-delimited files."""
+    delimiter = '\t'
+register_dialect("excel-tab", excel_tab)
+
+class unix_dialect(Dialect):
+    """Describe the usual properties of Unix-generated CSV files."""
+    delimiter = ','
+    quotechar = '"'
+    doublequote = True
+    skipinitialspace = False
+    lineterminator = '\n'
+    quoting = QUOTE_ALL
+register_dialect("unix", unix_dialect)
+
+
+class DictReader:
+    def __init__(self, f, fieldnames=None, restkey=None, restval=None,
+                 dialect="excel", *args, **kwds):
+        self._fieldnames = fieldnames   # list of keys for the dict
+        self.restkey = restkey          # key to catch long rows
+        self.restval = restval          # default value for short rows
+        self.reader = reader(f, dialect, *args, **kwds)
+        self.dialect = dialect
+        self.line_num = 0
+
+    def __iter__(self):
+        return self
+
+    @property
+    def fieldnames(self):
+        if self._fieldnames is None:
+            try:
+                self._fieldnames = next(self.reader)
+            except StopIteration:
+                pass
+        self.line_num = self.reader.line_num
+        return self._fieldnames
+
+    @fieldnames.setter
+    def fieldnames(self, value):
+        self._fieldnames = value
+
+    def __next__(self):
+        if self.line_num == 0:
+            # Used only for its side effect.
+            self.fieldnames
+        row = next(self.reader)
+        self.line_num = self.reader.line_num
+
+        # unlike the basic reader, we prefer not to return blanks,
+        # because we will typically wind up with a dict full of None
+        # values
+        while row == []:
+            row = next(self.reader)
+        d = dict(zip(self.fieldnames, row))
+        lf = len(self.fieldnames)
+        lr = len(row)
+        if lf < lr:
+            d[self.restkey] = row[lf:]
+        elif lf > lr:
+            for key in self.fieldnames[lr:]:
+                d[key] = self.restval
+        return d
+
+
+class DictWriter:
+    def __init__(self, f, fieldnames, restval="", extrasaction="raise",
+                 dialect="excel", *args, **kwds):
+        self.fieldnames = fieldnames    # list of keys for the dict
+        self.restval = restval          # for writing short dicts
+        if extrasaction.lower() not in ("raise", "ignore"):
+            raise ValueError("extrasaction (%s) must be 'raise' or 'ignore'"
+                             % extrasaction)
+        self.extrasaction = extrasaction
+        self.writer = writer(f, dialect, *args, **kwds)
+
+    def writeheader(self):
+        header = dict(zip(self.fieldnames, self.fieldnames))
+        return self.writerow(header)
+
+    def _dict_to_list(self, rowdict):
+        if self.extrasaction == "raise":
+            wrong_fields = rowdict.keys() - self.fieldnames
+            if wrong_fields:
+                raise ValueError("dict contains fields not in fieldnames: "
+                                 + ", ".join([repr(x) for x in wrong_fields]))
+        return (rowdict.get(key, self.restval) for key in self.fieldnames)
+
+    def writerow(self, rowdict):
+        return self.writer.writerow(self._dict_to_list(rowdict))
+
+    def writerows(self, rowdicts):
+        return self.writer.writerows(map(self._dict_to_list, rowdicts))
+
+# Guard Sniffer's type checking against builds that exclude complex()
+try:
+    complex
+except NameError:
+    complex = float
+
+class Sniffer:
+    '''
+    "Sniffs" the format of a CSV file (i.e. delimiter, quotechar)
+    Returns a Dialect object.
+    '''
+    def __init__(self):
+        # in case there is more than one possible delimiter
+        self.preferred = [',', '\t', ';', ' ', ':']
+
+
+    def sniff(self, sample, delimiters=None):
+        """
+        Returns a dialect (or None) corresponding to the sample
+        """
+
+        quotechar, doublequote, delimiter, skipinitialspace = \
+                   self._guess_quote_and_delimiter(sample, delimiters)
+        if not delimiter:
+            delimiter, skipinitialspace = self._guess_delimiter(sample,
+                                                                delimiters)
+
+        if not delimiter:
+            raise Error("Could not determine delimiter")
+
+        class dialect(Dialect):
+            _name = "sniffed"
+            lineterminator = '\r\n'
+            quoting = QUOTE_MINIMAL
+            # escapechar = ''
+
+        dialect.doublequote = doublequote
+        dialect.delimiter = delimiter
+        # _csv.reader won't accept a quotechar of ''
+        dialect.quotechar = quotechar or '"'
+        dialect.skipinitialspace = skipinitialspace
+
+        return dialect
+
+
+    def _guess_quote_and_delimiter(self, data, delimiters):
+        """
+        Looks for text enclosed between two identical quotes
+        (the probable quotechar) which are preceded and followed
+        by the same character (the probable delimiter).
+        For example:
+                         ,'some text',
+        The quote with the most wins, same with the delimiter.
+        If there is no quotechar the delimiter can't be determined
+        this way.
+        """
+
+        matches = []
+        for restr in (r'(?P<delim>[^\w\n"\'])(?P<space> ?)(?P<quote>["\']).*?(?P=quote)(?P=delim)', # ,".*?",
+                      r'(?:^|\n)(?P<quote>["\']).*?(?P=quote)(?P<delim>[^\w\n"\'])(?P<space> ?)',   #  ".*?",
+                      r'(?P<delim>[^\w\n"\'])(?P<space> ?)(?P<quote>["\']).*?(?P=quote)(?:$|\n)',   # ,".*?"
+                      r'(?:^|\n)(?P<quote>["\']).*?(?P=quote)(?:$|\n)'):                            #  ".*?" (no delim, no space)
+            regexp = re.compile(restr, re.DOTALL | re.MULTILINE)
+            matches = regexp.findall(data)
+            if matches:
+                break
+
+        if not matches:
+            # (quotechar, doublequote, delimiter, skipinitialspace)
+            return ('', False, None, 0)
+        quotes = {}
+        delims = {}
+        spaces = 0
+        groupindex = regexp.groupindex
+        for m in matches:
+            n = groupindex['quote'] - 1
+            key = m[n]
+            if key:
+                quotes[key] = quotes.get(key, 0) + 1
+            try:
+                n = groupindex['delim'] - 1
+                key = m[n]
+            except KeyError:
+                continue
+            if key and (delimiters is None or key in delimiters):
+                delims[key] = delims.get(key, 0) + 1
+            try:
+                n = groupindex['space'] - 1
+            except KeyError:
+                continue
+            if m[n]:
+                spaces += 1
+
+        quotechar = max(quotes, key=quotes.get)
+
+        if delims:
+            delim = max(delims, key=delims.get)
+            skipinitialspace = delims[delim] == spaces
+            if delim == '\n': # most likely a file with a single column
+                delim = ''
+        else:
+            # there is *no* delimiter, it's a single column of quoted data
+            delim = ''
+            skipinitialspace = 0
+
+        # if we see an extra quote between delimiters, we've got a
+        # double quoted format
+        dq_regexp = re.compile(
+                               r"((%(delim)s)|^)\W*%(quote)s[^%(delim)s\n]*%(quote)s[^%(delim)s\n]*%(quote)s\W*((%(delim)s)|$)" % \
+                               {'delim':re.escape(delim), 'quote':quotechar}, re.MULTILINE)
+
+
+
+        if dq_regexp.search(data):
+            doublequote = True
+        else:
+            doublequote = False
+
+        return (quotechar, doublequote, delim, skipinitialspace)
+
+
+    def _guess_delimiter(self, data, delimiters):
+        """
+        The delimiter /should/ occur the same number of times on
+        each row. However, due to malformed data, it may not. We don't want
+        an all or nothing approach, so we allow for small variations in this
+        number.
+          1) build a table of the frequency of each character on every line.
+          2) build a table of frequencies of this frequency (meta-frequency?),
+             e.g.  'x occurred 5 times in 10 rows, 6 times in 1000 rows,
+             7 times in 2 rows'
+          3) use the mode of the meta-frequency to determine the /expected/
+             frequency for that character
+          4) find out how often the character actually meets that goal
+          5) the character that best meets its goal is the delimiter
+        For performance reasons, the data is evaluated in chunks, so it can
+        try and evaluate the smallest portion of the data possible, evaluating
+        additional chunks as necessary.
+        """
+
+        data = list(filter(None, data.split('\n')))
+
+        ascii = [chr(c) for c in range(127)] # 7-bit ASCII
+
+        # build frequency tables
+        chunkLength = min(10, len(data))
+        iteration = 0
+        charFrequency = {}
+        modes = {}
+        delims = {}
+        start, end = 0, chunkLength
+        while start < len(data):
+            iteration += 1
+            for line in data[start:end]:
+                for char in ascii:
+                    metaFrequency = charFrequency.get(char, {})
+                    # must count even if frequency is 0
+                    freq = line.count(char)
+                    # value is the mode
+                    metaFrequency[freq] = metaFrequency.get(freq, 0) + 1
+                    charFrequency[char] = metaFrequency
+
+            for char in charFrequency.keys():
+                items = list(charFrequency[char].items())
+                if len(items) == 1 and items[0][0] == 0:
+                    continue
+                # get the mode of the frequencies
+                if len(items) > 1:
+                    modes[char] = max(items, key=lambda x: x[1])
+                    # adjust the mode - subtract the sum of all
+                    # other frequencies
+                    items.remove(modes[char])
+                    modes[char] = (modes[char][0], modes[char][1]
+                                   - sum(item[1] for item in items))
+                else:
+                    modes[char] = items[0]
+
+            # build a list of possible delimiters
+            modeList = modes.items()
+            total = float(min(chunkLength * iteration, len(data)))
+            # (rows of consistent data) / (number of rows) = 100%
+            consistency = 1.0
+            # minimum consistency threshold
+            threshold = 0.9
+            while len(delims) == 0 and consistency >= threshold:
+                for k, v in modeList:
+                    if v[0] > 0 and v[1] > 0:
+                        if ((v[1]/total) >= consistency and
+                            (delimiters is None or k in delimiters)):
+                            delims[k] = v
+                consistency -= 0.01
+
+            if len(delims) == 1:
+                delim = list(delims.keys())[0]
+                skipinitialspace = (data[0].count(delim) ==
+                                    data[0].count("%c " % delim))
+                return (delim, skipinitialspace)
+
+            # analyze another chunkLength lines
+            start = end
+            end += chunkLength
+
+        if not delims:
+            return ('', 0)
+
+        # if there's more than one, fall back to a 'preferred' list
+        if len(delims) > 1:
+            for d in self.preferred:
+                if d in delims.keys():
+                    skipinitialspace = (data[0].count(d) ==
+                                        data[0].count("%c " % d))
+                    return (d, skipinitialspace)
+
+        # nothing else indicates a preference, pick the character that
+        # dominates(?)
+        items = [(v,k) for (k,v) in delims.items()]
+        items.sort()
+        delim = items[-1][1]
+
+        skipinitialspace = (data[0].count(delim) ==
+                            data[0].count("%c " % delim))
+        return (delim, skipinitialspace)
+
+
+    def has_header(self, sample):
+        # Creates a dictionary of types of data in each column. If any
+        # column is of a single type (say, integers), *except* for the first
+        # row, then the first row is presumed to be labels. If the type
+        # can't be determined, it is assumed to be a string in which case
+        # the length of the string is the determining factor: if all of the
+        # rows except for the first are the same length, it's a header.
+        # Finally, a 'vote' is taken at the end for each column, adding or
+        # subtracting from the likelihood of the first row being a header.
+
+        rdr = reader(StringIO(sample), self.sniff(sample))
+
+        header = next(rdr) # assume first row is header
+
+        columns = len(header)
+        columnTypes = {}
+        for i in range(columns): columnTypes[i] = None
+
+        checked = 0
+        for row in rdr:
+            # arbitrary number of rows to check, to keep it sane
+            if checked > 20:
+                break
+            checked += 1
+
+            if len(row) != columns:
+                continue # skip rows that have irregular number of columns
+
+            for col in list(columnTypes.keys()):
+
+                for thisType in [int, float, complex]:
+                    try:
+                        thisType(row[col])
+                        break
+                    except (ValueError, OverflowError):
+                        pass
+                else:
+                    # fallback to length of string
+                    thisType = len(row[col])
+
+                if thisType != columnTypes[col]:
+                    if columnTypes[col] is None: # add new column type
+                        columnTypes[col] = thisType
+                    else:
+                        # type is inconsistent, remove column from
+                        # consideration
+                        del columnTypes[col]
+
+        # finally, compare results against first row and "vote"
+        # on whether it's a header
+        hasHeader = 0
+        for col, colType in columnTypes.items():
+            if type(colType) == type(0): # it's a length
+                if len(header[col]) != colType:
+                    hasHeader += 1
+                else:
+                    hasHeader -= 1
+            else: # attempt typecast
+                try:
+                    colType(header[col])
+                except (ValueError, TypeError):
+                    hasHeader += 1
+                else:
+                    hasHeader -= 1
+
+        return hasHeader > 0
diff --git a/py5paisa/order.py b/py5paisa/order.py
index 375d11d2..77ec69ec 100644
--- a/py5paisa/order.py
+++ b/py5paisa/order.py
@@ -3,7 +3,6 @@
 """
 from .const import GENERIC_PAYLOAD, HEADERS, NEXT_DAY_TIMESTAMP
 import requests
-from .conf import APP_SOURCE
 from enum import Enum
 
 
@@ -50,25 +49,39 @@ class AHPlaced(Enum):
     NORMAL_ORDER = "N"
 
 
+class RequestType(Enum):
+    ORDER_PLACE="OP"
+    ORDER_CANCEL="OC"
+    ORDER_MODIFY="OM"
+    ORDER_STATUS="OS"
+    TRADE_INFO="TI"
+    MARKET_FEED="MF"
+    MARKET_DEPTH="MD"
+    TRADE_BOOK="TB"
+    MARKET_STATUS="MS"
+    MARKET_HISTORY="MH"
+    GET_BASKET="GB"
+    BRACKET_ORDER="BO"
+    BRACKET_MODIFY="BM"
+    CREATE_BASKET="CB"
+
+
 class Order:
 
-    def __init__(self, order_type: OrderType, scrip_code: int, quantity: int, order_for: OrderFor = OrderFor.PLACE, exchange: Exchange = Exchange.BSE,
-                 exchange_segment: ExchangeSegment = ExchangeSegment.CASH, price: float = 0.0, order_id: int = 0,
-                 atmarket: bool = True, remote_order_id: int = 1, exch_order_id: int = 0,
-                 stoploss_price: float = 0, is_stoploss_order: bool = False, ioc_order: bool = False,
-                 is_intraday: bool = False, is_vtd: bool = False, vtd: str = f"/Date({NEXT_DAY_TIMESTAMP})/",
-                 ahplaced: AHPlaced = AHPlaced.NORMAL_ORDER, public_ip: str = '192.168.1.1',
-                 order_validity: OrderValidity = OrderValidity.DAY, traded_qty: int = 0):
-
-        self.order_for = order_for.value
-        self.exchange = exchange.value
-        self.exchange_segment = exchange_segment.value
+    def __init__(self, order_type: str, quantity: int, exchange: str,
+                 exchange_segment: str, price: float ,is_intraday: bool , 
+                 remote_order_id: str = "",  scrip_code: int=0, exch_order_id: int = 0,
+                 stoploss_price: float = 0, is_stoploss_order: bool = False, ioc_order: bool = False,scripdata: str='',
+                 order_id: int = 0,vtd: str = f"/Date({NEXT_DAY_TIMESTAMP})/",
+                 ahplaced: str= 'N',IsGTCOrder:bool =False,IsEOSOrder:bool =False):
+
+        self.exchange = exchange
+        self.exchange_segment = exchange_segment
         self.price = price
         self.order_id = order_id
-        self.order_type = order_type.value
+        self.order_type = order_type
         self.quantity = quantity
         self.scrip_code = scrip_code
-        self.atmarket = atmarket
         self.remote_order_id = remote_order_id
         self.exch_order_id = exch_order_id
         self.disqty = quantity
@@ -76,48 +89,78 @@ def __init__(self, order_type: OrderType, scrip_code: int, quantity: int, order_
         self.is_stoploss_order = is_stoploss_order
         self.ioc_order = ioc_order
         self.is_intraday = is_intraday
-        self.is_vtd = is_vtd
         self.vtd = vtd
-        self.ahplaced = ahplaced.value
-        self.public_ip = public_ip
-        self.order_validity = order_validity.value
-        self.traded_qty = traded_qty
-        self.app_source = int(APP_SOURCE)
-
-
-class OrderForStatus:
-    """
-    Order class for representing an order for only Status and trade information request.
-    """
-
-    def __init__(self, exchange: Exchange, exchange_segment: ExchangeSegment, scrip_code: int, order_id: str) -> None:
-        self.exchange = exchange
-        self.exchange_segment = exchange_segment
-        self.scrip_code = scrip_code
-        self.order_id = order_id
-
-    def __str__(self):
-        return f"Order -> Exchange:{self.exchange}, Type: {self.exchange_segment}, Scrip Code: {self.scrip_code}, Order ID: {self.order_id}"
-
-    def __repr__(self) -> dict:
-        """
-        Overriding repr to return dict which can be directly appended to the orders list.
-        """
-        return {
-            "Exch": self.exchange,
-            "ExchSegment": self.exchange_segment,
-            "ScripCode": self.scrip_code,
-            "RemoteOrderID": self.order_id
-        }
-
-
-class RequestList:
-
-    def __init__(self):
-        self.orders = []
-
-    def add_order(self, order: OrderForStatus) -> None:
-        """
-        Adds order to the RequestList object required in the request payload.
-        """
-        self.orders.append(order.__repr__())
+        self.ahplaced = ahplaced
+        self.scripData=scripdata
+        self.IsGTCOrder=IsGTCOrder
+        self.IsEOSOrder=IsEOSOrder
+        
+
+class Bo_co_order:
+
+    def __init__(self,scrip_code: int, Qty: int,LimitPriceInitialOrder:float,TriggerPriceInitialOrder:float
+                 ,LimitPriceProfitOrder:float,BuySell:str,Exch: str,ExchType:  str,RequestType: str,LimitPriceForSL:float,
+                 TriggerPriceForSL:float,TrailingSL:int=0,StopLoss:int=0,
+                 LocalOrderIDNormal:int=0,LocalOrderIDSL:int=0,LocalOrderIDLimit:int=0,
+                 public_ip: str = '192.168.1.1',traded_qty: int = 0,
+                 order_for: str="S",
+                 DisQty: int=0,ExchOrderId:str="0",AtMarket: bool = False,UniqueOrderIDNormal:str="",
+                 UniqueOrderIDSL:str="",UniqueOrderIDLimit:str=""):
+        
+
+        self.order_for = order_for
+        self.Exch = Exch
+        self.ExchType = ExchType
+        self.RequestType=RequestType
+        self.BuySell=BuySell
+        self.scrip_code=scrip_code
+        self.DisQty=DisQty
+        self.LimitPriceInitialOrder=LimitPriceInitialOrder
+        self.LimitPriceForSL=LimitPriceForSL
+        self.TriggerPriceInitialOrder=TriggerPriceInitialOrder
+        self.LimitPriceProfitOrder=LimitPriceProfitOrder
+        self.AtMarket=AtMarket
+        self.TriggerPriceForSL=TriggerPriceForSL
+        self.TrailingSL=TrailingSL
+        self.StopLoss=StopLoss
+        self.UniqueOrderIDNormal=UniqueOrderIDNormal
+        self.UniqueOrderIDSL=UniqueOrderIDSL
+        self.UniqueOrderIDLimit=UniqueOrderIDLimit
+        self.LocalOrderIDNormal=LocalOrderIDNormal
+        self.LocalOrderIDSL=LocalOrderIDSL
+        self.LocalOrderIDLimit=LocalOrderIDLimit
+        self.public_ip=public_ip
+        self.ExchOrderId=ExchOrderId
+        self.traded_qty =traded_qty
+        self.Qty=Qty
+        
+        if LimitPriceProfitOrder==0:
+            self.order_for="C"
+
+class Basket_order:
+
+    def __init__(self,Exchange:str,ExchangeType:str,Price:float,OrderType:str,Qty:int,ScripCode:str,DelvIntra:str,AtMarket:bool= False,StopLossPrice:float=0,
+                 IsStopLossOrder:bool =False,IOCOrder: bool =False,IsIntraday:bool = False,AHPlaced:str='N',PublicIP:str='0.0.0.0',DisQty:int=0,iOrderValidity:float=0):
+        
+
+        self.Exchange = Exchange
+        self.ExchangeType = ExchangeType
+        self.Price = Price
+        self.OrderType=OrderType
+        self.Qty=Qty
+        self.ScripCode=ScripCode
+        self.DelvIntra=DelvIntra
+        self.IsIntraday = IsIntraday
+        self.AtMarket=AtMarket
+        self.StopLossPrice=StopLossPrice
+        self.IsStopLossOrder=IsStopLossOrder
+        self.IOCOrder=IOCOrder
+        
+        self.AHPlaced=AHPlaced
+
+        self.PublicIP=PublicIP
+        self.DisQty=DisQty
+        self.iOrderValidity=iOrderValidity
+
+        if DelvIntra == 'I':
+            self.IsIntraday=True
diff --git a/py5paisa/py5paisa.py b/py5paisa/py5paisa.py
index 4ce1f932..7e01ff83 100644
--- a/py5paisa/py5paisa.py
+++ b/py5paisa/py5paisa.py
@@ -1,189 +1,1106 @@
 import requests
+from requests.packages.urllib3.exceptions import InsecureRequestWarning
 from .auth import EncryptionClient
-from .const import GENERIC_PAYLOAD, HEADERS, NEXT_DAY_TIMESTAMP, TODAY_TIMESTAMP
-from .conf import APP_SOURCE
-from .order import Order, RequestList, OrderType, OrderFor
+from .const import *
+from .order import Order, Bo_co_order, RequestType, Basket_order
 from .logging import log_response
-import datetime
-from typing import Union
+import json
+import csv
+import websocket
+import pandas as pd
+import websocket
+from .urlconst import *
+import jwt
+from datetime import *
+import httpx
 
+from io import StringIO
+from enum import Enum
 
-class FivePaisaClient:
-
-    LOGIN_ROUTE = "https://Openapi.5paisa.com/VendorsAPI/Service1.svc/V3/LoginRequestMobileNewbyEmail"
-
-    MARGIN_ROUTE = "https://Openapi.5paisa.com/VendorsAPI/Service1.svc/V3/Margin"
-    ORDER_BOOK_ROUTE = "https://Openapi.5paisa.com/VendorsAPI/Service1.svc/V2/OrderBook"
-    HOLDINGS_ROUTE = "https://openapi.5paisa.com/VendorsAPI/Service1.svc/V2/Holding"
-    POSITIONS_ROUTE = "https://Openapi.5paisa.com/VendorsAPI/Service1.svc/V1/NetPositionNetWise"
-
-    ORDER_PLACEMENT_ROUTE = "https://Openapi.5paisa.com/VendorsAPI/Service1.svc/V1/OrderRequest"
-    ORDER_STATUS_ROUTE = "https://Openapi.5paisa.com/VendorsAPI/Service1.svc/OrderStatus"
-    TRADE_INFO_ROUTE = "https://Openapi.5paisa.com/VendorsAPI/Service1.svc/TradeInformation"
 
-    MARGIN_REQUEST_CODE = "5PMarginV3"
-    ORDER_BOOK_REQUEST_CODE = "5POrdBkV2"
-    HOLDINGS_REQUEST_CODE = "5PHoldingV2"
-    POSITIONS_REQUEST_CODE = "5PNPNWV1"
+class FivePaisaClient:
 
-    def __init__(self, email=None, passwd=None, dob=None):
+    def __init__(self, cred=None):
         """
         Main constructor for client.
         Expects user's email, password and date of birth in YYYYMMDD format.
         """
-        self.email = email
-        self.passwd = passwd
-        self.dob = dob
-        self.payload = GENERIC_PAYLOAD
-        self.client_code = None
-        self.session = requests.Session()
-
-    def login(self):
-        encryption_client = EncryptionClient()
-        secret_email = encryption_client.encrypt(self.email)
-        secret_passwd = encryption_client.encrypt(self.passwd)
-        secret_dob = encryption_client.encrypt(self.dob)
-        self.payload["body"]["Email_id"] = secret_email
-        self.payload["body"]["Password"] = secret_passwd
-        self.payload["body"]["My2PIN"] = secret_dob
-        self.payload["head"]["requestCode"] = "5PLoginV3"
-        res = self._login_request(self.LOGIN_ROUTE)
-        message = res["body"]["Message"]
-        if message == "":
-            log_response("Logged in!!")
-        else:
-            log_response(message)
-        self._set_client_code(res["body"]["ClientCode"])
+        try:
+            self.client_code = ""
+            self.Jwt_token = ""
+            self.Aspx_auth = None
+            self.web_url = None
+            self.market_depth_url = None
+            self.Res_Data = None
+            self.ws = None
+            self.access_token = ""
+            self.request_token = None
+            self.scrip_data = None
+            self.WEBSOCKET_URL = ""
+            self.session = httpx.Client(verify=False)
+            self.APP_SOURCE = cred["APP_SOURCE"]
+            self.APP_NAME = cred["APP_NAME"]
+            self.USER_ID = cred["USER_ID"]
+            self.PASSWORD = cred["PASSWORD"]
+            self.USER_KEY = cred["USER_KEY"]
+            self.ENCRYPTION_KEY = cred["ENCRYPTION_KEY"]
+            self.APIUID = APIUID
+            self.VTT_TYPE = VTT_TYPE
+            self.create_payload()
+            self.set_url()
+
+        except Exception as e:
+            log_response(e)
+
+    def get_scrips(self):
+        try:
+            if self.scrip_data is None:
+                response = self.session.get(
+                    self.SCRIP_MASTER_ROUTE, headers=HEADERS)
+
+                data = response.content.decode("utf-8").strip()
+
+                reader = csv.DictReader(StringIO(data))
+                records = pd.DataFrame(reader)
+
+                self.scrip_data = records
+            return self.scrip_data
+        except Exception as e:
+            log_response(e)
+
+    def query_scrips(self, exchange, exchangetype, symbol, strike, type, expiry):
+        try:
+            if self.scrip_data is None:
+                self.get_scrips()
+            return self.scrip_data.query('Exch=="'+exchange+'" & ExchType=="'+exchangetype+'" & SymbolRoot=="'+symbol+'" & StrikeRate=="'+strike+'" & ScripType=="'+type+'" & Expiry=="'+expiry+'"')
+        except Exception as e:
+            log_response(e)
 
     def holdings(self):
-        return self._user_info_request("HOLDINGS")
+        try:
+            return self._user_info_request("HOLDINGS")
+        except Exception as e:
+            log_response(e)
 
     def margin(self):
-        return self._user_info_request("MARGIN")
+        try:
+            return self._user_info_request("MARGIN")
+        except Exception as e:
+            log_response(e)
 
     def order_book(self):
-        return self._user_info_request("ORDER_BOOK")
+        try:
+            return self._user_info_request("ORDER_BOOK")
+        except Exception as e:
+            log_response(e)
 
     def positions(self):
-        return self._user_info_request("POSITIONS")
+        try:
+            return self._user_info_request("POSITIONS")
+        except Exception as e:
+            log_response(e)
 
     def _login_request(self, route):
-        res = self.session.post(route, json=self.payload, headers=HEADERS)
-        return res.json()
+        try:
+            requests.packages.urllib3.disable_warnings(InsecureRequestWarning)
+            HEADERS["5Paisa-API-Uid"] = self.APIUID
+            res = self.session.post(
+                route, json=self.login_payload, headers=HEADERS)
+            resp = res.json()
+            self.Jwt_token = resp["body"]["JWTToken"]
+            self.access_token = self.Jwt_token
+            return res.json()
+        except Exception as e:
+            log_response(e)
 
     def _set_client_code(self, client_code):
-        self.client_code = client_code
+        try:
+            self.client_code = client_code
+        except Exception as e:
+            log_response(e)
 
     def _user_info_request(self, data_type):
-        payload = GENERIC_PAYLOAD
-        payload["body"]["ClientCode"] = self.client_code
-        return_type = ""
-        if data_type == "MARGIN":
-            request_code = self.MARGIN_REQUEST_CODE
-            url = self.MARGIN_ROUTE
-            return_type = "EquityMargin"
-        elif data_type == "ORDER_BOOK":
-            request_code = self.ORDER_BOOK_REQUEST_CODE
-            url = self.ORDER_BOOK_ROUTE
-            return_type = "OrderBookDetail"
-        elif data_type == "HOLDINGS":
-            request_code = self.HOLDINGS_REQUEST_CODE
-            url = self.HOLDINGS_ROUTE
-            return_type = "Data"
-        elif data_type == "POSITIONS":
-            request_code = self.POSITIONS_REQUEST_CODE
-            url = self.POSITIONS_ROUTE
-            return_type = "NetPositionDetail"
-        else:
-            raise Exception("Invalid data type requested")
+        try:
+            payload = GENERIC_PAYLOAD
+            payload["body"]["ClientCode"] = self.client_code
+            payload["head"]["key"] = self.USER_KEY
+            HEADERS["Authorization"] = f'Bearer {self.access_token}'
+            HEADERS["5Paisa-API-Uid"] = self.APIUID
+            return_type = ""
+            if data_type == "MARGIN":
+                url = self.MARGIN_ROUTE
+                return_type = "EquityMargin"
+            elif data_type == "ORDER_BOOK":
+                url = self.ORDER_BOOK_ROUTE
+                return_type = "OrderBookDetail"
+            elif data_type == "HOLDINGS":
+                url = self.HOLDINGS_ROUTE
+                return_type = "Data"
+            elif data_type == "POSITIONS":
+                url = self.POSITIONS_ROUTE
+                return_type = "NetPositionDetail"
+            elif data_type == "IB":
+                url = self.IDEAS_ROUTE
+                return_type = "Data"
+            elif data_type == "IT":
+                url = self.IDEAS_ROUTE
+                return_type = "Data"
+            else:
+                raise Exception("Invalid data type requested")
+            response = self.session.post(
+                url, json=payload, headers=HEADERS).json()
+            self.payload = GENERIC_PAYLOAD
 
-        payload["head"]["requestCode"] = request_code
-        response = self.session.post(url, json=payload, headers=HEADERS).json()
-        message = response["body"]["Message"]
-        data = response["body"][return_type]
-        return data
+            data = response["body"][return_type]
+            return data
+        except Exception as e:
+            log_response(e)
 
     def order_request(self, req_type) -> None:
+        try:
+            self.payload["body"]["ClientCode"] = self.client_code
+            self.payload["head"]["key"] = self.USER_KEY
+            if self.access_token != "":
+                    HEADERS["Authorization"] = f'Bearer {self.Jwt_token}'
+            else:
+                HEADERS["Authorization"] = f'Bearer {self.access_token}'
+            HEADERS["5Paisa-API-Uid"] = self.APIUID
+            if req_type == "OP":
+                url = self.ORDER_PLACEMENT_ROUTE
+                # self.payload["head"]["requestCode"] = "5PPlaceOrdReq"
+                if self.access_token != "":
+                    HEADERS["Authorization"] = f'Bearer {self.Jwt_token}'
+            elif req_type == "OC":
+                url = self.ORDER_CANCEL_ROUTE
+                # self.payload["head"]["requestCode"] = "5PCancelOrdReq"
+                if self.access_token != "":
+                    HEADERS["Authorization"] = f'Bearer {self.Jwt_token}'
+            elif req_type == "OM":
+                url = self.ORDER_MODIFY_ROUTE
+                # self.payload["head"]["requestCode"] = "5PModifyOrdReq"
+                if self.access_token != "":
+                    HEADERS["Authorization"] = f'Bearer {self.Jwt_token}'
+            elif req_type == "OS":
+                url = self.ORDER_STATUS_ROUTE
+                self.payload["head"]["requestCode"] = "5POrdStatus"
+            elif req_type == "TI":
+                url = self.TRADE_INFO_ROUTE
+                self.payload["head"]["requestCode"] = "5PTrdInfo"
+            elif req_type == "TH":
+                url = self.TRADE_HISTORY_ROUTE
+            elif req_type == "MF":
+                url = self.MARKET_FEED_ROUTE
+                self.payload["head"]["requestCode"] = "5PMF"
+                self.payload["body"]["COUNT"] = self.client_code
+            elif req_type == "MF1":
+                url = self.MARKET_FEED_ROUTE_BY_SCRIP
+                self.payload["head"]["requestCode"] = "5PMF"
+                self.payload["body"]["COUNT"] = self.client_code
+            elif req_type == "BM":
+                url = self.BRACKET_MOD_ROUTE
+                # self.payload["head"]["requestCode"] = "5PSModMOOrd"
+                # self.payload["body"]["legtype"]=0
+                # self.payload["body"]["TMOPartnerOrderID"]=0
+            elif req_type == "CM":
+                url = self.COVER_MOD_ROUTE
+            elif req_type == "CO":
+                url = self.COVER_ORDER_ROUTE
+            elif req_type == "MS":
+                url = self.MARKET_STATUS_ROUTE
+            elif req_type == "BO":
+                url = self.BRACKET_ORDER_ROUTE
 
-        self.payload["body"]["ClientCode"] = self.client_code
-
-        if req_type == "OP":
-            url = self.ORDER_PLACEMENT_ROUTE
-            self.payload["head"]["requestCode"] = "5POrdReq"
-        elif req_type == "OS":
-            url = self.ORDER_STATUS_ROUTE
-            self.payload["head"]["requestCode"] = "5POrdStatus"
-        elif req_type == "TI":
-            url = self.TRADE_INFO_ROUTE
-            self.payload["head"]["requestCode"] = "5PTrdInfo"
-        else:
-            raise Exception("Invalid request type!")
-
-        res = self.session.post(url, json=self.payload,
-                                headers=HEADERS).json()
-        log_response(res["body"]["Message"])
-        return res["body"]
-
-    def fetch_order_status(self, req_list: RequestList) -> dict:
-        self.payload["body"]["OrdStatusReqList"] = req_list.orders
-        return self.order_request("OS")
-
-    def fetch_trade_info(self, req_list: RequestList) -> dict:
-        self.payload["body"]["TradeDetailList"] = req_list.orders
-        return self.order_request("TI")
-
-    def set_payload(self, order: Order) -> None:
-        self.payload["body"]["OrderFor"] = order.order_for
-        self.payload["body"]["Exchange"] = order.exchange
-        self.payload["body"]["ExchangeType"] = order.exchange_segment
-        self.payload["body"]["Price"] = order.price
-        self.payload["body"]["OrderID"] = order.order_id
-        self.payload["body"]["OrderType"] = order.order_type
-        self.payload["body"]["Qty"] = order.quantity
-        # Passing today's unix timestamp
-        self.payload["body"]["OrderDateTime"] = f"/Date({TODAY_TIMESTAMP})/"
-        self.payload["body"]["ScripCode"] = order.scrip_code
-        self.payload["body"]["AtMarket"] = str(order.atmarket).lower()
-        self.payload["body"]["RemoteOrderID"] = order.remote_order_id
-        self.payload["body"]["ExchOrderID"] = order.exch_order_id
-        self.payload["body"]["DisQty"] = order.disqty
-        self.payload["body"]["IsStopLossOrder"] = str(
-            order.is_stoploss_order).lower()
-        self.payload["body"]["StopLossPrice"] = order.stoploss_price
-        self.payload["body"]["IsVTD"] = str(order.is_vtd).lower()
-        self.payload["body"]["IOCOrder"] = str(order.ioc_order).lower()
-        self.payload["body"]["IsIntraday"] = str(order.is_intraday).lower()
-        self.payload["body"]["PublicIP"] = order.public_ip
-        self.payload["body"]["AHPlaced"] = order.ahplaced
-        # Passing the next day's UNIX timestamp
-        self.payload["body"]["ValidTillDate"] = f"/Date({NEXT_DAY_TIMESTAMP})/"
-        self.payload["body"]["TradedQty"] = order.traded_qty
-        self.payload["body"]["OrderRequesterCode"] = self.client_code
-        self.payload["body"]["AppSource"] = APP_SOURCE
-        self.payload["body"]["iOrderValidity"] = order.order_validity
-
-    def place_order(self, order: Order):
+                # self.payload["head"]["requestCode"] = "5PSMOOrd"
+                # self.payload["body"]["OrderRequesterCode"]=self.client_code
+            elif req_type == "BC":
+                url = self.BRACKET_CANCEL_ROUTE
+            elif req_type == "CC":
+                url = self.COVER_CANCEL_ROUTE
+            elif req_type == "MD":
+                url = self.MARKET_DEPTH_ROUTE
+                # self.payload["head"]["requestCode"] = "5PMD"
+            elif req_type == "MDS":
+                url = self.MARKET_DEPTH_BY_SYMBOL_ROUTE
+                # self.payload["head"]["requestCode"] = "5PMD"
+            elif req_type == "MDSC":
+                url = self.MARKET_DEPTH_BY_SCRIP
+                # self.payload["head"]["requestCode"] = "5PMD"
+            elif req_type == "TB":
+                url = self.TRADEBOOK_ROUTE
+                # self.payload["head"]["requestCode"] = "5PTrdBkV1"
+            elif req_type == "GB":
+                url = self.GET_BASKET_ROUTE
+            elif req_type == "CB":
+                url = self.CREATE_BASKET_ROUTE
+            elif req_type == "RB":
+                url = self.RENAME_BASKET_ROUTE
+            elif req_type == "DB":
+                url = self.DELETE_BASKET_ROUTE
+            elif req_type == "CL":
+                url = self.CLONE_BASKET_ROUTE
+            elif req_type == "EB":
+                url = self.EXECUTE_BASKET_ROUTE
+            elif req_type == "GO":
+                url = self.GET_ORDER_IN_BASKET_ROUTE
+            elif req_type == "AB":
+                url = self.ADD_BASKET_ORDER_ROUTE
+            elif req_type == "GE":
+                url = self.OPTION_CHAIN_ROUTE
+            elif req_type == "GOC":
+                url = self.GET_OPTION_CHAIN_ROUTE
+            elif req_type == "CBO":
+                url = self.CANCEL_BULK_ORDER_ROUTE
+            elif req_type == "SO":
+                url = self.SQUAREOFF_ROUTE
+            elif req_type == "PO":
+                url = self.POSITION_CONVERSION_ROUTE
+            elif req_type == "OMC":
+                url = self.ORDERMARGIN_ROUTE
+                if self.access_token != "":
+                    HEADERS["Authorization"] = f'Bearer {self.Jwt_token}'
+            elif req_type == "VTT":
+                url = self.ADDVTTORDER_ROUTE
+            elif req_type == "MVTT":
+                url = self.MODVTTORDER_ROUTE
+            elif req_type == "CVTT":
+                url = self.CALVTTORDER_ROUTE
+            elif req_type == "GVTT":
+                url = self.GETVTTORDER_ROUTE
+            elif req_type == "HVTT":
+                url = self.HISVTTORDER_ROUTE
+            elif req_type == "BMC":
+                url = self.BASKETMARGIN_ROUTE
+            elif req_type == "BLKO":
+                url = self.PLACEORDERBULK_ROUTE
+                self.payload["body"]["AppSource"]=self.APP_SOURCE
+            elif req_type == "NETPOS":
+                url = self.NETPOSITION_ROUTE 
+            elif req_type == "MFS":
+                url = self.MARKETSNAPSHOT_ROUTE 
+            elif req_type == "TR":
+                url = self.TAXREPORT_ROUTE
+            elif req_type == "LR":
+                url = self.LEDGERREPORT_ROUTE
+            elif req_type == 'MOM':
+                url = self.MULTIORDERMARGIN_ROUTE
+            else:
+                raise Exception("Invalid request type!")
+            res = httpx.post(url, json=self.payload,
+                                    headers=HEADERS,verify=False).json()
+            self.payload = GENERIC_PAYLOAD
+
+            if req_type == "MS":
+                log_response(res["head"]["statusDescription"])
+            elif req_type == "TR" or req_type == "LR":
+                return res
+            else:
+                log_response(res["body"]["Message"])
+            return res["body"]
+
+        except Exception as e:
+            log_response(e)
+
+    def fetch_order_status(self, req_list: list):
+        try:
+            self.payload["body"]["OrdStatusReqList"] = req_list
+            return self.order_request("OS")
+        except Exception as e:
+            log_response(e)
+
+    def fetch_trade_info(self, req_list: list):
+        try:
+            self.payload["body"]["TradeInformationList"] = req_list
+            return self.order_request("TI")
+        except Exception as e:
+            log_response(e)
+
+    def fetch_market_depth(self, req_list: list):
+        try:
+            self.payload["body"]["Count"] = "1"
+            self.payload["body"]["MarketDepthData"] = req_list
+
+            return self.order_request("MD")
+        except Exception as e:
+            log_response(e)
+
+    def fetch_market_depth_by_symbol(self, req_list: list):
+        try:
+            self.payload["body"]["Count"] = "1"
+            self.payload["body"]["Data"] = req_list
+
+            return self.order_request("MDS")
+        except Exception as e:
+            log_response(e)
+
+    def fetch_market_depth_by_scrip(self, **param):
+        try:
+            self.payload["body"]["ClientCode"] = self.client_code
+            self.set_payload(param)
+            return self.order_request("MDSC")
+        except Exception as e:
+            log_response(e)
+
+    def fetch_market_feed(self, req_list: list):
+        """
+            market feed api
+        """
+        try:
+            self.payload["body"]["MarketFeedData"] = req_list
+            self.payload["body"]["ClientLoginType"] = 0
+            self.payload["body"]["LastRequestTime"] = f"/Date({TODAY_TIMESTAMP})/"
+            self.payload["body"]["RefreshRate"] = "H"
+            return self.order_request("MF")
+        except Exception as e:
+            log_response(e)
+
+    def fetch_market_feed_scrip(self, req_list: list):
+        """
+            market feed api
+        """
+        try:
+            self.payload["body"]["MarketFeedData"] = req_list
+            self.payload["body"]["ClientLoginType"] = 0
+            self.payload["body"]["LastRequestTime"] = f"/Date({TODAY_TIMESTAMP})/"
+            self.payload["body"]["RefreshRate"] = "H"
+            return self.order_request("MF1")
+        except Exception as e:
+            log_response(e)
+
+    def set_payload(self, order) -> None:
+        try:
+            for key, value in order.items():
+                self.payload["body"][key] = value
+        except Exception as e:
+            log_response(e)
+
+    def set_payload_bo(self, boco) -> None:
+        """
+            this is for bo-co order placement
+        """
+        try:
+            self.payload["body"]["RequestType"] = boco.RequestType
+            self.payload["body"]["BuySell"] = boco.BuySell
+            self.payload["body"]["Qty"] = boco.Qty
+            self.payload["body"]["Exch"] = boco.Exch
+            self.payload["body"]["ExchType"] = boco.ExchType
+            self.payload["body"]["DisQty"] = boco.DisQty
+            self.payload["body"]["AtMarket"] = boco.AtMarket
+            self.payload["body"]["ExchOrderId"] = boco.ExchOrderId
+            self.payload["body"]["LimitPriceForSL"] = boco.LimitPriceForSL
+            self.payload["body"]["LimitPriceInitialOrder"] = boco.LimitPriceInitialOrder
+            self.payload["body"]["TriggerPriceInitialOrder"] = boco.TriggerPriceInitialOrder
+            self.payload["body"]["LimitPriceProfitOrder"] = boco.LimitPriceProfitOrder
+            self.payload["body"]["TriggerPriceForSL"] = boco.TriggerPriceForSL
+            self.payload["body"]["TrailingSL"] = boco.TrailingSL
+            self.payload["body"]["StopLoss"] = boco.StopLoss
+            self.payload["body"]["ScripCode"] = boco.scrip_code
+            self.payload["body"]["OrderFor"] = boco.order_for
+            self.payload["body"]["UniqueOrderIDNormal"] = boco.UniqueOrderIDNormal
+            self.payload["body"]["UniqueOrderIDSL"] = boco.UniqueOrderIDSL
+            self.payload["body"]["UniqueOrderIDLimit"] = boco.UniqueOrderIDLimit
+            self.payload["body"]["LocalOrderIDNormal"] = boco.LocalOrderIDNormal
+            self.payload["body"]["LocalOrderIDSL"] = boco.LocalOrderIDSL
+            self.payload["body"]["LocalOrderIDLimit"] = boco.LocalOrderIDLimit
+            self.payload["body"]["PublicIP"] = boco.public_ip
+            self.payload["body"]["AppSource"] = self.APP_SOURCE
+            self.payload["body"]["TradedQty"] = boco.traded_qty
+        except Exception as e:
+            log_response(e)
+
+    def set_basket_payload(self, basket_order: Basket_order, basket_list: list) -> None:
+        """
+            this is for Basket order placement
+        """
+        try:
+            self.payload["body"]["Exchange"] = basket_order.Exchange
+            self.payload["body"]["ExchangeType"] = basket_order.ExchangeType
+            self.payload["body"]["Price"] = basket_order.Price
+            self.payload["body"]["OrderType"] = basket_order.OrderType
+            self.payload["body"]["Qty"] = basket_order.Qty
+            self.payload["body"]["ScripCode"] = basket_order.ScripCode
+            self.payload["body"]["AtMarket"] = basket_order.AtMarket
+            self.payload["body"]["StopLossPrice"] = basket_order.StopLossPrice
+            self.payload["body"]["IsStopLossOrder"] = basket_order.IsStopLossOrder
+            self.payload["body"]["IOCOrder"] = basket_order.IOCOrder
+            self.payload["body"]["DelvIntra"] = basket_order.DelvIntra
+            self.payload["body"]["AppSource"] = self.APP_SOURCE
+            self.payload["body"]["IsIntraday"] = basket_order.IsIntraday
+            self.payload["body"]["ValidTillDate"] = f"/Date({NEXT_DAY_TIMESTAMP})/"
+            self.payload["body"]["AHPlaced"] = basket_order.AHPlaced
+            self.payload["body"]["PublicIP"] = basket_order.PublicIP
+            self.payload["body"]["DisQty"] = basket_order.DisQty
+            self.payload["body"]["iOrderValidity"] = basket_order.iOrderValidity
+            self.payload["body"]["BasketIDs"] = basket_list
+        except Exception as e:
+            log_response(e)
+
+    def place_order(self, **order):
         """
         Places a fresh order
         """
-        self.set_payload(order)
-        return self.order_request("OP")
+        order_list = ['ScripData','ScripCode']
+        try:
+            if (order['Price'] >= 0  and order['Exchange'] and order['OrderType'] and order['Qty'] and order['ExchangeType']):
+                if (order_list[0] in order) or (order_list[1] in order) :
+                    self.set_payload(order)
+                    return self.order_request("OP")
+                else :
+                     return log_response("please enter valid input")
+            else:
+                return log_response("please enter valid input")
+
+        except Exception as e:
+            log_response(e)
 
-    def modify_order(self, exch_order_id: str, traded_qty: int, scrip_code: int):
+    def modify_order(self, **order):
         """
         Modifies an existing order
-        Only exch_order_id, traded_qty and scrip_code makes sense here.
         """
-        order = Order(order_type=OrderType.BUY, scrip_code=scrip_code,
-                      quantity=0, order_for=OrderFor.MODIFY, exch_order_id=exch_order_id, traded_qty=traded_qty)
-        self.set_payload(order)
-        return self.order_request("OP")
+        try:
+            if (order['Price'] >= 0 and order['ExchOrderID']):
+                self.set_payload(order)
+                return self.order_request("OM")
+        except Exception as e:
+            log_response(e)
 
-    def cancel_order(self, exch_order_id: str, traded_qty: int, scrip_code: int):
+    def cancel_order(self, exch_order_id: str):
         """
         Cancels an existing order
         """
-        order = Order(order_type=OrderType.BUY, scrip_code=scrip_code,
-                      quantity=0, order_for=OrderFor.CANCEL, exch_order_id=exch_order_id, traded_qty=traded_qty)
-        self.set_payload(order)
-        return self.order_request("OP")
+        try:
+            self.payload["body"]["ExchOrderID"] = exch_order_id
+            return self.order_request("OC")
+        except Exception as e:
+            log_response(e)
+
+    def bo_order(self, **order):
+        try:
+            if (order["ScripCode"] and order['Exchange'] and order['OrderType'] and order['Qty'] and order['ExchangeType']):
+                self.set_payload(order)
+                return self.order_request("BO")
+        except Exception as e:
+            log_response(e)
+
+    def modify_bo_order(self, **order):
+        try:
+            if (order['ExchangeOrderID']):
+                self.set_payload(order)
+                # self.payload["body"]["TriggerPriceForSL"] = order.stoploss_price
+                return self.order_request("BM")
+        except Exception as e:
+            log_response(e)
+
+    def cancel_bo_order(self, **order):
+        try:
+            if (order['ExchangeOrderID']):
+                self.set_payload(order)
+                # self.payload["body"]["TriggerPriceForSL"] = order.stoploss_price
+                return self.order_request("BC")
+        except Exception as e:
+            log_response(e)
+
+    def cover_order(self, **order):
+        try:
+            self.set_payload(order)
+            # self.payload["body"]["TriggerPriceForSL"] = order.stoploss_price
+            return self.order_request("CO")
+        except Exception as e:
+            log_response(e)
+
+    def modify_cover_order(self, **order):
+        try:
+            self.set_payload(order)
+            # self.payload["body"]["TriggerPriceForSL"] = order.stoploss_price
+            return self.order_request("CM")
+        except Exception as e:
+            log_response(e)
+
+    def cancel_cover_order(self, **order):
+        try:
+            self.set_payload(order)
+            # self.payload["body"]["TriggerPriceForSL"] = order.stoploss_price
+            return self.order_request("CC")
+        except Exception as e:
+            log_response(e)
+
+    def Request_Feed(self, Method: str, Operation: str, req_list: list):
+        try:
+            Method_dict = {"mf": "MarketFeedV3", "md": "MarketDepthService",
+                           "oi": "GetScripInfoForFuture", "i": "Indices"}
+            Operation_dict = {"s": "Subscribe", "u": "Unsubscribe"}
+
+            self.ws_payload['Method'] = Method_dict[Method]
+            self.ws_payload['Operation'] = Operation_dict[Operation]
+            self.ws_payload['ClientCode'] = self.client_code
+            self.ws_payload['MarketFeedData'] = req_list
+            return self.ws_payload
+        except Exception as e:
+            log_response(e)
+
+    def connect(self, wspayload: dict):
+        try:
+            if self.is_blank_or_none(self.WEBSOCKET_URL):
+                self.WEBSOCKET_URL=self.decode_token(self.Jwt_token)
+
+            self.web_url = f'{self.WEBSOCKET_URL}{self.Jwt_token}|{self.client_code}'
+
+            def on_open(ws):
+                log_response("Streaming Started")
+                try:
+                    ws.send(json.dumps(wspayload))
+                except Exception as e:
+                    log_response(e)
+            self.ws = websocket.WebSocketApp(self.web_url)
+
+            self.ws.on_open = on_open
+        except Exception as e:
+            log_response(e)
+            
+    def is_blank_or_none(self, value):
+        return value is None or value == "" or not value
+        
+    def send_data(self, open_: any):
+        try:
+            self.ws.on_open = open_
+        except Exception as e:
+            log_response(e)
+
+    def receive_data(self, msg: any):
+        try:
+            self.ws.on_message = msg
+            self.ws.run_forever()
+        except Exception as e:
+            log_response(e)
+
+    def close_data(self):
+        try:
+            self.ws.close()
+        except Exception as e:
+            log_response(e)
+
+    def error_data(self, err: any):
+        try:
+            self.ws.on_error = err
+        except Exception as e:
+            log_response(e)
+
+    def Login_check(self):
+        try:
+            self.login_check_payload["head"]["key"] = self.USER_KEY
+            self.login_check_payload["head"]["appName"] = self.APP_NAME
+            self.login_check_payload["head"]["LoginId"] = self.client_code
+            self.login_check_payload["body"]["RegistrationID"] = self.Jwt_token
+            HEADERS["5Paisa-API-Uid"] = self.APIUID
+            url = self.LOGIN_CHECK_ROUTE
+            resl = requests.post(
+                url, json=self.login_check_payload, headers=HEADERS)
+            self.Aspx_auth = resl.cookies.get(
+                '.ASPXAUTH', domain='openfeed.5paisa.com')
+
+            return f'.ASPXAUTH={self.Aspx_auth}'
+        except Exception as e:
+            log_response(e)
+
+    def jwt_validate(self):
+        try:
+            self.jwt_payload['ClientCode'] = self.client_code
+            self.jwt_payload['JwtCode'] = self.Jwt_token
+            HEADERS["5Paisa-API-Uid"] = self.APIUID
+            url = self.JWT_VALIDATION_ROUTE
+            response = self.session.post(
+                url, json=self.jwt_payload, headers=HEADERS).json()
+
+            return response['body']['Message']
+        except Exception as e:
+            log_response(e)
+
+    def historical_data(self, Exch: str, ExchangeSegment: str, ScripCode: int, time: str, From: str, To: str):
+        try:
+            self.jwt_headers["Authorization"] = f'Bearer {self.access_token}'
+            url = f'{self.HISTORICAL_DATA_ROUTE}{Exch}/{ExchangeSegment}/{ScripCode}/{time}?from={From}&end={To}'
+            timeList = ['1m', '3m', '5m', '10m', '15m', '30m', '60m', '1d']
+            if time not in timeList:
+                return 'Invalid Time Frame. it should be within [1m,5m,10m,15m,30m,60m,1d].'
+            else:
+                response = self.session.get(
+                    url, headers=self.jwt_headers).json()
+                candleList = response['data']['candles']
+                df = pd.DataFrame(candleList)
+                if df.empty != True:
+                    df.columns = ['Datetime', 'Open',
+                                  'High', 'Low', 'Close', 'Volume']
+                return df
+
+        except Exception as e:
+            log_response(e)
+
+    def get_buy(self):
+        try:
+            res = self._user_info_request("IB")
+            if len(res) > 0:
+                message = res[0]["payload"]
+                res1 = json.loads(message)
+                with pd.option_context('display.max_columns', None, 'display.max_rows', None):
+                    df = pd.DataFrame(res1)
+                return df
+            else:
+                message = "You don't have an active Ultra-Trader-Pack. Please subscribe to it to avail the services."
+                return message
+        except Exception as e:
+            log_response(e)
+
+    def get_trade(self):
+        try:
+            res = self._user_info_request("IT")
+            if len(res) > 0:
+                message = res[1]["payload"]
+                res1 = json.loads(message)
+                with pd.option_context('display.max_columns', None, 'display.max_rows', None):
+                    df = pd.DataFrame(res1)
+                return df
+            else:
+                message = "You don't have an active Ultra-Trader-Pack. Please subscribe to it to avail the services."
+                return message
+        except Exception as e:
+            log_response(e)
+
+    def get_tradebook(self):
+        try:
+            return self.order_request("TB")
+        except Exception as e:
+            log_response(e)
+
+    def set_url(self):
+        try:
+            self.SCRIP_MASTER_ROUTE = SCRIP_MASTER_ROUTE
+            self.LOGIN_ROUTE = LOGIN_ROUTE
+            self.MARGIN_ROUTE = MARGIN_ROUTE
+            self.ORDER_BOOK_ROUTE = ORDER_BOOK_ROUTE
+            self.HOLDINGS_ROUTE = HOLDINGS_ROUTE
+            self.POSITIONS_ROUTE = POSITIONS_ROUTE
+            self.ORDER_PLACEMENT_ROUTE = ORDER_PLACEMENT_ROUTE
+            self.ORDER_MODIFY_ROUTE = ORDER_MODIFY_ROUTE
+            self.ORDER_CANCEL_ROUTE = ORDER_CANCEL_ROUTE
+            self.ORDER_STATUS_ROUTE = ORDER_STATUS_ROUTE
+            self.TRADE_INFO_ROUTE = TRADE_INFO_ROUTE
+            self.BRACKET_MOD_ROUTE = BRACKET_MOD_ROUTE
+            self.BRACKET_ORDER_ROUTE = BRACKET_ORDER_ROUTE
+            self.BRACKET_CANCEL_ROUTE = BRACKET_CANCEL_ROUTE
+            self.COVER_MOD_ROUTE = COVER_MOD_ROUTE
+            self.COVER_ORDER_ROUTE = COVER_ORDER_ROUTE
+            self.COVER_CANCEL_ROUTE = COVER_CANCEL_ROUTE
+            self.MARKET_FEED_ROUTE = MARKET_FEED_ROUTE
+            self.MARKET_FEED_ROUTE_BY_SCRIP = MARKET_FEED_ROUTE_BY_SCRIP
+            self.LOGIN_CHECK_ROUTE = LOGIN_CHECK_ROUTE
+            self.MARKET_DEPTH_ROUTE = MARKET_DEPTH_ROUTE
+            self.JWT_VALIDATION_ROUTE = JWT_VALIDATION_ROUTE
+            self.HISTORICAL_DATA_ROUTE = HISTORICAL_DATA_ROUTE
+            self.IDEAS_ROUTE = IDEAS_ROUTE
+            self.TRADEBOOK_ROUTE = TRADEBOOK_ROUTE
+            self.ACCESS_TOKEN_ROUTE = ACCESS_TOKEN_ROUTE
+            self.GET_REQUEST_TOKEN_ROUTE = GET_REQUEST_TOKEN_ROUTE
+            self.MARKET_STATUS_ROUTE = MARKET_STATUS_ROUTE
+            self.TRADE_HISTORY_ROUTE = TRADE_HISTORY_ROUTE
+            self.GET_BASKET_ROUTE = GET_BASKET_ROUTE
+            self.CREATE_BASKET_ROUTE = CREATE_BASKET_ROUTE
+            self.RENAME_BASKET_ROUTE = RENAME_BASKET_ROUTE
+            self.DELETE_BASKET_ROUTE = DELETE_BASKET_ROUTE
+            self.CLONE_BASKET_ROUTE = CLONE_BASKET_ROUTE
+            self.EXECUTE_BASKET_ROUTE = EXECUTE_BASKET_ROUTE
+            self.GET_ORDER_IN_BASKET_ROUTE = GET_ORDER_IN_BASKET_ROUTE
+            self.ADD_BASKET_ORDER_ROUTE = ADD_BASKET_ORDER_ROUTE
+            self.OPTION_CHAIN_ROUTE = OPTION_CHAIN_ROUTE
+            self.GET_OPTION_CHAIN_ROUTE = GET_OPTION_CHAIN_ROUTE
+            self.CANCEL_BULK_ORDER_ROUTE = CANCEL_BULK_ORDER_ROUTE
+            self.SQUAREOFF_ROUTE = SQUAREOFF_ROUTE
+            self.MARKET_DEPTH_ROUTE_20 = MARKET_DEPTH_ROUTE_20
+            self.POSITION_CONVERSION_ROUTE = POSITION_CONVERSION_ROUTE
+            self.MARKET_DEPTH_BY_SYMBOL_ROUTE = MARKET_DEPTH_BY_SYMBOL_ROUTE
+            self.MARKET_DEPTH_BY_SCRIP = MARKET_DEPTH_BY_SCRIP
+            self.ADDVTTORDER_ROUTE = ADDVTTORDER_ROUTE
+            self.CALVTTORDER_ROUTE = CALVTTORDER_ROUTE
+            self.MODVTTORDER_ROUTE = MODVTTORDER_ROUTE
+            self.GETVTTORDER_ROUTE = GETVTTORDER_ROUTE
+            self.HISVTTORDER_ROUTE = HISVTTORDER_ROUTE
+            self.BASKETMARGIN_ROUTE = BASKETMARGIN_ROUTE
+            self.PLACEORDERBULK_ROUTE = PLACEORDERBULK_ROUTE
+            self.NETPOSITION_ROUTE = NETPOSITION_ROUTE
+            self.MARKETSNAPSHOT_ROUTE = MARKETSNAPSHOT_ROUTE
+            self.TAXREPORT_ROUTE = TAXREPORT_ROUTE
+            self.LEDGERREPORT_ROUTE = LEDGERREPORT_ROUTE
+            self.MULTIORDERMARGIN_ROUTE = MULTIORDERMARGIN_ROUTE
+        except Exception as e:
+            log_response(e)
+
+    def create_payload(self):
+        try:
+            self.payload = GENERIC_PAYLOAD
+            self.login_payload = LOGIN_PAYLOAD
+            self.login_check_payload = LOGIN_CHECK_PAYLOAD
+            self.ws_payload = WS_PAYLOAD
+            self.jwt_headers = JWT_HEADERS
+            self.jwt_payload = JWT_PAYLOAD
+            self.SOCKET_DEPTH_PAYLOAD = SOCKET_DEPTH_PAYLOAD
+            self.ORDERMARGIN_ROUTE = ORDERMARGIN_ROUTE
+        except Exception as e:
+            log_response(e)
+
+    def get_oauth_session(self, request_token):
+        try:
+            return self.get_access_token(request_token)
+        except Exception as e:
+            log_response(e)
+
+    def get_access_token(self, request_token=None):
+        try:
+            if request_token is None:
+                if self.access_token != "":
+                    return self.access_token
+                else:
+                    log_response("Please login first")
+            else:
+                self.payload["head"]["Key"] = self.USER_KEY
+                self.payload["body"]["RequestToken"] = request_token
+                self.payload["body"]["EncryKey"] = self.ENCRYPTION_KEY
+                self.payload["body"]["UserId"] = self.USER_ID
+                url = ACCESS_TOKEN_ROUTE
+
+                res = self.session.post(url, json=self.payload).json()
+                self.payload = GENERIC_PAYLOAD
+                message = res["body"]["Message"]
+
+                if message == "Success":
+                    self.access_token = res["body"]["AccessToken"]
+                    self.Jwt_token = self.access_token
+                    self._set_client_code(res["body"]["ClientCode"])
+                    log_response("Logged in!!")
+                    return self.access_token
+                else:
+                    log_response(message)
+        except Exception as e:
+            log_response(e)
+
+    def get_request_token(self, client_code, totp, pin):
+        try:
+            self.payload["head"]["Key"] = self.USER_KEY
+            self.payload["body"]["Email_ID"] = client_code
+            self.payload["body"]["TOTP"] = totp
+            self.payload["body"]["PIN"] = pin
+            url = GET_REQUEST_TOKEN_ROUTE
+
+            res = self.session.post(url, json=self.payload).json()
+            self.payload = GENERIC_PAYLOAD
+            message = res["body"]["Status"]
+
+            if message == 0:
+                self.request_token = res["body"]["RequestToken"]
+                log_response("RequestToken: " + self.request_token)
+                return self.request_token
+            else:
+                log_response(res["body"])
+        except Exception as e:
+            log_response(e)
+
+    def get_totp_session(self, client_code, totp, pin):
+        try:
+            self.get_request_token(client_code, totp, pin)
+            if self.request_token is not None:
+                return self.get_oauth_session(self.request_token)
+        except Exception as e:
+            log_response(e)
+
+    def get_market_status(self):
+        try:
+            market_status_response = self.order_request("MS")
+            return market_status_response["Data"]
+        except Exception as e:
+            log_response(e)
+
+    def get_trade_history(self, exchange_id):
+        try:
+            self.payload["body"]["ExchOrderID"] = exchange_id
+            if self.client_code != None:
+                return self.order_request("TH")
+        except Exception as e:
+            log_response(e)
+
+    def get_basket(self):
+        try:
+            if self.client_code != None:
+                # self.payload["body"]["ClientCode"] = self.client_code
+                return self.order_request("GB")
+        except Exception as e:
+            log_response(e)
+
+    def create_basket(self, basket_name: str):
+        try:
+            if self.client_code != None:
+                self.payload["body"]["BasketName"] = basket_name
+                return self.order_request("CB")
+        except Exception as e:
+            log_response(e)
+
+    def rename_basket(self, basket_name: str, basket_id: int):
+        try:
+            if self.client_code != None:
+                self.payload["body"]["NewBasketName"] = basket_name
+                self.payload["body"]["BasketID"] = basket_id
+                return self.order_request("RB")
+        except Exception as e:
+            log_response(e)
+
+    def delete_basket(self, basket_id: list):
+        try:
+            if self.client_code != None:
+                self.payload["body"]["BasketIDs"] = basket_id
+                return self.order_request("DB")
+        except Exception as e:
+            log_response(e)
+
+    def clone_basket(self, basket_id: int):
+        try:
+            if self.client_code != None:
+                self.payload["body"]["BasketID"] = basket_id
+                return self.order_request("CL")
+        except Exception as e:
+            log_response(e)
+
+    def execute_basket(self, basket_id: int):
+        try:
+            if self.client_code != None:
+                self.payload["body"]["BasketID"] = basket_id
+                return self.order_request("EB")
+        except Exception as e:
+            log_response(e)
+
+    def get_order_in_basket(self, basket_id: int):
+        try:
+            if self.client_code != None:
+                self.payload["body"]["BasketID"] = basket_id
+                return self.order_request("GO")
+        except Exception as e:
+            log_response(e)
+
+    def add_basket_order(self, basket_order: Basket_order, basket_list: list):
+        try:
+            if self.client_code != None:
+                self.set_basket_payload(basket_order, basket_list)
+                return self.order_request("AB")
+        except Exception as e:
+            log_response(e)
+
+    def get_expiry(self, exch: str, symbol: str):
+        try:
+            self.payload["body"]["Exch"] = exch
+            self.payload["body"]["Symbol"] = symbol
+            return self.order_request("GE")
+        except Exception as e:
+            log_response(e)
+
+    def get_option_chain(self, exch: str, symbol: str, expire: int):
+        try:
+            self.payload["body"]["Exch"] = exch
+            self.payload["body"]["Symbol"] = symbol
+            self.payload["body"]["ExpiryDate"] = f"/Date({expire})/"
+            return self.order_request("GOC")
+        except Exception as e:
+            log_response(e)
+
+    def cancel_bulk_order(self, ExchOrderIDs: list):
+        try:
+            if self.client_code != None:
+                self.payload["body"]["ExchOrderIDs"] = ExchOrderIDs
+            return self.order_request("CBO")
+        except Exception as e:
+            log_response(e)
+
+    def squareoff_all(self):
+        try:
+            if self.client_code != None:
+                return self.order_request("SO")
+        except Exception as e:
+            log_response(e)
+
+    def position_convertion(self, Exch: str, ExchType: str, ScripData: str, TradeType: str, ConvertQty: int,ConvertFrom: str, ConvertTo: str):
+        try:
+            if self.client_code != None:
+                self.payload["body"]["Exch"] = Exch
+                self.payload["body"]["ExchType"] = ExchType
+                self.payload["body"]["ScripData"] = ScripData
+                self.payload["body"]["TradeType"] = TradeType
+                self.payload["body"]["ConvertQty"] = ConvertQty
+                self.payload["body"]["ConvertFrom"] = ConvertFrom
+                self.payload["body"]["ConvertTo"] = ConvertTo
+                return self.order_request("PO")
+        except Exception as e:
+            log_response(e)
+
+    def socket_20_depth(self, socket_payload: dict):
+        try:
+            self.token = self.market_depth_token()
+            """
+            self.SOCKET_DEPTH_PAYLOAD["operation"]=operation
+            self.SOCKET_DEPTH_PAYLOAD["method"]=method
+            self.SOCKET_DEPTH_PAYLOAD["instruments"]=instruments
+            """
+            self.subscription_key = SUBSCRIPTION_KEY
+
+            self.market_depth_url = f'wss://gateway.5paisa.com/ws?subscription-key={self.subscription_key}&access_token={self.token}'
+
+            def on_open(ws):
+
+                try:
+                    ws.send(json.dumps(socket_payload))
+                except Exception as e:
+                    log_response(e)
+
+            self.ws = websocket.WebSocketApp(
+                self.market_depth_url, on_open=on_open)
+            # self.ws.run_forever()
+        except Exception as e:
+            log_response(e)
+
+    def market_depth_token(self):
+        try:
+            response = self.session.post(
+                self.MARKET_DEPTH_ROUTE_20, headers=self.jwt_headers).json()
+            return response["access_token"]
+        except Exception as e:
+            log_response(e)
+
+
+    def Order_margin(self,**order):
+        try:
+
+            if (order['AtMarket'] == 'Y' and order['LimitRate'] != 0 ):
+                log_response('Price must be 0')
+            elif (order['AtMarket'] == 'N' and order['LimitRate'] > 0 ):
+                log_response('Price should not be 0')
+                
+               
+            self.set_payload(order)
+            return self.order_request("OMC")
+        except Exception as e:
+            log_response(e)
+
+    def vtt_order(self, order_type, **order):
+        try:
+            self.set_payload(order)
+            order_type_str = self.VTT_TYPE[order_type].value
+            return self.order_request(order_type_str)
+        except KeyError:
+            # Handle unknown order_type if needed
+            pass
+        except Exception as e:
+            log_response(e)
+
+    def basket_margin(self, BasketID: str,CoverPositions : str):
+        try:
+            if self.client_code != None:
+                self.payload["body"]["BasketID"] = BasketID
+                self.payload["body"]["CoverPositions"] = CoverPositions
+            return self.order_request("BMC")
+        except Exception as e:
+            log_response(e)
+
+    def place_order_bulk(self, **order):
+        try:
+            self.set_payload(order)
+            return self.order_request('BLKO')
+        except KeyError:
+            # Handle unknown order_type if needed
+            pass
+        except Exception as e:
+            log_response(e)
+
+    def decode_token(self,token):
+        try:
+            decoded = jwt.decode(token, options={"verify_signature": False}) 
+            #decoded_token = jwt.decode(token)
+            url=self.get_feed_url(decoded['RedirectServer'])
+            return url
+        except jwt.InvalidTokenError:
+            log_response("Invalid token")
+
+    def get_feed_url(self,redirect_server):
+        if redirect_server == "A":
+            return "wss://aopenfeed.5paisa.com/feeds/api/chat?Value1="
+        elif redirect_server == "B":
+            return "wss://bopenfeed.5paisa.com/feeds/api/chat?Value1="
+        elif redirect_server == "C":
+            return "wss://openfeed.5paisa.com/feeds/api/chat?Value1="
+        else:
+            return "wss://openfeed.5paisa.com/Feeds/api/chat?Value1="
+        
+
+    def set_access_token(self,accessToken,clientCode):
+        self.access_token=accessToken
+        self.client_code=clientCode
+        self.Jwt_token = self.access_token
+
+
+    def positions_day(self):
+        try:
+            return self.order_request("NETPOS")
+        except Exception as e:
+            log_response(e)
+
+    def fetch_market_snapshot(self,reqList):
+        try:
+            self.payload["body"]["Data"] = reqList
+            return self.order_request("MFS")
+        except Exception as e:
+            log_response(e)
+
+    def tax_report(self, from_date: str, to_date: str):
+        try:
+            # Ensure the date format is in 'YYYY-MM-DD'
+            date_format = "%Y-%m-%d"
+            try:
+                from_date_obj = datetime.strptime(from_date, date_format)
+                to_date_obj = datetime.strptime(to_date, date_format)
+            except ValueError:
+                return ValueError("Dates must be in the format 'YYYY-MM-DD'.")
+
+            # Ensure the from_date is less than or equal to the to_date
+            if from_date_obj > to_date_obj:
+                return ValueError("From date must be earlier than or equal to To date.")
+
+            # Assign the dates to the payload
+            self.payload["body"]["FromDate"] = from_date
+            self.payload["body"]["ToDate"] = to_date
+
+            # Call the dynamic order request function with the appropriate request type
+            return self.order_request("TR")
+        except Exception as e:
+            log_response(e)
+    
+    def fetch_ledger(self, from_date: str, to_date: str):
+        try:
+            # Ensure the date format is in 'YYYY-MM-DD'
+            date_format = "%Y-%m-%d"
+            try:
+                from_date_obj = datetime.strptime(from_date, date_format)
+                to_date_obj = datetime.strptime(to_date, date_format)
+            except ValueError:
+                return ValueError("Dates must be in the format 'YYYY-MM-DD'.")
+
+            # Ensure the from_date is less than or equal to the to_date
+            if from_date_obj > to_date_obj:
+                return ValueError("From date must be earlier than or equal to To date.")
+
+            # Assign the dates to the payload
+            self.payload["body"]["FromDate"] = from_date
+            self.payload["body"]["ToDate"] = to_date
+
+            return self.order_request("LR")
+    
+        except Exception as e:
+            log_response(e)
+
+    def multi_order_Margin(self, **order):
+        try:
+            self.set_payload(order)
+            return self.order_request("MOM")
+        except Exception as e:
+            log_response(e)
\ No newline at end of file
diff --git a/py5paisa/strategy.py b/py5paisa/strategy.py
new file mode 100644
index 00000000..7fbbed76
--- /dev/null
+++ b/py5paisa/strategy.py
@@ -0,0 +1,313 @@
+from py5paisa import FivePaisaClient
+from py5paisa.order import Order,Bo_co_order
+import json
+
+
+class strategies:
+
+    def __init__(self, client_code=None, totp=None, pin=None, cred=None, request_token=None):
+        self.Client = FivePaisaClient(cred=cred)
+        if request_token is None:
+            self.Client.get_totp_session(client_code,totp,pin)
+        else:
+            self.Client.get_access_token(request_token)
+
+    def get_scripcode(self,symbol,strike,expiry,opt):
+        month={
+            "01":'JAN',
+            "02":'FEB',
+            "03":'MAR',
+            "04":'APR',
+            "05":'MAY',
+            "06":'JUN',
+            "07":'JUL',
+            "08":'AUG',
+            "09":'SEP',
+            "10":'OCT',
+            "11":'NOV',
+            "12":'DEC'      
+        }
+        date=expiry[6:]
+        mon=month[expiry[4:6]]
+        year=expiry[:4]
+        symbol=symbol.upper()
+        strike_f="{:.2f}".format(float(strike))
+        sym=f'{symbol} {date} {mon} {year} {opt} {strike_f}'
+        req=[{"Exch":"N","ExchType":"D","Symbol":sym,"Expiry":expiry,"StrikePrice":strike,"OptionType":opt}]
+
+        res=self.Client.fetch_market_feed(req)
+        token=res['Data'][0]['Token']
+        return token
+    
+    def filter_tag(self ,tag):
+        a=""
+        for char in tag:
+            if char.isalnum():
+                a =a + char
+        return a
+    
+    def opposite(self,type):
+        if type=='B':
+            return 'S'
+        if type=='S':
+            return 'B'
+
+    def intraday(self,intra):
+        if intra=='I':
+            return True
+        else:
+            return False
+
+    def short_straddle(self,symbol,strike,qty,expiry,intra,*args, **kwargs):
+        self.symbol=symbol
+        self.strike=strike
+        self.qty=qty
+        self.expiry=expiry
+        self.intra=intra
+        self.tag=kwargs.get('tag', None)
+        self.tag=self.filter_tag(self.tag)
+        scrip=[]
+        options =['CE','PE']
+        for opt in options:
+            sc=self.get_scripcode(self.symbol,self.strike,self.expiry,opt)
+            scrip.append(sc)
+         
+        for s in scrip:
+            order_status = self.Client.place_order(OrderType='S', Exchange='N', ExchangeType='D', ScripCode=s, Qty=qty,
+                                                   Price=0, IsIntraday=self.intraday(self.intra),
+                                                   remote_order_id=self.tag)
+            print(order_status)
+            if order_status['Message']=='Success':
+                continue
+            else:
+                break
+
+    def short_strangle(self,symbol,strike,qty,expiry,intra,*args, **kwargs):
+        strike.sort()
+        self.symbol=symbol
+        self.strike=strike
+        self.qty=qty
+        self.expiry=expiry
+        self.intra=intra
+        self.tag=kwargs.get('tag', None)
+        self.tag=self.filter_tag(self.tag)
+        scrip=[]
+        i=0
+        options =['PE','CE']
+        for opt in options:
+            sc=self.get_scripcode(self.symbol,self.strike[i],self.expiry,opt)
+            i=i+1
+            scrip.append(sc)
+         
+        for s in scrip:
+            order_status = self.Client.place_order(OrderType='S',Exchange='N',ExchangeType='D', ScripCode=s, Qty=qty, Price=0,IsIntraday=self.intraday(self.intra),remote_order_id=self.tag)
+            if order_status['Message']=='Success':
+                continue
+            else:
+                break
+
+    def long_straddle(self,symbol,strike,qty,expiry,intra,*args, **kwargs):
+        self.symbol=symbol
+        self.strike=strike
+        self.qty=qty
+        self.expiry=expiry
+        self.intra=intra
+        self.tag=kwargs.get('tag', None)
+        self.tag=self.filter_tag(self.tag)
+        scrip=[]
+        options =['CE','PE']
+        for opt in options:
+            sc=self.get_scripcode(self.symbol,self.strike,self.expiry,opt)
+            scrip.append(sc)
+         
+        for s in scrip:
+            order_status = self.Client.place_order(OrderType='B', Exchange='N', ExchangeType='D', ScripCode=s, Qty=qty,
+                                                   Price=0, IsIntraday=self.intraday(self.intra),
+                                                   remote_order_id=self.tag)
+            if order_status['Message']=='Success':
+                continue
+            else:
+                break
+
+    def long_strangle(self,symbol,strike,qty,expiry,intra,*args, **kwargs):
+        strike.sort()
+        self.symbol=symbol
+        self.strike=strike
+        self.qty=qty
+        self.expiry=expiry
+        self.intra=intra
+        self.tag=kwargs.get('tag', None)
+        self.tag=self.filter_tag(self.tag)
+        scrip=[]
+        i=0
+        options =['PE','CE']
+        for opt in options:
+            sc=self.get_scripcode(self.symbol,self.strike[i],self.expiry,opt)
+            i=i+1
+            scrip.append(sc)
+         
+        for s in scrip:
+            order_status = self.Client.place_order(OrderType='B', Exchange='N', ExchangeType='D', ScripCode=s, Qty=qty,
+                                                   Price=0, IsIntraday=self.intraday(self.intra),
+                                                   remote_order_id=self.tag)
+            if order_status['Message']=='Success':
+                continue
+            else:
+                break
+    
+    def iron_fly(self,symbol,buy_strike,sell_strike,qty,expiry,intra,*args, **kwargs):
+        buy_strike.sort()
+        self.symbol=symbol
+        self.buy_strike=buy_strike
+        self.sell_strike=sell_strike
+        self.qty=qty
+        self.expiry=expiry
+        self.intra=intra
+        self.tag=kwargs.get('tag', None)
+        self.tag=self.filter_tag(self.tag)
+        buy_scrip=[]
+        sell_scrip=[]
+        i=0
+        options =['PE','CE']
+        for opt in options:
+            sc=self.get_scripcode(self.symbol,self.buy_strike[i],self.expiry,opt)
+            i=i+1
+            buy_scrip.append(sc)
+        for opt in options:
+            sc=self.get_scripcode(self.symbol,self.sell_strike,self.expiry,opt)
+            sell_scrip.append(sc)
+        for s in buy_scrip:
+            order_status = self.Client.place_order(OrderType='B', Exchange='N', ExchangeType='D', ScripCode=s, Qty=qty,
+                                                   Price=0, IsIntraday=self.intraday(self.intra),
+                                                   remote_order_id=self.tag)
+            if order_status['Message']=='Success':
+                continue
+            else:
+                break
+        for s in sell_scrip:
+            order_status = self.Client.place_order(OrderType='S', Exchange='N', ExchangeType='D', ScripCode=s, Qty=qty,
+                                                   Price=0, IsIntraday=self.intraday(self.intra),
+                                                   remote_order_id=self.tag)
+            if order_status['Message']=='Success':
+                continue
+            else:
+                break
+    
+    def iron_condor(self,symbol,buy_strike,sell_strike,qty,expiry,intra,*args, **kwargs):
+        buy_strike.sort()
+        sell_strike.sort()
+        self.symbol=symbol
+        self.buy_strike=buy_strike
+        self.sell_strike=sell_strike
+        self.qty=qty
+        self.expiry=expiry
+        self.intra=intra
+        self.tag=kwargs.get('tag', None)
+        self.tag=self.filter_tag(self.tag)
+        buy_scrip=[]
+        sell_scrip=[]
+        i=0
+        j=0
+        options =['PE','CE']
+        for opt in options:
+            sc=self.get_scripcode(self.symbol,self.buy_strike[i],self.expiry,opt)
+            i=i+1
+            buy_scrip.append(sc)
+        for opt in options:
+            sc=self.get_scripcode(self.symbol,self.sell_strike[j],self.expiry,opt)
+            j=j+1
+            sell_scrip.append(sc)
+        for s in buy_scrip:
+            order_status = self.Client.place_order(OrderType='B', Exchange='N', ExchangeType='D', ScripCode=s, Qty=qty,
+                                                   Price=0, IsIntraday=self.intraday(self.intra),
+                                                   remote_order_id=self.tag)
+            print(order_status)
+            if order_status['Message']=='Success':
+                continue
+            else:
+                break
+        for s in sell_scrip:
+            order_status = self.Client.place_order(OrderType='S', Exchange='N', ExchangeType='D', ScripCode=s, Qty=qty,
+                                                   Price=0, IsIntraday=self.intraday(self.intra),
+                                                   remote_order_id=self.tag)
+            if order_status['Message']=='Success':
+                continue
+            else:
+                break
+
+    def call_calendar(self,symbol,strike,qty,expiry,intra,*args, **kwargs):
+        self.symbol=symbol
+        self.strike=strike
+        self.qty=qty
+        self.expiry=expiry
+        self.intra=intra
+        self.tag=kwargs.get('tag', None)
+        self.tag=self.filter_tag(self.tag)
+        scrip=[]
+        i=0
+        options =['CE','CE']
+        for opt in options:
+            sc=self.get_scripcode(self.symbol,self.strike,self.expiry[i],opt)
+            scrip.append(sc)
+            i=i+1
+        order_status = self.Client.place_order(OrderType='B', Exchange='N', ExchangeType='D', ScripCode=scrip[0], Qty=qty,
+                                               Price=0, IsIntraday=self.intraday(self.intra),
+                                               remote_order_id=self.tag)
+        order_status = self.Client.place_order(OrderType='S', Exchange='N', ExchangeType='D', ScripCode=scrip[1],
+                                               Qty=qty,
+                                               Price=0, IsIntraday=self.intraday(self.intra),
+                                               remote_order_id=self.tag)
+    
+    def put_calendar(self,symbol,strike,qty,expiry,intra,*args, **kwargs):
+        self.symbol=symbol
+        self.strike=strike
+        self.qty=qty
+        self.expiry=expiry
+        self.intra=intra
+        self.tag=kwargs.get('tag', None)
+        self.tag=self.filter_tag(self.tag)
+        scrip=[]
+        i=0
+        options =['PE','PE']
+        for opt in options:
+            sc=self.get_scripcode(self.symbol,self.strike,self.expiry[i],opt)
+            scrip.append(sc)
+            i=i+1 
+        order_status = self.Client.place_order(OrderType='B', Exchange='N', ExchangeType='D', ScripCode=scrip[0],
+                                               Qty=qty,
+                                               Price=0, IsIntraday=self.intraday(self.intra),
+                                               remote_order_id=self.tag)
+        order_status = self.Client.place_order(OrderType='S', Exchange='N', ExchangeType='D', ScripCode=scrip[1],
+                                               Qty=qty,
+                                               Price=0, IsIntraday=self.intraday(self.intra),
+                                               remote_order_id=self.tag)
+        
+    def squareoff(self, tag):
+        self.tag=self.filter_tag(tag)
+        id=[]
+        r=self.Client.fetch_order_status([
+                {
+                    "Exch": "N",
+                    "RemoteOrderID": self.tag
+                }])['OrdStatusResLst']
+        for order in r:
+            eoid=order['ExchOrderID']
+            if eoid!="":
+                id.append(eoid)
+        trdbook=self.Client.get_tradebook()['TradeBookDetail']
+        for eoid in id:
+            for trade in trdbook:
+                if eoid == int(trade['ExchOrderID']):
+                    self.type=self.opposite(trade['BuySell'])
+                    self.intra=trade['DelvIntra']
+                    self.scrip=trade['ScripCode']
+                    self.qty=trade['Qty']
+                    self.segment=trade['ExchType']
+                    order_status = self.Client.place_order(OrderType=self.type, Exchange='N', ExchangeType=self.segment,
+                                                           ScripCode=self.scrip,
+                                                           Qty=self.qty,
+                                                           Price=0, IsIntraday=self.intraday(self.intra),
+                                                           remote_order_id="sq"+self.tag)
+                else:
+                    continue
+
diff --git a/py5paisa/urlconst.py b/py5paisa/urlconst.py
new file mode 100644
index 00000000..f57f2cdd
--- /dev/null
+++ b/py5paisa/urlconst.py
@@ -0,0 +1,75 @@
+
+BaseUrl = 'https://Openapi.5paisa.com/VendorsAPI/Service1.svc/'
+
+
+LOGIN_ROUTE = f'{BaseUrl}V4/LoginRequestMobileNewbyEmail'
+
+SCRIP_MASTER_ROUTE=f'{BaseUrl}ScripMaster/segment/All'
+
+MARGIN_ROUTE = f'{BaseUrl}V4/Margin'
+ORDER_BOOK_ROUTE = f'{BaseUrl}V3/OrderBook'
+HOLDINGS_ROUTE = f'{BaseUrl}V3/Holding'
+POSITIONS_ROUTE = f'{BaseUrl}V2/NetPositionNetWise'
+
+ORDER_PLACEMENT_ROUTE = f'{BaseUrl}V1/PlaceOrderRequest'
+ORDER_MODIFY_ROUTE = f'{BaseUrl}V1/ModifyOrderRequest'
+ORDER_CANCEL_ROUTE = f'{BaseUrl}V1/CancelOrderRequest'
+ORDER_STATUS_ROUTE = f'{BaseUrl}V2/OrderStatus'
+TRADE_INFO_ROUTE = f'{BaseUrl}TradeInformation'
+
+BRACKET_MOD_ROUTE = f'{BaseUrl}ModifyBracketOrderRequest'
+BRACKET_ORDER_ROUTE = f'{BaseUrl}BracketOrderRequest'
+BRACKET_CANCEL_ROUTE = f'{BaseUrl}CancelBracketOrderRequest'
+
+COVER_MOD_ROUTE = f'{BaseUrl}ModifyCoverOrderequest'
+COVER_ORDER_ROUTE = f'{BaseUrl}CoverOrderRequest'
+COVER_CANCEL_ROUTE = f'{BaseUrl}CancelCoverOrderRequest'
+
+MARKET_FEED_ROUTE = f'{BaseUrl}MarketFeed'
+MARKET_FEED_ROUTE_BY_SCRIP = f'{BaseUrl}V1/MarketFeed'
+LOGIN_CHECK_ROUTE = "https://openfeed.5paisa.com/Feeds/api/UserActivity/LoginCheck"
+
+MARKET_DEPTH_ROUTE = f'{BaseUrl}V3/MarketDepth'
+MARKET_DEPTH_BY_SYMBOL_ROUTE = f'{BaseUrl}V1/MarketDepth'
+MARKET_DEPTH_BY_SCRIP = f'{BaseUrl}V2/MarketDepth'
+JWT_VALIDATION_ROUTE = "https://Openapi.indiainfoline.com/VendorsAPI/Service1.svc/JWTOpenApiValidation"
+#HISTORICAL_DATA_ROUTE = "https://openapi.5paisa.com/historical/" old url
+HISTORICAL_DATA_ROUTE = "https://openapi.5paisa.com/V2/historical/"
+IDEAS_ROUTE = f'{BaseUrl}TraderIDEAs'
+
+TRADEBOOK_ROUTE = f'{BaseUrl}V1/TradeBook'
+GET_REQUEST_TOKEN_ROUTE = f'{BaseUrl}TOTPLogin'
+ACCESS_TOKEN_ROUTE = f'{BaseUrl}GetAccessToken'
+MARKET_STATUS_ROUTE = f'{BaseUrl}MarketStatus'
+TRADE_HISTORY_ROUTE = f'{BaseUrl}TradeHistory'
+
+GET_BASKET_ROUTE = f'{BaseUrl}GetBaskets'
+CREATE_BASKET_ROUTE = f'{BaseUrl}CreateBasket'
+RENAME_BASKET_ROUTE = f'{BaseUrl}EditBasketName'
+DELETE_BASKET_ROUTE = f'{BaseUrl}DeleteBasket'
+CLONE_BASKET_ROUTE = f'{BaseUrl}CloneBasket'
+EXECUTE_BASKET_ROUTE = f'{BaseUrl}ExecuteBasket'
+GET_ORDER_IN_BASKET_ROUTE = f'{BaseUrl}GetOrderInBasket'
+ADD_BASKET_ORDER_ROUTE = f'{BaseUrl}AddOrderToBasket'
+OPTION_CHAIN_ROUTE = f'{BaseUrl}V2/GetExpiryForSymbolOptions'
+GET_OPTION_CHAIN_ROUTE = f'{BaseUrl}GetOptionsForSymbol'
+CANCEL_BULK_ORDER_ROUTE = f'{BaseUrl}CancelOrderBulk'
+SQUAREOFF_ROUTE = f'{BaseUrl}SquareOffAll'
+POSITION_CONVERSION_ROUTE = f'{BaseUrl}PositionConversion'
+MARKET_DEPTH_ROUTE_20 = "https://openapi.5paisa.com/marketfeed-token/token"
+APIUID = 'ka7SFqAU6SC'
+ORDERMARGIN_ROUTE=f'{BaseUrl}V1/PreOrdMarginCalculationVendor'
+ADDVTTORDER_ROUTE=f'{BaseUrl}AddVTTOrder'
+CALVTTORDER_ROUTE=f'{BaseUrl}CancelVTTOrder'
+MODVTTORDER_ROUTE=f'{BaseUrl}ModifyVTTOrder'
+GETVTTORDER_ROUTE=f'{BaseUrl}GetVTTOrder'
+HISVTTORDER_ROUTE=f'{BaseUrl}GetHistoryVTTOrder'
+BASKETMARGIN_ROUTE= f'{BaseUrl}PreOrdMarginCalculationBulkVendor'
+PLACEORDERBULK_ROUTE= f'{BaseUrl}PlaceOrderBulk'
+NETPOSITION_ROUTE= f'{BaseUrl}V4/NetPosition'
+MARKETSNAPSHOT_ROUTE = f'{BaseUrl}MarketSnapshot'
+TAXREPORT_ROUTE=f'{BaseUrl}taxreport'
+LEDGERREPORT_ROUTE=f'{BaseUrl}Ledger'
+
+MULTIORDERMARGIN_ROUTE=f'{BaseUrl}MultiOrderMargin'
+
diff --git a/requirements_dev.txt b/requirements_dev.txt
index e8097660..fc20e007 100644
--- a/requirements_dev.txt
+++ b/requirements_dev.txt
@@ -4,5 +4,7 @@ idna==2.9
 pbkdf2==1.3
 pycryptodome==3.9.8
 requests==2.23.0
-urllib3==1.25.8
-loguru==0.5.1
\ No newline at end of file
+urllib3==1.26.6
+loguru==0.5.1
+pyjwt==2.3.0
+httpx>=0.28.1,<0.29.0
\ No newline at end of file
diff --git a/setup.py b/setup.py
index 4da99607..c498d051 100644
--- a/setup.py
+++ b/setup.py
@@ -19,6 +19,10 @@
     "urllib3>=1.25.8",
     "idna>=2.9",
     "loguru>=0.5.1",
+    "websocket-client>=0.58.0",
+    "pandas>=1.2.4",
+    "pyjwt==2.3.0",
+    "httpx>=0.28.1,<0.29.0"  # Recommended (allows minor updates)
 ]
 
 setup_requirements = []
@@ -47,6 +51,6 @@
     test_suite='tests',
     tests_require=test_requirements,
     url='https://github.com/5paisa/py5paisa',
-    version='0.1.7',
+    version='0.7.21.2',
     zip_safe=False,
 )