Upload folder using huggingface_hub

patchy_trades.py

@@ -4,6 +4,8 @@ import pandas as pd
 import gradio as gr
 import os
 from datetime import datetime
+from pymongo import MongoClient
+import urllib
 
 
 
@@ -48,6 +50,7 @@ wallets = [
 
 API_TOKEN = os.getenv('SOLSCAN_KEY')
 
+
 headers = {
     "token": API_TOKEN
 }
@@ -116,11 +119,148 @@ def get_token_delta(row):
     else:
         return None  # or 'other', if you prefer
 
+#LIMIT ORDERS ===================================================================================
+
+SCRAPE_DO_TOKEN = os.getenv('SCRAPE_DO_TOKEN')
+client = MongoClient(os.getenv('MONGO_DB_URI'))
+db_1 = client["billy_balances"]
+token_collection = db_1["turnstile-tokens"]
+
+turnstile_token = token_collection.find_one(sort=[("timestamp", -1)])['x-turnstile-token']
+
+common_headers = {
+    "accept": "application/json",
+    "accept-encoding": "identity",
+    "accept-language": "en-GB,en-US;q=0.9,en;q=0.8",
+    "authorization": "Bearer CGtF4EdvDbBpwUXmZSKW3HsYkajy7e",
+    "content-type": "application/json",
+    "origin": "https://portfolio.jup.ag",
+    "referer": "https://portfolio.jup.ag/",
+    "user-agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36",
+    "x-turnstile-token": turnstile_token  # keep this updated
+}
+
+async def fetch_portfolio(session, wallet_address, results):
+    base_url = f"https://portfolio-api-jup.sonar.watch/v1/portfolio/fetch?address={wallet_address}&addressSystem=solana"
+    encoded_url = urllib.parse.quote(base_url)
+    proxy_url = f"http://api.scrape.do/?token={SCRAPE_DO_TOKEN}&url={encoded_url}&forwardHeaders=True&super=True"
+
+    try:
+        async with session.get(proxy_url, headers=common_headers) as resp:
+            text = await resp.json()
+            if resp.status == 200:
+                print(f"✅ Wallet {wallet_address[:6]}...: success")
+                results.append({"wallet": wallet_address,"data": text})
+            else:
+                print(f"❌ Wallet {wallet_address[:6]}...: HTTP {resp.status}")
+                results.append({"wallet": wallet_address, "data": None})
+    except Exception as e:
+        print(f"⚠️ Error fetching {wallet_address}: {e}")
+        results.append({"wallet": wallet_address, "status": "error", "error": str(e)})
+
+BATCH_SIZE = 20
+
+async def get_data(wallet_addresses):
+    results = []
+
+    async with aiohttp.ClientSession() as session:
+        # Split addresses into batches
+        for i in range(0, len(wallet_addresses), BATCH_SIZE):
+            batch = wallet_addresses[i:i + BATCH_SIZE]
+            tasks = [fetch_portfolio(session, address, results) for address in batch]
+            await asyncio.gather(*tasks)
+            await asyncio.sleep(0.5)  # optional: rate limit delay
+
+    return results
+
+all_elements = []
+
+async def process_limits():
+  portfolios = await get_data(wallets)
+  df = pd.DataFrame(portfolios)
+
+  print(df)
+
+  for index, row in df.iterrows():
+    data = row['data']
+    original_row = row['wallet'] 
+
+    # Token info mapping
+    token_info = data.get('tokenInfo', {}).get('solana', {})
+
+    # Navigate to assets list
+    elements = data.get('elements', [])
+    for element in elements:
+        if element.get("platformId") == "jupiter-exchange":
+            element['wallet'] = original_row
+            all_elements.append(element)
+            '''input_token = element.get("data", {}).get("assets", {}).get("input", {})
+            if input_token:
+                token_data = input_token.get("data", {})
+                address = token_data.get("address")
+                value = input_token.get("value")
+                amount = token_data.get("amount")
+                symbol = token_info.get(address, {}).get("symbol", address)
+
+                jup_rows.append({
+                    "original_row": original_row,
+                    "address": address,
+                    "symbol": symbol,
+                    "amount": amount,
+                    "value": value
+                })'''
+    
+
+async def process_limitss():
+    await process_limits()
+    order_df = pd.json_normalize(all_elements)
+    print(order_df)
+
+    def classify_type(row):
+        if row['data.inputAddress'] == '6D6ccmg71x56V5Je1Mh82MFPYL38gaZqNc2LG1XMbonk':
+            return 'sell'
+        elif row['data.outputAddress'] == '6D6ccmg71x56V5Je1Mh82MFPYL38gaZqNc2LG1XMbonk':
+            return 'buy'
+        else:
+            return None  # or 'other', if you prefer
+
+    order_df['type'] = order_df.apply(classify_type, axis=1)
+    def get_token_amounts(row):
+        if row['type'] == 'sell':
+            return float(row['data.assets.input.data.amount'])
+        elif row['type'] == 'buy':
+            return float(row['data.expectedOutputAmount'])
+        else:
+            return None  # or 'other', if you prefer
+
+    order_df['base_token_amount'] = order_df.apply(get_token_amounts, axis=1)
+    order_df['outputValue'] = order_df['data.outputPrice'] * order_df['data.expectedOutputAmount']
+    def get_price(row):
+        if row['type'] == 'buy':
+            return row['value']/row['base_token_amount']
+        elif row['type'] == 'sell':
+            return row['outputValue']/row['base_token_amount']
+        else:
+            return None
+
+    order_df['price'] = order_df.apply(get_price,axis=1)
+    order_df = order_df[['wallet','label','type','value','price','data.inputAddress','data.outputAddress','data.filledPercentage']]
+    order_df = order_df.rename(columns={'label':'order type','data.inputAddress':'token in','data.outputAddress':'token out','data.filledPercentage':'filled percentage'})
+    order_df = order_df.rename(columns={'type':'side','order type':'type','value':'value($)'})
+    order_df = order_df.sort_values('price',ascending=False).reset_index(drop=True)
+    order_df['wallet number'] = order_df['wallet'].apply(lambda x : wallets.index(x) + 1)
+    order_df = order_df[[order_df.columns[-1]] + list(order_df.columns[:-1])]
+
+    return order_df
+
+
+
 # Setup sync wrapper
 async def main():
     # Run async main and prepare data
     # Run the async code
     final_df = await process()
+    order_df = await process_limitss()
 
     cols_to_convert = ['routers.amount1', 'routers.token1_decimals']
     final_df[cols_to_convert] = final_df[cols_to_convert].apply(pd.to_numeric, errors='coerce')
@@ -154,11 +294,13 @@ async def main():
         lambda x: datetime.fromisoformat(x.replace("Z", "+00:00")).strftime("%B %d, %Y at %I:%M %p (UTC)")
     )
 
-    return final_df
+    return final_df,order_df
 
 # Async display function
 async def display_results():
-    final_df = await main()
+    both_dfs = await main()
+    final_df = both_dfs[0]
+    order_df = both_dfs[1]
     dollar_delta = final_df['dollar delta'].sum()
     token_delta = final_df['token delta'].sum()
     avg_position = abs(dollar_delta / token_delta)
@@ -168,14 +310,15 @@ async def display_results():
         f"**Token delta:** {token_delta:.2f}  \n"
         f"**Avg position:** {avg_position:.6f}"
     )
-    return final_df, metrics
+    return final_df,order_df,metrics
 
 # Gradio UI with async load
 with gr.Blocks() as demo:
     gr.Markdown("# Patchy Trades")
     df_output = gr.Dataframe(label="All Trades")
+    order_output = gr.Dataframe(label="All Jupiter Orders")
     metrics_output = gr.Markdown(label="Metrics Summary")
     
-    demo.load(fn=display_results, outputs=[df_output, metrics_output])
+    demo.load(fn=display_results, outputs=[df_output, order_output,metrics_output])
 
 demo.launch()