分享JMS流量统计面板

雪秋千

各位大侠有justmysocks的API的流量统计面板吗？自己用GPT写的太丑。
下面是自己写的效果预览图
Screenshot 2025-03-14 180331.png (65.11 KB, 下载次数: 2)

2025-3-14 18:03 上传

点击文件名下载附件

雪秋千

先把我的放上来吧
1. 首先是本地存储数据的，定期30秒运行一次。因为jms更新时间差不多就是半分钟。

1. import requests
   
2. import json
   
3. from datetime import datetime
   
4. 
   
5. API_URL = "https://justmysocks6.net/members/getbwcounter.php?service="
   
6. HISTORY_FILE = "扶墙_usage_history.json"
   
7. 
   
8. def fetch_bw_counter():
   
9.     response = requests.get(API_URL)
   
10.     data = response.json()
    
11.     # data = {"monthly_bw_limit_b": 1000000000000,
    
12.     #         "bw_counter_b": 651529129,
    
13.     #         "bw_reset_day_of_month": 13}
    
14.     return data["bw_counter_b"]
    
15. 
    
16. def load_history():
    
17.     try:
    
18.         with open(HISTORY_FILE, "r") as f:
    
19.             return json.load(f)
    
20.     except (IOError, ValueError):
    
21.         return []
    
22. 
    
23. def save_history(history):
    
24.     with open(HISTORY_FILE, "w") as f:
    
25.         json.dump(history, f, indent=2)
    
26. 
    
27. def record_usage():
    
28.     # 1) Fetch the current usage
    
29.     current_bw = fetch_bw_counter()
    
30.     timestamp = datetime.utcnow().isoformat()
    
31.    
    
32.     # 2) Append new record to history
    
33.     history = load_history()
    
34.     history.append({
    
35.         "timestamp": timestamp,
    
36.         "bw_counter_b": current_bw
    
37.     })
    
38.     save_history(history)
    
39.    
    
40. if __name__ == "__main__":
    
41.     record_usage()
    

复制代码

2. 第二是显示面板，第一个面板是总体使用量，第二个是在不同时间的速率，

1. import json
   
2. import pandas as pd
   
3. from datetime import timedelta
   
4. import dash
   
5. from dash import dcc, html, Input, Output
   
6. import plotly.graph_objs as go
   
7. 
   
8. # ----- Utility Functions -----
   
9. 
   
10. def load_usage_data(file_path="扶墙_usage_history.json"):
    
11.     """Load usage data from JSON, localize to America/Los_Angeles, then convert to UTC.
    
12.        Plotly will automatically render these timestamps in the visitor’s local time.
    
13.     """
    
14.     with open(file_path, "r") as f:
    
15.         data = json.load(f)
    
16.     df = pd.DataFrame(data)
    
17.     # Assume timestamps in the file are in California time.
    
18.     df['timestamp'] = pd.to_datetime(df['timestamp']).dt.tz_localize('America/Los_Angeles')
    
19.     # Convert to UTC for consistent plotting.
    
20.     df['timestamp'] = df['timestamp'].dt.tz_convert('UTC')
    
21.     df.sort_values('timestamp', inplace=True)
    
22.     return df
    
23. 
    
24. def convert_bytes(value_bytes):
    
25.     """
    
26.     Convert a byte value to a human-friendly string using a 1000 conversion factor.
    
27.     If the value in GB is less than 0.001, display in MB.
    
28.     If in MB is less than 0.001, display in B.
    
29.     """
    
30.     value_gb = value_bytes / 1e9
    
31.     if value_gb >= 0.001:
    
32.         return f"{value_gb:.3f} GB"
    
33.     value_mb = value_bytes / 1e6
    
34.     if value_mb >= 0.001:
    
35.         return f"{value_mb:.3f} MB"
    
36.     return f"{value_bytes} B"
    
37. 
    
38. def aggregate_data(df, resolution, window):
    
39.     """
    
40.     Aggregate usage data for a given resolution and time window.
    
41.     resolution: a pandas offset alias, e.g., 'T' for minute, 'H' for hour, 'D' for day, 'W' for week.
    
42.     window: timedelta object representing the lookback period.
    
43.     """
    
44.     end_time = df['timestamp'].max()
    
45.     start_time = end_time - window
    
46.     df_window = df[df['timestamp'] >= start_time].copy()
    
47.     if df_window.empty:
    
48.         return pd.DataFrame(columns=['timestamp', 'bw_counter_b'])
    
49.     df_window.set_index('timestamp', inplace=True)
    
50.     df_resampled = df_window.resample(resolution).last().dropna()
    
51.     df_resampled.reset_index(inplace=True)
    
52.     return df_resampled
    
53. 
    
54. def compute_usage_rates(df):
    
55.     """
    
56.     Compute the incremental usage (difference between consecutive bw_counter_b)
    
57.     and time differences. Returns the DataFrame with a new column 'usage_diff'.
    
58.     """
    
59.     df = df.copy()
    
60.     df['usage_diff'] = df['bw_counter_b'].diff()
    
61.     df['time_diff_sec'] = df['timestamp'].diff().dt.total_seconds()
    
62.     df['usage_rate'] = df['usage_diff'] / df['time_diff_sec']
    
63.     return df
    
64. 
    
65. # ----- Dash App Setup -----
    
66. 
    
67. app = dash.Dash(__name__)
    
68. server = app.server
    
69. 
    
