Update app.py

app.py

@@ -3,30 +3,39 @@ import streamlit as st
 import gspread
 from google.oauth2.service_account import Credentials
 import ast
-
+import requests
+from datetime import datetime
+import json
 # Define the scope
+start = False
+start_time =datetime.now
+end_time =datetime.now
+starting_position = []
+tradeHistory_positions = []
 scopes = ["https://www.googleapis.com/auth/spreadsheets"]
 
 # Service account credentials as a dictionary
 service_account_info = {
     
-                            "type": "service_account",
-                            "project_id": "primetrade-433011",
-                            "private_key_id": "8bdab2f373343c045c8712c27e34f858132675df",
-                            "private_key": "-----BEGIN PRIVATE KEY-----\nMIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQCtmNCg9Jkku2+W\nRXWqnOzoLQmXrn4BJC3yk7aaSGNh254/zMrWgyejTGpWxqklv0Hnxx1qn8nb3QoP\nKmRDbJnkt4doKupXFgfxPlebelLXgRT1JDbmVCTfCp8TcG8I1/9FpFNoqvpyeMZx\nd747UfP+bqym1pdhMr6rxCUEYVcKhc/4t+04k3i0IGGWW293CXGWGD54CIeFqWQX\n+SHo20pYfh8FKamytY8LHfwk1XbX1dMjnsxsQ/xZ8IjHZ//+m3bAG7n9QPe3a724\nG3L7iTZ15VET48j55aiSi4tJvHuy/I2kzOXrm/OuHRqJ+bH5+Ze8FVbmbBQlBjn8\nI8boxVSHAgMBAAECggEAMTAHEUwtJmjLpecZf5XGVMUKHkXtYxJmyICNMWsIad5q\nGQbEhIKWFSGeUecpX04xdOSI08Dh19/qLUDkNuyLMHDGN8BNNQ7DgloZRa8j0Pc8\nwncX7SxzZBVk3IOzmmxlYsy8a4BixVOuWtFEgBdpDLM8TWupafuQZigGGxcfrBWl\njgUoga05ybjpsdxW9c9+DoXXaOPHu/QQCEbv1X3dAJHJ0My2rBaO0s+0qoDJime1\nqNms6d36TnnoD6c0qhwD/E0eZfuaijcGxarq5BBnk9qsyxud2dmZd3M8jtVV/Env\n4o1rBV9Hao/z7DKbFdqOPNSMJRtY3e+hRjgm1/feaQKBgQDhKtsMRV+Ovkvu/JdA\nHG6We0nJ/kt8czEmbbW61rvUmJbI8hAK+0TERv/mwXaQqmo6JNhCREcx17vIE7Qy\nEzThGv7hYKotrrEXZq9Dje76KmAtk2zeJPXRriRu1rixRNPRwx9F2I+B3+iXaoqx\nsenzNMSy545P0YvssJYQLnKMTwKBgQDFXi3ZxtKCUwqdOvBEsVHeE00mUbqNm+fV\nDUgxFesQ8KkwuFib29NglnbxG3hgCVpA/4BoCsM2EyuZKap3gtoMW/EZqqhb9Hu+\nfwDoiJy3DmHivq6kHeEo6V6uTDxybqgPN+Yc08X+bqflDMYXLkBuJOnE+8O38TtE\n7BROW+EOSQKBgFiXHPH6BXvLAWM4/GVcCmKohUK1C4weYlMlTSACxooBsynCm29G\npyq2aI6oxXZrpjnUL0X7SSuiHp68qeQdzGtYzLlt5+brWX/EheaFXGYO8CJeY7IP\nRqxF4M2/K5GLa++W3qIDb4sAxql0YLdDMbHfrBhbpJFg97WbUJ9zNtxfAoGAdV23\n7lUpQY6YNT+jOXYotOLNcggP473ecvdfArGCA6TZN7uoFab3X+yZ9m7bemCVZymI\n9lXQGAv2VTJNyJvrhoX2LckqLOSJ4ZIsvBrg9op68xdpSvbpuiZsw0FagMIE9mfL\nU0Er8E1lUfPyqD482kLhMN52WJ//GtE4khBZGOECgYEAwD6mhwYdgQq1rujDZF8g\nzr4Ze3hiwoKGsEvybSYjqmsJMqwLWLCe9Wsj2bPWiMJmkpYdiCC+j3Wo6A1bdWy2\nFn/2T9dO35veJwM/HjP7/jMicyVr6S86vhMfzWuqvnQtuB/HAwctH+N4lJ5z0k8w\nn6WFbBEenJv8p5vZQi0NhHg=\n-----END PRIVATE KEY-----\n",
-                            "client_email": "[email protected]",
-                            "client_id": "104595139129046465243",
-                            "auth_uri": "https://accounts.google.com/o/oauth2/auth",
-                            "token_uri": "https://oauth2.googleapis.com/token",
-                            "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
-                            "client_x509_cert_url": "https://www.googleapis.com/robot/v1/metadata/x509/myapi-994%40primetrade-433011.iam.gserviceaccount.com",
-                            "universe_domain": "googleapis.com"
+"type": "service_account",
+"project_id": "primetrade-433011",
+"private_key_id": "8bdab2f373343c045c8712c27e34f858132675df",
+"private_key": "-----BEGIN PRIVATE KEY-----\nMIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQCtmNCg9Jkku2+W\nRXWqnOzoLQmXrn4BJC3yk7aaSGNh254/zMrWgyejTGpWxqklv0Hnxx1qn8nb3QoP\nKmRDbJnkt4doKupXFgfxPlebelLXgRT1JDbmVCTfCp8TcG8I1/9FpFNoqvpyeMZx\nd747UfP+bqym1pdhMr6rxCUEYVcKhc/4t+04k3i0IGGWW293CXGWGD54CIeFqWQX\n+SHo20pYfh8FKamytY8LHfwk1XbX1dMjnsxsQ/xZ8IjHZ//+m3bAG7n9QPe3a724\nG3L7iTZ15VET48j55aiSi4tJvHuy/I2kzOXrm/OuHRqJ+bH5+Ze8FVbmbBQlBjn8\nI8boxVSHAgMBAAECggEAMTAHEUwtJmjLpecZf5XGVMUKHkXtYxJmyICNMWsIad5q\nGQbEhIKWFSGeUecpX04xdOSI08Dh19/qLUDkNuyLMHDGN8BNNQ7DgloZRa8j0Pc8\nwncX7SxzZBVk3IOzmmxlYsy8a4BixVOuWtFEgBdpDLM8TWupafuQZigGGxcfrBWl\njgUoga05ybjpsdxW9c9+DoXXaOPHu/QQCEbv1X3dAJHJ0My2rBaO0s+0qoDJime1\nqNms6d36TnnoD6c0qhwD/E0eZfuaijcGxarq5BBnk9qsyxud2dmZd3M8jtVV/Env\n4o1rBV9Hao/z7DKbFdqOPNSMJRtY3e+hRjgm1/feaQKBgQDhKtsMRV+Ovkvu/JdA\nHG6We0nJ/kt8czEmbbW61rvUmJbI8hAK+0TERv/mwXaQqmo6JNhCREcx17vIE7Qy\nEzThGv7hYKotrrEXZq9Dje76KmAtk2zeJPXRriRu1rixRNPRwx9F2I+B3+iXaoqx\nsenzNMSy545P0YvssJYQLnKMTwKBgQDFXi3ZxtKCUwqdOvBEsVHeE00mUbqNm+fV\nDUgxFesQ8KkwuFib29NglnbxG3hgCVpA/4BoCsM2EyuZKap3gtoMW/EZqqhb9Hu+\nfwDoiJy3DmHivq6kHeEo6V6uTDxybqgPN+Yc08X+bqflDMYXLkBuJOnE+8O38TtE\n7BROW+EOSQKBgFiXHPH6BXvLAWM4/GVcCmKohUK1C4weYlMlTSACxooBsynCm29G\npyq2aI6oxXZrpjnUL0X7SSuiHp68qeQdzGtYzLlt5+brWX/EheaFXGYO8CJeY7IP\nRqxF4M2/K5GLa++W3qIDb4sAxql0YLdDMbHfrBhbpJFg97WbUJ9zNtxfAoGAdV23\n7lUpQY6YNT+jOXYotOLNcggP473ecvdfArGCA6TZN7uoFab3X+yZ9m7bemCVZymI\n9lXQGAv2VTJNyJvrhoX2LckqLOSJ4ZIsvBrg9op68xdpSvbpuiZsw0FagMIE9mfL\nU0Er8E1lUfPyqD482kLhMN52WJ//GtE4khBZGOECgYEAwD6mhwYdgQq1rujDZF8g\nzr4Ze3hiwoKGsEvybSYjqmsJMqwLWLCe9Wsj2bPWiMJmkpYdiCC+j3Wo6A1bdWy2\nFn/2T9dO35veJwM/HjP7/jMicyVr6S86vhMfzWuqvnQtuB/HAwctH+N4lJ5z0k8w\nn6WFbBEenJv8p5vZQi0NhHg=\n-----END PRIVATE KEY-----\n",
+"client_email": "[email protected]",
+"client_id": "104595139129046465243",
+"auth_uri": "https://accounts.google.com/o/oauth2/auth",
+"token_uri": "https://oauth2.googleapis.com/token",
+"auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
+"client_x509_cert_url": "https://www.googleapis.com/robot/v1/metadata/x509/myapi-994%40primetrade-433011.iam.gserviceaccount.com",
+"universe_domain": "googleapis.com"
 
 
                         
     # Add your service account credentials here
 }
