Update app.py

app.py

@@ -1,7 +1,9 @@
 import gradio as gr
 import pandas as pd
-import plotly.express as px
+import seaborn as sns
 from prophet import Prophet
+import io
+from PIL import Image
 
 # Ссылки на CSV-файлы
 URL_DASHA = "https://raw.githubusercontent.com/fruitpicker01/Storage_Dasha_2025/main/messages.csv"
@@ -10,41 +12,48 @@ URL_SVETA = "https://raw.githubusercontent.com/fruitpicker01/Storage_Sveta_2025/
 
 def read_and_process_data(url, user_name):
     """
+    Считывает CSV, отбирает нужные столбцы,
+    удаляет дубликаты (gender, generation, industry, opf),
+    приводит timestamp -> date.
     Возвращает:
-    1) unique_count: количество уникальных SMS (по gender, generation, industry, opf)
-    2) df_daily: дата, пользователь, дневное кол-во уникальных SMS (НЕ накопленное),
-                 уже после удаления дубликатов по 4 столбцам.
+      - unique_count (кол-во уникальных записей)
+      - df_daily: [date, count, user]
     """
+    print(f"\n=== [{user_name}] чтение CSV ===")
     df = pd.read_csv(url, na_values=["Не выбрано"])
+    print(f"[{user_name}] Исходное кол-во строк: {len(df)}")
+    
     cols = ["gender", "generation", "industry", "opf", "timestamp"]
     df = df[[c for c in cols if c in df.columns]].copy()
+    print(f"[{user_name}] После отбора столбцов: {df.shape}")
     
-    # Убираем дубликаты по ключевым столбцам
-    df_unique = df.drop_duplicates(subset=["gender", "generation", "industry", "opf"])
-    
-    # Количество уникальных SMS
-    unique_count = len(df_unique)
+    # Удаляем дубликаты
+    df_unique = df.drop_duplicates(subset=["gender", "generation", "industry", "opf"]).copy()
+    print(f"[{user_name}] После drop_duplicates: {df_unique.shape}")
     
     # Преобразуем timestamp -> date
-    if "timestamp" in df_unique.columns:
-        df_unique["timestamp"] = pd.to_numeric(df_unique["timestamp"], errors='coerce')
-        df_unique["date"] = pd.to_datetime(df_unique["timestamp"], unit="s", origin="unix", errors='coerce').dt.date
-    else:
-        df_unique["date"] = pd.NaT
+    df_unique["timestamp"] = pd.to_numeric(df_unique["timestamp"], errors='coerce')
+    df_unique["date"] = pd.to_datetime(df_unique["timestamp"], unit="s", origin="unix", errors='coerce').dt.date
+    
+    count_nat = df_unique["date"].isna().sum()
+    print(f"[{user_name}] Кол-во NaT дат: {count_nat}")
+
+    unique_count = len(df_unique)
     
-    # Сгруппируем по дате, чтобы получить кол-во за каждый день
+    # Группировка по датам
     df_daily = df_unique.groupby("date").size().reset_index(name="count")
     df_daily["user"] = user_name
-    
     return unique_count, df_daily
 
-def make_average_forecast(total_by_date, end_date_str="2025-02-28"):
+
+def make_average_forecast(total_by_date, end_date_str="2025-03-15"):
     """
-    Строит «прогноз по среднему» до указанной даты (end_date_str),
-    считая средний дневной прирост (по всем дням, без исключения выходных).
-    
-    Возвращает DataFrame с колонками ["ds", "yhat"], 
-    начиная с (last_date+1) по end_date_str (включительно).
+    Делает «прогноз по среднему» до указанной даты (end_date_str).
+    Берём средний дневной прирост count и 
+    добавляем его день за днём, не учитывая выходные.
+    Возвращает DataFrame: [ds, yhat]
+      ds   - дата (Timestamp)
+      yhat - прогноз накопленной суммы
     """
     if total_by_date.empty:
         return pd.DataFrame(columns=["ds", "yhat"])
