| """Released environment operations and snapshot validation.""" |
| from __future__ import annotations |
| from copy import deepcopy as ext_deepcopy |
| from datetime import datetime as ext_datetime |
| from datetime import timedelta as ext_timedelta |
| from functools import lru_cache |
| from pathlib import Path as ext_Path |
| from rescopebench.raw_module_isolation import load_isolated_modules as ext_load_isolated_modules |
| from typing import Any as ext_Any |
| import hashlib as mod_hashlib |
| import importlib as mod_importlib |
| import json as mod_json |
| import jsonschema as mod_jsonschema |
| import sys as mod_sys |
| from .spec import CASE_DIR, DATA_MIGRATED_ATOMS, DATA_TICKET_KINDS, DATA_TASK_IDS, DATA_SCHEDULE_2, DATA_SCHEDULE_3, DATA_WRITE_TOOLS, DATA_TOOLS_2, DATA_CHANGED_BINDINGS, DATA_CHANGED_RULES, DATA_STREAM_CLUSTERS, DATA_TASK_IDS_2, DATA_DRIFT_CHANGED_RULES, DATA_RULE_LANES, DATA_OFFER_LANES, DATA_DRIFT_CHANGED_STRUCTURES, DATA_IDENTITY_FIELDS, DATA_ENTITY_ID_FIELDS, DATA_EVENT_KINDS, DATA_TOOLS_BY_NAME, DATA_RULE_PROFILES, DATA_CHANGED_RULES_2, DATA_STREAM_SCHEDULE, DATA_STREAM_CUSTOMER_NAMES |
|
|
| def fn_handle(kind, value): |
| return f"{kind}-{fn_digest(['event-ticketing-v4', kind, value])[:14]}" |
|
|
| def fn_rekey_entities(entities, mappings): |
| return {kind: [fn_rekey_record(row, mappings) for row in rows] for (kind, rows) in entities.items()} |
|
|
| def fn_rekey_record(record, mappings): |
| """Only declared relational fields, not arbitrary strings or audit prose.""" |
| result = ext_deepcopy(record) |
| for field in DATA_IDENTITY_FIELDS: |
| if field in result: |
| result[field] = mappings[field].get(result[field], result[field]) |
| if 'ticket_type_ids' in result: |
| result['ticket_type_ids'] = [mappings['ticket_type_id'].get(x, x) for x in result['ticket_type_ids']] |
| return result |
|
|
| def fn_rule_id(event_kind, ticket_kind): |
| return f'R{DATA_EVENT_KINDS.index(event_kind) * 4 + DATA_TICKET_KINDS.index(ticket_kind) + 1:02d}' |
|
|
| def fn_profile(index): |
| return {'offer_profile_id': fn_handle_2('profile', str(index)), 'audience_certificate': ('public', 'membership')[index // 4], 'redemption_channel': ('counter', 'electronic')[index // 2 % 2], 'reimbursement_cycle': ('weekly', 'monthly')[index % 2]} |
|
|
| def fn_rule_index(atom, epoch): |
| value = DATA_RULE_PROFILES[int(atom[1:]) - 1] |
| return value ^ 5 if epoch and atom in DATA_CHANGED_RULES else value |
|
|
| def fn_rule_index_2(atom, epoch): |
| value = DATA_RULE_PROFILES[int(atom[1:]) - 1] |
| return value ^ 5 if epoch and atom in DATA_CHANGED_RULES_2 else value |
|
|
| def fn_handle_2(kind, value): |
| return f"{kind}-{fn_digest_2(['event-ticketing-v3', kind, value])[:14]}" |
|
|
| def fn__task_fixture(task_id, *, post_drift=None): |
| if task_id not in DATA_STREAM_SCHEDULE: |
| raise ValueError(f'unknown stream task: {task_id}') |
| if post_drift is None: |
| post_drift = int(task_id[1:]) >= 9 |
| fixture = fn__build_fixture(task_id, DATA_STREAM_CLUSTERS, DATA_STREAM_SCHEDULE[task_id], post_drift=post_drift) |
| for (index, target) in enumerate(fixture['targets'], 1): |
| old_customer_id = target['customer_id'] |
| customer = next((row for row in fixture['entities']['customer'] if row['customer_id'] == old_customer_id)) |
| suffix = mod_hashlib.sha256(f'event-ticketing-customer|{task_id}|{index}|{old_customer_id}'.encode('utf-8')).hexdigest()[:8] |
| customer_id = f'{old_customer_id}-q{suffix}' |
| customer['customer_id'] = customer_id |
| customer['full_name'] = f'{DATA_STREAM_CUSTOMER_NAMES[index - 1]} Case {suffix.upper()}' |
| customer['email_address'] = f'{customer_id}@example.invalid' |
| target['customer_id'] = customer_id |
| fixture['public_targets'][index - 1]['customer_name'] = customer['full_name'] |
| fixture['public_targets'][index - 1]['customer_reference'] = customer_id |
| return fixture |
|
|
| def fn__canonical_hash(value): |
| payload = mod_json.dumps(value, sort_keys=True, separators=(',', ':'), ensure_ascii=False) |
| return mod_hashlib.sha256(payload.encode('utf-8')).hexdigest() |
|
|
| def fn_digest(value): |
| payload = mod_json.dumps(value, sort_keys=True, separators=(',', ':'), ensure_ascii=True) |
| return mod_hashlib.sha256(payload.encode('ascii')).hexdigest() |
|
|
| def fn__error(code, message, **data): |
| return {'status': 'error', 'data': {'error_code': code, **data}, 'message': message} |
|
|
| def fn__normalize_result(result): |
| normalized = ext_deepcopy(result) |
| if normalized.get('status') == 'error': |
| message = str(normalized.get('message') or '') |
| code = message.split(':', 1)[0] if ':' in message else 'OPERATION_FAILED' |
| normalized.setdefault('data', {})['error_code'] = code |
| return normalized |
|
|
| def fn_digest_2(value): |
| return mod_hashlib.sha256(mod_json.dumps(value, sort_keys=True, separators=(',', ':')).encode()).hexdigest() |
|
|
| def fn__build_fixture(task_id, clusters, target_pairs, *, post_drift=False): |
| entities: dict[str, list[dict[str, ext_Any]]] = {name: [] for name in DATA_ENTITY_ID_FIELDS} |
| venue_ids = [f"ven-{cluster['code']}" for cluster in clusters] |
| entities['operator'] = [{'operator_id': 'operator-dev-box-office', 'full_name': 'Development Box Office Operator', 'role': 'box_office_sales_operator', 'active': True, 'permission_scopes': ['orders:write', 'inventory:write'], 'venue_ids': venue_ids, 'created_at': '2026-05-27T12:00:00Z', 'updated_at': '2026-05-27T12:00:00Z'}] |
| target_set = set(target_pairs) |
| targets: list[dict[str, ext_Any]] = [] |
| public_targets: list[dict[str, ext_Any]] = [] |
| buyer_names = (('Mara Voss', 'Ilan Beck', 'Nia Cole', 'Oren Pike'), ('Tessa Wynn', 'Bram Vale', 'Cora Reed', 'Deni Moss')) |
| for (cluster_index, cluster) in enumerate(clusters): |
| code = cluster['code'] |
| atom_id = cluster['atom_id'] |
| venue_id = f'ven-{code}' |
| event_id = f'evt-{code}' |
| live_performance_id = f'pf-{code}-n7' |
| canceled_performance_id = f'pf-{code}-q2' |
| start = ext_datetime.fromisoformat(cluster['starts_at'].replace('Z', '+00:00')) |
| entities['venue'].append({'venue_id': venue_id, 'name': cluster['venue_name'], 'city': 'Test City', 'timezone': 'UTC', 'venue_type': 'theater', 'capacity': 16, 'status': 'active', 'created_at': '2026-05-27T12:00:00Z', 'updated_at': '2026-05-27T12:00:00Z'}) |
| entities['event'].append({'event_id': event_id, 'venue_id': venue_id, 'name': cluster['event_name'], 'event_kind': cluster['event_kind'], 'status': 'on_sale', 'sales_start_at': '2026-05-01T00:00:00Z', 'sales_end_at': '2026-06-30T23:59:59Z', 'starts_at': cluster['starts_at'], 'ends_at': (start + ext_timedelta(hours=3)).strftime('%Y-%m-%dT%H:%M:%SZ'), 'public_capacity': 16, 'inventory_released': 16, 'inventory_sold': 0, 'inventory_held': 0, 'gross_sales_amount': 0.0, 'refund_amount': 0.0, 'created_at': '2026-05-27T12:00:00Z', 'updated_at': '2026-05-27T12:00:00Z'}) |
| entities['performance'].extend([{'performance_id': canceled_performance_id, 'event_id': event_id, 'venue_id': venue_id, 'starts_at': (start - ext_timedelta(days=1)).strftime('%Y-%m-%dT%H:%M:%SZ'), 'ends_at': (start - ext_timedelta(days=1) + ext_timedelta(hours=3)).strftime('%Y-%m-%dT%H:%M:%SZ'), 'door_open_at': (start - ext_timedelta(days=1, hours=1)).strftime('%Y-%m-%dT%H:%M:%SZ'), 'status': 'canceled', 'capacity_override': None, 'created_at': '2026-05-27T12:00:00Z', 'updated_at': '2026-05-27T12:00:00Z'}, {'performance_id': live_performance_id, 'event_id': event_id, 'venue_id': venue_id, 'starts_at': cluster['starts_at'], 'ends_at': (start + ext_timedelta(hours=3)).strftime('%Y-%m-%dT%H:%M:%SZ'), 'door_open_at': (start - ext_timedelta(hours=1)).strftime('%Y-%m-%dT%H:%M:%SZ'), 'status': 'on_sale', 'capacity_override': None, 'created_at': '2026-05-27T12:00:00Z', 'updated_at': '2026-05-27T12:00:00Z'}]) |
| section_ids: list[str] = [] |
| for section_index in range(4): |
| section_id = f"sec-{code}-{('q', 'm', 'x', 'b')[section_index]}" |
| section_ids.append(section_id) |
| entities['venue_section'].append({'venue_section_id': section_id, 'venue_id': venue_id, 'section_code': f'Z{cluster_index + 1}{section_index + 1}', 'name': ('Gallery', 'Terrace', 'Parterre', 'Loge')[section_index], 'section_type': ('balcony', 'floor', 'orchestra', 'suite')[section_index], 'capacity': 4, 'pricing_rank': section_index + 1, 'status': 'active', 'created_at': '2026-05-27T12:00:00Z', 'updated_at': '2026-05-27T12:00:00Z'}) |
| for seat_number in range(1, 5): |
| seat_id = f'st-{code}-{section_index + 1}-{seat_number:02d}' |
| entities['seat'].append({'seat_id': seat_id, 'venue_id': venue_id, 'venue_section_id': section_id, 'row_label': chr(65 + section_index), 'seat_number': seat_number, 'seat_label': f'{chr(65 + section_index)}-{seat_number}', 'seat_type': 'standard', 'status': 'active', 'created_at': '2026-05-27T12:00:00Z', 'updated_at': '2026-05-27T12:00:00Z'}) |
| type_records: dict[str, dict[str, ext_Any]] = {} |
| tier_records: dict[str, dict[str, ext_Any]] = {} |
| for (ticket_index, ticket_kind) in enumerate(DATA_TICKET_KINDS): |
| section_id = section_ids[fn__section_index(cluster_index, ticket_index)] |
| tier_id = f"pr-{code}-{('u', 'c', 'r', 'k')[ticket_index]}" |
| ticket_type_id = f"tt-{code}-{('h', 's', 'v', 'g')[ticket_index]}" |
| tier = {'price_tier_id': tier_id, 'event_id': event_id, 'venue_section_id': section_id, 'name': f'Price Band {ticket_index + 1}', 'currency': 'USD', 'base_price': float(55 + ticket_index * 17 + cluster_index), 'service_fee_rate': 0.1, 'active': True, 'inventory_limit': 4, 'inventory_released': 4, 'inventory_sold': 0, 'inventory_held': 0, 'created_at': '2026-05-27T12:00:00Z', 'updated_at': '2026-05-27T12:00:00Z'} |
| ticket_type = {'ticket_type_id': ticket_type_id, 'event_id': event_id, 'price_tier_id': tier_id, 'name': f'Admission Class {ticket_index + 1}', 'ticket_kind': ticket_kind, 'sale_start_at': '2026-05-01T00:00:00Z', 'sale_end_at': '2026-06-30T23:59:59Z', 'inventory_limit': 4, 'released_quantity': 4, 'sold_quantity': 0, 'held_quantity': 0, 'per_order_limit': 4, 'refundable_until_hours': 24, 'status': 'active', 'created_at': '2026-05-27T12:00:00Z', 'updated_at': '2026-05-27T12:00:00Z'} |
| entities['price_tier'].append(tier) |
| entities['ticket_type'].append(ticket_type) |
| type_records[ticket_kind] = ticket_type |
| tier_records[ticket_kind] = tier |
| campaigns: dict[str, str] = {} |
| for (lane_index, lane) in enumerate(DATA_OFFER_LANES): |
| campaign_id = f'offer-{code}-{lane}' |
| campaigns[lane] = campaign_id |
| eligible = [row['ticket_type_id'] for (kind, row) in type_records.items() if fn__lane_for(cluster['event_kind'], kind, post_drift=post_drift) == lane] |
| entities['discount_campaign'].append({'discount_campaign_id': campaign_id, 'event_id': event_id, 'name': f'House Offer {lane.title()}', 'campaign_kind': ('early_bird', 'member_offer', 'group_bundle', 'promo_code')[lane_index], 'code': f'{code.upper()}{lane.upper()}' if lane_index in {1, 3} else None, 'discount_type': 'percent', 'discount_value': 10.0, 'starts_at': '2026-05-01T00:00:00Z', 'ends_at': '2026-06-30T23:59:59Z', 'status': 'active', 'ticket_type_ids': eligible, 'max_redemptions': 100, 'redemption_count': 0, 'min_quantity': 2, 'created_at': '2026-05-27T12:00:00Z', 'updated_at': '2026-05-27T12:00:00Z'}) |
| for (ticket_index, ticket_kind) in enumerate(DATA_TICKET_KINDS): |
| lane = fn__lane_for(cluster['event_kind'], ticket_kind, post_drift=post_drift) |
| policy_customer_id = f'policy-{code}-{ticket_index + 1}' |
| policy_name = f"Policy Sample {cluster['event_kind']} {ticket_kind.replace('_', ' ')}" |
| entities['customer'].append({'customer_id': policy_customer_id, 'full_name': policy_name, 'email_address': f'{policy_customer_id}@example.invalid', 'phone': f'+1666{cluster_index:02d}{ticket_index:02d}2000', 'loyalty_tier': 'standard', 'marketing_opt_in': False, 'blocked': False, 'created_at': '2026-05-01T10:00:00Z', 'updated_at': '2026-05-01T10:10:00Z'}) |
| historical_order_id = f'archive-{code}-{ticket_index + 1}' |
| historical_line_id = f'archive-line-{code}-{ticket_index + 1}' |
| entities['order'].append({'order_id': historical_order_id, 'customer_id': policy_customer_id, 'event_id': event_id, 'performance_id': live_performance_id, 'order_status': 'refunded', 'payment_status': 'refunded', 'sales_channel': 'box_office', 'subtotal_amount': 100.0, 'discount_amount': 10.0, 'fee_amount': 10.0, 'total_amount': 100.0, 'refunded_amount': 100.0, 'currency': 'USD', 'line_count': 1, 'ticket_count': 0, 'applied_campaign_ids': [campaigns[lane]], 'expires_at': None, 'created_at': '2026-05-01T10:00:00Z', 'updated_at': '2026-05-02T10:00:00Z'}) |
| entities['order_line'].append({'order_line_id': historical_line_id, 'order_id': historical_order_id, 'event_id': event_id, 'performance_id': live_performance_id, 'ticket_type_id': type_records[ticket_kind]['ticket_type_id'], 'price_tier_id': tier_records[ticket_kind]['price_tier_id'], 'venue_section_id': tier_records[ticket_kind]['venue_section_id'], 'quantity': 2, 'unit_price': tier_records[ticket_kind]['base_price'], 'fee_amount': 10.0, 'discount_amount': 10.0, 'line_total': 100.0, 'seat_ids': [], 'status': 'refunded', 'created_at': '2026-05-01T10:00:00Z', 'updated_at': '2026-05-02T10:00:00Z'}) |
| if (atom_id, ticket_kind) not in target_set: |
| continue |
| if task_id == 'DEV01': |
| customer_name = buyer_names[0][cluster_index] |
| else: |
| customer_name = f"{buyer_names[1][cluster_index % 4]} {atom_id} {ticket_kind.replace('_', ' ').title()}" |
| customer_id = f"cu-{code}-{('a', 'e', 'i', 'o')[ticket_index]}" |
| entities['customer'].append({'customer_id': customer_id, 'full_name': customer_name, 'email_address': f'{customer_id}@example.invalid', 'phone': f'+1555{cluster_index:02d}{ticket_index:02d}1000', 'loyalty_tier': ('standard', 'silver', 'gold', 'platinum')[ticket_index], 'marketing_opt_in': False, 'blocked': False, 'created_at': '2026-05-27T12:00:00Z', 'updated_at': '2026-05-27T12:00:00Z'}) |
| section_id = tier_records[ticket_kind]['venue_section_id'] |
| section_seats = [row['seat_id'] for row in entities['seat'] if row['venue_section_id'] == section_id and row['status'] == 'active'] |
| target_id = f'request-{task_id.lower()}-{len(targets) + 1}' |
| target = {'target_id': target_id, 'structure_atom': atom_id, 'rule_atom': fn_rule_id(cluster['event_kind'], ticket_kind), 'customer_id': customer_id, 'event_id': event_id, 'event_kind': cluster['event_kind'], 'performance_id': live_performance_id, 'ticket_type_id': type_records[ticket_kind]['ticket_type_id'], 'ticket_kind': ticket_kind, 'price_tier_id': tier_records[ticket_kind]['price_tier_id'], 'venue_id': venue_id, 'venue_section_id': section_id, 'quantity': 2, 'preferred_seat_ids': section_seats[:2], 'required_offer_lane': lane, 'required_campaign_id': campaigns[lane], 'campaign_ids_by_lane': ext_deepcopy(campaigns)} |
| targets.append(target) |
| public_targets.append({'target_id': target_id, 'customer_name': customer_name, 'event_name': cluster['event_name'], 'performance_starts_at': cluster['starts_at'], 'ticket_kind': ticket_kind, 'quantity': 2, 'offer_requirement': 'Apply the one currently eligible house offer before payment.'}) |
| if len(targets) != 4: |
| raise ValueError(f'{task_id} must compile exactly four targets') |
| return {'task_id': task_id, 'actor_user_id': 'operator-dev-box-office', 'entities': entities, 'targets': targets, 'public_targets': public_targets, 'post_drift': post_drift} |
|
|
| def fn__section_index(cluster_index, ticket_index): |
| return (cluster_index * 3 + ticket_index * 2) % 4 |
|
|
| def fn__lane_for(event_kind, ticket_kind, *, post_drift): |
| lane = DATA_RULE_LANES[event_kind][ticket_kind] |
| atom = fn_rule_id(event_kind, ticket_kind) |
| if post_drift and atom in DATA_DRIFT_CHANGED_RULES: |
| return DATA_OFFER_LANES[(DATA_OFFER_LANES.index(lane) + 1) % len(DATA_OFFER_LANES)] |
| return lane |
|
|
| def fn__initial_entities(): |
| fixture = fn__task_fixture('T01', post_drift=False) |
| target_customer_ids = {row['customer_id'] for row in fixture['targets']} |
| entities = ext_deepcopy(fixture['entities']) |
| entities['customer'] = [row for row in entities['customer'] if row['customer_id'] not in target_customer_ids] |
| for ticket_type in entities['ticket_type']: |
| ticket_type['inventory_limit'] = 16 |
| ticket_type['released_quantity'] = 16 |
| for tier in entities['price_tier']: |
| tier['inventory_limit'] = 16 |
| tier['inventory_released'] = 16 |
| for event in entities['event']: |
| event['public_capacity'] = 16 * len(DATA_TICKET_KINDS) |
| event['inventory_released'] = 16 * len(DATA_TICKET_KINDS) |
| for campaign in entities['discount_campaign']: |
| campaign['max_redemptions'] = 64 |
| sections = {row['venue_section_id']: row for row in entities['venue_section']} |
| existing = {row['seat_id'] for row in entities['seat']} |
| for (section_id, section) in sections.items(): |
| section['capacity'] = 20 |
| code = section_id.split('-')[1] |
| section_index = int(section['section_code'][-1]) |
| for seat_number in range(1, 20 + 1): |
| seat_id = f'st-{code}-{section_index}-{seat_number:02d}' |
| if seat_id in existing: |
| continue |
| entities['seat'].append({'seat_id': seat_id, 'venue_id': section['venue_id'], 'venue_section_id': section_id, 'row_label': chr(64 + section_index), 'seat_number': seat_number, 'seat_label': f'{chr(64 + section_index)}-{seat_number}', 'seat_type': 'standard', 'status': 'active', 'created_at': '2026-05-27T12:00:00Z', 'updated_at': '2026-05-27T12:00:00Z'}) |
| return entities |
|
|
| @lru_cache(**{'maxsize': 4, 'typed': False}) |
| def fn__load_raw_logic(source_root): |
| prefix = 'mcp_servers' |
| saved = {name: module for (name, module) in list(mod_sys.modules.items()) if name == prefix or name.startswith(f'{prefix}.')} |
| for name in saved: |
| mod_sys.modules.pop(name, None) |
| mod_sys.path.insert(0, source_root) |
| try: |
| module = mod_importlib.import_module('mcp_servers.ticketing_logic') |
| module.NOW = '2026-05-27T12:00:00Z' |
| module.now_iso = lambda : '2026-05-27T12:00:00Z' |
| finally: |
| mod_sys.path.remove(source_root) |
| for name in list(mod_sys.modules): |
| if name == prefix or name.startswith(f'{prefix}.'): |
| mod_sys.modules.pop(name, None) |
| mod_sys.modules.update(saved) |
| return module |
|
|
| class World: |
|
|
| def apply_event(self, event_id): |
| if event_id != 'E1' or event_id in self._applied_boundary_events: |
| return self._ticketing_evolution_apply_event(event_id) |
| before = self.business_hash() |
| receipt = self._ticketing_evolution_apply_event(event_id) |
| entities = self._state.list_snapshot() |
| events = {self._catalog[atom]['event_id'] for atom in DATA_MIGRATED_ATOMS} |
| mappings = {} |
| for (kind, field) in (('event', 'event_id'), ('performance', 'performance_id'), ('ticket_type', 'ticket_type_id')): |
| mappings[field] = {row[field]: fn_handle(kind, 'event-catalog-migration-evolution-v4' + ':' + row[field]) for row in entities[kind] if row['event_id'] in events} |
| self._state.restore(fn_rekey_entities(entities, mappings)) |
| self._catalog = {atom: fn_rekey_record(row, mappings) for (atom, row) in self._catalog.items()} |
| self._assert_inventory_invariants() |
| return {**receipt, 'before': before, 'after': self.business_hash(), 'catalog_identity_migrations': mappings} |
|
|
| def snapshot(self): |
| value = self._event_independent_world_snapshot() |
| value['catalog_migration_contract'] = 'event-catalog-migration-evolution-v4' |
| return value |
|
|
| def restore(self, snapshot): |
| if snapshot.get('catalog_migration_contract') != 'event-catalog-migration-evolution-v4': |
| raise ValueError('Event catalog migration snapshot identity differs') |
| self._event_independent_world_restore(snapshot) |
|
|
| def public_task(self): |
| packet = self._event_independent_world_public_task() |
| packet['operational_contract'] += ' ' + 'The top-level event_id in this task packet identifies the request batch, not an event in the ticket catalog. Tool parameters named event_id refer to catalog event records. Each requested performance is identified in the targets by its event_name and performance_starts_at.' |
| return packet |
|
|
| def _priority_guard(self, arguments): |
| return None |
|
|
| def _ensure_stream_capacity(self): |
| """Keep the repeated 16-task path feasible without changing read cost.""" |
| entities = self._state.list_snapshot() |
| for ticket_type in entities['ticket_type']: |
| ticket_type['inventory_limit'] = 64 |
| ticket_type['released_quantity'] = 64 |
| for tier in entities['price_tier']: |
| tier['inventory_limit'] = 64 |
| tier['inventory_released'] = 64 |
| for event in entities['event']: |
| event['public_capacity'] = 64 * len(DATA_TICKET_KINDS) |
| event['inventory_released'] = event['public_capacity'] |
| for venue in entities['venue']: |
| venue['capacity'] = 64 * len(DATA_TICKET_KINDS) |
| seats_by_section: dict[str, list[dict[str, ext_Any]]] = {} |
| for seat in entities['seat']: |
| seats_by_section.setdefault(seat['venue_section_id'], []).append(seat) |
| for section in entities['venue_section']: |
| section_id = section['venue_section_id'] |
| section['capacity'] = 64 |
| existing = seats_by_section.get(section_id, []) |
| if not existing: |
| raise RuntimeError(f'section {section_id} has no seat template') |
| template = min(existing, key=lambda row: int(row['seat_number'])) |
| occupied_numbers = {int(row['seat_number']) for row in existing} |
| for seat_number in range(1, 64 + 1): |
| if seat_number in occupied_numbers: |
| continue |
| row = ext_deepcopy(template) |
| row.update({'seat_id': fn_handle('seat', f'{section_id}:{seat_number}'), 'seat_number': seat_number, 'seat_label': f"{template['row_label']}-{seat_number}", 'status': 'active', 'created_at': '2026-05-27T12:00:00Z', 'updated_at': '2026-05-27T12:00:00Z'}) |
| entities['seat'].append(row) |
| self._state = MemoryState(entities) |
| self._assert_inventory_invariants() |
|
|
| def _activate_without_events(self, task_id, *, evaluator_apply_scheduled_drift=True): |
| if task_id != DATA_TASK_IDS[len(self._activated_tasks)]: |
| raise ValueError('task boundary must be sequential') |
| before = self.business_hash() |
| closed = self._close_pending() |
| drift = None |
| if task_id == 'T09' and evaluator_apply_scheduled_drift: |
| drift = self.apply_stream_drift() |
| self._task_id = task_id |
| self._task_targets = [] |
| for (position, (atom, ticket_kind)) in enumerate(DATA_SCHEDULE_2[task_id], 1): |
| cluster = self._catalog[atom] |
| customer_id = fn_handle('customer', f'{task_id}:{position}') |
| self._state.add_entity('customer', {'customer_id': customer_id, 'full_name': f"Ticket request {fn_handle('ref', f'{task_id}:{position}')}", 'email_address': f'{customer_id}@example.invalid', 'loyalty_tier': 'standard', 'blocked': False}, 'customer_id') |
| ticket = next((row for row in self._state.list_entities('ticket_type') if row['event_id'] == cluster['event_id'] and row['ticket_kind'] == ticket_kind)) |
| self._task_targets.append(self._active_target({'target_id': fn_handle('request', f'{task_id}:{position}'), 'structure_atom': atom, 'binding_atom': f'{atom}:{ticket_kind}', 'rule_atom': fn_rule_id(cluster['event_kind'], ticket_kind), 'customer_id': customer_id, 'event_id': cluster['event_id'], 'event_kind': cluster['event_kind'], 'performance_id': cluster['performance_id'], 'ticket_kind': ticket_kind, 'ticket_type_id': ticket['ticket_type_id'], 'venue_id': cluster['venue_id'], 'quantity': 2})) |
| self._calls = self._read_units = self._write_attempts = 0 |
| self._active_event_start = len(self._events) |
| self._activated_tasks.append(task_id) |
| receipt = {'task_id': task_id, 'before_sha256': before, 'after_sha256': self.business_hash(), 'closed_pending_orders': closed, 'drift': drift} |
| self._boundary_receipts_v4.append(receipt) |
| return ext_deepcopy(receipt) |
|
|
| def __init__(self, **kwargs): |
| self._own_finalizations = {} |
| self._ticketing_init(**kwargs) |
|
|
| def activate_task(self, task_id, **kwargs): |
| if self._task_id == task_id: |
| return ext_deepcopy(self._boundary_receipts_v4[-1]) |
| if len(self._activated_tasks) >= len(DATA_TASK_IDS) or task_id != DATA_TASK_IDS[len(self._activated_tasks)]: |
| raise ValueError('event-ticketing task prefix differs') |
| before = self.business_hash() |
| closed = self._close_pending() |
| drift = None |
| for event in DATA_SCHEDULE_3['events']: |
| if int(task_id[1:]) == event['before_task']: |
| drift = self.apply_event(event['event_id']) |
| receipt = self._activate_without_events(task_id, evaluator_apply_scheduled_drift=False) |
| receipt.update(before_sha256=before, closed_pending_orders=closed, drift=drift) |
| self._boundary_receipts_v4[-1] = ext_deepcopy(receipt) |
| self._own_finalizations = {} |
| return receipt |
|
|
| def dispatch(self, name, arguments, actor_user_id='operator-dev-box-office'): |
| if name == 'get_order' and isinstance(arguments, dict) and (set(arguments) == {'order_id'}) and isinstance(arguments['order_id'], str) and (arguments['order_id'] in self._own_finalizations) and (self._own_finalizations[arguments['order_id']]['actor'] == actor_user_id): |
| return {'status': 'success', 'data': {'confirmation_only': True, 'completion_receipt': ext_deepcopy(self._own_finalizations[arguments['order_id']]['receipt'])}, 'budget': self._budget()} |
| result = self._ticketing_dispatch(name, arguments, actor_user_id) |
| if result.get('status') == 'success' and name == 'finalize_order_to_tickets': |
| self._own_finalizations[arguments['order_id']] = {'actor': actor_user_id, 'receipt': ext_deepcopy(result)} |
| elif result.get('status') == 'success' and name in DATA_WRITE_TOOLS: |
| self._own_finalizations.pop(arguments.get('order_id'), None) |
| return result |
|
|
| def _read(self, name, arguments): |
| if name == 'list_ticket_types': |
| return World._ticketing_read(self, name, ext_deepcopy(arguments)) |
| if name != 'read_offer_terms': |
| return self._ticketing_read_2(name, arguments) |
| atom = fn_rule_id(arguments['event_kind'], arguments['ticket_kind']) |
| row = fn_profile(fn_rule_index(atom, self._epoch)) |
| fields = ('audience_certificate', 'redemption_channel') if arguments['document'] == 'audience_eligibility' else ('reimbursement_cycle',) |
| return {'status': 'success', 'data': {'document': {'document_id': fn_handle('terms', f"{atom}:{arguments['document']}:{self._epoch}"), 'issuing_authority': 'Audience admission office' if len(fields) == 2 else 'Promoter accounts payable', 'scope': {'event_kind': arguments['event_kind'], 'ticket_kind': arguments['ticket_kind']}, 'requirements': {field: row[field] for field in fields}, 'authority': 'current commercial contract'}}} |
|
|
| def _after_read(self, name, arguments, result): |
| if result.get('status') == 'success': |
| if name == 'list_ticket_types': |
| key = self._binding_key_for_arguments(arguments) |
| if key and self.structure_revalidation.get(key) == 'awaiting_exact_stale': |
| self.structure_revalidation[key] = 'awaiting_fresh_binding' |
| elif name == 'read_offer_terms': |
| atom = fn_rule_id(arguments['event_kind'], arguments['ticket_kind']) |
| if self.rule_revalidation.get(atom) == 'awaiting_exact_stale': |
| self.rule_revalidation[atom] = 'awaiting_fresh_terms' |
| self._ticketing_after_read(name, arguments, result) |
|
|
| def _budget(self): |
| return {'read_work_units_used': self._read_units, 'read_work_units_remaining': max(0, 25 - self._read_units), 'write_attempts_used': self._write_attempts, 'write_attempts_remaining': max(0, 22 - self._write_attempts)} |
|
|
| def public_tool_schemas(self, role): |
| return ext_deepcopy(DATA_TOOLS_2) if role == 'box_office_sales_operator' else [] |
|
|
| def apply_stream_drift(self, event_id='ticketing-commercial-catalog-update-v4'): |
| if event_id in self._applied_boundary_events: |
| return {'status': 'success', 'idempotent': True} |
| archived_before = [ext_deepcopy(row) for row in self._state.list_entities('order') if row['order_id'].startswith('archive-')] |
| for key in DATA_CHANGED_BINDINGS: |
| (atom, ticket_kind) = key.split(':') |
| event_id_value = self._catalog[atom]['event_id'] |
| ticket = next((row for row in self._state.list_entities('ticket_type') if row['event_id'] == event_id_value and row['ticket_kind'] == ticket_kind)) |
| tiers = [row for row in self._state.list_entities('price_tier') if row['event_id'] == event_id_value] |
| old_index = next((index for (index, row) in enumerate(tiers) if row['price_tier_id'] == ticket['price_tier_id'])) |
| old_tier = tiers[old_index] |
| new_tier = tiers[(old_index + 1) % len(tiers)] |
| self._stale_bindings[key] = {'event_id': event_id_value, 'ticket_kind': ticket_kind, 'ticket_type_id': ticket['ticket_type_id'], 'price_tier_id': old_tier['price_tier_id'], 'venue_section_id': old_tier['venue_section_id'], 'replacement_price_tier_id': new_tier['price_tier_id'], 'replacement_venue_section_id': new_tier['venue_section_id']} |
| self._state.update_entity('ticket_type', ticket['ticket_type_id'], {'price_tier_id': new_tier['price_tier_id']}, 'ticket_type_id') |
| self.structure_revalidation[key] = 'awaiting_exact_stale' |
| self._epoch = 1 |
| for cluster in self._catalog.values(): |
| ticket_types = [row for row in self._state.list_entities('ticket_type') if row['event_id'] == cluster['event_id']] |
| for campaign in self._state.list_entities('discount_campaign'): |
| if campaign['event_id'] != cluster['event_id'] or 'offer_profile_id' not in campaign: |
| continue |
| eligible = [row['ticket_type_id'] for row in ticket_types if fn_profile(fn_rule_index(fn_rule_id(cluster['event_kind'], row['ticket_kind']), 1))['offer_profile_id'] == campaign['offer_profile_id']] |
| self._state.update_entity('discount_campaign', campaign['discount_campaign_id'], {'ticket_type_ids': eligible}, 'discount_campaign_id') |
| for atom in DATA_CHANGED_RULES: |
| self.rule_revalidation[atom] = 'awaiting_exact_stale' |
| self.rule_documents_seen[atom] = set() |
| self._applied_boundary_events.add(event_id) |
| archived_after = [row for row in self._state.list_entities('order') if row['order_id'].startswith('archive-')] |
| return {'status': 'success', 'idempotent': False, 'historical_transactions_unchanged': archived_before == archived_after} |
|
|
| def _binding_key_for_arguments(self, arguments): |
| event_id = arguments.get('event_id') |
| ticket_kind = arguments.get('ticket_kind') |
| return next((key for (key, stale) in self._stale_bindings.items() if stale['event_id'] == event_id and stale['ticket_kind'] == ticket_kind), None) |
|
|
| def _target_for_order(self, order_id): |
| order = self._state.get_entity('order', order_id, 'order_id') if order_id else None |
| if order is None: |
| return None |
| return next((target for target in self._task_targets if target['customer_id'] == order.get('customer_id') and target['event_id'] == order.get('event_id') and (target['performance_id'] == order.get('performance_id'))), None) |
|
|
| def _build_catalog(self): |
| entities = self._state.list_snapshot() |
| campaign_templates = {row['event_id']: ext_deepcopy(row) for row in entities['discount_campaign']} |
| historical_campaigns = ext_deepcopy(entities['discount_campaign']) |
| for row in historical_campaigns: |
| row['status'] = 'expired' |
| row['ticket_type_ids'] = [] |
| entities['discount_campaign'] = historical_campaigns |
| for cluster in DATA_STREAM_CLUSTERS: |
| code = cluster['code'] |
| event_id = f'evt-{code}' |
| types = [x for x in entities['ticket_type'] if x['event_id'] == event_id] |
| tiers = [x for x in entities['price_tier'] if x['event_id'] == event_id] |
| sections = [x for x in entities['venue_section'] if x['venue_id'] == f'ven-{code}'] |
| for (i, row) in enumerate(tiers): |
| row['venue_section_id'] = sections[i]['venue_section_id'] |
| row['inventory_limit'] = row['inventory_released'] = 20 |
| for row in types: |
| row['inventory_limit'] = row['released_quantity'] = 20 |
| event = next((x for x in entities['event'] if x['event_id'] == event_id)) |
| event['public_capacity'] = event['inventory_released'] = 80 |
| next((x for x in entities['venue'] if x['venue_id'] == f'ven-{code}'))['capacity'] = 80 |
| for i in range(8): |
| row = ext_deepcopy(campaign_templates[event_id]) |
| row.update(fn_profile(i)) |
| row.update({'discount_campaign_id': f'commercial-{code}-{i}', 'name': 'House commercial offer', 'status': 'active', 'code': None, 'max_redemptions': 256, 'redemption_count': 0}) |
| row['ticket_type_ids'] = [x['ticket_type_id'] for x in types if fn_rule_index_2(fn_rule_id(cluster['event_kind'], x['ticket_kind']), 0) == i] |
| entities['discount_campaign'].append(row) |
| ids = {} |
| for (entity, rows) in entities.items(): |
| if entity in {'customer', 'operator', 'order', 'order_line', 'audit_log'}: |
| continue |
| id_field = {'venue_section': 'venue_section_id', 'discount_campaign': 'discount_campaign_id'}.get(entity, f'{entity}_id') |
| for row in rows: |
| if id_field in row: |
| ids[row[id_field]] = fn_handle_2(entity, row[id_field]) |
|
|
| def renamed(value): |
| if isinstance(value, str): |
| return ids.get(value, value) |
| if isinstance(value, list): |
| return [renamed(x) for x in value] |
| if isinstance(value, dict): |
| return {k: renamed(v) for (k, v) in value.items()} |
| return value |
| entities = renamed(entities) |
| self._state = MemoryState(entities) |
| for cluster in DATA_STREAM_CLUSTERS: |
| self._catalog[cluster['atom_id']] = {**cluster, 'event_id': ids[f"evt-{cluster['code']}"], 'venue_id': ids[f"ven-{cluster['code']}"], 'performance_id': ids[f"pf-{cluster['code']}-n7"]} |
|
|
| def _close_pending(self): |
| closed = [] |
| for order in list(self._state.list_entities('order')): |
| if order['order_status'] not in {'draft', 'pending_payment'}: |
| continue |
| for line in list(self._state.list_entities('order_line')): |
| if line['order_id'] != order['order_id'] or line['status'] in {'canceled', 'refunded'}: |
| continue |
| quantity = int(line['quantity']) |
| for (entity, key, held) in (('event', 'event_id', 'inventory_held'), ('ticket_type', 'ticket_type_id', 'held_quantity'), ('price_tier', 'price_tier_id', 'inventory_held')): |
| record = self._state.get_entity(entity, line[key], key) |
| self._state.update_entity(entity, line[key], {held: int(record[held]) - quantity}, key) |
| self._state.update_entity('order_line', line['order_line_id'], {'status': 'canceled'}, 'order_line_id') |
| self._state.update_entity('order', order['order_id'], {'order_status': 'canceled'}, 'order_id') |
| closed.append(order['order_id']) |
| self._assert_inventory_invariants() |
| return closed |
|
|
| def grade(self, task_id): |
| full = self._event_ticketing_adapter_grade(task_id) |
| entities = self._state.list_snapshot() |
| for (target, grade) in zip(self._task_targets, full['deliverables'], strict=True): |
| orders = [x for x in entities['order'] if x.get('customer_id') == target['customer_id'] and x.get('event_id') == target['event_id'] and (x.get('performance_id') == target['performance_id']) and (x.get('order_status') != 'canceled')] |
| lines = [x for x in entities['order_line'] if any((o['order_id'] == x['order_id'] for o in orders)) and x.get('ticket_type_id') == target['ticket_type_id'] and (x.get('venue_section_id') == target['venue_section_id']) and (x.get('quantity') == 2) and (x.get('status') not in {'canceled', 'refunded'})] |
| seated = [x for x in lines if x.get('status') == 'confirmed' and len(set(x.get('seat_ids', []))) == 2] |
| offer = any((target['required_campaign_id'] in x.get('applied_campaign_ids', []) for x in orders)) and bool(seated) |
| duplicate = sum((x.get('order_status') == 'paid' for x in orders)) > 1 |
| complete = grade['score'] == 25 and (not duplicate) |
| grade.update({'registered_order': bool(orders), 'inventory_held': bool(lines), 'seats_bound': bool(seated), 'eligible_offer_applied': offer, 'complete': complete, 'conflicting_duplicate': duplicate}) |
| grade['score'] = 0.0 if duplicate else 25.0 if complete else float(bool(orders)) + 2.0 * bool(lines) + 5.0 * bool(seated) + 2.0 * offer |
| full['score'] = sum((x['score'] for x in full['deliverables'])) |
| full['completed_artifacts'] = sum((x['complete'] for x in full['deliverables'])) |
| return full |
|
|
| def _activate_without_drift(self, task_id): |
| if task_id != 'T09': |
| raise ValueError('counterfactual activation is defined only at T09') |
| expected = DATA_TASK_IDS_2[len(self._activated_tasks)] |
| if task_id != expected: |
| raise ValueError(f'expected {expected}, got {task_id}') |
| fixture = fn__task_fixture(task_id, post_drift=False) |
| fixture_customers = {row['customer_id']: row for row in fixture['entities']['customer']} |
| targets = [] |
| for fixture_target in fixture['targets']: |
| customer = fixture_customers[fixture_target['customer_id']] |
| if self._state.get_entity('customer', customer['customer_id'], 'customer_id') is None: |
| self._state.add_entity('customer', customer, 'customer_id') |
| targets.append(self._active_target(fixture_target)) |
| self._task_id = task_id |
| self._task_targets = targets |
| self._calls = 0 |
| self._read_units = 0 |
| self._write_attempts = 0 |
| self._active_event_start = len(self._events) |
| self._activated_tasks.append(task_id) |
| return {'status': 'success', 'task_id': task_id, 'world_reset': False, 'budget_reset': True, 'boundary_event_applied': False, 'entry_business_hash': self.business_hash(), 'entry_lineage_hash': self.lineage_hash(), 'counterfactual_pre_event': True} |
|
|
| @property |
| def activated_tasks(self): |
| return tuple(self._activated_tasks) |
|
|
| @property |
| def applied_boundary_events(self): |
| return frozenset(self._applied_boundary_events) |
|
|
| @property |
| def remaining(self): |
| return self._budget() |
|
|
| def business_hash(self): |
| return self._business_hash() |
|
|
| def lineage_hash(self): |
| return fn__canonical_hash(self.snapshot()) |
|
|
| def _apply_drift(self, event_id='evt-ticket-policy-and-binding-2026-07-v2'): |
| if event_id in self._applied_boundary_events: |
| return {'status': 'success', 'idempotent': True, 'changed': []} |
| changed: list[str] = [] |
| for cluster in DATA_STREAM_CLUSTERS: |
| code = cluster['code'] |
| event_id_value = f'evt-{code}' |
| section_ids = sorted((row['venue_section_id'] for row in self._state.list_entities('venue_section') if row['venue_id'] == f'ven-{code}')) |
| for (ticket_index, ticket_kind) in enumerate(DATA_TICKET_KINDS): |
| atom = fn_rule_id(cluster['event_kind'], ticket_kind) |
| ticket_type_id = f"tt-{code}-{('h', 's', 'v', 'g')[ticket_index]}" |
| if atom in DATA_DRIFT_CHANGED_RULES: |
| old_lane = DATA_RULE_LANES[cluster['event_kind']][ticket_kind] |
| new_lane = DATA_OFFER_LANES[(DATA_OFFER_LANES.index(old_lane) + 1) % len(DATA_OFFER_LANES)] |
| for campaign in self._state.list_entities('discount_campaign'): |
| if campaign['event_id'] != event_id_value: |
| continue |
| eligible = [value for value in campaign.get('ticket_type_ids', []) if value != ticket_type_id] |
| if campaign['discount_campaign_id'] == f'offer-{code}-{new_lane}': |
| eligible.append(ticket_type_id) |
| self._state.update_entity('discount_campaign', campaign['discount_campaign_id'], {'ticket_type_ids': sorted(set(eligible)), 'updated_at': '2026-05-27T12:00:00Z'}, 'discount_campaign_id') |
| archive_id = f'archive-{code}-{ticket_index + 1}' |
| self._state.update_entity('order', archive_id, {'applied_campaign_ids': [f'offer-{code}-{new_lane}'], 'updated_at': '2026-05-27T12:00:00Z'}, 'order_id') |
| changed.append(atom) |
| if cluster['atom_id'] in DATA_DRIFT_CHANGED_STRUCTURES: |
| ticket_type = self._state.get_entity('ticket_type', ticket_type_id, 'ticket_type_id') |
| tier = self._state.get_entity('price_tier', ticket_type['price_tier_id'], 'price_tier_id') |
| current_index = section_ids.index(tier['venue_section_id']) |
| new_section_id = section_ids[(current_index + 1) % len(section_ids)] |
| self._state.update_entity('price_tier', tier['price_tier_id'], {'venue_section_id': new_section_id, 'updated_at': '2026-05-27T12:00:00Z'}, 'price_tier_id') |
| if cluster['atom_id'] in DATA_DRIFT_CHANGED_STRUCTURES: |
| changed.append(cluster['atom_id']) |
| self._applied_boundary_events.add(event_id) |
| return {'status': 'success', 'idempotent': False, 'changed': sorted(set(changed))} |
|
|
| def _active_target(self, fixture_target): |
| target = ext_deepcopy(fixture_target) |
| ticket_type = self._state.get_entity('ticket_type', target['ticket_type_id'], 'ticket_type_id') |
| tier = self._state.get_entity('price_tier', ticket_type['price_tier_id'], 'price_tier_id') |
| target['price_tier_id'] = tier['price_tier_id'] |
| target['venue_section_id'] = tier['venue_section_id'] |
| campaigns = [row for row in self._state.list_entities('discount_campaign') if row['event_id'] == target['event_id'] and target['ticket_type_id'] in set(row.get('ticket_type_ids') or [])] |
| if len(campaigns) != 1: |
| raise AssertionError(f"expected one eligible campaign for {target['target_id']}") |
| target['required_campaign_id'] = campaigns[0]['discount_campaign_id'] |
| target['required_offer_lane'] = campaigns[0]['discount_campaign_id'].rsplit('-', 1)[-1] |
| target['preferred_seat_ids'] = self.available_seat_ids(target)[:target['quantity']] |
| if len(target['preferred_seat_ids']) != target['quantity']: |
| raise RuntimeError(f"insufficient seats for {target['target_id']}") |
| return target |
|
|
| def available_seat_ids(self, target): |
| assigned = {seat_id for line in self._state.list_entities('order_line') if line.get('performance_id') == target['performance_id'] and line.get('status') not in {'canceled', 'refunded'} for seat_id in line.get('seat_ids') or []} |
| assigned.update((row.get('seat_id') for row in self._state.list_entities('ticket') if row.get('performance_id') == target['performance_id'] and row.get('ticket_status') in {'issued', 'transferred'})) |
| return sorted((row['seat_id'] for row in self._state.list_entities('seat') if row['venue_section_id'] == target['venue_section_id'] and row.get('status') == 'active' and (row['seat_id'] not in assigned))) |
|
|
| def current_episode_events(self): |
| return ext_deepcopy(self._events[self._active_event_start:]) |
|
|
| def semantic_hash(self, snapshot=None): |
| return fn__canonical_hash(snapshot if snapshot is not None else self.snapshot()) |
|
|
| def business_events(self, since=0): |
| if not isinstance(since, int) or isinstance(since, bool) or since < 0: |
| raise ValueError('since must be a non-negative integer') |
| return ext_deepcopy(self._events[since:]) |
|
|
| def task_targets(self): |
| return ext_deepcopy(self._task_targets) |
|
|
| def _actor(self, actor_user_id): |
| actor = self._state.get_entity('operator', actor_user_id, 'operator_id') |
| if not actor or not actor.get('active', True) or actor.get('role') != 'box_office_sales_operator': |
| return None |
| return actor |
|
|
| def _event(self, event_id): |
| return self._state.get_entity('event', event_id, 'event_id') if event_id else None |
|
|
| def _target_venue(self, name, arguments): |
| if name == 'get_venue_seating_chart': |
| return arguments.get('venue_id') |
| if name in {'list_performances', 'list_ticket_types', 'list_price_tiers', 'get_event_sales_dashboard', 'create_order'}: |
| event = self._event(arguments.get('event_id')) |
| return event.get('venue_id') if event else None |
| if name in {'add_order_line', 'apply_discount_to_order', 'finalize_order_to_tickets'}: |
| order = self._state.get_entity('order', arguments.get('order_id'), 'order_id') |
| event = self._event(order.get('event_id')) if order else None |
| return event.get('venue_id') if event else None |
| if name == 'assign_seats_to_order_line': |
| line = self._state.get_entity('order_line', arguments.get('order_line_id'), 'order_line_id') |
| event = self._event(line.get('event_id')) if line else None |
| return event.get('venue_id') if event else None |
| return None |
|
|
| def _business_hash(self): |
| return fn__canonical_hash(self._state.list_snapshot()) |
|
|
| @staticmethod |
| def _read_cost(name, result): |
| if result.get('status') != 'success': |
| return 1 |
| data = result.get('data') or {} |
| if name == 'list_events': |
| return 1 + len(data.get('events') or []) |
| if name == 'list_performances': |
| return 1 + len(data.get('performances') or []) |
| if name == 'list_ticket_types': |
| return 1 + len(data.get('ticket_types') or []) |
| if name == 'list_price_tiers': |
| return 1 + len(data.get('price_tiers') or []) |
| if name == 'search_customers': |
| return 1 + len(data.get('customers') or []) |
| if name == 'get_customer_orders': |
| return 1 + len(data.get('orders') or []) |
| if name == 'get_venue_seating_chart': |
| sections = data.get('sections') or [] |
| return 1 + len(sections) + sum((len(row.get('seats') or []) for row in sections)) |
| if name == 'get_event_sales_dashboard': |
| return 1 + len(data.get('campaigns') or []) |
| if name == 'get_order': |
| return 5 + len(data.get('lines') or []) + len(data.get('tickets') or []) + len(data.get('refunds') or []) |
| return 1 |
|
|
| def _record_event(self, name, actor_user_id, result, before_hash, after_hash, cost): |
| self._events.append({'sequence': len(self._events) + 1, 'channel': 'learner', 'tool': name, 'actor_user_id': actor_user_id, 'status': result.get('status'), 'error_code': result.get('data', {}).get('error_code'), 'cost': cost, 'budget_after': self._budget(), 'state_hash_before': before_hash, 'state_hash_after': after_hash}) |
|
|
| def _assert_inventory_invariants(self): |
| ticket_types = self._state.list_entities('ticket_type') |
| tiers = self._state.list_entities('price_tier') |
| events = self._state.list_entities('event') |
| for row in ticket_types: |
| held = int(row.get('held_quantity') or 0) |
| sold = int(row.get('sold_quantity') or 0) |
| released = int(row.get('released_quantity') or 0) |
| if min(held, sold) < 0 or held + sold > released: |
| raise ValueError('ticket-type inventory invariant failed') |
| for row in tiers: |
| held = int(row.get('inventory_held') or 0) |
| sold = int(row.get('inventory_sold') or 0) |
| released = int(row.get('inventory_released') or 0) |
| if min(held, sold) < 0 or held + sold > released: |
| raise ValueError('price-tier inventory invariant failed') |
| for event in events: |
| event_types = [row for row in ticket_types if row.get('event_id') == event['event_id']] |
| event_tiers = [row for row in tiers if row.get('event_id') == event['event_id']] |
| held = int(event.get('inventory_held') or 0) |
| sold = int(event.get('inventory_sold') or 0) |
| if min(held, sold) < 0 or held + sold > int(event.get('public_capacity') or 0): |
| raise ValueError('event inventory invariant failed') |
| if held != sum((int(row.get('held_quantity') or 0) for row in event_types)): |
| raise ValueError('event and ticket-type held counters diverged') |
| if sold != sum((int(row.get('sold_quantity') or 0) for row in event_types)): |
| raise ValueError('event and ticket-type sold counters diverged') |
| if held != sum((int(row.get('inventory_held') or 0) for row in event_tiers)): |
| raise ValueError('event and price-tier held counters diverged') |
| if sold != sum((int(row.get('inventory_sold') or 0) for row in event_tiers)): |
| raise ValueError('event and price-tier sold counters diverged') |
|
|
| def _ticketing_evolution_apply_event(self, event_id): |
| if event_id not in {'E1', 'E2'}: |
| raise ValueError('unknown event-ticketing event') |
| before = self.business_hash() |
| if event_id in self._applied_boundary_events: |
| return {'event_id': event_id, 'applied': False, 'before': before, 'after': before} |
| if event_id == 'E1': |
| for binding in DATA_CHANGED_BINDINGS: |
| (atom, kind) = binding.split(':') |
| eid = self._catalog[atom]['event_id'] |
| ticket = next((t for t in self._state.list_entities('ticket_type') if t['event_id'] == eid and t['ticket_kind'] == kind)) |
| tiers = [t for t in self._state.list_entities('price_tier') if t['event_id'] == eid] |
| index = next((i for (i, t) in enumerate(tiers) if t['price_tier_id'] == ticket['price_tier_id'])) |
| self._state.update_entity('ticket_type', ticket['ticket_type_id'], {'price_tier_id': tiers[(index + 1) % len(tiers)]['price_tier_id']}, 'ticket_type_id') |
| else: |
| if 'E1' not in self._applied_boundary_events: |
| raise ValueError('event-ticketing events must be applied in order') |
| self._epoch = 1 |
| for cluster in self._catalog.values(): |
| tickets = [t for t in self._state.list_entities('ticket_type') if t['event_id'] == cluster['event_id']] |
| for campaign in self._state.list_entities('discount_campaign'): |
| if campaign['event_id'] != cluster['event_id'] or 'offer_profile_id' not in campaign: |
| continue |
| eligible = [t['ticket_type_id'] for t in tickets if fn_profile(fn_rule_index(fn_rule_id(cluster['event_kind'], t['ticket_kind']), 1))['offer_profile_id'] == campaign['offer_profile_id']] |
| self._state.update_entity('discount_campaign', campaign['discount_campaign_id'], {'ticket_type_ids': eligible}, 'discount_campaign_id') |
| self._applied_boundary_events.add(event_id) |
| self._assert_inventory_invariants() |
| return {'event_id': event_id, 'applied': True, 'before': before, 'after': self.business_hash()} |
|
|
| def _event_independent_world_snapshot(self): |
| value = self._ticketing_evolution_snapshot() |
| value['independent_purchase_contract'] = 'event-independent-purchases-evolution-v2' |
| return value |
|
|
| def _event_independent_world_restore(self, snapshot): |
| if snapshot.get('independent_purchase_contract') != 'event-independent-purchases-evolution-v2': |
| raise ValueError('Event independent purchase contract differs') |
| self._ticketing_evolution_restore(snapshot) |
|
|
| def _event_independent_world_public_task(self): |
| packet = self._ticketing_evolution_public_task() |
| if packet['objective'].count('Complete policy-compliant ticket purchases in listed priority order. A later request cannot be committed until every earlier request is complete.') != 1: |
| raise ValueError('Parent Event ordering text differs') |
| packet['objective'] = packet['objective'].replace('Complete policy-compliant ticket purchases in listed priority order. A later request cannot be committed until every earlier request is complete.', 'Complete policy-compliant ticket purchases in any order. An unfinished customer request does not block an unrelated purchase.') |
| packet['completion'].update(mode='independent', priority_order='none', started_item_must_close=False) |
| return packet |
|
|
| def _ticketing_init(self, source_root=CASE_DIR / 'raw', snapshot=None): |
| self._ticketing_init_2(source_root, snapshot=None) |
| self._ensure_stream_capacity() |
| self.structure_revalidation: dict[str, str] = {} |
| self.rule_revalidation: dict[str, str] = {} |
| self.rule_documents_seen: dict[str, set[str]] = {} |
| self._stale_bindings: dict[str, dict[str, str]] = {} |
| self._boundary_receipts_v4: list[dict[str, ext_Any]] = [] |
| if snapshot is not None: |
| self.restore(snapshot) |
|
|
| def _ticketing_dispatch(self, name, arguments, actor_user_id='operator-dev-box-office'): |
| if self._task_id is None: |
| return fn__error('TASK_NOT_ACTIVE', 'no active request event') |
| if name not in DATA_TOOLS_BY_NAME or self._actor(actor_user_id) is None: |
| return fn__error('TOOL_NOT_ALLOWED', 'tool or actor is not authorized') |
| try: |
| mod_jsonschema.validate(arguments, DATA_TOOLS_BY_NAME[name]['input_schema']) |
| except mod_jsonschema.ValidationError: |
| return fn__error('INVALID_ARGUMENTS', 'arguments do not match the public schema') |
| write = name in DATA_WRITE_TOOLS |
| if self._calls >= 96 or (self._write_attempts >= 22 if write else self._read_units >= 25): |
| return {**fn__error('WRITE_BUDGET_EXHAUSTED' if write else 'READ_BUDGET_EXHAUSTED', 'the work allowance is exhausted'), 'budget': self._budget()} |
| before = self._state.list_snapshot() |
| before_hash = self.business_hash() |
| args = ext_deepcopy(arguments) |
| target = None |
| stale_binding = False |
| stale_rule = False |
| selected_profile = args.get('offer_profile_id') |
| try: |
| if write: |
| result = None |
| if name == 'create_order': |
| result = self._priority_guard(args) |
| if name in {'add_order_line', 'apply_discount_to_order'}: |
| target = self._target_for_order(args.get('order_id')) |
| if target is not None and name == 'add_order_line': |
| key = target['binding_atom'] |
| stale = self._stale_bindings.get(key, {}) |
| stale_binding = bool(self.structure_revalidation.get(key) == 'awaiting_exact_stale' and args.get('ticket_type_id') == stale.get('ticket_type_id') and (args.get('venue_section_id') == stale.get('venue_section_id'))) |
| if target is not None and name == 'apply_discount_to_order': |
| atom = target['rule_atom'] |
| stale_rule = bool(self.rule_revalidation.get(atom) == 'awaiting_exact_stale' and selected_profile == fn_profile(fn_rule_index(atom, 0))['offer_profile_id']) |
| if result is None: |
| if name == 'apply_discount_to_order' and 'offer_profile_id' in args: |
| selected = args.pop('offer_profile_id') |
| order = self._state.get_entity('order', args['order_id'], 'order_id') |
| matches = [row for row in self._state.list_entities('discount_campaign') if order and row['event_id'] == order['event_id'] and (row.get('offer_profile_id') == selected) and (row['status'] == 'active')] |
| args['discount_campaign_id'] = matches[0]['discount_campaign_id'] if len(matches) == 1 else selected |
| if name in {'assign_seats_to_order_line', 'apply_discount_to_order', 'finalize_order_to_tickets'}: |
| args['operator_id'] = actor_user_id |
| result = self._logic.execute_tool(name, self._state, **args) |
| if result.get('status') == 'success': |
| self._assert_inventory_invariants() |
| else: |
| result = self._read(name, args) |
| except Exception: |
| self._state.restore(before) |
| raise |
| result = fn__normalize_result(result) |
| if stale_binding and result.get('status') == 'error': |
| result = fn__error('SECTION_PRICE_TIER_MISMATCH', 'ticket type and venue section do not match the current catalog binding') |
| self.structure_revalidation[target['binding_atom']] = 'awaiting_fresh_binding' |
| if stale_rule and result.get('status') == 'error': |
| result = fn__error('NO_ELIGIBLE_LINES', 'the selected house offer is not eligible for the current order lines') |
| self.rule_revalidation[target['rule_atom']] = 'awaiting_fresh_terms' |
| self.rule_documents_seen[target['rule_atom']] = set() |
| cost = {'read_work_units': 0, 'write_attempts': int(write)} |
| if write: |
| self._write_attempts += 1 |
| if result.get('status') != 'success': |
| self._state.restore(before) |
| elif target is not None and name == 'add_order_line': |
| key = target['binding_atom'] |
| if self.structure_revalidation.get(key) == 'ready_current': |
| self.structure_revalidation[key] = 'validated_current' |
| elif target is not None and name == 'apply_discount_to_order': |
| atom = target['rule_atom'] |
| if self.rule_revalidation.get(atom) == 'ready_current': |
| self.rule_revalidation[atom] = 'validated_current' |
| else: |
| units = 2 if name == 'read_offer_terms' and result.get('status') == 'success' else self._read_cost(name, result) |
| remaining = 25 - self._read_units |
| cost['read_work_units'] = min(units, remaining) |
| self._read_units += cost['read_work_units'] |
| if units > remaining: |
| result = fn__error('READ_BUDGET_EXHAUSTED', 'read exceeds the remaining returned work', required_units=units, available_units=remaining) |
| else: |
| self._after_read(name, arguments, result) |
| self._calls += 1 |
| result['budget'] = self._budget() |
| self._record_event(name, actor_user_id, result, before_hash, self.business_hash(), cost) |
| return ext_deepcopy(result) |
|
|
| def _ticketing_read(self, name, arguments): |
| args = ext_deepcopy(arguments) |
| if name == 'read_offer_terms': |
| atom = fn_rule_id(args['event_kind'], args['ticket_kind']) |
| row = fn_profile(fn_rule_index_2(atom, self._epoch)) |
| fields = ('audience_certificate', 'redemption_channel') if args['document'] == 'audience_eligibility' else ('reimbursement_cycle',) |
| return {'status': 'success', 'data': {'document': {'document_id': fn_handle_2('terms', f"{atom}:{args['document']}:{self._epoch}"), 'issuing_authority': 'Audience admission office' if len(fields) == 2 else 'Promoter accounts payable', 'scope': {'event_kind': args['event_kind'], 'ticket_kind': args['ticket_kind']}, 'requirements': {x: row[x] for x in fields}, 'authority': 'current commercial contract'}}} |
| if name == 'get_venue_seating_chart': |
| if args.get('available_only') and (not args.get('performance_id')): |
| return fn__error('PERFORMANCE_REQUIRED', 'availability requires a performance scope') |
| performance = self._state.get_entity('performance', args.get('performance_id'), 'performance_id') if args.get('performance_id') else None |
| if args.get('performance_id') and (performance is None or performance['venue_id'] != args['venue_id']): |
| return fn__error('PERFORMANCE_VENUE_MISMATCH', 'performance is not at this venue') |
| occupied = {seat for line in self._state.list_entities('order_line') if line.get('performance_id') == args.get('performance_id') and line.get('status') not in {'canceled', 'refunded'} for seat in line.get('seat_ids', [])} |
| sections = [ext_deepcopy(x) for x in self._state.list_entities('venue_section') if x['venue_id'] == args['venue_id'] and (not args.get('venue_section_id') or x['venue_section_id'] == args['venue_section_id']) and (not args.get('section_type_filter') or x['section_type'] == args['section_type_filter'])] |
| section_ids = {x['venue_section_id'] for x in sections} |
| seats = [ext_deepcopy(x) for x in self._state.list_entities('seat') if x['venue_section_id'] in section_ids and (not args.get('seat_status_filter') or x['status'] == args['seat_status_filter']) and (not args.get('available_only') or x['seat_id'] not in occupied)] |
| seats.sort(key=lambda x: x['seat_id']) |
| (offset, limit) = (args.get('offset', 0), args.get('limit', 2)) |
| page = seats[offset:offset + limit] if args.get('include_seats') else [] |
| for row in page: |
| row['occupied'] = row['seat_id'] in occupied if performance else None |
| for section in sections: |
| section['seats'] = [x for x in page if x['venue_section_id'] == section['venue_section_id']] |
| return {'status': 'success', 'data': {'sections': sections, 'total_seats': len(seats), 'next_offset': offset + limit if args.get('include_seats') and offset + limit < len(seats) else None, 'performance_id': args.get('performance_id')}} |
| tier_id = args.pop('price_tier_id', None) if name == 'list_price_tiers' else None |
| if tier_id: |
| rows = [ext_deepcopy(x) for x in self._state.list_entities('price_tier') if x['event_id'] == args['event_id'] and x['price_tier_id'] == tier_id and (not args.get('active_only') or x['active'])] |
| result = {'status': 'success', 'data': {'price_tiers': rows, 'total_count': len(rows)}} |
| else: |
| result = self._logic.execute_tool(name, self._state, **args) |
| if name == 'get_event_sales_dashboard' and result.get('status') == 'success': |
| current = [x for x in self._state.list_entities('discount_campaign') if x['event_id'] == args['event_id'] and x['status'] == 'active'] |
| result['data']['campaigns'] = [{k: x[k] for k in ('discount_campaign_id', 'offer_profile_id', 'audience_certificate', 'redemption_channel', 'reimbursement_cycle', 'status')} for x in current] if args.get('include_campaigns', True) else [] |
| return result |
|
|
| def _ticketing_read_2(self, name, arguments): |
| args = ext_deepcopy(arguments) |
| if name == 'read_offer_terms': |
| atom = fn_rule_id(args['event_kind'], args['ticket_kind']) |
| state = self.rule_revalidation.get(atom) |
| epoch = 0 if state == 'awaiting_exact_stale' else self._epoch |
| row = fn_profile(fn_rule_index(atom, epoch)) |
| fields = ('audience_certificate', 'redemption_channel') if args['document'] == 'audience_eligibility' else ('reimbursement_cycle',) |
| return {'status': 'success', 'data': {'document': {'document_id': fn_handle('terms', f"{atom}:{args['document']}:{epoch}"), 'issuing_authority': 'Audience admission office' if len(fields) == 2 else 'Promoter accounts payable', 'scope': {'event_kind': args['event_kind'], 'ticket_kind': args['ticket_kind']}, 'requirements': {field: row[field] for field in fields}, 'authority': 'current commercial contract'}}} |
| if name == 'get_event_sales_dashboard': |
| filters = {key: args.pop(key, None) for key in ('audience_certificate', 'redemption_channel', 'reimbursement_cycle')} |
| result = self._ticketing_read(name, args) |
| if result.get('status') == 'success': |
| campaigns = result['data'].get('campaigns', []) |
| result['data']['campaigns'] = [row for row in campaigns if all((value is None or row.get(key) == value for (key, value) in filters.items()))] |
| return result |
| result = self._ticketing_read(name, args) |
| if name == 'list_ticket_types' and result.get('status') == 'success': |
| for (key, stale) in self._stale_bindings.items(): |
| state = self.structure_revalidation.get(key) |
| exact = args.get('event_id') == stale['event_id'] and args.get('ticket_kind') == stale['ticket_kind'] |
| reveal = state in {'ready_current', 'validated_current'} or (exact and state in {'awaiting_fresh_binding', 'awaiting_fresh_tier'}) |
| if reveal: |
| continue |
| for row in result['data'].get('ticket_types', []): |
| if row.get('ticket_type_id') == stale['ticket_type_id']: |
| row['price_tier_id'] = stale['price_tier_id'] |
| return result |
|
|
| def _ticketing_after_read(self, name, arguments, result): |
| if result.get('status') != 'success': |
| return |
| if name == 'list_ticket_types': |
| key = self._binding_key_for_arguments(arguments) |
| if key and self.structure_revalidation.get(key) == 'awaiting_fresh_binding': |
| self.structure_revalidation[key] = 'awaiting_fresh_tier' |
| elif name == 'list_price_tiers': |
| for (key, stale) in self._stale_bindings.items(): |
| if self.structure_revalidation.get(key) == 'awaiting_fresh_tier' and arguments.get('event_id') == stale['event_id'] and (arguments.get('price_tier_id') == stale['replacement_price_tier_id']): |
| self.structure_revalidation[key] = 'ready_current' |
| elif name == 'read_offer_terms': |
| atom = fn_rule_id(arguments['event_kind'], arguments['ticket_kind']) |
| if self.rule_revalidation.get(atom) in {'awaiting_fresh_terms', 'awaiting_fresh_offer'}: |
| self.rule_documents_seen.setdefault(atom, set()).add(arguments['document']) |
| if self.rule_documents_seen[atom] == {'audience_eligibility', 'promoter_settlement'}: |
| self.rule_revalidation[atom] = 'awaiting_fresh_offer' |
| elif name == 'get_event_sales_dashboard': |
| exact_filters = all((arguments.get(key) is not None for key in ('audience_certificate', 'redemption_channel', 'reimbursement_cycle'))) |
| if not exact_filters or len(result.get('data', {}).get('campaigns', [])) != 1: |
| return |
| for target in self._task_targets: |
| atom = target['rule_atom'] |
| expected = fn_profile(fn_rule_index(atom, 1)) |
| if self.rule_revalidation.get(atom) == 'awaiting_fresh_offer' and arguments.get('event_id') == target['event_id'] and all((arguments.get(key) == expected[key] for key in ('audience_certificate', 'redemption_channel', 'reimbursement_cycle'))): |
| self.rule_revalidation[atom] = 'ready_current' |
|
|
| def _event_ticketing_adapter_grade(self, task_id): |
| if task_id != self._task_id: |
| raise ValueError('task is not active') |
| entities = self._state.list_snapshot() |
| deliverables = [] |
| for target in self._task_targets: |
| candidates = [row for row in entities['order'] if row.get('customer_id') == target['customer_id'] and row.get('event_id') == target['event_id'] and (row.get('performance_id') == target['performance_id']) and (row.get('order_status') == 'paid') and (row.get('payment_status') == 'paid') and (target['required_campaign_id'] in (row.get('applied_campaign_ids') or []))] |
| passed = None |
| for order in candidates: |
| lines = [row for row in entities['order_line'] if row.get('order_id') == order['order_id'] and row.get('ticket_type_id') == target['ticket_type_id'] and (row.get('venue_section_id') == target['venue_section_id']) and (int(row.get('quantity') or 0) == target['quantity']) and (row.get('status') == 'confirmed')] |
| if len(lines) != 1: |
| continue |
| line = lines[0] |
| seat_ids = line.get('seat_ids') or [] |
| tickets = [row for row in entities['ticket'] if row.get('order_id') == order['order_id'] and row.get('order_line_id') == line['order_line_id'] and (row.get('ticket_status') == 'issued')] |
| ticket_seats = {row.get('seat_id') for row in tickets} |
| if len(seat_ids) != target['quantity'] or len(tickets) != target['quantity']: |
| continue |
| if len(set(seat_ids)) != target['quantity'] or ticket_seats != set(seat_ids): |
| continue |
| if any(((self._state.get_entity('seat', seat_id, 'seat_id') or {}).get('venue_section_id') != target['venue_section_id'] for seat_id in seat_ids)): |
| continue |
| passed = {'order': order, 'line': line, 'tickets': tickets} |
| break |
| deliverables.append({'target_id': target['target_id'], 'structure_atom': target['structure_atom'], 'rule_atom': target['rule_atom'], 'paid_order': passed is not None, 'eligible_offer_applied': passed is not None, 'seats_bound': passed is not None, 'issued_tickets': passed is not None, 'inventory_conserved': passed is not None, 'order_id': passed['order']['order_id'] if passed else None, 'ticket_ids': [row['ticket_id'] for row in passed['tickets']] if passed else [], 'score': 25.0 if passed else 0.0}) |
| completed = sum((row['score'] == 25.0 for row in deliverables)) |
| return {'task_id': task_id, 'score': completed * 25.0, 'max_score': 100.0, 'completed_artifacts': completed, 'deliverables': deliverables, 'budget': self._budget()} |
|
|
| def _ticketing_evolution_snapshot(self): |
| value = self._ticketing_snapshot() |
| value['evolution'] = {'case_version': 'event-ticketing-two-event-evolution-v1', 'schedule': ext_deepcopy(DATA_SCHEDULE_3), 'blueprint_sha256': fn_digest(DATA_SCHEDULE_2), 'own_finalizations': ext_deepcopy(self._own_finalizations)} |
| return value |
|
|
| def _ticketing_evolution_restore(self, snapshot): |
| value = ext_deepcopy(snapshot) |
| metadata = value.pop('evolution') |
| if metadata['case_version'] != 'event-ticketing-two-event-evolution-v1' or metadata['schedule'] != DATA_SCHEDULE_3 or metadata['blueprint_sha256'] != fn_digest(DATA_SCHEDULE_2): |
| raise ValueError('event-ticketing evolution contract differs') |
| active = value['activated_tasks'] |
| expected = [e['event_id'] for e in DATA_SCHEDULE_3['events'] if e['before_task'] <= len(active)] |
| if active != list(DATA_TASK_IDS[:len(active)]) or value['task_id'] != (active[-1] if active else None) or value['applied_boundary_events'] != expected: |
| raise ValueError('event-ticketing evolution prefix or event ledger differs') |
| self._ticketing_restore(value) |
| self._own_finalizations = metadata['own_finalizations'] |
| self._assert_inventory_invariants() |
| if self.snapshot() != snapshot: |
| raise ValueError('event-ticketing snapshot did not round trip') |
|
|
| def _ticketing_evolution_public_task(self): |
| value = self._ticketing_public_task() |
| value['completion'].pop('verification_required') |
| value['completion']['evidence'] = {'mode': 'authoritative_receipt', 'source': 'successful finalize_order_to_tickets', 'proves': 'paid order and issued ticket IDs'} |
| value['operational_contract'] += ' Exact get_order confirmation of an order you finalized in this episode returns only its saved finalization receipt at zero read, write and business-call quota. Other order reads remain charged.' |
| return value |
|
|
| def _ticketing_init_2(self, source_root=CASE_DIR / 'raw', snapshot=None): |
| self._event_ticketing_mixed_successor_init(source_root) |
| self._epoch = 0 |
| self._boundary_receipts = [] |
| self._catalog = {} |
| self._build_catalog() |
| if snapshot is not None: |
| self.restore(snapshot) |
|
|
| def _ticketing_snapshot(self): |
| value = self._ticketing_snapshot_2() |
| value['v4'] = {'structure_revalidation': ext_deepcopy(self.structure_revalidation), 'rule_revalidation': ext_deepcopy(self.rule_revalidation), 'rule_documents_seen': {key: sorted(documents) for (key, documents) in self.rule_documents_seen.items()}, 'stale_bindings': ext_deepcopy(self._stale_bindings), 'boundary_receipts': ext_deepcopy(self._boundary_receipts_v4)} |
| return value |
|
|
| def _ticketing_restore(self, snapshot): |
| self._ticketing_restore_2(snapshot) |
| extra = snapshot.get('v4', {}) |
| self.structure_revalidation = ext_deepcopy(extra.get('structure_revalidation', {})) |
| self.rule_revalidation = ext_deepcopy(extra.get('rule_revalidation', {})) |
| self.rule_documents_seen = {key: set(documents) for (key, documents) in extra.get('rule_documents_seen', {}).items()} |
| self._stale_bindings = ext_deepcopy(extra.get('stale_bindings', {})) |
| self._boundary_receipts_v4 = ext_deepcopy(extra.get('boundary_receipts', [])) |
|
|
| def _ticketing_public_task(self): |
| task = self._ticketing_public_task_2() |
| task['operational_contract'] = task['operational_contract'].replace('Commercial conditions apply until a normal business action rejects the retained path.', 'Commercial conditions apply until contradicted by current authoritative terms or ordinary business evidence.') |
| return task |
|
|
| def _event_ticketing_mixed_successor_init(self, source_root=CASE_DIR / 'raw', snapshot=None): |
| source_root = ext_Path(source_root).resolve() |
| self._persistent_event_ticketing_adapter_init(source_root) |
| ((logic,), _) = ext_load_isolated_modules(source_root, ('mcp_servers.ticketing_logic',)) |
| logic.NOW = '2026-05-27T12:00:00Z' |
| logic.now_iso = lambda : '2026-05-27T12:00:00Z' |
| self._logic = logic |
| if snapshot is not None: |
| self.restore(snapshot) |
|
|
| def _ticketing_snapshot_2(self): |
| value = self._persistent_event_ticketing_adapter_snapshot() |
| value['v3'] = {'epoch': getattr(self, '_epoch', 0), 'catalog': ext_deepcopy(getattr(self, '_catalog', {})), 'boundary_receipts': ext_deepcopy(getattr(self, '_boundary_receipts', []))} |
| return value |
|
|
| def _ticketing_restore_2(self, snapshot): |
| self._persistent_event_ticketing_adapter_restore(snapshot) |
| extra = snapshot.get('v3', {}) |
| self._epoch = extra.get('epoch', 0) |
| self._catalog = ext_deepcopy(extra.get('catalog', {})) |
| self._boundary_receipts = ext_deepcopy(extra.get('boundary_receipts', [])) |
|
|
| def _ticketing_public_task_2(self): |
| requests = [] |
| for target in self._task_targets: |
| cluster = self._catalog[target['structure_atom']] |
| requests.append({'request_reference': target['target_id'], 'customer_reference': target['customer_id'], 'event_name': cluster['event_name'], 'performance_starts_at': cluster['starts_at'], 'ticket_kind': target['ticket_kind'], 'quantity': 2}) |
| return {'schema': 'rescopebench-public-task/v5', 'case_id': 'event_ticketing', 'task_id': fn_handle('event', self._task_id), 'objective': 'Complete policy-compliant ticket purchases in listed priority order. A later request cannot be committed until every earlier request is complete. A complete purchase has one paid order, the requested admission class in its current bound section, two distinct available seats, the eligible house offer, and issued tickets.', 'requests': requests, 'completion': {'mode': 'ordered_independent', 'subset_allowed': True, 'priority_order': 'listed', 'started_item_must_close': True, 'verification_required': True}, 'budget': {'read_work_units': 25, 'write_attempts': 22}, 'operational_contract': 'Catalog IDs and seat-to-section membership persist until contradicted by current business evidence. Commercial conditions apply until a normal business action rejects the retained path. Seat occupancy is live and performance-scoped. At a request boundary, unpaid orders expire and release their own held inventory; paid records remain. Reads are charged by returned work, and rejected mutations consume a write attempt. A successful finalize_order_to_tickets response is authoritative completion evidence because it reports the paid state and issued ticket IDs; get_order is only needed when that receipt is incomplete or a concrete current conflict must be resolved.'} |
|
|
| def _persistent_event_ticketing_adapter_init(self, source_root=CASE_DIR / 'raw'): |
| self._event_ticketing_adapter_init(source_root) |
| self._state = MemoryState(fn__initial_entities()) |
| self._task_id = None |
| self._task_targets = [] |
| self._events = [] |
| self._calls = 0 |
| self._read_units = 0 |
| self._write_attempts = 0 |
| self._activated_tasks: list[str] = [] |
| self._applied_boundary_events: set[str] = set() |
| self._active_event_start = 0 |
|
|
| def _persistent_event_ticketing_adapter_snapshot(self): |
| return {'schema': 'rescopebench-event-ticketing-stream-snapshot/v1', 'task_id': self._task_id, 'task_targets': ext_deepcopy(self._task_targets), 'entities': self._state.list_snapshot(), 'events': ext_deepcopy(self._events), 'calls': self._calls, 'read_units': self._read_units, 'write_attempts': self._write_attempts, 'activated_tasks': list(self._activated_tasks), 'applied_boundary_events': sorted(self._applied_boundary_events), 'active_event_start': self._active_event_start} |
|
|
| def _persistent_event_ticketing_adapter_restore(self, snapshot): |
| if snapshot.get('schema') != 'rescopebench-event-ticketing-stream-snapshot/v1': |
| raise ValueError('unsupported persistent stream snapshot schema') |
| self._task_id = snapshot.get('task_id') |
| self._task_targets = ext_deepcopy(snapshot.get('task_targets') or []) |
| self._state.restore(snapshot.get('entities') or {}) |
| self._events = ext_deepcopy(snapshot.get('events') or []) |
| self._calls = int(snapshot.get('calls') or 0) |
| self._read_units = int(snapshot.get('read_units') or 0) |
| self._write_attempts = int(snapshot.get('write_attempts') or 0) |
| self._activated_tasks = list(snapshot.get('activated_tasks') or []) |
| self._applied_boundary_events = set(snapshot.get('applied_boundary_events') or []) |
| self._active_event_start = int(snapshot.get('active_event_start') or 0) |
|
|
| def _event_ticketing_adapter_init(self, source_root=CASE_DIR / 'raw'): |
| self._logic = fn__load_raw_logic(str(ext_Path(source_root).resolve())) |
| self._state = MemoryState({name: [] for name in DATA_ENTITY_ID_FIELDS}) |
| self._task_id: str | None = None |
| self._task_targets: list[dict[str, ext_Any]] = [] |
| self._events: list[dict[str, ext_Any]] = [] |
| self._calls = 0 |
| self._read_units = 0 |
| self._write_attempts = 0 |
|
|
| class MemoryState: |
|
|
| def __init__(self, entities): |
| self._entities = ext_deepcopy(entities) |
|
|
| def get_entity(self, entity_type, entity_id, id_field='id'): |
| field = DATA_ENTITY_ID_FIELDS.get(entity_type, id_field) if id_field == 'id' else id_field |
| return next((ext_deepcopy(row) for row in self._entities.get(entity_type, []) if row.get(field) == entity_id), None) |
|
|
| def list_entities(self, entity_type): |
| return ext_deepcopy(self._entities.get(entity_type, [])) |
|
|
| def add_entity(self, entity_type, record, id_field='id'): |
| field = DATA_ENTITY_ID_FIELDS.get(entity_type, id_field) if id_field == 'id' else id_field |
| identity = record.get(field) |
| if identity is None or self.get_entity(entity_type, identity, field) is not None: |
| raise ValueError(f'duplicate or missing identity for {entity_type}') |
| self._entities.setdefault(entity_type, []).append(ext_deepcopy(record)) |
| return ext_deepcopy(record) |
|
|
| def update_entity(self, entity_type, entity_id, patch, id_field='id'): |
| field = DATA_ENTITY_ID_FIELDS.get(entity_type, id_field) if id_field == 'id' else id_field |
| for row in self._entities.get(entity_type, []): |
| if row.get(field) == entity_id: |
| row.update(ext_deepcopy(patch)) |
| return ext_deepcopy(row) |
| return None |
|
|
| def delete_entity(self, entity_type, entity_id, id_field='id'): |
| field = DATA_ENTITY_ID_FIELDS.get(entity_type, id_field) if id_field == 'id' else id_field |
| rows = self._entities.get(entity_type, []) |
| kept = [row for row in rows if row.get(field) != entity_id] |
| self._entities[entity_type] = kept |
| return len(kept) != len(rows) |
|
|
| def list_snapshot(self): |
| return ext_deepcopy(self._entities) |
|
|
| def restore(self, entities): |
| self._entities = ext_deepcopy(entities) |
|
|