-
+cookie_str = "p20t=web.740861259.532251DB15AFA4E2C9D5A7A4AA7EB97E" #cookie_str get by logging into binance
+csrft = "4f341a1a0b78bfb7ddb0bfc9b093ec06" #csrf_token get by logging into binance
+trade_type= "PERPETUAL" # perpetual or delivery
 # Authenticate using the service account info
 creds = Credentials.from_service_account_info(service_account_info, scopes=scopes)
 client = gspread.authorize(creds)
@@ -42,7 +51,6 @@ sheet = workbook.worksheet("LeaderBoardHistory")
 sheet2 = workbook.worksheet("LeaderBoard")
 
 
-
 # Extract the data from the Google Sheet into a pandas DataFrame
 data = sheet.get_all_values()
 data2 = sheet2.get_all_values()
@@ -51,7 +59,7 @@ headers2 = data2.pop(0)
 df = pd.DataFrame(data, columns=headers)
 df2 = pd.DataFrame(data2,columns=headers2)
 
-
+print("df2",df2.head())
 
 def combine_chunks(df):
     combined_rows = []
@@ -61,6 +69,7 @@ def combine_chunks(df):
     
     for uid, group in grouped:
         # Combine chunks for each UID
+    
         trade_history_combined = ''.join(group['trade_history'].tolist())
         
         # Create a DataFrame for the combined row
