Spaces:
Running
Running
Download python/borderland_verify/streaming_reference.py from FatUnc6969/borderland-rl: direct link, hf CLI and curl.
- Browser
- Download file 6.06 kB
-
https://huggingface.co/spaces/FatUnc6969/borderland-rl/resolve/main/python/borderland_verify/streaming_reference.py
- Command line
-
hf download hf://spaces/FatUnc6969/borderland-rl/python/borderland_verify/streaming_reference.py
-
curl -L -o streaming_reference.py https://huggingface.co/spaces/FatUnc6969/borderland-rl/resolve/main/python/borderland_verify/streaming_reference.py
6.06 kB
| from copy import deepcopy | |
| import json | |
| from types import SimpleNamespace | |
| from borderland import Action | |
| from borderland.plant import LANES, WITNESSES, SEALS | |
| from borderland_verify.causal_reference import CausalReference | |
| def encode(value): | |
| return json.dumps(value, sort_keys=True, separators=(',', ':'), ensure_ascii=False) | |
| class PublicTransition: | |
| def __init__(self, public): | |
| self.observation = SimpleNamespace(to_dict=lambda: deepcopy(public['observation'])) | |
| self.legal_actions = tuple(Action(a['tag'], a['arguments']) for a in public['legal_actions']) | |
| class StreamingController: | |
| def decide(self, public): | |
| o = public['observation'] | |
| b = o['board'] | |
| text = o['notebook']['text'] | |
| note = json.loads(text) if text else {'v': 4, 'a': [], 'p': {}} | |
| if note['v'] == 3 and o['phase'] == 3: | |
| return {'tool': 'execute_action', 'arguments': {'tag': 'bind_docket', 'arguments': {'record_ids': sorted(b['filed'].values())}}} | |
| if o['phase'] >= 4: | |
| assert note['v'] == 3 | |
| reference = CausalReference() | |
| action = reference.choose(PublicTransition(public)) | |
| return {'tool': 'execute_action', 'arguments': action.to_dict()} | |
| assert note['v'] == 4 | |
| previous = encode(note) | |
| readings = {cid: [bit, phase] for cid, bit, phase in note['a']} | |
| if o['phase'] == 1: | |
| pair = readings.setdefault(b['channel'], [None, None]) | |
| if b['live_sensor'] is not None: | |
| pair[0] = b['live_sensor'] ^ (b['latch'] & 1) | |
| if b['phase_mark'] is not None: | |
| pair[1] = (b['phase_mark'] - b['latch']) % 4 | |
| note['a'] = [[cid, *values] for cid, values in readings.items() if values != [None, None]] | |
| if o['phase'] == 2 and b['transit_plate'] is not None: | |
| plate = b['transit_plate'] | |
| note['t'] = [LANES.index(plate['freight_lane']), plate['delivery_residue'], plate['closure_residue'], plate['bridge_rating']] | |
| if o['phase'] == 3 and b['records']: | |
| for record in b['records']: | |
| if not record['authenticated'] or record['applies_channel'] is None: | |
| continue | |
| if readings[record['applies_channel']][0] != record['applies_bit']: | |
| continue | |
| active = note.get('q') | |
| if active and active[0] == record['subject'] and active[3] > record['issued_at']: | |
| continue | |
| self.compile_service(note, readings, record) | |
| note['q'] = [record['subject'], record['id'], record['supersedes'], record['issued_at']] | |
| if encode(note) != previous: | |
| return self.save(note, o) | |
| reference = CausalReference() | |
| reference.calibrations = readings | |
| reference.channel_order = b.get('channels', list(readings)) | |
| if 't' in note: | |
| from borderland.plant import Transit | |
| t = note['t'] | |
| reference.transit = Transit(LANES[t[0]], *t[1:]) | |
| if o['phase'] in (1, 2): | |
| action = reference.choose(PublicTransition(public)) | |
| else: | |
| p = note['p'] | |
| if len(b['filed']) == b['service_count']: | |
| return self.save({'v': 3, 'p': self.ordered_plan(p)}, o) | |
| active = note.get('q') | |
| current_service = b['records'][0]['subject'] if b['records'] else None | |
| if b['slot'] is None or current_service in b['filed']: | |
| slot = 0 if b['slot'] is None else b['slot'] + 1 | |
| action = Action('open_scroll', {'slot': slot}) | |
| elif b['page'] + 1 < b['page_count']: | |
| action = Action('advance_page', {}) | |
| else: | |
| assert active and active[0] == current_service | |
| if b['result'] == 'verified exposed civic revision chain': | |
| action = Action('file_record', {'record_id': active[1]}) | |
| else: | |
| action = Action('compare_seal', {'left_id': active[2], 'right_id': active[1]}) | |
| return {'tool': 'execute_action', 'arguments': action.to_dict()} | |
| def save(self, note, observation): | |
| text = encode(note) | |
| assert len(text.encode('utf-8')) <= observation['notebook']['capacity_bytes'], len(text.encode('utf-8')) | |
| assert text != observation['notebook']['text'] | |
| return {'tool': 'replace_notebook', 'arguments': {'text': text}} | |
| def compile_service(self, note, readings, record): | |
| p = note['p'] | |
| body = record['body'] | |
| bit, phase = readings[body['channel']] | |
| freight, residue, _, _ = note['t'] | |
| service = record['subject'] | |
| if body['kind'] == 'circuit': | |
| entry = [service, LANES[bit ^ freight ^ body['bus_shift']], body['predecessors'], ''.join(map(str, record['ratings']))] | |
| circuits = {c[0]: c for c in p.get('c', [])} | |
| circuits[service] = entry | |
| p['c'] = list(circuits.values()) | |
| elif body['kind'] == 'delivery': | |
| p['d'] = [LANES[freight ^ bit ^ LANES.index(body['lane'])], (residue - phase) % 4] | |
| elif body['kind'] == 'permit': | |
| p['w'] = WITNESSES[(WITNESSES.index(body['witness']) + freight) % 3] | |
| p['s'] = SEALS[(SEALS.index(body['seal']) + phase) % 3] | |
| p['a'] = service | |
| elif body['kind'] == 'egress': | |
| p['e'] = [(freight + phase + body['track_delta']) % 3, LANES[bit ^ freight ^ body['valve_shift']]] | |
| p['g'] = service | |
| def ordered_plan(self, plan): | |
| plan = deepcopy(plan) | |
| remaining = {entry[0]: entry for entry in plan['c']} | |
| ordered = [] | |
| while remaining: | |
| live = {entry[0] for entry in ordered} | |
| ready = sorted(cid for cid, entry in remaining.items() if set(entry[2]) <= live) | |
| assert ready | |
| ordered.append(remaining.pop(ready[0])) | |
| plan['c'] = ordered | |
| return plan | |
| def choose(public): | |
| return StreamingController().decide(deepcopy(public)) | |