devagent-ignition 0.1.0__py3-none-any.whl

devagent_spatial/_resources/reference/r9-original/flow_sim.py

@@ -0,0 +1,117 @@
+"""V1J deterministic LAB parcel timeline. isolated concept assets, no real PLC controls."""
+import json, math, time
+from pathlib import Path
+from threading import RLock
+from collections import deque
+MODEL=json.loads((Path(__file__).with_name('flow_routes.json')).read_text())
+IDS=tuple(MODEL['ids'])
+ORIGINAL=tuple(MODEL['original'])
+SCANNERS={'DWS01':('CV202',0.50),'DEST_SCAN':('CV302',0.50)}
+SPEED=2.05  # representative scene units per second; NOT a measured belt speed
+BEAM_HALF_WIDTH=.53 # parcel geometry + illustrative detector window
+
+class ParcelFlow:
+    def __init__(self):
+        self._lock=RLock();self.wave=-1;self.cycle=0;self.parcels=[];self.delivered=0
+        self.sensors={eid:{'PE_IN':False,'PE_OUT':False,'IN_COUNT':0,'OUT_COUNT':0} for eid in IDS}
+        self.scanners={k:{'LastBarcode':'','LastParcelId':'','LastResult':'NO_SCAN','ScanCount':0,'NoReadCount':0,'Revision':0} for k in SCANNERS}
+        self.events=deque(maxlen=32);self.sequence=0;self.timestamp=0.0;self.last_scan=None
+    def _make_wave(self,w):
+        self.wave=w;self.cycle+=1;self.parcels=[]
+        for i in range(11):
+            # Keep original six + R6 one-time return; add four demonstration parcels
+            # each starting on a connected R9 compact sorter station.
+            route=MODEL['routes'][i]
+            length=sum(MODEL['lengths'][eid] for eid in route)
+            # Evenly stagger baseline routes, but seed the *single* added
+            # recirculation demo parcel just upstream of the new Floor-3
+            # discharge so an operator can inspect it without waiting for a
+            # full multi-floor traversal. The position moves continuously
+            # thereafter, with no teleport at any junction.
+            initial=(i/8)*length if i<6 else 0.0
+            if 'R6_CHUTE_F2' in route:
+                index=route.index('SORT301')
+                initial=sum(MODEL['lengths'][eid] for eid in route[:index])+MODEL['lengths']['SORT301']*.05
+            if i>=7:
+                # Position a parcel near its assigned R8 mainline station.
+                # It still follows every physical segment of its route.
+                chute=f'R9_CHUTE_{i-6:02d}'
+                index=route.index(f'R9_SORT_{i-6:02d}')
+                initial=sum(MODEL['lengths'][eid] for eid in route[:index])+MODEL['lengths'][route[index]]*.01
+            self.parcels.append({'id':'PKG-%06d'%(w*100000+self.cycle*100+i+1),'route':route,'offset':initial,'distance':initial,'done':False})
+    def _locate_with_index(self,p):
+        d=p['distance']
+        for i,eid in enumerate(p['route']):
+            ln=MODEL['lengths'][eid]
+            if d<=ln:return i,eid,max(0.0,min(1.0,d/ln))
+            d-=ln
+        return len(p['route'])-1,p['route'][-1],1.0
+    def _locate(self,p):
+        _,eid,progress=self._locate_with_index(p)
+        return eid,progress
+    def _cross(self,p,old,new,index,at):
+        # Route positions, NOT equipment names: a re-sort parcel traverses
+        # CV302 and SORT301 twice. Counting only the first occurrence silently
+        # loses scanner/PE events on recirculated parcels.
+        length=MODEL['lengths'][p['route'][index]]
+        offset=sum(MODEL['lengths'][eid] for eid in p['route'][:index])
+        return old < offset+at*length <= new
+    def _event(self,kind,eid,pid):
+        self.sequence+=1
+        event={'sequence':self.sequence,'kind':kind,'equipmentId':eid,'parcelId':pid,'timestamp':self.timestamp}
+        self.events.append(event)
+        if kind.startswith('SCAN_'):self.last_scan=event
+    def step(self,state,wave,dt,now=None):
+        with self._lock:
+            self.timestamp=round(float(now if now is not None else time.time()),3)
+            if wave != self.wave:
+                self._make_wave(wave) if state=='RUNNING' else self._reset(wave)
+            if state=='RUNNING' and (not self.parcels or all(p['done'] for p in self.parcels)):
+                self._make_wave(wave)
+            for p in self.parcels:
+                if p['done']:continue
+                old=p['distance'];total=sum(MODEL['lengths'][x] for x in p['route'])
+                new=min(total,old+max(0,min(dt,.5))*SPEED) if state=='RUNNING' else old
+                if state=='RUNNING':
+                    for index,eid in enumerate(p['route']):
+                        for direction,frac,key in [('PE_IN',.08,'IN_COUNT'),('PE_OUT',.92,'OUT_COUNT')]:
+                            if self._cross(p,old,new,index,frac):
+                                self.sensors[eid][key]+=1;self._event(direction,eid,p['id'])
+                    for scanner,(eid,frac) in SCANNERS.items():
+                        for index,current in enumerate(p['route']):
+                            if current != eid or not self._cross(p,old,new,index,frac):continue
+                            s=self.scanners[scanner];s['ScanCount']+=1
+                            serial=int(p['id'].split('-')[-1]);read='NO_READ' if serial%4==0 else 'GOOD_READ'
+                            if read=='NO_READ':s['NoReadCount']+=1
+                            s['LastBarcode']=p['id'] if read=='GOOD_READ' else ''
+                            s['LastParcelId']=p['id'];s['LastResult']=read;s['Revision']+=1
+                            self._event('SCAN_'+read,scanner,p['id'])
+                p['distance']=new
+                if new>=total and state=='RUNNING':p['done']=True;self.delivered+=1;self._event('DELIVERED',p['route'][-1],p['id'])
+            # Derived instantaneous beam states; frozen while stopped/faulted.
+            for eid,s in self.sensors.items():s['PE_IN']=False;s['PE_OUT']=False
+            for p in self.parcels:
+                if p['done']:continue
+                e,t=self._locate(p);dist=t*MODEL['lengths'][e]
+                for key,frac in (('PE_IN',.08),('PE_OUT',.92)):
+                    if abs(dist-frac*MODEL['lengths'][e])<=BEAM_HALF_WIDTH:self.sensors[e][key]=True
+            return self.snapshot()
+    def _reset(self,wave):
+        self.wave=wave;self.cycle=0;self.parcels=[];self.delivered=0
+        self.events.clear();self.sequence=0;self.last_scan=None
+        self.sensors={eid:{'PE_IN':False,'PE_OUT':False,'IN_COUNT':0,'OUT_COUNT':0} for eid in IDS}
+        self.scanners={k:{'LastBarcode':'','LastParcelId':'','LastResult':'NO_SCAN','ScanCount':0,'NoReadCount':0,'Revision':0} for k in SCANNERS}
+    def snapshot(self):
+        with self._lock:
+            poses=[]
+            for p in self.parcels:
+                if not p['done']:
+                    index,eid,t=self._locate_with_index(p)
+                    poses.append({'parcelId':p['id'],'equipmentId':eid,'progress':round(t,5),
+                                  'nextEquipmentId':p['route'][index+1] if index+1<len(p['route']) else None})
+            return {'sensor_quality':'ISOLATED_SIMULATOR','timestamp':self.timestamp,
+                    'equipment':{k:dict(v) for k,v in self.sensors.items()},
+                    'scanners':{k:dict(v) for k,v in self.scanners.items()},
+                    'parcels':poses,'parcels_in_transit':len(poses),'delivered':self.delivered,
+                    'blocked_sensors':sum(int(v['PE_IN'])+int(v['PE_OUT']) for v in self.sensors.values()),
+                    'sensor_events':list(self.events)[-16:],'last_scan':self.last_scan}