@@ -52,45 +61,44 @@ def make_average_forecast(total_by_date, end_date_str="2025-02-28"):
     df_tmp = total_by_date.copy()
     df_tmp["date"] = pd.to_datetime(df_tmp["date"])
     
-    # Средний дневной прирост (столбец "count") по всем дням
     avg_inc = df_tmp["count"].mean() if len(df_tmp) else 0
-    
     last_date = df_tmp["date"].max()
     last_cumulative = df_tmp["cumulative"].iloc[-1]
     
     end_date = pd.to_datetime(end_date_str)
     
-    # Движемся по календарю день за днём
-    current_date = last_date
     forecast_data = []
     running_total = last_cumulative
+    current_date = last_date
     
     while current_date < end_date:
         current_date += pd.Timedelta(days=1)
         if current_date > end_date:
             break
-        # Прибавляем средний прирост независимо от выходного или буднего дня
+        
         running_total += avg_inc
         forecast_data.append({"ds": current_date, "yhat": running_total})
     
     return pd.DataFrame(forecast_data)
 
+
 def process_data():
-    # Шаг 1: Считываем CSV по каждому репозиторию (Даша, Лера, Света)
+    print("\n=== Начинаем process_data (Seaborn + Prophet + средний) ===")
+    
+    # 1) Считываем CSV
     dasha_count, dasha_daily = read_and_process_data(URL_DASHA, "Даша")
     lera_count, lera_daily = read_and_process_data(URL_LERA, "Лера")
     sveta_count, sveta_daily = read_and_process_data(URL_SVETA, "Света")
     
-    # Сумма
     total_count = dasha_count + lera_count + sveta_count
+    print(f"Суммарное количество (Д+Л+С): {total_count}")
     
-    # Подсчитываем проценты
+    # 2) Прогресс-бары
     dasha_percent = round((dasha_count / 234) * 100) if 234 else 0
     lera_percent = round((lera_count / 234) * 100) if 234 else 0
     sveta_percent = round((sveta_count / 234) * 100) if 234 else 0
     total_percent = round((total_count / 702) * 100) if 702 else 0
     
-    # Генерируем HTML для прогресс-баров
     def get_progress_bar(label, abs_val, pct):
         capacity = 234 if label in ["Даша", "Лера", "Света"] else 702
         return f"""
@@ -103,7 +111,6 @@ def process_data():
             </div>
         </div>
         """
-    
     bars_html = (
         get_progress_bar("Даша", dasha_count, dasha_percent) +
         get_progress_bar("Лера", lera_count, lera_percent) +
@@ -111,124 +118,140 @@ def process_data():
         get_progress_bar("Всего", total_count, total_percent)
     )
     
-    # Шаг 2: Готовим общий датафрейм по датам
+    # 3) Формируем общий DF
     daily_all = pd.concat([dasha_daily, lera_daily, sveta_daily], ignore_index=True)
-    daily_all = daily_all.dropna(subset=["date"])  # убираем NaT
-    
-    # Считаем кумулятивное значение для каждого пользователя
-    daily_all = daily_all.sort_values(by=["user", "date"])
+    daily_all = daily_all.dropna(subset=["date"])
+    daily_all = daily_all.sort_values(["user", "date"])
     daily_all["cumulative"] = daily_all.groupby("user")["count"].cumsum()
     
     # «Всего»
     total_by_date = daily_all.groupby("date")["count"].sum().reset_index(name="count")
-    total_by_date = total_by_date.sort_values(by="date")
+    total_by_date = total_by_date.sort_values("date")
     total_by_date["cumulative"] = total_by_date["count"].cumsum()
     total_by_date["user"] = "Всего"
     
-    # Объединяем
+    # 4) Первый график: накопительное (все пользователи)
     daily_all_final = pd.concat([daily_all, total_by_date], ignore_index=True)
