wip

src/production/flow.py

@@ -1,29 +1,19 @@
-import os
 import time
-import json
 import random
 import numpy as np
 import pandas as pd
 from datetime import datetime, timedelta
 
 from .downtime import machine_errors
-from .processing import process
 
-PRODUCTION = False
-PROD_STATE = {
-    "current_time": None,
-    "part_id": None,
-    "data": None
-}
-
-def synthetic_data():
+def generate_data(state):
     """
     Generate synthetic production data for a manufacturing process.
     """
-    global PROD_STATE
-    data = PROD_STATE["data"] if PROD_STATE["data"] else []
-    current_time = PROD_STATE["current_time"] if PROD_STATE["current_time"] else datetime.now()
-    part_id = PROD_STATE["part_id"] if PROD_STATE["part_id"] else 1
+    current_time = state["current_time"] if state["current_time"] else datetime.now()
+    part_id = state["part_id"] if state["part_id"] else 0
+    if 'raw' not in state['data']:
+        state['data']['raw'] = []
     non_compliance_rates = {
         1: 0.05,
         2: 0.10,
@@ -32,7 +22,7 @@ def synthetic_data():
     }
 
     for _ in range(1000):
-        if not PRODUCTION:
+        if not state["running"]:
             break
 
         if random.random() < 0.2:
@@ -40,7 +30,7 @@ def synthetic_data():
             error = machine_errors[error_key]
             downtime = error["downtime"]
 
