Changed to using user id

app.py

@@ -36,14 +36,13 @@ if torch.cuda.is_available():
     torch.cuda.manual_seed_all(SEED)
 
 # Global variables
-global G, features, usernames, pyg_data, trained_model
+global G, features, user_ids, pyg_data, trained_model
 G = None
 features = None
-usernames = None
+user_ids = None
 pyg_data = None
 trained_model = None
 
-SUPABASE_ID = os.getenv('supabaseID')
 SUPABASE_URL = os.getenv('supabaseUrl')
 SUPABASE_KEY = os.getenv('supabaseAnonKey')
 
@@ -53,32 +52,27 @@ def get_supabase_client():
 def load_and_preprocess_data():
     supabase = get_supabase_client()
     followers_response = supabase.table('followers').select('*').execute()
-    users_response = supabase.table('profiles').select('id, username').execute()
+    users_response = supabase.table('profiles').select('id').execute()
 
     followers = pd.DataFrame(followers_response.data)
     users = pd.DataFrame(users_response.data)
 
-    merged = followers.merge(users[['id', 'username']],
-                             left_on='following', right_on='id', how='left')
-    merged = merged.rename(columns={'username': 'follower_username'}).drop(columns=['id_y'])
+    merged = followers.merge(users, left_on='following', right_on='id', how='left')
+    merged = merged.rename(columns={'id_x': 'follower_id', 'id_y': 'followed_id'})
 
-    merged = merged.merge(users[['id', 'username']],
-                           left_on='id_x', right_on='id', how='left')
-    merged = merged.rename(columns={'username': 'followed_username'})
-
-    merged = merged[['follower_username', 'followed_username']].dropna()
-    return merged[(merged['follower_username'] != '') & (merged['followed_username'] != '')]
+    merged = merged[['follower_id', 'followed_id']].dropna()
+    return merged[(merged['follower_id'] != '') & (merged['followed_id'] != '')]
 
 def create_graph_dataframe(merged_df):
-    G = nx.from_pandas_edgelist(merged_df, source='follower_username', target='followed_username', create_using=nx.DiGraph())
-    usernames = sorted(G.nodes())
-    return G, torch.eye(len(usernames)), usernames
+    G = nx.from_pandas_edgelist(merged_df, source='follower_id', target='followed_id', create_using=nx.DiGraph())
+    user_ids = sorted(G.nodes())
+    return G, torch.eye(len(user_ids)), user_ids
 
-def prepare_training_data(G, usernames):
-    pos_edges = [(usernames.index(u), usernames.index(v)) for u, v in G.edges()]
+def prepare_training_data(G, user_ids):
+    pos_edges = [(user_ids.index(u), user_ids.index(v)) for u, v in G.edges()]
     pos_edge_index = torch.tensor(pos_edges).T
 
-    num_nodes = len(usernames)
+    num_nodes = len(user_ids)
     all_possible_edges = set(itertools.permutations(range(num_nodes), 2))
     existing_edges = set(zip(pos_edge_index[0].tolist(), pos_edge_index[1].tolist()))
     negative_edges = random.sample(list(all_possible_edges - existing_edges), len(pos_edges))
@@ -131,20 +125,20 @@ def train_model(model, data, pos_edges, neg_edges, epochs=200):
 
     return model
 
-def get_recommendations(username, model, data, G, usernames, top_k=10):
-    if username not in usernames:
+def get_recommendations(user_id, model, data, G, user_ids, top_k=10):
+    if user_id not in user_ids:
         return []
 
-    user_idx = usernames.index(username)
-    current_follows = set(G.successors(username))
+    user_idx = user_ids.index(user_id)
+    current_follows = set(G.successors(user_id))
 
-    candidates = [u for u in usernames if u != username and u not in current_follows]
+    candidates = [u for u in user_ids if u != user_id and u not in current_follows]
 
     with torch.no_grad():
         embeddings = model(data.x, data.edge_index)
         user_embed = embeddings[user_idx]
 
-        candidate_indices = [usernames.index(u) for u in candidates]
+        candidate_indices = [user_ids.index(u) for u in candidates]
         candidate_embeds = embeddings[candidate_indices]
 
         scores = torch.mm(user_embed.view(1, -1), candidate_embeds.T).squeeze()
@@ -153,14 +147,14 @@ def get_recommendations(username, model, data, G, usernames, top_k=10):
     return [candidates[i] for i in top_indices]
 
 def rebuild_model():
-    global G, features, usernames, pyg_data, trained_model
+    global G, features, user_ids, pyg_data, trained_model
     merged_df = load_and_preprocess_data()
-    G, features, usernames = create_graph_dataframe(merged_df)
+    G, features, user_ids = create_graph_dataframe(merged_df)
     pyg_data = from_networkx(G)
     pyg_data.x = features
 
-    pos_edge_index, neg_edge_index = prepare_training_data(G, usernames)
-    model = GraphRecommender(input_dim=len(usernames))
+    pos_edge_index, neg_edge_index = prepare_training_data(G, user_ids)
+    model = GraphRecommender(input_dim=len(user_ids))
     trained_model = train_model(model, pyg_data, pos_edge_index, neg_edge_index)
 
 @app.post("/rebuild")
@@ -169,11 +163,11 @@ async def rebuild_handler():
     return {"status": "success", "message": "Model and data rebuilt successfully"}
 
 @app.get("/recommend/network")
-async def get_recommendations_handler(username: str = Query(...)):
+async def get_recommendations_handler(user_id: int = Query(...)):
     if not trained_model:
         raise HTTPException(status_code=500, detail="Model not initialized, please rebuild first.")
 
-    recommendations = get_recommendations(username, trained_model, pyg_data, G, usernames)
+    recommendations = get_recommendations(user_id, trained_model, pyg_data, G, user_ids)
     return {"status": "success", "recommendations": recommendations}
 
 @app.get("/")