| """Released environment operations and snapshot validation.""" |
| from __future__ import annotations |
| from copy import deepcopy as ext_deepcopy |
| 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 json as mod_json |
| import jsonschema as mod_jsonschema |
| import rescopebench.stream_engine as mod_engine |
| from .spec import CASE_DIR, DATA_RETEST_TASKS, DATA_RETEST_ORDER, DATA_POST_AUTHORITY, DATA_TOOLS_2, DATA_PROFILE_BY_RULE, DATA_TASK_IDS, DATA_WRITE_TOOLS, DATA_ENTITY_ID_FIELDS, DATA_APPROVAL_ROLES, DATA_REPLACEMENTS, DATA_PRE_AUTHORITY, DATA_TOOL_BY_NAME, DATA_READ_COSTS, DATA_SCHEDULE_2, DATA_ACTOR_GRANTS, DATA_TASK_BLUEPRINT, DATA_STRUCTURE_ATOMS, DATA_STRUCTURE_TRACKS, DATA_TASK_BLUEPRINT_2, DATA_TASK_BLUEPRINT_3 |
|
|
| def fn_public_task(task_id): |
| packet = fn_public_task_2(task_id) |
| if task_id in DATA_RETEST_TASKS: |
| packet['targets'] = [packet['targets'][i] for i in DATA_RETEST_ORDER] |
| token = fn__opaque('EV', 'scf-lead-retest-lifecycle-evolution-v2', task_id, packet['targets'], length=12) |
| packet['task_id'] = token.upper() |
| return packet |
|
|
| def fn__authority_candidates(atom_id, current): |
| stale = DATA_PRE_AUTHORITY[atom_id] |
| foreign_scope = fn__opaque_2('funding-scope', atom_id, 'foreign', length=14) |
| foreign_chain = fn__opaque_2('approval-chain', atom_id, 'foreign', length=14) |
| routes = [{'funding_scope_id': current['funding_scope_id'], 'submission_channel': current['submission_channel'], 'approval_chain_ref': current['approval_chain_ref'], 'route_status': 'eligible'}, {'funding_scope_id': foreign_scope, 'submission_channel': 'operations_console', 'approval_chain_ref': foreign_chain, 'route_status': 'eligible'}] |
| if stale != current: |
| routes.append({'funding_scope_id': stale['funding_scope_id'], 'submission_channel': stale['submission_channel'], 'approval_chain_ref': stale['approval_chain_ref'], 'route_status': 'retired'}) |
| routes.sort(key=lambda row: row['funding_scope_id']) |
| delegations = [] |
| for row in current['delegations']: |
| delegations.append({'role': row['role'], 'principal_ref': 'current-finance-operator', 'delegation_id': row['delegation_id'], 'scope_id': row['scope_id'], 'approval_chain_ref': current['approval_chain_ref'], 'status': 'active'}) |
| if stale != current: |
| for row in stale['delegations']: |
| delegations.append({'role': row['role'], 'principal_ref': 'current-finance-operator', 'delegation_id': row['delegation_id'], 'scope_id': row['scope_id'], 'approval_chain_ref': stale['approval_chain_ref'], 'status': 'revoked'}) |
| for role in DATA_APPROVAL_ROLES: |
| delegations.append({'role': role, 'principal_ref': 'external-finance-operator', 'delegation_id': fn__opaque_2('delegation', atom_id, 'foreign', role, length=14), 'scope_id': foreign_scope, 'approval_chain_ref': foreign_chain, 'status': 'active'}) |
| return {'routes': routes, 'delegations': delegations} |
|
|
| def fn_approval_task_ids(target, authority): |
| slug = str(target['invoice_id']).removeprefix('invoice-') |
| namespace = authority['approval_namespace'] |
| return [f"approval-{slug}-{namespace}-{role.replace('_', '-')}-{index:03d}" for (index, role) in enumerate(DATA_APPROVAL_ROLES, 1)] |
|
|
| def fn__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__normalize(result): |
| value = ext_deepcopy(result) |
| data = value.setdefault('data', {}) |
| if value.get('status') == 'error' and (not data.get('error_code')): |
| message = str(value.get('message') or '') |
| data['status'] = 'failed' |
| data['error_code'] = message.split(':', 1)[0] if message else 'OPERATION_FAILED' |
| elif value.get('status') == 'success': |
| data.setdefault('status', 'succeeded') |
| data.setdefault('error_code', None) |
| return value |
|
|
| def fn__success(**data): |
| return {'status': 'success', 'data': {'status': 'succeeded', 'error_code': None, **ext_deepcopy(data)}, 'message': 'OK'} |
|
|
| def fn__money(value): |
| return round(float(value or 0), 2) |
|
|
| def fn_activate_coverage(snapshot, task_id, current_terms): |
| """Replace only the newly released, previously inaccessible work records.""" |
| result = ext_deepcopy(snapshot) |
| old_targets = fn_stream_targets(task_id) |
| targets = fn_stream_targets_2(task_id) |
| for slot in DATA_REPLACEMENTS.get(task_id, {}): |
| (old, new) = (old_targets[slot - 1], targets[slot - 1]) |
| for decoy in (False, True): |
| old_invoice = fn__invoice_row(old, decoy=decoy) |
| new_invoice = fn__invoice_row(new, decoy=decoy) |
| existing = [r for r in result['entities']['invoice'] if r['invoice_id'] == old_invoice['invoice_id']] |
| if existing != [old_invoice]: |
| raise ValueError('Coverage replacement cannot discard changed business records') |
| fn_replace_one(result['entities']['invoice'], 'invoice_id', old_invoice['invoice_id'], new_invoice) |
| released = result['release_by_invoice'].pop(old_invoice['invoice_id']) |
| if released != new['position']: |
| raise ValueError('Replacement changes invoice release timing') |
| result['release_by_invoice'][new_invoice['invoice_id']] = released |
| item = next((r for r in result['work_items'] if r['request_reference'] == old['request_reference'])) |
| replacement = ext_deepcopy(item) |
| for (field, target_field) in {'work_queue_id': 'queue_id', 'request_reference': 'request_reference', 'buyer_legal_name': 'buyer_name', 'buyer_region': 'buyer_region', 'supplier_legal_name': 'supplier_name', 'supplier_country': 'supplier_country', 'supplier_industry': 'supplier_industry', 'invoice_number': 'invoice_number', 'invoice_id': 'invoice_id', 'currency': 'currency', 'requested_amount': 'requested_amount'}.items(): |
| replacement[field] = new[target_field] |
| fn_replace_one(result['work_items'], 'request_reference', old['request_reference'], replacement) |
| fn_replace_one(result['all_targets'], 'target_id', old['target_id'], new) |
| released = result['release_by_request'].pop(old['request_reference']) |
| if released != new['position']: |
| raise ValueError('Replacement changes request release timing') |
| result['release_by_request'][new['request_reference']] = released |
| active = ext_deepcopy(new) |
| (active['advance_rate_percent'], active['discount_rate_percent']) = current_terms[new['rule_atom_id']] |
| result['targets'][slot - 1] = active |
| limits = {row['credit_limit_id']: row for row in result['entities']['credit_limit']} |
| result['task_baseline_limits'] = {target['credit_limit_id']: {key: float(limits[target['credit_limit_id']][key]) for key in ('used_amount', 'available_amount')} for target in result['targets']} |
| return result |
|
|
| def fn_public_task_2(task_id): |
| task = fn_public_task_3(task_id) |
| task['completion'].pop('verification_required') |
| task['completion'].pop('verification_evidence') |
| task['completion']['evidence'] = {'mode': 'authoritative_receipt', 'source': 'finalize_factoring_advance completion_receipt', 'proves': "the submitted advance's completed settlement and matched reconciliation"} |
| task['budget']['mechanism'] = task['budget']['mechanism'].replace('Exact timeline verification costs 1.', 'An exact invoice_id-only timeline request for your own successful settlement in this episode returns only that completion receipt for zero work units and zero call/write quota; other timeline reads cost 1.') |
| return task |
|
|
| def fn__opaque(prefix, *parts, length=12): |
| seed = '|'.join((str(part) for part in parts)) |
| value = mod_hashlib.sha256(f'scf-authority-v5|{seed}'.encode('utf-8')).hexdigest() |
| return f'{prefix}-{value[:length]}' |
|
|
| @lru_cache(**{'maxsize': 1, 'typed': False}) |
| def fn__fixture(): |
| base = fn__fixture_3() |
| entities = ext_deepcopy(base['entities']) |
| entities['invoice'] = [] |
| for (index, row) in enumerate(entities['credit_limit'], 1): |
| row['limit_amount'] = 100000.0 |
| row['used_amount'] = float(index * 100) |
| row['available_amount'] = float(100000 - index * 100) |
| for index in range(5, 17): |
| rows = fn__profile_entities(DATA_PROFILE_BY_RULE[f'R{index:02d}'], index) |
| for (entity_type, values) in rows.items(): |
| entities[entity_type].extend(values) |
| targets = [row for task_id in DATA_TASK_IDS for row in fn_stream_targets(task_id)] |
| for target in targets: |
| for invoice in (fn__invoice_row(target), fn__invoice_row(target, decoy=True)): |
| entities['invoice'].append(invoice) |
| fixture = {'entities': entities, 'queues': ext_deepcopy(base['queues']), 'work_items': [{'work_queue_id': target['queue_id'], 'request_reference': target['request_reference'], 'buyer_legal_name': target['buyer_name'], 'buyer_region': target['buyer_region'], 'supplier_legal_name': target['supplier_name'], 'supplier_country': target['supplier_country'], 'supplier_industry': target['supplier_industry'], 'invoice_number': target['invoice_number'], 'invoice_id': target['invoice_id'], 'currency': target['currency'], 'requested_amount': target['requested_amount'], 'instruction': 'Use the current program maximum advance rate, standard discount, and current funding authority, then settle the factoring advance.'} for target in targets], 'targets': targets, 'release_by_invoice': {}, 'release_by_request': {}} |
| for target in targets: |
| fixture['release_by_invoice'][target['invoice_id']] = target['position'] |
| fixture['release_by_invoice'][f"invoice-decoy-{target['invoice_id'].removeprefix('invoice-')}"] = target['position'] |
| fixture['release_by_request'][target['request_reference']] = target['position'] |
| fixture['baseline_limits'] = {row['credit_limit_id']: {'used_amount': row['used_amount'], 'available_amount': row['available_amount']} for row in fixture['entities']['credit_limit']} |
| return fixture |
|
|
| def fn__error(code, message): |
| return {'status': 'error', 'data': {'status': 'failed', 'error_code': code}, 'message': message} |
|
|
| def fn__opaque_2(prefix, *parts, length=12): |
| seed = '|'.join((str(part) for part in parts)) |
| value = mod_hashlib.sha256(f'scf-authority-v3|{seed}'.encode('utf-8')).hexdigest() |
| return f'{prefix}-{value[:length]}' |
|
|
| def fn_stream_targets(task_id): |
| if task_id not in DATA_TASK_IDS: |
| raise ValueError(f'unknown stream task: {task_id}') |
| return tuple((ext_deepcopy(row) for row in fn__catalog()[task_id])) |
|
|
| def fn_opaque_event_id(task_id): |
| if task_id not in DATA_TASK_IDS: |
| raise ValueError(f'unknown stream task: {task_id}') |
| refs = [row['request_reference'] for row in fn_stream_targets(task_id)] |
| return fn__opaque('EV', task_id, refs, length=12).upper() |
|
|
| def fn_stream_targets_2(task_id): |
| targets = list(fn_stream_targets(task_id)) |
| for (slot, pair) in DATA_REPLACEMENTS.get(task_id, {}).items(): |
| targets[slot - 1] = fn__target(DATA_TASK_IDS.index(task_id) + 1, slot, *pair) |
| return tuple(targets) |
|
|
| def fn__invoice_row(target, *, decoy=False): |
| suffix = target['invoice_id'].removeprefix('invoice-') |
| amount = target['requested_amount'] + (111.0 if decoy else 0.0) |
| return {'invoice_id': f'invoice-decoy-{suffix}' if decoy else target['invoice_id'], 'invoice_number': f"DECOY-{target['invoice_number']}" if decoy else target['invoice_number'], 'buyer_id': target['buyer_id'], 'supplier_id': target['supplier_id'], 'program_id': target['program_id'], 'credit_limit_id': target['credit_limit_id'], 'currency': target['currency'], 'description': 'Ineligible comparison invoice' if decoy else 'Assigned finance invoice', 'gross_amount': amount, 'approved_amount': amount, 'paid_amount': 0.0, 'outstanding_amount': amount, 'status': 'disputed' if decoy else 'approved', 'payment_status': 'unpaid', 'eligible_for_factoring': not decoy, 'issue_date': f"2026-06-{target['position']:02d}T09:00:00Z", 'due_date': '2026-11-15T09:00:00Z', 'approved_at': '2026-06-01T09:00:00Z', 'created_at': f"2026-06-{target['position']:02d}T09:00:00Z", 'updated_at': f"2026-06-{target['position']:02d}T09:00:00Z"} |
|
|
| def fn_replace_one(rows, key, old_value, replacement): |
| matches = [i for (i, row) in enumerate(rows) if row[key] == old_value] |
| if len(matches) != 1: |
| raise ValueError(f'Expected one unopened fixture record for {key}') |
| rows[matches[0]] = ext_deepcopy(replacement) |
|
|
| def fn_public_task_3(task_id): |
| task = fn_public_task_4(task_id) |
| if task_id not in DATA_REPLACEMENTS: |
| return task |
| for slot in DATA_REPLACEMENTS[task_id]: |
| target = fn_stream_targets_2(task_id)[slot - 1] |
| task['targets'][slot - 1].update({key: target[key] for key in ('request_reference', 'service_band', 'routing_track')}) |
| task['task_id'] = 'EV-' + mod_engine.digest(['scf-authority-lifecycle-evolution-v1', task_id, task['targets']])[:12].upper() |
| return task |
|
|
| @lru_cache(**{'maxsize': 1, 'typed': False}) |
| def fn__fixture_2(): |
| base = fn__fixture_3() |
| entities = ext_deepcopy(base['entities']) |
| entities['invoice'] = [] |
| for (index, row) in enumerate(entities['credit_limit'], 1): |
| row['limit_amount'] = 100000.0 |
| row['used_amount'] = float(index * 100) |
| row['available_amount'] = float(100000 - index * 100) |
| for index in range(5, 17): |
| rows = fn__profile_entities(DATA_PROFILE_BY_RULE[f'R{index:02d}'], index) |
| for (entity_type, values) in rows.items(): |
| entities[entity_type].extend(values) |
| targets = [row for task_id in DATA_TASK_IDS for row in fn_stream_targets_3(task_id)] |
| for target in targets: |
| for invoice in (fn__invoice_row(target), fn__invoice_row(target, decoy=True)): |
| entities['invoice'].append(invoice) |
| fixture = {'entities': entities, 'queues': ext_deepcopy(base['queues']), 'work_items': [{'work_queue_id': target['queue_id'], 'request_reference': target['request_reference'], 'buyer_legal_name': target['buyer_name'], 'buyer_region': target['buyer_region'], 'supplier_legal_name': target['supplier_name'], 'supplier_country': target['supplier_country'], 'supplier_industry': target['supplier_industry'], 'invoice_number': target['invoice_number'], 'invoice_id': target['invoice_id'], 'currency': target['currency'], 'requested_amount': target['requested_amount'], 'instruction': 'Use the current program maximum advance rate, standard discount, and current funding authority, then settle the factoring advance.'} for target in targets], 'targets': targets, 'release_by_invoice': {}, 'release_by_request': {}} |
| for target in targets: |
| fixture['release_by_invoice'][target['invoice_id']] = target['position'] |
| fixture['release_by_invoice'][f"invoice-decoy-{target['invoice_id'].removeprefix('invoice-')}"] = target['position'] |
| fixture['release_by_request'][target['request_reference']] = target['position'] |
| fixture['baseline_limits'] = {row['credit_limit_id']: {'used_amount': row['used_amount'], 'available_amount': row['available_amount']} for row in fixture['entities']['credit_limit']} |
| return fixture |
|
|
| def fn__fixture_3(): |
| entities = {name: [] for name in DATA_ENTITY_ID_FIELDS} |
| queues = [('FQ-4V', 'SB-ALPHA', 'Domestic intake'), ('FQ-7K', 'SB-ALPHA', 'Domestic exception desk'), ('FQ-2M', 'SB-BRAVO', 'Food supply intake'), ('FQ-9P', 'SB-BRAVO', 'Food supply overflow'), ('FQ-5R', 'SB-CHARLIE', 'Healthcare intake'), ('FQ-8C', 'SB-CHARLIE', 'Healthcare exception desk'), ('FQ-3H', 'SB-DELTA', 'International intake'), ('FQ-6X', 'SB-DELTA', 'International overflow')] |
| buyer_rows = [('buyer-7q2m', 'Aster Retail Cooperative', 'west', 'low', 'USD', 'active'), ('buyer-3m8k', 'Beacon Foods Network', 'southeast', 'medium', 'EUR', 'active'), ('buyer-9k4d', 'Cedar Medical Group', 'northeast', 'low', 'GBP', 'active'), ('buyer-5t1p', 'Delta Hospitality Holdings', 'emea', 'medium', 'EUR', 'active'), ('buyer-1a6n', 'Atlas Retail Services', 'west', 'high', 'USD', 'watchlist'), ('buyer-8w3c', 'Bayside Foods Cooperative', 'southeast', 'high', 'EUR', 'paused'), ('buyer-2f7r', 'Civic Health Partners', 'northeast', 'medium', 'GBP', 'watchlist'), ('buyer-6j5x', 'Dover Lodging Group', 'emea', 'high', 'EUR', 'paused')] |
| for (buyer_id, name, region, risk, currency, status) in buyer_rows: |
| entities['buyer'].append({'buyer_id': buyer_id, 'legal_name': name, 'status': status, 'risk_tier': risk, 'region': region, 'credit_rating': 'A' if risk == 'low' else 'BBB', 'default_currency': currency, 'payment_terms_days': 30, 'created_at': '2026-01-01T09:00:00Z', 'updated_at': '2026-05-20T09:00:00Z'}) |
| supplier_rows = [('supplier-4h9v', 'Northwind Packaging Ltd', 'US', 'packaging', 'active', 'verified'), ('supplier-8c2q', 'Blue Harbor Produce GmbH', 'DE', 'produce', 'active', 'verified'), ('supplier-6p5s', 'Silverline Medical Supply', 'GB', 'medical', 'active', 'verified'), ('supplier-2r7n', 'Orchard Linen Works', 'NL', 'textiles', 'active', 'verified'), ('supplier-1x4b', 'Pioneer Packaging Co', 'US', 'packaging', 'active', 'expired'), ('supplier-7d3f', 'Greenbank Produce GmbH', 'DE', 'produce', 'suspended', 'verified'), ('supplier-9l6a', 'Riverside Medical Supply', 'GB', 'medical', 'active', 'under_review'), ('supplier-5g8e', 'Harbor Linen Works', 'NL', 'textiles', 'active', 'expired')] |
| for (index, (supplier_id, name, country, industry, status, kyc_status)) in enumerate(supplier_rows, start=1): |
| entities['supplier'].append({'supplier_id': supplier_id, 'legal_name': name, 'status': status, 'country': country, 'industry': industry, 'primary_contact': f'Contact {index}', 'contact_email': f'contact{index}@example.test', 'preferred_currency': 'USD', 'created_at': '2026-01-01T09:00:00Z', 'updated_at': '2026-05-20T09:00:00Z'}) |
| entities['supplier_kyc_profile'].append({'supplier_kyc_profile_id': f'supplier-kyc-{index:02d}', 'supplier_id': supplier_id, 'status': kyc_status, 'risk_score': 10 + index, 'risk_band': 'low' if kyc_status == 'verified' else 'high', 'beneficial_owner_verified': kyc_status == 'verified', 'sanctions_screen_status': 'clear', 'tax_document_status': 'accepted', 'reviewed_at': '2026-05-01T09:00:00Z', 'next_review_at': '2026-12-01T09:00:00Z', 'created_at': '2026-04-30T09:00:00Z', 'updated_at': '2026-05-01T09:00:00Z'}) |
| target_specs = [{'target_id': 'finance-outcome-a', 'request_reference': 'SCF-ALPHA-271', 'service_band': 'SB-ALPHA', 'queue_id': 'FQ-7K', 'buyer_id': 'buyer-7q2m', 'buyer_name': 'Aster Retail Cooperative', 'buyer_region': 'west', 'supplier_id': 'supplier-4h9v', 'supplier_name': 'Northwind Packaging Ltd', 'supplier_country': 'US', 'supplier_industry': 'packaging', 'program_id': 'program-4n7x', 'credit_limit_id': 'limit-8v2h', 'invoice_id': 'invoice-7v2q', 'invoice_number': 'AP-2609-1042', 'currency': 'USD', 'requested_amount': 1200.0, 'advance_rate_percent': 0.713, 'discount_rate_percent': 0.017, 'waterfall_id': 'payment-waterfall-6k1r-active'}, {'target_id': 'finance-outcome-b', 'request_reference': 'SCF-BRAVO-684', 'service_band': 'SB-BRAVO', 'queue_id': 'FQ-2M', 'buyer_id': 'buyer-3m8k', 'buyer_name': 'Beacon Foods Network', 'buyer_region': 'southeast', 'supplier_id': 'supplier-8c2q', 'supplier_name': 'Blue Harbor Produce GmbH', 'supplier_country': 'DE', 'supplier_industry': 'produce', 'program_id': 'program-9c3w', 'credit_limit_id': 'limit-2q9m', 'invoice_id': 'invoice-3k8p', 'invoice_number': 'BF-2609-2087', 'currency': 'EUR', 'requested_amount': 1450.0, 'advance_rate_percent': 0.827, 'discount_rate_percent': 0.023, 'waterfall_id': 'payment-waterfall-3d8p-active'}, {'target_id': 'finance-outcome-c', 'request_reference': 'SCF-CHARLIE-395', 'service_band': 'SB-CHARLIE', 'queue_id': 'FQ-8C', 'buyer_id': 'buyer-9k4d', 'buyer_name': 'Cedar Medical Group', 'buyer_region': 'northeast', 'supplier_id': 'supplier-6p5s', 'supplier_name': 'Silverline Medical Supply', 'supplier_country': 'GB', 'supplier_industry': 'medical', 'program_id': 'program-2b6f', 'credit_limit_id': 'limit-7m4c', 'invoice_id': 'invoice-9d4n', 'invoice_number': 'CM-2609-3314', 'currency': 'GBP', 'requested_amount': 980.0, 'advance_rate_percent': 0.764, 'discount_rate_percent': 0.014, 'waterfall_id': 'payment-waterfall-8h5t-active'}, {'target_id': 'finance-outcome-d', 'request_reference': 'SCF-DELTA-812', 'service_band': 'SB-DELTA', 'queue_id': 'FQ-3H', 'buyer_id': 'buyer-5t1p', 'buyer_name': 'Delta Hospitality Holdings', 'buyer_region': 'emea', 'supplier_id': 'supplier-2r7n', 'supplier_name': 'Orchard Linen Works', 'supplier_country': 'NL', 'supplier_industry': 'textiles', 'program_id': 'program-5j1s', 'credit_limit_id': 'limit-4x6b', 'invoice_id': 'invoice-2f7m', 'invoice_number': 'DH-2609-4471', 'currency': 'EUR', 'requested_amount': 1730.0, 'advance_rate_percent': 0.891, 'discount_rate_percent': 0.019, 'waterfall_id': 'payment-waterfall-1q7v-active'}] |
| queue_rows = [{'work_queue_id': queue_id, 'service_band': band, 'label': label} for (queue_id, band, label) in queues] |
| work_items = [] |
| for target in target_specs: |
| work_items.append({'work_queue_id': target['queue_id'], 'request_reference': target['request_reference'], 'buyer_legal_name': target['buyer_name'], 'buyer_region': target['buyer_region'], 'supplier_legal_name': target['supplier_name'], 'supplier_country': target['supplier_country'], 'supplier_industry': target['supplier_industry'], 'invoice_number': target['invoice_number'], 'currency': target['currency'], 'requested_amount': target['requested_amount'], 'instruction': 'Use the current program maximum advance rate and standard discount, then settle the factoring advance.'}) |
| for (index, target) in enumerate(target_specs, start=1): |
| entities['program'].extend([{'program_id': target['program_id'], 'buyer_id': target['buyer_id'], 'program_name': f'Current program {index}', 'program_type': 'invoice_factoring', 'currency': target['currency'], 'status': 'active', 'max_advance_rate_percent': target['advance_rate_percent'], 'base_discount_rate_percent': target['discount_rate_percent'], 'settlement_terms_days': 15, 'created_at': '2026-01-01T09:00:00Z', 'updated_at': '2026-05-20T09:00:00Z'}, {'program_id': f'program-decoy-{index}', 'buyer_id': target['buyer_id'], 'program_name': f'Retired program {index}', 'program_type': 'invoice_factoring', 'currency': target['currency'], 'status': 'closed', 'max_advance_rate_percent': round(target['advance_rate_percent'] - 0.1, 3), 'base_discount_rate_percent': round(target['discount_rate_percent'] + 0.01, 3), 'settlement_terms_days': 30, 'created_at': '2025-01-01T09:00:00Z', 'updated_at': '2025-12-01T09:00:00Z'}]) |
| baseline_used = float(200 * index) |
| limit_amount = float(10000 + index * 1000) |
| entities['credit_limit'].append({'credit_limit_id': target['credit_limit_id'], 'buyer_id': target['buyer_id'], 'supplier_id': target['supplier_id'], 'program_id': target['program_id'], 'currency': target['currency'], 'limit_amount': limit_amount, 'used_amount': baseline_used, 'available_amount': limit_amount - baseline_used, 'status': 'active', 'risk_grade': 'strong', 'approved_by': 'Credit Committee', 'effective_from': '2026-01-01T09:00:00Z', 'effective_until': None, 'created_at': '2026-01-01T09:00:00Z', 'updated_at': '2026-05-20T09:00:00Z'}) |
| entities['invoice'].extend([{'invoice_id': target['invoice_id'], 'invoice_number': target['invoice_number'], 'buyer_id': target['buyer_id'], 'supplier_id': target['supplier_id'], 'program_id': target['program_id'], 'credit_limit_id': target['credit_limit_id'], 'currency': target['currency'], 'description': f'T01 target invoice {index}', 'gross_amount': target['requested_amount'], 'approved_amount': target['requested_amount'], 'paid_amount': 0.0, 'outstanding_amount': target['requested_amount'], 'status': 'approved', 'payment_status': 'unpaid', 'eligible_for_factoring': True, 'issue_date': '2026-05-01T09:00:00Z', 'due_date': '2026-10-15T09:00:00Z', 'approved_at': '2026-05-02T09:00:00Z', 'created_at': '2026-05-01T09:00:00Z', 'updated_at': '2026-05-02T09:00:00Z'}, {'invoice_id': f'invoice-decoy-{index}', 'invoice_number': f'DECOY-2609-{index:04d}', 'buyer_id': target['buyer_id'], 'supplier_id': target['supplier_id'], 'program_id': target['program_id'], 'credit_limit_id': target['credit_limit_id'], 'currency': target['currency'], 'description': f'Ineligible comparison invoice {index}', 'gross_amount': target['requested_amount'] + 111.0, 'approved_amount': target['requested_amount'] + 111.0, 'paid_amount': 0.0, 'outstanding_amount': target['requested_amount'] + 111.0, 'status': 'disputed', 'payment_status': 'unpaid', 'eligible_for_factoring': False, 'issue_date': '2026-04-01T09:00:00Z', 'due_date': '2026-09-15T09:00:00Z', 'approved_at': '2026-04-02T09:00:00Z', 'created_at': '2026-04-01T09:00:00Z', 'updated_at': '2026-04-02T09:00:00Z'}]) |
| allocation_rules = [{'rank': 1, 'allocation_target': 'platform_fee', 'percentage': 0.02}, {'rank': 2, 'allocation_target': 'funder_advance', 'percentage': 0.9}, {'rank': 3, 'allocation_target': 'supplier_reserve', 'percentage': 0.07}, {'rank': 4, 'allocation_target': 'buyer_rebate', 'percentage': 0.01}] |
| entities['payment_waterfall'].extend([{'payment_waterfall_id': target['waterfall_id'], 'program_id': target['program_id'], 'buyer_id': target['buyer_id'], 'currency': target['currency'], 'name': f'Current allocation {index}', 'status': 'active', 'priority_rules': allocation_rules, 'reserve_release_days': 30, 'effective_from': '2026-05-01T09:00:00Z', 'effective_until': None, 'created_at': '2026-05-01T09:00:00Z', 'updated_at': '2026-05-01T09:00:00Z'}, {'payment_waterfall_id': f'payment-waterfall-retired-{index}', 'program_id': target['program_id'], 'buyer_id': target['buyer_id'], 'currency': target['currency'], 'name': f'Retired allocation {index}', 'status': 'retired', 'priority_rules': allocation_rules, 'reserve_release_days': 45, 'effective_from': '2025-01-01T09:00:00Z', 'effective_until': '2026-04-30T09:00:00Z', 'created_at': '2025-01-01T09:00:00Z', 'updated_at': '2026-04-30T09:00:00Z'}]) |
| baseline_limits = {row['credit_limit_id']: {'used_amount': row['used_amount'], 'available_amount': row['available_amount']} for row in entities['credit_limit']} |
| return {'entities': entities, 'queues': queue_rows, 'work_items': work_items, 'targets': target_specs, 'baseline_limits': baseline_limits} |
|
|
| def fn__profile_entities(profile, index): |
| timestamp = '2026-05-20T09:00:00Z' |
| buyer = {'buyer_id': profile['buyer_id'], 'legal_name': profile['buyer_name'], 'status': 'active', 'risk_tier': profile['buyer_risk'], 'region': profile['buyer_region'], 'credit_rating': 'A' if profile['buyer_risk'] == 'low' else 'BBB', 'default_currency': profile['currency'], 'payment_terms_days': 30, 'created_at': '2026-01-01T09:00:00Z', 'updated_at': timestamp} |
| supplier = {'supplier_id': profile['supplier_id'], 'legal_name': profile['supplier_name'], 'status': 'active', 'country': profile['supplier_country'], 'industry': profile['supplier_industry'], 'primary_contact': f'Operations contact {index}', 'contact_email': f'ops{index}@example.test', 'preferred_currency': profile['currency'], 'created_at': '2026-01-01T09:00:00Z', 'updated_at': timestamp} |
| kyc = {'supplier_kyc_profile_id': f'supplier-kyc-stream-{index:02d}', 'supplier_id': profile['supplier_id'], 'status': 'verified', 'risk_score': 10 + index, 'risk_band': 'low', 'beneficial_owner_verified': True, 'sanctions_screen_status': 'clear', 'tax_document_status': 'accepted', 'reviewed_at': '2026-05-01T09:00:00Z', 'next_review_at': '2026-12-01T09:00:00Z', 'created_at': '2026-04-30T09:00:00Z', 'updated_at': '2026-05-01T09:00:00Z'} |
| program = {'program_id': profile['program_id'], 'buyer_id': profile['buyer_id'], 'program_name': f'Current finance program {index:02d}', 'program_type': 'invoice_factoring', 'currency': profile['currency'], 'status': 'active', 'max_advance_rate_percent': profile['advance_rate_percent'], 'base_discount_rate_percent': profile['discount_rate_percent'], 'settlement_terms_days': 15, 'created_at': '2026-01-01T09:00:00Z', 'updated_at': timestamp} |
| closed_program = {**program, 'program_id': f'program-retired-stream-{index:02d}', 'program_name': f'Retired finance program {index:02d}', 'status': 'closed', 'max_advance_rate_percent': round(profile['advance_rate_percent'] - 0.08, 3), 'base_discount_rate_percent': round(profile['discount_rate_percent'] + 0.01, 3), 'settlement_terms_days': 30, 'updated_at': '2025-12-01T09:00:00Z'} |
| limit = {'credit_limit_id': profile['credit_limit_id'], 'buyer_id': profile['buyer_id'], 'supplier_id': profile['supplier_id'], 'program_id': profile['program_id'], 'currency': profile['currency'], 'limit_amount': 100000.0, 'used_amount': float(index * 100), 'available_amount': float(100000 - index * 100), 'status': 'active', 'risk_grade': 'strong', 'approved_by': 'Credit Committee', 'effective_from': '2026-01-01T09:00:00Z', 'effective_until': None, 'created_at': '2026-01-01T09:00:00Z', 'updated_at': timestamp} |
| allocation = [{'rank': 1, 'allocation_target': 'platform_fee', 'percentage': 0.02}, {'rank': 2, 'allocation_target': 'funder_advance', 'percentage': 0.9}, {'rank': 3, 'allocation_target': 'supplier_reserve', 'percentage': 0.07}, {'rank': 4, 'allocation_target': 'buyer_rebate', 'percentage': 0.01}] |
| waterfall = {'payment_waterfall_id': profile['waterfall_id'], 'program_id': profile['program_id'], 'buyer_id': profile['buyer_id'], 'currency': profile['currency'], 'name': f'Current allocation {index:02d}', 'status': 'active', 'priority_rules': allocation, 'reserve_release_days': 30, 'effective_from': '2026-05-01T09:00:00Z', 'effective_until': None, 'created_at': '2026-05-01T09:00:00Z', 'updated_at': '2026-05-01T09:00:00Z'} |
| retired = {**waterfall, 'payment_waterfall_id': f'payment-waterfall-retired-stream-{index:02d}', 'name': f'Retired allocation {index:02d}', 'status': 'retired', 'reserve_release_days': 45, 'effective_from': '2025-01-01T09:00:00Z', 'effective_until': '2026-04-30T09:00:00Z', 'updated_at': '2026-04-30T09:00:00Z'} |
| return {'buyer': [buyer], 'supplier': [supplier], 'supplier_kyc_profile': [kyc], 'program': [program, closed_program], 'credit_limit': [limit], 'payment_waterfall': [waterfall, retired]} |
|
|
| @lru_cache(**{'maxsize': 1, 'typed': False}) |
| def fn__catalog(): |
| result = {task_id: tuple((fn__target(position, slot, structure_id, rule_id) for (slot, (structure_id, rule_id)) in enumerate(DATA_TASK_BLUEPRINT[task_id], 1))) for (position, task_id) in enumerate(DATA_TASK_IDS, 1)} |
| flattened = [row for task in result.values() for row in task] |
| for key in ('target_id', 'request_reference', 'invoice_id', 'invoice_number'): |
| if len({row[key] for row in flattened}) != 64: |
| raise ValueError(f'stream target field is not unique: {key}') |
| return result |
|
|
| def fn__target(position, slot, structure_id, rule_id): |
| profile = DATA_PROFILE_BY_RULE[rule_id] |
| (queue_id, service_band) = DATA_STRUCTURE_ATOMS[structure_id] |
| token = fn__opaque('x', position, slot, structure_id, rule_id, length=14).split('-', 1)[1] |
| amount = float(850 + (position * 173 + slot * 67 + int(rule_id[1:]) * 41) % 1150) |
| return {'position': position, 'slot': slot, 'target_id': f'finance-outcome-{token}', 'request_reference': f'SCF-{token[:5].upper()}-{token[5:10].upper()}', 'service_band': service_band, 'routing_track': DATA_STRUCTURE_TRACKS[structure_id], 'queue_id': queue_id, 'buyer_id': profile['buyer_id'], 'buyer_name': profile['buyer_name'], 'buyer_region': profile['buyer_region'], 'supplier_id': profile['supplier_id'], 'supplier_name': profile['supplier_name'], 'supplier_country': profile['supplier_country'], 'supplier_industry': profile['supplier_industry'], 'program_id': profile['program_id'], 'credit_limit_id': profile['credit_limit_id'], 'invoice_id': f'invoice-{token}', 'invoice_number': f'IV-{token[:6].upper()}-{token[6:10].upper()}', 'currency': profile['currency'], 'requested_amount': amount, 'advance_rate_percent': profile['advance_rate_percent'], 'discount_rate_percent': profile['discount_rate_percent'], 'waterfall_id': profile['waterfall_id'], 'structure_atom_id': structure_id, 'rule_atom_id': rule_id} |
|
|
| def fn_public_task_4(task_id): |
| return {'schema': 'rescopebench-supply-chain-finance-task/v5', 'case_id': 'supply_chain_finance_c_05_10_53', 'task_id': fn_opaque_event_id(task_id), 'objective': 'Complete as many listed invoice-finance requests as possible in listed priority order. Use current public evidence for each request and preserve credit, approval, payment, ledger, and reconciliation invariants.', 'targets': [{'request_reference': target['request_reference'], 'service_band': target['service_band'], 'routing_track': target['routing_track'], 'requirement': 'Fund the full eligible invoice balance under current program terms and authority, then complete settlement and matched reconciliation.'} for target in fn_stream_targets(task_id)], 'completion': {'mode': 'ordered_independent', 'subset_allowed': True, 'priority_order': 'listed', 'started_item_must_close': True, 'verification_required': True, 'verification_evidence': 'the successful finalize_factoring_advance completion_receipt; a duplicate timeline read is optional'}, 'budget': {'kind': 'finance_work_units', 'allowance': 73, 'mechanism': 'Exact queue lookup costs 2; funding-authority and credit-delegation inspections cost 7 each; bounded lists cost 2 plus returned rows; submit costs 5 and finalize costs 10. Exact timeline verification costs 1. A failed admitted submit costs 6.'}, 'status': 'candidate_model_validation', 'runnable': True} |
|
|
| @lru_cache(**{'maxsize': 1, 'typed': False}) |
| def fn__fixture_4(): |
| fixture = fn__fixture_3() |
| entities = ext_deepcopy(fixture['entities']) |
| queues = ext_deepcopy(fixture['queues']) |
| for (index, row) in enumerate(entities['credit_limit'], 1): |
| row['limit_amount'] = 100000.0 |
| row['used_amount'] = float(index * 100) |
| row['available_amount'] = float(100000 - index * 100) |
| for index in range(5, 17): |
| rows = fn__profile_entities(DATA_PROFILE_BY_RULE[f'R{index:02d}'], index) |
| for (entity_type, values) in rows.items(): |
| entities[entity_type].extend(values) |
| for task_id in DATA_TASK_IDS[1:]: |
| for target in fn_stream_targets_4(task_id): |
| entities['invoice'].extend((fn__invoice_row(target), fn__invoice_row(target, decoy=True))) |
| targets = [row for task_id in DATA_TASK_IDS for row in fn_stream_targets_4(task_id)] |
| work_items = [{'work_queue_id': target['queue_id'], 'request_reference': target['request_reference'], 'buyer_legal_name': target['buyer_name'], 'buyer_region': target['buyer_region'], 'supplier_legal_name': target['supplier_name'], 'supplier_country': target['supplier_country'], 'supplier_industry': target['supplier_industry'], 'invoice_number': target['invoice_number'], 'invoice_id': target['invoice_id'], 'currency': target['currency'], 'requested_amount': target['requested_amount'], 'instruction': 'Use the current program maximum advance rate, standard discount, and current funding authority, then settle the factoring advance.'} for target in targets] |
| baseline_limits = {row['credit_limit_id']: {'used_amount': row['used_amount'], 'available_amount': row['available_amount']} for row in entities['credit_limit']} |
| release_by_invoice: dict[str, int] = {} |
| release_by_request: dict[str, int] = {} |
| for target in targets: |
| release_by_invoice[target['invoice_id']] = target['position'] |
| release_by_invoice[f"invoice-decoy-{target['invoice_id'].removeprefix('invoice-')}"] = target['position'] |
| release_by_request[target['request_reference']] = target['position'] |
| return {'entities': entities, 'queues': queues, 'work_items': work_items, 'targets': targets, 'baseline_limits': baseline_limits, 'release_by_invoice': release_by_invoice, 'release_by_request': release_by_request} |
|
|
| def fn_stream_targets_3(task_id): |
| if task_id not in DATA_TASK_IDS: |
| raise ValueError(f'unknown stream task: {task_id}') |
| return tuple((ext_deepcopy(row) for row in fn__catalog_2()[task_id])) |
|
|
| def fn_stream_targets_4(task_id): |
| if task_id not in DATA_TASK_IDS: |
| raise ValueError(f'unknown stream task: {task_id}') |
| return tuple((ext_deepcopy(row) for row in fn__catalog_3()[task_id])) |
|
|
| @lru_cache(**{'maxsize': 1, 'typed': False}) |
| def fn__catalog_2(): |
| result = {task_id: tuple((fn__target_2(position, slot, structure_id, rule_id) for (slot, (structure_id, rule_id)) in enumerate(DATA_TASK_BLUEPRINT_2[task_id], 1))) for (position, task_id) in enumerate(DATA_TASK_IDS, 1)} |
| flattened = [row for task in result.values() for row in task] |
| for key in ('target_id', 'request_reference', 'invoice_id', 'invoice_number'): |
| if len({row[key] for row in flattened}) != 64: |
| raise ValueError(f'stream target field is not unique: {key}') |
| return result |
|
|
| @lru_cache(**{'maxsize': 1, 'typed': False}) |
| def fn__catalog_3(): |
| result = {task_id: tuple((fn__target_3(position, slot, structure_id, rule_id) for (slot, (structure_id, rule_id)) in enumerate(DATA_TASK_BLUEPRINT_3[task_id], 1))) for (position, task_id) in enumerate(DATA_TASK_IDS, 1)} |
| flattened = [row for task in result.values() for row in task] |
| for key in ('target_id', 'request_reference', 'invoice_id', 'invoice_number'): |
| if len({row[key] for row in flattened}) != 64: |
| raise ValueError(f'stream target field is not unique: {key}') |
| return result |
|
|
| def fn__target_2(position, slot, structure_id, rule_id): |
| profile = DATA_PROFILE_BY_RULE[rule_id] |
| (queue_id, service_band) = DATA_STRUCTURE_ATOMS[structure_id] |
| token = fn__opaque_3('x', position, slot, structure_id, rule_id, length=14).split('-', 1)[1] |
| amount = float(850 + (position * 173 + slot * 67 + int(rule_id[1:]) * 41) % 1150) |
| return {'position': position, 'slot': slot, 'target_id': f'finance-outcome-{token}', 'request_reference': f'SCF-{token[:5].upper()}-{token[5:10].upper()}', 'service_band': service_band, 'routing_track': DATA_STRUCTURE_TRACKS[structure_id], 'queue_id': queue_id, 'buyer_id': profile['buyer_id'], 'buyer_name': profile['buyer_name'], 'buyer_region': profile['buyer_region'], 'supplier_id': profile['supplier_id'], 'supplier_name': profile['supplier_name'], 'supplier_country': profile['supplier_country'], 'supplier_industry': profile['supplier_industry'], 'program_id': profile['program_id'], 'credit_limit_id': profile['credit_limit_id'], 'invoice_id': f'invoice-{token}', 'invoice_number': f'IV-{token[:6].upper()}-{token[6:10].upper()}', 'currency': profile['currency'], 'requested_amount': amount, 'advance_rate_percent': profile['advance_rate_percent'], 'discount_rate_percent': profile['discount_rate_percent'], 'waterfall_id': profile['waterfall_id'], 'structure_atom_id': structure_id, 'rule_atom_id': rule_id} |
|
|
| def fn__target_3(position, slot, structure_id, rule_id): |
| profile = DATA_PROFILE_BY_RULE[rule_id] |
| (queue_id, service_band) = DATA_STRUCTURE_ATOMS[structure_id] |
| if position == 1: |
| original = ext_deepcopy(fn__fixture_3()['targets'][slot - 1]) |
| original.update({'position': position, 'slot': slot, 'structure_atom_id': structure_id, 'rule_atom_id': rule_id, 'routing_track': DATA_STRUCTURE_TRACKS[structure_id]}) |
| return original |
| token = fn__opaque_2('x', position, slot, structure_id, rule_id, length=14).split('-', 1)[1] |
| amount = float(850 + (position * 173 + slot * 67 + int(rule_id[1:]) * 41) % 1150) |
| return {'position': position, 'slot': slot, 'target_id': f'finance-outcome-{token}', 'request_reference': f'SCF-{token[:5].upper()}-{token[5:10].upper()}', 'service_band': service_band, 'routing_track': DATA_STRUCTURE_TRACKS[structure_id], 'queue_id': queue_id, 'buyer_id': profile['buyer_id'], 'buyer_name': profile['buyer_name'], 'buyer_region': profile['buyer_region'], 'supplier_id': profile['supplier_id'], 'supplier_name': profile['supplier_name'], 'supplier_country': profile['supplier_country'], 'supplier_industry': profile['supplier_industry'], 'program_id': profile['program_id'], 'credit_limit_id': profile['credit_limit_id'], 'invoice_id': f'invoice-{token}', 'invoice_number': f'IV-{token[:6].upper()}-{token[6:10].upper()}', 'currency': profile['currency'], 'requested_amount': amount, 'advance_rate_percent': profile['advance_rate_percent'], 'discount_rate_percent': profile['discount_rate_percent'], 'waterfall_id': profile['waterfall_id'], 'structure_atom_id': structure_id, 'rule_atom_id': rule_id} |
|
|
| def fn__opaque_3(prefix, *parts, length=12): |
| seed = '|'.join((str(part) for part in parts)) |
| value = mod_hashlib.sha256(f'scf-authority-v4|{seed}'.encode('utf-8')).hexdigest() |
| return f'{prefix}-{value[:length]}' |
|
|
| class World: |
|
|
| def _prior_targets_complete(self, target): |
| return True |
|
|
| def snapshot(self): |
| value = self._scf_lead_retest_world_snapshot() |
| if not getattr(self, '_restoring_independent', False): |
| value['independent_settlement_contract'] = 'scf-independent-settlements-evolution-v3' |
| return value |
|
|
| def restore(self, snapshot): |
| value = ext_deepcopy(snapshot) |
| if value.pop('independent_settlement_contract', None) != 'scf-independent-settlements-evolution-v3': |
| raise ValueError('SCF independent-settlement snapshot version differs') |
| self._restoring_independent = True |
| try: |
| self._scf_lead_retest_world_restore(value) |
| finally: |
| self._restoring_independent = False |
| if self.snapshot() != snapshot: |
| raise ValueError('SCF independent-settlement snapshot did not round trip') |
|
|
| def activate_task(self, task_id, **kwargs): |
| result = self._scf_evolution_activate_task(task_id, **kwargs) |
| if task_id in DATA_RETEST_TASKS: |
| self._targets = [self._targets[i] for i in DATA_RETEST_ORDER] |
| for (slot, row) in enumerate(self._targets, 1): |
| row['slot'] = slot |
| result['data']['event_id'] = fn_public_task(task_id)['task_id'] |
| return result |
|
|
| def __init__(self, *args, **kwargs): |
| self._own_settlements = {} |
| self._supply_chain_finance_authority_init(*args, **kwargs) |
|
|
| def dispatch(self, name, arguments, actor_id='operator-t01-scf'): |
| exact = name == 'get_invoice_timeline' and isinstance(arguments, dict) and (set(arguments) == {'invoice_id'}) and isinstance(arguments['invoice_id'], str) and (actor_id == 'operator-t01-scf') |
| issued = self._own_settlements.get(arguments['invoice_id']) if exact else None |
| if issued is not None and issued['task_id'] == self._task_id: |
| before = self.business_hash() |
| result = {'status': 'success', 'data': {'invoice_id': arguments['invoice_id'], 'confirmation_only': True, 'completion_receipt': ext_deepcopy(issued['receipt']), 'budget': self._budget_receipt(0)}, 'message': 'Receipt for your completed settlement in this episode.'} |
| self._record_event(name, actor_id, result, before, before, 0) |
| return result |
| result = self._supply_chain_finance_authority_dispatch(name, arguments, actor_id) |
| if name == 'finalize_factoring_advance' and result.get('status') == 'success': |
| request = self._state.get_entity('factoring_request', arguments['factoring_request_id'], 'factoring_request_id') |
| self._own_settlements[request['invoice_id']] = {'task_id': self._task_id, 'receipt': ext_deepcopy(result['data']['completion_receipt'])} |
| return result |
|
|
| def _submit(self, arguments): |
| outside = self._active_target_by_invoice(arguments['invoice_id']) is None |
| result = self._supply_chain_finance_authority_submit(arguments) |
| if outside and result.get('data', {}).get('error_code') == 'INVOICE_NOT_FOUND': |
| result['data']['error_code'] = 'INVOICE_OUTSIDE_CURRENT_REQUESTS' |
| result['message'] = "This invoice is not among the current event's requested invoices." |
| return result |
|
|
| @staticmethod |
| def _public_receipt(kind, *parts): |
| payload = '|'.join((str(part) for part in parts)) |
| token = mod_hashlib.sha256(f'scf-v5-receipt|{kind}|{payload}'.encode('utf-8')).hexdigest() |
| return f'{kind}-{token[:20]}' |
|
|
| def _finalize(self, arguments, actor_id): |
| result = self._supply_chain_finance_authority_finalize(arguments, actor_id) |
| if result.get('status') != 'success': |
| return result |
| result['data']['completion_receipt'] = {'receipt_id': self._public_receipt('completion', arguments['factoring_request_id'], arguments['payment_amount']), 'factoring_request_id': arguments['factoring_request_id'], 'status': 'settled_and_reconciled', 'verification_complete': True} |
| return result |
|
|
| def cost(self, before, action, result, after): |
| if action['tool'] == 'get_invoice_timeline': |
| return 1 |
| if action['tool'] == 'submit_factoring_request' and result.get('status') != 'success': |
| return 6 |
| return self._supply_chain_finance_authority_cost(before, action, result, after) |
|
|
| def grade(self, task_id): |
| grade = self._persistent_supply_chain_finance_adapter_grade(task_id) |
| for deliverable in grade['deliverables']: |
| deliverable['diagnostic_score'] = deliverable['score'] |
| deliverable['score'] = 25.0 if deliverable['score'] == 25.0 else 0.0 |
| grade['score'] = sum((row['score'] for row in grade['deliverables'])) |
| grade['completed_artifacts'] = int(grade['score'] // 25.0) |
| return grade |
|
|
| def apply_drift(self): |
| before = self.business_hash() |
| if 'evt-finance-authority-rotation-2026-09-v5' in self._applied_boundary_events: |
| return {'event_id': 'evt-finance-authority-rotation-2026-09-v5', 'applied': False, 'idempotent_noop': True, 'before_world_sha256': before, 'after_world_sha256': before} |
| self.authority_moved = True |
| self.authority = ext_deepcopy(DATA_POST_AUTHORITY) |
| self._applied_boundary_events.append('evt-finance-authority-rotation-2026-09-v5') |
| after = self.business_hash() |
| return {'event_id': 'evt-finance-authority-rotation-2026-09-v5', 'applied': True, 'idempotent_noop': False, 'before_world_sha256': before, 'after_world_sha256': after} |
|
|
| def public_tool_schemas(self, role): |
| return ext_deepcopy(DATA_TOOLS_2) if role == 'supply_chain_finance_operations' else [] |
|
|
| def _active_target_by_request(self, request_reference): |
| return next((row for row in self._targets if row['request_reference'] == request_reference), None) |
|
|
| def _active_target_by_invoice(self, invoice_id): |
| return next((row for row in self._targets if row['invoice_id'] == invoice_id), None) |
|
|
| def _inspect_queue(self, arguments): |
| result = World._persistent_supply_chain_finance_adapter_inspect_queue(self, arguments) |
| target = self._active_target_by_request(arguments['request_reference']) |
| if result.get('status') == 'success' and result['data'].get('found') and target: |
| result['data']['request']['invoice_id'] = target['invoice_id'] |
| return result |
|
|
| def _inspect_funding_authority(self, arguments): |
| target = self._active_target_by_request(arguments['request_reference']) |
| if target is None or target['queue_id'] != arguments['work_queue_id']: |
| return {'status': 'success', 'data': {'status': 'succeeded', 'error_code': None, 'found': False, 'funding_route_candidates': []}, 'message': 'No matching request authority was found'} |
| candidates = fn__authority_candidates(target['structure_atom_id'], self.authority[target['structure_atom_id']]) |
| return {'status': 'success', 'data': {'status': 'succeeded', 'error_code': None, 'found': True, 'funding_route_candidates': ext_deepcopy(candidates['routes'])}, 'message': 'Funding authority candidates inspected'} |
|
|
| def _inspect_credit_limit(self, arguments): |
| result = World._persistent_supply_chain_finance_adapter_execute(self, 'inspect_credit_limit', arguments, 'operator-t01-scf') |
| target = next((row for row in self._targets if row['credit_limit_id'] == arguments['credit_limit_id']), None) |
| if result.get('status') == 'success' and target: |
| candidates = fn__authority_candidates(target['structure_atom_id'], self.authority[target['structure_atom_id']]) |
| result['data']['approval_delegation_candidates'] = ext_deepcopy(candidates['delegations']) |
| return result |
|
|
| def _rename_approval_tasks(self, target, authority, raw_ids): |
| expected = fn_approval_task_ids(target, authority) |
| if len(raw_ids) != len(expected): |
| raise ValueError('raw approval chain does not contain four tasks') |
| delegate_by_role = {row['role']: row for row in authority['delegations']} |
| renamed = [] |
| for (old_id, new_id) in zip(raw_ids, expected): |
| task = self._state.get_entity('approval_task', old_id, 'approval_task_id') |
| if task is None: |
| raise ValueError('raw approval task is missing') |
| delegate = delegate_by_role[task['approver_role']] |
| updated = self._state.update_entity('approval_task', old_id, {'approval_task_id': new_id, 'authority_scope_id': authority['funding_scope_id'], 'approval_chain_ref': authority['approval_chain_ref'], 'delegation_id': delegate['delegation_id'], 'delegated_principal_id': delegate['principal_id'], 'delegation_status': delegate['status']}, id_field='approval_task_id') |
| if updated is None: |
| raise ValueError('approval task rename failed') |
| renamed.append(new_id) |
| return renamed |
|
|
| def _execute(self, name, arguments, actor_id): |
| if name == 'inspect_finance_work_queue': |
| return self._inspect_queue(arguments) |
| if name == 'inspect_funding_authority': |
| return self._inspect_funding_authority(arguments) |
| if name == 'inspect_credit_limit': |
| return self._inspect_credit_limit(arguments) |
| if name == 'submit_factoring_request': |
| return self._submit(arguments) |
| if name == 'finalize_factoring_advance': |
| return self._finalize(arguments, actor_id) |
| return World._persistent_supply_chain_finance_adapter_execute(self, name, arguments, actor_id) |
|
|
| def business_hash(self): |
| return fn__hash({'entities': self._state.snapshot()['entities'], 'boundary_events': self._applied_boundary_events, 'authority': self.authority}) |
|
|
| @property |
| def applied_boundary_events(self): |
| return tuple(self._applied_boundary_events) |
|
|
| @property |
| def current_terms(self): |
| result = {} |
| for (rule_id, profile) in DATA_PROFILE_BY_RULE.items(): |
| program = self._state.get_entity('program', profile['program_id'], 'program_id') |
| if program is None: |
| raise ValueError(f'missing program for {rule_id}') |
| result[rule_id] = (float(program['max_advance_rate_percent']), float(program['base_discount_rate_percent'])) |
| return result |
|
|
| def task_targets(self): |
| return [{'target_id': row['target_id'], 'request_reference': row['request_reference'], 'service_band': row['service_band']} for row in self._targets] |
|
|
| def current_episode_events(self): |
| return ext_deepcopy(self._events[self._episode_event_start:]) |
|
|
| def _active_position(self): |
| return DATA_TASK_IDS.index(self._task_id) + 1 if self._task_id in DATA_TASK_IDS else 0 |
|
|
| def _visible_state(self): |
| position = self._active_position() |
| entities = self._state.snapshot()['entities'] |
| entities['invoice'] = [row for row in entities['invoice'] if self._release_by_invoice.get(row['invoice_id'], 0) <= position] |
| visible_invoice_ids = {row['invoice_id'] for row in entities['invoice']} |
| for entity_type in ('factoring_request', 'approval_task', 'early_payment_offer', 'payment', 'reconciliation_item', 'dispute'): |
| entities[entity_type] = [row for row in entities[entity_type] if row.get('invoice_id') in visible_invoice_ids] |
| return MemoryState(entities) |
|
|
| def _search_invoices(self, arguments): |
| result = self._logic.LOGIC_BY_TOOL['search_invoices'](self._visible_state(), **ext_deepcopy(arguments)) |
| _normalize = fn__normalize |
| normalized = _normalize(result) |
| if normalized.get('status') == 'success': |
| for item in normalized['data'].get('invoices', []): |
| invoice = self._state.get_entity('invoice', item['invoice_id'], 'invoice_id') or {} |
| item['credit_limit_id'] = invoice.get('credit_limit_id') |
| item['currency'] = invoice.get('currency') |
| return normalized |
|
|
| def lineage_hash(self): |
| return fn__hash(self.snapshot()) |
|
|
| def semantic_hash(self, snapshot=None): |
| return fn__hash(snapshot if snapshot is not None else self.snapshot()) |
|
|
| def close(self): |
| return None |
|
|
| 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 configure_fault_injection(self, tool_name, after_mutations=1): |
| if tool_name not in DATA_WRITE_TOOLS or after_mutations < 1: |
| raise ValueError('fault injection requires a write tool and positive mutation count') |
| self._state.configure_fault(tool_name, after_mutations) |
|
|
| def _business_hash(self): |
| return fn__hash(self._state.snapshot()) |
|
|
| def _budget_receipt(self, charged): |
| return {'charged_work_units': charged, 'work_units_used': self._work_units, 'work_units_remaining': self._work_unit_limit - self._work_units, 'call_attempts_used': self._calls, 'call_attempts_remaining': 64 - self._calls, 'write_attempts_used': self._writes, 'write_attempts_remaining': 10 - self._writes} |
|
|
| def _record_event(self, name, actor_id, result, before_hash, after_hash, charged): |
| self._events.append({'sequence': len(self._events) + 1, 'channel': 'learner', 'tool': name, 'actor_id': actor_id, 'status': result.get('status'), 'error_code': result.get('data', {}).get('error_code'), 'state_hash_before': before_hash, 'state_hash_after': after_hash, **self._budget_receipt(charged)}) |
|
|
| def _raw(self, name, arguments): |
| function = self._logic.LOGIC_BY_TOOL[name] |
| return fn__normalize(function(self._state, **ext_deepcopy(arguments))) |
|
|
| def _list_queues(self, arguments): |
| rows = self._queues |
| if arguments.get('service_band'): |
| rows = [row for row in rows if row['service_band'] == arguments['service_band']] |
| offset = arguments.get('offset', 0) |
| limit = arguments.get('limit', 8) |
| page = rows[offset:offset + limit] |
| return fn__success(work_queues=page, count=len(page), total_count=len(rows), offset=offset, limit=limit) |
|
|
| def _require_success(self, result): |
| if result.get('status') != 'success': |
| raise Abort(result) |
| return result['data'] |
|
|
| def _result_rows(self, name, result): |
| if result.get('status') != 'success': |
| return 0 |
| data = result.get('data', {}) |
| key_by_tool = {'list_finance_work_queues': 'work_queues', 'list_buyers': 'buyers', 'list_suppliers': 'suppliers', 'list_programs': 'programs', 'search_invoices': 'invoices', 'get_invoice_timeline': 'timeline'} |
| key = key_by_tool.get(name) |
| return len(data.get(key, [])) if key else 0 |
|
|
| def _assert_invariants(self): |
| for (entity_type, id_field) in DATA_ENTITY_ID_FIELDS.items(): |
| rows = self._state.list_entities(entity_type) |
| identifiers = [row.get(id_field) for row in rows] |
| if None in identifiers or len(identifiers) != len(set(identifiers)): |
| raise ValueError(f'{entity_type} identities are missing or duplicated') |
| limits = {row['credit_limit_id']: row for row in self._state.list_entities('credit_limit')} |
| invoices = {row['invoice_id']: row for row in self._state.list_entities('invoice')} |
| requests = self._state.list_entities('factoring_request') |
| tasks = {row['approval_task_id']: row for row in self._state.list_entities('approval_task')} |
| payments = {row['payment_id']: row for row in self._state.list_entities('payment')} |
| waterfalls = {row['payment_waterfall_id']: row for row in self._state.list_entities('payment_waterfall')} |
| for (limit_id, limit) in limits.items(): |
| if fn__money(limit['used_amount'] + limit['available_amount']) != fn__money(limit['limit_amount']): |
| raise ValueError(f'credit limit {limit_id} does not conserve capacity') |
| baseline = self._baseline_limits.get(limit_id) |
| if baseline is None: |
| continue |
| reserved = sum((fn__money(request.get('requested_amount')) for request in requests if invoices.get(request.get('invoice_id'), {}).get('credit_limit_id') == limit_id and request.get('status') in {'submitted', 'approved', 'funded'})) |
| if fn__money(limit['used_amount']) != fn__money(baseline['used_amount'] + reserved): |
| raise ValueError(f'credit limit {limit_id} reservation is inconsistent') |
| for request in requests: |
| invoice = invoices.get(request.get('invoice_id')) |
| if invoice is None: |
| raise ValueError('factoring request references an unknown invoice') |
| linked = [tasks.get(task_id) for task_id in request.get('approval_task_ids', [])] |
| if len(linked) != 4 or any((task is None for task in linked)): |
| raise ValueError('factoring request does not have four approval tasks') |
| if {task['approver_role'] for task in linked} != set(DATA_APPROVAL_ROLES): |
| raise ValueError('factoring request approval roles are incomplete') |
| if request.get('status') in {'approved', 'funded'}: |
| if any((task.get('status') != 'approved' for task in linked)): |
| raise ValueError('approved request has incomplete approval state') |
| if any((task.get('assigned_to') != 'operator-t01-scf' for task in linked)): |
| raise ValueError('approval decision is not bound to the authenticated actor') |
| for payment in payments.values(): |
| invoice = invoices.get(payment.get('invoice_id')) |
| waterfall = waterfalls.get(payment.get('payment_waterfall_id')) |
| if invoice is None or waterfall is None: |
| raise ValueError('payment references an unknown invoice or waterfall') |
| if payment.get('status') == 'settled': |
| if waterfall.get('status') != 'active': |
| raise ValueError('settled payment references a retired waterfall') |
| allocation = payment.get('allocation_breakdown') or {} |
| if fn__money(sum((float(value) for value in allocation.values()))) != fn__money(payment['amount']): |
| raise ValueError('payment allocation does not conserve value') |
| for invoice in invoices.values(): |
| if fn__money(invoice.get('paid_amount') + invoice.get('outstanding_amount')) != fn__money(invoice.get('gross_amount')): |
| raise ValueError('invoice paid and outstanding amounts do not conserve value') |
|
|
| def _supply_chain_finance_authority_restore(self, snapshot): |
| if snapshot.get('schema') != 'rescopebench-supply-chain-finance-authority/v5': |
| raise ValueError('unsupported authority-v5 snapshot schema') |
| base = ext_deepcopy(snapshot) |
| base['schema'] = 'rescopebench-supply-chain-finance-authority/v4' |
| self._supply_chain_finance_authority_restore_2(base) |
|
|
| def _scf_lead_retest_world_snapshot(self): |
| value = self._scf_evolution_snapshot() |
| value['lead_retest_contract'] = 'scf-lead-retest-lifecycle-evolution-v2' |
| return value |
|
|
| def _scf_lead_retest_world_restore(self, snapshot): |
| value = ext_deepcopy(snapshot) |
| if value.pop('lead_retest_contract', None) != 'scf-lead-retest-lifecycle-evolution-v2': |
| raise ValueError('SCF lead-retest snapshot version differs') |
| self._scf_evolution_restore(value) |
| if self.snapshot() != snapshot: |
| raise ValueError('SCF lead-retest snapshot did not round trip') |
|
|
| def _scf_evolution_activate_task(self, task_id, *, apply_boundary=True): |
| before = self.snapshot() |
| try: |
| index = len(self._activated_tasks) |
| if index >= len(DATA_TASK_IDS) or DATA_TASK_IDS[index] != task_id: |
| raise ValueError('out-of-order SCF activation') |
| if task_id == 'T13' and apply_boundary: |
| self.apply_drift() |
| result = World._supply_chain_finance_authority_activate_task(self, task_id, apply_boundary=False) |
| if task_id in DATA_REPLACEMENTS: |
| self.restore(fn_activate_coverage(self.snapshot(), task_id, self.current_terms)) |
| self._own_settlements = {} |
| result['data']['event_id'] = fn_public_task_2(task_id)['task_id'] |
| return result |
| except Exception: |
| self.restore(before) |
| raise |
|
|
| def _supply_chain_finance_authority_init(self, source_root=None, source=None, work_unit_limit=73): |
| self._supply_chain_finance_authority_init_2(source_root=source_root, source=source, work_unit_limit=work_unit_limit) |
| fixture = ext_deepcopy(fn__fixture()) |
| self._state = MemoryState(fixture['entities']) |
| self._queues = fixture['queues'] |
| self._work_items = fixture['work_items'] |
| self._all_targets = fixture['targets'] |
| self._release_by_invoice = fixture['release_by_invoice'] |
| self._release_by_request = fixture['release_by_request'] |
| self._initial_limits = fixture['baseline_limits'] |
| self._targets = [] |
| self._baseline_limits = ext_deepcopy(self._initial_limits) |
| self._task_baseline_limits = {} |
| self._task_id = None |
| self._activated_tasks = [] |
| self._applied_boundary_events = [] |
| self._events = [] |
| self._episode_event_start = 0 |
| self._calls = 0 |
| self._writes = 0 |
| self._work_units = 0 |
| self.authority_moved = False |
| self.authority = ext_deepcopy(DATA_PRE_AUTHORITY) |
| self._assert_invariants() |
|
|
| def _supply_chain_finance_authority_dispatch(self, name, arguments, actor_id='operator-t01-scf'): |
| if self._task_id is None: |
| return fn__error('TASK_NOT_ACTIVE', 'activate a task before dispatch') |
| tool = DATA_TOOL_BY_NAME.get(name) |
| if tool is None: |
| return fn__error('TOOL_NOT_ALLOWED', 'tool is not in the learner allowlist') |
| if actor_id != 'operator-t01-scf': |
| return fn__error('ACTOR_NOT_AUTHORIZED', 'actor is not an authorized finance operator') |
| try: |
| mod_jsonschema.validate(arguments, tool['input_schema']) |
| except mod_jsonschema.ValidationError: |
| return fn__error('INVALID_ARGUMENTS', 'arguments do not match the public tool schema') |
| if self._calls >= 64: |
| return fn__error('CALL_LIMIT_EXHAUSTED', 'task safety call limit is exhausted') |
| if name in DATA_WRITE_TOOLS and self._writes >= 10: |
| return fn__error('WRITE_LIMIT_EXHAUSTED', 'task write-attempt limit is exhausted') |
| before_state = self._state.snapshot() |
| before_hash = self.business_hash() |
| self._state.begin_tool(name) |
| try: |
| result = self._execute(name, ext_deepcopy(arguments), actor_id) |
| if result.get('status') != 'success': |
| raise Abort(result) |
| if name in DATA_WRITE_TOOLS: |
| self._assert_invariants() |
| except Abort as exc: |
| self._state.restore(before_state) |
| result = exc.result |
| except Exception: |
| self._state.restore(before_state) |
| result = fn__error('ADAPTER_EXECUTION_FAILED', 'operation failed without committing state') |
| finally: |
| self._state.end_tool() |
| after_state = self._state.snapshot() |
| charged = self.cost(before_state, {'tool': name, 'arguments': ext_deepcopy(arguments)}, result, after_state) |
| if self._work_units + charged > self._work_unit_limit: |
| self._state.restore(before_state) |
| result = fn__error('WORK_BUDGET_EXHAUSTED', 'the remaining work units cannot fund this operation') |
| result['data']['budget'] = self._budget_receipt(0) |
| return result |
| self._calls += 1 |
| self._work_units += charged |
| if name in DATA_WRITE_TOOLS: |
| self._writes += 1 |
| after_hash = self.business_hash() |
| result.setdefault('data', {})['budget'] = self._budget_receipt(charged) |
| self._record_event(name, actor_id, result, before_hash, after_hash, charged) |
| return ext_deepcopy(result) |
|
|
| def _supply_chain_finance_authority_submit(self, arguments): |
| result = self._supply_chain_finance_authority_submit_2(arguments) |
| if result.get('status') != 'success': |
| return result |
| requested = float(arguments['requested_amount']) |
| discount = float(arguments['fee_rate_percent']) |
| result['data']['settlement_quote'] = {'factoring_request_id': result['data']['factoring_request_id'], 'offered_amount': requested, 'discount_rate_percent': discount, 'payment_amount': round(requested * (1 - discount), 2), 'quote_status': 'current'} |
| result['data']['submission_receipt_id'] = self._public_receipt('submission', result['data']['factoring_request_id'], requested, discount) |
| return result |
|
|
| def _supply_chain_finance_authority_finalize(self, arguments, actor_id): |
| request = self._state.get_entity('factoring_request', arguments['factoring_request_id'], 'factoring_request_id') |
| if request is None: |
| return World._supply_chain_finance_adapter_finalize(self, arguments, actor_id) |
| tasks = [self._state.get_entity('approval_task', task_id, 'approval_task_id') for task_id in arguments['approval_task_ids']] |
| if any((task is None for task in tasks)) or any((task.get('authority_scope_id') != request.get('funding_scope_id') or task.get('approval_chain_ref') != request.get('approval_chain_ref') or task.get('delegated_principal_id') != actor_id or (task.get('delegation_status') != 'active') for task in tasks)): |
| return fn__error('APPROVAL_AUTHORITY_MISMATCH', 'the supplied approval authority is not valid for this request scope') |
| return World._supply_chain_finance_adapter_finalize(self, arguments, actor_id) |
|
|
| def _supply_chain_finance_authority_cost(self, before, action, result, after): |
| if action['tool'] in DATA_READ_COSTS: |
| return DATA_READ_COSTS[action['tool']] |
| return World._supply_chain_finance_adapter_cost(self, before, action, result, after) |
|
|
| def _persistent_supply_chain_finance_adapter_grade(self, task_id): |
| if task_id != self._task_id: |
| raise ValueError('only the active task can be graded') |
| active = self._task_id |
| persistent_baselines = self._baseline_limits |
| self._task_id = 'T01' |
| self._baseline_limits = self._task_baseline_limits |
| try: |
| grade = self._supply_chain_finance_adapter_grade('T01') |
| finally: |
| self._task_id = active |
| self._baseline_limits = persistent_baselines |
| grade['task_id'] = task_id |
| return grade |
|
|
| def _persistent_supply_chain_finance_adapter_inspect_queue(self, arguments): |
| queue = next((row for row in self._queues if row['work_queue_id'] == arguments['work_queue_id']), None) |
| if queue is None: |
| return fn__error('WORK_QUEUE_NOT_FOUND', 'finance work queue does not exist') |
| position = self._active_position() |
| item = next((row for row in self._work_items if self._release_by_request[row['request_reference']] <= position and row['work_queue_id'] == arguments['work_queue_id'] and (row['request_reference'] == arguments['request_reference'])), None) |
| return {'status': 'success', 'data': {'status': 'succeeded', 'error_code': None, 'work_queue': ext_deepcopy(queue), 'found': item is not None, 'request': ext_deepcopy(item)}, 'message': 'OK'} |
|
|
| def _persistent_supply_chain_finance_adapter_execute(self, name, arguments, actor_id): |
| if name == 'get_invoice_timeline': |
| invoice_id = arguments.get('invoice_id') |
| if self._release_by_invoice.get(invoice_id, 0) > self._active_position(): |
| return fn__error('INVOICE_NOT_FOUND', 'invoice not found') |
| _normalize = fn__normalize |
| return _normalize(self._logic.LOGIC_BY_TOOL[name](self._visible_state(), **ext_deepcopy(arguments))) |
| if name == 'submit_factoring_request': |
| invoice_id = arguments.get('invoice_id') |
| if self._release_by_invoice.get(invoice_id, 0) > self._active_position(): |
| return fn__error('INVOICE_NOT_FOUND', 'invoice not found') |
| return self._supply_chain_finance_adapter_execute(name, arguments, actor_id) |
|
|
| def _supply_chain_finance_authority_restore_2(self, snapshot): |
| if snapshot.get('schema') != 'rescopebench-supply-chain-finance-authority/v4': |
| raise ValueError('unsupported authority-v4 snapshot schema') |
| base = ext_deepcopy(snapshot) |
| base['schema'] = 'rescopebench-supply-chain-finance-authority/v3' |
| self._supply_chain_finance_authority_restore_3(base) |
|
|
| def _scf_evolution_snapshot(self): |
| value = self._supply_chain_finance_authority_snapshot() |
| value['evolution_contract'] = {'case_version': 'scf-authority-lifecycle-evolution-v1', 'schedule': ext_deepcopy(DATA_SCHEDULE_2)} |
| value['own_settlement_receipts'] = ext_deepcopy(self._own_settlements) |
| return value |
|
|
| def _scf_evolution_restore(self, snapshot): |
| value = ext_deepcopy(snapshot) |
| if value.pop('evolution_contract', None) != {'case_version': 'scf-authority-lifecycle-evolution-v1', 'schedule': DATA_SCHEDULE_2}: |
| raise ValueError('SCF evolution contract differs') |
| self._own_settlements = value.pop('own_settlement_receipts') |
| self._supply_chain_finance_authority_restore(value) |
|
|
| def _supply_chain_finance_authority_activate_task(self, task_id, *, apply_boundary=True): |
| if task_id not in DATA_TASK_IDS: |
| raise ValueError(f'unknown stream task: {task_id}') |
| expected = DATA_TASK_IDS[len(self._activated_tasks)] if len(self._activated_tasks) < 16 else None |
| if task_id != expected: |
| raise ValueError(f'expected {expected}, received {task_id}') |
| if task_id == 'T09' and apply_boundary: |
| self.apply_drift() |
| current_terms = self.current_terms |
| self._targets = [] |
| for target in fn_stream_targets(task_id): |
| active = ext_deepcopy(target) |
| (active['advance_rate_percent'], active['discount_rate_percent']) = current_terms[target['rule_atom_id']] |
| self._targets.append(active) |
| self._task_baseline_limits = {} |
| for target in self._targets: |
| limit = self._state.get_entity('credit_limit', target['credit_limit_id'], 'credit_limit_id') |
| if limit is None: |
| raise ValueError('active target references a missing credit limit') |
| self._task_baseline_limits[target['credit_limit_id']] = {'used_amount': float(limit['used_amount']), 'available_amount': float(limit['available_amount'])} |
| self._task_id = task_id |
| self._activated_tasks.append(task_id) |
| self._episode_event_start = len(self._events) |
| self._calls = 0 |
| self._writes = 0 |
| self._work_units = 0 |
| self._assert_invariants() |
| return {'status': 'success', 'data': {'status': 'succeeded', 'event_id': fn_opaque_event_id(task_id), 'work_unit_limit': self._work_unit_limit}, 'message': 'Finance work packet activated'} |
|
|
| def _supply_chain_finance_authority_init_2(self, source_root=None, source=None, work_unit_limit=70): |
| self._supply_chain_finance_authority_init_3(source_root=source_root, source=source, work_unit_limit=work_unit_limit) |
| fixture = ext_deepcopy(fn__fixture_2()) |
| self._state = MemoryState(fixture['entities']) |
| self._queues = fixture['queues'] |
| self._work_items = fixture['work_items'] |
| self._all_targets = fixture['targets'] |
| self._release_by_invoice = fixture['release_by_invoice'] |
| self._release_by_request = fixture['release_by_request'] |
| self._initial_limits = fixture['baseline_limits'] |
| self._targets = [] |
| self._baseline_limits = ext_deepcopy(self._initial_limits) |
| self._task_baseline_limits = {} |
| self._task_id = None |
| self._activated_tasks = [] |
| self._applied_boundary_events = [] |
| self._events = [] |
| self._episode_event_start = 0 |
| self._calls = 0 |
| self._writes = 0 |
| self._work_units = 0 |
| self.authority_moved = False |
| self.authority = ext_deepcopy(DATA_PRE_AUTHORITY) |
| self._assert_invariants() |
|
|
| def _supply_chain_finance_authority_submit_2(self, arguments): |
| target = self._active_target_by_invoice(arguments['invoice_id']) |
| if target is None: |
| return fn__error('INVOICE_NOT_FOUND', 'invoice not found') |
| if not self._prior_targets_complete(target): |
| return fn__error('PRIOR_TARGET_INCOMPLETE', 'complete earlier listed requests before starting this request') |
| profile_fields = ('buyer_id', 'supplier_id', 'program_id', 'credit_limit_id') |
| if any((arguments.get(field) != target[field] for field in profile_fields)): |
| return fn__error('FINANCE_PROFILE_BINDING_MISMATCH', 'the supplied finance profile is not valid for this invoice') |
| authority = self.authority[target['structure_atom_id']] |
| authority_fields = ('funding_scope_id', 'submission_channel', 'approval_chain_ref') |
| if any((arguments.get(field) != authority[field] for field in authority_fields)): |
| return fn__error('FUNDING_AUTHORITY_SCOPE_MISMATCH', 'the supplied funding authority is not valid for this request scope') |
| business_arguments = {key: ext_deepcopy(arguments[key]) for key in ('invoice_id', 'requested_amount', 'advance_rate_percent', 'fee_rate_percent', 'submission_channel')} |
| result = World._supply_chain_finance_adapter_submit(self, business_arguments) |
| if result.get('status') != 'success': |
| return result |
| request_id = result['data']['factoring_request_id'] |
| renamed = self._rename_approval_tasks(target, authority, list(result['data']['approval_task_ids'])) |
| self._state.update_entity('factoring_request', request_id, {'approval_task_ids': renamed, 'funding_scope_id': authority['funding_scope_id'], 'approval_chain_ref': authority['approval_chain_ref']}, id_field='factoring_request_id') |
| result['data'].update({'approval_task_ids': renamed, 'funding_scope_id': authority['funding_scope_id'], 'approval_chain_ref': authority['approval_chain_ref']}) |
| return result |
|
|
| def _supply_chain_finance_adapter_finalize(self, arguments, actor_id): |
| request = self._state.get_entity('factoring_request', arguments['factoring_request_id'], 'factoring_request_id') |
| if request is None: |
| return fn__error('FACTORING_REQUEST_NOT_FOUND', 'factoring request does not exist') |
| supplied_ids = arguments['approval_task_ids'] |
| if set(supplied_ids) != set(request.get('approval_task_ids') or []): |
| return fn__error('APPROVAL_TASK_BINDING_MISMATCH', 'supplied approval handles do not match the factoring request') |
| program = self._state.get_entity('program', request.get('program_id'), 'program_id') |
| expected_discount = float((program or {}).get('base_discount_rate_percent') or 0) |
| expected_payment = fn__money(float(request.get('requested_amount') or 0) * (1 - expected_discount)) |
| if program is None or fn__money(arguments['offered_amount']) != fn__money(request.get('requested_amount')) or float(arguments['discount_rate_percent']) != expected_discount or (fn__money(arguments['payment_amount']) != expected_payment): |
| return fn__error('SETTLEMENT_TERMS_MISMATCH', 'the supplied offer or payment does not match current program terms') |
| grants = DATA_ACTOR_GRANTS.get(actor_id, frozenset()) |
| ordered_tasks = [] |
| for role in DATA_APPROVAL_ROLES: |
| task = next((self._state.get_entity('approval_task', task_id, 'approval_task_id') for task_id in supplied_ids if (self._state.get_entity('approval_task', task_id, 'approval_task_id') or {}).get('approver_role') == role), None) |
| if task is None: |
| return fn__error('APPROVAL_ROLE_MISSING', 'the request lacks one required approval role') |
| if role not in grants: |
| return fn__error('APPROVER_ROLE_NOT_AUTHORIZED', 'the authenticated actor is not authorized for the approval role') |
| ordered_tasks.append(task) |
| for task in ordered_tasks: |
| self._require_success(self._raw('approve_factoring_task', {'approval_task_id': task['approval_task_id'], 'decision_note': 'Approved through the bounded T01 operations workflow.', 'decided_by': actor_id})) |
| offer = self._require_success(self._raw('create_early_payment_offer', {'factoring_request_id': request['factoring_request_id'], 'offered_amount': arguments['offered_amount'], 'discount_rate_percent': arguments['discount_rate_percent'], 'expires_at': '2026-12-01T09:00:00Z', 'offer_type': 'factoring_advance'})) |
| offer_id = offer['early_payment_offer_id'] |
| self._require_success(self._raw('accept_early_payment_offer', {'early_payment_offer_id': offer_id, 'accepted_by': actor_id})) |
| payment = self._require_success(self._raw('schedule_payment', {'invoice_id': request['invoice_id'], 'early_payment_offer_id': offer_id, 'payment_type': 'funder_advance', 'amount': arguments['payment_amount'], 'scheduled_at': '2026-10-01T09:00:00Z', 'reference_code': f"advance-{request['factoring_request_id']}"})) |
| payment_id = payment['payment_id'] |
| scheduled = self._state.get_entity('payment', payment_id, 'payment_id') or {} |
| waterfall = self._state.get_entity('payment_waterfall', scheduled.get('payment_waterfall_id'), 'payment_waterfall_id') |
| if not waterfall or waterfall.get('status') != 'active': |
| return fn__error('PAYMENT_WATERFALL_PRECONDITION_FAILED', 'the scheduled payment does not reference the active waterfall') |
| settlement = self._require_success(self._raw('execute_payment_waterfall', {'payment_id': payment_id, 'execution_date': '2026-10-01T09:05:00Z'})) |
| return fn__success(factoring_request_id=request['factoring_request_id'], approval_task_ids=[task['approval_task_id'] for task in ordered_tasks], early_payment_offer_id=offer_id, payment_id=payment_id, ledger_event_id=settlement['ledger_event_id'], reconciliation_item_id=settlement['reconciliation_item_id']) |
|
|
| def _supply_chain_finance_adapter_cost(self, before, action, result, after): |
| del before, after |
| name = action['tool'] |
| if name in DATA_WRITE_TOOLS: |
| if result.get('status') != 'success': |
| return 5 |
| return 5 if name == 'submit_factoring_request' else 10 |
| if name in {'inspect_finance_work_queue', 'inspect_credit_limit'}: |
| return 3 |
| base = 3 if name == 'get_invoice_timeline' else 2 |
| return base + self._result_rows(name, result) |
|
|
| def _supply_chain_finance_adapter_grade(self, task_id='T01'): |
| if task_id != 'T01' or task_id != self._task_id: |
| raise ValueError('only the active T01 fixture can be graded') |
| deliverables = [] |
| requests = self._state.list_entities('factoring_request') |
| offers = self._state.list_entities('early_payment_offer') |
| payments = self._state.list_entities('payment') |
| reconciliations = self._state.list_entities('reconciliation_item') |
| ledgers = self._state.list_entities('ledger_event') |
| for target in self._targets: |
| request_rows = [row for row in requests if row.get('invoice_id') == target['invoice_id']] |
| request = request_rows[0] if len(request_rows) == 1 else None |
| invoice = self._state.get_entity('invoice', target['invoice_id'], 'invoice_id') |
| limit = self._state.get_entity('credit_limit', target['credit_limit_id'], 'credit_limit_id') |
| task_rows = [self._state.get_entity('approval_task', task_id, 'approval_task_id') for task_id in request.get('approval_task_ids', [])] if request else [] |
| offer_rows = [row for row in offers if request and row.get('factoring_request_id') == request['factoring_request_id']] |
| offer = offer_rows[0] if len(offer_rows) == 1 else None |
| payment_rows = [row for row in payments if offer and row.get('early_payment_offer_id') == offer['early_payment_offer_id']] |
| payment = payment_rows[0] if len(payment_rows) == 1 else None |
| recon_rows = [row for row in reconciliations if payment and row.get('payment_id') == payment['payment_id']] |
| ledger_rows = [row for row in ledgers if payment and row.get('related_type') == 'payment' and (row.get('related_id') == payment['payment_id'])] |
| expected_payment = fn__money(target['requested_amount'] * (1 - target['discount_rate_percent'])) |
| baseline = self._baseline_limits[target['credit_limit_id']] |
| milestones = {'binding_and_terms_verified': bool(request and request.get('program_id') == target['program_id'] and (fn__money(request.get('requested_amount')) == fn__money(target['requested_amount'])) and (float(request.get('advance_rate_percent') or 0) == target['advance_rate_percent']) and (float(request.get('fee_rate_percent') or 0) == target['discount_rate_percent'])), 'credit_reservation_conserved': bool(request and limit and (fn__money(limit.get('used_amount')) == fn__money(baseline['used_amount'] + target['requested_amount'])) and (fn__money(limit.get('available_amount')) == fn__money(baseline['available_amount'] - target['requested_amount'])) and (fn__money(limit.get('used_amount') + limit.get('available_amount')) == fn__money(limit.get('limit_amount')))), 'role_approvals_complete': bool(request and len(task_rows) == 4 and all((task is not None for task in task_rows)) and ({task['approver_role'] for task in task_rows} == set(DATA_APPROVAL_ROLES)) and all((task.get('status') == 'approved' and task.get('assigned_to') == 'operator-t01-scf' for task in task_rows))), 'advance_payment_settled': bool(request and request.get('status') == 'funded' and offer and (offer.get('status') == 'accepted') and (fn__money(offer.get('offered_amount')) == fn__money(target['requested_amount'])) and (float(offer.get('discount_rate_percent') or 0) == target['discount_rate_percent']) and payment and (payment.get('status') == 'settled') and (payment.get('payment_type') == 'funder_advance') and (fn__money(payment.get('amount')) == expected_payment) and invoice and (fn__money(invoice.get('paid_amount')) == expected_payment)), 'ledger_and_reconciliation_closed': bool(payment and len(ledger_rows) == 1 and (fn__money(ledger_rows[0].get('amount')) == fn__money(payment.get('amount'))) and (len(recon_rows) == 1) and (recon_rows[0].get('status') == 'matched') and (fn__money(recon_rows[0].get('difference_amount')) == 0.0) and (fn__money(sum((payment.get('allocation_breakdown') or {}).values())) == fn__money(payment.get('amount'))))} |
| score = 5.0 * sum(milestones.values()) |
| deliverables.append({'target_id': target['target_id'], 'request_reference': target['request_reference'], 'score': score, **milestones, 'invoice_id': target['invoice_id'], 'factoring_request_id': request.get('factoring_request_id') if request else None, 'payment_id': payment.get('payment_id') if payment else None}) |
| return {'task_id': task_id, 'score': sum((row['score'] for row in deliverables)), 'max_score': 100.0, 'completed_artifacts': sum((row['score'] == 25.0 for row in deliverables)), 'work_units_used': self._work_units, 'work_units_remaining': self._work_unit_limit - self._work_units, 'write_attempts_used': self._writes, 'deliverables': deliverables} |
|
|
| def _supply_chain_finance_adapter_execute(self, name, arguments, actor_id): |
| if name == 'list_finance_work_queues': |
| return self._list_queues(arguments) |
| if name == 'inspect_finance_work_queue': |
| return self._inspect_queue(arguments) |
| if name in {'list_buyers', 'list_suppliers', 'list_programs', 'inspect_credit_limit', 'get_invoice_timeline'}: |
| return self._raw(name, arguments) |
| if name == 'search_invoices': |
| return self._search_invoices(arguments) |
| if name == 'submit_factoring_request': |
| return self._submit(arguments) |
| if name == 'finalize_factoring_advance': |
| return self._finalize(arguments, actor_id) |
| return fn__error('TOOL_NOT_ALLOWED', 'tool is not in the learner allowlist') |
|
|
| def _supply_chain_finance_authority_restore_3(self, snapshot): |
| if snapshot.get('schema') != 'rescopebench-supply-chain-finance-authority/v3': |
| raise ValueError('unsupported authority-v3 snapshot schema') |
| base = ext_deepcopy(snapshot) |
| base['schema'] = 'rescopebench-supply-chain-finance-stream-snapshot/v1' |
| base.pop('authority_moved', None) |
| base.pop('authority', None) |
| self._persistent_supply_chain_finance_adapter_restore(base) |
| self.authority_moved = bool(snapshot['authority_moved']) |
| self.authority = ext_deepcopy(snapshot['authority']) |
|
|
| def _supply_chain_finance_authority_snapshot(self): |
| value = self._supply_chain_finance_authority_snapshot_2() |
| value['schema'] = 'rescopebench-supply-chain-finance-authority/v5' |
| return value |
|
|
| def _supply_chain_finance_authority_init_3(self, source_root=None, source=None, work_unit_limit=70): |
| if work_unit_limit <= 0: |
| raise ValueError('work_unit_limit must be positive') |
| selected = ext_Path(source_root or source or CASE_DIR / 'raw').resolve() |
| (modules, _) = ext_load_isolated_modules(selected, ('mcp_servers.finance_logic',)) |
| self._logic = modules[0] |
| self._logic.now_iso = lambda : '2026-09-25T12:00:00Z' |
| self._work_unit_limit = int(work_unit_limit) |
| fixture = ext_deepcopy(fn__fixture_4()) |
| self._state = MemoryState(fixture['entities']) |
| self._queues = fixture['queues'] |
| self._work_items = fixture['work_items'] |
| self._all_targets = fixture['targets'] |
| self._release_by_invoice = fixture['release_by_invoice'] |
| self._release_by_request = fixture['release_by_request'] |
| self._initial_limits = fixture['baseline_limits'] |
| self._targets: list[dict[str, ext_Any]] = [] |
| self._baseline_limits = ext_deepcopy(self._initial_limits) |
| self._task_baseline_limits: dict[str, dict[str, float]] = {} |
| self._task_id: str | None = None |
| self._activated_tasks: list[str] = [] |
| self._applied_boundary_events: list[str] = [] |
| self._events: list[dict[str, ext_Any]] = [] |
| self._episode_event_start = 0 |
| self._calls = 0 |
| self._writes = 0 |
| self._work_units = 0 |
| self.authority_moved = False |
| self.authority = ext_deepcopy(DATA_PRE_AUTHORITY) |
| self._suppress_boundary = False |
| self._assert_invariants() |
|
|
| def _supply_chain_finance_adapter_submit(self, arguments): |
| invoice = self._state.get_entity('invoice', arguments['invoice_id'], 'invoice_id') |
| if invoice is not None: |
| program = self._state.get_entity('program', invoice.get('program_id'), 'program_id') |
| if program is not None and (fn__money(arguments['requested_amount']) != fn__money(invoice.get('outstanding_amount')) or float(arguments['advance_rate_percent']) != float(program.get('max_advance_rate_percent') or 0) or float(arguments['fee_rate_percent']) != float(program.get('base_discount_rate_percent') or 0)): |
| return fn__error('PROGRAM_TERMS_MISMATCH', 'the request does not use the invoice balance and current program terms') |
| return self._raw('submit_factoring_request', arguments) |
|
|
| def _persistent_supply_chain_finance_adapter_restore(self, snapshot): |
| if snapshot.get('schema') != 'rescopebench-supply-chain-finance-stream-snapshot/v1': |
| raise ValueError('unsupported stream snapshot schema') |
| base = ext_deepcopy(snapshot) |
| base['schema'] = 'rescopebench-supply-chain-finance-snapshot/v1' |
| for key in ('all_targets', 'release_by_invoice', 'release_by_request', 'initial_limits', 'task_baseline_limits', 'activated_tasks', 'applied_boundary_events', 'episode_event_start'): |
| base.pop(key, None) |
| self._supply_chain_finance_adapter_restore(base) |
| self._all_targets = ext_deepcopy(snapshot['all_targets']) |
| self._release_by_invoice = {key: int(value) for (key, value) in snapshot['release_by_invoice'].items()} |
| self._release_by_request = {key: int(value) for (key, value) in snapshot['release_by_request'].items()} |
| self._initial_limits = ext_deepcopy(snapshot['initial_limits']) |
| self._task_baseline_limits = ext_deepcopy(snapshot['task_baseline_limits']) |
| self._activated_tasks = list(snapshot['activated_tasks']) |
| self._applied_boundary_events = list(snapshot['applied_boundary_events']) |
| self._episode_event_start = int(snapshot['episode_event_start']) |
| self._logic.now_iso = lambda : '2026-09-25T12:00:00Z' |
|
|
| def _supply_chain_finance_authority_snapshot_2(self): |
| value = self._supply_chain_finance_authority_snapshot_3() |
| value['schema'] = 'rescopebench-supply-chain-finance-authority/v4' |
| return value |
|
|
| def _supply_chain_finance_adapter_restore(self, snapshot): |
| if snapshot.get('schema') != 'rescopebench-supply-chain-finance-snapshot/v1': |
| raise ValueError('unsupported snapshot schema') |
| self._task_id = snapshot.get('task_id') |
| self._state.restore({'entities': snapshot.get('entities') or {}}) |
| self._queues = ext_deepcopy(snapshot.get('queues') or []) |
| self._work_items = ext_deepcopy(snapshot.get('work_items') or []) |
| self._targets = ext_deepcopy(snapshot.get('targets') or []) |
| self._baseline_limits = ext_deepcopy(snapshot.get('baseline_limits') or {}) |
| self._events = ext_deepcopy(snapshot.get('events') or []) |
| self._calls = int(snapshot.get('calls') or 0) |
| self._writes = int(snapshot.get('writes') or 0) |
| self._work_units = int(snapshot.get('work_units') or 0) |
| self._work_unit_limit = int(snapshot.get('work_unit_limit') or 65) |
| self._assert_invariants() |
|
|
| def _supply_chain_finance_authority_snapshot_3(self): |
| value = self._persistent_supply_chain_finance_adapter_snapshot() |
| value['schema'] = 'rescopebench-supply-chain-finance-authority/v3' |
| value['authority_moved'] = self.authority_moved |
| value['authority'] = ext_deepcopy(self.authority) |
| return value |
|
|
| def _persistent_supply_chain_finance_adapter_snapshot(self): |
| base = self._supply_chain_finance_adapter_snapshot() |
| base['schema'] = 'rescopebench-supply-chain-finance-stream-snapshot/v1' |
| base.update({'all_targets': ext_deepcopy(self._all_targets), 'release_by_invoice': ext_deepcopy(self._release_by_invoice), 'release_by_request': ext_deepcopy(self._release_by_request), 'initial_limits': ext_deepcopy(self._initial_limits), 'task_baseline_limits': ext_deepcopy(self._task_baseline_limits), 'activated_tasks': list(self._activated_tasks), 'applied_boundary_events': list(self._applied_boundary_events), 'episode_event_start': self._episode_event_start}) |
| return base |
|
|
| def _supply_chain_finance_adapter_snapshot(self): |
| return {'schema': 'rescopebench-supply-chain-finance-snapshot/v1', 'task_id': self._task_id, 'entities': self._state.snapshot()['entities'], 'queues': ext_deepcopy(self._queues), 'work_items': ext_deepcopy(self._work_items), 'targets': ext_deepcopy(self._targets), 'baseline_limits': ext_deepcopy(self._baseline_limits), 'events': ext_deepcopy(self._events), 'calls': self._calls, 'writes': self._writes, 'work_units': self._work_units, 'work_unit_limit': self._work_unit_limit} |
|
|
| class MemoryState: |
|
|
| def __init__(self, entities): |
| self._entities = ext_deepcopy(entities) |
| self._fault: dict[str, ext_Any] | None = None |
| self._active_tool: str | None = None |
| self._mutation_count = 0 |
|
|
| def list_entities(self, entity_type): |
| return ext_deepcopy(self._entities.get(entity_type, [])) |
|
|
| def query_entities(self, entity_type, predicate): |
| return [row for row in self.list_entities(entity_type) if predicate(row)] |
|
|
| def get_entity(self, entity_type, entity_id, id_field='id'): |
| field = DATA_ENTITY_ID_FIELDS[entity_type] 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 add_entity(self, entity_type, entity, id_field='id'): |
| field = DATA_ENTITY_ID_FIELDS[entity_type] if id_field == 'id' else id_field |
| identifier = entity.get(field) |
| if not identifier: |
| raise ValueError(f'missing identity for {entity_type}') |
| rows = self._entities.setdefault(entity_type, []) |
| for (index, row) in enumerate(rows): |
| if row.get(field) == identifier: |
| rows[index] = ext_deepcopy(entity) |
| self._after_mutation() |
| return ext_deepcopy(rows[index]) |
| rows.append(ext_deepcopy(entity)) |
| self._after_mutation() |
| return ext_deepcopy(entity) |
|
|
| def update_entity(self, entity_type, entity_id, patch, id_field='id'): |
| field = DATA_ENTITY_ID_FIELDS[entity_type] 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)) |
| self._after_mutation() |
| return ext_deepcopy(row) |
| return None |
|
|
| def get_core_state(self): |
| unresolved = sum((abs(float(row.get('difference_amount') or 0)) for row in self._entities.get('reconciliation_item', []) if row.get('status') in {'open', 'exception'})) |
| return {'reconciliation_control': {'unresolved_difference_amount': round(unresolved, 2)}} |
|
|
| def snapshot(self): |
| return {'entities': ext_deepcopy(self._entities)} |
|
|
| def restore(self, snapshot): |
| self._entities = ext_deepcopy(snapshot['entities']) |
| self._fault = None |
| self._active_tool = None |
| self._mutation_count = 0 |
|
|
| def begin_tool(self, name): |
| self._active_tool = name |
| self._mutation_count = 0 |
|
|
| def end_tool(self): |
| self._active_tool = None |
| self._mutation_count = 0 |
|
|
| def configure_fault(self, tool, after_mutations): |
| self._fault = {'tool': tool, 'after_mutations': after_mutations} |
|
|
| def _after_mutation(self): |
| self._mutation_count += 1 |
| if not self._fault or self._fault.get('tool') != self._active_tool: |
| return |
| if self._mutation_count >= int(self._fault['after_mutations']): |
| self._fault = None |
| raise InjectedFailure('case-local injected write failure') |
|
|
| class Abort(RuntimeError): |
|
|
| def __init__(self, result): |
| RuntimeError.__init__(self, str(result.get('message') or 'operation aborted')) |
| self.result = result |
|
|
| class InjectedFailure(RuntimeError): |
| pass |
|
|
