Update app.py

app.py

@@ -31,7 +31,7 @@ def create_trend_chart(space_id, daily_ranks_df):
             xaxis_title="Date",
             yaxis_title="Rank",
             yaxis=dict(
-                range=[100, 1],
+                range=[100, 1],  # 랭킹이 1이 최고이므로 y축을 뒤집어서 표시
                 tickmode='linear',
                 tick0=1,
                 dtick=10
@@ -54,55 +54,111 @@ def create_trend_chart(space_id, daily_ranks_df):
         
         return fig
     except Exception as e:
-        print(f"Error creating chart: {e}")
+        print(f"Error creating trend chart: {e}")
+        traceback.print_exc()
         return None
 
-def get_total_scores(daily_ranks_df):
+def load_and_process_data():
+    """
+    1) spaces.parquet를 다운로드하여 DataFrame으로 변환
+    2) 최근 30일치 데이터만 필터링
+    3) 매 일자별로 trendingScore 내림차순으로 rank를 매긴 뒤, 누적
+    """
     try:
-        # 최신 날짜 찾기
-        latest_date = daily_ranks_df['date'].max()
-        print(f"Latest date: {latest_date}")
+        url = "https://huggingface.co/datasets/cfahlgren1/hub-stats/resolve/main/spaces.parquet"
+        response = requests.get(url)
+        df = pd.read_parquet(BytesIO(response.content))
+        
+        # 최근 30일 기준으로 필터링
+        thirty_days_ago = datetime.now() - timedelta(days=30)
+        df['createdAt'] = pd.to_datetime(df['createdAt'])
+        df = df[df['createdAt'] >= thirty_days_ago].copy()
+        
+        # 30일 동안의 모든 날짜에 대해
+        dates = pd.date_range(start=thirty_days_ago, end=datetime.now(), freq='D')
+        daily_ranks = []
+        
+        for date in dates:
+            # date 날짜까지 생성된 스페이스만 필터링
+            date_data = df[df['createdAt'].dt.date <= date.date()].copy()
+            # trendingScore 높은 순, id 오름차순으로 정렬 후 rank 부여
+            date_data = date_data.sort_values(['trendingScore', 'id'], ascending=[False, True])
+            date_data['rank'] = range(1, len(date_data) + 1)
+            date_data['date'] = date.date()
+            
+            daily_ranks.append(
+                date_data[['id', 'date', 'rank', 'trendingScore', 'createdAt']]
+            )
         
-        # 최신 날짜의 Top 100 데이터 가져오기
-        latest_top_100 = daily_ranks_df[
+        # 하루하루 쌓인 rank 기록을 모두 합침
+        daily_ranks_df = pd.concat(daily_ranks, ignore_index=True)
+        
+        # 최신 날짜의 Top100만 별도로 추출
+        latest_date = daily_ranks_df['date'].max()
+        top_100_spaces = daily_ranks_df[
             (daily_ranks_df['date'] == latest_date) &
             (daily_ranks_df['rank'] <= 100)
+        ].sort_values('rank').copy()
+        
+        return daily_ranks_df, top_100_spaces
+    except Exception as e:
+        print(f"Error loading data: {e}")
+        traceback.print_exc()
+        return pd.DataFrame(), pd.DataFrame()
+
+def get_top20_multiple_ids(daily_ranks_df):
+    """
+    '최신 날짜의 Top100'에서, 동일한 id가 2개 이상 등장하는 경우
+    해당 스코어를 합산하여, 합계가 높은 순으로 top 20까지만 리턴하는 함수
+    """
+    if daily_ranks_df.empty:
+        return pd.DataFrame()
+    
+    try:
+        # 최신 날짜 파악
+        latest_date = daily_ranks_df['date'].max()
+        
+        # 최신 날짜의 Top100만 필터링
+        latest_top100 = daily_ranks_df[
+            (daily_ranks_df['date'] == latest_date) & (daily_ranks_df['rank'] <= 100)
         ].copy()
-        print(f"Number of entries in top 100: {len(latest_top_100)}")
         
-        # ID 빈도수 확인
-        id_counts = latest_top_100['id'].value_counts()
+        # id별 등장 횟수 (Top100 내)
+        id_counts = latest_top100['id'].value_counts()
+        # 2개 이상 등장하는 id만 추출
         multiple_ids = id_counts[id_counts >= 2].index
-        print(f"IDs with multiple entries: {len(multiple_ids)}")
         
-        # 중복 등록된 ID들의 데이터만 필터링
-        multiple_entries = latest_top_100[latest_top_100['id'].isin(multiple_ids)].copy()
+        if len(multiple_ids) == 0:
+            # 중복 id가 아예 없는 경우
+            return pd.DataFrame()
         
-        # ID별로 스코어 합산 및 등장 횟수 계산
-        summary = pd.DataFrame({
-            'total_score': multiple_entries.groupby('id')['trendingScore'].sum(),
-            'count': multiple_entries.groupby('id')['id'].count()
-        }).sort_values('total_score', ascending=True)
+        # 중복된 id에 해당하는 행만 모으기
+        multiple_entries = latest_top100[latest_top100['id'].isin(multiple_ids)].copy()
         
-        print("Summary of multiple entries:")
-        print(summary)
+        # id별로 score 합산
+        df_sum = (multiple_entries
+                  .groupby('id')['trendingScore']
+                  .sum()
+                  .reset_index()
+                  .rename(columns={'trendingScore': 'total_score'}))
         
-        return summary
+        # 합산된 total_score 순으로 내림차순 정렬 후 상위 20
+        df_sum = df_sum.sort_values(by='total_score', ascending=False).head(20)
         
+        return df_sum
     except Exception as e:
-        print(f"Error in get_total_scores: {e}")
+        print(f"Error in get_top20_multiple_ids: {e}")
         traceback.print_exc()
         return pd.DataFrame()
 
-def create_score_chart(total_scores):
+def create_score_chart(multiple_ids_df):
     """
-    - total_scores가 비었을 경우 'No multiple entries found'라는 제목의
-      간단한 placeholder 차트를 반환하여, 오른쪽 상단 영역이 비어 있지 않도록 함.
-    - 상위 10개만 표시 (total_score 기준 내림차순).
+    위에서 만든 df_sum (id + total_score) 를 가지고,
+    id별 total_score 막대 차트를 생성. 상위 20개만 표시.
     """
     try:
-        if total_scores.empty:
-            # 중복된 ID 자체가 전혀 없는 경우
+        if multiple_ids_df.empty:
+            # 중복된 id 자체가 하나도 없는 경우(또는 집계결과 없음)
             placeholder_df = pd.DataFrame({"id": ["No multiple entries"], "total_score": [0]})
             fig = px.bar(
                 placeholder_df,
@@ -121,40 +177,17 @@ def create_score_chart(total_scores):
             )
             return fig
         
-        # total_score 기준으로 내림차순 정렬 후 상위 10개만 차트에 표시
-        df = total_scores.reset_index().sort_values('total_score', ascending=False).head(10)
+        # 여기서 multiple_ids_df에는 이미 상위 20개만 있는 상태
+        df = multiple_ids_df.copy()
         
-        if df.empty:
-            # 중복된 ID는 존재하지만 스코어가 0이거나 등등, 의도치 않게 비었을 경우 대비
-            placeholder_df = pd.DataFrame({"id": ["No multiple entries"], "total_score": [0]})
-            fig = px.bar(
-                placeholder_df,
-                x="total_score",
-                y="id",
-                orientation='h'
-            )
-            fig.update_layout(
-                title="No multiple entries found in Top 100",
-                xaxis_title="Total Trending Score",
-                yaxis_title="Space ID",
-                plot_bgcolor='white',
-                paper_bgcolor='white',
-                showlegend=False,
-                margin=dict(l=200, r=20, t=40, b=40),
-            )
-            return fig
-
         fig = px.bar(
             df,
             y='id',
             x='total_score',
             orientation='h',
-            title=f"Top 10 Spaces with Multiple Entries in Top 100",
+            title=f"Top 20 IDs with Multiple Entries in Top 100",
             height=400,
-            text=[
-                f"Score: {score:.1f}\nEntries: {count}"
-                for score, count in zip(df['total_score'], df['count'])
-            ]
+            text=[f"Score: {score:.2f}" for score in df['total_score']]
         )
         
         fig.update_layout(
@@ -182,6 +215,10 @@ def create_score_chart(total_scores):
         return None
 
 def update_display(selection):
+    """
+    사용자가 왼쪽/HTML 카드에서 특정 id를 선택했을 때,
+    그 id에 대한 일간 Trend Chart + 상세 정보를 반환
+    """
     global daily_ranks_df
     
     if not selection:
@@ -219,58 +256,25 @@ def update_display(selection):
         print(f"Error in update_display: {e}")
         return None, gr.HTML(value=f"<div style='color: red;'>Error processing data: {str(e)}</div>")
 
-def load_and_process_data():
-    try:
-        url = "https://huggingface.co/datasets/cfahlgren1/hub-stats/resolve/main/spaces.parquet"
-        response = requests.get(url)
-        df = pd.read_parquet(BytesIO(response.content))
-        
-        thirty_days_ago = datetime.now() - timedelta(days=30)
-        df['createdAt'] = pd.to_datetime(df['createdAt'])
-        df = df[df['createdAt'] >= thirty_days_ago].copy()
-        
-        dates = pd.date_range(start=thirty_days_ago, end=datetime.now(), freq='D')
-        daily_ranks = []
-        
-        for date in dates:
-            date_data = df[df['createdAt'].dt.date <= date.date()].copy()
-            date_data = date_data.sort_values(['trendingScore', 'id'], ascending=[False, True])
-            date_data['rank'] = range(1, len(date_data) + 1)
-            date_data['date'] = date.date()
-            daily_ranks.append(
-                date_data[['id', 'date', 'rank', 'trendingScore', 'createdAt']]
-            )
-        
-        daily_ranks_df = pd.concat(daily_ranks, ignore_index=True)
-        
-        latest_date = daily_ranks_df['date'].max()
-        top_100_spaces = daily_ranks_df[
-            (daily_ranks_df['date'] == latest_date) &
-            (daily_ranks_df['rank'] <= 100)
-        ].sort_values('rank').copy()
-        
-        return daily_ranks_df, top_100_spaces
-    except Exception as e:
-        print(f"Error loading data: {e}")
-        traceback.print_exc()
-        return pd.DataFrame(), pd.DataFrame()
+########## 메인 실행 ##########
 
 # 데이터 로드
 print("Loading initial data...")
 daily_ranks_df, top_100_spaces = load_and_process_data()
 print("Data loaded successfully!")
 
-# 총 스코어 분석
-print("Analyzing total scores...")
-total_scores = get_total_scores(daily_ranks_df)
-score_chart = create_score_chart(total_scores)  # <- 여기서 차트 생성
+# '최신 날짜의 Top100' 중복 ID 집계 -> 상위 20
+multiple_ids_df = get_top20_multiple_ids(daily_ranks_df)
+score_chart = create_score_chart(multiple_ids_df)
 
 # Gradio 인터페이스 생성
 with gr.Blocks(theme=gr.themes.Soft()) as demo:
     gr.Markdown("""
     # HF Space Ranking Tracker
     
-    Track, analyze, and discover trending AI applications in the Hugging Face ecosystem. Our service continuously monitors and ranks all Spaces over a 30-day period, providing detailed analytics and daily ranking changes for the top 100 performers.
+    Track, analyze, and discover trending AI applications in the Hugging Face ecosystem. 
+    Our service continuously monitors and ranks all Spaces over a 30-day period, 
+    providing detailed analytics and daily ranking changes for the top 100 performers.
     """)
     
     with gr.Tabs():
@@ -284,26 +288,27 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
                     )
                 # 오른쪽(Score Chart)
                 with gr.Column(scale=3):
-                    # 이미 생성한 score_chart를 기본값으로 넣어줌
+                    # multiple_ids_df 기반 차트
                     score_plot = gr.Plot(
                         value=score_chart,
-                        label="Multiple Entries Analysis (Top 10)",
+                        label="Multiple-Entry IDs (Top 20)",
                         container=True
                     )
             
+            # Space 상세 정보
             with gr.Row():
                 info_box = gr.HTML(
                     value="<div style='text-align: center; padding: 20px; color: #666;'>Select a space to view details</div>"
                 )
             
-            # 라디오 버튼을 먼저 정의
+            # 라디오 버튼(가려놓고 HTML 버튼 -> JS -> 라디오 change 이벤트 트리거)
             space_selection = gr.Radio(
                 choices=[row['id'] for _, row in top_100_spaces.iterrows()],
                 value=None,
                 visible=False
             )
             
-            # HTML에서 JavaScript 이벤트를 직접 처리
+            # Top100 리스트를 HTML 카드로 표시 (JS 로 클릭 이벤트 -> 라디오 선택)
             html_content = """
             <div style='display: flex; flex-wrap: wrap; gap: 16px; justify-content: center;'>
             """ + "".join([
@@ -391,12 +396,15 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
             - Make data-driven decisions about your AI projects
             - Stay ahead of the curve in AI application development
             
-            Our dashboard provides a comprehensive view of the Hugging Face Spaces ecosystem, helping developers, researchers, and enthusiasts track and understand the dynamics of popular AI applications. Whether you're monitoring your own Space's performance or discovering new trending applications, HF Space Ranking Tracker offers the insights you need.
+            Our dashboard provides a comprehensive view of the Hugging Face Spaces ecosystem, 
+            helping developers, researchers, and enthusiasts track and understand 
+            the dynamics of popular AI applications.
             
-            Experience the pulse of the AI community through our daily updated rankings and discover what's making waves in the world of practical AI applications.
+            Whether you're monitoring your own Space's performance or discovering new trending applications, 
+            HF Space Ranking Tracker offers the insights you need.
             """)
     
-    # 라디오 버튼 변경 이벤트 연결
+    # 라디오 버튼 change 이벤트 -> update_display 함수
     space_selection.change(
         fn=update_display,
         inputs=[space_selection],
@@ -406,4 +414,3 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
 
 if __name__ == "__main__":
     demo.launch(share=True)
-