core: datashape

app.py

@@ -1,3 +1,5 @@
+import json
+import pandas as pd
 import gradio as gr
 
 from src.chat import respond
@@ -33,20 +35,24 @@ with gr.Blocks(theme=custom_theme) as demo:
                             pause = gr.Button("⏸️ Pause")
                             reset = gr.Button("🔄 Reset")
 
-            with gr.Column(scale=2):
-                display_df = gr.DataFrame(
-                    label="Production Data",
-                    headers=[
-                        "Part ID", "Timestamp", "Position", "Orientation", "Tool ID",
-                        "Compliance", "Event", "Error Code", "Error Description",
-                        "Downtime Start", "Downtime End"
-                    ]
-                )
+            with gr.Column(scale=3):
+                df_outputs = {
+                    "DataFrame 1": pd.DataFrame(),
+                    "DataFrame 2": pd.DataFrame(),
+                    "DataFrame 3": pd.DataFrame(),
+                    "DataFrame 4": pd.DataFrame(),
+                    "DataFrame 5": pd.DataFrame(),
+                }
+                json_output = {}
+
+                df_components = [gr.DataFrame(label=df_name, visible=False) for df_name in df_outputs.keys()]
+                json_component = gr.JSON(label="Machine JSON", value=json_output, visible=False)
+
                 play.click(
                         fn=play_fn,
                         inputs=None,
-                        outputs=display_df,
-                    )
+                        outputs=df_components + [json_component]
+                )
                 pause.click(
                     fn=pause_fn,
                     inputs=None,
@@ -58,6 +64,7 @@ with gr.Blocks(theme=custom_theme) as demo:
                     outputs=None
                 )
 
+
     with gr.Tab("Description"):
         gr.Markdown(
             """

src/production/flow.py

@@ -1,4 +1,6 @@
+import os
 import time
+import json
 import random
 import numpy as np
 import pandas as pd
@@ -112,8 +114,8 @@ def play_fn():
     while PRODUCTION:
         data = synthetic_data()
         raw_data = compile(data)
-        yield raw_data
-        process(raw_data)
+        tools_dfs, machine_json = process(raw_data)
+        yield [tools_dfs[key] for key in tools_dfs.keys()] + [machine_json]
 
 
 def pause_fn():
@@ -129,6 +131,7 @@ def reset_fn():
     """
     Reset the production state and clear the data.
     """
+    os.system('clear')
     print("=== RESET DONE ===")
     global PRODUCTION, PROD_STATE
     PRODUCTION = False

src/production/metrics/machine.py

@@ -2,7 +2,7 @@ import pandas as pd
 import json
 import os
 
-def machine_metrics(raw_data):
+def get_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.
@@ -49,7 +49,7 @@ def machine_metrics(raw_data):
     else:
         mttr = pd.Timedelta(0)
 
-    results = {
+    return {
         "opening_time": str(opening_time),
         "required_time": str(required_time),
         "unplanned_stop_time": str(unplanned_stop_time),
@@ -62,11 +62,4 @@ def machine_metrics(raw_data):
         "TRS": TRS,
         "MTBF": str(mtbf),
         "MTTR": str(mttr)
-    }
-
-    os.makedirs('data', exist_ok=True)
-
-    with open('data/efficiency.json', 'w') as json_file:
-        json.dump(results, json_file, indent=4)
-
-    return results
+    }

src/production/metrics/tools.py

@@ -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, file_id=None):
+def process_unique_tool(tool, raw_data):
     """
     Process data for a single tool and save the results to a CSV file.
     Args:
@@ -29,24 +29,29 @@ def process_unique_tool(tool, raw_data, file_id=None):
         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']
     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)
-    tool_data.to_csv(f'./data/tool_{file_id}.csv', index=False)
+    return tool, tool_data
 
 
-def tools_metrics(raw_data):
+def get_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:
-        executor.map(lambda tool: process_unique_tool(tool, raw_data, file_id=tool), tools)
+        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
 
     # 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['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)
-    all_tools_data.to_csv('./data/tool_all.csv', index=False)
+    metrics['all'] = all_tools_data
+
+    return metrics

src/production/processing.py

@@ -1,9 +1,25 @@
-from .metrics.tools import tools_metrics
-from .metrics.machine import machine_metrics
+import json
+import numpy as np
+
+from .metrics.tools import get_tools_metrics
+from .metrics.machine import get_machine_metrics
 
 def process(raw_data):
     """
     Process the raw production data to extract metrics.
     """
-    tools_metrics(raw_data)
-    machine_metrics(raw_data)
+    print("=== TOOLS METRICS ===\n")
+    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.head())
+        print("\n")
+
+    print("=== MACHINE METRICS ===")
+    machine_results = get_machine_metrics(raw_data)
+    machine_json = json.dumps(machine_results, indent=4)
+    print(machine_json)
+
+    return tools_dfs, machine_json