instruction stringlengths 0 1k | input stringlengths 1 1k | output stringlengths 10 6.51k |
|---|---|---|
import asyncio
import datetime
from typing import Dict, List, TypedDict
import reflex as rx
from futuristic_dashboard.states.data import (
performance_chart_data,
quick_actions_data,
resource_allocation_data,
stat_card_data,
system_status_data,
)
class StatCardData(TypedDict):
title: str
value: str
sub_detail: str
icon: str
color: str
chart_data: List[Dict[str, int]]
class SystemStatusData(TypedDict):
name: str
value: int
color: str
class ResourceAllocationData(TypedDict):
name: str
value: int
color: str
class QuickActionData(TypedDict):
name: str
icon: str
|
class DashboardState(rx.State):
"""Holds the state for the dashboard."""
current_time: str = datetime.datetime.now().strftime("%H:%M:%S")
current_date: str = datetime.datetime.now().strftime("%b %d, %Y")
uptime: str = "14d 06:42:18"
time_zone: str = "UTC-08:00"
active_nav: str = "Dashboard"
active_performance_tab: str = "Performance"
mobile_sidebar_open: bool = False
stat_cards: List[StatCardData] = stat_card_data
system_status: List[SystemStatusData] = system_status_data
resource_allocation: List[ResourceAllocationData] = resource_allocation_data
quick_actions: List[QuickActionData] = quick_actions_data
performance_chart_data: List[PerformanceChartData] = performance_chart_data
system_load: int = 35
@rx.event(background=True)
async def update_time(self):
while True:
async with self:
self.current_time = datetime.datetime.now().strftime("%H:%M:%S")
self.current_date = | class PerformanceChartData(TypedDict):
time: str
CPU: int
Memory: int
Network: int |
QuickActionData(TypedDict):
name: str
icon: str
class PerformanceChartData(TypedDict):
time: str
CPU: int
Memory: int
Network: int
class DashboardState(rx.State):
"""Holds the state for the dashboard."""
current_time: str = datetime.datetime.now().strftime("%H:%M:%S")
current_date: str = datetime.datetime.now().strftime("%b %d, %Y")
uptime: str = "14d 06:42:18"
time_zone: str = "UTC-08:00"
active_nav: str = "Dashboard"
active_performance_tab: str = "Performance"
mobile_sidebar_open: bool = False
stat_cards: List[StatCardData] = stat_card_data
system_status: List[SystemStatusData] = system_status_data
resource_allocation: List[ResourceAllocationData] = resource_allocation_data
quick_actions: List[QuickActionData] = quick_actions_data
performance_chart_data: List[PerformanceChartData] = performance_chart_data
system_load: int = 35
@rx.event(background=True)
async def update_time(self):
|
@rx.event
def set_active_nav(self, nav_item: str):
self.active_nav = nav_item
if self.mobile_sidebar_open:
self.mobile_sidebar_open = False
@rx.event
def set_active_performance_tab(self, tab_name: str):
self.active_performance_tab = tab_name
@rx.event
def toggle_mobile_sidebar(self):
self.mobile_sidebar_open = not self.mobile_sidebar_open
@rx.var
def nav_items(self) -> List[Dict[str, str]]:
return [
{
"name": "Dashboard",
"icon": "layout-dashboard",
},
{"name": "Diagnostics", "icon": "activity"},
{"name": "Data Center", "icon": "database"},
{"name": "Network", "icon": "wifi"},
{"name": "Security", "icon": "shield"},
{"name": "Console", "icon": "terminal"},
{
"name": "Communications",
"icon": "message-circle",
},
{"nam | while True:
async with self:
self.current_time = datetime.datetime.now().strftime("%H:%M:%S")
self.current_date = datetime.datetime.now().strftime("%b %d, %Y")
await asyncio.sleep(1) |
class PerformanceChartData(TypedDict):
time: str
CPU: int
Memory: int
Network: int
class DashboardState(rx.State):
"""Holds the state for the dashboard."""
current_time: str = datetime.datetime.now().strftime("%H:%M:%S")
current_date: str = datetime.datetime.now().strftime("%b %d, %Y")
uptime: str = "14d 06:42:18"
time_zone: str = "UTC-08:00"
active_nav: str = "Dashboard"
active_performance_tab: str = "Performance"
mobile_sidebar_open: bool = False
stat_cards: List[StatCardData] = stat_card_data
system_status: List[SystemStatusData] = system_status_data
resource_allocation: List[ResourceAllocationData] = resource_allocation_data
quick_actions: List[QuickActionData] = quick_actions_data
performance_chart_data: List[PerformanceChartData] = performance_chart_data
system_load: int = 35
@rx.event(background=True)
async def update_time(self):
while True:
async with self:
|
self.current_date = datetime.datetime.now().strftime("%b %d, %Y")
await asyncio.sleep(1)
@rx.event
def set_active_nav(self, nav_item: str):
self.active_nav = nav_item
if self.mobile_sidebar_open:
self.mobile_sidebar_open = False
@rx.event
def set_active_performance_tab(self, tab_name: str):
self.active_performance_tab = tab_name
@rx.event
def toggle_mobile_sidebar(self):
self.mobile_sidebar_open = not self.mobile_sidebar_open
@rx.var
def nav_items(self) -> List[Dict[str, str]]:
return [
{
"name": "Dashboard",
"icon": "layout-dashboard",
},
{"name": "Diagnostics", "icon": "activity"},
{"name": "Data Center", "icon": "database"},
{"name": "Network", "icon": "wifi"},
{"name": "Security", "icon": "shield"},
{"name": "Console", "icon": "terminal"},
{ | self.current_time = datetime.datetime.now().strftime("%H:%M:%S") |
nt
Network: int
class DashboardState(rx.State):
"""Holds the state for the dashboard."""
current_time: str = datetime.datetime.now().strftime("%H:%M:%S")
current_date: str = datetime.datetime.now().strftime("%b %d, %Y")
uptime: str = "14d 06:42:18"
time_zone: str = "UTC-08:00"
active_nav: str = "Dashboard"
active_performance_tab: str = "Performance"
mobile_sidebar_open: bool = False
stat_cards: List[StatCardData] = stat_card_data
system_status: List[SystemStatusData] = system_status_data
resource_allocation: List[ResourceAllocationData] = resource_allocation_data
quick_actions: List[QuickActionData] = quick_actions_data
performance_chart_data: List[PerformanceChartData] = performance_chart_data
system_load: int = 35
@rx.event(background=True)
async def update_time(self):
while True:
async with self:
self.current_time = datetime.datetime.now().strftime("%H:%M:%S")
|
await asyncio.sleep(1)
@rx.event
def set_active_nav(self, nav_item: str):
self.active_nav = nav_item
if self.mobile_sidebar_open:
self.mobile_sidebar_open = False
@rx.event
def set_active_performance_tab(self, tab_name: str):
self.active_performance_tab = tab_name
@rx.event
def toggle_mobile_sidebar(self):
self.mobile_sidebar_open = not self.mobile_sidebar_open
@rx.var
def nav_items(self) -> List[Dict[str, str]]:
return [
{
"name": "Dashboard",
"icon": "layout-dashboard",
},
{"name": "Diagnostics", "icon": "activity"},
{"name": "Data Center", "icon": "database"},
{"name": "Network", "icon": "wifi"},
{"name": "Security", "icon": "shield"},
{"name": "Console", "icon": "terminal"},
{
"name": "Communications",
"icon": "message-circle | self.current_date = datetime.datetime.now().strftime("%b %d, %Y") |
r = datetime.datetime.now().strftime("%H:%M:%S")
current_date: str = datetime.datetime.now().strftime("%b %d, %Y")
uptime: str = "14d 06:42:18"
time_zone: str = "UTC-08:00"
active_nav: str = "Dashboard"
active_performance_tab: str = "Performance"
mobile_sidebar_open: bool = False
stat_cards: List[StatCardData] = stat_card_data
system_status: List[SystemStatusData] = system_status_data
resource_allocation: List[ResourceAllocationData] = resource_allocation_data
quick_actions: List[QuickActionData] = quick_actions_data
performance_chart_data: List[PerformanceChartData] = performance_chart_data
system_load: int = 35
@rx.event(background=True)
async def update_time(self):
while True:
async with self:
self.current_time = datetime.datetime.now().strftime("%H:%M:%S")
self.current_date = datetime.datetime.now().strftime("%b %d, %Y")
await asyncio.sleep(1)
@rx.event
|
@rx.event
def set_active_performance_tab(self, tab_name: str):
self.active_performance_tab = tab_name
@rx.event
def toggle_mobile_sidebar(self):
self.mobile_sidebar_open = not self.mobile_sidebar_open
@rx.var
def nav_items(self) -> List[Dict[str, str]]:
return [
{
"name": "Dashboard",
"icon": "layout-dashboard",
},
{"name": "Diagnostics", "icon": "activity"},
{"name": "Data Center", "icon": "database"},
{"name": "Network", "icon": "wifi"},
{"name": "Security", "icon": "shield"},
{"name": "Console", "icon": "terminal"},
{
"name": "Communications",
"icon": "message-circle",
},
{"name": "Settings", "icon": "settings"},
]
| def set_active_nav(self, nav_item: str):
self.active_nav = nav_item
if self.mobile_sidebar_open:
self.mobile_sidebar_open = False |
current_date: str = datetime.datetime.now().strftime("%b %d, %Y")
uptime: str = "14d 06:42:18"
time_zone: str = "UTC-08:00"
active_nav: str = "Dashboard"
active_performance_tab: str = "Performance"
mobile_sidebar_open: bool = False
stat_cards: List[StatCardData] = stat_card_data
system_status: List[SystemStatusData] = system_status_data
resource_allocation: List[ResourceAllocationData] = resource_allocation_data
quick_actions: List[QuickActionData] = quick_actions_data
performance_chart_data: List[PerformanceChartData] = performance_chart_data
system_load: int = 35
@rx.event(background=True)
async def update_time(self):
while True:
async with self:
self.current_time = datetime.datetime.now().strftime("%H:%M:%S")
self.current_date = datetime.datetime.now().strftime("%b %d, %Y")
await asyncio.sleep(1)
@rx.event
def set_active_nav(self, nav_item: str):
|
if self.mobile_sidebar_open:
self.mobile_sidebar_open = False
@rx.event
def set_active_performance_tab(self, tab_name: str):
self.active_performance_tab = tab_name
@rx.event
def toggle_mobile_sidebar(self):
self.mobile_sidebar_open = not self.mobile_sidebar_open
@rx.var
def nav_items(self) -> List[Dict[str, str]]:
return [
{
"name": "Dashboard",
"icon": "layout-dashboard",
},
{"name": "Diagnostics", "icon": "activity"},
{"name": "Data Center", "icon": "database"},
{"name": "Network", "icon": "wifi"},
{"name": "Security", "icon": "shield"},
{"name": "Console", "icon": "terminal"},
{
"name": "Communications",
"icon": "message-circle",
},
{"name": "Settings", "icon": "settings"},
]
| self.active_nav = nav_item |
tetime.now().strftime("%b %d, %Y")
uptime: str = "14d 06:42:18"
time_zone: str = "UTC-08:00"
active_nav: str = "Dashboard"
active_performance_tab: str = "Performance"
mobile_sidebar_open: bool = False
stat_cards: List[StatCardData] = stat_card_data
system_status: List[SystemStatusData] = system_status_data
resource_allocation: List[ResourceAllocationData] = resource_allocation_data
quick_actions: List[QuickActionData] = quick_actions_data
performance_chart_data: List[PerformanceChartData] = performance_chart_data
system_load: int = 35
@rx.event(background=True)
async def update_time(self):
while True:
async with self:
self.current_time = datetime.datetime.now().strftime("%H:%M:%S")
self.current_date = datetime.datetime.now().strftime("%b %d, %Y")
await asyncio.sleep(1)
@rx.event
def set_active_nav(self, nav_item: str):
self.active_nav = nav_item
|
@rx.event
def set_active_performance_tab(self, tab_name: str):
self.active_performance_tab = tab_name
@rx.event
def toggle_mobile_sidebar(self):
self.mobile_sidebar_open = not self.mobile_sidebar_open
@rx.var
def nav_items(self) -> List[Dict[str, str]]:
return [
{
"name": "Dashboard",
"icon": "layout-dashboard",
},
{"name": "Diagnostics", "icon": "activity"},
{"name": "Data Center", "icon": "database"},
{"name": "Network", "icon": "wifi"},
{"name": "Security", "icon": "shield"},
{"name": "Console", "icon": "terminal"},
{
"name": "Communications",
"icon": "message-circle",
},
{"name": "Settings", "icon": "settings"},
]
| if self.mobile_sidebar_open:
self.mobile_sidebar_open = False |
time: str = "14d 06:42:18"
time_zone: str = "UTC-08:00"
active_nav: str = "Dashboard"
active_performance_tab: str = "Performance"
mobile_sidebar_open: bool = False
stat_cards: List[StatCardData] = stat_card_data
system_status: List[SystemStatusData] = system_status_data
resource_allocation: List[ResourceAllocationData] = resource_allocation_data
quick_actions: List[QuickActionData] = quick_actions_data
performance_chart_data: List[PerformanceChartData] = performance_chart_data
system_load: int = 35
@rx.event(background=True)
async def update_time(self):
while True:
async with self:
self.current_time = datetime.datetime.now().strftime("%H:%M:%S")
self.current_date = datetime.datetime.now().strftime("%b %d, %Y")
await asyncio.sleep(1)
@rx.event
def set_active_nav(self, nav_item: str):
self.active_nav = nav_item
if self.mobile_sidebar_open:
|
@rx.event
def set_active_performance_tab(self, tab_name: str):
self.active_performance_tab = tab_name
@rx.event
def toggle_mobile_sidebar(self):
self.mobile_sidebar_open = not self.mobile_sidebar_open
@rx.var
def nav_items(self) -> List[Dict[str, str]]:
return [
{
"name": "Dashboard",
"icon": "layout-dashboard",
},
{"name": "Diagnostics", "icon": "activity"},
{"name": "Data Center", "icon": "database"},
{"name": "Network", "icon": "wifi"},
{"name": "Security", "icon": "shield"},
{"name": "Console", "icon": "terminal"},
{
"name": "Communications",
"icon": "message-circle",
},
{"name": "Settings", "icon": "settings"},
]
| self.mobile_sidebar_open = False |
-08:00"
active_nav: str = "Dashboard"
active_performance_tab: str = "Performance"
mobile_sidebar_open: bool = False
stat_cards: List[StatCardData] = stat_card_data
system_status: List[SystemStatusData] = system_status_data
resource_allocation: List[ResourceAllocationData] = resource_allocation_data
quick_actions: List[QuickActionData] = quick_actions_data
performance_chart_data: List[PerformanceChartData] = performance_chart_data
system_load: int = 35
@rx.event(background=True)
async def update_time(self):
while True:
async with self:
self.current_time = datetime.datetime.now().strftime("%H:%M:%S")
self.current_date = datetime.datetime.now().strftime("%b %d, %Y")
await asyncio.sleep(1)
@rx.event
def set_active_nav(self, nav_item: str):
self.active_nav = nav_item
if self.mobile_sidebar_open:
self.mobile_sidebar_open = False
@rx.event
|
@rx.event
def toggle_mobile_sidebar(self):
self.mobile_sidebar_open = not self.mobile_sidebar_open
@rx.var
def nav_items(self) -> List[Dict[str, str]]:
return [
{
"name": "Dashboard",
"icon": "layout-dashboard",
},
{"name": "Diagnostics", "icon": "activity"},
{"name": "Data Center", "icon": "database"},
{"name": "Network", "icon": "wifi"},
{"name": "Security", "icon": "shield"},
{"name": "Console", "icon": "terminal"},
{
"name": "Communications",
"icon": "message-circle",
},
{"name": "Settings", "icon": "settings"},
]
| def set_active_performance_tab(self, tab_name: str):
self.active_performance_tab = tab_name |
nce_tab: str = "Performance"
mobile_sidebar_open: bool = False
stat_cards: List[StatCardData] = stat_card_data
system_status: List[SystemStatusData] = system_status_data
resource_allocation: List[ResourceAllocationData] = resource_allocation_data
quick_actions: List[QuickActionData] = quick_actions_data
performance_chart_data: List[PerformanceChartData] = performance_chart_data
system_load: int = 35
@rx.event(background=True)
async def update_time(self):
while True:
async with self:
self.current_time = datetime.datetime.now().strftime("%H:%M:%S")
self.current_date = datetime.datetime.now().strftime("%b %d, %Y")
await asyncio.sleep(1)
@rx.event
def set_active_nav(self, nav_item: str):
self.active_nav = nav_item
if self.mobile_sidebar_open:
self.mobile_sidebar_open = False
@rx.event
def set_active_performance_tab(self, tab_name: str):
|
@rx.event
def toggle_mobile_sidebar(self):
self.mobile_sidebar_open = not self.mobile_sidebar_open
@rx.var
def nav_items(self) -> List[Dict[str, str]]:
return [
{
"name": "Dashboard",
"icon": "layout-dashboard",
},
{"name": "Diagnostics", "icon": "activity"},
{"name": "Data Center", "icon": "database"},
{"name": "Network", "icon": "wifi"},
{"name": "Security", "icon": "shield"},
{"name": "Console", "icon": "terminal"},
{
"name": "Communications",
"icon": "message-circle",
},
{"name": "Settings", "icon": "settings"},
]
| self.active_performance_tab = tab_name |
= False
stat_cards: List[StatCardData] = stat_card_data
system_status: List[SystemStatusData] = system_status_data
resource_allocation: List[ResourceAllocationData] = resource_allocation_data
quick_actions: List[QuickActionData] = quick_actions_data
performance_chart_data: List[PerformanceChartData] = performance_chart_data
system_load: int = 35
@rx.event(background=True)
async def update_time(self):
while True:
async with self:
self.current_time = datetime.datetime.now().strftime("%H:%M:%S")
self.current_date = datetime.datetime.now().strftime("%b %d, %Y")
await asyncio.sleep(1)
@rx.event
def set_active_nav(self, nav_item: str):
self.active_nav = nav_item
if self.mobile_sidebar_open:
self.mobile_sidebar_open = False
@rx.event
def set_active_performance_tab(self, tab_name: str):
self.active_performance_tab = tab_name
@rx.event
|
@rx.var
def nav_items(self) -> List[Dict[str, str]]:
return [
{
"name": "Dashboard",
"icon": "layout-dashboard",
},
{"name": "Diagnostics", "icon": "activity"},
{"name": "Data Center", "icon": "database"},
{"name": "Network", "icon": "wifi"},
{"name": "Security", "icon": "shield"},
{"name": "Console", "icon": "terminal"},
{
"name": "Communications",
"icon": "message-circle",
},
{"name": "Settings", "icon": "settings"},
]
| def toggle_mobile_sidebar(self):
self.mobile_sidebar_open = not self.mobile_sidebar_open |
a] = stat_card_data
system_status: List[SystemStatusData] = system_status_data
resource_allocation: List[ResourceAllocationData] = resource_allocation_data
quick_actions: List[QuickActionData] = quick_actions_data
performance_chart_data: List[PerformanceChartData] = performance_chart_data
system_load: int = 35
@rx.event(background=True)
async def update_time(self):
while True:
async with self:
self.current_time = datetime.datetime.now().strftime("%H:%M:%S")
self.current_date = datetime.datetime.now().strftime("%b %d, %Y")
await asyncio.sleep(1)
@rx.event
def set_active_nav(self, nav_item: str):
self.active_nav = nav_item
if self.mobile_sidebar_open:
self.mobile_sidebar_open = False
@rx.event
def set_active_performance_tab(self, tab_name: str):
self.active_performance_tab = tab_name
@rx.event
def toggle_mobile_sidebar(self):
|
@rx.var
def nav_items(self) -> List[Dict[str, str]]:
return [
{
"name": "Dashboard",
"icon": "layout-dashboard",
},
{"name": "Diagnostics", "icon": "activity"},
{"name": "Data Center", "icon": "database"},
{"name": "Network", "icon": "wifi"},
{"name": "Security", "icon": "shield"},
{"name": "Console", "icon": "terminal"},
{
"name": "Communications",
"icon": "message-circle",
},
{"name": "Settings", "icon": "settings"},
]
| self.mobile_sidebar_open = not self.mobile_sidebar_open |
{"v": 18},
{"v": 25},
{"v": 22},
{"v": 30},
{"v": 28},
{"v": 37},
],
},
{
"title": "Memory",
"value": "74%",
"sub_detail": "16.4 GB / 24 GB",
"icon": "memory-stick",
"color": "purple",
"chart_data": [
{"v": 60},
{"v": 65},
{"v": 62},
{"v": 70},
{"v": 68},
{"v": 75},
{"v": 72},
{"v": 80},
{"v": 78},
{"v": 74},
],
},
{
"title": "Network",
"value": "86%",
"sub_detail": "1.2 GB/s | 42ms",
"icon": "wifi",
"color": "teal",
"chart_data": [
{"v": 70},
{"v": 75},
{"v": 72},
{"v": 80},
{"v": 78},
{"v": 85},
{"v": 82},
{"v": 90},
{"v": 88},
{"v": 86},
],
},
]
|
resource_allocation_data = [
{
"name": "Processing Power",
"value": 42,
"color": "cyan",
},
{
"name": "Memory Allocation",
"value": 68,
"color": "pink",
},
{
"name": "Network Bandwidth",
"value": 35,
"color": "blue",
},
]
quick_actions_data = [
{"name": "Security Scan", "icon": "shield-check"},
{"name": "Sync Data", "icon": "refresh-cw"},
{"name": "Backup", "icon": "database"},
{"name": "Console", "icon": "terminal"},
]
performance_chart_data = [
{
"time": "00:00",
"CPU": 28,
"Memory": 25,
"Network": 15,
},
{
"time": "03:00",
"CPU": 32,
"Memory": 30,
"Network": 20,
},
{
"time": "06:00",
"CPU": 30,
"Memory": 35,
"Network": 25,
},
{
"time": "09:00",
"CPU": 35,
"Memory": 40,
"Network": 30,
},
{
"time": | system_status_data = [
{
"name": "Core Systems",
"value": 89,
"color": "green",
},
{"name": "Security", "value": 75, "color": "cyan"},
{"name": "Network", "value": 86, "color": "blue"},
] |
": 74},
],
},
{
"title": "Network",
"value": "86%",
"sub_detail": "1.2 GB/s | 42ms",
"icon": "wifi",
"color": "teal",
"chart_data": [
{"v": 70},
{"v": 75},
{"v": 72},
{"v": 80},
{"v": 78},
{"v": 85},
{"v": 82},
{"v": 90},
{"v": 88},
{"v": 86},
],
},
]
system_status_data = [
{
"name": "Core Systems",
"value": 89,
"color": "green",
},
{"name": "Security", "value": 75, "color": "cyan"},
{"name": "Network", "value": 86, "color": "blue"},
]
resource_allocation_data = [
{
"name": "Processing Power",
"value": 42,
"color": "cyan",
},
{
"name": "Memory Allocation",
"value": 68,
"color": "pink",
},
{
"name": "Network Bandwidth",
"value": 35,
"color": "blue",
},
]
|
performance_chart_data = [
{
"time": "00:00",
"CPU": 28,
"Memory": 25,
"Network": 15,
},
{
"time": "03:00",
"CPU": 32,
"Memory": 30,
"Network": 20,
},
{
"time": "06:00",
"CPU": 30,
"Memory": 35,
"Network": 25,
},
{
"time": "09:00",
"CPU": 35,
"Memory": 40,
"Network": 30,
},
{
"time": "12:00",
"CPU": 38,
"Memory": 42,
"Network": 35,
},
{
"time": "15:00",
"CPU": 36,
"Memory": 40,
"Network": 32,
},
{
"time": "18:00",
"CPU": 34,
"Memory": 38,
"Network": 30,
},
{
"time": "21:00",
"CPU": 32,
"Memory": 35,
"Network": 28,
},
{
"time": "24:00",
"CPU": 30,
"Memory": 33,
"Network": 25,
},
]
| quick_actions_data = [
{"name": "Security Scan", "icon": "shield-check"},
{"name": "Sync Data", "icon": "refresh-cw"},
{"name": "Backup", "icon": "database"},
{"name": "Console", "icon": "terminal"},
] |
from manufacturing_dashboard.components.dashboard_header import dashboard_header
from manufacturing_dashboard.components.metrics_summary import metrics_summary
from manufacturing_dashboard.components.pie_chart import ooc_pie_chart
from manufacturing_dashboard.components.sidebar import sidebar
from manufacturing_dashboard.components.spc_chart import spc_chart
def index() -> rx.Component:
"""The main dashboard page."""
return rx.el.div(
sidebar(),
rx.el.main(
dashboard_header(),
metrics_summary(),
spc_chart(),
rx.el.div(
ooc_pie_chart(),
class_name="mt-6 grid grid-cols-1 gap-6",
),
class_name="w-full p-8 overflow-y-auto bg-slate-900 text-slate-100 min-h-screen lg:ml-64",
),
class_name="flex max-h-screen w-full",
)
app = rx.App(
theme=rx.theme(appearance="light"),
style={
"font_family": "'Inter', sans-serif",
"hei | import reflex as rx | |
import reflex as rx
|
from manufacturing_dashboard.components.metrics_summary import metrics_summary
from manufacturing_dashboard.components.pie_chart import ooc_pie_chart
from manufacturing_dashboard.components.sidebar import sidebar
from manufacturing_dashboard.components.spc_chart import spc_chart
def index() -> rx.Component:
"""The main dashboard page."""
return rx.el.div(
sidebar(),
rx.el.main(
dashboard_header(),
metrics_summary(),
spc_chart(),
rx.el.div(
ooc_pie_chart(),
class_name="mt-6 grid grid-cols-1 gap-6",
),
class_name="w-full p-8 overflow-y-auto bg-slate-900 text-slate-100 min-h-screen lg:ml-64",
),
class_name="flex max-h-screen w-full",
)
app = rx.App(
theme=rx.theme(appearance="light"),
style={
"font_family": "'Inter', sans-serif",
"height": "100%",
"background_color": "#0f172a",
"::selection": {
| from manufacturing_dashboard.components.dashboard_header import dashboard_header |
import reflex as rx
from manufacturing_dashboard.components.dashboard_header import dashboard_header
|
from manufacturing_dashboard.components.pie_chart import ooc_pie_chart
from manufacturing_dashboard.components.sidebar import sidebar
from manufacturing_dashboard.components.spc_chart import spc_chart
def index() -> rx.Component:
"""The main dashboard page."""
return rx.el.div(
sidebar(),
rx.el.main(
dashboard_header(),
metrics_summary(),
spc_chart(),
rx.el.div(
ooc_pie_chart(),
class_name="mt-6 grid grid-cols-1 gap-6",
),
class_name="w-full p-8 overflow-y-auto bg-slate-900 text-slate-100 min-h-screen lg:ml-64",
),
class_name="flex max-h-screen w-full",
)
app = rx.App(
theme=rx.theme(appearance="light"),
style={
"font_family": "'Inter', sans-serif",
"height": "100%",
"background_color": "#0f172a",
"::selection": {
"background_color": "#06b6d4",
"color": "#ffffff",
| from manufacturing_dashboard.components.metrics_summary import metrics_summary |
import reflex as rx
from manufacturing_dashboard.components.dashboard_header import dashboard_header
from manufacturing_dashboard.components.metrics_summary import metrics_summary
|
from manufacturing_dashboard.components.sidebar import sidebar
from manufacturing_dashboard.components.spc_chart import spc_chart
def index() -> rx.Component:
"""The main dashboard page."""
return rx.el.div(
sidebar(),
rx.el.main(
dashboard_header(),
metrics_summary(),
spc_chart(),
rx.el.div(
ooc_pie_chart(),
class_name="mt-6 grid grid-cols-1 gap-6",
),
class_name="w-full p-8 overflow-y-auto bg-slate-900 text-slate-100 min-h-screen lg:ml-64",
),
class_name="flex max-h-screen w-full",
)
app = rx.App(
theme=rx.theme(appearance="light"),
style={
"font_family": "'Inter', sans-serif",
"height": "100%",
"background_color": "#0f172a",
"::selection": {
"background_color": "#06b6d4",
"color": "#ffffff",
},
"body": {"height": "100%", "margin": 0},
"#__next": | from manufacturing_dashboard.components.pie_chart import ooc_pie_chart |
import reflex as rx
from manufacturing_dashboard.components.dashboard_header import dashboard_header
from manufacturing_dashboard.components.metrics_summary import metrics_summary
from manufacturing_dashboard.components.pie_chart import ooc_pie_chart
|
from manufacturing_dashboard.components.spc_chart import spc_chart
def index() -> rx.Component:
"""The main dashboard page."""
return rx.el.div(
sidebar(),
rx.el.main(
dashboard_header(),
metrics_summary(),
spc_chart(),
rx.el.div(
ooc_pie_chart(),
class_name="mt-6 grid grid-cols-1 gap-6",
),
class_name="w-full p-8 overflow-y-auto bg-slate-900 text-slate-100 min-h-screen lg:ml-64",
),
class_name="flex max-h-screen w-full",
)
app = rx.App(
theme=rx.theme(appearance="light"),
style={
"font_family": "'Inter', sans-serif",
"height": "100%",
"background_color": "#0f172a",
"::selection": {
"background_color": "#06b6d4",
"color": "#ffffff",
},
"body": {"height": "100%", "margin": 0},
"#__next": {"height": "100%"},
},
)
app.add_page(index)
| from manufacturing_dashboard.components.sidebar import sidebar |
import reflex as rx
from manufacturing_dashboard.components.dashboard_header import dashboard_header
from manufacturing_dashboard.components.metrics_summary import metrics_summary
from manufacturing_dashboard.components.pie_chart import ooc_pie_chart
from manufacturing_dashboard.components.sidebar import sidebar
|
def index() -> rx.Component:
"""The main dashboard page."""
return rx.el.div(
sidebar(),
rx.el.main(
dashboard_header(),
metrics_summary(),
spc_chart(),
rx.el.div(
ooc_pie_chart(),
class_name="mt-6 grid grid-cols-1 gap-6",
),
class_name="w-full p-8 overflow-y-auto bg-slate-900 text-slate-100 min-h-screen lg:ml-64",
),
class_name="flex max-h-screen w-full",
)
app = rx.App(
theme=rx.theme(appearance="light"),
style={
"font_family": "'Inter', sans-serif",
"height": "100%",
"background_color": "#0f172a",
"::selection": {
"background_color": "#06b6d4",
"color": "#ffffff",
},
"body": {"height": "100%", "margin": 0},
"#__next": {"height": "100%"},
},
)
app.add_page(index)
| from manufacturing_dashboard.components.spc_chart import spc_chart |
from manufacturing_dashboard.states.dashboard_state import DashboardState
def dashboard_header() -> rx.Component:
"""Renders the header section of the dashboard."""
return rx.el.div(
rx.el.div(
rx.el.h1(
"CONTROL CHARTS DASHBOARD",
class_name="text-xs font-semibold text-slate-400 tracking-wider uppercase mr-4",
),
rx.el.button(
rx.cond(
DashboardState.is_running,
"Running...",
"Start Process",
),
on_click=DashboardState.start_process,
disabled=DashboardState.is_running,
class_name=rx.cond(
DashboardState.is_running,
"px-4 py-1.5 text-sm font-medium text-slate-300 bg-slate-700 rounded-md opacity-50 cursor-not-allowed",
"px-4 py-1.5 text-sm font-medium text-white bg-cyan-600 rounded-md hover:bg-cyan-700 t | import reflex as rx | |
import reflex as rx
|
def dashboard_header() -> rx.Component:
"""Renders the header section of the dashboard."""
return rx.el.div(
rx.el.div(
rx.el.h1(
"CONTROL CHARTS DASHBOARD",
class_name="text-xs font-semibold text-slate-400 tracking-wider uppercase mr-4",
),
rx.el.button(
rx.cond(
DashboardState.is_running,
"Running...",
"Start Process",
),
on_click=DashboardState.start_process,
disabled=DashboardState.is_running,
class_name=rx.cond(
DashboardState.is_running,
"px-4 py-1.5 text-sm font-medium text-slate-300 bg-slate-700 rounded-md opacity-50 cursor-not-allowed",
"px-4 py-1.5 text-sm font-medium text-white bg-cyan-600 rounded-md hover:bg-cyan-700 transition-colors duration-150",
),
),
| from manufacturing_dashboard.states.dashboard_state import DashboardState |
from manufacturing_dashboard.states.dashboard_state import DashboardState
def distribution_chart() -> rx.Component:
"""Renders the vertical bar chart for distribution data."""
return rx.el.div(
rx.el.h2(
"Diameter Distribution",
class_name="text-xl font-semibold text-slate-200 mb-2 text-center px-4 pt-4",
),
rx.recharts.bar_chart(
rx.recharts.cartesian_grid(
stroke_dasharray="3 3",
stroke="#475569",
horizontal=True,
vertical=False,
),
rx.recharts.x_axis(data_key="name", type_="category", hide=True),
rx.recharts.y_axis(
type_="number",
allow_decimals=False,
axis_line=False,
tick_line=False,
width=30,
stroke="#94a3b8",
font_size="10px",
),
rx.recharts.bar(
data_key="val | import reflex as rx | |
import reflex as rx
|
def distribution_chart() -> rx.Component:
"""Renders the vertical bar chart for distribution data."""
return rx.el.div(
rx.el.h2(
"Diameter Distribution",
class_name="text-xl font-semibold text-slate-200 mb-2 text-center px-4 pt-4",
),
rx.recharts.bar_chart(
rx.recharts.cartesian_grid(
stroke_dasharray="3 3",
stroke="#475569",
horizontal=True,
vertical=False,
),
rx.recharts.x_axis(data_key="name", type_="category", hide=True),
rx.recharts.y_axis(
type_="number",
allow_decimals=False,
axis_line=False,
tick_line=False,
width=30,
stroke="#94a3b8",
font_size="10px",
),
rx.recharts.bar(
data_key="value",
fill="#fbbf24",
radius=[4, 4, 0, 0],
| from manufacturing_dashboard.states.dashboard_state import DashboardState |
import reflex as rx
from manufacturing_dashboard.states.dashboard_state import (
DashboardState,
)
def sparkline_chart(
data: rx.Var[List[Dict[str, int]]],
) -> rx.Component:
"""Renders a small sparkline chart for the metrics table."""
return rx.recharts.line_chart(
rx.recharts.line(
data_key="uv",
stroke="#fbbf24",
stroke_width=2,
dot=False,
is_animation_active=False,
),
data=data,
width=120,
height=40,
margin={
"top": 5,
"right": 0,
"left": 0,
"bottom": 5,
},
)
def ooc_progress_bar(
percentage: rx.Var[float],
) -> rx.Component:
"""Renders a segmented progress bar for OOC percentage.
Teal: 0-3%, Amber: 3-7%, Red: 7-10%
"""
teal_width = rx.cond(percentage <= 3, percentage * 100 / 3, 100).to_string() + "%"
yellow_width = (
rx.cond(
percentage > 3,
| from typing import Dict, List | |
from typing import Dict, List
|
from manufacturing_dashboard.states.dashboard_state import (
DashboardState,
)
def sparkline_chart(
data: rx.Var[List[Dict[str, int]]],
) -> rx.Component:
"""Renders a small sparkline chart for the metrics table."""
return rx.recharts.line_chart(
rx.recharts.line(
data_key="uv",
stroke="#fbbf24",
stroke_width=2,
dot=False,
is_animation_active=False,
),
data=data,
width=120,
height=40,
margin={
"top": 5,
"right": 0,
"left": 0,
"bottom": 5,
},
)
def ooc_progress_bar(
percentage: rx.Var[float],
) -> rx.Component:
"""Renders a segmented progress bar for OOC percentage.
Teal: 0-3%, Amber: 3-7%, Red: 7-10%
"""
teal_width = rx.cond(percentage <= 3, percentage * 100 / 3, 100).to_string() + "%"
yellow_width = (
rx.cond(
percentage > 3,
rx.cond(
| import reflex as rx |
from typing import Dict, List
import reflex as rx
|
def sparkline_chart(
data: rx.Var[List[Dict[str, int]]],
) -> rx.Component:
"""Renders a small sparkline chart for the metrics table."""
return rx.recharts.line_chart(
rx.recharts.line(
data_key="uv",
stroke="#fbbf24",
stroke_width=2,
dot=False,
is_animation_active=False,
),
data=data,
width=120,
height=40,
margin={
"top": 5,
"right": 0,
"left": 0,
"bottom": 5,
},
)
def ooc_progress_bar(
percentage: rx.Var[float],
) -> rx.Component:
"""Renders a segmented progress bar for OOC percentage.
Teal: 0-3%, Amber: 3-7%, Red: 7-10%
"""
teal_width = rx.cond(percentage <= 3, percentage * 100 / 3, 100).to_string() + "%"
yellow_width = (
rx.cond(
percentage > 3,
rx.cond(
percentage <= 7,
(percentage - 3) * 100 / 4,
| from manufacturing_dashboard.states.dashboard_state import (
DashboardState,
) |
from typing import Dict, List
import reflex as rx
from manufacturing_dashboard.states.dashboard_state import (
DashboardState,
)
|
def ooc_progress_bar(
percentage: rx.Var[float],
) -> rx.Component:
"""Renders a segmented progress bar for OOC percentage.
Teal: 0-3%, Amber: 3-7%, Red: 7-10%
"""
teal_width = rx.cond(percentage <= 3, percentage * 100 / 3, 100).to_string() + "%"
yellow_width = (
rx.cond(
percentage > 3,
rx.cond(
percentage <= 7,
(percentage - 3) * 100 / 4,
100,
),
0,
).to_string()
+ "%"
)
red_width = (
rx.cond(
percentage > 7,
rx.cond(
percentage <= 10,
(percentage - 7) * 100 / 3,
100,
),
0,
).to_string()
+ "%"
)
return rx.el.div(
rx.el.div(
rx.el.div(
style={"width": teal_width},
class_name="h-full bg-teal-500 rounded-l",
),
class_name="w-1/3 h-ful | def sparkline_chart(
data: rx.Var[List[Dict[str, int]]],
) -> rx.Component:
"""Renders a small sparkline chart for the metrics table."""
return rx.recharts.line_chart(
rx.recharts.line(
data_key="uv",
stroke="#fbbf24",
stroke_width=2,
dot=False,
is_animation_active=False,
),
data=data,
width=120,
height=40,
margin={
"top": 5,
"right": 0,
"left": 0,
"bottom": 5,
},
) |
from typing import Dict, List
import reflex as rx
from manufacturing_dashboard.states.dashboard_state import (
DashboardState,
)
def sparkline_chart(
data: rx.Var[List[Dict[str, int]]],
) -> rx.Component:
"""Renders a small sparkline chart for the metrics table."""
return rx.recharts.line_chart(
rx.recharts.line(
data_key="uv",
stroke="#fbbf24",
stroke_width=2,
dot=False,
is_animation_active=False,
),
data=data,
width=120,
height=40,
margin={
"top": 5,
"right": 0,
"left": 0,
"bottom": 5,
},
)
def ooc_progress_bar(
percentage: rx.Var[float],
) -> rx.Component:
"""Renders a segmented progress bar for OOC percentage.
Teal: 0-3%, Amber: 3-7%, Red: 7-10%
"""
|
yellow_width = (
rx.cond(
percentage > 3,
rx.cond(
percentage <= 7,
(percentage - 3) * 100 / 4,
100,
),
0,
).to_string()
+ "%"
)
red_width = (
rx.cond(
percentage > 7,
rx.cond(
percentage <= 10,
(percentage - 7) * 100 / 3,
100,
),
0,
).to_string()
+ "%"
)
return rx.el.div(
rx.el.div(
rx.el.div(
style={"width": teal_width},
class_name="h-full bg-teal-500 rounded-l",
),
class_name="w-1/3 h-full",
),
rx.el.div(
rx.el.div(
style={"width": yellow_width},
class_name="h-full bg-amber-400",
),
class_name="w-1/3 h-full",
),
rx.el.div(
rx.el.div(
| teal_width = rx.cond(percentage <= 3, percentage * 100 / 3, 100).to_string() + "%" |
from typing import Dict, List
import reflex as rx
from manufacturing_dashboard.states.dashboard_state import (
DashboardState,
)
def sparkline_chart(
data: rx.Var[List[Dict[str, int]]],
) -> rx.Component:
"""Renders a small sparkline chart for the metrics table."""
return rx.recharts.line_chart(
rx.recharts.line(
data_key="uv",
stroke="#fbbf24",
stroke_width=2,
dot=False,
is_animation_active=False,
),
data=data,
width=120,
height=40,
margin={
"top": 5,
"right": 0,
"left": 0,
"bottom": 5,
},
)
def ooc_progress_bar(
percentage: rx.Var[float],
) -> rx.Component:
"""Renders a segmented progress bar for OOC percentage.
Teal: 0-3%, Amber: 3-7%, Red: 7-10%
"""
teal_width = rx.cond(percentage <= 3, percentage * 100 / 3, 100).to_string() + "%"
|
red_width = (
rx.cond(
percentage > 7,
rx.cond(
percentage <= 10,
(percentage - 7) * 100 / 3,
100,
),
0,
).to_string()
+ "%"
)
return rx.el.div(
rx.el.div(
rx.el.div(
style={"width": teal_width},
class_name="h-full bg-teal-500 rounded-l",
),
class_name="w-1/3 h-full",
),
rx.el.div(
rx.el.div(
style={"width": yellow_width},
class_name="h-full bg-amber-400",
),
class_name="w-1/3 h-full",
),
rx.el.div(
rx.el.div(
style={"width": red_width},
class_name="h-full bg-red-500 rounded-r",
),
class_name="w-1/3 h-full",
),
class_name="w-24 h-3 bg-slate-600 rounded flex overflow-hidden shadow-inner",
)
def | yellow_width = (
rx.cond(
percentage > 3,
rx.cond(
percentage <= 7,
(percentage - 3) * 100 / 4,
100,
),
0,
).to_string()
+ "%"
) |
"""Renders a small sparkline chart for the metrics table."""
return rx.recharts.line_chart(
rx.recharts.line(
data_key="uv",
stroke="#fbbf24",
stroke_width=2,
dot=False,
is_animation_active=False,
),
data=data,
width=120,
height=40,
margin={
"top": 5,
"right": 0,
"left": 0,
"bottom": 5,
},
)
def ooc_progress_bar(
percentage: rx.Var[float],
) -> rx.Component:
"""Renders a segmented progress bar for OOC percentage.
Teal: 0-3%, Amber: 3-7%, Red: 7-10%
"""
teal_width = rx.cond(percentage <= 3, percentage * 100 / 3, 100).to_string() + "%"
yellow_width = (
rx.cond(
percentage > 3,
rx.cond(
percentage <= 7,
(percentage - 3) * 100 / 4,
100,
),
0,
).to_string()
+ "%"
)
|
return rx.el.div(
rx.el.div(
rx.el.div(
style={"width": teal_width},
class_name="h-full bg-teal-500 rounded-l",
),
class_name="w-1/3 h-full",
),
rx.el.div(
rx.el.div(
style={"width": yellow_width},
class_name="h-full bg-amber-400",
),
class_name="w-1/3 h-full",
),
rx.el.div(
rx.el.div(
style={"width": red_width},
class_name="h-full bg-red-500 rounded-r",
),
class_name="w-1/3 h-full",
),
class_name="w-24 h-3 bg-slate-600 rounded flex overflow-hidden shadow-inner",
)
def pass_fail_indicator(
status: rx.Var[bool],
) -> rx.Component:
"""Renders a small colored dot indicating pass (amber) or fail (red)."""
return rx.el.div(
class_name=rx.cond(
status,
"w-3 h-3 rounded-full bg-amber | red_width = (
rx.cond(
percentage > 7,
rx.cond(
percentage <= 10,
(percentage - 7) * 100 / 3,
100,
),
0,
).to_string()
+ "%"
) |
)
red_width = (
rx.cond(
percentage > 7,
rx.cond(
percentage <= 10,
(percentage - 7) * 100 / 3,
100,
),
0,
).to_string()
+ "%"
)
return rx.el.div(
rx.el.div(
rx.el.div(
style={"width": teal_width},
class_name="h-full bg-teal-500 rounded-l",
),
class_name="w-1/3 h-full",
),
rx.el.div(
rx.el.div(
style={"width": yellow_width},
class_name="h-full bg-amber-400",
),
class_name="w-1/3 h-full",
),
rx.el.div(
rx.el.div(
style={"width": red_width},
class_name="h-full bg-red-500 rounded-r",
),
class_name="w-1/3 h-full",
),
class_name="w-24 h-3 bg-slate-600 rounded flex overflow-hidden shadow-inner",
)
|
def metrics_summary() -> rx.Component:
"""Renders the main table for process control metrics."""
headers = [
"Parameter",
"Count",
"Trend",
"OOC %",
"% OOC Bar",
"Status",
]
return rx.el.div(
rx.el.h2(
"Process Control Metrics Summary",
class_name="text-xl font-semibold text-slate-200 mb-4",
),
rx.el.div(
rx.el.table(
rx.el.thead(
rx.el.tr(
rx.foreach(
headers,
lambda header: rx.el.th(
header,
class_name="px-5 py-3 text-left text-xs font-medium text-slate-400 uppercase tracking-wider border-b border-slate-700 bg-slate-800",
),
)
)
),
rx.el.tbody(
rx.foreach(
| def pass_fail_indicator(
status: rx.Var[bool],
) -> rx.Component:
"""Renders a small colored dot indicating pass (amber) or fail (red)."""
return rx.el.div(
class_name=rx.cond(
status,
"w-3 h-3 rounded-full bg-amber-400 shadow-md",
"w-3 h-3 rounded-full bg-red-500 shadow-md",
)
) |
lass_name="w-1/3 h-full",
),
rx.el.div(
rx.el.div(
style={"width": yellow_width},
class_name="h-full bg-amber-400",
),
class_name="w-1/3 h-full",
),
rx.el.div(
rx.el.div(
style={"width": red_width},
class_name="h-full bg-red-500 rounded-r",
),
class_name="w-1/3 h-full",
),
class_name="w-24 h-3 bg-slate-600 rounded flex overflow-hidden shadow-inner",
)
def pass_fail_indicator(
status: rx.Var[bool],
) -> rx.Component:
"""Renders a small colored dot indicating pass (amber) or fail (red)."""
return rx.el.div(
class_name=rx.cond(
status,
"w-3 h-3 rounded-full bg-amber-400 shadow-md",
"w-3 h-3 rounded-full bg-red-500 shadow-md",
)
)
def metrics_summary() -> rx.Component:
"""Renders the main table for process control metrics."""
|
return rx.el.div(
rx.el.h2(
"Process Control Metrics Summary",
class_name="text-xl font-semibold text-slate-200 mb-4",
),
rx.el.div(
rx.el.table(
rx.el.thead(
rx.el.tr(
rx.foreach(
headers,
lambda header: rx.el.th(
header,
class_name="px-5 py-3 text-left text-xs font-medium text-slate-400 uppercase tracking-wider border-b border-slate-700 bg-slate-800",
),
)
)
),
rx.el.tbody(
rx.foreach(
DashboardState.process_metrics,
lambda metric: rx.el.tr(
rx.el.td(
metric["parameter"],
class_name=" | headers = [
"Parameter",
"Count",
"Trend",
"OOC %",
"% OOC Bar",
"Status",
] |
from manufacturing_dashboard.states.dashboard_state import DashboardState
def ooc_pie_chart() -> rx.Component:
"""Renders the Pie chart showing % OOC per Parameter."""
return rx.el.div(
rx.el.h2(
"% OOC per Parameter",
class_name="text-xl font-semibold text-slate-200 mb-4 text-center",
),
rx.recharts.pie_chart(
rx.recharts.pie(
rx.foreach(
DashboardState.pie_data,
lambda item, index: rx.recharts.cell(fill=item["fill"]),
),
data=DashboardState.pie_data,
data_key="value",
name_key="name",
cx="50%",
cy="50%",
outer_radius="80%",
inner_radius="40%",
padding_angle=2,
label_line=False,
label=False,
is_animation_active=False,
),
rx.recharts.legend(
| import reflex as rx | |
import reflex as rx
|
def ooc_pie_chart() -> rx.Component:
"""Renders the Pie chart showing % OOC per Parameter."""
return rx.el.div(
rx.el.h2(
"% OOC per Parameter",
class_name="text-xl font-semibold text-slate-200 mb-4 text-center",
),
rx.recharts.pie_chart(
rx.recharts.pie(
rx.foreach(
DashboardState.pie_data,
lambda item, index: rx.recharts.cell(fill=item["fill"]),
),
data=DashboardState.pie_data,
data_key="value",
name_key="name",
cx="50%",
cy="50%",
outer_radius="80%",
inner_radius="40%",
padding_angle=2,
label_line=False,
label=False,
is_animation_active=False,
),
rx.recharts.legend(
layout="vertical",
vertical_align="middle",
| from manufacturing_dashboard.states.dashboard_state import DashboardState |
from manufacturing_dashboard.states.dashboard_state import DashboardState
def time_completion_circle() -> rx.Component:
"""Renders the circular progress indicator for time to completion."""
radius = 40
return rx.el.svg(
rx.el.circle(
cx="50",
cy="50",
r=str(radius),
stroke="#334155",
stroke_width="8",
fill="none",
class_name="text-slate-700",
),
rx.el.circle(
cx="50",
cy="50",
r=str(radius),
stroke="#06b6d4",
stroke_width="8",
fill="none",
stroke_dasharray=DashboardState.get_time_stroke_dasharray,
stroke_linecap="round",
transform="rotate(-90 50 50)",
class_name="transition-all duration-300 ease-linear",
),
rx.el.text(
DashboardState.time_to_completion.to(int).to_string() + "%",
x="50",
y="50",
| import reflex as rx | |
import reflex as rx
|
def time_completion_circle() -> rx.Component:
"""Renders the circular progress indicator for time to completion."""
radius = 40
return rx.el.svg(
rx.el.circle(
cx="50",
cy="50",
r=str(radius),
stroke="#334155",
stroke_width="8",
fill="none",
class_name="text-slate-700",
),
rx.el.circle(
cx="50",
cy="50",
r=str(radius),
stroke="#06b6d4",
stroke_width="8",
fill="none",
stroke_dasharray=DashboardState.get_time_stroke_dasharray,
stroke_linecap="round",
transform="rotate(-90 50 50)",
class_name="transition-all duration-300 ease-linear",
),
rx.el.text(
DashboardState.time_to_completion.to(int).to_string() + "%",
x="50",
y="50",
text_anchor="middle",
dominant_baseline="middle",
| from manufacturing_dashboard.states.dashboard_state import DashboardState |
cle(
cx="50",
cy="50",
r=str(radius),
stroke="#334155",
stroke_width="8",
fill="none",
class_name="text-slate-700",
),
rx.el.circle(
cx="50",
cy="50",
r=str(radius),
stroke="#06b6d4",
stroke_width="8",
fill="none",
stroke_dasharray=DashboardState.get_time_stroke_dasharray,
stroke_linecap="round",
transform="rotate(-90 50 50)",
class_name="transition-all duration-300 ease-linear",
),
rx.el.text(
DashboardState.time_to_completion.to(int).to_string() + "%",
x="50",
y="50",
text_anchor="middle",
dominant_baseline="middle",
font_size="18",
font_weight="bold",
fill="#cbd5e1",
),
view_box="0 0 100 100",
class_name="w-28 h-28 mx-auto",
)
|
def sidebar() -> rx.Component:
"""Renders the sidebar component."""
return rx.el.aside(
rx.el.div(
rx.el.div(
rx.el.img(
src="/favicon.ico",
alt="Company Logo",
class_name="h-8 w-auto mr-3",
),
rx.el.span(
"Process Monitor",
class_name="text-xl font-bold text-white whitespace-nowrap",
),
class_name="flex items-center justify-center h-16 border-b border-slate-700",
),
rx.el.div(
rx.el.h3(
"Operator Info",
class_name="text-xs font-semibold text-slate-500 uppercase tracking-wider mb-3 px-4",
),
rx.el.div(
rx.el.span(
"Operator ID:",
class_name="text-slate-400",
),
r | def specification_item(label: str, value: rx.Var[str | float]) -> rx.Component:
"""Renders a single specification item row."""
return rx.el.div(
rx.el.span(label, class_name="text-slate-400 text-sm"),
rx.el.span(
value.to_string(),
class_name="text-slate-200 text-sm font-mono",
),
class_name="flex justify-between items-center py-1.5 px-3 rounded bg-slate-700/50",
) |
from manufacturing_dashboard.states.dashboard_state import (
DashboardState,
SpcDataPoint,
)
def render_ooc_dot(
point: rx.Var[SpcDataPoint],
) -> rx.Component:
"""Renders a ReferenceDot for an out-of-control point."""
return rx.recharts.reference_dot(
x=point["name"],
y=point["value"].to(str),
r=5,
fill="#ef4444",
stroke="none",
is_front=True,
if_overflow="discard",
)
def spc_chart() -> rx.Component:
"""Renders the Live SPC (Statistical Process Control) chart."""
return rx.el.div(
rx.el.div(
rx.el.h2(
"Live SPC Chart: Diameter",
class_name="text-xl font-semibold text-slate-200",
),
rx.el.div(
rx.el.div(
rx.el.div(class_name="w-3 h-0.5 bg-amber-400 mr-1.5"),
rx.el.span(
"Measurement",
class_name="text-xs text-slate-4 | import reflex as rx | |
import reflex as rx
|
def render_ooc_dot(
point: rx.Var[SpcDataPoint],
) -> rx.Component:
"""Renders a ReferenceDot for an out-of-control point."""
return rx.recharts.reference_dot(
x=point["name"],
y=point["value"].to(str),
r=5,
fill="#ef4444",
stroke="none",
is_front=True,
if_overflow="discard",
)
def spc_chart() -> rx.Component:
"""Renders the Live SPC (Statistical Process Control) chart."""
return rx.el.div(
rx.el.div(
rx.el.h2(
"Live SPC Chart: Diameter",
class_name="text-xl font-semibold text-slate-200",
),
rx.el.div(
rx.el.div(
rx.el.div(class_name="w-3 h-0.5 bg-amber-400 mr-1.5"),
rx.el.span(
"Measurement",
class_name="text-xs text-slate-400 mr-4",
),
class_name="flex items-center",
) | from manufacturing_dashboard.states.dashboard_state import (
DashboardState,
SpcDataPoint,
) |
import reflex as rx
from manufacturing_dashboard.states.dashboard_state import (
DashboardState,
SpcDataPoint,
)
|
def spc_chart() -> rx.Component:
"""Renders the Live SPC (Statistical Process Control) chart."""
return rx.el.div(
rx.el.div(
rx.el.h2(
"Live SPC Chart: Diameter",
class_name="text-xl font-semibold text-slate-200",
),
rx.el.div(
rx.el.div(
rx.el.div(class_name="w-3 h-0.5 bg-amber-400 mr-1.5"),
rx.el.span(
"Measurement",
class_name="text-xs text-slate-400 mr-4",
),
class_name="flex items-center",
),
rx.el.div(
rx.el.div(class_name="w-2.5 h-2.5 bg-red-500 rounded-full mr-1.5"),
rx.el.span(
"Out of Control",
class_name="text-xs text-slate-400 mr-4",
),
class_name="flex items-center",
),
| def render_ooc_dot(
point: rx.Var[SpcDataPoint],
) -> rx.Component:
"""Renders a ReferenceDot for an out-of-control point."""
return rx.recharts.reference_dot(
x=point["name"],
y=point["value"].to(str),
r=5,
fill="#ef4444",
stroke="none",
is_front=True,
if_overflow="discard",
) |
import random
from typing import Dict, List, TypedDict
import reflex as rx
from faker import Faker
fake = Faker()
class MetricData(TypedDict):
parameter: str
count: int
sparkline_data: List[Dict[str, int]]
ooc_percent: float
pass_fail: bool
class SpcDataPoint(TypedDict):
name: int
value: float
class PieChartData(TypedDict):
name: str
value: float
fill: str
class DistributionPoint(TypedDict):
name: str
value: int
def _generate_sparkline_data(
count: int = 20,
) -> List[Dict[str, int]]:
return [{"uv": fake.random_int(300, 500)} for _ in range(count)]
def _generate_process_metrics(
num_metrics: int = 4,
) -> List[MetricData]:
parameters = [
"DIAMETER",
"ETCH1",
"FILM-THICKNESS",
"ETCH2",
"LINE-WIDTH",
"OVERLAY",
"VOLUME",
]
random.shuffle(parameters)
metrics = []
for i in range(num_metrics):
param = parameters[i % len(parameters)]
| import asyncio | |
import asyncio
|
from typing import Dict, List, TypedDict
import reflex as rx
from faker import Faker
fake = Faker()
class MetricData(TypedDict):
parameter: str
count: int
sparkline_data: List[Dict[str, int]]
ooc_percent: float
pass_fail: bool
class SpcDataPoint(TypedDict):
name: int
value: float
class PieChartData(TypedDict):
name: str
value: float
fill: str
class DistributionPoint(TypedDict):
name: str
value: int
def _generate_sparkline_data(
count: int = 20,
) -> List[Dict[str, int]]:
return [{"uv": fake.random_int(300, 500)} for _ in range(count)]
def _generate_process_metrics(
num_metrics: int = 4,
) -> List[MetricData]:
parameters = [
"DIAMETER",
"ETCH1",
"FILM-THICKNESS",
"ETCH2",
"LINE-WIDTH",
"OVERLAY",
"VOLUME",
]
random.shuffle(parameters)
metrics = []
for i in range(num_metrics):
param = parameters[i % len(parameters)]
ooc = f | import random |
import asyncio
import random
|
import reflex as rx
from faker import Faker
fake = Faker()
class MetricData(TypedDict):
parameter: str
count: int
sparkline_data: List[Dict[str, int]]
ooc_percent: float
pass_fail: bool
class SpcDataPoint(TypedDict):
name: int
value: float
class PieChartData(TypedDict):
name: str
value: float
fill: str
class DistributionPoint(TypedDict):
name: str
value: int
def _generate_sparkline_data(
count: int = 20,
) -> List[Dict[str, int]]:
return [{"uv": fake.random_int(300, 500)} for _ in range(count)]
def _generate_process_metrics(
num_metrics: int = 4,
) -> List[MetricData]:
parameters = [
"DIAMETER",
"ETCH1",
"FILM-THICKNESS",
"ETCH2",
"LINE-WIDTH",
"OVERLAY",
"VOLUME",
]
random.shuffle(parameters)
metrics = []
for i in range(num_metrics):
param = parameters[i % len(parameters)]
ooc = fake.pyfloat(
left_digits=1,
| from typing import Dict, List, TypedDict |
import asyncio
import random
from typing import Dict, List, TypedDict
|
from faker import Faker
fake = Faker()
class MetricData(TypedDict):
parameter: str
count: int
sparkline_data: List[Dict[str, int]]
ooc_percent: float
pass_fail: bool
class SpcDataPoint(TypedDict):
name: int
value: float
class PieChartData(TypedDict):
name: str
value: float
fill: str
class DistributionPoint(TypedDict):
name: str
value: int
def _generate_sparkline_data(
count: int = 20,
) -> List[Dict[str, int]]:
return [{"uv": fake.random_int(300, 500)} for _ in range(count)]
def _generate_process_metrics(
num_metrics: int = 4,
) -> List[MetricData]:
parameters = [
"DIAMETER",
"ETCH1",
"FILM-THICKNESS",
"ETCH2",
"LINE-WIDTH",
"OVERLAY",
"VOLUME",
]
random.shuffle(parameters)
metrics = []
for i in range(num_metrics):
param = parameters[i % len(parameters)]
ooc = fake.pyfloat(
left_digits=1,
right_digi | import reflex as rx |
import asyncio
import random
from typing import Dict, List, TypedDict
import reflex as rx
|
fake = Faker()
class MetricData(TypedDict):
parameter: str
count: int
sparkline_data: List[Dict[str, int]]
ooc_percent: float
pass_fail: bool
class SpcDataPoint(TypedDict):
name: int
value: float
class PieChartData(TypedDict):
name: str
value: float
fill: str
class DistributionPoint(TypedDict):
name: str
value: int
def _generate_sparkline_data(
count: int = 20,
) -> List[Dict[str, int]]:
return [{"uv": fake.random_int(300, 500)} for _ in range(count)]
def _generate_process_metrics(
num_metrics: int = 4,
) -> List[MetricData]:
parameters = [
"DIAMETER",
"ETCH1",
"FILM-THICKNESS",
"ETCH2",
"LINE-WIDTH",
"OVERLAY",
"VOLUME",
]
random.shuffle(parameters)
metrics = []
for i in range(num_metrics):
param = parameters[i % len(parameters)]
ooc = fake.pyfloat(
left_digits=1,
right_digits=1,
positi | from faker import Faker |
import asyncio
import random
from typing import Dict, List, TypedDict
import reflex as rx
from faker import Faker
|
class MetricData(TypedDict):
parameter: str
count: int
sparkline_data: List[Dict[str, int]]
ooc_percent: float
pass_fail: bool
class SpcDataPoint(TypedDict):
name: int
value: float
class PieChartData(TypedDict):
name: str
value: float
fill: str
class DistributionPoint(TypedDict):
name: str
value: int
def _generate_sparkline_data(
count: int = 20,
) -> List[Dict[str, int]]:
return [{"uv": fake.random_int(300, 500)} for _ in range(count)]
def _generate_process_metrics(
num_metrics: int = 4,
) -> List[MetricData]:
parameters = [
"DIAMETER",
"ETCH1",
"FILM-THICKNESS",
"ETCH2",
"LINE-WIDTH",
"OVERLAY",
"VOLUME",
]
random.shuffle(parameters)
metrics = []
for i in range(num_metrics):
param = parameters[i % len(parameters)]
ooc = fake.pyfloat(
left_digits=1,
right_digits=1,
positive=True,
| fake = Faker() |
import asyncio
import random
from typing import Dict, List, TypedDict
import reflex as rx
from faker import Faker
fake = Faker()
|
class SpcDataPoint(TypedDict):
name: int
value: float
class PieChartData(TypedDict):
name: str
value: float
fill: str
class DistributionPoint(TypedDict):
name: str
value: int
def _generate_sparkline_data(
count: int = 20,
) -> List[Dict[str, int]]:
return [{"uv": fake.random_int(300, 500)} for _ in range(count)]
def _generate_process_metrics(
num_metrics: int = 4,
) -> List[MetricData]:
parameters = [
"DIAMETER",
"ETCH1",
"FILM-THICKNESS",
"ETCH2",
"LINE-WIDTH",
"OVERLAY",
"VOLUME",
]
random.shuffle(parameters)
metrics = []
for i in range(num_metrics):
param = parameters[i % len(parameters)]
ooc = fake.pyfloat(
left_digits=1,
right_digits=1,
positive=True,
max_value=10.0,
)
metrics.append(
{
"parameter": param,
"count": fake.random_int(40, | class MetricData(TypedDict):
parameter: str
count: int
sparkline_data: List[Dict[str, int]]
ooc_percent: float
pass_fail: bool |
import asyncio
import random
from typing import Dict, List, TypedDict
import reflex as rx
from faker import Faker
fake = Faker()
class MetricData(TypedDict):
parameter: str
count: int
sparkline_data: List[Dict[str, int]]
ooc_percent: float
pass_fail: bool
|
class PieChartData(TypedDict):
name: str
value: float
fill: str
class DistributionPoint(TypedDict):
name: str
value: int
def _generate_sparkline_data(
count: int = 20,
) -> List[Dict[str, int]]:
return [{"uv": fake.random_int(300, 500)} for _ in range(count)]
def _generate_process_metrics(
num_metrics: int = 4,
) -> List[MetricData]:
parameters = [
"DIAMETER",
"ETCH1",
"FILM-THICKNESS",
"ETCH2",
"LINE-WIDTH",
"OVERLAY",
"VOLUME",
]
random.shuffle(parameters)
metrics = []
for i in range(num_metrics):
param = parameters[i % len(parameters)]
ooc = fake.pyfloat(
left_digits=1,
right_digits=1,
positive=True,
max_value=10.0,
)
metrics.append(
{
"parameter": param,
"count": fake.random_int(40, 60),
"sparkline_data": _generate_sparkline_data | class SpcDataPoint(TypedDict):
name: int
value: float |
import asyncio
import random
from typing import Dict, List, TypedDict
import reflex as rx
from faker import Faker
fake = Faker()
class MetricData(TypedDict):
parameter: str
count: int
sparkline_data: List[Dict[str, int]]
ooc_percent: float
pass_fail: bool
class SpcDataPoint(TypedDict):
name: int
value: float
|
class DistributionPoint(TypedDict):
name: str
value: int
def _generate_sparkline_data(
count: int = 20,
) -> List[Dict[str, int]]:
return [{"uv": fake.random_int(300, 500)} for _ in range(count)]
def _generate_process_metrics(
num_metrics: int = 4,
) -> List[MetricData]:
parameters = [
"DIAMETER",
"ETCH1",
"FILM-THICKNESS",
"ETCH2",
"LINE-WIDTH",
"OVERLAY",
"VOLUME",
]
random.shuffle(parameters)
metrics = []
for i in range(num_metrics):
param = parameters[i % len(parameters)]
ooc = fake.pyfloat(
left_digits=1,
right_digits=1,
positive=True,
max_value=10.0,
)
metrics.append(
{
"parameter": param,
"count": fake.random_int(40, 60),
"sparkline_data": _generate_sparkline_data(),
"ooc_percent": round(ooc, 1),
"pass_fail": | class PieChartData(TypedDict):
name: str
value: float
fill: str |
import asyncio
import random
from typing import Dict, List, TypedDict
import reflex as rx
from faker import Faker
fake = Faker()
class MetricData(TypedDict):
parameter: str
count: int
sparkline_data: List[Dict[str, int]]
ooc_percent: float
pass_fail: bool
class SpcDataPoint(TypedDict):
name: int
value: float
class PieChartData(TypedDict):
name: str
value: float
fill: str
|
def _generate_sparkline_data(
count: int = 20,
) -> List[Dict[str, int]]:
return [{"uv": fake.random_int(300, 500)} for _ in range(count)]
def _generate_process_metrics(
num_metrics: int = 4,
) -> List[MetricData]:
parameters = [
"DIAMETER",
"ETCH1",
"FILM-THICKNESS",
"ETCH2",
"LINE-WIDTH",
"OVERLAY",
"VOLUME",
]
random.shuffle(parameters)
metrics = []
for i in range(num_metrics):
param = parameters[i % len(parameters)]
ooc = fake.pyfloat(
left_digits=1,
right_digits=1,
positive=True,
max_value=10.0,
)
metrics.append(
{
"parameter": param,
"count": fake.random_int(40, 60),
"sparkline_data": _generate_sparkline_data(),
"ooc_percent": round(ooc, 1),
"pass_fail": ooc <= 7.0,
}
)
return metrics
def _gene | class DistributionPoint(TypedDict):
name: str
value: int |
import asyncio
import random
from typing import Dict, List, TypedDict
import reflex as rx
from faker import Faker
fake = Faker()
class MetricData(TypedDict):
parameter: str
count: int
sparkline_data: List[Dict[str, int]]
ooc_percent: float
pass_fail: bool
class SpcDataPoint(TypedDict):
name: int
value: float
class PieChartData(TypedDict):
name: str
value: float
fill: str
class DistributionPoint(TypedDict):
name: str
value: int
|
def _generate_process_metrics(
num_metrics: int = 4,
) -> List[MetricData]:
parameters = [
"DIAMETER",
"ETCH1",
"FILM-THICKNESS",
"ETCH2",
"LINE-WIDTH",
"OVERLAY",
"VOLUME",
]
random.shuffle(parameters)
metrics = []
for i in range(num_metrics):
param = parameters[i % len(parameters)]
ooc = fake.pyfloat(
left_digits=1,
right_digits=1,
positive=True,
max_value=10.0,
)
metrics.append(
{
"parameter": param,
"count": fake.random_int(40, 60),
"sparkline_data": _generate_sparkline_data(),
"ooc_percent": round(ooc, 1),
"pass_fail": ooc <= 7.0,
}
)
return metrics
def _generate_spc_data(
num_points: int = 30,
base_min: float = 0.415,
base_max: float = 0.428,
ooc_freq_up: int = 5,
ooc_amount_up: float | def _generate_sparkline_data(
count: int = 20,
) -> List[Dict[str, int]]:
return [{"uv": fake.random_int(300, 500)} for _ in range(count)] |
import asyncio
import random
from typing import Dict, List, TypedDict
import reflex as rx
from faker import Faker
fake = Faker()
class MetricData(TypedDict):
parameter: str
count: int
sparkline_data: List[Dict[str, int]]
ooc_percent: float
pass_fail: bool
class SpcDataPoint(TypedDict):
name: int
value: float
class PieChartData(TypedDict):
name: str
value: float
fill: str
class DistributionPoint(TypedDict):
name: str
value: int
def _generate_sparkline_data(
count: int = 20,
) -> List[Dict[str, int]]:
return [{"uv": fake.random_int(300, 500)} for _ in range(count)]
|
def _generate_spc_data(
num_points: int = 30,
base_min: float = 0.415,
base_max: float = 0.428,
ooc_freq_up: int = 5,
ooc_amount_up: float = 0.005,
ooc_freq_down: int = 7,
ooc_amount_down: float = 0.008,
) -> List[SpcDataPoint]:
data = []
for i in range(num_points):
base_value = fake.pyfloat(
left_digits=0,
right_digits=4,
positive=True,
min_value=base_min,
max_value=base_max,
)
if random.random() < 0.1:
base_value += random.uniform(ooc_amount_up * 1.5, ooc_amount_up * 2.5)
elif random.random() < 0.1:
base_value -= random.uniform(ooc_amount_down * 1.5, ooc_amount_down * 2.5)
elif i % ooc_freq_up == 0:
base_value += random.uniform(ooc_amount_up * 0.5, ooc_amount_up * 1.5)
elif i % ooc_freq_down == 0:
base_value -= random.uniform(ooc_amount_down * 0.5, ooc_amount_down * 1.5)
data.append({ | def _generate_process_metrics(
num_metrics: int = 4,
) -> List[MetricData]:
parameters = [
"DIAMETER",
"ETCH1",
"FILM-THICKNESS",
"ETCH2",
"LINE-WIDTH",
"OVERLAY",
"VOLUME",
]
random.shuffle(parameters)
metrics = []
for i in range(num_metrics):
param = parameters[i % len(parameters)]
ooc = fake.pyfloat(
left_digits=1,
right_digits=1,
positive=True,
max_value=10.0,
)
metrics.append(
{
"parameter": param,
"count": fake.random_int(40, 60),
"sparkline_data": _generate_sparkline_data(),
"ooc_percent": round(ooc, 1),
"pass_fail": ooc <= 7.0,
}
)
return metrics |
import asyncio
import random
from typing import Dict, List, TypedDict
import reflex as rx
from faker import Faker
fake = Faker()
class MetricData(TypedDict):
parameter: str
count: int
sparkline_data: List[Dict[str, int]]
ooc_percent: float
pass_fail: bool
class SpcDataPoint(TypedDict):
name: int
value: float
class PieChartData(TypedDict):
name: str
value: float
fill: str
class DistributionPoint(TypedDict):
name: str
value: int
def _generate_sparkline_data(
count: int = 20,
) -> List[Dict[str, int]]:
return [{"uv": fake.random_int(300, 500)} for _ in range(count)]
def _generate_process_metrics(
num_metrics: int = 4,
) -> List[MetricData]:
|
random.shuffle(parameters)
metrics = []
for i in range(num_metrics):
param = parameters[i % len(parameters)]
ooc = fake.pyfloat(
left_digits=1,
right_digits=1,
positive=True,
max_value=10.0,
)
metrics.append(
{
"parameter": param,
"count": fake.random_int(40, 60),
"sparkline_data": _generate_sparkline_data(),
"ooc_percent": round(ooc, 1),
"pass_fail": ooc <= 7.0,
}
)
return metrics
def _generate_spc_data(
num_points: int = 30,
base_min: float = 0.415,
base_max: float = 0.428,
ooc_freq_up: int = 5,
ooc_amount_up: float = 0.005,
ooc_freq_down: int = 7,
ooc_amount_down: float = 0.008,
) -> List[SpcDataPoint]:
data = []
for i in range(num_points):
base_value = fake.pyfloat(
left_digits=0,
right_digits=4,
| parameters = [
"DIAMETER",
"ETCH1",
"FILM-THICKNESS",
"ETCH2",
"LINE-WIDTH",
"OVERLAY",
"VOLUME",
] |
import asyncio
import random
from typing import Dict, List, TypedDict
import reflex as rx
from faker import Faker
fake = Faker()
class MetricData(TypedDict):
parameter: str
count: int
sparkline_data: List[Dict[str, int]]
ooc_percent: float
pass_fail: bool
class SpcDataPoint(TypedDict):
name: int
value: float
class PieChartData(TypedDict):
name: str
value: float
fill: str
class DistributionPoint(TypedDict):
name: str
value: int
def _generate_sparkline_data(
count: int = 20,
) -> List[Dict[str, int]]:
return [{"uv": fake.random_int(300, 500)} for _ in range(count)]
def _generate_process_metrics(
num_metrics: int = 4,
) -> List[MetricData]:
parameters = [
"DIAMETER",
"ETCH1",
"FILM-THICKNESS",
"ETCH2",
"LINE-WIDTH",
"OVERLAY",
"VOLUME",
]
random.shuffle(parameters)
|
for i in range(num_metrics):
param = parameters[i % len(parameters)]
ooc = fake.pyfloat(
left_digits=1,
right_digits=1,
positive=True,
max_value=10.0,
)
metrics.append(
{
"parameter": param,
"count": fake.random_int(40, 60),
"sparkline_data": _generate_sparkline_data(),
"ooc_percent": round(ooc, 1),
"pass_fail": ooc <= 7.0,
}
)
return metrics
def _generate_spc_data(
num_points: int = 30,
base_min: float = 0.415,
base_max: float = 0.428,
ooc_freq_up: int = 5,
ooc_amount_up: float = 0.005,
ooc_freq_down: int = 7,
ooc_amount_down: float = 0.008,
) -> List[SpcDataPoint]:
data = []
for i in range(num_points):
base_value = fake.pyfloat(
left_digits=0,
right_digits=4,
positive=True,
min_value=base_min,
| metrics = [] |
import asyncio
import random
from typing import Dict, List, TypedDict
import reflex as rx
from faker import Faker
fake = Faker()
class MetricData(TypedDict):
parameter: str
count: int
sparkline_data: List[Dict[str, int]]
ooc_percent: float
pass_fail: bool
class SpcDataPoint(TypedDict):
name: int
value: float
class PieChartData(TypedDict):
name: str
value: float
fill: str
class DistributionPoint(TypedDict):
name: str
value: int
def _generate_sparkline_data(
count: int = 20,
) -> List[Dict[str, int]]:
return [{"uv": fake.random_int(300, 500)} for _ in range(count)]
def _generate_process_metrics(
num_metrics: int = 4,
) -> List[MetricData]:
parameters = [
"DIAMETER",
"ETCH1",
"FILM-THICKNESS",
"ETCH2",
"LINE-WIDTH",
"OVERLAY",
"VOLUME",
]
random.shuffle(parameters)
metrics = []
|
return metrics
def _generate_spc_data(
num_points: int = 30,
base_min: float = 0.415,
base_max: float = 0.428,
ooc_freq_up: int = 5,
ooc_amount_up: float = 0.005,
ooc_freq_down: int = 7,
ooc_amount_down: float = 0.008,
) -> List[SpcDataPoint]:
data = []
for i in range(num_points):
base_value = fake.pyfloat(
left_digits=0,
right_digits=4,
positive=True,
min_value=base_min,
max_value=base_max,
)
if random.random() < 0.1:
base_value += random.uniform(ooc_amount_up * 1.5, ooc_amount_up * 2.5)
elif random.random() < 0.1:
base_value -= random.uniform(ooc_amount_down * 1.5, ooc_amount_down * 2.5)
elif i % ooc_freq_up == 0:
base_value += random.uniform(ooc_amount_up * 0.5, ooc_amount_up * 1.5)
elif i % ooc_freq_down == 0:
base_value -= random.uniform(ooc_amount_down * 0.5, ooc_amount_down * 1.5)
| for i in range(num_metrics):
param = parameters[i % len(parameters)]
ooc = fake.pyfloat(
left_digits=1,
right_digits=1,
positive=True,
max_value=10.0,
)
metrics.append(
{
"parameter": param,
"count": fake.random_int(40, 60),
"sparkline_data": _generate_sparkline_data(),
"ooc_percent": round(ooc, 1),
"pass_fail": ooc <= 7.0,
}
) |
import asyncio
import random
from typing import Dict, List, TypedDict
import reflex as rx
from faker import Faker
fake = Faker()
class MetricData(TypedDict):
parameter: str
count: int
sparkline_data: List[Dict[str, int]]
ooc_percent: float
pass_fail: bool
class SpcDataPoint(TypedDict):
name: int
value: float
class PieChartData(TypedDict):
name: str
value: float
fill: str
class DistributionPoint(TypedDict):
name: str
value: int
def _generate_sparkline_data(
count: int = 20,
) -> List[Dict[str, int]]:
return [{"uv": fake.random_int(300, 500)} for _ in range(count)]
def _generate_process_metrics(
num_metrics: int = 4,
) -> List[MetricData]:
parameters = [
"DIAMETER",
"ETCH1",
"FILM-THICKNESS",
"ETCH2",
"LINE-WIDTH",
"OVERLAY",
"VOLUME",
]
random.shuffle(parameters)
metrics = []
for i in range(num_metrics):
|
ooc = fake.pyfloat(
left_digits=1,
right_digits=1,
positive=True,
max_value=10.0,
)
metrics.append(
{
"parameter": param,
"count": fake.random_int(40, 60),
"sparkline_data": _generate_sparkline_data(),
"ooc_percent": round(ooc, 1),
"pass_fail": ooc <= 7.0,
}
)
return metrics
def _generate_spc_data(
num_points: int = 30,
base_min: float = 0.415,
base_max: float = 0.428,
ooc_freq_up: int = 5,
ooc_amount_up: float = 0.005,
ooc_freq_down: int = 7,
ooc_amount_down: float = 0.008,
) -> List[SpcDataPoint]:
data = []
for i in range(num_points):
base_value = fake.pyfloat(
left_digits=0,
right_digits=4,
positive=True,
min_value=base_min,
max_value=base_max,
)
if random.random() < 0.1:
| param = parameters[i % len(parameters)] |
random
from typing import Dict, List, TypedDict
import reflex as rx
from faker import Faker
fake = Faker()
class MetricData(TypedDict):
parameter: str
count: int
sparkline_data: List[Dict[str, int]]
ooc_percent: float
pass_fail: bool
class SpcDataPoint(TypedDict):
name: int
value: float
class PieChartData(TypedDict):
name: str
value: float
fill: str
class DistributionPoint(TypedDict):
name: str
value: int
def _generate_sparkline_data(
count: int = 20,
) -> List[Dict[str, int]]:
return [{"uv": fake.random_int(300, 500)} for _ in range(count)]
def _generate_process_metrics(
num_metrics: int = 4,
) -> List[MetricData]:
parameters = [
"DIAMETER",
"ETCH1",
"FILM-THICKNESS",
"ETCH2",
"LINE-WIDTH",
"OVERLAY",
"VOLUME",
]
random.shuffle(parameters)
metrics = []
for i in range(num_metrics):
param = parameters[i % len(parameters)]
|
metrics.append(
{
"parameter": param,
"count": fake.random_int(40, 60),
"sparkline_data": _generate_sparkline_data(),
"ooc_percent": round(ooc, 1),
"pass_fail": ooc <= 7.0,
}
)
return metrics
def _generate_spc_data(
num_points: int = 30,
base_min: float = 0.415,
base_max: float = 0.428,
ooc_freq_up: int = 5,
ooc_amount_up: float = 0.005,
ooc_freq_down: int = 7,
ooc_amount_down: float = 0.008,
) -> List[SpcDataPoint]:
data = []
for i in range(num_points):
base_value = fake.pyfloat(
left_digits=0,
right_digits=4,
positive=True,
min_value=base_min,
max_value=base_max,
)
if random.random() < 0.1:
base_value += random.uniform(ooc_amount_up * 1.5, ooc_amount_up * 2.5)
elif random.random() < 0.1:
base_value -= random.u | ooc = fake.pyfloat(
left_digits=1,
right_digits=1,
positive=True,
max_value=10.0,
) |
ER",
"ETCH1",
"FILM-THICKNESS",
"ETCH2",
"LINE-WIDTH",
"OVERLAY",
"VOLUME",
]
random.shuffle(parameters)
metrics = []
for i in range(num_metrics):
param = parameters[i % len(parameters)]
ooc = fake.pyfloat(
left_digits=1,
right_digits=1,
positive=True,
max_value=10.0,
)
metrics.append(
{
"parameter": param,
"count": fake.random_int(40, 60),
"sparkline_data": _generate_sparkline_data(),
"ooc_percent": round(ooc, 1),
"pass_fail": ooc <= 7.0,
}
)
return metrics
def _generate_spc_data(
num_points: int = 30,
base_min: float = 0.415,
base_max: float = 0.428,
ooc_freq_up: int = 5,
ooc_amount_up: float = 0.005,
ooc_freq_down: int = 7,
ooc_amount_down: float = 0.008,
) -> List[SpcDataPoint]:
data = []
|
return data
def _generate_pie_data(
metrics: List[MetricData],
) -> List[PieChartData]:
pie_data = []
colors_fail = [
"#f87171",
"#ef4444",
"#dc2626",
"#fb923c",
"#f97316",
]
colors_pass = [
"#2dd4bf",
"#14b8a6",
"#0d9488",
"#60a5fa",
"#3b82f6",
"#a78bfa",
"#93c5fd",
]
color_index_fail = 0
color_index_pass = 0
for metric in metrics:
if metric["ooc_percent"] > 0.1:
if not metric["pass_fail"]:
fill_color = colors_fail[color_index_fail % len(colors_fail)]
color_index_fail += 1
else:
fill_color = colors_pass[color_index_pass % len(colors_pass)]
color_index_pass += 1
pie_data.append(
{
"name": metric["parameter"],
"value": metric["ooc_percent"],
"fill": fill_color,
| for i in range(num_points):
base_value = fake.pyfloat(
left_digits=0,
right_digits=4,
positive=True,
min_value=base_min,
max_value=base_max,
)
if random.random() < 0.1:
base_value += random.uniform(ooc_amount_up * 1.5, ooc_amount_up * 2.5)
elif random.random() < 0.1:
base_value -= random.uniform(ooc_amount_down * 1.5, ooc_amount_down * 2.5)
elif i % ooc_freq_up == 0:
base_value += random.uniform(ooc_amount_up * 0.5, ooc_amount_up * 1.5)
elif i % ooc_freq_down == 0:
base_value -= random.uniform(ooc_amount_down * 0.5, ooc_amount_down * 1.5)
data.append({"name": i, "value": round(base_value, 4)}) |
THICKNESS",
"ETCH2",
"LINE-WIDTH",
"OVERLAY",
"VOLUME",
]
random.shuffle(parameters)
metrics = []
for i in range(num_metrics):
param = parameters[i % len(parameters)]
ooc = fake.pyfloat(
left_digits=1,
right_digits=1,
positive=True,
max_value=10.0,
)
metrics.append(
{
"parameter": param,
"count": fake.random_int(40, 60),
"sparkline_data": _generate_sparkline_data(),
"ooc_percent": round(ooc, 1),
"pass_fail": ooc <= 7.0,
}
)
return metrics
def _generate_spc_data(
num_points: int = 30,
base_min: float = 0.415,
base_max: float = 0.428,
ooc_freq_up: int = 5,
ooc_amount_up: float = 0.005,
ooc_freq_down: int = 7,
ooc_amount_down: float = 0.008,
) -> List[SpcDataPoint]:
data = []
for i in range(num_points):
|
if random.random() < 0.1:
base_value += random.uniform(ooc_amount_up * 1.5, ooc_amount_up * 2.5)
elif random.random() < 0.1:
base_value -= random.uniform(ooc_amount_down * 1.5, ooc_amount_down * 2.5)
elif i % ooc_freq_up == 0:
base_value += random.uniform(ooc_amount_up * 0.5, ooc_amount_up * 1.5)
elif i % ooc_freq_down == 0:
base_value -= random.uniform(ooc_amount_down * 0.5, ooc_amount_down * 1.5)
data.append({"name": i, "value": round(base_value, 4)})
return data
def _generate_pie_data(
metrics: List[MetricData],
) -> List[PieChartData]:
pie_data = []
colors_fail = [
"#f87171",
"#ef4444",
"#dc2626",
"#fb923c",
"#f97316",
]
colors_pass = [
"#2dd4bf",
"#14b8a6",
"#0d9488",
"#60a5fa",
"#3b82f6",
"#a78bfa",
"#93c5fd",
]
color_index_fail = 0
color_index_pass = 0
for | base_value = fake.pyfloat(
left_digits=0,
right_digits=4,
positive=True,
min_value=base_min,
max_value=base_max,
) |
parameters[i % len(parameters)]
ooc = fake.pyfloat(
left_digits=1,
right_digits=1,
positive=True,
max_value=10.0,
)
metrics.append(
{
"parameter": param,
"count": fake.random_int(40, 60),
"sparkline_data": _generate_sparkline_data(),
"ooc_percent": round(ooc, 1),
"pass_fail": ooc <= 7.0,
}
)
return metrics
def _generate_spc_data(
num_points: int = 30,
base_min: float = 0.415,
base_max: float = 0.428,
ooc_freq_up: int = 5,
ooc_amount_up: float = 0.005,
ooc_freq_down: int = 7,
ooc_amount_down: float = 0.008,
) -> List[SpcDataPoint]:
data = []
for i in range(num_points):
base_value = fake.pyfloat(
left_digits=0,
right_digits=4,
positive=True,
min_value=base_min,
max_value=base_max,
)
|
data.append({"name": i, "value": round(base_value, 4)})
return data
def _generate_pie_data(
metrics: List[MetricData],
) -> List[PieChartData]:
pie_data = []
colors_fail = [
"#f87171",
"#ef4444",
"#dc2626",
"#fb923c",
"#f97316",
]
colors_pass = [
"#2dd4bf",
"#14b8a6",
"#0d9488",
"#60a5fa",
"#3b82f6",
"#a78bfa",
"#93c5fd",
]
color_index_fail = 0
color_index_pass = 0
for metric in metrics:
if metric["ooc_percent"] > 0.1:
if not metric["pass_fail"]:
fill_color = colors_fail[color_index_fail % len(colors_fail)]
color_index_fail += 1
else:
fill_color = colors_pass[color_index_pass % len(colors_pass)]
color_index_pass += 1
pie_data.append(
{
"name": metric["parameter"],
"value": metric[ | if random.random() < 0.1:
base_value += random.uniform(ooc_amount_up * 1.5, ooc_amount_up * 2.5)
elif random.random() < 0.1:
base_value -= random.uniform(ooc_amount_down * 1.5, ooc_amount_down * 2.5)
elif i % ooc_freq_up == 0:
base_value += random.uniform(ooc_amount_up * 0.5, ooc_amount_up * 1.5)
elif i % ooc_freq_down == 0:
base_value -= random.uniform(ooc_amount_down * 0.5, ooc_amount_down * 1.5) |
positive=True,
max_value=10.0,
)
metrics.append(
{
"parameter": param,
"count": fake.random_int(40, 60),
"sparkline_data": _generate_sparkline_data(),
"ooc_percent": round(ooc, 1),
"pass_fail": ooc <= 7.0,
}
)
return metrics
def _generate_spc_data(
num_points: int = 30,
base_min: float = 0.415,
base_max: float = 0.428,
ooc_freq_up: int = 5,
ooc_amount_up: float = 0.005,
ooc_freq_down: int = 7,
ooc_amount_down: float = 0.008,
) -> List[SpcDataPoint]:
data = []
for i in range(num_points):
base_value = fake.pyfloat(
left_digits=0,
right_digits=4,
positive=True,
min_value=base_min,
max_value=base_max,
)
if random.random() < 0.1:
base_value += random.uniform(ooc_amount_up * 1.5, ooc_amount_up * 2.5)
|
data.append({"name": i, "value": round(base_value, 4)})
return data
def _generate_pie_data(
metrics: List[MetricData],
) -> List[PieChartData]:
pie_data = []
colors_fail = [
"#f87171",
"#ef4444",
"#dc2626",
"#fb923c",
"#f97316",
]
colors_pass = [
"#2dd4bf",
"#14b8a6",
"#0d9488",
"#60a5fa",
"#3b82f6",
"#a78bfa",
"#93c5fd",
]
color_index_fail = 0
color_index_pass = 0
for metric in metrics:
if metric["ooc_percent"] > 0.1:
if not metric["pass_fail"]:
fill_color = colors_fail[color_index_fail % len(colors_fail)]
color_index_fail += 1
else:
fill_color = colors_pass[color_index_pass % len(colors_pass)]
color_index_pass += 1
pie_data.append(
{
"name": metric["parameter"],
"value": metric[ | elif random.random() < 0.1:
base_value -= random.uniform(ooc_amount_down * 1.5, ooc_amount_down * 2.5)
elif i % ooc_freq_up == 0:
base_value += random.uniform(ooc_amount_up * 0.5, ooc_amount_up * 1.5)
elif i % ooc_freq_down == 0:
base_value -= random.uniform(ooc_amount_down * 0.5, ooc_amount_down * 1.5) |
eter": param,
"count": fake.random_int(40, 60),
"sparkline_data": _generate_sparkline_data(),
"ooc_percent": round(ooc, 1),
"pass_fail": ooc <= 7.0,
}
)
return metrics
def _generate_spc_data(
num_points: int = 30,
base_min: float = 0.415,
base_max: float = 0.428,
ooc_freq_up: int = 5,
ooc_amount_up: float = 0.005,
ooc_freq_down: int = 7,
ooc_amount_down: float = 0.008,
) -> List[SpcDataPoint]:
data = []
for i in range(num_points):
base_value = fake.pyfloat(
left_digits=0,
right_digits=4,
positive=True,
min_value=base_min,
max_value=base_max,
)
if random.random() < 0.1:
base_value += random.uniform(ooc_amount_up * 1.5, ooc_amount_up * 2.5)
elif random.random() < 0.1:
base_value -= random.uniform(ooc_amount_down * 1.5, ooc_amount_down * 2.5)
|
data.append({"name": i, "value": round(base_value, 4)})
return data
def _generate_pie_data(
metrics: List[MetricData],
) -> List[PieChartData]:
pie_data = []
colors_fail = [
"#f87171",
"#ef4444",
"#dc2626",
"#fb923c",
"#f97316",
]
colors_pass = [
"#2dd4bf",
"#14b8a6",
"#0d9488",
"#60a5fa",
"#3b82f6",
"#a78bfa",
"#93c5fd",
]
color_index_fail = 0
color_index_pass = 0
for metric in metrics:
if metric["ooc_percent"] > 0.1:
if not metric["pass_fail"]:
fill_color = colors_fail[color_index_fail % len(colors_fail)]
color_index_fail += 1
else:
fill_color = colors_pass[color_index_pass % len(colors_pass)]
color_index_pass += 1
pie_data.append(
{
"name": metric["parameter"],
"value": metric[ | elif i % ooc_freq_up == 0:
base_value += random.uniform(ooc_amount_up * 0.5, ooc_amount_up * 1.5)
elif i % ooc_freq_down == 0:
base_value -= random.uniform(ooc_amount_down * 0.5, ooc_amount_down * 1.5) |
data(),
"ooc_percent": round(ooc, 1),
"pass_fail": ooc <= 7.0,
}
)
return metrics
def _generate_spc_data(
num_points: int = 30,
base_min: float = 0.415,
base_max: float = 0.428,
ooc_freq_up: int = 5,
ooc_amount_up: float = 0.005,
ooc_freq_down: int = 7,
ooc_amount_down: float = 0.008,
) -> List[SpcDataPoint]:
data = []
for i in range(num_points):
base_value = fake.pyfloat(
left_digits=0,
right_digits=4,
positive=True,
min_value=base_min,
max_value=base_max,
)
if random.random() < 0.1:
base_value += random.uniform(ooc_amount_up * 1.5, ooc_amount_up * 2.5)
elif random.random() < 0.1:
base_value -= random.uniform(ooc_amount_down * 1.5, ooc_amount_down * 2.5)
elif i % ooc_freq_up == 0:
base_value += random.uniform(ooc_amount_up * 0.5, ooc_amount_up * 1.5)
|
data.append({"name": i, "value": round(base_value, 4)})
return data
def _generate_pie_data(
metrics: List[MetricData],
) -> List[PieChartData]:
pie_data = []
colors_fail = [
"#f87171",
"#ef4444",
"#dc2626",
"#fb923c",
"#f97316",
]
colors_pass = [
"#2dd4bf",
"#14b8a6",
"#0d9488",
"#60a5fa",
"#3b82f6",
"#a78bfa",
"#93c5fd",
]
color_index_fail = 0
color_index_pass = 0
for metric in metrics:
if metric["ooc_percent"] > 0.1:
if not metric["pass_fail"]:
fill_color = colors_fail[color_index_fail % len(colors_fail)]
color_index_fail += 1
else:
fill_color = colors_pass[color_index_pass % len(colors_pass)]
color_index_pass += 1
pie_data.append(
{
"name": metric["parameter"],
"value": metric[ | elif i % ooc_freq_down == 0:
base_value -= random.uniform(ooc_amount_down * 0.5, ooc_amount_down * 1.5) |
amount_up: float = 0.005,
ooc_freq_down: int = 7,
ooc_amount_down: float = 0.008,
) -> List[SpcDataPoint]:
data = []
for i in range(num_points):
base_value = fake.pyfloat(
left_digits=0,
right_digits=4,
positive=True,
min_value=base_min,
max_value=base_max,
)
if random.random() < 0.1:
base_value += random.uniform(ooc_amount_up * 1.5, ooc_amount_up * 2.5)
elif random.random() < 0.1:
base_value -= random.uniform(ooc_amount_down * 1.5, ooc_amount_down * 2.5)
elif i % ooc_freq_up == 0:
base_value += random.uniform(ooc_amount_up * 0.5, ooc_amount_up * 1.5)
elif i % ooc_freq_down == 0:
base_value -= random.uniform(ooc_amount_down * 0.5, ooc_amount_down * 1.5)
data.append({"name": i, "value": round(base_value, 4)})
return data
def _generate_pie_data(
metrics: List[MetricData],
) -> List[PieChartData]:
|
colors_fail = [
"#f87171",
"#ef4444",
"#dc2626",
"#fb923c",
"#f97316",
]
colors_pass = [
"#2dd4bf",
"#14b8a6",
"#0d9488",
"#60a5fa",
"#3b82f6",
"#a78bfa",
"#93c5fd",
]
color_index_fail = 0
color_index_pass = 0
for metric in metrics:
if metric["ooc_percent"] > 0.1:
if not metric["pass_fail"]:
fill_color = colors_fail[color_index_fail % len(colors_fail)]
color_index_fail += 1
else:
fill_color = colors_pass[color_index_pass % len(colors_pass)]
color_index_pass += 1
pie_data.append(
{
"name": metric["parameter"],
"value": metric["ooc_percent"],
"fill": fill_color,
}
)
if not pie_data:
default_low_ooc = [
("Diameter", 0.5),
| pie_data = [] |
0.005,
ooc_freq_down: int = 7,
ooc_amount_down: float = 0.008,
) -> List[SpcDataPoint]:
data = []
for i in range(num_points):
base_value = fake.pyfloat(
left_digits=0,
right_digits=4,
positive=True,
min_value=base_min,
max_value=base_max,
)
if random.random() < 0.1:
base_value += random.uniform(ooc_amount_up * 1.5, ooc_amount_up * 2.5)
elif random.random() < 0.1:
base_value -= random.uniform(ooc_amount_down * 1.5, ooc_amount_down * 2.5)
elif i % ooc_freq_up == 0:
base_value += random.uniform(ooc_amount_up * 0.5, ooc_amount_up * 1.5)
elif i % ooc_freq_down == 0:
base_value -= random.uniform(ooc_amount_down * 0.5, ooc_amount_down * 1.5)
data.append({"name": i, "value": round(base_value, 4)})
return data
def _generate_pie_data(
metrics: List[MetricData],
) -> List[PieChartData]:
pie_data = []
|
colors_pass = [
"#2dd4bf",
"#14b8a6",
"#0d9488",
"#60a5fa",
"#3b82f6",
"#a78bfa",
"#93c5fd",
]
color_index_fail = 0
color_index_pass = 0
for metric in metrics:
if metric["ooc_percent"] > 0.1:
if not metric["pass_fail"]:
fill_color = colors_fail[color_index_fail % len(colors_fail)]
color_index_fail += 1
else:
fill_color = colors_pass[color_index_pass % len(colors_pass)]
color_index_pass += 1
pie_data.append(
{
"name": metric["parameter"],
"value": metric["ooc_percent"],
"fill": fill_color,
}
)
if not pie_data:
default_low_ooc = [
("Diameter", 0.5),
("Etch1", 0.3),
]
for name, value in default_low_ooc:
pie_data.append(
{
| colors_fail = [
"#f87171",
"#ef4444",
"#dc2626",
"#fb923c",
"#f97316",
] |
in range(num_points):
base_value = fake.pyfloat(
left_digits=0,
right_digits=4,
positive=True,
min_value=base_min,
max_value=base_max,
)
if random.random() < 0.1:
base_value += random.uniform(ooc_amount_up * 1.5, ooc_amount_up * 2.5)
elif random.random() < 0.1:
base_value -= random.uniform(ooc_amount_down * 1.5, ooc_amount_down * 2.5)
elif i % ooc_freq_up == 0:
base_value += random.uniform(ooc_amount_up * 0.5, ooc_amount_up * 1.5)
elif i % ooc_freq_down == 0:
base_value -= random.uniform(ooc_amount_down * 0.5, ooc_amount_down * 1.5)
data.append({"name": i, "value": round(base_value, 4)})
return data
def _generate_pie_data(
metrics: List[MetricData],
) -> List[PieChartData]:
pie_data = []
colors_fail = [
"#f87171",
"#ef4444",
"#dc2626",
"#fb923c",
"#f97316",
]
|
color_index_fail = 0
color_index_pass = 0
for metric in metrics:
if metric["ooc_percent"] > 0.1:
if not metric["pass_fail"]:
fill_color = colors_fail[color_index_fail % len(colors_fail)]
color_index_fail += 1
else:
fill_color = colors_pass[color_index_pass % len(colors_pass)]
color_index_pass += 1
pie_data.append(
{
"name": metric["parameter"],
"value": metric["ooc_percent"],
"fill": fill_color,
}
)
if not pie_data:
default_low_ooc = [
("Diameter", 0.5),
("Etch1", 0.3),
]
for name, value in default_low_ooc:
pie_data.append(
{
"name": name,
"value": value,
"fill": colors_pass[color_index_pass % len(colors_pass)],
| colors_pass = [
"#2dd4bf",
"#14b8a6",
"#0d9488",
"#60a5fa",
"#3b82f6",
"#a78bfa",
"#93c5fd",
] |
e=base_min,
max_value=base_max,
)
if random.random() < 0.1:
base_value += random.uniform(ooc_amount_up * 1.5, ooc_amount_up * 2.5)
elif random.random() < 0.1:
base_value -= random.uniform(ooc_amount_down * 1.5, ooc_amount_down * 2.5)
elif i % ooc_freq_up == 0:
base_value += random.uniform(ooc_amount_up * 0.5, ooc_amount_up * 1.5)
elif i % ooc_freq_down == 0:
base_value -= random.uniform(ooc_amount_down * 0.5, ooc_amount_down * 1.5)
data.append({"name": i, "value": round(base_value, 4)})
return data
def _generate_pie_data(
metrics: List[MetricData],
) -> List[PieChartData]:
pie_data = []
colors_fail = [
"#f87171",
"#ef4444",
"#dc2626",
"#fb923c",
"#f97316",
]
colors_pass = [
"#2dd4bf",
"#14b8a6",
"#0d9488",
"#60a5fa",
"#3b82f6",
"#a78bfa",
"#93c5fd",
]
|
color_index_pass = 0
for metric in metrics:
if metric["ooc_percent"] > 0.1:
if not metric["pass_fail"]:
fill_color = colors_fail[color_index_fail % len(colors_fail)]
color_index_fail += 1
else:
fill_color = colors_pass[color_index_pass % len(colors_pass)]
color_index_pass += 1
pie_data.append(
{
"name": metric["parameter"],
"value": metric["ooc_percent"],
"fill": fill_color,
}
)
if not pie_data:
default_low_ooc = [
("Diameter", 0.5),
("Etch1", 0.3),
]
for name, value in default_low_ooc:
pie_data.append(
{
"name": name,
"value": value,
"fill": colors_pass[color_index_pass % len(colors_pass)],
}
)
| color_index_fail = 0 |
ax_value=base_max,
)
if random.random() < 0.1:
base_value += random.uniform(ooc_amount_up * 1.5, ooc_amount_up * 2.5)
elif random.random() < 0.1:
base_value -= random.uniform(ooc_amount_down * 1.5, ooc_amount_down * 2.5)
elif i % ooc_freq_up == 0:
base_value += random.uniform(ooc_amount_up * 0.5, ooc_amount_up * 1.5)
elif i % ooc_freq_down == 0:
base_value -= random.uniform(ooc_amount_down * 0.5, ooc_amount_down * 1.5)
data.append({"name": i, "value": round(base_value, 4)})
return data
def _generate_pie_data(
metrics: List[MetricData],
) -> List[PieChartData]:
pie_data = []
colors_fail = [
"#f87171",
"#ef4444",
"#dc2626",
"#fb923c",
"#f97316",
]
colors_pass = [
"#2dd4bf",
"#14b8a6",
"#0d9488",
"#60a5fa",
"#3b82f6",
"#a78bfa",
"#93c5fd",
]
color_index_fail = 0
|
for metric in metrics:
if metric["ooc_percent"] > 0.1:
if not metric["pass_fail"]:
fill_color = colors_fail[color_index_fail % len(colors_fail)]
color_index_fail += 1
else:
fill_color = colors_pass[color_index_pass % len(colors_pass)]
color_index_pass += 1
pie_data.append(
{
"name": metric["parameter"],
"value": metric["ooc_percent"],
"fill": fill_color,
}
)
if not pie_data:
default_low_ooc = [
("Diameter", 0.5),
("Etch1", 0.3),
]
for name, value in default_low_ooc:
pie_data.append(
{
"name": name,
"value": value,
"fill": colors_pass[color_index_pass % len(colors_pass)],
}
)
color_index_pass += 1 | color_index_pass = 0 |
)
if random.random() < 0.1:
base_value += random.uniform(ooc_amount_up * 1.5, ooc_amount_up * 2.5)
elif random.random() < 0.1:
base_value -= random.uniform(ooc_amount_down * 1.5, ooc_amount_down * 2.5)
elif i % ooc_freq_up == 0:
base_value += random.uniform(ooc_amount_up * 0.5, ooc_amount_up * 1.5)
elif i % ooc_freq_down == 0:
base_value -= random.uniform(ooc_amount_down * 0.5, ooc_amount_down * 1.5)
data.append({"name": i, "value": round(base_value, 4)})
return data
def _generate_pie_data(
metrics: List[MetricData],
) -> List[PieChartData]:
pie_data = []
colors_fail = [
"#f87171",
"#ef4444",
"#dc2626",
"#fb923c",
"#f97316",
]
colors_pass = [
"#2dd4bf",
"#14b8a6",
"#0d9488",
"#60a5fa",
"#3b82f6",
"#a78bfa",
"#93c5fd",
]
color_index_fail = 0
color_index_pass = 0
|
if not pie_data:
default_low_ooc = [
("Diameter", 0.5),
("Etch1", 0.3),
]
for name, value in default_low_ooc:
pie_data.append(
{
"name": name,
"value": value,
"fill": colors_pass[color_index_pass % len(colors_pass)],
}
)
color_index_pass += 1
return pie_data
def _generate_distribution_data(
spc_data: List[SpcDataPoint], num_bins=8
) -> List[DistributionPoint]:
"""Generates histogram-like data from SPC points."""
if not spc_data:
return []
values = [p["value"] for p in spc_data]
min_val, max_val = (min(values), max(values))
if min_val == max_val:
return [{"name": f"{min_val:.3f}", "value": len(values)}]
bin_width = (max_val - min_val) / num_bins
bins = [0] * num_bins
for val in values:
bin_index = min(int((val - min_val) / bin_width), num_bins | for metric in metrics:
if metric["ooc_percent"] > 0.1:
if not metric["pass_fail"]:
fill_color = colors_fail[color_index_fail % len(colors_fail)]
color_index_fail += 1
else:
fill_color = colors_pass[color_index_pass % len(colors_pass)]
color_index_pass += 1
pie_data.append(
{
"name": metric["parameter"],
"value": metric["ooc_percent"],
"fill": fill_color,
}
) |
< 0.1:
base_value += random.uniform(ooc_amount_up * 1.5, ooc_amount_up * 2.5)
elif random.random() < 0.1:
base_value -= random.uniform(ooc_amount_down * 1.5, ooc_amount_down * 2.5)
elif i % ooc_freq_up == 0:
base_value += random.uniform(ooc_amount_up * 0.5, ooc_amount_up * 1.5)
elif i % ooc_freq_down == 0:
base_value -= random.uniform(ooc_amount_down * 0.5, ooc_amount_down * 1.5)
data.append({"name": i, "value": round(base_value, 4)})
return data
def _generate_pie_data(
metrics: List[MetricData],
) -> List[PieChartData]:
pie_data = []
colors_fail = [
"#f87171",
"#ef4444",
"#dc2626",
"#fb923c",
"#f97316",
]
colors_pass = [
"#2dd4bf",
"#14b8a6",
"#0d9488",
"#60a5fa",
"#3b82f6",
"#a78bfa",
"#93c5fd",
]
color_index_fail = 0
color_index_pass = 0
for metric in metrics:
|
if not pie_data:
default_low_ooc = [
("Diameter", 0.5),
("Etch1", 0.3),
]
for name, value in default_low_ooc:
pie_data.append(
{
"name": name,
"value": value,
"fill": colors_pass[color_index_pass % len(colors_pass)],
}
)
color_index_pass += 1
return pie_data
def _generate_distribution_data(
spc_data: List[SpcDataPoint], num_bins=8
) -> List[DistributionPoint]:
"""Generates histogram-like data from SPC points."""
if not spc_data:
return []
values = [p["value"] for p in spc_data]
min_val, max_val = (min(values), max(values))
if min_val == max_val:
return [{"name": f"{min_val:.3f}", "value": len(values)}]
bin_width = (max_val - min_val) / num_bins
bins = [0] * num_bins
for val in values:
bin_index = min(int((val - min_val) / bin_width), num_bins | if metric["ooc_percent"] > 0.1:
if not metric["pass_fail"]:
fill_color = colors_fail[color_index_fail % len(colors_fail)]
color_index_fail += 1
else:
fill_color = colors_pass[color_index_pass % len(colors_pass)]
color_index_pass += 1
pie_data.append(
{
"name": metric["parameter"],
"value": metric["ooc_percent"],
"fill": fill_color,
}
) |
orm(ooc_amount_up * 1.5, ooc_amount_up * 2.5)
elif random.random() < 0.1:
base_value -= random.uniform(ooc_amount_down * 1.5, ooc_amount_down * 2.5)
elif i % ooc_freq_up == 0:
base_value += random.uniform(ooc_amount_up * 0.5, ooc_amount_up * 1.5)
elif i % ooc_freq_down == 0:
base_value -= random.uniform(ooc_amount_down * 0.5, ooc_amount_down * 1.5)
data.append({"name": i, "value": round(base_value, 4)})
return data
def _generate_pie_data(
metrics: List[MetricData],
) -> List[PieChartData]:
pie_data = []
colors_fail = [
"#f87171",
"#ef4444",
"#dc2626",
"#fb923c",
"#f97316",
]
colors_pass = [
"#2dd4bf",
"#14b8a6",
"#0d9488",
"#60a5fa",
"#3b82f6",
"#a78bfa",
"#93c5fd",
]
color_index_fail = 0
color_index_pass = 0
for metric in metrics:
if metric["ooc_percent"] > 0.1:
|
pie_data.append(
{
"name": metric["parameter"],
"value": metric["ooc_percent"],
"fill": fill_color,
}
)
if not pie_data:
default_low_ooc = [
("Diameter", 0.5),
("Etch1", 0.3),
]
for name, value in default_low_ooc:
pie_data.append(
{
"name": name,
"value": value,
"fill": colors_pass[color_index_pass % len(colors_pass)],
}
)
color_index_pass += 1
return pie_data
def _generate_distribution_data(
spc_data: List[SpcDataPoint], num_bins=8
) -> List[DistributionPoint]:
"""Generates histogram-like data from SPC points."""
if not spc_data:
return []
values = [p["value"] for p in spc_data]
min_val, max_val = (min(values), max(values))
if min_val == max_val:
r | if not metric["pass_fail"]:
fill_color = colors_fail[color_index_fail % len(colors_fail)]
color_index_fail += 1
else:
fill_color = colors_pass[color_index_pass % len(colors_pass)]
color_index_pass += 1 |
)
elif random.random() < 0.1:
base_value -= random.uniform(ooc_amount_down * 1.5, ooc_amount_down * 2.5)
elif i % ooc_freq_up == 0:
base_value += random.uniform(ooc_amount_up * 0.5, ooc_amount_up * 1.5)
elif i % ooc_freq_down == 0:
base_value -= random.uniform(ooc_amount_down * 0.5, ooc_amount_down * 1.5)
data.append({"name": i, "value": round(base_value, 4)})
return data
def _generate_pie_data(
metrics: List[MetricData],
) -> List[PieChartData]:
pie_data = []
colors_fail = [
"#f87171",
"#ef4444",
"#dc2626",
"#fb923c",
"#f97316",
]
colors_pass = [
"#2dd4bf",
"#14b8a6",
"#0d9488",
"#60a5fa",
"#3b82f6",
"#a78bfa",
"#93c5fd",
]
color_index_fail = 0
color_index_pass = 0
for metric in metrics:
if metric["ooc_percent"] > 0.1:
if not metric["pass_fail"]:
|
color_index_fail += 1
else:
fill_color = colors_pass[color_index_pass % len(colors_pass)]
color_index_pass += 1
pie_data.append(
{
"name": metric["parameter"],
"value": metric["ooc_percent"],
"fill": fill_color,
}
)
if not pie_data:
default_low_ooc = [
("Diameter", 0.5),
("Etch1", 0.3),
]
for name, value in default_low_ooc:
pie_data.append(
{
"name": name,
"value": value,
"fill": colors_pass[color_index_pass % len(colors_pass)],
}
)
color_index_pass += 1
return pie_data
def _generate_distribution_data(
spc_data: List[SpcDataPoint], num_bins=8
) -> List[DistributionPoint]:
"""Generates histogram-like data from SPC points." | fill_color = colors_fail[color_index_fail % len(colors_fail)] |
lif i % ooc_freq_up == 0:
base_value += random.uniform(ooc_amount_up * 0.5, ooc_amount_up * 1.5)
elif i % ooc_freq_down == 0:
base_value -= random.uniform(ooc_amount_down * 0.5, ooc_amount_down * 1.5)
data.append({"name": i, "value": round(base_value, 4)})
return data
def _generate_pie_data(
metrics: List[MetricData],
) -> List[PieChartData]:
pie_data = []
colors_fail = [
"#f87171",
"#ef4444",
"#dc2626",
"#fb923c",
"#f97316",
]
colors_pass = [
"#2dd4bf",
"#14b8a6",
"#0d9488",
"#60a5fa",
"#3b82f6",
"#a78bfa",
"#93c5fd",
]
color_index_fail = 0
color_index_pass = 0
for metric in metrics:
if metric["ooc_percent"] > 0.1:
if not metric["pass_fail"]:
fill_color = colors_fail[color_index_fail % len(colors_fail)]
color_index_fail += 1
else:
|
color_index_pass += 1
pie_data.append(
{
"name": metric["parameter"],
"value": metric["ooc_percent"],
"fill": fill_color,
}
)
if not pie_data:
default_low_ooc = [
("Diameter", 0.5),
("Etch1", 0.3),
]
for name, value in default_low_ooc:
pie_data.append(
{
"name": name,
"value": value,
"fill": colors_pass[color_index_pass % len(colors_pass)],
}
)
color_index_pass += 1
return pie_data
def _generate_distribution_data(
spc_data: List[SpcDataPoint], num_bins=8
) -> List[DistributionPoint]:
"""Generates histogram-like data from SPC points."""
if not spc_data:
return []
values = [p["value"] for p in spc_data]
min_val, max_val = (min(values), max(values) | fill_color = colors_pass[color_index_pass % len(colors_pass)] |
rate_pie_data(
metrics: List[MetricData],
) -> List[PieChartData]:
pie_data = []
colors_fail = [
"#f87171",
"#ef4444",
"#dc2626",
"#fb923c",
"#f97316",
]
colors_pass = [
"#2dd4bf",
"#14b8a6",
"#0d9488",
"#60a5fa",
"#3b82f6",
"#a78bfa",
"#93c5fd",
]
color_index_fail = 0
color_index_pass = 0
for metric in metrics:
if metric["ooc_percent"] > 0.1:
if not metric["pass_fail"]:
fill_color = colors_fail[color_index_fail % len(colors_fail)]
color_index_fail += 1
else:
fill_color = colors_pass[color_index_pass % len(colors_pass)]
color_index_pass += 1
pie_data.append(
{
"name": metric["parameter"],
"value": metric["ooc_percent"],
"fill": fill_color,
}
)
|
return pie_data
def _generate_distribution_data(
spc_data: List[SpcDataPoint], num_bins=8
) -> List[DistributionPoint]:
"""Generates histogram-like data from SPC points."""
if not spc_data:
return []
values = [p["value"] for p in spc_data]
min_val, max_val = (min(values), max(values))
if min_val == max_val:
return [{"name": f"{min_val:.3f}", "value": len(values)}]
bin_width = (max_val - min_val) / num_bins
bins = [0] * num_bins
for val in values:
bin_index = min(int((val - min_val) / bin_width), num_bins - 1)
if val == max_val:
bin_index = num_bins - 1
bins[bin_index] += 1
dist_data = []
for i in range(num_bins):
bin_start = min_val + i * bin_width
bin_name = f"{bin_start:.3f}"
dist_data.append({"name": bin_name, "value": bins[i]})
return dist_data
initial_process_metrics = _generate_process_metrics()
initial_spc_data = _generate_spc_data(base_min=0.415, | if not pie_data:
default_low_ooc = [
("Diameter", 0.5),
("Etch1", 0.3),
]
for name, value in default_low_ooc:
pie_data.append(
{
"name": name,
"value": value,
"fill": colors_pass[color_index_pass % len(colors_pass)],
}
)
color_index_pass += 1 |
s: List[MetricData],
) -> List[PieChartData]:
pie_data = []
colors_fail = [
"#f87171",
"#ef4444",
"#dc2626",
"#fb923c",
"#f97316",
]
colors_pass = [
"#2dd4bf",
"#14b8a6",
"#0d9488",
"#60a5fa",
"#3b82f6",
"#a78bfa",
"#93c5fd",
]
color_index_fail = 0
color_index_pass = 0
for metric in metrics:
if metric["ooc_percent"] > 0.1:
if not metric["pass_fail"]:
fill_color = colors_fail[color_index_fail % len(colors_fail)]
color_index_fail += 1
else:
fill_color = colors_pass[color_index_pass % len(colors_pass)]
color_index_pass += 1
pie_data.append(
{
"name": metric["parameter"],
"value": metric["ooc_percent"],
"fill": fill_color,
}
)
if not pie_data:
|
for name, value in default_low_ooc:
pie_data.append(
{
"name": name,
"value": value,
"fill": colors_pass[color_index_pass % len(colors_pass)],
}
)
color_index_pass += 1
return pie_data
def _generate_distribution_data(
spc_data: List[SpcDataPoint], num_bins=8
) -> List[DistributionPoint]:
"""Generates histogram-like data from SPC points."""
if not spc_data:
return []
values = [p["value"] for p in spc_data]
min_val, max_val = (min(values), max(values))
if min_val == max_val:
return [{"name": f"{min_val:.3f}", "value": len(values)}]
bin_width = (max_val - min_val) / num_bins
bins = [0] * num_bins
for val in values:
bin_index = min(int((val - min_val) / bin_width), num_bins - 1)
if val == max_val:
bin_index = num_bins - 1
bins[bin_index] += 1
dist_data = []
| default_low_ooc = [
("Diameter", 0.5),
("Etch1", 0.3),
] |
171",
"#ef4444",
"#dc2626",
"#fb923c",
"#f97316",
]
colors_pass = [
"#2dd4bf",
"#14b8a6",
"#0d9488",
"#60a5fa",
"#3b82f6",
"#a78bfa",
"#93c5fd",
]
color_index_fail = 0
color_index_pass = 0
for metric in metrics:
if metric["ooc_percent"] > 0.1:
if not metric["pass_fail"]:
fill_color = colors_fail[color_index_fail % len(colors_fail)]
color_index_fail += 1
else:
fill_color = colors_pass[color_index_pass % len(colors_pass)]
color_index_pass += 1
pie_data.append(
{
"name": metric["parameter"],
"value": metric["ooc_percent"],
"fill": fill_color,
}
)
if not pie_data:
default_low_ooc = [
("Diameter", 0.5),
("Etch1", 0.3),
]
|
return pie_data
def _generate_distribution_data(
spc_data: List[SpcDataPoint], num_bins=8
) -> List[DistributionPoint]:
"""Generates histogram-like data from SPC points."""
if not spc_data:
return []
values = [p["value"] for p in spc_data]
min_val, max_val = (min(values), max(values))
if min_val == max_val:
return [{"name": f"{min_val:.3f}", "value": len(values)}]
bin_width = (max_val - min_val) / num_bins
bins = [0] * num_bins
for val in values:
bin_index = min(int((val - min_val) / bin_width), num_bins - 1)
if val == max_val:
bin_index = num_bins - 1
bins[bin_index] += 1
dist_data = []
for i in range(num_bins):
bin_start = min_val + i * bin_width
bin_name = f"{bin_start:.3f}"
dist_data.append({"name": bin_name, "value": bins[i]})
return dist_data
initial_process_metrics = _generate_process_metrics()
initial_spc_data = _generate_spc_data(base_min=0.415, | for name, value in default_low_ooc:
pie_data.append(
{
"name": name,
"value": value,
"fill": colors_pass[color_index_pass % len(colors_pass)],
}
)
color_index_pass += 1 |
ics:
if metric["ooc_percent"] > 0.1:
if not metric["pass_fail"]:
fill_color = colors_fail[color_index_fail % len(colors_fail)]
color_index_fail += 1
else:
fill_color = colors_pass[color_index_pass % len(colors_pass)]
color_index_pass += 1
pie_data.append(
{
"name": metric["parameter"],
"value": metric["ooc_percent"],
"fill": fill_color,
}
)
if not pie_data:
default_low_ooc = [
("Diameter", 0.5),
("Etch1", 0.3),
]
for name, value in default_low_ooc:
pie_data.append(
{
"name": name,
"value": value,
"fill": colors_pass[color_index_pass % len(colors_pass)],
}
)
color_index_pass += 1
return pie_data
|
initial_process_metrics = _generate_process_metrics()
initial_spc_data = _generate_spc_data(base_min=0.415, base_max=0.424)
initial_pie_data = _generate_pie_data(initial_process_metrics)
initial_distribution_data = _generate_distribution_data(initial_spc_data)
class DashboardState(rx.State):
"""Handles the state and logic for the dashboard application."""
operator_id: str = fake.bothify(text="OP-####")
time_to_completion: float = 0.0
is_running: bool = False
ucl: float = 0.432
lcl: float = 0.407
target_mean: float = 0.42
usl: float = 0.424
lsl: float = 0.415
process_metrics: List[MetricData] = initial_process_metrics
spc_chart_data: List[SpcDataPoint] = initial_spc_data
pie_data: List[PieChartData] = initial_pie_data
distribution_data: List[DistributionPoint] = initial_distribution_data
def _reset_to_initial(self):
"""Resets data to a new initial state."""
self.process_metrics = _generate_process_metrics()
| def _generate_distribution_data(
spc_data: List[SpcDataPoint], num_bins=8
) -> List[DistributionPoint]:
"""Generates histogram-like data from SPC points."""
if not spc_data:
return []
values = [p["value"] for p in spc_data]
min_val, max_val = (min(values), max(values))
if min_val == max_val:
return [{"name": f"{min_val:.3f}", "value": len(values)}]
bin_width = (max_val - min_val) / num_bins
bins = [0] * num_bins
for val in values:
bin_index = min(int((val - min_val) / bin_width), num_bins - 1)
if val == max_val:
bin_index = num_bins - 1
bins[bin_index] += 1
dist_data = []
for i in range(num_bins):
bin_start = min_val + i * bin_width
bin_name = f"{bin_start:.3f}"
dist_data.append({"name": bin_name, "value": bins[i]})
return dist_data |
color_index_fail += 1
else:
fill_color = colors_pass[color_index_pass % len(colors_pass)]
color_index_pass += 1
pie_data.append(
{
"name": metric["parameter"],
"value": metric["ooc_percent"],
"fill": fill_color,
}
)
if not pie_data:
default_low_ooc = [
("Diameter", 0.5),
("Etch1", 0.3),
]
for name, value in default_low_ooc:
pie_data.append(
{
"name": name,
"value": value,
"fill": colors_pass[color_index_pass % len(colors_pass)],
}
)
color_index_pass += 1
return pie_data
def _generate_distribution_data(
spc_data: List[SpcDataPoint], num_bins=8
) -> List[DistributionPoint]:
"""Generates histogram-like data from SPC points."""
|
values = [p["value"] for p in spc_data]
min_val, max_val = (min(values), max(values))
if min_val == max_val:
return [{"name": f"{min_val:.3f}", "value": len(values)}]
bin_width = (max_val - min_val) / num_bins
bins = [0] * num_bins
for val in values:
bin_index = min(int((val - min_val) / bin_width), num_bins - 1)
if val == max_val:
bin_index = num_bins - 1
bins[bin_index] += 1
dist_data = []
for i in range(num_bins):
bin_start = min_val + i * bin_width
bin_name = f"{bin_start:.3f}"
dist_data.append({"name": bin_name, "value": bins[i]})
return dist_data
initial_process_metrics = _generate_process_metrics()
initial_spc_data = _generate_spc_data(base_min=0.415, base_max=0.424)
initial_pie_data = _generate_pie_data(initial_process_metrics)
initial_distribution_data = _generate_distribution_data(initial_spc_data)
class DashboardState(rx.State):
"""Handles the state and logic for | if not spc_data:
return [] |
else:
fill_color = colors_pass[color_index_pass % len(colors_pass)]
color_index_pass += 1
pie_data.append(
{
"name": metric["parameter"],
"value": metric["ooc_percent"],
"fill": fill_color,
}
)
if not pie_data:
default_low_ooc = [
("Diameter", 0.5),
("Etch1", 0.3),
]
for name, value in default_low_ooc:
pie_data.append(
{
"name": name,
"value": value,
"fill": colors_pass[color_index_pass % len(colors_pass)],
}
)
color_index_pass += 1
return pie_data
def _generate_distribution_data(
spc_data: List[SpcDataPoint], num_bins=8
) -> List[DistributionPoint]:
"""Generates histogram-like data from SPC points."""
if not spc_data:
return []
|
min_val, max_val = (min(values), max(values))
if min_val == max_val:
return [{"name": f"{min_val:.3f}", "value": len(values)}]
bin_width = (max_val - min_val) / num_bins
bins = [0] * num_bins
for val in values:
bin_index = min(int((val - min_val) / bin_width), num_bins - 1)
if val == max_val:
bin_index = num_bins - 1
bins[bin_index] += 1
dist_data = []
for i in range(num_bins):
bin_start = min_val + i * bin_width
bin_name = f"{bin_start:.3f}"
dist_data.append({"name": bin_name, "value": bins[i]})
return dist_data
initial_process_metrics = _generate_process_metrics()
initial_spc_data = _generate_spc_data(base_min=0.415, base_max=0.424)
initial_pie_data = _generate_pie_data(initial_process_metrics)
initial_distribution_data = _generate_distribution_data(initial_spc_data)
class DashboardState(rx.State):
"""Handles the state and logic for the dashboard application."""
operator_ | values = [p["value"] for p in spc_data] |
rs_pass[color_index_pass % len(colors_pass)]
color_index_pass += 1
pie_data.append(
{
"name": metric["parameter"],
"value": metric["ooc_percent"],
"fill": fill_color,
}
)
if not pie_data:
default_low_ooc = [
("Diameter", 0.5),
("Etch1", 0.3),
]
for name, value in default_low_ooc:
pie_data.append(
{
"name": name,
"value": value,
"fill": colors_pass[color_index_pass % len(colors_pass)],
}
)
color_index_pass += 1
return pie_data
def _generate_distribution_data(
spc_data: List[SpcDataPoint], num_bins=8
) -> List[DistributionPoint]:
"""Generates histogram-like data from SPC points."""
if not spc_data:
return []
values = [p["value"] for p in spc_data]
|
if min_val == max_val:
return [{"name": f"{min_val:.3f}", "value": len(values)}]
bin_width = (max_val - min_val) / num_bins
bins = [0] * num_bins
for val in values:
bin_index = min(int((val - min_val) / bin_width), num_bins - 1)
if val == max_val:
bin_index = num_bins - 1
bins[bin_index] += 1
dist_data = []
for i in range(num_bins):
bin_start = min_val + i * bin_width
bin_name = f"{bin_start:.3f}"
dist_data.append({"name": bin_name, "value": bins[i]})
return dist_data
initial_process_metrics = _generate_process_metrics()
initial_spc_data = _generate_spc_data(base_min=0.415, base_max=0.424)
initial_pie_data = _generate_pie_data(initial_process_metrics)
initial_distribution_data = _generate_distribution_data(initial_spc_data)
class DashboardState(rx.State):
"""Handles the state and logic for the dashboard application."""
operator_id: str = fake.bothify(text="OP-####")
time_to | min_val, max_val = (min(values), max(values)) |
color_index_pass += 1
pie_data.append(
{
"name": metric["parameter"],
"value": metric["ooc_percent"],
"fill": fill_color,
}
)
if not pie_data:
default_low_ooc = [
("Diameter", 0.5),
("Etch1", 0.3),
]
for name, value in default_low_ooc:
pie_data.append(
{
"name": name,
"value": value,
"fill": colors_pass[color_index_pass % len(colors_pass)],
}
)
color_index_pass += 1
return pie_data
def _generate_distribution_data(
spc_data: List[SpcDataPoint], num_bins=8
) -> List[DistributionPoint]:
"""Generates histogram-like data from SPC points."""
if not spc_data:
return []
values = [p["value"] for p in spc_data]
min_val, max_val = (min(values), max(values))
|
bin_width = (max_val - min_val) / num_bins
bins = [0] * num_bins
for val in values:
bin_index = min(int((val - min_val) / bin_width), num_bins - 1)
if val == max_val:
bin_index = num_bins - 1
bins[bin_index] += 1
dist_data = []
for i in range(num_bins):
bin_start = min_val + i * bin_width
bin_name = f"{bin_start:.3f}"
dist_data.append({"name": bin_name, "value": bins[i]})
return dist_data
initial_process_metrics = _generate_process_metrics()
initial_spc_data = _generate_spc_data(base_min=0.415, base_max=0.424)
initial_pie_data = _generate_pie_data(initial_process_metrics)
initial_distribution_data = _generate_distribution_data(initial_spc_data)
class DashboardState(rx.State):
"""Handles the state and logic for the dashboard application."""
operator_id: str = fake.bothify(text="OP-####")
time_to_completion: float = 0.0
is_running: bool = False
ucl: float = 0.432
lcl: float = | if min_val == max_val:
return [{"name": f"{min_val:.3f}", "value": len(values)}] |
"name": metric["parameter"],
"value": metric["ooc_percent"],
"fill": fill_color,
}
)
if not pie_data:
default_low_ooc = [
("Diameter", 0.5),
("Etch1", 0.3),
]
for name, value in default_low_ooc:
pie_data.append(
{
"name": name,
"value": value,
"fill": colors_pass[color_index_pass % len(colors_pass)],
}
)
color_index_pass += 1
return pie_data
def _generate_distribution_data(
spc_data: List[SpcDataPoint], num_bins=8
) -> List[DistributionPoint]:
"""Generates histogram-like data from SPC points."""
if not spc_data:
return []
values = [p["value"] for p in spc_data]
min_val, max_val = (min(values), max(values))
if min_val == max_val:
return [{"name": f"{min_val:.3f}", "value": len(values)}]
|
bins = [0] * num_bins
for val in values:
bin_index = min(int((val - min_val) / bin_width), num_bins - 1)
if val == max_val:
bin_index = num_bins - 1
bins[bin_index] += 1
dist_data = []
for i in range(num_bins):
bin_start = min_val + i * bin_width
bin_name = f"{bin_start:.3f}"
dist_data.append({"name": bin_name, "value": bins[i]})
return dist_data
initial_process_metrics = _generate_process_metrics()
initial_spc_data = _generate_spc_data(base_min=0.415, base_max=0.424)
initial_pie_data = _generate_pie_data(initial_process_metrics)
initial_distribution_data = _generate_distribution_data(initial_spc_data)
class DashboardState(rx.State):
"""Handles the state and logic for the dashboard application."""
operator_id: str = fake.bothify(text="OP-####")
time_to_completion: float = 0.0
is_running: bool = False
ucl: float = 0.432
lcl: float = 0.407
target_mean: float = 0.42
usl: f | bin_width = (max_val - min_val) / num_bins |
ooc_percent"],
"fill": fill_color,
}
)
if not pie_data:
default_low_ooc = [
("Diameter", 0.5),
("Etch1", 0.3),
]
for name, value in default_low_ooc:
pie_data.append(
{
"name": name,
"value": value,
"fill": colors_pass[color_index_pass % len(colors_pass)],
}
)
color_index_pass += 1
return pie_data
def _generate_distribution_data(
spc_data: List[SpcDataPoint], num_bins=8
) -> List[DistributionPoint]:
"""Generates histogram-like data from SPC points."""
if not spc_data:
return []
values = [p["value"] for p in spc_data]
min_val, max_val = (min(values), max(values))
if min_val == max_val:
return [{"name": f"{min_val:.3f}", "value": len(values)}]
bin_width = (max_val - min_val) / num_bins
bins = [0] * num_bins
|
dist_data = []
for i in range(num_bins):
bin_start = min_val + i * bin_width
bin_name = f"{bin_start:.3f}"
dist_data.append({"name": bin_name, "value": bins[i]})
return dist_data
initial_process_metrics = _generate_process_metrics()
initial_spc_data = _generate_spc_data(base_min=0.415, base_max=0.424)
initial_pie_data = _generate_pie_data(initial_process_metrics)
initial_distribution_data = _generate_distribution_data(initial_spc_data)
class DashboardState(rx.State):
"""Handles the state and logic for the dashboard application."""
operator_id: str = fake.bothify(text="OP-####")
time_to_completion: float = 0.0
is_running: bool = False
ucl: float = 0.432
lcl: float = 0.407
target_mean: float = 0.42
usl: float = 0.424
lsl: float = 0.415
process_metrics: List[MetricData] = initial_process_metrics
spc_chart_data: List[SpcDataPoint] = initial_spc_data
pie_data: List[PieChartData] = initial_pie_data
| for val in values:
bin_index = min(int((val - min_val) / bin_width), num_bins - 1)
if val == max_val:
bin_index = num_bins - 1
bins[bin_index] += 1 |
"fill": fill_color,
}
)
if not pie_data:
default_low_ooc = [
("Diameter", 0.5),
("Etch1", 0.3),
]
for name, value in default_low_ooc:
pie_data.append(
{
"name": name,
"value": value,
"fill": colors_pass[color_index_pass % len(colors_pass)],
}
)
color_index_pass += 1
return pie_data
def _generate_distribution_data(
spc_data: List[SpcDataPoint], num_bins=8
) -> List[DistributionPoint]:
"""Generates histogram-like data from SPC points."""
if not spc_data:
return []
values = [p["value"] for p in spc_data]
min_val, max_val = (min(values), max(values))
if min_val == max_val:
return [{"name": f"{min_val:.3f}", "value": len(values)}]
bin_width = (max_val - min_val) / num_bins
bins = [0] * num_bins
for val in values:
|
if val == max_val:
bin_index = num_bins - 1
bins[bin_index] += 1
dist_data = []
for i in range(num_bins):
bin_start = min_val + i * bin_width
bin_name = f"{bin_start:.3f}"
dist_data.append({"name": bin_name, "value": bins[i]})
return dist_data
initial_process_metrics = _generate_process_metrics()
initial_spc_data = _generate_spc_data(base_min=0.415, base_max=0.424)
initial_pie_data = _generate_pie_data(initial_process_metrics)
initial_distribution_data = _generate_distribution_data(initial_spc_data)
class DashboardState(rx.State):
"""Handles the state and logic for the dashboard application."""
operator_id: str = fake.bothify(text="OP-####")
time_to_completion: float = 0.0
is_running: bool = False
ucl: float = 0.432
lcl: float = 0.407
target_mean: float = 0.42
usl: float = 0.424
lsl: float = 0.415
process_metrics: List[MetricData] = initial_process_metrics
spc_chart_data: L | bin_index = min(int((val - min_val) / bin_width), num_bins - 1) |
ie_data:
default_low_ooc = [
("Diameter", 0.5),
("Etch1", 0.3),
]
for name, value in default_low_ooc:
pie_data.append(
{
"name": name,
"value": value,
"fill": colors_pass[color_index_pass % len(colors_pass)],
}
)
color_index_pass += 1
return pie_data
def _generate_distribution_data(
spc_data: List[SpcDataPoint], num_bins=8
) -> List[DistributionPoint]:
"""Generates histogram-like data from SPC points."""
if not spc_data:
return []
values = [p["value"] for p in spc_data]
min_val, max_val = (min(values), max(values))
if min_val == max_val:
return [{"name": f"{min_val:.3f}", "value": len(values)}]
bin_width = (max_val - min_val) / num_bins
bins = [0] * num_bins
for val in values:
bin_index = min(int((val - min_val) / bin_width), num_bins - 1)
|
bins[bin_index] += 1
dist_data = []
for i in range(num_bins):
bin_start = min_val + i * bin_width
bin_name = f"{bin_start:.3f}"
dist_data.append({"name": bin_name, "value": bins[i]})
return dist_data
initial_process_metrics = _generate_process_metrics()
initial_spc_data = _generate_spc_data(base_min=0.415, base_max=0.424)
initial_pie_data = _generate_pie_data(initial_process_metrics)
initial_distribution_data = _generate_distribution_data(initial_spc_data)
class DashboardState(rx.State):
"""Handles the state and logic for the dashboard application."""
operator_id: str = fake.bothify(text="OP-####")
time_to_completion: float = 0.0
is_running: bool = False
ucl: float = 0.432
lcl: float = 0.407
target_mean: float = 0.42
usl: float = 0.424
lsl: float = 0.415
process_metrics: List[MetricData] = initial_process_metrics
spc_chart_data: List[SpcDataPoint] = initial_spc_data
pie_data: List[PieChart | if val == max_val:
bin_index = num_bins - 1 |
c = [
("Diameter", 0.5),
("Etch1", 0.3),
]
for name, value in default_low_ooc:
pie_data.append(
{
"name": name,
"value": value,
"fill": colors_pass[color_index_pass % len(colors_pass)],
}
)
color_index_pass += 1
return pie_data
def _generate_distribution_data(
spc_data: List[SpcDataPoint], num_bins=8
) -> List[DistributionPoint]:
"""Generates histogram-like data from SPC points."""
if not spc_data:
return []
values = [p["value"] for p in spc_data]
min_val, max_val = (min(values), max(values))
if min_val == max_val:
return [{"name": f"{min_val:.3f}", "value": len(values)}]
bin_width = (max_val - min_val) / num_bins
bins = [0] * num_bins
for val in values:
bin_index = min(int((val - min_val) / bin_width), num_bins - 1)
if val == max_val:
|
bins[bin_index] += 1
dist_data = []
for i in range(num_bins):
bin_start = min_val + i * bin_width
bin_name = f"{bin_start:.3f}"
dist_data.append({"name": bin_name, "value": bins[i]})
return dist_data
initial_process_metrics = _generate_process_metrics()
initial_spc_data = _generate_spc_data(base_min=0.415, base_max=0.424)
initial_pie_data = _generate_pie_data(initial_process_metrics)
initial_distribution_data = _generate_distribution_data(initial_spc_data)
class DashboardState(rx.State):
"""Handles the state and logic for the dashboard application."""
operator_id: str = fake.bothify(text="OP-####")
time_to_completion: float = 0.0
is_running: bool = False
ucl: float = 0.432
lcl: float = 0.407
target_mean: float = 0.42
usl: float = 0.424
lsl: float = 0.415
process_metrics: List[MetricData] = initial_process_metrics
spc_chart_data: List[SpcDataPoint] = initial_spc_data
pie_data: List[PieChart | bin_index = num_bins - 1 |
0.3),
]
for name, value in default_low_ooc:
pie_data.append(
{
"name": name,
"value": value,
"fill": colors_pass[color_index_pass % len(colors_pass)],
}
)
color_index_pass += 1
return pie_data
def _generate_distribution_data(
spc_data: List[SpcDataPoint], num_bins=8
) -> List[DistributionPoint]:
"""Generates histogram-like data from SPC points."""
if not spc_data:
return []
values = [p["value"] for p in spc_data]
min_val, max_val = (min(values), max(values))
if min_val == max_val:
return [{"name": f"{min_val:.3f}", "value": len(values)}]
bin_width = (max_val - min_val) / num_bins
bins = [0] * num_bins
for val in values:
bin_index = min(int((val - min_val) / bin_width), num_bins - 1)
if val == max_val:
bin_index = num_bins - 1
bins[bin_index] += 1
|
for i in range(num_bins):
bin_start = min_val + i * bin_width
bin_name = f"{bin_start:.3f}"
dist_data.append({"name": bin_name, "value": bins[i]})
return dist_data
initial_process_metrics = _generate_process_metrics()
initial_spc_data = _generate_spc_data(base_min=0.415, base_max=0.424)
initial_pie_data = _generate_pie_data(initial_process_metrics)
initial_distribution_data = _generate_distribution_data(initial_spc_data)
class DashboardState(rx.State):
"""Handles the state and logic for the dashboard application."""
operator_id: str = fake.bothify(text="OP-####")
time_to_completion: float = 0.0
is_running: bool = False
ucl: float = 0.432
lcl: float = 0.407
target_mean: float = 0.42
usl: float = 0.424
lsl: float = 0.415
process_metrics: List[MetricData] = initial_process_metrics
spc_chart_data: List[SpcDataPoint] = initial_spc_data
pie_data: List[PieChartData] = initial_pie_data
distribution_data: | dist_data = [] |
for name, value in default_low_ooc:
pie_data.append(
{
"name": name,
"value": value,
"fill": colors_pass[color_index_pass % len(colors_pass)],
}
)
color_index_pass += 1
return pie_data
def _generate_distribution_data(
spc_data: List[SpcDataPoint], num_bins=8
) -> List[DistributionPoint]:
"""Generates histogram-like data from SPC points."""
if not spc_data:
return []
values = [p["value"] for p in spc_data]
min_val, max_val = (min(values), max(values))
if min_val == max_val:
return [{"name": f"{min_val:.3f}", "value": len(values)}]
bin_width = (max_val - min_val) / num_bins
bins = [0] * num_bins
for val in values:
bin_index = min(int((val - min_val) / bin_width), num_bins - 1)
if val == max_val:
bin_index = num_bins - 1
bins[bin_index] += 1
dist_data = []
|
return dist_data
initial_process_metrics = _generate_process_metrics()
initial_spc_data = _generate_spc_data(base_min=0.415, base_max=0.424)
initial_pie_data = _generate_pie_data(initial_process_metrics)
initial_distribution_data = _generate_distribution_data(initial_spc_data)
class DashboardState(rx.State):
"""Handles the state and logic for the dashboard application."""
operator_id: str = fake.bothify(text="OP-####")
time_to_completion: float = 0.0
is_running: bool = False
ucl: float = 0.432
lcl: float = 0.407
target_mean: float = 0.42
usl: float = 0.424
lsl: float = 0.415
process_metrics: List[MetricData] = initial_process_metrics
spc_chart_data: List[SpcDataPoint] = initial_spc_data
pie_data: List[PieChartData] = initial_pie_data
distribution_data: List[DistributionPoint] = initial_distribution_data
def _reset_to_initial(self):
"""Resets data to a new initial state."""
self.process_metrics = _generat | for i in range(num_bins):
bin_start = min_val + i * bin_width
bin_name = f"{bin_start:.3f}"
dist_data.append({"name": bin_name, "value": bins[i]}) |
ow_ooc:
pie_data.append(
{
"name": name,
"value": value,
"fill": colors_pass[color_index_pass % len(colors_pass)],
}
)
color_index_pass += 1
return pie_data
def _generate_distribution_data(
spc_data: List[SpcDataPoint], num_bins=8
) -> List[DistributionPoint]:
"""Generates histogram-like data from SPC points."""
if not spc_data:
return []
values = [p["value"] for p in spc_data]
min_val, max_val = (min(values), max(values))
if min_val == max_val:
return [{"name": f"{min_val:.3f}", "value": len(values)}]
bin_width = (max_val - min_val) / num_bins
bins = [0] * num_bins
for val in values:
bin_index = min(int((val - min_val) / bin_width), num_bins - 1)
if val == max_val:
bin_index = num_bins - 1
bins[bin_index] += 1
dist_data = []
for i in range(num_bins):
|
bin_name = f"{bin_start:.3f}"
dist_data.append({"name": bin_name, "value": bins[i]})
return dist_data
initial_process_metrics = _generate_process_metrics()
initial_spc_data = _generate_spc_data(base_min=0.415, base_max=0.424)
initial_pie_data = _generate_pie_data(initial_process_metrics)
initial_distribution_data = _generate_distribution_data(initial_spc_data)
class DashboardState(rx.State):
"""Handles the state and logic for the dashboard application."""
operator_id: str = fake.bothify(text="OP-####")
time_to_completion: float = 0.0
is_running: bool = False
ucl: float = 0.432
lcl: float = 0.407
target_mean: float = 0.42
usl: float = 0.424
lsl: float = 0.415
process_metrics: List[MetricData] = initial_process_metrics
spc_chart_data: List[SpcDataPoint] = initial_spc_data
pie_data: List[PieChartData] = initial_pie_data
distribution_data: List[DistributionPoint] = initial_distribution_data
def _reset_to_ini | bin_start = min_val + i * bin_width |
{
"name": name,
"value": value,
"fill": colors_pass[color_index_pass % len(colors_pass)],
}
)
color_index_pass += 1
return pie_data
def _generate_distribution_data(
spc_data: List[SpcDataPoint], num_bins=8
) -> List[DistributionPoint]:
"""Generates histogram-like data from SPC points."""
if not spc_data:
return []
values = [p["value"] for p in spc_data]
min_val, max_val = (min(values), max(values))
if min_val == max_val:
return [{"name": f"{min_val:.3f}", "value": len(values)}]
bin_width = (max_val - min_val) / num_bins
bins = [0] * num_bins
for val in values:
bin_index = min(int((val - min_val) / bin_width), num_bins - 1)
if val == max_val:
bin_index = num_bins - 1
bins[bin_index] += 1
dist_data = []
for i in range(num_bins):
bin_start = min_val + i * bin_width
|
dist_data.append({"name": bin_name, "value": bins[i]})
return dist_data
initial_process_metrics = _generate_process_metrics()
initial_spc_data = _generate_spc_data(base_min=0.415, base_max=0.424)
initial_pie_data = _generate_pie_data(initial_process_metrics)
initial_distribution_data = _generate_distribution_data(initial_spc_data)
class DashboardState(rx.State):
"""Handles the state and logic for the dashboard application."""
operator_id: str = fake.bothify(text="OP-####")
time_to_completion: float = 0.0
is_running: bool = False
ucl: float = 0.432
lcl: float = 0.407
target_mean: float = 0.42
usl: float = 0.424
lsl: float = 0.415
process_metrics: List[MetricData] = initial_process_metrics
spc_chart_data: List[SpcDataPoint] = initial_spc_data
pie_data: List[PieChartData] = initial_pie_data
distribution_data: List[DistributionPoint] = initial_distribution_data
def _reset_to_initial(self):
"""Resets data to | bin_name = f"{bin_start:.3f}" |
pass[color_index_pass % len(colors_pass)],
}
)
color_index_pass += 1
return pie_data
def _generate_distribution_data(
spc_data: List[SpcDataPoint], num_bins=8
) -> List[DistributionPoint]:
"""Generates histogram-like data from SPC points."""
if not spc_data:
return []
values = [p["value"] for p in spc_data]
min_val, max_val = (min(values), max(values))
if min_val == max_val:
return [{"name": f"{min_val:.3f}", "value": len(values)}]
bin_width = (max_val - min_val) / num_bins
bins = [0] * num_bins
for val in values:
bin_index = min(int((val - min_val) / bin_width), num_bins - 1)
if val == max_val:
bin_index = num_bins - 1
bins[bin_index] += 1
dist_data = []
for i in range(num_bins):
bin_start = min_val + i * bin_width
bin_name = f"{bin_start:.3f}"
dist_data.append({"name": bin_name, "value": bins[i]})
return dist_data
|
initial_spc_data = _generate_spc_data(base_min=0.415, base_max=0.424)
initial_pie_data = _generate_pie_data(initial_process_metrics)
initial_distribution_data = _generate_distribution_data(initial_spc_data)
class DashboardState(rx.State):
"""Handles the state and logic for the dashboard application."""
operator_id: str = fake.bothify(text="OP-####")
time_to_completion: float = 0.0
is_running: bool = False
ucl: float = 0.432
lcl: float = 0.407
target_mean: float = 0.42
usl: float = 0.424
lsl: float = 0.415
process_metrics: List[MetricData] = initial_process_metrics
spc_chart_data: List[SpcDataPoint] = initial_spc_data
pie_data: List[PieChartData] = initial_pie_data
distribution_data: List[DistributionPoint] = initial_distribution_data
def _reset_to_initial(self):
"""Resets data to a new initial state."""
self.process_metrics = _generate_process_metrics()
self.spc_chart_data = _generate_spc_data(base_min | initial_process_metrics = _generate_process_metrics() |
}
)
color_index_pass += 1
return pie_data
def _generate_distribution_data(
spc_data: List[SpcDataPoint], num_bins=8
) -> List[DistributionPoint]:
"""Generates histogram-like data from SPC points."""
if not spc_data:
return []
values = [p["value"] for p in spc_data]
min_val, max_val = (min(values), max(values))
if min_val == max_val:
return [{"name": f"{min_val:.3f}", "value": len(values)}]
bin_width = (max_val - min_val) / num_bins
bins = [0] * num_bins
for val in values:
bin_index = min(int((val - min_val) / bin_width), num_bins - 1)
if val == max_val:
bin_index = num_bins - 1
bins[bin_index] += 1
dist_data = []
for i in range(num_bins):
bin_start = min_val + i * bin_width
bin_name = f"{bin_start:.3f}"
dist_data.append({"name": bin_name, "value": bins[i]})
return dist_data
initial_process_metrics = _generate_process_metrics()
|
initial_pie_data = _generate_pie_data(initial_process_metrics)
initial_distribution_data = _generate_distribution_data(initial_spc_data)
class DashboardState(rx.State):
"""Handles the state and logic for the dashboard application."""
operator_id: str = fake.bothify(text="OP-####")
time_to_completion: float = 0.0
is_running: bool = False
ucl: float = 0.432
lcl: float = 0.407
target_mean: float = 0.42
usl: float = 0.424
lsl: float = 0.415
process_metrics: List[MetricData] = initial_process_metrics
spc_chart_data: List[SpcDataPoint] = initial_spc_data
pie_data: List[PieChartData] = initial_pie_data
distribution_data: List[DistributionPoint] = initial_distribution_data
def _reset_to_initial(self):
"""Resets data to a new initial state."""
self.process_metrics = _generate_process_metrics()
self.spc_chart_data = _generate_spc_data(base_min=self.lsl, base_max=self.usl)
self.pie_data = _generate_pie_da | initial_spc_data = _generate_spc_data(base_min=0.415, base_max=0.424) |
data
def _generate_distribution_data(
spc_data: List[SpcDataPoint], num_bins=8
) -> List[DistributionPoint]:
"""Generates histogram-like data from SPC points."""
if not spc_data:
return []
values = [p["value"] for p in spc_data]
min_val, max_val = (min(values), max(values))
if min_val == max_val:
return [{"name": f"{min_val:.3f}", "value": len(values)}]
bin_width = (max_val - min_val) / num_bins
bins = [0] * num_bins
for val in values:
bin_index = min(int((val - min_val) / bin_width), num_bins - 1)
if val == max_val:
bin_index = num_bins - 1
bins[bin_index] += 1
dist_data = []
for i in range(num_bins):
bin_start = min_val + i * bin_width
bin_name = f"{bin_start:.3f}"
dist_data.append({"name": bin_name, "value": bins[i]})
return dist_data
initial_process_metrics = _generate_process_metrics()
initial_spc_data = _generate_spc_data(base_min=0.415, base_max=0.424)
|
initial_distribution_data = _generate_distribution_data(initial_spc_data)
class DashboardState(rx.State):
"""Handles the state and logic for the dashboard application."""
operator_id: str = fake.bothify(text="OP-####")
time_to_completion: float = 0.0
is_running: bool = False
ucl: float = 0.432
lcl: float = 0.407
target_mean: float = 0.42
usl: float = 0.424
lsl: float = 0.415
process_metrics: List[MetricData] = initial_process_metrics
spc_chart_data: List[SpcDataPoint] = initial_spc_data
pie_data: List[PieChartData] = initial_pie_data
distribution_data: List[DistributionPoint] = initial_distribution_data
def _reset_to_initial(self):
"""Resets data to a new initial state."""
self.process_metrics = _generate_process_metrics()
self.spc_chart_data = _generate_spc_data(base_min=self.lsl, base_max=self.usl)
self.pie_data = _generate_pie_data(self.process_metrics)
self.distribution_data = _gene | initial_pie_data = _generate_pie_data(initial_process_metrics) |
ataPoint], num_bins=8
) -> List[DistributionPoint]:
"""Generates histogram-like data from SPC points."""
if not spc_data:
return []
values = [p["value"] for p in spc_data]
min_val, max_val = (min(values), max(values))
if min_val == max_val:
return [{"name": f"{min_val:.3f}", "value": len(values)}]
bin_width = (max_val - min_val) / num_bins
bins = [0] * num_bins
for val in values:
bin_index = min(int((val - min_val) / bin_width), num_bins - 1)
if val == max_val:
bin_index = num_bins - 1
bins[bin_index] += 1
dist_data = []
for i in range(num_bins):
bin_start = min_val + i * bin_width
bin_name = f"{bin_start:.3f}"
dist_data.append({"name": bin_name, "value": bins[i]})
return dist_data
initial_process_metrics = _generate_process_metrics()
initial_spc_data = _generate_spc_data(base_min=0.415, base_max=0.424)
initial_pie_data = _generate_pie_data(initial_process_metrics)
|
class DashboardState(rx.State):
"""Handles the state and logic for the dashboard application."""
operator_id: str = fake.bothify(text="OP-####")
time_to_completion: float = 0.0
is_running: bool = False
ucl: float = 0.432
lcl: float = 0.407
target_mean: float = 0.42
usl: float = 0.424
lsl: float = 0.415
process_metrics: List[MetricData] = initial_process_metrics
spc_chart_data: List[SpcDataPoint] = initial_spc_data
pie_data: List[PieChartData] = initial_pie_data
distribution_data: List[DistributionPoint] = initial_distribution_data
def _reset_to_initial(self):
"""Resets data to a new initial state."""
self.process_metrics = _generate_process_metrics()
self.spc_chart_data = _generate_spc_data(base_min=self.lsl, base_max=self.usl)
self.pie_data = _generate_pie_data(self.process_metrics)
self.distribution_data = _generate_distribution_data(self.spc_chart_data)
@rx.event(background=True | initial_distribution_data = _generate_distribution_data(initial_spc_data) |
l + i * bin_width
bin_name = f"{bin_start:.3f}"
dist_data.append({"name": bin_name, "value": bins[i]})
return dist_data
initial_process_metrics = _generate_process_metrics()
initial_spc_data = _generate_spc_data(base_min=0.415, base_max=0.424)
initial_pie_data = _generate_pie_data(initial_process_metrics)
initial_distribution_data = _generate_distribution_data(initial_spc_data)
class DashboardState(rx.State):
"""Handles the state and logic for the dashboard application."""
operator_id: str = fake.bothify(text="OP-####")
time_to_completion: float = 0.0
is_running: bool = False
ucl: float = 0.432
lcl: float = 0.407
target_mean: float = 0.42
usl: float = 0.424
lsl: float = 0.415
process_metrics: List[MetricData] = initial_process_metrics
spc_chart_data: List[SpcDataPoint] = initial_spc_data
pie_data: List[PieChartData] = initial_pie_data
distribution_data: List[DistributionPoint] = initial_distribution_data
|
@rx.event(background=True)
async def start_process(self):
"""Simulates starting a process and updating data over time using Faker."""
async with self:
if self.is_running:
return
self.is_running = True
self.time_to_completion = 0.0
update_interval = 0.1
data_gen_interval = 10
metrics_update_interval = 30
for i in range(101):
async with self:
self.time_to_completion = float(i)
if i > 0 and i % data_gen_interval == 0:
last_name = (
self.spc_chart_data[-1]["name"] if self.spc_chart_data else -1
)
new_name = last_name + 1
new_value_base = fake.pyfloat(
left_digits=0,
right_digits=4,
positive=True,
min_value=self.lsl - 0.002,
| def _reset_to_initial(self):
"""Resets data to a new initial state."""
self.process_metrics = _generate_process_metrics()
self.spc_chart_data = _generate_spc_data(base_min=self.lsl, base_max=self.usl)
self.pie_data = _generate_pie_data(self.process_metrics)
self.distribution_data = _generate_distribution_data(self.spc_chart_data) |
": bin_name, "value": bins[i]})
return dist_data
initial_process_metrics = _generate_process_metrics()
initial_spc_data = _generate_spc_data(base_min=0.415, base_max=0.424)
initial_pie_data = _generate_pie_data(initial_process_metrics)
initial_distribution_data = _generate_distribution_data(initial_spc_data)
class DashboardState(rx.State):
"""Handles the state and logic for the dashboard application."""
operator_id: str = fake.bothify(text="OP-####")
time_to_completion: float = 0.0
is_running: bool = False
ucl: float = 0.432
lcl: float = 0.407
target_mean: float = 0.42
usl: float = 0.424
lsl: float = 0.415
process_metrics: List[MetricData] = initial_process_metrics
spc_chart_data: List[SpcDataPoint] = initial_spc_data
pie_data: List[PieChartData] = initial_pie_data
distribution_data: List[DistributionPoint] = initial_distribution_data
def _reset_to_initial(self):
"""Resets data to a new initial state."""
|
self.spc_chart_data = _generate_spc_data(base_min=self.lsl, base_max=self.usl)
self.pie_data = _generate_pie_data(self.process_metrics)
self.distribution_data = _generate_distribution_data(self.spc_chart_data)
@rx.event(background=True)
async def start_process(self):
"""Simulates starting a process and updating data over time using Faker."""
async with self:
if self.is_running:
return
self.is_running = True
self.time_to_completion = 0.0
update_interval = 0.1
data_gen_interval = 10
metrics_update_interval = 30
for i in range(101):
async with self:
self.time_to_completion = float(i)
if i > 0 and i % data_gen_interval == 0:
last_name = (
self.spc_chart_data[-1]["name"] if self.spc_chart_data else -1
)
new_name = last_name + 1
| self.process_metrics = _generate_process_metrics() |
ial_process_metrics = _generate_process_metrics()
initial_spc_data = _generate_spc_data(base_min=0.415, base_max=0.424)
initial_pie_data = _generate_pie_data(initial_process_metrics)
initial_distribution_data = _generate_distribution_data(initial_spc_data)
class DashboardState(rx.State):
"""Handles the state and logic for the dashboard application."""
operator_id: str = fake.bothify(text="OP-####")
time_to_completion: float = 0.0
is_running: bool = False
ucl: float = 0.432
lcl: float = 0.407
target_mean: float = 0.42
usl: float = 0.424
lsl: float = 0.415
process_metrics: List[MetricData] = initial_process_metrics
spc_chart_data: List[SpcDataPoint] = initial_spc_data
pie_data: List[PieChartData] = initial_pie_data
distribution_data: List[DistributionPoint] = initial_distribution_data
def _reset_to_initial(self):
"""Resets data to a new initial state."""
self.process_metrics = _generate_process_metrics()
|
self.pie_data = _generate_pie_data(self.process_metrics)
self.distribution_data = _generate_distribution_data(self.spc_chart_data)
@rx.event(background=True)
async def start_process(self):
"""Simulates starting a process and updating data over time using Faker."""
async with self:
if self.is_running:
return
self.is_running = True
self.time_to_completion = 0.0
update_interval = 0.1
data_gen_interval = 10
metrics_update_interval = 30
for i in range(101):
async with self:
self.time_to_completion = float(i)
if i > 0 and i % data_gen_interval == 0:
last_name = (
self.spc_chart_data[-1]["name"] if self.spc_chart_data else -1
)
new_name = last_name + 1
new_value_base = fake.pyfloat(
left_digits=0,
| self.spc_chart_data = _generate_spc_data(base_min=self.lsl, base_max=self.usl) |
(base_min=0.415, base_max=0.424)
initial_pie_data = _generate_pie_data(initial_process_metrics)
initial_distribution_data = _generate_distribution_data(initial_spc_data)
class DashboardState(rx.State):
"""Handles the state and logic for the dashboard application."""
operator_id: str = fake.bothify(text="OP-####")
time_to_completion: float = 0.0
is_running: bool = False
ucl: float = 0.432
lcl: float = 0.407
target_mean: float = 0.42
usl: float = 0.424
lsl: float = 0.415
process_metrics: List[MetricData] = initial_process_metrics
spc_chart_data: List[SpcDataPoint] = initial_spc_data
pie_data: List[PieChartData] = initial_pie_data
distribution_data: List[DistributionPoint] = initial_distribution_data
def _reset_to_initial(self):
"""Resets data to a new initial state."""
self.process_metrics = _generate_process_metrics()
self.spc_chart_data = _generate_spc_data(base_min=self.lsl, base_max=self.usl)
|
self.distribution_data = _generate_distribution_data(self.spc_chart_data)
@rx.event(background=True)
async def start_process(self):
"""Simulates starting a process and updating data over time using Faker."""
async with self:
if self.is_running:
return
self.is_running = True
self.time_to_completion = 0.0
update_interval = 0.1
data_gen_interval = 10
metrics_update_interval = 30
for i in range(101):
async with self:
self.time_to_completion = float(i)
if i > 0 and i % data_gen_interval == 0:
last_name = (
self.spc_chart_data[-1]["name"] if self.spc_chart_data else -1
)
new_name = last_name + 1
new_value_base = fake.pyfloat(
left_digits=0,
right_digits=4,
pos | self.pie_data = _generate_pie_data(self.process_metrics) |
_data(initial_process_metrics)
initial_distribution_data = _generate_distribution_data(initial_spc_data)
class DashboardState(rx.State):
"""Handles the state and logic for the dashboard application."""
operator_id: str = fake.bothify(text="OP-####")
time_to_completion: float = 0.0
is_running: bool = False
ucl: float = 0.432
lcl: float = 0.407
target_mean: float = 0.42
usl: float = 0.424
lsl: float = 0.415
process_metrics: List[MetricData] = initial_process_metrics
spc_chart_data: List[SpcDataPoint] = initial_spc_data
pie_data: List[PieChartData] = initial_pie_data
distribution_data: List[DistributionPoint] = initial_distribution_data
def _reset_to_initial(self):
"""Resets data to a new initial state."""
self.process_metrics = _generate_process_metrics()
self.spc_chart_data = _generate_spc_data(base_min=self.lsl, base_max=self.usl)
self.pie_data = _generate_pie_data(self.process_metrics)
|
@rx.event(background=True)
async def start_process(self):
"""Simulates starting a process and updating data over time using Faker."""
async with self:
if self.is_running:
return
self.is_running = True
self.time_to_completion = 0.0
update_interval = 0.1
data_gen_interval = 10
metrics_update_interval = 30
for i in range(101):
async with self:
self.time_to_completion = float(i)
if i > 0 and i % data_gen_interval == 0:
last_name = (
self.spc_chart_data[-1]["name"] if self.spc_chart_data else -1
)
new_name = last_name + 1
new_value_base = fake.pyfloat(
left_digits=0,
right_digits=4,
positive=True,
min_value=self.lsl - 0.002,
| self.distribution_data = _generate_distribution_data(self.spc_chart_data) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.