feat: add general graphs

src/production/flow.py

@@ -88,7 +88,7 @@ async def generate_data(state):
             elif not new_row.empty and not new_row.isna().all().all():
                 state['data']['raw_df'] = new_row.copy()
 
-            print(f"- part {part_id} data generated")
+            #print(f"- part {part_id} data generated")
             part_id += 1
             await asyncio.sleep(0.2)
 

src/ui/dashboard.py

@@ -7,6 +7,7 @@ from src.production.flow import generate_data
 from src.production.metrics.tools import tools_metrics
 from src.production.metrics.machine import machine_metrics, fetch_issues
 from src.ui.graphs.tools_graphs import ToolMetricsDisplay
+from src.ui.graphs.general_graphs import GeneralMetricsDisplay
 
 MAX_ROWS = 1000
 TOOLS_COUNT = 2
@@ -20,28 +21,52 @@ async def dataflow(state):
     Main function that updates data if necessary.
     Avoids processing if the raw data hasn't changed.
     """
+    # Initialize state
     state.setdefault('data', {}).setdefault('tools', {})
+    state['data']['tools'].setdefault('all', pd.DataFrame())
+
+    for i in range(1, TOOLS_COUNT + 1):
+        state['data']['tools'].setdefault(f'tool_{i}', pd.DataFrame())
+
     state['data'].setdefault('issues', {})
+    state.setdefault('efficiency', {})
 
+    # Check running state
     if state.get('running'):
         if 'gen_task' not in state or state['gen_task'] is None or state['gen_task'].done():
             state['gen_task'] = asyncio.create_task(generate_data(state))
 
     raw_data = state['data'].get('raw_df', pd.DataFrame())
-    if raw_data.empty:
-        return [pd.DataFrame()] * TOOLS_COUNT
 
+    # Cold start
+    if raw_data.empty:
+        return (
+                [pd.DataFrame()] * TOOLS_COUNT +    # outils
+                [pd.DataFrame()] +                  # all
+                [pd.DataFrame()] +                  # issues
+                [{}]                                # efficiency
+        )
+
+    # Limit MAX_ROWS
     if len(raw_data) > MAX_ROWS:
         raw_data = raw_data.tail(MAX_ROWS)
 
+    # Check if data has changed
     current_hash = hash_dataframe(raw_data)
     if state.get('last_hash') == current_hash:
         return [
             pd.DataFrame(state['data']['tools'].get(f'tool_{i}', pd.DataFrame()))
             for i in range(1, TOOLS_COUNT+1)
+        ] + [
+            pd.DataFrame(state['data']['tools'].get('all', pd.DataFrame()))
+        ] + [
+            pd.DataFrame(state['data']['issues'])
+        ] + [
+            state['efficiency']
         ]
     state['last_hash'] = current_hash
 
+    # Process data
     tools_data = await tools_metrics(raw_data)
     tools_data = {tool: df for tool, df in tools_data.items() if not df.empty}
     for tool, df in tools_data.items():
@@ -53,58 +78,107 @@ async def dataflow(state):
     issues = await fetch_issues(raw_data)
     state['data']['issues'] = issues
 
-    return [
-        pd.DataFrame(state['data']['tools'].get(f'tool_{i}', pd.DataFrame()))
-        for i in range(1, TOOLS_COUNT+1)
-    ]
+    return (
+        [
+            pd.DataFrame(state['data']['tools'].get(f'tool_{i}', pd.DataFrame()))
+            for i in range(1, TOOLS_COUNT + 1)
+        ] + [
+            pd.DataFrame(state['data']['tools'].get('all', pd.DataFrame()))
+        ] + [
+            pd.DataFrame(state['data']['issues'])
+        ] + [
+            state['efficiency']
+        ]
+    )
 
-def update_display_and_plots(df, display):
-    """
-    Uses an existing instance of ToolMetricsDisplay to generate plots.
-    """
-    return [
-        display.normal_curve(df, cote='pos'),
-        display.gauge(df, type='cp', cote='pos'),
-        display.gauge(df, type='cpk', cote='pos'),
-        display.normal_curve(df, cote='ori'),
-        display.gauge(df, type='cp', cote='ori'),
-        display.gauge(df, type='cpk', cote='ori'),
-        display.control_graph(df),
-    ]
-
-def init_displays_and_blocks(n=TOOLS_COUNT):
+
+def init_components(n=TOOLS_COUNT):
     """