+    daily_all_final["date_dt"] = pd.to_datetime(daily_all_final["date"])
+    
+    fig1, ax1 = plt.subplots(figsize=(8,5))
+    sns.lineplot(
+        data=daily_all_final,
+        x="date_dt", y="cumulative", hue="user",
+        ax=ax1, marker="o"
+    )
+    ax1.set_title("Накопительное количество SMS")
+    ax1.set_xlabel("Дата")
+    ax1.set_ylabel("Накопленное число SMS")
+    fig1.autofmt_xdate(rotation=30)
+    
+    buf1 = io.BytesIO()
+    plt.savefig(buf1, format="png")
+    buf1.seek(0)
+    image1_pil = Image.open(buf1)
+    
+    # 5) Делаем «Всего» для Prophet + средний прогноз
+    # Готовим DataFrame для Prophet
+    df_prophet = total_by_date[["date", "cumulative"]].copy()
+    df_prophet.columns = ["ds", "y"]
+    df_prophet["ds"] = pd.to_datetime(df_prophet["ds"])
     
-    # Сортируем легенду: у кого итог больше, тот сверху
-    last_values = daily_all_final.groupby("user")["cumulative"].last().sort_values(ascending=False)
-    sorted_users = last_values.index.tolist()
+    # Prophet-модель
+    model = Prophet()
+    model.fit(df_prophet)
     
