feat: perf

src/production/flow.py

@@ -20,7 +20,6 @@ async def generate_data(state):
         4: 0.07
     }
 
-    # Initialize raw_df if it doesn't exist
     if 'raw_df' not in state['data']:
         state['data']['raw_df'] = pd.DataFrame(columns=[
             "Part ID", "Timestamp", "Position", "Orientation", "Tool ID",
@@ -79,9 +78,17 @@ async def generate_data(state):
                 "Downtime End": "N/A"
             }])
 
-            state['data']['raw_df'] = pd.concat([state['data']['raw_df'], new_row], ignore_index=True)
+            if (
+                    (not new_row.empty and not new_row.isna().all().all())
+                and \
+                    (not state['data']['raw_df'].empty and not state['data']['raw_df'].isna().all().all())
+            ):
+                state['data']['raw_df'] = pd.concat([state['data']['raw_df'], new_row], ignore_index=True)
+
+            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/production/metrics/machine.py

@@ -1,51 +1,40 @@
 import pandas as pd
 
 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.
-    :return: a dictionary with calculated metrics including opening time, required time, unplanned stop time, operating time, net time, useful time, quality rate, operating rate, availability rate, TRS (Total Resource Score), MTBF (Mean Time Between Failures), and MTTR (Mean Time To Repair).
-    """
     df = pd.DataFrame(raw_data)
-    df['Timestamp'] = pd.to_datetime(df['Timestamp'])
-    df['Downtime Start'] = pd.to_datetime(df['Downtime Start'], format="%Y-%m-%d %H:%M:%S", errors='coerce')
-    df['Downtime End'] = pd.to_datetime(df['Downtime End'], format="%Y-%m-%d %H:%M:%S", errors='coerce')
 
-    opening_time = df['Timestamp'].max() - df['Timestamp'].min()        # Calculate opening time
-    planned_stop_time = pd.Timedelta(0)                                 # Planned stop time (not implemented)
-    required_time = opening_time - planned_stop_time
+    datetime_cols = ['Timestamp', 'Downtime Start', 'Downtime End']
+    for col in datetime_cols:
+        df[col] = pd.to_datetime(df[col], errors='coerce', format="%Y-%m-%d %H:%M:%S")
 
-    downtime_df = df.dropna(subset=['Downtime Start', 'Downtime End'])                              # Create a subset for calculating unplanned stop time
-    unplanned_stop_time = (downtime_df['Downtime End'] - downtime_df['Downtime Start']).sum()       # Calculate unplanned stop time
-    operating_time = required_time - unplanned_stop_time                                            # Operating time
+    opening_time = df['Timestamp'].max() - df['Timestamp'].min()
+    required_time = opening_time  # planned_stop_time = 0 non implémenté
 
-    cadency_variance = pd.Timedelta(0)                  # Cadency variance (not implemented)
-    net_time = operating_time - cadency_variance        # Net time
+    downtime_df = df.dropna(subset=['Downtime Start', 'Downtime End'])
+    unplanned_stop_time = (downtime_df['Downtime End'] - downtime_df['Downtime Start']).sum()
+    operating_time = required_time - unplanned_stop_time
 
-    nok_time = df[df['Compliance'] != 'OK']['Timestamp'].count()        # Time NOK (non-compliant)
-    useful_time = net_time - pd.Timedelta(seconds=nok_time)             # Useful time
+    net_time = operating_time  # cadency_variance = 0 non implémenté
 
-    total_parts = df['Part ID'].count()                                         # Compliance metrics
-    compliant_parts = df[df['Compliance'] == 'OK']['Compliance'].count()
+    nok_count = (df['Compliance'] != 'OK').sum()
+    useful_time = net_time - pd.Timedelta(seconds=nok_count)
 
-    quality_rate = (compliant_parts / total_parts) * 100            # Quality rate
-    operating_rate = (net_time / operating_time) * 100              # Operating rate
-    availability_rate = (operating_time / required_time) * 100      # Availability rate
+    total_parts = len(df)
+    compliant_parts = (df['Compliance'] == 'OK').sum()
 
-    # Overall Equipment Effectiveness (OEE)
-    TRS = (quality_rate / 100) * (operating_rate / 100) * (availability_rate / 100) * 100
+    operating_sec = operating_time.total_seconds()
+    net_sec = net_time.total_seconds()
+    required_sec = required_time.total_seconds()
+
+    quality_rate = (compliant_parts / total_parts) * 100 if total_parts > 0 else 0
+    operating_rate = (net_sec / operating_sec) * 100 if operating_sec > 0 else 0
+    availability_rate = (operating_sec / required_sec) * 100 if required_sec > 0 else 0
 
-    # Mean Time Between Failures (MTBF)
-    if len(downtime_df) > 0:
-        mtbf = operating_time / len(downtime_df)
-    else:
-        mtbf = pd.Timedelta(0)
+    TRS = (quality_rate / 100) * (operating_rate / 100) * (availability_rate / 100) * 100
 
-    # Mean Time To Repair (MTTR)
-    if len(downtime_df) > 0:
-        mttr = unplanned_stop_time / len(downtime_df)
-    else:
-        mttr = pd.Timedelta(0)
+    downtime_count = len(downtime_df)
+    mtbf = operating_time / downtime_count if downtime_count > 0 else pd.Timedelta(0)
+    mttr = unplanned_stop_time / downtime_count if downtime_count > 0 else pd.Timedelta(0)
 
     return {
         "opening_time": str(opening_time),

src/production/metrics/tools.py

@@ -1,15 +1,9 @@
 import numpy as np
+import pandas as pd
 import asyncio
+from concurrent.futures import ThreadPoolExecutor
 
 def stats_metrics(data, column, usl, lsl):
-    """
-    Calculate rolling mean, standard deviation, Cp, and Cpk for a given column.
-    Args:
-        data (pd.DataFrame): DataFrame containing the production data.
-        column (str): The column for which to calculate metrics.
-        usl (float): Upper specification limit.
-        lsl (float): Lower specification limit.
-    """
     rolling_mean = data[column].expanding().mean()
     rolling_std = data[column].expanding().std()
     cp = (usl - lsl) / (6 * rolling_std)
@@ -20,37 +14,35 @@ def stats_metrics(data, column, usl, lsl):
     cpk[rolling_std == 0] = 0
     return rolling_mean, rolling_std, cp, cpk
 
-
-async def process_unique_tool(tool, raw_data):
-    """
-    Process data for a single tool and save the results to a CSV file.
-    Args:
-        tool (str): Tool ID to process.
-        raw_data (pd.DataFrame): DataFrame containing the raw production data.
-    """
-    tool_data = raw_data[raw_data['Tool ID'] == tool].copy()
-    tool_data = tool_data[tool_data['Tool ID'] != 'N/A']
+def process_unique_tool(tool, tool_data):
     tool_data['pos_rolling_mean'], tool_data['pos_rolling_std'], tool_data['pos_rolling_cp'], tool_data['pos_rolling_cpk'] = stats_metrics(tool_data, 'Position', 0.5, 0.3)
     tool_data['ori_rolling_mean'], tool_data['ori_rolling_std'], tool_data['ori_rolling_cp'], tool_data['ori_rolling_cpk'] = stats_metrics(tool_data, 'Orientation', 0.6, 0.2)
     return tool, tool_data
 
-
 async def tools_metrics(raw_data):
-    """
-    Process the raw production data to extract tool metrics in parallel.
-    """
+    filtered_data = raw_data[raw_data['Tool ID'] != 'N/A']
+    tools = filtered_data['Tool ID'].unique()
+
+    loop = asyncio.get_running_loop()
     metrics = {}
-    tools = raw_data['Tool ID'].unique()
 
-    tasks = [process_unique_tool(tool, raw_data) for tool in tools]
-    results = await asyncio.gather(*tasks)
+    with ThreadPoolExecutor() as executor:
+        tasks = [
+            loop.run_in_executor(
+                executor,
+                process_unique_tool,
+                tool,
+                filtered_data[filtered_data['Tool ID'] == tool].copy()
+            )
+            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()
-    all_tools_data = all_tools_data[all_tools_data['Tool ID'] != 'N/A']
+    all_tools_data = filtered_data.copy()
     all_tools_data['pos_rolling_mean'], all_tools_data['pos_rolling_std'], all_tools_data['pos_rolling_cp'], all_tools_data['pos_rolling_cpk'] = stats_metrics(all_tools_data, 'Position', 0.5, 0.3)
     all_tools_data['ori_rolling_mean'], all_tools_data['ori_rolling_std'], all_tools_data['ori_rolling_cp'], all_tools_data['ori_rolling_cpk'] = stats_metrics(all_tools_data, 'Orientation', 0.6, 0.2)
     metrics['all'] = all_tools_data

src/ui/dashboard.py

@@ -20,7 +20,6 @@ async 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))
 
     raw_data = state['data'].get('raw_df', pd.DataFrame())