fyers-apiv3 3.1.8__py3-none-any.whl → 3.1.9__py3-none-any.whl

fyers_apiv3/fyersModel.py

@@ -43,7 +43,19 @@ class Config:
     logout = "/logout"
     price_alert ="/price-alert"
     toggle_alert = "/toggle-alert"
-    triggered_alerts = "/triggered-alerts"
+    create_smartorder_step ="/smart-order/step"
+    create_smartorder_limit ="/smart-order/limit"
+    create_smartorder_trail ="/smart-order/trail"
+    create_smartorder_sip ="/smart-order/sip"
+    modify_smartorder="/smart-order/modify"
+    cancel_smartorder="/smart-order/cancel"
+    pause_smartorder="/smart-order/pause"
+    resume_smartorder="/smart-order/resume"
+    smartorder_orderbook="/smart-order/orderbook"
+    smartexit_trigger="/flows/tc/se"
+    activate_smartexit_trigger="/flows/tc/se/activate"
+    
+    
     
 
 
@@ -55,12 +67,14 @@ class FyersServiceSync:
 
         Args:
             logger: The logger object used for logging errors.
+            request_logger: The logger object used for logging requests.
         """
         self.api_logger = logger
         self.request_logger = request_logger
         self.content = "application/json"
         self.error_resp = {"s":"error", "code": 0 , "message":"Bad request"}
         self.error_message = "invalid input please check your input"
+        self.session = requests.Session()
 
 
     def post_call(self, api: str, header: str, data=None) -> dict:
@@ -77,7 +91,7 @@ class FyersServiceSync:
         """
         try:
             URL = Config.API + api 