@@ -76,37 +85,15 @@ def combine_chunks(df):
     
     return combined_df
 
-# Sample usage
-# Assuming df is already defined as your input DataFrame
-df= combine_chunks(df)
-
-
-# Ensure data types are correctly set
-df["U_IDs"] = df["U_IDs"].astype(str)
-df["trade_history"] = df["trade_history"].astype(str)
-
-df2["U_IDs"] = df2["U_IDs"].astype(str)
-df2['Positions'] = df2['Positions'].astype(str)
-# Fill NaN values with None
 df = df.fillna(value=pd.NA)
 df = df.where(pd.notnull(df), None)
-
 df2 = df2.fillna(value=pd.NA)
 df2 = df2.where(pd.notnull(df2), None)
-# Replace empty lists with None
-def replace_empty_list(lst):
-    if isinstance(lst, list) and len(lst) == 0:
-        return None
-    else:
-        return lst
 
-for col in df.columns:
-    df[col] = df[col].map(replace_empty_list)
 
-for col2 in df2.columns:
-    df2[col2] = df2[col2].map(replace_empty_list)
+df = combine_chunks(df)
+# df2 = combine_chunks(df2)
 
-# Convert string representations of lists to actual lists
 def convert_str_to_list_or_keep(value):
     if isinstance(value, str):
         try:
