feat: real-time

app.py

@@ -15,7 +15,7 @@ STATE = {
     "current_time": None,
     "part_id": None,
     "data": {},
-    "machine": {},
+    "efficiency": {},
 }
 
 with gr.Blocks(theme=custom_theme) as demo:

src/production/flow.py

@@ -1,12 +1,12 @@
-import time
 import random
 import numpy as np
 import pandas as pd
+import asyncio
 from datetime import datetime, timedelta
 
 from .downtime import machine_errors
 
-def generate_data(state):
+async def generate_data(state):
     """
     Generate synthetic production data for a manufacturing process.
     """
@@ -83,7 +83,7 @@ def generate_data(state):
 
             print(f"     - part {part_id} data generated")
             part_id += 1
-            time.sleep(0.5)
+            await asyncio.sleep(0.5)
 
         current_time += timedelta(seconds=1)
 

src/production/metrics/machine.py

@@ -1,8 +1,6 @@
 import pandas as pd
-import json
-import os
 
-def machine_metrics(raw_data):
+async def machine_metrics(raw_data):
     """
     Calculate machine efficiency metrics from raw production data.
     :param raw_data: collection of raw production data containing timestamps, downtime, and compliance information.
@@ -64,7 +62,7 @@ def machine_metrics(raw_data):
         "MTTR": str(mttr)
     }
 
-def fetch_issues(raw_data):
+async def fetch_issues(raw_data):
     df = pd.DataFrame(raw_data)
     issues = df[df["Event"] == "Machine Error"]
     return issues[["Timestamp", "Event", "Error Code", "Error Description", "Downtime Start", "Downtime End"]]

src/production/metrics/tools.py

@@ -1,5 +1,5 @@
 import numpy as np
-from concurrent.futures import ThreadPoolExecutor
+import asyncio
 
 def stats_metrics(data, column, usl, lsl):
     """
@@ -21,7 +21,7 @@ def stats_metrics(data, column, usl, lsl):
     return rolling_mean, rolling_std, cp, cpk
 
 