-            data.append({
+            state['data']['raw'].append({
                 "timestamp": current_time.strftime("%Y-%m-%d %H:%M:%S"),
                 "event": "Machine Error",
                 "error_code": error_key,
@@ -61,7 +51,7 @@ def synthetic_data():
 
             compliance = 'OK' if (0.3 <= position <= 0.5) and (0.2 <= orientation <= 0.6) else 'NOK'
 
-            data.append({
+            state['data']['raw'].append({
                 "part_id": part_id,
                 "timestamp": current_time.strftime("%Y-%m-%d %H:%M:%S"),
                 "position": round(position, 4),
@@ -76,18 +66,11 @@ def synthetic_data():
 
         current_time += timedelta(seconds=1)
 
-    PROD_STATE["data"] = data
-    PROD_STATE["current_time"] = current_time
-    PROD_STATE["part_id"] = part_id
-
-    return data
+    state["current_time"] = current_time
+    state["part_id"] = part_id
 
-def compile(data):
-    """
-    Update production data in real-time.
-    """
     raw_data = []
-    for row in data:
+    for row in state['data']['raw']:
         raw_data.append({
             "Part ID": row.get("part_id", "N/A"),
             "Timestamp": row.get("timestamp", "N/A"),
@@ -101,42 +84,5 @@ def compile(data):
             "Downtime Start": row.get("downtime_start", "N/A"),
             "Downtime End": row.get("downtime_end", "N/A")
         })
-    return pd.DataFrame(raw_data)
-
-
-def play_fn():
-    """
-    Start the production simulation and generate synthetic data.
-    """
-    print("=== STARTING PRODUCTION ===")
-    global PRODUCTION
-    PRODUCTION = True
-    while PRODUCTION:
-        data = synthetic_data()
-        raw_data = compile(data)
-        tools_dfs, machine_json = process(raw_data)
-        yield [tools_dfs[key] for key in tools_dfs.keys()] + [machine_json]
 
-
-def stop_fn():
-    """
-    Pause the production simulation.
-    """
-    print("--- PAUSE ---")
-    global PRODUCTION
-    PRODUCTION = False
-
-
-def reset_fn():
-    """
-    Reset the production state and clear the data.
-    """
-    os.system('clear')
-    print("=== RESET DONE ===")
-    global PRODUCTION, PROD_STATE
-    PRODUCTION = False
-    PROD_STATE = {
-        "current_time": None,
-        "part_id": None,
-        "data": None
-    }
+    state['data']['raw_df'] = pd.DataFrame(raw_data)

src/ui/dashboard.py

@@ -1,42 +1,98 @@
+import time
+import json
 import gradio as gr
-import pandas as pd
-
-from src.production.flow import play_fn, stop_fn, reset_fn
-
-def dashboard_ui():
-    with gr.Tab("Dashboard"):
-        with gr.Row():
-            with gr.Blocks():
-                play = gr.Button("▶️ Play")
-                stop = gr.Button("⏸️ Pause")
-                reset = gr.Button("🔄 Reset")
-
-        with gr.Row():
-            with gr.Column(scale=3):
-                json_output = {}
-                json_component = gr.JSON(label="Machine JSON", value=json_output, visible=True)
-
-                df_outputs = {
-                    "DataFrame 1": pd.DataFrame(),
-                    "DataFrame 2": pd.DataFrame(),
-                    "DataFrame 3": pd.DataFrame(),
-                    "DataFrame 4": pd.DataFrame(),
-                    "DataFrame 5": pd.DataFrame(),
-                }
-                df_components = [gr.DataFrame(label=df_name, visible=False) for df_name in df_outputs.keys()]
-
-                play.click(
-                    fn=play_fn,
-                    inputs=None,
-                    outputs=df_components + [json_component]
-                )
-                stop.click(
-                    fn=stop_fn,
-                    inputs=None,
-                    outputs=None
-                )
-                reset.click(
-                    fn=reset_fn,
-                    inputs=None,
-                    outputs=None
-                )
+
+from src.production.flow import generate_data#, compile
+from src.production.metrics.tools import get_tools_metrics
+from src.production.metrics.machine import get_machine_metrics
+
+def dashboard_ui(state):
+
+    def update_dashboard(state):
+        if state['running']:
+            generate_data(state)
+
+            raw_data = state['data']['raw_df']
+            print(raw_data)
+
+
+            tools_dfs = get_tools_metrics(raw_data)
+            tools_dfs = {tool: df for tool, df in tools_dfs.items() if not df.empty}
+
+            for tool, df in tools_dfs.items():
+                print(tool)
+                print(df.columns.tolist())
+                print("\n")
+
+            machine_results = get_machine_metrics(raw_data)
+            machine_json = json.dumps(machine_results, indent=4)
+            print(machine_json)
+
+        return state
+
+
+
+
+
+    timer = gr.Timer(0.1)
+    timer.tick(
+        fn=update_dashboard,
+        inputs=state,
+        outputs=state
+    )
+
+
+
+#        # ----------------   TOOLS METRICS DISPLAY   ----------------
+#        tools_count = 4
+#        visualizers = [ToolMetricsDisplay() for _ in range(tools_count)]
+#        for id, display in enumerate(visualizers, start=1):
+#            with gr.Row():
+#                df = datalist.value['data'][id - 1][0]
+#                header = f"Tool {id}"
+#                html_content = f"""
+#                                    <div style="display: flex; align-items: center; justify-content: flex-start; width: 100%;">
+#                                        <div style="flex: 0 0 2%; border-top: 1px solid white;"></div>
+#                                        <h2 style="flex: 0 0 auto; margin: 0 10px;">{header}</h2>
+#                                        <div style="flex: 1; border-top: 1px solid white;"></div>
+#                                </div>
+#                                """
+#                gr.HTML(html_content)
+#            with gr.Row():
+#                with gr.Column(scale=1):
+#                    gr.Markdown("### `Position`")
+#                    with gr.Group():
+#                        with gr.Row(height=250):
+#                            pos_normal_plot = gr.Plot(display.normal_curve(df=df, cote='pos'))
+#                        with gr.Row(height=150):
+#                            pos_cp_gauge = gr.Plot(display.gauge(df=df, type='cp', cote='pos'))
+#                            pos_cpk_gauge = gr.Plot(display.gauge(df=df, type='cpk', cote='pos'))
+#
+#                with gr.Column(scale=1):
+#                    gr.Markdown("### `Orientation`")
+#                    with gr.Group():
+#                        with gr.Row(height=250):
+#                            ori_normal_plot = gr.Plot(display.normal_curve(df=df, cote='ori'))
+#                        with gr.Row(height=150):
+#                            ori_cp_gauge = gr.Plot(display.gauge(df=df, type='cp', cote='ori'))
+#                            ori_cpk_gauge = gr.Plot(display.gauge(df=df, type='cpk', cote='ori'))
+#
+#                with gr.Column(scale=2):
+#                    gr.Markdown("### `Control card`")
+#                    with gr.Row(height=400):
+#                        control_plot = gr.Plot(display.control_graph(df=df))
+#
+#            timer = gr.Timer(1)
+#            timer.tick(
+#                lambda : [
+#                    display.normal_curve(df=df, cote='pos'),
+#                    display.gauge(df=df, type='cp', cote='pos'),
+#                    display.gauge(df=df, type='cpk', cote='pos'),
+#                    display.normal_curve(df=df, cote='ori'),
+#                    display.gauge(df=df, type='cp', cote='ori'),
+#                    display.gauge(df=df, type='cpk', cote='ori'),
+#                    display.control_graph(df=df)
+#                ],
+#                outputs=[pos_normal_plot, pos_cp_gauge, pos_cpk_gauge, ori_normal_plot, ori_cp_gauge, ori_cpk_gauge,
+#                         control_plot]
+#            )

src/ui/graphs/tools_graphs.py

@@ -0,0 +1,194 @@
+import numpy as np
+from scipy.stats import norm
+import pandas as pd
+import plotly.graph_objects as go
+import gradio as gr
+
+
+class ToolMetricsDisplay:
+    def __init__(self):
+        self.df = None
+        self.pos_color = '#2CFCFF'
+        self.ori_color = '#ff8508'
+
+    @staticmethod
+    def gauge(df, type=None, cote=None):
+        if df is None or df.empty:
+            fig = go.Figure()
+            fig.update_layout(
+                template='plotly_dark',
+                width=200,
+                height=170,
+                margin=dict(l=30, r=50, t=30, b=0),
+                annotations=[dict(
+                    text="No data available",
+                    showarrow=False,
+                    font=dict(size=16, color="white")
+                )]
+            )
+            return fig
+
+        column = f"{cote}_rolling_{type}"
+        idx = df['Timestamp'].idxmax()
+        value = df.loc[idx, column]
+        fig = go.Figure(go.Indicator(
+            mode="gauge+number",
+            value=value,
+            number={'font': {'color': 'white', 'size': 20}},
+            domain={'x': [0, 1], 'y': [0, 1]},
+            title={'text': type, 'font': {'color': 'white', 'size': 16}},
+            gauge={'axis': {'range': [0, 3]},
+                   'bar': {'color': 'black', 'thickness': 0.4},
+                   'steps': [
+                       {'range': [0, 1.33], 'color': "red"},
+                       {'range': [1.33, 2], 'color': "yellow"},
+                       {'range': [2, 3], 'color': "green"}],
+                   'threshold': {
+                       'line': {'color': 'black', 'width': 3},
+                       'thickness': 0.8,
+                       'value': value}}
+        ))
+        fig.update_layout(
+            template='plotly_dark',
+            width=200,
+            height=170,
+            margin=dict(l=30, r=50, t=30, b=0),
+        )
+        return fig
+
+    def control_graph(self, df):
+        if df is None or df.empty:
+            fig = go.Figure()
+            fig.update_layout(
+                template='plotly_dark',
+                xaxis_title='Timestamp',
+                yaxis_title='Valeurs',
+                showlegend=True,
+                width=720,
+                height=400,
+                margin=dict(l=70, r=10, t=30, b=70),
+                annotations=[dict(
+                    text="No data available",
+                    showarrow=False,
+                    font=dict(size=20, color="white")
+                )]
+            )
+            return fig
+
+        fig = go.Figure()
+        fig.add_trace(go.Scatter(x=df['Timestamp'], y=[0.3] * len(df), mode='lines',
+                                 line=dict(dash='dot', color=self.pos_color, width=1), name='lsl pos'))
+        fig.add_trace(go.Scatter(x=df['Timestamp'], y=[0.5] * len(df), mode='lines',
+                                 line=dict(dash='dot', color=self.pos_color, width=1), name='usl pos'))
+        fig.add_trace(go.Scatter(x=df['Timestamp'], y=[0.2] * len(df), mode='lines',
+                                 line=dict(dash='dot', color=self.ori_color, width=1), name='lsl ori'))
+        fig.add_trace(go.Scatter(x=df['Timestamp'], y=[0.6] * len(df), mode='lines',
+                                 line=dict(dash='dot', color=self.ori_color, width=1), name='usl ori'))
+        fig.add_trace(
+            go.Scatter(x=df['Timestamp'], y=df['Position'], mode='lines+markers', line=dict(color=self.pos_color),
+                       name='pos'))
+        fig.add_trace(
+            go.Scatter(x=df['Timestamp'], y=df['Orientation'], mode='lines+markers', line=dict(color=self.ori_color),
+                       name='ori'))
+        fig.update_layout(
+            template='plotly_dark',
+            xaxis_title='Timestamp',
+            yaxis_title='Valeurs',
+            showlegend=True,
+            width=720,
+            height=400,
+            margin=dict(l=70, r=10, t=30, b=70)
+        )
+        return fig
+
+    def normal_curve(self, df, cote=None):
+        if df is None or df.empty:
+            fig = go.Figure()
+            fig.update_layout(
+                template='plotly_dark',
+                showlegend=False,
+                width=370,
+                height=250,
+                margin=dict(l=40, r=40, t=40, b=40),
+                annotations=[dict(
+                    text="No data available",
+                    showarrow=False,
+                    font=dict(size=16, color="white")
+                )]
+            )
+            return fig
+
+        if cote == 'pos':
+            color = self.pos_color
+        else:
+            color = self.ori_color
+        mu_column = f"{cote}_rolling_mean"
+        std_column = f"{cote}_rolling_std"
+        idx = df['Timestamp'].idxmax()
+        mu, std = df.loc[idx, [mu_column, std_column]]
+        x = np.linspace(mu - 3 * std, mu + 3 * std, 100)
+        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"),
+                      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"),
+                      name='lsl')
+        fig.update_layout(
+            template='plotly_dark',
+            showlegend=False,
+            width=370,
+            height=250,
+            margin=dict(l=40, r=40, t=40, b=40)
+        )
+        return fig
+
+    #def tool_block(self, df, id=1):
+    #            header = f"Tool {id}"
+    #            html_content = f"""
+    #            <div style="display: flex; align-items: center; justify-content: flex-start; width: 100%;">
+    #                <div style="flex: 0 0 2%; border-top: 1px solid white;"></div>
+    #                <h2 style="flex: 0 0 auto; margin: 0 10px;">{header}</h2>
+    #                <div style="flex: 1; border-top: 1px solid white;"></div>
+    #            </div>
+    #            """
+    #            gr.HTML(html_content)
+#
+    #            with gr.Row():
+    #                with gr.Column(scale=1):
+    #                    gr.Markdown("### `Position`")
+    #                    with gr.Group():
+    #                        with gr.Row(height=250):
+    #                            pos_normal_plot = gr.Plot(self.normal_curve(df=df, cote='pos'))
+    #                        with gr.Row(height=150):
+    #                            pos_cp_gauge = gr.Plot(self.gauge(df=df, type='cp', cote='pos'))
+    #                            pos_cpk_gauge = gr.Plot(self.gauge(df=df, type='cpk', cote='pos'))
+#
+    #                with gr.Column(scale=1):
+    #                    gr.Markdown("### `Orientation`")
+    #                    with gr.Group():
+    #                        with gr.Row(height=250):
+    #                            ori_normal_plot = gr.Plot(self.normal_curve(df=df, cote='ori'))
+    #                        with gr.Row(height=150):
+    #                            ori_cp_gauge = gr.Plot(self.gauge(df=df, type='cp', cote='ori'))
+    #                            ori_cpk_gauge = gr.Plot(self.gauge(df=df, type='cpk', cote='ori'))
+#
+    #                with gr.Column(scale=2):
+    #                    gr.Markdown("### `Control card`")
+    #                    with gr.Row(height=400):
+    #                        control_plot = gr.Plot(self.control_graph(df=df))
+
+            #timer = gr.Timer(1)
+#
+            #timer.tick(
+            #    lambda: [
+            #        self.update_normal_curve(cote='pos'),
+            #        self.update_gauge(type='cp', cote='pos'),
+            #        self.update_gauge(type='cpk', cote='pos'),
+            #        self.update_normal_curve(cote='ori'),
+            #        self.update_gauge(type='cp', cote='ori'),
+            #        self.update_gauge(type='cpk', cote='ori'),
+            #        self.update_control_graph()
+            #    ],
+            #    outputs=[pos_normal_plot, pos_cp_gauge, pos_cpk_gauge, ori_normal_plot, ori_cp_gauge, ori_cpk_gauge, control_plot]
+            #)