-    color_map = {
-        "Даша": "#1f77b4",
-        "Лера": "#2ca02c",
-        "Света": "#d62728",
-        "Всего": "#9467bd"
+    # Прогноз до 15 марта 2025
+    end_date = pd.to_datetime("2025-03-15")
+    last_date = df_prophet["ds"].max()
+    additional_days = (end_date - last_date).days
+    future = model.make_future_dataframe(periods=additional_days if additional_days>0 else 0)
+    forecast = model.predict(future)
+    
+    # Разделим историю и будущее
+    df_plot = pd.merge(
+        forecast[["ds", "yhat"]],
+        df_prophet[["ds", "y"]],
+        on="ds",
+        how="left"
+    )
+    df_history = df_plot.dropna(subset=["y"]).copy()
+    df_future = df_plot[df_plot["y"].isna()].copy()
+    
+    # Прогноз по среднему
+    df_avg = make_average_forecast(total_by_date, "2025-03-15")
+    
+    # Преобразуем для Seaborn
+    # История
+    df_history["type"] = "История"
+    df_history["value"] = df_history["y"]
+    # Prophet
+    df_future["type"] = "Прогноз (Prophet)"
+    df_future["value"] = df_future["yhat"]
+    
+    # Средний
+    df_avg["type"] = "Прогноз (среднее)"
+    df_avg["value"] = df_avg["yhat"]
+    df_avg.rename(columns={"ds":"ds"}, inplace=True)
+    
+    # Сшиваем все в один DataFrame
+    df_combined = pd.concat([df_history, df_future, df_avg], ignore_index=True)
+    
+    # Для удобства
+    df_combined["ds"] = pd.to_datetime(df_combined["ds"])
+    
+    # 6) Второй график: «История», «Прогноз (Prophet)», «Прогноз (среднее)» — пунктир
+    # Сделаем стили dashes вручную: сплошная для «История», пунктир для двух «Прогнозов»
+    line_styles = {
+        "История": "",
+        "Прогноз (Prophet)": (2,2),   # пунктир
+        "Прогноз (среднее)": (2,2)    # пунктир
+    }
+    line_colors = {
+        "История": "blue",
+        "Прогноз (Prophet)": "red",
+        "Прогноз (среднее)": "green"
     }
     
-    # Строим накопительный график
-    fig = px.line(
-        daily_all_final,
-        x="date",
-        y="cumulative",
-        color="user",
-        title="Накопительное количество SMS",
-        labels={"date": "Дата", "cumulative": "Накопленное количество SMS", "user": "Редактор"},
-        category_orders={"user": sorted_users},
-        color_discrete_map=color_map
+    fig2, ax2 = plt.subplots(figsize=(8,5))
+    sns.lineplot(
+        data=df_combined,
+        x="ds", y="value",
+        hue="type",
+        style="type",
+        dashes=line_styles,
+        palette=line_colors,
+        markers=False,
+        ax=ax2
     )
+    ax2.set_title("Прогноз до середины марта 2025 (Prophet & Средний)")
+    ax2.set_xlabel("Дата")
+    ax2.set_ylabel("Накопленное число SMS (Всего)")
+    fig2.autofmt_xdate(rotation=30)
     
-    # Шаг 3: Два прогноза
-    forecast_fig = None
+    buf2 = io.BytesIO()
+    plt.savefig(buf2, format="png")
+    buf2.seek(0)
+    image2_pil = Image.open(buf2)
     
-    # Если есть данные "Всего", делаем прогноз
-    if not total_by_date.empty:
-        df_prophet = total_by_date[["date", "cumulative"]].copy()
-        df_prophet.columns = ["ds", "y"]
-        df_prophet["ds"] = pd.to_datetime(df_prophet["ds"])
-        
-        # Прогноз Prophet
-        model = Prophet()
-        model.fit(df_prophet)
-        
-        end_date = pd.to_datetime("2025-02-28")
-        last_date = df_prophet["ds"].max()
-        additional_days = (end_date - last_date).days
-        
-        future = model.make_future_dataframe(periods=0)  # если уже после
-        if additional_days > 0:
-            future = model.make_future_dataframe(periods=additional_days)
-        
-        forecast = model.predict(future)
-        
-        # Совмещаем
-        df_plot = pd.merge(
-            forecast[["ds", "yhat"]],
-            df_prophet[["ds", "y"]],
-            on="ds",
-            how="left"
-        )
-        df_history = df_plot.dropna(subset=["y"])
-        df_future = df_plot[df_plot["y"].isna()]
-        
-        # Прогноз по среднему (без учёта выходных — т. е. на каждый календарный день)
-        df_avg = make_average_forecast(total_by_date, "2025-02-28")
-        
-        # Общий график для сравнения
-        forecast_fig = px.line(
-            df_history,
-            x="ds",
-            y="y",
-            title="Прогноз до конца февраля 2025 (всего)",
-            labels={"ds": "Дата", "y": "Накопленное число SMS"}
-        )
-        # Prophet-пунктир
-        forecast_fig.add_scatter(
-            x=df_future["ds"],
-            y=df_future["yhat"],
-            mode="lines",
-            name="Прогноз (Prophet)",
-            line=dict(dash="dash", color="red")
-        )
-        
-        # Средний-пунктир
-        if not df_avg.empty:
-            forecast_fig.add_scatter(
-                x=df_avg["ds"],
-                y=df_avg["yhat"],
-                mode="lines",
-                name="Прогноз (по среднему)",
-                line=dict(dash="dash", color="green")
-            )
-        
-        forecast_fig.update_layout(showlegend=True)
+    # 7) Возвращаем результат
+    #    (прогресс-бары, первый график, второй график)
+    return bars_html, image1_pil, image2_pil
 
-    # Возвращаем всё в Gradio
-#    return (bars_html, fig, forecast_fig)
-    return (bars_html)
 
+# Gradio-интерфейс
 with gr.Blocks() as demo:
-    gr.Markdown("<h2>Количество сохраненных SMS (Даша, Лера, Света) - графики постараюсь скоро вернуть</h2>")
+    gr.Markdown("<h2>Количество сохраненных SMS + Прогноз (Prophet и Средний)</h2>")
     btn = gr.Button("Обновить данные и показать результат")
+    
     html_output = gr.HTML(label="Прогресс-бары: количество SMS и %")
-#    plot_output = gr.Plot(label="Накопительный график (Даша, Лера, Света, Всего)")
-#    forecast_output = gr.Plot(label="Прогноз до конца февраля 2025 (всего)")
+    image_output1 = gr.Image(type="pil", label="Накопительный график")
+    image_output2 = gr.Image(type="pil", label="Прогноз: Prophet & Средний")
     
-#    btn.click(fn=process_data, outputs=[html_output, plot_output, forecast_output])
-    btn.click(fn=process_data, outputs=[html_output])
+    # process_data возвращает (bars_html, image1_pil, image2_pil)
+    btn.click(
+        fn=process_data,
+        outputs=[html_output, image_output1, image_output2]
+    )
 
 if __name__ == "__main__":
     demo.launch()