@@ -117,116 +104,352 @@ def convert_str_to_list_or_keep(value):
         return value
 
 df = df.apply(lambda col: col.map(convert_str_to_list_or_keep))
-df2 =df2.apply(lambda col: col.map(convert_str_to_list_or_keep))
+df2 = df2.apply(lambda col: col.map(convert_str_to_list_or_keep))
 
 uid_input = st.text_input("Enter U_IDs to filter")
 
-# Ensure `option` is defined before checking data
 option = st.radio("Choose an option:", ["Show Position History", "Show Live Positions"])
 
 if df is not None and uid_input:
-    # Filter DataFrame based on U_IDs
-    filtered_df = df[df['U_IDs'] == uid_input].copy()  # Use .copy() to avoid modifying a view
 
+    if option == "Show Position History":
+        st.title("Position History Viewer")
+        # Display starting positions with clickable rows
+        st.header("Starting Positions")
+
+        filtered_df = df[df['U_IDs'] == uid_input].copy() 
+
+        if not filtered_df.empty:
+            trade_list = filtered_df['trade_history'].iloc[0]
+        else:
+            st.write("No data found for the provided U_ID.")
+
+
+        unique_lists = []
+
+        def get_amounts_from_positions_and_closed_trades(data):
+            
+
+                    # Check if 'Modified' key exists and extract amounts
+                    if 'Modified' in data:
+                        modified_positions = data['Modified']
+                        # modified_positions = modified_positions[0]
+                        if isinstance(modified_positions, dict) and 'amount' in modified_positions:
+                                    amount = modified_positions.get('amount')
+                                    if isinstance(amount, (int, float)):  # Check if amount is a number
+                                        amounts =amount
+                    # Check if 'ClosedTrades' key exists and extract amounts
+                    if 'ClosedTrades' in data:
+                        closed_trades = data['ClosedTrades']
+                        closed_trades =closed_trades[0]
+                        if isinstance(closed_trades, dict) and 'amount' in closed_trades:
+                                    amount = closed_trades.get('amount')
+                                    if isinstance(amount, (int, float)):  # Check if amount is a number
+                                        amounts = amount
+
+                    return amounts
                 
-#     print(trade_history)
-#     print(len(trade_history))
-    def convert_to_list(value):
-        if isinstance(value, str):
-            try:
-                return ast.literal_eval(value)
-            except (ValueError, SyntaxError):
-                # Handle cases where literal_eval fails
-                return value
-        return value
+        def get_symbols_from_positions_and_closed_trades(data):
+                        
 
-# Apply the function to the 'trade_history' column
-    filtered_df['trade_history'] = filtered_df['trade_history'].apply(convert_to_list)
-    print(filtered_df['trade_history'])
+                        # Check if 'Modified' key exists and extract symbols
+                        if 'Modified' in data:
+                            modified_positions = data['Modified']
+                            # modified_positions =modified_positions
+                            if isinstance(modified_positions, dict) and 'symbol' in modified_positions:
+                                        symbol = modified_positions['symbol']
+
+                        # Check if 'ClosedTrades' key exists and extract symbols
+                        if 'ClosedTrades' in data:
+                            closed_trades = data['ClosedTrades']
+                            closed_trades =closed_trades[0]
+                            if isinstance(closed_trades, dict) and 'symbol' in closed_trades:
+                                        symbol = closed_trades['symbol']
+
+                        return symbol
+
+        for i in range(len(trade_list)):
+            
+            if trade_list[i]=="none":
+                continue
+
+            foundCLosed = False
+            changeInAmount = 0
+            
+            if 'symbol' in trade_list[i]:
+                symbol = trade_list[i]['symbol']
+                side  ="buy" if trade_list[i]['amount']>0 else "sell"
+                amount = trade_list[i]['amount']
+                symbol = trade_list[i]['symbol']
+                if start==False:
+                 start_time = trade_list[i]['updateTime'] 
+                 start =True
+
+                trade_list[i]['side'] =side
+                trade_list[i]['changeInAmount'] = changeInAmount
+                trade_list[i]['i'] = i
+                unique_lists.append({"position":trade_list[i]})
+                trade_list[i] = "none"
+                
 