-def process_unique_tool(tool, raw_data):
+async def process_unique_tool(tool, raw_data):
     """
     Process data for a single tool and save the results to a CSV file.
     Args:
@@ -35,17 +35,18 @@ def process_unique_tool(tool, raw_data):
     return tool, tool_data
 
 
-def tools_metrics(raw_data):
+async def tools_metrics(raw_data):
     """
     Process the raw production data to extract tool metrics in parallel.
     """
     metrics = {}
     tools = raw_data['Tool ID'].unique()
 
-    with ThreadPoolExecutor() as executor:
-        results = list(executor.map(lambda tool: process_unique_tool(tool, raw_data), tools))
-        for tool, tool_data in results:
-            metrics[f"tool_{tool}"] = tool_data
+    tasks = [process_unique_tool(tool, raw_data) for tool in tools]
+    results = await asyncio.gather(*tasks)
+
+    for tool, tool_data in results:
+        metrics[f"tool_{tool}"] = tool_data
 
     # Calculate metrics for all tools together
     all_tools_data = raw_data.copy()

src/ui/dashboard.py

@@ -1,54 +1,63 @@
-import time
-import json
 import gradio as gr
 import pandas as pd
+import asyncio
 
 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
 
-def dashboard_ui(state):
+async def dataflow(state):
+    if 'tools' not in state['data']:
+        state['data']['tools'] = {}
 
-    display1 = ToolMetricsDisplay()
+    if 'issues' not in state['data']:
+        state['data']['issues'] = {}
 
-    def dataflow(state):
+    if state['running']:
+        if 'gen_task' not in state or state['gen_task'] is None or state['gen_task'].done():
+            print("Launching generate_data in background")
+            state['gen_task'] = asyncio.create_task(generate_data(state))
 
-        # --- INIT ---
-        if 'tools' not in state['data']:
-            state['data']['tools'] = {}
+    raw_data = state['data'].get('raw_df', pd.DataFrame())
+    if raw_data.empty:
+        return pd.DataFrame()
 
-        if 'issues' not in state['data']:
-            state['data']['issues'] = {}
+    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():
+        state['data']['tools'][tool] = df
 
-        # --- DATA FLOW ---
-        if state['running']:
+    machine_data = await machine_metrics(raw_data)
+    state['efficiency'] = machine_data
+    issues = await fetch_issues(raw_data)
+    state['data']['issues'] = issues
 
-            # Generation
-            generate_data(state)
-            raw_data = state['data']['raw_df']
+    df1 = pd.DataFrame(state['data']['tools'].get('tool_1', pd.DataFrame()))
+    return df1
+
+def dashboard_ui(state):
+    display = ToolMetricsDisplay()
+    plots = display.tool_block(df=pd.DataFrame(), id=1)
 
-            # Process tools metrics
-            tools_data = 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():
-                state['data']['tools'][tool] = df
+    async def on_tick(state):
+        df1 = await dataflow(state)
+        updated = [
+            display.normal_curve(df1, cote='pos'),
+            display.gauge(df1, type='cp', cote='pos'),
+            display.gauge(df1, type='cpk', cote='pos'),
 
-            # Process machine metrics
-            machine_data = machine_metrics(raw_data)
-            state['machine'] = machine_data
-            issues = fetch_issues(raw_data)
-            state['data']['issues'] = issues
+            display.normal_curve(df1, cote='ori'),
+            display.gauge(df1, type='cp', cote='ori'),
+            display.gauge(df1, type='cpk', cote='ori'),
 
-        # --- UPDATE UI ---
-        df1 = pd.DataFrame(state['data']['tools'].get('tool_1', pd.DataFrame()))
-        return display1.tool_block(df=df1, id=1)
+            display.control_graph(df1),
+        ]
+        return updated + [state]
 
-    plots = display1.tool_block(df=pd.DataFrame(), id=1)
     timer = gr.Timer(1)
     timer.tick(
-        fn=dataflow,
-        inputs=state,
-        outputs=plots
+        fn=on_tick,
+        inputs=[state],
+        outputs=plots + [state]
     )

src/ui/graphs/tools_graphs.py

@@ -1,6 +1,5 @@
 import numpy as np
 from scipy.stats import norm
-import pandas as pd
 import plotly.graph_objects as go
 import gradio as gr
 
@@ -10,6 +9,7 @@ class ToolMetricsDisplay:
         self.df = None
         self.pos_color = '#2CFCFF'
         self.ori_color = '#ff8508'
+        self.plots = []
 
     @staticmethod
     def gauge(df, type=None, cote=None):
@@ -120,8 +120,12 @@ class ToolMetricsDisplay:
 
         if cote == 'pos':
             color = self.pos_color
+            lsl = 0.3
+            usl = 0.5
         else:
             color = self.ori_color
+            lsl = 0.2
+            usl = 0.6
         mu_column = f"{cote}_rolling_mean"
         std_column = f"{cote}_rolling_std"
         idx = df['Timestamp'].idxmax()
@@ -130,9 +134,9 @@ class ToolMetricsDisplay:
         y = norm.pdf(x, mu, std)
         fig = go.Figure()
         fig.add_trace(go.Scatter(x=x, y=y, mode='lines', name='Normal Curve', line=dict(color=color)))
-        fig.add_shape(type="line", x0=0.6, y0=0, x1=0.6, y1=max(y), line=dict(color="red", width=1, dash="dot"),
+        fig.add_shape(type="line", x0=usl, y0=0, x1=usl, y1=max(y), line=dict(color="red", width=1, dash="dot"),
                       name='usl')
-        fig.add_shape(type="line", x0=0.2, y0=0, x1=0.2, y1=max(y), line=dict(color="red", width=1, dash="dot"),
+        fig.add_shape(type="line", x0=lsl, y0=0, x1=lsl, y1=max(y), line=dict(color="red", width=1, dash="dot"),
                       name='lsl')
         fig.update_layout(
             template='plotly_dark',
@@ -175,5 +179,9 @@ class ToolMetricsDisplay:
                 with gr.Row(height=400):
                     control_plot = gr.Plot(self.control_graph(df=df))
 
-            return [pos_normal_plot, pos_cp_gauge, pos_cpk_gauge, ori_normal_plot, ori_cp_gauge, ori_cpk_gauge,
-                    control_plot]
+            self.plots = [
+                pos_normal_plot, pos_cp_gauge, pos_cpk_gauge,
+                ori_normal_plot, ori_cp_gauge, ori_cpk_gauge,
+                control_plot
+            ]
+            return self.plots