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

fyers_apiv3/FyersWebsocket/order_ws.py

@@ -124,6 +124,10 @@ class FyersOrderSocket:
             for key , value in self.position_mapper.items():
                 if key in msg["positions"]:
                     position_data[value] = msg["positions"][key]
+            
+            # Add id_fyers only if the key is present
+            if "id_fyers" in msg["positions"]:
+                position_data["id_fyers"] = msg["positions"]["id_fyers"]
 
             return { "s": msg["s"], "positions": position_data}
 
@@ -146,8 +150,10 @@ class FyersOrderSocket:
             for key , value in self.trade_mapper.items():
                 if key in msg["trades"]:
                     trade_data[value] = msg["trades"][key]
-
-
+            
+            # Add id_fyers only if the key is present
+            if "id_fyers" in msg["trades"]:
+                trade_data["id_fyers"] = msg["trades"]["id_fyers"]
 
             return { "s": msg["s"], "trades": trade_data}
 
@@ -169,7 +175,11 @@ class FyersOrderSocket:
             for key , value in self.order_mapper.items():
                 if key in msg["orders"]:
                     order_data[value] = msg["orders"][key]
-            order_data["orderNumStatus"] =  msg["orders"]["id"] + ":" + str(msg["orders"]["org_ord_status"])
+                    
+            # Add id_fyers only if the key is present
+            if "id_fyers" in msg["orders"]:
+                order_data["id_fyers"] = msg["orders"]["id_fyers"]
+            
             return { "s": msg["s"], "orders": order_data}
 
         except Exception as e:

fyers_apiv3/fyersModel.py

@@ -41,6 +41,22 @@ class Config:
     option_chain = "/options-chain-v3"
     multileg_orders = "/multileg/orders/sync"
     logout = "/logout"
+    price_alert ="/price-alert"
+    toggle_alert = "/toggle-alert"
+    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"
+    
+    
+    
 
 
 
@@ -51,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:
@@ -73,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"},
@@ -129,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,
@@ -179,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"},
@@ -229,7 +247,56 @@ 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"},
+            )
+            self.request_logger.debug({"Status Code":response.status_code, "API":api  })
+            self.api_logger.debug({"URL": URL, "data": json.dumps(data), \
+                                   "Response Status Code": response.status_code, \
+                                   "Response": response.json()})
+            response.raise_for_status()            
+            return response.json()
+
+        except requests.HTTPError as e:
+            self.api_logger.error({"API":api, "Error": response.json()})
+            return response.json()
+        
+        except TypeError as e:
+            if "response" in locals():
+                self.error_resp["code"] = response.status_code
+            else:
+                self.error_resp["code"] = -99
+                self.error_resp["message"]=self.error_message
+            self.api_logger.error({"API": api, "error": e})
+            self.api_logger.debug({"URL": URL,"data": json.dumps(data),"message": self.error_resp})
+            return self.error_resp 
+                 
+        except Exception as e:
+            if "response" in locals():
+                self.error_resp["code"] = response.status_code
+            else:
+                self.error_resp["code"] = -99
+            self.api_logger.error({"API": api, "error": e})
+            self.api_logger.debug({"URL": URL,"data": json.dumps(data),"message": e})
+            return self.error_resp
+
+    def put_call(self, api: str, header: str, data) -> dict:
+        """
+        Makes a PUT request to the specified API.
+
+        Args:
+            api: The API endpoint to make the request to.
+            header: The authorization header for the request.
+            data: The data to send in the request payload.
+
+        Returns:
+            The response JSON as a dictionary, or the response object if an error occurs.
+        """
+        try:
+            URL = Config.API + api
+            response = self.session.put(
                 URL,
                 data=json.dumps(data),
                 headers={"Authorization": header, "Content-Type": self.content ,"version": "3"},
@@ -271,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:
@@ -293,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)})
@@ -349,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)})
@@ -401,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)})
@@ -451,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)})
@@ -489,6 +566,68 @@ class FyersServiceAsync:
             self.api_logger.debug({"URL": url,"data": json.dumps(data),"message": e})
             return self.error_resp
 