-    # Ensure 'trade_history' column contains lists
-    filtered_df['trade_history'] = filtered_df['trade_history'].apply(lambda x: x if isinstance(x, list) else [x])
-    print(filtered_df)
+            else:    
+                if 'positions' in trade_list[i]:
+                    reached = False
+                    # Collect necessary data first before modifying the dictionary
+                    for k, v in list(trade_list[i].items()):  # Convert to a list to avoid modifying during iteration
+                        for entry in v:
+                            if 'NewPosition' in entry:
+                                new_position = entry.get('NewPosition', {})
+                                # Extract symbol and amount
+                                symbol = new_position.get('symbol')
+                                amount = new_position.get('amount')
+                                if start==False:
+                                    start_time = new_position.get('updateTime')
+                                    start =True
+                                side = "buy" if amount > 0 else "sell"
+                                new_position['side'] = side
+                                new_position['changeInAmount'] = changeInAmount
+                                new_position['i'] = i
+                                # Update the entry with the modified 'NewPosition'
+                                entry['NewPosition'] = new_position
+                                
+                                # Append the updated trade_list[i] to unique_lists
+                                unique_lists.append(trade_list[i])
+
+                                reached = True
+
+                    # Now safely modify the dictionary after iteration is complete
+                    if reached:
+                        trade_list[i] = "none"
+
+                    # Now safely modify the dictionary after iteration is complete
+                                
+
+            for j in range(i+1, len(trade_list)):
+                if trade_list[j] == "none":
+                    continue
+
+                if 'positions' in trade_list[j] and isinstance(trade_list[j]['positions'], list):
+                    for position in trade_list[j]['positions']:
+                        # Check if 'Modified' is in the position and is a dict
+                        if 'Modified' in position and isinstance(position['Modified'], dict):
+                            if start==False:
+                                start_time =  datetime.now()
+                                start =True
+                            modified_amount = get_amounts_from_positions_and_closed_trades(position)
+                            modified_symbol = get_symbols_from_positions_and_closed_trades(position)
+
+                            if modified_amount > 0:
+                                modified_side = "buy"
+                            else:
+                                modified_side = "sell"
+                            
+                            if symbol == modified_symbol and side == modified_side:
+                                position['Modified']['side'] = modified_side
+                                position['Modified']['changeInAmount'] = amount - modified_amount if modified_amount < 0 else modified_amount - amount
+                                position['Modified']['i'] = i
+                                amount = modified_amount
+                                unique_lists.append(trade_list[j])
+                                trade_list[j] = "none"
+                        
+                        # Check if 'ClosedTrades' is in the position and is a tuple
+                        if 'ClosedTrades' in position and isinstance(position['ClosedTrades'], tuple):
+                            if start==False:
+                                start_time =  datetime.now()
+                                start =True
+                            foundCLosed = False
+                            closed_trades_tuple = position['ClosedTrades']
+                            closed_trades_dict = {
+                                'trade_info': closed_trades_tuple[0],
+                                'side': closed_trades_tuple[1]
+                            }
+                            
+                            closed_amount = get_amounts_from_positions_and_closed_trades(position)
+                            closed_symbol = get_symbols_from_positions_and_closed_trades(position)
+
+                            if closed_amount > 0:
+                                closed_side = "buy"
+                            else:
+                                closed_side = "sell"
+
+                            if symbol == closed_symbol and side == closed_side:
+                                closed_trades_dict['side'] = closed_side
+                                trade_info = closed_trades_dict['trade_info']
+                                trade_info['changeInAmount'] = amount - closed_amount if closed_amount < 0 else closed_amount - amount
+                                amount = closed_amount
+                                print("Reached closed trade")
+                                closed_trades_dict['trade_info']['i'] = i  # Store index 'i' inside 'ClosedTrades'
+                                closed_trades_dict['trade_info']['closed'] = True
+
+                                # Update the position with the new dictionary
+                                position['ClosedTrades'] = (closed_trades_dict['trade_info'], closed_trades_dict['side'])
+                                
+                                # Append the updated trade_list[j] to unique_lists
+                                unique_lists.append(trade_list[j])
+                                trade_list[j] = "none"
+                                foundCLosed = True
+                                break
+
+                        # Break the inner loop if a closed trade was found
+                if foundCLosed:
+                            break        
+
+
+                                                
+                            
+            for k in range(len(unique_lists)):
+                data = unique_lists[k]
+                            
+
+                if k ==0: 
+                    
+                    
+                    if 'positions' in data:
+                        if isinstance(data['positions'], list):
+                            for a in data['positions']:
+                                if 'NewPosition' in a:
+                                    
+                                    position_data = a['NewPosition']
+                                    starting_position.append(position_data)
+                                    tradeHistory_positions.append(position_data)
+                                    
+
+                    else:
+                        if 'position' in data:
+                            position_data =data['position']
+                            starting_position.append(position_data)
+                            tradeHistory_positions.append(position_data)
 
