128 lines
3.6 KiB
Python
128 lines
3.6 KiB
Python
"""Single-cycle live material polling orchestration."""
|
|
|
|
from dataclasses import dataclass
|
|
from datetime import datetime
|
|
from typing import Protocol
|
|
|
|
from production_analytics.calculations.material_consumption import (
|
|
MaterialConsumptionIntegrator,
|
|
MaterialIntegrationState,
|
|
MaterialIntegratorConfig,
|
|
)
|
|
from production_analytics.enlyze.gateway import (
|
|
EnlyzeApiGateway,
|
|
EnlyzeProductionRun,
|
|
)
|
|
|
|
|
|
@dataclass(frozen=True, slots=True)
|
|
class MaterialPollingState:
|
|
run_id: str
|
|
integration_state: MaterialIntegrationState
|
|
|
|
|
|
class MaterialStateStore(Protocol):
|
|
def load(
|
|
self,
|
|
machine_id: str,
|
|
production_order: str,
|
|
) -> MaterialPollingState | None: ...
|
|
|
|
def save(
|
|
self,
|
|
machine_id: str,
|
|
production_order: str,
|
|
state: MaterialPollingState,
|
|
) -> None: ...
|
|
|
|
|
|
@dataclass(frozen=True, slots=True)
|
|
class MaterialPollResult:
|
|
run: EnlyzeProductionRun
|
|
state: MaterialIntegrationState
|
|
|
|
|
|
class MaterialPollingService:
|
|
def __init__(
|
|
self,
|
|
*,
|
|
gateway: EnlyzeApiGateway,
|
|
state_store: MaterialStateStore,
|
|
machine_id: str,
|
|
rate_variable_id: str,
|
|
gate_variable_id: str,
|
|
gate_threshold: float,
|
|
max_sample_gap_seconds: float,
|
|
) -> None:
|
|
self._gateway = gateway
|
|
self._state_store = state_store
|
|
self._machine_id = machine_id
|
|
self._rate_variable_id = rate_variable_id
|
|
self._gate_variable_id = gate_variable_id
|
|
self._config = MaterialIntegratorConfig(
|
|
gate_threshold=gate_threshold,
|
|
max_sample_gap_seconds=max_sample_gap_seconds,
|
|
)
|
|
|
|
def poll_once(self, *, now: datetime) -> MaterialPollResult | None:
|
|
if now.tzinfo is None or now.utcoffset() is None:
|
|
raise ValueError("now must be timezone-aware")
|
|
run = self._gateway.get_open_production_run(self._machine_id)
|
|
if run is None or now < run.start:
|
|
return None
|
|
|
|
saved_polling_state = self._state_store.load(
|
|
self._machine_id,
|
|
run.production_order,
|
|
)
|
|
|
|
if saved_polling_state is None:
|
|
initial_state = None
|
|
start = run.start
|
|
elif saved_polling_state.run_id == run.uuid:
|
|
initial_state = saved_polling_state.integration_state
|
|
start = (
|
|
initial_state.last_processed_timestamp
|
|
if initial_state.last_processed_timestamp is not None
|
|
else run.start
|
|
)
|
|
else:
|
|
previous = saved_polling_state.integration_state
|
|
initial_state = MaterialIntegrationState(
|
|
cumulative_consumption_kg=previous.cumulative_consumption_kg,
|
|
integrated_running_seconds=previous.integrated_running_seconds,
|
|
)
|
|
start = run.start
|
|
|
|
if now < start:
|
|
return None
|
|
|
|
integrator = MaterialConsumptionIntegrator(
|
|
self._config,
|
|
initial_state=initial_state,
|
|
)
|
|
|
|
samples = self._gateway.get_material_samples(
|
|
machine_id=self._machine_id,
|
|
rate_variable_id=self._rate_variable_id,
|
|
gate_variable_id=self._gate_variable_id,
|
|
start=start,
|
|
end=now,
|
|
)
|
|
|
|
integrator.process_many(samples)
|
|
|
|
self._state_store.save(
|
|
self._machine_id,
|
|
run.production_order,
|
|
MaterialPollingState(
|
|
run_id=run.uuid,
|
|
integration_state=integrator.state,
|
|
),
|
|
)
|
|
|
|
return MaterialPollResult(
|
|
run=run,
|
|
state=integrator.state,
|
|
)
|