devagent_spatial/_resources/reference/r9-original/lab_control.py

@@ -0,0 +1,73 @@
+"""Isolated, in-memory simulator command model. No OPC UA / V1C writes."""
+from __future__ import annotations
+import threading
+import time
+from collections import deque
+from dataclasses import dataclass, field
+
+VALID = frozenset({'start', 'stop', 'reset', 'ack', 'inject_jam'})
+
+class CommandConflict(Exception):
+    pass
+
+@dataclass
+class LabController:
+    state: str = 'STOPPED'
+    revision: int = 0
+    wave: int = 0
+    fault: str | None = None
+    alarm_acknowledged: bool = False
+    updated: float = field(default_factory=time.time)
+    events: deque = field(default_factory=lambda: deque(maxlen=100))
+    _replays: dict = field(default_factory=dict)
+    sensor_data: dict = field(default_factory=dict)
+    _lock: threading.RLock = field(default_factory=threading.RLock)
+
+    def update_sensors(self, data):
+        with self._lock:
+            self.sensor_data = data
+
+    def snapshot(self):
+        with self._lock:
+            return {'mode':'ISOLATED_SIMULATOR','run_state':self.state,
+                    'revision':self.revision, 'wave':self.wave,
+                    'fault':self.fault,'ack_required':bool(self.fault and not self.alarm_acknowledged),
+                    'alarm_acknowledged':bool(self.fault and self.alarm_acknowledged),
+                    'updated_at':self.updated,
+                    'equipment_id':'CV208' if self.fault else None,
+                    'writes_to_v1c':False,'writes_to_opcua':False,'events':list(self.events)[-8:],
+                    'sensor_data': self.sensor_data}
+
+    def command(self, name: str, request_id: str):
+        if name not in VALID: raise ValueError('unsupported command')
+        with self._lock:
+            if request_id in self._replays:
+                if self._replays[request_id] != name:
+                    raise CommandConflict('request_id reused for different command')
+                return self.snapshot()
+            if name == 'start':
+                if self.state != 'STOPPED' or self.fault:
+                    raise CommandConflict('START requires STOPPED state and no active fault')
+                self.state='RUNNING'
+            elif name == 'stop':
+                if self.state != 'RUNNING': raise CommandConflict('STOP requires RUNNING state')
+                self.state='STOPPED'
+            elif name == 'inject_jam':
+                if self.state != 'RUNNING': raise CommandConflict('JAM TEST requires RUNNING state')
+                self.state='FAULT'; self.fault='SIMULATED_JAM_CV208'; self.alarm_acknowledged=False
+            elif name == 'ack':
+                if not self.fault or self.alarm_acknowledged:
+                    raise CommandConflict('ACK requires an unacknowledged simulated alarm')
+                self.alarm_acknowledged=True
+            elif name == 'reset':
+                if self.state == 'RUNNING': raise CommandConflict('STOP before RESET')
+                if self.fault and not self.alarm_acknowledged:
+                    raise CommandConflict('ACK the simulated jam before RESET')
+                self.state='STOPPED'; self.fault=None; self.alarm_acknowledged=False; self.wave+=1
+            self.revision+=1; self.updated=time.time()
+            self.events.append({'command':name.upper(),'revision':self.revision,'state':self.state,
+                                'time':self.updated,'request_id':request_id})
+            self._replays[request_id]=name
+            # Bound memory growth without allowing stale repeated IDs to mutate silently within the recent window.
+            if len(self._replays)>512:self._replays.pop(next(iter(self._replays)))
+            return self.snapshot()