70. app.layout = html.Div([
    
71.     html.H1("扶墙 Data Usage Dashboard"),
    
72.     html.Div([
    
73.         html.Button("Minutes", id="btn-minutes", n_clicks=0),
    
74.         html.Button("Hourly", id="btn-hourly", n_clicks=0),
    
75.         html.Button("Daily", id="btn-daily", n_clicks=0),
    
76.         html.Button("Weekly", id="btn-weekly", n_clicks=0)
    
77.     ], style={'marginBottom': '20px'}),
    
78.     html.Div(id="summary-stats", style={'marginBottom': '20px'}),
    
79.     dcc.Graph(id="usage-graph"),
    
80.     dcc.Graph(id="rate-graph"),
    
81.     dcc.Interval(id="interval-update", interval=60*1000, n_intervals=0)  # update every minute
    
82. ])
    
83. 
    
84. # ----- Callback to Update Graphs and Stats -----
    
85. 
    
86. @app.callback(
    
87.     [Output("usage-graph", "figure"),
    
88.      Output("rate-graph", "figure"),
    
89.      Output("summary-stats", "children")],
    
90.     [Input("btn-minutes", "n_clicks"),
    
91.      Input("btn-hourly", "n_clicks"),
    
92.      Input("btn-daily", "n_clicks"),
    
93.      Input("btn-weekly", "n_clicks"),
    
94.      Input("interval-update", "n_intervals")]
    
95. )
    
96. def update_dashboard(n_min, n_hour, n_day, n_week, n_interval):
    
97.     df = load_usage_data()
    
98.    
    
99.     # Determine which button was most recently pressed
    
100.     ctx = dash.callback_context
     
101.     if not ctx.triggered:
     
102.         resolution_choice = 'H'
     
103.         window = timedelta(hours=24)
     
104.     else:
     
105.         button_id = ctx.triggered[0]['prop_id'].split('.')[0]
     
106.         if button_id == "btn-minutes":
     
107.             resolution_choice = 'T'  # minute resolution
     
108.             window = timedelta(hours=1)
     
109.         elif button_id == "btn-hourly":
     
110.             resolution_choice = 'H'
     
111.             window = timedelta(hours=24)
     
112.         elif button_id == "btn-daily":
     
113.             resolution_choice = 'D'
     
114.             window = timedelta(days=7)
     
115.         elif button_id == "btn-weekly":
     
116.             resolution_choice = 'W'
     
117.             window = timedelta(weeks=4)
     
118.         else:
     
119.             resolution_choice = 'H'
     
120.             window = timedelta(hours=24)
     
121.    
     
122.     df_agg = aggregate_data(df, resolution_choice, window)
     
123.     df_rate = compute_usage_rates(df_agg)
     
124.    
     
125.     # ----- Cumulative Usage Figure -----
     
126.     cum_fig = go.Figure()
     
127.     cum_fig.add_trace(go.Scatter(
     
128.         x=df_agg['timestamp'],
     
129.         y=df_agg['bw_counter_b'] / 1e9,  # cumulative usage in GB
     
130.         mode='lines+markers',
     
131.         name="Cumulative Usage (GB)",
     
132.         connectgaps=False
     
133.     ))
     
134.     cum_fig.update_layout(
     
135.         title="扶墙 Cumulative Usage Over Time",
     
136.         xaxis_title="Time",
     
137.         yaxis_title="Usage (GB)",
     
138.         hovermode="x unified"
     
139.     )
     
140.    
     
141.     # ----- Usage Rate Figure -----
     
142.     df_rate_clean = df_rate.dropna(subset=['usage_diff'])
     
143.     if not df_rate_clean.empty:
     
144.         max_diff = df_rate_clean['usage_diff'].max()
     
145.         if max_diff / 1e9 >= 0.001:
     
146.             factor = 1e9
     
147.             y_label = "Usage per Interval (GB)"
     
148.         elif max_diff / 1e6 >= 0.001:
     
149.             factor = 1e6
     
150.             y_label = "Usage per Interval (MB)"
     
151.         else:
     
152.             factor = 1
     
153.             y_label = "Usage per Interval (B)"
     
154.         usage_diff_converted = df_rate_clean['usage_diff'] / factor
     
155.     else:
     
156.         usage_diff_converted = []
     
157.         y_label = "Usage per Interval"
     
158.    
     
159.     rate_fig = go.Figure()
     
160.     rate_fig.add_trace(go.Scatter(
     
161.         x=df_rate_clean['timestamp'],
     
162.         y=usage_diff_converted,
     
163.         mode='lines+markers',
     
164.         name="Interval Usage",
     
165.         connectgaps=False
     
166.     ))
     
167.     rate_fig.update_layout(
     
168.         title="扶墙 Usage Rate Over Time",
     
169.         xaxis_title="Time",
     
170.         yaxis_title=y_label,
     
171.         hovermode="x unified"
     
172.     )
     
173.    
     
174.     # ----- Summary Statistics -----
     
175.     if not df_rate['usage_rate'].dropna().empty:
     
176.         avg_rate = df_rate['usage_rate'].dropna().mean()  # bytes per second
     
177.         avg_per_min = convert_bytes(avg_rate * 60)
     
178.         avg_per_hour = convert_bytes(avg_rate * 3600)
     
179.         avg_per_day = convert_bytes(avg_rate * 3600 * 24)
     
180.         avg_per_week = convert_bytes(avg_rate * 3600 * 24 * 7)
     
181.     else:
     
182.         avg_per_min = avg_per_hour = avg_per_day = avg_per_week = "N/A"
     
183.    
     
184.     summary = html.Div([
     
185.         html.P(f"Average Usage per Minute: {avg_per_min}"),
     
186.         html.P(f"Average Usage per Hour: {avg_per_hour}"),
     
187.         html.P(f"Average Usage per Day: {avg_per_day}"),
     
188.         html.P(f"Average Usage per Week: {avg_per_week}")
     
189.     ])
     
190.    
     
191.     return cum_fig, rate_fig, summary
     
192. 
     
193. if __name__ == '__main__':
     
194.     app.run_server(debug=True)
     

复制代码