-    
+                        
+                
+                if 'positions' in data:
+                    if isinstance(data['positions'],list):
+                        for a in data['positions']:
+                                if 'ClosedTrades' in a:
+                                    position_data = a['ClosedTrades'][0]
+                                    tradeHistory_positions.append(position_data)
 
-    # Flatten nested lists in 'trade_history'
-   
 
 
+                if 'positions' in data:
+                    if isinstance(data['positions'],list):
+                        for a in data['positions']:
+                                if 'Modified' in a:
+                                    position_data = a['Modified']
+                                    tradeHistory_positions.append(position_data)
 
-    if not filtered_df.empty:
-        if option == "Show Position History":
-            st.subheader("Position History")
-            # Similar code for displaying position history
-            modified_positions = []
-            new_positions = []
-            sell_positions = []
-        
 
-            for index, row in filtered_df.iterrows():
-                trade_history = row['trade_history']
+                
 
+            unique_lists =[]
 
-                if isinstance(trade_history, list):
+    elif option == "Show Live Positions":
+        filtered_df2 = df2[df2['U_IDs'] == uid_input]
 
-                    
-                    
-                    print("type",type(trade_history))
-                    for record in trade_history:
-                        if isinstance(record, dict):
-                            if 'symbol' in record:
-                                new_positions.append(record)
-                            if 'positions' in record:
-                                positions = record['positions']
-                                if isinstance(positions, list):
-                                    for pos in positions:
-                                            if 'Modified' in pos:
-                                                modified_positions.extend(pos['Modified'])
-                                            if 'NewPosition' in pos:
-                                                new_positions.extend(pos['NewPosition'])
-                                            if 'ClosedTrades' in pos:
-                                                sell_positions.extend(pos['ClosedTrades'])
-
-            if new_positions:
-                new_positions_df = pd.DataFrame(new_positions)
-                st.subheader("New Positions")
-                st.dataframe(new_positions_df)
-            else:
-                st.subheader("New Positions")
-                st.write("No data available")
+        if not filtered_df2.empty:
+            print("Filtered DataFrame for UID:", filtered_df2)
+
+            positions_list = filtered_df2['Positions'].iloc[0]  # Extract the first match
 
-            if modified_positions:
-                modified_positions_df = pd.DataFrame(modified_positions)
-                st.subheader("Modified Positions")
-                st.dataframe(modified_positions_df)
+            # Convert the list of dictionaries to a DataFrame
+            if isinstance(positions_list, list) and positions_list:
+                positions_df = pd.DataFrame(positions_list)
+                st.subheader("Live Positions")
+                st.dataframe(positions_df)
             else:
