Update main.py

main.py

@@ -78,55 +78,73 @@ def generate_recommendations_for_session(session_id):
         # Convert session data to a DataFrame
         raw_df = pd.DataFrame(session_data)
         
-        # Aggregate data by id and action
-        aggregated_data = raw_df.groupby(['id', 'action']).agg(
-            presence=('action', 'size'),
-            total_duration=('duration', 'sum')
-        ).reset_index()
+        # Debug: Print column names
+        logger.debug(f"Columns in raw_df: {raw_df.columns.tolist()}")
         
-        # Create a pivot table from the aggregated data
+        # Check if required columns exist
+        required_columns = ['id', 'action']
+        missing_columns = [col for col in required_columns if col not in raw_df.columns]
+        if missing_columns:
+            logger.error(f"Missing required columns: {missing_columns}")
+            return None
+
+        # Determine aggregation based on presence of 'duration' column
+        if 'duration' in raw_df.columns:
+            aggregated_data = raw_df.groupby(['id', 'action']).agg(
+                presence=('action', 'size'),
+                total_duration=('duration', 'sum')
+            ).reset_index()
+        else:
+            aggregated_data = raw_df.groupby(['id', 'action']).agg(
+                presence=('action', 'size')
+            ).reset_index()
+
+        # Create pivot table
+        pivot_columns = ['presence', 'total_duration'] if 'duration' in raw_df.columns else ['presence']
         pivot_df = aggregated_data.pivot_table(
             index=['id'],
             columns='action',
-            values=['presence', 'total_duration'],
+            values=pivot_columns,
             fill_value=0
         )
-        
+
         # Flatten column names
         pivot_df.columns = ['_'.join(col).strip() for col in pivot_df.columns.values]
-        
+
         # Ensure all expected columns exist in the pivot table
         for col in ALL_COLUMNS:
             if f'presence_{col}' not in pivot_df.columns and col != 'time_spent':
                 pivot_df[f'presence_{col}'] = 0
-            elif col == 'time_spent' and 'total_duration_time_spent' not in pivot_df.columns:
+            elif col == 'time_spent' and 'duration' in raw_df.columns and 'total_duration_time_spent' not in pivot_df.columns:
                 pivot_df['total_duration_time_spent'] = 0
-        
+
         # Calculate interaction score for each row
         pivot_df['interaction_score'] = pivot_df.apply(calculate_interaction_score, axis=1)
-        
+
         # Create a user vector based on the interaction scores
         user_vector = pd.Series(index=user_item_matrix_columns, dtype=float).fillna(0)
         for property_id, score in pivot_df['interaction_score'].items():
             if property_id in user_vector.index:
                 user_vector[property_id] = score
-        
+
         # Transform the user vector using the SVD model
         user_vector_array = user_vector.values.reshape(1, -1)
         user_latent = svd.transform(user_vector_array)
-        
+
         # Calculate similarity scores between the user vector and item factors
         similarity_scores = cosine_similarity(user_latent, item_factors)
-        
+
         # Get the indices of the top 10 most similar items
         top_indices = similarity_scores.argsort()[0][-10:][::-1]
-        
+
         # Get the corresponding property IDs for the top indices
         recommendations = user_item_matrix_columns[top_indices].tolist()
-        
+
         return recommendations
+
     except Exception as e:
-        logger.error(f"Error in generate_recommendations_for_session: {e}")
+        logger.error(f"Error in generate_recommendations_for_session: {str(e)}")
+        logger.debug(f"Raw dataframe info: {raw_df.info()}")
         return None