+    async def put_async_call(self, api: str, header: str, data) -> dict:
+        """
+        Makes an asynchronous PUT request to the specified API.
+
+        Args:
+            api: The API endpoint to make the request to.
+            header: The authorization header for the request.
+            data: The data to send in the request payload.
+
+        Returns:
+            The response JSON as a dictionary, or the response object if an error occurs.
+        """
+        try:
+            url = Config.API + api
+            # 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)})
+            return await response.json()
+        
+        except TypeError as e:
+            if "response" in locals():
+                self.error_resp["code"] = response.status
+            else:
+                self.error_resp["code"] = -99
+                self.error_resp["message"]=self.error_message
+            self.api_logger.error({"API": api, "error": e})
+            self.api_logger.debug({"URL": url,"data": json.dumps(data),"message": self.error_resp})
+            return self.error_resp 
+                 
+        except Exception as e:
+            if "response" in locals():
+                self.error_resp["code"] = response.status
+            else:
+                self.error_resp["code"] = -99
+            self.api_logger.error({"API": api, "error": e})
+            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:
@@ -590,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:
         """
@@ -814,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.
@@ -1133,4 +1273,560 @@ class FyersModel:
             response = self.service.get_call(
                 Config.option_chain, self.header, data, data_flag=True
             )
-        return response
+        return response
+    
+    def create_alert(self, data) -> dict:
+        """
+        Creates a new price alert for a user.
+
+        Args:
+            data (dict): A dictionary containing the alert details.
+                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.
+        """
+        if self.is_async:
+            response = self.service.post_async_call(Config.price_alert, self.header, data)
+        else:
+            response = self.service.post_call(Config.price_alert, self.header, data)
+        return response
+       
+    def get_alert(self, data=None) -> dict:
+        """
+        Retrieves alert details. If data with 'id' is provided, filters alerts by ID(s).
+        Otherwise, returns all alerts. Supports fetching archived alerts via 'archive' parameter.
+
+        Args:
+            data (dict, optional): Optional dictionary containing query parameters.
+                - 'archive' (int, optional): Set to 1 to retrieve archived alerts instead of active alerts.
+                    Default: 0 (active alerts)
+
+        Returns:
+            The response JSON as a dictionary :
+        """
+        if data is None:
+            data = {}
+        
+        if self.is_async:
+            response = self.service.get_async_call(Config.price_alert, self.header, data)
+        else:
+            response = self.service.get_call(Config.price_alert, self.header, data)
+        return response
+
+    def delete_alert(self, data) -> dict:
+        """
+        Deletes a price alert.
+
+        Args:
+            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.
+        """
+        if self.is_async:
+            response = self.service.delete_async_call(Config.price_alert, self.header, data)
+        else:
+            response = self.service.delete_call(Config.price_alert, self.header, data)
+        return response     
+
+    def update_alert(self, data) -> dict:
+        """
+        Modifies the parameters of an existing alert based on the provided details.
+
+        Args:
+            data (dict): A dictionary containing the alert modification details.
+                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.
+        """
+        if self.is_async:
+            response = self.service.put_async_call(Config.price_alert, self.header, data)
+        else:
+            response = self.service.put_call(Config.price_alert, self.header, data)
+        return response
+
+    def toggle_alert(self, data) -> dict:
+        """
+        Toggles the status of an existing alert between enabled (1) and disabled (2).
+        If the alert is currently disabled, it will be enabled. If enabled, it will be disabled.
+
+        Args:
+            data (dict): A dictionary containing the alert toggle details.
+                - 'alertId' (str, mandatory): ID of the alert to be toggled. Eg: "3870991"
+
+        Returns:
+            The response JSON as a dictionary with success message indicating the alert status has been modified.
+        """
+        if self.is_async:
+            response = self.service.put_async_call(Config.toggle_alert, self.header, data)
+        else:
+            response = self.service.put_call(Config.toggle_alert, self.header, data)
+        return response
+    
+    def create_smart_order_step(self, data: dict) -> dict:
+        """
+        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:
+            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.post_async_call(Config.create_smartorder_trail, self.header, data)
+        else:
+            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.7.dist-info → fyers_apiv3-3.1.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: fyers_apiv3
-Version: 3.1.7
+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
@@ -15,13 +15,14 @@ Requires-Dist: asyncio==3.4.3
 Requires-Dist: aiohttp==3.9.3
 Requires-Dist: aws_lambda_powertools==1.25.5
 Requires-Dist: websocket-client==1.6.1
-Requires-Dist: protobuf==5.29.3
+Requires-Dist: setuptools==68.0.0
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier
 Dynamic: description
 Dynamic: description-content-type
 Dynamic: home-page
+Dynamic: license-file
 Dynamic: requires-dist
 Dynamic: summary
 
@@ -181,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))
@@ -349,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
@@ -436,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.7.dist-info → fyers_apiv3-3.1.9.dist-info}/RECORD

@@ -1,15 +1,15 @@
 fyers_apiv3/__init__.py,sha256=1vA_F8dAtLKcyOqrmdUOkw1Syl8gIFUtxDoLde8y94E,18
-fyers_apiv3/fyersModel.py,sha256=MHo1NWgphuZBUx-t1VAnqsuLZZS_-9P5xwWOBMIwj_U,45096
+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
 fyers_apiv3/FyersWebsocket/defines.py,sha256=mhKkkQ6FZHFa6e0_83cRYMOucmSn5yHtcod1Jn2ygCc,1143
 fyers_apiv3/FyersWebsocket/map.json,sha256=GfAgk-zqzUki5Cu0ZlG08PiMhfKTyGIsPo62mIYotZ4,10075
 fyers_apiv3/FyersWebsocket/msg_pb2.py,sha256=Po6emBFB6aCmt3rkuN6zjDA7JEzsixejfNSOQYtYgnE,6272
-fyers_apiv3/FyersWebsocket/order_ws.py,sha256=npLBtCcpPxclc5YRaVtLvBkRDCF3oV9NabK_y5EwoAk,16998
+fyers_apiv3/FyersWebsocket/order_ws.py,sha256=B0ioHcFinlu40zIYWiU6nLpiEmID3317R_9gdmiPh5M,17451
 fyers_apiv3/FyersWebsocket/tbt_ws.py,sha256=rlg0taA9KCS8YbyKZ8UxqRw5rUcqRETz0sbM9KBUcF0,21191
-fyers_apiv3-3.1.7.dist-info/LICENSE.txt,sha256=_a5I4lWvSmoZQxwGSPGVVvUbuYby780N9YevsBqNY3k,1063
-fyers_apiv3-3.1.7.dist-info/METADATA,sha256=JOgjxfBjmTzfhPPt_A0rxaA_ThhD1Tf9_7TZBtKfTro,19232
-fyers_apiv3-3.1.7.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
-fyers_apiv3-3.1.7.dist-info/top_level.txt,sha256=IaT774gXqIM6uJpgCQPvXruJBOINsupO9oTe2ao6pkc,12
-fyers_apiv3-3.1.7.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.7.dist-info → fyers_apiv3-3.1.9.dist-info}/WHEEL

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