fyers-apiv3 3.1.6__py3-none-any.whl → 3.1.8__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/FyersWebsocket/tbt_ws.py

@@ -502,7 +502,7 @@ class FyersTbtSocket:
             if self.onopen:
                 self.onopen()
                 open_chans = self._subsinfo.getChannelInfo()
-                self.switchChannel(self._subsinfo.getChannelInfo(), Set())
+                self.switchChannel(self._subsinfo.getChannelInfo(), set())
                 for channel in open_chans:
                     self.subscribe(self._subsinfo.getSymbolsInfo(channel), channel, self._subsinfo.getModeInfo(channel))
         except Exception as e:

fyers_apiv3/fyersModel.py

@@ -41,6 +41,10 @@ class Config:
     option_chain = "/options-chain-v3"
     multileg_orders = "/multileg/orders/sync"
     logout = "/logout"
+    price_alert ="/price-alert"
+    toggle_alert = "/toggle-alert"
+    triggered_alerts = "/triggered-alerts"
+    
 
 
 
@@ -264,6 +268,55 @@ class FyersServiceSync:
             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 = requests.put(
+                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
+
 class FyersServiceAsync:
     def __init__(self, logger, request_logger):
         """
@@ -489,6 +542,58 @@ 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
+            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 
+                
+        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
+
 
 
 class SessionModel:
@@ -1133,4 +1238,144 @@ 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.
+                - '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.
+
+        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.
+                - '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)
+
+        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 by its ID.
+
+        Args:
+            data (dict): A dictionary containing the alert ID to delete.
+                - 'id' (str, mandatory): Alert ID to be deleted.
+
+        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.
+                - '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.
+
+        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 trending_alert(self) -> 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.
+
+        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
+        """
+        if self.is_async:
+            response = self.service.get_async_call(Config.trending_alert, self.header)
+        else:
+            response = self.service.get_call(Config.trending_alert, self.header)
+        return response
+    
+    

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: fyers_apiv3
-Version: 3.1.6
+Version: 3.1.8
 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
 
@@ -531,4 +532,91 @@ fyers = order_ws.FyersOrderSocket(
 fyers.connect()
 
 
+```
+
+## Getting started with TBT Socket
+
+```python
+from  fyers_apiv3.FyersWebsocket.tbt_ws import FyersTbtSocket, SubscriptionModes
+
+def on_depth_update(ticker, message):
+    """
+    Callback function to handle incoming messages from the FyersDataSocket WebSocket.
+
+    Parameters:
+        ticker (str): The symbol for which the message is received.
+        message (dict): The received message from the WebSocket.
+
+    """
+    print("Depth Response:", ticker, message)
+
+
+def onerror_message( message):
+    """
+    Callback function to handle incoming messages from the FyersDataSocket WebSocket.
+
+    Parameters:
+        message (str): error message from the server
+
+    """
+    print("server returned error:", message)
+
+
+def onerror(message):
+    """
+    Callback function to handle WebSocket errors.
+
+    Parameters:
+        message (dict): The error message received from the WebSocket.
+
+
+    """
+    print("Error:", message)
+
+
+def onclose(message):
+    """
+    Callback function to handle WebSocket connection close events.
+    """
+    print("Connection closed:", message)
+
+
+def onopen():
+    """
+    Callback function to subscribe to data type and symbols upon WebSocket connection.
+
+    """
+    print("Connection opened")
+    # Specify the data type and symbols you want to subscribe to
+    mode = SubscriptionModes.DEPTH
+    Channel = '1'
+    # Subscribe to the specified symbols and data type
+    symbols = ['NSE:NIFTY25MARFUT']
+    
+    fyers.subscribe(symbol_tickers=symbols, channelNo=Channel, mode=mode)
+    fyers.switchChannel(resume_channels=[Channel], pause_channels=[])
+
+    # Keep the socket running to receive real-time data
+    fyers.keep_running()
+
+
+# Replace the sample access token with your actual access token obtained from Fyers
+access_token = "XCXXXXXXM-100:eyJ0tHfZNSBoLo"
+
+fyers = FyersTbtSocket(
+    access_token=access_token,  # Your access token for authenticating with the Fyers API.
+    write_to_file=False,        # A boolean flag indicating whether to write data to a log file or not.
+    log_path="",                # The path to the log file if write_to_file is set to True (empty string means current directory).
+    on_open=onopen,          # Callback function to be executed upon successful WebSocket connection.
+    on_close=onclose,           # Callback function to be executed when the WebSocket connection is closed.
+    on_error=onerror,           # Callback function to handle any WebSocket errors that may occur.
+    on_depth_update=on_depth_update, # Callback function to handle depth-related events from the WebSocket
+    on_error_message=onerror_message         # Callback function to handle server-related erros from the WebSocket.
+)
+
+
+# Establish a connection to the Fyers WebSocket
+fyers.connect()
+
+
 ```

{fyers_apiv3-3.1.6.dist-info → fyers_apiv3-3.1.8.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=YeztWqabCf0PTdIYEcDWaBaSM_u6uFqchjbcs2pPh6k,56119
 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/tbt_ws.py,sha256=-UUO9LD3FVjre23m7SfVpJ44HcMBACPAnSUyWIS3yPA,21191
-fyers_apiv3-3.1.6.dist-info/LICENSE.txt,sha256=_a5I4lWvSmoZQxwGSPGVVvUbuYby780N9YevsBqNY3k,1063
-fyers_apiv3-3.1.6.dist-info/METADATA,sha256=vLA3LkYMTBqA-oMR26HEPEBFxmQdU04_zqg7F8nVKnE,16478
-fyers_apiv3-3.1.6.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
-fyers_apiv3-3.1.6.dist-info/top_level.txt,sha256=IaT774gXqIM6uJpgCQPvXruJBOINsupO9oTe2ao6pkc,12
-fyers_apiv3-3.1.6.dist-info/RECORD,,
+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.6.dist-info → fyers_apiv3-3.1.8.dist-info}/WHEEL

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