-                st.subheader("Modified Positions")
-                st.write("No data available")
+                st.write("No live positions data available for the given U_ID.")
+            
+            url = "https://www.binance.com/bapi/futures/v2/public/future/leaderboard/getOtherPerformance"
+
+        def performance_request(uid):
+            heading = {
+                'Clienttype': 'web',
+                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36',
+                'Csrftoken': csrft,
+                'Cookie': cookie_str 
+            } 
+            payload = {"encryptedUid": uid, "tradeType": trade_type}
+            response = requests.post(url, headers=heading, json=payload)
+            
+            if response.status_code == 200:
+                response_data = response.json()
+                if response_data['data'] is not None:
+                    other_performance_list = response_data['data']['performanceRetList']
+                    if other_performance_list:
+                        return other_performance_list
+                    else:
+                        return None
+                else:
+                    return None
+            else:
+                return None
+
+        def check_request(uid):
+            heading = {
+                'Clienttype': 'web',
+                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36',
+                'Csrftoken': csrft,
+                'Cookie': cookie_str 
+            } 
+            payload = {"encryptedUid": uid, "tradeType": trade_type}
+
+            response = requests.post(url, headers=heading, json=payload)  
+            return response.status_code == 200
+
+        # Check if we are logged in
+        if check_request(uid_input):
+            print(f"We are logged in! Fetching performance for UID: {uid_input}")
+
+            # Fetch performance for the specific uid_input
+            performance_data = performance_request(uid_input)
+            if performance_data:
+                print(f"Performance data for UID {uid_input}: {performance_data}")
+
+                # Display performance data as a DataFrame in the UI
+                performance_df = pd.DataFrame(performance_data)
+                st.subheader("Performance Data")
+                st.dataframe(performance_df)  # Show the performance data as a table in the UI
 
-            if sell_positions:
-                sell_positions_df = pd.DataFrame(sell_positions)
-                st.subheader("Sell Positions")
-                st.dataframe(sell_positions_df)
+                
             else:
-                st.subheader("Sell Positions")
-                st.write("No data available")
+                st.write(f"No performance data available for UID {uid_input}")
+        else:
+            st.write("We are logged out, please update cookie_str and csrft!")
+
         
-        elif option == "Show Live Positions":
-            filtered_df2 = df2[df2['U_IDs'] == uid_input]
-
-            if not filtered_df2.empty:
-                # Assuming 'Positions' contains the list of dictionaries
-                positions_list = filtered_df2['Positions'].iloc[0]  # Extracting the first match
-
-                # Convert the list of dictionaries to a DataFrame
-                if isinstance(positions_list, list) and positions_list:
-                    positions_df = pd.DataFrame(positions_list)
-                    st.subheader("Live Positions")
-                    st.dataframe(positions_df)
-                else:
-                    st.write("No live positions data available for the given U_ID.")
 
+
+
+    def main():
+
+        df_starting = pd.DataFrame(starting_position)
+
+        for index, row in df_starting.iterrows():
+            if row['amount']>0:
+                side =True
+            else:
+                side = False
+            if st.button(f"{row['symbol']} : Long: {side},  Entry Price: {row['entryPrice']}, Market Price :{row['markPrice']}  Amount: {row['amount']}, leverage: {row['leverage']}, Time: {row['updateTimeStamp']}"):
+                show_position_history(row['i'])
+
+    def show_position_history(selected_position):
+        st.header(f"History for {selected_position}")
         
-    else:
-        st.write("No data to display. Please check the U_IDs and try again.")
+        # Filter trade history for the selected position
+        position_history = [pos for pos in tradeHistory_positions if pos['i'] == selected_position]
+        
+        if position_history:
+            df_history = pd.DataFrame(position_history)
+            st.dataframe(df_history)
+        else:
+            st.write("No history found for this position.")
+
+    if __name__ == "__main__":
+        main()
+        
+                    
+
+    
+
+
+