-    Initializes the graphical objects (ToolMetricsDisplay) and their associated blocks.
+    Initializes the graphical objects (ToolMetricsDisplay and GeneralMetricsDisplay)
+    and returns:
+    - displays: list of display objects [GeneralMetricsDisplay, ToolMetricsDisplay1, ToolMetricsDisplay2, ...]
+    - tool_plots: list of tool-related Gradio components
+    - general_plots: list of general-related Gradio components
     """
     displays = []
-    blocks = []
+    tool_plots = []
+    general_plots = []
+
+    # General metrics display and its plots
+    main_display = GeneralMetricsDisplay()
+    displays.append(main_display)
+    general_plots.extend(
+            main_display.block(
+            all_tools_df=pd.DataFrame(),
+            issues_df=pd.DataFrame(),
+            efficiency_data={}
+        )
+    )
+    # Tool metrics displays and their plots
     for i in range(1, n + 1):
         display = ToolMetricsDisplay()
         displays.append(display)
-        blocks.extend(display.tool_block(df=pd.DataFrame(), id=i))
-    return displays, blocks
+        tool_plots.extend(display.tool_block(df=pd.DataFrame(), id=i))
+
+    return displays, tool_plots, general_plots
+
 
 async def on_tick(state, displays):
     """
-    Tick function called periodically: updates plots only if data has changed.
-    Uses a lock to prevent concurrent execution.
+    Tick function called periodically to update plots if data has changed.
+
+    Handles:
+    - Tool-specific plots (tool_1, tool_2, ..., tool_n)
+    - General plots (all tools, issues, efficiency)
+
+    Returns two lists of plots separately for tools and general metrics, plus state.
     """
     async with state.setdefault('lock', asyncio.Lock()):
-        dfs = await dataflow(state)
-        all_plots = []
-        for df, display in zip(dfs, displays):
-            plots = update_display_and_plots(df, display)
-            all_plots.extend(plots)
-        return all_plots + [state]
+
+        data = await dataflow(state)
+        tool_dfs = data[:-3]             # all individual tool DataFrames
+        all_tools_df = data[-3]          # 'all' tools DataFrame
+        issues_df = data[-2]             # issues DataFrame
+        efficiency_data = data[-1]       # efficiency dict
+
+        # Update general plots
+        general_plots = []
+        general_display = displays[0]
+        general_plots.extend(
+                general_display.update(
+                all_tools_df=all_tools_df,
+                issues_df=issues_df,
+                efficiency_data=efficiency_data
+            )
+        )
+        # Update tool-specific plots
+        tool_plots = []
+        for df, display in zip(tool_dfs, displays[1:]):
+            tool_plots.extend(
+                [
+                    display.normal_curve(df, cote='pos'),
+                    display.gauge(df, type='cp', cote='pos'),
+                    display.gauge(df, type='cpk', cote='pos'),
+                    display.normal_curve(df, cote='ori'),
+                    display.gauge(df, type='cp', cote='ori'),
+                    display.gauge(df, type='cpk', cote='ori'),
+                    display.control_graph(df),
+                ]
+            )
+        return tool_plots + general_plots + [state]
 
 def dashboard_ui(state):
     """
     Creates the Gradio interface and sets a refresh every second.
+
+    The outputs are separated into two groups for tools and general metrics to
+    preserve layout order and grouping.
     """
-    displays, initial_plots = init_displays_and_blocks()
+    displays, tool_plots, general_plots = init_components()
+
     timer = gr.Timer(1.0)
     timer.tick(
         fn=partial(on_tick, displays=displays),
         inputs=[state],
-        outputs=initial_plots + [state]
+        outputs=tool_plots + general_plots + [state]
     )

src/ui/graphs/general_graphs.py

@@ -0,0 +1,18 @@
+import gradio as gr
+import plotly.express as px
+
+class GeneralMetricsDisplay:
+    def __init__(self):
+        self.plot_all_tools = gr.Plot()
+        self.plot_issues = gr.Plot()
+        self.plot_efficiency = gr.Plot()
+
+    def block(self, all_tools_df, issues_df, efficiency_data):
+        return [self.plot_all_tools, self.plot_issues, self.plot_efficiency]
+
+    def update(self, all_tools_df, issues_df, efficiency_data):
+        #fig_all = px.scatter(tools_df, x="Position", y="Orientation", color="Compliance", title="All Tools Summary")
+        #fig_issues = px.histogram(issues_df, x="Error Description", title="Error Types Distribution")
+        #fig_eff = px.bar(x=list(efficiency_data.keys()), y=list(efficiency_data.values()), title="Machine Efficiency")
+        #return [fig_all, fig_issues, fig_eff]
+        return self.plot_all_tools, self.plot_issues, self.plot_efficiency