-            response = requests.post(
+            response = self.session.post(
                 URL,
                 data=json.dumps(data),
                 headers={"Authorization": header, "Content-Type": self.content ,"version": "3"},
@@ -133,7 +147,7 @@ class FyersServiceSync:
             if data is not None:
                 url_params = urllib.parse.urlencode(data)
                 URL = URL + "?" + url_params   
-            response = requests.get(
+            response = self.session.get(
                 url=URL,
                 headers={
                     "Authorization": header,
@@ -183,7 +197,7 @@ class FyersServiceSync:
         """
         try:
             URL = Config.API + api
-            response = requests.delete(
+            response = self.session.delete(
                 URL,
                 data=json.dumps(data),
                 headers={"Authorization": header, "Content-Type": self.content ,"version": "3"},
@@ -233,7 +247,7 @@ class FyersServiceSync:
         """
         try:
             URL = Config.API + api
-            response = requests.patch(
+            response = self.session.patch(
                 URL,
                 data=json.dumps(data),
                 headers={"Authorization": header, "Content-Type": self.content ,"version": "3"},
@@ -282,7 +296,7 @@ class FyersServiceSync:
         """
         try:
             URL = Config.API + api
-            response = requests.put(
+            response = self.session.put(
                 URL,
                 data=json.dumps(data),
                 headers={"Authorization": header, "Content-Type": self.content ,"version": "3"},
@@ -324,12 +338,15 @@ class FyersServiceAsync:
 
         Args:
             logger: The logger object used for logging errors.
+            request_logger: The logger object used for logging requests.
         """
         self.api_logger = logger
         self.request_logger = request_logger
         self.content = "application/json"
         self.error_resp = {"s":"error", "code": 0 , "message":"Bad request"}
         self.error_message = "invalid input please check your input"
+        self.session = None
+        self._session_created_here = True
 
 
     async def post_async_call(self, api: str, header: str, data=None) -> dict:
@@ -346,18 +363,20 @@ class FyersServiceAsync:
         """
         try:
             url = Config.API + api
-            async with aiohttp.ClientSession(
-                headers={"Authorization": header, "Content-Type": self.content ,"version": "3"}
-            ) as session:
-                async with session.post(url, data=json.dumps(data)) as response:
-                    self.request_logger.debug({"Status Code":response.status, "API":api  })
-                    content = await response.read()
-                    self.api_logger.debug({"URL": url,"Post Data": json.dumps(data), \
-                                           "Response Status Code": response.status, \
-                                            "Response": json.loads(content)})
-                    response.raise_for_status()
-                    response = await response.json()
-                    return response
+            # Create session on first use if not provided
+            if self.session is None:
+                self.session = aiohttp.ClientSession()
+            
+            headers = {"Authorization": header, "Content-Type": self.content, "version": "3"}
+            async with self.session.post(url, data=json.dumps(data), headers=headers) as response:
+                self.request_logger.debug({"Status Code":response.status, "API":api  })
+                content = await response.read()
+                self.api_logger.debug({"URL": url,"Post Data": json.dumps(data), \
+                                       "Response Status Code": response.status, \
+                                        "Response": json.loads(content)})
+                response.raise_for_status()
+                response = await response.json()
+                return response
 
         except aiohttp.ClientResponseError as e:
             self.api_logger.error({"Api": api, "Response": json.loads(content)})
@@ -402,20 +421,22 @@ class FyersServiceAsync:
                 URL = Config.DATA_API + api
             else:
                 URL = Config.API + api
-            async with aiohttp.ClientSession(
-                headers={
-                    "Authorization": header,
-                    "Content-Type": self.content,
-                    "version": "3",
-                }
-            ) as session:
-                async with session.get(URL, params=params) as response:
-                    self.request_logger.debug({"Status Code": response.status, "API":api })
-                    content = await response.read()
-                    self.api_logger.debug({"URL": URL, "Status Code": response.status, "Response": json.loads(content)})
-                    response.raise_for_status()
-                    response = await response.json()
-                    return response               
+            # Create session on first use if not provided
+            if self.session is None:
+                self.session = aiohttp.ClientSession()
+            
+            headers = {
+                "Authorization": header,
+                "Content-Type": self.content,
+                "version": "3",
+            }
+            async with self.session.get(URL, params=params, headers=headers) as response:
+                self.request_logger.debug({"Status Code": response.status, "API":api })
+                content = await response.read()
+                self.api_logger.debug({"URL": URL, "Status Code": response.status, "Response": json.loads(content)})
+                response.raise_for_status()
+                response = await response.json()
+                return response               
 
         except aiohttp.ClientResponseError as e:
             self.api_logger.error({"Api": api, "Response": json.loads(content)})
@@ -454,18 +475,20 @@ class FyersServiceAsync:
         """
         try:
             url = Config.API + api
-            async with aiohttp.ClientSession(
-                headers={"Authorization": header, "Content-Type": self.content ,"version": "3"}
-            ) as session:
-                async with session.delete(url, data=json.dumps(data)) as response:
-                    self.request_logger.debug({"Status Code": response.status, "API":api })
-                    content = await response.read()
-                    self.api_logger.debug({"URL": url, "data": json.dumps(data), \
-                                            "Response Status Code": response.status, \
-                                            "Response": json.loads(content)})
-                    response.raise_for_status()
-                    response = await response.json()          
-                    return response
+            # Create session on first use if not provided
+            if self.session is None:
+                self.session = aiohttp.ClientSession()
+            
+            headers = {"Authorization": header, "Content-Type": self.content, "version": "3"}
+            async with self.session.delete(url, data=json.dumps(data), headers=headers) as response:
+                self.request_logger.debug({"Status Code": response.status, "API":api })
+                content = await response.read()
+                self.api_logger.debug({"URL": url, "data": json.dumps(data), \
+                                        "Response Status Code": response.status, \
+                                        "Response": json.loads(content)})
+                response.raise_for_status()
+                response = await response.json()          
+                return response
 
         except aiohttp.ClientResponseError as e:
             self.api_logger.error({"Api": api, "Response": json.loads(content)})
@@ -504,20 +527,21 @@ class FyersServiceAsync:
         """
         try:
             url = Config.API + api
-            async with aiohttp.ClientSession(
-                headers={"Authorization": header, "Content-Type": self.content ,"version": "3"}
-            ) as session:
-                json_data = json.dumps(data).encode("utf-8")
-
-                async with session.patch(url, data=json_data) as response:
-                    self.request_logger.debug({"Status Code": response.status, "API":api })
-                    content = await response.read()
-                    self.api_logger.debug({"URL": url, "data": json.dumps(data), \
-                                          "Status Code": response.status, \
-                                          "Response": json.loads(content)})
-                    response.raise_for_status()
-                    response = await response.json()           
-                    return response 
+            # Create session on first use if not provided
+            if self.session is None:
+                self.session = aiohttp.ClientSession()
+            
+            json_data = json.dumps(data).encode("utf-8")
+            headers = {"Authorization": header, "Content-Type": self.content, "version": "3"}
+            async with self.session.patch(url, data=json_data, headers=headers) as response:
+                self.request_logger.debug({"Status Code": response.status, "API":api })
+                content = await response.read()
+                self.api_logger.debug({"URL": url, "data": json.dumps(data), \
+                                      "Status Code": response.status, \
+                                      "Response": json.loads(content)})
+                response.raise_for_status()
+                response = await response.json()           
+                return response 
                 
         except aiohttp.ClientResponseError as e:
             self.api_logger.error({"Api": api, "Response": json.loads(content)})
@@ -556,20 +580,21 @@ class FyersServiceAsync:
         """
         try:
             url = Config.API + api
-            async with aiohttp.ClientSession(
-                headers={"Authorization": header, "Content-Type": self.content ,"version": "3"}
-            ) as session:
-                json_data = json.dumps(data).encode("utf-8")
-
-                async with session.put(url, data=json_data) as response:
-                    self.request_logger.debug({"Status Code": response.status, "API":api })
-                    content = await response.read()
-                    self.api_logger.debug({"URL": url, "data": json.dumps(data), \
-                                          "Status Code": response.status, \
-                                          "Response": json.loads(content)})
-                    response.raise_for_status()
-                    response = await response.json()           
-                    return response 
+            # Create session on first use if not provided
+            if self.session is None:
+                self.session = aiohttp.ClientSession()
+            
+            json_data = json.dumps(data).encode("utf-8")
+            headers = {"Authorization": header, "Content-Type": self.content, "version": "3"}
+            async with self.session.put(url, data=json_data, headers=headers) as response:
+                self.request_logger.debug({"Status Code": response.status, "API":api })
+                content = await response.read()
+                self.api_logger.debug({"URL": url, "data": json.dumps(data), \
+                                      "Status Code": response.status, \
+                                      "Response": json.loads(content)})
+                response.raise_for_status()
+                response = await response.json()           
+                return response 
                 
         except aiohttp.ClientResponseError as e:
             self.api_logger.error({"Api": api, "Response": json.loads(content)})
@@ -594,6 +619,15 @@ class FyersServiceAsync:
             self.api_logger.debug({"URL": url,"data": json.dumps(data),"message": e})
             return self.error_resp
 
+    async def close(self):
+        """
+        Closes the aiohttp session if it was created by this instance.
+        Should be called when done with the service to properly clean up resources.
+        """
+        if self.session is not None and self._session_created_here:
+            await self.session.close()
+            self.session = None
+
 
 
 class SessionModel:
@@ -695,7 +729,7 @@ class FyersModel:
         if is_async:
             self.service = FyersServiceAsync(self.api_logger, self.request_logger)
         else:
-            self.service = FyersServiceSync(self.api_logger,self.request_logger)
+            self.service = FyersServiceSync(self.api_logger, self.request_logger)
 
     def get_profile(self) -> dict:
         """
@@ -919,6 +953,7 @@ class FyersModel:
             - 'limitPrice' (float): Valid price for Limit and Stoplimit orders. Default: 0.
             - 'stopPrice' (float): Valid price for Stop and Stoplimit orders. Default: 0.
             - 'offlineOrder' (bool): Specifies if the order is placed when the market is open (False) or as an AMO order (True).
+            - 'isSliceOrder' (bool): Specifies if the order is a slice order. Default: False.
 
         Returns:
             The response JSON as a dictionary.
@@ -1246,17 +1281,19 @@ class FyersModel:
 
         Args:
             data (dict): A dictionary containing the alert details.
-                - 'agent' (str, optional): Source of alert creation. Eg: "fyers-api"
-                - 'alert-type' (int, mandatory): Type of alert. 1 usually means price-based alert.
-                - 'name' (str, optional): User-provided name/label for the alert.
-                - 'symbol' (str, mandatory): Trading symbol in full format. 
-                    Eg: "NSE:SBIN-EQ", "NSE:SILVERMIC25DECFUT"
-                - 'comparisonType' (str, mandatory): Selects the price parameter used for comparison.
-                    Allowed: "OPEN", "HIGH", "LOW", "CLOSE", "LTP"
-                - 'condition' (str, mandatory): Price comparison operator.
-                    Allowed: "GT" (greater), "LT" (lesser), "EQ" (equal)
-                - 'value' (float/int, mandatory): Target price against which comparison is performed.
-                - 'notes' (str, optional): Additional notes for the alert.
+                Required:
+                    - alert-type (int): Type of alert. 1 usually means price-based alert.
+                    - name (str): User-provided name/label for the alert.
+                    - symbol (str): Trading symbol in full format.
+                        Eg: "NSE:SBIN-EQ", "NSE:SILVERMIC25DECFUT"
+                    - comparisonType (str): Price parameter used for comparison.
+                        Allowed: "OPEN", "HIGH", "LOW", "CLOSE", "LTP"
+                    - condition (str): Price comparison operator.
+                        Allowed: "GT" (greater), "LT" (lesser), "EQ" (equal)
+                    - value (float/int/str): Target price against which comparison is performed.
+                Optional:
+                    - agent (str): Source of alert creation. Eg: "fyers-api"
+                    - notes (str): Additional notes for the alert.
 
         Returns:
             The response JSON as a dictionary.
@@ -1274,8 +1311,6 @@ class FyersModel:
 
         Args:
             data (dict, optional): Optional dictionary containing query parameters.
-                - 'id' (str, optional): Comma-separated alert IDs to filter. 
-                    Eg: "3870982,3870983" or "3870982"
                 - 'archive' (int, optional): Set to 1 to retrieve archived alerts instead of active alerts.
                     Default: 0 (active alerts)
 
@@ -1293,11 +1328,14 @@ class FyersModel:
 
     def delete_alert(self, data) -> dict:
         """
-        Deletes a price alert by its ID.
+        Deletes a price alert.
 
         Args:
-            data (dict): A dictionary containing the alert ID to delete.
-                - 'id' (str, mandatory): Alert ID to be deleted.
+            data (dict): A dictionary containing the alert deletion details.
+                Required Attributes:
+                    - alertId (str): Alert ID from creation
+                Optional Attributes:
+                    - agent (str): Client calling the API (e.g., "fyers-api")
 
         Returns:
             The response JSON as a dictionary.
@@ -1314,18 +1352,20 @@ class FyersModel:
 
         Args:
             data (dict): A dictionary containing the alert modification details.
-                - 'alertId' (str, mandatory): ID of the alert to be modified. Eg: "3870991"
-                - 'agent' (str, optional): Source of alert creation. Eg: "fyers-api"
-                - 'alert-type' (int, optional): Type of alert. 1 usually means price-based alert.
-                - 'name' (str, optional): User-provided name/label for the alert.
-                - 'symbol' (str, optional): Trading symbol in full format. 
-                    Eg: "NSE:SBIN-EQ", "NSE:SILVERMIC25DECFUT"
-                - 'comparisonType' (str, optional): Selects the price parameter used for comparison.
-                    Allowed: "OPEN", "HIGH", "LOW", "CLOSE", "LTP"
-                - 'condition' (str, optional): Price comparison operator.
-                    Allowed: "GT" (greater), "LT" (lesser), "E" (equal)
-                - 'value' (float/int, optional): Target price against which comparison is performed.
-                - 'status' (int, optional): Status of the alert.
+                Required Attributes:
+                    - alertId (str): ID of the alert to be modified. Eg: "3870991"
+                    - alert-type (int): Type of alert. 1 usually means price-based alert.
+                    - symbol (str): Trading symbol in full format.
+                        Eg: "NSE:SBIN-EQ", "NSE:SILVERMIC25DECFUT"
+                    - comparisonType (str): Price parameter used for comparison.
+                        Allowed: "OPEN", "HIGH", "LOW", "CLOSE", "LTP"
+                    - condition (str): Price comparison operator.
+                        Allowed: "GT" (greater), "LT" (lesser), "E" (equal)
+                    - value (float/int/str): Target price against which comparison is performed.
+                    - name (str): User-provided name/label for the alert.
+                Optional Attributes:
+                    - agent (str): Source of alert creation. Eg: "fyers-api"
+                    
 
         Returns:
             The response JSON as a dictionary.
@@ -1354,28 +1394,439 @@ class FyersModel:
             response = self.service.put_call(Config.toggle_alert, self.header, data)
         return response
     
-    def trending_alert(self) -> dict:
+    def create_smart_order_step(self, data: dict) -> dict:
         """
-        Retrieves trending alerts - the top 5 most popular alerts based on user activity.
-        This endpoint returns alerts that are currently trending with their symbol details,
-        price changes, and alert counts.
+        Creates a step smart order based on the provided data.
+
+        Args:
+            data (dict): A dictionary containing the smart order creation details.
+               Required Attributes:
+                - symbol (str): Symbol of the product. Eg: "NSE:SBIN-EQ"
+                - side (int): Side of the order. 1 for Buy, -1 for Sell
+                - qty (int): Total quantity of the product
+                - productType (str): Type of the product. Possible values: 'CNC', 'INTRADAY', 'MARGIN'
+                - avgqty (int): Average quantity per step
+                - avgdiff (int): Average difference between steps
+                - direction (int): Direction of the order
+                - orderType (int): Type of the order
+                - startTime (int): Start time in epoch format
+                - endTime (int): End time in epoch format
+                
+               Conditional Attributes:  
+                - limitPrice (float): Limit price for the order
+                
+               Optional Attributes:   
+                - initQty (int): Initial quantity to be placed
+                - hpr (float): Higher price range
+                - lpr (float): Lower price range
+                - mpp (int): Maximum price per order
 
         Returns:
-            The response JSON as a dictionary 
-            
-            Each alert in the data array contains:
-                - 'symbol' (str): Trading symbol in full format
-                - 'description' (str): Description/name of the symbol
-                - 'exchange' (str): Exchange name (NSE, BSE, MCX, etc.)
-                - 'change' (float): Change in price
-                - 'changeInP' (float): Percentage change in price
-                - 'ltp' (float): Last traded price
-                - 'count' (int): Number of alerts set for this symbol
+            dict: The response JSON as a dictionary.
+        """
+
+       
+        
+        if self.is_async:
+            response = self.service.post_async_call(Config.create_smartorder_step, self.header, data)
+        else:
+            response = self.service.post_call(Config.create_smartorder_step, self.header, data) 
+        return response
+    
+    async def close(self):
+        """
+        Closes the HTTP session(s) to properly clean up resources.
+        Should be called when done with the FyersModel instance, especially for async mode.
+        """
+        if self.is_async:
+            if hasattr(self, 'async_session') and self.async_session:
+                await self.async_session.close()
+                self.async_session = None
+            if hasattr(self, 'service') and hasattr(self.service, 'close'):
+                await self.service.close()
+        else:
+            if hasattr(self, 'session') and self.session:
+                self.session.close()
+                self.session = None
+    
+
+    def create_smart_order_limit(self,data: dict) -> dict:
+        """
+        Creates a Smart Limit Order based on the provided data.
+        
+        Smart Limit Orders allow you to place limit orders that remain active until the specified end time.
+        Once the end time is reached, the order can be converted to an MPP order or cancelled.
+
+        Args:
+            data (dict): A dictionary containing the smart order creation details.
+                Required Attributes:
+                    - symbol (str): The instrument's unique identifier, e.g., "NSE:SBIN-EQ"
+                    - side (int): Order side: 1 for Buy, -1 for Sell (enum: 1, -1)
+                    - qty (int): Order quantity (Min: 1, Max: 999999; must be a multiple of lot size)
+                    - productType (str): Must be one of: "CNC", "MARGIN", "INTRADAY", "MTF"
+                    - limitPrice (number): The price at which the order should be placed (Min: 0.01)
+                    - endTime (int): Order expiry time as a Unix timestamp (epoch)
+                    - orderType (int): Order type: 1 for Limit, 4 for Stop-Limit (enum: 1, 4)
+                    - onExp (int): Action on expiry: 1 = Cancel, 2 = Market (enum: 1, 2)
+                
+                Optional Attributes:
+                    - stopPrice (number): Default: 0. Required when orderType is 4 (Stop-Limit)
+                    - hpr (number): Default: 0. 0 = no upper price limit. If provided, order executes only below this price
+                    - lpr (number): Default: 0. 0 = no lower price limit. If provided, order executes only above this price
+                    - mpp (number): Default: 0. 0 = no market protection. Valid values: 0–3 or -1 (disabled)
+
+        Returns:
+            dict: The response JSON as a dictionary.
+        """
+        if self.is_async:
+            response = self.service.post_async_call(Config.create_smartorder_limit, self.header, data)
+        else:
+            response = self.service.post_call(Config.create_smartorder_limit, self.header, data) 
+        return response
+    
+    def create_smart_order_trail(self, data: dict) -> dict:
+        """
+        Creates a Smart Trail Order (Trailing Stop Loss) based on the provided data.
+        
+        A Smart Trail Order is a trailing stop-loss that automatically adjusts the stop price as the market moves 
+        in your favour. The stop price trails the market by a specified jump price.
+
+        Args:
+            data (dict): A dictionary containing the smart order creation details.
+                Required Attributes:
+                    - symbol (str): The instrument's unique identifier, e.g., "NSE:SBIN-EQ"
+                    - side (int): Order side: 1 for Buy, -1 for Sell (enum: 1, -1)
+                    - qty (int): Order quantity (Min: 1, Max: 999999; must be a multiple of lot size)
+                    - productType (str): Must be one of: "CNC", "MARGIN", "INTRADAY", "MTF"
+                    - orderType (int): Order type: 1 for Limit Order, 2 for Market Order (enum: 1, 2)
+                    - stopPrice (number): Initial stop/trigger price (must be greater than 0)
+                    - jump_diff (number): Jump price — the value by which the stop price trails (Min: 0.2)
+                
+                Optional Attributes:
+                    - limitPrice (number): Default: 0. If not provided, executes at market price. Required if orderType = 1
+                    - target_price (number): Default: 0 (no target). If provided, must be greater than current LTP
+                    - mpp (number): Default: 0 (no market protection). Valid values: 0–3 or -1 (disabled)
+
+        Returns:
+            dict: The response JSON as a dictionary.
         """
         if self.is_async:
-            response = self.service.get_async_call(Config.trending_alert, self.header)
+            response = self.service.post_async_call(Config.create_smartorder_trail, self.header, data)
         else:
-            response = self.service.get_call(Config.trending_alert, self.header)
+            response = self.service.post_call(Config.create_smartorder_trail, self.header, data) 
         return response
     
+    def create_smart_order_sip(self, data: dict) -> dict:
+        """
+        Creates a Smart SIP (Systematic Investment Plan) order based on the provided data.
+        
+        Smart SIP allows you to automate recurring investments in equity stocks, ETFs, with orders placed automatically 
+        at your selected frequency—daily, weekly, monthly, or on custom dates.
+
+        Args:
+            data (dict): A dictionary containing the smart order creation details.
+                Required Attributes:
+                    - symbol (str): The instrument's unique identifier (Equity only), e.g., "NSE:SBIN-EQ"
+                    - productType (str): Must be one of: "CNC", "MTF"
+                    - freq (int): SIP frequency (enum: 1, 2, 3, 6)
+                    - sip_day (int): Day of the month for SIP execution (Min: 1, Max: 28)
+                    - qty OR amount (int/number): At least one required - Quantity or amount per SIP instalment (Max: 999999)
+                
+                Conditional Attributes:
+                    - sip_time (int): Required if freq = 1 (Daily). Unix timestamp for SIP execution time (must be within market hours)
+                
+                Optional Attributes:
+                    - imd_start (bool): Whether to start SIP immediately. true = start now, false = wait for schedule
+                    - endTime (int): Default: 0 (no end date). Unix timestamp when the SIP should end
+                    - hpr (number): Default: 0. Skips SIP if price is above this upper limit
+                    - lpr (number): Default: 0. Skips SIP if price is below this lower limit
+                    - step_up_freq (int): Frequency of step-up increase (enum: 3, 5). Default: 0 (no step-up)
+                    - step_up_qty (int): Quantity to increase at each step-up (Default: 0; Max: 999999)
+                    - step_up_amount (number): Amount to increase at each step-up (Default: 0; Max: 999999)
+                    - exp_qty (int): Quantity for expiry/final SIP order (Default: 0; Max: 999999)
+
+        Returns:
+            dict: The response JSON as a dictionary.
+        """
+        if self.is_async:
+            response = self.service.post_async_call(Config.create_smartorder_sip, self.header, data)
+        else:
+            response = self.service.post_call(Config.create_smartorder_sip, self.header, data) 
+        return response
+    
+    
+        
+    
+    def modify_smart_order(self, data) -> dict:
+        """
+        Modifies a smart order based on the provided data.
+
+        Args:
+            data (dict): A dictionary containing the smart order modification details.
+
+                Required:
+                    - flowId (str): Unique identifier of the Smart Order to be modified
+
+                Optional (by order type/flowtype):
+
+                    Limit Order (flowtype: 4):
+                        - qty (int): To update order quantity
+                        - limitPrice (number): To update limit price
+                        - stopPrice (number): To update stop/trigger price
+                        - endTime (int): To update expiry time (Unix timestamp)
+                        - hpr (number): To update upper price limit (High Price Range)
+                        - lpr (number): To update lower price limit (Low Price Range)
+                        - mpp (number): To update market protection percentage
+                        - onExp (int): To update expiry action (1 = Cancel, 2 = Market Order)
+
+                    Trail Order (flowtype: 6):
+                        - qty (int): To update order quantity
+                        - limitPrice (number): To update limit price (required if orderType = 1; must be 0 if orderType = 2)
+                        - stopPrice (number): To update stop/trigger price
+                        - jump_diff (number): To update jump value for trailing stop
+                        - target_price (number): To update target price (optional profit booking)
+                        - mpp (number): To update market protection percentage
+
+                    Step Order (flowtype: 3):
+                        - qty (int): To update total order quantity
+                        - startTime (int): To update order start time
+                        - endTime (int): To update order end time
+                        - hpr (number): To update upper price limit (High Price Range)
+                        - lpr (number): To update lower price limit (Low Price Range)
+                        - mpp (number): To update market protection percentage
+                        - avgqty (int): To update quantity per averaging step
+                        - avgdiff (number): To update price gap between steps
+                        - initQty (int): To update initial quantity (only before order starts)
+                        - limitPrice (number): To update limit price (only before order starts)
+                        - direction (int): To update direction for averaging (1 = price drop, -1 = price rise)
+
+                    SIP Order (flowtype: 7):
+                        - qty (int): To update investment quantity per instalment
+                        - amount (number): To update investment amount per instalment
+                        - hpr (number): To update upper price limit (skip if price is above this)
+                        - lpr (number): To update lower price limit (skip if price is below this)
+                        - sip_day (int): To update SIP day (applicable for monthly/custom frequency)
+                        - sip_time (int): To update SIP time (required for daily/custom frequency)
+                        - step_up_amount (number): To update step-up amount (amount-based SIP only)
+                        - step_up_qty (int): To update step-up quantity (qty-based SIP only)
+                        - exp_qty (int): To update expiry quantity
+                        - exp_amount (number): To update expiry amount
+
+        Returns:
+            The response JSON as a dictionary.
+        """
+        if self.is_async:
+            response = self.service.patch_async_call(Config.modify_smartorder, self.header, data)
+        else:
+            response = self.service.patch_call(Config.modify_smartorder, self.header, data)
+        return response
+
+    def cancel_order(self, data) -> dict:
+        """
+        Cancels a smart order based on the provided data.
+
+        Args:
+            data (dict): A dictionary containing the smart order cancellation details.
+                - flowId (str): Unique identifier of the smart order flow to cancel
+
+        Returns:
+            The response JSON as a dictionary.
+        """
+        if self.is_async:
+            response = self.service.delete_async_call(Config.cancel_smartorder, self.header, data)
+        else:
+            response = self.service.delete_call(Config.cancel_smartorder, self.header, data)
+        return response
+
+    def pause_order(self, data) -> dict:
+        """
+        Pauses a smart order based on the provided data.
+
+        Args:
+            data (dict): A dictionary containing the smart order pause details.
+                - flowId (str): Unique identifier of the smart order flow to pause
+
+        Returns:
+            The response JSON as a dictionary.
+        """
+        if self.is_async:
+            response = self.service.patch_async_call(Config.pause_smartorder, self.header, data)
+        else:
+            response = self.service.patch_call(Config.pause_smartorder, self.header, data)
+        return response
+
+    def resume_order(self, data) -> dict:
+        """
+        Resumes a paused smart order based on the provided data.
+
+        Args:
+            data (dict): A dictionary containing the smart order resume details.
+                - flowId (str): Unique identifier of the smart order flow to resume
+
+        Returns:
+            The response JSON as a dictionary.
+        """
+        if self.is_async:
+            response = self.service.patch_async_call(Config.resume_smartorder, self.header, data)
+        else:
+            response = self.service.patch_call(Config.resume_smartorder, self.header, data)
+        return response
+
+    def smart_orderbook_with_filter(self, data=None) -> dict:
+        """
+        Retrieves smart order book information with optional filters.
+
+        Optional Query Parameters (pass as keys in data dict for GET query params):
+            - flowtype (int[]): Filter by order type (repeatable). 3 = Step, 4 = Limit, 5 = Peg, 6 = Trail, 7 = SIP. Default: all types
+            - messageType (int[]): Filter by order status/message type (repeatable). Default: all
+            - page_no (int): Page number for pagination. Default: 1
+            - page_size (int): Number of records per page. Default: 15
+            - sort_by (str): Sort by field: "CreatedTime", "UpdatedTime", "Alphabet". Default: "UpdatedTime"
+            - ord_by (int): Sort order: 1 for ascending, -1 for descending. Default: -1
+            - side (int[]): Filter by side (repeatable). 1 for buy, -1 for sell. Default: all
+            - exchange (str[]): Filter by exchange (repeatable). "NSE", "BSE", "MCX". Default: all
+            - product (str[]): Filter by product type (repeatable). "CNC", "MARGIN", "INTRADAY", "MTF". Default: all
+            - search (str): Search by symbol name. Default: none
+
+        Args:
+            data (dict, optional): A dictionary containing the optional query parameters above.
+
+        Returns:
+            The response JSON as a dictionary.
+        """
+        if self.is_async:
+            response = self.service.get_async_call(Config.smartorder_orderbook, self.header, data)
+        else:
+            response = self.service.get_call(Config.smartorder_orderbook, self.header, data)
+        return response
+
+
+    def create_smartexit_trigger(self, data) -> dict:
+        """
+        Creates a new smart exit trigger based on the provided data.
+        
+        Smart exit triggers support three types of strategies:
+        
+        Type 1: Only Alert (notification only, no auto-exit)
+            - Sends notification when profit/loss thresholds are reached
+            - Does not automatically exit positions
+            - Example:
+                {
+                    "name": "Alert Only Strategy",
+                    "type": 1,
+                    "profitRate": 5000,
+                    "lossRate": -2000
+                }
+        
+        Type 2: Exit with Alert (notification + immediate exit)
+            - Sends notification and immediately exits positions when thresholds are reached
+            - Example:
+                {
+                    "name": "Auto Exit Strategy",
+                    "type": 2,
+                    "profitRate": 5000,
+                    "lossRate": -2000
+                }
+        
+        Type 3: Exit with Alert + Wait for Recovery (notification + delayed exit)
+            - Sends notification and waits for recovery before exiting
+            - Requires waitTime parameter (in minutes)
+            - Example:
+                {
+                    "name": "Recovery Exit Strategy",
+                    "type": 3,
+                    "profitRate": 10000,
+                    "lossRate": -3000,
+                    "waitTime": 5
+                }
+
+        Args:
+            data (dict): A dictionary containing the smart exit trigger creation details.
+                - name (str): Name of the smart exit trigger strategy
+                - type (int): Type of the trigger (1: Alert only, 2: Exit with alert, 3: Exit with alert + wait for recovery)
+                - profitRate (float): Profit rate threshold (positive value, e.g., 5000)
+                - lossRate (float): Loss rate threshold (negative value, e.g., -2000)
+                - waitTime (int, optional): Wait time in minutes (required for type 3, default: 0)
+
+        """
+        if self.is_async:
+            response = self.service.post_async_call(Config.smartexit_trigger, self.header, data)
+        else:
+            response = self.service.post_call(Config.smartexit_trigger, self.header, data)
+        return response
+
+    def get_smartexit_triggers(self, data=None) -> dict:
+        """
+        Retrieves smart exit trigger information.
+
+        Args:
+            data (dict, optional): A dictionary containing parameters for filtering smart exit triggers.
+
+        Returns:
+            The response JSON as a dictionary.
+        """
+        if self.is_async:
+            response = self.service.get_async_call(Config.smartexit_trigger, self.header, data)
+        else:
+            response = self.service.get_call(Config.smartexit_trigger, self.header, data)
+        return response
+
+    def update_smartexit_trigger(self, data) -> dict:
+        """
+        Updates an existing smart exit trigger based on the provided data.
+        
+        Use this endpoint to modify a Smart Exit trigger. You can update the target values, exit type, or wait time.
+        If the trigger is active, updates are validated against the current P&L.
+        Either a profit target or a loss limit must be provided.
+        
+        Exit Types (type field):
+            - Value 1: Only Alert - Notification Only
+                Sends a notification when target is hit. Does NOT exit positions automatically.
+            - Value 2: Exit with Alert - Notification + Immediate Exit
+                Sends notification AND exits all intraday positions immediately.
+            - Value 3: Exit with Alert (Wait for Recovery) - Notification + Delayed Exit
+                Sends notification, waits for waitTime minutes, then exits positions.
+
+        Args:
+            data (dict): A dictionary containing the smart exit trigger update details.
+                Required Attributes:
+                    - flowId (str): The unique identifier of the smart exit to update
+                
+                Optional Attributes:
+                    - name (str): Unique name for your Smart Exit trigger
+                    - profitRate (number): Book profit value (positive) or Minimize loss value (negative). 
+                                         (Min: -1,00,00,000, Max: 1,00,00,000)
+                    - lossRate (number): Max loss value (negative) or Min profit value (positive). 
+                                       (Min: -1,00,00,000, Max: 1,00,00,000)
+                    - type (int): Exit type (enum: 1, 2, 3). Default is 1 if not provided.
+                    - waitTime (int): Wait time in minutes (required if type=3). Default: 0 (Min: 0, Max: 60)
+                
+                Note: Either profitRate or lossRate must be provided.
+
+        Returns:
+            The response JSON as a dictionary.
+        """
+        if self.is_async:
+            response = self.service.put_async_call(Config.smartexit_trigger, self.header, data)
+        else:
+            response = self.service.put_call(Config.smartexit_trigger, self.header, data)
+        return response
+
+    def activate_deactivate_smartexit_trigger(self, data) -> dict:
+        """
+        Activates a smart exit trigger based on the provided data.
+
+        Args:
+            data (dict): A dictionary containing the smart exit trigger activation details.
+                - flowId (str): Unique identifier of the smart exit trigger flow to activate
+
+        Returns:
+            The response JSON as a dictionary.
+        """
+        if self.is_async:
+            response = self.service.post_async_call(Config.activate_smartexit_trigger, self.header, data)
+        else:
+            response = self.service.post_call(Config.activate_smartexit_trigger, self.header, data)
+        return response
+
     

{fyers_apiv3-3.1.8.dist-info → fyers_apiv3-3.1.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fyers_apiv3
-Version: 3.1.8
+Version: 3.1.9
 Summary: Fyers trading APIs.
 Home-page: https://github.com/FyersDev/fyers-api-sample-code/tree/sample_v3/v3/python
 Author: Fyers-Tech
@@ -182,7 +182,8 @@ data =  {
       "disclosedQty":0,
       "offlineOrder":False,
       "stopLoss":0,
-      "takeProfit":0
+      "takeProfit":0,
+      "isSliceOrder":False
     }                              ## This is a sample example to place a limit order you can make the further changes based on your requriements 
 
 print(fyers.place_order(data))
@@ -350,6 +351,230 @@ data = {"symbol":"NSE:SBIN-EQ","ohlcv_flag":"1"}
 print(fyers.depth(data))
 
 
+#################################################################################################################
+
+"""
+PRICE ALERTS : This includes following APIs (create_alert, get_alert, update_alert, delete_alert, toggle_alert)
+"""
+
+## Create Price Alert
+data = {
+    "agent": "fyers-api",
+    "alert-type": 1,
+    "name": "gold alert",
+    "symbol": "NSE:GOLDBEES-EQ",
+    "comparisonType": "LTP",
+    "condition": "GT",
+    "value": "9888",
+    "notes": " iji"
+}
+
+print(fyers.create_alert(data))
+
+## Get Price Alerts
+# Get all active alerts
+print(fyers.get_alert())
+
+# Get archived alerts
+data = {"archive": "1"}
+print(fyers.get_alert(data))
+
+## Update Price Alert
+data = {
+    "alertId": "6249977",
+    "agent": "fyers-api",
+    "alert-type": 1,
+    "name": "goldy bees",
+    "symbol": "NSE:GOLDBEES-EQ",
+    "comparisonType": "OPEN",
+    "condition": "GT",
+    "value": "10000.00676766767676676667"
+}
+
+print(fyers.update_alert(data))
+
+## Delete Price Alert
+data = {"alertId": "6131416", "agent": "fyers-api"}
+print(fyers.delete_alert(data))
+
+## Toggle Price Alert (Enable/Disable)
+data = {"alertId": "3870991"}
+print(fyers.toggle_alert(data))
+
+
+#################################################################################################################
+
+"""
+SMART ORDERS : This includes following APIs (create, modify, cancel, pause, resume, orderbook)
+Smart orders support different flow types: step, limit, trail, sip
+"""
+
+## Create Smart Order - Step
+data = {
+    "symbol": "NSE:SBIN-EQ",
+    "qty": 10,
+    "type": 1,
+    "side": 1,
+    "productType": "INTRADAY",
+    "limitPrice": 600.00,
+    "stopPrice": 0,
+    "validity": "DAY",
+    "disclosedQty": 0,
+    "offlineOrder": False
+}
+
+print(fyers.create_smart_order_step(data))
+
+## Create Smart Order - Limit
+data = {
+    "symbol": "NSE:SBIN-EQ",
+    "qty": 10,
+    "type": 1,
+    "side": 1,
+    "productType": "INTRADAY",
+    "limitPrice": 600.00,
+    "stopPrice": 0,
+    "validity": "DAY",
+    "disclosedQty": 0,
+    "offlineOrder": False
+}
+
+print(fyers.create_smart_order_limit(data))
+
+## Create Smart Order - Trail
+data = {
+    "symbol": "NSE:SBIN-EQ",
+    "qty": 10,
+    "type": 1,
+    "side": 1,
+    "productType": "INTRADAY",
+    "limitPrice": 600.00,
+    "stopPrice": 0,
+    "validity": "DAY",
+    "disclosedQty": 0,
+    "offlineOrder": False
+}
+
+print(fyers.create_smart_order_trail(data))
+
+## Create Smart Order - SIP
+data = {
+    "symbol": "NSE:SBIN-EQ",
+    "qty": 10,
+    "type": 1,
+    "side": 1,
+    "productType": "CNC",
+    "limitPrice": 600.00,
+    "stopPrice": 0,
+    "validity": "DAY",
+    "disclosedQty": 0,
+    "offlineOrder": False
+}
+
+print(fyers.create_smart_order_sip(data))
+
+## Modify Smart Order
+data = {
+    "flowId": "123456789",
+    "limitPrice": 610.00,
+    "qty": 15
+}
+
+print(fyers.modify_smart_order(data))
+
+## Cancel Smart Order
+data = {"flowId": "123456789"}
+print(fyers.cancel_order(data))
+
+## Pause Smart Order
+data = {"flowId": "123456789"}
+print(fyers.pause_order(data))
+
+## Resume Smart Order
+data = {"flowId": "123456789"}
+print(fyers.resume_order(data))
+
+## Get Smart Order Book with Filter
+# Get all smart orders
+print(fyers.smart_orderbook_with_filter())
+
+# Get filtered smart orders
+# Filter by side (1 for Buy, -1 for Sell)
+data = {"side": [1]}
+print(fyers.smart_orderbook_with_filter(data))
+
+# Filter by multiple parameters
+data = {
+    "exchange": ["NSE"],
+    "side": [1, -1],
+    "flowtype": [1, 2],
+    "product": ["CNC", "INTRADAY"],
+    "messageType": [1, 2],
+    "search": "SBIN",
+    "sort_by": "CreatedTime",
+    "ord_by": 1,
+    "page_no": 1,
+    "page_size": 15
+}
+print(fyers.smart_orderbook_with_filter(data))
+
+
+#################################################################################################################
+
+"""
+SMART EXIT TRIGGERS : This includes following APIs (create, get, update, activate)
+"""
+
+## Create Smart Exit Trigger
+
+# Type 1: Only Alert (notification only, no auto-exit)
+data = {
+    "name": "Alert Only Strategy",
+    "type": 1,
+    "profitRate": 5000,
+    "lossRate": -2000
+}
+print(fyers.create_smartexit_trigger(data))
+
+# Type 2: Exit with Alert (notification + immediate exit)
+data = {
+    "name": "Auto Exit Strategy",
+    "type": 2,
+    "profitRate": 5000,
+    "lossRate": -2000
+}
+print(fyers.create_smartexit_trigger(data))
+
+# Type 3: Exit with Alert + Wait for Recovery (notification + delayed exit)
+data = {
+    "name": "Recovery Exit Strategy",
+    "type": 3,
+    "profitRate": 10000,
+    "lossRate": -3000,
+    "waitTime": 5
+}
+print(fyers.create_smartexit_trigger(data))
+
+## Get Smart Exit Triggers
+# Get all smart exit triggers
+print(fyers.get_smartexit_triggers())
+
+
+## Update Smart Exit Trigger
+data = {
+    "flowId": "123456789",
+    "triggerPrice": 610.00,
+    "stopLoss": 600.00,
+    "takeProfit": 630.00
+}
+
+print(fyers.update_smartexit_trigger(data))
+
+## Activate Smart Exit Trigger
+data = {"flowId": "123456789"}
+print(fyers.activate_smartexit_trigger(data))
+
+
 ```
 
 ## Getting started with Data Socket
@@ -437,43 +662,61 @@ from fyers_apiv3.FyersWebsocket import order_ws
 
 def onTrade(message):
     """
-    Callback function to handle incoming messages from the FyersDataSocket WebSocket.
+    Callback function to handle incoming trade messages from the FyersOrderSocket WebSocket.
 
     Parameters:
         message (dict): The received message from the WebSocket.
-
+            - message["trades"]: Contains trade data including id_fyers field if present
+            - message["s"]: Status of the message
+    
+    Note: The message may contain an "id_fyers" field in the trades data, which is a unique identifier
+    for Fyers-specific trade tracking.
     """
     print("Trade Response:", message)
 
+
 def onOrder(message):
     """
-    Callback function to handle incoming messages from the FyersDataSocket WebSocket.
+    Callback function to handle incoming order messages from the FyersOrderSocket WebSocket.
 
     Parameters:
         message (dict): The received message from the WebSocket.
-
+            - message["orders"]: Contains order data including id_fyers field if present
+            - message["s"]: Status of the message
+    
+    Note: The message may contain an "id_fyers" field in the orders data, which is a unique identifier
+    for Fyers-specific order tracking.
     """
     print("Order Response:", message)
 
+
 def onPosition(message):
     """
-    Callback function to handle incoming messages from the FyersDataSocket WebSocket.
+    Callback function to handle incoming position messages from the FyersOrderSocket WebSocket.
 
     Parameters:
         message (dict): The received message from the WebSocket.
-
+            - message["positions"]: Contains position data including id_fyers field if present
+            - message["s"]: Status of the message
+    
     """
     print("Position Response:", message)
 
+
 def onGeneral(message):
     """
-    Callback function to handle incoming messages from the FyersDataSocket WebSocket.
+    Callback function to handle incoming general messages from the FyersOrderSocket WebSocket.
+    This includes eDIS updates, price alerts, and login events.
 
     Parameters:
         message (dict): The received message from the WebSocket.
+            - May contain price alerts with id_fyers field if present
+            - May contain eDIS updates
+            - May contain login events
 
     """
     print("General Response:", message)
+
 def onerror(message):
     """
     Callback function to handle WebSocket errors.

{fyers_apiv3-3.1.8.dist-info → fyers_apiv3-3.1.9.dist-info}/RECORD

@@ -1,5 +1,5 @@
 fyers_apiv3/__init__.py,sha256=1vA_F8dAtLKcyOqrmdUOkw1Syl8gIFUtxDoLde8y94E,18
-fyers_apiv3/fyersModel.py,sha256=YeztWqabCf0PTdIYEcDWaBaSM_u6uFqchjbcs2pPh6k,56119
+fyers_apiv3/fyersModel.py,sha256=ov1YZqRAtrE6nP7GG19nK8b2jHABHPMSBwbm9YTFGdY,78536
 fyers_apiv3/fyers_logger.py,sha256=S_WiIwBLytQ_tyHd9bUC8gZo7GHpANCJO0CS6rCJE90,3795
 fyers_apiv3/FyersWebsocket/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fyers_apiv3/FyersWebsocket/data_ws.py,sha256=fSNfsUB_I5-MkWX4hQZvklRQhuQ9n3w5hMDRFrMaBE8,68105
@@ -8,8 +8,8 @@ fyers_apiv3/FyersWebsocket/map.json,sha256=GfAgk-zqzUki5Cu0ZlG08PiMhfKTyGIsPo62m
 fyers_apiv3/FyersWebsocket/msg_pb2.py,sha256=Po6emBFB6aCmt3rkuN6zjDA7JEzsixejfNSOQYtYgnE,6272
 fyers_apiv3/FyersWebsocket/order_ws.py,sha256=B0ioHcFinlu40zIYWiU6nLpiEmID3317R_9gdmiPh5M,17451
 fyers_apiv3/FyersWebsocket/tbt_ws.py,sha256=rlg0taA9KCS8YbyKZ8UxqRw5rUcqRETz0sbM9KBUcF0,21191
-fyers_apiv3-3.1.8.dist-info/licenses/LICENSE.txt,sha256=_a5I4lWvSmoZQxwGSPGVVvUbuYby780N9YevsBqNY3k,1063
-fyers_apiv3-3.1.8.dist-info/METADATA,sha256=UZIdnpxu2i9mnjMvru1a0CefJ0B9nfXcIgPZgUi4RgQ,19256
-fyers_apiv3-3.1.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-fyers_apiv3-3.1.8.dist-info/top_level.txt,sha256=IaT774gXqIM6uJpgCQPvXruJBOINsupO9oTe2ao6pkc,12
-fyers_apiv3-3.1.8.dist-info/RECORD,,
+fyers_apiv3-3.1.9.dist-info/licenses/LICENSE.txt,sha256=_a5I4lWvSmoZQxwGSPGVVvUbuYby780N9YevsBqNY3k,1063
+fyers_apiv3-3.1.9.dist-info/METADATA,sha256=oNJNLy6DpYePTpsdn9B5s-K-tA7UqlkGO3TKw8i8vdg,25190
+fyers_apiv3-3.1.9.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+fyers_apiv3-3.1.9.dist-info/top_level.txt,sha256=IaT774gXqIM6uJpgCQPvXruJBOINsupO9oTe2ao6pkc,12
+fyers_apiv3-3.1.9.dist-info/RECORD,,

{fyers_apiv3-3.1.8.dist-info → fyers_apiv3-3.1.9.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any